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

113 files changed, 436 insertions, 436 deletions

diff --git a/chalk/plugins/filters/blur/blur.cc b/chalk/plugins/filters/blur/blur.cc
index bcf798b9..69bac7b1 100644
--- a/chalk/plugins/filters/blur/blur.cc
+++ b/chalk/plugins/filters/blur/blur.cc
@@ -27,8 +27,8 @@
 typedef KGenericFactory<BlurFilterPlugin> BlurFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkblurfilter, BlurFilterPluginFactory( "chalk" ) )
 
-BlurFilterPlugin::BlurFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+BlurFilterPlugin::BlurFilterPlugin(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(BlurFilterPluginFactory::instance());
 
@@ -36,11 +36,11 @@ BlurFilterPlugin::BlurFilterPlugin(TQObject *tqparent, const char *name, const T
     kdDebug(41006) << "Extensions Convolution Filters plugin. Class: "
           << className()
           << ", Parent: "
-          << tqparent -> className()
+          << parent -> className()
           << "\n";
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisBlurFilter());
     }
 }
diff --git a/chalk/plugins/filters/blur/blur.h b/chalk/plugins/filters/blur/blur.h
index 8ce31706..239d05d0 100644
--- a/chalk/plugins/filters/blur/blur.h
+++ b/chalk/plugins/filters/blur/blur.h
@@ -30,7 +30,7 @@
 class BlurFilterPlugin : public KParts::Plugin
 {
 public:
-    BlurFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    BlurFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~BlurFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/blur/kis_blur_filter.cc b/chalk/plugins/filters/blur/kis_blur_filter.cc
index 8709c073..0217b7e1 100644
--- a/chalk/plugins/filters/blur/kis_blur_filter.cc
+++ b/chalk/plugins/filters/blur/kis_blur_filter.cc
@@ -56,9 +56,9 @@ KisBlurFilter::KisBlurFilter() : KisFilter(id(), "blur", i18n("&Blur..."))
 {
 }
 
-KisFilterConfigWidget * KisBlurFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP )
+KisFilterConfigWidget * KisBlurFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP )
 {
-    return new KisWdgBlur(this, tqparent, "configuration of color to alpha");
+    return new KisWdgBlur(this, parent, "configuration of color to alpha");
 }
 
 KisFilterConfiguration* KisBlurFilter::configuration(TQWidget* w)
@@ -110,19 +110,19 @@ void KisBlurFilter::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilte
             kas = new KisAutobrushCircleShape(width, height, hFade, vFade);
             break;
     }
-    TQImage tqmask;
-    kas->createBrush(&tqmask);
+    TQImage mask;
+    kas->createBrush(&mask);
 
-    tqmask.convertDepth(1);
+    mask.convertDepth(1);
 
     if( rotate != 0)
     {
         TQWMatrix m;
         m.rotate( rotate );
-        tqmask = tqmask.xForm( m );
-        if( (tqmask.height() & 1) || tqmask.width() & 1)
+        mask = mask.xForm( m );
+        if( (mask.height() & 1) || mask.width() & 1)
         {
-            tqmask.smoothScale( tqmask.width() + !(tqmask.width() & 1), tqmask.height() + !(tqmask.height() & 1) );
+            mask.smoothScale( mask.width() + !(mask.width() & 1), mask.height() + !(mask.height() & 1) );
         }
     }
 
@@ -130,7 +130,7 @@ void KisBlurFilter::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilte
     if (m_progressDisplay)
         m_progressDisplay->setSubject( &painter, true, true );
 
-    KisKernelSP kernel = kernelFromTQImage(tqmask); // TODO: for 1.6 reuse the chalk's core function for creating kernel : KisKernel::fromTQImage
+    KisKernelSP kernel = kernelFromTQImage(mask); // TODO: for 1.6 reuse the chalk's core function for creating kernel : KisKernel::fromTQImage
 
     painter.applyMatrix(kernel, rect.x(), rect.y(), rect.width(), rect.height(), BORDER_REPEAT, KisChannelInfo::FLAG_COLOR_AND_ALPHA);
 
diff --git a/chalk/plugins/filters/blur/kis_blur_filter.h b/chalk/plugins/filters/blur/kis_blur_filter.h
index 88655186..b1d2a65a 100644
--- a/chalk/plugins/filters/blur/kis_blur_filter.h
+++ b/chalk/plugins/filters/blur/kis_blur_filter.h
@@ -42,7 +42,7 @@ class KisBlurFilter : public KisFilter
         virtual bool supportsThreading() { return false; }
         virtual ColorSpaceIndependence colorSpaceIndependence() { return FULLY_INDEPENDENT; };
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };
 
diff --git a/chalk/plugins/filters/blur/kis_wdg_blur.cc b/chalk/plugins/filters/blur/kis_wdg_blur.cc
index bfed7474..dc836971 100644
--- a/chalk/plugins/filters/blur/kis_wdg_blur.cc
+++ b/chalk/plugins/filters/blur/kis_wdg_blur.cc
@@ -32,7 +32,7 @@
 
 #include "wdgblur.h"
 
-KisWdgBlur::KisWdgBlur( KisFilter* nfilter, TQWidget * tqparent, const char * name) : KisFilterConfigWidget ( tqparent, name )
+KisWdgBlur::KisWdgBlur( KisFilter* nfilter, TQWidget * parent, const char * name) : KisFilterConfigWidget ( parent, name )
 {
     Q_UNUSED( nfilter );
 
diff --git a/chalk/plugins/filters/blur/kis_wdg_blur.h b/chalk/plugins/filters/blur/kis_wdg_blur.h
index c0cc4834..f305df25 100644
--- a/chalk/plugins/filters/blur/kis_wdg_blur.h
+++ b/chalk/plugins/filters/blur/kis_wdg_blur.h
@@ -35,7 +35,7 @@ class KisWdgBlur : public KisFilterConfigWidget
     Q_OBJECT
   TQ_OBJECT
     public:
-        KisWdgBlur( KisFilter* nfilter, TQWidget * tqparent, const char * name);
+        KisWdgBlur( KisFilter* nfilter, TQWidget * parent, const char * name);
         inline WdgBlur* widget() { return m_widget; };
         virtual void setConfiguration(KisFilterConfiguration*);
     private slots:
diff --git a/chalk/plugins/filters/bumpmap/bumpmap.cc b/chalk/plugins/filters/bumpmap/bumpmap.cc
index 455889d5..4ae92469 100644
--- a/chalk/plugins/filters/bumpmap/bumpmap.cc
+++ b/chalk/plugins/filters/bumpmap/bumpmap.cc
@@ -72,14 +72,14 @@
 typedef KGenericFactory<ChalkBumpmap> ChalkBumpmapFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkbumpmap, ChalkBumpmapFactory( "chalk" ) )
 
-ChalkBumpmap::ChalkBumpmap(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkBumpmap::ChalkBumpmap(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkBumpmapFactory::instance());
 
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisFilterBumpmap());
     }
 }
@@ -347,9 +347,9 @@ void KisFilterBumpmap::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFi
 
 }
 
-KisFilterConfigWidget * KisFilterBumpmap::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev)
+KisFilterConfigWidget * KisFilterBumpmap::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev)
 {
-    KisBumpmapConfigWidget * w = new KisBumpmapConfigWidget(this, dev, tqparent);
+    KisBumpmapConfigWidget * w = new KisBumpmapConfigWidget(this, dev, parent);
 
 
     return w;
@@ -456,8 +456,8 @@ TQString KisBumpmapConfiguration::toString()
     return KisFilterConfiguration::toString();
 }
 
