Remove the tq in front of these incorrectly TQt4-converted methods/data members:

tqrepaint[...]
tqinvalidate[...]
tqparent[...]
tqmask[...]
tqlayout[...]
tqalignment[...]


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

11 files changed, 169 insertions, 169 deletions

diff --git a/kig/misc/argsparser.cpp b/kig/misc/argsparser.cpp
index 9d722752..c2387970 100644
--- a/kig/misc/argsparser.cpp
+++ b/kig/misc/argsparser.cpp
@@ -152,15 +152,15 @@ ArgsParser ArgsParser::without( const ObjectImpType* type ) const
   return ArgsParser( ret );
 }
 
-ArgsParser::spec ArgsParser::findSpec( const ObjectImp* obj, const Args& tqparents ) const
+ArgsParser::spec ArgsParser::findSpec( const ObjectImp* obj, const Args& parents ) const
 {
   spec ret;
   ret.type = 0;
 
   std::vector<bool> found( margs.size(), false );
 
-  for ( Args::const_iterator o = tqparents.begin();
-        o != tqparents.end(); ++o )
+  for ( Args::const_iterator o = parents.begin();
+        o != parents.end(); ++o )
   {
     for ( uint i = 0; i < margs.size(); ++i )
     {
@@ -183,9 +183,9 @@ ArgsParser::spec ArgsParser::findSpec( const ObjectImp* obj, const Args& tqparen
 }
 
 const ObjectImpType* ArgsParser::impRequirement(
-  const ObjectImp* o, const Args& tqparents ) const
+  const ObjectImp* o, const Args& parents ) const
 {
-  spec s = findSpec( o, tqparents );
+  spec s = findSpec( o, parents );
   return s.type;
 }
 
@@ -233,9 +233,9 @@ ArgsParser::~ArgsParser()
 {
 }
 
-bool ArgsParser::isDefinedOnOrThrough( const ObjectImp* o, const Args& tqparents ) const
+bool ArgsParser::isDefinedOnOrThrough( const ObjectImp* o, const Args& parents ) const
 {
-  spec s = findSpec( o, tqparents );
+  spec s = findSpec( o, parents );
   return s.onOrThrough;
 }
 
diff --git a/kig/misc/argsparser.h b/kig/misc/argsparser.h
index a3aff562..001d9359 100644
--- a/kig/misc/argsparser.h
+++ b/kig/misc/argsparser.h
@@ -26,7 +26,7 @@ class ObjectImpType;
 
 /**
  * This class is meant to take care of checking the types of the
- * tqparents to ObjectCalcer's, and to put them in the correct order.
+ * parents to ObjectCalcer's, and to put them in the correct order.
  * An ObjectType should construct an ArgsParser with a specification
  * of the arguments it wants.  This specification is given as an array
  * of ArgsParser::spec structs.  This struct contains a pointer to an
@@ -117,7 +117,7 @@ private:
    */
   std::vector<spec> margs;
 
-  spec findSpec( const ObjectImp* o, const Args& tqparents ) const;
+  spec findSpec( const ObjectImp* o, const Args& parents ) const;
 public:
   ArgsParser( const struct spec* args, int n );
   ArgsParser( const std::vector<spec>& args );
@@ -137,7 +137,7 @@ public:
   int check( const std::vector<ObjectCalcer*>& os ) const;
   /**
    * returns the usetext for the argument that o would be used for,
-   * if sel were used as tqparents..
+   * if sel were used as parents..
    * \p o should be in \p sel ...
    */
   std::string usetext( const ObjectImp* o, const Args& sel ) const;
@@ -155,16 +155,16 @@ public:
 
   /**
    * returns the minimal ObjectImp ID that \p o needs to inherit in order
-   * to be useful..  \p o should be part of \p tqparents .
+   * to be useful..  \p o should be part of \p parents .
    */
-  const ObjectImpType* impRequirement( const ObjectImp* o, const Args& tqparents ) const;
+  const ObjectImpType* impRequirement( const ObjectImp* o, const Args& parents ) const;
 
   /**
-   * Supposing that \p tqparents would be given as tqparents, this function
+   * Supposing that \p parents would be given as parents, this function
    * returns whether the returned ObjectImp will be, by construction,
    * on \p o ( if \p o is a curve ), or through \p o ( if \p o is a point ).
    */
-  bool isDefinedOnOrThrough( const ObjectImp* o, const Args& tqparents ) const;
+  bool isDefinedOnOrThrough( const ObjectImp* o, const Args& parents ) const;
 
   // Checks the args according to this args specification.  If the
   // objects should never have occurred, then an assertion failure
diff --git a/kig/misc/calcpaths.cc b/kig/misc/calcpaths.cc
index 55787518..15dd9d98 100644
--- a/kig/misc/calcpaths.cc
+++ b/kig/misc/calcpaths.cc
@@ -124,7 +124,7 @@ std::vector<ObjectCalcer*> calcPath( const std::vector<ObjectCalcer*>& os )
   };
 
   // now we know that if all objects appear at least once after all of
-  // their tqparents.  So, we take all, and of every object, we remove
+  // their parents.  So, we take all, and of every object, we remove
   // every reference except the last one...
   std::vector<ObjectCalcer*> ret;
   ret.reserve( os.size() );
@@ -182,9 +182,9 @@ static void addNonCache( ObjectCalcer* o, std::vector<ObjectCalcer*>& ret )
       ret.push_back( o );
   else
   {
-    std::vector<ObjectCalcer*> tqparents = o->tqparents();
-    for ( uint i = 0; i < tqparents.size(); ++i )
-      addNonCache( tqparents[i], ret );
+    std::vector<ObjectCalcer*> parents = o->parents();
+    for ( uint i = 0; i < parents.size(); ++i )
+      addNonCache( parents[i], ret );
   };
 }
 
