Trinity Qt initial conversion

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

143 files changed, 2096 insertions, 2096 deletions

diff --git a/kode/automakefile.cpp b/kode/automakefile.cpp
index 4ee5408fb..468059ae3 100644
--- a/kode/automakefile.cpp
+++ b/kode/automakefile.cpp
@@ -23,7 +23,7 @@
 
 using namespace KODE;
 
-AutoMakefile::Target::Target( const QString &type, const QString &name )
+AutoMakefile::Target::Target( const TQString &type, const TQString &name )
   : mType( type ), mName( name )
 {
 }
@@ -40,17 +40,17 @@ void AutoMakefile::addTarget( const Target &t )
   }
 }
 
-void AutoMakefile::addEntry( const QString &variable, const QString &value )
+void AutoMakefile::addEntry( const TQString &variable, const TQString &value )
 {
   if ( variable.isEmpty() ) {
     mEntries.append( variable );
     return;
   }
   
-  QStringList::ConstIterator it = mEntries.find( variable );
+  TQStringList::ConstIterator it = mEntries.find( variable );
   if ( it == mEntries.end() ) {
     mEntries.append( variable );
-    QMap<QString,QString>::Iterator it = mValues.find( variable );
+    TQMap<TQString,TQString>::Iterator it = mValues.find( variable );
     if ( it == mValues.end() ) {
       mValues.insert( variable, value );
     } else {
@@ -64,13 +64,13 @@ void AutoMakefile::newLine()
   addEntry( "" );
 }
 
-QString AutoMakefile::text() const
+TQString AutoMakefile::text() const
 {
-  QString out;
+  TQString out;
 
-  QStringList::ConstIterator it;
+  TQStringList::ConstIterator it;
   for( it = mEntries.begin(); it != mEntries.end(); ++it ) {
-    QString variable = *it;
+    TQString variable = *it;
     if ( variable.isEmpty() ) {
       out += '\n';
     } else {
@@ -80,7 +80,7 @@ QString AutoMakefile::text() const
   out += '\n';
   
   for( it = mTargetTypes.begin(); it != mTargetTypes.end(); ++it ) {
-    QString targetType = *it;
+    TQString targetType = *it;
     
     out += targetType + " = ";
 
@@ -97,7 +97,7 @@ QString AutoMakefile::text() const
       Target t = *it2;
       if ( t.type() != targetType ) continue;
 
-      QString name = t.name();
+      TQString name = t.name();
       name.replace( '.', '_' );
       
       out += name + "_SOURCES = " + t.sources() + '\n';
diff --git a/kode/automakefile.h b/kode/automakefile.h
index 328d4fcf8..ec0dce7e5 100644
--- a/kode/automakefile.h
+++ b/kode/automakefile.h
@@ -21,10 +21,10 @@
 #ifndef KODE_AUTOMAKEFILE_H
 #define KODE_AUTOMAKEFILE_H
 
-#include <qvaluelist.h>
-#include <qstring.h>
-#include <qmap.h>
-#include <qstringlist.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
+#include <tqmap.h>
+#include <tqstringlist.h>
 
 #include <kdepimmacros.h>
 
@@ -36,37 +36,37 @@ class KDE_EXPORT AutoMakefile
     class KDE_EXPORT Target
     {
       public:
-        typedef QValueList<Target> List;
+        typedef TQValueList<Target> List;
 
         Target() {}
-        Target( const QString &type, const QString &name );
+        Target( const TQString &type, const TQString &name );
 
-        void setType( const QString &type ) { mType = type; }
-        QString type() const { return mType; }
+        void setType( const TQString &type ) { mType = type; }
+        TQString type() const { return mType; }
 
-        void setName( const QString &name ) { mName = name; }
-        QString name() const { return mName; }
+        void setName( const TQString &name ) { mName = name; }
+        TQString name() const { return mName; }
 
-        void setSources( const QString &sources ) { mSources = sources; }
-        QString sources() const { return mSources; }
+        void setSources( const TQString &sources ) { mSources = sources; }
+        TQString sources() const { return mSources; }
 
-        void setLibAdd( const QString &libAdd ) { mLibAdd = libAdd; }
-        QString libAdd() const { return mLibAdd; }
+        void setLibAdd( const TQString &libAdd ) { mLibAdd = libAdd; }
+        TQString libAdd() const { return mLibAdd; }
 
-        void setLdAdd( const QString &ldAdd ) { mLdAdd = ldAdd; }
-        QString ldAdd() const { return mLdAdd; }
+        void setLdAdd( const TQString &ldAdd ) { mLdAdd = ldAdd; }
+        TQString ldAdd() const { return mLdAdd; }
 
-        void setLdFlags( const QString &ldFlags ) { mLdFlags = ldFlags; }
-        QString ldFlags() const { return mLdFlags; }
+        void setLdFlags( const TQString &ldFlags ) { mLdFlags = ldFlags; }
+        TQString ldFlags() const { return mLdFlags; }
 
       private:
-        QString mType;
-        QString mName;
+        TQString mType;
+        TQString mName;
 
-        QString mSources;
-        QString mLibAdd;
-        QString mLdAdd;
-        QString mLdFlags;
+        TQString mSources;
+        TQString mLibAdd;
+        TQString mLdAdd;
+        TQString mLdFlags;
     };
   
     AutoMakefile();
@@ -74,19 +74,19 @@ class KDE_EXPORT AutoMakefile
     void addTarget( const Target &t );
     Target::List targets() const { return mTargets; }
 
-    void addEntry( const QString &variable,
-                   const QString &value = QString::null );
+    void addEntry( const TQString &variable,
+                   const TQString &value = TQString::null );
 
     void newLine();
 
-    QString text() const;
+    TQString text() const;
 
   private:
     Target::List mTargets;
-    QStringList mTargetTypes;
+    TQStringList mTargetTypes;
 
-    QStringList mEntries;
-    QMap<QString,QString> mValues;
+    TQStringList mEntries;
+    TQMap<TQString,TQString> mValues;
 };
 
 }
diff --git a/kode/class.cpp b/kode/class.cpp
index a65fac1ac..48c0e22f9 100644
--- a/kode/class.cpp
+++ b/kode/class.cpp
@@ -30,7 +30,7 @@ Class::Class()
   mBaseClasses.setAutoDelete( true );
 }
 
-Class::Class( const QString &name, const QString &nameSpace )
+Class::Class( const TQString &name, const TQString &nameSpace )
   : mName( name ), mNameSpace( nameSpace )
 {
 }
@@ -54,7 +54,7 @@ Class &Class::operator=( const Class &c )
   mEnums = c.mEnums;
   mDocs = c.mDocs;
 
-  QPtrListIterator<Class> it( c.mBaseClasses );
+  TQPtrListIterator<Class> it( c.mBaseClasses );
   while( it.current() ) {
     mBaseClasses.append( new Class( *( it.current() ) ) );
     ++it;
@@ -65,18 +65,18 @@ Class &Class::operator=( const Class &c )
   return *this;
 }
 
-void Class::setName( const QString &name )
+void Class::setName( const TQString &name )
 {
   mName = name;
 }
 
-void Class::setNameSpace( const QString &nameSpace )
+void Class::setNameSpace( const TQString &nameSpace )
 {
   mNameSpace = nameSpace;
 }
 
-void Class::addInclude( const QString &include,
-  const QString &forwardDeclaration )
+void Class::addInclude( const TQString &include,
+  const TQString &forwardDeclaration )
 {
   if ( mIncludes.find( include ) == mIncludes.end() ) {
     mIncludes.append( include );
@@ -89,7 +89,7 @@ void Class::addInclude( const QString &include,
   }
 }
 
-void Class::addHeaderInclude( const QString &include )
+void Class::addHeaderInclude( const TQString &include )
 {
   if ( include.isEmpty() )
     return;
@@ -99,9 +99,9 @@ void Class::addHeaderInclude( const QString &include )
   }
 }
 
-void Class::addHeaderIncludes( const QStringList &includes )
+void Class::addHeaderIncludes( const TQStringList &includes )
 {
-  QStringList::ConstIterator it;
+  TQStringList::ConstIterator it;
   for ( it = includes.begin(); it != includes.end(); ++it )
     addHeaderInclude( *it );
 }
@@ -125,7 +125,7 @@ Class::List Class::baseClasses() const
 {
   Class::List b;
   
-  QPtrListIterator<Class> it( mBaseClasses );
+  TQPtrListIterator<Class> it( mBaseClasses );
   while( it.current() ) {
     b.append( Class( *( it.current() ) ) );
     ++it;
@@ -149,7 +149,7 @@ bool Class::isValid() const
   return !mName.isEmpty();
 }
 
-bool Class::hasFunction( const QString &functionName ) const
+bool Class::hasFunction( const TQString &functionName ) const
 {
   Function::List::ConstIterator it;
   for( it = mFunctions.begin(); it != mFunctions.end(); ++it ) {
@@ -170,7 +170,7 @@ bool Class::isQObject() const
   return false;
 }
 
-void Class::setDocs( const QString &str )
+void Class::setDocs( const TQString &str )
 {
   mDocs = str;
 }
diff --git a/kode/class.h b/kode/class.h
index dde50e8bd..21edc015f 100644
--- a/kode/class.h
+++ b/kode/class.h
@@ -27,70 +27,70 @@
 #include "typedef.h"
 
 #include <kdepimmacros.h>
-#include <qvaluelist.h>
-#include <qstring.h>
-#include <qstringlist.h>
-#include <qptrlist.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
+#include <tqptrlist.h>
 
 namespace KODE {
 
 class KDE_EXPORT Class
 {
   public:
-    typedef QValueList<Class> List;
+    typedef TQValueList<Class> List;
     
     Class();
-    Class( const QString &name, const QString &nameSpace = QString::null );
+    Class( const TQString &name, const TQString &nameSpace = TQString::null );
 
     Class( const Class & );
     Class &operator=( const Class &c );
 
     bool isValid() const;
 
-    void addInclude( const QString &file,
-      const QString &forwardDeclaration = QString::null );
-    void addHeaderInclude( const QString &file );
-    void addHeaderIncludes( const QStringList &files );
+    void addInclude( const TQString &file,
+      const TQString &forwardDeclaration = TQString::null );
+    void addHeaderInclude( const TQString &file );
+    void addHeaderIncludes( const TQStringList &files );
     void addBaseClass( const Class & );
     void addFunction( const Function & );
     void addMemberVariable( const MemberVariable &v );
     void addTypedef( const Typedef & );
     void addEnum( const Enum & );
 
-    void setName( const QString &name );
-    QString name() const { return mName; }
-    void setNameSpace( const QString &nameSpace );
-    QString nameSpace() const { return mNameSpace; }
-    QStringList includes() const { return mIncludes; }
-    QStringList headerIncludes() const { return mHeaderIncludes; }
-    QStringList forwardDeclarations() const { return mForwardDeclarations; }
+    void setName( const TQString &name );
+    TQString name() const { return mName; }
+    void setNameSpace( const TQString &nameSpace );
+    TQString nameSpace() const { return mNameSpace; }
+    TQStringList includes() const { return mIncludes; }
+    TQStringList headerIncludes() const { return mHeaderIncludes; }
+    TQStringList forwardDeclarations() const { return mForwardDeclarations; }
     Function::List functions() const { return mFunctions; }
     MemberVariable::List memberVariables() const { return mMemberVariables; }
     Class::List baseClasses() const;
     Typedef::List typedefs() const { return mTypedefs; }
     Enum::List enums() const { return mEnums; }
 
-    void setDocs( const QString & );
-    QString docs() const { return mDocs; }
+    void setDocs( const TQString & );
+    TQString docs() const { return mDocs; }
 
-    bool hasFunction( const QString &name ) const;
+    bool hasFunction( const TQString &name ) const;
     
     bool isQObject() const;
     
   private:
     // WARNING: If you add member variables, you have to adjust the copy
     //          constructor.
-    QString mName;
-    QString mNameSpace;
+    TQString mName;
+    TQString mNameSpace;
     Function::List mFunctions;
     MemberVariable::List mMemberVariables;
-    QStringList mIncludes;
-    QStringList mForwardDeclarations;
-    QStringList mHeaderIncludes;
-    QPtrList<Class> mBaseClasses;
+    TQStringList mIncludes;
+    TQStringList mForwardDeclarations;
+    TQStringList mHeaderIncludes;
+    TQPtrList<Class> mBaseClasses;
     Typedef::List mTypedefs;
     Enum::List mEnums;
-    QString mDocs;
+    TQString mDocs;
 };
 
 }
diff --git a/kode/code.cpp b/kode/code.cpp
index 9d02736c6..da8976931 100644
--- a/kode/code.cpp
+++ b/kode/code.cpp
@@ -23,8 +23,8 @@
 
 #include <kdebug.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
 
 using namespace KODE;
 
@@ -41,7 +41,7 @@ Code::Code( int indent )
 void Code::clear()
 {
   mIndent = 0;
-  mText = QString::null;
+  mText = TQString::null;
 }
 
 bool Code::isEmpty() const
@@ -65,7 +65,7 @@ void Code::unindent()
   if ( mIndent < 0 ) mIndent = 0;
 }
 
-void Code::addLine( const QString &line )
+void Code::addLine( const TQString &line )
 {
   mText += spaces( mIndent );
   mText += line;
@@ -77,22 +77,22 @@ void Code::newLine()
   mText += '\n';
 }
 
-QString Code::spaces( int count )
+TQString Code::spaces( int count )
 {
-  QString str;
+  TQString str;
   for( int i = 0; i < count; ++i ) {
     str += ' ';
   }
   return str;
 }
 
-void Code::addBlock( const QString &block )
+void Code::addBlock( const TQString &block )
 {
-  QStringList lines = QStringList::split( "\n", block, true );
+  TQStringList lines = TQStringList::split( "\n", block, true );
   if ( !lines.isEmpty() && lines.last().isEmpty() ) {
     lines.pop_back();
   }
-  QStringList::ConstIterator it;
+  TQStringList::ConstIterator it;
   for( it = lines.begin(); it != lines.end(); ++it ) {
     if ( !(*it).isEmpty() ) mText += spaces( mIndent );
     mText += *it;
@@ -100,7 +100,7 @@ void Code::addBlock( const QString &block )
   }
 }
 
-void Code::addBlock( const QString &block, int indent )
+void Code::addBlock( const TQString &block, int indent )
 {
   int tmp = mIndent;
   mIndent = indent;
@@ -113,26 +113,26 @@ void Code::addBlock( const Code &c )
   addBlock( c.text() );
 }
 
-void Code::addWrappedText( const QString &txt )
+void Code::addWrappedText( const TQString &txt )
 {
   int maxWidth = 80 - mIndent;
   unsigned int pos = 0;
   while ( pos < txt.length() ) {
-    QString line = txt.mid( pos, maxWidth );
+    TQString line = txt.mid( pos, maxWidth );
     addLine( line );
     pos += maxWidth;
   }
 }
 
-void Code::addFormattedText( const QString &text )
+void Code::addFormattedText( const TQString &text )
 {
   int maxWidth = 80 - mIndent;
   int lineLength = 0;
 
-  QString line;
-  const QStringList words = QStringList::split( ' ', text, false );
+  TQString line;
+  const TQStringList words = TQStringList::split( ' ', text, false );
 
-  QStringList::ConstIterator it;
+  TQStringList::ConstIterator it;
   for ( it = words.begin(); it != words.end(); ++it ) {
     if ( (int)(*it).length() + lineLength >= maxWidth ) {
       addLine( line );
@@ -147,7 +147,7 @@ void Code::addFormattedText( const QString &text )
   addLine( line );
 }
 
-Code &Code::operator+=( const QString &str )
+Code &Code::operator+=( const TQString &str )
 {
   addLine( str );
 
@@ -156,7 +156,7 @@ Code &Code::operator+=( const QString &str )
 
 Code &Code::operator+=( const char *str )
 {
-  addLine( QString::fromLocal8Bit( str ) );
+  addLine( TQString::fromLocal8Bit( str ) );
   return *this;
 }
 
diff --git a/kode/code.h b/kode/code.h
index 1723df905..9f056df2b 100644
--- a/kode/code.h
+++ b/kode/code.h
@@ -23,9 +23,9 @@
 
 #include "license.h"
 
-#include <qvaluelist.h>
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 #include <kdepimmacros.h>
 namespace KODE {
 
@@ -43,26 +43,26 @@ class KDE_EXPORT Code
     void indent();
     void unindent();
 
-    QString text() const { return mText; }
+    TQString text() const { return mText; }
 
-    void addLine( const QString & );
+    void addLine( const TQString & );
     void addBlock( const Code & );
-    void addBlock( const QString & );
-    void addBlock( const QString &, int indent );
+    void addBlock( const TQString & );
+    void addBlock( const TQString &, int indent );
 
-    void addWrappedText( const QString & );
-    void addFormattedText( const QString & );
+    void addWrappedText( const TQString & );
+    void addFormattedText( const TQString & );
 
     void newLine();
 
-    Code &operator+=( const QString & );
+    Code &operator+=( const TQString & );
     Code &operator+=( const char * );
     Code &operator+=( const Code & );
 
-    static QString spaces( int count );
+    static TQString spaces( int count );
 
   private:
-    QString mText;
+    TQString mText;
     int mIndent;
 };
 
diff --git a/kode/enum.cpp b/kode/enum.cpp
index 3d8ac6081..64bf8f790 100644
--- a/kode/enum.cpp
+++ b/kode/enum.cpp
@@ -28,22 +28,22 @@ Enum::Enum()
 {
 }
 
-Enum::Enum( const QString &name, const QStringList &enums, bool combinable )
+Enum::Enum( const TQString &name, const TQStringList &enums, bool combinable )
   : mName( name ), mEnums( enums ), mCombinable( combinable )
 {
 }
     
-QString Enum::declaration() const
+TQString Enum::declaration() const
 {
-  QString retval( "enum " + mName + " {" );
+  TQString retval( "enum " + mName + " {" );
   uint value = 0;
-  QStringList::ConstIterator it;
+  TQStringList::ConstIterator it;
   for ( it = mEnums.begin(); it != mEnums.end(); ++it, ++value ) {
     if ( mCombinable ) {
       if ( it == mEnums.begin() )
-        retval += QString( " %1 = %2" ).arg( *it ).arg( 1 << value );
+        retval += TQString( " %1 = %2" ).arg( *it ).arg( 1 << value );
       else
-        retval += QString( ", %1 = %2" ).arg( *it ).arg( 1 << value );
+        retval += TQString( ", %1 = %2" ).arg( *it ).arg( 1 << value );
     } else {
       if ( it == mEnums.begin() )
         retval += " " + *it;
diff --git a/kode/enum.h b/kode/enum.h
index e3bc695aa..cc75b2c03 100644
--- a/kode/enum.h
+++ b/kode/enum.h
@@ -21,7 +21,7 @@
 #ifndef KODE_ENUM_H
 #define KODE_ENUM_H
 
-#include <qstringlist.h>
+#include <tqstringlist.h>
 #include <kdepimmacros.h>
 
 namespace KODE {
@@ -29,16 +29,16 @@ namespace KODE {
 class KDE_EXPORT Enum
 {
   public:
-    typedef QValueList<Enum> List;
+    typedef TQValueList<Enum> List;
   
     Enum();
-    Enum( const QString &name, const QStringList &enums, bool combinable = false );
+    Enum( const TQString &name, const TQStringList &enums, bool combinable = false );
     
-    QString declaration() const;
+    TQString declaration() const;
 
   private:
-    QString mName;
-    QStringList mEnums;
+    TQString mName;
+    TQStringList mEnums;
     bool mCombinable;
 };
 
diff --git a/kode/file.cpp b/kode/file.cpp
index fa93326c9..51c19131f 100644
--- a/kode/file.cpp
+++ b/kode/file.cpp
@@ -23,8 +23,8 @@
 
 #include <kdebug.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
 
 using namespace KODE;
 
@@ -33,37 +33,37 @@ File::File()
 {
 }
 
-void File::setFilename( const QString &filename )
+void File::setFilename( const TQString &filename )
 {
   mFilename = filename;
 }
 
-QString File::filename() const
+TQString File::filename() const
 {
   if ( !mFilename.isEmpty() ) return mFilename;
 
   if ( !mClasses.isEmpty() ) {
-    QString className = mClasses[ 0 ].name();
+    TQString className = mClasses[ 0 ].name();
     return className.lower();
   }
 
-  return QString::null;
+  return TQString::null;
 }
 
-void File::setNameSpace( const QString &n )
+void File::setNameSpace( const TQString &n )
 {
   mNameSpace = n;
 }
 
-void File::setProject( const QString &project )
+void File::setProject( const TQString &project )
 {
   if ( project.isEmpty() ) return;
   mProject = project;
 }
 
-void File::addCopyright( int year, const QString &name, const QString &email )
+void File::addCopyright( int year, const TQString &name, const TQString &email )
 {
-  QString str = "Copyright (c) " + QString::number( year ) + " " + name + " <" +
+  TQString str = "Copyright (c) " + TQString::number( year ) + " " + name + " <" +
                 email + ">";
   mCopyrightStrings.append( str );
 }
@@ -73,9 +73,9 @@ void File::setLicense( const License &l )
   mLicense = l;
 }
 
-void File::addInclude( const QString &i )
+void File::addInclude( const TQString &i )
 {
-  QString include = i;
+  TQString include = i;
   if( !include.endsWith( ".h" ) ) include.append( ".h" );
 
   if ( mIncludes.find( include ) == mIncludes.end() ) {
@@ -97,7 +97,7 @@ void File::insertClass( const Class &c )
   mClasses.append( c );
 }
 
-bool File::hasClass( const QString &name )
+bool File::hasClass( const TQString &name )
 {
   Class::List::ConstIterator it;
   for( it = mClasses.begin(); it != mClasses.end(); ++it ) {
@@ -106,7 +106,7 @@ bool File::hasClass( const QString &name )
   return it != mClasses.end();
 }
 
-Class File::findClass( const QString &name )
+Class File::findClass( const TQString &name )
 {
   Class::List::ConstIterator it;
   for( it = mClasses.begin(); it != mClasses.end(); ++it ) {
@@ -125,7 +125,7 @@ void File::addFileFunction( const Function &f )
   mFileFunctions.append( f );
 }
 
-void File::addExternCDeclaration( const QString &s )
+void File::addExternCDeclaration( const TQString &s )
 {
   mExternCDeclarations.append( s );
 }
diff --git a/kode/file.h b/kode/file.h
index e4efdca6c..0520d7872 100644
--- a/kode/file.h
+++ b/kode/file.h
@@ -26,8 +26,8 @@
 #include "class.h"
 #include "membervariable.h"
 
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 #include <kdepimmacros.h>
 
 namespace KODE {
@@ -37,30 +37,30 @@ class KDE_EXPORT File
   public:
     File();
 
-    void setFilename( const QString & );
-    QString filename() const;
+    void setFilename( const TQString & );
+    TQString filename() const;
 
-    void setNameSpace( const QString & );
-    QString nameSpace() const { return mNameSpace; }
+    void setNameSpace( const TQString & );
+    TQString nameSpace() const { return mNameSpace; }
 
-    void setProject( const QString &project );
-    QString project() const { return mProject; }
+    void setProject( const TQString &project );
+    TQString project() const { return mProject; }
 
-    void addCopyright( int year, const QString &name, const QString &email );
-    QStringList copyrightStrings() const { return mCopyrightStrings; }
+    void addCopyright( int year, const TQString &name, const TQString &email );
+    TQStringList copyrightStrings() const { return mCopyrightStrings; }
 
     void setLicense( const License & );
     License license() const { return mLicense; }
 
-    void addInclude( const QString &include );
-    QStringList includes() const { return mIncludes; }
+    void addInclude( const TQString &include );
+    TQStringList includes() const { return mIncludes; }
 
     void insertClass( const Class & );
     Class::List classes() const { return mClasses; }
 
-    bool hasClass( const QString &className );
+    bool hasClass( const TQString &className );
 
-    Class findClass( const QString &name );
+    Class findClass( const TQString &name );
 
     void clearClasses();
     void clearFileFunctions();
@@ -74,23 +74,23 @@ class KDE_EXPORT File
     void addFileFunction( const Function & );
     Function::List fileFunctions() const { return mFileFunctions; }
 
-    void addExternCDeclaration( const QString & );
-    QStringList externCDeclarations() const { return mExternCDeclarations; }
+    void addExternCDeclaration( const TQString & );
+    TQStringList externCDeclarations() const { return mExternCDeclarations; }
 
     void addFileCode( const Code & );
     Code fileCode() const { return mFileCode; }
 
   private:
-    QString mFilename;
-    QString mNameSpace;
-    QString mProject;
-    QStringList mCopyrightStrings;
+    TQString mFilename;
+    TQString mNameSpace;
+    TQString mProject;
+    TQStringList mCopyrightStrings;
     License mLicense;
-    QStringList mIncludes;
+    TQStringList mIncludes;
     Class::List mClasses;
     Variable::List mFileVariables;
     Function::List mFileFunctions;
-    QStringList mExternCDeclarations;
+    TQStringList mExternCDeclarations;
     Code mFileCode;
 };
 
diff --git a/kode/function.cpp b/kode/function.cpp
index 1e379e46c..2cea97368 100644
--- a/kode/function.cpp
+++ b/kode/function.cpp
@@ -30,7 +30,7 @@ Function::Function()
 {
 }
 
-Function::Function( const QString &name, const QString &returnType,
+Function::Function( const TQString &name, const TQString &returnType,
                     int access, bool isStatic )
   :  mAccess( access ), mIsConst( false ), mIsStatic( isStatic ),
      mReturnType( returnType ), mName( name )
@@ -47,27 +47,27 @@ void Function::setStatic( bool isStatic )
   mIsStatic = isStatic;
 }
    
-void Function::addArgument( const QString &argument )
+void Function::addArgument( const TQString &argument )
 {
   mArguments.append( argument );
 }
 
-void Function::addInitializer( const QString &initializer )
+void Function::addInitializer( const TQString &initializer )
 {
   mInitializers.append( initializer );
 }
 
-void Function::setArgumentString( const QString &argumentString )
+void Function::setArgumentString( const TQString &argumentString )
 {
   mArguments.clear();
-  QStringList arguments = QStringList::split( ",", argumentString );
-  QStringList::ConstIterator it;
+  TQStringList arguments = TQStringList::split( ",", argumentString );
+  TQStringList::ConstIterator it;
   for( it = arguments.begin(); it != arguments.end(); ++it ) {
     addArgument( *it );
   }
 }
 
-void Function::setBody( const QString &body )
+void Function::setBody( const TQString &body )
 {
   mBody = body;
 }
@@ -77,7 +77,7 @@ void Function::setBody( const Code &body )
   mBody = body.text();
 }
 
-void Function::addBodyLine( const QString &bodyLine )
+void Function::addBodyLine( const TQString &bodyLine )
 {
   mBody.append( bodyLine );
   if ( bodyLine.right( 1 ) != "\n" ) mBody.append( '\n' );
@@ -88,9 +88,9 @@ void Function::setAccess( int a )
   mAccess = a;
 }
 
-QString Function::accessAsString() const
+TQString Function::accessAsString() const
 {
-  QString access;
+  TQString access;
 
   if ( mAccess & Public )
     access = "public";
@@ -107,17 +107,17 @@ QString Function::accessAsString() const
   return access;
 }
 
-void Function::setReturnType( const QString &str )
+void Function::setReturnType( const TQString &str )
 {
   mReturnType = str;
 }
 
-void Function::setName( const QString &str )
+void Function::setName( const TQString &str )
 {
   mName = str;
 }
 
-void Function::setDocs( const QString &str )
+void Function::setDocs( const TQString &str )
 {
   mDocs = str;
 }
diff --git a/kode/function.h b/kode/function.h
index 53ba43720..47f0dd756 100644
--- a/kode/function.h
+++ b/kode/function.h
@@ -23,9 +23,9 @@
 
 #include "code.h"
 
-#include <qvaluelist.h>
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 #include <kdepimmacros.h>
 
 namespace KODE {
@@ -33,12 +33,12 @@ namespace KODE {
 class KDE_EXPORT Function
 {
   public:
-    typedef QValueList<Function> List;
+    typedef TQValueList<Function> List;
 
     enum AccessSpecifier { Public = 1, Protected = 2, Private = 4, Signal = 8, Slot = 16 };
 
     Function();
-    Function( const QString &name, const QString &returnType = QString::null,
+    Function( const TQString &name, const TQString &returnType = TQString::null,
               int access = Public, bool isStatic = false );
 
     void setConst( bool isConst );
@@ -47,43 +47,43 @@ class KDE_EXPORT Function
     void setStatic( bool isStatic );
     bool isStatic() const { return mIsStatic; }
     
-    void addArgument( const QString &argument );
-    void setArgumentString( const QString &argumentString );
+    void addArgument( const TQString &argument );
+    void setArgumentString( const TQString &argumentString );
     
-    void addInitializer( const QString & );
-    QStringList initializers() const { return mInitializers; }
+    void addInitializer( const TQString & );
+    TQStringList initializers() const { return mInitializers; }
     
-    void setBody( const QString &body );
+    void setBody( const TQString &body );
     void setBody( const Code &code );
-    void addBodyLine( const QString &bodyLine );
+    void addBodyLine( const TQString &bodyLine );
 
     void setAccess( int );
     int access() const { return mAccess; }
-    QString accessAsString() const;
+    TQString accessAsString() const;
 
-    void setReturnType( const QString & );
-    QString returnType() const { return mReturnType; }
+    void setReturnType( const TQString & );
+    TQString returnType() const { return mReturnType; }
 
-    void setName( const QString & );
-    QString name() const { return mName; }
+    void setName( const TQString & );
+    TQString name() const { return mName; }
 
-    QStringList arguments() const { return mArguments; }
+    TQStringList arguments() const { return mArguments; }
 
-    QString body() const { return mBody; }
+    TQString body() const { return mBody; }
 
-    void setDocs( const QString & );
-    QString docs() const { return mDocs; }
+    void setDocs( const TQString & );
+    TQString docs() const { return mDocs; }
 
   private:
     int mAccess;
     bool mIsConst;
     bool mIsStatic;
-    QString mReturnType;
-    QString mName;
-    QStringList mArguments;
-    QStringList mInitializers;
-    QString mBody;
-    QString mDocs;
+    TQString mReturnType;
+    TQString mName;
+    TQStringList mArguments;
+    TQStringList mInitializers;
+    TQString mBody;
+    TQString mDocs;
 };
 
 }
diff --git a/kode/kodemain.cpp b/kode/kodemain.cpp
index a567f20a0..e248a93a6 100644
--- a/kode/kodemain.cpp
+++ b/kode/kodemain.cpp
@@ -39,10 +39,10 @@
 #include <ksavefile.h>
 #include <kprocess.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
-#include <qfileinfo.h>
-#include <qregexp.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+#include <tqfileinfo.h>
+#include <tqregexp.h>
 
 #include <iostream>
 
@@ -73,15 +73,15 @@ static const KCmdLineOptions options[] =
   KCmdLineLastOption
 };
 
-void addPropertyFunctions( QString &out, const QString &type,
-  const QString &name )
+void addPropertyFunctions( TQString &out, const TQString &type,
+  const TQString &name )
 {
   // FIXME: Use KODE::Function
 
   bool isReference = type.endsWith( "*" ) || type.endsWith( "&" );
 
-  QString argument;
-  QString upper = KODE::Style::upperFirst( name );
+  TQString argument;
+  TQString upper = KODE::Style::upperFirst( name );
   if ( !isReference ) {
     argument = "const " + type + " &";
   } else argument = type;
@@ -107,10 +107,10 @@ void addPropertyFunctions( QString &out, const QString &type,
   out += code.text();
 }
 
-void addPropertyVariable( QString &out, const QString &type,
-  const QString &name )
+void addPropertyVariable( TQString &out, const TQString &type,
+  const TQString &name )
 {
-  QString upper = KODE::Style::upperFirst( name );
+  TQString upper = KODE::Style::upperFirst( name );
   bool isReference = type.endsWith( "*" ) || type.endsWith( "&" );
 
   KODE::Code code;
@@ -129,68 +129,68 @@ int addProperty( KCmdLineArgs *args )
     return 1;
   }
   
-  QString className = args->arg( 0 );
-  QString type = args->arg( 1 );
-  QString name = args->arg( 2 );
+  TQString className = args->arg( 0 );
+  TQString type = args->arg( 1 );
+  TQString name = args->arg( 2 );
 
   kdDebug() << "Add property: class " << className << ": " << type << " " <<
     name << endl;
 
-  QString headerFileName = className.lower() + ".h";
+  TQString headerFileName = className.lower() + ".h";
   
-  QFile headerFile( headerFileName );
+  TQFile headerFile( headerFileName );
   if ( !headerFile.open( IO_ReadOnly ) ) {
     std::cerr << "Unable to open file '" << headerFileName.utf8() << "'" <<
       std::endl;
     return 1;
   }
   
-  QTextStream in( &headerFile );
+  TQTextStream in( &headerFile );
 
   enum State { FindClass, FindConstructor, FindProperties, FindPrivate,
     FindVariables, Finish };
   State state = FindClass;
 
-  QString accessor;
-  QString mutator;
+  TQString accessor;
+  TQString mutator;
   
-  QString out;
+  TQString out;
   
-  QString readAhead;
+  TQString readAhead;
   
-  QString line;
+  TQString line;
   while ( !( line = in.readLine() ).isNull() ) {
 //    std::cout << line.utf8() << std::endl;
     kdDebug() << state << " LINE: " << line << endl;
-    QString readAheadPrevious = readAhead;
+    TQString readAheadPrevious = readAhead;
     readAhead += line + "\n";
 //    out += line + "\n";
     switch( state ) {
       case FindClass:
-//        if ( line.find( QRegExp( className ) ) >= 0 ) {
-        if ( line.find( QRegExp( "^\\s*class\\s+" + className ) ) >= 0 ) {
+//        if ( line.find( TQRegExp( className ) ) >= 0 ) {
+        if ( line.find( TQRegExp( "^\\s*class\\s+" + className ) ) >= 0 ) {
           kdDebug() << "  FOUND CLASS" << endl;
           state = FindConstructor;
         }
         break;
       case FindConstructor:
-        if ( line.find( QRegExp( "^\\s*" + className + "\\s*\\(" ) ) >= 0 ) {
+        if ( line.find( TQRegExp( "^\\s*" + className + "\\s*\\(" ) ) >= 0 ) {
           kdDebug() << "  FOUND CONSTRUCTOR" << endl;
           out += readAhead;
-          readAhead = QString::null;
+          readAhead = TQString::null;
           state = FindProperties;
         }
         break;
       case FindProperties:
         {
-          QRegExp re( "(\\w+)\\s*\\(" );
+          TQRegExp re( "(\\w+)\\s*\\(" );
           if ( re.search( line ) >= 0 ) {
-            QString function = re.cap( 1 ).lower();
+            TQString function = re.cap( 1 ).lower();
             if ( !function.isEmpty() ) {
               kdDebug() << "Function: " << function << endl;
               if ( function == className || function == "~" + className ) {
                 out += readAhead;
-                readAhead = QString::null;
+                readAhead = TQString::null;
               } else {
                 if ( function.startsWith( "set" ) ) {
                   mutator = function.mid( 3 );
@@ -200,7 +200,7 @@ int addProperty( KCmdLineArgs *args )
                     accessor = function;
                     kdDebug() << "ACCESSOR: " << accessor << endl;
                     out += readAhead;
-                    readAhead = QString::null;
+                    readAhead = TQString::null;
                   } else {
                     kdDebug() << "CREATE PROPERTY" << endl;
                     out += readAheadPrevious;
@@ -212,13 +212,13 @@ int addProperty( KCmdLineArgs *args )
                 }
               }
             }
-          } else if ( line.find( QRegExp( "\\s*protected" ) ) >= 0 ) {
+          } else if ( line.find( TQRegExp( "\\s*protected" ) ) >= 0 ) {
             state = FindPrivate;
-          } else if ( line.find( QRegExp( "\\s*private" ) ) >= 0 ) {
+          } else if ( line.find( TQRegExp( "\\s*private" ) ) >= 0 ) {
             if ( accessor.isEmpty() ) {
               addPropertyFunctions( out, type, name );
               out += readAhead;
-              readAhead = QString::null;
+              readAhead = TQString::null;
               addPropertyVariable( out, type, name );
               state = Finish;
             } else {
@@ -227,7 +227,7 @@ int addProperty( KCmdLineArgs *args )
                 addPropertyFunctions( out, type, name );
                 out += "\n";
                 out += line + "\n";
-                readAhead = QString::null;
+                readAhead = TQString::null;
               }
               state = FindVariables;
             }
@@ -235,10 +235,10 @@ int addProperty( KCmdLineArgs *args )
         }
         break;
       case FindPrivate:
-        if ( line.find( QRegExp( "\\s*private" ) ) >= 0 ) {
+        if ( line.find( TQRegExp( "\\s*private" ) ) >= 0 ) {
           if ( accessor.isEmpty() ) {
             out += readAhead;
-            readAhead = QString::null;
+            readAhead = TQString::null;
             addPropertyVariable( out, type, name );
             state = Finish;
           } else {
@@ -250,7 +250,7 @@ int addProperty( KCmdLineArgs *args )
         {
           if ( line.find( "m" + accessor.lower(), 0, false ) >= 0 ) {
             out += readAhead;
-            readAhead = QString::null;
+            readAhead = TQString::null;
             addPropertyVariable( out, type, name );
             state = Finish;
           }
@@ -266,11 +266,11 @@ int addProperty( KCmdLineArgs *args )
   out += readAhead;
 
   if ( args->isSet( "inplace" ) ) {
-    QString headerFileNameOut = headerFileName + ".kodeorig" ;
+    TQString headerFileNameOut = headerFileName + ".kodeorig" ;
 
     KProcess proc;
-    proc << "cp" << QFile::encodeName( headerFileName ) <<
-      QFile::encodeName( headerFileNameOut );
+    proc << "cp" << TQFile::encodeName( headerFileName ) <<
+      TQFile::encodeName( headerFileNameOut );
     
     if ( !proc.start( KProcess::Block ) ) {
       kdError() << "Copy failed" << endl;
@@ -281,7 +281,7 @@ int addProperty( KCmdLineArgs *args )
           "' for writing." << endl;
         return 1;
       }
-      QTextStream o( &headerFile );
+      TQTextStream o( &headerFile );
       o << out << endl;
     }
   } else {
@@ -298,16 +298,16 @@ int codify( KCmdLineArgs *args )
     return 1;
   }
 
-  QString filename = args->arg( 0 );
+  TQString filename = args->arg( 0 );
 
-  QFile f( filename );
+  TQFile f( filename );
   if ( !f.open( IO_ReadOnly ) ) {
     kdError() << "Unable to open file '" << filename << "'." << endl;
     return 1;            
   } else {
     std::cout << "KODE::Code code;" << std::endl;
-    QTextStream ts( &f );
-    QString line;
+    TQTextStream ts( &f );
+    TQString line;
     while( !( line = ts.readLine() ).isNull() ) {
       line.replace( "\\", "\\\\" ); 
       line.replace( "\"", "\\\"" );
@@ -328,7 +328,7 @@ int create( KCmdLineArgs *args )
   bool createKioslave = args->isSet( "create-kioslave" );
   bool createMain = args->isSet( "create-main" );
 
-  QString filename = args->getOption( "filename" );
+  TQString filename = args->getOption( "filename" );
 
   if ( createMain ) {
     if ( filename.isEmpty() ) {
@@ -346,9 +346,9 @@ int create( KCmdLineArgs *args )
     }
   }
 
-  QString className = args->getOption( "classname" );
+  TQString className = args->getOption( "classname" );
 
-  QString protocol;
+  TQString protocol;
 
   if ( createKioslave ) {
     if ( !args->isSet( "protocol" ) ) {
@@ -364,8 +364,8 @@ int create( KCmdLineArgs *args )
 
   file.setProject( args->getOption( "project" ) );
 
-  QString authorEmail = args->getOption( "author-email" );
-  QString authorName;
+  TQString authorEmail = args->getOption( "author-email" );
+  TQString authorName;
   KABC::Addressee a;
   if ( authorEmail.isEmpty() ) {
     a = KABC::StdAddressBook::self()->whoAmI();
@@ -384,7 +384,7 @@ int create( KCmdLineArgs *args )
       authorName = a.realName();
   }
   if ( !authorEmail.isEmpty() ) {
-    file.addCopyright( QDate::currentDate().year(), authorName, authorEmail );
+    file.addCopyright( TQDate::currentDate().year(), authorName, authorEmail );
   }
 
   KODE::License l;
@@ -464,7 +464,7 @@ int create( KCmdLineArgs *args )
     code += "mimeType( \"text/plain\" );";
     code.newLine();
     
-    code += "QCString str( \"Hello!\" );";
+    code += "TQCString str( \"Hello!\" );";
     code += "data( str );";
     code.newLine();
     
@@ -544,8 +544,8 @@ int create( KCmdLineArgs *args )
   }
 
   if ( createKioslave ) {
-    constructor.addArgument( "const QCString &pool" );
-    constructor.addArgument( "const QCString &app" );
+    constructor.addArgument( "const TQCString &pool" );
+    constructor.addArgument( "const TQCString &app" );
 
     constructor.addInitializer( "SlaveBase( \"" + protocol + "\", pool, app )" );
   }
@@ -582,14 +582,14 @@ int create( KCmdLineArgs *args )
   
     
     // Write protocol file
-    QString protocolFilename = protocol + ".protocol";
+    TQString protocolFilename = protocol + ".protocol";
 
-    QFileInfo fi( protocolFilename );
+    TQFileInfo fi( protocolFilename );
     protocolFilename = fi.absFilePath();
 
-    KSaveFile::backupFile( protocolFilename, QString::null, ".backup" );
+    KSaveFile::backupFile( protocolFilename, TQString::null, ".backup" );
     
-    QFile::remove( protocolFilename );
+    TQFile::remove( protocolFilename );
     
     KSimpleConfig protocolFile( protocolFilename );
 
diff --git a/kode/kwsdl/binding.cpp b/kode/kwsdl/binding.cpp
index 540de5fbe..cfce54d48 100644
--- a/kode/kwsdl/binding.cpp
+++ b/kode/kwsdl/binding.cpp
@@ -27,7 +27,7 @@ Binding::Operation::Operation()
 {
 }
 
-Binding::Operation::Operation( const QString &name, const QString &action )
+Binding::Operation::Operation( const TQString &name, const TQString &action )
   : mName( name ), mAction( action )
 {
 }
@@ -36,7 +36,7 @@ Binding::Binding()
 {
 }
 
-Binding::Binding( const QString &name, const QString &type )
+Binding::Binding( const TQString &name, const TQString &type )
   : mName( name ), mType( type )
 {
 }
@@ -47,7 +47,7 @@ void Binding::addOperation( const Operation &operation )
   mOperations.append( operation );
 }
 
-Binding::Operation Binding::operation( const QString &name ) const
+Binding::Operation Binding::operation( const TQString &name ) const
 {
   Operation::List::ConstIterator it;
   for ( it = mOperations.begin(); it != mOperations.end(); ++it )
diff --git a/kode/kwsdl/binding.h b/kode/kwsdl/binding.h
index eba155c7d..a0a0d68fb 100644
--- a/kode/kwsdl/binding.h
+++ b/kode/kwsdl/binding.h
@@ -22,46 +22,46 @@
 #ifndef KWSDL_BINDING_H
 #define KWSDL_BINDING_H
 
-#include <qmap.h>
+#include <tqmap.h>
 
 namespace KWSDL {
 
 class Binding
 {
   public:
-    typedef QValueList<Binding> List;
+    typedef TQValueList<Binding> List;
 
     class Operation
     {
       public:
-        typedef QValueList<Operation> List;
+        typedef TQValueList<Operation> List;
 
         class Item
         {
           public:
-            void setUse( const QString &use ) { mUse = use; }
-            QString use() const { return mUse; }
+            void setUse( const TQString &use ) { mUse = use; }
+            TQString use() const { return mUse; }
 
-            void setNameSpace( const QString &nameSpace ) { mNameSpace = nameSpace; }
-            QString nameSpace() const { return mNameSpace; }
+            void setNameSpace( const TQString &nameSpace ) { mNameSpace = nameSpace; }
+            TQString nameSpace() const { return mNameSpace; }
 
-            void setEncodingStyle( const QString &encodingStyle ) { mEncodingStyle = encodingStyle; }
-            QString encodingStyle() const { return mEncodingStyle; }
+            void setEncodingStyle( const TQString &encodingStyle ) { mEncodingStyle = encodingStyle; }
+            TQString encodingStyle() const { return mEncodingStyle; }
 
           private:
-            QString mUse;
-            QString mNameSpace;
-            QString mEncodingStyle;
+            TQString mUse;
+            TQString mNameSpace;
+            TQString mEncodingStyle;
         };
 
         Operation();
-        Operation( const QString &name, const QString &action );
+        Operation( const TQString &name, const TQString &action );
 
-        void setName( const QString &name ) { mName = name; }
-        QString name() const { return mName; }
+        void setName( const TQString &name ) { mName = name; }
+        TQString name() const { return mName; }
 
-        void setAction( const QString &action ) { mAction = action; }
-        QString action() const { return mAction; }
+        void setAction( const TQString &action ) { mAction = action; }
+        TQString action() const { return mAction; }
 
         void setInput( const Item &item ) { mInput = item; }
         Item input() const { return mInput; }
@@ -70,36 +70,36 @@ class Binding
         Item output() const { return mOutput; }
 
       private:
-        QString mName;
-        QString mAction;
+        TQString mName;
+        TQString mAction;
         Item mInput;
         Item mOutput;
     };
 
     Binding();
-    Binding( const QString &name, const QString &type );
+    Binding( const TQString &name, const TQString &type );
 
-    void setName( const QString &name ) { mName = name; }
-    QString name() const { return mName; }
+    void setName( const TQString &name ) { mName = name; }
+    TQString name() const { return mName; }
 
-    void setType( const QString &type ) { mType = type; }
-    QString type() const { return mType; }
+    void setType( const TQString &type ) { mType = type; }
+    TQString type() const { return mType; }
 
-    void setStyle( const QString &style ) { mStyle = style; }
-    QString style() const { return mStyle; }
+    void setStyle( const TQString &style ) { mStyle = style; }
+    TQString style() const { return mStyle; }
 
-    void setTransport( const QString &transport ) { mTransport = transport; }
-    QString transport() const { return mTransport; }
+    void setTransport( const TQString &transport ) { mTransport = transport; }
+    TQString transport() const { return mTransport; }
 
     void addOperation( const Operation &operation );
-    Operation operation( const QString &name ) const;
+    Operation operation( const TQString &name ) const;
     Operation::List operations() const;
 
   private:
-    QString mName;
-    QString mType;
-    QString mStyle;
-    QString mTransport;
+    TQString mName;
+    TQString mType;
+    TQString mStyle;
+    TQString mTransport;
     Operation::List mOperations;
 };
 
diff --git a/kode/kwsdl/compiler.cpp b/kode/kwsdl/compiler.cpp
index dbbe52b7e..9e4c86ab9 100644
--- a/kode/kwsdl/compiler.cpp
+++ b/kode/kwsdl/compiler.cpp
@@ -19,8 +19,8 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qapplication.h>
-#include <qfile.h>
+#include <tqapplication.h>
+#include <tqfile.h>
 
 #include <schema/fileprovider.h>
 
@@ -32,11 +32,11 @@
 using namespace KWSDL;
 
 Compiler::Compiler()
-  : QObject( 0, "KWSDL::Compiler" )
+  : TQObject( 0, "KWSDL::Compiler" )
 {
 }
 
-void Compiler::setWSDLUrl( const QString &wsdlUrl )
+void Compiler::setWSDLUrl( const TQString &wsdlUrl )
 {
   mWSDLUrl = wsdlUrl;
   mWSDLBaseUrl = mWSDLUrl.left( mWSDLUrl.findRev( '/' ) );
@@ -44,7 +44,7 @@ void Compiler::setWSDLUrl( const QString &wsdlUrl )
   mParser.setSchemaBaseUrl( mWSDLBaseUrl );
 }
 
-void Compiler::setOutputDirectory( const QString &outputDirectory )
+void Compiler::setOutputDirectory( const TQString &outputDirectory )
 {
   mOutputDirectory = outputDirectory;
 
@@ -52,7 +52,7 @@ void Compiler::setOutputDirectory( const QString &outputDirectory )
     mOutputDirectory.append( "/" );
 }
 
-void Compiler::setNameSpace( const QString &nameSpace )
+void Compiler::setNameSpace( const TQString &nameSpace )
 {
   mNameSpace = nameSpace;
 }
@@ -66,18 +66,18 @@ void Compiler::download()
 {
   Schema::FileProvider provider;
 
-  QString fileName;
+  TQString fileName;
   if ( provider.get( mWSDLUrl, fileName ) ) {
-    QFile file( fileName );
+    TQFile file( fileName );
     if ( !file.open( IO_ReadOnly ) ) {
       qDebug( "Unable to download schema file %s", mWSDLUrl.latin1() );
       provider.cleanUp();
       return;
     }
 
-    QString errorMsg;
+    TQString errorMsg;
     int errorLine, errorCol;
-    QDomDocument doc;
+    TQDomDocument doc;
     if ( !doc.setContent( &file, true, &errorMsg, &errorLine, &errorCol ) ) {
       qDebug( "%s at (%d,%d)", errorMsg.latin1(), errorLine, errorCol );
       return;
@@ -89,7 +89,7 @@ void Compiler::download()
   }
 }
 
-void Compiler::parse( const QDomElement &element )
+void Compiler::parse( const TQDomElement &element )
 {
   mParser.parse( element );
   create();
diff --git a/kode/kwsdl/compiler.h b/kode/kwsdl/compiler.h
index 49626ba57..1bb27e1b8 100644
--- a/kode/kwsdl/compiler.h
+++ b/kode/kwsdl/compiler.h
@@ -22,8 +22,8 @@
 #ifndef KWSDL_COMPILER_H
 #define KWSDL_COMPILER_H
 
-#include <qdom.h>
-#include <qobject.h>
+#include <tqdom.h>
+#include <tqobject.h>
 
 #include "parser.h"
 
@@ -36,25 +36,25 @@ class Compiler : public QObject
   public:
     Compiler();
 
-    void setWSDLUrl( const QString &wsdlUrl );
-    void setOutputDirectory( const QString &outputDirectory );
-    void setNameSpace( const QString &nameSpace );
+    void setWSDLUrl( const TQString &wsdlUrl );
+    void setOutputDirectory( const TQString &outputDirectory );
+    void setNameSpace( const TQString &nameSpace );
 
   public slots:
     void run();
 
   private slots:
     void download();
-    void parse( const QDomElement& );
+    void parse( const TQDomElement& );
     void create();
 
   private:
-    QString mWSDLUrl;
-    QString mOutputDirectory;
-    QString mNameSpace;    
+    TQString mWSDLUrl;
+    TQString mOutputDirectory;
+    TQString mNameSpace;    
 
     Parser mParser;
-    QString mWSDLBaseUrl;
+    TQString mWSDLBaseUrl;
 };
 
 }
diff --git a/kode/kwsdl/converter.cpp b/kode/kwsdl/converter.cpp
index fc255d74e..5d824afe3 100644
--- a/kode/kwsdl/converter.cpp
+++ b/kode/kwsdl/converter.cpp
@@ -23,21 +23,21 @@
 
 using namespace KWSDL;
 
-static QString capitalize( const QString &str )
+static TQString capitalize( const TQString &str )
 {
   return str[ 0 ].upper() + str.mid( 1 );
 }
 
-static QString escapeEnum( const QString &str )
+static TQString escapeEnum( const TQString &str )
 {
-  QString enumStr = capitalize( str );
+  TQString enumStr = capitalize( str );
 
   return enumStr.replace( "-", "_" );
 }
 
 Converter::Converter()
 {
-  mQObject = KODE::Class( "QObject" );
+  mQObject = KODE::Class( "TQObject" );
 }
 
 void Converter::setWSDL( const WSDL &wsdl )
@@ -91,7 +91,7 @@ void Converter::convertSimpleType( const Schema::SimpleType *type )
       Use setter and getter method for enums as well.
      */
     if ( type->facetType() & Schema::SimpleType::ENUM ) {
-      QStringList enums = type->facetEnums();
+      TQStringList enums = type->facetEnums();
       for ( uint i = 0; i < enums.count(); ++i )
         enums[ i ] = escapeEnum( enums[ i ] );
 
@@ -123,12 +123,12 @@ void Converter::convertSimpleType( const Schema::SimpleType *type )
          type->baseType() != Schema::XSDType::INVALID &&
          !(type->facetType() & Schema::SimpleType::ENUM) ) {
 
-      const QString baseName = type->baseTypeName();
-      const QString typeName = mTypeMapper.type( baseName );
+      const TQString baseName = type->baseTypeName();
+      const TQString typeName = mTypeMapper.type( baseName );
 
       // include header
-      QMap<QString, QString> headerDec = mTypeMapper.headerDec( baseName );
-      QMap<QString, QString>::ConstIterator it;
+      TQMap<TQString, TQString> headerDec = mTypeMapper.headerDec( baseName );
+      TQMap<TQString, TQString>::ConstIterator it;
       for ( it = headerDec.begin(); it != headerDec.end(); ++it ) {
         if ( !it.key().isEmpty() )
           newClass.addInclude( it.key(), it.data() );
@@ -159,13 +159,13 @@ void Converter::convertSimpleType( const Schema::SimpleType *type )
       newClass.addFunction( getter );
     }
   } else if ( type->subType() == Schema::SimpleType::TypeList ) {
-    newClass.addHeaderInclude( "qptrlist.h" );
-    const QString baseName = type->listTypeName();
-    const QString typeName = mTypeMapper.type( baseName );
+    newClass.addHeaderInclude( "tqptrlist.h" );
+    const TQString baseName = type->listTypeName();
+    const TQString typeName = mTypeMapper.type( baseName );
 
     // include header
-    QMap<QString, QString> headerDec = mTypeMapper.headerDec( baseName );
-    QMap<QString, QString>::ConstIterator it;
+    TQMap<TQString, TQString> headerDec = mTypeMapper.headerDec( baseName );
+    TQMap<TQString, TQString>::ConstIterator it;
     for ( it = headerDec.begin(); it != headerDec.end(); ++it ) {
       if ( !it.key().isEmpty() )
         newClass.addInclude( it.key(), it.data() );
@@ -175,7 +175,7 @@ void Converter::convertSimpleType( const Schema::SimpleType *type )
     }
 
     // member variables
-    KODE::MemberVariable variable( "entries", "QPtrList<" + typeName + ">*" );
+    KODE::MemberVariable variable( "entries", "TQPtrList<" + typeName + ">*" );
     newClass.addMemberVariable( variable );
 
     ctorCode += variable.name() + " = 0;";
@@ -188,7 +188,7 @@ void Converter::convertSimpleType( const Schema::SimpleType *type )
     setter.setBody( variable.name() + " = entries;" );
 
     // getter method
-    KODE::Function getter( "entries", "QPtrList<" + typeName + ">*" );
+    KODE::Function getter( "entries", "TQPtrList<" + typeName + ">*" );
     getter.setBody( " return " + variable.name() + ";" );
     getter.setConst( true );
 
@@ -212,26 +212,26 @@ void Converter::convertSimpleType( const Schema::SimpleType *type )
 
 void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
 {
-  const QString typeName = mTypeMapper.type( type );
-  const QString baseType = mTypeMapper.type( type->baseTypeName() );
+  const TQString typeName = mTypeMapper.type( type );
+  const TQString baseType = mTypeMapper.type( type->baseTypeName() );
 
   KODE::Function marshal( "marshal", "void" );
   marshal.setStatic( true );
-  marshal.addArgument( "QDomDocument &doc" );
-  marshal.addArgument( "QDomElement &parent" );
-  marshal.addArgument( "const QString &name" );
+  marshal.addArgument( "TQDomDocument &doc" );
+  marshal.addArgument( "TQDomElement &parent" );
+  marshal.addArgument( "const TQString &name" );
   marshal.addArgument( "const " + typeName + "* value" );
 
   KODE::Function demarshal( "demarshal", "void" );
   demarshal.setStatic( true );
-  demarshal.addArgument( "const QDomElement &parent" );
+  demarshal.addArgument( "const TQDomElement &parent" );
   demarshal.addArgument( typeName + "* value" );
 
   KODE::Code marshalCode, demarshalCode, code;
 
   // include header
-  QMap<QString, QString> headerDec = mTypeMapper.headerDec( type->name() );
-  QMap<QString, QString>::ConstIterator it;
+  TQMap<TQString, TQString> headerDec = mTypeMapper.headerDec( type->name() );
+  TQMap<TQString, TQString>::ConstIterator it;
   for ( it = headerDec.begin(); it != headerDec.end(); ++it ) {
     if ( !it.key().isEmpty() )
       mSerializer.addInclude( it.key(), it.data() );
@@ -243,13 +243,13 @@ void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
   if ( type->subType() == Schema::SimpleType::TypeRestriction ) {
     // is an enumeration
     if ( type->facetType() & Schema::SimpleType::ENUM ) {
-      QStringList enums = type->facetEnums();
-      QStringList escapedEnums;
+      TQStringList enums = type->facetEnums();
+      TQStringList escapedEnums;
       for ( uint i = 0; i < enums.count(); ++i )
         escapedEnums.append( escapeEnum( enums[ i ] ) );
 
       // marshal value
-      KODE::Function marshalValue( "marshalValue", "QString" );
+      KODE::Function marshalValue( "marshalValue", "TQString" );
       marshalValue.setStatic( true );
       marshalValue.addArgument( "const " + typeName + "* value" );
       code += "switch ( value->type() ) {";
@@ -269,11 +269,11 @@ void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
       code.unindent();
       code += "}";
       code.newLine();
-      code += "return QString();";
+      code += "return TQString();";
       marshalValue.setBody( code );
 
       // marshal
-      marshalCode += "QDomElement root = doc.createElement( name );";
+      marshalCode += "TQDomElement root = doc.createElement( name );";
       marshalCode += "root.setAttribute( \"xsi:type\", \"ns1:" + type->name() + "\" );";
       marshalCode += "parent.appendChild( root );";
       marshalCode += "root.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );";
@@ -281,7 +281,7 @@ void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
       // demarshal value
       KODE::Function demarshalValue( "demarshalValue", "void" );
       demarshalValue.setStatic( true );
-      demarshalValue.addArgument( "const QString &str" );
+      demarshalValue.addArgument( "const TQString &str" );
       demarshalValue.addArgument( typeName + "* value" );
       code.clear();
       for ( uint i = 0; i < enums.count(); ++i ) {
@@ -305,7 +305,7 @@ void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
       marshalCode.unindent();
       marshalCode += "}";
 
-      demarshalCode += "const QString text = parent.text();";
+      demarshalCode += "const TQString text = parent.text();";
       demarshalCode.newLine();
       demarshalCode += "if ( !text.isEmpty() ) {";
       demarshalCode.indent();
@@ -315,7 +315,7 @@ void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
       demarshalCode.unindent();
       demarshalCode += "}";
 
-      KODE::Function marshalValue( "marshalValue", "QString" );
+      KODE::Function marshalValue( "marshalValue", "TQString" );
       marshalValue.setStatic( true );
       marshalValue.addArgument( "const " + typeName + "* value" );
       marshalValue.setBody( "return Serializer::marshalValue( value->value() );" );
@@ -324,7 +324,7 @@ void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
 
       KODE::Function demarshalValue( "demarshalValue", "void" );
       demarshalValue.setStatic( true );
-      demarshalValue.addArgument( "const QString &str" );
+      demarshalValue.addArgument( "const TQString &str" );
       demarshalValue.addArgument( typeName + "* value" );
       KODE::Code code;
       code += baseType + "* data = new " + baseType + ";";
@@ -335,15 +335,15 @@ void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
       mSerializer.addFunction( demarshalValue );
     }
   } else if ( type->subType() == Schema::SimpleType::TypeList ) {
-    const QString listType = mTypeMapper.type( type->listTypeName() );
+    const TQString listType = mTypeMapper.type( type->listTypeName() );
 
-    mSerializer.addInclude( "qstringlist.h" );
+    mSerializer.addInclude( "tqstringlist.h" );
 
     marshalCode += "if ( value->entries() ) {";
     marshalCode.indent();
-    marshalCode += "QStringList list;";
-    marshalCode += "QPtrList<" + listType + ">* entries = value->entries();";
-    marshalCode += "QPtrListIterator<" + listType + "> it( *entries );";
+    marshalCode += "TQStringList list;";
+    marshalCode += "TQPtrList<" + listType + ">* entries = value->entries();";
+    marshalCode += "TQPtrListIterator<" + listType + "> it( *entries );";
     marshalCode += "while ( it.current() != 0 ) {";
     marshalCode.indent();
     marshalCode += "list.append( Serializer::marshalValue( it.current() ) );";
@@ -351,18 +351,18 @@ void Converter::createSimpleTypeSerializer( const Schema::SimpleType *type )
     marshalCode.unindent();
     marshalCode += "}";
     marshalCode.newLine();
-    marshalCode += "QDomElement element = doc.createElement( name );";
+    marshalCode += "TQDomElement element = doc.createElement( name );";
     marshalCode += "parent.appendChild( element );";
     marshalCode += "element.appendChild( doc.createTextNode( list.join( \" \" ) ) );";
     marshalCode.unindent();
     marshalCode += "}";
 
-    demarshalCode += "const QStringList list = QStringList::split( \" \", parent.text(), false );";
+    demarshalCode += "const TQStringList list = TQStringList::split( \" \", parent.text(), false );";
     demarshalCode += "if ( !list.isEmpty() ) {";
     demarshalCode.indent();
-    demarshalCode += "QPtrList<" + listType + ">* entries = new QPtrList<" + listType + ">;";
+    demarshalCode += "TQPtrList<" + listType + ">* entries = new TQPtrList<" + listType + ">;";
     demarshalCode += "entries->setAutoDelete( true );";
-    demarshalCode += "QStringList::ConstIterator it;";
+    demarshalCode += "TQStringList::ConstIterator it;";
     demarshalCode += "for ( it = list.begin(); it != list.end(); ++it ) {";
     demarshalCode.indent();
     demarshalCode += listType + " *entry = new " + listType + ";";
@@ -391,7 +391,7 @@ void Converter::convertComplexType( const Schema::ComplexType *type )
   KODE::Code ctorCode, dtorCode;
 
   if ( type->baseType() != Schema::XSDType::ANYTYPE && !type->isArray() ) {
-    QString baseName = mTypeMapper.type( type->baseTypeName() );
+    TQString baseName = mTypeMapper.type( type->baseTypeName() );
     newClass.addBaseClass( KODE::Class( baseName ) );
     newClass.addHeaderIncludes( mTypeMapper.header( type->baseTypeName() ) );
   }
@@ -403,10 +403,10 @@ void Converter::convertComplexType( const Schema::ComplexType *type )
   Schema::Element::List elements = type->elements();
   Schema::Element::List::ConstIterator elemIt;
   for ( elemIt = elements.begin(); elemIt != elements.end(); ++elemIt ) {
-    QString typeName = mTypeMapper.type( &*elemIt );
+    TQString typeName = mTypeMapper.type( &*elemIt );
 
     if ( (*elemIt).maxOccurs() > 1 )
-      typeName = "QPtrList<" + typeName + ">";
+      typeName = "TQPtrList<" + typeName + ">";
 
     // member variables
     KODE::MemberVariable variable( (*elemIt).name(), typeName + "*" );
@@ -416,8 +416,8 @@ void Converter::convertComplexType( const Schema::ComplexType *type )
     dtorCode += "delete " + variable.name() + ";";
     dtorCode += variable.name() + " = 0;";
 
-    QString upperName = (*elemIt).name();
-    QString lowerName = (*elemIt).name();
+    TQString upperName = (*elemIt).name();
+    TQString lowerName = (*elemIt).name();
     upperName[ 0 ] = upperName[ 0 ].upper();
     lowerName[ 0 ] = lowerName[ 0 ].lower();
 
@@ -435,8 +435,8 @@ void Converter::convertComplexType( const Schema::ComplexType *type )
     newClass.addFunction( getter );
 
     // include header
-    QMap<QString, QString> headerDec = mTypeMapper.headerDec( &*elemIt);
-    QMap<QString, QString>::ConstIterator it;
+    TQMap<TQString, TQString> headerDec = mTypeMapper.headerDec( &*elemIt);
+    TQMap<TQString, TQString>::ConstIterator it;
     for ( it = headerDec.begin(); it != headerDec.end(); ++it ) {
       if ( !it.key().isEmpty() )
         newClass.addInclude( it.key(), it.data() );
@@ -450,7 +450,7 @@ void Converter::convertComplexType( const Schema::ComplexType *type )
   Schema::Attribute::List attributes = type->attributes();
   Schema::Attribute::List::ConstIterator attrIt;
   for ( attrIt = attributes.begin(); attrIt != attributes.end(); ++attrIt ) {
-    const QString typeName = mTypeMapper.type( &*attrIt );
+    const TQString typeName = mTypeMapper.type( &*attrIt );
 
     // member variables
     KODE::MemberVariable variable( (*attrIt).name(), typeName + "*" );
@@ -460,8 +460,8 @@ void Converter::convertComplexType( const Schema::ComplexType *type )
     dtorCode += "delete " + variable.name() + ";";
     dtorCode += variable.name() + " = 0;";
 
-    QString upperName = (*attrIt).name();
-    QString lowerName = (*attrIt).name();
+    TQString upperName = (*attrIt).name();
+    TQString lowerName = (*attrIt).name();
     upperName[ 0 ] = upperName[ 0 ].upper();
     lowerName[ 0 ] = lowerName[ 0 ].lower();
 
@@ -479,8 +479,8 @@ void Converter::convertComplexType( const Schema::ComplexType *type )
     newClass.addFunction( getter );
 
     // include header
-    QMap<QString, QString> headerDec = mTypeMapper.headerDec( &*attrIt);
-    QMap<QString, QString>::ConstIterator it;
+    TQMap<TQString, TQString> headerDec = mTypeMapper.headerDec( &*attrIt);
+    TQMap<TQString, TQString>::ConstIterator it;
     for ( it = headerDec.begin(); it != headerDec.end(); ++it ) {
       if ( !it.key().isEmpty() )
         newClass.addInclude( it.key(), it.data() );
@@ -506,25 +506,25 @@ void Converter::convertComplexType( const Schema::ComplexType *type )
 
 void Converter::createComplexTypeSerializer( const Schema::ComplexType *type )
 {
-  const QString typeName = mTypeMapper.type( type );
+  const TQString typeName = mTypeMapper.type( type );
 
   KODE::Function marshal( "marshal", "void" );
   marshal.setStatic( true );
-  marshal.addArgument( "QDomDocument &doc" );
-  marshal.addArgument( "QDomElement &parent" );
-  marshal.addArgument( "const QString &name" );
+  marshal.addArgument( "TQDomDocument &doc" );
+  marshal.addArgument( "TQDomElement &parent" );
+  marshal.addArgument( "const TQString &name" );
   marshal.addArgument( "const " + typeName + "* value" );
 
   KODE::Function demarshal( "demarshal", "void" );
   demarshal.setStatic( true );
-  demarshal.addArgument( "const QDomElement &parent" );
+  demarshal.addArgument( "const TQDomElement &parent" );
   demarshal.addArgument( typeName + "* value" );
 
   KODE::Code marshalCode, demarshalCode, demarshalFinalCode;
 
   // include header
-  QMap<QString, QString> headerDec = mTypeMapper.headerDec( type->name() );
-  QMap<QString, QString>::ConstIterator it;
+  TQMap<TQString, TQString> headerDec = mTypeMapper.headerDec( type->name() );
+  TQMap<TQString, TQString>::ConstIterator it;
   for ( it = headerDec.begin(); it != headerDec.end(); ++it ) {
     if ( !it.key().isEmpty() )
       mSerializer.addInclude( it.key(), it.data() );
@@ -533,14 +533,14 @@ void Converter::createComplexTypeSerializer( const Schema::ComplexType *type )
       mSerializer.addHeaderInclude( it.key() );
   }
 
-  marshalCode += "QDomElement root = doc.createElement( name );";
+  marshalCode += "TQDomElement root = doc.createElement( name );";
   marshalCode += "root.setAttribute( \"xsi:type\", \"ns1:" + typeName + "\" );";
   marshalCode += "parent.appendChild( root );";
 
-  demarshalCode += "QDomNode node = parent.firstChild();";
+  demarshalCode += "TQDomNode node = parent.firstChild();";
   demarshalCode += "while ( !node.isNull() ) {";
   demarshalCode.indent();
-  demarshalCode += "QDomElement element = node.toElement();";
+  demarshalCode += "TQDomElement element = node.toElement();";
   demarshalCode += "if ( !element.isNull() ) {";
   demarshalCode.indent();
 
@@ -548,10 +548,10 @@ void Converter::createComplexTypeSerializer( const Schema::ComplexType *type )
   Schema::Element::List elements = type->elements();
   Schema::Element::List::ConstIterator elemIt;
   for ( elemIt = elements.begin(); elemIt != elements.end(); ++elemIt ) {
-    const QString typeName = mTypeMapper.type( &*elemIt );
+    const TQString typeName = mTypeMapper.type( &*elemIt );
 
-    QString upperName = (*elemIt).name();
-    QString lowerName = (*elemIt).name();
+    TQString upperName = (*elemIt).name();
+    TQString lowerName = (*elemIt).name();
     upperName[ 0 ] = upperName[ 0 ].upper();
     lowerName[ 0 ] = lowerName[ 0 ].lower();
 
@@ -561,16 +561,16 @@ void Converter::createComplexTypeSerializer( const Schema::ComplexType *type )
     if ( (*elemIt).maxOccurs() > 1 ) {
       marshalCode += "if ( value->" + mNameMapper.escape( lowerName ) + "() ) {";
       marshalCode.indent();
-      marshalCode += "const QPtrList<" + typeName + ">* list = value->" + mNameMapper.escape( lowerName ) + "();";
+      marshalCode += "const TQPtrList<" + typeName + ">* list = value->" + mNameMapper.escape( lowerName ) + "();";
       marshalCode.newLine();
-      marshalCode += "QDomElement element = doc.createElement( name );";
+      marshalCode += "TQDomElement element = doc.createElement( name );";
       // no idea about the namespaces here...
       marshalCode += "element.setAttribute( \"xmlns:ns1\", \"http://schemas.xmlsoap.org/soap/encoding/\" );";
       marshalCode += "element.setAttribute( \"xsi:type\", \"ns1:Array\" );";
-      marshalCode += "element.setAttribute( \"ns1:arrayType\", \"ns1:" + typeName + "[\" + QString::number( list->count() ) + \"]\" );";
+      marshalCode += "element.setAttribute( \"ns1:arrayType\", \"ns1:" + typeName + "[\" + TQString::number( list->count() ) + \"]\" );";
       marshalCode += "parent.appendChild( element );";
       marshalCode.newLine();
-      marshalCode += "QPtrListIterator<" + typeName + "> it( *list );";
+      marshalCode += "TQPtrListIterator<" + typeName + "> it( *list );";
       marshalCode += "while ( it.current() != 0 ) {";
       marshalCode.indent();
       marshalCode += "Serializer::marshal( doc, element, \"item\", it.current() );";
@@ -580,10 +580,10 @@ void Converter::createComplexTypeSerializer( const Schema::ComplexType *type )
       marshalCode.unindent();
       marshalCode += "}";
 
-      const QString listName = mNameMapper.escape( lowerName ) + "List";
+      const TQString listName = mNameMapper.escape( lowerName ) + "List";
       // TODO: prepend the code somehow
       KODE::Code code;
-      code += "QPtrList<" + typeName + ">* " + listName + " = new QPtrList<" + typeName + ">();";
+      code += "TQPtrList<" + typeName + ">* " + listName + " = new TQPtrList<" + typeName + ">();";
       code += listName + "->setAutoDelete( true );";
       code += demarshalCode;
       demarshalCode = code;
@@ -617,10 +617,10 @@ void Converter::createComplexTypeSerializer( const Schema::ComplexType *type )
   Schema::Attribute::List attributes = type->attributes();
   Schema::Attribute::List::ConstIterator attrIt;
   for ( attrIt = attributes.begin(); attrIt != attributes.end(); ++attrIt ) {
-    const QString typeName = mTypeMapper.type( &*attrIt );
+    const TQString typeName = mTypeMapper.type( &*attrIt );
 
-    QString upperName = (*attrIt).name();
-    QString lowerName = (*attrIt).name();
+    TQString upperName = (*attrIt).name();
+    TQString lowerName = (*attrIt).name();
     upperName[ 0 ] = upperName[ 0 ].upper();
     lowerName[ 0 ] = lowerName[ 0 ].lower();
 
@@ -661,8 +661,8 @@ void Converter::convertService( const Service &service )
 {
   KODE::Class newClass( service.name() );
   newClass.addBaseClass( mQObject );
-  newClass.addHeaderInclude( "qobject.h" );
-  newClass.addHeaderInclude( "qstring.h" );
+  newClass.addHeaderInclude( "tqobject.h" );
+  newClass.addHeaderInclude( "tqstring.h" );
   newClass.addHeaderInclude( "transport.h" );
 
   newClass.addInclude( "serializer.h" );
@@ -689,9 +689,9 @@ void Converter::convertService( const Service &service )
       KODE::MemberVariable transport( inputMessage.name() + "Transport", "Transport" );
       ctorCode += transport.name() + " = new Transport( \"" + (*it).mLocation + "\" );";
 
-      ctorCode += "connect( " + transport.name() + ", SIGNAL( result( const QString& ) ),";
+      ctorCode += "connect( " + transport.name() + ", TQT_SIGNAL( result( const TQString& ) ),";
       ctorCode.indent();
-      ctorCode += "this, SLOT( " + outputMessage.name() + "Slot( const QString& ) ) );";
+      ctorCode += "this, TQT_SLOT( " + outputMessage.name() + "Slot( const TQString& ) ) );";
       ctorCode.unindent();
 
       dtorCode += "delete " + transport.name() + ";";
@@ -714,7 +714,7 @@ void Converter::convertInputMessage( const Port &port, const Message &message, K
   newClass.addMemberVariable( transport );
 
   // call
-  QString messageName = message.name();
+  TQString messageName = message.name();
   messageName[ 0 ] = messageName[ 0 ].lower();
   KODE::Function callFunc( mNameMapper.escape( messageName ), "void", KODE::Function::Public );
 
@@ -722,30 +722,30 @@ void Converter::convertInputMessage( const Port &port, const Message &message, K
   Message::Part::List::ConstIterator it;
   for ( it = parts.begin(); it != parts.end(); ++it ) {
     newClass.addHeaderIncludes( mTypeMapper.header( (*it).type() ) );
-    QString lowerName = (*it).name();
+    TQString lowerName = (*it).name();
     lowerName[ 0 ] = lowerName[ 0 ].lower();
     callFunc.addArgument( mTypeMapper.argument( mNameMapper.escape( lowerName ), (*it).type() ) );
   }
 
   KODE::Code code;
-  code += "QDomDocument doc( \"kwsdl\" );";
+  code += "TQDomDocument doc( \"kwsdl\" );";
   code += "doc.appendChild( doc.createProcessingInstruction( \"xml\", \"version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"\" ) );";
-  code += "QDomElement env = doc.createElement( \"SOAP-ENV:Envelope\" );";
+  code += "TQDomElement env = doc.createElement( \"SOAP-ENV:Envelope\" );";
   code += "env.setAttribute( \"xmlns:SOAP-ENV\", \"http://schemas.xmlsoap.org/soap/envelope/\" );";
   code += "env.setAttribute( \"xmlns:xsi\", \"http://www.w3.org/1999/XMLSchema-instance\" );";
   code += "env.setAttribute( \"xmlns:xsd\", \"http://www.w3.org/1999/XMLSchema\" );";
   code += "doc.appendChild( env );";
-  code += "QDomElement body = doc.createElement( \"SOAP-ENV:Body\" );";
+  code += "TQDomElement body = doc.createElement( \"SOAP-ENV:Body\" );";
   code += "env.appendChild( body );";
-  code += "QDomElement method = doc.createElement( \"ns1:" + message.name() + "\" );";
-  QString nameSpace = mWSDL.findBindingOperation( port.name(), message.name() ).input().nameSpace();
+  code += "TQDomElement method = doc.createElement( \"ns1:" + message.name() + "\" );";
+  TQString nameSpace = mWSDL.findBindingOperation( port.name(), message.name() ).input().nameSpace();
   code += "method.setAttribute( \"xmlns:ns1\", \"" + nameSpace + "\" );";
   code += "method.setAttribute( \"SOAP-ENV:encodingStyle\", \"http://schemas.xmlsoap.org/soap/encoding/\" );";
   code += "body.appendChild( method );";
   code.newLine();
 
   for ( it = parts.begin(); it != parts.end(); ++it ) {
-    QString lowerName = (*it).name();
+    TQString lowerName = (*it).name();
     lowerName[ 0 ] = lowerName[ 0 ].lower();
     code += "Serializer::marshal( doc, method, \"" + (*it).name() + "\", " + mNameMapper.escape( lowerName ) + " );";
     code += "delete " + mNameMapper.escape( lowerName ) + ";";
@@ -763,7 +763,7 @@ void Converter::convertOutputMessage( const Port&, const Message &message, KODE:
   Message::Part part = message.parts().first();
 
   // signal
-  QString messageName = message.name();
+  TQString messageName = message.name();
   messageName[ 0 ] = messageName[ 0 ].lower();
   KODE::Function respSignal( messageName, "void", KODE::Function::Signal );
 
@@ -777,7 +777,7 @@ void Converter::convertOutputMessage( const Port&, const Message &message, KODE:
   const Message::Part::List parts = message.parts();
   Message::Part::List::ConstIterator it;
   for ( it = parts.begin(); it != parts.end(); ++it ) {
-    QStringList headers = mTypeMapper.header( (*it).type() );
+    TQStringList headers = mTypeMapper.header( (*it).type() );
     for ( uint i = 0; i < headers.count(); ++i )
       if ( !headers[ i ].isEmpty() )
         newClass.addHeaderInclude( headers[ i ] );
@@ -789,11 +789,11 @@ void Converter::convertOutputMessage( const Port&, const Message &message, KODE:
 
   // slot
   KODE::Function respSlot( messageName + "Slot", "void", KODE::Function::Slot | KODE::Function::Private );
-  respSlot.addArgument( "const QString &xml" );
+  respSlot.addArgument( "const TQString &xml" );
 
   KODE::Code code;
-  code += "QDomDocument doc;";
-  code += "QString errorMsg;";
+  code += "TQDomDocument doc;";
+  code += "TQString errorMsg;";
   code += "int column, row;";
   code.newLine();
   code += "qDebug( \"%s\", xml.latin1() );";
@@ -806,9 +806,9 @@ void Converter::convertOutputMessage( const Port&, const Message &message, KODE:
   code += "}";
   code.newLine();
   code += mTypeMapper.type( part.type() ) + "* value = new " + mTypeMapper.type( part.type() ) + ";";
-  code += "QDomElement envelope = doc.documentElement();";
-  code += "QDomElement body = envelope.firstChild().toElement();";
-  code += "QDomElement method = body.firstChild().toElement();";
+  code += "TQDomElement envelope = doc.documentElement();";
+  code += "TQDomElement body = envelope.firstChild().toElement();";
+  code += "TQDomElement method = body.firstChild().toElement();";
   code += "Serializer::demarshal( method.firstChild().toElement(), value );";
   code.newLine();
   code += "emit " + respSignal.name() + "( value );";
@@ -820,18 +820,18 @@ void Converter::convertOutputMessage( const Port&, const Message &message, KODE:
 void Converter::createUtilClasses()
 {
   mSerializer = KODE::Class( "Serializer" );
-  mSerializer.addHeaderInclude( "qcstring.h" );
-  mSerializer.addHeaderInclude( "qdom.h" );
-  mSerializer.addHeaderInclude( "qdatetime.h" );
-  mSerializer.addHeaderInclude( "qstring.h" );
-  mSerializer.addHeaderInclude( "qptrlist.h" );
+  mSerializer.addHeaderInclude( "tqcstring.h" );
+  mSerializer.addHeaderInclude( "tqdom.h" );
+  mSerializer.addHeaderInclude( "tqdatetime.h" );
+  mSerializer.addHeaderInclude( "tqstring.h" );
+  mSerializer.addHeaderInclude( "tqptrlist.h" );
   mSerializer.addInclude( "kmdcodec.h" );
 
   typedef struct {
-    QString type;
-    QString xsdType;
-    QString marshalCode;
-    QString demarshalCode;
+    TQString type;
+    TQString xsdType;
+    TQString marshalCode;
+    TQString demarshalCode;
   } TypeEntry;
 
   /**
@@ -839,18 +839,18 @@ void Converter::createUtilClasses()
     of typing and is easier to maintain at the end ;)
    */
   TypeEntry types[] = {
-    { "QString", "xsd:string", "*value", "str" },
+    { "TQString", "xsd:string", "*value", "str" },
     { "bool", "xsd:boolean", "(*value ? \"true\" : \"false\")", "(str.lower() == \"true\" ? true : false)" },
-    { "float", "xsd:TODO", "QString::number( *value )", "str.toFloat()" },
-    { "int", "xsd:int", "QString::number( *value )", "str.toInt()" },
-    { "unsigned int", "xsd:unsignedByte", "QString::number( *value )", "str.toUInt()" },
-    { "double", "xsd:double", "QString::number( *value )", "str.toDouble()" },
-    { "char", "xsd:byte", "QString( QChar( *value ) )", "str[ 0 ].latin1()" },
-    { "unsigned char", "xsd:unsignedByte", "QString( QChar( *value ) )", "str[ 0 ].latin1()" },
-    { "short", "xsd:short", "QString::number( *value )", "str.toShort()" },
-    { "QByteArray", "xsd:base64Binary", "QString::fromUtf8( KCodecs::base64Encode( *value ) )", "KCodecs::base64Decode( str.utf8() )" },
-    { "QDateTime", "xsd:dateTime", "value->toString( Qt::ISODate )", "QDateTime::fromString( str, Qt::ISODate )" },
-    { "QDate", "xsd:date", "value->toString( Qt::ISODate )", "QDate::fromString( str, Qt::ISODate )" }
+    { "float", "xsd:TODO", "TQString::number( *value )", "str.toFloat()" },
+    { "int", "xsd:int", "TQString::number( *value )", "str.toInt()" },
+    { "unsigned int", "xsd:unsignedByte", "TQString::number( *value )", "str.toUInt()" },
+    { "double", "xsd:double", "TQString::number( *value )", "str.toDouble()" },
+    { "char", "xsd:byte", "TQString( TQChar( *value ) )", "str[ 0 ].latin1()" },
+    { "unsigned char", "xsd:unsignedByte", "TQString( TQChar( *value ) )", "str[ 0 ].latin1()" },
+    { "short", "xsd:short", "TQString::number( *value )", "str.toShort()" },
+    { "TQByteArray", "xsd:base64Binary", "TQString::fromUtf8( KCodecs::base64Encode( *value ) )", "KCodecs::base64Decode( str.utf8() )" },
+    { "TQDateTime", "xsd:dateTime", "value->toString( Qt::ISODate )", "TQDateTime::fromString( str, Qt::ISODate )" },
+    { "TQDate", "xsd:date", "value->toString( Qt::ISODate )", "TQDate::fromString( str, Qt::ISODate )" }
   };
 
   for ( uint i = 0; i < sizeof( types ) / sizeof( TypeEntry ); ++i ) {
@@ -859,7 +859,7 @@ void Converter::createUtilClasses()
 
     TypeEntry entry = types[ i ]; 
 
-    marshal = KODE::Function( "marshalValue", "QString" );
+    marshal = KODE::Function( "marshalValue", "TQString" );
     marshal.setStatic( true );
     marshal.addArgument( "const " + entry.type + "* value" );
 
@@ -870,7 +870,7 @@ void Converter::createUtilClasses()
 
     demarshal = KODE::Function( "demarshalValue", "void" );
     demarshal.setStatic( true );
-    demarshal.addArgument( "const QString &str" );
+    demarshal.addArgument( "const TQString &str" );
     demarshal.addArgument( entry.type + " *value" );
     demarshal.setBody( "*value = " + entry.demarshalCode + ";" );
 
@@ -878,13 +878,13 @@ void Converter::createUtilClasses()
 
     marshal = KODE::Function( "marshal", "void" );
     marshal.setStatic( true );
-    marshal.addArgument( "QDomDocument &doc" );
-    marshal.addArgument( "QDomElement &parent" );
-    marshal.addArgument( "const QString &name" );
+    marshal.addArgument( "TQDomDocument &doc" );
+    marshal.addArgument( "TQDomElement &parent" );
+    marshal.addArgument( "const TQString &name" );
     marshal.addArgument( "const " + entry.type + "* value" );
 
     code.clear();
-    code += "QDomElement element = doc.createElement( name );";
+    code += "TQDomElement element = doc.createElement( name );";
     code += "element.setAttribute( \"xsi:type\", \"" + entry.xsdType + "\" );";
     code += "element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );";
     code += "parent.appendChild( element );";
@@ -894,7 +894,7 @@ void Converter::createUtilClasses()
 
     demarshal = KODE::Function( "demarshal", "void" );
     demarshal.setStatic( true );
-    demarshal.addArgument( "const QDomElement &element" );
+    demarshal.addArgument( "const TQDomElement &element" );
     demarshal.addArgument( entry.type + "* value" );
     demarshal.setBody( "Serializer::demarshalValue( element.text(), value );" );
 
@@ -906,33 +906,33 @@ void Converter::createTransportClass()
 {
   KODE::Class transport( "Transport" );
   transport.addBaseClass( mQObject );
-  transport.addHeaderInclude( "qobject.h" );
+  transport.addHeaderInclude( "tqobject.h" );
   transport.addHeaderInclude( "kio/job.h" );
 
   transport.addInclude( "kdebug.h" );
 
-  KODE::MemberVariable url( "url", "QString" );
+  KODE::MemberVariable url( "url", "TQString" );
   transport.addMemberVariable( url );
 
-  KODE::MemberVariable slotDataVar( "data", "QByteArray" );
+  KODE::MemberVariable slotDataVar( "data", "TQByteArray" );
   transport.addMemberVariable( slotDataVar );
 
   // ctor
   KODE::Function ctor( "Transport" );
-  ctor.addArgument( "const QString &url" );
+  ctor.addArgument( "const TQString &url" );
   ctor.setBody( url.name() + " = url;" );
 
   transport.addFunction( ctor );
 
   // query
   KODE::Function query( "query", "void" );
-  query.addArgument( "const QString &xml" );
+  query.addArgument( "const TQString &xml" );
 
   KODE::Code queryCode;
   queryCode += slotDataVar.name() + ".truncate( 0 );";
   queryCode.newLine();
-  queryCode += "QByteArray postData;";
-  queryCode += "QDataStream stream( postData, IO_WriteOnly );";
+  queryCode += "TQByteArray postData;";
+  queryCode += "TQDataStream stream( postData, IO_WriteOnly );";
   queryCode += "stream.writeRawBytes( xml.utf8(), xml.utf8().length() );";
   queryCode.newLine();
   queryCode += "KIO::TransferJob* job = KIO::http_post( KURL( " + url.name() + " ), postData, false );";
@@ -946,8 +946,8 @@ void Converter::createTransportClass()
   queryCode += "job->addMetaData( \"UserAgent\", \"KWSDL\" );";
   queryCode += "job->addMetaData( \"content-type\", \"Content-Type: text/xml; charset=utf-8\" );";
   queryCode.newLine();
-  queryCode += "connect( job, SIGNAL( data( KIO::Job*, const QByteArray& ) ), this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );";
-  queryCode += "connect( job, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotResult( KIO::Job* ) ) );";
+  queryCode += "connect( job, TQT_SIGNAL( data( KIO::Job*, const TQByteArray& ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray& ) ) );";
+  queryCode += "connect( job, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( slotResult( KIO::Job* ) ) );";
 
   query.setBody( queryCode );
 
@@ -955,7 +955,7 @@ void Converter::createTransportClass()
 
   // signal
   KODE::Function result( "result", "void", KODE::Function::Signal );
-  result.addArgument( "const QString &xml" );
+  result.addArgument( "const TQString &xml" );
 
   transport.addFunction( result );
 
@@ -963,7 +963,7 @@ void Converter::createTransportClass()
   KODE::Function slotData( "slotData", "void", KODE::Function::Private | KODE::Function::Slot );
 
   slotData.addArgument( "KIO::Job*" );
-  slotData.addArgument( "const QByteArray &data" );
+  slotData.addArgument( "const TQByteArray &data" );
 
   KODE::Code slotDataCode;
   slotDataCode += "unsigned int oldSize = " + slotDataVar.name() + ".size();";
@@ -988,7 +988,7 @@ void Converter::createTransportClass()
   slotResultCode += "}";
   slotResultCode.newLine();
 
-  slotResultCode += "emit result( QString::fromUtf8( " + slotDataVar.name() + ".data(), " + slotDataVar.name() + ".size() ) );";
+  slotResultCode += "emit result( TQString::fromUtf8( " + slotDataVar.name() + ".data(), " + slotDataVar.name() + ".size() ) );";
 
   slotResult.setBody( slotResultCode );
 
diff --git a/kode/kwsdl/creator.cpp b/kode/kwsdl/creator.cpp
index 53e82937e..32e7eb4b5 100644
--- a/kode/kwsdl/creator.cpp
+++ b/kode/kwsdl/creator.cpp
@@ -36,7 +36,7 @@ void Creator::create( const KODE::Class::List &list )
   KODE::Printer printer;
   printer.setOutputDirectory( mOutputDirectory );
 
-  QStringList cppFiles;
+  TQStringList cppFiles;
 
   KODE::Class::List::ConstIterator it;
   for ( it = list.begin(); it != list.end(); ++it ) {
diff --git a/kode/kwsdl/creator.h b/kode/kwsdl/creator.h
index 465c3302a..776b592df 100644
--- a/kode/kwsdl/creator.h
+++ b/kode/kwsdl/creator.h
@@ -31,17 +31,17 @@ class Creator
   public:
     Creator();
 
-    void setOutputDirectory( const QString &outputDirectory ) { mOutputDirectory = outputDirectory; }
-    QString outputDirectory() const { return mOutputDirectory; }
+    void setOutputDirectory( const TQString &outputDirectory ) { mOutputDirectory = outputDirectory; }
+    TQString outputDirectory() const { return mOutputDirectory; }
 
-    void setNameSpace( const QString &nameSpace ) { mNameSpace = nameSpace; }
-    QString nameSpace() const { return mNameSpace; }
+    void setNameSpace( const TQString &nameSpace ) { mNameSpace = nameSpace; }
+    TQString nameSpace() const { return mNameSpace; }
 
     void create( const KODE::Class::List &list );
 
   private:
-    QString mOutputDirectory;
-    QString mNameSpace;
+    TQString mOutputDirectory;
+    TQString mNameSpace;
 };
 
 }
diff --git a/kode/kwsdl/kung/binaryinputfield.cpp b/kode/kwsdl/kung/binaryinputfield.cpp
index f83e55b1f..56643b3d2 100644
--- a/kode/kwsdl/kung/binaryinputfield.cpp
+++ b/kode/kwsdl/kung/binaryinputfield.cpp
@@ -29,23 +29,23 @@
 #include <kparts/componentfactory.h>
 #include <ktempfile.h>
 
-#include <qfile.h>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qpushbutton.h>
-#include <qwidget.h>
+#include <tqfile.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqpushbutton.h>
+#include <tqwidget.h>
 
 #include <schema/simpletype.h>
 
 #include "binaryinputfield.h"
 
-BinaryInputField::BinaryInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type )
+BinaryInputField::BinaryInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type )
   : SimpleInputField( name, type ),
     mValue( 0 ), mTypeName( typeName )
 {
 }
 
-void BinaryInputField::setXMLData( const QDomElement &element )
+void BinaryInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "BinaryInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -55,28 +55,28 @@ void BinaryInputField::setXMLData( const QDomElement &element )
   setData( element.text() );
 }
 
-void BinaryInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void BinaryInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
   element.setAttribute( "xsi:type", "xsd:" + mTypeName );
-  QDomText text = document.createTextNode( data() );
+  TQDomText text = document.createTextNode( data() );
   element.appendChild( text );
 
   parent.appendChild( element );
 }
 
-void BinaryInputField::setData( const QString &data )
+void BinaryInputField::setData( const TQString &data )
 {
   KCodecs::base64Decode( data.utf8(), mValue );
 }
 
-QString BinaryInputField::data() const
+TQString BinaryInputField::data() const
 {
-  QByteArray data = KCodecs::base64Encode( mValue, false );
-  return QString::fromUtf8( data.data(), data.size() );
+  TQByteArray data = KCodecs::base64Encode( mValue, false );
+  return TQString::fromUtf8( data.data(), data.size() );
 }
 
-QWidget *BinaryInputField::createWidget( QWidget *parent )
+TQWidget *BinaryInputField::createWidget( TQWidget *parent )
 {
   mInputWidget = new BinaryWidget( parent );
 
@@ -86,7 +86,7 @@ QWidget *BinaryInputField::createWidget( QWidget *parent )
   return mInputWidget;
 }
 
-void BinaryInputField::valueChanged( const QByteArray &value )
+void BinaryInputField::valueChanged( const TQByteArray &value )
 {
   mValue = value;
 
@@ -94,27 +94,27 @@ void BinaryInputField::valueChanged( const QByteArray &value )
 }
 
 
-BinaryWidget::BinaryWidget( QWidget *parent )
-  : QWidget( parent, "BinaryWidget" ),
+BinaryWidget::BinaryWidget( TQWidget *parent )
+  : TQWidget( parent, "BinaryWidget" ),
     mMainWidget( 0 )
 {
-  mLayout = new QGridLayout( this, 3, 2, 11, 6 );
+  mLayout = new TQGridLayout( this, 3, 2, 11, 6 );
 
-  mLoadButton = new QPushButton( i18n( "Load..." ), this );
-  mSaveButton = new QPushButton( i18n( "Save..." ), this );
+  mLoadButton = new TQPushButton( i18n( "Load..." ), this );
+  mSaveButton = new TQPushButton( i18n( "Save..." ), this );
   mSaveButton->setEnabled( false );
 
   mLayout->addWidget( mLoadButton, 0, 1 );
   mLayout->addWidget( mSaveButton, 1, 1 );
 
-  connect( mLoadButton, SIGNAL( clicked() ), SLOT( load() ) );
-  connect( mSaveButton, SIGNAL( clicked() ), SLOT( save() ) );
+  connect( mLoadButton, TQT_SIGNAL( clicked() ), TQT_SLOT( load() ) );
+  connect( mSaveButton, TQT_SIGNAL( clicked() ), TQT_SLOT( save() ) );
 }
 
-void BinaryWidget::setData( const QByteArray &data )
+void BinaryWidget::setData( const TQByteArray &data )
 {
   KMimeMagic magic;
-  QString mimetype;
+  TQString mimetype;
 
   delete mMainWidget;
 
@@ -123,7 +123,7 @@ void BinaryWidget::setData( const QByteArray &data )
     mimetype = result->mimeType();
 
   if ( !mimetype.isEmpty() ) {
-    KParts::ReadOnlyPart *part = KParts::ComponentFactory::createPartInstanceFromQuery<KParts::ReadOnlyPart>( mimetype, QString::null, this, 0, this, 0 );
+    KParts::ReadOnlyPart *part = KParts::ComponentFactory::createPartInstanceFromQuery<KParts::ReadOnlyPart>( mimetype, TQString::null, this, 0, this, 0 );
     if ( part ) {
       KTempFile file;
       file.file()->writeBlock( data );
@@ -131,13 +131,13 @@ void BinaryWidget::setData( const QByteArray &data )
       part->openURL( KURL( file.name() ) );
       mMainWidget = part->widget();
     } else {
-      mMainWidget = new QLabel( i18n( "No part found for visualization of mimetype %1" ).arg( mimetype ), this );
+      mMainWidget = new TQLabel( i18n( "No part found for visualization of mimetype %1" ).arg( mimetype ), this );
     }
 
     mData = data;
     mSaveButton->setEnabled( true );
   } else {
-    mMainWidget = new QLabel( i18n( "Got data of unknown mimetype" ), this );
+    mMainWidget = new TQLabel( i18n( "Got data of unknown mimetype" ), this );
   }
 
   mLayout->addMultiCellWidget( mMainWidget, 0, 2, 0, 0 );
@@ -146,19 +146,19 @@ void BinaryWidget::setData( const QByteArray &data )
 
 void BinaryWidget::load()
 {
-  KURL url = KFileDialog::getOpenURL( QString(), QString(), this );
+  KURL url = KFileDialog::getOpenURL( TQString(), TQString(), this );
   if ( url.isEmpty() )
     return;
 
-  QString tempFile;
+  TQString tempFile;
   if ( KIO::NetAccess::download( url, tempFile, this ) ) {
-    QFile file( tempFile );
+    TQFile file( tempFile );
     if ( !file.open( IO_ReadOnly ) ) {
       KMessageBox::error( this, i18n( "Unable to open file %1" ).arg( url.url() ) );
       return;
     }
 
-    QByteArray data = file.readAll();
+    TQByteArray data = file.readAll();
     setData( data );
 
     file.close();
@@ -171,7 +171,7 @@ void BinaryWidget::load()
 
 void BinaryWidget::save()
 {
-  KURL url = KFileDialog::getSaveURL( QString(), QString(), this );
+  KURL url = KFileDialog::getSaveURL( TQString(), TQString(), this );
   if ( url.isEmpty() )
     return;
 
diff --git a/kode/kwsdl/kung/binaryinputfield.h b/kode/kwsdl/kung/binaryinputfield.h
index eeb721d5f..479828f52 100644
--- a/kode/kwsdl/kung/binaryinputfield.h
+++ b/kode/kwsdl/kung/binaryinputfield.h
@@ -22,7 +22,7 @@
 #ifndef BINARY_INPUTFIELD_H
 #define BINARY_INPUTFIELD_H
 
-#include <qwidget.h>
+#include <tqwidget.h>
 
 #include "inputfield.h"
 
@@ -35,24 +35,24 @@ class BinaryInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    BinaryInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type );
+    BinaryInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private slots:
-    void valueChanged( const QByteArray &value );
+    void valueChanged( const TQByteArray &value );
 
   private:
     BinaryWidget *mInputWidget;
 
-    QByteArray mValue;
-    QString mTypeName;
+    TQByteArray mValue;
+    TQString mTypeName;
 };
 
 class BinaryWidget : public QWidget
@@ -60,24 +60,24 @@ class BinaryWidget : public QWidget
   Q_OBJECT
 
   public:
-    BinaryWidget( QWidget *parent );
+    BinaryWidget( TQWidget *parent );
 
-    void setData( const QByteArray &data );
+    void setData( const TQByteArray &data );
 
   signals:
-    void valueChanged( const QByteArray &data );
+    void valueChanged( const TQByteArray &data );
 
   private slots:
     void load();
     void save();
 
   private:
-    QByteArray mData;
+    TQByteArray mData;
 
-    QGridLayout *mLayout;
-    QPushButton *mLoadButton;
-    QPushButton *mSaveButton;
-    QWidget* mMainWidget;
+    TQGridLayout *mLayout;
+    TQPushButton *mLoadButton;
+    TQPushButton *mSaveButton;
+    TQWidget* mMainWidget;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/boolinputfield.cpp b/kode/kwsdl/kung/boolinputfield.cpp
index 69e0e8e04..e3eb3eef1 100644
--- a/kode/kwsdl/kung/boolinputfield.cpp
+++ b/kode/kwsdl/kung/boolinputfield.cpp
@@ -19,17 +19,17 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qcheckbox.h>
+#include <tqcheckbox.h>
 
 #include "boolinputfield.h"
 
-BoolInputField::BoolInputField( const QString &name, const Schema::SimpleType *type )
+BoolInputField::BoolInputField( const TQString &name, const Schema::SimpleType *type )
   : SimpleInputField( name, type ),
     mValue( false )
 {
 }
 
-void BoolInputField::setXMLData( const QDomElement &element )
+void BoolInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "BoolInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -39,34 +39,34 @@ void BoolInputField::setXMLData( const QDomElement &element )
   setData( element.text() );
 }
 
-void BoolInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void BoolInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
   element.setAttribute( "xsi:type", "xsd:boolean" );
-  QDomText text = document.createTextNode( data() );
+  TQDomText text = document.createTextNode( data() );
   element.appendChild( text );
 
   parent.appendChild( element );
 }
 
-void BoolInputField::setData( const QString &data )
+void BoolInputField::setData( const TQString &data )
 {
   mValue = ( data.lower() == "true" );
 }
 
-QString BoolInputField::data() const
+TQString BoolInputField::data() const
 {
   return ( mValue ? "true" : "false" );
 }
 
-QWidget *BoolInputField::createWidget( QWidget *parent )
+TQWidget *BoolInputField::createWidget( TQWidget *parent )
 {
-  mInputWidget = new QCheckBox( parent );
+  mInputWidget = new TQCheckBox( parent );
 
   mInputWidget->setChecked( mValue );
 
-  connect( mInputWidget, SIGNAL( toggled( bool ) ),
-           this, SLOT( inputChanged( bool ) ) );
+  connect( mInputWidget, TQT_SIGNAL( toggled( bool ) ),
+           this, TQT_SLOT( inputChanged( bool ) ) );
 
   return mInputWidget;
 }
diff --git a/kode/kwsdl/kung/boolinputfield.h b/kode/kwsdl/kung/boolinputfield.h
index 1ba5347b8..f5cd9cf22 100644
--- a/kode/kwsdl/kung/boolinputfield.h
+++ b/kode/kwsdl/kung/boolinputfield.h
@@ -22,7 +22,7 @@
 #ifndef BOOL_INPUTFIELD_H
 #define BOOL_INPUTFIELD_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #include "inputfield.h"
 
@@ -33,21 +33,21 @@ class BoolInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    BoolInputField( const QString &name, const Schema::SimpleType *type );
+    BoolInputField( const TQString &name, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private slots:
     void inputChanged( bool );
 
   private:
-    QCheckBox *mInputWidget;
+    TQCheckBox *mInputWidget;
     bool mValue;
 };
 
diff --git a/kode/kwsdl/kung/complexbaseinputfield.cpp b/kode/kwsdl/kung/complexbaseinputfield.cpp
index 26434940a..80f755817 100644
--- a/kode/kwsdl/kung/complexbaseinputfield.cpp
+++ b/kode/kwsdl/kung/complexbaseinputfield.cpp
@@ -19,9 +19,9 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qgroupbox.h>
-#include <qlabel.h>
-#include <qlayout.h>
+#include <tqgroupbox.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
 
 #include <schema/complextype.h>
 
@@ -29,7 +29,7 @@
 
 #include "complexbaseinputfield.h"
 
-ComplexBaseInputField::ComplexBaseInputField( const QString &name, const Schema::ComplexType *type )
+ComplexBaseInputField::ComplexBaseInputField( const TQString &name, const Schema::ComplexType *type )
   : ComplexInputField( name, type )
 {
   Schema::Element::List elements = type->elements();
@@ -56,7 +56,7 @@ ComplexBaseInputField::ComplexBaseInputField( const QString &name, const Schema:
   }
 }
 
-void ComplexBaseInputField::setXMLData( const QDomElement &element )
+void ComplexBaseInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "ComplexBaseInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -68,9 +68,9 @@ void ComplexBaseInputField::setXMLData( const QDomElement &element )
     InputField *field = childField( "item" );
     field->setXMLData( element );
   } else {
-    QDomNode node = element.firstChild();
+    TQDomNode node = element.firstChild();
     while ( !node.isNull() ) {
-      QDomElement child = node.toElement();
+      TQDomElement child = node.toElement();
       if ( !child.isNull() ) {
         InputField *field = childField( child.tagName() );
         if ( !field ) {
@@ -85,10 +85,10 @@ void ComplexBaseInputField::setXMLData( const QDomElement &element )
   }
 
   // attributes
-  QDomNamedNodeMap nodes = element.attributes();
+  TQDomNamedNodeMap nodes = element.attributes();
   for ( uint i = 0; i < nodes.count(); ++i ) {
-    QDomNode node = nodes.item( i );
-    QDomAttr attr = node.toAttr();
+    TQDomNode node = nodes.item( i );
+    TQDomAttr attr = node.toAttr();
 
     InputField *field = childField( attr.name() );
     if ( !field ) {
@@ -99,9 +99,9 @@ void ComplexBaseInputField::setXMLData( const QDomElement &element )
   }
 }
 
-void ComplexBaseInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void ComplexBaseInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
 
   Schema::Element::List elements = mType->elements();
   Schema::Element::List::ConstIterator elemIt;
@@ -128,25 +128,25 @@ void ComplexBaseInputField::xmlData( QDomDocument &document, QDomElement &parent
   parent.appendChild( element );
 }
 
-void ComplexBaseInputField::setData( const QString& )
+void ComplexBaseInputField::setData( const TQString& )
 {
 }
 
-QString ComplexBaseInputField::data() const
+TQString ComplexBaseInputField::data() const
 {
-  return QString();
+  return TQString();
 }
 
-QWidget *ComplexBaseInputField::createWidget( QWidget *parent )
+TQWidget *ComplexBaseInputField::createWidget( TQWidget *parent )
 {
-  QGroupBox *inputWidget = new QGroupBox( mName, parent );
+  TQGroupBox *inputWidget = new TQGroupBox( mName, parent );
   inputWidget->setColumnLayout( 0, Qt::Horizontal );
-  QGridLayout *layout = new QGridLayout( inputWidget->layout(), 2, 2, 6 );
+  TQGridLayout *layout = new TQGridLayout( inputWidget->layout(), 2, 2, 6 );
 
   InputField::List::Iterator it;
   int row = 0;
   for ( it = mFields.begin(); it != mFields.end(); ++it, ++row ) {
-    QLabel *label = new QLabel( (*it)->name(), inputWidget );
+    TQLabel *label = new TQLabel( (*it)->name(), inputWidget );
     layout->addWidget( label, row, 0 );
     layout->addWidget( (*it)->createWidget( inputWidget ), row, 1 );
   }
diff --git a/kode/kwsdl/kung/complexbaseinputfield.h b/kode/kwsdl/kung/complexbaseinputfield.h
index e8d563ae2..9fc47dbc7 100644
--- a/kode/kwsdl/kung/complexbaseinputfield.h
+++ b/kode/kwsdl/kung/complexbaseinputfield.h
@@ -27,15 +27,15 @@
 class ComplexBaseInputField : public ComplexInputField
 {
   public:
-    ComplexBaseInputField( const QString &name, const Schema::ComplexType *type );
+    ComplexBaseInputField( const TQString &name, const Schema::ComplexType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 };
 
 #endif
diff --git a/kode/kwsdl/kung/conversationmanager.h b/kode/kwsdl/kung/conversationmanager.h
index 6ef403c7b..74932376f 100644
--- a/kode/kwsdl/kung/conversationmanager.h
+++ b/kode/kwsdl/kung/conversationmanager.h
@@ -22,7 +22,7 @@
 #ifndef CONVERSATIONMANAGER_H
 #define CONVERSATIONMANAGER_H
 
-#include <qstringlist.h>
+#include <tqstringlist.h>
 
 class ConversationManager
 {
@@ -31,7 +31,7 @@ class ConversationManager
       Returns a list of all actions which can be called after the
       current action with a special condition.
      */
-    virtual QStringList nextActions( const QString &currentAction, const QString &condition = QString() ) = 0;
+    virtual TQStringList nextActions( const TQString &currentAction, const TQString &condition = TQString() ) = 0;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/dateinputfield.cpp b/kode/kwsdl/kung/dateinputfield.cpp
index ff60da20f..b38d46b14 100644
--- a/kode/kwsdl/kung/dateinputfield.cpp
+++ b/kode/kwsdl/kung/dateinputfield.cpp
@@ -23,13 +23,13 @@
 
 #include "dateinputfield.h"
 
-DateInputField::DateInputField( const QString &name, const Schema::SimpleType *type )
+DateInputField::DateInputField( const TQString &name, const Schema::SimpleType *type )
   : SimpleInputField( name, type ),
-    mValue( QDate::currentDate() )
+    mValue( TQDate::currentDate() )
 {
 }
 
-void DateInputField::setXMLData( const QDomElement &element )
+void DateInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "DateInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -39,39 +39,39 @@ void DateInputField::setXMLData( const QDomElement &element )
   setData( element.text() );
 }
 
-void DateInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void DateInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
   element.setAttribute( "xsi:type", "xsd:date" );
-  QDomText text = document.createTextNode( data() );
+  TQDomText text = document.createTextNode( data() );
   element.appendChild( text );
 
   parent.appendChild( element );
 }
 
-void DateInputField::setData( const QString &data )
+void DateInputField::setData( const TQString &data )
 {
-  mValue = QDate::fromString( data, Qt::ISODate );
+  mValue = TQDate::fromString( data, Qt::ISODate );
 }
 
-QString DateInputField::data() const
+TQString DateInputField::data() const
 {
   return mValue.toString( Qt::ISODate );
 }
 
-QWidget *DateInputField::createWidget( QWidget *parent )
+TQWidget *DateInputField::createWidget( TQWidget *parent )
 {
   mInputWidget = new KDatePicker( parent );
 
   mInputWidget->setDate( mValue );
 
-  connect( mInputWidget, SIGNAL( dateChanged( QDate ) ),
-           this, SLOT( inputChanged( QDate ) ) );
+  connect( mInputWidget, TQT_SIGNAL( dateChanged( TQDate ) ),
+           this, TQT_SLOT( inputChanged( TQDate ) ) );
 
   return mInputWidget;
 }
 
-void DateInputField::inputChanged( QDate date )
+void DateInputField::inputChanged( TQDate date )
 {
   mValue = date;
 
diff --git a/kode/kwsdl/kung/dateinputfield.h b/kode/kwsdl/kung/dateinputfield.h
index a42e22102..28efe5e33 100644
--- a/kode/kwsdl/kung/dateinputfield.h
+++ b/kode/kwsdl/kung/dateinputfield.h
@@ -22,8 +22,8 @@
 #ifndef DATE_INPUTFIELD_H
 #define DATE_INPUTFIELD_H
 
-#include <qdatetime.h>
-#include <qobject.h>
+#include <tqdatetime.h>
+#include <tqobject.h>
 
 #include "inputfield.h"
 
@@ -34,22 +34,22 @@ class DateInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    DateInputField( const QString &name, const Schema::SimpleType *type );
+    DateInputField( const TQString &name, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private slots:
-    void inputChanged( QDate );
+    void inputChanged( TQDate );
 
   private:
     KDatePicker *mInputWidget;
-    QDate mValue;
+    TQDate mValue;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/dispatcher.cpp b/kode/kwsdl/kung/dispatcher.cpp
index 79f6bd949..d337d19f3 100644
--- a/kode/kwsdl/kung/dispatcher.cpp
+++ b/kode/kwsdl/kung/dispatcher.cpp
@@ -19,9 +19,9 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qapplication.h>
-#include <qtimer.h>
-#include <qwidget.h>
+#include <tqapplication.h>
+#include <tqtimer.h>
+#include <tqwidget.h>
 
 #include <kinputdialog.h>
 #include <klocale.h>
@@ -37,7 +37,7 @@
 #include "dispatcher.h"
 
 Dispatcher::Dispatcher()
-  : QObject( 0, "Dispatcher" ),
+  : TQObject( 0, "Dispatcher" ),
     mConversationManager( 0 )
 {
 }
@@ -57,10 +57,10 @@ void Dispatcher::setWSDL( const KWSDL::WSDL &wsdl )
   mConversationManager = new GeneralConversationManager( mWSDL );
 
   mTransport = new Transport( mWSDL.service().ports().first().mLocation );
-  connect( mTransport, SIGNAL( result( const QString& ) ),
-           this, SLOT( result( const QString& ) ) );
-  connect( mTransport, SIGNAL( error( const QString& ) ),
-           this, SLOT( error( const QString& ) ) );
+  connect( mTransport, TQT_SIGNAL( result( const TQString& ) ),
+           this, TQT_SLOT( result( const TQString& ) ) );
+  connect( mTransport, TQT_SIGNAL( error( const TQString& ) ),
+           this, TQT_SLOT( error( const TQString& ) ) );
 }
 
 void Dispatcher::run()
@@ -75,9 +75,9 @@ void Dispatcher::nextMessage()
     return;
   }
 
-  QStringList items = mConversationManager->nextActions( mLastMessage, QString() );
+  TQStringList items = mConversationManager->nextActions( mLastMessage, TQString() );
 
-  mCurrentMessage = QString();
+  mCurrentMessage = TQString();
   if ( items.count() > 1 ) {
     mCurrentMessage = KInputDialog::getItem( i18n( "Select a functionality of the service:" ), i18n( "Functions" ),
                                          items );
@@ -91,25 +91,25 @@ void Dispatcher::nextMessage()
 
   KWSDL::Message message = mWSDL.findMessage( mCurrentMessage );
   InputField *field = new PageInputField( message.name(), message );
-  QWidget *page = field->createWidget( 0 );
+  TQWidget *page = field->createWidget( 0 );
 
   InputDialog dlg( page, 0 );
   if ( dlg.exec() ) {
-    QDomDocument doc( "kwsdl" );
+    TQDomDocument doc( "kwsdl" );
     doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
-    QDomElement env = doc.createElement( "SOAP-ENV:Envelope" );
+    TQDomElement env = doc.createElement( "SOAP-ENV:Envelope" );
     env.setAttribute( "xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/" );
     env.setAttribute( "xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance" );
     env.setAttribute( "xmlns:xsd", "http://www.w3.org/1999/XMLSchema" );
     doc.appendChild( env );
 
-    QDomElement body = doc.createElement( "SOAP-ENV:Body" );
+    TQDomElement body = doc.createElement( "SOAP-ENV:Body" );
     env.appendChild( body );
 
     field->xmlData( doc, body );
 
-    QDomElement method = body.firstChild().toElement();
-    QString nameSpace = mWSDL.findBindingOperation( "", message.name() ).input().nameSpace();
+    TQDomElement method = body.firstChild().toElement();
+    TQString nameSpace = mWSDL.findBindingOperation( "", message.name() ).input().nameSpace();
     method.setAttribute( "xmlns:ns1", "urn:GoogleSearch" );
     method.setAttribute( "SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/" );
     body.appendChild( method );
@@ -122,32 +122,32 @@ void Dispatcher::nextMessage()
     qApp->quit();
 }
 
-void Dispatcher::result( const QString &xml )
+void Dispatcher::result( const TQString &xml )
 {
   qDebug( "Got data %s", xml.latin1() );
 
   KWSDL::Message message = mWSDL.findOutputMessage( mCurrentMessage );
   InputField *field = new PageInputField( message.name(), message );
 
-  QDomDocument doc;
+  TQDomDocument doc;
   doc.setContent( xml, true );
 
   field->setXMLData( doc.documentElement().firstChild().firstChild().toElement() );
-  QWidget *page = field->createWidget( 0 );
+  TQWidget *page = field->createWidget( 0 );
 
   OutputDialog dlg( page, 0 );
   dlg.exec();
 
   mLastMessage = mCurrentMessage;
 
-  QTimer::singleShot( 0, this, SLOT( nextMessage() ) );
+  TQTimer::singleShot( 0, this, TQT_SLOT( nextMessage() ) );
 }
 
-void Dispatcher::error( const QString &errorMsg )
+void Dispatcher::error( const TQString &errorMsg )
 {
   KMessageBox::error( 0, errorMsg );
 
-  QTimer::singleShot( 0, this, SLOT( nextMessage() ) );
+  TQTimer::singleShot( 0, this, TQT_SLOT( nextMessage() ) );
 }
 
 #include "dispatcher.moc"
diff --git a/kode/kwsdl/kung/dispatcher.h b/kode/kwsdl/kung/dispatcher.h
index 892635d50..c770fe777 100644
--- a/kode/kwsdl/kung/dispatcher.h
+++ b/kode/kwsdl/kung/dispatcher.h
@@ -22,7 +22,7 @@
 #ifndef DISPATCHER_H
 #define DISPATCHER_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #include <kwsdl/wsdl.h>
 
@@ -43,14 +43,14 @@ class Dispatcher : public QObject
 
   private slots:
     void nextMessage();
-    void result( const QString &xml );
-    void error( const QString &errorMsg );
+    void result( const TQString &xml );
+    void error( const TQString &errorMsg );
 
   private:
     KWSDL::WSDL mWSDL;
 
-    QString mCurrentMessage;
-    QString mLastMessage;
+    TQString mCurrentMessage;
+    TQString mLastMessage;
     ConversationManager *mConversationManager;
     Transport *mTransport;
 };
diff --git a/kode/kwsdl/kung/doubleinputfield.cpp b/kode/kwsdl/kung/doubleinputfield.cpp
index 4c19abf97..78f73bcd6 100644
--- a/kode/kwsdl/kung/doubleinputfield.cpp
+++ b/kode/kwsdl/kung/doubleinputfield.cpp
@@ -25,13 +25,13 @@
 
 #include "doubleinputfield.h"
 
-DoubleInputField::DoubleInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type )
+DoubleInputField::DoubleInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type )
   : SimpleInputField( name, type ),
     mValue( 0 ), mTypeName( typeName )
 {
 }
 
-void DoubleInputField::setXMLData( const QDomElement &element )
+void DoubleInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "DoubleInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -41,27 +41,27 @@ void DoubleInputField::setXMLData( const QDomElement &element )
   setData( element.text() );
 }
 
-void DoubleInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void DoubleInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
   element.setAttribute( "xsi:type", "xsd:" + mTypeName );
-  QDomText text = document.createTextNode( data() );
+  TQDomText text = document.createTextNode( data() );
   element.appendChild( text );
 
   parent.appendChild( element );
 }
 
-void DoubleInputField::setData( const QString &data )
+void DoubleInputField::setData( const TQString &data )
 {
   mValue = data.toDouble();
 }
 
-QString DoubleInputField::data() const
+TQString DoubleInputField::data() const
 {
-  return QString::number( mValue );
+  return TQString::number( mValue );
 }
 
-QWidget *DoubleInputField::createWidget( QWidget *parent )
+TQWidget *DoubleInputField::createWidget( TQWidget *parent )
 {
   mInputWidget = new KDoubleSpinBox( parent );
 
@@ -78,8 +78,8 @@ QWidget *DoubleInputField::createWidget( QWidget *parent )
 
   mInputWidget->setValue( mValue );
 
-  connect( mInputWidget, SIGNAL( valueChanged( double ) ),
-           this, SLOT( inputChanged( double ) ) );
+  connect( mInputWidget, TQT_SIGNAL( valueChanged( double ) ),
+           this, TQT_SLOT( inputChanged( double ) ) );
 
   return mInputWidget;
 }
diff --git a/kode/kwsdl/kung/doubleinputfield.h b/kode/kwsdl/kung/doubleinputfield.h
index f1eeb789e..61299a5cc 100644
--- a/kode/kwsdl/kung/doubleinputfield.h
+++ b/kode/kwsdl/kung/doubleinputfield.h
@@ -22,7 +22,7 @@
 #ifndef DOUBLE_INPUTFIELD_H
 #define DOUBLE_INPUTFIELD_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #include "inputfield.h"
 
@@ -33,15 +33,15 @@ class DoubleInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    DoubleInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type );
+    DoubleInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private slots:
     void inputChanged( double );
@@ -49,7 +49,7 @@ class DoubleInputField : public SimpleInputField
   private:
     KDoubleSpinBox *mInputWidget;
     double mValue;
-    QString mTypeName;
+    TQString mTypeName;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/enuminputfield.cpp b/kode/kwsdl/kung/enuminputfield.cpp
index 61ff328d6..f290803b6 100644
--- a/kode/kwsdl/kung/enuminputfield.cpp
+++ b/kode/kwsdl/kung/enuminputfield.cpp
@@ -25,7 +25,7 @@
 
 #include "enuminputfield.h"
 
-EnumInputField::EnumInputField( const QString &name, const Schema::SimpleType *type )
+EnumInputField::EnumInputField( const TQString &name, const Schema::SimpleType *type )
   : SimpleInputField( name, type )
 {
   mEnums = type->facetEnums();
@@ -33,7 +33,7 @@ EnumInputField::EnumInputField( const QString &name, const Schema::SimpleType *t
   mValue = mEnums.first();
 }
 
-void EnumInputField::setXMLData( const QDomElement &element )
+void EnumInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "EnumInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -43,35 +43,35 @@ void EnumInputField::setXMLData( const QDomElement &element )
   setData( element.text() );
 }
 
-void EnumInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void EnumInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
   element.setAttribute( "xsi:type", "xsd:string" );
-  QDomText text = document.createTextNode( data() );
+  TQDomText text = document.createTextNode( data() );
   element.appendChild( text );
 
   parent.appendChild( element );
 }
 
-void EnumInputField::setData( const QString &data )
+void EnumInputField::setData( const TQString &data )
 {
   mValue = data;
 }
 
-QString EnumInputField::data() const
+TQString EnumInputField::data() const
 {
   return mValue;
 }
 
-QWidget *EnumInputField::createWidget( QWidget *parent )
+TQWidget *EnumInputField::createWidget( TQWidget *parent )
 {
   mInputWidget = new KComboBox( parent );
 
   mInputWidget->insertStringList( mEnums );
   mInputWidget->setCurrentItem( mEnums.findIndex( mValue ) );
 
-  connect( mInputWidget, SIGNAL( activated( int ) ),
-           this, SLOT( inputChanged( int ) ) );
+  connect( mInputWidget, TQT_SIGNAL( activated( int ) ),
+           this, TQT_SLOT( inputChanged( int ) ) );
 
   return mInputWidget;
 }
diff --git a/kode/kwsdl/kung/enuminputfield.h b/kode/kwsdl/kung/enuminputfield.h
index 40369273c..14e360332 100644
--- a/kode/kwsdl/kung/enuminputfield.h
+++ b/kode/kwsdl/kung/enuminputfield.h
@@ -22,7 +22,7 @@
 #ifndef ENUM_INPUTFIELD_H
 #define ENUM_INPUTFIELD_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #include "inputfield.h"
 
@@ -33,23 +33,23 @@ class EnumInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    EnumInputField( const QString &name, const Schema::SimpleType *type );
+    EnumInputField( const TQString &name, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private slots:
     void inputChanged( int );
 
   private:
     KComboBox *mInputWidget;
-    QString mValue;
-    QStringList mEnums;
+    TQString mValue;
+    TQStringList mEnums;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/generalconversationmanager.cpp b/kode/kwsdl/kung/generalconversationmanager.cpp
index 266eca3b3..939935684 100644
--- a/kode/kwsdl/kung/generalconversationmanager.cpp
+++ b/kode/kwsdl/kung/generalconversationmanager.cpp
@@ -39,9 +39,9 @@ GeneralConversationManager::GeneralConversationManager( const KWSDL::WSDL &wsdl
   }
 }
 
-QStringList GeneralConversationManager::nextActions( const QString&, const QString& )
+TQStringList GeneralConversationManager::nextActions( const TQString&, const TQString& )
 {
-  QStringList actions;
+  TQStringList actions;
 
   KWSDL::Message::List::ConstIterator it;
   for ( it = mInputMessages.begin(); it != mInputMessages.end(); ++it )
diff --git a/kode/kwsdl/kung/generalconversationmanager.h b/kode/kwsdl/kung/generalconversationmanager.h
index 2f0297577..ea2b52066 100644
--- a/kode/kwsdl/kung/generalconversationmanager.h
+++ b/kode/kwsdl/kung/generalconversationmanager.h
@@ -31,7 +31,7 @@ class GeneralConversationManager : public ConversationManager
   public:
     GeneralConversationManager( const KWSDL::WSDL &wsdl );
 
-    virtual QStringList nextActions( const QString &currentAction, const QString &condition = QString() );
+    virtual TQStringList nextActions( const TQString &currentAction, const TQString &condition = TQString() );
 
   private:
     KWSDL::WSDL mWSDL;
diff --git a/kode/kwsdl/kung/inputdialog.cpp b/kode/kwsdl/kung/inputdialog.cpp
index 2885fdc4b..17aa601b0 100644
--- a/kode/kwsdl/kung/inputdialog.cpp
+++ b/kode/kwsdl/kung/inputdialog.cpp
@@ -23,7 +23,7 @@
 
 #include "inputdialog.h"
 
-InputDialog::InputDialog( QWidget *page, QWidget *parent )
+InputDialog::InputDialog( TQWidget *page, TQWidget *parent )
   : KDialogBase( Swallow, "", Ok | Cancel, Ok, parent, "", true, true )
 {
   setMainWidget( page );
diff --git a/kode/kwsdl/kung/inputdialog.h b/kode/kwsdl/kung/inputdialog.h
index 10b107c3a..b592545b7 100644
--- a/kode/kwsdl/kung/inputdialog.h
+++ b/kode/kwsdl/kung/inputdialog.h
@@ -27,7 +27,7 @@
 class InputDialog : public KDialogBase
 {
   public:
-    InputDialog( QWidget *page, QWidget *parent );
+    InputDialog( TQWidget *page, TQWidget *parent );
 };
 
 #endif
diff --git a/kode/kwsdl/kung/inputfield.cpp b/kode/kwsdl/kung/inputfield.cpp
index d4efcbe49..7bdd4cdeb 100644
--- a/kode/kwsdl/kung/inputfield.cpp
+++ b/kode/kwsdl/kung/inputfield.cpp
@@ -24,8 +24,8 @@
 
 #include "inputfield.h"
 
-InputField::InputField( const QString &name )
-  : QObject( 0, QString( "InputField( %1 )" ).arg( name ).latin1() ),
+InputField::InputField( const TQString &name )
+  : TQObject( 0, TQString( "InputField( %1 )" ).arg( name ).latin1() ),
     mName( name )
 {
 }
@@ -39,7 +39,7 @@ InputField::~InputField()
   mFields.clear();
 }
 
-QString InputField::name() const
+TQString InputField::name() const
 {
   return mName;
 }
@@ -54,7 +54,7 @@ void InputField::removeChild( InputField *field )
   mFields.remove( field );
 }
 
-InputField *InputField::childField( const QString &name ) const
+InputField *InputField::childField( const TQString &name ) const
 {
   InputField::List::ConstIterator it;
   for ( it = mFields.begin(); it != mFields.end(); ++it )
@@ -69,7 +69,7 @@ InputField::List InputField::childFields() const
   return mFields;
 }
 
-SimpleInputField::SimpleInputField( const QString &name, const Schema::SimpleType *type )
+SimpleInputField::SimpleInputField( const TQString &name, const Schema::SimpleType *type )
   : InputField( name ), mType( 0 )
 {
   if ( type ) {
@@ -84,7 +84,7 @@ SimpleInputField::~SimpleInputField()
   mType = 0;
 }
 
-ComplexInputField::ComplexInputField( const QString &name, const Schema::ComplexType *type )
+ComplexInputField::ComplexInputField( const TQString &name, const Schema::ComplexType *type )
   : InputField( name ), mType( 0 )
 {
   if ( type ) {
diff --git a/kode/kwsdl/kung/inputfield.h b/kode/kwsdl/kung/inputfield.h
index 71030bdaa..1f6242d34 100644
--- a/kode/kwsdl/kung/inputfield.h
+++ b/kode/kwsdl/kung/inputfield.h
@@ -22,10 +22,10 @@
 #ifndef INPUTFIELD_H
 #define INPUTFIELD_H
 
-#include <qdom.h>
-#include <qobject.h>
-#include <qstring.h>
-#include <qvaluelist.h>
+#include <tqdom.h>
+#include <tqobject.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
 
 class QWidget;
 
@@ -42,12 +42,12 @@ class InputField : public QObject
   Q_OBJECT
 
   public:
-    typedef QValueList<InputField*> List;
+    typedef TQValueList<InputField*> List;
 
     /**
       Constructs a input field.
      */
-    InputField( const QString &name );
+    InputField( const TQString &name );
 
     /**
       Destructor.
@@ -57,33 +57,33 @@ class InputField : public QObject
     /**
       Returns the name of the field.
      */
-    QString name() const;
+    TQString name() const;
 
     /**
       Sets the xml data of this field.
      */
-    virtual void setXMLData( const QDomElement &element ) = 0;
+    virtual void setXMLData( const TQDomElement &element ) = 0;
 
     /**
       Returns the xml value of this field.
      */
-    virtual void xmlData( QDomDocument &document, QDomElement &parent ) = 0;
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent ) = 0;
 
     /**
       Sets the plain data of this field as string.
      */
-    virtual void setData( const QString &data ) = 0;
+    virtual void setData( const TQString &data ) = 0;
 
     /**
       Returns the data of this field as string.
      */
-    virtual QString data() const = 0;
+    virtual TQString data() const = 0;
 
     /**
       Returns a pointer to a new created input widget which can be used to
       to modify the value.
      */
-    virtual QWidget *createWidget( QWidget *parent ) = 0;
+    virtual TQWidget *createWidget( TQWidget *parent ) = 0;
 
     /**
       Add a child field.
@@ -99,7 +99,7 @@ class InputField : public QObject
       Returns a field with the given name or 0 when no field with this name
       exists.
      */
-    virtual InputField *childField( const QString &name ) const;
+    virtual InputField *childField( const TQString &name ) const;
 
     /**
       Returns a list of all child fields.
@@ -113,7 +113,7 @@ class InputField : public QObject
     void modified();
 
   protected:
-    QString mName;
+    TQString mName;
     InputField::List mFields;
 };
 
@@ -123,7 +123,7 @@ class InputField : public QObject
 class SimpleInputField : public InputField
 {
   public:
-    SimpleInputField( const QString &name, const Schema::SimpleType *type );
+    SimpleInputField( const TQString &name, const Schema::SimpleType *type );
     ~SimpleInputField();
 
   protected:
@@ -136,7 +136,7 @@ class SimpleInputField : public InputField
 class ComplexInputField : public InputField
 {
   public:
-    ComplexInputField( const QString &name, const Schema::ComplexType *type );
+    ComplexInputField( const TQString &name, const Schema::ComplexType *type );
     ~ComplexInputField();
 
   protected:
diff --git a/kode/kwsdl/kung/inputfieldfactory.cpp b/kode/kwsdl/kung/inputfieldfactory.cpp
index 43a844c65..42905aee3 100644
--- a/kode/kwsdl/kung/inputfieldfactory.cpp
+++ b/kode/kwsdl/kung/inputfieldfactory.cpp
@@ -53,7 +53,7 @@ void InputFieldFactory::setTypes( const Schema::Types &types )
   mTypes = types;
 }
 
-InputField *InputFieldFactory::createField( const QString &name, const QString &typeName, bool isList )
+InputField *InputFieldFactory::createField( const TQString &name, const TQString &typeName, bool isList )
 {
   Schema::SimpleType::List simpleTypes = mTypes.simpleTypes();
   Schema::SimpleType::List::ConstIterator simpleIt;
@@ -80,7 +80,7 @@ InputField *InputFieldFactory::createField( const QString &name, const QString &
   return createBasicField( name, typeName, 0, isList );
 }
 
-InputField *InputFieldFactory::createBasicField( const QString &name, const QString &typeName,
+InputField *InputFieldFactory::createBasicField( const TQString &name, const TQString &typeName,
                                                  const Schema::SimpleType *type, bool isList )
 {
   if ( isList )
diff --git a/kode/kwsdl/kung/inputfieldfactory.h b/kode/kwsdl/kung/inputfieldfactory.h
index 2c1e30eb9..38eae73e1 100644
--- a/kode/kwsdl/kung/inputfieldfactory.h
+++ b/kode/kwsdl/kung/inputfieldfactory.h
@@ -44,12 +44,12 @@ class InputFieldFactory
     /**
       Creates an input field of the given type with the given name.
      */
-    InputField *createField( const QString &name, const QString &typeName, bool isList = false );
+    InputField *createField( const TQString &name, const TQString &typeName, bool isList = false );
 
     /**
       Creates an input field of the given type with the given name.
      */
-    InputField *createBasicField( const QString &name, const QString &typeName, const Schema::SimpleType *type, bool isList = false );
+    InputField *createBasicField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type, bool isList = false );
 
     /**
       Sets the types description, so that the factory can pass
diff --git a/kode/kwsdl/kung/integerinputfield.cpp b/kode/kwsdl/kung/integerinputfield.cpp
index a06136823..022ec0d84 100644
--- a/kode/kwsdl/kung/integerinputfield.cpp
+++ b/kode/kwsdl/kung/integerinputfield.cpp
@@ -27,13 +27,13 @@
 
 #include "integerinputfield.h"
 
-IntegerInputField::IntegerInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type )
+IntegerInputField::IntegerInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type )
   : SimpleInputField( name, type ),
     mValue( 0 ), mTypeName( typeName )
 {
 }
 
-void IntegerInputField::setXMLData( const QDomElement &element )
+void IntegerInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "IntegerInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -43,27 +43,27 @@ void IntegerInputField::setXMLData( const QDomElement &element )
   setData( element.text() );
 }
 
-void IntegerInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void IntegerInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
   element.setAttribute( "xsi:type", "xsd:" + mTypeName );
-  QDomText text = document.createTextNode( data() );
+  TQDomText text = document.createTextNode( data() );
   element.appendChild( text );
 
   parent.appendChild( element );
 }
 
-void IntegerInputField::setData( const QString &data )
+void IntegerInputField::setData( const TQString &data )
 {
   mValue = data.toInt();
 }
 
-QString IntegerInputField::data() const
+TQString IntegerInputField::data() const
 {
-  return QString::number( mValue );
+  return TQString::number( mValue );
 }
 
-QWidget *IntegerInputField::createWidget( QWidget *parent )
+TQWidget *IntegerInputField::createWidget( TQWidget *parent )
 {
   mInputWidget = new KIntSpinBox( parent );
 
@@ -116,8 +116,8 @@ QWidget *IntegerInputField::createWidget( QWidget *parent )
 
   mInputWidget->setValue( mValue );
 
-  connect( mInputWidget, SIGNAL( valueChanged( int ) ),
-           this, SLOT( inputChanged( int ) ) );
+  connect( mInputWidget, TQT_SIGNAL( valueChanged( int ) ),
+           this, TQT_SLOT( inputChanged( int ) ) );
 
   return mInputWidget;
 }
diff --git a/kode/kwsdl/kung/integerinputfield.h b/kode/kwsdl/kung/integerinputfield.h
index 6576aa1df..2cda162c6 100644
--- a/kode/kwsdl/kung/integerinputfield.h
+++ b/kode/kwsdl/kung/integerinputfield.h
@@ -22,7 +22,7 @@
 #ifndef INTEGER_INPUTFIELD_H
 #define INTEGER_INPUTFIELD_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #include "inputfield.h"
 
@@ -33,15 +33,15 @@ class IntegerInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    IntegerInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type );
+    IntegerInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private slots:
     void inputChanged( int );
@@ -49,7 +49,7 @@ class IntegerInputField : public SimpleInputField
   private:
     KIntSpinBox *mInputWidget;
     int mValue;
-    QString mTypeName;
+    TQString mTypeName;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/listinputfield.cpp b/kode/kwsdl/kung/listinputfield.cpp
index a812df6a9..6bc1d8240 100644
--- a/kode/kwsdl/kung/listinputfield.cpp
+++ b/kode/kwsdl/kung/listinputfield.cpp
@@ -19,9 +19,9 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qlayout.h>
-#include <qlistbox.h>
-#include <qpushbutton.h>
+#include <tqlayout.h>
+#include <tqlistbox.h>
+#include <tqpushbutton.h>
 
 #include <klocale.h>
 
@@ -33,12 +33,12 @@
 
 #include "listinputfield.h"
 
-ListInputField::ListInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type )
+ListInputField::ListInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type )
   : SimpleInputField( name, type ), mTypeName( typeName )
 {
 }
 
-void ListInputField::setXMLData( const QDomElement &element )
+void ListInputField::setXMLData( const TQDomElement &element )
 {
   InputField::List::Iterator it;
   for ( it = mFields.begin(); it != mFields.end(); ++it ) {
@@ -46,9 +46,9 @@ void ListInputField::setXMLData( const QDomElement &element )
   }
   mFields.clear();
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement child = node.toElement();
+    TQDomElement child = node.toElement();
     if ( !child.isNull() ) {
       InputField *field = InputFieldFactory::self()->createField( name(), mTypeName );
       if ( field ) {
@@ -62,7 +62,7 @@ void ListInputField::setXMLData( const QDomElement &element )
   }
 }
 
-void ListInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void ListInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
   InputField::List::Iterator it;
   for ( it = mFields.begin(); it != mFields.end(); ++it ) {
@@ -70,16 +70,16 @@ void ListInputField::xmlData( QDomDocument &document, QDomElement &parent )
   }
 }
 
-void ListInputField::setData( const QString& )
+void ListInputField::setData( const TQString& )
 {
 }
 
-QString ListInputField::data() const
+TQString ListInputField::data() const
 {
-  return QString();
+  return TQString();
 }
 
-QWidget *ListInputField::createWidget( QWidget *parent )
+TQWidget *ListInputField::createWidget( TQWidget *parent )
 {
   mInputWidget = new ListWidget( this, name(), mTypeName, parent );
 
@@ -87,27 +87,27 @@ QWidget *ListInputField::createWidget( QWidget *parent )
 }
 
 
-ListWidget::ListWidget( InputField *parentField, const QString &name, const QString &type, QWidget *parent )
-  : QWidget( parent ),
+ListWidget::ListWidget( InputField *parentField, const TQString &name, const TQString &type, TQWidget *parent )
+  : TQWidget( parent ),
     mParentField( parentField ), mName( name ), mType( type )
 {
-  QGridLayout *layout = new QGridLayout( this, 4, 2, 11, 6 );
+  TQGridLayout *layout = new TQGridLayout( this, 4, 2, 11, 6 );
 
-  mView = new QListBox( this );
+  mView = new TQListBox( this );
   layout->addMultiCellWidget( mView, 0, 3, 0, 0 );
 
-  mAddButton = new QPushButton( i18n( "Add" ), this );
+  mAddButton = new TQPushButton( i18n( "Add" ), this );
   layout->addWidget( mAddButton, 0, 1 );
 
-  mEditButton = new QPushButton( i18n( "Edit..." ), this );
+  mEditButton = new TQPushButton( i18n( "Edit..." ), this );
   layout->addWidget( mEditButton, 1, 1 );
 
-  mRemoveButton = new QPushButton( i18n( "Remove" ), this );
+  mRemoveButton = new TQPushButton( i18n( "Remove" ), this );
   layout->addWidget( mRemoveButton, 2, 1 );
 
-  connect( mAddButton, SIGNAL( clicked() ), SLOT( add() ) );
-  connect( mEditButton, SIGNAL( clicked() ), SLOT( edit() ) );
-  connect( mRemoveButton, SIGNAL( clicked() ), SLOT( remove() ) );
+  connect( mAddButton, TQT_SIGNAL( clicked() ), TQT_SLOT( add() ) );
+  connect( mEditButton, TQT_SIGNAL( clicked() ), TQT_SLOT( edit() ) );
+  connect( mRemoveButton, TQT_SIGNAL( clicked() ), TQT_SLOT( remove() ) );
 
   update();
 }
diff --git a/kode/kwsdl/kung/listinputfield.h b/kode/kwsdl/kung/listinputfield.h
index 3b3779e25..57430d2e4 100644
--- a/kode/kwsdl/kung/listinputfield.h
+++ b/kode/kwsdl/kung/listinputfield.h
@@ -22,7 +22,7 @@
 #ifndef LIST_INPUTFIELD_H
 #define LIST_INPUTFIELD_H
 
-#include <qwidget.h>
+#include <tqwidget.h>
 
 #include "inputfield.h"
 
@@ -35,19 +35,19 @@ class ListInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    ListInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type );
+    ListInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private:
     ListWidget *mInputWidget;
-    QString mTypeName;
+    TQString mTypeName;
 };
 
 class ListWidget : public QWidget
@@ -55,7 +55,7 @@ class ListWidget : public QWidget
   Q_OBJECT
 
   public:
-    ListWidget( InputField *parentField, const QString &name, const QString &type, QWidget *parent );
+    ListWidget( InputField *parentField, const TQString &name, const TQString &type, TQWidget *parent );
 
     void update();
 
@@ -68,13 +68,13 @@ class ListWidget : public QWidget
     void updateButtons();
 
     InputField *mParentField;
-    QString mName;
-    QString mType;
+    TQString mName;
+    TQString mType;
 
-    QListBox *mView;
-    QPushButton *mAddButton;
-    QPushButton *mEditButton;
-    QPushButton *mRemoveButton;
+    TQListBox *mView;
+    TQPushButton *mAddButton;
+    TQPushButton *mEditButton;
+    TQPushButton *mRemoveButton;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/loader.cpp b/kode/kwsdl/kung/loader.cpp
index 1b13549fa..8b0281ac8 100644
--- a/kode/kwsdl/kung/loader.cpp
+++ b/kode/kwsdl/kung/loader.cpp
@@ -19,7 +19,7 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qfile.h>
+#include <tqfile.h>
 
 #include <schema/fileprovider.h>
 
@@ -28,11 +28,11 @@
 #include "loader.h"
 
 Loader::Loader()
-  : QObject( 0, "KWSDL::Loader" )
+  : TQObject( 0, "KWSDL::Loader" )
 {
 }
 
-void Loader::setWSDLUrl( const QString &wsdlUrl )
+void Loader::setWSDLUrl( const TQString &wsdlUrl )
 {
   mWSDLUrl = wsdlUrl;
   mWSDLBaseUrl = mWSDLUrl.left( mWSDLUrl.findRev( '/' ) );
@@ -49,18 +49,18 @@ void Loader::download()
 {
   Schema::FileProvider provider;
 
-  QString fileName;
+  TQString fileName;
   if ( provider.get( mWSDLUrl, fileName ) ) {
-    QFile file( fileName );
+    TQFile file( fileName );
     if ( !file.open( IO_ReadOnly ) ) {
       qDebug( "Unable to download wsdl file %s", mWSDLUrl.latin1() );
       provider.cleanUp();
       return;
     }
 
-    QString errorMsg;
+    TQString errorMsg;
     int errorLine, errorCol;
-    QDomDocument doc;
+    TQDomDocument doc;
     if ( !doc.setContent( &file, true, &errorMsg, &errorLine, &errorCol ) ) {
       qDebug( "%s at (%d,%d)", errorMsg.latin1(), errorLine, errorCol );
       return;
@@ -72,7 +72,7 @@ void Loader::download()
   }
 }
 
-void Loader::parse( const QDomElement &element )
+void Loader::parse( const TQDomElement &element )
 {
   mParser.parse( element );
   execute();
diff --git a/kode/kwsdl/kung/loader.h b/kode/kwsdl/kung/loader.h
index 2229eb23a..7762e292a 100644
--- a/kode/kwsdl/kung/loader.h
+++ b/kode/kwsdl/kung/loader.h
@@ -33,21 +33,21 @@ class Loader : public QObject
   public:
     Loader();
 
-    void setWSDLUrl( const QString &wsdlUrl );
+    void setWSDLUrl( const TQString &wsdlUrl );
 
   public slots:
     void run();
 
   private slots:
     void download();
-    void parse( const QDomElement& );
+    void parse( const TQDomElement& );
     void execute();
 
   private:
-    QString mWSDLUrl;
+    TQString mWSDLUrl;
 
     KWSDL::Parser mParser;
-    QString mWSDLBaseUrl;
+    TQString mWSDLBaseUrl;
 
     Dispatcher *mDispatcher;
 };
diff --git a/kode/kwsdl/kung/main.cpp b/kode/kwsdl/kung/main.cpp
index 92de443ff..b01f04dc2 100644
--- a/kode/kwsdl/kung/main.cpp
+++ b/kode/kwsdl/kung/main.cpp
@@ -25,7 +25,7 @@
 #include <kdebug.h>
 #include <klocale.h>
 
-#include <qtimer.h>
+#include <tqtimer.h>
 
 #include "loader.h"
 
@@ -58,7 +58,7 @@ int main( int argc, char **argv )
   Loader loader;
   loader.setWSDLUrl( args->url( 0 ).path() );
 
-  QTimer::singleShot( 0, &loader, SLOT( run() ) );
+  TQTimer::singleShot( 0, &loader, TQT_SLOT( run() ) );
 
   return app.exec();
 }
diff --git a/kode/kwsdl/kung/outputdialog.cpp b/kode/kwsdl/kung/outputdialog.cpp
index 7a04db478..6cdb7e579 100644
--- a/kode/kwsdl/kung/outputdialog.cpp
+++ b/kode/kwsdl/kung/outputdialog.cpp
@@ -23,7 +23,7 @@
 
 #include "outputdialog.h"
 
-OutputDialog::OutputDialog( QWidget *page, QWidget *parent )
+OutputDialog::OutputDialog( TQWidget *page, TQWidget *parent )
   : KDialogBase( Swallow, "", Ok, Ok, parent, "", true, true )
 {
   setMainWidget( page );
diff --git a/kode/kwsdl/kung/outputdialog.h b/kode/kwsdl/kung/outputdialog.h
index e671e0841..a3c558789 100644
--- a/kode/kwsdl/kung/outputdialog.h
+++ b/kode/kwsdl/kung/outputdialog.h
@@ -27,7 +27,7 @@
 class OutputDialog : public KDialogBase
 {
   public:
-    OutputDialog( QWidget *page, QWidget *parent );
+    OutputDialog( TQWidget *page, TQWidget *parent );
 };
 
 #endif
diff --git a/kode/kwsdl/kung/pageinputfield.cpp b/kode/kwsdl/kung/pageinputfield.cpp
index 36a5b02da..956e54bfc 100644
--- a/kode/kwsdl/kung/pageinputfield.cpp
+++ b/kode/kwsdl/kung/pageinputfield.cpp
@@ -19,14 +19,14 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qlabel.h>
-#include <qlayout.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
 
 #include "inputfieldfactory.h"
 
 #include "pageinputfield.h"
 
-PageInputField::PageInputField( const QString &name, const KWSDL::Message &message )
+PageInputField::PageInputField( const TQString &name, const KWSDL::Message &message )
  : InputField( name ),
    mMessage( message )
 {
@@ -42,16 +42,16 @@ PageInputField::PageInputField( const QString &name, const KWSDL::Message &messa
   }
 }
 
-void PageInputField::setXMLData( const QDomElement &element )
+void PageInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "PageInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
     return;
   }
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement child = node.toElement();
+    TQDomElement child = node.toElement();
     if ( !child.isNull() ) {
       InputField *field = childField( child.tagName() );
       if ( !field ) {
@@ -65,9 +65,9 @@ void PageInputField::setXMLData( const QDomElement &element )
   }
 }
 
-void PageInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void PageInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( "ns1:" + mName );
+  TQDomElement element = document.createElement( "ns1:" + mName );
 
   InputField::List::Iterator it;
   for ( it = mFields.begin(); it != mFields.end(); ++it )
@@ -76,24 +76,24 @@ void PageInputField::xmlData( QDomDocument &document, QDomElement &parent )
   parent.appendChild( element );
 }
 
-void PageInputField::setData( const QString& )
+void PageInputField::setData( const TQString& )
 {
 }
 
-QString PageInputField::data() const
+TQString PageInputField::data() const
 {
-  return QString();
+  return TQString();
 }
 
-QWidget *PageInputField::createWidget( QWidget *parent )
+TQWidget *PageInputField::createWidget( TQWidget *parent )
 {
-  QWidget *mInputWidget = new QWidget( parent, "PageInputWidget" );
-  QGridLayout *layout = new QGridLayout( mInputWidget, 2, 2, 11, 6 );
+  TQWidget *mInputWidget = new TQWidget( parent, "PageInputWidget" );
+  TQGridLayout *layout = new TQGridLayout( mInputWidget, 2, 2, 11, 6 );
 
   InputField::List::Iterator it;
   int row = 0;
   for ( it = mFields.begin(); it != mFields.end(); ++it, ++row ) {
-    QLabel *label = new QLabel( (*it)->name(), mInputWidget );
+    TQLabel *label = new TQLabel( (*it)->name(), mInputWidget );
     label->setAlignment( Qt::AlignTop );
     layout->addWidget( label, row, 0 );
     layout->addWidget( (*it)->createWidget( mInputWidget ), row, 1 );
diff --git a/kode/kwsdl/kung/pageinputfield.h b/kode/kwsdl/kung/pageinputfield.h
index c63e97aeb..152d337ed 100644
--- a/kode/kwsdl/kung/pageinputfield.h
+++ b/kode/kwsdl/kung/pageinputfield.h
@@ -22,7 +22,7 @@
 #ifndef PAGE_INPUTFIELD_H
 #define PAGE_INPUTFIELD_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #include <kwsdl/message.h>
 
@@ -33,18 +33,18 @@ class PageInputField : public InputField
   Q_OBJECT
 
   public:
-    PageInputField( const QString &name, const KWSDL::Message &message );
+    PageInputField( const TQString &name, const KWSDL::Message &message );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private:
-    QWidget *mInputWidget;
+    TQWidget *mInputWidget;
     const KWSDL::Message mMessage;
 };
 
diff --git a/kode/kwsdl/kung/simplebaseinputfield.cpp b/kode/kwsdl/kung/simplebaseinputfield.cpp
index f9cb1bd56..0198723cf 100644
--- a/kode/kwsdl/kung/simplebaseinputfield.cpp
+++ b/kode/kwsdl/kung/simplebaseinputfield.cpp
@@ -25,7 +25,7 @@
 
 #include "simplebaseinputfield.h"
 
-SimpleBaseInputField::SimpleBaseInputField( const QString &name, const Schema::SimpleType *type )
+SimpleBaseInputField::SimpleBaseInputField( const TQString &name, const Schema::SimpleType *type )
   : SimpleInputField( name, type )
 {
   if ( type->subType() == Schema::SimpleType::TypeRestriction ) {
@@ -40,7 +40,7 @@ SimpleBaseInputField::SimpleBaseInputField( const QString &name, const Schema::S
   }
 }
 
-void SimpleBaseInputField::setXMLData( const QDomElement &element )
+void SimpleBaseInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "SimpleBaseInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -59,7 +59,7 @@ void SimpleBaseInputField::setXMLData( const QDomElement &element )
   }
 }
 
-void SimpleBaseInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void SimpleBaseInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
   if ( mType->subType() == Schema::SimpleType::TypeRestriction ) {
     InputField *field = mFields.first();
@@ -73,7 +73,7 @@ void SimpleBaseInputField::xmlData( QDomDocument &document, QDomElement &parent
   }
 }
 
-void SimpleBaseInputField::setData( const QString &data )
+void SimpleBaseInputField::setData( const TQString &data )
 {
   if ( mType->subType() == Schema::SimpleType::TypeRestriction ) {
     InputField *field = mFields.first();
@@ -87,7 +87,7 @@ void SimpleBaseInputField::setData( const QString &data )
   }
 }
 
-QString SimpleBaseInputField::data() const
+TQString SimpleBaseInputField::data() const
 {
   if ( mType->subType() == Schema::SimpleType::TypeRestriction ) {
     InputField *field = mFields.first();
@@ -100,10 +100,10 @@ QString SimpleBaseInputField::data() const
     qDebug( "SimpleBaseInputField: Unsupported subtype" );
   }
 
-  return QString();
+  return TQString();
 }
 
-QWidget *SimpleBaseInputField::createWidget( QWidget *parent )
+TQWidget *SimpleBaseInputField::createWidget( TQWidget *parent )
 {
   if ( mType->subType() == Schema::SimpleType::TypeRestriction ) {
     InputField *field = mFields.first();
diff --git a/kode/kwsdl/kung/simplebaseinputfield.h b/kode/kwsdl/kung/simplebaseinputfield.h
index 7af65ab37..dab7e906c 100644
--- a/kode/kwsdl/kung/simplebaseinputfield.h
+++ b/kode/kwsdl/kung/simplebaseinputfield.h
@@ -27,15 +27,15 @@
 class SimpleBaseInputField : public SimpleInputField
 {
   public:
-    SimpleBaseInputField( const QString &name, const Schema::SimpleType *type );
+    SimpleBaseInputField( const TQString &name, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 };
 
 #endif
diff --git a/kode/kwsdl/kung/stringinputfield.cpp b/kode/kwsdl/kung/stringinputfield.cpp
index e0dc10ccc..390c5bc1b 100644
--- a/kode/kwsdl/kung/stringinputfield.cpp
+++ b/kode/kwsdl/kung/stringinputfield.cpp
@@ -19,20 +19,20 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qlineedit.h>
-#include <qvalidator.h>
+#include <tqlineedit.h>
+#include <tqvalidator.h>
 
 #include <schema/simpletype.h>
 
 #include "stringinputfield.h"
 
-StringInputField::StringInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type )
+StringInputField::StringInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type )
   : SimpleInputField( name, type ),
     mTypeName( typeName )
 {
 }
 
-void StringInputField::setXMLData( const QDomElement &element )
+void StringInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "StringInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -42,36 +42,36 @@ void StringInputField::setXMLData( const QDomElement &element )
   setData( element.text() );
 }
 
-void StringInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void StringInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
   element.setAttribute( "xsi:type", "xsd:" + mTypeName );
-  QDomText text = document.createTextNode( data() );
+  TQDomText text = document.createTextNode( data() );
   element.appendChild( text );
 
   parent.appendChild( element );
 }
 
-void StringInputField::setData( const QString &data )
+void StringInputField::setData( const TQString &data )
 {
   mValue = data;
 }
 
-QString StringInputField::data() const
+TQString StringInputField::data() const
 {
   return mValue;
 }
 
-QWidget *StringInputField::createWidget( QWidget *parent )
+TQWidget *StringInputField::createWidget( TQWidget *parent )
 {
-  mInputWidget = new QLineEdit( parent );
+  mInputWidget = new TQLineEdit( parent );
 
   if ( mType ) {
-    if ( mType->facetType() & Schema::SimpleType::LENGTH ) // TODO: using QValidator here?
+    if ( mType->facetType() & Schema::SimpleType::LENGTH ) // TODO: using TQValidator here?
       mInputWidget->setMaxLength( mType->facetLength() );
 
     if ( mType->facetType() & Schema::SimpleType::MINLEN ) {
-      // TODO: using QValidator here?
+      // TODO: using TQValidator here?
       // mInputWidget->setMaxLength( type->facetMinimumLength() );
     }
 
@@ -79,18 +79,18 @@ QWidget *StringInputField::createWidget( QWidget *parent )
       mInputWidget->setMaxLength( mType->facetMaximumLength() );
 
     if ( mType->facetType() & Schema::SimpleType::PATTERN )
-      mInputWidget->setValidator( new QRegExpValidator( mType->facetPattern(), mInputWidget ) );
+      mInputWidget->setValidator( new TQRegExpValidator( mType->facetPattern(), mInputWidget ) );
   }
 
   mInputWidget->setText( mValue );
 
-  connect( mInputWidget, SIGNAL( textChanged( const QString& ) ),
-           this, SLOT( inputChanged( const QString& ) ) );
+  connect( mInputWidget, TQT_SIGNAL( textChanged( const TQString& ) ),
+           this, TQT_SLOT( inputChanged( const TQString& ) ) );
 
   return mInputWidget;
 }
 
-void StringInputField::inputChanged( const QString &text )
+void StringInputField::inputChanged( const TQString &text )
 {
   mValue = text;
 
diff --git a/kode/kwsdl/kung/stringinputfield.h b/kode/kwsdl/kung/stringinputfield.h
index 2713dded8..0ef30164d 100644
--- a/kode/kwsdl/kung/stringinputfield.h
+++ b/kode/kwsdl/kung/stringinputfield.h
@@ -22,7 +22,7 @@
 #ifndef STRING_INPUTFIELD_H
 #define STRING_INPUTFIELD_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #include "inputfield.h"
 
@@ -33,23 +33,23 @@ class StringInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    StringInputField( const QString &name, const QString &typeName, const Schema::SimpleType *type );
+    StringInputField( const TQString &name, const TQString &typeName, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private slots:
-    void inputChanged( const QString& );
+    void inputChanged( const TQString& );
 
   private:
-    QLineEdit *mInputWidget;
-    QString mValue;
-    QString mTypeName;
+    TQLineEdit *mInputWidget;
+    TQString mValue;
+    TQString mTypeName;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/timeinputfield.cpp b/kode/kwsdl/kung/timeinputfield.cpp
index 0864b8c17..9da18a0cc 100644
--- a/kode/kwsdl/kung/timeinputfield.cpp
+++ b/kode/kwsdl/kung/timeinputfield.cpp
@@ -23,13 +23,13 @@
 
 #include "timeinputfield.h"
 
-TimeInputField::TimeInputField( const QString &name, const Schema::SimpleType *type )
+TimeInputField::TimeInputField( const TQString &name, const Schema::SimpleType *type )
   : SimpleInputField( name, type ),
-    mValue( QTime::currentTime() )
+    mValue( TQTime::currentTime() )
 {
 }
 
-void TimeInputField::setXMLData( const QDomElement &element )
+void TimeInputField::setXMLData( const TQDomElement &element )
 {
   if ( mName != element.tagName() ) {
     qDebug( "TimeInputField: Wrong dom element passed: expected %s, got %s", mName.latin1(), element.tagName().latin1() );
@@ -39,39 +39,39 @@ void TimeInputField::setXMLData( const QDomElement &element )
   setData( element.text() );
 }
 
-void TimeInputField::xmlData( QDomDocument &document, QDomElement &parent )
+void TimeInputField::xmlData( TQDomDocument &document, TQDomElement &parent )
 {
-  QDomElement element = document.createElement( mName );
+  TQDomElement element = document.createElement( mName );
   element.setAttribute( "xsi:type", "xsd:time" );
-  QDomText text = document.createTextNode( data() );
+  TQDomText text = document.createTextNode( data() );
   element.appendChild( text );
 
   parent.appendChild( element );
 }
 
-void TimeInputField::setData( const QString &data )
+void TimeInputField::setData( const TQString &data )
 {
-  mValue = QTime::fromString( data, Qt::ISODate );
+  mValue = TQTime::fromString( data, Qt::ISODate );
 }
 
-QString TimeInputField::data() const
+TQString TimeInputField::data() const
 {
   return mValue.toString( Qt::ISODate );
 }
 
-QWidget *TimeInputField::createWidget( QWidget *parent )
+TQWidget *TimeInputField::createWidget( TQWidget *parent )
 {
   mInputWidget = new KTimeWidget( parent );
 
   mInputWidget->setTime( mValue );
 
-  connect( mInputWidget, SIGNAL( valueChanged( const QTime& ) ),
-           this, SLOT( inputChanged( const QTime& ) ) );
+  connect( mInputWidget, TQT_SIGNAL( valueChanged( const TQTime& ) ),
+           this, TQT_SLOT( inputChanged( const TQTime& ) ) );
 
   return mInputWidget;
 }
 
-void TimeInputField::inputChanged( const QTime &time )
+void TimeInputField::inputChanged( const TQTime &time )
 {
   mValue = time;
 
diff --git a/kode/kwsdl/kung/timeinputfield.h b/kode/kwsdl/kung/timeinputfield.h
index 6edf9540e..c363151de 100644
--- a/kode/kwsdl/kung/timeinputfield.h
+++ b/kode/kwsdl/kung/timeinputfield.h
@@ -22,8 +22,8 @@
 #ifndef TIME_INPUTFIELD_H
 #define TIME_INPUTFIELD_H
 
-#include <qdatetime.h>
-#include <qobject.h>
+#include <tqdatetime.h>
+#include <tqobject.h>
 
 #include "inputfield.h"
 
@@ -34,22 +34,22 @@ class TimeInputField : public SimpleInputField
   Q_OBJECT
 
   public:
-    TimeInputField( const QString &name, const Schema::SimpleType *type );
+    TimeInputField( const TQString &name, const Schema::SimpleType *type );
 
-    virtual void setXMLData( const QDomElement &element );
-    virtual void xmlData( QDomDocument &document, QDomElement &parent );
+    virtual void setXMLData( const TQDomElement &element );
+    virtual void xmlData( TQDomDocument &document, TQDomElement &parent );
 
-    virtual void setData( const QString &data );
-    virtual QString data() const;
+    virtual void setData( const TQString &data );
+    virtual TQString data() const;
 
-    virtual QWidget *createWidget( QWidget *parent );
+    virtual TQWidget *createWidget( TQWidget *parent );
 
   private slots:
-    void inputChanged( const QTime& );
+    void inputChanged( const TQTime& );
 
   private:
     KTimeWidget *mInputWidget;
-    QTime mValue;
+    TQTime mValue;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/transport.cpp b/kode/kwsdl/kung/transport.cpp
index 5cb414c99..fd7e545e1 100644
--- a/kode/kwsdl/kung/transport.cpp
+++ b/kode/kwsdl/kung/transport.cpp
@@ -22,18 +22,18 @@
 
 #include <kdebug.h>
 
-Transport::Transport( const QString &url )
+Transport::Transport( const TQString &url )
 {
   mUrl = url;
   qDebug( "url=%s", url.latin1() );
 }
 
-void Transport::query( const QString &xml )
+void Transport::query( const TQString &xml )
 {
   mData.truncate( 0 );
   
-  QByteArray postData;
-  QDataStream stream( postData, IO_WriteOnly );
+  TQByteArray postData;
+  TQDataStream stream( postData, IO_WriteOnly );
   stream.writeRawBytes( xml.utf8(), xml.utf8().length() );
   
   KIO::TransferJob* job = KIO::http_post( KURL( mUrl ), postData, false );
@@ -45,11 +45,11 @@ void Transport::query( const QString &xml )
   job->addMetaData( "UserAgent", "KDE Kung" );
   job->addMetaData( "content-type", "Content-Type: text/xml; charset=utf-8" );
   
-  connect( job, SIGNAL( data( KIO::Job*, const QByteArray& ) ), this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );
-  connect( job, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotResult( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( data( KIO::Job*, const TQByteArray& ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray& ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( slotResult( KIO::Job* ) ) );
 }
 
-void Transport::slotData( KIO::Job*, const QByteArray &data )
+void Transport::slotData( KIO::Job*, const TQByteArray &data )
 {
   unsigned int oldSize = mData.size();
   mData.resize( oldSize + data.size() );
@@ -61,7 +61,7 @@ void Transport::slotResult( KIO::Job* job )
   if ( job->error() != 0 )
     emit error( job->errorText() );
   else
-    emit result( QString::fromUtf8( mData.data(), mData.size() ) );
+    emit result( TQString::fromUtf8( mData.data(), mData.size() ) );
 }
 
 
diff --git a/kode/kwsdl/kung/transport.h b/kode/kwsdl/kung/transport.h
index 5b7662fe1..240755d18 100644
--- a/kode/kwsdl/kung/transport.h
+++ b/kode/kwsdl/kung/transport.h
@@ -20,7 +20,7 @@
 #ifndef TRANSPORT_H
 #define TRANSPORT_H
 
-#include <qobject.h>
+#include <tqobject.h>
 #include <kio/job.h>
 
 class Transport : public QObject
@@ -28,20 +28,20 @@ class Transport : public QObject
   Q_OBJECT
 
   public:
-    Transport( const QString &url );
-    void query( const QString &xml );
+    Transport( const TQString &url );
+    void query( const TQString &xml );
   
   signals:
-    void result( const QString &xml );
-    void error( const QString &errorMsg );
+    void result( const TQString &xml );
+    void error( const TQString &errorMsg );
   
   private slots:
-    void slotData( KIO::Job*, const QByteArray &data );
+    void slotData( KIO::Job*, const TQByteArray &data );
     void slotResult( KIO::Job* job );
   
   private:
-    QString mUrl;
-    QByteArray mData;
+    TQString mUrl;
+    TQByteArray mData;
 };
 
 #endif
diff --git a/kode/kwsdl/kung/wsclconversationmanager.cpp b/kode/kwsdl/kung/wsclconversationmanager.cpp
index c553edee6..b4f4f9c73 100644
--- a/kode/kwsdl/kung/wsclconversationmanager.cpp
+++ b/kode/kwsdl/kung/wsclconversationmanager.cpp
@@ -35,7 +35,7 @@ void WSCLConversationManager::setConversation( const WSCL::Conversation &convers
   mConversation = conversation;
 }
 
-QStringList WSCLConversationManager::nextActions( const QString &currentAction, const QString &condition )
+TQStringList WSCLConversationManager::nextActions( const TQString &currentAction, const TQString &condition )
 {
   WSCL::Transition::List transitions = mConversation.transitions();
   WSCL::Transition::List::ConstIterator it;
@@ -46,5 +46,5 @@ QStringList WSCLConversationManager::nextActions( const QString &currentAction,
     }
   }
 
-  return QStringList();
+  return TQStringList();
 }
diff --git a/kode/kwsdl/kung/wsclconversationmanager.h b/kode/kwsdl/kung/wsclconversationmanager.h
index eb02ab708..cdd19f312 100644
--- a/kode/kwsdl/kung/wsclconversationmanager.h
+++ b/kode/kwsdl/kung/wsclconversationmanager.h
@@ -34,7 +34,7 @@ class WSCLConversationManager : public ConversationManager
 
     void setConversation( const WSCL::Conversation &conversation );
 
-    QStringList nextActions( const QString &currentAction, const QString &condition = QString() );
+    TQStringList nextActions( const TQString &currentAction, const TQString &condition = TQString() );
 
   private:
     WSCL::Conversation mConversation;
diff --git a/kode/kwsdl/main.cpp b/kode/kwsdl/main.cpp
index c793dde79..aff51ec4d 100644
--- a/kode/kwsdl/main.cpp
+++ b/kode/kwsdl/main.cpp
@@ -27,9 +27,9 @@
 #include <kdebug.h>
 #include <klocale.h>
 
-#include <qdir.h>
-#include <qfile.h>
-#include <qtimer.h>
+#include <tqdir.h>
+#include <tqfile.h>
+#include <tqtimer.h>
 
 static const KCmdLineOptions options[] =
 {
@@ -61,9 +61,9 @@ int main( int argc, char **argv )
 
   KApplication app( false, false );
 
-  QString outputDirectory = QFile::decodeName( args->getOption( "directory" ) );
+  TQString outputDirectory = TQFile::decodeName( args->getOption( "directory" ) );
   if ( outputDirectory.isEmpty() )
-    outputDirectory = QDir::current().path();
+    outputDirectory = TQDir::current().path();
 
   KWSDL::Compiler compiler;
   compiler.setWSDLUrl( args->url( 0 ).path() );
@@ -71,7 +71,7 @@ int main( int argc, char **argv )
   if ( args->isSet( "namespace" ) )
     compiler.setNameSpace( args->getOption( "namespace" ) );
 
-  QTimer::singleShot( 0, &compiler, SLOT( run() ) );
+  TQTimer::singleShot( 0, &compiler, TQT_SLOT( run() ) );
 
   return app.exec();
 }
diff --git a/kode/kwsdl/message.cpp b/kode/kwsdl/message.cpp
index ee1abbc06..227441c35 100644
--- a/kode/kwsdl/message.cpp
+++ b/kode/kwsdl/message.cpp
@@ -27,7 +27,7 @@ Message::Part::Part()
 {
 }
 
-Message::Part::Part( const QString &name, const QString &type )
+Message::Part::Part( const TQString &name, const TQString &type )
  : mName( name ), mType( type )
 {
 }
@@ -36,17 +36,17 @@ Message::Message()
 {
 }
 
-Message::Message( const QString &name )
+Message::Message( const TQString &name )
   : mName( name )
 {
 }
 
-void Message::setName( const QString &name )
+void Message::setName( const TQString &name )
 {
   mName = name;
 }
 
-QString Message::name() const
+TQString Message::name() const
 {
   return mName;
 }
@@ -56,7 +56,7 @@ void Message::addPart( const Part &part )
   mParts.append( part );
 }
 
-Message::Part Message::part( const QString &name ) const
+Message::Part Message::part( const TQString &name ) const
 {
   Part::List::ConstIterator it;
   for ( it = mParts.begin(); it != mParts.end(); ++it )
diff --git a/kode/kwsdl/message.h b/kode/kwsdl/message.h
index c8b1d4eda..23a3cba77 100644
--- a/kode/kwsdl/message.h
+++ b/kode/kwsdl/message.h
@@ -22,47 +22,47 @@
 #ifndef KWSDL_MESSAGE_H
 #define KWSDL_MESSAGE_H
 
-#include <qmap.h>
+#include <tqmap.h>
 
 namespace KWSDL {
 
 class Message
 {
   public:
-    typedef QValueList<Message> List;
+    typedef TQValueList<Message> List;
 
     class Part
     {
       public:
-        typedef QMap<QString, Part> Map;
-        typedef QValueList<Part> List;
+        typedef TQMap<TQString, Part> Map;
+        typedef TQValueList<Part> List;
 
         Part();
-        Part( const QString &name, const QString &type );
+        Part( const TQString &name, const TQString &type );
 
-        void setName( const QString &name ) { mName = name; }
-        QString name() const { return mName; }
+        void setName( const TQString &name ) { mName = name; }
+        TQString name() const { return mName; }
 
-        void setType( const QString &type ) { mType = type; }
-        QString type() const { return mType; }
+        void setType( const TQString &type ) { mType = type; }
+        TQString type() const { return mType; }
 
       private:
-        QString mName;
-        QString mType;
+        TQString mName;
+        TQString mType;
     };
 
     Message();
-    Message( const QString &name );
+    Message( const TQString &name );
 
-    void setName( const QString &name );
-    QString name() const;
+    void setName( const TQString &name );
+    TQString name() const;
 
     void addPart( const Part &part );
-    Part part( const QString &name ) const;
+    Part part( const TQString &name ) const;
     Part::List parts() const;
 
   private:
-    QString mName;
+    TQString mName;
     Part::List mParts;
 };
 
diff --git a/kode/kwsdl/namemapper.cpp b/kode/kwsdl/namemapper.cpp
index e11d2ef0c..426498f5c 100644
--- a/kode/kwsdl/namemapper.cpp
+++ b/kode/kwsdl/namemapper.cpp
@@ -28,7 +28,7 @@ NameMapper::NameMapper()
   mKeyWords << "delete" << "class" << "default" << "new" << "not";
 }
 
-QString NameMapper::escape( const QString &name ) const
+TQString NameMapper::escape( const TQString &name ) const
 {
   if ( mKeyWords.contains( name ) )
     return "_" + name;
@@ -36,7 +36,7 @@ QString NameMapper::escape( const QString &name ) const
     return name;
 }
 
-QString NameMapper::unescape( const QString &name ) const
+TQString NameMapper::unescape( const TQString &name ) const
 {
   if ( name.startsWith( "_" ) )
     return name.mid( 1 );
diff --git a/kode/kwsdl/namemapper.h b/kode/kwsdl/namemapper.h
index 88c29a49d..af10aec7e 100644
--- a/kode/kwsdl/namemapper.h
+++ b/kode/kwsdl/namemapper.h
@@ -22,7 +22,7 @@
 #ifndef KWSDL_NAMEMAPPER_H
 #define KWSDL_NAMEMAPPER_H
 
-#include <qstringlist.h>
+#include <tqstringlist.h>
 
 namespace KWSDL {
 
@@ -31,11 +31,11 @@ class NameMapper
   public:
     NameMapper();
 
-    QString escape( const QString &name ) const;
-    QString unescape( const QString &name ) const;
+    TQString escape( const TQString &name ) const;
+    TQString unescape( const TQString &name ) const;
 
   private:
-    QStringList mKeyWords;
+    TQStringList mKeyWords;
 };
 
 }
diff --git a/kode/kwsdl/parser.cpp b/kode/kwsdl/parser.cpp
index ab168b579..49f77eca4 100644
--- a/kode/kwsdl/parser.cpp
+++ b/kode/kwsdl/parser.cpp
@@ -19,13 +19,13 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qdom.h>
+#include <tqdom.h>
 
 #include "parser.h"
 
 using namespace KWSDL;
 
-static QString sns( const QString &str )
+static TQString sns( const TQString &str )
 {
   int pos = str.find( ':' );
   if ( pos != -1 )
@@ -59,18 +59,18 @@ void Parser::reset()
   mParser.clear();
 }
 
-void Parser::setSchemaBaseUrl( const QString &url )
+void Parser::setSchemaBaseUrl( const TQString &url )
 {
   mParser.setSchemaBaseUrl( url );
 }
 
-void Parser::parse( const QDomElement &root )
+void Parser::parse( const TQDomElement &root )
 {
   reset();
 
-  QDomNode node = root.firstChild();
+  TQDomNode node = root.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "types" )
         parseTypes( element );
@@ -94,11 +94,11 @@ void Parser::parse( const QDomElement &root )
   }
 }
 
-void Parser::parseTypes( const QDomElement &parent )
+void Parser::parseTypes( const TQDomElement &parent )
 {
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "schema" )
         mParser.parseSchemaTag( element );
@@ -108,16 +108,16 @@ void Parser::parseTypes( const QDomElement &parent )
   }
 }
 
-void Parser::parseMessage( const QDomElement &parent, Message &message )
+void Parser::parseMessage( const TQDomElement &parent, Message &message )
 {
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "part" ) {
 
         // HACK(groupwise): is element valid here as attribute?
-        QString type = sns( element.attribute( "type" ) );
+        TQString type = sns( element.attribute( "type" ) );
         if ( type.isEmpty() )
           type = sns( element.attribute( "element" ) );
 
@@ -130,18 +130,18 @@ void Parser::parseMessage( const QDomElement &parent, Message &message )
   }
 }
 
-void Parser::parsePortType( const QDomElement &parent, Port &port )
+void Parser::parsePortType( const TQDomElement &parent, Port &port )
 {
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "operation" ) {
-        QString input, output;
+        TQString input, output;
 
-        QDomNode childNode = element.firstChild();
+        TQDomNode childNode = element.firstChild();
         while ( !childNode.isNull() ) {
-          QDomElement childElement = childNode.toElement();
+          TQDomElement childElement = childNode.toElement();
           if ( !childElement.isNull() ) {
             if ( childElement.tagName() == "input" )
               input = sns( childElement.attribute( "message" ) );
@@ -161,13 +161,13 @@ void Parser::parsePortType( const QDomElement &parent, Port &port )
   }
 }
 
-void Parser::parseBinding( const QDomElement &parent )
+void Parser::parseBinding( const TQDomElement &parent )
 {
   Binding binding( sns( parent.attribute( "name" ) ), sns( parent.attribute( "type" ) ) );
 
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "binding" ) {
         binding.setStyle( element.attribute( "style" ) );
@@ -176,14 +176,14 @@ void Parser::parseBinding( const QDomElement &parent )
         Binding::Operation operation;
         operation.setName( element.attribute( "name" ) );
 
-        QDomNode opNode = element.firstChild();
+        TQDomNode opNode = element.firstChild();
         while ( !opNode.isNull() ) {
-          QDomElement opElement = opNode.toElement();
+          TQDomElement opElement = opNode.toElement();
           if ( !opElement.isNull() ) {
             if ( opElement.tagName() == "operation" )
               operation.setAction( opElement.attribute( "soapAction" ) );
             else if ( opElement.tagName() == "input" ) {
-              QDomElement inputElement = opElement.firstChild().toElement();
+              TQDomElement inputElement = opElement.firstChild().toElement();
 
               Binding::Operation::Item input;
               input.setUse( inputElement.attribute( "use" ) );
@@ -192,7 +192,7 @@ void Parser::parseBinding( const QDomElement &parent )
 
               operation.setInput( input );
             } else if ( opElement.tagName() == "output" ) {
-              QDomElement outputElement = opElement.firstChild().toElement();
+              TQDomElement outputElement = opElement.firstChild().toElement();
 
               Binding::Operation::Item output;
               output.setUse( outputElement.attribute( "use" ) );
@@ -216,19 +216,19 @@ void Parser::parseBinding( const QDomElement &parent )
   mBindings.append( binding );
 }
 
-void Parser::parseService( const QDomElement &parent )
+void Parser::parseService( const TQDomElement &parent )
 {
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "port" ) {
         Service::Port port;
         port.mName = sns( element.attribute( "name" ) );
         port.mBinding = sns( element.attribute( "binding" ) );
-        QDomNode childNode = element.firstChild();
+        TQDomNode childNode = element.firstChild();
         if ( !childNode.isNull() ) {
-          QDomElement childElement = childNode.toElement();
+          TQDomElement childElement = childNode.toElement();
           port.mLocation = childElement.attribute( "location" );
         }
         mService.addPort( port );
diff --git a/kode/kwsdl/parser.h b/kode/kwsdl/parser.h
index f075efa70..1fd6856f0 100644
--- a/kode/kwsdl/parser.h
+++ b/kode/kwsdl/parser.h
@@ -22,8 +22,8 @@
 #ifndef KWSDL_PARSER_H
 #define KWSDL_PARSER_H
 
-#include <qdom.h>
-#include <qvaluelist.h>
+#include <tqdom.h>
+#include <tqvaluelist.h>
 
 #include <schema/parser.h>
 
@@ -36,21 +36,21 @@ class Parser
   public:
     Parser();
 
-    void parse( const QDomElement &element );
+    void parse( const TQDomElement &element );
     void reset();
 
-    void setSchemaBaseUrl( const QString& );
+    void setSchemaBaseUrl( const TQString& );
 
     WSDL wsdl() const;
 
   private:
-    void parseTypes( const QDomElement& );
-    void parseMessage( const QDomElement&, Message& );
-    void parsePortType( const QDomElement&, Port& );
-    void parseBinding( const QDomElement& );
-    void parseService( const QDomElement& );
+    void parseTypes( const TQDomElement& );
+    void parseMessage( const TQDomElement&, Message& );
+    void parsePortType( const TQDomElement&, Port& );
+    void parseBinding( const TQDomElement& );
+    void parseService( const TQDomElement& );
 
-    void parseSchema( const QDomElement& );
+    void parseSchema( const TQDomElement& );
 
     Binding::List mBindings;
     Message::List mMessages;
diff --git a/kode/kwsdl/port.cpp b/kode/kwsdl/port.cpp
index 90381f9df..d28654db7 100644
--- a/kode/kwsdl/port.cpp
+++ b/kode/kwsdl/port.cpp
@@ -27,7 +27,7 @@ Port::Operation::Operation()
 {
 }
 
-Port::Operation::Operation( const QString &name, const QString &input, const QString &output )
+Port::Operation::Operation( const TQString &name, const TQString &input, const TQString &output )
   : mName( name ), mInput( input ), mOutput( output )
 {
 }
@@ -36,7 +36,7 @@ Port::Port()
 {
 }
 
-Port::Port( const QString &name )
+Port::Port( const TQString &name )
   : mName( name )
 {
 }
@@ -46,7 +46,7 @@ void Port::addOperation( const Operation &operation )
   mOperations.append( operation );
 }
 
-Port::Operation Port::operation( const QString &name ) const
+Port::Operation Port::operation( const TQString &name ) const
 {
   Operation::List::ConstIterator it;
   for ( it = mOperations.begin(); it != mOperations.end(); ++it )
diff --git a/kode/kwsdl/port.h b/kode/kwsdl/port.h
index b0e982086..fe99295c1 100644
--- a/kode/kwsdl/port.h
+++ b/kode/kwsdl/port.h
@@ -22,51 +22,51 @@
 #ifndef KWSDL_PORT_H
 #define KWSDL_PORT_H
 
-#include <qmap.h>
+#include <tqmap.h>
 
 namespace KWSDL {
 
 class Port
 {
   public:
-    typedef QValueList<Port> List;
+    typedef TQValueList<Port> List;
 
     class Operation
     {
       public:
-        typedef QValueList<Operation> List;
-        typedef QMap<QString, Operation> Map;
+        typedef TQValueList<Operation> List;
+        typedef TQMap<TQString, Operation> Map;
 
         Operation();
-        Operation( const QString &name, const QString &input, const QString &output );
+        Operation( const TQString &name, const TQString &input, const TQString &output );
 
-        void setName( const QString &name ) { mName = name; }
-        QString name() const { return mName; }
+        void setName( const TQString &name ) { mName = name; }
+        TQString name() const { return mName; }
 
-        void setInput( const QString &input ) { mInput = input; }
-        QString input() const { return mInput; }
+        void setInput( const TQString &input ) { mInput = input; }
+        TQString input() const { return mInput; }
 
-        void setOutput( const QString &output ) { mOutput = output; }
-        QString output() const { return mOutput; }
+        void setOutput( const TQString &output ) { mOutput = output; }
+        TQString output() const { return mOutput; }
 
       private:
-        QString mName;
-        QString mInput;
-        QString mOutput;
+        TQString mName;
+        TQString mInput;
+        TQString mOutput;
     };
 
     Port();
-    Port( const QString &name );
+    Port( const TQString &name );
 
-    void setName( const QString &name ) { mName = name; }
-    QString name() const { return mName; }
+    void setName( const TQString &name ) { mName = name; }
+    TQString name() const { return mName; }
 
     void addOperation( const Operation &operation );
-    Operation operation( const QString &name ) const;
+    Operation operation( const TQString &name ) const;
     Operation::List operations() const;
 
   private:
-    QString mName;
+    TQString mName;
     Operation::List mOperations;
 };
 
diff --git a/kode/kwsdl/schema/attribute.cpp b/kode/kwsdl/schema/attribute.cpp
index 9be9be790..5637f35cd 100644
--- a/kode/kwsdl/schema/attribute.cpp
+++ b/kode/kwsdl/schema/attribute.cpp
@@ -25,8 +25,8 @@
 using namespace Schema;
 
 
-Attribute::Attribute( const QString &name, int type, bool qualified,
-                      const QString &defaultValue, const QString &fixedValue,
+Attribute::Attribute( const TQString &name, int type, bool qualified,
+                      const TQString &defaultValue, const TQString &fixedValue,
                       bool use )
   : mName( name ), mType( type ), mQualified( qualified ),
     mDefaultValue( defaultValue ), mFixedValue( fixedValue ),
@@ -39,7 +39,7 @@ Attribute::Attribute()
 {
 }
 
-QString Attribute::name() const
+TQString Attribute::name() const
 {
   return mName;
 }
@@ -49,22 +49,22 @@ int Attribute::type() const
   return mType;
 }
 
-void Attribute::setTypeName( const QString &typeName )
+void Attribute::setTypeName( const TQString &typeName )
 {
   mTypeName = typeName;
 }
 
-QString Attribute::typeName() const
+TQString Attribute::typeName() const
 {
   return mTypeName;
 }
 
-QString Attribute::defaultValue() const
+TQString Attribute::defaultValue() const
 {
   return mDefaultValue;
 }
 
-QString Attribute::fixedValue() const
+TQString Attribute::fixedValue() const
 {
   return mFixedValue;
 }
diff --git a/kode/kwsdl/schema/attribute.h b/kode/kwsdl/schema/attribute.h
index 62db99d7d..d7bdf364e 100644
--- a/kode/kwsdl/schema/attribute.h
+++ b/kode/kwsdl/schema/attribute.h
@@ -23,43 +23,43 @@
 #ifndef SCHEMA_ATTRIBUTE_H
 #define SCHEMA_ATTRIBUTE_H
 
-#include <qstring.h>
-#include <qvaluelist.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
 
 namespace Schema {
 
 class Attribute
 {
   public:
-    typedef QValueList<Attribute> List;
-    typedef QValueList<Attribute*> PtrList;
+    typedef TQValueList<Attribute> List;
+    typedef TQValueList<Attribute*> PtrList;
 
     Attribute();
 
-    Attribute( const QString &name, int type, bool qualified = false,
-               const QString &defaultValue = QString(),
-               const QString &fixedValue = QString(),
+    Attribute( const TQString &name, int type, bool qualified = false,
+               const TQString &defaultValue = TQString(),
+               const TQString &fixedValue = TQString(),
                bool use = true );
 
-    QString name() const;
+    TQString name() const;
     int type() const;
 
-    void setTypeName( const QString &typeName );
-    QString typeName() const;
+    void setTypeName( const TQString &typeName );
+    TQString typeName() const;
 
-    QString defaultValue() const;
-    QString fixedValue() const;
+    TQString defaultValue() const;
+    TQString fixedValue() const;
 
     bool isQualified() const;
     bool isUsed() const;
 
   private:
-    QString mName;
+    TQString mName;
     int mType;
-    QString mTypeName;
+    TQString mTypeName;
     bool mQualified;
-    QString mDefaultValue;
-    QString mFixedValue;
+    TQString mDefaultValue;
+    TQString mFixedValue;
     bool mUse;
 };
 
diff --git a/kode/kwsdl/schema/complextype.cpp b/kode/kwsdl/schema/complextype.cpp
index 418fdf92f..51ed2ad08 100644
--- a/kode/kwsdl/schema/complextype.cpp
+++ b/kode/kwsdl/schema/complextype.cpp
@@ -24,7 +24,7 @@
 
 using namespace Schema;
 
-ComplexType::ComplexType( const QString &nameSpace )
+ComplexType::ComplexType( const TQString &nameSpace )
   : mNameSpace( nameSpace ), mType ( 0 ), mContentModel( COMPLEX ),
     mMixed( false ), mAnonymous( false ), mIsArray( false ), mContentType( 0 ),
     mTopLevelGroup( ALL ), mCurrentGroup( 0 ), mPreviousGroup( 0 ),
@@ -50,7 +50,7 @@ ComplexType::~ComplexType()
 {
 }
 
-QString ComplexType::name() const
+TQString ComplexType::name() const
 {
   return mName;
 }
@@ -62,12 +62,12 @@ QualifiedName ComplexType::qualifiedName() const
   return qn;
 }
 
-void ComplexType::setDocumentation( const QString &documentation )
+void ComplexType::setDocumentation( const TQString &documentation )
 {
   mDocumentation = documentation;
 }
 
-QString ComplexType::documentation() const
+TQString ComplexType::documentation() const
 {
   return mDocumentation;
 }
@@ -97,7 +97,7 @@ int ComplexType::attributeType( int index )
   return attribute( index )->type();
 }
 
-QString ComplexType::attributeName( int index )
+TQString ComplexType::attributeName( int index )
 {
   return attribute( index )->name();
 }
@@ -107,7 +107,7 @@ int ComplexType::elementType( int index )
   return element( index )->type();
 }
 
-QString ComplexType::elementName( int index )
+TQString ComplexType::elementName( int index )
 {
   return element( index )->name();
 }
@@ -127,12 +127,12 @@ bool ComplexType::isAnonymous() const
   return mAnonymous;
 }
 
-void ComplexType::setBaseTypeName( const QString &baseTypeName )
+void ComplexType::setBaseTypeName( const TQString &baseTypeName )
 {
   mBaseType.name = baseTypeName;
 }
 
-QString ComplexType::baseTypeName() const
+TQString ComplexType::baseTypeName() const
 {
   return mBaseType.name;
 }
@@ -157,7 +157,7 @@ ComplexType::Compositor ComplexType::groupType( int groupId ) const
   return mGroups[ groupId ].type;
 }
 
-const Element *ComplexType::element( const QString &name )
+const Element *ComplexType::element( const TQString &name )
 {
   Element::List::ConstIterator it;
   for ( it = mElements.begin(); it != mElements.end(); ++it ) {
@@ -183,7 +183,7 @@ Element *ComplexType::element( int id )
   return 0;
 }
 
-const Attribute *ComplexType::attribute( const QString &name )
+const Attribute *ComplexType::attribute( const TQString &name )
 {
   Attribute::List::ConstIterator it;
   for ( it = mAttributes.begin(); it != mAttributes.end(); ++it ) {
@@ -254,7 +254,7 @@ void ComplexType::setAnonymous( bool anonymous )
   mAnonymous = anonymous;
 }
 
-void ComplexType::setName( const QString &name )
+void ComplexType::setName( const TQString &name )
 {
   mName = name;
 }
@@ -274,8 +274,8 @@ void ComplexType::setContentModel( int model )
     mMixed = false;
 }
 
-void ComplexType::addAttribute( const QString &name, int type_id, bool qualified,
-                                const QString &defaultValue, const QString &fixedValue,
+void ComplexType::addAttribute( const TQString &name, int type_id, bool qualified,
+                                const TQString &defaultValue, const TQString &fixedValue,
                                 bool use )
 {
   if ( type_id == 0 ) {
@@ -295,15 +295,15 @@ void ComplexType::addAttribute( const QString &name, int type_id, bool qualified
 
 void ComplexType::addAttributeRef( const QualifiedName &name, bool qualified, bool use )
 {
-  addAttribute( name.localName(), XSDType::ANYTYPE, qualified, QString(), QString(), use );
+  addAttribute( name.localName(), XSDType::ANYTYPE, qualified, TQString(), TQString(), use );
   mForwardAttributeRef = true;
 }
 
 
-void ComplexType::addElement( const QString &name, int type_id, int minOccurs,
+void ComplexType::addElement( const TQString &name, int type_id, int minOccurs,
                               int maxOccurs, bool qualified,
-                              const QString &defaultValue, const QString &fixedValue,
-                              const QString &documentation )
+                              const TQString &defaultValue, const TQString &fixedValue,
+                              const TQString &documentation )
 {
   if ( type_id == 0 ) {
     qDebug( "ComplexType:addElement() :No type given for element " );
@@ -332,7 +332,7 @@ void ComplexType::addElementRef( const QualifiedName &name, int minOccurs, int m
   mForwardElementRef = true;
 }
 
-void ComplexType::matchElementRef( const QString &name, Element &element )
+void ComplexType::matchElementRef( const TQString &name, Element &element )
 {
   if ( mForwardElementRef ) {
     Element *elementPtr = (Element*)this->element( name );
@@ -350,7 +350,7 @@ void ComplexType::matchElementRef( const QString &name, Element &element )
   }
 }
 
-void ComplexType::matchAttributeRef( const QString &name, Attribute &attribute )
+void ComplexType::matchAttributeRef( const TQString &name, Attribute &attribute )
 {
   if ( mForwardAttributeRef ) {
     Attribute *attributePtr = (Attribute*)this->attribute( name );
diff --git a/kode/kwsdl/schema/complextype.h b/kode/kwsdl/schema/complextype.h
index 8664e007a..39db08b69 100644
--- a/kode/kwsdl/schema/complextype.h
+++ b/kode/kwsdl/schema/complextype.h
@@ -23,7 +23,7 @@
 #ifndef SCHEMA_COMPLEXTYPE_H
 #define SCHEMA_COMPLEXTYPE_H
 
-#include <qstring.h>
+#include <tqstring.h>
 
 #include "attribute.h"
 #include "element.h"
@@ -35,7 +35,7 @@ namespace Schema {
 class ComplexType : public XSDType
 {
   public:
-    typedef QValueList<ComplexType> List;
+    typedef TQValueList<ComplexType> List;
 
     typedef enum { 
       SEQ = 0, 
@@ -49,16 +49,16 @@ class ComplexType : public XSDType
     } Derivation;
        
     ComplexType();
-    ComplexType( const QString& );
+    ComplexType( const TQString& );
     ~ComplexType();
 
-    void setName( const QString &name );
-    QString name() const;
+    void setName( const TQString &name );
+    TQString name() const;
 
     QualifiedName qualifiedName() const;
 
-    void setDocumentation( const QString &documentation );
-    QString documentation() const;
+    void setDocumentation( const TQString &documentation );
+    TQString documentation() const;
 
     void setType( int type );
     int type() const;
@@ -72,10 +72,10 @@ class ComplexType : public XSDType
     bool isSimple() const;
 
     int attributeType( int index );
-    QString attributeName( int index );
+    TQString attributeName( int index );
 
     int elementType( int index );
-    QString elementName( int index );
+    TQString elementName( int index );
 
     int numElements() const;
     int numAttributes() const;
@@ -84,17 +84,17 @@ class ComplexType : public XSDType
     bool isAnonymous() const;
 
     void setBaseType( int type, Derivation derivation, const XSDType *ptr );
-    void setBaseTypeName( const QString &baseTypeName );
+    void setBaseTypeName( const TQString &baseTypeName );
 
     int baseType() const;
     int baseDerivation() const;
-    QString baseTypeName() const;
+    TQString baseTypeName() const;
 
     Compositor topLevelGroup() const;
     Compositor groupType( int groupId ) const;
 
-    const Element *element( const QString &name );
-    const Attribute *attribute( const QString &name );
+    const Element *element( const TQString &name );
+    const Attribute *attribute( const TQString &name );
     Element *element( int id );
     Attribute *attribute( int id );
 
@@ -109,29 +109,29 @@ class ComplexType : public XSDType
 
     void setCompositor( Compositor type, bool open = true, int minOccurs = 1, int maxOccurs = 1 );
 
-    void addAttribute( const QString &name, int type_id, bool qualified = false,
-                       const QString &defaultValue = QString(),
-                       const QString &fixedValue = QString(),
+    void addAttribute( const TQString &name, int type_id, bool qualified = false,
+                       const TQString &defaultValue = TQString(),
+                       const TQString &fixedValue = TQString(),
                        bool use = false );
     void addAttributeRef( const QualifiedName &name, bool qualified, bool use );
 
-    void addElement( const QString &name, int type_id, int minOccurs = 1,
+    void addElement( const TQString &name, int type_id, int minOccurs = 1,
                      int maxOccurs = 1, bool qualified = false,
-                     const QString &defaultValue = QString(),
-                     const QString &fixedValue = QString(),
-                     const QString &documentation = QString() );
+                     const TQString &defaultValue = TQString(),
+                     const TQString &fixedValue = TQString(),
+                     const TQString &documentation = TQString() );
     void addElementRef( const QualifiedName &name, int minOccurs, int maxOccurs );
 
-    void matchAttributeRef( const QString &name, Attribute &attribute );
-    void matchElementRef( const QString &name, Element &element );
+    void matchAttributeRef( const TQString &name, Attribute &attribute );
+    void matchElementRef( const TQString &name, Element &element );
 
     bool checkOccurrences();
     void resetCounters();
 
   private:
-    QString mName;
-    QString mNameSpace;
-    QString mDocumentation;
+    TQString mName;
+    TQString mNameSpace;
+    TQString mDocumentation;
     int mType;
 
     Element::List mElements;
@@ -148,7 +148,7 @@ class ComplexType : public XSDType
       int typeId;
       Derivation derivation;
       const  XSDType *type;
-      QString name;
+      TQString name;
     } mBaseType;
   
     struct CompositorStruct
@@ -167,7 +167,7 @@ class ComplexType : public XSDType
       int maxOccurs;
     };
 
-    QValueList<struct CompositorStruct> mGroups;
+    TQValueList<struct CompositorStruct> mGroups;
 
     Compositor mTopLevelGroup;
     int mCurrentGroup;
diff --git a/kode/kwsdl/schema/element.cpp b/kode/kwsdl/schema/element.cpp
index bfb745e2b..d8edbee9d 100644
--- a/kode/kwsdl/schema/element.cpp
+++ b/kode/kwsdl/schema/element.cpp
@@ -31,15 +31,15 @@ Element::Element()
 {
 }
 
-Element::Element( const QString &name, int type, int minOccurs, int maxOccurs,
-                  bool qualified, const QString &defaultValue, const QString &fixedValue )
+Element::Element( const TQString &name, int type, int minOccurs, int maxOccurs,
+                  bool qualified, const TQString &defaultValue, const TQString &fixedValue )
   : mName( name ), mType( type ), mMinOccurs( minOccurs ), mMaxOccurs( maxOccurs ),
     mQualified( qualified ), mDefaultValue( defaultValue ), mFixedValue( fixedValue ),
     mOccurrence( 0 )
 {
 }
 
-QString Element::name() const
+TQString Element::name() const
 {
   return mName;
 }
@@ -54,22 +54,22 @@ int Element::type() const
   return mType;
 }
 
-void Element::setTypeName( const QString &typeName )
+void Element::setTypeName( const TQString &typeName )
 {
   mTypeName = typeName;
 }
 
-QString Element::typeName() const
+TQString Element::typeName() const
 {
   return mTypeName;
 }
 
-void Element::setDocumentation( const QString &documentation )
+void Element::setDocumentation( const TQString &documentation )
 {
   mDocumentation = documentation;
 }
 
-QString Element::documentation() const
+TQString Element::documentation() const
 {
   return mDocumentation;
 }
@@ -104,12 +104,12 @@ int Element::maxOccurs() const
   return mMaxOccurs;
 }
 
-QString Element::defaultValue() const
+TQString Element::defaultValue() const
 {
   return mDefaultValue;
 }
 
-QString Element::fixedValue() const
+TQString Element::fixedValue() const
 {
   return mFixedValue;
 }
diff --git a/kode/kwsdl/schema/element.h b/kode/kwsdl/schema/element.h
index 6335693f6..dfd886b41 100644
--- a/kode/kwsdl/schema/element.h
+++ b/kode/kwsdl/schema/element.h
@@ -23,8 +23,8 @@
 #ifndef SCHEMA_ELEMENT_H
 #define SCHEMA_ELEMENT_H
 
-#include <qstring.h>
-#include <qvaluelist.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
 
 #define UNBOUNDED 1000
 
@@ -33,25 +33,25 @@ namespace Schema {
 class Element
 {
   public:
-    typedef QValueList<Element> List;
-    typedef QValueList<Element*> PtrList;
+    typedef TQValueList<Element> List;
+    typedef TQValueList<Element*> PtrList;
 
     Element();
 
-    Element( const QString &name, int type, int minOccurs = 1, int maxOccurs = 1, 
-             bool qualified = false, const QString &defaultValue = QString(),
-             const QString &fixedValue = QString() );
+    Element( const TQString &name, int type, int minOccurs = 1, int maxOccurs = 1, 
+             bool qualified = false, const TQString &defaultValue = TQString(),
+             const TQString &fixedValue = TQString() );
 
-    QString name() const;
+    TQString name() const;
 
     void setType( int id );
     int type() const;
 
-    void setTypeName( const QString &typeName );
-    QString typeName() const;
+    void setTypeName( const TQString &typeName );
+    TQString typeName() const;
 
-    void setDocumentation( const QString &documentation );
-    QString documentation() const;
+    void setDocumentation( const TQString &documentation );
+    TQString documentation() const;
 
     void setGroupId( int group );
     int groupId() const;
@@ -62,8 +62,8 @@ class Element
     void setMaxOccurs( int maxOccurs );
     int maxOccurs() const;
 
-    QString defaultValue() const;
-    QString fixedValue() const;
+    TQString defaultValue() const;
+    TQString fixedValue() const;
 
     bool isQualified() const;
 
@@ -71,15 +71,15 @@ class Element
     int occurrence() const;
 
   private:
-    QString mName;
+    TQString mName;
     int mType;
-    QString mTypeName;
-    QString mDocumentation;
+    TQString mTypeName;
+    TQString mDocumentation;
     int mMinOccurs;
     int mMaxOccurs;
     bool mQualified;
-    QString mDefaultValue;
-    QString mFixedValue;
+    TQString mDefaultValue;
+    TQString mFixedValue;
     int mGroupId;
     int mOccurrence;
 };
diff --git a/kode/kwsdl/schema/fileprovider.cpp b/kode/kwsdl/schema/fileprovider.cpp
index 642592bf4..2a7448c4f 100644
--- a/kode/kwsdl/schema/fileprovider.cpp
+++ b/kode/kwsdl/schema/fileprovider.cpp
@@ -21,9 +21,9 @@
 
 #include <unistd.h>
 
-#include <qapplication.h>
-#include <qeventloop.h>
-#include <qfile.h>
+#include <tqapplication.h>
+#include <tqeventloop.h>
+#include <tqfile.h>
 
 #include <kio/job.h>
 #include <ktempfile.h>
@@ -33,11 +33,11 @@
 using namespace Schema;
 
 FileProvider::FileProvider()
-  : QObject( 0 ), mBlocked( false )
+  : TQObject( 0 ), mBlocked( false )
 {
 }
 
-bool FileProvider::get( const QString &url, QString &target )
+bool FileProvider::get( const TQString &url, TQString &target )
 {
   if ( !mFileName.isEmpty() )
     cleanUp();
@@ -53,14 +53,14 @@ bool FileProvider::get( const QString &url, QString &target )
   qDebug( "Downloading external schema '%s'", url.latin1() );
 
   KIO::TransferJob* job = KIO::get( KURL( url ), false, false );
-  connect( job, SIGNAL( data( KIO::Job*, const QByteArray& ) ),
-           this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );
-  connect( job, SIGNAL( result( KIO::Job* ) ),
-           this, SLOT( slotResult( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( data( KIO::Job*, const TQByteArray& ) ),
+           this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray& ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ),
+           this, TQT_SLOT( slotResult( KIO::Job* ) ) );
 
   mBlocked = true;
   while ( mBlocked ) {
-    qApp->eventLoop()->processEvents( QEventLoop::ExcludeUserInput );
+    qApp->eventLoop()->processEvents( TQEventLoop::ExcludeUserInput );
     usleep( 500 );
   }
 
@@ -69,11 +69,11 @@ bool FileProvider::get( const QString &url, QString &target )
 
 void FileProvider::cleanUp()
 {
-  ::unlink( QFile::encodeName( mFileName ) );
-  mFileName = QString();
+  ::unlink( TQFile::encodeName( mFileName ) );
+  mFileName = TQString();
 }
 
-void FileProvider::slotData( KIO::Job*, const QByteArray &data )
+void FileProvider::slotData( KIO::Job*, const TQByteArray &data )
 {
   unsigned int oldSize = mData.size();
   mData.resize( oldSize + data.size() );
@@ -87,7 +87,7 @@ void FileProvider::slotResult( KIO::Job *job )
     return;
   }
 
-  QFile file( mFileName );
+  TQFile file( mFileName );
   if ( !file.open( IO_WriteOnly ) ) {
     qDebug( "Unable to create temporary file" );
     return;
diff --git a/kode/kwsdl/schema/fileprovider.h b/kode/kwsdl/schema/fileprovider.h
index 8b2903c50..c665c3dac 100644
--- a/kode/kwsdl/schema/fileprovider.h
+++ b/kode/kwsdl/schema/fileprovider.h
@@ -22,7 +22,7 @@
 #ifndef SCHEMA_FILEPROVIDER_H
 #define SCHEMA_FILEPROVIDER_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 namespace KIO {
 class Job;
@@ -37,16 +37,16 @@ class FileProvider : QObject
   public:
     FileProvider();
 
-    bool get( const QString &url, QString &target );
+    bool get( const TQString &url, TQString &target );
     void cleanUp();
 
   private slots:
-    void slotData( KIO::Job*, const QByteArray& );
+    void slotData( KIO::Job*, const TQByteArray& );
     void slotResult( KIO::Job* );
 
   private:
-    QString mFileName;
-    QByteArray mData;
+    TQString mFileName;
+    TQByteArray mData;
     bool mBlocked;
 };
 
diff --git a/kode/kwsdl/schema/parser.cpp b/kode/kwsdl/schema/parser.cpp
index ec0daabe4..7ec3804f8 100644
--- a/kode/kwsdl/schema/parser.cpp
+++ b/kode/kwsdl/schema/parser.cpp
@@ -20,20 +20,20 @@
     Boston, MA 02110-1301, USA.
  */
 
-#include <qdir.h>
-#include <qfile.h>
-#include <qurl.h>
+#include <tqdir.h>
+#include <tqfile.h>
+#include <tqurl.h>
 
 #include "fileprovider.h"
 #include "parser.h"
 
 using namespace Schema;
 
-const QString soapEncUri = "http://schemas.xmlsoap.org/soap/encoding/";
-const QString wsdlUri = "http://schemas.xmlsoap.org/wsdl/";
+const TQString soapEncUri = "http://schemas.xmlsoap.org/soap/encoding/";
+const TQString wsdlUri = "http://schemas.xmlsoap.org/wsdl/";
 
 
-Parser::Parser( const QString &nameSpace )
+Parser::Parser( const TQString &nameSpace )
   : mNameSpace( nameSpace )
 {
   mElementQualified = false;
@@ -113,24 +113,24 @@ void Parser::clear()
     delete mAttributes[ i ];
 }
 
-void Parser::setSchemaBaseUrl( const QString &url )
+void Parser::setSchemaBaseUrl( const TQString &url )
 {
   mSchemaBaseUrl = url;
 }
 
-void Parser::parseNameSpace( const QDomElement &element )
+void Parser::parseNameSpace( const TQDomElement &element )
 {
-  QDomNamedNodeMap attributes = element.attributes();
+  TQDomNamedNodeMap attributes = element.attributes();
   for ( uint i = 0; i < attributes.count(); ++i ) {
-    QDomNode node = attributes.item( i );
-    QDomAttr attribute = node.toAttr();
+    TQDomNode node = attributes.item( i );
+    TQDomAttr attribute = node.toAttr();
 
     if ( attribute.name().startsWith( "xmlns:" ) )
       mNameSpaceMap.insert( attribute.value(), attribute.name().mid( 6 ) );
   }
 }
 
-bool Parser::parseSchemaTag( const QDomElement &root )
+bool Parser::parseSchemaTag( const TQDomElement &root )
 {
   QualifiedName name = root.tagName();
   if ( name.localName() != "schema" )
@@ -140,7 +140,7 @@ bool Parser::parseSchemaTag( const QDomElement &root )
     mNameSpace = root.attribute( "targetNamespace" );
 
   if ( root.hasAttribute( "elementFormDefault" ) ) {
-    const QString value = root.attribute( "elementFormDefault" );
+    const TQString value = root.attribute( "elementFormDefault" );
     if ( value == "unqualified" )
       mElementQualified = false;
     else if ( value == "qualified" )
@@ -156,9 +156,9 @@ bool Parser::parseSchemaTag( const QDomElement &root )
       m_tnsPrefix = xParser->getNamespacePrefix(i);
 */
 
-  QDomNode node = root.firstChild();
+  TQDomNode node = root.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
 
       QualifiedName name = element.tagName();
@@ -195,9 +195,9 @@ bool Parser::parseSchemaTag( const QDomElement &root )
   return true;
 }
 
-void Parser::parseImport( const QDomElement &element )
+void Parser::parseImport( const TQDomElement &element )
 {
-  QString location = element.attribute( "schemaLocation" );
+  TQString location = element.attribute( "schemaLocation" );
   if ( !location.isEmpty() ) {
     // don't import a schema twice
     if ( mImportedSchemas.contains( location ) )
@@ -209,15 +209,15 @@ void Parser::parseImport( const QDomElement &element )
   }
 }
 
-void Parser::parseAnnotation( const QDomElement& )
+void Parser::parseAnnotation( const TQDomElement& )
 {
 }
 
-void Parser::parseAnnotation( const QDomElement &element, QString &documentation )
+void Parser::parseAnnotation( const TQDomElement &element, TQString &documentation )
 {
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
       QualifiedName name = childElement.tagName();
       if ( name.localName() == "documentation" )
@@ -228,11 +228,11 @@ void Parser::parseAnnotation( const QDomElement &element, QString &documentation
   }
 }
 
-void Parser::parseAnnotation( const QDomElement &element, ComplexType *complexType )
+void Parser::parseAnnotation( const TQDomElement &element, ComplexType *complexType )
 {
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
       QualifiedName name = childElement.tagName();
       if ( name.localName() == "documentation" )
@@ -243,11 +243,11 @@ void Parser::parseAnnotation( const QDomElement &element, ComplexType *complexTy
   }
 }
 
-void Parser::parseAnnotation( const QDomElement &element, SimpleType *simpleType )
+void Parser::parseAnnotation( const TQDomElement &element, SimpleType *simpleType )
 {
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
       QualifiedName name = childElement.tagName();
       if ( name.localName() == "documentation" )
@@ -258,7 +258,7 @@ void Parser::parseAnnotation( const QDomElement &element, SimpleType *simpleType
   }
 }
 
-XSDType *Parser::parseComplexType( const QDomElement &element )
+XSDType *Parser::parseComplexType( const TQDomElement &element )
 {
   ComplexType *newType = new ComplexType( mNameSpace );
 
@@ -266,9 +266,9 @@ XSDType *Parser::parseComplexType( const QDomElement &element )
   if ( element.hasAttribute( "mixed" ) )
     newType->setContentModel( newType->MIXED );
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
 
       QualifiedName name = childElement.tagName();
@@ -297,18 +297,18 @@ XSDType *Parser::parseComplexType( const QDomElement &element )
   return newType;
 }
 
-void Parser::all( const QDomElement &element, ComplexType * ct )
+void Parser::all( const TQDomElement &element, ComplexType * ct )
 {
   int min, max;
-  QString tmp;
+  TQString tmp;
 
   min = element.attribute( "minOccurs", "1" ).toInt();
   max = element.attribute( "maxOccurs", "1" ).toInt();
   ct->setCompositor( ct->ALL, true, min, max );
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
 
       QualifiedName name = childElement.tagName();
@@ -332,14 +332,14 @@ void Parser::all( const QDomElement &element, ComplexType * ct )
 }
 
 
-void Parser::cs( const QDomElement &element, ComplexType *ct )
+void Parser::cs( const TQDomElement &element, ComplexType *ct )
 {
   int min = 1, max = 1;
 
   QualifiedName name = element.tagName();
   if ( name.localName() == "choice" || name.localName() == "sequence" ) {
     min = element.attribute( "minOccurs", "1" ).toInt();
-    QString value = element.attribute( "maxOccurs", "1" );
+    TQString value = element.attribute( "maxOccurs", "1" );
     if ( value == "unbounded" )
       max = UNBOUNDED;
     else
@@ -350,9 +350,9 @@ void Parser::cs( const QDomElement &element, ComplexType *ct )
     else        
       ct->setCompositor( ct->SEQ, true, min, max );
 
-    QDomNode node = element.firstChild();
+    TQDomNode node = element.firstChild();
     while ( !node.isNull() ) {
-      QDomElement childElement = node.toElement();
+      TQDomElement childElement = node.toElement();
       if ( !childElement.isNull() ) {
         QualifiedName csName = childElement.tagName();
         if ( csName.localName() == "element" )
@@ -377,9 +377,9 @@ void Parser::cs( const QDomElement &element, ComplexType *ct )
   return;
 }
 
-void Parser::addElement( const QDomElement &element, ComplexType *cType )
+void Parser::addElement( const TQDomElement &element, ComplexType *cType )
 {
-  QString name, fixedValue, defaultValue, documentation;
+  TQString name, fixedValue, defaultValue, documentation;
   QualifiedName refName;
   int type_id = 0, minOccurs = 1, maxOccurs = 1;
   bool qualified = false, added = false, nill = false;
@@ -418,7 +418,7 @@ void Parser::addElement( const QDomElement &element, ComplexType *cType )
   }
 
   minOccurs = element.attribute( "minOccurs", "1" ).toInt();
-  QString value = element.attribute( "maxOccurs", "1" );
+  TQString value = element.attribute( "maxOccurs", "1" );
   if ( value == "unbounded" )
     maxOccurs = UNBOUNDED;
   else
@@ -430,9 +430,9 @@ void Parser::addElement( const QDomElement &element, ComplexType *cType )
   if ( element.hasAttribute( "nillable" ) )
     nill = true;
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
 
       QualifiedName childName = childElement.tagName();
@@ -476,14 +476,14 @@ void Parser::addElement( const QDomElement &element, ComplexType *cType )
   }
 }
 
-void Parser::addAny( const QDomElement &element, ComplexType *cType )
+void Parser::addAny( const TQDomElement &element, ComplexType *cType )
 {
-  QString ns, any( "any" );
+  TQString ns, any( "any" );
   int type_id = XSDType::ANY, min = 1, max = 1;
 
   ns = element.attribute( "namespace" );
   min = element.attribute( "minOccurs", "1" ).toInt();
-  QString value = element.attribute( "maxOccurs", "1" );
+  TQString value = element.attribute( "maxOccurs", "1" );
   if ( value == "unbounded" )
     max = UNBOUNDED;
   else
@@ -492,18 +492,18 @@ void Parser::addAny( const QDomElement &element, ComplexType *cType )
   cType->addElement( any, type_id, min, max, false, ns );
 }
 
-void Parser::addAnyAttribute( const QDomElement &element, ComplexType *cType )
+void Parser::addAnyAttribute( const TQDomElement &element, ComplexType *cType )
 {
-  QString ns, anyAttribute( "anyAttribute" );
+  TQString ns, anyAttribute( "anyAttribute" );
 
   ns = element.attribute( "namespace" );
 
   cType->addAttribute( anyAttribute, XSDType::ANY, false, ns );
 }
 
-void Parser::addAttribute( const QDomElement &element, ComplexType *cType )
+void Parser::addAttribute( const TQDomElement &element, ComplexType *cType )
 {
-  QString name, fixedVal, defaultVal;
+  TQString name, fixedVal, defaultVal;
   int type_id = 0;
   bool qualified = false, use = false, added = false;
   QualifiedName refAttribute;
@@ -553,9 +553,9 @@ void Parser::addAttribute( const QDomElement &element, ComplexType *cType )
       use = true;
   }
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
 
       QualifiedName childName = childElement.tagName();
@@ -579,7 +579,7 @@ void Parser::addAttribute( const QDomElement &element, ComplexType *cType )
     cType->addAttributeRef( refAttribute, qualified, use );
 }
 
-XSDType *Parser::parseSimpleType( const QDomElement &element )
+XSDType *Parser::parseSimpleType( const TQDomElement &element )
 {
   SimpleType *st = new SimpleType( mNameSpace );
 
@@ -587,9 +587,9 @@ XSDType *Parser::parseSimpleType( const QDomElement &element )
 
   st->setName( element.attribute( "name" ) );
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
 
       QualifiedName name = childElement.tagName();
@@ -624,14 +624,14 @@ XSDType *Parser::parseSimpleType( const QDomElement &element )
   return st;
 }
 
-void Parser::parseRestriction( const QDomElement &element, SimpleType *st )
+void Parser::parseRestriction( const TQDomElement &element, SimpleType *st )
 {
   if ( st->baseType() == 0 )
     qDebug( "<restriction>:unkown BaseType" );
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
 
       if ( !st->isValidFacet( childElement.tagName() ) ) {
@@ -646,7 +646,7 @@ void Parser::parseRestriction( const QDomElement &element, SimpleType *st )
   }
 }
 
-void Parser::parseComplexContent( const QDomElement &element, ComplexType *ct )
+void Parser::parseComplexContent( const TQDomElement &element, ComplexType *ct )
 {
   QualifiedName typeName;
 
@@ -657,9 +657,9 @@ void Parser::parseComplexContent( const QDomElement &element, ComplexType *ct )
 
   ct->setContentModel( ct->COMPLEX );
 
-  QDomNode node = element.firstChild();
+  TQDomNode node = element.firstChild();
   while ( !node.isNull() ) {
-    QDomElement childElement = node.toElement();
+    TQDomElement childElement = node.toElement();
     if ( !childElement.isNull() ) {
       QualifiedName name = childElement.tagName();
 
@@ -680,16 +680,16 @@ void Parser::parseComplexContent( const QDomElement &element, ComplexType *ct )
 
         // if the base soapenc:Array, then read only the arrayType attribute and nothing else
         if ( typeName.localName() == "Array" ) {
-          QDomElement arrayElement = childElement.firstChild().toElement();
+          TQDomElement arrayElement = childElement.firstChild().toElement();
           ct->setIsArray( true );
 
           QualifiedName arrayType( arrayElement.attribute( "arrayType" ) );
 //          arrayType.setNamespace(xParser->getNamespace(arrayType.getPrefix()));
           ct->addElement( "item", typeId( arrayType, true ), 0, UNBOUNDED );
         } else {
-          QDomNode childNode = childElement.firstChild();
+          TQDomNode childNode = childElement.firstChild();
           while ( !childNode.isNull() ) {
-            QDomElement ctElement = childNode.toElement();
+            TQDomElement ctElement = childNode.toElement();
             if ( !ctElement.isNull() ) {
               QualifiedName name = ctElement.tagName();
 
@@ -716,11 +716,11 @@ void Parser::parseComplexContent( const QDomElement &element, ComplexType *ct )
   }
 }
 
-void Parser::parseSimpleContent( const QDomElement &element, ComplexType *ct )
+void Parser::parseSimpleContent( const TQDomElement &element, ComplexType *ct )
 {
   ct->setContentModel( ct->SIMPLE );
 
-  const QDomElement childElement = element.firstChild().toElement();
+  const TQDomElement childElement = element.firstChild().toElement();
 
   QualifiedName name = childElement.tagName();
   if ( name.localName() == "restriction" ) {
@@ -753,9 +753,9 @@ void Parser::parseSimpleContent( const QDomElement &element, ComplexType *ct )
 //      typeName.setNamespace(xParser->getNamespace(typeName.getPrefix()));
       ct->setContentType( basetype_id = typeId( typeName, true ) );
 
-      QDomNode childNode = childElement.firstChild();
+      TQDomNode childNode = childElement.firstChild();
       while ( !childNode.isNull() ) {
-        QDomElement ctElement = childNode.toElement();
+        TQDomElement ctElement = childNode.toElement();
         if ( !ctElement.isNull() ) {
           QualifiedName name = ctElement.tagName();
           if ( name.localName() == "attribute" )
@@ -776,7 +776,7 @@ bool Parser::isBasicType( int type ) const
     return true;
 }
 
-void Parser::parseElement( const QDomElement &element )
+void Parser::parseElement( const TQDomElement &element )
 {
   ComplexType *ct = new ComplexType( mNameSpace );
   addElement( element, ct );
@@ -793,7 +793,7 @@ void Parser::parseElement( const QDomElement &element )
   mElements.append( elementPtr );
 }
 
-void Parser::parseAttribute( const QDomElement &element )
+void Parser::parseAttribute( const TQDomElement &element )
 {
   ComplexType *ct = new ComplexType( mNameSpace );
   addAttribute( element, ct );
@@ -805,7 +805,7 @@ void Parser::parseAttribute( const QDomElement &element )
   mAttributes.append( attributePtr );
 }
 
-int Parser::addExternalElement( const QString &name, int localTypeId )
+int Parser::addExternalElement( const TQString &name, int localTypeId )
 {
   Element *element = new Element( name, localTypeId );
   mElements.append( element );
@@ -817,7 +817,7 @@ int Parser::typeId( const QualifiedName &type, bool create )
 {
   QualifiedName typeName( type );
 
-  QString typens = typeName.nameSpace();
+  TQString typens = typeName.nameSpace();
   if ( typens.isEmpty() )
     typeName.setNameSpace( typens = mNameSpace );
 
@@ -828,7 +828,7 @@ int Parser::typeId( const QualifiedName &type, bool create )
   }
 }
 
-QString Parser::typeName( int id ) const
+TQString Parser::typeName( int id ) const
 {
   return mTypesTable.typeName( id );
 }
@@ -880,7 +880,7 @@ void Parser::resolveForwardDerivations()
   int id;
   ComplexType *type = 0;
 
-  QValueList<ForwardDerivation>::ConstIterator it;
+  TQValueList<ForwardDerivation>::ConstIterator it;
   for ( it = mForwardDerivations.begin(); it != mForwardDerivations.end(); ++it ) {
     if ( ( id = typeId( (*it).type, false ) ) == 0 )
       continue;
@@ -898,7 +898,7 @@ int Parser::elementId( const QualifiedName &type )
 {
   QualifiedName typeName( type );
 
-  QString typens = typeName.nameSpace();
+  TQString typens = typeName.nameSpace();
   if ( typens.isEmpty() )
     typeName.setNameSpace( typens = mNameSpace );
 
@@ -930,7 +930,7 @@ Element *Parser::element( const QualifiedName &name ) const
 {
   QualifiedName elementName( name );
 
-  QString typens = elementName.nameSpace();
+  TQString typens = elementName.nameSpace();
   if ( typens.isEmpty() )
     elementName.setNameSpace( typens = mNameSpace );
 
@@ -965,7 +965,7 @@ int Parser::attributeId( const QualifiedName &type ) const
 {
   QualifiedName typeName( type );
 
-  QString typens = typeName.nameSpace();
+  TQString typens = typeName.nameSpace();
   if ( typens.isEmpty() )
     typeName.setNameSpace( typens = mNameSpace );
 
@@ -1012,7 +1012,7 @@ Attribute *Parser::attribute( const QualifiedName &name ) const
     return 0;
 }
 
-QString Parser::targetNamespace() const
+TQString Parser::targetNamespace() const
 {
   return mNameSpace;
 }
@@ -1052,27 +1052,27 @@ bool Parser::shouldResolve()
   return true;
 }
 
-void Parser::importSchema( const QString &location )
+void Parser::importSchema( const TQString &location )
 {
   FileProvider provider;
-  QString fileName;
-  QString schemaLocation( location );
+  TQString fileName;
+  TQString schemaLocation( location );
 
-  QUrl url( location );
-  QDir dir( location );
+  TQUrl url( location );
+  TQDir dir( location );
 
   if ( (url.protocol().isEmpty() || url.protocol() == "file") && dir.isRelative() )
     schemaLocation = mSchemaBaseUrl + "/" + location;
 
   if ( provider.get( schemaLocation, fileName ) ) {
-    QFile file( fileName );
+    TQFile file( fileName );
     if ( !file.open( IO_ReadOnly ) ) {
       qDebug( "Unable to open file %s", file.name().latin1() );
       return;
     }
 
-    QDomDocument doc( "kwsdl" );
-    QString errorMsg;
+    TQDomDocument doc( "kwsdl" );
+    TQString errorMsg;
     int errorLine, errorColumn;
     bool ok = doc.setContent( &file, true, &errorMsg, &errorLine, &errorColumn );
     if ( !ok ) {
@@ -1080,9 +1080,9 @@ void Parser::importSchema( const QString &location )
       return;
     }
 
-    QDomNodeList nodes = doc.elementsByTagName( "schema" );
+    TQDomNodeList nodes = doc.elementsByTagName( "schema" );
     if ( nodes.count() > 0 ) {
-      QDomElement schemaElement = nodes.item( 0 ).toElement();
+      TQDomElement schemaElement = nodes.item( 0 ).toElement();
       parseSchemaTag( schemaElement );
     } else {
       qDebug( "No schema tag found in schema file" );
diff --git a/kode/kwsdl/schema/parser.h b/kode/kwsdl/schema/parser.h
index afaf3dae6..3469e016b 100644
--- a/kode/kwsdl/schema/parser.h
+++ b/kode/kwsdl/schema/parser.h
@@ -23,8 +23,8 @@
 #ifndef SCHEMA_PARSER_H
 #define SCHEMA_PARSER_H
 
-#include <qdom.h>
-#include <qvaluelist.h>
+#include <tqdom.h>
+#include <tqvaluelist.h>
 
 #include "types.h"
 #include "typestable.h"
@@ -34,23 +34,23 @@ namespace Schema {
 class Parser
 {
   public:
-    Parser( const QString &nameSpace = QString() );
+    Parser( const TQString &nameSpace = TQString() );
 
     ~Parser();
 
     Types types() const;
 
     void clear();
-    void setSchemaBaseUrl( const QString& );
+    void setSchemaBaseUrl( const TQString& );
 
-    void parseNameSpace( const QDomElement &element );
-    bool parseSchemaTag( const QDomElement &element );
+    void parseNameSpace( const TQDomElement &element );
+    bool parseSchemaTag( const TQDomElement &element );
 
     const XSDType *type( const QualifiedName &type );
     const XSDType *type( int id ) const;
     int numTypes() const;
 
-    QString typeName( int id ) const;
+    TQString typeName( int id ) const;
 
     Element *element( const QualifiedName &element ) const;
     Element *element( int id ) const;
@@ -61,7 +61,7 @@ class Parser
     Attribute *attribute( int id ) const;
     int numAttributes() const;
 
-    QString targetNamespace() const;
+    TQString targetNamespace() const;
 
     int typeId( const QualifiedName &name, bool create = false );
 
@@ -75,30 +75,30 @@ class Parser
     int attributeType( const QualifiedName &type );
 
   private:
-    void parseImport( const QDomElement& );
-    void parseElement( const QDomElement& );
-    void parseAttribute( const QDomElement& );
+    void parseImport( const TQDomElement& );
+    void parseElement( const TQDomElement& );
+    void parseAttribute( const TQDomElement& );
 
-    void parseAnnotation( const QDomElement& );
-    void parseAnnotation( const QDomElement&, QString& );
-    void parseAnnotation( const QDomElement&, ComplexType* );
-    void parseAnnotation( const QDomElement&, SimpleType* );
-    XSDType *parseComplexType( const QDomElement& );
+    void parseAnnotation( const TQDomElement& );
+    void parseAnnotation( const TQDomElement&, TQString& );
+    void parseAnnotation( const TQDomElement&, ComplexType* );
+    void parseAnnotation( const TQDomElement&, SimpleType* );
+    XSDType *parseComplexType( const TQDomElement& );
 
-    void all( const QDomElement&, ComplexType* );
-    void cs( const QDomElement&, ComplexType* );
+    void all( const TQDomElement&, ComplexType* );
+    void cs( const TQDomElement&, ComplexType* );
 
-    void addElement( const QDomElement&, ComplexType* );
+    void addElement( const TQDomElement&, ComplexType* );
 
-    void addAttribute( const QDomElement&, ComplexType* );
-    void addAny( const QDomElement&, ComplexType* );
-    void addAnyAttribute( const QDomElement&, ComplexType* );
-    int addExternalElement( const QString&, int );
+    void addAttribute( const TQDomElement&, ComplexType* );
+    void addAny( const TQDomElement&, ComplexType* );
+    void addAnyAttribute( const TQDomElement&, ComplexType* );
+    int addExternalElement( const TQString&, int );
 
-    XSDType *parseSimpleType( const QDomElement& );
-    void parseRestriction( const QDomElement&, SimpleType* );
-    void parseComplexContent( const QDomElement&, ComplexType* );
-    void parseSimpleContent( const QDomElement&, ComplexType* );
+    XSDType *parseSimpleType( const TQDomElement& );
+    void parseRestriction( const TQDomElement&, SimpleType* );
+    void parseComplexContent( const TQDomElement&, ComplexType* );
+    void parseSimpleContent( const TQDomElement&, ComplexType* );
 
 
     void resolveForwardElementRefs();
@@ -106,13 +106,13 @@ class Parser
     void resolveForwardDerivations();
     bool shouldResolve();
 
-    void importSchema( const QString &location );
+    void importSchema( const TQString &location );
 
     bool mElementQualified;
     bool mAttributeQualified;
-    QMap<QString, QString> mNameSpaceMap;
-    QString mNameSpace;
-    QString mPrefix;
+    TQMap<TQString, TQString> mNameSpaceMap;
+    TQString mNameSpace;
+    TQString mPrefix;
   
     TypesTable mTypesTable;
     Element::PtrList mElements;
@@ -127,9 +127,9 @@ class Parser
       ComplexType::Derivation derivation;
     } ForwardDerivation;
 
-    QValueList<ForwardDerivation> mForwardDerivations;
-    QStringList mImportedSchemas;
-    QString mSchemaBaseUrl;
+    TQValueList<ForwardDerivation> mForwardDerivations;
+    TQStringList mImportedSchemas;
+    TQString mSchemaBaseUrl;
 };
 
 }
diff --git a/kode/kwsdl/schema/qualifiedname.cpp b/kode/kwsdl/schema/qualifiedname.cpp
index 5b19f1669..350bca32f 100644
--- a/kode/kwsdl/schema/qualifiedname.cpp
+++ b/kode/kwsdl/schema/qualifiedname.cpp
@@ -24,7 +24,7 @@
 
 using namespace Schema;
 
-QualifiedName::QualifiedName( const QString &name )
+QualifiedName::QualifiedName( const TQString &name )
 {
   parse( name );
 }
@@ -33,27 +33,27 @@ QualifiedName::QualifiedName()
 {
 }
 
-void QualifiedName::operator=( const QString &name )
+void QualifiedName::operator=( const TQString &name )
 {
   parse( name );
 }
 
-QString QualifiedName::localName() const
+TQString QualifiedName::localName() const
 {
   return mLocalName;
 }
 
-QString QualifiedName::prefix() const
+TQString QualifiedName::prefix() const
 {
   return mPrefix;
 }
 
-void QualifiedName::setNameSpace( const QString &nameSpace )
+void QualifiedName::setNameSpace( const TQString &nameSpace )
 {
   mNameSpace = nameSpace;
 }
 
-QString QualifiedName::nameSpace() const
+TQString QualifiedName::nameSpace() const
 {
   return mNameSpace;
 }
@@ -63,7 +63,7 @@ bool QualifiedName::operator==( const QualifiedName &qn ) const
   return (qn.nameSpace() == mNameSpace && qn.localName() == mLocalName );
 }
 
-void QualifiedName::parse( const QString &str )
+void QualifiedName::parse( const TQString &str )
 {
   int pos = str.find( ':' );
   if ( pos != -1 ) {
diff --git a/kode/kwsdl/schema/qualifiedname.h b/kode/kwsdl/schema/qualifiedname.h
index 5b2f59bcd..f879836cd 100644
--- a/kode/kwsdl/schema/qualifiedname.h
+++ b/kode/kwsdl/schema/qualifiedname.h
@@ -23,35 +23,35 @@
 #ifndef SCHEMA_QUALIFIEDNAME_H
 #define SCHEMA_QUALIFIEDNAME_H
 
-#include <qstring.h>
-#include <qvaluelist.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
 
 namespace Schema {
 
 class QualifiedName
 {
   public:
-    typedef QValueList<QualifiedName> List;
+    typedef TQValueList<QualifiedName> List;
 
     QualifiedName();
-    QualifiedName( const QString &name );
+    QualifiedName( const TQString &name );
 
-    void operator=( const QString &name );
+    void operator=( const TQString &name );
 
-    QString localName() const;
-    QString prefix() const;
+    TQString localName() const;
+    TQString prefix() const;
 
-    void setNameSpace( const QString &nameSpace );
-    QString nameSpace() const;
+    void setNameSpace( const TQString &nameSpace );
+    TQString nameSpace() const;
 
     bool operator==( const QualifiedName& ) const;
 
   private:
-    void parse( const QString& );
+    void parse( const TQString& );
 
-    QString mNameSpace;
-    QString mLocalName;
-    QString mPrefix;
+    TQString mNameSpace;
+    TQString mLocalName;
+    TQString mPrefix;
 };
 
 }
diff --git a/kode/kwsdl/schema/simpletype.cpp b/kode/kwsdl/schema/simpletype.cpp
index 6943563f4..d5dcf2fd9 100644
--- a/kode/kwsdl/schema/simpletype.cpp
+++ b/kode/kwsdl/schema/simpletype.cpp
@@ -31,7 +31,7 @@ SimpleType::SimpleType()
 {
 }
 
-SimpleType::SimpleType( const QString &nameSpace )
+SimpleType::SimpleType( const TQString &nameSpace )
   : mNameSpace( nameSpace ), mBaseType( 0 ), mContentModel( SIMPLE ),
     mRestriction( false ), mFacetId( NONE ), mAnonymous( false ),
     mSubType( TypeRestriction ), mListType( INVALID )
@@ -42,12 +42,12 @@ SimpleType::~SimpleType()
 {
 }
 
-void SimpleType::setName( const QString &name )
+void SimpleType::setName( const TQString &name )
 {
   mName = name;
 }
 
-QString SimpleType::name() const
+TQString SimpleType::name() const
 {
   return mName;
 }
@@ -59,12 +59,12 @@ QualifiedName SimpleType::qualifiedName() const
   return qn;
 }
 
-void SimpleType::setDocumentation( const QString &documentation )
+void SimpleType::setDocumentation( const TQString &documentation )
 {
   mDocumentation = documentation;
 }
 
-QString SimpleType::documentation() const
+TQString SimpleType::documentation() const
 {
   return mDocumentation;
 }
@@ -90,12 +90,12 @@ int SimpleType::baseType() const
   return mBaseType;
 }
 
-void SimpleType::setBaseTypeName( const QString &baseTypeName )
+void SimpleType::setBaseTypeName( const TQString &baseTypeName )
 {
   mBaseTypeName = baseTypeName;
 }
 
-QString SimpleType::baseTypeName() const
+TQString SimpleType::baseTypeName() const
 {
   return mBaseTypeName;
 }
@@ -120,12 +120,12 @@ int SimpleType::listType() const
   return mListType;
 }
 
-void SimpleType::setListTypeName( const QString &name )
+void SimpleType::setListTypeName( const TQString &name )
 {
   mListTypeName = name;
 }
 
-QString SimpleType::listTypeName() const
+TQString SimpleType::listTypeName() const
 {
   return mListTypeName;
 }
@@ -150,7 +150,7 @@ bool SimpleType::isAnonymous() const
   return mAnonymous;
 }
 
-bool SimpleType::isValidFacet( const QString &facet )
+bool SimpleType::isValidFacet( const TQString &facet )
 {
   if ( mBaseType == 0 ) {
     qDebug( "isValidFacet:Unknown base type" );
@@ -189,7 +189,7 @@ bool SimpleType::isValidFacet( const QString &facet )
   return true;
 }
 
-void SimpleType::setFacetValue( const QString &value )
+void SimpleType::setFacetValue( const TQString &value )
 {
   int number = -1;
 
@@ -255,7 +255,7 @@ int SimpleType::facetMaximumLength() const
   return mFacetValue.lenRange.maxlen;
 }
 
-QStringList SimpleType::facetEnums() const
+TQStringList SimpleType::facetEnums() const
 {
   return mEnums;
 }
@@ -295,7 +295,7 @@ int SimpleType::facetFractionDigits() const
   return mFacetValue.frac;
 }
 
-QString SimpleType::facetPattern() const
+TQString SimpleType::facetPattern() const
 {
   return mFacetValue.pattern;
 }
diff --git a/kode/kwsdl/schema/simpletype.h b/kode/kwsdl/schema/simpletype.h
index 12d129a48..b82145f71 100644
--- a/kode/kwsdl/schema/simpletype.h
+++ b/kode/kwsdl/schema/simpletype.h
@@ -23,7 +23,7 @@
 #ifndef SCHEMA_SIMPLETYPE_H
 #define SCHEMA_SIMPLETYPE_H
 
-#include <qstringlist.h>
+#include <tqstringlist.h>
 
 #include "qualifiedname.h"
 #include "xsdtype.h"
@@ -33,7 +33,7 @@ namespace Schema {
 class SimpleType : public XSDType
 {
   public:
-    typedef QValueList<SimpleType> List;
+    typedef TQValueList<SimpleType> List;
 
     enum FacetType
     {
@@ -67,16 +67,16 @@ class SimpleType : public XSDType
     };
 
     SimpleType();
-    SimpleType( const QString &nameSpace );
+    SimpleType( const TQString &nameSpace );
     ~SimpleType();
 
-    void setName( const QString &name );
-    QString name() const;
+    void setName( const TQString &name );
+    TQString name() const;
 
     QualifiedName qualifiedName() const;
 
-    void setDocumentation( const QString &documentation );
-    QString documentation() const;
+    void setDocumentation( const TQString &documentation );
+    TQString documentation() const;
 
     void setType( int type );
     int type() const;
@@ -84,17 +84,17 @@ class SimpleType : public XSDType
     void setBaseType( int baseType );
     int baseType() const;
 
-    void setBaseTypeName( const QString &baseTypeName );
-    QString baseTypeName() const;
+    void setBaseTypeName( const TQString &baseTypeName );
+    TQString baseTypeName() const;
 
     void setSubType( SubType subType );
     SubType subType() const;
 
     void setListType( int listType );
-    void setListTypeName( const QString &name );
+    void setListTypeName( const TQString &name );
 
     int listType() const;
-    QString listTypeName() const;
+    TQString listTypeName() const;
 
     void setContentModel( int contentModel );
     int contentModel() const;
@@ -102,15 +102,15 @@ class SimpleType : public XSDType
     void setAnonymous( bool anonymous );
     bool isAnonymous() const;
 
-    bool isValidFacet( const QString &facet );
-    void setFacetValue( const QString &value );
+    bool isValidFacet( const TQString &facet );
+    void setFacetValue( const TQString &value );
 
     int facetType() const;
 
     int facetLength() const;
     int facetMinimumLength() const;
     int facetMaximumLength() const;
-    QStringList facetEnums() const;
+    TQStringList facetEnums() const;
     WhiteSpaceType facetWhiteSpace() const;
     int facetMinimumInclusive() const;
     int facetMaximumInclusive() const;
@@ -118,24 +118,24 @@ class SimpleType : public XSDType
     int facetMaximumExclusive() const;
     int facetTotalDigits() const;
     int facetFractionDigits() const;
-    QString facetPattern() const;
+    TQString facetPattern() const;
 
   private:
-    QString mName;
-    QString mNameSpace;
-    QString mDocumentation;
+    TQString mName;
+    TQString mNameSpace;
+    TQString mDocumentation;
     int mType;
     int mBaseType;
-    QString mBaseTypeName;
+    TQString mBaseTypeName;
     int mContentModel;
     bool mRestriction;
     int mFacetId;
     bool mAnonymous;
-    QStringList mEnums;
+    TQStringList mEnums;
     SubType mSubType;
 
     int mListType;
-    QString mListTypeName;
+    TQString mListTypeName;
 
     typedef struct
     {
@@ -151,7 +151,7 @@ class SimpleType : public XSDType
       } valRange;
       int tot;
       int frac;
-      QString pattern;
+      TQString pattern;
     } FacetValueType;
 
 
diff --git a/kode/kwsdl/schema/typestable.cpp b/kode/kwsdl/schema/typestable.cpp
index 8e0e66dd0..91a85f516 100644
--- a/kode/kwsdl/schema/typestable.cpp
+++ b/kode/kwsdl/schema/typestable.cpp
@@ -68,7 +68,7 @@ TypesTable::~TypesTable()
 
 void TypesTable::clear()
 {
-  QMap<QString, int>::Iterator it;
+  TQMap<TQString, int>::Iterator it;
   for ( it = mUserTypes.begin(); it != mUserTypes.end(); ++it )
     delete typePtr( it.data() );
 
@@ -94,7 +94,7 @@ int TypesTable::extRefType( int index ) const
 int TypesTable::addType( XSDType *type )
 {
   QualifiedName qn = type->qualifiedName();
-  QString type_name( qn.localName() );
+  TQString type_name( qn.localName() );
 
   int i = 0;
 
@@ -146,12 +146,12 @@ int TypesTable::typeId( const QualifiedName &name, bool create )
   return typeId;
 }
 
-QString TypesTable::typeName( int id ) const
+TQString TypesTable::typeName( int id ) const
 {
   if ( id < 0 )
-    return QString();
+    return TQString();
 
-  QMap<QString, int>::ConstIterator it;
+  TQMap<TQString, int>::ConstIterator it;
 
   if ( id >= 0 && id <= XSDType::ANYURI ) {
     for ( it = mBasicTypes.begin(); it != mBasicTypes.end(); ++it )
@@ -204,7 +204,7 @@ bool TypesTable::detectUndefinedTypes()
   return false;
 }
 
-void TypesTable::resolveForwardElementRefs( const QString &name, Element &element )
+void TypesTable::resolveForwardElementRefs( const TQString &name, Element &element )
 {
   for ( int i = 0; i < (int)mTypes.count(); i++ )
     if ( mTypes[i] != 0 ) {
@@ -215,7 +215,7 @@ void TypesTable::resolveForwardElementRefs( const QString &name, Element &elemen
     }
 }
 
-void TypesTable::resolveForwardAttributeRefs( const QString &name, Attribute &attribute )
+void TypesTable::resolveForwardAttributeRefs( const TQString &name, Attribute &attribute )
 {
   for ( int i = 0; i < (int)mTypes.count(); i++ )
     if ( mTypes[i] != 0 ) {
@@ -240,12 +240,12 @@ int TypesTable::numTypes() const
   return mTypes.count();
 }
 
-void TypesTable::setTargetNamespace( const QString &nameSpace )
+void TypesTable::setTargetNamespace( const TQString &nameSpace )
 {
   mNameSpace = nameSpace;
 }
 
-QString TypesTable::targetNamespace() const
+TQString TypesTable::targetNamespace() const
 {
   return mNameSpace;
 }
diff --git a/kode/kwsdl/schema/typestable.h b/kode/kwsdl/schema/typestable.h
index 6dfa378ed..a6ca8bf22 100644
--- a/kode/kwsdl/schema/typestable.h
+++ b/kode/kwsdl/schema/typestable.h
@@ -23,8 +23,8 @@
 #ifndef SCHEMA_TYPESTABLE_H
 #define SCHEMA_TYPESTABLE_H
 
-#include <qmap.h>
-#include <qstring.h>
+#include <tqmap.h>
+#include <tqstring.h>
 
 #include "complextype.h"
 #include "simpletype.h"
@@ -44,7 +44,7 @@ class TypesTable
 
     int typeId( const QualifiedName &name, bool create = false );
 
-    QString typeName( int id ) const;
+    TQString typeName( int id ) const;
 
     int addExternalTypeId( const QualifiedName &type, XSDType *type );
 
@@ -52,8 +52,8 @@ class TypesTable
     QualifiedName extRefName( int index ) const;
     int extRefType( int index ) const;
 
-    void resolveForwardElementRefs( const QString &name, Element &element );
-    void resolveForwardAttributeRefs( const QString &name, Attribute &attribute );
+    void resolveForwardElementRefs( const TQString &name, Element &element );
+    void resolveForwardAttributeRefs( const TQString &name, Attribute &attribute );
 
     XSDType *typePtr( int id ) const;
 
@@ -61,19 +61,19 @@ class TypesTable
 
     bool detectUndefinedTypes();
 
-    void setTargetNamespace( const QString &nameSpace );
-    QString targetNamespace() const;
+    void setTargetNamespace( const TQString &nameSpace );
+    TQString targetNamespace() const;
 
   private:
-    QValueList<XSDType*> mTypes;
+    TQValueList<XSDType*> mTypes;
 
     //maintains a map of all user defined type names and their ids
-    QMap<QString, int> mUserTypes;
-    QMap<QString, int> mBasicTypes;
+    TQMap<TQString, int> mUserTypes;
+    TQMap<TQString, int> mBasicTypes;
 
     int mCurrentId;
 
-    QString mNameSpace;
+    TQString mNameSpace;
 
     struct ExternRef
     {
@@ -81,7 +81,7 @@ class TypesTable
       QualifiedName qname;
     };
 
-    QValueList<struct ExternRef> mExternRefs;
+    TQValueList<struct ExternRef> mExternRefs;
 };
 
 }
diff --git a/kode/kwsdl/schema/xsdtype.h b/kode/kwsdl/schema/xsdtype.h
index b1bc4a7f8..b1077ebe5 100644
--- a/kode/kwsdl/schema/xsdtype.h
+++ b/kode/kwsdl/schema/xsdtype.h
@@ -23,20 +23,20 @@
 #ifndef SCHEMA_XSDTYPE_H
 #define SCHEMA_XSDTYPE_H
 
-#include <qstring.h>
-#include <qvaluelist.h>
-#include <qmap.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
+#include <tqmap.h>
 
 #include "qualifiedname.h"
 
 namespace Schema {
 
-const QString SchemaUri = "http://www.w3.org/2001/XMLSchema";
+const TQString SchemaUri = "http://www.w3.org/2001/XMLSchema";
 
 class XSDType
 {
   public:
-    typedef QValueList<const XSDType*> List;
+    typedef TQValueList<const XSDType*> List;
 
     enum
     {
@@ -78,7 +78,7 @@ class XSDType
       ANYURI
     };
 
-    XSDType( const QString& )
+    XSDType( const TQString& )
     {
     };
 
@@ -90,9 +90,9 @@ class XSDType
     {
     };
 
-    virtual QString name() const = 0;
+    virtual TQString name() const = 0;
     virtual QualifiedName qualifiedName() const = 0;
-    virtual QString documentation() const = 0;
+    virtual TQString documentation() const = 0;
     virtual int contentModel() const = 0;
     virtual int type() const = 0;
     virtual bool isAnonymous() const = 0;
@@ -102,8 +102,8 @@ class XSDType
       return true;
     }
 
-    virtual void setName( const QString& ) = 0;
-    virtual void setDocumentation( const QString& ) = 0;
+    virtual void setName( const TQString& ) = 0;
+    virtual void setDocumentation( const TQString& ) = 0;
     virtual void setContentModel( int ) = 0;
     virtual void setType( int ) = 0;
     virtual void setAnonymous( bool ) = 0;
diff --git a/kode/kwsdl/service.cpp b/kode/kwsdl/service.cpp
index a34e1df49..a34cdb1d2 100644
--- a/kode/kwsdl/service.cpp
+++ b/kode/kwsdl/service.cpp
@@ -27,7 +27,7 @@ Service::Service()
 {
 }
 
-Service::Service( const QString &name )
+Service::Service( const TQString &name )
   : mName( name )
 {
 }
@@ -37,7 +37,7 @@ void Service::addPort( const Port &port )
   mPorts.insert( port.mName, port );
 }
 
-Service::Port Service::port( const QString &name ) const
+Service::Port Service::port( const TQString &name ) const
 {
   return mPorts[ name ];
 }
diff --git a/kode/kwsdl/service.h b/kode/kwsdl/service.h
index 25f00d9b4..e73db4bf9 100644
--- a/kode/kwsdl/service.h
+++ b/kode/kwsdl/service.h
@@ -22,8 +22,8 @@
 #ifndef KWSDL_SERVICE_H
 #define KWSDL_SERVICE_H
 
-#include <qmap.h>
-#include <qstringlist.h>
+#include <tqmap.h>
+#include <tqstringlist.h>
 
 namespace KWSDL {
 
@@ -33,26 +33,26 @@ class Service
     class Port
     {
       public:
-        typedef QValueList<Port> List;
+        typedef TQValueList<Port> List;
 
-        QString mName;
-        QString mBinding;
-        QString mLocation;
+        TQString mName;
+        TQString mBinding;
+        TQString mLocation;
     };
 
     Service();
-    Service( const QString &name );
+    Service( const TQString &name );
 
-    void setName( const QString &name ) { mName = name; }
-    QString name() const { return mName; }
+    void setName( const TQString &name ) { mName = name; }
+    TQString name() const { return mName; }
 
     void addPort( const Port &port );
-    Port port( const QString &name ) const;
+    Port port( const TQString &name ) const;
     Port::List ports() const;
 
   private:
-    QString mName;
-    QMap<QString, Port> mPorts;
+    TQString mName;
+    TQMap<TQString, Port> mPorts;
 };
 
 }
diff --git a/kode/kwsdl/tests/google/directorycategory.cpp b/kode/kwsdl/tests/google/directorycategory.cpp
index 87f9c5f1a..6a61dab53 100644
--- a/kode/kwsdl/tests/google/directorycategory.cpp
+++ b/kode/kwsdl/tests/google/directorycategory.cpp
@@ -25,24 +25,24 @@
 #include "directorycategory.h"
 
 #include <serializer.h>
-#include <qstring.h>
+#include <tqstring.h>
 
-void DirectoryCategory::setFullViewableName( QString* fullViewableName )
+void DirectoryCategory::setFullViewableName( TQString* fullViewableName )
 {
   mFullViewableName = fullViewableName;
 }
 
-QString*DirectoryCategory::fullViewableName() const
+TQString*DirectoryCategory::fullViewableName() const
 {
    return mFullViewableName;
 }
 
-void DirectoryCategory::setSpecialEncoding( QString* specialEncoding )
+void DirectoryCategory::setSpecialEncoding( TQString* specialEncoding )
 {
   mSpecialEncoding = specialEncoding;
 }
 
-QString*DirectoryCategory::specialEncoding() const
+TQString*DirectoryCategory::specialEncoding() const
 {
    return mSpecialEncoding;
 }
diff --git a/kode/kwsdl/tests/google/directorycategory.h b/kode/kwsdl/tests/google/directorycategory.h
index 0ce1c417d..82dadedc0 100644
--- a/kode/kwsdl/tests/google/directorycategory.h
+++ b/kode/kwsdl/tests/google/directorycategory.h
@@ -29,16 +29,16 @@ class QString;
 class DirectoryCategory
 {
   public:
-    void setFullViewableName( QString* fullViewableName );
-    QString*fullViewableName() const;
-    void setSpecialEncoding( QString* specialEncoding );
-    QString*specialEncoding() const;
+    void setFullViewableName( TQString* fullViewableName );
+    TQString*fullViewableName() const;
+    void setSpecialEncoding( TQString* specialEncoding );
+    TQString*specialEncoding() const;
     DirectoryCategory();
     ~DirectoryCategory();
   
   private:
-    QString*mFullViewableName;
-    QString*mSpecialEncoding;
+    TQString*mFullViewableName;
+    TQString*mSpecialEncoding;
 };
 
 #endif
diff --git a/kode/kwsdl/tests/google/directorycategoryarray.cpp b/kode/kwsdl/tests/google/directorycategoryarray.cpp
index 724cf26cf..b8305222c 100644
--- a/kode/kwsdl/tests/google/directorycategoryarray.cpp
+++ b/kode/kwsdl/tests/google/directorycategoryarray.cpp
@@ -26,14 +26,14 @@
 
 #include <serializer.h>
 #include <directorycategory.h>
-#include <qptrlist.h>
+#include <tqptrlist.h>
 
-void DirectoryCategoryArray::setItems( QPtrList<DirectoryCategory>* items )
+void DirectoryCategoryArray::setItems( TQPtrList<DirectoryCategory>* items )
 {
   mItems = items;
 }
 
-QPtrList<DirectoryCategory>*DirectoryCategoryArray::items() const
+TQPtrList<DirectoryCategory>*DirectoryCategoryArray::items() const
 {
    return mItems;
 }
diff --git a/kode/kwsdl/tests/google/directorycategoryarray.h b/kode/kwsdl/tests/google/directorycategoryarray.h
index db19d9bfa..f4c279952 100644
--- a/kode/kwsdl/tests/google/directorycategoryarray.h
+++ b/kode/kwsdl/tests/google/directorycategoryarray.h
@@ -24,20 +24,20 @@
 #ifndef DIRECTORYCATEGORYARRAY_H
 #define DIRECTORYCATEGORYARRAY_H
 
-#include <qptrlist.h>
+#include <tqptrlist.h>
 
 class DirectoryCategory;
 
 class DirectoryCategoryArray
 {
   public:
-    void setItems( QPtrList<DirectoryCategory>* items );
-    QPtrList<DirectoryCategory>*items() const;
+    void setItems( TQPtrList<DirectoryCategory>* items );
+    TQPtrList<DirectoryCategory>*items() const;
     DirectoryCategoryArray();
     ~DirectoryCategoryArray();
   
   private:
-    QPtrList<DirectoryCategory>*mItems;
+    TQPtrList<DirectoryCategory>*mItems;
 };
 
 #endif
diff --git a/kode/kwsdl/tests/google/googlesearch.cc b/kode/kwsdl/tests/google/googlesearch.cc
index 2e1374b47..5e26c769a 100644
--- a/kode/kwsdl/tests/google/googlesearch.cc
+++ b/kode/kwsdl/tests/google/googlesearch.cc
@@ -27,38 +27,38 @@
 #include "resultelementarray.h"
 
 GoogleSearch::GoogleSearch()
-  : QObject( 0, "" )
+  : TQObject( 0, "" )
 {
-  connect( &mService, SIGNAL( doGetCachedPageResponse( QByteArray* ) ),
-           this, SLOT( cachedPageResult( QByteArray* ) ) );
-  connect( &mService, SIGNAL( doSpellingSuggestionResponse( QString* ) ),
-           this, SLOT( spellingSuggestionResult( QString* ) ) );
-  connect( &mService, SIGNAL( doGoogleSearchResponse( GoogleSearchResult* ) ),
-           this, SLOT( googleSearchResult( GoogleSearchResult* ) ) );
+  connect( &mService, TQT_SIGNAL( doGetCachedPageResponse( TQByteArray* ) ),
+           this, TQT_SLOT( cachedPageResult( TQByteArray* ) ) );
+  connect( &mService, TQT_SIGNAL( doSpellingSuggestionResponse( TQString* ) ),
+           this, TQT_SLOT( spellingSuggestionResult( TQString* ) ) );
+  connect( &mService, TQT_SIGNAL( doGoogleSearchResponse( GoogleSearchResult* ) ),
+           this, TQT_SLOT( googleSearchResult( GoogleSearchResult* ) ) );
 
   mKey = "";
 }
 
-void GoogleSearch::cachedPage( const QString &url )
+void GoogleSearch::cachedPage( const TQString &url )
 {
-  mService.doGetCachedPage( new QString( mKey ), new QString( url ) );
+  mService.doGetCachedPage( new TQString( mKey ), new TQString( url ) );
 }
 
-void GoogleSearch::spellingSuggestion( const QString &phrase )
+void GoogleSearch::spellingSuggestion( const TQString &phrase )
 {
-  mService.doSpellingSuggestion( new QString( mKey ), new QString( phrase ) );
+  mService.doSpellingSuggestion( new TQString( mKey ), new TQString( phrase ) );
 }
 
-void GoogleSearch::googleSearch( const QString &query, int start, int maxResults, bool filter,
-                                 const QString &restrict, bool safeSearch, const QString &lr, const QString &ie,
-                                 const QString &oe )
+void GoogleSearch::googleSearch( const TQString &query, int start, int maxResults, bool filter,
+                                 const TQString &restrict, bool safeSearch, const TQString &lr, const TQString &ie,
+                                 const TQString &oe )
 {
-  mService.doGoogleSearch( new QString( mKey ), new QString( query ), new int( start ), new int( maxResults ),
-                           new bool( filter ), new QString( restrict ), new bool( safeSearch ), new QString( lr ),
-                           new QString( ie ), new QString( oe ) );
+  mService.doGoogleSearch( new TQString( mKey ), new TQString( query ), new int( start ), new int( maxResults ),
+                           new bool( filter ), new TQString( restrict ), new bool( safeSearch ), new TQString( lr ),
+                           new TQString( ie ), new TQString( oe ) );
 }
 
-void GoogleSearch::cachedPageResult( QByteArray *array )
+void GoogleSearch::cachedPageResult( TQByteArray *array )
 {
   qDebug( "--------------- Cached Page Results ---------------------" );
   qDebug( "%s", array->data() );
@@ -67,7 +67,7 @@ void GoogleSearch::cachedPageResult( QByteArray *array )
   delete array;
 }
 
-void GoogleSearch::spellingSuggestionResult( QString *word )
+void GoogleSearch::spellingSuggestionResult( TQString *word )
 {
   qDebug( "--------------- Spelling Suggestion ---------------------" );
   qDebug( "%s", word->latin1() );
@@ -80,8 +80,8 @@ void GoogleSearch::googleSearchResult( GoogleSearchResult *result )
 {
   qDebug( "--------------------- Search Results ---------------------" );
   ResultElementArray *array = result->resultElements();
-  QPtrList<ResultElement> *list = array->items();
-  QPtrListIterator<ResultElement> it( *list );
+  TQPtrList<ResultElement> *list = array->items();
+  TQPtrListIterator<ResultElement> it( *list );
   while ( it.current() != 0 ) {
     qDebug( "%s: %s", it.current()->summary()->latin1(), it.current()->uRL()->latin1() );
     ++it;
diff --git a/kode/kwsdl/tests/google/googlesearch.hh b/kode/kwsdl/tests/google/googlesearch.hh
index 21aed9574..a1c490bbf 100644
--- a/kode/kwsdl/tests/google/googlesearch.hh
+++ b/kode/kwsdl/tests/google/googlesearch.hh
@@ -25,7 +25,7 @@
 #ifndef GOOGLESEARCH_H
 #define GOOGLESEARCH_H
 
-#include <qobject.h>
+#include <tqobject.h>
 #include "googlesearchservice.h"
 
 class GoogleSearch : public QObject
@@ -35,25 +35,25 @@ class GoogleSearch : public QObject
   public:
     GoogleSearch();
 
-    void cachedPage( const QString &url );
-    void spellingSuggestion( const QString &phrase );
-    void googleSearch( const QString &query,
+    void cachedPage( const TQString &url );
+    void spellingSuggestion( const TQString &phrase );
+    void googleSearch( const TQString &query,
                        int start,
                        int maxResults,
                        bool filter,
-                       const QString &restrict,
+                       const TQString &restrict,
                        bool safeSearch,
-                       const QString &lr,
-                       const QString &ie,
-                       const QString &oe );
+                       const TQString &lr,
+                       const TQString &ie,
+                       const TQString &oe );
 
   private slots:
-    void cachedPageResult( QByteArray* );
-    void spellingSuggestionResult( QString* );
+    void cachedPageResult( TQByteArray* );
+    void spellingSuggestionResult( TQString* );
     void googleSearchResult( GoogleSearchResult* );
 
   private:
-    QString mKey;
+    TQString mKey;
     GoogleSearchService mService;
 };
 
diff --git a/kode/kwsdl/tests/google/googlesearchresult.cpp b/kode/kwsdl/tests/google/googlesearchresult.cpp
index 2d3ce11e2..faa209ce6 100644
--- a/kode/kwsdl/tests/google/googlesearchresult.cpp
+++ b/kode/kwsdl/tests/google/googlesearchresult.cpp
@@ -25,7 +25,7 @@
 #include "googlesearchresult.h"
 
 #include <serializer.h>
-#include <qstring.h>
+#include <tqstring.h>
 #include <resultelementarray.h>
 #include <directorycategoryarray.h>
 
@@ -39,12 +39,12 @@ bool*GoogleSearchResult::documentFiltering() const
    return mDocumentFiltering;
 }
 
-void GoogleSearchResult::setSearchComments( QString* searchComments )
+void GoogleSearchResult::setSearchComments( TQString* searchComments )
 {
   mSearchComments = searchComments;
 }
 
-QString*GoogleSearchResult::searchComments() const
+TQString*GoogleSearchResult::searchComments() const
 {
    return mSearchComments;
 }
@@ -79,12 +79,12 @@ ResultElementArray*GoogleSearchResult::resultElements() const
    return mResultElements;
 }
 
-void GoogleSearchResult::setSearchQuery( QString* searchQuery )
+void GoogleSearchResult::setSearchQuery( TQString* searchQuery )
 {
   mSearchQuery = searchQuery;
 }
 
-QString*GoogleSearchResult::searchQuery() const
+TQString*GoogleSearchResult::searchQuery() const
 {
    return mSearchQuery;
 }
@@ -109,12 +109,12 @@ int*GoogleSearchResult::endIndex() const
    return mEndIndex;
 }
 
-void GoogleSearchResult::setSearchTips( QString* searchTips )
+void GoogleSearchResult::setSearchTips( TQString* searchTips )
 {
   mSearchTips = searchTips;
 }
 
-QString*GoogleSearchResult::searchTips() const
+TQString*GoogleSearchResult::searchTips() const
 {
    return mSearchTips;
 }
diff --git a/kode/kwsdl/tests/google/googlesearchresult.h b/kode/kwsdl/tests/google/googlesearchresult.h
index 542fb6864..c2cfa16dc 100644
--- a/kode/kwsdl/tests/google/googlesearchresult.h
+++ b/kode/kwsdl/tests/google/googlesearchresult.h
@@ -33,22 +33,22 @@ class GoogleSearchResult
   public:
     void setDocumentFiltering( bool* documentFiltering );
     bool*documentFiltering() const;
-    void setSearchComments( QString* searchComments );
-    QString*searchComments() const;
+    void setSearchComments( TQString* searchComments );
+    TQString*searchComments() const;
     void setEstimatedTotalResultsCount( int* estimatedTotalResultsCount );
     int*estimatedTotalResultsCount() const;
     void setEstimateIsExact( bool* estimateIsExact );
     bool*estimateIsExact() const;
     void setResultElements( ResultElementArray* resultElements );
     ResultElementArray*resultElements() const;
-    void setSearchQuery( QString* searchQuery );
-    QString*searchQuery() const;
+    void setSearchQuery( TQString* searchQuery );
+    TQString*searchQuery() const;
     void setStartIndex( int* startIndex );
     int*startIndex() const;
     void setEndIndex( int* endIndex );
     int*endIndex() const;
-    void setSearchTips( QString* searchTips );
-    QString*searchTips() const;
+    void setSearchTips( TQString* searchTips );
+    TQString*searchTips() const;
     void setDirectoryCategories( DirectoryCategoryArray* directoryCategories );
     DirectoryCategoryArray*directoryCategories() const;
     void setSearchTime( double* searchTime );
@@ -58,14 +58,14 @@ class GoogleSearchResult
   
   private:
     bool*mDocumentFiltering;
-    QString*mSearchComments;
+    TQString*mSearchComments;
     int*mEstimatedTotalResultsCount;
     bool*mEstimateIsExact;
     ResultElementArray*mResultElements;
-    QString*mSearchQuery;
+    TQString*mSearchQuery;
     int*mStartIndex;
     int*mEndIndex;
-    QString*mSearchTips;
+    TQString*mSearchTips;
     DirectoryCategoryArray*mDirectoryCategories;
     double*mSearchTime;
 };
diff --git a/kode/kwsdl/tests/google/googlesearchservice.cpp b/kode/kwsdl/tests/google/googlesearchservice.cpp
index 555850713..3ccdb4935 100644
--- a/kode/kwsdl/tests/google/googlesearchservice.cpp
+++ b/kode/kwsdl/tests/google/googlesearchservice.cpp
@@ -26,18 +26,18 @@
 
 #include <serializer.h>
 
-void GoogleSearchService::doGetCachedPage( QString* key, QString* url )
+void GoogleSearchService::doGetCachedPage( TQString* key, TQString* url )
 {
-  QDomDocument doc( "kwsdl" );
+  TQDomDocument doc( "kwsdl" );
   doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
-  QDomElement env = doc.createElement( "SOAP-ENV:Envelope" );
+  TQDomElement env = doc.createElement( "SOAP-ENV:Envelope" );
   env.setAttribute( "xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/" );
   env.setAttribute( "xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance" );
   env.setAttribute( "xmlns:xsd", "http://www.w3.org/1999/XMLSchema" );
   doc.appendChild( env );
-  QDomElement body = doc.createElement( "SOAP-ENV:Body" );
+  TQDomElement body = doc.createElement( "SOAP-ENV:Body" );
   env.appendChild( body );
-  QDomElement method = doc.createElement( "ns1:doGetCachedPage" );
+  TQDomElement method = doc.createElement( "ns1:doGetCachedPage" );
   method.setAttribute( "xmlns:ns1", "urn:GoogleSearch" );
   method.setAttribute( "SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/" );
   body.appendChild( method );
@@ -50,10 +50,10 @@ void GoogleSearchService::doGetCachedPage( QString* key, QString* url )
   mDoGetCachedPageTransport->query( doc.toString() );
 }
 
-void GoogleSearchService::doGetCachedPageResponseSlot( const QString &xml )
+void GoogleSearchService::doGetCachedPageResponseSlot( const TQString &xml )
 {
-  QDomDocument doc;
-  QString errorMsg;
+  TQDomDocument doc;
+  TQString errorMsg;
   int column, row;
   
   qDebug( "%s", xml.latin1() );
@@ -63,27 +63,27 @@ void GoogleSearchService::doGetCachedPageResponseSlot( const QString &xml )
     return;
   }
   
-  QByteArray* value = new QByteArray;
-  QDomElement envelope = doc.documentElement();
-  QDomElement body = envelope.firstChild().toElement();
-  QDomElement method = body.firstChild().toElement();
+  TQByteArray* value = new QByteArray;
+  TQDomElement envelope = doc.documentElement();
+  TQDomElement body = envelope.firstChild().toElement();
+  TQDomElement method = body.firstChild().toElement();
   Serializer::demarshal( method.firstChild().toElement(), value );
   
   emit doGetCachedPageResponse( value );
 }
 
-void GoogleSearchService::doSpellingSuggestion( QString* key, QString* phrase )
+void GoogleSearchService::doSpellingSuggestion( TQString* key, TQString* phrase )
 {
-  QDomDocument doc( "kwsdl" );
+  TQDomDocument doc( "kwsdl" );
   doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
-  QDomElement env = doc.createElement( "SOAP-ENV:Envelope" );
+  TQDomElement env = doc.createElement( "SOAP-ENV:Envelope" );
   env.setAttribute( "xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/" );
   env.setAttribute( "xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance" );
   env.setAttribute( "xmlns:xsd", "http://www.w3.org/1999/XMLSchema" );
   doc.appendChild( env );
-  QDomElement body = doc.createElement( "SOAP-ENV:Body" );
+  TQDomElement body = doc.createElement( "SOAP-ENV:Body" );
   env.appendChild( body );
-  QDomElement method = doc.createElement( "ns1:doSpellingSuggestion" );
+  TQDomElement method = doc.createElement( "ns1:doSpellingSuggestion" );
   method.setAttribute( "xmlns:ns1", "urn:GoogleSearch" );
   method.setAttribute( "SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/" );
   body.appendChild( method );
@@ -96,10 +96,10 @@ void GoogleSearchService::doSpellingSuggestion( QString* key, QString* phrase )
   mDoSpellingSuggestionTransport->query( doc.toString() );
 }
 
-void GoogleSearchService::doSpellingSuggestionResponseSlot( const QString &xml )
+void GoogleSearchService::doSpellingSuggestionResponseSlot( const TQString &xml )
 {
-  QDomDocument doc;
-  QString errorMsg;
+  TQDomDocument doc;
+  TQString errorMsg;
   int column, row;
   
   qDebug( "%s", xml.latin1() );
@@ -109,27 +109,27 @@ void GoogleSearchService::doSpellingSuggestionResponseSlot( const QString &xml )
     return;
   }
   
-  QString* value = new QString;
-  QDomElement envelope = doc.documentElement();
-  QDomElement body = envelope.firstChild().toElement();
-  QDomElement method = body.firstChild().toElement();
+  TQString* value = new QString;
+  TQDomElement envelope = doc.documentElement();
+  TQDomElement body = envelope.firstChild().toElement();
+  TQDomElement method = body.firstChild().toElement();
   Serializer::demarshal( method.firstChild().toElement(), value );
   
   emit doSpellingSuggestionResponse( value );
 }
 
-void GoogleSearchService::doGoogleSearch( QString* key, QString* q, int* start, int* maxResults, bool* filter, QString* restrict, bool* safeSearch, QString* lr, QString* ie, QString* oe )
+void GoogleSearchService::doGoogleSearch( TQString* key, TQString* q, int* start, int* maxResults, bool* filter, TQString* restrict, bool* safeSearch, TQString* lr, TQString* ie, TQString* oe )
 {
-  QDomDocument doc( "kwsdl" );
+  TQDomDocument doc( "kwsdl" );
   doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
-  QDomElement env = doc.createElement( "SOAP-ENV:Envelope" );
+  TQDomElement env = doc.createElement( "SOAP-ENV:Envelope" );
   env.setAttribute( "xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/" );
   env.setAttribute( "xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance" );
   env.setAttribute( "xmlns:xsd", "http://www.w3.org/1999/XMLSchema" );
   doc.appendChild( env );
-  QDomElement body = doc.createElement( "SOAP-ENV:Body" );
+  TQDomElement body = doc.createElement( "SOAP-ENV:Body" );
   env.appendChild( body );
-  QDomElement method = doc.createElement( "ns1:doGoogleSearch" );
+  TQDomElement method = doc.createElement( "ns1:doGoogleSearch" );
   method.setAttribute( "xmlns:ns1", "urn:GoogleSearch" );
   method.setAttribute( "SOAP-ENV:encodingStyle", "http://schemas.xmlsoap.org/soap/encoding/" );
   body.appendChild( method );
@@ -158,10 +158,10 @@ void GoogleSearchService::doGoogleSearch( QString* key, QString* q, int* start,
   mDoGoogleSearchTransport->query( doc.toString() );
 }
 
-void GoogleSearchService::doGoogleSearchResponseSlot( const QString &xml )
+void GoogleSearchService::doGoogleSearchResponseSlot( const TQString &xml )
 {
-  QDomDocument doc;
-  QString errorMsg;
+  TQDomDocument doc;
+  TQString errorMsg;
   int column, row;
   
   qDebug( "%s", xml.latin1() );
@@ -172,9 +172,9 @@ void GoogleSearchService::doGoogleSearchResponseSlot( const QString &xml )
   }
   
   GoogleSearchResult* value = new GoogleSearchResult;
-  QDomElement envelope = doc.documentElement();
-  QDomElement body = envelope.firstChild().toElement();
-  QDomElement method = body.firstChild().toElement();
+  TQDomElement envelope = doc.documentElement();
+  TQDomElement body = envelope.firstChild().toElement();
+  TQDomElement method = body.firstChild().toElement();
   Serializer::demarshal( method.firstChild().toElement(), value );
   
   emit doGoogleSearchResponse( value );
@@ -183,14 +183,14 @@ void GoogleSearchService::doGoogleSearchResponseSlot( const QString &xml )
 GoogleSearchService::GoogleSearchService()
 {
   mDoGetCachedPageTransport = new Transport( "http://api.google.com/search/beta2" );
-  connect( mDoGetCachedPageTransport, SIGNAL( result( const QString& ) ),
-    this, SLOT( doGetCachedPageResponseSlot( const QString& ) ) );
+  connect( mDoGetCachedPageTransport, TQT_SIGNAL( result( const TQString& ) ),
+    this, TQT_SLOT( doGetCachedPageResponseSlot( const TQString& ) ) );
   mDoSpellingSuggestionTransport = new Transport( "http://api.google.com/search/beta2" );
-  connect( mDoSpellingSuggestionTransport, SIGNAL( result( const QString& ) ),
-    this, SLOT( doSpellingSuggestionResponseSlot( const QString& ) ) );
+  connect( mDoSpellingSuggestionTransport, TQT_SIGNAL( result( const TQString& ) ),
+    this, TQT_SLOT( doSpellingSuggestionResponseSlot( const TQString& ) ) );
   mDoGoogleSearchTransport = new Transport( "http://api.google.com/search/beta2" );
-  connect( mDoGoogleSearchTransport, SIGNAL( result( const QString& ) ),
-    this, SLOT( doGoogleSearchResponseSlot( const QString& ) ) );
+  connect( mDoGoogleSearchTransport, TQT_SIGNAL( result( const TQString& ) ),
+    this, TQT_SLOT( doGoogleSearchResponseSlot( const TQString& ) ) );
 }
 
 GoogleSearchService::~GoogleSearchService()
diff --git a/kode/kwsdl/tests/google/googlesearchservice.h b/kode/kwsdl/tests/google/googlesearchservice.h
index cc8bef027..6efd65239 100644
--- a/kode/kwsdl/tests/google/googlesearchservice.h
+++ b/kode/kwsdl/tests/google/googlesearchservice.h
@@ -24,10 +24,10 @@
 #ifndef GOOGLESEARCHSERVICE_H
 #define GOOGLESEARCHSERVICE_H
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 #include <transport.h>
-#include <qcstring.h>
+#include <tqcstring.h>
 #include <googlesearchresult.h>
 
 class GoogleSearchService : public QObject
@@ -35,21 +35,21 @@ class GoogleSearchService : public QObject
   Q_OBJECT
 
   public:
-    void doGetCachedPage( QString* key, QString* url );
-    void doSpellingSuggestion( QString* key, QString* phrase );
-    void doGoogleSearch( QString* key, QString* q, int* start, int* maxResults, bool* filter, QString* restrict, bool* safeSearch, QString* lr, QString* ie, QString* oe );
+    void doGetCachedPage( TQString* key, TQString* url );
+    void doSpellingSuggestion( TQString* key, TQString* phrase );
+    void doGoogleSearch( TQString* key, TQString* q, int* start, int* maxResults, bool* filter, TQString* restrict, bool* safeSearch, TQString* lr, TQString* ie, TQString* oe );
     GoogleSearchService();
     ~GoogleSearchService();
   
   signals:
-    void doGetCachedPageResponse( QByteArray* value );
-    void doSpellingSuggestionResponse( QString* value );
+    void doGetCachedPageResponse( TQByteArray* value );
+    void doSpellingSuggestionResponse( TQString* value );
     void doGoogleSearchResponse( GoogleSearchResult* value );
   
   private slots:
-    void doGetCachedPageResponseSlot( const QString &xml );
-    void doSpellingSuggestionResponseSlot( const QString &xml );
-    void doGoogleSearchResponseSlot( const QString &xml );
+    void doGetCachedPageResponseSlot( const TQString &xml );
+    void doSpellingSuggestionResponseSlot( const TQString &xml );
+    void doGoogleSearchResponseSlot( const TQString &xml );
   
   private:
     Transport*mDoGetCachedPageTransport;
diff --git a/kode/kwsdl/tests/google/resultelement.cpp b/kode/kwsdl/tests/google/resultelement.cpp
index b02b8ca44..c340f8b04 100644
--- a/kode/kwsdl/tests/google/resultelement.cpp
+++ b/kode/kwsdl/tests/google/resultelement.cpp
@@ -25,55 +25,55 @@
 #include "resultelement.h"
 
 #include <serializer.h>
-#include <qstring.h>
+#include <tqstring.h>
 #include <directorycategory.h>
 
-void ResultElement::setSummary( QString* summary )
+void ResultElement::setSummary( TQString* summary )
 {
   mSummary = summary;
 }
 
-QString*ResultElement::summary() const
+TQString*ResultElement::summary() const
 {
    return mSummary;
 }
 
-void ResultElement::setURL( QString* uRL )
+void ResultElement::setURL( TQString* uRL )
 {
   mURL = uRL;
 }
 
-QString*ResultElement::uRL() const
+TQString*ResultElement::uRL() const
 {
    return mURL;
 }
 
-void ResultElement::setSnippet( QString* snippet )
+void ResultElement::setSnippet( TQString* snippet )
 {
   mSnippet = snippet;
 }
 
-QString*ResultElement::snippet() const
+TQString*ResultElement::snippet() const
 {
    return mSnippet;
 }
 
-void ResultElement::setTitle( QString* title )
+void ResultElement::setTitle( TQString* title )
 {
   mTitle = title;
 }
 
-QString*ResultElement::title() const
+TQString*ResultElement::title() const
 {
    return mTitle;
 }
 
-void ResultElement::setCachedSize( QString* cachedSize )
+void ResultElement::setCachedSize( TQString* cachedSize )
 {
   mCachedSize = cachedSize;
 }
 
-QString*ResultElement::cachedSize() const
+TQString*ResultElement::cachedSize() const
 {
    return mCachedSize;
 }
@@ -88,12 +88,12 @@ bool*ResultElement::relatedInformationPresent() const
    return mRelatedInformationPresent;
 }
 
-void ResultElement::setHostName( QString* hostName )
+void ResultElement::setHostName( TQString* hostName )
 {
   mHostName = hostName;
 }
 
-QString*ResultElement::hostName() const
+TQString*ResultElement::hostName() const
 {
    return mHostName;
 }
@@ -108,12 +108,12 @@ DirectoryCategory*ResultElement::directoryCategory() const
    return mDirectoryCategory;
 }
 
-void ResultElement::setDirectoryTitle( QString* directoryTitle )
+void ResultElement::setDirectoryTitle( TQString* directoryTitle )
 {
   mDirectoryTitle = directoryTitle;
 }
 
-QString*ResultElement::directoryTitle() const
+TQString*ResultElement::directoryTitle() const
 {
    return mDirectoryTitle;
 }
diff --git a/kode/kwsdl/tests/google/resultelement.h b/kode/kwsdl/tests/google/resultelement.h
index 4a24f7291..e83ff3713 100644
--- a/kode/kwsdl/tests/google/resultelement.h
+++ b/kode/kwsdl/tests/google/resultelement.h
@@ -30,37 +30,37 @@ class DirectoryCategory;
 class ResultElement
 {
   public:
-    void setSummary( QString* summary );
-    QString*summary() const;
-    void setURL( QString* uRL );
-    QString*uRL() const;
-    void setSnippet( QString* snippet );
-    QString*snippet() const;
-    void setTitle( QString* title );
-    QString*title() const;
-    void setCachedSize( QString* cachedSize );
-    QString*cachedSize() const;
+    void setSummary( TQString* summary );
+    TQString*summary() const;
+    void setURL( TQString* uRL );
+    TQString*uRL() const;
+    void setSnippet( TQString* snippet );
+    TQString*snippet() const;
+    void setTitle( TQString* title );
+    TQString*title() const;
+    void setCachedSize( TQString* cachedSize );
+    TQString*cachedSize() const;
     void setRelatedInformationPresent( bool* relatedInformationPresent );
     bool*relatedInformationPresent() const;
-    void setHostName( QString* hostName );
-    QString*hostName() const;
+    void setHostName( TQString* hostName );
+    TQString*hostName() const;
     void setDirectoryCategory( DirectoryCategory* directoryCategory );
     DirectoryCategory*directoryCategory() const;
-    void setDirectoryTitle( QString* directoryTitle );
-    QString*directoryTitle() const;
+    void setDirectoryTitle( TQString* directoryTitle );
+    TQString*directoryTitle() const;
     ResultElement();
     ~ResultElement();
   
   private:
-    QString*mSummary;
-    QString*mURL;
-    QString*mSnippet;
-    QString*mTitle;
-    QString*mCachedSize;
+    TQString*mSummary;
+    TQString*mURL;
+    TQString*mSnippet;
+    TQString*mTitle;
+    TQString*mCachedSize;
     bool*mRelatedInformationPresent;
-    QString*mHostName;
+    TQString*mHostName;
     DirectoryCategory*mDirectoryCategory;
-    QString*mDirectoryTitle;
+    TQString*mDirectoryTitle;
 };
 
 #endif
diff --git a/kode/kwsdl/tests/google/resultelementarray.cpp b/kode/kwsdl/tests/google/resultelementarray.cpp
index f356f0101..0ea65755f 100644
--- a/kode/kwsdl/tests/google/resultelementarray.cpp
+++ b/kode/kwsdl/tests/google/resultelementarray.cpp
@@ -25,15 +25,15 @@
 #include "resultelementarray.h"
 
 #include <serializer.h>
-#include <qptrlist.h>
+#include <tqptrlist.h>
 #include <resultelement.h>
 
-void ResultElementArray::setItems( QPtrList<ResultElement>* items )
+void ResultElementArray::setItems( TQPtrList<ResultElement>* items )
 {
   mItems = items;
 }
 
-QPtrList<ResultElement>*ResultElementArray::items() const
+TQPtrList<ResultElement>*ResultElementArray::items() const
 {
    return mItems;
 }
diff --git a/kode/kwsdl/tests/google/resultelementarray.h b/kode/kwsdl/tests/google/resultelementarray.h
index 2d63fe4dd..972171172 100644
--- a/kode/kwsdl/tests/google/resultelementarray.h
+++ b/kode/kwsdl/tests/google/resultelementarray.h
@@ -24,20 +24,20 @@
 #ifndef RESULTELEMENTARRAY_H
 #define RESULTELEMENTARRAY_H
 
-#include <qptrlist.h>
+#include <tqptrlist.h>
 
 class ResultElement;
 
 class ResultElementArray
 {
   public:
-    void setItems( QPtrList<ResultElement>* items );
-    QPtrList<ResultElement>*items() const;
+    void setItems( TQPtrList<ResultElement>* items );
+    TQPtrList<ResultElement>*items() const;
     ResultElementArray();
     ~ResultElementArray();
   
   private:
-    QPtrList<ResultElement>*mItems;
+    TQPtrList<ResultElement>*mItems;
 };
 
 #endif
diff --git a/kode/kwsdl/tests/google/serializer.cpp b/kode/kwsdl/tests/google/serializer.cpp
index 595666fab..273ce5929 100644
--- a/kode/kwsdl/tests/google/serializer.cpp
+++ b/kode/kwsdl/tests/google/serializer.cpp
@@ -31,297 +31,297 @@
 #include <directorycategory.h>
 #include <resultelement.h>
 
-QString Serializer::marshalValue( const QString* value )
+TQString Serializer::marshalValue( const TQString* value )
 {
   return *value;
 }
 
-void Serializer::demarshalValue( const QString &str, QString *value )
+void Serializer::demarshalValue( const TQString &str, TQString *value )
 {
   *value = str;
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const QString* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const TQString* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:string" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, QString* value )
+void Serializer::demarshal( const TQDomElement &element, TQString* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const bool* value )
+TQString Serializer::marshalValue( const bool* value )
 {
   return (*value ? "true" : "false");
 }
 
-void Serializer::demarshalValue( const QString &str, bool *value )
+void Serializer::demarshalValue( const TQString &str, bool *value )
 {
   *value = (str.lower() == "true" ? true : false);
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const bool* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const bool* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:boolean" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, bool* value )
+void Serializer::demarshal( const TQDomElement &element, bool* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const float* value )
+TQString Serializer::marshalValue( const float* value )
 {
-  return QString::number( *value );
+  return TQString::number( *value );
 }
 
-void Serializer::demarshalValue( const QString &str, float *value )
+void Serializer::demarshalValue( const TQString &str, float *value )
 {
   *value = str.toFloat();
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const float* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const float* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:TODO" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, float* value )
+void Serializer::demarshal( const TQDomElement &element, float* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const int* value )
+TQString Serializer::marshalValue( const int* value )
 {
-  return QString::number( *value );
+  return TQString::number( *value );
 }
 
-void Serializer::demarshalValue( const QString &str, int *value )
+void Serializer::demarshalValue( const TQString &str, int *value )
 {
   *value = str.toInt();
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const int* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const int* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:int" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, int* value )
+void Serializer::demarshal( const TQDomElement &element, int* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const unsigned int* value )
+TQString Serializer::marshalValue( const unsigned int* value )
 {
-  return QString::number( *value );
+  return TQString::number( *value );
 }
 
-void Serializer::demarshalValue( const QString &str, unsigned int *value )
+void Serializer::demarshalValue( const TQString &str, unsigned int *value )
 {
   *value = str.toUInt();
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const unsigned int* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const unsigned int* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:unsignedByte" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, unsigned int* value )
+void Serializer::demarshal( const TQDomElement &element, unsigned int* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const double* value )
+TQString Serializer::marshalValue( const double* value )
 {
-  return QString::number( *value );
+  return TQString::number( *value );
 }
 
-void Serializer::demarshalValue( const QString &str, double *value )
+void Serializer::demarshalValue( const TQString &str, double *value )
 {
   *value = str.toDouble();
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const double* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const double* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:double" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, double* value )
+void Serializer::demarshal( const TQDomElement &element, double* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const char* value )
+TQString Serializer::marshalValue( const char* value )
 {
-  return QString( QChar( *value ) );
+  return TQString( TQChar( *value ) );
 }
 
-void Serializer::demarshalValue( const QString &str, char *value )
+void Serializer::demarshalValue( const TQString &str, char *value )
 {
   *value = str[ 0 ].latin1();
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const char* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const char* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:byte" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, char* value )
+void Serializer::demarshal( const TQDomElement &element, char* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const unsigned char* value )
+TQString Serializer::marshalValue( const unsigned char* value )
 {
-  return QString( QChar( *value ) );
+  return TQString( TQChar( *value ) );
 }
 
-void Serializer::demarshalValue( const QString &str, unsigned char *value )
+void Serializer::demarshalValue( const TQString &str, unsigned char *value )
 {
   *value = str[ 0 ].latin1();
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const unsigned char* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const unsigned char* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:unsignedByte" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, unsigned char* value )
+void Serializer::demarshal( const TQDomElement &element, unsigned char* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const short* value )
+TQString Serializer::marshalValue( const short* value )
 {
-  return QString::number( *value );
+  return TQString::number( *value );
 }
 
-void Serializer::demarshalValue( const QString &str, short *value )
+void Serializer::demarshalValue( const TQString &str, short *value )
 {
   *value = str.toShort();
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const short* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const short* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:short" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, short* value )
+void Serializer::demarshal( const TQDomElement &element, short* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const QByteArray* value )
+TQString Serializer::marshalValue( const TQByteArray* value )
 {
-  return QString::fromUtf8( KCodecs::base64Encode( *value ) );
+  return TQString::fromUtf8( KCodecs::base64Encode( *value ) );
 }
 
-void Serializer::demarshalValue( const QString &str, QByteArray *value )
+void Serializer::demarshalValue( const TQString &str, TQByteArray *value )
 {
   *value = KCodecs::base64Decode( str.utf8() );
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const QByteArray* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const TQByteArray* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:base64Binary" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, QByteArray* value )
+void Serializer::demarshal( const TQDomElement &element, TQByteArray* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const QDateTime* value )
+TQString Serializer::marshalValue( const TQDateTime* value )
 {
   return value->toString( Qt::ISODate );
 }
 
-void Serializer::demarshalValue( const QString &str, QDateTime *value )
+void Serializer::demarshalValue( const TQString &str, TQDateTime *value )
 {
-  *value = QDateTime::fromString( str, Qt::ISODate );
+  *value = TQDateTime::fromString( str, Qt::ISODate );
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const QDateTime* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const TQDateTime* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:dateTime" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, QDateTime* value )
+void Serializer::demarshal( const TQDomElement &element, TQDateTime* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-QString Serializer::marshalValue( const QDate* value )
+TQString Serializer::marshalValue( const TQDate* value )
 {
   return value->toString( Qt::ISODate );
 }
 
-void Serializer::demarshalValue( const QString &str, QDate *value )
+void Serializer::demarshalValue( const TQString &str, TQDate *value )
 {
-  *value = QDate::fromString( str, Qt::ISODate );
+  *value = TQDate::fromString( str, Qt::ISODate );
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const QDate* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const TQDate* value )
 {
-  QDomElement element = doc.createElement( name );
+  TQDomElement element = doc.createElement( name );
   element.setAttribute( "xsi:type", "xsd:date" );
   element.appendChild( doc.createTextNode( Serializer::marshalValue( value ) ) );
   parent.appendChild( element );
 }
 
-void Serializer::demarshal( const QDomElement &element, QDate* value )
+void Serializer::demarshal( const TQDomElement &element, TQDate* value )
 {
   Serializer::demarshalValue( element.text(), value );
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const ResultElementArray* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const ResultElementArray* value )
 {
-  QDomElement root = doc.createElement( name );
+  TQDomElement root = doc.createElement( name );
   root.setAttribute( "xsi:type", "ns1:ResultElementArray" );
   parent.appendChild( root );
   if ( value->items() ) {
-    const QPtrList<ResultElement>* list = value->items();
+    const TQPtrList<ResultElement>* list = value->items();
   
-    QDomElement element = doc.createElement( name );
+    TQDomElement element = doc.createElement( name );
     element.setAttribute( "xmlns:ns1", "http://schemas.xmlsoap.org/soap/encoding/" );
     element.setAttribute( "xsi:type", "ns1:Array" );
-    element.setAttribute( "ns1:arrayType", "ns1:ResultElement[" + QString::number( list->count() ) + "]" );
+    element.setAttribute( "ns1:arrayType", "ns1:ResultElement[" + TQString::number( list->count() ) + "]" );
     parent.appendChild( element );
   
-    QPtrListIterator<ResultElement> it( *list );
+    TQPtrListIterator<ResultElement> it( *list );
     while ( it.current() != 0 ) {
       Serializer::marshal( doc, element, "item", it.current() );
       ++it;
@@ -329,13 +329,13 @@ void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString
   }
 }
 
-void Serializer::demarshal( const QDomElement &parent, ResultElementArray* value )
+void Serializer::demarshal( const TQDomElement &parent, ResultElementArray* value )
 {
-  QPtrList<ResultElement>* itemsList = new QPtrList<ResultElement>();
+  TQPtrList<ResultElement>* itemsList = new TQPtrList<ResultElement>();
   itemsList->setAutoDelete( true );
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
   if ( element.tagName() == "item" ) {
     ResultElement *item = new ResultElement;
@@ -349,21 +349,21 @@ void Serializer::demarshal( const QDomElement &parent, ResultElementArray* value
   value->setItems( itemsList );
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const DirectoryCategoryArray* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const DirectoryCategoryArray* value )
 {
-  QDomElement root = doc.createElement( name );
+  TQDomElement root = doc.createElement( name );
   root.setAttribute( "xsi:type", "ns1:DirectoryCategoryArray" );
   parent.appendChild( root );
   if ( value->items() ) {
-    const QPtrList<DirectoryCategory>* list = value->items();
+    const TQPtrList<DirectoryCategory>* list = value->items();
   
-    QDomElement element = doc.createElement( name );
+    TQDomElement element = doc.createElement( name );
     element.setAttribute( "xmlns:ns1", "http://schemas.xmlsoap.org/soap/encoding/" );
     element.setAttribute( "xsi:type", "ns1:Array" );
-    element.setAttribute( "ns1:arrayType", "ns1:DirectoryCategory[" + QString::number( list->count() ) + "]" );
+    element.setAttribute( "ns1:arrayType", "ns1:DirectoryCategory[" + TQString::number( list->count() ) + "]" );
     parent.appendChild( element );
   
-    QPtrListIterator<DirectoryCategory> it( *list );
+    TQPtrListIterator<DirectoryCategory> it( *list );
     while ( it.current() != 0 ) {
       Serializer::marshal( doc, element, "item", it.current() );
       ++it;
@@ -371,13 +371,13 @@ void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString
   }
 }
 
-void Serializer::demarshal( const QDomElement &parent, DirectoryCategoryArray* value )
+void Serializer::demarshal( const TQDomElement &parent, DirectoryCategoryArray* value )
 {
-  QPtrList<DirectoryCategory>* itemsList = new QPtrList<DirectoryCategory>();
+  TQPtrList<DirectoryCategory>* itemsList = new TQPtrList<DirectoryCategory>();
   itemsList->setAutoDelete( true );
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
   if ( element.tagName() == "item" ) {
     DirectoryCategory *item = new DirectoryCategory;
@@ -391,9 +391,9 @@ void Serializer::demarshal( const QDomElement &parent, DirectoryCategoryArray* v
   value->setItems( itemsList );
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const GoogleSearchResult* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const GoogleSearchResult* value )
 {
-  QDomElement root = doc.createElement( name );
+  TQDomElement root = doc.createElement( name );
   root.setAttribute( "xsi:type", "ns1:GoogleSearchResult" );
   parent.appendChild( root );
   if ( value->documentFiltering() ) {
@@ -431,11 +431,11 @@ void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString
   }
 }
 
-void Serializer::demarshal( const QDomElement &parent, GoogleSearchResult* value )
+void Serializer::demarshal( const TQDomElement &parent, GoogleSearchResult* value )
 {
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "documentFiltering" ) {
         bool* item = new bool;
@@ -443,7 +443,7 @@ void Serializer::demarshal( const QDomElement &parent, GoogleSearchResult* value
         value->setDocumentFiltering( item );
       }
       if ( element.tagName() == "searchComments" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setSearchComments( item );
       }
@@ -463,7 +463,7 @@ void Serializer::demarshal( const QDomElement &parent, GoogleSearchResult* value
         value->setResultElements( item );
       }
       if ( element.tagName() == "searchQuery" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setSearchQuery( item );
       }
@@ -478,7 +478,7 @@ void Serializer::demarshal( const QDomElement &parent, GoogleSearchResult* value
         value->setEndIndex( item );
       }
       if ( element.tagName() == "searchTips" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setSearchTips( item );
       }
@@ -498,9 +498,9 @@ void Serializer::demarshal( const QDomElement &parent, GoogleSearchResult* value
   
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const DirectoryCategory* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const DirectoryCategory* value )
 {
-  QDomElement root = doc.createElement( name );
+  TQDomElement root = doc.createElement( name );
   root.setAttribute( "xsi:type", "ns1:DirectoryCategory" );
   parent.appendChild( root );
   if ( value->fullViewableName() ) {
@@ -511,19 +511,19 @@ void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString
   }
 }
 
-void Serializer::demarshal( const QDomElement &parent, DirectoryCategory* value )
+void Serializer::demarshal( const TQDomElement &parent, DirectoryCategory* value )
 {
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "fullViewableName" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setFullViewableName( item );
       }
       if ( element.tagName() == "specialEncoding" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setSpecialEncoding( item );
       }
@@ -533,9 +533,9 @@ void Serializer::demarshal( const QDomElement &parent, DirectoryCategory* value
   
 }
 
-void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const ResultElement* value )
+void Serializer::marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const ResultElement* value )
 {
-  QDomElement root = doc.createElement( name );
+  TQDomElement root = doc.createElement( name );
   root.setAttribute( "xsi:type", "ns1:ResultElement" );
   parent.appendChild( root );
   if ( value->summary() ) {
@@ -567,34 +567,34 @@ void Serializer::marshal( QDomDocument &doc, QDomElement &parent, const QString
   }
 }
 
-void Serializer::demarshal( const QDomElement &parent, ResultElement* value )
+void Serializer::demarshal( const TQDomElement &parent, ResultElement* value )
 {
-  QDomNode node = parent.firstChild();
+  TQDomNode node = parent.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "summary" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setSummary( item );
       }
       if ( element.tagName() == "URL" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setURL( item );
       }
       if ( element.tagName() == "snippet" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setSnippet( item );
       }
       if ( element.tagName() == "title" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setTitle( item );
       }
       if ( element.tagName() == "cachedSize" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setCachedSize( item );
       }
@@ -604,7 +604,7 @@ void Serializer::demarshal( const QDomElement &parent, ResultElement* value )
         value->setRelatedInformationPresent( item );
       }
       if ( element.tagName() == "hostName" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setHostName( item );
       }
@@ -614,7 +614,7 @@ void Serializer::demarshal( const QDomElement &parent, ResultElement* value )
         value->setDirectoryCategory( item );
       }
       if ( element.tagName() == "directoryTitle" ) {
-        QString* item = new QString;
+        TQString* item = new QString;
         Serializer::demarshal( element, item );
         value->setDirectoryTitle( item );
       }
diff --git a/kode/kwsdl/tests/google/serializer.h b/kode/kwsdl/tests/google/serializer.h
index d2db93d87..eb60d3f26 100644
--- a/kode/kwsdl/tests/google/serializer.h
+++ b/kode/kwsdl/tests/google/serializer.h
@@ -24,11 +24,11 @@
 #ifndef SERIALIZER_H
 #define SERIALIZER_H
 
-#include <qcstring.h>
-#include <qdom.h>
-#include <qdatetime.h>
-#include <qstring.h>
-#include <qptrlist.h>
+#include <tqcstring.h>
+#include <tqdom.h>
+#include <tqdatetime.h>
+#include <tqstring.h>
+#include <tqptrlist.h>
 
 class ResultElementArray;
 class DirectoryCategoryArray;
@@ -39,64 +39,64 @@ class ResultElement;
 class Serializer
 {
   public:
-    static QString marshalValue( const QString* value );
-    static void demarshalValue( const QString &str, QString *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const QString* value );
-    static void demarshal( const QDomElement &element, QString* value );
-    static QString marshalValue( const bool* value );
-    static void demarshalValue( const QString &str, bool *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const bool* value );
-    static void demarshal( const QDomElement &element, bool* value );
-    static QString marshalValue( const float* value );
-    static void demarshalValue( const QString &str, float *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const float* value );
-    static void demarshal( const QDomElement &element, float* value );
-    static QString marshalValue( const int* value );
-    static void demarshalValue( const QString &str, int *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const int* value );
-    static void demarshal( const QDomElement &element, int* value );
-    static QString marshalValue( const unsigned int* value );
-    static void demarshalValue( const QString &str, unsigned int *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const unsigned int* value );
-    static void demarshal( const QDomElement &element, unsigned int* value );
-    static QString marshalValue( const double* value );
-    static void demarshalValue( const QString &str, double *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const double* value );
-    static void demarshal( const QDomElement &element, double* value );
-    static QString marshalValue( const char* value );
-    static void demarshalValue( const QString &str, char *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const char* value );
-    static void demarshal( const QDomElement &element, char* value );
-    static QString marshalValue( const unsigned char* value );
-    static void demarshalValue( const QString &str, unsigned char *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const unsigned char* value );
-    static void demarshal( const QDomElement &element, unsigned char* value );
-    static QString marshalValue( const short* value );
-    static void demarshalValue( const QString &str, short *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const short* value );
-    static void demarshal( const QDomElement &element, short* value );
-    static QString marshalValue( const QByteArray* value );
-    static void demarshalValue( const QString &str, QByteArray *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const QByteArray* value );
-    static void demarshal( const QDomElement &element, QByteArray* value );
-    static QString marshalValue( const QDateTime* value );
-    static void demarshalValue( const QString &str, QDateTime *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const QDateTime* value );
-    static void demarshal( const QDomElement &element, QDateTime* value );
-    static QString marshalValue( const QDate* value );
-    static void demarshalValue( const QString &str, QDate *value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const QDate* value );
-    static void demarshal( const QDomElement &element, QDate* value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const ResultElementArray* value );
-    static void demarshal( const QDomElement &parent, ResultElementArray* value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const DirectoryCategoryArray* value );
-    static void demarshal( const QDomElement &parent, DirectoryCategoryArray* value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const GoogleSearchResult* value );
-    static void demarshal( const QDomElement &parent, GoogleSearchResult* value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const DirectoryCategory* value );
-    static void demarshal( const QDomElement &parent, DirectoryCategory* value );
-    static void marshal( QDomDocument &doc, QDomElement &parent, const QString &name, const ResultElement* value );
-    static void demarshal( const QDomElement &parent, ResultElement* value );
+    static TQString marshalValue( const TQString* value );
+    static void demarshalValue( const TQString &str, TQString *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const TQString* value );
+    static void demarshal( const TQDomElement &element, TQString* value );
+    static TQString marshalValue( const bool* value );
+    static void demarshalValue( const TQString &str, bool *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const bool* value );
+    static void demarshal( const TQDomElement &element, bool* value );
+    static TQString marshalValue( const float* value );
+    static void demarshalValue( const TQString &str, float *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const float* value );
+    static void demarshal( const TQDomElement &element, float* value );
+    static TQString marshalValue( const int* value );
+    static void demarshalValue( const TQString &str, int *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const int* value );
+    static void demarshal( const TQDomElement &element, int* value );
+    static TQString marshalValue( const unsigned int* value );
+    static void demarshalValue( const TQString &str, unsigned int *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const unsigned int* value );
+    static void demarshal( const TQDomElement &element, unsigned int* value );
+    static TQString marshalValue( const double* value );
+    static void demarshalValue( const TQString &str, double *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const double* value );
+    static void demarshal( const TQDomElement &element, double* value );
+    static TQString marshalValue( const char* value );
+    static void demarshalValue( const TQString &str, char *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const char* value );
+    static void demarshal( const TQDomElement &element, char* value );
+    static TQString marshalValue( const unsigned char* value );
+    static void demarshalValue( const TQString &str, unsigned char *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const unsigned char* value );
+    static void demarshal( const TQDomElement &element, unsigned char* value );
+    static TQString marshalValue( const short* value );
+    static void demarshalValue( const TQString &str, short *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const short* value );
+    static void demarshal( const TQDomElement &element, short* value );
+    static TQString marshalValue( const TQByteArray* value );
+    static void demarshalValue( const TQString &str, TQByteArray *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const TQByteArray* value );
+    static void demarshal( const TQDomElement &element, TQByteArray* value );
+    static TQString marshalValue( const TQDateTime* value );
+    static void demarshalValue( const TQString &str, TQDateTime *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const TQDateTime* value );
+    static void demarshal( const TQDomElement &element, TQDateTime* value );
+    static TQString marshalValue( const TQDate* value );
+    static void demarshalValue( const TQString &str, TQDate *value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const TQDate* value );
+    static void demarshal( const TQDomElement &element, TQDate* value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const ResultElementArray* value );
+    static void demarshal( const TQDomElement &parent, ResultElementArray* value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const DirectoryCategoryArray* value );
+    static void demarshal( const TQDomElement &parent, DirectoryCategoryArray* value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const GoogleSearchResult* value );
+    static void demarshal( const TQDomElement &parent, GoogleSearchResult* value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const DirectoryCategory* value );
+    static void demarshal( const TQDomElement &parent, DirectoryCategory* value );
+    static void marshal( TQDomDocument &doc, TQDomElement &parent, const TQString &name, const ResultElement* value );
+    static void demarshal( const TQDomElement &parent, ResultElement* value );
   
 };
 
diff --git a/kode/kwsdl/tests/google/transport.cpp b/kode/kwsdl/tests/google/transport.cpp
index 4f4583ba2..5d7d92f2b 100644
--- a/kode/kwsdl/tests/google/transport.cpp
+++ b/kode/kwsdl/tests/google/transport.cpp
@@ -26,17 +26,17 @@
 
 #include <kdebug.h>
 
-Transport::Transport( const QString &url )
+Transport::Transport( const TQString &url )
 {
   mUrl = url;
 }
 
-void Transport::query( const QString &xml )
+void Transport::query( const TQString &xml )
 {
   mData.truncate( 0 );
   
-  QByteArray postData;
-  QDataStream stream( postData, IO_WriteOnly );
+  TQByteArray postData;
+  TQDataStream stream( postData, IO_WriteOnly );
   stream.writeRawBytes( xml.utf8(), xml.utf8().length() );
   
   KIO::TransferJob* job = KIO::http_post( KURL( mUrl ), postData, false );
@@ -48,11 +48,11 @@ void Transport::query( const QString &xml )
   job->addMetaData( "UserAgent", "KWSDL" );
   job->addMetaData( "content-type", "Content-Type: text/xml; charset=utf-8" );
   
-  connect( job, SIGNAL( data( KIO::Job*, const QByteArray& ) ), this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );
-  connect( job, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotResult( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( data( KIO::Job*, const TQByteArray& ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray& ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( slotResult( KIO::Job* ) ) );
 }
 
-void Transport::slotData( KIO::Job*, const QByteArray &data )
+void Transport::slotData( KIO::Job*, const TQByteArray &data )
 {
   unsigned int oldSize = mData.size();
   mData.resize( oldSize + data.size() );
@@ -67,7 +67,7 @@ void Transport::slotResult( KIO::Job* job )
     return;
   }
   
-  emit result( QString::fromUtf8( mData.data(), mData.size() ) );
+  emit result( TQString::fromUtf8( mData.data(), mData.size() ) );
 }
 
 
diff --git a/kode/kwsdl/tests/google/transport.h b/kode/kwsdl/tests/google/transport.h
index b39d6e82c..f2386832f 100644
--- a/kode/kwsdl/tests/google/transport.h
+++ b/kode/kwsdl/tests/google/transport.h
@@ -24,7 +24,7 @@
 #ifndef TRANSPORT_H
 #define TRANSPORT_H
 
-#include <qobject.h>
+#include <tqobject.h>
 #include <kio/job.h>
 
 class Transport : public QObject
@@ -32,19 +32,19 @@ class Transport : public QObject
   Q_OBJECT
 
   public:
-    Transport( const QString &url );
-    void query( const QString &xml );
+    Transport( const TQString &url );
+    void query( const TQString &xml );
   
   signals:
-    void result( const QString &xml );
+    void result( const TQString &xml );
   
   private slots:
-    void slotData( KIO::Job*, const QByteArray &data );
+    void slotData( KIO::Job*, const TQByteArray &data );
     void slotResult( KIO::Job* job );
   
   private:
-    QString mUrl;
-    QByteArray mData;
+    TQString mUrl;
+    TQByteArray mData;
 };
 
 #endif
diff --git a/kode/kwsdl/typemapper.cpp b/kode/kwsdl/typemapper.cpp
index b8d1a80ba..88842ecea 100644
--- a/kode/kwsdl/typemapper.cpp
+++ b/kode/kwsdl/typemapper.cpp
@@ -19,7 +19,7 @@
     Boston, MA 02110-1301, USA.
 */
 
-#include <qmap.h>
+#include <tqmap.h>
 
 #include <schema/attribute.h>
 #include <schema/complextype.h>
@@ -33,21 +33,21 @@ using namespace KWSDL;
 
 TypeMapper::TypeMapper()
 {
-  mMap.insert( "any", TypeInfo( "any", "QString", "qstring.h" ) );
-  mMap.insert( "anyURI", TypeInfo( "anyUri", "QString", "qstring.h" ) );
-  mMap.insert( "base64Binary", TypeInfo( "base64Binary", "QByteArray", "qcstring.h" ) );
-  mMap.insert( "binary", TypeInfo( "binary", "QByteArray", "qcstring.h" ) );
+  mMap.insert( "any", TypeInfo( "any", "TQString", "tqstring.h" ) );
+  mMap.insert( "anyURI", TypeInfo( "anyUri", "TQString", "tqstring.h" ) );
+  mMap.insert( "base64Binary", TypeInfo( "base64Binary", "TQByteArray", "tqcstring.h" ) );
+  mMap.insert( "binary", TypeInfo( "binary", "TQByteArray", "tqcstring.h" ) );
   mMap.insert( "boolean", TypeInfo( "boolean", "bool", "" ) );
   mMap.insert( "byte", TypeInfo( "byte", "char", "" ) );
-  mMap.insert( "date", TypeInfo( "date", "QDate", "qdatetime.h" ) );
-  mMap.insert( "dateTime", TypeInfo( "dateTime", "QDateTime", "qdatetime.h" ) );
+  mMap.insert( "date", TypeInfo( "date", "TQDate", "tqdatetime.h" ) );
+  mMap.insert( "dateTime", TypeInfo( "dateTime", "TQDateTime", "tqdatetime.h" ) );
   mMap.insert( "decimal", TypeInfo( "decimal", "float", "" ) );
   mMap.insert( "double", TypeInfo( "double", "double", "" ) );
-  mMap.insert( "duration", TypeInfo( "duration", "QString", "qstring.h" ) ); // TODO: add duration class
+  mMap.insert( "duration", TypeInfo( "duration", "TQString", "tqstring.h" ) ); // TODO: add duration class
   mMap.insert( "int", TypeInfo( "int", "int", "" ) );
-  mMap.insert( "language", TypeInfo( "language", "QString", "qstring.h" ) );
+  mMap.insert( "language", TypeInfo( "language", "TQString", "tqstring.h" ) );
   mMap.insert( "short", TypeInfo( "short", "short", "" ) );
-  mMap.insert( "string", TypeInfo( "string", "QString", "qstring.h" ) );
+  mMap.insert( "string", TypeInfo( "string", "TQString", "tqstring.h" ) );
   mMap.insert( "unsignedByte", TypeInfo( "unsignedByte", "unsigned char", "" ) );
   mMap.insert( "unsignedInt", TypeInfo( "unsignedInt", "unsigned int", "" ) );
 }
@@ -57,21 +57,21 @@ void TypeMapper::setTypes( const Schema::Types &types )
   mTypes = types;
 }
 
-QString TypeMapper::type( const Schema::XSDType *type ) const
+TQString TypeMapper::type( const Schema::XSDType *type ) const
 {
-  QString typeName = type->name();
+  TQString typeName = type->name();
   typeName[ 0 ] = typeName[ 0 ].upper();
 
   return typeName;
 }
 
-QString TypeMapper::type( const Schema::Element *element ) const
+TQString TypeMapper::type( const Schema::Element *element ) const
 {
-  QString typeName = element->typeName();
+  TQString typeName = element->typeName();
 
-  QString type;
+  TQString type;
   // check basic types
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() )
     type = it.data().type;
 
@@ -83,13 +83,13 @@ QString TypeMapper::type( const Schema::Element *element ) const
   return type;
 }
 
-QString TypeMapper::type( const Schema::Attribute *attribute ) const
+TQString TypeMapper::type( const Schema::Attribute *attribute ) const
 {
-  QString typeName = attribute->typeName();
+  TQString typeName = attribute->typeName();
 
-  QString type;
+  TQString type;
   // check basic types
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() )
     type = it.data().type;
 
@@ -101,10 +101,10 @@ QString TypeMapper::type( const Schema::Attribute *attribute ) const
   return type;
 }
 
-QString TypeMapper::type( const QString &typeName ) const
+TQString TypeMapper::type( const TQString &typeName ) const
 {
   // check basic types
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() )
     return it.data().type;
 
@@ -132,22 +132,22 @@ QString TypeMapper::type( const QString &typeName ) const
     }
   }
 
-  return QString();
+  return TQString();
 }
 
-QStringList TypeMapper::header( const Schema::XSDType *type ) const
+TQStringList TypeMapper::header( const Schema::XSDType *type ) const
 {
   return type->name().lower() + ".h";
 }
 
-QStringList TypeMapper::header( const Schema::Element *element ) const
+TQStringList TypeMapper::header( const Schema::Element *element ) const
 {
-  QString typeName = element->typeName();
+  TQString typeName = element->typeName();
 
-  QStringList headers;
+  TQStringList headers;
 
   // check basic types
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() ) {
     if ( !it.data().header.isEmpty() )
       headers.append( it.data().header );
@@ -155,23 +155,23 @@ QStringList TypeMapper::header( const Schema::Element *element ) const
     headers.append( typeName.lower() + ".h" );
   
   if ( element->maxOccurs() > 1 )
-    headers.append( "qptrlist.h" );
+    headers.append( "tqptrlist.h" );
 
   return headers;
 }
 
-QMap<QString, QString> TypeMapper::headerDec( const Schema::Element *element ) const
+TQMap<TQString, TQString> TypeMapper::headerDec( const Schema::Element *element ) const
 {
-  QString typeName = element->typeName();
+  TQString typeName = element->typeName();
 
-  QMap<QString, QString> headers;
+  TQMap<TQString, TQString> headers;
 
   // check basic types
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() ) {
     if ( !it.data().header.isEmpty() ) {
-      if ( it.data().type == "QByteArray" )
-        headers.insert( it.data().header, QString() );
+      if ( it.data().type == "TQByteArray" )
+        headers.insert( it.data().header, TQString() );
       else
         headers.insert( it.data().header, it.data().type );
     }
@@ -181,19 +181,19 @@ QMap<QString, QString> TypeMapper::headerDec( const Schema::Element *element ) c
   }
 
   if ( element->maxOccurs() > 1 )
-    headers.insert( "qptrlist.h", QString() );
+    headers.insert( "tqptrlist.h", TQString() );
 
   return headers;
 }
 
-QStringList TypeMapper::header( const Schema::Attribute *attribute ) const
+TQStringList TypeMapper::header( const Schema::Attribute *attribute ) const
 {
-  QString typeName = attribute->typeName();
+  TQString typeName = attribute->typeName();
 
-  QStringList headers;
+  TQStringList headers;
 
   // check basic types
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() ) {
     if ( !it.data().header.isEmpty() )
       headers.append( it.data().header );
@@ -203,18 +203,18 @@ QStringList TypeMapper::header( const Schema::Attribute *attribute ) const
   return headers;
 }
 
-QMap<QString, QString> TypeMapper::headerDec( const Schema::Attribute *attribute ) const
+TQMap<TQString, TQString> TypeMapper::headerDec( const Schema::Attribute *attribute ) const
 {
-  QString typeName = attribute->typeName();
+  TQString typeName = attribute->typeName();
 
-  QMap<QString, QString> headers;
+  TQMap<TQString, TQString> headers;
 
   // check basic types
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() ) {
     if ( !it.data().header.isEmpty() ) {
-      if ( it.data().type == "QByteArray" )
-        headers.insert( it.data().header, QString() );
+      if ( it.data().type == "TQByteArray" )
+        headers.insert( it.data().header, TQString() );
       else
         headers.insert( it.data().header, it.data().type );
     }
@@ -226,13 +226,13 @@ QMap<QString, QString> TypeMapper::headerDec( const Schema::Attribute *attribute
   return headers;
 }
 
-QStringList TypeMapper::header( const QString &typeName ) const
+TQStringList TypeMapper::header( const TQString &typeName ) const
 {
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() )
     return it.data().header;
 
-  const QString convertedType = type( typeName );
+  const TQString convertedType = type( typeName );
   if ( isBaseType( convertedType ) ) {
     for ( it = mMap.begin(); it != mMap.end(); ++it )
       if ( it.data().type == convertedType )
@@ -240,20 +240,20 @@ QStringList TypeMapper::header( const QString &typeName ) const
   } else
     return typeName.lower() + ".h";
 
-  return QStringList();
+  return TQStringList();
 }
 
-QMap<QString, QString> TypeMapper::headerDec( const QString &typeName ) const
+TQMap<TQString, TQString> TypeMapper::headerDec( const TQString &typeName ) const
 {
-  QString type( typeName );
-  QMap<QString, QString> headers;
+  TQString type( typeName );
+  TQMap<TQString, TQString> headers;
 
   // check basic types
-  QMap<QString, TypeInfo>::ConstIterator it = mMap.find( typeName );
+  TQMap<TQString, TypeInfo>::ConstIterator it = mMap.find( typeName );
   if ( it != mMap.end() ) {
     if ( !it.data().header.isEmpty() ) {
-      if ( it.data().type == "QByteArray" )
-        headers.insert( it.data().header, QString() );
+      if ( it.data().type == "TQByteArray" )
+        headers.insert( it.data().header, TQString() );
       else
         headers.insert( it.data().header, it.data().type );
     }
@@ -265,33 +265,33 @@ QMap<QString, QString> TypeMapper::headerDec( const QString &typeName ) const
   return headers;
 }
 
-QString TypeMapper::argument( const QString &name, const Schema::Element *element ) const
+TQString TypeMapper::argument( const TQString &name, const Schema::Element *element ) const
 {
-  QString typeName = type( element );
+  TQString typeName = type( element );
 
   if ( element->maxOccurs() > 1 )
-    return "QPtrList<" + typeName + ">* " + name;
+    return "TQPtrList<" + typeName + ">* " + name;
   else
     return typeName + "* " + name;
 }
 
-QString TypeMapper::argument( const QString &name, const Schema::Attribute *attribute ) const
+TQString TypeMapper::argument( const TQString &name, const Schema::Attribute *attribute ) const
 {
   return type( attribute ) + "* " + name;
 }
 
-QString TypeMapper::argument( const QString &name, const QString &typeName, bool isList ) const
+TQString TypeMapper::argument( const TQString &name, const TQString &typeName, bool isList ) const
 {
   if ( isList ) {
-    return "QPtrList<" + type( typeName ) + ">* " + name;
+    return "TQPtrList<" + type( typeName ) + ">* " + name;
   } else {
     return type( typeName ) + "* " + name;
   }
 }
 
-bool TypeMapper::isBaseType( const QString &type ) const
+bool TypeMapper::isBaseType( const TQString &type ) const
 {
-  QMap<QString, TypeInfo>::ConstIterator it;
+  TQMap<TQString, TypeInfo>::ConstIterator it;
   for ( it = mMap.begin(); it != mMap.end(); ++it )
     if ( it.data().type == type )
       return true;
diff --git a/kode/kwsdl/typemapper.h b/kode/kwsdl/typemapper.h
index 529b004fe..9a718bb24 100644
--- a/kode/kwsdl/typemapper.h
+++ b/kode/kwsdl/typemapper.h
@@ -22,7 +22,7 @@
 #ifndef KWSDL_TYPEMAPPER_H
 #define KWSDL_TYPEMAPPER_H
 
-#include <qstringlist.h>
+#include <tqstringlist.h>
 
 #include <schema/types.h>
 
@@ -40,13 +40,13 @@ class TypeInfo
     TypeInfo()
     {}
 
-    TypeInfo( const QString &_xsdType, const QString &_type, const QString &_header )
+    TypeInfo( const TQString &_xsdType, const TQString &_type, const TQString &_header )
       : xsdType( _xsdType ), type( _type ), header( _header )
     {}
 
-    QString xsdType;
-    QString type;
-    QString header;
+    TQString xsdType;
+    TQString type;
+    TQString header;
 };
 
 class TypeMapper
@@ -56,27 +56,27 @@ class TypeMapper
 
     void setTypes( const Schema::Types &types );
 
-    QString type( const Schema::XSDType *type ) const;
-    QString type( const Schema::Element *element ) const;
-    QString type( const Schema::Attribute *attribute ) const;
-    QString type( const QString &typeName ) const;
+    TQString type( const Schema::XSDType *type ) const;
+    TQString type( const Schema::Element *element ) const;
+    TQString type( const Schema::Attribute *attribute ) const;
+    TQString type( const TQString &typeName ) const;
 
-    QStringList header( const Schema::XSDType *type ) const;
-    QStringList header( const Schema::Element *element ) const;
-    QMap<QString,QString> headerDec( const Schema::Element *element ) const;
-    QStringList header( const Schema::Attribute *attribute ) const;
-    QMap<QString,QString> headerDec( const Schema::Attribute *attribute ) const;
-    QStringList header( const QString &typeName ) const;
-    QMap<QString,QString> headerDec( const QString &typeName ) const;
+    TQStringList header( const Schema::XSDType *type ) const;
+    TQStringList header( const Schema::Element *element ) const;
+    TQMap<TQString,TQString> headerDec( const Schema::Element *element ) const;
+    TQStringList header( const Schema::Attribute *attribute ) const;
+    TQMap<TQString,TQString> headerDec( const Schema::Attribute *attribute ) const;
+    TQStringList header( const TQString &typeName ) const;
+    TQMap<TQString,TQString> headerDec( const TQString &typeName ) const;
 
-    QString argument( const QString &name, const Schema::Element *element ) const;
-    QString argument( const QString &name, const Schema::Attribute *attribute ) const;
-    QString argument( const QString &name, const QString &typeName, bool isList = false ) const;
+    TQString argument( const TQString &name, const Schema::Element *element ) const;
+    TQString argument( const TQString &name, const Schema::Attribute *attribute ) const;
+    TQString argument( const TQString &name, const TQString &typeName, bool isList = false ) const;
 
   private:
-    bool isBaseType( const QString& ) const;
+    bool isBaseType( const TQString& ) const;
 
-    QMap<QString, TypeInfo> mMap;
+    TQMap<TQString, TypeInfo> mMap;
     Schema::Types mTypes;
 };
 
diff --git a/kode/kwsdl/wscl/conversation.cpp b/kode/kwsdl/wscl/conversation.cpp
index 692f566fb..97de47d47 100644
--- a/kode/kwsdl/wscl/conversation.cpp
+++ b/kode/kwsdl/wscl/conversation.cpp
@@ -31,72 +31,72 @@ Conversation::~Conversation()
 {
 }
 
-void Conversation::setName( const QString &name )
+void Conversation::setName( const TQString &name )
 {
   mName = name;
 }
 
-QString Conversation::name() const
+TQString Conversation::name() const
 {
   return mName;
 }
 
-void Conversation::setVersion( const QString &version )
+void Conversation::setVersion( const TQString &version )
 {
   mVersion = version;
 }
 
-QString Conversation::version() const
+TQString Conversation::version() const
 {
   return mVersion;
 }
 
-void Conversation::setDescription( const QString &description )
+void Conversation::setDescription( const TQString &description )
 {
   mDescription = description;
 }
 
-QString Conversation::description() const
+TQString Conversation::description() const
 {
   return mDescription;
 }
 
-void Conversation::setNameSpace( const QString &nameSpace )
+void Conversation::setNameSpace( const TQString &nameSpace )
 {
   mNameSpace = nameSpace;
 }
 
-QString Conversation::nameSpace() const
+TQString Conversation::nameSpace() const
 {
   return mNameSpace;
 }
 
-void Conversation::setSchema( const QString &schema )
+void Conversation::setSchema( const TQString &schema )
 {
   mSchema = schema;
 }
 
-QString Conversation::schema() const
+TQString Conversation::schema() const
 {
   return mSchema;
 }
 
-void Conversation::setInitialInteraction( const QString &initialInteraction )
+void Conversation::setInitialInteraction( const TQString &initialInteraction )
 {
   mInitialInteraction = initialInteraction;
 }
 
-QString Conversation::initialInteraction() const
+TQString Conversation::initialInteraction() const
 {
   return mInitialInteraction;
 }
 
-void Conversation::setFinalInteraction( const QString &finalInteraction )
+void Conversation::setFinalInteraction( const TQString &finalInteraction )
 {
   mFinalInteraction = finalInteraction;
 }
 
-QString Conversation::finalInteraction() const
+TQString Conversation::finalInteraction() const
 {
   return mFinalInteraction;
 }
diff --git a/kode/kwsdl/wscl/conversation.h b/kode/kwsdl/wscl/conversation.h
index 757edfab9..448bd3e09 100644
--- a/kode/kwsdl/wscl/conversation.h
+++ b/kode/kwsdl/wscl/conversation.h
@@ -33,26 +33,26 @@ class Conversation
     Conversation();
     ~Conversation();
 
-    void setName( const QString &name );
-    QString name() const;
+    void setName( const TQString &name );
+    TQString name() const;
 
-    void setVersion( const QString &version );
-    QString version() const;
+    void setVersion( const TQString &version );
+    TQString version() const;
 
-    void setDescription( const QString &description );
-    QString description() const;
+    void setDescription( const TQString &description );
+    TQString description() const;
 
-    void setNameSpace( const QString &nameSpace );
-    QString nameSpace() const;
+    void setNameSpace( const TQString &nameSpace );
+    TQString nameSpace() const;
 
-    void setSchema( const QString &schema );
-    QString schema() const;
+    void setSchema( const TQString &schema );
+    TQString schema() const;
 
-    void setInitialInteraction( const QString &initialInteraction );
-    QString initialInteraction() const;
+    void setInitialInteraction( const TQString &initialInteraction );
+    TQString initialInteraction() const;
 
-    void setFinalInteraction( const QString &finalInteraction );
-    QString finalInteraction() const;
+    void setFinalInteraction( const TQString &finalInteraction );
+    TQString finalInteraction() const;
 
     void setInteractions( const Interaction::List &interactions );
     Interaction::List interactions() const;
@@ -61,13 +61,13 @@ class Conversation
     Transition::List transitions() const;
 
   private:
-    QString mName;
-    QString mVersion;
-    QString mDescription;
-    QString mNameSpace;
-    QString mSchema;
-    QString mInitialInteraction;
-    QString mFinalInteraction;
+    TQString mName;
+    TQString mVersion;
+    TQString mDescription;
+    TQString mNameSpace;
+    TQString mSchema;
+    TQString mInitialInteraction;
+    TQString mFinalInteraction;
 
     Interaction::List mInteractions;
     Transition::List mTransitions;
diff --git a/kode/kwsdl/wscl/documents.cpp b/kode/kwsdl/wscl/documents.cpp
index 92b7928e4..d020e63be 100644
--- a/kode/kwsdl/wscl/documents.cpp
+++ b/kode/kwsdl/wscl/documents.cpp
@@ -23,22 +23,22 @@
 
 using namespace WSCL;
 
-void XMLDocument::setId( const QString &id )
+void XMLDocument::setId( const TQString &id )
 {
   mId = id;
 }
 
-QString XMLDocument::id() const
+TQString XMLDocument::id() const
 {
   return mId;
 }
 
-void XMLDocument::setSchema( const QString &schema )
+void XMLDocument::setSchema( const TQString &schema )
 {
   mSchema = schema;
 }
 
-QString XMLDocument::schema() const
+TQString XMLDocument::schema() const
 {
   return mSchema;
 }
diff --git a/kode/kwsdl/wscl/documents.h b/kode/kwsdl/wscl/documents.h
index 2bba60ad1..638aaa2d7 100644
--- a/kode/kwsdl/wscl/documents.h
+++ b/kode/kwsdl/wscl/documents.h
@@ -22,25 +22,25 @@
 #ifndef WSCL_DOCUMENTS_H
 #define WSCL_DOCUMENTS_H
 
-#include <qstring.h>
-#include <qvaluelist.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
 
 namespace WSCL {
 
 class XMLDocument
 {
   public:
-    typedef QValueList<XMLDocument> List;
+    typedef TQValueList<XMLDocument> List;
 
-    void setId( const QString &id );
-    QString id() const;
+    void setId( const TQString &id );
+    TQString id() const;
 
-    void setSchema( const QString &schema );
-    QString schema() const;
+    void setSchema( const TQString &schema );
+    TQString schema() const;
 
   private:
-    QString mId;
-    QString mSchema;
+    TQString mId;
+    TQString mSchema;
 };
 
 class ReceiveSendDocument
diff --git a/kode/kwsdl/wscl/interaction.cpp b/kode/kwsdl/wscl/interaction.cpp
index ff88408a9..78db369c6 100644
--- a/kode/kwsdl/wscl/interaction.cpp
+++ b/kode/kwsdl/wscl/interaction.cpp
@@ -32,12 +32,12 @@ Interaction::~Interaction()
 {
 }
 
-void Interaction::setId( const QString &id )
+void Interaction::setId( const TQString &id )
 {
   mId = id;
 }
 
-QString Interaction::id() const
+TQString Interaction::id() const
 {
   return mId;
 }
diff --git a/kode/kwsdl/wscl/interaction.h b/kode/kwsdl/wscl/interaction.h
index 2700d7c00..50ececb8c 100644
--- a/kode/kwsdl/wscl/interaction.h
+++ b/kode/kwsdl/wscl/interaction.h
@@ -22,7 +22,7 @@
 #ifndef WSCL_INTERACTION_H
 #define WSCL_INTERACTION_H
 
-#include <qvaluelist.h>
+#include <tqvaluelist.h>
 
 #include "documents.h"
 
@@ -31,7 +31,7 @@ namespace WSCL {
 class Interaction
 {
   public:
-    typedef QValueList<Interaction> List;
+    typedef TQValueList<Interaction> List;
 
     enum Type
     {
@@ -45,8 +45,8 @@ class Interaction
     Interaction();
     ~Interaction();
 
-    void setId( const QString &id );
-    QString id() const;
+    void setId( const TQString &id );
+    TQString id() const;
 
     void setType( Type type );
     Type type() const;
@@ -64,7 +64,7 @@ class Interaction
     SendDocument sendDocument() const;
 
   private:
-    QString mId;
+    TQString mId;
     Type mType;
 
     SendReceiveDocument mSendReceiveDocument;
diff --git a/kode/kwsdl/wscl/parser.cpp b/kode/kwsdl/wscl/parser.cpp
index 129c3c3dc..a21d05fe8 100644
--- a/kode/kwsdl/wscl/parser.cpp
+++ b/kode/kwsdl/wscl/parser.cpp
@@ -19,7 +19,7 @@
     Boston, MA 02110-1301, USA.
  */
 
-#include <qdom.h>
+#include <tqdom.h>
 
 #include "parser.h"
 
@@ -33,10 +33,10 @@ Parser::~Parser()
 {
 }
 
-void Parser::parse( const QString &xml )
+void Parser::parse( const TQString &xml )
 {
-  QDomDocument doc( "kwscl" );
-  QString errorMsg;
+  TQDomDocument doc( "kwscl" );
+  TQString errorMsg;
   int errorLine, errorColumn;
   bool ok = doc.setContent( xml, true, &errorMsg, &errorLine, &errorColumn );
   if ( !ok ) {
@@ -44,13 +44,13 @@ void Parser::parse( const QString &xml )
     return;
   }
 
-  QDomNodeList nodes = doc.elementsByTagName( "Conversation" );
+  TQDomNodeList nodes = doc.elementsByTagName( "Conversation" );
   if ( nodes.count() <= 0 ) {
     qDebug( "No conversation tag found in wscl data" );
     return;
   }
 
-  QDomElement conversationElement = nodes.item( 0 ).toElement();
+  TQDomElement conversationElement = nodes.item( 0 ).toElement();
 
   mConversation.setName( conversationElement.attribute( "name" ) );
   mConversation.setVersion( conversationElement.attribute( "version" ) );
@@ -60,16 +60,16 @@ void Parser::parse( const QString &xml )
   mConversation.setInitialInteraction( conversationElement.attribute( "initialInteraction" ) );
   mConversation.setFinalInteraction( conversationElement.attribute( "finalInteraction" ) );
 
-  QDomNode node = conversationElement.firstChild();
+  TQDomNode node = conversationElement.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "ConversationInteractions" ) {
         Interaction::List interactions;
 
-        QDomNode interactionNode = element.firstChild();
+        TQDomNode interactionNode = element.firstChild();
         while ( !interactionNode.isNull() ) {
-          QDomElement interactionElement = interactionNode.toElement();
+          TQDomElement interactionElement = interactionNode.toElement();
           if ( !interactionElement.isNull() ) {
             if ( interactionElement.tagName() != "Interaction" ) {
               qDebug( "Expected tag name 'Interaction', got '%s'", interactionElement.tagName().latin1() );
@@ -78,7 +78,7 @@ void Parser::parse( const QString &xml )
 
             Interaction interaction;
             interaction.setId( interactionElement.attribute( "id" ) );
-            const QString type = interactionElement.attribute( "interactionType" );
+            const TQString type = interactionElement.attribute( "interactionType" );
             if ( type == "ReceiveSend" )
               interaction.setType( Interaction::ReceiveSend );
             else if ( type == "SendReceive" )
@@ -97,11 +97,11 @@ void Parser::parse( const QString &xml )
             XMLDocument inputDocument;
             XMLDocument outputDocument;
 
-            QDomNode contentNode = interactionElement.firstChild();
+            TQDomNode contentNode = interactionElement.firstChild();
             while ( !contentNode.isNull() ) {
-              QDomElement contentElement = contentNode.toElement();
+              TQDomElement contentElement = contentNode.toElement();
               if ( !contentElement.isNull() ) {
-                const QString tagName = contentElement.tagName();
+                const TQString tagName = contentElement.tagName();
                 if ( tagName == "InboundXMLDocument" ) {
                   XMLDocument document;
                   document.setId( contentElement.attribute( "id" ) );
@@ -170,9 +170,9 @@ void Parser::parse( const QString &xml )
       } else if ( element.tagName() == "ConversationTransitions" ) {
         Transition::List transitions;
 
-        QDomNode transitionNode = element.firstChild();
+        TQDomNode transitionNode = element.firstChild();
         while ( !transitionNode.isNull() ) {
-          QDomElement transitionElement = transitionNode.toElement();
+          TQDomElement transitionElement = transitionNode.toElement();
           if ( !transitionElement.isNull() ) {
             if ( transitionElement.tagName() != "Transition" ) {
               qDebug( "Expected tag name 'Transition', got '%s'", transitionElement.tagName().latin1() );
@@ -181,11 +181,11 @@ void Parser::parse( const QString &xml )
 
             Transition transition;
 
-            QDomNode contentNode = transitionElement.firstChild();
+            TQDomNode contentNode = transitionElement.firstChild();
             while ( !contentNode.isNull() ) {
-              QDomElement contentElement = contentNode.toElement();
+              TQDomElement contentElement = contentNode.toElement();
               if ( !contentElement.isNull() ) {
-                const QString tagName = contentElement.tagName();
+                const TQString tagName = contentElement.tagName();
                 if ( tagName == "SourceInteraction" )
                   transition.setSourceInteraction( contentElement.attribute( "href" ) );
                 else if ( tagName == "DestinationInteraction" )
diff --git a/kode/kwsdl/wscl/parser.h b/kode/kwsdl/wscl/parser.h
index 8f8824747..49b5a2184 100644
--- a/kode/kwsdl/wscl/parser.h
+++ b/kode/kwsdl/wscl/parser.h
@@ -32,7 +32,7 @@ class Parser
     Parser();
     ~Parser();
 
-    void parse( const QString &xml );
+    void parse( const TQString &xml );
     void reset();
 
     Conversation conversation() const;
diff --git a/kode/kwsdl/wscl/transition.cpp b/kode/kwsdl/wscl/transition.cpp
index c3a088a04..9e4ae491d 100644
--- a/kode/kwsdl/wscl/transition.cpp
+++ b/kode/kwsdl/wscl/transition.cpp
@@ -31,32 +31,32 @@ Transition::~Transition()
 {
 }
 
-void Transition::setSourceInteraction( const QString &sourceInteraction )
+void Transition::setSourceInteraction( const TQString &sourceInteraction )
 {
   mSourceInteraction = sourceInteraction;
 }
 
-QString Transition::sourceInteraction() const
+TQString Transition::sourceInteraction() const
 {
   return mSourceInteraction;
 }
 
-void Transition::setDestinationInteraction( const QString &destinationInteraction )
+void Transition::setDestinationInteraction( const TQString &destinationInteraction )
 {
   mDestinationInteraction = destinationInteraction;
 }
 
-QString Transition::destinationInteraction() const
+TQString Transition::destinationInteraction() const
 {
   return mDestinationInteraction;
 }
 
-void Transition::setSourceInteractionCondition( const QString &sourceInteractionCondition )
+void Transition::setSourceInteractionCondition( const TQString &sourceInteractionCondition )
 {
   mSourceInteractionCondition = sourceInteractionCondition;
 }
 
-QString Transition::sourceInteractionCondition() const
+TQString Transition::sourceInteractionCondition() const
 {
   return mSourceInteractionCondition;
 }
diff --git a/kode/kwsdl/wscl/transition.h b/kode/kwsdl/wscl/transition.h
index cb6d0a563..1a64691fb 100644
--- a/kode/kwsdl/wscl/transition.h
+++ b/kode/kwsdl/wscl/transition.h
@@ -22,32 +22,32 @@
 #ifndef WSCL_TRANSITION_H
 #define WSCL_TRANSITION_H
 
-#include <qstring.h>
-#include <qvaluelist.h>
+#include <tqstring.h>
+#include <tqvaluelist.h>
 
 namespace WSCL {
 
 class Transition
 {
   public:
-    typedef QValueList<Transition> List;
+    typedef TQValueList<Transition> List;
 
     Transition();
     ~Transition();
 
-    void setSourceInteraction( const QString &sourceInteraction );
-    QString sourceInteraction() const;
+    void setSourceInteraction( const TQString &sourceInteraction );
+    TQString sourceInteraction() const;
 
-    void setDestinationInteraction( const QString &destinationInteraction );
-    QString destinationInteraction() const;
+    void setDestinationInteraction( const TQString &destinationInteraction );
+    TQString destinationInteraction() const;
 
-    void setSourceInteractionCondition( const QString &sourceInteractionCondition );
-    QString sourceInteractionCondition() const;
+    void setSourceInteractionCondition( const TQString &sourceInteractionCondition );
+    TQString sourceInteractionCondition() const;
 
   private:
-    QString mSourceInteraction;
-    QString mDestinationInteraction;
-    QString mSourceInteractionCondition;
+    TQString mSourceInteraction;
+    TQString mDestinationInteraction;
+    TQString mSourceInteractionCondition;
 };
 
 }
diff --git a/kode/kwsdl/wsdl.cpp b/kode/kwsdl/wsdl.cpp
index c03692417..b74ade93e 100644
--- a/kode/kwsdl/wsdl.cpp
+++ b/kode/kwsdl/wsdl.cpp
@@ -73,7 +73,7 @@ Schema::Types WSDL::types() const
   return mTypes;
 }
 
-Message WSDL::findMessage( const QString &name ) const
+Message WSDL::findMessage( const TQString &name ) const
 {
   Message::List::ConstIterator it;
   for ( it = mMessages.begin(); it != mMessages.end(); ++it ) {
@@ -85,7 +85,7 @@ Message WSDL::findMessage( const QString &name ) const
   return Message();
 }
 
-Message WSDL::findOutputMessage( const QString &name ) const
+Message WSDL::findOutputMessage( const TQString &name ) const
 {
   Port::List::ConstIterator it;
   for ( it = mPorts.begin(); it != mPorts.end(); ++it ) {
@@ -100,7 +100,7 @@ Message WSDL::findOutputMessage( const QString &name ) const
   return Message();
 }
 
-Port WSDL::findPort( const QString &name ) const
+Port WSDL::findPort( const TQString &name ) const
 {
   Port::List::ConstIterator it;
   for ( it = mPorts.begin(); it != mPorts.end(); ++it ) {
@@ -111,7 +111,7 @@ Port WSDL::findPort( const QString &name ) const
   return Port();
 }
 
-Binding WSDL::findBinding( const QString &name ) const
+Binding WSDL::findBinding( const TQString &name ) const
 {
   Binding::List::ConstIterator it;
   for ( it = mBindings.begin(); it != mBindings.end(); ++it ) {
@@ -122,7 +122,7 @@ Binding WSDL::findBinding( const QString &name ) const
   return Binding();
 }
 
-Binding::Operation WSDL::findBindingOperation( const QString &portName, const QString &operationName ) const
+Binding::Operation WSDL::findBindingOperation( const TQString &portName, const TQString &operationName ) const
 {
   Binding::List::ConstIterator it;
   for ( it = mBindings.begin(); it != mBindings.end(); ++it ) {
diff --git a/kode/kwsdl/wsdl.h b/kode/kwsdl/wsdl.h
index e057ff101..8a35ba3ba 100644
--- a/kode/kwsdl/wsdl.h
+++ b/kode/kwsdl/wsdl.h
@@ -49,11 +49,11 @@ class WSDL
     void setTypes( const Schema::Types &types );
     Schema::Types types() const;
 
-    Message findMessage( const QString& ) const;
-    Message findOutputMessage( const QString& ) const;
-    Port findPort( const QString& ) const;
-    Binding findBinding( const QString& ) const;
-    Binding::Operation findBindingOperation( const QString&, const QString& ) const;
+    Message findMessage( const TQString& ) const;
+    Message findOutputMessage( const TQString& ) const;
+    Port findPort( const TQString& ) const;
+    Binding findBinding( const TQString& ) const;
+    Binding::Operation findBindingOperation( const TQString&, const TQString& ) const;
 
   private:
     Binding::List mBindings;
diff --git a/kode/kxml_compiler/creator.cpp b/kode/kxml_compiler/creator.cpp
index 1277d8d71..591265887 100644
--- a/kode/kxml_compiler/creator.cpp
+++ b/kode/kxml_compiler/creator.cpp
@@ -36,11 +36,11 @@
 #include <ksimpleconfig.h>
 #include <kstandarddirs.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
-#include <qdom.h>
-#include <qregexp.h>
-#include <qmap.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+#include <tqdom.h>
+#include <tqregexp.h>
+#include <tqmap.h>
 
 #include <iostream>
 
@@ -50,7 +50,7 @@ Creator::Creator( XmlParserType p, XmlWriterType w )
   setExternalClassNames();
 }
 
-void Creator::setExternalClassPrefix( const QString &prefix )
+void Creator::setExternalClassPrefix( const TQString &prefix )
 {
   mExternalClassPrefix = prefix;
 
@@ -65,18 +65,18 @@ void Creator::setExternalClassNames()
 
 KODE::File &Creator::file() { return mFile; }
 
-QString Creator::upperFirst( const QString &str )
+TQString Creator::upperFirst( const TQString &str )
 {
   return KODE::Style::upperFirst( str );
 }
 
-QString Creator::lowerFirst( const QString &str )
+TQString Creator::lowerFirst( const TQString &str )
 {
   return KODE::Style::lowerFirst( str );
 }
 
-void Creator::createProperty( KODE::Class &c, const QString &type,
-                     const QString &name )
+void Creator::createProperty( KODE::Class &c, const TQString &type,
+                     const TQString &name )
 {
   KODE::MemberVariable v( name, type );
   c.addMemberVariable( v );
@@ -95,28 +95,28 @@ void Creator::createProperty( KODE::Class &c, const QString &type,
 void Creator::createElementFunctions( KODE::Class &c, Element *e )
 {
   if ( e->hasText ) {
-    createProperty( c, "QString", e->name );
+    createProperty( c, "TQString", e->name );
     if ( mXmlParserType == XmlParserCustomExternal ) {
       createTextElementParserCustom( c, e );
     }
     return;
   }
 
-  QString type = upperFirst( e->name );
+  TQString type = upperFirst( e->name );
 
   if ( !mFile.hasClass( type ) ) {
     createClass( e );
   }
 
-  QString name = lowerFirst( e->name );
+  TQString name = lowerFirst( e->name );
 
   if ( e->pattern.oneOrMore || e->pattern.zeroOrMore ||
        e->pattern.choice || e->pattern.optional ) {
     registerListTypedef( type );
 
-    c.addHeaderInclude( "qvaluelist.h" );
+    c.addHeaderInclude( "tqvaluelist.h" );
     type = type + "::List";
-    QString className = upperFirst( name );
+    TQString className = upperFirst( name );
     name = name + "List";
 
     KODE::Function adder( "add" + className, "void" );
@@ -135,7 +135,7 @@ void Creator::createElementFunctions( KODE::Class &c, Element *e )
 
 void Creator::createClass( Element *element )
 {
-  QString className = upperFirst( element->name );
+  TQString className = upperFirst( element->name );
 
   if ( mProcessedClasses.find( className ) != mProcessedClasses.end() ) {
     return;
@@ -145,21 +145,21 @@ void Creator::createClass( Element *element )
 
   mProcessedClasses.append( className );
 
-  QValueList<Attribute *>::ConstIterator itA;
+  TQValueList<Attribute *>::ConstIterator itA;
   for( itA = element->attributes.begin();
        itA != element->attributes.end(); ++itA ) {
     Attribute *a = *itA;
 
-    createProperty( c, "QString", a->name );
+    createProperty( c, "TQString", a->name );
   }
 
-  QValueList<Element *>::ConstIterator itE;
+  TQValueList<Element *>::ConstIterator itE;
   for( itE = element->elements.begin(); itE != element->elements.end();
        ++itE ) {
     createElementFunctions( c, *itE );
   }
 
-  QValueList<Reference *>::ConstIterator itR;
+  TQValueList<Reference *>::ConstIterator itR;
   for( itR = element->references.begin(); itR != element->references.end();
        ++itR ) {
     Element e;
@@ -176,15 +176,15 @@ void Creator::createClass( Element *element )
 
 void Creator::createElementWriter( KODE::Class &c, Element *element )
 {
-  KODE::Function writer( "writeElement", "QString" );
+  KODE::Function writer( "writeElement", "TQString" );
   
   KODE::Code code;
   
-  code += "QString xml;";
+  code += "TQString xml;";
   
-  QString tag = "<" + element->name;
+  TQString tag = "<" + element->name;
 
-  QValueList<Attribute *>::ConstIterator it3;
+  TQValueList<Attribute *>::ConstIterator it3;
   for( it3 = element->attributes.begin(); it3 != element->attributes.end();
         ++it3 ) {
     tag += " " + (*it3)->name + "=\\\"\" + " + (*it3)->name + "() + \"\\\"";
@@ -201,10 +201,10 @@ void Creator::createElementWriter( KODE::Class &c, Element *element )
   if ( !element->isEmpty ) {
     code += "indent( 2 );";
 
-    QValueList<Element *>::ConstIterator it;
+    TQValueList<Element *>::ConstIterator it;
     for( it = element->elements.begin(); it != element->elements.end(); ++it ) {
       Element *e = *it;
-      QString type = upperFirst( e->name );
+      TQString type = upperFirst( e->name );
       if ( e->pattern.oneOrMore || e->pattern.zeroOrMore ) {
         code += type + "::List list = " + e->name + "List();";
         code += type + "::List::ConstIterator it;";
@@ -223,11 +223,11 @@ void Creator::createElementWriter( KODE::Class &c, Element *element )
       }
     }
 
-    QValueList<Reference *>::ConstIterator it2;
+    TQValueList<Reference *>::ConstIterator it2;
     for( it2 = element->references.begin(); it2 != element->references.end();
          ++it2 ) {
       Reference *r = *it2;
-      QString type = upperFirst( r->name );
+      TQString type = upperFirst( r->name );
       if ( r->pattern.oneOrMore || r->pattern.zeroOrMore ) {
         code += type + "::List list2 = " + r->name + "List();";
         code += type + "::List::ConstIterator it2;";
@@ -268,11 +268,11 @@ void Creator::createElementParser( KODE::Class &c, Element *e )
 
 void Creator::createTextElementParserCustom( KODE::Class &, Element *e )
 {
-  KODE::Function parser( "parseElement" + upperFirst( e->name ), "QString" );
+  KODE::Function parser( "parseElement" + upperFirst( e->name ), "TQString" );
 
   KODE::Code code;
   
-  code += "QString result;";
+  code += "TQString result;";
   code.newLine();
 
   KODE::StateMachine sm;
@@ -285,7 +285,7 @@ void Creator::createTextElementParserCustom( KODE::Class &, Element *e )
   stateCode += "} else if ( c == '&' ) {";
   stateCode += "  entityStart = mRunning + 1;";
   stateCode += "} else if ( entityStart >= 0 && c == ';' ) {";
-  stateCode += "  QString entity = mBuffer.mid( entityStart, mRunning - entityStart );";
+  stateCode += "  TQString entity = mBuffer.mid( entityStart, mRunning - entityStart );";
   stateCode += "  if ( entity == \"quot\" ) result += '\"';";
   stateCode += "  entityStart = -1;";
   stateCode += "} else if ( entityStart < 0 ) {";
@@ -330,7 +330,7 @@ void Creator::createTextElementParserCustom( KODE::Class &, Element *e )
   code.newLine();
   code += "while ( mRunning < mBuffer.length() ) {";
   code.indent();
-  code += "QChar c = mBuffer[ mRunning ];";
+  code += "TQChar c = mBuffer[ mRunning ];";
   code.addBlock( sm.transitionLogic() );
   code += "++mRunning;";
   code.unindent();
@@ -382,9 +382,9 @@ void Creator::createElementParserCustom( KODE::Class &c, Element *e )
     for( it = e->elements.begin(); it != e->elements.end(); ++it ) { 
       createFoundTextFunction( (*it)->name );
 
-      QString eName = upperFirst( (*it)->name );
+      TQString eName = upperFirst( (*it)->name );
       stateCode += "} else if ( foundText" + eName + "() ) {";
-      QString line = "  result->";
+      TQString line = "  result->";
       if ( (*it)->hasText ) line += "set";
       else line += "add";
       line += eName + "( parseElement" + eName + "() );";
@@ -395,7 +395,7 @@ void Creator::createElementParserCustom( KODE::Class &c, Element *e )
     for( it3 = e->references.begin(); it3 != e->references.end(); ++it3 ) { 
       createFoundTextFunction( (*it3)->name );
 
-      QString eName = upperFirst( (*it3)->name );
+      TQString eName = upperFirst( (*it3)->name );
       stateCode += "} else if ( foundText" + eName + "() ) {";
       stateCode += "  result->add" + eName + "( parseElement" + eName + "() );";
       stateCode += "  state = WHITESPACE;";
@@ -451,7 +451,7 @@ void Creator::createElementParserCustom( KODE::Class &c, Element *e )
 
   code += "while ( mRunning < mBuffer.length() ) {";
   code.indent();
-  code += "QChar c = mBuffer[ mRunning ];";
+  code += "TQChar c = mBuffer[ mRunning ];";
 
   if ( e->isEmpty ) {
     code += "if ( c == '>' ) {";
@@ -485,11 +485,11 @@ KODE::Code Creator::createAttributeScanner( Attribute *a, bool firstAttribute )
 {
   KODE::Code code;
 
-  QString aName = upperFirst( a->name );
+  TQString aName = upperFirst( a->name );
 
   createFoundTextFunction( a->name );
 
-  QString line;
+  TQString line;
   if ( !firstAttribute ) line = "} else ";
   line += "if ( foundText" + aName + "() ) {";
   code += line;
@@ -509,7 +509,7 @@ KODE::Code Creator::createAttributeScanner( Attribute *a, bool firstAttribute )
 
 void Creator::createElementParserDom( KODE::Class &c, Element *e )
 {
-  QString functionName;
+  TQString functionName;
   if ( externalParser() ) functionName = "parseElement" + c.name();
   else functionName = "parseElement";
 
@@ -517,7 +517,7 @@ void Creator::createElementParserDom( KODE::Class &c, Element *e )
   parser.setStatic( true );
   parser.setDocs( "Parse XML object from DOM element." );
 
-  parser.addArgument( "const QDomElement &element" );
+  parser.addArgument( "const TQDomElement &element" );
 
   KODE::Code code;
 
@@ -533,27 +533,27 @@ void Creator::createElementParserDom( KODE::Class &c, Element *e )
   code += c.name() + " *result = new " + c.name() + "();";
   code.newLine();
 
-  code += "QDomNode n;";
+  code += "TQDomNode n;";
   code += "for( n = element.firstChild(); !n.isNull();"
               " n = n.nextSibling() ) {";
   code.indent();
-  code += "QDomElement e = n.toElement();";
+  code += "TQDomElement e = n.toElement();";
 
-  QValueList<Element *>::ConstIterator it;
+  TQValueList<Element *>::ConstIterator it;
   for( it = e->elements.begin(); it != e->elements.end(); ++it ) {
-    QString condition;
+    TQString condition;
     if ( it != e->elements.begin() ) condition = "else ";
     condition += "if";
 
     code += condition + " ( e.tagName() == \"" + (*it)->name + "\" ) {";
     code.indent();
 
-    QString className = upperFirst( (*it)->name );
+    TQString className = upperFirst( (*it)->name );
 
     if ( (*it)->hasText ) {
       code += "result->set" + className + "( e.text() );"; 
     } else {
-      QString line = className + " *o = ";
+      TQString line = className + " *o = ";
       if ( externalParser() ) {
         line += "parseElement" + className;
       } else {
@@ -571,18 +571,18 @@ void Creator::createElementParserDom( KODE::Class &c, Element *e )
 
   code.newLine();
 
-  QValueList<Reference *>::ConstIterator it3;
+  TQValueList<Reference *>::ConstIterator it3;
   for( it3 = e->references.begin(); it3 != e->references.end(); ++it3 ) {
-    QString condition;
+    TQString condition;
     if ( it3 != e->references.begin() ) condition = "else ";
     condition += "if";
 
     code += condition + " ( e.tagName() == \"" + (*it3)->name + "\" ) {";
     code.indent();
 
-    QString className = upperFirst( (*it3)->name );
+    TQString className = upperFirst( (*it3)->name );
 
-    QString line = className + " *o = ";
+    TQString line = className + " *o = ";
     if ( externalParser() ) {
       line += "parseElement" + className;
     } else {
@@ -601,7 +601,7 @@ void Creator::createElementParserDom( KODE::Class &c, Element *e )
   code += "}";
   code.newLine();
 
-  QValueList<Attribute *>::ConstIterator it2;
+  TQValueList<Attribute *>::ConstIterator it2;
   for( it2 = e->attributes.begin(); it2 != e->attributes.end(); ++it2 ) {
     code += "result->set" + upperFirst( (*it2)->name ) +
             "( element.attribute( \"" + (*it2)->name + "\" ) );";
@@ -619,32 +619,32 @@ void Creator::createElementParserDom( KODE::Class &c, Element *e )
   }
 }
 
-void Creator::registerListTypedef( const QString &type )
+void Creator::registerListTypedef( const TQString &type )
 {
   if ( !mListTypedefs.contains( type ) ) mListTypedefs.append( type );
 }
 
 void Creator::createListTypedefs()
 {
-  QStringList::ConstIterator it;
+  TQStringList::ConstIterator it;
   for( it = mListTypedefs.begin(); it != mListTypedefs.end(); ++it ) {
     KODE::Class c = mFile.findClass( *it );
     if ( !c.isValid() ) continue;
-    c.addTypedef( KODE::Typedef( "QValueList<" + *it + " *>", "List" ) );
+    c.addTypedef( KODE::Typedef( "TQValueList<" + *it + " *>", "List" ) );
     mFile.insertClass( c );
   }
 }
 
 void Creator::createIndenter( KODE::File &file )
 {
-  KODE::Function indenter( "indent", "QString" );
+  KODE::Function indenter( "indent", "TQString" );
   indenter.addArgument( "int n = 0" );
   
   KODE::Code code;
 
   code += "static int i = 0;";
   code += "i += n;";
-  code += "QString space;";
+  code += "TQString space;";
   code += "return space.fill( ' ', i );"; 
 
   indenter.setBody( code );
@@ -652,15 +652,15 @@ void Creator::createIndenter( KODE::File &file )
   file.addFileFunction( indenter );
 }
 
-void Creator::createFileWriter( Element *element, const QString &dtd )
+void Creator::createFileWriter( Element *element, const TQString &dtd )
 {
-  QString className = upperFirst( element->name );
+  TQString className = upperFirst( element->name );
 
   KODE::Class c = mFile.findClass( className );
 
   c.addInclude( "kdebug.h" );
-  c.addInclude( "qtextstream.h" );
-  c.addInclude( "qfile.h" );
+  c.addInclude( "tqtextstream.h" );
+  c.addInclude( "tqfile.h" );
 
   if ( !externalWriter() ) {
     createIndenter( mFile );
@@ -668,19 +668,19 @@ void Creator::createFileWriter( Element *element, const QString &dtd )
 
   KODE::Function writer( "writeFile", "bool" );
 
-  writer.addArgument( "const QString &filename" );
+  writer.addArgument( "const TQString &filename" );
 
-  c.addInclude( "qfile.h" );
+  c.addInclude( "tqfile.h" );
 
   KODE::Code code;
 
-  code += "QFile file( filename );";
+  code += "TQFile file( filename );";
   code += "if ( !file.open( IO_WriteOnly ) ) {";
   code += "  kdError() << \"Unable to open file '\" << filename << \"'\" << endl;";
   code += "  return false;";
   code += "}";
   code += "";
-  code += "QTextStream ts( &file );";
+  code += "TQTextStream ts( &file );";
 
   code += "ts << \"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\n\";";
   code += "ts << \"<!DOCTYPE features SYSTEM \\\"" + dtd + "\\\">\\n\";";
@@ -714,29 +714,29 @@ void Creator::createFileParserCustom( Element *element )
 {
   kdDebug() << "Creator::createFileParserCustom()" << endl;
 
-  QString className = upperFirst( element->name );
+  TQString className = upperFirst( element->name );
 
   KODE::Function parser( "parseFile", className + " *" );
 
-  parser.addArgument( "const QString &filename" );
+  parser.addArgument( "const TQString &filename" );
 
-  mParserClass.addInclude( "qfile.h" );
+  mParserClass.addInclude( "tqfile.h" );
   mParserClass.addInclude( "kdebug.h" );
 
   mParserClass.addMemberVariable( KODE::MemberVariable( "mBuffer",
-                                                        "QString" ) );
+                                                        "TQString" ) );
   mParserClass.addMemberVariable( KODE::MemberVariable( "mRunning",
                                                         "unsigned int" ) );
 
   KODE::Code code;
 
-  code += "QFile file( filename );";
+  code += "TQFile file( filename );";
   code += "if ( !file.open( IO_ReadOnly ) ) {";
   code += "  kdError() << \"Unable to open file '\" << filename << \"'\" << endl;";
   code += "  return 0;";
   code += "}";
   code += "";
-  code += "QTextStream ts( &file );";
+  code += "TQTextStream ts( &file );";
   code += "mBuffer = ts.read();";
   code += "";
   code += "mRunning = 0;";
@@ -771,7 +771,7 @@ void Creator::createFileParserCustom( Element *element )
 
   code += "while ( mRunning < mBuffer.length() ) {";
   code.indent();
-  code += "QChar c = mBuffer[ mRunning ];";
+  code += "TQChar c = mBuffer[ mRunning ];";
   code.addBlock( sm.transitionLogic() );
   code += "++mRunning;";
   code.unindent();
@@ -785,9 +785,9 @@ void Creator::createFileParserCustom( Element *element )
   mParserClass.addFunction( parser );
 }
 
-void Creator::createFoundTextFunction( const QString &text )
+void Creator::createFoundTextFunction( const TQString &text )
 {
-  QString functionName = "foundText" + upperFirst( text );
+  TQString functionName = "foundText" + upperFirst( text );
 
   if ( mParserClass.hasFunction( functionName ) ) return;
 
@@ -798,8 +798,8 @@ void Creator::createFoundTextFunction( const QString &text )
   code += "if ( mBuffer[ mRunning ] != '" + text.right( 1 ) + "' ) return false;";
   code += "";
   code += "return mBuffer.mid( mRunning - " +
-          QString::number( text.length() - 1 ) + ", " +
-          QString::number( text.length() ) + " ) == \"" + text + "\";";
+          TQString::number( text.length() - 1 ) + ", " +
+          TQString::number( text.length() ) + " ) == \"" + text + "\";";
 
   f.setBody( code );
   
@@ -810,7 +810,7 @@ void Creator::createFileParserDom( Element *element )
 {
   kdDebug() << "Creator::createFileParserDom()" << endl;
 
-  QString className = upperFirst( element->name );
+  TQString className = upperFirst( element->name );
 
   KODE::Class c;
 
@@ -823,23 +823,23 @@ void Creator::createFileParserDom( Element *element )
   KODE::Function parser( "parseFile", className + " *" );
   parser.setStatic( true );
 
-  parser.addArgument( "const QString &filename" );
+  parser.addArgument( "const TQString &filename" );
 
-  c.addInclude( "qfile.h" );
-  c.addInclude( "qdom.h" );
+  c.addInclude( "tqfile.h" );
+  c.addInclude( "tqdom.h" );
   c.addInclude( "kdebug.h" );
 
   KODE::Code code;
 
-  code += "QFile file( filename );";
+  code += "TQFile file( filename );";
   code += "if ( !file.open( IO_ReadOnly ) ) {";
   code += "  kdError() << \"Unable to open file '\" << filename << \"'\" << endl;";
   code += "  return 0;";
   code += "}";
   code += "";
-  code += "QString errorMsg;";
+  code += "TQString errorMsg;";
   code += "int errorLine, errorCol;";
-  code += "QDomDocument doc;";
+  code += "TQDomDocument doc;";
   code += "if ( !doc.setContent( &file, false, &errorMsg, &errorLine, &errorCol ) ) {";
   code += "  kdError() << errorMsg << \" at \" << errorLine << \",\" << errorCol << endl;";
   code += "  return 0;";
@@ -849,7 +849,7 @@ void Creator::createFileParserDom( Element *element )
 
   code += "";
   
-  QString line = className + " *c = parseElement";
+  TQString line = className + " *c = parseElement";
   if ( externalParser() ) line += className;
   line += "( doc.documentElement() );";
   code += line;
diff --git a/kode/kxml_compiler/creator.h b/kode/kxml_compiler/creator.h
index 6e0d6f8b3..2103f928e 100644
--- a/kode/kxml_compiler/creator.h
+++ b/kode/kxml_compiler/creator.h
@@ -38,11 +38,11 @@
 #include <ksimpleconfig.h>
 #include <kstandarddirs.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
-#include <qdom.h>
-#include <qregexp.h>
-#include <qmap.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+#include <tqdom.h>
+#include <tqregexp.h>
+#include <tqmap.h>
 
 #include <iostream>
 
@@ -56,28 +56,28 @@ class Creator
     Creator( XmlParserType p = XmlParserDom,
              XmlWriterType w = XmlWriterCustom );
 
-    void setExternalClassPrefix( const QString & );
+    void setExternalClassPrefix( const TQString & );
 
     bool externalParser() const;
     bool externalWriter() const;
 
     KODE::File &file();
 
-    QString upperFirst( const QString &str );
-    QString lowerFirst( const QString &str );
+    TQString upperFirst( const TQString &str );
+    TQString lowerFirst( const TQString &str );
     
-    void createProperty( KODE::Class &c, const QString &type,
-                         const QString &name );
+    void createProperty( KODE::Class &c, const TQString &type,
+                         const TQString &name );
     void createElementFunctions( KODE::Class &c, Element *e );
     void createClass( Element *element );
 
-    void registerListTypedef( const QString &type );
+    void registerListTypedef( const TQString &type );
 
     void createListTypedefs();
 
     void createFileParser( Element *element );
 
-    void createFileWriter( Element *element, const QString &dtd );
+    void createFileWriter( Element *element, const TQString &dtd );
 
     void printFiles( KODE::Printer & );
 
@@ -94,7 +94,7 @@ class Creator
     void createElementParserCustom( KODE::Class &c, Element *e );
     void createTextElementParserCustom( KODE::Class &c, Element *e );
     KODE::Code createAttributeScanner( Attribute *a, bool firstAttribute );
-    void createFoundTextFunction( const QString &text );
+    void createFoundTextFunction( const TQString &text );
 
     void createElementWriter( KODE::Class &c, Element *e );
 
@@ -103,13 +103,13 @@ class Creator
   private:
     XmlParserType mXmlParserType;
     XmlWriterType mXmlWriterType;
-    QString mExternalClassPrefix;
+    TQString mExternalClassPrefix;
 
     KODE::File mFile;
     KODE::Class mParserClass;
     KODE::Class mWriterClass;
-    QStringList mProcessedClasses;
-    QStringList mListTypedefs;
+    TQStringList mProcessedClasses;
+    TQStringList mListTypedefs;
 };
 
 #endif
diff --git a/kode/kxml_compiler/kxml_compiler.cpp b/kode/kxml_compiler/kxml_compiler.cpp
index 62b2162c5..71720d6b9 100644
--- a/kode/kxml_compiler/kxml_compiler.cpp
+++ b/kode/kxml_compiler/kxml_compiler.cpp
@@ -36,11 +36,11 @@
 #include <ksimpleconfig.h>
 #include <kstandarddirs.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
-#include <qdom.h>
-#include <qregexp.h>
-#include <qmap.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+#include <tqdom.h>
+#include <tqregexp.h>
+#include <tqmap.h>
 
 #include <iostream>
 
@@ -77,25 +77,25 @@ int main( int argc, char **argv )
     return 1;
   }
 
-  QString baseDir = QFile::decodeName( args->getOption( "directory" ) );
+  TQString baseDir = TQFile::decodeName( args->getOption( "directory" ) );
   if ( !baseDir.endsWith( "/" ) ) baseDir.append( "/" );
 
-  QString dtdFilename = args->url( 0 ).path();
+  TQString dtdFilename = args->url( 0 ).path();
 
-  QString baseName = args->url( 0 ).fileName();
+  TQString baseName = args->url( 0 ).fileName();
   int pos = baseName.findRev( '.' );
   if ( pos > 0 ) baseName = baseName.left( pos );
 
 
-  QFile dtdFile( dtdFilename );
+  TQFile dtdFile( dtdFilename );
   if ( !dtdFile.open( IO_ReadOnly ) ) {
     kdError() << "Unable to open '" << dtdFilename << "'" << endl;
     return 1;
   }
 
-  QString errorMsg;
+  TQString errorMsg;
   int errorLine, errorCol;
-  QDomDocument doc;
+  TQDomDocument doc;
   if ( !doc.setContent( &dtdFile, false, &errorMsg, &errorLine, &errorCol ) ) {
     kdError() << errorMsg << " at " << errorLine << "," << errorCol << endl;
     return 1;
@@ -135,7 +135,7 @@ int main( int argc, char **argv )
   Creator c( pt );
 
   kdDebug() << "Create classes" << endl;
-  QValueList<Element *>::ConstIterator it;
+  TQValueList<Element *>::ConstIterator it;
   for( it = start->elements.begin(); it != start->elements.end(); ++it ) {
     c.createClass( *it );
   }
@@ -149,7 +149,7 @@ int main( int argc, char **argv )
   c.createListTypedefs();
 
 #if 0
-  QValueList<Reference *>::ConstIterator it2;
+  TQValueList<Reference *>::ConstIterator it2;
   for( it2 = start->references.begin(); it2 != start->references.end();
        ++it2 ) {
     Element e;
diff --git a/kode/kxml_compiler/parser.cpp b/kode/kxml_compiler/parser.cpp
index bc451ce0d..9b3f33b99 100644
--- a/kode/kxml_compiler/parser.cpp
+++ b/kode/kxml_compiler/parser.cpp
@@ -35,11 +35,11 @@
 #include <ksimpleconfig.h>
 #include <kstandarddirs.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
-#include <qdom.h>
-#include <qregexp.h>
-#include <qmap.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+#include <tqdom.h>
+#include <tqregexp.h>
+#include <tqmap.h>
 
 #include <iostream>
 
@@ -54,10 +54,10 @@ bool Pattern::isEmpty()
   return !optional && !zeroOrMore && !oneOrMore && !choice;
 }
 
-QString Pattern::asString()
+TQString Pattern::asString()
 {
   if ( isEmpty() ) return "";
-  QString str = "( ";
+  TQString str = "( ";
   if ( optional ) str += "optional ";      
   if ( zeroOrMore ) str += "zeroOrMore ";
   if ( oneOrMore ) str += "oneOrMore ";
@@ -83,20 +83,20 @@ Parser::Parser()
 {
 }
 
-Element *Parser::parse( const QDomElement &docElement )
+Element *Parser::parse( const TQDomElement &docElement )
 {
   Element *start = 0;
 
-  QDomNode n1;
+  TQDomNode n1;
   for( n1 = docElement.firstChild(); !n1.isNull(); n1 = n1.nextSibling() ) {
-    QDomElement e1 = n1.toElement();
+    TQDomElement e1 = n1.toElement();
     kdDebug() << "TOP LEVEL element " << e1.tagName() << endl;
     if ( e1.tagName() == "define" ) {
       Element *d = new Element;
       d->name = e1.attribute( "name" );
       parseElement( e1, d, Pattern() );
       Element::List definitions;
-      QMap<QString,Element::List >::ConstIterator it; 
+      TQMap<TQString,Element::List >::ConstIterator it; 
       it = mDefinitionMap.find( d->name );
       if ( it != mDefinitionMap.end() ) definitions = *it;
       definitions.append( d );
@@ -112,14 +112,14 @@ Element *Parser::parse( const QDomElement &docElement )
   return start;
 }
 
-Reference *Parser::parseReference( const QDomElement &referenceElement )
+Reference *Parser::parseReference( const TQDomElement &referenceElement )
 {
   Reference *r = new Reference;
   r->name = referenceElement.attribute( "name" );
   return r;
 }
 
-bool Parser::parseAttribute( const QDomElement &attributeElement,
+bool Parser::parseAttribute( const TQDomElement &attributeElement,
                            Attribute *a )
 {
   a->name = attributeElement.attribute( "name" );
@@ -127,14 +127,14 @@ bool Parser::parseAttribute( const QDomElement &attributeElement,
   return true;
 }
 
-bool Parser::parseElement( const QDomElement &elementElement, Element *e,
+bool Parser::parseElement( const TQDomElement &elementElement, Element *e,
                    Pattern pattern )
 {
   kdDebug() << "parseElement " << e->name << endl;
 
-  QDomNode n1;
+  TQDomNode n1;
   for( n1 = elementElement.firstChild(); !n1.isNull(); n1 = n1.nextSibling() ) {
-    QDomElement e1 = n1.toElement();
+    TQDomElement e1 = n1.toElement();
     if ( e1.tagName() == "element" ) {
       Element *element = new Element;
       element->name = e1.attribute( "name" );
@@ -191,7 +191,7 @@ void Parser::substituteReferences( Element *s )
     } else {
       r->substituted = true;
     }
-    QMap<QString,Element::List >::ConstIterator it1;
+    TQMap<TQString,Element::List >::ConstIterator it1;
     it1 = mDefinitionMap.find( r->name );
     if ( it1 != mDefinitionMap.end() ) {
       Element::List elements = *it1;
@@ -292,7 +292,7 @@ void Parser::dumpTree( Element *s )
 void Parser::dumpDefinitionMap()
 {
   std::cout << "DEFINITION MAP" << std::endl;
-  QMap<QString,Element::List >::ConstIterator it;
+  TQMap<TQString,Element::List >::ConstIterator it;
   for( it = mDefinitionMap.begin(); it != mDefinitionMap.end(); ++it ) {
     dumpElements( *it, 2 );
   }
diff --git a/kode/kxml_compiler/parser.h b/kode/kxml_compiler/parser.h
index b9ff542c0..6efd6f746 100644
--- a/kode/kxml_compiler/parser.h
+++ b/kode/kxml_compiler/parser.h
@@ -35,11 +35,11 @@
 #include <ksimpleconfig.h>
 #include <kstandarddirs.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
-#include <qdom.h>
-#include <qregexp.h>
-#include <qmap.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+#include <tqdom.h>
+#include <tqregexp.h>
+#include <tqmap.h>
 
 #include <iostream>
 
@@ -50,7 +50,7 @@ class Pattern
 
     bool isEmpty();
 
-    QString asString();
+    TQString asString();
 
     void merge( Pattern p );
   
@@ -63,11 +63,11 @@ class Pattern
 class Reference
 {
   public:
-    typedef QValueList<Reference *> List;
+    typedef TQValueList<Reference *> List;
   
     Reference() : substituted( false ) {}
   
-    QString name;
+    TQString name;
     Pattern pattern;
 
     bool substituted;
@@ -76,22 +76,22 @@ class Reference
 class Attribute
 {
   public:
-    typedef QValueList<Attribute *> List;
+    typedef TQValueList<Attribute *> List;
   
-    QString name;
-    QValueList<QString> choices;
-    QString defaultValue;
+    TQString name;
+    TQValueList<TQString> choices;
+    TQString defaultValue;
     Pattern pattern;
 };
 
 class Element
 {
   public:
-    typedef QValueList<Element *> List;
+    typedef TQValueList<Element *> List;
   
     Element();
   
-    QString name;
+    TQString name;
     Element::List elements;
     Attribute::List attributes;
     Reference::List references;
@@ -105,12 +105,12 @@ class Parser
   public:
     Parser();
 
-    Element *parse( const QDomElement &docElement );
+    Element *parse( const TQDomElement &docElement );
 
-    Reference *parseReference( const QDomElement &referenceElement );
-    bool parseAttribute( const QDomElement &attributeElement,
+    Reference *parseReference( const TQDomElement &referenceElement );
+    bool parseAttribute( const TQDomElement &attributeElement,
                                Attribute *a );
-    bool parseElement( const QDomElement &elementElement, Element *e,
+    bool parseElement( const TQDomElement &elementElement, Element *e,
                        Pattern pattern );
 
     void substituteReferences( Element *s );
@@ -128,7 +128,7 @@ class Parser
     void dumpDefinitionMap();
 
   private:
-    QMap<QString,Element::List> mDefinitionMap;
+    TQMap<TQString,Element::List> mDefinitionMap;
 };
 
 #endif
diff --git a/kode/license.cpp b/kode/license.cpp
index 1e251eaf3..12208f8c5 100644
--- a/kode/license.cpp
+++ b/kode/license.cpp
@@ -40,9 +40,9 @@ void License::setQtException( bool v )
   mQtException = v;
 }
 
-QString License::text()
+TQString License::text()
 {
-  QString txt;
+  TQString txt;
 
   switch ( mType ) {
     case GPL:
diff --git a/kode/license.h b/kode/license.h
index 0d413f08d..d74a0b579 100644
--- a/kode/license.h
+++ b/kode/license.h
@@ -21,7 +21,7 @@
 #ifndef KODE_LICENSE_H
 #define KODE_LICENSE_H
 
-#include <qstring.h>
+#include <tqstring.h>
 #include <kdepimmacros.h>
 
 namespace KODE {
@@ -36,7 +36,7 @@ class KDE_EXPORT License
 
     void setQtException( bool );
 
-    QString text();
+    TQString text();
 
   private:
     Type mType;
diff --git a/kode/membervariable.cpp b/kode/membervariable.cpp
index e497529eb..ac8f2c25e 100644
--- a/kode/membervariable.cpp
+++ b/kode/membervariable.cpp
@@ -30,11 +30,11 @@ MemberVariable::MemberVariable()
 {
 }
 
-MemberVariable::MemberVariable( const QString &name, const QString &type,
+MemberVariable::MemberVariable( const TQString &name, const TQString &type,
                                 bool isStatic )
   : Variable( name, type, isStatic )
 {
-  QString n;
+  TQString n;
 
   if ( name.isEmpty() ) {
     n = "mUndefined";
diff --git a/kode/membervariable.h b/kode/membervariable.h
index e864f69ab..957df34a4 100644
--- a/kode/membervariable.h
+++ b/kode/membervariable.h
@@ -23,8 +23,8 @@
 
 #include "variable.h"
 
-#include <qvaluelist.h>
-#include <qstring.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
 #include <kdepimmacros.h>
 
 namespace KODE {
@@ -32,10 +32,10 @@ namespace KODE {
 class KDE_EXPORT MemberVariable : public Variable
 {
   public:
-    typedef QValueList<MemberVariable> List;
+    typedef TQValueList<MemberVariable> List;
 
     MemberVariable();
-    MemberVariable( const QString &name, const QString &type,
+    MemberVariable( const TQString &name, const TQString &type,
                     bool isStatic = false );
 };
 
diff --git a/kode/printer.cpp b/kode/printer.cpp
index 2a5cba2fc..3adf32caf 100644
--- a/kode/printer.cpp
+++ b/kode/printer.cpp
@@ -24,8 +24,8 @@
 #include <kdebug.h>
 #include <ksavefile.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
 
 using namespace KODE;
 
@@ -44,32 +44,32 @@ void Printer::setCreationWarning( bool v )
   mCreationWarning = v;
 }
 
-void Printer::setGenerator( const QString &g )
+void Printer::setGenerator( const TQString &g )
 {
   mGenerator = g;
 }
 
-void Printer::setOutputDirectory( const QString &o )
+void Printer::setOutputDirectory( const TQString &o )
 {
   mOutputDirectory = o;
 }
 
-void Printer::setSourceFile( const QString &s )
+void Printer::setSourceFile( const TQString &s )
 {
   mSourceFile = s;
 }
 
-QString Printer::functionSignature( const Function &f,
-                                    const QString &className,
+TQString Printer::functionSignature( const Function &f,
+                                    const TQString &className,
                                     bool includeClassQualifier )
 {
-  QString s;
+  TQString s;
   
   if ( f.isStatic() && !includeClassQualifier ) {
     s += "static ";
   }
 
-  QString ret = f.returnType();
+  TQString ret = f.returnType();
   if ( !ret.isEmpty() ) {
     s += ret;
     if ( ret.right( 1 ) != "*" && ret.right( 1 ) != "&" ) {
@@ -95,10 +95,10 @@ QString Printer::functionSignature( const Function &f,
   return s;
 }
 
-QString Printer::creationWarning()
+TQString Printer::creationWarning()
 {
   // Create warning about generated file
-  QString str = "// This file is generated by " + mGenerator;
+  TQString str = "// This file is generated by " + mGenerator;
   if ( !mSourceFile.isEmpty() ) {
     str += " from " + mSourceFile;
   }
@@ -109,7 +109,7 @@ QString Printer::creationWarning()
   return str;
 }
 
-QString Printer::licenseHeader( const File &file )
+TQString Printer::licenseHeader( const File &file )
 {
   Code code;
   code += "/*";
@@ -118,7 +118,7 @@ QString Printer::licenseHeader( const File &file )
   code += "This file is part of " + file.project() + ".";
   code.newLine();
   
-  QStringList copyrights = file.copyrightStrings();
+  TQStringList copyrights = file.copyrightStrings();
   if ( !copyrights.isEmpty() ) {
     code.addBlock( copyrights.join( "\n" ) );
     code.newLine();
@@ -133,7 +133,7 @@ QString Printer::licenseHeader( const File &file )
 }
 
 Code Printer::functionHeaders( const Function::List &functions,
-                               const QString &className,
+                               const TQString &className,
                                int access )
 {
   bool needNewLine = false;
@@ -167,7 +167,7 @@ Code Printer::functionHeaders( const Function::List &functions,
   return code;
 }
 
-QString Printer::classHeader( const Class &c )
+TQString Printer::classHeader( const Class &c )
 {
   Code code;
 
@@ -179,7 +179,7 @@ QString Printer::classHeader( const Class &c )
     code += "*/";
   }
 
-  QString txt = "class " + mStyle.className( c.name() );
+  TQString txt = "class " + mStyle.className( c.name() );
 
   Class::List baseClasses = c.baseClasses();
   if ( !baseClasses.isEmpty() ) {
@@ -252,7 +252,7 @@ QString Printer::classHeader( const Class &c )
     for( it2 = variables.begin(); it2 != variables.end(); ++it2 ) {
       MemberVariable v = *it2;
 
-      QString decl;
+      TQString decl;
       if ( v.isStatic() ) decl += "static ";
       decl += v.type();
       if ( v.type().right( 1 ) != "*" && v.type().right( 1 ) != "&" ) {
@@ -270,7 +270,7 @@ QString Printer::classHeader( const Class &c )
   return code.text();
 }
 
-QString Printer::classImplementation( const Class &c )
+TQString Printer::classImplementation( const Class &c )
 {
   Code code;
 
@@ -325,10 +325,10 @@ void Printer::printHeader( const File &f )
   out.addBlock( licenseHeader( f ) );
 
   // Create include guard
-  QString className = f.filename();
+  TQString className = f.filename();
   className.replace( "-", "_" );
 
-  QString includeGuard;
+  TQString includeGuard;
   if ( !f.nameSpace().isEmpty() ) includeGuard += f.nameSpace().upper() + "_";
   includeGuard += className.upper() + "_H";
 
@@ -339,12 +339,12 @@ void Printer::printHeader( const File &f )
 
 
   // Create includes
-  QStringList processed;
+  TQStringList processed;
   Class::List classes = f.classes();
   Class::List::ConstIterator it;
   for( it = classes.begin(); it != classes.end(); ++it ) {
-    QStringList includes = (*it).headerIncludes();
-    QStringList::ConstIterator it2;
+    TQStringList includes = (*it).headerIncludes();
+    TQStringList::ConstIterator it2;
     for( it2 = includes.begin(); it2 != includes.end(); ++it2 ) {
       if ( processed.find( *it2 ) == processed.end() ) {
         out += "#include <" + *it2 + ">";
@@ -358,8 +358,8 @@ void Printer::printHeader( const File &f )
   // Create forward declarations
   processed.clear();
   for( it = classes.begin(); it != classes.end(); ++it ) {
-    QStringList decls = (*it).forwardDeclarations();
-    QStringList::ConstIterator it2;
+    TQStringList decls = (*it).forwardDeclarations();
+    TQStringList::ConstIterator it2;
     for( it2 = decls.begin(); it2 != decls.end(); ++it2 ) {
       if ( processed.find( *it2 ) == processed.end() ) {
         out += "class " + *it2 + ";";
@@ -391,19 +391,19 @@ void Printer::printHeader( const File &f )
 
 
   // Print to file
-  QString filename = f.filename() + ".h";
+  TQString filename = f.filename() + ".h";
 
   if ( !mOutputDirectory.isEmpty() ) filename.prepend( mOutputDirectory + "/" );
 
-  KSaveFile::backupFile( filename, QString::null, ".backup" );
+  KSaveFile::backupFile( filename, TQString::null, ".backup" );
 
-  QFile header( filename );
+  TQFile header( filename );
   if ( !header.open( IO_WriteOnly ) ) {
     kdError() << "Can't open '" << filename << "' for writing." << endl;
     return;
   }
 
-  QTextStream h( &header );
+  TQTextStream h( &header );
 
   h << out.text();
 
@@ -426,20 +426,20 @@ void Printer::printImplementation( const File &f, bool createHeaderInclude )
     out.newLine();
   }
 
-  QStringList includes = f.includes();
-  QStringList::ConstIterator it2;
+  TQStringList includes = f.includes();
+  TQStringList::ConstIterator it2;
   for( it2 = includes.begin(); it2 != includes.end(); ++it2 ) {
     out += "#include <" + *it2 + ">";
   }
   if ( !includes.isEmpty() ) out.newLine();
 
   // Create class includes
-  QStringList processed;
+  TQStringList processed;
   Class::List classes = f.classes();
   Class::List::ConstIterator it;
   for( it = classes.begin(); it != classes.end(); ++it ) {
-    QStringList includes = (*it).includes();
-    QStringList::ConstIterator it2;
+    TQStringList includes = (*it).includes();
+    TQStringList::ConstIterator it2;
     for( it2 = includes.begin(); it2 != includes.end(); ++it2 ) {
       if ( processed.find( *it2 ) == processed.end() ) {
         out += "#include <" + *it2 + ">";
@@ -455,10 +455,10 @@ void Printer::printImplementation( const File &f, bool createHeaderInclude )
   }
 
   // 'extern "C"' declarations
-  QStringList externCDeclarations = f.externCDeclarations();
+  TQStringList externCDeclarations = f.externCDeclarations();
   if ( !externCDeclarations.isEmpty() ) {
     out += "extern \"C\" {";
-    QStringList::ConstIterator it;
+    TQStringList::ConstIterator it;
     for( it = externCDeclarations.begin(); it != externCDeclarations.end();
          ++it ) {
       out += *it + ";";
@@ -472,7 +472,7 @@ void Printer::printImplementation( const File &f, bool createHeaderInclude )
   Variable::List::ConstIterator itV;
   for( itV = vars.begin(); itV != vars.end(); ++itV ) {
     Variable v = *itV;
-    QString str;
+    TQString str;
     if ( v.isStatic() ) str += "static ";
     str += v.type() + " " + v.name() + ";";
     out += str;
@@ -499,24 +499,24 @@ void Printer::printImplementation( const File &f, bool createHeaderInclude )
 
   // Classes
   for( it = classes.begin(); it != classes.end(); ++it ) {
-    QString str = classImplementation( *it );
+    TQString str = classImplementation( *it );
     if ( !str.isEmpty() ) out += classImplementation( *it );
   }
 
   // Print to file
-  QString filename = f.filename() + ".cpp";
+  TQString filename = f.filename() + ".cpp";
 
   if ( !mOutputDirectory.isEmpty() ) filename.prepend( mOutputDirectory + "/" );
 
-  KSaveFile::backupFile( filename, QString::null, ".backup" );
+  KSaveFile::backupFile( filename, TQString::null, ".backup" );
 
-  QFile implementation( filename );
+  TQFile implementation( filename );
   if ( !implementation.open( IO_WriteOnly ) ) {
     kdError() << "Can't open '" << filename << "' for writing." << endl;
     return;
   }
 
-  QTextStream h( &implementation );
+  TQTextStream h( &implementation );
 
   h << out.text();
 
@@ -525,19 +525,19 @@ void Printer::printImplementation( const File &f, bool createHeaderInclude )
 
 void Printer::printAutoMakefile( const AutoMakefile &am )
 {
-  QString filename = "Makefile.am";
+  TQString filename = "Makefile.am";
 
   if ( !mOutputDirectory.isEmpty() ) filename.prepend( mOutputDirectory + "/" );
 
-  KSaveFile::backupFile( filename, QString::null, ".backup" );
+  KSaveFile::backupFile( filename, TQString::null, ".backup" );
 
-  QFile file( filename );
+  TQFile file( filename );
   if ( !file.open( IO_WriteOnly ) ) {
     kdError() << "Can't open '" << filename << "' for writing." << endl;
     return;
   }
 
-  QTextStream ts( &file );
+  TQTextStream ts( &file );
 
   ts << am.text();
 }
diff --git a/kode/printer.h b/kode/printer.h
index 169884571..ec50bec01 100644
--- a/kode/printer.h
+++ b/kode/printer.h
@@ -27,9 +27,9 @@
 #include "automakefile.h"
 
 #include <kdepimmacros.h>
-#include <qvaluelist.h>
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 
 namespace KODE {
 
@@ -40,34 +40,34 @@ class KDE_EXPORT Printer
     Printer( const Style & );
 
     void setCreationWarning( bool );
-    void setGenerator( const QString & );
-    void setOutputDirectory( const QString & );
-    void setSourceFile( const QString & );
+    void setGenerator( const TQString & );
+    void setOutputDirectory( const TQString & );
+    void setSourceFile( const TQString & );
 
     void printHeader( const File & );
     void printImplementation( const File &, bool createHeaderInclude = true );
     void printAutoMakefile( const AutoMakefile & );
 
-    QString functionSignature( const Function &f,
-      const QString &className = QString::null,
+    TQString functionSignature( const Function &f,
+      const TQString &className = TQString::null,
       bool includeClassQualifier = false );
 
   protected:
-    QString creationWarning();
-    QString licenseHeader( const File & );
-    QString classHeader( const Class & );
-    QString classImplementation( const Class & );
+    TQString creationWarning();
+    TQString licenseHeader( const File & );
+    TQString classHeader( const Class & );
+    TQString classImplementation( const Class & );
     Code functionHeaders( const Function::List &functions,
-                          const QString &className,
+                          const TQString &className,
                           int access );
 
   private:
     Style mStyle;
 
     bool mCreationWarning;
-    QString mGenerator;
-    QString mOutputDirectory;
-    QString mSourceFile;
+    TQString mGenerator;
+    TQString mOutputDirectory;
+    TQString mSourceFile;
 };
 
 }
diff --git a/kode/statemachine.cpp b/kode/statemachine.cpp
index fe90d5d6b..d3d49fb03 100644
--- a/kode/statemachine.cpp
+++ b/kode/statemachine.cpp
@@ -28,14 +28,14 @@ StateMachine::StateMachine()
 }
 
 
-void StateMachine::setState( const QString &state, const Code &code )
+void StateMachine::setState( const TQString &state, const Code &code )
 {
   mStateMap.insert( state, code );
 
   if ( mInitialState.isEmpty() ) mInitialState = state;
 }
 
-void StateMachine::setInitialState( const QString &state )
+void StateMachine::setInitialState( const TQString &state )
 {
   mInitialState = state;
 }
@@ -44,8 +44,8 @@ Code StateMachine::stateDefinition()
 {
   Code code;
   
-  QStringList states;  
-  QMap<QString,Code>::ConstIterator it;
+  TQStringList states;  
+  TQMap<TQString,Code>::ConstIterator it;
   for ( it = mStateMap.begin(); it != mStateMap.end(); ++it ) {
     states.append( it.key() );
   }
@@ -63,7 +63,7 @@ Code StateMachine::transitionLogic()
   code += "switch( state ) {";
   code.indent();
 
-  QMap<QString,Code>::ConstIterator it;
+  TQMap<TQString,Code>::ConstIterator it;
   for ( it = mStateMap.begin(); it != mStateMap.end(); ++it ) {
     code += "case " + it.key() + ":";
     code.indent();
diff --git a/kode/statemachine.h b/kode/statemachine.h
index 0adcd5548..e6593c942 100644
--- a/kode/statemachine.h
+++ b/kode/statemachine.h
@@ -23,8 +23,8 @@
 
 #include "code.h"
 
-#include <qstring.h>
-#include <qmap.h>
+#include <tqstring.h>
+#include <tqmap.h>
 #include <kdepimmacros.h>
 
 namespace KODE {
@@ -34,17 +34,17 @@ class KDE_EXPORT StateMachine
   public:
     StateMachine();
   
-    void setState( const QString &state, const Code &code );
+    void setState( const TQString &state, const Code &code );
 
-    void setInitialState( const QString &state );
+    void setInitialState( const TQString &state );
 
     Code stateDefinition();
     Code transitionLogic();
 
   private:
-    QMap<QString,Code> mStateMap;
+    TQMap<TQString,Code> mStateMap;
 
-    QString mInitialState;
+    TQString mInitialState;
 };
 
 }
diff --git a/kode/style.cpp b/kode/style.cpp
index c7d20f4ca..8f4d255bd 100644
--- a/kode/style.cpp
+++ b/kode/style.cpp
@@ -23,8 +23,8 @@
 
 #include <kdebug.h>
 
-#include <qfile.h>
-#include <qtextstream.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
 
 using namespace KODE;
 
@@ -36,18 +36,18 @@ Style::~Style()
 {
 }
 
-QString Style::className( const QString &str )
+TQString Style::className( const TQString &str )
 {
   return upperFirst( str );
 }
 
-QString Style::upperFirst( const QString &str )
+TQString Style::upperFirst( const TQString &str )
 {
   if ( str.isEmpty() ) return str;
   return str[ 0 ].upper() + str.mid( 1 );
 }
 
-QString Style::lowerFirst( const QString &str )
+TQString Style::lowerFirst( const TQString &str )
 {
   if ( str.isEmpty() ) return str;
   return str[ 0 ].lower() + str.mid( 1 );
diff --git a/kode/style.h b/kode/style.h
index f88c107b4..f8a260221 100644
--- a/kode/style.h
+++ b/kode/style.h
@@ -23,9 +23,9 @@
 
 #include "license.h"
 
-#include <qvaluelist.h>
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 
 #include <kdepimmacros.h>
 
@@ -37,10 +37,10 @@ class KDE_EXPORT Style
     Style();
     virtual ~Style();
 
-    virtual QString className( const QString &str );
+    virtual TQString className( const TQString &str );
 
-    static QString upperFirst( const QString &str );
-    static QString lowerFirst( const QString &str );
+    static TQString upperFirst( const TQString &str );
+    static TQString lowerFirst( const TQString &str );
 };
 
 }
diff --git a/kode/typedef.cpp b/kode/typedef.cpp
index 10b2df46b..d8ccb0594 100644
--- a/kode/typedef.cpp
+++ b/kode/typedef.cpp
@@ -27,12 +27,12 @@ Typedef::Typedef()
 {
 }
 
-Typedef::Typedef( const QString &type, const QString &alias )
+Typedef::Typedef( const TQString &type, const TQString &alias )
   : mType( type ), mAlias( alias )
 {
 }
 
-QString Typedef::declaration() const
+TQString Typedef::declaration() const
 {
   return "typedef " + mType + " " + mAlias + ";";
 }
diff --git a/kode/typedef.h b/kode/typedef.h
index 59f129c9d..860d0081d 100644
--- a/kode/typedef.h
+++ b/kode/typedef.h
@@ -21,7 +21,7 @@
 #ifndef KODE_TYPEDEF_H
 #define KODE_TYPEDEF_H
 
-#include <qvaluelist.h>
+#include <tqvaluelist.h>
 #include <kdepimmacros.h>
 
 namespace KODE {
@@ -29,16 +29,16 @@ namespace KODE {
 class KDE_EXPORT Typedef
 {
   public:
-    typedef QValueList<Typedef> List;
+    typedef TQValueList<Typedef> List;
   
     Typedef();
-    Typedef( const QString &type, const QString &alias );
+    Typedef( const TQString &type, const TQString &alias );
     
-    QString declaration() const;
+    TQString declaration() const;
 
   private:
-    QString mType;
-    QString mAlias;
+    TQString mType;
+    TQString mAlias;
 };
 
 }
diff --git a/kode/variable.cpp b/kode/variable.cpp
index f56b351e0..9fa985ab2 100644
--- a/kode/variable.cpp
+++ b/kode/variable.cpp
@@ -30,7 +30,7 @@ Variable::Variable()
 {
 }
 
-Variable::Variable( const QString &name, const QString &type, bool isStatic )
+Variable::Variable( const TQString &name, const TQString &type, bool isStatic )
   : mIsStatic( isStatic )
 {
   mType = type;
@@ -42,12 +42,12 @@ Variable::Variable( const QString &name, const QString &type, bool isStatic )
   }
 }
 
-void Variable::setName( const QString &n )
+void Variable::setName( const TQString &n )
 {
   mName = n;
 }
 
-void Variable::setType( const QString &t )
+void Variable::setType( const TQString &t )
 {
   mType = t;
 }
@@ -57,7 +57,7 @@ void Variable::setStatic( bool s )
   mIsStatic = s;
 }
 
-void Variable::setInitializer( const QString &i )
+void Variable::setInitializer( const TQString &i )
 {
   mInitializer = i;
 }
diff --git a/kode/variable.h b/kode/variable.h
index 21c315c19..4cc66aa5a 100644
--- a/kode/variable.h
+++ b/kode/variable.h
@@ -21,8 +21,8 @@
 #ifndef KODE_VARIABLE_H
 #define KODE_VARIABLE_H
 
-#include <qvaluelist.h>
-#include <qstring.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
 
 #include <kdepimmacros.h>
 
@@ -31,28 +31,28 @@ namespace KODE {
 class KDE_EXPORT Variable
 {
   public:
-    typedef QValueList<Variable> List;
+    typedef TQValueList<Variable> List;
 
     Variable();
-    Variable( const QString &name, const QString &type, bool isStatic = false );
+    Variable( const TQString &name, const TQString &type, bool isStatic = false );
 
-    void setType( const QString & );
-    QString type() const { return mType; }
+    void setType( const TQString & );
+    TQString type() const { return mType; }
 
-    void setName( const QString & );
-    QString name() const { return mName; }
+    void setName( const TQString & );
+    TQString name() const { return mName; }
 
     void setStatic( bool );
     bool isStatic() const { return mIsStatic; }
 
-    void setInitializer( const QString & );
-    QString initializer() const { return mInitializer; }
+    void setInitializer( const TQString & );
+    TQString initializer() const { return mInitializer; }
 
   private:
-    QString mType;
-    QString mName;
+    TQString mType;
+    TQString mName;
     bool mIsStatic;
-    QString mInitializer;
+    TQString mInitializer;
 };
 
 }