-KisBumpmapConfigWidget::KisBumpmapConfigWidget(KisFilter *, KisPaintDeviceSP dev, TQWidget * tqparent, const char * name, WFlags f)
-    : KisFilterConfigWidget(tqparent, name, f)
+KisBumpmapConfigWidget::KisBumpmapConfigWidget(KisFilter *, KisPaintDeviceSP dev, TQWidget * parent, const char * name, WFlags f)
+    : KisFilterConfigWidget(parent, name, f)
 {
     m_page = new WdgBumpmap(this);
     TQHBoxLayout * l = new TQHBoxLayout(this);
diff --git a/chalk/plugins/filters/bumpmap/bumpmap.h b/chalk/plugins/filters/bumpmap/bumpmap.h
index b1c16b1a..efaf4058 100644
--- a/chalk/plugins/filters/bumpmap/bumpmap.h
+++ b/chalk/plugins/filters/bumpmap/bumpmap.h
@@ -49,7 +49,7 @@ using namespace chalk;
 class ChalkBumpmap : public KParts::Plugin
 {
 public:
-    ChalkBumpmap(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkBumpmap(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkBumpmap();
 };
 
@@ -76,7 +76,7 @@ public:
     virtual bool supportsAdjustmentLayers() { return false; }
     virtual bool supportsThreading() { return false; }
 
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration * configuration(TQWidget*);
     virtual KisFilterConfiguration * configuration();
 
@@ -116,7 +116,7 @@ class KisBumpmapConfigWidget : public KisFilterConfigWidget {
   TQ_OBJECT
 
 public:
-    KisBumpmapConfigWidget(KisFilter * filter, KisPaintDeviceSP dev, TQWidget * tqparent, const char * name = 0, WFlags f = 0 );
+    KisBumpmapConfigWidget(KisFilter * filter, KisPaintDeviceSP dev, TQWidget * parent, const char * name = 0, WFlags f = 0 );
     virtual ~KisBumpmapConfigWidget() {};
 
     KisBumpmapConfiguration * config();
diff --git a/chalk/plugins/filters/cimg/CImg.h b/chalk/plugins/filters/cimg/CImg.h
index 8d6a24f6..abd1bb66 100644
--- a/chalk/plugins/filters/cimg/CImg.h
+++ b/chalk/plugins/filters/cimg/CImg.h
@@ -659,7 +659,7 @@ namespace cimg_library {
       - \b CImgDisplayException : Thrown when an error occured when trying to display an image in a window.
       This exception is thrown when image display request cannot be satisfied.
       
-      The tqparent class CImgException may be thrown itself when errors that cannot be classified in one of
+      The parent class CImgException may be thrown itself when errors that cannot be classified in one of
       the above type occur. It is recommended not to throw CImgExceptions yourself, since there are normally
       reserved to %CImg Library functions.
       \b CImgInstanceException, \b CImgArgumentException, \b CImgIOException and \b CImgDisplayException are simple
@@ -4425,11 +4425,11 @@ namespace cimg_library {
         pthread_mutex_lock(cimg::X11attr().mutex);
         for (unsigned int i=0; i<cimg::X11attr().nb_wins; i++) {
           const unsigned int xevent_type = (cimg::X11attr().wins[i]->events)&3;
-          const unsigned int etqmask =
+          const unsigned int emask =
             ((xevent_type>=1)?ExposureMask|StructureNotifyMask:0)|
             ((xevent_type>=2)?ButtonPressMask|KeyPressMask|PointerMotionMask|LeaveWindowMask:0)|
             ((xevent_type>=3)?ButtonReleaseMask|KeyReleaseMask:0);
-          XSelectInput(cimg::X11attr().display,cimg::X11attr().wins[i]->window,etqmask);
+          XSelectInput(cimg::X11attr().display,cimg::X11attr().wins[i]->window,emask);
         }
         bool event_flag = XCheckTypedEvent(cimg::X11attr().display, ClientMessage, &event);
         if (!event_flag) event_flag = XCheckMaskEvent(cimg::X11attr().display,
@@ -4599,10 +4599,10 @@ namespace cimg_library {
         do {
           pthread_mutex_lock(cimg::X11attr().mutex);
           const unsigned int 
-            etqmask = ExposureMask|StructureNotifyMask|
+            emask = ExposureMask|StructureNotifyMask|
             ((events>=2)?ButtonPressMask|KeyPressMask|PointerMotionMask|LeaveWindowMask:0)|
             ((events>=3)?ButtonReleaseMask|KeyReleaseMask:0);
-          XSelectInput(cimg::X11attr().display,window,etqmask);
+          XSelectInput(cimg::X11attr().display,window,emask);
           XPeekEvent(cimg::X11attr().display,&event);
           cimg::X11attr().thread_finished = false;
           pthread_mutex_unlock(cimg::X11attr().mutex);
@@ -7867,13 +7867,13 @@ namespace cimg_library {
     CImg get_resize_halfXY() const {
       typedef typename cimg::largest<T,float>::type ftype;
       if (is_empty()) return CImg<T>();
-      CImg<ftype> tqmask = CImg<ftype>::matrix(0.07842776544f, 0.1231940459f, 0.07842776544f,
+      CImg<ftype> mask = CImg<ftype>::matrix(0.07842776544f, 0.1231940459f, 0.07842776544f,
 					     0.1231940459f,  0.1935127547f, 0.1231940459f,
 					     0.07842776544f, 0.1231940459f, 0.07842776544f);
       CImg_3x3x1(I,ftype);
       CImg dest(width/2,height/2,depth,dim);
       cimg_mapZV(*this,z,k) cimg_map3x3x1(*this,x,y,z,k,I) 
-	if (x%2 && y%2) dest(x/2,y/2,z,k) = (T)cimg_conv3x3x1(I,tqmask);
+	if (x%2 && y%2) dest(x/2,y/2,z,k) = (T)cimg_conv3x3x1(I,mask);
       return dest;
     }
 
@@ -8816,7 +8816,7 @@ namespace cimg_library {
 	CImg_2x2x1(I,restype);
 	cimg_mapZV(*this,z,k) cimg_map2x2x1(*this,x,y,z,k,I) { res[0](x,y,0,k) = Inc-Icc; res[1](x,y,z,k) = Icn-Icc; }
       } break;
-      case 2: { // using Sobel tqmask
+      case 2: { // using Sobel mask
 	CImg_3x3x1(I,restype);
 	const float a = 1, b = 2;
 	cimg_mapZV(*this,z,k) cimg_map3x3x1(*this,x,y,z,k,I) {
@@ -8824,7 +8824,7 @@ namespace cimg_library {
 	  res[1](x,y,z,k) = -a*Ipp-b*Icp-a*Inp+a*Ipn+b*Icn+a*Inn;
 	}
       } break;
-      case 3: { // using rotation invariant tqmask
+      case 3: { // using rotation invariant mask
 	CImg_3x3x1(I,restype);     
 	const float a = (float)(0.25*(2-std::sqrt(2.0))), b = (float)(0.5f*(std::sqrt(2.0)-1));
 	cimg_mapZV(*this,z,k) cimg_map3x3x1(*this,x,y,z,k,I) {
@@ -9825,42 +9825,42 @@ namespace cimg_library {
     //! Draw a masked sprite image in the instance image, at coordinates (\c x0,\c y0,\c z0,\c v0).
     /**
        \param sprite = sprite image.
-       \param tqmask = tqmask image.
+       \param mask = mask image.
        \param x0 = X-coordinate of the sprite position in the instance image.
        \param y0 = Y-coordinate of the sprite position in the instance image.
        \param z0 = Z-coordinate of the sprite position in the instance image.
        \param v0 = V-coordinate of the sprite position in the instance image.
-       \param mask_valmax = Maximum pixel value of the tqmask image \c tqmask.
+       \param mask_valmax = Maximum pixel value of the mask image \c mask.
        \param opacity = opacity of the drawing.
-       \note Pixel values of \c tqmask set the opacity of the corresponding pixels in \c sprite.
+       \note Pixel values of \c mask set the opacity of the corresponding pixels in \c sprite.
        \note Clipping is supported.
-       \note Dimensions along x,y and z of \c sprite and \c tqmask must be the same.
+       \note Dimensions along x,y and z of \c sprite and \c mask must be the same.
     **/
-    template<typename ti,typename tm> CImg& draw_image(const CImg<ti>& sprite,const CImg<tm>& tqmask,
+    template<typename ti,typename tm> CImg& draw_image(const CImg<ti>& sprite,const CImg<tm>& mask,
                                                        const int x0=0,const int y0=0,const int z0=0,const int v0=0,
                                                        const tm mask_valmax=1,const float opacity=1) {
       if (!is_empty()) {
 	if (sprite.is_empty())
 	  throw CImgArgumentException("CImg<%s>::draw_image() : Specified sprite image (%u,%u,%u,%u,%p) is empty.",
 				      pixel_type(),sprite.width,sprite.height,sprite.depth,sprite.dim,sprite.data);
-	if (tqmask.is_empty())
-	  throw CImgArgumentException("CImg<%s>::draw_image() : Specified tqmask image (%u,%u,%u,%u,%p) is empty.",
-				      pixel_type(),tqmask.width,tqmask.height,tqmask.depth,tqmask.dim,tqmask.data);
-	if ((void*)this==(void*)&sprite) return draw_image(CImg<T>(sprite),tqmask,x0,y0,z0,v0);
-	if(tqmask.width!=sprite.width || tqmask.height!=sprite.height || tqmask.depth!=sprite.depth)
+	if (mask.is_empty())
+	  throw CImgArgumentException("CImg<%s>::draw_image() : Specified mask image (%u,%u,%u,%u,%p) is empty.",
+				      pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);
+	if ((void*)this==(void*)&sprite) return draw_image(CImg<T>(sprite),mask,x0,y0,z0,v0);
+	if(mask.width!=sprite.width || mask.height!=sprite.height || mask.depth!=sprite.depth)
 	  throw CImgArgumentException("CImg<%s>::draw_image() : Mask dimension is (%u,%u,%u,%u), while sprite is (%u,%u,%u,%u)",
-				      pixel_type(),tqmask.width,tqmask.height,tqmask.depth,tqmask.dim,sprite.width,sprite.height,sprite.depth,sprite.dim);
+				      pixel_type(),mask.width,mask.height,mask.depth,mask.dim,sprite.width,sprite.height,sprite.depth,sprite.dim);
 	const bool bx=(x0<0), by=(y0<0), bz=(z0<0), bv=(v0<0);
 	const int
 	  lX = sprite.dimx() - (x0+sprite.dimx()>dimx()?x0+sprite.dimx()-dimx():0) + (bx?x0:0),
 	  lY = sprite.dimy() - (y0+sprite.dimy()>dimy()?y0+sprite.dimy()-dimy():0) + (by?y0:0),
 	  lZ = sprite.dimz() - (z0+sprite.dimz()>dimz()?z0+sprite.dimz()-dimz():0) + (bz?z0:0),      
 	  lV = sprite.dimv() - (v0+sprite.dimv()>dimv()?v0+sprite.dimv()-dimv():0) + (bv?v0:0);    
-	const int coff = -(bx?x0:0)-(by?y0*tqmask.dimx():0)-(bz?z0*tqmask.dimx()*tqmask.dimy():0)-
-	  (bv?v0*tqmask.dimx()*tqmask.dimy()*tqmask.dimz():0),
-	  ssize = tqmask.dimx()*tqmask.dimy()*tqmask.dimz();
+	const int coff = -(bx?x0:0)-(by?y0*mask.dimx():0)-(bz?z0*mask.dimx()*mask.dimy():0)-
+	  (bv?v0*mask.dimx()*mask.dimy()*mask.dimz():0),
+	  ssize = mask.dimx()*mask.dimy()*mask.dimz();
 	const ti *ptrs = sprite.ptr() + coff;
-	const tm *ptrm = tqmask.ptr() + coff;
+	const tm *ptrm = mask.ptr() + coff;
 	const unsigned int
 	  offX = width-lX, soffX = sprite.width-lX,
 	  offY = width*(height-lY), soffY = sprite.width*(sprite.height-lY),
@@ -9868,7 +9868,7 @@ namespace cimg_library {
 	T *ptrd = ptr(x0<0?0:x0,y0<0?0:y0,z0<0?0:z0,v0<0?0:v0);
 	if (lX>0 && lY>0 && lZ>0 && lV>0)
 	  for (int v=0; v<lV; v++) {
-	    ptrm = tqmask.data + (ptrm - tqmask.data)%ssize;
+	    ptrm = mask.data + (ptrm - mask.data)%ssize;
 	    for (int z=0; z<lZ; z++) {
 	      for (int y=0; y<lY; y++) {
 		for (int x=0; x<lX; x++) {
@@ -10785,12 +10785,12 @@ namespace cimg_library {
         case '\t': x+=4*font[' '].width; break;
         default: if (c<font.size) {
             letter = font[c];
-            const CImg& tqmask = (c+256)<(int)font.size?font[c+256]:font[c];
+            const CImg& mask = (c+256)<(int)font.size?font[c+256]:font[c];
             if (fgcolor) for (unsigned int p=0; p<letter.width*letter.height; p++) 
-	      if (tqmask(p)) cimg_mapV(*this,k) letter(p,0,0,k)=(T)(letter(p,0,0,k)*fgcolor[k]);
+	      if (mask(p)) cimg_mapV(*this,k) letter(p,0,0,k)=(T)(letter(p,0,0,k)*fgcolor[k]);
             if (bgcolor) for (unsigned int p=0; p<letter.width*letter.height; p++)
-	      if (!tqmask(p)) cimg_mapV(*this,k) letter(p,0,0,k)=bgcolor[k];
-            if (!bgcolor && font.size>=512) draw_image(letter,tqmask,x,y,0,0,(T)1,opacity); else draw_image(letter,x,y,0,0,opacity);
+	      if (!mask(p)) cimg_mapV(*this,k) letter(p,0,0,k)=bgcolor[k];
+            if (!bgcolor && font.size>=512) draw_image(letter,mask,x,y,0,0,(T)1,opacity); else draw_image(letter,x,y,0,0,opacity);
             x+=letter.width;
           }
           break;
@@ -11163,11 +11163,11 @@ namespace cimg_library {
        \param y = Y-coordinate of the starting point of the region to fill.
        \param z = Z-coordinate of the starting point of the region to fill.
        \param color = an array of dimv() values of type \c T, defining the drawing color.
-       \param region = image that will contain the tqmask of the filled region tqmask, as an output.
+       \param region = image that will contain the mask of the filled region mask, as an output.
        \param sigma = tolerance concerning neighborhood values.
        \param opacity = opacity of the drawing.
 
-       \return \p region is initialized with the binary tqmask of the filled region.
+       \return \p region is initialized with the binary mask of the filled region.
     **/
     template<typename t> CImg& draw_fill(const int x,const int y,const int z,
                                          const T *const color, CImg<t>& region,const float sigma=0,
@@ -11963,107 +11963,107 @@ namespace cimg_library {
     //@{
     //----------------------------
   
-    //! Return the correlation of the image by a tqmask.
+    //! Return the correlation of the image by a mask.
     /**
-       The result \p res of the correlation of an image \p img by a tqmask \p tqmask is defined to be :
+       The result \p res of the correlation of an image \p img by a mask \p mask is defined to be :
        
-       res(x,y,z) = sum_{i,j,k} img(x+i,y+j,z+k)*tqmask(i,j,k)
+       res(x,y,z) = sum_{i,j,k} img(x+i,y+j,z+k)*mask(i,j,k)
 
-       \param tqmask = the correlation kernel.
+       \param mask = the correlation kernel.
        \param cond = the border condition type (0=zero, 1=dirichlet)
        \param weighted_correl = enable local normalization.
     **/
     template<typename t> CImg<typename cimg::largest<T,t>::type> 
-    get_correlate(const CImg<t>& tqmask,const unsigned int cond=1,const bool weighted_correl=false) const {
+    get_correlate(const CImg<t>& mask,const unsigned int cond=1,const bool weighted_correl=false) const {
       typedef typename cimg::largest<T,t>::type restype;
       typedef typename cimg::largest<t,float>::type fftype;
       typedef typename cimg::largest<T,fftype>::type ftype;
       
       if (is_empty()) return CImg<restype>();
-      if (tqmask.is_empty() || tqmask.dim!=1)
-	throw CImgArgumentException("CImg<%s>::get_correlate() : Specified tqmask (%u,%u,%u,%u,%p) is not scalar.",
-				    pixel_type(),tqmask.width,tqmask.height,tqmask.depth,tqmask.dim,tqmask.data);
+      if (mask.is_empty() || mask.dim!=1)
+	throw CImgArgumentException("CImg<%s>::get_correlate() : Specified mask (%u,%u,%u,%u,%p) is not scalar.",
+				    pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);
       CImg<restype> dest(*this,false);
-      if (cond && tqmask.width==tqmask.height && ((tqmask.depth==1 && tqmask.width<=5) || (tqmask.depth==tqmask.width && tqmask.width<=3))) {
-        // A special optimization is done for 2x2,3x3,4x4,5x5,2x2x2 and 3x3x3 tqmask (with cond=1)
-        switch (tqmask.depth) {
+      if (cond && mask.width==mask.height && ((mask.depth==1 && mask.width<=5) || (mask.depth==mask.width && mask.width<=3))) {
+        // A special optimization is done for 2x2,3x3,4x4,5x5,2x2x2 and 3x3x3 mask (with cond=1)
+        switch (mask.depth) {
         case 3: {
           CImg_3x3x3(I,T);
-          if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map3x3x3(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr3x3x3(I,tqmask);
+          if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map3x3x3(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr3x3x3(I,mask);
           else cimg_mapZV(*this,z,v) cimg_map3x3x3(*this,x,y,z,v,I) {
             const double norm = (double)cimg_squaresum3x3x3(I);
-            dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr3x3x3(I,tqmask)/std::sqrt(norm)):0;
+            dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr3x3x3(I,mask)/std::sqrt(norm)):0;
           }
         } break;
         case 2: {
           CImg_2x2x2(I,T);
-          if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map2x2x2(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr2x2x2(I,tqmask);
+          if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map2x2x2(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr2x2x2(I,mask);
           else cimg_mapZV(*this,z,v) cimg_map2x2x2(*this,x,y,z,v,I) {
             const double norm = (double)cimg_squaresum2x2x2(I);
-            dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr2x2x2(I,tqmask)/std::sqrt(norm)):0;
+            dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr2x2x2(I,mask)/std::sqrt(norm)):0;
           }
         } break;
         default:
         case 1:
-          switch (tqmask.width) {
+          switch (mask.width) {
           case 5: {
             CImg_5x5x1(I,T);
-            if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map5x5x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr5x5x1(I,tqmask);
+            if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map5x5x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr5x5x1(I,mask);
             else cimg_mapZV(*this,z,v) cimg_map5x5x1(*this,x,y,z,v,I) {
               const double norm = (double)cimg_squaresum5x5x1(I);
-              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr5x5x1(I,tqmask)/std::sqrt(norm)):0;
+              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr5x5x1(I,mask)/std::sqrt(norm)):0;
             }            
           } break;          
           case 4: {
             CImg_4x4x1(I,T);
-            if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map4x4x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr4x4x1(I,tqmask);
+            if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map4x4x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr4x4x1(I,mask);
             else cimg_mapZV(*this,z,v) cimg_map4x4x1(*this,x,y,z,v,I) {
               const double norm = (double)cimg_squaresum4x4x1(I);
-              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr4x4x1(I,tqmask)/std::sqrt(norm)):0;
+              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr4x4x1(I,mask)/std::sqrt(norm)):0;
             }            
           } break;              
           case 3: {
             CImg_3x3x1(I,T);
-            if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map3x3x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr3x3x1(I,tqmask);
+            if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map3x3x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr3x3x1(I,mask);
             else cimg_mapZV(*this,z,v) cimg_map3x3x1(*this,x,y,z,v,I) {
               const double norm = (double)cimg_squaresum3x3x1(I);
-              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr3x3x1(I,tqmask)/std::sqrt(norm)):0;
+              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr3x3x1(I,mask)/std::sqrt(norm)):0;
             }            
           } break;   
           case 2: {
             CImg_2x2x1(I,T);
-            if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map2x2x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr2x2x1(I,tqmask);
+            if (!weighted_correl) cimg_mapZV(*this,z,v) cimg_map2x2x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_corr2x2x1(I,mask);
             else cimg_mapZV(*this,z,v) cimg_map2x2x1(*this,x,y,z,v,I) {
               const double norm = (double)cimg_squaresum2x2x1(I);
-              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr2x2x1(I,tqmask)/std::sqrt(norm)):0;
+              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_corr2x2x1(I,mask)/std::sqrt(norm)):0;
             }            
           } break;  
-          case 1: dest = tqmask(0)*(*this); break;
+          case 1: dest = mask(0)*(*this); break;
           }
         }
       } else { 
         // Generic version for other masks      
-        const int cxm=tqmask.width/2, cym=tqmask.height/2, czm=tqmask.depth/2, fxm=cxm-1+(tqmask.width%2), fym=cym-1+(tqmask.height%2), fzm=czm-1+(tqmask.depth%2);
+        const int cxm=mask.width/2, cym=mask.height/2, czm=mask.depth/2, fxm=cxm-1+(mask.width%2), fym=cym-1+(mask.height%2), fzm=czm-1+(mask.depth%2);
         cimg_mapV(*this,v) 
           if (!weighted_correl) {	// Classical correlation
             for (int z=czm; z<dimz()-czm; z++) for (int y=cym; y<dimy()-cym; y++) for (int x=cxm; x<dimx()-cxm; x++) {
               ftype val = 0;
               for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-                val+= (*this)(x+xm,y+ym,z+zm,v)*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                val+= (*this)(x+xm,y+ym,z+zm,v)*mask(cxm+xm,cym+ym,czm+zm,0);
               dest(x,y,z,v)=(restype)val;
             }
             if (cond) cimg_mapYZV(*this,y,z,v)
               for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
                 ftype val = 0;
                 for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-                  val+= pix3d(x+xm,y+ym,z+zm,v)*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                  val+= pix3d(x+xm,y+ym,z+zm,v)*mask(cxm+xm,cym+ym,czm+zm,0);
                 dest(x,y,z,v)=(restype)val;
               }
             else cimg_mapYZV(*this,y,z,v)
               for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
                 ftype val = 0;
                 for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++)  for (int xm=-cxm; xm<=fxm; xm++)
-                  val+= pix3d(x+xm,y+ym,z+zm,v,0)*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                  val+= pix3d(x+xm,y+ym,z+zm,v,0)*mask(cxm+xm,cym+ym,czm+zm,0);
                 dest(x,y,z,v)=(restype)val;
               }
           } else {	// Weighted correlation
@@ -12071,7 +12071,7 @@ namespace cimg_library {
               ftype val = 0, norm = 0;
               for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++) {
                 const T cval = (*this)(x+xm,y+ym,z+zm,v);
-                val+= cval*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                val+= cval*mask(cxm+xm,cym+ym,czm+zm,0);
                 norm+= cval*cval;
               }
               dest(x,y,z,v)=(norm!=0)?(restype)(val/std::sqrt((double)norm)):0;
@@ -12081,7 +12081,7 @@ namespace cimg_library {
                 ftype val = 0, norm = 0;
                 for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++) {
                   const T cval = pix3d(x+xm,y+ym,z+zm,v);
-                  val+= cval*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                  val+= cval*mask(cxm+xm,cym+ym,czm+zm,0);
                   norm+=cval*cval;
                 }
                 dest(x,y,z,v)=(norm!=0)?(restype)(val/std::sqrt((double)norm)):0;
@@ -12091,7 +12091,7 @@ namespace cimg_library {
                 ftype val = 0, norm = 0;
                 for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++) {
                   const T cval = pix3d(x+xm,y+ym,z+zm,v,0);
-                  val+= cval*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                  val+= cval*mask(cxm+xm,cym+ym,czm+zm,0);
                   norm+= cval*cval;
                 }
                 dest(x,y,z,v)=(norm!=0)?(restype)(val/std::sqrt((double)norm)):0;
@@ -12102,115 +12102,115 @@ namespace cimg_library {
     }
 
 
-    //! Correlate the image by a tqmask
+    //! Correlate the image by a mask
     /**
        This is the in-place version of get_correlate.
        \see get_correlate
     **/
-    template<typename t> CImg& correlate(const CImg<t>& tqmask,const unsigned int cond=1,const bool weighted_correl=false) { 
-      return get_correlate(tqmask,cond,weighted_correl).swap(*this); 
+    template<typename t> CImg& correlate(const CImg<t>& mask,const unsigned int cond=1,const bool weighted_correl=false) { 
+      return get_correlate(mask,cond,weighted_correl).swap(*this); 
     }
   
-    //! Return the convolution of the image by a tqmask
+    //! Return the convolution of the image by a mask
     /**
-       The result \p res of the convolution of an image \p img by a tqmask \p tqmask is defined to be :
+       The result \p res of the convolution of an image \p img by a mask \p mask is defined to be :
        
-       res(x,y,z) = sum_{i,j,k} img(x-i,y-j,z-k)*tqmask(i,j,k)
+       res(x,y,z) = sum_{i,j,k} img(x-i,y-j,z-k)*mask(i,j,k)
 
-       \param tqmask = the correlation kernel.
+       \param mask = the correlation kernel.
        \param cond = the border condition type (0=zero, 1=dirichlet)
        \param weighted_convol = enable local normalization.
     **/
     template<typename t> CImg<typename cimg::largest<T,t>::type>
-    get_convolve(const CImg<t>& tqmask,const unsigned int cond=1,const bool weighted_convol=false) const {
+    get_convolve(const CImg<t>& mask,const unsigned int cond=1,const bool weighted_convol=false) const {
       typedef typename cimg::largest<T,t>::type restype;
       typedef typename cimg::largest<t,float>::type fftype;
       typedef typename cimg::largest<T,fftype>::type ftype;
       
       if (is_empty()) return CImg<restype>();
-      if (tqmask.is_empty() || tqmask.dim!=1)
-	throw CImgArgumentException("CImg<%s>::get_convolve() : Specified tqmask (%u,%u,%u,%u,%p) is not scalar.",
-				    pixel_type(),tqmask.width,tqmask.height,tqmask.depth,tqmask.dim,tqmask.data);
+      if (mask.is_empty() || mask.dim!=1)
+	throw CImgArgumentException("CImg<%s>::get_convolve() : Specified mask (%u,%u,%u,%u,%p) is not scalar.",
+				    pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);
       CImg<restype> dest(*this,false);
-      if (cond && tqmask.width==tqmask.height && ((tqmask.depth==1 && tqmask.width<=5) || (tqmask.depth==tqmask.width && tqmask.width<=3))) { // optimized version
-        switch (tqmask.depth) {
+      if (cond && mask.width==mask.height && ((mask.depth==1 && mask.width<=5) || (mask.depth==mask.width && mask.width<=3))) { // optimized version
+        switch (mask.depth) {
         case 3: {
           CImg_3x3x3(I,T);
-          if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map3x3x3(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_conv3x3x3(I,tqmask);
+          if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map3x3x3(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_conv3x3x3(I,mask);
           else cimg_mapZV(*this,z,v) cimg_map3x3x3(*this,x,y,z,v,I) {
             const double norm = (double)cimg_squaresum3x3x3(I);
-            dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv3x3x3(I,tqmask)/std::sqrt(norm)):0;
+            dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv3x3x3(I,mask)/std::sqrt(norm)):0;
           }
         } break;
         case 2: {
           CImg_2x2x2(I,T);
-          if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map2x2x2(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_conv2x2x2(I,tqmask);
+          if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map2x2x2(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_conv2x2x2(I,mask);
           else cimg_mapZV(*this,z,v) cimg_map2x2x2(*this,x,y,z,v,I) {
             const double norm = (double)cimg_squaresum2x2x2(I);
-            dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv2x2x2(I,tqmask)/std::sqrt(norm)):0;
+            dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv2x2x2(I,mask)/std::sqrt(norm)):0;
           }
         } break;
         default:
         case 1:
-          switch (tqmask.width) {
+          switch (mask.width) {
           case 5: {
             CImg_5x5x1(I,T);
-            if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map5x5x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_conv5x5x1(I,tqmask);
+            if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map5x5x1(*this,x,y,z,v,I) dest(x,y,z,v) = cimg_conv5x5x1(I,mask);
             else cimg_mapZV(*this,z,v) cimg_map5x5x1(*this,x,y,z,v,I) {
               const double norm = (double)cimg_squaresum5x5x1(I);
-              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv5x5x1(I,tqmask)/std::sqrt(norm)):0;
+              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv5x5x1(I,mask)/std::sqrt(norm)):0;
             }            
           } break;          
           case 4: {
             CImg_4x4x1(I,T);
-            if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map4x4x1(*this,x,y,z,v,I) dest(x,y,z,v) = (T)cimg_conv4x4x1(I,tqmask);
+            if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map4x4x1(*this,x,y,z,v,I) dest(x,y,z,v) = (T)cimg_conv4x4x1(I,mask);
             else cimg_mapZV(*this,z,v) cimg_map4x4x1(*this,x,y,z,v,I) {
               const double norm = (double)cimg_squaresum4x4x1(I);
-              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv4x4x1(I,tqmask)/std::sqrt(norm)):0;
+              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv4x4x1(I,mask)/std::sqrt(norm)):0;
             }
           } break;              
           case 3: {
             CImg_3x3x1(I,T);
-            if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map3x3x1(*this,x,y,z,v,I) dest(x,y,z,v) = (T)cimg_conv3x3x1(I,tqmask);
+            if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map3x3x1(*this,x,y,z,v,I) dest(x,y,z,v) = (T)cimg_conv3x3x1(I,mask);
             else cimg_mapZV(*this,z,v) cimg_map3x3x1(*this,x,y,z,v,I) {
               const double norm = (double)cimg_squaresum3x3x1(I);
-              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv3x3x1(I,tqmask)/std::sqrt(norm)):0;
+              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv3x3x1(I,mask)/std::sqrt(norm)):0;
             }            
           } break;   
           case 2: {
             CImg_2x2x1(I,T);
-            if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map2x2x1(*this,x,y,z,v,I) dest(x,y,z,v) = (T)cimg_conv2x2x1(I,tqmask);
+            if (!weighted_convol) cimg_mapZV(*this,z,v) cimg_map2x2x1(*this,x,y,z,v,I) dest(x,y,z,v) = (T)cimg_conv2x2x1(I,mask);
             else cimg_mapZV(*this,z,v) cimg_map2x2x1(*this,x,y,z,v,I) {
               const double norm = (double)cimg_squaresum2x2x1(I);
-              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv2x2x1(I,tqmask)/std::sqrt(norm)):0;
+              dest(x,y,z,v) = (norm!=0)?(restype)(cimg_conv2x2x1(I,mask)/std::sqrt(norm)):0;
             } 
           } break;  
-          case 1: dest = tqmask(0)*(*this); break;
+          case 1: dest = mask(0)*(*this); break;
           }
         }
       } else { // generic version
           
-        const int cxm=tqmask.width/2, cym=tqmask.height/2, czm=tqmask.depth/2, fxm=cxm-1+(tqmask.width%2), fym=cym-1+(tqmask.height%2), fzm=czm-1+(tqmask.depth%2);
+        const int cxm=mask.width/2, cym=mask.height/2, czm=mask.depth/2, fxm=cxm-1+(mask.width%2), fym=cym-1+(mask.height%2), fzm=czm-1+(mask.depth%2);
         cimg_mapV(*this,v) 
           if (!weighted_convol) {	// Classical convolution
             for (int z=czm; z<dimz()-czm; z++) for (int y=cym; y<dimy()-cym; y++) for (int x=cxm; x<dimx()-cxm; x++) {
               ftype val = 0;
               for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-                val+= (*this)(x-xm,y-ym,z-zm,v)*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                val+= (*this)(x-xm,y-ym,z-zm,v)*mask(cxm+xm,cym+ym,czm+zm,0);
               dest(x,y,z,v)=(restype)val;
             }
             if (cond) cimg_mapYZV(*this,y,z,v)
               for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
                 ftype val = 0;
                 for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-                  val+= pix3d(x-xm,y-ym,z-zm,v)*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                  val+= pix3d(x-xm,y-ym,z-zm,v)*mask(cxm+xm,cym+ym,czm+zm,0);
                 dest(x,y,z,v)=(restype)val;
               }
             else cimg_mapYZV(*this,y,z,v)
               for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
                 ftype val = 0;
                 for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++)  for (int xm=-cxm; xm<=fxm; xm++)
-                  val+= pix3d(x-xm,y-ym,z-zm,v,0)*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                  val+= pix3d(x-xm,y-ym,z-zm,v,0)*mask(cxm+xm,cym+ym,czm+zm,0);
                 dest(x,y,z,v)=(restype)val;
               }
           } else {	// Weighted convolution
@@ -12218,7 +12218,7 @@ namespace cimg_library {
               ftype val = 0, norm = 0;
               for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++) {
                 const T cval = (*this)(x-xm,y-ym,z-zm,v);
-                val+= cval*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                val+= cval*mask(cxm+xm,cym+ym,czm+zm,0);
                 norm+= cval*cval;
               }
               dest(x,y,z,v)=(norm!=0)?(restype)(val/std::sqrt(norm)):0;
@@ -12228,7 +12228,7 @@ namespace cimg_library {
                 ftype val = 0, norm = 0;
                 for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++) {
                   const T cval = pix3d(x-xm,y-ym,z-zm,v);
-                  val+= cval*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                  val+= cval*mask(cxm+xm,cym+ym,czm+zm,0);
                   norm+=cval*cval;
                 }
                 dest(x,y,z,v)=(norm!=0)?(restype)(val/std::sqrt(norm)):0;
@@ -12238,7 +12238,7 @@ namespace cimg_library {
                 double val = 0, norm = 0;
                 for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++)  for (int xm=-cxm; xm<=fxm; xm++) {
                   const T cval = pix3d(x-xm,y-ym,z-zm,v,0);
-                  val+= cval*tqmask(cxm+xm,cym+ym,czm+zm,0);
+                  val+= cval*mask(cxm+xm,cym+ym,czm+zm,0);
                   norm+= cval*cval;
                 }
                 dest(x,y,z,v)=(norm!=0)?(restype)(val/std::sqrt(norm)):0;
@@ -12248,46 +12248,46 @@ namespace cimg_library {
       return dest;
     }
   
-    //! Convolve the image by a tqmask
+    //! Convolve the image by a mask
     /**
        This is the in-place version of get_convolve().
        \see get_convolve()
     **/
-    template<typename t> CImg& convolve(const CImg<t>& tqmask,const unsigned int cond=1,const bool weighted_convol=false) {
-      return get_convolve(tqmask,cond,weighted_convol).swap(*this); 
+    template<typename t> CImg& convolve(const CImg<t>& mask,const unsigned int cond=1,const bool weighted_convol=false) {
+      return get_convolve(mask,cond,weighted_convol).swap(*this); 
     }
 
     //! Return the erosion of the image by a structuring element.
     template<typename t> CImg<typename cimg::largest<T,t>::type> 
-    get_erode(const CImg<t>& tqmask, const unsigned int cond=1, const bool weighted_erosion=false) const {
+    get_erode(const CImg<t>& mask, const unsigned int cond=1, const bool weighted_erosion=false) const {
       typedef typename cimg::largest<T,t>::type restype;
       if (is_empty()) return CImg<restype>();
-      if (tqmask.is_empty() || tqmask.dim!=1)
-	throw CImgArgumentException("CImg<%s>::get_erosion() : Specified tqmask (%u,%u,%u,%u,%p) is not a scalar image.",
-				    pixel_type(),tqmask.width,tqmask.height,tqmask.depth,tqmask.dim,tqmask.data);
+      if (mask.is_empty() || mask.dim!=1)
+	throw CImgArgumentException("CImg<%s>::get_erosion() : Specified mask (%u,%u,%u,%u,%p) is not a scalar image.",
+				    pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);
       CImg<restype> dest(*this,false);
-      const int cxm=tqmask.width/2, cym=tqmask.height/2, czm=tqmask.depth/2,
-	fxm=cxm-1+(tqmask.width%2), fym=cym-1+(tqmask.height%2), fzm=czm-1+(tqmask.depth%2);
+      const int cxm=mask.width/2, cym=mask.height/2, czm=mask.depth/2,
+	fxm=cxm-1+(mask.width%2), fym=cym-1+(mask.height%2), fzm=czm-1+(mask.depth%2);
       cimg_mapV(*this,v) 
 	if (!weighted_erosion) {	// Classical erosion
 	  for (int z=czm; z<dimz()-czm; z++) for (int y=cym; y<dimy()-cym; y++) for (int x=cxm; x<dimx()-cxm; x++) {
 	    restype foo, min_val = cimg::get_type_max(foo);
 	    for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-	      if (tqmask(cxm+xm,cym+ym,czm+zm,0)) min_val = cimg::min((restype)(*this)(x+xm,y+ym,z+zm,v),min_val);
+	      if (mask(cxm+xm,cym+ym,czm+zm,0)) min_val = cimg::min((restype)(*this)(x+xm,y+ym,z+zm,v),min_val);
 	    dest(x,y,z,v)=min_val;
 	  }
 	  if (cond) cimg_mapYZV(*this,y,z,v)
 		      for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
 			restype foo, min_val = cimg::get_type_max(foo);
 			for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-			  if (tqmask(cxm+xm,cym+ym,czm+zm,0)) min_val = cimg::min((restype)pix3d(x+xm,y+ym,z+zm,v),min_val);
+			  if (mask(cxm+xm,cym+ym,czm+zm,0)) min_val = cimg::min((restype)pix3d(x+xm,y+ym,z+zm,v),min_val);
 			dest(x,y,z,v)=min_val;
 		      }
 	  else cimg_mapYZV(*this,y,z,v)
 		 for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
 		   restype foo, min_val = cimg::get_type_max(foo);
 		   for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-		     if (tqmask(cxm+xm,cym+ym,czm+zm,0)) min_val = cimg::min((restype)pix3d(x+xm,y+ym,z+zm,v,0),min_val);
+		     if (mask(cxm+xm,cym+ym,czm+zm,0)) min_val = cimg::min((restype)pix3d(x+xm,y+ym,z+zm,v,0),min_val);
 		   dest(x,y,z,v)=min_val;
 		 }
 	} else { // Weighted erosion
@@ -12295,21 +12295,21 @@ namespace cimg_library {
 	  for (int z=czm; z<dimz()-czm; z++) for (int y=cym; y<dimy()-cym; y++) for (int x=cxm; x<dimx()-cxm; x++) {
 	    restype foo, min_val = cimg::get_type_max(foo);
 	    for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-	      if ((mval=tqmask(cxm+xm,cym+ym,czm+zm,0))!=0) min_val = cimg::min((restype)((*this)(x+xm,y+ym,z+zm,v)+mval),min_val);
+	      if ((mval=mask(cxm+xm,cym+ym,czm+zm,0))!=0) min_val = cimg::min((restype)((*this)(x+xm,y+ym,z+zm,v)+mval),min_val);
 	    dest(x,y,z,v)=min_val;
 	  }
 	  if (cond) cimg_mapYZV(*this,y,z,v)
 		      for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
 			restype foo, min_val = cimg::get_type_max(foo);
 			for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-			  if ((mval=tqmask(cxm+xm,cym+ym,czm+zm,0))!=0) min_val = cimg::min((restype)(pix3d(x+xm,y+ym,z+zm,v)+mval),min_val);
+			  if ((mval=mask(cxm+xm,cym+ym,czm+zm,0))!=0) min_val = cimg::min((restype)(pix3d(x+xm,y+ym,z+zm,v)+mval),min_val);
 			dest(x,y,z,v)=min_val;
 		      }
 	  else cimg_mapYZV(*this,y,z,v)
 		 for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
 		   restype foo, min_val = cimg::get_type_max(foo);
 		   for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-		     if ((mval=tqmask(cxm+xm,cym+ym,czm+zm,0))!=0) min_val = cimg::min((restype)(pix3d(x+xm,y+ym,z+zm,v,0)+mval),min_val);
+		     if ((mval=mask(cxm+xm,cym+ym,czm+zm,0))!=0) min_val = cimg::min((restype)(pix3d(x+xm,y+ym,z+zm,v,0)+mval),min_val);
 		   dest(x,y,z,v)=min_val;
 		 }
 	}    
@@ -12321,14 +12321,14 @@ namespace cimg_library {
        This is the in-place version of get_erode().
        \see get_erode()
     **/
-    template<typename t> CImg& erode(const CImg<t>& tqmask,const unsigned int cond=1,const bool weighted_erosion=false) {
-      return get_erode(tqmask,cond,weighted_erosion).swap(*this); 
+    template<typename t> CImg& erode(const CImg<t>& mask,const unsigned int cond=1,const bool weighted_erosion=false) {
+      return get_erode(mask,cond,weighted_erosion).swap(*this); 
     }
 
     //! Erode the image by a square structuring element of size n
     CImg get_erode(const unsigned int n=1, const unsigned int cond=1) const {
-      static const CImg<T> tqmask(3,3,1,1,1);
-      return get_erode(tqmask,cond,false);      
+      static const CImg<T> mask(3,3,1,1,1);
+      return get_erode(mask,cond,false);      
     }
 
     //! Erode the image by a square structuring element of size n
@@ -12338,35 +12338,35 @@ namespace cimg_library {
 
     //! Return the dilatation of the image by a structuring element.
     template<typename t> CImg<typename cimg::largest<T,t>::type> 
-    get_dilate(const CImg<t>& tqmask, const unsigned int cond=1, const bool weighted_dilatation=false) const {
+    get_dilate(const CImg<t>& mask, const unsigned int cond=1, const bool weighted_dilatation=false) const {
       typedef typename cimg::largest<T,t>::type restype;
       if (is_empty()) return CImg<restype>();
-      if (tqmask.is_empty() || tqmask.dim!=1)
-	throw CImgArgumentException("CImg<%s>::get_dilate() : Specified tqmask (%u,%u,%u,%u,%p) is not a scalar image.",
-				    pixel_type(),tqmask.width,tqmask.height,tqmask.depth,tqmask.dim,tqmask.data);
+      if (mask.is_empty() || mask.dim!=1)
+	throw CImgArgumentException("CImg<%s>::get_dilate() : Specified mask (%u,%u,%u,%u,%p) is not a scalar image.",
+				    pixel_type(),mask.width,mask.height,mask.depth,mask.dim,mask.data);
       CImg<restype> dest(*this,false);
-      const int cxm=tqmask.width/2, cym=tqmask.height/2, czm=tqmask.depth/2,
-	fxm=cxm-1+(tqmask.width%2), fym=cym-1+(tqmask.height%2), fzm=czm-1+(tqmask.depth%2);
+      const int cxm=mask.width/2, cym=mask.height/2, czm=mask.depth/2,
+	fxm=cxm-1+(mask.width%2), fym=cym-1+(mask.height%2), fzm=czm-1+(mask.depth%2);
       cimg_mapV(*this,v) 
 	if (!weighted_dilatation) { // Classical dilatation
 	  for (int z=czm; z<dimz()-czm; z++) for (int y=cym; y<dimy()-cym; y++) for (int x=cxm; x<dimx()-cxm; x++) {
 	    restype foo, max_val = cimg::get_type_min(foo);
 	    for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-	      if (tqmask(cxm+xm,cym+ym,czm+zm,0)) max_val = cimg::max((restype)(*this)(x+xm,y+ym,z+zm,v),max_val);
+	      if (mask(cxm+xm,cym+ym,czm+zm,0)) max_val = cimg::max((restype)(*this)(x+xm,y+ym,z+zm,v),max_val);
 	    dest(x,y,z,v)=max_val;
 	  }
 	  if (cond) cimg_mapYZV(*this,y,z,v)
 		      for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
 			restype foo, max_val = cimg::get_type_min(foo);
 			for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-			  if (tqmask(cxm+xm,cym+ym,czm+zm,0)) max_val = cimg::max((restype)pix3d(x+xm,y+ym,z+zm,v),max_val);
+			  if (mask(cxm+xm,cym+ym,czm+zm,0)) max_val = cimg::max((restype)pix3d(x+xm,y+ym,z+zm,v),max_val);
 			dest(x,y,z,v)=max_val;
 		      }
 	  else cimg_mapYZV(*this,y,z,v)
 		 for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
 		   restype foo, max_val = cimg::get_type_min(foo);
 		   for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-		     if (tqmask(cxm+xm,cym+ym,czm+zm,0)) max_val = cimg::max((restype)pix3d(x+xm,y+ym,z+zm,v,0),max_val);
+		     if (mask(cxm+xm,cym+ym,czm+zm,0)) max_val = cimg::max((restype)pix3d(x+xm,y+ym,z+zm,v,0),max_val);
 		   dest(x,y,z,v)=max_val;
 		 }
 	} else { // Weighted dilatation
@@ -12374,21 +12374,21 @@ namespace cimg_library {
 	  for (int z=czm; z<dimz()-czm; z++) for (int y=cym; y<dimy()-cym; y++) for (int x=cxm; x<dimx()-cxm; x++) {
 	    restype foo, max_val = cimg::get_type_min(foo);
 	    for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-	      if ((mval=tqmask(cxm+xm,cym+ym,czm+zm,0))!=0) max_val = cimg::max((restype)((*this)(x+xm,y+ym,z+zm,v)-mval),max_val);
+	      if ((mval=mask(cxm+xm,cym+ym,czm+zm,0))!=0) max_val = cimg::max((restype)((*this)(x+xm,y+ym,z+zm,v)-mval),max_val);
 	    dest(x,y,z,v)=max_val;
 	  }
 	  if (cond) cimg_mapYZV(*this,y,z,v)
 		      for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
 			restype foo, max_val = cimg::get_type_min(foo);
 			for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-			  if ((mval=tqmask(cxm+xm,cym+ym,czm+zm,0))!=0) max_val = cimg::max((restype)(pix3d(x+xm,y+ym,z+zm,v)-mval),max_val);
+			  if ((mval=mask(cxm+xm,cym+ym,czm+zm,0))!=0) max_val = cimg::max((restype)(pix3d(x+xm,y+ym,z+zm,v)-mval),max_val);
 			dest(x,y,z,v)=max_val;
 		      }
 	  else cimg_mapYZV(*this,y,z,v)
 		 for (int x=0; x<dimx(); (y<cym || y>=dimy()-cym || z<czm || z>=dimz()-czm)?x++:((x<cxm-1 || x>=dimx()-cxm)?x++:(x=dimx()-cxm))) {
 		   restype foo, max_val = cimg::get_type_min(foo);
 		   for (int zm=-czm; zm<=fzm; zm++) for (int ym=-cym; ym<=fym; ym++) for (int xm=-cxm; xm<=fxm; xm++)
-		     if ((mval=tqmask(cxm+xm,cym+ym,czm+zm,0))!=0) max_val = cimg::max((restype)(pix3d(x+xm,y+ym,z+zm,v,0)-mval),max_val);
+		     if ((mval=mask(cxm+xm,cym+ym,czm+zm,0))!=0) max_val = cimg::max((restype)(pix3d(x+xm,y+ym,z+zm,v,0)-mval),max_val);
 		   dest(x,y,z,v)=max_val;
 		 }
 	}    
@@ -12400,14 +12400,14 @@ namespace cimg_library {
        This is the in-place version of get_dilate().
        \see get_dilate()
     **/
-    template<typename t> CImg& dilate(const CImg<t>& tqmask,const unsigned int cond=1,const bool weighted_dilatation=false) {
-      return get_dilate(tqmask,cond,weighted_dilatation).swap(*this); 
+    template<typename t> CImg& dilate(const CImg<t>& mask,const unsigned int cond=1,const bool weighted_dilatation=false) {
+      return get_dilate(mask,cond,weighted_dilatation).swap(*this); 
     }
 
     //! Dilate the image by a square structuring element of size n
     CImg get_dilate(const unsigned int n=1, const unsigned int cond=1) const {
-      static const CImg<T> tqmask(3,3,1,1,1);
-      return get_dilate(tqmask,cond,false);      
+      static const CImg<T> mask(3,3,1,1,1);
+      return get_dilate(mask,cond,false);      
     }
 
     //! Dilate the image by a square structuring element of size n
@@ -14723,27 +14723,27 @@ namespace cimg_library {
       switch (bpp) {
       case 1: { // Monochrome
 	for (int y=res.height-1; y>=0; y--) { 
-	  unsigned char tqmask = 0x80, val = 0;
+	  unsigned char mask = 0x80, val = 0;
 	  cimg_mapX(res,x) {
-	    if (tqmask==0x80) val = *(ptrs++);
-	    const unsigned char *col = (unsigned char*)(palette+(val&tqmask?1:0));
+	    if (mask==0x80) val = *(ptrs++);
+	    const unsigned char *col = (unsigned char*)(palette+(val&mask?1:0));
 	    res(x,y,2) = (T)*(col++);
 	    res(x,y,1) = (T)*(col++);
 	    res(x,y,0) = (T)*(col++);
-	    tqmask = cimg::ror(tqmask);
+	    mask = cimg::ror(mask);
 	  } ptrs+=align; }
       } break;
       case 4: { // 16 colors
 	for (int y=res.height-1; y>=0; y--) { 
-	  unsigned char tqmask = 0xF0, val = 0;
+	  unsigned char mask = 0xF0, val = 0;
 	  cimg_mapX(res,x) {
-	    if (tqmask==0xF0) val = *(ptrs++);
-	    const unsigned char color = (tqmask<16)?(val&tqmask):((val&tqmask)>>4);
+	    if (mask==0xF0) val = *(ptrs++);
+	    const unsigned char color = (mask<16)?(val&mask):((val&mask)>>4);
 	    unsigned char *col = (unsigned char*)(palette+color);
 	    res(x,y,2) = (T)*(col++);
 	    res(x,y,1) = (T)*(col++);
 	    res(x,y,0) = (T)*(col++);
-	    tqmask = cimg::ror(tqmask,4);
+	    mask = cimg::ror(mask,4);
 	  } ptrs+=align; }
       } break;
       case 8: { //  256 colors
@@ -17670,9 +17670,9 @@ namespace cimg_library {
       for (unsigned int y=0; y<h; y++)
 	for (unsigned int x=0; x<256*w; x++) {
 	  m>>=1; if (!m) { m=0x80000000; val = *(ptr++); }
-	  CImg<T>& img = res[x/w], &tqmask = res[x/w+256];
+	  CImg<T>& img = res[x/w], &mask = res[x/w+256];
 	  unsigned int xm = x%w;
-	  img(xm,y,0) = img(xm,y,1) = img(xm,y,2) = tqmask(xm,y,0) = (T)((val&m)?1:0);
+	  img(xm,y,0) = img(xm,y,1) = img(xm,y,2) = mask(xm,y,0) = (T)((val&m)?1:0);
 	}
       if (variable_size) res.crop_font();
       if (paddingx || paddingy) cimgl_map(res,l) res[l].resize(res[l].dimx()+paddingx, res[l].dimy()+paddingy,1,-100,0);
diff --git a/chalk/plugins/filters/cimg/kis_cimg_filter.cc b/chalk/plugins/filters/cimg/kis_cimg_filter.cc
index dc074e7b..665dfc09 100644
--- a/chalk/plugins/filters/cimg/kis_cimg_filter.cc
+++ b/chalk/plugins/filters/cimg/kis_cimg_filter.cc
@@ -291,7 +291,7 @@ void get_geom(const char *geom, int &geom_w, int &geom_h)
 void KisCImgFilter::cleanup()
 {
     img0 = flow = G = dest = sum= W = CImg<>();
-    tqmask = CImg<uchar> ();
+    mask = CImg<uchar> ();
 }
 
 //----------------------------------------------------------------------------
@@ -351,45 +351,45 @@ bool KisCImgFilter::prepare_restore()
 
 bool KisCImgFilter::prepare_inpaint()
 {
-    const char *file_m         = NULL; //cimg_option("-m",(const char*)NULL,"Input inpainting tqmask");
+    const char *file_m         = NULL; //cimg_option("-m",(const char*)NULL,"Input inpainting mask");
     if (!file_m)
     {
         // XXX: Do KDE messagebox
-        // g_message ("You need to specify an inpainting tqmask (option '-m') !");
+        // g_message ("You need to specify an inpainting mask (option '-m') !");
         return false;
     }
 
-    const unsigned int dilate  = 0; //cimg_option("-dilate",0,"Inpainting tqmask dilatation");
+    const unsigned int dilate  = 0; //cimg_option("-dilate",0,"Inpainting mask dilatation");
     const unsigned int ip_init = 3; //cimg_option("-init",3,"Inpainting init (0=black, 1=white, 2=noise, 3=unchanged, 4=interpol)");
     if (cimg::strncasecmp("block",file_m,5))
-        tqmask = CImg<uchar>(file_m);
+        mask = CImg<uchar>(file_m);
     else {
         int l=16; std::sscanf(file_m,"block%d",&l);
-        tqmask = CImg<uchar>(img.width/l,img.height/l);
-        cimg_mapXY(tqmask,x,y) tqmask(x,y)=(x+y)%2;
+        mask = CImg<uchar>(img.width/l,img.height/l);
+        cimg_mapXY(mask,x,y) mask(x,y)=(x+y)%2;
     }
-    tqmask.resize(img.width,img.height,1,1);
-    if (dilate) tqmask.dilate(dilate);
+    mask.resize(img.width,img.height,1,1);
+    if (dilate) mask.dilate(dilate);
     switch (ip_init) {
-    case 0 : { cimg_mapXYV(img,x,y,k) if (tqmask(x,y)) img(x,y,k) = 0; } break;
-    case 1 : { cimg_mapXYV(img,x,y,k) if (tqmask(x,y)) img(x,y,k) = 255; } break;
-    case 2 : { cimg_mapXYV(img,x,y,k) if (tqmask(x,y)) img(x,y,k) = (float)(255*cimg::rand()); } break;
+    case 0 : { cimg_mapXYV(img,x,y,k) if (mask(x,y)) img(x,y,k) = 0; } break;
+    case 1 : { cimg_mapXYV(img,x,y,k) if (mask(x,y)) img(x,y,k) = 255; } break;
+    case 2 : { cimg_mapXYV(img,x,y,k) if (mask(x,y)) img(x,y,k) = (float)(255*cimg::rand()); } break;
     case 3 : break;
     case 4 : {
-        CImg<uchar> ttqmask(tqmask),nttqmask(ttqmask);
+        CImg<uchar> tmask(mask),ntmask(tmask);
         CImg_3x3(M,uchar);
         CImg_3x3(I,float);
-        while (CImgStats(nttqmask,false).max>0) {
-            cimg_map3x3(ttqmask,x,y,0,0,M) if (Mcc && (!Mpc || !Mnc || !Mcp || !Mcn)) {
+        while (CImgStats(ntmask,false).max>0) {
+            cimg_map3x3(tmask,x,y,0,0,M) if (Mcc && (!Mpc || !Mnc || !Mcp || !Mcn)) {
                 const float ccp = Mcp?0.0f:1.0f, cpc = Mpc?0.0f:1.0f,
                     cnc = Mnc?0.0f:1.0f, ccn = Mcn?0.0f:1.0f, csum = ccp + cpc + cnc + ccn;
                 cimg_mapV(img,k) {
                     cimg_get3x3(img,x,y,0,k,I);
                     img(x,y,k) = (ccp*Icp + cpc*Ipc + cnc*Inc + ccn*Icn)/csum;
                 }
-                nttqmask(x,y) = 0;
+                ntmask(x,y) = 0;
             }
-            ttqmask = nttqmask;
+            tmask = ntmask;
         }
     } break;
     default: break;
@@ -398,7 +398,7 @@ bool KisCImgFilter::prepare_inpaint()
     G = CImg<>(img.width,img.height,1,3,0);
     CImg_3x3(g,uchar);
     CImg_3x3(I,float);
-    cimg_map3x3(tqmask,x,y,0,0,g) if (!gcc && !(gnc-gcc) && !(gcc-gpc) && !(gcn-gcc) && !(gcc-gcp)) cimg_mapV(img,k) {
+    cimg_map3x3(mask,x,y,0,0,g) if (!gcc && !(gnc-gcc) && !(gcc-gpc) && !(gcn-gcc) && !(gcc-gcp)) cimg_mapV(img,k) {
         cimg_get3x3(img,x,y,0,k,I);
         const float ix = 0.5f*(Inc-Ipc), iy = 0.5f*(Icn-Icp);
         G(x,y,0)+= ix*ix; G(x,y,1)+= ix*iy; G(x,y,2)+= iy*iy;
@@ -433,8 +433,8 @@ bool KisCImgFilter::prepare_resize()
     const bool anchor = true; //cimg_option("-anchor",true,"Anchor original pixels");
     if (!geom) throw CImgArgumentException("You need to specify an output geomety (option -g)");
     int w,h; get_geom(geom,w,h);
-    tqmask = CImg<uchar>(img.width,img.height,1,1,255);
-    if (!anchor) tqmask.resize(w,h,1,1,1); else tqmask = ~tqmask.resize(w,h,1,1,4);
+    mask = CImg<uchar>(img.width,img.height,1,1,255);
+    if (!anchor) mask.resize(w,h,1,1,1); else mask = ~mask.resize(w,h,1,1,4);
     img0 = img.get_resize(w,h,1,-100,1);
     img.resize(w,h,1,-100,3);
     G = CImg<>(img.width,img.height,1,3);
@@ -618,7 +618,7 @@ void KisCImgFilter::compute_LIC(int &progressSteps)
                 return;
             }
 
-            if (!tqmask.data || tqmask(x,y)) compute_LIC_back_forward(x,y);
+            if (!mask.data || mask(x,y)) compute_LIC_back_forward(x,y);
         }
     }
 
@@ -680,9 +680,9 @@ bool KisCImgFilter::process()
         return true;
 }
 
-KisFilterConfigWidget * KisCImgFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP /*dev*/)
+KisFilterConfigWidget * KisCImgFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
 {
-    return new KisCImgconfigWidget(this, tqparent);
+    return new KisCImgconfigWidget(this, parent);
 }
 
 KisFilterConfiguration* KisCImgFilter::configuration(TQWidget* nwidget)
diff --git a/chalk/plugins/filters/cimg/kis_cimg_filter.h b/chalk/plugins/filters/cimg/kis_cimg_filter.h
index 3b745476..965ecbd8 100644
--- a/chalk/plugins/filters/cimg/kis_cimg_filter.h
+++ b/chalk/plugins/filters/cimg/kis_cimg_filter.h
@@ -60,7 +60,7 @@ public:
     virtual bool supportsPreview() { return false; }
     virtual ColorSpaceIndependence colorSpaceIndependence();
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration * configuration(TQWidget*);
     virtual KisFilterConfiguration * configuration() { return new KisCImgFilterConfiguration();};
 private:
@@ -115,7 +115,7 @@ private:
         cimg_library::CImg<> dest, sum, W;
         cimg_library::CImg<> img, img0, flow,G;
         cimg_library::CImgl<> eigen;
-        cimg_library::CImg<unsigned char> tqmask;
+        cimg_library::CImg<unsigned char> mask;
 
 
 
diff --git a/chalk/plugins/filters/cimg/kis_cimg_plugin.cc b/chalk/plugins/filters/cimg/kis_cimg_plugin.cc
index 6c3e9522..9ed82fe2 100644
--- a/chalk/plugins/filters/cimg/kis_cimg_plugin.cc
+++ b/chalk/plugins/filters/cimg/kis_cimg_plugin.cc
@@ -28,12 +28,12 @@
 typedef KGenericFactory<KisCImgPlugin> KisCImgPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkcimg, KisCImgPluginFactory( "chalk" ) )
 
-KisCImgPlugin::KisCImgPlugin(TQObject *tqparent, const char *name, const TQStringList &) : KParts::Plugin(tqparent, name)
+KisCImgPlugin::KisCImgPlugin(TQObject *parent, const char *name, const TQStringList &) : KParts::Plugin(parent, name)
 {
     setInstance(KisCImgPluginFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisCImgFilter());
     }
 }
diff --git a/chalk/plugins/filters/cimg/kis_cimg_plugin.h b/chalk/plugins/filters/cimg/kis_cimg_plugin.h
index 2d35bff4..d016abf1 100644
--- a/chalk/plugins/filters/cimg/kis_cimg_plugin.h
+++ b/chalk/plugins/filters/cimg/kis_cimg_plugin.h
@@ -25,7 +25,7 @@
 class KisCImgPlugin : public KParts::Plugin
 {
 public:
-    KisCImgPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisCImgPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisCImgPlugin();
 };
 
diff --git a/chalk/plugins/filters/cimg/kis_cimgconfig_widget.cc b/chalk/plugins/filters/cimg/kis_cimgconfig_widget.cc
index c12ebf5f..b65a435f 100644
--- a/chalk/plugins/filters/cimg/kis_cimgconfig_widget.cc
+++ b/chalk/plugins/filters/cimg/kis_cimgconfig_widget.cc
@@ -29,8 +29,8 @@
 #include "kis_cimgconfig_widget.h"
 #include "kis_cimg_filter.h"
 
-KisCImgconfigWidget::KisCImgconfigWidget(KisFilter* nfilter, TQWidget * tqparent, const char * name, WFlags f)
-    : KisFilterConfigWidget(tqparent, name, f)
+KisCImgconfigWidget::KisCImgconfigWidget(KisFilter* nfilter, TQWidget * parent, const char * name, WFlags f)
+    : KisFilterConfigWidget(parent, name, f)
 {
     m_page = new WdgCImg(this);
     Q_CHECK_PTR(m_page);
diff --git a/chalk/plugins/filters/cimg/kis_cimgconfig_widget.h b/chalk/plugins/filters/cimg/kis_cimgconfig_widget.h
index aba373ca..e95b34f0 100644
--- a/chalk/plugins/filters/cimg/kis_cimgconfig_widget.h
+++ b/chalk/plugins/filters/cimg/kis_cimgconfig_widget.h
@@ -34,7 +34,7 @@ class KisCImgconfigWidget : public KisFilterConfigWidget {
 
 public:
 
-    KisCImgconfigWidget(KisFilter* nfilter, TQWidget * tqparent = 0, const char * name = 0, WFlags f = 0 );
+    KisCImgconfigWidget(KisFilter* nfilter, TQWidget * parent = 0, const char * name = 0, WFlags f = 0 );
     virtual ~KisCImgconfigWidget() {};
 
 public:
diff --git a/chalk/plugins/filters/colorify/Colorify.cpp b/chalk/plugins/filters/colorify/Colorify.cpp
index 0b5010cf..11f28d9a 100644
--- a/chalk/plugins/filters/colorify/Colorify.cpp
+++ b/chalk/plugins/filters/colorify/Colorify.cpp
@@ -31,8 +31,8 @@
 typedef KGenericFactory<ChalkColorify> ChalkColorifyFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkcolorify, ChalkColorifyFactory( "chalk" ) )
 
-ChalkColorify::ChalkColorify(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkColorify::ChalkColorify(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkColorifyFactory::instance());
 
@@ -40,11 +40,11 @@ ChalkColorify::ChalkColorify(TQObject *tqparent, const char *name, const TQStrin
     kdDebug(41006) << "Colorify Filter plugin. Class: "
           << className()
           << ", Parent: "
-          << tqparent -> className()
+          << parent -> className()
           << "\n";
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisColorify());
     }
 }
@@ -59,9 +59,9 @@ KisColorify::KisColorify() : KisFilter(id(), "colors", i18n("&Colorify..."))
 {
 }
 
-KisFilterConfigWidget * KisColorify::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP )
+KisFilterConfigWidget * KisColorify::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP )
 {
-    return new KisWdgColorify(this, tqparent, "configuration of colorify");
+    return new KisWdgColorify(this, parent, "configuration of colorify");
 }
 
 KisFilterConfiguration* KisColorify::configuration(TQWidget* w)
diff --git a/chalk/plugins/filters/colorify/Colorify.h b/chalk/plugins/filters/colorify/Colorify.h
index 36378505..6a984134 100644
--- a/chalk/plugins/filters/colorify/Colorify.h
+++ b/chalk/plugins/filters/colorify/Colorify.h
@@ -32,7 +32,7 @@
 class ChalkColorify : public KParts::Plugin
 {
 public:
-    ChalkColorify(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkColorify(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkColorify();
 };
 
@@ -49,7 +49,7 @@ class KisColorify : public KisFilter {
         virtual bool supportsAdjustmentLayers() { return false; }
         virtual ColorSpaceIndependence colorSpaceIndendendence() { return TO_LAB16; };
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };
 
diff --git a/chalk/plugins/filters/colorify/KisWdgColorify.cpp b/chalk/plugins/filters/colorify/KisWdgColorify.cpp
index 3d1e2413..5b03ad70 100644
--- a/chalk/plugins/filters/colorify/KisWdgColorify.cpp
+++ b/chalk/plugins/filters/colorify/KisWdgColorify.cpp
@@ -30,7 +30,7 @@
 
 #include "WdgColorifyBase.h"
 
-KisWdgColorify::KisWdgColorify( KisFilter* nfilter, TQWidget * tqparent, const char * name) : KisFilterConfigWidget ( tqparent, name )
+KisWdgColorify::KisWdgColorify( KisFilter* nfilter, TQWidget * parent, const char * name) : KisFilterConfigWidget ( parent, name )
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 1, 1);
     m_widget = new WdgColorifyBase(this);
diff --git a/chalk/plugins/filters/colorify/KisWdgColorify.h b/chalk/plugins/filters/colorify/KisWdgColorify.h
index 662a24cd..9e160fb7 100644
--- a/chalk/plugins/filters/colorify/KisWdgColorify.h
+++ b/chalk/plugins/filters/colorify/KisWdgColorify.h
@@ -35,7 +35,7 @@ class KisWdgColorify : public KisFilterConfigWidget
     Q_OBJECT
   TQ_OBJECT
     public:
-        KisWdgColorify( KisFilter* nfilter, TQWidget * tqparent, const char * name);
+        KisWdgColorify( KisFilter* nfilter, TQWidget * parent, const char * name);
         inline WdgColorifyBase* widget() { return m_widget; };
         virtual void setConfiguration(KisFilterConfiguration*);
     private:
diff --git a/chalk/plugins/filters/colors/colors.cc b/chalk/plugins/filters/colors/colors.cc
index d9a42134..d3cadc68 100644
--- a/chalk/plugins/filters/colors/colors.cc
+++ b/chalk/plugins/filters/colors/colors.cc
@@ -28,8 +28,8 @@
 typedef KGenericFactory<ChalkExtensionsColors> ChalkExtensionsColorsFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkextensioncolorsfilters, ChalkExtensionsColorsFactory( "chalk" ) )
 
-ChalkExtensionsColors::ChalkExtensionsColors(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkExtensionsColors::ChalkExtensionsColors(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkExtensionsColorsFactory::instance());
 
@@ -37,11 +37,11 @@ ChalkExtensionsColors::ChalkExtensionsColors(TQObject *tqparent, const char *nam
     kdDebug(41006) << "Extensions Colors Filter plugin. Class: "
           << className()
           << ", Parent: "
-          << tqparent -> className()
+          << parent -> className()
           << "\n";
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisFilterMax());
         manager->add(new KisFilterMin());
         manager->add(new KisFilterColorToAlpha());
diff --git a/chalk/plugins/filters/colors/colors.h b/chalk/plugins/filters/colors/colors.h
index d93ae1cc..dd27cc91 100644
--- a/chalk/plugins/filters/colors/colors.h
+++ b/chalk/plugins/filters/colors/colors.h
@@ -30,7 +30,7 @@
 class ChalkExtensionsColors : public KParts::Plugin
 {
 public:
-    ChalkExtensionsColors(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkExtensionsColors(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkExtensionsColors();
 };
 
diff --git a/chalk/plugins/filters/colors/kis_color_to_alpha.cc b/chalk/plugins/filters/colors/kis_color_to_alpha.cc
index 28814910..26f42844 100644
--- a/chalk/plugins/filters/colors/kis_color_to_alpha.cc
+++ b/chalk/plugins/filters/colors/kis_color_to_alpha.cc
@@ -34,9 +34,9 @@ KisFilterColorToAlpha::KisFilterColorToAlpha() : KisFilter(id(), "colors", i18n(
 {
 }
 
-KisFilterConfigWidget * KisFilterColorToAlpha::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP )
+KisFilterConfigWidget * KisFilterColorToAlpha::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP )
 {
-    return new KisWdgColorToAlpha(this, tqparent, "configuration of color to alpha");
+    return new KisWdgColorToAlpha(this, parent, "configuration of color to alpha");
 }
 
 KisFilterConfiguration* KisFilterColorToAlpha::configuration(TQWidget* w)
diff --git a/chalk/plugins/filters/colors/kis_color_to_alpha.h b/chalk/plugins/filters/colors/kis_color_to_alpha.h
index 9161b38e..57f6ca7e 100644
--- a/chalk/plugins/filters/colors/kis_color_to_alpha.h
+++ b/chalk/plugins/filters/colors/kis_color_to_alpha.h
@@ -39,7 +39,7 @@ class KisFilterColorToAlpha : public KisFilter {
         virtual bool supportsAdjustmentLayers() { return false; }
         virtual ColorSpaceIndependence colorSpaceIndependence() { return FULLY_INDEPENDENT; };
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };
 
diff --git a/chalk/plugins/filters/colors/kis_wdg_color_to_alpha.cc b/chalk/plugins/filters/colors/kis_wdg_color_to_alpha.cc
index e70fbc85..31b726bf 100644
--- a/chalk/plugins/filters/colors/kis_wdg_color_to_alpha.cc
+++ b/chalk/plugins/filters/colors/kis_wdg_color_to_alpha.cc
@@ -30,7 +30,7 @@
 
 #include "wdgcolortoalphabase.h"
 
-KisWdgColorToAlpha::KisWdgColorToAlpha( KisFilter* nfilter, TQWidget * tqparent, const char * name) : KisFilterConfigWidget ( tqparent, name )
+KisWdgColorToAlpha::KisWdgColorToAlpha( KisFilter* nfilter, TQWidget * parent, const char * name) : KisFilterConfigWidget ( parent, name )
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 1, 1);
     m_widget = new WdgColorToAlphaBase(this);
diff --git a/chalk/plugins/filters/colors/kis_wdg_color_to_alpha.h b/chalk/plugins/filters/colors/kis_wdg_color_to_alpha.h
index d2b5c9b9..90d16ef2 100644
--- a/chalk/plugins/filters/colors/kis_wdg_color_to_alpha.h
+++ b/chalk/plugins/filters/colors/kis_wdg_color_to_alpha.h
@@ -35,7 +35,7 @@ class KisWdgColorToAlpha : public KisFilterConfigWidget
     Q_OBJECT
   TQ_OBJECT
     public:
-        KisWdgColorToAlpha( KisFilter* nfilter, TQWidget * tqparent, const char * name);
+        KisWdgColorToAlpha( KisFilter* nfilter, TQWidget * parent, const char * name);
         inline WdgColorToAlphaBase* widget() { return m_widget; };
         virtual void setConfiguration(KisFilterConfiguration*);
     private:
diff --git a/chalk/plugins/filters/colorsfilters/colorsfilters.cc b/chalk/plugins/filters/colorsfilters/colorsfilters.cc
index cdc7dede..ae84bcaa 100644
--- a/chalk/plugins/filters/colorsfilters/colorsfilters.cc
+++ b/chalk/plugins/filters/colorsfilters/colorsfilters.cc
@@ -54,13 +54,13 @@
 typedef KGenericFactory<ColorsFilters> ColorsFiltersFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkcolorsfilters, ColorsFiltersFactory( "chalk" ) )
 
-ColorsFilters::ColorsFilters(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ColorsFilters::ColorsFilters(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ColorsFiltersFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisBrightnessContrastFilter());
         manager->add(new KisAutoContrast());
         manager->add(new KisPerChannelFilter());
diff --git a/chalk/plugins/filters/colorsfilters/colorsfilters.h b/chalk/plugins/filters/colorsfilters/colorsfilters.h
index ebf2dfeb..40dc8d74 100644
--- a/chalk/plugins/filters/colorsfilters/colorsfilters.h
+++ b/chalk/plugins/filters/colorsfilters/colorsfilters.h
@@ -29,7 +29,7 @@ class KisColorAdjustment;
 class ColorsFilters : public KParts::Plugin
 {
     public:
-        ColorsFilters(TQObject *tqparent, const char *name, const TQStringList &);
+        ColorsFilters(TQObject *parent, const char *name, const TQStringList &);
         virtual ~ColorsFilters();
 };
 
diff --git a/chalk/plugins/filters/colorsfilters/kis_brightness_contrast_filter.cc b/chalk/plugins/filters/colorsfilters/kis_brightness_contrast_filter.cc
index e9280425..a97f809b 100644
--- a/chalk/plugins/filters/colorsfilters/kis_brightness_contrast_filter.cc
+++ b/chalk/plugins/filters/colorsfilters/kis_brightness_contrast_filter.cc
@@ -144,9 +144,9 @@ KisBrightnessContrastFilter::KisBrightnessContrastFilter()
 
 }
 
-KisFilterConfigWidget * KisBrightnessContrastFilter::createConfigurationWidget(TQWidget *tqparent, KisPaintDeviceSP dev)
+KisFilterConfigWidget * KisBrightnessContrastFilter::createConfigurationWidget(TQWidget *parent, KisPaintDeviceSP dev)
 {
-    return new KisBrightnessContrastConfigWidget(tqparent, dev);
+    return new KisBrightnessContrastConfigWidget(parent, dev);
 }
 
 KisFilterConfiguration* KisBrightnessContrastFilter::configuration(TQWidget *nwidget)
@@ -252,8 +252,8 @@ void KisBrightnessContrastFilter::process(KisPaintDeviceSP src, KisPaintDeviceSP
     setProgressDone();
 }
 
-KisBrightnessContrastConfigWidget::KisBrightnessContrastConfigWidget(TQWidget * tqparent, KisPaintDeviceSP dev, const char * name, WFlags f)
-    : KisFilterConfigWidget(tqparent, name, f)
+KisBrightnessContrastConfigWidget::KisBrightnessContrastConfigWidget(TQWidget * parent, KisPaintDeviceSP dev, const char * name, WFlags f)
+    : KisFilterConfigWidget(parent, name, f)
 {
     int i;
     int height;
diff --git a/chalk/plugins/filters/colorsfilters/kis_brightness_contrast_filter.h b/chalk/plugins/filters/colorsfilters/kis_brightness_contrast_filter.h
index 598e4bcc..fb80a302 100644
--- a/chalk/plugins/filters/colorsfilters/kis_brightness_contrast_filter.h
+++ b/chalk/plugins/filters/colorsfilters/kis_brightness_contrast_filter.h
@@ -55,7 +55,7 @@ public:
 
 public:
 
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration * configuration(TQWidget *);
     virtual KisFilterConfiguration * configuration() { return new KisBrightnessContrastFilterConfiguration(); };
     virtual void process(KisPaintDeviceSP, KisPaintDeviceSP, KisFilterConfiguration* , const TQRect&);
@@ -73,7 +73,7 @@ public:
 class KisBrightnessContrastConfigWidget : public KisFilterConfigWidget {
 
 public:
-    KisBrightnessContrastConfigWidget(TQWidget * tqparent, KisPaintDeviceSP dev, const char * name = 0, WFlags f = 0 );
+    KisBrightnessContrastConfigWidget(TQWidget * parent, KisPaintDeviceSP dev, const char * name = 0, WFlags f = 0 );
     virtual ~KisBrightnessContrastConfigWidget() {};
 
     KisBrightnessContrastFilterConfiguration * config();
diff --git a/chalk/plugins/filters/colorsfilters/kis_perchannel_filter.cc b/chalk/plugins/filters/colorsfilters/kis_perchannel_filter.cc
index 1eaa1417..928baded 100644
--- a/chalk/plugins/filters/colorsfilters/kis_perchannel_filter.cc
+++ b/chalk/plugins/filters/colorsfilters/kis_perchannel_filter.cc
@@ -154,9 +154,9 @@ TQString KisPerChannelFilterConfiguration::toString()
 }
 
 
-KisFilterConfigWidget * KisPerChannelFilter::createConfigurationWidget(TQWidget *tqparent, KisPaintDeviceSP dev)
+KisFilterConfigWidget * KisPerChannelFilter::createConfigurationWidget(TQWidget *parent, KisPaintDeviceSP dev)
 {
-    return new KisPerChannelConfigWidget(tqparent, dev);
+    return new KisPerChannelConfigWidget(parent, dev);
 }
 
 KisFilterConfiguration* KisPerChannelFilter::configuration(TQWidget *nwidget)
@@ -300,8 +300,8 @@ void KisPerChannelConfigWidget::setActiveChannel(int ch)
     m_page->kCurve->setPixmap(pix);
 }
 
-KisPerChannelConfigWidget::KisPerChannelConfigWidget(TQWidget * tqparent, KisPaintDeviceSP dev, const char * name, WFlags f)
-    : KisFilterConfigWidget(tqparent, name, f)
+KisPerChannelConfigWidget::KisPerChannelConfigWidget(TQWidget * parent, KisPaintDeviceSP dev, const char * name, WFlags f)
+    : KisFilterConfigWidget(parent, name, f)
 {
     int i;
     int height;
diff --git a/chalk/plugins/filters/colorsfilters/kis_perchannel_filter.h b/chalk/plugins/filters/colorsfilters/kis_perchannel_filter.h
index 6d11ab43..9497075a 100644
--- a/chalk/plugins/filters/colorsfilters/kis_perchannel_filter.h
+++ b/chalk/plugins/filters/colorsfilters/kis_perchannel_filter.h
@@ -59,7 +59,7 @@ class KisPerChannelFilter
 public:
     KisPerChannelFilter() : KisFilter( id(), "adjust", i18n("&Color Adjustment...")) {};
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration* configuration(TQWidget*);
     virtual KisFilterConfiguration* configuration() { return new KisPerChannelFilterConfiguration(0); };
     virtual void process(KisPaintDeviceSP, KisPaintDeviceSP, KisFilterConfiguration* , const TQRect&);
@@ -80,7 +80,7 @@ class KisPerChannelConfigWidget : public KisFilterConfigWidget {
   TQ_OBJECT
 
 public:
-    KisPerChannelConfigWidget(TQWidget * tqparent, KisPaintDeviceSP dev, const char * name = 0, WFlags f = 0 );
+    KisPerChannelConfigWidget(TQWidget * parent, KisPaintDeviceSP dev, const char * name = 0, WFlags f = 0 );
     virtual ~KisPerChannelConfigWidget() {};
 
     KisPerChannelFilterConfiguration * config();
diff --git a/chalk/plugins/filters/convolutionfilters/convolutionfilters.cc b/chalk/plugins/filters/convolutionfilters/convolutionfilters.cc
index ddf2332f..b3c73a92 100644
--- a/chalk/plugins/filters/convolutionfilters/convolutionfilters.cc
+++ b/chalk/plugins/filters/convolutionfilters/convolutionfilters.cc
@@ -60,13 +60,13 @@ KisKernelSP createKernel( TQ_INT32 i0, TQ_INT32 i1, TQ_INT32 i2,
 typedef KGenericFactory<ChalkConvolutionFilters> ChalkConvolutionFiltersFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkconvolutionfilters, ChalkConvolutionFiltersFactory( "chalk" ) )
 
-ChalkConvolutionFilters::ChalkConvolutionFilters(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkConvolutionFilters::ChalkConvolutionFilters(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkConvolutionFiltersFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisGaussianBlurFilter());
         manager->add(new KisSharpenFilter());
         manager->add(new KisMeanRemovalFilter());
diff --git a/chalk/plugins/filters/convolutionfilters/convolutionfilters.h b/chalk/plugins/filters/convolutionfilters/convolutionfilters.h
index 94e4654c..aa8dc749 100644
--- a/chalk/plugins/filters/convolutionfilters/convolutionfilters.h
+++ b/chalk/plugins/filters/convolutionfilters/convolutionfilters.h
@@ -145,7 +145,7 @@ public:
 class ChalkConvolutionFilters : public KParts::Plugin
 {
 public:
-    ChalkConvolutionFilters(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkConvolutionFilters(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkConvolutionFilters();
 };
 
diff --git a/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter.cc b/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter.cc
index 8d48d25d..39da5b18 100644
--- a/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter.cc
+++ b/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter.cc
@@ -30,9 +30,9 @@
 #include "kis_matrix_widget.h"
 
 
-KisFilterConfigWidget * KisCustomConvolutionFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP)
+KisFilterConfigWidget * KisCustomConvolutionFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP)
 {
-    KisCustomConvolutionFilterConfigurationWidget* ccfcw = new KisCustomConvolutionFilterConfigurationWidget(this,tqparent, "custom convolution config widget");
+    KisCustomConvolutionFilterConfigurationWidget* ccfcw = new KisCustomConvolutionFilterConfigurationWidget(this,parent, "custom convolution config widget");
     Q_CHECK_PTR(ccfcw);
     return ccfcw;
 }
diff --git a/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter.h b/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter.h
index cbfd375e..60c009ce 100644
--- a/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter.h
+++ b/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter.h
@@ -39,7 +39,7 @@ public:
     virtual bool supportsIncrementalPainting() { return true; }
 
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration * configuration(TQWidget*);
     virtual KisFilterConfiguration * configuration() { return configuration(0); }; 
 protected:
diff --git a/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter_configuration_widget.cc b/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter_configuration_widget.cc
index b1905d30..2c1c87d9 100644
--- a/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter_configuration_widget.cc
+++ b/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter_configuration_widget.cc
@@ -34,8 +34,8 @@
 #include "kis_custom_convolution_filter_configuration_base_widget.h"
 #include "kis_matrix_widget.h"
 
-KisCustomConvolutionFilterConfigurationWidget::KisCustomConvolutionFilterConfigurationWidget( KisFilter* /*nfilter*/, TQWidget * tqparent, const char * name)
-    : KisFilterConfigWidget ( tqparent, name )
+KisCustomConvolutionFilterConfigurationWidget::KisCustomConvolutionFilterConfigurationWidget( KisFilter* /*nfilter*/, TQWidget * parent, const char * name)
+    : KisFilterConfigWidget ( parent, name )
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 2, 1);
     Q_CHECK_PTR(widgetLayout);
diff --git a/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter_configuration_widget.h b/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter_configuration_widget.h
index b5819e39..eb16e587 100644
--- a/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter_configuration_widget.h
+++ b/chalk/plugins/filters/convolutionfilters/kis_custom_convolution_filter_configuration_widget.h
@@ -34,7 +34,7 @@ class KisCustomConvolutionFilterConfigurationWidget : public KisFilterConfigWidg
 
 public:
 
-    KisCustomConvolutionFilterConfigurationWidget( KisFilter* nfilter, TQWidget * tqparent, const char * name);
+    KisCustomConvolutionFilterConfigurationWidget( KisFilter* nfilter, TQWidget * parent, const char * name);
     inline KisCustomConvolutionFilterConfigurationBaseWidget* matrixWidget() { return m_ccfcws; };
     void setConfiguration(KisFilterConfiguration * config);
 
diff --git a/chalk/plugins/filters/cubismfilter/kis_cubism_filter.cc b/chalk/plugins/filters/cubismfilter/kis_cubism_filter.cc
index 1cd1aa8d..68f560c4 100644
--- a/chalk/plugins/filters/cubismfilter/kis_cubism_filter.cc
+++ b/chalk/plugins/filters/cubismfilter/kis_cubism_filter.cc
@@ -433,12 +433,12 @@ void KisCubismFilter::cubism(KisPaintDeviceSP src, KisPaintDeviceSP dst, const T
         setProgressDone();
 }
 
-KisFilterConfigWidget * KisCubismFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP /*dev*/)
+KisFilterConfigWidget * KisCubismFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 2, 40, 10, i18n("Tile size"), "tileSize" ) );
     param.push_back( KisIntegerWidgetParam( 2, 40, 10, i18n("Tile saturation"), "tileSaturation" ) );
-    return new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisCubismFilter::configuration(TQWidget* nwidget)
diff --git a/chalk/plugins/filters/cubismfilter/kis_cubism_filter.h b/chalk/plugins/filters/cubismfilter/kis_cubism_filter.h
index f2624030..332e5fd1 100644
--- a/chalk/plugins/filters/cubismfilter/kis_cubism_filter.h
+++ b/chalk/plugins/filters/cubismfilter/kis_cubism_filter.h
@@ -60,7 +60,7 @@ public:
     virtual bool workWith(KisColorSpace* cs);
     virtual ColorSpaceIndependence colorSpaceIndependence() { return TO_RGBA8; };
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration* configuration(TQWidget*);
     virtual KisFilterConfiguration* configuration() { return new KisCubismFilterConfiguration( 10, 10); };
 private:
diff --git a/chalk/plugins/filters/cubismfilter/kis_cubism_filter_plugin.cc b/chalk/plugins/filters/cubismfilter/kis_cubism_filter_plugin.cc
index 4e7dfa7d..7215a2e3 100644
--- a/chalk/plugins/filters/cubismfilter/kis_cubism_filter_plugin.cc
+++ b/chalk/plugins/filters/cubismfilter/kis_cubism_filter_plugin.cc
@@ -25,13 +25,13 @@
 typedef KGenericFactory<KisCubismFilterPlugin> KisCubismFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkcubismfilter, KisCubismFilterPluginFactory( "chalk" ) )
 
-KisCubismFilterPlugin::KisCubismFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &) : KParts::Plugin(tqparent, name)
+KisCubismFilterPlugin::KisCubismFilterPlugin(TQObject *parent, const char *name, const TQStringList &) : KParts::Plugin(parent, name)
 {
     setInstance(KisCubismFilterPluginFactory::instance());
 
-    if ( tqparent->inherits("KisFilterRegistry") )
+    if ( parent->inherits("KisFilterRegistry") )
     {
-        KisFilterRegistry * r = dynamic_cast<KisFilterRegistry*>(tqparent);
+        KisFilterRegistry * r = dynamic_cast<KisFilterRegistry*>(parent);
         r->add(new KisCubismFilter());
     }
 }
diff --git a/chalk/plugins/filters/cubismfilter/kis_cubism_filter_plugin.h b/chalk/plugins/filters/cubismfilter/kis_cubism_filter_plugin.h
index b37e40c1..064c55e3 100644
--- a/chalk/plugins/filters/cubismfilter/kis_cubism_filter_plugin.h
+++ b/chalk/plugins/filters/cubismfilter/kis_cubism_filter_plugin.h
@@ -25,7 +25,7 @@
 class KisCubismFilterPlugin : public KParts::Plugin
 {
 public:
-    KisCubismFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisCubismFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisCubismFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/embossfilter/kis_emboss_filter.cc b/chalk/plugins/filters/embossfilter/kis_emboss_filter.cc
index f15b5952..6e69761b 100644
--- a/chalk/plugins/filters/embossfilter/kis_emboss_filter.cc
+++ b/chalk/plugins/filters/embossfilter/kis_emboss_filter.cc
@@ -158,11 +158,11 @@ int KisEmbossFilter::Lim_Max (int Now, int Up, int Max)
     return (Up);
 }
 
-KisFilterConfigWidget * KisEmbossFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP)
+KisFilterConfigWidget * KisEmbossFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP)
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 10, 300, 30, i18n("Depth"), "depth" ) );
-    KisFilterConfigWidget * w = new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    KisFilterConfigWidget * w = new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
     Q_CHECK_PTR(w);
     return w;
 }
diff --git a/chalk/plugins/filters/embossfilter/kis_emboss_filter.h b/chalk/plugins/filters/embossfilter/kis_emboss_filter.h
index fe4410ed..1e46d21f 100644
--- a/chalk/plugins/filters/embossfilter/kis_emboss_filter.h
+++ b/chalk/plugins/filters/embossfilter/kis_emboss_filter.h
@@ -50,7 +50,7 @@ public:
     virtual std::list<KisFilterConfiguration*> listOfExamplesConfiguration(KisPaintDeviceSP )
     { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisEmbossFilterConfiguration(100)); return list; }
     public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration* configuration(TQWidget*);
     virtual KisFilterConfiguration* configuration() {return new KisEmbossFilterConfiguration( 30 );};
 
diff --git a/chalk/plugins/filters/embossfilter/kis_emboss_filter_plugin.cc b/chalk/plugins/filters/embossfilter/kis_emboss_filter_plugin.cc
index 4aec1db6..bd11b115 100644
--- a/chalk/plugins/filters/embossfilter/kis_emboss_filter_plugin.cc
+++ b/chalk/plugins/filters/embossfilter/kis_emboss_filter_plugin.cc
@@ -25,12 +25,12 @@
 typedef KGenericFactory<KisEmbossFilterPlugin> KisEmbossFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkembossfilter, KisEmbossFilterPluginFactory( "chalk" ) )
 
-KisEmbossFilterPlugin::KisEmbossFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &) : KParts::Plugin(tqparent, name)
+KisEmbossFilterPlugin::KisEmbossFilterPlugin(TQObject *parent, const char *name, const TQStringList &) : KParts::Plugin(parent, name)
 {
     setInstance(KisEmbossFilterPluginFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisEmbossFilter());
     }
 }
diff --git a/chalk/plugins/filters/embossfilter/kis_emboss_filter_plugin.h b/chalk/plugins/filters/embossfilter/kis_emboss_filter_plugin.h
index 39803418..81312b01 100644
--- a/chalk/plugins/filters/embossfilter/kis_emboss_filter_plugin.h
+++ b/chalk/plugins/filters/embossfilter/kis_emboss_filter_plugin.h
@@ -24,7 +24,7 @@
 class KisEmbossFilterPlugin : public KParts::Plugin
 {
 public:
-    KisEmbossFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisEmbossFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisEmbossFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/example/example.cc b/chalk/plugins/filters/example/example.cc
index 2e2fbc7c..e1e33ade 100644
--- a/chalk/plugins/filters/example/example.cc
+++ b/chalk/plugins/filters/example/example.cc
@@ -44,14 +44,14 @@
 typedef KGenericFactory<ChalkExample> ChalkExampleFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkexample, ChalkExampleFactory( "chalk" ) )
 
-ChalkExample::ChalkExample(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkExample::ChalkExample(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkExampleFactory::instance());
 
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisFilterInvert());
     }
 }
diff --git a/chalk/plugins/filters/example/example.h b/chalk/plugins/filters/example/example.h
index df49d036..4df6705c 100644
--- a/chalk/plugins/filters/example/example.h
+++ b/chalk/plugins/filters/example/example.h
@@ -27,7 +27,7 @@
 class ChalkExample : public KParts::Plugin
 {
 public:
-    ChalkExample(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkExample(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkExample();
 };
 
diff --git a/chalk/plugins/filters/fastcolortransfer/fastcolortransfer.cc b/chalk/plugins/filters/fastcolortransfer/fastcolortransfer.cc
index 10ef044d..c43e5690 100644
--- a/chalk/plugins/filters/fastcolortransfer/fastcolortransfer.cc
+++ b/chalk/plugins/filters/fastcolortransfer/fastcolortransfer.cc
@@ -37,19 +37,19 @@ typedef KGenericFactory<FastColorTransferPlugin> ChalkFastColorTransferFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkfastcolortransfer, ChalkFastColorTransferFactory( "chalk" ) )
 
 
-FastColorTransferPlugin::FastColorTransferPlugin(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+FastColorTransferPlugin::FastColorTransferPlugin(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkFastColorTransferFactory::instance());
 
     kdDebug(41006) << "Color Transfer Filter plugin. Class: "
           << className()
           << ", Parent: "
-          << tqparent -> className()
+          << parent -> className()
           << "\n";
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisFilterFastColorTransfer());
     }
 }
@@ -63,9 +63,9 @@ KisFilterFastColorTransfer::KisFilterFastColorTransfer() : KisFilter(id(), "colo
 }
 
 
-KisFilterConfigWidget * KisFilterFastColorTransfer::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP )
+KisFilterConfigWidget * KisFilterFastColorTransfer::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP )
 {
-    return new KisWdgFastColorTransfer(this, tqparent, "configuration of color to alpha");
+    return new KisWdgFastColorTransfer(this, parent, "configuration of color to alpha");
 }
 
 KisFilterConfiguration* KisFilterFastColorTransfer::configuration(TQWidget* w)
diff --git a/chalk/plugins/filters/fastcolortransfer/fastcolortransfer.h b/chalk/plugins/filters/fastcolortransfer/fastcolortransfer.h
index d8a3c898..dbaee9f8 100644
--- a/chalk/plugins/filters/fastcolortransfer/fastcolortransfer.h
+++ b/chalk/plugins/filters/fastcolortransfer/fastcolortransfer.h
@@ -31,7 +31,7 @@
 class FastColorTransferPlugin : public KParts::Plugin
 {
     public:
-        FastColorTransferPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+        FastColorTransferPlugin(TQObject *parent, const char *name, const TQStringList &);
         virtual ~FastColorTransferPlugin();
 };
 
@@ -48,7 +48,7 @@ class KisFilterFastColorTransfer : public KisFilter
         virtual bool supportsIncrementalPainting() { return false; }
         virtual bool supportsAdjustmentLayers() { return false; }
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };
 
diff --git a/chalk/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp b/chalk/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
index 3c08cac3..49826ccb 100644
--- a/chalk/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
+++ b/chalk/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.cpp
@@ -26,7 +26,7 @@
 
 #include "wdgfastcolortransfer.h"
 
-KisWdgFastColorTransfer::KisWdgFastColorTransfer(KisFilter* nfilter, TQWidget * tqparent, const char * name) : KisFilterConfigWidget ( tqparent, name )
+KisWdgFastColorTransfer::KisWdgFastColorTransfer(KisFilter* nfilter, TQWidget * parent, const char * name) : KisFilterConfigWidget ( parent, name )
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 1, 1);
     m_widget = new WdgFastColorTransfer(this);
diff --git a/chalk/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.h b/chalk/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.h
index 0a29aef5..0e95e319 100644
--- a/chalk/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.h
+++ b/chalk/plugins/filters/fastcolortransfer/kis_wdg_fastcolortransfer.h
@@ -36,7 +36,7 @@ class WdgFastColorTransfer;
 class KisWdgFastColorTransfer : public KisFilterConfigWidget
 {
     public:
-        KisWdgFastColorTransfer(KisFilter* nfilter, TQWidget * tqparent, const char * name);
+        KisWdgFastColorTransfer(KisFilter* nfilter, TQWidget * parent, const char * name);
         ~KisWdgFastColorTransfer();
         virtual void setConfiguration(KisFilterConfiguration*);
         inline WdgFastColorTransfer* widget() { return m_widget; }
diff --git a/chalk/plugins/filters/halftone/kis_halftone.cpp b/chalk/plugins/filters/halftone/kis_halftone.cpp
index 35e838ed..c2c2f463 100644
--- a/chalk/plugins/filters/halftone/kis_halftone.cpp
+++ b/chalk/plugins/filters/halftone/kis_halftone.cpp
@@ -36,21 +36,21 @@
     typedef KGenericFactory<ChalkHalftone> ChalkHalftoneFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkhalftone, ChalkHalftoneFactory( "chalk" ) )
 
-        ChalkHalftone::ChalkHalftone(TQObject *tqparent, const char *name, const TQStringList &)
-  : KParts::Plugin(tqparent, name)
+        ChalkHalftone::ChalkHalftone(TQObject *parent, const char *name, const TQStringList &)
+  : KParts::Plugin(parent, name)
 {
     setInstance(ChalkHalftoneFactory::instance());
 
     kdDebug(41006) << "Halftone filter plugin. Class: "
            << className()
            << ", Parent: "
-           << tqparent->className()
+           << parent->className()
            << "\n";
 
 
-    if ( tqparent->inherits("KisFilterRegistry") )
+    if ( parent->inherits("KisFilterRegistry") )
     {
-        KisFilterRegistry * r = dynamic_cast<KisFilterRegistry*>(tqparent);
+        KisFilterRegistry * r = dynamic_cast<KisFilterRegistry*>(parent);
         r->add(new KisHalftoneReduction());
     }
 }
@@ -71,12 +71,12 @@ KisHalftoneReduction::~KisHalftoneReduction()
 {
 }
 
-KisFilterConfigWidget * KisHalftoneReduction::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP )
+KisFilterConfigWidget * KisHalftoneReduction::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP )
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 0, 100, BEST_WAVELET_FREQUENCY_VALUE, i18n("Frequency"), "frequency" ) );
     param.push_back( KisIntegerWidgetParam( 0, 100, 2, i18n("Half-size"), "halfsize" ) );
-    return new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisHalftoneReduction::configuration(TQWidget* nwidget )
@@ -121,11 +121,11 @@ void KisHalftoneReduction::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, K
     kdDebug(41005) << halfSize << endl;
     KisAutobrushShape* kas = new KisAutobrushCircleShape(2*halfSize+1, 2*halfSize+1 , halfSize, halfSize);
     
-    TQImage tqmask;
-    kas->createBrush(&tqmask);
+    TQImage mask;
+    kas->createBrush(&mask);
     
-    KisKernelSP kernel = KisKernel::fromTQImage(tqmask); // TODO: for 1.6 reuse the chalk's core function for creating kernel : KisKernel::fromTQImage
-    tqmask.save("testtqmask.png", "PNG");
+    KisKernelSP kernel = KisKernel::fromTQImage(mask); // TODO: for 1.6 reuse the chalk's core function for creating kernel : KisKernel::fromTQImage
+    mask.save("testmask.png", "PNG");
     
     KisPaintDeviceSP interm = new KisPaintDevice(*src);
     KisColorSpace * cs = src->colorSpace();
diff --git a/chalk/plugins/filters/halftone/kis_halftone.h b/chalk/plugins/filters/halftone/kis_halftone.h
index 38842d31..96f22e8f 100644
--- a/chalk/plugins/filters/halftone/kis_halftone.h
+++ b/chalk/plugins/filters/halftone/kis_halftone.h
@@ -32,7 +32,7 @@
 class ChalkHalftone : public KParts::Plugin
 {
   public:
-        ChalkHalftone(TQObject *tqparent, const char *name, const TQStringList &);
+        ChalkHalftone(TQObject *parent, const char *name, const TQStringList &);
         virtual ~ChalkHalftone();
 };
 
@@ -65,7 +65,7 @@ public:
     virtual void process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration*, const TQRect&);
     virtual KisFilterConfiguration * configuration(TQWidget* nwidget);
     virtual KisFilterConfiguration * configuration() {return new KisHalftoneReductionConfiguration( BEST_WAVELET_FREQUENCY_VALUE, 2 );};
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
 
     static inline KisID id() { return KisID("halftone", i18n("Halftone Reducer")); };
     virtual bool supportsPainting() { return false; }
diff --git a/chalk/plugins/filters/imageenhancement/imageenhancement.cpp b/chalk/plugins/filters/imageenhancement/imageenhancement.cpp
index 8108a3d6..78398157 100644
--- a/chalk/plugins/filters/imageenhancement/imageenhancement.cpp
+++ b/chalk/plugins/filters/imageenhancement/imageenhancement.cpp
@@ -47,21 +47,21 @@
 typedef KGenericFactory<ChalkImageEnhancement> ChalkImageEnhancementFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkimageenhancement, ChalkImageEnhancementFactory( "chalk" ) )
 
-        ChalkImageEnhancement::ChalkImageEnhancement(TQObject *tqparent, const char *name, const TQStringList &)
-  : KParts::Plugin(tqparent, name)
+        ChalkImageEnhancement::ChalkImageEnhancement(TQObject *parent, const char *name, const TQStringList &)
+  : KParts::Plugin(parent, name)
 {
     setInstance(ChalkImageEnhancementFactory::instance());
 
     kdDebug(41006) << "Image enhancement filter plugin. Class: "
            << className()
            << ", Parent: "
-           << tqparent->className()
+           << parent->className()
            << "\n";
 
 
-    if ( tqparent->inherits("KisFilterRegistry") )
+    if ( parent->inherits("KisFilterRegistry") )
     {
-        KisFilterRegistry * r = dynamic_cast<KisFilterRegistry*>(tqparent);
+        KisFilterRegistry * r = dynamic_cast<KisFilterRegistry*>(parent);
         r->add(new KisSimpleNoiseReducer());
         r->add(new KisWaveletNoiseReduction());
     }
diff --git a/chalk/plugins/filters/imageenhancement/imageenhancement.h b/chalk/plugins/filters/imageenhancement/imageenhancement.h
index b333e25f..7a00f352 100644
--- a/chalk/plugins/filters/imageenhancement/imageenhancement.h
+++ b/chalk/plugins/filters/imageenhancement/imageenhancement.h
@@ -27,7 +27,7 @@
 class ChalkImageEnhancement : public KParts::Plugin
 {
   public:
-        ChalkImageEnhancement(TQObject *tqparent, const char *name, const TQStringList &);
+        ChalkImageEnhancement(TQObject *parent, const char *name, const TQStringList &);
         virtual ~ChalkImageEnhancement();
 };
 
diff --git a/chalk/plugins/filters/imageenhancement/kis_simple_noise_reducer.cpp b/chalk/plugins/filters/imageenhancement/kis_simple_noise_reducer.cpp
index 0ff7a958..f38f364c 100644
--- a/chalk/plugins/filters/imageenhancement/kis_simple_noise_reducer.cpp
+++ b/chalk/plugins/filters/imageenhancement/kis_simple_noise_reducer.cpp
@@ -37,12 +37,12 @@ KisSimpleNoiseReducer::~KisSimpleNoiseReducer()
 {
 }
 
-KisFilterConfigWidget * KisSimpleNoiseReducer::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP)
+KisFilterConfigWidget * KisSimpleNoiseReducer::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP)
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 0, 255, 50, i18n("Threshold"), "threshold" ) );
     param.push_back( KisIntegerWidgetParam( 0, 10, 1, i18n("Window size"), "windowsize") );
-    return new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisSimpleNoiseReducer::configuration(TQWidget* nwidget)
@@ -77,13 +77,13 @@ void KisSimpleNoiseReducer::process(KisPaintDeviceSP src, KisPaintDeviceSP dst,
 
     KisColorSpace* cs = src->colorSpace();
 
-    // Compute the blur tqmask
+    // Compute the blur mask
     KisAutobrushShape* kas = new KisAutobrushCircleShape(2*windowsize+1, 2*windowsize+1, windowsize, windowsize);
 
-    TQImage tqmask;
-    kas->createBrush(&tqmask);
+    TQImage mask;
+    kas->createBrush(&mask);
 
-    KisKernelSP kernel = KisKernel::fromTQImage(tqmask);
+    KisKernelSP kernel = KisKernel::fromTQImage(mask);
 
     KisPaintDeviceSP interm = new KisPaintDevice(*src);
     KisConvolutionPainter painter( interm );
diff --git a/chalk/plugins/filters/imageenhancement/kis_simple_noise_reducer.h b/chalk/plugins/filters/imageenhancement/kis_simple_noise_reducer.h
index a233bb85..620981c7 100644
--- a/chalk/plugins/filters/imageenhancement/kis_simple_noise_reducer.h
+++ b/chalk/plugins/filters/imageenhancement/kis_simple_noise_reducer.h
@@ -47,7 +47,7 @@ class KisSimpleNoiseReducer : public KisFilter
         virtual void process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration*, const TQRect&);
         virtual KisFilterConfiguration * configuration(TQWidget* nwidget);
         virtual KisFilterConfiguration * configuration() { return new KisSimpleNoiseReducerConfiguration( 50, 1); };
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
 
         static inline KisID id() { return KisID("gaussiannoisereducer", i18n("Gaussian Noise Reducer")); };
         virtual bool supportsPainting() { return false; }
diff --git a/chalk/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.cpp b/chalk/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.cpp
index 021bf5c6..e5cca62e 100644
--- a/chalk/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.cpp
+++ b/chalk/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.cpp
@@ -38,11 +38,11 @@ KisWaveletNoiseReduction::~KisWaveletNoiseReduction()
 {
 }
 
-KisFilterConfigWidget * KisWaveletNoiseReduction::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP )
+KisFilterConfigWidget * KisWaveletNoiseReduction::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP )
 {
     vKisDoubleWidgetParam param;
     param.push_back( KisDoubleWidgetParam( 0.0, 256.0, BEST_WAVELET_THRESHOLD_VALUE, i18n("Threshold"), "threshold" ) );
-    return new KisMultiDoubleFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiDoubleFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisWaveletNoiseReduction::configuration(TQWidget* nwidget )
diff --git a/chalk/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.h b/chalk/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.h
index 85a96ec8..b6da5773 100644
--- a/chalk/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.h
+++ b/chalk/plugins/filters/imageenhancement/kis_wavelet_noise_reduction.h
@@ -54,7 +54,7 @@ public:
     virtual void process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration*, const TQRect&);
     virtual KisFilterConfiguration * configuration(TQWidget* nwidget);
     virtual KisFilterConfiguration * configuration() {return new KisWaveletNoiseReductionConfiguration( BEST_WAVELET_THRESHOLD_VALUE );};
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
 
     static inline KisID id() { return KisID("waveletnoisereducer", i18n("Wavelet Noise Reducer")); };
     virtual bool supportsPainting() { return false; }