@@ -196,13 +196,13 @@ static bool visit( const ObjectCalcer* o, const std::vector<ObjectCalcer*>& from
   // but their direct tqchildren do ), then we add them to ret.
   if ( std::find( from.begin(), from.end(), o ) != from.end() ) return true;
 
-  std::vector<bool> deps( o->tqparents().size(), false );
+  std::vector<bool> deps( o->parents().size(), false );
   bool somedepend = false;
   bool alldepend = true;
-  std::vector<ObjectCalcer*> tqparents = o->tqparents();
-  for ( uint i = 0; i < tqparents.size(); ++i )
+  std::vector<ObjectCalcer*> parents = o->parents();
+  for ( uint i = 0; i < parents.size(); ++i )
   {
-    bool v = visit( tqparents[i], from, ret );
+    bool v = visit( parents[i], from, ret );
     somedepend |= v;
     alldepend &= v;
     deps[i] = v;
@@ -211,7 +211,7 @@ static bool visit( const ObjectCalcer* o, const std::vector<ObjectCalcer*>& from
   {
     for ( uint i = 0; i < deps.size(); ++i )
       if ( ! deps[i] )
-        addNonCache( tqparents[i], ret );
+        addNonCache( parents[i], ret );
   };
 
   return somedepend;
@@ -234,8 +234,8 @@ std::vector<ObjectCalcer*> getAllParents( const std::vector<ObjectCalcer*>& objs
     std::set<ObjectCalcer*> next;
     for ( std::set<ObjectCalcer*>::const_iterator i = cur.begin(); i != cur.end(); ++i )
     {
-      std::vector<ObjectCalcer*> tqparents = (*i)->tqparents();
-      next.insert( tqparents.begin(), tqparents.end() );
+      std::vector<ObjectCalcer*> parents = (*i)->parents();
+      next.insert( parents.begin(), parents.end() );
     };
 
     ret.insert( next.begin(), next.end() );
@@ -253,16 +253,16 @@ std::vector<ObjectCalcer*> getAllParents( ObjectCalcer* obj )
 
 bool isChild( const ObjectCalcer* o, const std::vector<ObjectCalcer*>& os )
 {
-  std::vector<ObjectCalcer*> tqparents = o->tqparents();
-  std::set<ObjectCalcer*> cur( tqparents.begin(), tqparents.end() );
+  std::vector<ObjectCalcer*> parents = o->parents();
+  std::set<ObjectCalcer*> cur( parents.begin(), parents.end() );
   while ( ! cur.empty() )
   {
     std::set<ObjectCalcer*> next;
     for ( std::set<ObjectCalcer*>::const_iterator i = cur.begin(); i != cur.end(); ++i )
     {
       if ( std::find( os.begin(), os.end(), *i ) != os.end() ) return true;
-      std::vector<ObjectCalcer*> tqparents = (*i)->tqparents();
-      next.insert( tqparents.begin(), tqparents.end() );
+      std::vector<ObjectCalcer*> parents = (*i)->parents();
+      next.insert( parents.begin(), parents.end() );
     };
     cur = next;
   };
diff --git a/kig/misc/calcpaths.h b/kig/misc/calcpaths.h
index 3abf19a6..f81ddc09 100644
--- a/kig/misc/calcpaths.h
+++ b/kig/misc/calcpaths.h
@@ -23,7 +23,7 @@
 /**
  * This function sorts \p os such that they're in the right order for
  * calc()-ing.  This means that child objects must appear after their
- * tqparents ( for you graph people, this is just a topological sort.. )
+ * parents ( for you graph people, this is just a topological sort.. )
  */
 std::vector<ObjectCalcer*> calcPath( const std::vector<ObjectCalcer*>& os );
 
diff --git a/kig/misc/cubic-common.cc b/kig/misc/cubic-common.cc
index 6bdf3aca..029f1194 100644
--- a/kig/misc/cubic-common.cc
+++ b/kig/misc/cubic-common.cc
@@ -486,7 +486,7 @@ const CubicCartesianData calcCubicTransformation (
 //   assert (fabs(b[0][1][2] - b[1][2][0]) < 1e-8);  // test a couple of cases
 //   assert (fabs(b[0][1][1] - b[1][1][0]) < 1e-8);
 
-  // aptqparently, the above assertions are wrong ( due to rounding
+  // apparently, the above assertions are wrong ( due to rounding
   // errors, Maurizio and I hope :) ), so since the symmetry is not
   // present, we just take the sum of the parts of the matrix elements
   // that should be symmetric, instead of taking one of them, and
diff --git a/kig/misc/object_constructor.cc b/kig/misc/object_constructor.cc
index a5802d45..5522a598 100644
--- a/kig/misc/object_constructor.cc
+++ b/kig/misc/object_constructor.cc
@@ -124,12 +124,12 @@ SimpleObjectTypeConstructor::~SimpleObjectTypeConstructor()
 {
 }
 
-void SimpleObjectTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+void SimpleObjectTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                                               const KigDocument& doc ) const
 {
   Args args;
   using namespace std;
-  transform( tqparents.begin(), tqparents.end(),
+  transform( parents.begin(), parents.end(),
              back_inserter( args ), mem_fun( &ObjectCalcer::imp ) );
   ObjectImp* data = mtype->calc( args, doc );
   drawer.draw( *data, p, true );
@@ -178,12 +178,12 @@ MultiObjectTypeConstructor::~MultiObjectTypeConstructor()
 {
 }
 
-void MultiObjectTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+void MultiObjectTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                                              const KigDocument& doc ) const
 {
   Args args;
   using namespace std;
-  transform( tqparents.begin(), tqparents.end(),
+  transform( parents.begin(), parents.end(),
              back_inserter( args ), mem_fun( &ObjectCalcer::imp ) );
 
   for ( vector<int>::const_iterator i = mparams.begin(); i != mparams.end(); ++i )
@@ -551,26 +551,26 @@ PropertyObjectConstructor::~PropertyObjectConstructor()
 }
 
 void PropertyObjectConstructor::drawprelim(
-  const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
   const KigDocument& d ) const
 {
-  int index = tqparents[0]->imp()->propertiesInternalNames().tqfindIndex( mpropinternalname );
+  int index = parents[0]->imp()->propertiesInternalNames().tqfindIndex( mpropinternalname );
   assert ( index != -1 );
-  ObjectImp* imp = tqparents[0]->imp()->property( index, d );
+  ObjectImp* imp = parents[0]->imp()->property( index, d );
   drawer.draw( *imp, p, true );
   delete imp;
 }
 
 std::vector<ObjectHolder*> PropertyObjectConstructor::build(
-  const std::vector<ObjectCalcer*>& tqparents, KigDocument&,
+  const std::vector<ObjectCalcer*>& parents, KigDocument&,
   KigWidget& ) const
 {
-  int index = tqparents[0]->imp()->propertiesInternalNames().tqfindIndex( mpropinternalname );
+  int index = parents[0]->imp()->propertiesInternalNames().tqfindIndex( mpropinternalname );
   assert( index != -1 );
   std::vector<ObjectHolder*> ret;
   ret.push_back(
     new ObjectHolder(
-      new ObjectPropertyCalcer( tqparents[0], index ) ) );
+      new ObjectPropertyCalcer( parents[0], index ) ) );
   return ret;
 }
 
diff --git a/kig/misc/object_constructor.h b/kig/misc/object_constructor.h
index 9233426f..9b03ece0 100644
--- a/kig/misc/object_constructor.h
+++ b/kig/misc/object_constructor.h
@@ -165,7 +165,7 @@ public:
                      const KigDocument& d, const KigWidget& v
     ) const;
 
-  virtual void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  virtual void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                            const KigDocument& ) const = 0;
 
   TQString useText( const ObjectCalcer& o, const std::vector<ObjectCalcer*>& sel,
@@ -196,7 +196,7 @@ public:
 
   ~SimpleObjectTypeConstructor();
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                    const KigDocument& ) const;
 
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os,
@@ -225,7 +225,7 @@ public:
 
   ~PropertyObjectConstructor();
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                    const KigDocument& ) const;
 
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os,
@@ -265,7 +265,7 @@ public:
     int a, int b, int c = -999, int d = -999 );
   ~MultiObjectTypeConstructor();
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                    const KigDocument& ) const;
 
   std::vector<ObjectHolder*> build(
diff --git a/kig/misc/object_hierarchy.cc b/kig/misc/object_hierarchy.cc
index 7a977e63..264f7e8c 100644
--- a/kig/misc/object_hierarchy.cc
+++ b/kig/misc/object_hierarchy.cc
@@ -47,14 +47,14 @@ public:
   // on the given objects.  The dependsstack contains a set of
   // booleans telling which parts of the hierarchy certainly depend on
   // the given objects.  In this function, the node should check
-  // whether any of its tqparents have true set, and if so, set its own
+  // whether any of its parents have true set, and if so, set its own
   // value to true.
   virtual void checkDependsOnGiven( std::vector<bool>& dependsstack, int loc ) const = 0;
   // this function is used to check whether the given objects are all
   // used by one or more of the final objects.  The usedstack tqcontains
   // a set of booleans telling which parts of the hierarchy are
   // certainly ancestors of the final objects.  In this function, the
-  // node should set all of its tqparents' booleans to true.
+  // node should set all of its parents' booleans to true.
   virtual void checkArgumentsUsed( std::vector<bool>& usedstack ) const = 0;
 };
 
