TQt4 port kdeedu

This enables compilation under both Qt3 and Qt4


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

1 files changed, 53 insertions, 53 deletions

diff --git a/kig/objects/point_type.cc b/kig/objects/point_type.cc
index 2acd8479..74fc9d37 100644
--- a/kig/objects/point_type.cc
+++ b/kig/objects/point_type.cc
@@ -52,12 +52,12 @@ FixedPointType::~FixedPointType()
 {
 }
 
-ObjectImp* FixedPointType::calc( const Args& parents, const KigDocument& ) const
+ObjectImp* FixedPointType::calc( const Args& tqparents, const KigDocument& ) const
 {
-  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
+  if ( ! margsparser.checkArgs( tqparents ) ) return new InvalidImp;
 
-  double a = static_cast<const DoubleImp*>( parents[0] )->data();
-  double b = static_cast<const DoubleImp*>( parents[1] )->data();
+  double a = static_cast<const DoubleImp*>( tqparents[0] )->data();
+  double b = static_cast<const DoubleImp*>( tqparents[1] )->data();
 
   return new PointImp( Coordinate( a, b ) );
 }
@@ -80,14 +80,14 @@ RelativePointType::~RelativePointType()
 {
 }
 
-ObjectImp* RelativePointType::calc( const Args& parents, const KigDocument& ) const
+ObjectImp* RelativePointType::calc( const Args& tqparents, const KigDocument& ) const
 {
-  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
-  if ( ! parents[2]->attachPoint().valid() ) return new InvalidImp;
+  if ( ! margsparser.checkArgs( tqparents ) ) return new InvalidImp;
+  if ( ! tqparents[2]->attachPoint().valid() ) return new InvalidImp;
 
-  Coordinate reference = static_cast<const ObjectImp*>( parents[2] )->attachPoint();
-  double a = static_cast<const DoubleImp*>( parents[0] )->data();
-  double b = static_cast<const DoubleImp*>( parents[1] )->data();
+  Coordinate reference = static_cast<const ObjectImp*>( tqparents[2] )->attachPoint();
+  double a = static_cast<const DoubleImp*>( tqparents[0] )->data();
+  double b = static_cast<const DoubleImp*>( tqparents[1] )->data();
 
   return new PointImp( reference + Coordinate( a, b ) );
 }
@@ -109,12 +109,12 @@ const CursorPointType* CursorPointType::instance()
   return &t;
 }
 
-ObjectImp* CursorPointType::calc( const Args& parents, const KigDocument& ) const
+ObjectImp* CursorPointType::calc( const Args& tqparents, const KigDocument& ) const
 {
-  assert ( parents[0]->inherits( DoubleImp::stype() ) );
-  assert ( parents[1]->inherits( DoubleImp::stype() ) );
-  double a = static_cast<const DoubleImp*>( parents[0] )->data();
-  double b = static_cast<const DoubleImp*>( parents[1] )->data();
+  assert ( tqparents[0]->inherits( DoubleImp::stype() ) );
+  assert ( tqparents[1]->inherits( DoubleImp::stype() ) );
+  double a = static_cast<const DoubleImp*>( tqparents[0] )->data();
+  double b = static_cast<const DoubleImp*>( tqparents[1] )->data();
 
   return new BogusPointImp( Coordinate( a, b ) );
 }
@@ -124,12 +124,12 @@ const ObjectImpType* CursorPointType::resultId() const
   return BogusPointImp::stype();
 }
 
-ObjectImp* ConstrainedPointType::calc( const Args& parents, const KigDocument& doc ) const
+ObjectImp* ConstrainedPointType::calc( const Args& tqparents, const KigDocument& doc ) const
 {
-  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
+  if ( ! margsparser.checkArgs( tqparents ) ) return new InvalidImp;
 
-  double param = static_cast<const DoubleImp*>( parents[0] )->data();
-  const Coordinate nc = static_cast<const CurveImp*>( parents[1] )->getPoint( param, doc );
+  double param = static_cast<const DoubleImp*>( tqparents[0] )->data();
+  const Coordinate nc = static_cast<const CurveImp*>( tqparents[1] )->getPoint( param, doc );
   if ( nc.valid() ) return new PointImp( nc );
   else return new InvalidImp;
 }