diff --git a/chalk/plugins/filters/lenscorrectionfilter/kis_wdg_lens_correction.cpp b/chalk/plugins/filters/lenscorrectionfilter/kis_wdg_lens_correction.cpp
index f33681a5..b83baa11 100644
--- a/chalk/plugins/filters/lenscorrectionfilter/kis_wdg_lens_correction.cpp
+++ b/chalk/plugins/filters/lenscorrectionfilter/kis_wdg_lens_correction.cpp
@@ -26,8 +26,8 @@
 
 #include "wdglenscorrectionoptions.h"
 
-KisWdgLensCorrection::KisWdgLensCorrection(KisFilter* /*nfilter*/, TQWidget* tqparent, const char* name)
-    : KisFilterConfigWidget(tqparent,name)
+KisWdgLensCorrection::KisWdgLensCorrection(KisFilter* /*nfilter*/, TQWidget* parent, const char* name)
+    : KisFilterConfigWidget(parent,name)
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 1, 1);
     m_widget = new WdgLensCorrectionOptions(this);
diff --git a/chalk/plugins/filters/lenscorrectionfilter/kis_wdg_lens_correction.h b/chalk/plugins/filters/lenscorrectionfilter/kis_wdg_lens_correction.h
index 193aa5aa..d5d3ce96 100644
--- a/chalk/plugins/filters/lenscorrectionfilter/kis_wdg_lens_correction.h
+++ b/chalk/plugins/filters/lenscorrectionfilter/kis_wdg_lens_correction.h
@@ -31,7 +31,7 @@ class KisWdgLensCorrection : public KisFilterConfigWidget
     Q_OBJECT
   TQ_OBJECT
     public:
-        KisWdgLensCorrection(KisFilter* nfilter, TQWidget* tqparent = 0, const char* name = 0);
+        KisWdgLensCorrection(KisFilter* nfilter, TQWidget* parent = 0, const char* name = 0);
         ~KisWdgLensCorrection();
     public:
         inline WdgLensCorrectionOptions* widget() { return m_widget; };
diff --git a/chalk/plugins/filters/lenscorrectionfilter/lenscorrectionfilter.cc b/chalk/plugins/filters/lenscorrectionfilter/lenscorrectionfilter.cc
index cd3627c5..4fefb597 100644
--- a/chalk/plugins/filters/lenscorrectionfilter/lenscorrectionfilter.cc
+++ b/chalk/plugins/filters/lenscorrectionfilter/lenscorrectionfilter.cc
@@ -52,14 +52,14 @@
 typedef KGenericFactory<ChalkLensCorrectionFilter> ChalkLensCorrectionFilterFactory;
 K_EXPORT_COMPONENT_FACTORY( chalklenscorrectionfilter, ChalkLensCorrectionFilterFactory( "chalk" ) )
 
-ChalkLensCorrectionFilter::ChalkLensCorrectionFilter(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkLensCorrectionFilter::ChalkLensCorrectionFilter(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkLensCorrectionFilterFactory::instance());
 
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisFilterLensCorrection());
     }
 }