@@ -118,15 +118,15 @@ class ApplyTypeNode
   : public ObjectHierarchy::Node
 {
   const ObjectType* mtype;
-  std::vector<int> mtqparents;
+  std::vector<int> mparents;
 public:
-  ApplyTypeNode( const ObjectType* type, const std::vector<int>& tqparents )
-    : mtype( type ), mtqparents( tqparents ) {}
+  ApplyTypeNode( const ObjectType* type, const std::vector<int>& parents )
+    : mtype( type ), mparents( parents ) {}
   ~ApplyTypeNode();
   Node* copy() const;
 
   const ObjectType* type() const { return mtype; }
-  const std::vector<int>& tqparents() const { return mtqparents; }
+  const std::vector<int>& parents() const { return mparents; }
 
   int id() const;
   void apply( std::vector<const ObjectImp*>& stack,
@@ -141,17 +141,17 @@ int ApplyTypeNode::id() const { return ID_ApplyType; }
 
 void ApplyTypeNode::checkArgumentsUsed( std::vector<bool>& usedstack ) const
 {
-  for ( uint i = 0; i < mtqparents.size(); ++i )
+  for ( uint i = 0; i < mparents.size(); ++i )
   {
-    usedstack[mtqparents[i]] = true;
+    usedstack[mparents[i]] = true;
   }
 }
 
 void ApplyTypeNode::checkDependsOnGiven( std::vector<bool>& dependsstack, int loc ) const
 {
   bool result = false;
-  for ( uint i = 0; i < mtqparents.size(); ++i )
-    if ( dependsstack[mtqparents[i]] == true ) result = true;
+  for ( uint i = 0; i < mparents.size(); ++i )
+    if ( dependsstack[mparents[i]] == true ) result = true;
   dependsstack[loc] = result;
 }
 
@@ -161,23 +161,23 @@ ApplyTypeNode::~ApplyTypeNode()
 
 ObjectHierarchy::Node* ApplyTypeNode::copy() const
 {
-  return new ApplyTypeNode( mtype, mtqparents );
+  return new ApplyTypeNode( mtype, mparents );
 }
 
 void ApplyTypeNode::apply( std::vector<ObjectCalcer*>& stack, int loc ) const
 {
-  std::vector<ObjectCalcer*> tqparents;
-  for ( uint i = 0; i < mtqparents.size(); ++i )
-    tqparents.push_back( stack[ mtqparents[i] ] );
-  stack[loc] = new ObjectTypeCalcer( mtype, tqparents );
+  std::vector<ObjectCalcer*> parents;
+  for ( uint i = 0; i < mparents.size(); ++i )
+    parents.push_back( stack[ mparents[i] ] );
+  stack[loc] = new ObjectTypeCalcer( mtype, parents );
 }
 
 void ApplyTypeNode::apply( std::vector<const ObjectImp*>& stack,
                            int loc, const KigDocument& doc ) const
 {
   Args args;
-  for ( uint i = 0; i < mtqparents.size(); ++i )
-    args.push_back( stack[mtqparents[i]] );
+  for ( uint i = 0; i < mparents.size(); ++i )
+    args.push_back( stack[mparents[i]] );
   args = mtype->sortArgs( args );
   stack[loc] = mtype->calc( args, doc );
 }
@@ -297,23 +297,23 @@ int ObjectHierarchy::visit( const ObjectCalcer* o, std::map<const ObjectCalcer*,
       // because that's where we expect it..  We therefore copy it
       // there using CopyObjectType..
       int ret = mnumberofargs + mnodes.size();
-      std::vector<int> tqparents;
-      tqparents.push_back( smi->second );
-      mnodes.push_back( new ApplyTypeNode( CopyObjectType::instance(), tqparents ) );
+      std::vector<int> parents;
+      parents.push_back( smi->second );
+      mnodes.push_back( new ApplyTypeNode( CopyObjectType::instance(), parents ) );
       return ret;
     }
     else return smi->second;
   }
 
-  std::vector<ObjectCalcer*> p( o->tqparents() );
+  std::vector<ObjectCalcer*> p( o->parents() );
   // we check if o descends from the given objects..
   bool descendsfromgiven = false;
-  std::vector<int> tqparents;
-  tqparents.resize( p.size(), -1 );
+  std::vector<int> parents;
+  parents.resize( p.size(), -1 );
   for ( uint i = 0; i < p.size(); ++i )
   {
     int v = visit( p[i], seenmap, false );
-    tqparents[i] = v;
+    parents[i] = v;
     descendsfromgiven |= (v != -1);
   };
 
@@ -335,7 +335,7 @@ int ObjectHierarchy::visit( const ObjectCalcer* o, std::map<const ObjectCalcer*,
       return -1;
   };
 
-  return storeObject( o, p, tqparents, seenmap );
+  return storeObject( o, p, parents, seenmap );
 }
 
 ObjectHierarchy::~ObjectHierarchy()