@@ -155,7 +155,7 @@ void FixedPointType::move( ObjectTypeCalcer& ourobj, const Coordinate& to,
                            const KigDocument& ) const
 {
   // fetch the old coord..;
-  std::vector<ObjectCalcer*> pa = ourobj.parents();
+  std::vector<ObjectCalcer*> pa = ourobj.tqparents();
   assert( margsparser.checkArgs( pa ) );
   assert( dynamic_cast<ObjectConstCalcer*>( pa.front() ) );
   assert( dynamic_cast<ObjectConstCalcer*>( pa.back() ) );
@@ -173,7 +173,7 @@ void RelativePointType::move( ObjectTypeCalcer& ourobj, const Coordinate& to,
   // fetch the attach point..;
   // this routine is tightly paired with what moveReferencePoint returns!
   // right now moveReferencePoint always returns the origin
-  std::vector<ObjectCalcer*> pa = ourobj.parents();
+  std::vector<ObjectCalcer*> pa = ourobj.tqparents();
   assert( margsparser.checkArgs( pa ) );
   assert( dynamic_cast<ObjectConstCalcer*>( pa[0] ) );
   assert( dynamic_cast<ObjectConstCalcer*>( pa[1] ) );
@@ -192,7 +192,7 @@ void CursorPointType::move( ObjectTypeCalcer& ourobj, const Coordinate& to,
 {
   // fetch the old coord..;
 
-  std::vector<ObjectCalcer*> pa = ourobj.parents();
+  std::vector<ObjectCalcer*> pa = ourobj.tqparents();
   assert( pa.size() == 2 );
   assert( dynamic_cast<ObjectConstCalcer*>( pa.front() ) );
   assert( dynamic_cast<ObjectConstCalcer*>( pa.back() ) );
@@ -208,12 +208,12 @@ void ConstrainedPointType::move( ObjectTypeCalcer& ourobj, const Coordinate& to,
                                  const KigDocument& d ) const
 {
   // fetch the CurveImp..
-  std::vector<ObjectCalcer*> parents = ourobj.parents();
-  assert( margsparser.checkArgs( parents ) );
+  std::vector<ObjectCalcer*> tqparents = ourobj.tqparents();
+  assert( margsparser.checkArgs( tqparents ) );
 
-  assert( dynamic_cast<ObjectConstCalcer*>( parents[0] ) );
-  ObjectConstCalcer* paramo = static_cast<ObjectConstCalcer*>( parents[0] );
-  const CurveImp* ci = static_cast<const CurveImp*>( parents[1]->imp() );
+  assert( dynamic_cast<ObjectConstCalcer*>( tqparents[0] ) );
+  ObjectConstCalcer* paramo = static_cast<ObjectConstCalcer*>( tqparents[0] );
+  const CurveImp* ci = static_cast<const CurveImp*>( tqparents[1]->imp() );
 
   // fetch the new param..
   const double np = ci->getParam( to, d );
@@ -395,7 +395,7 @@ void FixedPointType::executeAction(
     Coordinate oldc = static_cast<const PointImp*>( o.imp() )->coordinate();
     KigInputDialog::getCoordinate(
       i18n( "Set Coordinate" ),
-      i18n( "Enter the new coordinate." ) + TQString::fromLatin1( "<br>" ) +
+      i18n( "Enter the new coordinate." ) + TQString::tqfromLatin1( "<br>" ) +
       d.document().coordinateSystem().coordinateFormatNoticeMarkup(),
       &w, &ok, d.document(), &oldc );
     if ( ! ok ) break;
@@ -427,11 +427,11 @@ void ConstrainedPointType::executeAction(
     break;
   case 0:
   {
-    std::vector<ObjectCalcer*> parents = o.parents();
-    assert( dynamic_cast<ObjectConstCalcer*>( parents[0] ) &&
-            parents[0]->imp()->inherits( DoubleImp::stype() ) );
+    std::vector<ObjectCalcer*> tqparents = o.tqparents();
+    assert( dynamic_cast<ObjectConstCalcer*>( tqparents[0] ) &&
+            tqparents[0]->imp()->inherits( DoubleImp::stype() ) );
 
-    ObjectConstCalcer* po = static_cast<ObjectConstCalcer*>( parents[0] );
+    ObjectConstCalcer* po = static_cast<ObjectConstCalcer*>( tqparents[0] );
     double oldp = static_cast<const DoubleImp*>( po->imp() )->data();
 
     bool ok = true;
@@ -440,7 +440,7 @@ void ConstrainedPointType::executeAction(
       oldp, &w, &ok, 0, 1, 4 );
     if ( ! ok ) return;
 
-    MonitorDataObjects mon( parents );
+    MonitorDataObjects mon( tqparents );
     po->setImp( new DoubleImp( newp ) );
     KigCommand* kc = new KigCommand( d, i18n( "Change Parameter of Constrained Point" ) );
     mon.finish( kc );
@@ -473,46 +473,46 @@ const Coordinate ConstrainedPointType::moveReferencePoint( const ObjectTypeCalce
 
 std::vector<ObjectCalcer*> FixedPointType::movableParents( const ObjectTypeCalcer& ourobj ) const
 {
-  return ourobj.parents();
+  return ourobj.tqparents();
 }
 
 std::vector<ObjectCalcer*> RelativePointType::movableParents( const ObjectTypeCalcer& ourobj ) const
 {
   std::vector<ObjectCalcer*> ret;
-  ret.push_back( ourobj.parents()[0] );
-  ret.push_back( ourobj.parents()[1] );
+  ret.push_back( ourobj.tqparents()[0] );
+  ret.push_back( ourobj.tqparents()[1] );
   return ret;
 }
 
 std::vector<ObjectCalcer*> ConstrainedPointType::movableParents( const ObjectTypeCalcer& ourobj ) const
 {
   std::vector<ObjectCalcer*> ret;
-  ret.push_back( ourobj.parents()[0] );
+  ret.push_back( ourobj.tqparents()[0] );
   return ret;
 }
 
 /* ----------------- Transport of measure ------------------------------ */
 
-ObjectImp* MeasureTransportType::calc( const Args& parents, const KigDocument& doc ) const
+ObjectImp* MeasureTransportType::calc( const Args& tqparents, const KigDocument& doc ) const
 {
   double measure;
 
-  if ( parents.size() != 3 ) return new InvalidImp;
+  if ( tqparents.size() != 3 ) return new InvalidImp;
 
-  if ( parents[0]->inherits (SegmentImp::stype()) )
+  if ( tqparents[0]->inherits (SegmentImp::stype()) )
   {
-    const SegmentImp* s = static_cast<const SegmentImp*>( parents[0] );
+    const SegmentImp* s = static_cast<const SegmentImp*>( tqparents[0] );
     measure = s->length();
-  } else if ( parents[0]->inherits (ArcImp::stype()) )
+  } else if ( tqparents[0]->inherits (ArcImp::stype()) )
   {
-    const ArcImp* s = static_cast<const ArcImp*>( parents[0] );
+    const ArcImp* s = static_cast<const ArcImp*>( tqparents[0] );
     measure = s->radius()*s->angle();
   } else return new InvalidImp;
 
-  const Coordinate& p = static_cast<const PointImp*>( parents[2] )->coordinate();
-  if ( parents[1]->inherits (LineImp::stype()) )
+  const Coordinate& p = static_cast<const PointImp*>( tqparents[2] )->coordinate();
+  if ( tqparents[1]->inherits (LineImp::stype()) )
   {
-    const LineImp* c = static_cast<const LineImp*>( parents[1] );
+    const LineImp* c = static_cast<const LineImp*>( tqparents[1] );
 
     if ( !c->containsPoint( p, doc ) )
       return new InvalidImp;
@@ -523,9 +523,9 @@ ObjectImp* MeasureTransportType::calc( const Args& parents, const KigDocument& d
 
     if ( nc.valid() ) return new PointImp( nc );
     else return new InvalidImp;
-  } else if ( parents[1]->inherits (CircleImp::stype()) )
+  } else if ( tqparents[1]->inherits (CircleImp::stype()) )
   {
-    const CircleImp* c = static_cast<const CircleImp*>( parents[1] );
+    const CircleImp* c = static_cast<const CircleImp*>( tqparents[1] );
     if ( !c->containsPoint( p, doc ) )
       return new InvalidImp;
 
@@ -607,17 +607,17 @@ Args MeasureTransportType::sortArgs( const Args& args ) const
 
 /* - transport of measure (old, for compatibility with prev. kig files) - */
 
-ObjectImp* MeasureTransportTypeOld::calc( const Args& parents, const KigDocument& doc ) const
+ObjectImp* MeasureTransportTypeOld::calc( const Args& tqparents, const KigDocument& doc ) const
 {
-  if ( ! margsparser.checkArgs( parents ) ) return new InvalidImp;
+  if ( ! margsparser.checkArgs( tqparents ) ) return new InvalidImp;
 
-  const CircleImp* c = static_cast<const CircleImp*>( parents[0] );
-  const Coordinate& p = static_cast<const PointImp*>( parents[1] )->coordinate();
+  const CircleImp* c = static_cast<const CircleImp*>( tqparents[0] );
+  const Coordinate& p = static_cast<const PointImp*>( tqparents[1] )->coordinate();
 
   if ( !c->containsPoint( p, doc ) )
     return new InvalidImp;
 
-  const SegmentImp* s = static_cast<const SegmentImp*>( parents[2] );
+  const SegmentImp* s = static_cast<const SegmentImp*>( tqparents[2] );
   double param = c->getParam( p, doc );
   double measure = s->length();
   measure /= 2*c->radius()*M_PI;