rename the following methods:

tqparent parent
tqmask mask


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

36 files changed, 233 insertions, 233 deletions

diff --git a/chalk/core/createdcop.py b/chalk/core/createdcop.py
index de773270..2356a8c4 100755
--- a/chalk/core/createdcop.py
+++ b/chalk/core/createdcop.py
@@ -34,7 +34,7 @@ class %(classname)sIface : virtual public DCOPObject
 {
 	K_DCOP
 public:
-	%(classname)sIface( %(classname)s * tqparent );
+	%(classname)sIface( %(classname)s * parent );
 k_dcop:
 
 private:
@@ -73,10 +73,10 @@ dcopiface_template = """/*
 
 #include <dcopclient.h>
 
-%(classname)sIface::%(classname)sIface( %(classname)s * tqparent )
+%(classname)sIface::%(classname)sIface( %(classname)s * parent )
 	: DCOPObject()
 {
-	m_parent = tqparent;
+	m_parent = parent;
 }
 
 """
diff --git a/chalk/core/kis_alpha_mask.cc b/chalk/core/kis_alpha_mask.cc
index 1b40e806..3f382c30 100644
--- a/chalk/core/kis_alpha_mask.cc
+++ b/chalk/core/kis_alpha_mask.cc
@@ -109,19 +109,19 @@ void KisAlphaMask::computeAlpha(const TQImage& img)
     }
 }
 