@@ -88,9 +88,9 @@ KisFilterConfiguration* KisFilterLensCorrection::configuration(TQWidget* w)
     return config;
 }
 
-KisFilterConfigWidget * KisFilterLensCorrection::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP /*dev*/)
+KisFilterConfigWidget * KisFilterLensCorrection::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
 {
-    return new KisWdgLensCorrection((KisFilter*)this, (TQWidget*)tqparent, i18n("Configuration of lens correction filter").ascii());
+    return new KisWdgLensCorrection((KisFilter*)this, (TQWidget*)parent, i18n("Configuration of lens correction filter").ascii());
 }
 
 void KisFilterLensCorrection::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration* config, const TQRect& rawrect)
diff --git a/chalk/plugins/filters/lenscorrectionfilter/lenscorrectionfilter.h b/chalk/plugins/filters/lenscorrectionfilter/lenscorrectionfilter.h
index f04012b6..a54f11a9 100644
--- a/chalk/plugins/filters/lenscorrectionfilter/lenscorrectionfilter.h
+++ b/chalk/plugins/filters/lenscorrectionfilter/lenscorrectionfilter.h
@@ -29,7 +29,7 @@ class KisFilterConfigWidget;
 class ChalkLensCorrectionFilter : public KParts::Plugin
 {
 public:
-    ChalkLensCorrectionFilter(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkLensCorrectionFilter(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkLensCorrectionFilter();
 };
 
@@ -46,7 +46,7 @@ class KisFilterLensCorrection : public KisFilter
         virtual bool supportsIncrementalPainting() { return false; }
         virtual bool supportsAdjustmentLayers() { return false; }
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };
 
diff --git a/chalk/plugins/filters/levelfilter/kgradientslider.cc b/chalk/plugins/filters/levelfilter/kgradientslider.cc
index 948fd277..7b836436 100644
--- a/chalk/plugins/filters/levelfilter/kgradientslider.cc
+++ b/chalk/plugins/filters/levelfilter/kgradientslider.cc
@@ -34,8 +34,8 @@
 
 #include "kgradientslider.h"
 
-KGradientSlider::KGradientSlider(TQWidget *tqparent, const char *name, WFlags f)
-            : TQWidget(tqparent, name, f)
+KGradientSlider::KGradientSlider(TQWidget *parent, const char *name, WFlags f)
+            : TQWidget(parent, name, f)
 {
     m_dragging = false;
     
diff --git a/chalk/plugins/filters/levelfilter/kgradientslider.h b/chalk/plugins/filters/levelfilter/kgradientslider.h
index c8990c80..ad667ca2 100644
--- a/chalk/plugins/filters/levelfilter/kgradientslider.h
+++ b/chalk/plugins/filters/levelfilter/kgradientslider.h
@@ -40,7 +40,7 @@ Q_OBJECT
     } eCursor;
 
 public:
-    KGradientSlider(TQWidget *tqparent = 0, const char *name = 0, WFlags f = 0);
+    KGradientSlider(TQWidget *parent = 0, const char *name = 0, WFlags f = 0);
 
     virtual ~KGradientSlider();
 
diff --git a/chalk/plugins/filters/levelfilter/kis_level_filter.cc b/chalk/plugins/filters/levelfilter/kis_level_filter.cc
index fb437f26..b7c1cb00 100644
--- a/chalk/plugins/filters/levelfilter/kis_level_filter.cc
+++ b/chalk/plugins/filters/levelfilter/kis_level_filter.cc
@@ -86,9 +86,9 @@ KisLevelFilter::KisLevelFilter()
 
 }
 