@@ -385,9 +385,9 @@ void ObjectHierarchy::init( const std::vector<ObjectCalcer*>& from, const std::v
     seenmap[from[i]] = i;
   for ( std::vector<ObjectCalcer*>::const_iterator i = to.begin(); i != to.end(); ++i )
   {
-    std::vector<ObjectCalcer*> tqparents = (*i)->tqparents();
-    for ( std::vector<ObjectCalcer*>::const_iterator j = tqparents.begin();
-          j != tqparents.end(); ++j )
+    std::vector<ObjectCalcer*> parents = (*i)->parents();
+    for ( std::vector<ObjectCalcer*>::const_iterator j = parents.begin();
+          j != parents.end(); ++j )
       visit( *j, seenmap, true );
   }
   for ( std::vector<ObjectCalcer*>::const_iterator i = to.begin(); i != to.end(); ++i )
@@ -438,9 +438,9 @@ void ObjectHierarchy::serialize( TQDomElement& tqparent, TQDomDocument& doc ) co
       const ApplyTypeNode* node = static_cast<const ApplyTypeNode*>( mnodes[i] );
       e.setAttribute( "action", "calc" );
       e.setAttribute( "type", TQString::tqfromLatin1( node->type()->fullName() ) );
-      for ( uint i = 0; i < node->tqparents().size(); ++i )
+      for ( uint i = 0; i < node->parents().size(); ++i )
       {
-        int tqparent = node->tqparents()[i] + 1;
+        int tqparent = node->parents()[i] + 1;
         TQDomElement arge = doc.createElement( "arg" );
         arge.appendChild( doc.createTextNode( TQString::number( tqparent ) ) );
         e.appendChild( arge );
@@ -548,7 +548,7 @@ ObjectHierarchy* ObjectHierarchy::buildSafeObjectHierarchy( const TQDomElement&
         return 0;
       }
 
-      std::vector<int> tqparents;
+      std::vector<int> parents;
       for ( TQDomNode p = e.firstChild(); !p.isNull(); p = p.nextSibling() )
       {
         TQDomElement q = p.toElement();
@@ -556,9 +556,9 @@ ObjectHierarchy* ObjectHierarchy::buildSafeObjectHierarchy( const TQDomElement&
         if ( q.tagName() != "arg" ) KIG_GENERIC_PARSE_ERROR;
         int pid = q.text().toInt(&ok );
         if ( !ok ) KIG_GENERIC_PARSE_ERROR;
-        tqparents.push_back( pid - 1 );
+        parents.push_back( pid - 1 );
       };
-      newnode = new ApplyTypeNode( type, tqparents );
+      newnode = new ApplyTypeNode( type, parents );
     }
     else if ( tmp == "fetch-property" )
     {
@@ -640,11 +640,11 @@ ObjectHierarchy ObjectHierarchy::transformFinalObject( const Transformation& t )
   ObjectHierarchy ret( *this );
   ret.mnodes.push_back( new PushStackNode( new TransformationImp( t ) ) );
 
-  std::vector<int> tqparents;
-  tqparents.push_back( ret.mnodes.size() - 1);
-  tqparents.push_back( ret.mnodes.size() );
+  std::vector<int> parents;
+  parents.push_back( ret.mnodes.size() - 1);
+  parents.push_back( ret.mnodes.size() );
   const ObjectType* type = ApplyTransformationObjectType::instance();
-  ret.mnodes.push_back( new ApplyTypeNode( type, tqparents ) );
+  ret.mnodes.push_back( new ApplyTypeNode( type, parents ) );
   return ret;
 }
 
@@ -696,7 +696,7 @@ const ObjectImpType* lowermost( const ObjectImpType* a, const ObjectImpType* b )
 // this function is part of the visit procedure really.  It is
 // factored out, because it recurses for cache ObjectImp's.  What this
 // does is, it makes sure that object o is calcable, by putting
-// appropriate Node's in mnodes..  po is o->tqparents() and pl tqcontains
+// appropriate Node's in mnodes..  po is o->parents() and pl tqcontains
 // the location of objects that are already in mnodes and -1
 // otherwise..  -1 means we have to store their ObjectImp, unless
 // they're cache ObjectImp's etc.
@@ -723,8 +723,8 @@ int ObjectHierarchy::storeObject( const ObjectCalcer* o, const std::vector<Objec
     }
     else if ( (uint) pl[i] < mnumberofargs )
     {
-      ObjectCalcer* tqparent = o->tqparents()[i];
-      std::vector<ObjectCalcer*> opl = o->tqparents();
+      ObjectCalcer* tqparent = o->parents()[i];
+      std::vector<ObjectCalcer*> opl = o->parents();
 
       margrequirements[pl[i]] =
         lowermost( margrequirements[pl[i]],
diff --git a/kig/misc/object_hierarchy.h b/kig/misc/object_hierarchy.h
index cda2615f..35e7cbef 100644
--- a/kig/misc/object_hierarchy.h
+++ b/kig/misc/object_hierarchy.h
@@ -88,7 +88,7 @@ public:
    * build a set of objects that interdepend according to this
    * ObjectHierarchy..  Only the result objects are returned.  Helper
    * objects that connect the given objects with the returned objects,
-   * can only be found by following the returned objects' tqparents()
+   * can only be found by following the returned objects' parents()
    * methods..
    */
   std::vector<ObjectCalcer*> buildObjects( const std::vector<ObjectCalcer*>& os, const KigDocument& ) const;
diff --git a/kig/misc/special_constructors.cc b/kig/misc/special_constructors.cc
index ccb92ac6..0806f09b 100644
--- a/kig/misc/special_constructors.cc
+++ b/kig/misc/special_constructors.cc
@@ -68,7 +68,7 @@ public:
   ConicConicIntersectionConstructor();
   ~ConicConicIntersectionConstructor();
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                    const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d, KigWidget& w ) const;
   void plug( KigPart* doc, KigGUIAction* kact );
@@ -109,13 +109,13 @@ ConicRadicalConstructor::~ConicRadicalConstructor()
 }
 
 void ConicRadicalConstructor::drawprelim(
-  const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents, const KigDocument& doc ) const
+  const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents, const KigDocument& doc ) const
 {
-  if ( tqparents.size() == 2 && tqparents[0]->imp()->inherits( ConicImp::stype() ) &&
-       tqparents[1]->imp()->inherits( ConicImp::stype() ) )
+  if ( parents.size() == 2 && parents[0]->imp()->inherits( ConicImp::stype() ) &&
+       parents[1]->imp()->inherits( ConicImp::stype() ) )
   {
     Args args;
-    std::transform( tqparents.begin(), tqparents.end(),
+    std::transform( parents.begin(), parents.end(),
                     std::back_inserter( args ), std::mem_fun( &ObjectCalcer::imp ) );
     for ( int i = -1; i < 2; i += 2 )
     {
@@ -170,27 +170,27 @@ LocusConstructor::~LocusConstructor()
 {
 }
 
-void LocusConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+void LocusConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                                    const KigDocument& ) const
 {
   // this function is rather ugly, but it is necessary to do it this
   // way in order to play nice with Kig's design..
 
-  if ( tqparents.size() != 2 ) return;
-  const ObjectTypeCalcer* constrained = dynamic_cast<ObjectTypeCalcer*>( tqparents.front() );
-  const ObjectCalcer* moving = tqparents.back();
+  if ( parents.size() != 2 ) return;
+  const ObjectTypeCalcer* constrained = dynamic_cast<ObjectTypeCalcer*>( parents.front() );
+  const ObjectCalcer* moving = parents.back();
   if ( ! constrained || ! constrained->type()->inherits( ObjectType::ID_ConstrainedPointType ) )
   {
     // moving is in fact the constrained point.. swap them..
-    moving = tqparents.front();
-    constrained = dynamic_cast<const ObjectTypeCalcer*>( tqparents.back() );
+    moving = parents.front();
+    constrained = dynamic_cast<const ObjectTypeCalcer*>( parents.back() );
     assert( constrained );
   };
   assert( constrained->type()->inherits( ObjectType::ID_ConstrainedPointType ) );
 
-  const ObjectImp* oimp = constrained->tqparents().back()->imp();
+  const ObjectImp* oimp = constrained->parents().back()->imp();
   if( !oimp->inherits( CurveImp::stype() ) )
-    oimp = constrained->tqparents().front()->imp();
+    oimp = constrained->parents().front()->imp();
   assert( oimp->inherits( CurveImp::stype() ) );
   const CurveImp* cimp = static_cast<const CurveImp*>( oimp );
 
@@ -222,18 +222,18 @@ const int LocusConstructor::wantArgs(
   return ArgsParser::Invalid;
 }
 
-std::vector<ObjectHolder*> LocusConstructor::build( const std::vector<ObjectCalcer*>& tqparents, KigDocument&, KigWidget& ) const
+std::vector<ObjectHolder*> LocusConstructor::build( const std::vector<ObjectCalcer*>& parents, KigDocument&, KigWidget& ) const
 {
   std::vector<ObjectHolder*> ret;
-  assert( tqparents.size() == 2 );
+  assert( parents.size() == 2 );
 
-  ObjectTypeCalcer* constrained = dynamic_cast<ObjectTypeCalcer*>( tqparents.front() );
-  ObjectCalcer* moving = tqparents.back();
+  ObjectTypeCalcer* constrained = dynamic_cast<ObjectTypeCalcer*>( parents.front() );
+  ObjectCalcer* moving = parents.back();
   if ( ! constrained || ! constrained->type()->inherits( ObjectType::ID_ConstrainedPointType ) )
   {
     // moving is in fact the constrained point.. swap them..
-    moving = tqparents.front();
-    constrained = dynamic_cast<ObjectTypeCalcer*>( tqparents.back() );
+    moving = parents.front();
+    constrained = dynamic_cast<ObjectTypeCalcer*>( parents.back() );
     assert( constrained );
   };
   assert( constrained->type()->inherits( ObjectType::ID_ConstrainedPointType ) );
@@ -374,21 +374,21 @@ TQString PolygonBNPTypeConstructor::selectStatement(
   return i18n("Select a point to be a vertex of the new polygon...");
 }
 
-void PolygonBNPTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+void PolygonBNPTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                                    const KigDocument& ) const
 {
-  if ( tqparents.size() < 2 ) return;
+  if ( parents.size() < 2 ) return;
 
   std::vector<Coordinate> points;
 
-  for ( uint i = 0; i < tqparents.size(); ++i )
+  for ( uint i = 0; i < parents.size(); ++i )
   {
     const Coordinate vertex =
-        static_cast<const PointImp*>( tqparents[i]->imp() )->coordinate();
+        static_cast<const PointImp*>( parents[i]->imp() )->coordinate();
     points.push_back( vertex );
   }
 
-  if ( tqparents.size() == 2 )
+  if ( parents.size() == 2 )
   {
     SegmentImp segment = SegmentImp( points[0], points[1] );
     drawer.draw( segment, p, true );
@@ -398,12 +398,12 @@ void PolygonBNPTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPaint
   }
 }
 
-std::vector<ObjectHolder*> PolygonBNPTypeConstructor::build( const std::vector<ObjectCalcer*>& tqparents, KigDocument&, KigWidget& ) const
+std::vector<ObjectHolder*> PolygonBNPTypeConstructor::build( const std::vector<ObjectCalcer*>& parents, KigDocument&, KigWidget& ) const
 {
-  uint count = tqparents.size() - 1;
+  uint count = parents.size() - 1;
   assert ( count >= 3 );
   std::vector<ObjectCalcer*> args;
-  for ( uint i = 0; i < count; ++i ) args.push_back( tqparents[i] );
+  for ( uint i = 0; i < count; ++i ) args.push_back( parents[i] );
   ObjectTypeCalcer* calcer = new ObjectTypeCalcer( mtype, args );
   ObjectHolder* h = new ObjectHolder( calcer );
   std::vector<ObjectHolder*> ret;
@@ -443,12 +443,12 @@ PolygonVertexTypeConstructor::~PolygonVertexTypeConstructor()
 {
 }
 
-void PolygonVertexTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+void PolygonVertexTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                                    const KigDocument& ) const
 {
-  if ( tqparents.size() != 1 ) return;
+  if ( parents.size() != 1 ) return;
 
-  const PolygonImp* polygon = dynamic_cast<const PolygonImp*>( tqparents.front()->imp() );
+  const PolygonImp* polygon = dynamic_cast<const PolygonImp*>( parents.front()->imp() );
   const std::vector<Coordinate> points = polygon->points();
 
   int sides = points.size();
@@ -459,11 +459,11 @@ void PolygonVertexTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPa
   }
 }
 
-std::vector<ObjectHolder*> PolygonVertexTypeConstructor::build( const std::vector<ObjectCalcer*>& tqparents, KigDocument&, KigWidget& ) const
+std::vector<ObjectHolder*> PolygonVertexTypeConstructor::build( const std::vector<ObjectCalcer*>& parents, KigDocument&, KigWidget& ) const
 {
   std::vector<ObjectHolder*> ret;
-  assert( tqparents.size() == 1 );
-  const PolygonImp* polygon = dynamic_cast<const PolygonImp*>( tqparents.front()->imp() );
+  assert( parents.size() == 1 );
+  const PolygonImp* polygon = dynamic_cast<const PolygonImp*>( parents.front()->imp() );
   const std::vector<Coordinate> points = polygon->points();
 
   int sides = points.size();
@@ -471,7 +471,7 @@ std::vector<ObjectHolder*> PolygonVertexTypeConstructor::build( const std::vecto
   for ( int i = 0; i < sides; ++i )
   {
     ObjectConstCalcer* d = new ObjectConstCalcer( new IntImp( i ) );
-    std::vector<ObjectCalcer*> args( tqparents );
+    std::vector<ObjectCalcer*> args( parents );
     args.push_back( d );
     ret.push_back( new ObjectHolder( new ObjectTypeCalcer( mtype, args ) ) );
   }
@@ -510,12 +510,12 @@ PolygonSideTypeConstructor::~PolygonSideTypeConstructor()
 {
 }
 
-void PolygonSideTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+void PolygonSideTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                                    const KigDocument& ) const
 {
-  if ( tqparents.size() != 1 ) return;
+  if ( parents.size() != 1 ) return;
 
-  const PolygonImp* polygon = dynamic_cast<const PolygonImp*>( tqparents.front()->imp() );
+  const PolygonImp* polygon = dynamic_cast<const PolygonImp*>( parents.front()->imp() );
   const std::vector<Coordinate> points = polygon->points();
 
   uint sides = points.size();
@@ -527,11 +527,11 @@ void PolygonSideTypeConstructor::drawprelim( const ObjectDrawer& drawer, KigPain
   }
 }
 
-std::vector<ObjectHolder*> PolygonSideTypeConstructor::build( const std::vector<ObjectCalcer*>& tqparents, KigDocument&, KigWidget& ) const
+std::vector<ObjectHolder*> PolygonSideTypeConstructor::build( const std::vector<ObjectCalcer*>& parents, KigDocument&, KigWidget& ) const
 {
   std::vector<ObjectHolder*> ret;
-  assert( tqparents.size() == 1 );
-  const PolygonImp* polygon = dynamic_cast<const PolygonImp*>( tqparents.front()->imp() );
+  assert( parents.size() == 1 );
+  const PolygonImp* polygon = dynamic_cast<const PolygonImp*>( parents.front()->imp() );
   const std::vector<Coordinate> points = polygon->points();
 
   uint sides = points.size();
@@ -539,7 +539,7 @@ std::vector<ObjectHolder*> PolygonSideTypeConstructor::build( const std::vector<
   for ( uint i = 0; i < sides; ++i )
   {
     ObjectConstCalcer* d = new ObjectConstCalcer( new IntImp( i ) );
-    std::vector<ObjectCalcer*> args( tqparents );
+    std::vector<ObjectCalcer*> args( parents );
     args.push_back( d );
     ret.push_back( new ObjectHolder( new ObjectTypeCalcer( mtype, args ) ) );
   }
@@ -700,17 +700,17 @@ void PolygonBCVConstructor::handlePrelim(
   delete_all( args.begin() + 2, args.end() );
 }
 
-std::vector<ObjectHolder*> PolygonBCVConstructor::build( const std::vector<ObjectCalcer*>& tqparents, KigDocument&, KigWidget& ) const
+std::vector<ObjectHolder*> PolygonBCVConstructor::build( const std::vector<ObjectCalcer*>& parents, KigDocument&, KigWidget& ) const
 {
-  assert ( tqparents.size() == 3 );
+  assert ( parents.size() == 3 );
   std::vector<ObjectCalcer*> args;
 
-  Coordinate c = static_cast<const PointImp*>( tqparents[0]->imp() )->coordinate();
-  Coordinate v = static_cast<const PointImp*>( tqparents[1]->imp() )->coordinate();
-  Coordinate cntrl = static_cast<const PointImp*>( tqparents[2]->imp() )->coordinate();
+  Coordinate c = static_cast<const PointImp*>( parents[0]->imp() )->coordinate();
+  Coordinate v = static_cast<const PointImp*>( parents[1]->imp() )->coordinate();
+  Coordinate cntrl = static_cast<const PointImp*>( parents[2]->imp() )->coordinate();
 
-  args.push_back( tqparents[0] );
-  args.push_back( tqparents[1] );
+  args.push_back( parents[0] );
+  args.push_back( parents[1] );
   int winding = 0;
   int nsides = computeNsides( c, v, cntrl, winding );
   ObjectConstCalcer* d = new ObjectConstCalcer( new IntImp( nsides ) );
@@ -789,20 +789,20 @@ TQString PolygonBCVConstructor::selectStatement(
   return "";
 }
 
-void PolygonBCVConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+void PolygonBCVConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                                    const KigDocument& doc ) const
 {
-  if ( tqparents.size() < 3 || tqparents.size() > 4 ) return;
+  if ( parents.size() < 3 || parents.size() > 4 ) return;
 
-  assert ( tqparents[0]->imp()->inherits( PointImp::stype() ) &&
-           tqparents[1]->imp()->inherits( PointImp::stype() ) &&
-           tqparents[2]->imp()->inherits( IntImp::stype() ) );
+  assert ( parents[0]->imp()->inherits( PointImp::stype() ) &&
+           parents[1]->imp()->inherits( PointImp::stype() ) &&
+           parents[2]->imp()->inherits( IntImp::stype() ) );
 
-  if ( tqparents.size() == 4 )
-    assert ( tqparents[3]->imp()->inherits( IntImp::stype() ) );
+  if ( parents.size() == 4 )
+    assert ( parents[3]->imp()->inherits( IntImp::stype() ) );
 
   Args args;
-  std::transform( tqparents.begin(), tqparents.end(),
+  std::transform( parents.begin(), parents.end(),
                std::back_inserter( args ), std::mem_fun( &ObjectCalcer::imp ) );
 
   ObjectImp* data = mtype->calc( args, doc );
@@ -878,16 +878,16 @@ ConicConicIntersectionConstructor::~ConicConicIntersectionConstructor()
 {
 }
 
-void ConicConicIntersectionConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+void ConicConicIntersectionConstructor::drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                                                     const KigDocument& ) const
 {
-  if ( tqparents.size() != 2 ) return;
-  assert ( tqparents[0]->imp()->inherits( ConicImp::stype() ) &&
-           tqparents[1]->imp()->inherits( ConicImp::stype() ) );
+  if ( parents.size() != 2 ) return;
+  assert ( parents[0]->imp()->inherits( ConicImp::stype() ) &&
+           parents[1]->imp()->inherits( ConicImp::stype() ) );
   const ConicCartesianData conica =
-    static_cast<const ConicImp*>( tqparents[0]->imp() )->cartesianData();
+    static_cast<const ConicImp*>( parents[0]->imp() )->cartesianData();
   const ConicCartesianData conicb =
-    static_cast<const ConicImp*>( tqparents[1]->imp() )->cartesianData();
+    static_cast<const ConicImp*>( parents[1]->imp() )->cartesianData();
   bool ok = true;
   for ( int wr = -1; wr < 2; wr += 2 )
   {
@@ -1190,12 +1190,12 @@ void MeasureTransportConstructor::handlePrelim(
 
 void MeasureTransportConstructor::drawprelim( const ObjectDrawer& drawer,
                          KigPainter& p,
-                         const std::vector<ObjectCalcer*>& tqparents,
+                         const std::vector<ObjectCalcer*>& parents,
                          const KigDocument& doc ) const
 {
   Args args;
   using namespace std;
-  transform( tqparents.begin(), tqparents.end(),
+  transform( parents.begin(), parents.end(),
              back_inserter( args ), mem_fun( &ObjectCalcer::imp ) );
   ObjectImp* data = mtype->calc( args, doc );
   drawer.draw( *data, p, true );
@@ -1236,13 +1236,13 @@ TQString MeasureTransportConstructor::selectStatement(
 }
 
 std::vector<ObjectHolder*> MeasureTransportConstructor::build(
-    const std::vector<ObjectCalcer*>& tqparents,
+    const std::vector<ObjectCalcer*>& parents,
     KigDocument&, KigWidget& ) const
 {
-  assert ( tqparents.size() == 3 );
+  assert ( parents.size() == 3 );
 //  std::vector<ObjectCalcer*> args;
-//  for ( uint i = 0; i < count; ++i ) args.push_back( tqparents[i] );
-  ObjectTypeCalcer* calcer = new ObjectTypeCalcer( mtype, tqparents );
+//  for ( uint i = 0; i < count; ++i ) args.push_back( parents[i] );
+  ObjectTypeCalcer* calcer = new ObjectTypeCalcer( mtype, parents );
   ObjectHolder* h = new ObjectHolder( calcer );
   std::vector<ObjectHolder*> ret;
   ret.push_back( h );
@@ -1386,15 +1386,15 @@ MidPointOfTwoPointsConstructor::~MidPointOfTwoPointsConstructor()
 }
 
 void MidPointOfTwoPointsConstructor::drawprelim(
-  const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
   const KigDocument& ) const
 {
-  if ( tqparents.size() != 2 ) return;
-  assert( tqparents[0]->imp()->inherits( PointImp::stype() ) );
-  assert( tqparents[1]->imp()->inherits( PointImp::stype() ) );
+  if ( parents.size() != 2 ) return;
+  assert( parents[0]->imp()->inherits( PointImp::stype() ) );
+  assert( parents[1]->imp()->inherits( PointImp::stype() ) );
   const Coordinate m =
-    ( static_cast<const PointImp*>( tqparents[0]->imp() )->coordinate() +
-      static_cast<const PointImp*>( tqparents[1]->imp() )->coordinate() ) / 2;
+    ( static_cast<const PointImp*>( parents[0]->imp() )->coordinate() +
+      static_cast<const PointImp*>( parents[1]->imp() )->coordinate() ) / 2;
   drawer.draw( PointImp( m ), p, true );
 }
 
diff --git a/kig/misc/special_constructors.h b/kig/misc/special_constructors.h
index 796c8cd0..5b80693c 100644
--- a/kig/misc/special_constructors.h
+++ b/kig/misc/special_constructors.h
@@ -29,7 +29,7 @@ public:
   PolygonVertexTypeConstructor();
   ~PolygonVertexTypeConstructor();
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents, const KigDocument& ) const;
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents, const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d, KigWidget& w ) const;
   void plug( KigPart* doc, KigGUIAction* kact );
   bool isTransform() const;
@@ -44,7 +44,7 @@ public:
   PolygonSideTypeConstructor();
   ~PolygonSideTypeConstructor();
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents, const KigDocument& ) const;
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents, const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d, KigWidget& w ) const;
   void plug( KigPart* doc, KigGUIAction* kact );
   bool isTransform() const;
@@ -83,7 +83,7 @@ public:
                              const KigWidget& v
     ) const;
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents, const KigDocument& ) const;
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents, const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d, KigWidget& w ) const;
   void plug( KigPart* doc, KigGUIAction* kact );
   bool isTransform() const;
@@ -121,7 +121,7 @@ public:
                              const KigDocument& d,
                              const KigWidget& v
     ) const;
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents, const KigDocument& ) const;
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents, const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d, KigWidget& w ) const;
   void plug( KigPart* doc, KigGUIAction* kact );
   bool isTransform() const;
@@ -163,7 +163,7 @@ public:
                              const KigWidget& v
     ) const;
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents, const KigDocument& ) const;
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents, const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d, KigWidget& w ) const;
   void plug( KigPart* doc, KigGUIAction* kact );
   bool isTransform() const;