-KisAlphaMaskSP KisAlphaMask::interpolate(KisAlphaMaskSP tqmask1, KisAlphaMaskSP tqmask2, double t)
+KisAlphaMaskSP KisAlphaMask::interpolate(KisAlphaMaskSP mask1, KisAlphaMaskSP mask2, double t)
 {
-    Q_ASSERT((tqmask1->width() == tqmask2->width()) && (tqmask1->height() == tqmask2->height()));
+    Q_ASSERT((mask1->width() == mask2->width()) && (mask1->height() == mask2->height()));
     Q_ASSERT(t > -DBL_EPSILON && t < 1 + DBL_EPSILON);
 
-    int width = tqmask1->width();
-    int height = tqmask1->height();
+    int width = mask1->width();
+    int height = mask1->height();
     KisAlphaMaskSP outputMask = new KisAlphaMask(width, height);
     Q_CHECK_PTR(outputMask);
 
     for (int x = 0; x < width; x++) {
         for (int y = 0; y < height; y++) {
-            TQ_UINT8 d = static_cast<TQ_UINT8>((1 - t) * tqmask1->alphaAt(x, y) + t * tqmask2->alphaAt(x, y));
+            TQ_UINT8 d = static_cast<TQ_UINT8>((1 - t) * mask1->alphaAt(x, y) + t * mask2->alphaAt(x, y));
             outputMask->setAlphaAt(x, y, d);
         }
     }
diff --git a/chalk/core/kis_alpha_mask.h b/chalk/core/kis_alpha_mask.h
index 5573f5e6..c19cae59 100644
--- a/chalk/core/kis_alpha_mask.h
+++ b/chalk/core/kis_alpha_mask.h
@@ -28,15 +28,15 @@
 
 /**
  * KisAlphaMask is intended to create alpha values from a TQImage for use
- * in brush creation. It is not a generic alpha tqmask that can be used with
+ * in brush creation. It is not a generic alpha mask that can be used with
  * KisPaintDevices: use a KisSelection for that.
  */
 class KisAlphaMask : public KShared {
     
  public:
     /**
-       Create an alpha tqmask based on the specified TQImage. If the image is
-       not a grayscale, the tqmask value is calculated from the effective grey
+       Create an alpha mask based on the specified TQImage. If the image is
+       not a grayscale, the mask value is calculated from the effective grey
        level and alpha value.
     */
     KisAlphaMask(const TQImage& img);
@@ -48,7 +48,7 @@ class KisAlphaMask : public KShared {
     KisAlphaMask(const TQImage& img, bool hasColor);
 
     /**
-       Create a transparent tqmask.
+       Create a transparent mask.
     */
     KisAlphaMask(TQ_INT32 width, TQ_INT32 height);
 
@@ -60,7 +60,7 @@ class KisAlphaMask : public KShared {
     TQ_INT32 height() const;
 
     /**
-       @return the number of lines in the tqmask.
+       @return the number of lines in the mask.
      */
        TQ_INT32 width() const;
 
@@ -68,14 +68,14 @@ class KisAlphaMask : public KShared {
        @return the alpha value at the specified position.
 
        Returns TQ_UINT8 OPACITY_TRANSPARENT if the value is
-       outside the bounds of the tqmask.
+       outside the bounds of the mask.
 
        XXX: this is, of course, not the best way of masking.
        Better would be to let KisAlphaMask fill a chunk of memory
        with the alpha values at the right position, something like
        void applyMask(TQ_UINT8 *pixeldata, TQ_INT32 pixelWidth,
        TQ_INT32 alphaPos). That would be fastest, or we could
-       provide an iterator over the tqmask, that would be nice, too.
+       provide an iterator over the mask, that would be nice, too.
     */
     inline TQ_UINT8 alphaAt(TQ_INT32 x, TQ_INT32 y) const
     {
@@ -89,9 +89,9 @@ class KisAlphaMask : public KShared {
 
     void setAlphaAt(TQ_INT32 x, TQ_INT32 y, TQ_UINT8 alpha);
 
-    // Create a new tqmask by interpolating between tqmask1 and tqmask2 as t
+    // Create a new mask by interpolating between mask1 and mask2 as t
     // goes from 0 to 1.
-    static KisAlphaMaskSP interpolate(KisAlphaMaskSP tqmask1, KisAlphaMaskSP tqmask2, double t);
+    static KisAlphaMaskSP interpolate(KisAlphaMaskSP mask1, KisAlphaMaskSP mask2, double t);
 
 private:
     void computeAlpha(const TQImage& img);
diff --git a/chalk/core/kis_brush.cc b/chalk/core/kis_brush.cc
index 60f475f0..31ee9d18 100644
--- a/chalk/core/kis_brush.cc
+++ b/chalk/core/kis_brush.cc
@@ -375,7 +375,7 @@ TQImage KisBrush::img()
     return image;
 }
 
-KisAlphaMaskSP KisBrush::tqmask(const KisPaintInformation& info, double subPixelX, double subPixelY) const
+KisAlphaMaskSP KisBrush::mask(const KisPaintInformation& info, double subPixelX, double subPixelY) const
 {
     if (m_scaledBrushes.isEmpty()) {
         createScaledBrushes();
@@ -405,9 +405,9 @@ KisAlphaMaskSP KisBrush::tqmask(const KisPaintInformation& info, double subPixel
             // Exact match.
             outputMask = scaleMask(aboveBrush, scale, subPixelX, subPixelY);
         } else {
-            // We are smaller than the smallest tqmask, which is always 1x1.
+            // We are smaller than the smallest mask, which is always 1x1.
             double s = scale / aboveBrush->scale();
-            outputMask = scaleSinglePixelMask(s, aboveBrush->tqmask()->alphaAt(0, 0), subPixelX, subPixelY);
+            outputMask = scaleSinglePixelMask(s, aboveBrush->mask()->alphaAt(0, 0), subPixelX, subPixelY);
         }
     }
 
@@ -629,7 +629,7 @@ KisAlphaMaskSP KisBrush::scaleMask(const ScaledBrush *srcBrush, double scale, do
     KisAlphaMaskSP dstMask = new KisAlphaMask(dstWidth, dstHeight);
     Q_CHECK_PTR(dstMask);
 
-    KisAlphaMaskSP srcMask = srcBrush->tqmask();
+    KisAlphaMaskSP srcMask = srcBrush->mask();
 
     // Compute scales to map the scaled brush onto the required scale.
     double xScale = srcBrush->xScale() / scale;
@@ -1167,7 +1167,7 @@ TQImage KisBrush::interpolate(const TQImage& image1, const TQImage& image2, doub
 
 KisBrush::ScaledBrush::ScaledBrush()
 {
-    m_tqmask = 0;
+    m_mask = 0;
     m_image = TQImage();
     m_scale = 1;
     m_xScale = 1;
@@ -1176,7 +1176,7 @@ KisBrush::ScaledBrush::ScaledBrush()
 
 KisBrush::ScaledBrush::ScaledBrush(KisAlphaMaskSP scaledMask, const TQImage& scaledImage, double scale, double xScale, double yScale)
 {
-    m_tqmask = scaledMask;
+    m_mask = scaledMask;
     m_image = scaledImage;
     m_scale = scale;
     m_xScale = xScale;
@@ -1262,7 +1262,7 @@ void KisBrush::generateBoundary() {
     if (brushType() == IMAGE || brushType() == PIPE_IMAGE) {
         dev = image(KisMetaRegistry::instance()->csRegistry() ->getColorSpace(KisID("RGBA",""),""), KisPaintInformation());
     } else {
-        KisAlphaMaskSP atqmask = tqmask(KisPaintInformation());
+        KisAlphaMaskSP amask = mask(KisPaintInformation());
         KisColorSpace* cs = KisMetaRegistry::instance()->csRegistry()->getColorSpace(KisID("RGBA",""),"");
         dev = new KisPaintDevice(cs, "tmp for generateBoundary");
         for (int y = 0; y < h; y++) {
@@ -1270,7 +1270,7 @@ void KisBrush::generateBoundary() {
             int x = 0;
 
             while(!it.isDone()) {
-                cs->setAlpha(it.rawData(), atqmask->alphaAt(x++, y), 1);
+                cs->setAlpha(it.rawData(), amask->alphaAt(x++, y), 1);
                 ++it;
             }
         }
diff --git a/chalk/core/kis_brush.h b/chalk/core/kis_brush.h
index 57dd9d9e..9a7f3bb0 100644
--- a/chalk/core/kis_brush.h
+++ b/chalk/core/kis_brush.h
@@ -77,10 +77,10 @@ public:
     virtual bool saveToDevice(TQIODevice* dev) const;
 
     /**
-       @return a tqmask computed from the grey-level values of the
+       @return a mask computed from the grey-level values of the
        pixels in the brush.
     */
-    virtual KisAlphaMaskSP tqmask(const KisPaintInformation& info,
+    virtual KisAlphaMaskSP mask(const KisPaintInformation& info,
                                 double subPixelX = 0, double subPixelY = 0) const;
     // XXX: return non-tiled simple buffer
     virtual KisPaintDeviceSP image(KisColorSpace * colorSpace, const KisPaintInformation& info,
@@ -94,7 +94,7 @@ public:
     double xSpacing(double pressure = PRESSURE_DEFAULT) const;
     double ySpacing(double pressure = PRESSURE_DEFAULT) const;
 
-    // Dimensions in pixels of the tqmask/image at a given pressure.
+    // Dimensions in pixels of the mask/image at a given pressure.
     TQ_INT32 maskWidth(const KisPaintInformation& info) const;
     TQ_INT32 maskHeight(const KisPaintInformation& info) const;
 
@@ -135,11 +135,11 @@ private:
         double scale() const { return m_scale; }
         double xScale() const { return m_xScale; }
         double yScale() const { return m_yScale; }
-        KisAlphaMaskSP tqmask() const { return m_tqmask; }
+        KisAlphaMaskSP mask() const { return m_mask; }
         TQImage image() const { return m_image; }
 
     private:
-        KisAlphaMaskSP m_tqmask;
+        KisAlphaMaskSP m_mask;
         TQImage m_image;
         double m_scale;
         double m_xScale;
diff --git a/chalk/core/kis_fill_painter.cc b/chalk/core/kis_fill_painter.cc
index 5b8fdcc9..54e730a7 100644
--- a/chalk/core/kis_fill_painter.cc
+++ b/chalk/core/kis_fill_painter.cc
@@ -203,10 +203,10 @@ void KisFillPainter::genericFillEnd(KisPaintDeviceSP filled) {
 }
 
 struct FillSegment {
-    FillSegment(int x, int y/*, FillSegment* tqparent*/) : x(x), y(y)/*, tqparent(tqparent)*/ {}
+    FillSegment(int x, int y/*, FillSegment* parent*/) : x(x), y(y)/*, parent(parent)*/ {}
     int x;
     int y;
-//    FillSegment* tqparent;
+//    FillSegment* parent;
 };
 
 typedef enum { None = 0, Added = 1, Checked = 2 } tqStatus;
diff --git a/chalk/core/kis_fill_painter.h b/chalk/core/kis_fill_painter.h
index da244a67..12aa0c2f 100644
--- a/chalk/core/kis_fill_painter.h
+++ b/chalk/core/kis_fill_painter.h
@@ -102,7 +102,7 @@ public:
     void fillPattern(int startX, int startY);
 
     /**
-     * Returns a selection tqmask for the floodfill starting at the specified position.
+     * Returns a selection mask for the floodfill starting at the specified position.
      **/
     KisSelectionSP createFloodSelection(int startX, int startY);
 
diff --git a/chalk/core/kis_filter.h b/chalk/core/kis_filter.h
index 807ecff8..193be6ce 100644
--- a/chalk/core/kis_filter.h
+++ b/chalk/core/kis_filter.h
@@ -158,12 +158,12 @@ public:
     /**
      * Create the configuration widget for this filter.
      *
-     * @param tqparent the TQt owner widget of this widget
+     * @param parent the TQt owner widget of this widget
      * @param dev the paintdevice this filter will act on
      * @return NULL if the filter does not use user-settable configuration settings.
      *         else return a pointer to the new configuration widget
      */
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget * tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget * parent, KisPaintDeviceSP dev);
 
     virtual void cancel() { m_cancelRequested = true; }
 
diff --git a/chalk/core/kis_filter_config_widget.cc b/chalk/core/kis_filter_config_widget.cc
index df7c13d5..1df05f64 100644
--- a/chalk/core/kis_filter_config_widget.cc
+++ b/chalk/core/kis_filter_config_widget.cc
@@ -19,8 +19,8 @@
 #include "kis_filter_config_widget.h"
 
 
-KisFilterConfigWidget::KisFilterConfigWidget(TQWidget * tqparent, const char * name, WFlags f)
-    : TQWidget(tqparent, name, f) 
+KisFilterConfigWidget::KisFilterConfigWidget(TQWidget * parent, const char * name, WFlags f)
+    : TQWidget(parent, name, f) 
 {
 }
 
diff --git a/chalk/core/kis_filter_config_widget.h b/chalk/core/kis_filter_config_widget.h
index ddb600ab..f893b138 100644
--- a/chalk/core/kis_filter_config_widget.h
+++ b/chalk/core/kis_filter_config_widget.h
@@ -33,7 +33,7 @@ class KisFilterConfigWidget : public TQWidget {
 
 public:
 
-    KisFilterConfigWidget(TQWidget * tqparent, const char * name = 0, WFlags f = 0 );
+    KisFilterConfigWidget(TQWidget * parent, const char * name = 0, WFlags f = 0 );
     virtual ~KisFilterConfigWidget();
 
     virtual void setConfiguration(KisFilterConfiguration * config) = 0;
diff --git a/chalk/core/kis_group_layer.cc b/chalk/core/kis_group_layer.cc
index ea8d0213..1f08dbdd 100644
--- a/chalk/core/kis_group_layer.cc
+++ b/chalk/core/kis_group_layer.cc
@@ -90,9 +90,9 @@ bool KisGroupLayer::paintLayerInducesProjectionOptimization(KisPaintLayer* l) {
 
 KisPaintDeviceSP KisGroupLayer::projection(const TQRect & rect)
 {
-    // We don't have a tqparent, and we've got only one child: abuse the child's
+    // We don't have a parent, and we've got only one child: abuse the child's
     // paint device as the projection if the child is visible and 100% opaque
-    if (tqparent() == 0 && childCount() == 1) {
+    if (parent() == 0 && childCount() == 1) {
         KisPaintLayerSP l = dynamic_cast<KisPaintLayer*>(firstChild().data());
         if (paintLayerInducesProjectionOptimization(l)) {
             l->setClean(rect);
@@ -146,14 +146,14 @@ KisLayerSP KisGroupLayer::at(int index) const
 
 int KisGroupLayer::index(KisLayerSP layer) const
 {
-    if (layer->tqparent().data() == this)
+    if (layer->parent().data() == this)
         return layer->index();
     return -1;
 }
 
 void KisGroupLayer::setIndex(KisLayerSP layer, int index)
 {
-    if (layer->tqparent().data() != this)
+    if (layer->parent().data() != this)
         return;
     //TODO optimize
     removeLayer(layer);
@@ -163,7 +163,7 @@ void KisGroupLayer::setIndex(KisLayerSP layer, int index)
 bool KisGroupLayer::addLayer(KisLayerSP newLayer, int x)
 {
     if (x < 0 || kClamp(uint(x), uint(0), childCount()) != uint(x) ||
-        newLayer->tqparent() || m_layers.contains(newLayer))
+        newLayer->parent() || m_layers.contains(newLayer))
     {
         kdWarning() << "invalid input to KisGroupLayer::addLayer(KisLayerSP newLayer, int x)!" << endl;
         return false;
@@ -185,7 +185,7 @@ bool KisGroupLayer::addLayer(KisLayerSP newLayer, int x)
 
 bool KisGroupLayer::addLayer(KisLayerSP newLayer, KisLayerSP aboveThis)
 {
-    if (aboveThis && aboveThis->tqparent().data() != this)
+    if (aboveThis && aboveThis->parent().data() != this)
     {
         kdWarning() << "invalid input to KisGroupLayer::addLayer(KisLayerSP newLayer, KisLayerSP aboveThis)!" << endl;
         return false;
@@ -219,7 +219,7 @@ bool KisGroupLayer::removeLayer(int x)
 
 bool KisGroupLayer::removeLayer(KisLayerSP layer)
 {
-    if (layer->tqparent().data() != this)
+    if (layer->parent().data() != this)
     {
         kdWarning() << "invalid input to KisGroupLayer::removeLayer()!" << endl;
         return false;
@@ -317,7 +317,7 @@ void KisGroupLayer::updateProjection(const TQRect & rc)
 
     // If this is the rootlayer, don't do anything with adj. layers that are below the
     // first paintlayer
-    bool gotPaintLayer = (tqparent() != 0);
+    bool gotPaintLayer = (parent() != 0);
 
     // Look through all the child layers, searching for the first dirty layer
     // if it's found, and if we have found an adj. layer before the the dirty layer,
@@ -404,8 +404,8 @@ void KisGroupLayer::updateProjection(const TQRect & rc)
             const KisCompositeOp cop = child->compositeOp();
             const bool block = child->signalsBlocked();
             child->blockSignals(true);
-            // Composite op copy doesn't take a tqmask/selection into account, so we need
-            // to make a difference between a paintlayer with a tqmask, and one without
+            // Composite op copy doesn't take a mask/selection into account, so we need
+            // to make a difference between a paintlayer with a mask, and one without
             KisPaintLayer* l = dynamic_cast<KisPaintLayer*>(child.data());
             if (l && l->hasMask())
                 child->m_compositeOp = COMPOSITE_OVER;
diff --git a/chalk/core/kis_group_layer.h b/chalk/core/kis_group_layer.h
index 3a2e042a..a516ac72 100644
--- a/chalk/core/kis_group_layer.h
+++ b/chalk/core/kis_group_layer.h
@@ -48,14 +48,14 @@ public:
 public:
 
     /**
-     * Set the entire layer extent dirty; this percolates up to tqparent layers all the
+     * Set the entire layer extent dirty; this percolates up to parent layers all the
      * way to the root layer.
      */
     virtual void setDirty(bool propagate = true);
 
     /**
      * Add the given rect to the set of dirty rects for this layer;
-     * this percolates up to tqparent layers all the way to the root
+     * this percolates up to parent layers all the way to the root
      * layer.
      */
     virtual void setDirty(const TQRect & rect, bool propagate = true);
diff --git a/chalk/core/kis_image.cc b/chalk/core/kis_image.cc
index 30f3ad36..1efeb715 100644
--- a/chalk/core/kis_image.cc
+++ b/chalk/core/kis_image.cc
@@ -258,12 +258,12 @@ namespace {
         typedef KisImageCommand super;
 
     public:
-        KisLayerPositionCommand(const TQString& name, KisImageSP image, KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis) : super(name, image)
+        KisLayerPositionCommand(const TQString& name, KisImageSP image, KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis) : super(name, image)
             {
                 m_layer = layer;
-                m_oldParent = layer->tqparent();
+                m_oldParent = layer->parent();
                 m_oldAboveThis = layer->nextSibling();
-                m_newParent = tqparent;
+                m_newParent = parent;
                 m_newAboveThis = aboveThis;
            }
 
@@ -300,7 +300,7 @@ namespace {
             {
                 m_img = img;
                 m_layer = layer;
-                m_parent = layer->tqparent();
+                m_parent = layer->parent();
                 m_aboveThis = layer->nextSibling();
             }
 
@@ -385,7 +385,7 @@ namespace {
                 m_layer = layer;
                 m_prevParent = wasParent;
                 m_prevAbove = wasAbove;
-                m_newParent = layer->tqparent();
+                m_newParent = layer->parent();
                 m_newAbove = layer->nextSibling();
             }
 
@@ -1048,7 +1048,7 @@ KisLayerSP KisImage::newLayer(const TQString& name, TQ_UINT8 opacity, const KisC
     layer->setVisible(true);
 
     if (m_activeLayer != 0) {
-        addLayer(layer, m_activeLayer->tqparent().data(), m_activeLayer->nextSibling());
+        addLayer(layer, m_activeLayer->parent().data(), m_activeLayer->nextSibling());
     }
     else {
         addLayer(layer, m_rootLayer, 0);
@@ -1116,17 +1116,17 @@ KisLayerSP KisImage::findLayer(int id) const
 }
 
 
-bool KisImage::addLayer(KisLayerSP layer, KisGroupLayerSP tqparent)
+bool KisImage::addLayer(KisLayerSP layer, KisGroupLayerSP parent)
 {
-    return addLayer(layer, tqparent, tqparent->firstChild());
+    return addLayer(layer, parent, parent->firstChild());
 }
 
-bool KisImage::addLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis)
+bool KisImage::addLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis)
 {
-    if (!tqparent)
+    if (!parent)
         return false;
 
-    const bool success = tqparent->addLayer(layer, aboveThis);
+    const bool success = parent->addLayer(layer, aboveThis);
     if (success)
     {
         KisPaintLayerSP player = dynamic_cast<KisPaintLayer*>(layer.data());
@@ -1163,7 +1163,7 @@ bool KisImage::removeLayer(KisLayerSP layer)
     if (!layer || layer->image() != this)
         return false;
 
-    if (KisGroupLayerSP tqparent = layer->tqparent()) {
+    if (KisGroupLayerSP parent = layer->parent()) {
         // Adjustment layers should mark the layers underneath them, whose rendering
         // they have cached, diryt on removal. Otherwise, the group won't be re-rendered.
         KisAdjustmentLayer * al = dynamic_cast<KisAdjustmentLayer*>(layer.data());
@@ -1196,21 +1196,21 @@ bool KisImage::removeLayer(KisLayerSP layer)
         const bool wasActive = layer == activeLayer();
         // sigLayerRemoved can set it to 0, we don't want that in the else of wasActive!
         KisLayerSP actLayer = activeLayer();
-        const bool success = tqparent->removeLayer(layer);
+        const bool success = parent->removeLayer(layer);
         if (success) {
             layer->setImage(0);
             if (!layer->temporary() && undo()) {
-                m_adapter->addCommand(new LayerRmCmd(m_adapter, this, layer, tqparent, wasAbove));
+                m_adapter->addCommand(new LayerRmCmd(m_adapter, this, layer, parent, wasAbove));
             }
             if (!layer->temporary()) {
-                emit sigLayerRemoved(layer, tqparent, wasAbove);
+                emit sigLayerRemoved(layer, parent, wasAbove);
                 if (wasActive) {
                     if (wasBelow)
                         activate(wasBelow);
                     else if (wasAbove)
                         activate(wasAbove);
-                    else if (tqparent != rootLayer())
-                        activate(tqparent.data());
+                    else if (parent != rootLayer())
+                        activate(parent.data());
                     else
                         activate(rootLayer()->firstChild());
                 } else {
@@ -1228,7 +1228,7 @@ bool KisImage::raiseLayer(KisLayerSP layer)
 {
     if (!layer)
         return false;
-    return moveLayer(layer, layer->tqparent().data(), layer->prevSibling());
+    return moveLayer(layer, layer->parent().data(), layer->prevSibling());
 }
 
 bool KisImage::lowerLayer(KisLayerSP layer)
@@ -1236,7 +1236,7 @@ bool KisImage::lowerLayer(KisLayerSP layer)
     if (!layer)
         return false;
     if (KisLayerSP next = layer->nextSibling())
-        return moveLayer(layer, layer->tqparent().data(), next->nextSibling());
+        return moveLayer(layer, layer->parent().data(), next->nextSibling());
     return false;
 }
 
@@ -1254,15 +1254,15 @@ bool KisImage::toBottom(KisLayerSP layer)
     return moveLayer(layer, rootLayer(), 0);
 }
 
-bool KisImage::moveLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis)
+bool KisImage::moveLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis)
 {
-    if (!tqparent)
+    if (!parent)
         return false;
 
-    KisGroupLayerSP wasParent = layer->tqparent();
+    KisGroupLayerSP wasParent = layer->parent();
     KisLayerSP wasAbove = layer->nextSibling();
 
-    if (wasParent.data() == tqparent.data() && wasAbove.data() == aboveThis.data())
+    if (wasParent.data() == parent.data() && wasAbove.data() == aboveThis.data())
         return false;
 
     lock();
@@ -1272,7 +1272,7 @@ bool KisImage::moveLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP
         return false;
     }
 
-    const bool success = tqparent->addLayer(layer, aboveThis);
+    const bool success = parent->addLayer(layer, aboveThis);
 
     layer->setDirty();
 
@@ -1357,7 +1357,7 @@ void KisImage::mergeLayer(KisLayerSP layer)
     layer->accept(visitor);
 
     removeLayer(layer->nextSibling());
-    addLayer(player, layer->tqparent(), layer);
+    addLayer(player, layer->parent(), layer);
     removeLayer(layer);
 
     undoAdapter()->endMacro();
diff --git a/chalk/core/kis_image.h b/chalk/core/kis_image.h
index 4db23d3c..132505b2 100644
--- a/chalk/core/kis_image.h
+++ b/chalk/core/kis_image.h
@@ -248,23 +248,23 @@ public:
     KisLayerSP findLayer(int id) const;
 
     /// Move layer to specified position
-    bool moveLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis);
+    bool moveLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis);
 
     /**
     * Add an already existing layer to the image. The layer is put on top
     * of the layers in the specified layergroup
     * @param layer the layer to be added
-    * @param tqparent the tqparent layer
+    * @param parent the parent layer
     */
-    bool addLayer(KisLayerSP layer, KisGroupLayerSP tqparent);
+    bool addLayer(KisLayerSP layer, KisGroupLayerSP parent);
     
     /**
     * Add already existing layer to image.
     *
     * @param layer the layer to be added
-    * @param tqparent the tqparent layer
+    * @param parent the parent layer
     * @param aboveThis in the list with child layers of the specified
-    *                  tqparent, add this layer above the specified sibling.
+    *                  parent, add this layer above the specified sibling.
     *                  if 0, the layer is put in the lowermost position in
     *                  its group.
     * @param notify If true, the image is immediately recomposited, if false,
@@ -272,7 +272,7 @@ public:
     *
     * returns false if adding the layer didn't work, true if the layer got added
     */
-    bool addLayer(KisLayerSP layer, KisGroupLayerSP tqparent, KisLayerSP aboveThis);
+    bool addLayer(KisLayerSP layer, KisGroupLayerSP parent, KisLayerSP aboveThis);
 
     /// Remove layer
     bool removeLayer(KisLayerSP layer);
@@ -355,21 +355,21 @@ signals:
     /// Emitted after a different layer is made active.
     void sigLayerActivated(KisLayerSP layer);
 
-    /// Emitted after a layer is added: you can find out where by asking it for its tqparent(), et al.
+    /// Emitted after a layer is added: you can find out where by asking it for its parent(), et al.
     void sigLayerAdded(KisLayerSP layer);
 
     /** Emitted after a layer is removed.
         It's no longer in the image, but still exists, so @p layer is valid.
 
         @param layer the removed layer
-        @param tqparent the tqparent of the layer, before it was removed
+        @param parent the parent of the layer, before it was removed
         @param wasAboveThis the layer it was above, before it was removed.
     */
     void sigLayerRemoved(KisLayerSP layer, KisGroupLayerSP wasParent, KisLayerSP wasAboveThis);
 
-    /** Emitted after a layer is moved to a different position under its tqparent layer, or its tqparent changes.
+    /** Emitted after a layer is moved to a different position under its parent layer, or its parent changes.
 
-        @param previousParent the tqparent of the layer, before it was moved
+        @param previousParent the parent of the layer, before it was moved
         @param wasAboveThis the layer it was above, before it was moved.
     */
     void sigLayerMoved(KisLayerSP layer, KisGroupLayerSP previousParent, KisLayerSP wasAboveThis);
@@ -409,7 +409,7 @@ signals:
     void sigColorSpaceChanged(KisColorSpace*  cs);
 
 
-    /// Emitted when any layer's tqmask info got updated (or when the current layer changes)
+    /// Emitted when any layer's mask info got updated (or when the current layer changes)
     void sigMaskInfoChanged();
 public slots:
     void slotSelectionChanged();
diff --git a/chalk/core/kis_imagepipe_brush.cc b/chalk/core/kis_imagepipe_brush.cc
index 9b71c83d..726d0295 100644
--- a/chalk/core/kis_imagepipe_brush.cc
+++ b/chalk/core/kis_imagepipe_brush.cc
@@ -318,11 +318,11 @@ TQImage KisImagePipeBrush::img()
     }
 }
 
-KisAlphaMaskSP KisImagePipeBrush::tqmask(const KisPaintInformation& info, double subPixelX, double subPixelY) const
+KisAlphaMaskSP KisImagePipeBrush::mask(const KisPaintInformation& info, double subPixelX, double subPixelY) const
 {
     if (m_brushes.isEmpty()) return 0;
     selectNextBrush(info);
-    return m_brushes.at(m_currentBrush)->tqmask(info, subPixelX, subPixelY);
+    return m_brushes.at(m_currentBrush)->mask(info, subPixelX, subPixelY);
 }
 
 KisPaintDeviceSP KisImagePipeBrush::image(KisColorSpace * colorSpace, const KisPaintInformation& info, double subPixelX, double subPixelY) const
diff --git a/chalk/core/kis_imagepipe_brush.h b/chalk/core/kis_imagepipe_brush.h
index bc54204b..eea58194 100644
--- a/chalk/core/kis_imagepipe_brush.h
+++ b/chalk/core/kis_imagepipe_brush.h
@@ -125,9 +125,9 @@ public:
     virtual TQImage img();
 
     /**
-       @return the next tqmask in the pipe.
+       @return the next mask in the pipe.
     */
-    virtual KisAlphaMaskSP tqmask(const KisPaintInformation& info,
+    virtual KisAlphaMaskSP mask(const KisPaintInformation& info,
                                 double subPixelX = 0, double subPixelY = 0) const;
     virtual KisPaintDeviceSP image(KisColorSpace * colorSpace, const KisPaintInformation& info,
                              double subPixelX = 0, double subPixelY = 0) const;
diff --git a/chalk/core/kis_iteratorpixeltrait.h b/chalk/core/kis_iteratorpixeltrait.h
index 5d2c957f..2b047c0e 100644
--- a/chalk/core/kis_iteratorpixeltrait.h
+++ b/chalk/core/kis_iteratorpixeltrait.h
@@ -103,7 +103,7 @@ public:
         };
 
     /**
-     * Returns the selectiontqmask from the current point; this is guaranteed
+     * Returns the selectionmask from the current point; this is guaranteed
      * to have the same number of consecutive pixels that the iterator has
      * at a given point. It return a 0 if there is no selection.
      */
diff --git a/chalk/core/kis_iterators_pixel.h b/chalk/core/kis_iterators_pixel.h
index bd82f856..65ad7831 100644
--- a/chalk/core/kis_iterators_pixel.h
+++ b/chalk/core/kis_iterators_pixel.h
@@ -66,10 +66,10 @@ public:
     
     TQ_INT32 nConseqHPixels() const {
         if (m_selectionIterator) {
-            TQ_INT32 tqparent = KisHLineIteratorPixel::nConseqHPixels();
+            TQ_INT32 parent = KisHLineIteratorPixel::nConseqHPixels();
             TQ_INT32 selection = m_selectionIterator->nConseqHPixels();
-            if (tqparent < selection)
-                return tqparent;
+            if (parent < selection)
+                return parent;
             return selection;
         }
         return KisHLineIteratorPixel::nConseqHPixels();
@@ -137,10 +137,10 @@ public:
 
     TQ_INT32 nConseqPixels() const {
         if (m_selectionIterator) {
-            TQ_INT32 tqparent = KisRectIterator::nConseqPixels();
+            TQ_INT32 parent = KisRectIterator::nConseqPixels();
             TQ_INT32 selection = m_selectionIterator->nConseqPixels();
-            if (tqparent < selection)
-                return tqparent;
+            if (parent < selection)
+                return parent;
             return selection;
         }
         return KisRectIterator::nConseqPixels();
diff --git a/chalk/core/kis_layer.cc b/chalk/core/kis_layer.cc
index 752159c0..2b7307e5 100644
--- a/chalk/core/kis_layer.cc
+++ b/chalk/core/kis_layer.cc
@@ -341,7 +341,7 @@ void KisLayer::setDirty(bool propagate)
 
     if (rc.isValid()) m_dirtyRect = rc;
 
-    // If we're dirty, our tqparent is dirty, if we've got a tqparent
+    // If we're dirty, our parent is dirty, if we've got a parent
     if (propagate && m_parent && rc.isValid()) m_parent->setDirty(m_dirtyRect);
 
     if (m_image && rc.isValid()) {
@@ -351,7 +351,7 @@ void KisLayer::setDirty(bool propagate)
 
 void KisLayer::setDirty(const TQRect & rc, bool propagate)
 {
-    // If we're dirty, our tqparent is dirty, if we've got a tqparent
+    // If we're dirty, our parent is dirty, if we've got a parent
 
     if (rc.isValid())
         m_dirtyRect |= rc;
@@ -364,23 +364,23 @@ void KisLayer::setDirty(const TQRect & rc, bool propagate)
     }
 }
 
-KisGroupLayerSP KisLayer::tqparent() const
+KisGroupLayerSP KisLayer::parent() const
 {
     return m_parent;
 }
 
 KisLayerSP KisLayer::prevSibling() const
 {
-    if (!tqparent())
+    if (!parent())
         return 0;
-    return tqparent()->at(index() - 1);
+    return parent()->at(index() - 1);
 }
 
 KisLayerSP KisLayer::nextSibling() const
 {
-    if (!tqparent())
+    if (!parent())
         return 0;
-    return tqparent()->at(index() + 1);
+    return parent()->at(index() + 1);
 }
 
 int KisLayer::index() const
@@ -390,9 +390,9 @@ int KisLayer::index() const
 
 void KisLayer::setIndex(int i)
 {
-    if (!tqparent())
+    if (!parent())
         return;
-    tqparent()->setIndex(this, i);
+    parent()->setIndex(this, i);
 }
 
 KisLayerSP KisLayer::findLayer(const TQString& n) const
diff --git a/chalk/core/kis_layer.h b/chalk/core/kis_layer.h
index 09ecd235..2cff4bc9 100644
--- a/chalk/core/kis_layer.h
+++ b/chalk/core/kis_layer.h
@@ -69,14 +69,14 @@ public:
     
     
     /**
-     * Set the entire layer extent dirty; this percolates up to tqparent layers all the
+     * Set the entire layer extent dirty; this percolates up to parent layers all the
      * way to the root layer.
      */
     virtual void setDirty(bool propagate = true);
 
     /**
      * Add the given rect to the set of dirty rects for this layer;
-     * this percolates up to tqparent layers all the way to the root
+     * this percolates up to parent layers all the way to the root
      * layer.
      */
     virtual void setDirty(const TQRect & rect, bool propagate = true);
@@ -87,41 +87,41 @@ public:
     /// Returns the ID of the layer, which is guaranteed to be unique among all KisLayers.
     int id() const { return m_id; }
 
-    /* Returns the index of the layer in its tqparent's list of child layers. Indices
+    /* Returns the index of the layer in its parent's list of child layers. Indices
      * increase from 0, which is the topmost layer in the list, to the bottommost.
      */
     virtual int index() const;
 
-    /// Moves this layer to the specified index within its tqparent's list of child layers.
+    /// Moves this layer to the specified index within its parent's list of child layers.
     virtual void setIndex(int index);
 
     /**
-     * Returns the tqparent layer of a layer. This is 0 only for a root layer; otherwise
+     * Returns the parent layer of a layer. This is 0 only for a root layer; otherwise
      * this will be an actual GroupLayer */
-    virtual KisGroupLayerSP tqparent() const;
+    virtual KisGroupLayerSP parent() const;
 
     /**
-     * Returns the previous sibling of this layer in the tqparent's list. This is the layer
-     * *above* this layer. 0 is returned if there is no tqparent, or if this child has no more
+     * Returns the previous sibling of this layer in the parent's list. This is the layer
+     * *above* this layer. 0 is returned if there is no parent, or if this child has no more
      * previous siblings (== firstChild())
      */
     virtual KisLayerSP prevSibling() const;
 
     /**
-     * Returns the next sibling of this layer in the tqparent's list. This is the layer *below*
-     * this layer. 0 is returned if there is no tqparent, or if this child has no more next 
+     * Returns the next sibling of this layer in the parent's list. This is the layer *below*
+     * this layer. 0 is returned if there is no parent, or if this child has no more next 
      * siblings (== lastChild())
      */
     virtual KisLayerSP nextSibling() const;
 
     /**
-     * Returns the sibling above this layer in its tqparent's list. 0 is returned if there is no tqparent,
+     * Returns the sibling above this layer in its parent's list. 0 is returned if there is no parent,
      * or if this layer is the topmost layer in its group. This is the same as calling prevSibling().
      */
     KisLayerSP siblingAbove() const { return prevSibling(); }
 
     /**
-     * Returns the sibling below this layer in its tqparent's list. 0 is returned if there is no tqparent,
+     * Returns the sibling below this layer in its parent's list. 0 is returned if there is no parent,
      * or if this layer is the bottommost layer in its group.  This is the same as calling nextSibling().
      */
     KisLayerSP siblingBelow() const { return nextSibling(); }
@@ -197,7 +197,7 @@ public:
 
     KisUndoAdapter *undoAdapter() const;
 
-    /// paints a tqmask where the selection on this layer resides
+    /// paints a mask where the selection on this layer resides
     virtual void paintSelection(TQImage &img, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h);
     virtual void paintSelection(TQImage &img, const TQRect& scaledImageRect, const TQSize& scaledImageSize, const TQSize& imageSize);
 
diff --git a/chalk/core/kis_merge_visitor.h b/chalk/core/kis_merge_visitor.h
index 721ce827..afd8fb37 100644
--- a/chalk/core/kis_merge_visitor.h
+++ b/chalk/core/kis_merge_visitor.h
@@ -114,11 +114,11 @@ public:
             gc.bitBlt(dx, dy, layer->compositeOp(), source, layer->opacity(), sx, sy, w, h);
         } else {
             if (layer->renderMask()) {
-                // To display the tqmask, we don't do things with composite op and opacity
+                // To display the mask, we don't do things with composite op and opacity
                 // This is like the gimp does it, I guess that's ok?
 
                 // Note that here we'll use m_rc, because even if the extent of the device is
-                // empty, we want a full tqmask to be drawn! (we don't change rc, since
+                // empty, we want a full mask to be drawn! (we don't change rc, since
                 // it'd mess with setClean). This is because KisPainter::bitBlt &'s with
                 // the source device's extent. This is ok in normal circumstances, but
                 // we changed the default tile. Fixing this properly would mean fixing it there.
@@ -129,36 +129,36 @@ public:
                 dx = sx;
                 dy = sy;
 
-                // The problem is that the extent of the layer tqmask might not be extended
+                // The problem is that the extent of the layer mask might not be extended
                 // enough. Check if that is the case
-                KisPaintDeviceSP tqmask = layer->getMask();
-                TQRect mextent = tqmask->extent();
+                KisPaintDeviceSP mask = layer->getMask();
+                TQRect mextent = mask->extent();
                 if ((mextent & m_rc) != m_rc) {
                     // Iterate over all pixels in the m_rc area. With just accessing the
                     // tiles in read-write mode, we ensure that the tiles get created if they
                     // do not exist. If they do, they'll remain untouched since we don't
                     // actually write data to it.
                     // XXX Admission: this is actually kind of a hack :-(
-                    KisRectIteratorPixel it = tqmask->createRectIterator(sx, sy, w, h, true);
+                    KisRectIteratorPixel it = mask->createRectIterator(sx, sy, w, h, true);
                     while (!it.isDone())
                         ++it;
                 }
                 if (tempTarget) {
                     KisPaintDeviceSP temp = new KisPaintDevice(source->colorSpace());
-                    tqmask = paintIndirect(tqmask, temp, layer, sx, sy, dx, dy, w, h);
+                    mask = paintIndirect(mask, temp, layer, sx, sy, dx, dy, w, h);
                 }
 
-                gc.bitBlt(dx, dy, COMPOSITE_OVER, tqmask, OPACITY_OPAQUE, sx, sy, w, h);
+                gc.bitBlt(dx, dy, COMPOSITE_OVER, mask, OPACITY_OPAQUE, sx, sy, w, h);
             } else {
-                KisSelectionSP tqmask = layer->getMaskAsSelection();
-                // The indirect painting happens on the tqmask
+                KisSelectionSP mask = layer->getMaskAsSelection();
+                // The indirect painting happens on the mask
                 if (tempTarget && layer->editMask()) {
                     KisPaintDeviceSP maskSrc = layer->getMask();
                     KisPaintDeviceSP temp = new KisPaintDevice(maskSrc->colorSpace());
                     temp = paintIndirect(maskSrc, temp, layer, sx, sy, dx, dy, w, h);
                     // Blegh
                     KisRectIteratorPixel srcIt = temp->createRectIterator(sx, sy, w, h, false);
-                    KisRectIteratorPixel dstIt = tqmask->createRectIterator(sx, sy, w, h, true);
+                    KisRectIteratorPixel dstIt = mask->createRectIterator(sx, sy, w, h, true);
 
                     while(!dstIt.isDone()) {
                         // Same as in convertMaskToSelection
@@ -167,7 +167,7 @@ public:
                         ++dstIt;
                     }
                 } else if (tempTarget) {
-                    // We have a tqmask, and paint indirect, but not on the tqmask
+                    // We have a mask, and paint indirect, but not on the mask
                     KisPaintDeviceSP temp = new KisPaintDevice(source->colorSpace());
                     source = paintIndirect(source, temp, layer, sx, sy, dx, dy, w, h);
                 }
@@ -175,7 +175,7 @@ public:
                 gc.bltSelection(dx, dy,
                                 layer->compositeOp(),
                                 source,
-                                tqmask,
+                                mask,
                                 layer->opacity(), sx, sy, w, h);
             }
         }
diff --git a/chalk/core/kis_paint_device.cc b/chalk/core/kis_paint_device.cc
index 59665829..195364c6 100644
--- a/chalk/core/kis_paint_device.cc
+++ b/chalk/core/kis_paint_device.cc
@@ -236,7 +236,7 @@ KisPaintDevice::KisPaintDevice(KisColorSpace * colorSpace, const char * name) :
 
 }
 
-KisPaintDevice::KisPaintDevice(KisLayer *tqparent, KisColorSpace * colorSpace, const char * name) :
+KisPaintDevice::KisPaintDevice(KisLayer *parent, KisColorSpace * colorSpace, const char * name) :
         TQObject(0, name), KShared(), m_exifInfo(0), m_lock( false )
 {
 
@@ -250,10 +250,10 @@ KisPaintDevice::KisPaintDevice(KisLayer *tqparent, KisColorSpace * colorSpace, c
     m_selectionDeselected = false;
     m_selection = 0;
 
-    m_parentLayer = tqparent;
+    m_parentLayer = parent;
 
-    if (colorSpace == 0 && tqparent != 0 && tqparent->image() != 0) {
-        m_colorSpace = tqparent->image()->colorSpace();
+    if (colorSpace == 0 && parent != 0 && parent->image() != 0) {
+        m_colorSpace = parent->image()->colorSpace();
     }
     else {
         m_colorSpace = colorSpace;
@@ -1107,15 +1107,15 @@ void KisPaintDevice::clearSelection()
     }
 }
 
-void KisPaintDevice::applySelectionMask(KisSelectionSP tqmask)
+void KisPaintDevice::applySelectionMask(KisSelectionSP mask)
 {
-    TQRect r = tqmask->selectedRect();
+    TQRect r = mask->selectedRect();
     crop(r);
 
     for (TQ_INT32 y = r.top(); y <= r.bottom(); ++y) {
 
         KisHLineIterator pixelIt = createHLineIterator(r.x(), y, r.width(), true);
-        KisHLineIterator maskIt = tqmask->createHLineIterator(r.x(), y, r.width(), false);
+        KisHLineIterator maskIt = mask->createHLineIterator(r.x(), y, r.width(), false);
 
         while (!pixelIt.isDone()) {
             // XXX: Optimize by using stretches
diff --git a/chalk/core/kis_paint_device.h b/chalk/core/kis_paint_device.h
index 7fe6250b..5e5dbb3f 100644
--- a/chalk/core/kis_paint_device.h
+++ b/chalk/core/kis_paint_device.h
@@ -274,7 +274,7 @@ public:
     virtual TQImage convertToTQImage(KisProfile *  dstProfile, TQ_INT32 x, TQ_INT32 y, TQ_INT32 w, TQ_INT32 h, float exposure = 0.0f);
 
     /**
-     * Create an RGBA TQImage from a rectangle in the paint device. The rectangle is defined by the tqparent image's bounds.
+     * Create an RGBA TQImage from a rectangle in the paint device. The rectangle is defined by the parent image's bounds.
      *
      * @param dstProfile RGB profile to use in conversion. May be 0, in which
      * case it's up to the colour strategy to choose a profile (most
@@ -403,12 +403,12 @@ public:
     void setParentLayer(KisLayer *parentLayer);
 
     /**
-     * Add the specified rect top the tqparent layer (if present)
+     * Add the specified rect top the parent layer (if present)
      */
     virtual void setDirty(const TQRect & rc);
 
     /**
-     * Set the tqparent layer completely dirty, if this paint device has one.
+     * Set the parent layer completely dirty, if this paint device has one.
      */
     virtual void setDirty();
     
@@ -479,10 +479,10 @@ public:
     void clearSelection();
 
     /**
-     * Apply a tqmask to the image data, i.e. multiply each pixel's opacity by its
-     * selectedness in the tqmask.
+     * Apply a mask to the image data, i.e. multiply each pixel's opacity by its
+     * selectedness in the mask.
      */
-    void applySelectionMask(KisSelectionSP tqmask);
+    void applySelectionMask(KisSelectionSP mask);
 
     /**
      * Sets the selection of this paint device to the new selection,
diff --git a/chalk/core/kis_paint_device_iface.cc b/chalk/core/kis_paint_device_iface.cc
index 1aace538..220c716b 100644
--- a/chalk/core/kis_paint_device_iface.cc
+++ b/chalk/core/kis_paint_device_iface.cc
@@ -27,10 +27,10 @@
 
 #include "kis_paint_device.h"
 
-KisPaintDeviceIface::KisPaintDeviceIface( KisPaintDevice * tqparent )
+KisPaintDeviceIface::KisPaintDeviceIface( KisPaintDevice * parent )
     : DCOPObject("paintdevice")
 {
-    m_parent = tqparent;
+    m_parent = parent;
 }
 
 TQ_INT32 KisPaintDeviceIface::pixelSize() const
diff --git a/chalk/core/kis_paint_device_iface.h b/chalk/core/kis_paint_device_iface.h
index df7c9372..eee4d3f5 100644
--- a/chalk/core/kis_paint_device_iface.h
+++ b/chalk/core/kis_paint_device_iface.h
@@ -31,7 +31,7 @@ class KisPaintDeviceIface : virtual public DCOPObject
 {
     K_DCOP
 public:
-    KisPaintDeviceIface( KisPaintDevice * tqparent );
+    KisPaintDeviceIface( KisPaintDevice * parent );
 k_dcop:
 
     /**
diff --git a/chalk/core/kis_paint_layer.cc b/chalk/core/kis_paint_layer.cc
index 2df12e01..a4c5412d 100644
--- a/chalk/core/kis_paint_layer.cc
+++ b/chalk/core/kis_paint_layer.cc
@@ -39,7 +39,7 @@ KisPaintLayer::KisPaintLayer(KisImage *img, const TQString& name, TQ_UINT8 opaci
     Q_ASSERT(img);
     Q_ASSERT(dev);
     m_paintdev = dev;
-    m_tqmask = 0;
+    m_mask = 0;
     m_maskAsSelection = 0;
     m_paintdev->setParentLayer(this);
     m_renderMask = false;
@@ -52,7 +52,7 @@ KisPaintLayer::KisPaintLayer(KisImage *img, const TQString& name, TQ_UINT8 opaci
 {
     Q_ASSERT(img);
     m_paintdev = new KisPaintDevice(this, img->colorSpace(), name.latin1());
-    m_tqmask = 0;
+    m_mask = 0;
     m_maskAsSelection = 0;
     m_renderMask = false;
     m_editMask = true;
@@ -64,7 +64,7 @@ KisPaintLayer::KisPaintLayer(KisImage *img, const TQString& name, TQ_UINT8 opaci
     Q_ASSERT(img);
     Q_ASSERT(colorSpace);
     m_paintdev = new KisPaintDevice(this, colorSpace,  name.latin1());
-    m_tqmask = 0;
+    m_mask = 0;
     m_maskAsSelection = 0;
     m_renderMask = false;
     m_editMask = true;
@@ -76,8 +76,8 @@ KisPaintLayer::KisPaintLayer(const KisPaintLayer& rhs) :
     m_paintdev = new KisPaintDevice( *rhs.m_paintdev.data() );
     m_paintdev->setParentLayer(this);
     if (rhs.hasMask()) {
-        m_tqmask = new KisPaintDevice(*rhs.m_tqmask.data());
-        m_tqmask->setParentLayer(this);
+        m_mask = new KisPaintDevice(*rhs.m_mask.data());
+        m_mask->setParentLayer(this);
     }
     m_renderMask = rhs.m_renderMask;
     m_editMask = rhs.m_editMask;
@@ -93,8 +93,8 @@ KisPaintLayer::~KisPaintLayer()
     if (m_paintdev != 0) {
         m_paintdev->setParentLayer(0);
     }
-    if (m_tqmask != 0) {
-        m_tqmask->setParentLayer(0);
+    if (m_mask != 0) {
+        m_mask->setParentLayer(0);
     }
 }
 
@@ -102,8 +102,8 @@ void KisPaintLayer::paintSelection(TQImage &img, TQ_INT32 x, TQ_INT32 y, TQ_INT3
 {
     if (m_paintdev && m_paintdev->hasSelection()) {
         m_paintdev->selection()->paintSelection(img, x, y, w, h);
-    } else if (m_tqmask && m_editMask && m_tqmask->hasSelection()) {
-        m_tqmask->selection()->paintSelection(img, x, y, w, h);
+    } else if (m_mask && m_editMask && m_mask->hasSelection()) {
+        m_mask->selection()->paintSelection(img, x, y, w, h);
     }
 }
 
@@ -111,8 +111,8 @@ void KisPaintLayer::paintSelection(TQImage &img, const TQRect& scaledImageRect,
 {
     if (m_paintdev && m_paintdev->hasSelection()) {
         m_paintdev->selection()->paintSelection(img, scaledImageRect, scaledImageSize, imageSize);
-    } else if (m_tqmask && m_editMask && m_tqmask->hasSelection()) {
-        m_tqmask->selection()->paintSelection(img, scaledImageRect, scaledImageSize, imageSize);
+    } else if (m_mask && m_editMask && m_mask->hasSelection()) {
+        m_mask->selection()->paintSelection(img, scaledImageRect, scaledImageSize, imageSize);
     }
 }
 
@@ -191,15 +191,15 @@ void KisPaintLayer::removeMask() {
     if (!hasMask())
         return;
 
-    m_tqmask->setParentLayer(0);
-    m_tqmask = 0;
+    m_mask->setParentLayer(0);
+    m_mask = 0;
     m_maskAsSelection = 0;
     setDirty();
 
     emit sigMaskInfoChanged();
 }
 
-// ### XXX Do we apply the tqmask outside the image boundaries too? I'd say no, but I'm not sure
+// ### XXX Do we apply the mask outside the image boundaries too? I'd say no, but I'm not sure
 void KisPaintLayer::applyMask() {
     if (!hasMask())
         return;
@@ -221,18 +221,18 @@ void KisPaintLayer::applyMask() {
 
 KisPaintDeviceSP KisPaintLayer::createMask() {
     if (hasMask())
-        return m_tqmask;
+        return m_mask;
 
     kdDebug() << k_funcinfo << endl;
     // Grey8 nicely fits our needs of being intuitively comparable to other apps'
-    // tqmask layer interfaces. It does have an alpha component though, which is a bit
+    // mask layer interfaces. It does have an alpha component though, which is a bit
     // less appropriate in this context.
-    m_tqmask = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()
+    m_mask = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()
             ->getColorSpace(KisID("GRAYA"), 0));
 
     genericMaskCreationHelper();
 
-    return m_tqmask;
+    return m_mask;
 }
 
 // FIXME If from is a paint device is not grey8!!
@@ -241,22 +241,22 @@ void KisPaintLayer::createMaskFromPaintDevice(KisPaintDeviceSP from) {
         return; // Or overwrite? XXX
 
     kdDebug() << k_funcinfo << endl;
-    m_tqmask = from; // KisPaintDevice(*from); XXX
+    m_mask = from; // KisPaintDevice(*from); XXX
 
     genericMaskCreationHelper();
 }
 
 void KisPaintLayer::createMaskFromSelection(KisSelectionSP from) {
     kdDebug() << k_funcinfo << endl;
-    m_tqmask = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()
+    m_mask = new KisPaintDevice(KisMetaRegistry::instance()->csRegistry()
             ->getColorSpace(KisID("GRAYA"), 0));
-    m_tqmask->setParentLayer(this);
+    m_mask->setParentLayer(this);
 
     m_maskAsSelection = new KisSelection(); // Anonymous selection is good enough
 
-    // Default pixel is opaque white == don't tqmask?
+    // Default pixel is opaque white == don't mask?
     TQ_UINT8 const defPixel[] = { 255, 255 };
-    m_tqmask->dataManager()->setDefaultPixel(defPixel);
+    m_mask->dataManager()->setDefaultPixel(defPixel);
 
     if (from) {
         TQRect r(extent());
@@ -265,7 +265,7 @@ void KisPaintLayer::createMaskFromSelection(KisSelectionSP from) {
         int h = r.height();
         for (int y = r.y(); y < h; y++) {
             KisHLineIteratorPixel srcIt = from->createHLineIterator(r.x(), y, w, false);
-            KisHLineIteratorPixel dstIt = m_tqmask->createHLineIterator(r.x(), y, w, true);
+            KisHLineIteratorPixel dstIt = m_mask->createHLineIterator(r.x(), y, w, true);
 
             while(!dstIt.isDone()) {
                 // XXX same remark as in convertMaskToSelection
@@ -286,7 +286,7 @@ void KisPaintLayer::createMaskFromSelection(KisSelectionSP from) {
 KisPaintDeviceSP KisPaintLayer::getMask() {
     createMask();
     kdDebug() << k_funcinfo << endl;
-    return m_tqmask;
+    return m_mask;
 }
 
 KisSelectionSP KisPaintLayer::getMaskAsSelection() {
@@ -310,7 +310,7 @@ void KisPaintLayer::setRenderMask(bool b) {
 }
 
 void KisPaintLayer::convertMaskToSelection(const TQRect& r) {
-    KisRectIteratorPixel srcIt = m_tqmask->createRectIterator(r.x(), r.y(),
+    KisRectIteratorPixel srcIt = m_mask->createRectIterator(r.x(), r.y(),
             r.width(), r.height(), false);
     KisRectIteratorPixel dstIt = m_maskAsSelection->createRectIterator(r.x(), r.y(),
             r.width(), r.height(), true);
@@ -326,13 +326,13 @@ void KisPaintLayer::convertMaskToSelection(const TQRect& r) {
 }
 
 void KisPaintLayer::genericMaskCreationHelper() {
-    m_tqmask->setParentLayer(this);
+    m_mask->setParentLayer(this);
 
     m_maskAsSelection = new KisSelection(); // Anonymous selection is good enough
 
-    // Default pixel is opaque white == don't tqmask?
+    // Default pixel is opaque white == don't mask?
     TQ_UINT8 const defPixel[] = { 255, 255 };
-    m_tqmask->dataManager()->setDefaultPixel(defPixel);
+    m_mask->dataManager()->setDefaultPixel(defPixel);
 
     setDirty();
     emit sigMaskInfoChanged();
@@ -355,16 +355,16 @@ namespace {
     class KisCreateMaskCommand : public KNamedCommand {
         typedef KNamedCommand super;
         KisPaintLayerSP m_layer;
-        KisPaintDeviceSP m_tqmask;
+        KisPaintDeviceSP m_mask;
     public:
         KisCreateMaskCommand(const TQString& name, KisPaintLayer* layer)
             : super(name), m_layer(layer) {}
         virtual void execute() {
             kdDebug() << k_funcinfo << endl;
-            if (!m_tqmask)
-                m_tqmask = m_layer->createMask();
+            if (!m_mask)
+                m_mask = m_layer->createMask();
             else
-                m_layer->createMaskFromPaintDevice(m_tqmask);
+                m_layer->createMaskFromPaintDevice(m_mask);
         }
         virtual void unexecute() {
             m_layer->removeMask();
@@ -411,12 +411,12 @@ namespace {
     class KisMaskToSelectionCommand : public KNamedCommand {
         typedef KNamedCommand super;
         KisPaintLayerSP m_layer;
-        KisPaintDeviceSP m_tqmask;
+        KisPaintDeviceSP m_mask;
         KisSelectionSP m_selection;
     public:
         KisMaskToSelectionCommand(const TQString& name, KisPaintLayer* layer)
             : super(name), m_layer(layer) {
-            m_tqmask = m_layer->getMask();
+            m_mask = m_layer->getMask();
             if (m_layer->paintDevice()->hasSelection())
                 m_selection = m_layer->paintDevice()->selection();
             else
@@ -431,18 +431,18 @@ namespace {
                 m_layer->paintDevice()->setSelection(m_selection);
             else
                 m_layer->paintDevice()->deselect();
-            m_layer->createMaskFromPaintDevice(m_tqmask);
+            m_layer->createMaskFromPaintDevice(m_mask);
         }
     };
 
     class KisRemoveMaskCommand : public KNamedCommand {
         typedef KNamedCommand super;
         KisPaintLayerSP m_layer;
-        KisPaintDeviceSP m_tqmask;
+        KisPaintDeviceSP m_mask;
     public:
         KisRemoveMaskCommand(const TQString& name, KisPaintLayer* layer)
             : super(name), m_layer(layer) {
-            m_tqmask = m_layer->getMask();
+            m_mask = m_layer->getMask();
         }
         virtual void execute() {
             kdDebug() << k_funcinfo << endl;
@@ -451,19 +451,19 @@ namespace {
         virtual void unexecute() {
             // I hope that if the undo stack unwinds, it will end up here in the right
             // state again; taking a deep-copy sounds like wasteful to me
-            m_layer->createMaskFromPaintDevice(m_tqmask);
+            m_layer->createMaskFromPaintDevice(m_mask);
         }
     };
 
     class KisApplyMaskCommand : public KNamedCommand {
         typedef KNamedCommand super;
         KisPaintLayerSP m_layer;
-        KisPaintDeviceSP m_tqmask;
+        KisPaintDeviceSP m_mask;
         KisPaintDeviceSP m_original;
     public:
         KisApplyMaskCommand(const TQString& name, KisPaintLayer* layer)
             : super(name), m_layer(layer) {
-            m_tqmask = m_layer->getMask();
+            m_mask = m_layer->getMask();
             m_original = new KisPaintDevice(*m_layer->paintDevice());
         }
         virtual void execute() {
@@ -479,7 +479,7 @@ namespace {
             gc.bitBlt(x, y, COMPOSITE_COPY, m_original, OPACITY_OPAQUE, x, y, w, h);
             gc.end();
 
-            m_layer->createMaskFromPaintDevice(m_tqmask);
+            m_layer->createMaskFromPaintDevice(m_mask);
         }
     };
 }
diff --git a/chalk/core/kis_paint_layer.h b/chalk/core/kis_paint_layer.h
index 6319f981..2cbd5e48 100644
--- a/chalk/core/kis_paint_layer.h
+++ b/chalk/core/kis_paint_layer.h
@@ -73,55 +73,55 @@ public:
 
     inline KisPaintDeviceSP paintDevice() const { return m_paintdev; }
 
-    /// Returns the paintDevice that accompanies this layer (or tqmask, see editMask)
+    /// Returns the paintDevice that accompanies this layer (or mask, see editMask)
     inline KisPaintDeviceSP paintDeviceOrMask() const {
         if (hasMask() && editMask())
-            return m_tqmask;
+            return m_mask;
         return m_paintdev;
     }
 
     // Mask Layer
 
-    /// Does this layer have a layer tqmask?
-    bool hasMask() const { return m_tqmask != 0; }
+    /// Does this layer have a layer mask?
+    bool hasMask() const { return m_mask != 0; }
     // XXX TODO: Make these undo-able!
-    /// Create a tqmask if it does not yet exist, and return it
+    /// Create a mask if it does not yet exist, and return it
     KisPaintDeviceSP createMask();
-    /// Convert the from argument to the tqmask
+    /// Convert the from argument to the mask
     void createMaskFromPaintDevice(KisPaintDeviceSP from);
     /**
      * Convert the from selection to a paint device (should convert the getMaskAsSelection
-     * result back to the tqmask). Overwrites the current tqmask, if any. Also removes the selection
+     * result back to the mask). Overwrites the current mask, if any. Also removes the selection
      */
     void createMaskFromSelection(KisSelectionSP from);
-    /// Remove the layer tqmask
+    /// Remove the layer mask
     void removeMask();
-    /// Apply the layer tqmask to the paint device, this removes the tqmask afterwards
+    /// Apply the layer mask to the paint device, this removes the mask afterwards
     void applyMask();
-    /// Returns the layer tqmask's device. Creates one if there is currently none
+    /// Returns the layer mask's device. Creates one if there is currently none
     KisPaintDeviceSP getMask();
-    /// Returns the layer tqmask's device, converted to a selection. Creates one if there is currently none
+    /// Returns the layer mask's device, converted to a selection. Creates one if there is currently none
     KisSelectionSP getMaskAsSelection();
 
     /// Undoable version of createMask
     KNamedCommand* createMaskCommand();
     /// Undoable version of createMaskFromSelection
     KNamedCommand* maskFromSelectionCommand();
-    /// Undoable, removes the current tqmask, but converts it to the current selection
+    /// Undoable, removes the current mask, but converts it to the current selection
     KNamedCommand* maskToSelectionCommand();
     /// Undoable version of removeMask
     KNamedCommand* removeMaskCommand();
     /// Undoable version of applyMask
     KNamedCommand* applyMaskCommand();
 
-    /// Returns true if the masked part of the tqmask will be rendered instead of being transparent
+    /// Returns true if the masked part of the mask will be rendered instead of being transparent
     bool renderMask() const { return m_renderMask; }
     /// Set the renderMask property
     void setRenderMask(bool b);
 
     /**
      * When this returns true, the KisPaintDevice returned in paintDevice will actually
-     * be the layer tqmask (if there is one). This is so that tools can draw on the tqmask
+     * be the layer mask (if there is one). This is so that tools can draw on the mask
      * without needing to know its existance.
      */
     bool editMask() const { return m_editMask; }
@@ -136,17 +136,17 @@ public:
     // KisLayerSupportsIndirectPainting
     virtual KisLayer* layer() { return this; }
 signals:
-    /// When the tqmask is created/destroyed or the edittqmask or rendertqmask is changed
+    /// When the mask is created/destroyed or the editmask or rendermask is changed
     void sigMaskInfoChanged();
 
 private:
     void convertMaskToSelection(const TQRect& r);
     void genericMaskCreationHelper();
     KisPaintDeviceSP m_paintdev;
-    // Layer tqmask related:
+    // Layer mask related:
     // XXX It would be nice to merge the next 2 devices...
-    KisPaintDeviceSP m_tqmask; // The tqmask that we can edit and display easily
-    KisSelectionSP m_maskAsSelection; // The tqmask as selection, to apply and render easily
+    KisPaintDeviceSP m_mask; // The mask that we can edit and display easily
+    KisSelectionSP m_maskAsSelection; // The mask as selection, to apply and render easily
     bool m_renderMask;
     bool m_editMask;
 };
diff --git a/chalk/core/kis_painter.cc b/chalk/core/kis_painter.cc
index b8353918..c64935fc 100644
--- a/chalk/core/kis_painter.cc
+++ b/chalk/core/kis_painter.cc
@@ -812,7 +812,7 @@ void KisPainter::fillPolygon(const vKisPoint& points, FillStyle fillStyle)
     }
 
     // Fill the polygon bounding rectangle with the required contents then we'll
-    // create a tqmask for the actual polygon coverage.
+    // create a mask for the actual polygon coverage.
 
     KisPaintDeviceSP polygon = new KisPaintDevice(m_device->colorSpace(), "polygon");
     Q_CHECK_PTR(polygon);
diff --git a/chalk/core/kis_painter.h b/chalk/core/kis_painter.h
index abfd8b17..9ca623f6 100644
--- a/chalk/core/kis_painter.h
+++ b/chalk/core/kis_painter.h
@@ -123,7 +123,7 @@ public:
                 TQ_INT32 sw, TQ_INT32 sh);
 
     /**
-     * A version of bitBlt that renders using an external tqmask, ignoring
+     * A version of bitBlt that renders using an external mask, ignoring
      * the src device's own selection, if it has one.
      */
     void bltMask(TQ_INT32 dx, TQ_INT32 dy,
@@ -135,7 +135,7 @@ public:
                       TQ_INT32 sw, TQ_INT32 sh);
 
     /**
-     * A version of bitBlt that renders using an external selection tqmask, ignoring
+     * A version of bitBlt that renders using an external selection mask, ignoring
      * the src device's own selection, if it has one.
      */
     void bltSelection(TQ_INT32 dx, TQ_INT32 dy,
@@ -148,7 +148,7 @@ public:
 
 
     /**
-     * A version of bitBlt that renders using the src device's selection tqmask, if it has one.
+     * A version of bitBlt that renders using the src device's selection mask, if it has one.
      */
     void bltSelection(TQ_INT32 dx, TQ_INT32 dy,
                       const KisCompositeOp &op,
diff --git a/chalk/core/kis_paintop.cc b/chalk/core/kis_paintop.cc
index bff50cf5..edb9faf6 100644
--- a/chalk/core/kis_paintop.cc
+++ b/chalk/core/kis_paintop.cc
@@ -42,11 +42,11 @@ KisPaintOp::~KisPaintOp()
 {
 }
 
-KisPaintDeviceSP KisPaintOp::computeDab(KisAlphaMaskSP tqmask) {
-    return computeDab(tqmask, m_painter->device()->colorSpace());
+KisPaintDeviceSP KisPaintOp::computeDab(KisAlphaMaskSP mask) {
+    return computeDab(mask, m_painter->device()->colorSpace());
 }
 
-KisPaintDeviceSP KisPaintOp::computeDab(KisAlphaMaskSP tqmask, KisColorSpace *cs)
+KisPaintDeviceSP KisPaintOp::computeDab(KisAlphaMaskSP mask, KisColorSpace *cs)
 {
     // XXX: According to the SeaShore source, the Gimp uses a
     // temporary layer the size of the layer that is being painted
@@ -65,8 +65,8 @@ KisPaintDeviceSP KisPaintOp::computeDab(KisAlphaMaskSP tqmask, KisColorSpace *cs
 
     TQ_INT32 pixelSize = colorSpace->pixelSize();
 
-    TQ_INT32 maskWidth = tqmask->width();
-    TQ_INT32 maskHeight = tqmask->height();
+    TQ_INT32 maskWidth = mask->width();
+    TQ_INT32 maskHeight = mask->height();
 
     // Convert the kiscolor to the right colorspace.
     kc.convertTo(colorSpace);
@@ -77,8 +77,8 @@ KisPaintDeviceSP KisPaintOp::computeDab(KisAlphaMaskSP tqmask, KisColorSpace *cs
         int x=0;
         while(! hiter.isDone())
         {
-            // XXX: Set tqmask
-            colorSpace->setAlpha(kc.data(), tqmask->alphaAt(x++, y), 1);
+            // XXX: Set mask
+            colorSpace->setAlpha(kc.data(), mask->alphaAt(x++, y), 1);
             memcpy(hiter.rawData(), kc.data(), pixelSize);
             ++hiter;
         }
@@ -110,4 +110,4 @@ void KisPaintOp::setSource(KisPaintDeviceSP p) {
 }
 
 
-KisPaintOpSettings* KisPaintOpFactory::settings(TQWidget* /*tqparent*/, const KisInputDevice& /*inputDevice*/) { return 0; }
+KisPaintOpSettings* KisPaintOpFactory::settings(TQWidget* /*parent*/, const KisInputDevice& /*inputDevice*/) { return 0; }
diff --git a/chalk/core/kis_paintop.h b/chalk/core/kis_paintop.h
index 8e8587ea..668856f7 100644
--- a/chalk/core/kis_paintop.h
+++ b/chalk/core/kis_paintop.h
@@ -79,8 +79,8 @@ public:
 
 protected:
 
-    virtual KisPaintDeviceSP computeDab(KisAlphaMaskSP tqmask);
-    virtual KisPaintDeviceSP computeDab(KisAlphaMaskSP tqmask, KisColorSpace *cs);
+    virtual KisPaintDeviceSP computeDab(KisAlphaMaskSP mask);
+    virtual KisPaintDeviceSP computeDab(KisAlphaMaskSP mask, KisColorSpace *cs);
 
 
     /**
@@ -97,7 +97,7 @@ private:
 class KisPaintOpSettings {
 
 public:
-    KisPaintOpSettings(TQWidget *tqparent) { Q_UNUSED(tqparent); }
+    KisPaintOpSettings(TQWidget *parent) { Q_UNUSED(parent); }
     virtual ~KisPaintOpSettings() {}
 
     virtual TQWidget *widget() const { return 0; }
@@ -135,7 +135,7 @@ public:
      * specified input device. Return 0 if there are no settings available for the given
      * device.
      */
-    virtual KisPaintOpSettings* settings(TQWidget* tqparent, const KisInputDevice& inputDevice);
+    virtual KisPaintOpSettings* settings(TQWidget* parent, const KisInputDevice& inputDevice);
 
 };
 #endif // KIS_PAINTOP_H_
diff --git a/chalk/core/kis_paintop_registry.cc b/chalk/core/kis_paintop_registry.cc
index 3651f35d..012f2027 100644
--- a/chalk/core/kis_paintop_registry.cc
+++ b/chalk/core/kis_paintop_registry.cc
@@ -103,11 +103,11 @@ KisPaintOp * KisPaintOpRegistry::paintOp(const TQString & id, const KisPaintOpSe
     return paintOp(KisID(id, ""), settings, painter);
 }
 
-KisPaintOpSettings * KisPaintOpRegistry::settings(const KisID& id, TQWidget * tqparent, const KisInputDevice& inputDevice) const
+KisPaintOpSettings * KisPaintOpRegistry::settings(const KisID& id, TQWidget * parent, const KisInputDevice& inputDevice) const
 {
     KisPaintOpFactory* f = get(id);
     if (f)
-        return f->settings( tqparent, inputDevice );
+        return f->settings( parent, inputDevice );
 
     return 0;
 }
diff --git a/chalk/core/kis_paintop_registry.h b/chalk/core/kis_paintop_registry.h
index c61105b6..338b9f01 100644
--- a/chalk/core/kis_paintop_registry.h
+++ b/chalk/core/kis_paintop_registry.h
@@ -56,10 +56,10 @@ public:
     /**
      * Create and return an (abstracted) configuration widget
      * for using the specified paintop with the specified input device,
-     * with the specified tqparent as widget tqparent. Returns 0 if there
+     * with the specified parent as widget parent. Returns 0 if there
      * are no settings available for the given device.
      */
-    KisPaintOpSettings * settings(const KisID& id, TQWidget * tqparent, const KisInputDevice& inputDevice) const;
+    KisPaintOpSettings * settings(const KisID& id, TQWidget * parent, const KisInputDevice& inputDevice) const;
     
     // Whether we should show this paintop in the toolchest
     bool userVisible(const KisID & id, KisColorSpace* cs) const;
diff --git a/chalk/core/kis_random_accessor.h b/chalk/core/kis_random_accessor.h
index 6e2e10ad..62d90e04 100644
--- a/chalk/core/kis_random_accessor.h
+++ b/chalk/core/kis_random_accessor.h
@@ -68,7 +68,7 @@ class KisRandomAccessorPixelTrait {
         };
 
         /**
-         * Returns the selectiontqmask from the current point; this is guaranteed
+         * Returns the selectionmask from the current point; this is guaranteed
          * to have the same number of consecutive pixels that the iterator has
          * at a given point. It return a 0 if there is no selection.
          */
diff --git a/chalk/core/kis_selection.cc b/chalk/core/kis_selection.cc
index b5cd8e6e..03d76616 100644
--- a/chalk/core/kis_selection.cc
+++ b/chalk/core/kis_selection.cc
@@ -81,7 +81,7 @@ void KisSelection::setSelected(TQ_INT32 x, TQ_INT32 y, TQ_UINT8 s)
 
 TQImage KisSelection::maskImage()
 {
-    // If part of a KisAdjustmentLayer, there may be no tqparent device.
+    // If part of a KisAdjustmentLayer, there may be no parent device.
     TQImage img;
     TQRect bounds;
     if (m_parentPaintDevice) {
diff --git a/chalk/core/kis_selection.h b/chalk/core/kis_selection.h
index d5323337..ae21e696 100644
--- a/chalk/core/kis_selection.h
+++ b/chalk/core/kis_selection.h
@@ -47,13 +47,13 @@ class KRITACORE_EXPORT KisSelection : public KisPaintDevice {
 public:
     /**
      * Create a new KisSelection
-    * @param dev the tqparent paint device. The selection will never be bigger than the tqparent
+    * @param dev the parent paint device. The selection will never be bigger than the parent
      *              paint device.
      */
     KisSelection(KisPaintDeviceSP dev);
 
     /**
-     * Create a new KisSelection. This selection will not have a tqparent paint device.
+     * Create a new KisSelection. This selection will not have a parent paint device.
      */
     KisSelection();
     
@@ -108,7 +108,7 @@ public:
     void startCachingExactRect();
     void stopCachingExactRect();
 
-    // if the tqparent layer is interested in keeping up to date with the dirtyness
+    // if the parent layer is interested in keeping up to date with the dirtyness
     // of this layer, set to true
     void setInterestedInDirtyness(bool b) { m_dirty = b; }
     bool interestedInDirtyness() const { return m_dirty; }