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, 33 insertions, 33 deletions

diff --git a/kig/objects/object_calcer.h b/kig/objects/object_calcer.h
index 6df94fe8..1aa83db4 100644
--- a/kig/objects/object_calcer.h
+++ b/kig/objects/object_calcer.h
@@ -33,12 +33,12 @@ void intrusive_ptr_release( ObjectCalcer* p );
  * be calculated from the two PointImp's it has to go through; every
  * time either of them moves, this calculation is redone.  In this
  * case, there would be an ObjectCalcer that keeps a reference to its
- * two parents ( the ObjectCalcer's representing the points ), and
+ * two tqparents ( the ObjectCalcer's representing the points ), and
  * that will calculate its ObjectImp value every time it is asked to
- * do so ( i.e. every time one of its parents moves.. ).
+ * do so ( i.e. every time one of its tqparents moves.. ).
  *
  * Each ObjectHolder keeps its ObjectImp itself, and recalculates it
- * from its parents in its calc() method ( if necessary ).
+ * from its tqparents in its calc() method ( if necessary ).
  *
  * Because of the complex relations that ObjectCalcer's hold to other
  * ObjectCalcer's and to other classes, they have been made
@@ -46,12 +46,12 @@ void intrusive_ptr_release( ObjectCalcer* p );
  * how much times a pointer to them is held.  If this count reaches 0,
  * this means that nobody needs them anymore, and they delete
  * themselves.  E.g. an ObjectCalcer always keeps a reference to its
- * parents, to ensure that those aren't deleted before it is deleted.
+ * tqparents, to ensure that those aren't deleted before it is deleted.
  *
  * At runtime, there will be an entire graph of ObjectCalcer that
- * depend on their parents..  At the bottom, there are Calcer's that
+ * depend on their tqparents..  At the bottom, there are Calcer's that
  * the user is aware of, and that are held by ObjectHolder's.  At the
- * top, there are Calcer's without parents that serve only to hold
+ * top, there are Calcer's without tqparents that serve only to hold
  * some data.  Those are most likely ObjectConstCalcer's.  There are
  * some algorithms to work with the dependency graph in various ways
  * in ../misc/calcpath.h
@@ -67,7 +67,7 @@ class ObjectCalcer
 protected:
   /**
    * ObjectCalcer's are reference counted..  They all take a reference
-   * to their parents, and some other classes like ObjectHolder take a
+   * to their tqparents, and some other classes like ObjectHolder take a
    * reference to some ObjectCalcer's that they don't want to see
    * deleted..
    */
@@ -77,10 +77,10 @@ protected:
   void ref();
   void deref();
 
-  // we keep track of our children, so algorithms can easily walk over
+  // we keep track of our tqchildren, so algorithms can easily walk over
   // the dependency graph..
 
-  std::vector<ObjectCalcer*> mchildren;
+  std::vector<ObjectCalcer*> mtqchildren;
 
   ObjectCalcer();
 public:
@@ -90,7 +90,7 @@ public:
    */
   void addChild( ObjectCalcer* c );
   /**
-   * a calcer should call this in its destructor, to inform its parent
+   * a calcer should call this in its destructor, to inform its tqparent
    * that it is no longer a child of this calcer.  This will release
    * the reference taken in addChild..
    */
@@ -102,29 +102,29 @@ public:
   /**
    * Returns the child ObjectCalcer's of this ObjectCalcer.
    */
- std::vector<ObjectCalcer*> children() const;
+ std::vector<ObjectCalcer*> tqchildren() const;
 
   virtual ~ObjectCalcer();
   /**
-   * Returns the parent ObjectCalcer's of this ObjectCalcer.
+   * Returns the tqparent ObjectCalcer's of this ObjectCalcer.
    */
-  virtual std::vector<ObjectCalcer*> parents() const = 0;
+  virtual std::vector<ObjectCalcer*> tqparents() const = 0;
   /**
    * Returns the ObjectImp of this ObjectCalcer.
    */
   virtual const ObjectImp* imp() const = 0;
   /**
    * Makes the ObjectCalcer recalculate its ObjectImp from its
-   * parents.
+   * tqparents.
    */
   virtual void calc( const KigDocument& ) = 0;
 
   /**
-   * An ObjectCalcer expects its parents to have an ObjectImp of a
+   * An ObjectCalcer expects its tqparents to have an ObjectImp of a
    * certain type.  This method returns the ObjectImpType that \p o
-   * should have. \p os is a list of all the parents in order, and
+   * should have. \p os is a list of all the tqparents in order, and
    * \p o is part of it. This method will return the ObjectImpType
-   * that the parent should *at least* be.  For example, a Translated
+   * that the tqparent should *at least* be.  For example, a Translated
    * object can translate any sort of object, so it will return
    * ObjectImp::stype() here ( the topmost ObjectImpType, that all
    * other ObjectImpType's inherit ).
@@ -144,7 +144,7 @@ public:
   virtual bool isFreelyTranslatable() const;
   /**
    * Moving an object most of the time signifies invoking changes in
-   * some of its parents.  This method returns the set of parents that
+   * some of its tqparents.  This method returns the set of tqparents that
    * will be changed in the move() method.  The object itself should
    * not be included.
    */
@@ -182,30 +182,30 @@ public:
 class ObjectTypeCalcer
   : public ObjectCalcer
 {
-  std::vector<ObjectCalcer*> mparents;
+  std::vector<ObjectCalcer*> mtqparents;
   const ObjectType* mtype;
   ObjectImp* mimp;
 public:
   typedef myboost::intrusive_ptr<ObjectTypeCalcer> shared_ptr;
   /**
-   * Construct a new ObjectTypeCalcer with a given type and parents.
+   * Construct a new ObjectTypeCalcer with a given type and tqparents.
    */
-//  ObjectTypeCalcer( const ObjectType* type, const std::vector<ObjectCalcer*>& parents );
+//  ObjectTypeCalcer( const ObjectType* type, const std::vector<ObjectCalcer*>& tqparents );
   /**
    * the sort boolean tells whether the sortArgs method should be invoked or not;
    * if not present
    */
-  ObjectTypeCalcer( const ObjectType* type, const std::vector<ObjectCalcer*>& parents, bool sort=true );
+  ObjectTypeCalcer( const ObjectType* type, const std::vector<ObjectCalcer*>& tqparents, bool sort=true );
   ~ObjectTypeCalcer();
 
   const ObjectImp* imp() const;
-  std::vector<ObjectCalcer*> parents() const;
+  std::vector<ObjectCalcer*> tqparents() const;
   void calc( const KigDocument& doc );
 
   /**
-   * Set the parents of this ObjectTypeCalcer to np.  This object will
-   * release the reference it had to its old parents, and take a new
-   * one on the new parents.
+   * Set the tqparents of this ObjectTypeCalcer to np.  This object will
+   * release the reference it had to its old tqparents, and take a new
+   * one on the new tqparents.
    */
   void setParents( const std::vector<ObjectCalcer*> np );
   void setType( const ObjectType* t );
@@ -248,7 +248,7 @@ public:
 
   const ObjectImp* imp() const;
   void calc( const KigDocument& doc );
-  std::vector<ObjectCalcer*> parents() const;
+  std::vector<ObjectCalcer*> tqparents() const;
 
   /**
    * Set the ObjectImp of this ObjectConstCalcer to the given
@@ -267,7 +267,7 @@ public:
 };
 
 /**
- * This is an ObjectCalcer that has a single parent, and gets a
+ * This is an ObjectCalcer that has a single tqparent, and gets a
  * certain property from it in its calc() method.
  *
  * \see ObjectImp::property
@@ -276,22 +276,22 @@ class ObjectPropertyCalcer
   : public ObjectCalcer
 {
   ObjectImp* mimp;
-  ObjectCalcer* mparent;
+  ObjectCalcer* mtqparent;
   int mpropid;
 public:
   /**
    * Construct a new ObjectPropertyCalcer, that will get the property
-   * from parent with number propid.
+   * from tqparent with number propid.
    */
-  ObjectPropertyCalcer( ObjectCalcer* parent, int propid );
+  ObjectPropertyCalcer( ObjectCalcer* tqparent, int propid );
   ~ObjectPropertyCalcer();
 
   const ObjectImp* imp() const;
-  std::vector<ObjectCalcer*> parents() const;
+  std::vector<ObjectCalcer*> tqparents() const;
   void calc( const KigDocument& doc );
 
   int propId() const;
-  ObjectCalcer* parent() const;
+  ObjectCalcer* tqparent() const;
 
   const ObjectImpType* impRequirement(
     ObjectCalcer* o, const std::vector<ObjectCalcer*>& os ) const;