-KisFilterConfigWidget * KisLevelFilter::createConfigurationWidget(TQWidget *tqparent, KisPaintDeviceSP dev)
+KisFilterConfigWidget * KisLevelFilter::createConfigurationWidget(TQWidget *parent, KisPaintDeviceSP dev)
 {
-    return new KisLevelConfigWidget(tqparent, dev);
+    return new KisLevelConfigWidget(parent, dev);
 }
 
 KisFilterConfiguration* KisLevelFilter::configuration(TQWidget *nwidget)
@@ -207,8 +207,8 @@ void KisLevelFilter::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilt
     setProgressDone();
 }
 
-KisLevelConfigWidget::KisLevelConfigWidget(TQWidget * tqparent, KisPaintDeviceSP dev, const char * name, WFlags f)
-    : KisFilterConfigWidget(tqparent, name, f)
+KisLevelConfigWidget::KisLevelConfigWidget(TQWidget * parent, KisPaintDeviceSP dev, const char * name, WFlags f)
+    : KisFilterConfigWidget(parent, name, f)
 {
     m_page = new WdgLevel(this);
     histogram = NULL;
diff --git a/chalk/plugins/filters/levelfilter/kis_level_filter.h b/chalk/plugins/filters/levelfilter/kis_level_filter.h
index 8f3d3591..b2a38521 100644
--- a/chalk/plugins/filters/levelfilter/kis_level_filter.h
+++ b/chalk/plugins/filters/levelfilter/kis_level_filter.h
@@ -57,7 +57,7 @@ public:
 
 public:
 
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration * configuration(TQWidget *);
     virtual KisFilterConfiguration * configuration() { return new KisLevelFilterConfiguration(); };
     virtual void process(KisPaintDeviceSP, KisPaintDeviceSP, KisFilterConfiguration* , const TQRect&);
@@ -76,7 +76,7 @@ class KisLevelConfigWidget : public KisFilterConfigWidget {
 Q_OBJECT
   TQ_OBJECT
 public:
-    KisLevelConfigWidget(TQWidget * tqparent, KisPaintDeviceSP dev, const char * name = 0, WFlags f = 0 );
+    KisLevelConfigWidget(TQWidget * parent, KisPaintDeviceSP dev, const char * name = 0, WFlags f = 0 );
     virtual ~KisLevelConfigWidget();
 
     KisLevelFilterConfiguration * config();
diff --git a/chalk/plugins/filters/levelfilter/levelfilter.cc b/chalk/plugins/filters/levelfilter/levelfilter.cc
index 669775fb..cabda0b5 100644
--- a/chalk/plugins/filters/levelfilter/levelfilter.cc
+++ b/chalk/plugins/filters/levelfilter/levelfilter.cc
@@ -51,13 +51,13 @@
 typedef KGenericFactory<LevelFilter> LevelFilterFactory;
 K_EXPORT_COMPONENT_FACTORY( chalklevelfilter, LevelFilterFactory( "chalk" ) )
 
-LevelFilter::LevelFilter(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+LevelFilter::LevelFilter(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(LevelFilterFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisLevelFilter());
     }
 }
diff --git a/chalk/plugins/filters/levelfilter/levelfilter.h b/chalk/plugins/filters/levelfilter/levelfilter.h
index 69627ff7..433a8d8a 100644
--- a/chalk/plugins/filters/levelfilter/levelfilter.h
+++ b/chalk/plugins/filters/levelfilter/levelfilter.h
@@ -28,7 +28,7 @@ class KisColorAdjustment;
 class LevelFilter : public KParts::Plugin
 {
     public:
-        LevelFilter(TQObject *tqparent, const char *name, const TQStringList &);
+        LevelFilter(TQObject *parent, const char *name, const TQStringList &);
         virtual ~LevelFilter();
 };
 
diff --git a/chalk/plugins/filters/noisefilter/kis_wdg_noise.cpp b/chalk/plugins/filters/noisefilter/kis_wdg_noise.cpp
index 060418f3..c13db952 100644
--- a/chalk/plugins/filters/noisefilter/kis_wdg_noise.cpp
+++ b/chalk/plugins/filters/noisefilter/kis_wdg_noise.cpp
@@ -26,8 +26,8 @@
 
 #include "wdgnoiseoptions.h"
 
-KisWdgNoise::KisWdgNoise(KisFilter* /*nfilter*/, TQWidget* tqparent, const char* name)
-    : KisFilterConfigWidget(tqparent,name)
+KisWdgNoise::KisWdgNoise(KisFilter* /*nfilter*/, TQWidget* parent, const char* name)
+    : KisFilterConfigWidget(parent,name)
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 1, 1);
     m_widget = new WdgNoiseOptions(this);
diff --git a/chalk/plugins/filters/noisefilter/kis_wdg_noise.h b/chalk/plugins/filters/noisefilter/kis_wdg_noise.h
index ca42ebd2..a9b34745 100644
--- a/chalk/plugins/filters/noisefilter/kis_wdg_noise.h
+++ b/chalk/plugins/filters/noisefilter/kis_wdg_noise.h
@@ -31,7 +31,7 @@ class KisWdgNoise : public KisFilterConfigWidget
     Q_OBJECT
   TQ_OBJECT
     public:
-        KisWdgNoise(KisFilter* nfilter, TQWidget* tqparent = 0, const char* name = 0);
+        KisWdgNoise(KisFilter* nfilter, TQWidget* parent = 0, const char* name = 0);
         ~KisWdgNoise();
     public:
         inline WdgNoiseOptions* widget() { return m_widget; };
diff --git a/chalk/plugins/filters/noisefilter/noisefilter.cc b/chalk/plugins/filters/noisefilter/noisefilter.cc
index af593703..0f634eb8 100644
--- a/chalk/plugins/filters/noisefilter/noisefilter.cc
+++ b/chalk/plugins/filters/noisefilter/noisefilter.cc
@@ -48,14 +48,14 @@
 typedef KGenericFactory<ChalkNoiseFilter> ChalkNoiseFilterFactory;
 K_EXPORT_COMPONENT_FACTORY( chalknoisefilter, ChalkNoiseFilterFactory( "chalk" ) )
 
-ChalkNoiseFilter::ChalkNoiseFilter(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkNoiseFilter::ChalkNoiseFilter(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkNoiseFilterFactory::instance());
 
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisFilterNoise());
     }
 }
