1 files changed, 50 insertions, 50 deletions
diff --git a/umbrello/umbrello/codegenerators/cppwriter.h b/umbrello/umbrello/codegenerators/cppwriter.h
index 8ae58226..06f914e4 100644
--- a/umbrello/umbrello/codegenerators/cppwriter.h
+++ b/umbrello/umbrello/codegenerators/cppwriter.h
@@ -62,12 +62,12 @@ public:
     /**
      * Add C++ primitives as datatypes
      */
-    QStringList defaultDatatypes();
+    TQStringList defaultDatatypes();
 
     /**
      * get list of reserved keywords
      */
-    virtual const QStringList reservedKeywords() const;
+    virtual const TQStringList reservedKeywords() const;
 
 private:
 
@@ -75,25 +75,25 @@ private:
      * Writes class's documentation to the class header
      * public abstract class Foo extents {
      */
-    void writeClassDecl(UMLClassifier *c, QTextStream &cpp);
+    void writeClassDecl(UMLClassifier *c, TQTextStream &cpp);
 
     /**
      * Writes the comment and class constructor declaration or methods
      */
-    void writeConstructorDecls(QTextStream &h);
-    void writeConstructorMethods(QTextStream &cpp);
+    void writeConstructorDecls(TQTextStream &h);
+    void writeConstructorMethods(TQTextStream &cpp);
 
     /**
      * write all field declarations, for both attributes and associations for the
      * given permitted scope.
      */
-    void writeFieldDecl(UMLClassifier *c, Uml::Visibility permitScope, QTextStream &stream);
+    void writeFieldDecl(UMLClassifier *c, Uml::Visibility permitScope, TQTextStream &stream);
 
     /**
      * write all method declarations, for attributes and associations
      * for the given permitted scope.
      */
-    void writeAccessorMethodDecl(UMLClassifier *c, Uml::Visibility permitScope, QTextStream &stream);
+    void writeAccessorMethodDecl(UMLClassifier *c, Uml::Visibility permitScope, TQTextStream &stream);
 
     /**
      * write all operations for a given class
@@ -102,7 +102,7 @@ private:
      * @param permitScope what type of method to write (by Scope)
      * @param j the stream associated with the output file
      */
-    void writeOperations(UMLClassifier *c, bool isHeaderMethod, Uml::Visibility permitScope, QTextStream &j);
+    void writeOperations(UMLClassifier *c, bool isHeaderMethod, Uml::Visibility permitScope, TQTextStream &j);
 
     /**
      * write a list of operations for a given class
@@ -110,14 +110,14 @@ private:
      * @param isHeaderMethod true when writing to a header file, false for body file
      * @param j the stream associated with the output file
      */
-    void writeOperations(UMLOperationList &list, bool isHeaderMethod, QTextStream &j);
+    void writeOperations(UMLOperationList &list, bool isHeaderMethod, TQTextStream &j);
 
     /**
      * write all attributes for a given class
      * @param c the class for which we are generating code
      * @param j the stream associated with the output file
      */
-    void writeAttributes(UMLClassifier *c, QTextStream &j);
+    void writeAttributes(UMLClassifier *c, TQTextStream &j);
 
     /**
      * writes the Attribute declarations
@@ -125,143 +125,143 @@ private:
      * @param writeStatic whether to write static or non-static attributes out
      * @param stream text stream
      */
-    void writeAttributeDecls (Uml::Visibility visibility, bool writeStatic, QTextStream &stream );
+    void writeAttributeDecls (Uml::Visibility visibility, bool writeStatic, TQTextStream &stream );
 
     /**
      * Write out fields and operations for this class selected on a particular
      * visibility.
      */
-    void writeHeaderFieldDecl(UMLClassifier *c, Uml::Visibility permitVisibility, QTextStream &stream);
+    void writeHeaderFieldDecl(UMLClassifier *c, Uml::Visibility permitVisibility, TQTextStream &stream);
 
-    void writeHeaderAttributeAccessorMethods (Uml::Visibility visibility, bool writeStatic, QTextStream &stream );
+    void writeHeaderAttributeAccessorMethods (Uml::Visibility visibility, bool writeStatic, TQTextStream &stream );
 
-    void writeHeaderAttributeAccessorMethodDecls(UMLClassifier *c, Uml::Visibility permitVisibility, QTextStream &stream);
-    void writeHeaderAccessorMethodDecl(UMLClassifier *c, Uml::Visibility permitScope, QTextStream &stream);
+    void writeHeaderAttributeAccessorMethodDecls(UMLClassifier *c, Uml::Visibility permitVisibility, TQTextStream &stream);
+    void writeHeaderAccessorMethodDecl(UMLClassifier *c, Uml::Visibility permitScope, TQTextStream &stream);
 
 
     /**
      * Searches a list of associations for appropriate ones to write out as attributes
      */
-    void writeAssociationDecls(UMLAssociationList associations, Uml::Visibility permit, Uml::IDType id, QTextStream &stream);
+    void writeAssociationDecls(UMLAssociationList associations, Uml::Visibility permit, Uml::IDType id, TQTextStream &stream);
 
     /**
      * Writes out an association as an attribute using Vector
      */
-    void writeAssociationRoleDecl(QString fieldClassName, QString roleName, QString multi,
-                                  QString doc, QTextStream &stream);
+    void writeAssociationRoleDecl(TQString fieldClassName, TQString roleName, TQString multi,
+                                  TQString doc, TQTextStream &stream);
 
     /**
      * calls @ref writeSingleAttributeAccessorMethods() on each of the attributes in attribs list.
      */
     void writeAttributeMethods(UMLAttributeList *attribs, Uml::Visibility visib, bool isHeaderMethod,
                                bool isStatic,
-                               bool writeMethodBody, QTextStream &stream);
+                               bool writeMethodBody, TQTextStream &stream);
 
     /**
      * calls @ref writeAssociationRoleMethod() on each of the associations in the given list
      */
     void writeAssociationMethods(UMLAssociationList associations, Uml::Visibility permitVisib,
                                  bool isHeaderMethod,
-                                 bool writeMethodBody, bool writePointerVar, Uml::IDType id, QTextStream &stream);
+                                 bool writeMethodBody, bool writePointerVar, Uml::IDType id, TQTextStream &stream);
 
     /**
      * calls @ref writeSingleAttributeAccessorMethods() or @ref
      * writeVectorAttributeAccessorMethods() on the association
      * role
      */