@@ -179,7 +179,7 @@ public:
   ~ConicRadicalConstructor();
   TQString useText( const ObjectCalcer& o, const std::vector<ObjectCalcer*>& sel, const KigDocument& d,
                    const KigWidget& v ) const;
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents, const KigDocument& ) const;
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents, const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d, KigWidget& w ) const;
   void plug( KigPart* doc, KigGUIAction* kact );
 
@@ -205,7 +205,7 @@ public:
   TQString useText( const ObjectCalcer& o, const std::vector<ObjectCalcer*>& sel, const KigDocument& d,
                    const KigWidget& v ) const;
 
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents, const KigDocument& ) const;
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents, const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d, KigWidget& w ) const;
   void plug( KigPart* doc, KigGUIAction* kact );
 
@@ -259,7 +259,7 @@ class MidPointOfTwoPointsConstructor
 public:
   MidPointOfTwoPointsConstructor();
   ~MidPointOfTwoPointsConstructor();
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                    const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d,
                  KigWidget& w ) const;
@@ -275,7 +275,7 @@ public:
   TestConstructor( const ArgsParserObjectType* type, const char* descname,
     const char* desc, const char* iconfile );
   ~TestConstructor();
-  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& tqparents,
+  void drawprelim( const ObjectDrawer& drawer, KigPainter& p, const std::vector<ObjectCalcer*>& parents,
                    const KigDocument& ) const;
   std::vector<ObjectHolder*> build( const std::vector<ObjectCalcer*>& os, KigDocument& d,
                  KigWidget& w ) const;