@@ -80,9 +80,9 @@ KisFilterConfiguration* KisFilterNoise::configuration(TQWidget* w)
     return config;
 }
 
-KisFilterConfigWidget * KisFilterNoise::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev)
+KisFilterConfigWidget * KisFilterNoise::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev)
 {
-    return new KisWdgNoise((KisFilter*)this, (TQWidget*)tqparent, i18n("Configuration of noise filter").ascii());
+    return new KisWdgNoise((KisFilter*)this, (TQWidget*)parent, i18n("Configuration of noise filter").ascii());
 }
 
 void KisFilterNoise::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration* config, const TQRect& rect)
diff --git a/chalk/plugins/filters/noisefilter/noisefilter.h b/chalk/plugins/filters/noisefilter/noisefilter.h
index b73c761f..c630e71f 100644
--- a/chalk/plugins/filters/noisefilter/noisefilter.h
+++ b/chalk/plugins/filters/noisefilter/noisefilter.h
@@ -29,7 +29,7 @@ class KisFilterConfigWidget;
 class ChalkNoiseFilter : public KParts::Plugin
 {
 public:
-    ChalkNoiseFilter(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkNoiseFilter(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkNoiseFilter();
 };
 
@@ -45,7 +45,7 @@ class KisFilterNoise : public KisFilter
         virtual bool supportsPreview() { return true; }
         virtual bool supportsIncrementalPainting() { return false; }
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };
 
diff --git a/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter.cc b/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter.cc
index a658b863..2909e8a1 100644
--- a/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter.cc
+++ b/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter.cc
@@ -228,12 +228,12 @@ uint KisOilPaintFilter::MostFrequentColor (KisPaintDeviceSP src, const TQRect& b
 }
 
 
-KisFilterConfigWidget * KisOilPaintFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP /*dev*/)
+KisFilterConfigWidget * KisOilPaintFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 1, 5, 1, i18n("Brush size"), "brushSize" ) );
     param.push_back( KisIntegerWidgetParam( 10, 255, 30, i18n("Smooth"), "smooth" ) );
-    return new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisOilPaintFilter::configuration(TQWidget* nwidget)
diff --git a/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter.h b/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter.h
index fbc07a63..912f8b45 100644
--- a/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter.h
+++ b/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter.h
@@ -55,7 +55,7 @@ public:
     virtual bool supportsAdjustmentLayers() { return false; }
     virtual std::list<KisFilterConfiguration*> listOfExamplesConfiguration(KisPaintDeviceSP dev);
     public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration * configuration(TQWidget*);
     virtual KisFilterConfiguration * configuration() { return new KisOilPaintFilterConfiguration( 1, 30); };
 private:
diff --git a/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter_plugin.cc b/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter_plugin.cc
index 7167b04d..d9c9f3e6 100644
--- a/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter_plugin.cc
+++ b/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter_plugin.cc
@@ -26,12 +26,12 @@
 typedef KGenericFactory<KisOilPaintFilterPlugin> KisOilPaintFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkoilpaintfilter, KisOilPaintFilterPluginFactory( "chalk" ) )
 
-KisOilPaintFilterPlugin::KisOilPaintFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &) : KParts::Plugin(tqparent, name)
+KisOilPaintFilterPlugin::KisOilPaintFilterPlugin(TQObject *parent, const char *name, const TQStringList &) : KParts::Plugin(parent, name)
 {
     setInstance(KisOilPaintFilterPluginFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisOilPaintFilter());
     }
 
diff --git a/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter_plugin.h b/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter_plugin.h
index 1f780918..2900f59f 100644
--- a/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter_plugin.h
+++ b/chalk/plugins/filters/oilpaintfilter/kis_oilpaint_filter_plugin.h
@@ -25,7 +25,7 @@
 class KisOilPaintFilterPlugin : public KParts::Plugin
 {
 public:
-    KisOilPaintFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisOilPaintFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisOilPaintFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter.cc b/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter.cc
index 267b159b..33886f2c 100644
--- a/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter.cc
+++ b/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter.cc
@@ -163,12 +163,12 @@ void KisPixelizeFilter::pixelize(KisPaintDeviceSP src, KisPaintDeviceSP dst, int
     setProgressDone();
 }
 
-KisFilterConfigWidget * KisPixelizeFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP /*dev*/)
+KisFilterConfigWidget * KisPixelizeFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 2, 40, 10, i18n("Pixel width"), "pixelWidth" ) );
     param.push_back( KisIntegerWidgetParam( 2, 40, 10, i18n("Pixel height"), "pixelHeight" ) );
-    return new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisPixelizeFilter::configuration(TQWidget* nwidget)
diff --git a/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter.h b/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter.h
index c7d8bb31..306921e8 100644
--- a/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter.h
+++ b/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter.h
@@ -51,7 +51,7 @@ public:
     virtual std::list<KisFilterConfiguration*> listOfExamplesConfiguration(KisPaintDeviceSP )
         { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisPixelizeFilterConfiguration(10,10)); return list; }
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration* configuration(TQWidget*);
     virtual KisFilterConfiguration * configuration();
 private:
diff --git a/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter_plugin.cc b/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter_plugin.cc
index 93309146..d93cad4e 100644
--- a/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter_plugin.cc
+++ b/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter_plugin.cc
@@ -26,13 +26,13 @@
 typedef KGenericFactory<KisPixelizeFilterPlugin> KisPixelizeFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkpixelizefilter, KisPixelizeFilterPluginFactory( "chalk" ) )
 
-KisPixelizeFilterPlugin::KisPixelizeFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &)
-    : KParts::Plugin(tqparent, name)
+KisPixelizeFilterPlugin::KisPixelizeFilterPlugin(TQObject *parent, const char *name, const TQStringList &)
+    : KParts::Plugin(parent, name)
 {
     setInstance(KisPixelizeFilterPluginFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisPixelizeFilter());
     }
 }
diff --git a/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter_plugin.h b/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter_plugin.h
index 25d8a62f..f662cf9d 100644
--- a/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter_plugin.h
+++ b/chalk/plugins/filters/pixelizefilter/kis_pixelize_filter_plugin.h
@@ -25,7 +25,7 @@
 class KisPixelizeFilterPlugin : public KParts::Plugin
 {
 public:
-    KisPixelizeFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisPixelizeFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisPixelizeFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter.cc b/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter.cc
index c208bb52..81ee1448 100644
--- a/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter.cc
+++ b/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter.cc
@@ -418,13 +418,13 @@ uchar KisRainDropsFilter::LimitValues (int ColorValue)
     return ((uchar) ColorValue);
 }
 
-KisFilterConfigWidget * KisRainDropsFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP)
+KisFilterConfigWidget * KisRainDropsFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP)
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 1, 200, 80, i18n("Drop size"), "dropsize" ) );
     param.push_back( KisIntegerWidgetParam( 1, 500, 80, i18n("Number"), "number" ) );
     param.push_back( KisIntegerWidgetParam( 1, 100, 30, i18n("Fish eyes"), "fishEyes" ) );
-    return new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisRainDropsFilter::configuration(TQWidget* nwidget)
diff --git a/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter.h b/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter.h
index 0d797d7d..91a2963c 100644
--- a/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter.h
+++ b/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter.h
@@ -55,7 +55,7 @@ public:
     { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisRainDropsFilterConfiguration( 30, 80, 20)); return list; }
 
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration* configuration(TQWidget*);
 private:
     void   rainDrops(KisPaintDeviceSP src, KisPaintDeviceSP dst, const TQRect& rect, int DropSize, int Amount, int Coeff);
diff --git a/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter_plugin.cc b/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter_plugin.cc
index 593311d5..f62196cb 100644
--- a/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter_plugin.cc
+++ b/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter_plugin.cc
@@ -29,12 +29,12 @@
 typedef KGenericFactory<KisRainDropsFilterPlugin> KisRainDropsFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkraindropsfilter, KisRainDropsFilterPluginFactory( "chalk" ) )
 
-KisRainDropsFilterPlugin::KisRainDropsFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &) : KParts::Plugin(tqparent, name)
+KisRainDropsFilterPlugin::KisRainDropsFilterPlugin(TQObject *parent, const char *name, const TQStringList &) : KParts::Plugin(parent, name)
 {
     setInstance(KisRainDropsFilterPluginFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisRainDropsFilter());
     }
 }
diff --git a/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter_plugin.h b/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter_plugin.h
index ca4e05d3..edbf33bf 100644
--- a/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter_plugin.h
+++ b/chalk/plugins/filters/raindropsfilter/kis_raindrops_filter_plugin.h
@@ -26,7 +26,7 @@
 class KisRainDropsFilterPlugin : public KParts::Plugin
 {
 public:
-    KisRainDropsFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisRainDropsFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisRainDropsFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/randompickfilter/kis_wdg_random_pick.cpp b/chalk/plugins/filters/randompickfilter/kis_wdg_random_pick.cpp
index 044f9613..ba157e14 100644
--- a/chalk/plugins/filters/randompickfilter/kis_wdg_random_pick.cpp
+++ b/chalk/plugins/filters/randompickfilter/kis_wdg_random_pick.cpp
@@ -26,8 +26,8 @@
 
 #include "wdgrandompickoptions.h"
 
-KisWdgRandomPick::KisWdgRandomPick(KisFilter* /*nfilter*/, TQWidget* tqparent, const char* name)
-    : KisFilterConfigWidget(tqparent,name)
+KisWdgRandomPick::KisWdgRandomPick(KisFilter* /*nfilter*/, TQWidget* parent, const char* name)
+    : KisFilterConfigWidget(parent,name)
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 1, 1);
     m_widget = new WdgRandomPickOptions(this);
diff --git a/chalk/plugins/filters/randompickfilter/kis_wdg_random_pick.h b/chalk/plugins/filters/randompickfilter/kis_wdg_random_pick.h
index 54b46e20..76171530 100644
--- a/chalk/plugins/filters/randompickfilter/kis_wdg_random_pick.h
+++ b/chalk/plugins/filters/randompickfilter/kis_wdg_random_pick.h
@@ -31,7 +31,7 @@ class KisWdgRandomPick : public KisFilterConfigWidget
     Q_OBJECT
   TQ_OBJECT
     public:
-        KisWdgRandomPick(KisFilter* nfilter, TQWidget* tqparent = 0, const char* name = 0);
+        KisWdgRandomPick(KisFilter* nfilter, TQWidget* parent = 0, const char* name = 0);
         ~KisWdgRandomPick();
     public:
         inline WdgRandomPickOptions* widget() { return m_widget; };
diff --git a/chalk/plugins/filters/randompickfilter/randompickfilter.cc b/chalk/plugins/filters/randompickfilter/randompickfilter.cc
index 3a645590..54af3e7b 100644
--- a/chalk/plugins/filters/randompickfilter/randompickfilter.cc
+++ b/chalk/plugins/filters/randompickfilter/randompickfilter.cc
@@ -49,14 +49,14 @@
 typedef KGenericFactory<ChalkRandomPickFilter> ChalkRandomPickFilterFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkrandompickfilter, ChalkRandomPickFilterFactory( "chalk" ) )
 
-ChalkRandomPickFilter::ChalkRandomPickFilter(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkRandomPickFilter::ChalkRandomPickFilter(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkRandomPickFilterFactory::instance());
 
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisFilterRandomPick());
     }
 }
@@ -82,9 +82,9 @@ KisFilterConfiguration* KisFilterRandomPick::configuration(TQWidget* w)
     return config;
 }
 
-KisFilterConfigWidget * KisFilterRandomPick::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev)
+KisFilterConfigWidget * KisFilterRandomPick::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev)
 {
-    return new KisWdgRandomPick((KisFilter*)this, (TQWidget*)tqparent, i18n("Configuration of random pick filter").ascii());
+    return new KisWdgRandomPick((KisFilter*)this, (TQWidget*)parent, i18n("Configuration of random pick filter").ascii());
 }
 
 void KisFilterRandomPick::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration* config, const TQRect& rect)
diff --git a/chalk/plugins/filters/randompickfilter/randompickfilter.h b/chalk/plugins/filters/randompickfilter/randompickfilter.h
index 4b50c215..a4fa1da8 100644
--- a/chalk/plugins/filters/randompickfilter/randompickfilter.h
+++ b/chalk/plugins/filters/randompickfilter/randompickfilter.h
@@ -29,7 +29,7 @@ class KisFilterConfigWidget;
 class ChalkRandomPickFilter : public KParts::Plugin
 {
 public:
-    ChalkRandomPickFilter(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkRandomPickFilter(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkRandomPickFilter();
 };
 
@@ -45,7 +45,7 @@ class KisFilterRandomPick : public KisFilter
         virtual bool supportsPreview() { return true; }
         virtual bool supportsIncrementalPainting() { return false; }
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };
 
diff --git a/chalk/plugins/filters/roundcorners/kis_round_corners_filter.cc b/chalk/plugins/filters/roundcorners/kis_round_corners_filter.cc
index 3b8177d4..a823f812 100644
--- a/chalk/plugins/filters/roundcorners/kis_round_corners_filter.cc
+++ b/chalk/plugins/filters/roundcorners/kis_round_corners_filter.cc
@@ -139,11 +139,11 @@ void KisRoundCornersFilter::process(KisPaintDeviceSP src, KisPaintDeviceSP dst,
     setProgressDone();
 }
 
-KisFilterConfigWidget * KisRoundCornersFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP /*dev*/)
+KisFilterConfigWidget * KisRoundCornersFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 2, 100, 30, i18n("Radius"), "radius" ) );
-    return new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisRoundCornersFilter::configuration(TQWidget* nwidget)
diff --git a/chalk/plugins/filters/roundcorners/kis_round_corners_filter.h b/chalk/plugins/filters/roundcorners/kis_round_corners_filter.h
index ec5fb9fb..3fdc83d0 100644
--- a/chalk/plugins/filters/roundcorners/kis_round_corners_filter.h
+++ b/chalk/plugins/filters/roundcorners/kis_round_corners_filter.h
@@ -49,7 +49,7 @@ public:
     virtual std::list<KisFilterConfiguration*> listOfExamplesConfiguration(KisPaintDeviceSP )
         { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisRoundCornersFilterConfiguration(30)); return list; }
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration* configuration(TQWidget*);
     virtual KisFilterConfiguration * configuration() { return new KisRoundCornersFilterConfiguration( 30 ); };
 private:
diff --git a/chalk/plugins/filters/roundcorners/kis_round_corners_filter_plugin.cc b/chalk/plugins/filters/roundcorners/kis_round_corners_filter_plugin.cc
index f53acf46..14610c8e 100644
--- a/chalk/plugins/filters/roundcorners/kis_round_corners_filter_plugin.cc
+++ b/chalk/plugins/filters/roundcorners/kis_round_corners_filter_plugin.cc
@@ -26,13 +26,13 @@
 typedef KGenericFactory<KisRoundCornersFilterPlugin> KisRoundCornersFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkroundcornersfilter, KisRoundCornersFilterPluginFactory( "chalk" ) )
 
-KisRoundCornersFilterPlugin::KisRoundCornersFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &)
-    : KParts::Plugin(tqparent, name)
+KisRoundCornersFilterPlugin::KisRoundCornersFilterPlugin(TQObject *parent, const char *name, const TQStringList &)
+    : KParts::Plugin(parent, name)
 {
     setInstance(KisRoundCornersFilterPluginFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisRoundCornersFilter());
     }
 }
diff --git a/chalk/plugins/filters/roundcorners/kis_round_corners_filter_plugin.h b/chalk/plugins/filters/roundcorners/kis_round_corners_filter_plugin.h
index e55239e4..cbf87108 100644
--- a/chalk/plugins/filters/roundcorners/kis_round_corners_filter_plugin.h
+++ b/chalk/plugins/filters/roundcorners/kis_round_corners_filter_plugin.h
@@ -25,7 +25,7 @@
 class KisRoundCornersFilterPlugin : public KParts::Plugin
 {
 public:
-    KisRoundCornersFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisRoundCornersFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisRoundCornersFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter.cc b/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter.cc
index 6c621e47..f1f9f5df 100644
--- a/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter.cc
+++ b/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter.cc
@@ -168,11 +168,11 @@ void KisSmallTilesFilter::createSmallTiles(KisPaintDeviceSP src, KisPaintDeviceS
     setProgressDone();
 }
 
-KisFilterConfigWidget * KisSmallTilesFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP /*dev*/)
+KisFilterConfigWidget * KisSmallTilesFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
 {
     vKisIntegerWidgetParam param;
     param.push_back( KisIntegerWidgetParam( 2, 5, 1, i18n("Number of tiles"), "smalltiles" ) );
-    return new KisMultiIntegerFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiIntegerFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisSmallTilesFilter::configuration(TQWidget* nwidget)
diff --git a/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter.h b/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter.h
index 8d82eda2..dee775bd 100644
--- a/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter.h
+++ b/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter.h
@@ -59,7 +59,7 @@ public:
     { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisSmallTilesFilterConfiguration(2)); return list; }
 
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration * configuration(TQWidget*);
     virtual KisFilterConfiguration * configuration() { return new KisSmallTilesFilterConfiguration( 2 ); };
 
diff --git a/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.cc b/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.cc
index 5283980c..6a7fe9ea 100644
--- a/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.cc
+++ b/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.cc
@@ -26,13 +26,13 @@
 typedef KGenericFactory<KisSmallTilesFilterPlugin> KisSmallTilesFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalksmalltilesfilter, KisSmallTilesFilterPluginFactory( "chalk" ) )
 
-KisSmallTilesFilterPlugin::KisSmallTilesFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &)
-    : KParts::Plugin(tqparent, name)
+KisSmallTilesFilterPlugin::KisSmallTilesFilterPlugin(TQObject *parent, const char *name, const TQStringList &)
+    : KParts::Plugin(parent, name)
 {
     setInstance(KisSmallTilesFilterPluginFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisSmallTilesFilter());
     }
 }
diff --git a/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.h b/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.h
index 601568f2..26c30012 100644
--- a/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.h
+++ b/chalk/plugins/filters/smalltilesfilter/kis_small_tiles_filter_plugin.h
@@ -25,7 +25,7 @@
 class KisSmallTilesFilterPlugin : public KParts::Plugin
 {
 public:
-    KisSmallTilesFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisSmallTilesFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisSmallTilesFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/sobelfilter/kis_sobel_filter.cc b/chalk/plugins/filters/sobelfilter/kis_sobel_filter.cc
index 9a2f5604..52424ce2 100644
--- a/chalk/plugins/filters/sobelfilter/kis_sobel_filter.cc
+++ b/chalk/plugins/filters/sobelfilter/kis_sobel_filter.cc
@@ -195,14 +195,14 @@ void KisSobelFilter::sobel(const TQRect & rc, KisPaintDeviceSP src, KisPaintDevi
 }
 
 
-KisFilterConfigWidget * KisSobelFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP)
+KisFilterConfigWidget * KisSobelFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP)
 {
     vKisBoolWidgetParam param;
     param.push_back( KisBoolWidgetParam( true, i18n("Sobel horizontally"), "doHorizontally" ) );
     param.push_back( KisBoolWidgetParam( true, i18n("Sobel vertically"), "doVertically" ) );
     param.push_back( KisBoolWidgetParam( true, i18n("Keep sign of result"), "keepSign" ) );
     param.push_back( KisBoolWidgetParam( true, i18n("Make image opaque"), "makeOpaque" ) );
-    return new KisMultiBoolFilterWidget(tqparent, id().id().ascii(), id().id().ascii(), param );
+    return new KisMultiBoolFilterWidget(parent, id().id().ascii(), id().id().ascii(), param );
 }
 
 KisFilterConfiguration* KisSobelFilter::configuration(TQWidget* nwidget)
diff --git a/chalk/plugins/filters/sobelfilter/kis_sobel_filter.h b/chalk/plugins/filters/sobelfilter/kis_sobel_filter.h
index 757757bc..813f8172 100644
--- a/chalk/plugins/filters/sobelfilter/kis_sobel_filter.h
+++ b/chalk/plugins/filters/sobelfilter/kis_sobel_filter.h
@@ -64,7 +64,7 @@ public:
     virtual std::list<KisFilterConfiguration*> listOfExamplesConfiguration(KisPaintDeviceSP )
         { std::list<KisFilterConfiguration*> list; list.insert(list.begin(), new KisSobelFilterConfiguration(true,true,true,true)); return list; }
 public:
-    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+    virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
     virtual KisFilterConfiguration* configuration(TQWidget*);
     virtual KisFilterConfiguration * configuration() { return new KisSobelFilterConfiguration( true, true, true, true); };
 private:
diff --git a/chalk/plugins/filters/sobelfilter/kis_sobel_filter_plugin.cc b/chalk/plugins/filters/sobelfilter/kis_sobel_filter_plugin.cc
index e0ef8c80..3b21c547 100644
--- a/chalk/plugins/filters/sobelfilter/kis_sobel_filter_plugin.cc
+++ b/chalk/plugins/filters/sobelfilter/kis_sobel_filter_plugin.cc
@@ -26,13 +26,13 @@
 typedef KGenericFactory<KisSobelFilterPlugin> KisSobelFilterPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalksobelfilter, KisSobelFilterPluginFactory( "chalk" ) )
 
-KisSobelFilterPlugin::KisSobelFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &)
-    : KParts::Plugin(tqparent, name)
+KisSobelFilterPlugin::KisSobelFilterPlugin(TQObject *parent, const char *name, const TQStringList &)
+    : KParts::Plugin(parent, name)
 {
     setInstance(KisSobelFilterPluginFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisSobelFilter());
     }
 }
diff --git a/chalk/plugins/filters/sobelfilter/kis_sobel_filter_plugin.h b/chalk/plugins/filters/sobelfilter/kis_sobel_filter_plugin.h
index 87564cfe..a4cc323a 100644
--- a/chalk/plugins/filters/sobelfilter/kis_sobel_filter_plugin.h
+++ b/chalk/plugins/filters/sobelfilter/kis_sobel_filter_plugin.h
@@ -25,7 +25,7 @@
 class KisSobelFilterPlugin : public KParts::Plugin
 {
 public:
-    KisSobelFilterPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    KisSobelFilterPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~KisSobelFilterPlugin();
 };
 
diff --git a/chalk/plugins/filters/threadtest/threadtest.cc b/chalk/plugins/filters/threadtest/threadtest.cc
index f96a1616..1274c55f 100644
--- a/chalk/plugins/filters/threadtest/threadtest.cc
+++ b/chalk/plugins/filters/threadtest/threadtest.cc
@@ -47,13 +47,13 @@
 typedef KGenericFactory<ChalkThreadTest> ChalkThreadTestFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkthreadtest, ChalkThreadTestFactory( "chalk" ) )
 
-ChalkThreadTest::ChalkThreadTest(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkThreadTest::ChalkThreadTest(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkThreadTestFactory::instance());
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * r = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * r = dynamic_cast<KisFilterRegistry *>(parent);
         r->add(new KisFilterInvert());
     }
 }
diff --git a/chalk/plugins/filters/threadtest/threadtest.h b/chalk/plugins/filters/threadtest/threadtest.h
index 26c61a58..d7ebae7f 100644
--- a/chalk/plugins/filters/threadtest/threadtest.h
+++ b/chalk/plugins/filters/threadtest/threadtest.h
@@ -27,7 +27,7 @@
 class ChalkThreadTest : public KParts::Plugin
 {
 public:
-    ChalkThreadTest(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkThreadTest(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkThreadTest();
 };
 
diff --git a/chalk/plugins/filters/unsharp/kis_unsharp_filter.cc b/chalk/plugins/filters/unsharp/kis_unsharp_filter.cc
index d9539920..845262b1 100644
--- a/chalk/plugins/filters/unsharp/kis_unsharp_filter.cc
+++ b/chalk/plugins/filters/unsharp/kis_unsharp_filter.cc
@@ -55,9 +55,9 @@ KisUnsharpFilter::KisUnsharpFilter() : KisFilter(id(), "enhance", i18n("&Unsharp
 {
 }
 
-KisFilterConfigWidget * KisUnsharpFilter::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP )
+KisFilterConfigWidget * KisUnsharpFilter::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP )
 {
-    return new KisWdgUnsharp(this, tqparent, "configuration of color to alpha");
+    return new KisWdgUnsharp(this, parent, "configuration of color to alpha");
 }
 
 KisFilterConfiguration* KisUnsharpFilter::configuration(TQWidget* w)
@@ -92,10 +92,10 @@ void KisUnsharpFilter::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFi
     kdDebug() << " brush size = " << size << " " << halfSize << endl;
     KisAutobrushShape* kas = new KisAutobrushCircleShape(size, size , halfSize, halfSize);
     
-    TQImage tqmask;
-    kas->createBrush(&tqmask);
+    TQImage mask;
+    kas->createBrush(&mask);
     
-    KisKernelSP kernel = kernelFromTQImage(tqmask); // TODO: for 1.6 reuse the chalk's core function for creating kernel : KisKernel::fromTQImage
+    KisKernelSP kernel = kernelFromTQImage(mask); // TODO: for 1.6 reuse the chalk's core function for creating kernel : KisKernel::fromTQImage
     
     KisPaintDeviceSP interm = new KisPaintDevice(*src);
     KisColorSpace * cs = src->colorSpace();
diff --git a/chalk/plugins/filters/unsharp/kis_unsharp_filter.h b/chalk/plugins/filters/unsharp/kis_unsharp_filter.h
index 0f25f318..9b92e009 100644
--- a/chalk/plugins/filters/unsharp/kis_unsharp_filter.h
+++ b/chalk/plugins/filters/unsharp/kis_unsharp_filter.h
@@ -33,14 +33,14 @@ class KisUnsharpFilter : public KisFilter
         KisUnsharpFilter();
     public:
         virtual void process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration*, const TQRect&);
-        static inline KisID id() { return KisID("unsharptqmask", i18n("Unsharp Mask")); };
+        static inline KisID id() { return KisID("unsharpmask", i18n("Unsharp Mask")); };
         virtual bool supportsPainting() { return true; }
         virtual bool supportsPreview() { return true; }
         virtual bool supportsIncrementalPainting() { return false; }
         virtual bool supportsAdjustmentLayers() { return false; }
         virtual ColorSpaceIndependence colorSpaceIndependence() { return FULLY_INDEPENDENT; };
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };
 
diff --git a/chalk/plugins/filters/unsharp/kis_wdg_unsharp.cc b/chalk/plugins/filters/unsharp/kis_wdg_unsharp.cc
index 4a59a224..627d105c 100644
--- a/chalk/plugins/filters/unsharp/kis_wdg_unsharp.cc
+++ b/chalk/plugins/filters/unsharp/kis_wdg_unsharp.cc
@@ -30,7 +30,7 @@
 
 #include "wdgunsharp.h"
 
-KisWdgUnsharp::KisWdgUnsharp( KisFilter* , TQWidget * tqparent, const char * name) : KisFilterConfigWidget ( tqparent, name )
+KisWdgUnsharp::KisWdgUnsharp( KisFilter* , TQWidget * parent, const char * name) : KisFilterConfigWidget ( parent, name )
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 1, 1);
     m_widget = new WdgUnsharp(this);
diff --git a/chalk/plugins/filters/unsharp/kis_wdg_unsharp.h b/chalk/plugins/filters/unsharp/kis_wdg_unsharp.h
index 52ffb584..3b46ff1a 100644
--- a/chalk/plugins/filters/unsharp/kis_wdg_unsharp.h
+++ b/chalk/plugins/filters/unsharp/kis_wdg_unsharp.h
@@ -35,7 +35,7 @@ class KisWdgUnsharp : public KisFilterConfigWidget
     Q_OBJECT
   TQ_OBJECT
     public:
-        KisWdgUnsharp( KisFilter* nfilter, TQWidget * tqparent, const char * name);
+        KisWdgUnsharp( KisFilter* nfilter, TQWidget * parent, const char * name);
         inline WdgUnsharp* widget() { return m_widget; };
         virtual void setConfiguration(KisFilterConfiguration*);
     private:
diff --git a/chalk/plugins/filters/unsharp/unsharp.cc b/chalk/plugins/filters/unsharp/unsharp.cc
index 60516f42..3d90d49e 100644
--- a/chalk/plugins/filters/unsharp/unsharp.cc
+++ b/chalk/plugins/filters/unsharp/unsharp.cc
@@ -27,8 +27,8 @@
 typedef KGenericFactory<UnsharpPlugin> UnsharpPluginFactory;
 K_EXPORT_COMPONENT_FACTORY( chalkunsharpfilter, UnsharpPluginFactory( "chalk" ) )
 
-UnsharpPlugin::UnsharpPlugin(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+UnsharpPlugin::UnsharpPlugin(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(UnsharpPluginFactory::instance());
 
@@ -36,11 +36,11 @@ UnsharpPlugin::UnsharpPlugin(TQObject *tqparent, const char *name, const TQStrin
     kdDebug(41006) << "Extensions Image enhancement Filters plugin. Class: "
           << className()
           << ", Parent: "
-          << tqparent -> className()
+          << parent -> className()
           << "\n";
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisUnsharpFilter());
     }
 }
diff --git a/chalk/plugins/filters/unsharp/unsharp.h b/chalk/plugins/filters/unsharp/unsharp.h
index 59a92694..5717cccc 100644
--- a/chalk/plugins/filters/unsharp/unsharp.h
+++ b/chalk/plugins/filters/unsharp/unsharp.h
@@ -30,7 +30,7 @@
 class UnsharpPlugin : public KParts::Plugin
 {
 public:
-    UnsharpPlugin(TQObject *tqparent, const char *name, const TQStringList &);
+    UnsharpPlugin(TQObject *parent, const char *name, const TQStringList &);
     virtual ~UnsharpPlugin();
 };
 
diff --git a/chalk/plugins/filters/wavefilter/kis_wdg_wave.cpp b/chalk/plugins/filters/wavefilter/kis_wdg_wave.cpp
index 374fc6c8..e7537c27 100644
--- a/chalk/plugins/filters/wavefilter/kis_wdg_wave.cpp
+++ b/chalk/plugins/filters/wavefilter/kis_wdg_wave.cpp
@@ -27,8 +27,8 @@
 
 #include "wdgwaveoptions.h"
 
-KisWdgWave::KisWdgWave(KisFilter* /*nfilter*/, TQWidget* tqparent, const char* name)
-    : KisFilterConfigWidget(tqparent,name)
+KisWdgWave::KisWdgWave(KisFilter* /*nfilter*/, TQWidget* parent, const char* name)
+    : KisFilterConfigWidget(parent,name)
 {
     TQGridLayout *widgetLayout = new TQGridLayout(this, 1, 1);
     m_widget = new WdgWaveOptions(this);
diff --git a/chalk/plugins/filters/wavefilter/kis_wdg_wave.h b/chalk/plugins/filters/wavefilter/kis_wdg_wave.h
index 6f9b0744..71732bf5 100644
--- a/chalk/plugins/filters/wavefilter/kis_wdg_wave.h
+++ b/chalk/plugins/filters/wavefilter/kis_wdg_wave.h
@@ -31,7 +31,7 @@ class KisWdgWave : public KisFilterConfigWidget
     Q_OBJECT
   TQ_OBJECT
     public:
-        KisWdgWave(KisFilter* nfilter, TQWidget* tqparent = 0, const char* name = 0);
+        KisWdgWave(KisFilter* nfilter, TQWidget* parent = 0, const char* name = 0);
         ~KisWdgWave();
     public:
         inline WdgWaveOptions* widget() { return m_widget; };
diff --git a/chalk/plugins/filters/wavefilter/wavefilter.cc b/chalk/plugins/filters/wavefilter/wavefilter.cc
index 1d78bafc..ddcfc4bd 100644
--- a/chalk/plugins/filters/wavefilter/wavefilter.cc
+++ b/chalk/plugins/filters/wavefilter/wavefilter.cc
@@ -83,14 +83,14 @@ class KisTriangleWaveCurve : public KisWaveCurve {
 
 
 
-ChalkWaveFilter::ChalkWaveFilter(TQObject *tqparent, const char *name, const TQStringList &)
-        : KParts::Plugin(tqparent, name)
+ChalkWaveFilter::ChalkWaveFilter(TQObject *parent, const char *name, const TQStringList &)
+        : KParts::Plugin(parent, name)
 {
     setInstance(ChalkWaveFilterFactory::instance());
 
 
-    if (tqparent->inherits("KisFilterRegistry")) {
-        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(tqparent);
+    if (parent->inherits("KisFilterRegistry")) {
+        KisFilterRegistry * manager = dynamic_cast<KisFilterRegistry *>(parent);
         manager->add(new KisFilterWave());
     }
 }
@@ -121,9 +121,9 @@ KisFilterConfiguration* KisFilterWave::configuration(TQWidget* w)
     return config;
 }
 
-KisFilterConfigWidget * KisFilterWave::createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP /*dev*/)
+KisFilterConfigWidget * KisFilterWave::createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP /*dev*/)
 {
-    return new KisWdgWave((KisFilter*)this, (TQWidget*)tqparent, i18n("Configuration of wave filter").ascii());
+    return new KisWdgWave((KisFilter*)this, (TQWidget*)parent, i18n("Configuration of wave filter").ascii());
 }
 
 void KisFilterWave::process(KisPaintDeviceSP src, KisPaintDeviceSP dst, KisFilterConfiguration* config, const TQRect& rect)
diff --git a/chalk/plugins/filters/wavefilter/wavefilter.h b/chalk/plugins/filters/wavefilter/wavefilter.h
index 3397ab0b..8493c4f8 100644
--- a/chalk/plugins/filters/wavefilter/wavefilter.h
+++ b/chalk/plugins/filters/wavefilter/wavefilter.h
@@ -29,7 +29,7 @@ class KisFilterConfigWidget;
 class ChalkWaveFilter : public KParts::Plugin
 {
 public:
-    ChalkWaveFilter(TQObject *tqparent, const char *name, const TQStringList &);
+    ChalkWaveFilter(TQObject *parent, const char *name, const TQStringList &);
     virtual ~ChalkWaveFilter();
 };
 
@@ -46,7 +46,7 @@ class KisFilterWave : public KisFilter
         virtual bool supportsIncrementalPainting() { return false; }
         virtual bool supportsAdjustmentLayers() { return false; }
     public:
-        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* tqparent, KisPaintDeviceSP dev);
+        virtual KisFilterConfigWidget * createConfigurationWidget(TQWidget* parent, KisPaintDeviceSP dev);
         virtual KisFilterConfiguration* configuration(TQWidget*);
 };