-    void writeAssociationRoleMethod(const QString &fieldClassName, bool isHeaderMethod, bool writeMethodBody,
-                                    const QString &roleName, const QString &multi,
-                                    const QString &description, Uml::Changeability_Type change,
-                                    QTextStream &stream);
+    void writeAssociationRoleMethod(const TQString &fieldClassName, bool isHeaderMethod, bool writeMethodBody,
+                                    const TQString &roleName, const TQString &multi,
+                                    const TQString &description, Uml::Changeability_Type change,
+                                    TQTextStream &stream);
 
     /**
      * Writes getFoo() and setFoo() accessor methods for the attribute
      */
     void writeSingleAttributeAccessorMethods(
-            const QString &fieldClassName, const QString &Name,
-            const QString &fieldName, const QString &description,
+            const TQString &fieldClassName, const TQString &Name,
+            const TQString &fieldName, const TQString &description,
             Uml::Changeability_Type change,
             bool isHeaderMethod,
-            bool isStatic, bool writeMethodBody, QTextStream &cpp);
+            bool isStatic, bool writeMethodBody, TQTextStream &cpp);
 
     /**
      * Writes addFoo() and removeFoo() accessor methods for the Vector attribute
      */
     void writeVectorAttributeAccessorMethods(
-            const QString &fieldClassName, const QString &fieldVarName,
-            const QString &fieldName, const QString &description,
+            const TQString &fieldClassName, const TQString &fieldVarName,
+            const TQString &fieldName, const TQString &description,
             Uml::Changeability_Type change,
             bool isHeaderMethod,
             bool writeMethodBody,
-            QTextStream &cpp);
+            TQTextStream &cpp);
 
     /**
      * Writes a // style comment
      */
-    void writeComment(const QString &text, const QString &indent, QTextStream &cpp);
+    void writeComment(const TQString &text, const TQString &indent, TQTextStream &cpp);
 
     /**
      * Writes a documentation comment
      */
-    void writeDocumentation(QString header, QString body, QString end, QTextStream &cpp);
+    void writeDocumentation(TQString header, TQString body, TQString end, TQTextStream &cpp);
 
 
     /**
      * write the header file for this classifier.
      */
-    void writeHeaderFile (UMLClassifier *c, QFile &file);
+    void writeHeaderFile (UMLClassifier *c, TQFile &file);
 
     /**
      * write the source code body file for this classifier.
      */
-    void writeSourceFile (UMLClassifier *c, QFile &file);
+    void writeSourceFile (UMLClassifier *c, TQFile &file);
 
     /**
      * utility method to break up a block of text, which has embedded newline chars,
      * and print them to a stream as separate lines of text, indented as directed.
      */
-    void printTextAsSeparateLinesWithIndent (const QString &text, const QString &indent,
-                                             QTextStream &stream);
+    void printTextAsSeparateLinesWithIndent (const TQString &text, const TQString &indent,
+                                             TQTextStream &stream);
 
     /**
      * Intellegently print out header include/forward decl. for associated classes.
      */
-    void printAssociationIncludeDecl (UMLAssociationList list, Uml::IDType this_id, QTextStream &stream);
+    void printAssociationIncludeDecl (UMLAssociationList list, Uml::IDType this_id, TQTextStream &stream);
 
     /**
      * If needed, write out the method to initialize attributes of our class.
      */
-    void writeInitAttibuteMethod (QTextStream &stream);
+    void writeInitAttibuteMethod (TQTextStream &stream);
 
     /**
      * If needed, write out the declaration for the method to initialize attributes of our class.
      */
-    void writeInitAttibuteDecl (QTextStream &stream);
+    void writeInitAttibuteDecl (TQTextStream &stream);
 
     /**
      * Returns the name of the given object (if it exists)
      */
-    QString getUMLObjectName(UMLObject *obj);
+    TQString getUMLObjectName(UMLObject *obj);
 
     /**
      * Replaces `string' with STRING_TYPENAME.
      */
-    QString fixTypeName(const QString &string);
+    TQString fixTypeName(const TQString &string);
 
     /**
      * check that initial values of strings have quotes around them
      */
-    QString fixInitialStringDeclValue(const QString &value, const QString &type);
+    TQString fixInitialStringDeclValue(const TQString &value, const TQString &type);
 
     /**
      * Determine what the variable name of this attribute should be.
      */
-    QString getAttributeVariableName (UMLAttribute *at);
+    TQString getAttributeVariableName (UMLAttribute *at);
 
     /**
      * Write a blank line
      */
-    void writeBlankLine(QTextStream &stream);
+    void writeBlankLine(TQTextStream &stream);
 
     /**
      * Return the policy object
@@ -273,18 +273,18 @@ private:
      */
     ClassifierInfo * m_classifierInfo;
 
-    QString VECTOR_METHOD_APPEND;
-    QString VECTOR_METHOD_REMOVE;
-    QString VECTOR_METHOD_INIT;
-    QString OBJECT_METHOD_INIT;
+    TQString VECTOR_METHOD_APPEND;
+    TQString VECTOR_METHOD_REMOVE;
+    TQString VECTOR_METHOD_INIT;
+    TQString OBJECT_METHOD_INIT;
 
     /**
      * Create association methods for class attributes/associations/operations as inline decl in header.
      */
     bool INLINE_ASSOCIATION_METHODS;
 
-    QStringList ObjectFieldVariables;
-    QStringList VectorFieldVariables;
+    TQStringList ObjectFieldVariables;
+    TQStringList VectorFieldVariables;
 
 };