Trinity Qt initial conversion

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

34 files changed, 294 insertions, 294 deletions

diff --git a/certmanager/lib/kleo/cryptobackend.h b/certmanager/lib/kleo/cryptobackend.h
index a94e1ae3a..a004fc899 100644
--- a/certmanager/lib/kleo/cryptobackend.h
+++ b/certmanager/lib/kleo/cryptobackend.h
@@ -33,7 +33,7 @@
 #ifndef __KLEO_CRYPTOBACKEND_H__
 #define __KLEO_CRYPTOBACKEND_H__
 
-#include <qstring.h>
+#include <tqstring.h>
 
 namespace Kleo {
   class CryptoConfig;
@@ -69,12 +69,12 @@ namespace Kleo {
 
     virtual ~CryptoBackend() {}
 
-    virtual QString name() const = 0;
-    virtual QString displayName() const = 0;
+    virtual TQString name() const = 0;
+    virtual TQString displayName() const = 0;
 
-    virtual bool checkForOpenPGP( QString * reason=0 ) const = 0;
-    virtual bool checkForSMIME( QString * reason=0 ) const = 0;
-    virtual bool checkForProtocol( const char * name,  QString * reason=0 ) const = 0;
+    virtual bool checkForOpenPGP( TQString * reason=0 ) const = 0;
+    virtual bool checkForSMIME( TQString * reason=0 ) const = 0;
+    virtual bool checkForProtocol( const char * name,  TQString * reason=0 ) const = 0;
 
     virtual bool supportsOpenPGP() const = 0;
     virtual bool supportsSMIME() const = 0;
@@ -93,9 +93,9 @@ namespace Kleo {
   public:
     virtual ~Protocol() {}
 
-    virtual QString name() const = 0;
+    virtual TQString name() const = 0;
 
-    virtual QString displayName() const = 0;
+    virtual TQString displayName() const = 0;
 
     virtual KeyListJob        * keyListJob( bool remote=false, bool includeSigs=false, bool validate=false ) const = 0;
     virtual EncryptJob        * encryptJob( bool armor=false, bool textmode=false ) const = 0;
@@ -107,14 +107,14 @@ namespace Kleo {
     virtual ImportJob         * importJob() const = 0;
     virtual ExportJob         * publicKeyExportJob( bool armor=false ) const = 0;
     // @param charset the encoding of the passphrase in the exported file
-    virtual ExportJob         * secretKeyExportJob( bool armor=false, const QString& charset = QString::null ) const = 0;
+    virtual ExportJob         * secretKeyExportJob( bool armor=false, const TQString& charset = TQString::null ) const = 0;
     virtual DownloadJob       * downloadJob( bool armor=false ) const = 0;
     virtual DeleteJob         * deleteJob() const = 0;
     virtual SignEncryptJob    * signEncryptJob( bool armor=false, bool textMode=false ) const = 0;
     virtual DecryptVerifyJob  * decryptVerifyJob( bool textmode=false ) const = 0;
     virtual RefreshKeysJob    * refreshKeysJob() const = 0;
 
-    virtual SpecialJob        * specialJob( const char * type, const QMap<QString,QVariant> & args ) const = 0;
+    virtual SpecialJob        * specialJob( const char * type, const TQMap<TQString,TQVariant> & args ) const = 0;
   };
 
 }
diff --git a/certmanager/lib/kleo/cryptobackendfactory.cpp b/certmanager/lib/kleo/cryptobackendfactory.cpp
index c56a7096f..88ba036de 100644
--- a/certmanager/lib/kleo/cryptobackendfactory.cpp
+++ b/certmanager/lib/kleo/cryptobackendfactory.cpp
@@ -66,7 +66,7 @@ static const char * availableProtocols[] = {
 static const unsigned int numAvailableProtocols = sizeof availableProtocols / sizeof *availableProtocols;
 
 Kleo::CryptoBackendFactory::CryptoBackendFactory()
-  : QObject( qApp, "CryptoBackendFactory::instance()" ),
+  : TQObject( qApp, "CryptoBackendFactory::instance()" ),
     mConfigObject( 0 ),
     mAvailableProtocols( availableProtocols, availableProtocols + numAvailableProtocols )
 {
@@ -146,11 +146,11 @@ bool Kleo::CryptoBackendFactory::hasBackends() const {
   return !mBackendList.empty();
 }
 
-void Kleo::CryptoBackendFactory::scanForBackends( QStringList * reasons ) {
+void Kleo::CryptoBackendFactory::scanForBackends( TQStringList * reasons ) {
   for ( std::vector<CryptoBackend*>::const_iterator it = mBackendList.begin() ; it != mBackendList.end() ; ++it ) {
     assert( *it );
     for ( int i = 0 ; const char * protocol = (*it)->enumerateProtocols( i ) ; ++i ) {
-      QString reason;
+      TQString reason;
       if ( (*it)->supportsProtocol( protocol ) && !(*it)->checkForProtocol( protocol, &reason ) ) {
         if ( reasons ) {
           reasons->push_back( i18n("While scanning for %1 support in backend %2:")
@@ -166,7 +166,7 @@ const Kleo::CryptoBackend * Kleo::CryptoBackendFactory::backend( unsigned int id
   return ( idx < mBackendList.size() ) ? mBackendList[idx] : 0 ;
 }
 
-const Kleo::CryptoBackend * Kleo::CryptoBackendFactory::backendByName( const QString& name ) const {
+const Kleo::CryptoBackend * Kleo::CryptoBackendFactory::backendByName( const TQString& name ) const {
   for ( std::vector<CryptoBackend*>::const_iterator it = mBackendList.begin() ; it != mBackendList.end() ; ++it ) {
     if ( (*it)->name() == name )
       return *it;
@@ -174,7 +174,7 @@ const Kleo::CryptoBackend * Kleo::CryptoBackendFactory::backendByName( const QSt
   return 0;
 }
 
-Kleo::BackendConfigWidget * Kleo::CryptoBackendFactory::configWidget( QWidget * parent, const char * name ) const {
+Kleo::BackendConfigWidget * Kleo::CryptoBackendFactory::configWidget( TQWidget * parent, const char * name ) const {
   return new Kleo::BackendConfigWidget( mSelf, parent, name );
 }
 
@@ -194,7 +194,7 @@ void Kleo::CryptoBackendFactory::setOpenPGPBackend( const CryptoBackend* backend
 }
 
 void Kleo::CryptoBackendFactory::setProtocolBackend( const char * protocol, const CryptoBackend * backend ) {
-  const QString name = backend ? backend->name() : QString::null ;
+  const TQString name = backend ? backend->name() : TQString::null ;
   KConfigGroup group( configObject(), "Backends" );
   group.writeEntry( protocol, name );
   configObject()->sync();
@@ -220,7 +220,7 @@ void Kleo::CryptoBackendFactory::readConfig() {
   mBackends.clear();
   const KConfigGroup group( configObject(), "Backends" );
   for ( ProtocolSet::const_iterator it = mAvailableProtocols.begin(), end = mAvailableProtocols.end() ; it != end ; ++it ) {
-    const QString backend = group.readEntry( *it, defaultBackend( *it ) );
+    const TQString backend = group.readEntry( *it, defaultBackend( *it ) );
     mBackends[*it] = backendByName( backend );
   }
 }
diff --git a/certmanager/lib/kleo/cryptobackendfactory.h b/certmanager/lib/kleo/cryptobackendfactory.h
index 7a54e9fd1..09136f7e3 100644
--- a/certmanager/lib/kleo/cryptobackendfactory.h
+++ b/certmanager/lib/kleo/cryptobackendfactory.h
@@ -33,7 +33,7 @@
 #ifndef __KLEO_CRYPTOBACKENDFACTORY_H__
 #define __KLEO_CRYPTOBACKENDFACTORY_H__
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #include "cryptobackend.h"
 #include <kdepimmacros.h>
@@ -56,7 +56,7 @@ namespace Kleo {
     }
   };
 
-  class KDE_EXPORT CryptoBackendFactory : public QObject {
+  class KDE_EXPORT CryptoBackendFactory : public TQObject {
     Q_OBJECT
   protected:
     CryptoBackendFactory();
@@ -73,7 +73,7 @@ namespace Kleo {
 
     bool hasBackends() const;
 
-    Kleo::BackendConfigWidget * configWidget( QWidget * parent=0, const char * name=0 ) const;
+    Kleo::BackendConfigWidget * configWidget( TQWidget * parent=0, const char * name=0 ) const;
 
     KConfig* configObject() const;
 
@@ -88,7 +88,7 @@ namespace Kleo {
     void setOpenPGPBackend( const CryptoBackend* backend );
     void setProtocolBackend( const char * name, const CryptoBackend * backend );
 
-    void scanForBackends( QStringList * reasons=0 );
+    void scanForBackends( TQStringList * reasons=0 );
 
     const char * enumerateProtocols( int i ) const;
 
@@ -103,7 +103,7 @@ namespace Kleo {
     ProtocolSet mAvailableProtocols;
 
   private:
-    const CryptoBackend * backendByName( const QString& name ) const;
+    const CryptoBackend * backendByName( const TQString& name ) const;
     void readConfig();
     CryptoBackendFactory( const CryptoBackendFactory & );
     void operator=( const CryptoBackendFactory & );
diff --git a/certmanager/lib/kleo/cryptoconfig.h b/certmanager/lib/kleo/cryptoconfig.h
index da16ca5b5..ec0a0ed5d 100644
--- a/certmanager/lib/kleo/cryptoconfig.h
+++ b/certmanager/lib/kleo/cryptoconfig.h
@@ -91,12 +91,12 @@ namespace Kleo {
     /**
      * Return the internal name of this entry
      */
-    virtual QString name() const = 0;
+    virtual TQString name() const = 0;
 
     /**
      * @return user-visible description of this entry
      */
-    virtual QString description() const = 0;
+    virtual TQString description() const = 0;
 
     /**
      * @return true if the argument is optional
@@ -142,7 +142,7 @@ namespace Kleo {
      * Return value as a string (available for all argtypes)
      * The returned string can be empty (explicitely set to empty) or null (not set).
      */
-    virtual QString stringValue() const = 0;
+    virtual TQString stringValue() const = 0;
 
     /**
      * Return value as a signed int
@@ -167,17 +167,17 @@ namespace Kleo {
     /**
      * Return value as a list of strings (mostly meaningful for String, Path and URL argtypes, if isList())
      */
-    virtual QStringList stringValueList() const = 0;
+    virtual TQStringList stringValueList() const = 0;
 
     /**
      * Return value as a list of signed ints
      */
-    virtual QValueList<int> intValueList() const = 0;
+    virtual TQValueList<int> intValueList() const = 0;
 
     /**
      * Return value as a list of unsigned ints
      */
-    virtual QValueList<unsigned int> uintValueList() const = 0;
+    virtual TQValueList<unsigned int> uintValueList() const = 0;
 
     /**
      * Return value as a list of URLs (only meaningful for Path and URL argtypes, if isList())
@@ -198,7 +198,7 @@ namespace Kleo {
     /**
      * Set string value (allowed for all argtypes)
      */
-    virtual void setStringValue( const QString& ) = 0;
+    virtual void setStringValue( const TQString& ) = 0;
 
     /**
      * Set a new signed int value
@@ -223,17 +223,17 @@ namespace Kleo {
     /**
      * Set a new string-list value (only allowed for String, Path and URL argtypes, if isList())
      */
-    virtual void setStringValueList( const QStringList& ) = 0;
+    virtual void setStringValueList( const TQStringList& ) = 0;
 
     /**
      * Set a new list of signed int values
      */
-    virtual void setIntValueList( const QValueList<int>& ) = 0;
+    virtual void setIntValueList( const TQValueList<int>& ) = 0;
 
     /**
      * Set a new list of unsigned int values
      */
-    virtual void setUIntValueList( const QValueList<unsigned int>& ) = 0;
+    virtual void setUIntValueList( const TQValueList<unsigned int>& ) = 0;
 
     /**
      * Set value as a URL list (only meaningful for Path (if all URLs are local) and URL argtypes, if isList())
@@ -257,17 +257,17 @@ namespace Kleo {
     /**
      * Return the internal name of this group
      */
-    virtual QString name() const = 0;
+    virtual TQString name() const = 0;
 
     /**
      * Return the name of the icon for this group
      */
-    virtual QString iconName() const = 0;
+    virtual TQString iconName() const = 0;
 
     /**
      * @return user-visible description of this group
      */
-    virtual QString description() const = 0;
+    virtual TQString description() const = 0;
 
     /**
      * User level
@@ -279,14 +279,14 @@ namespace Kleo {
      *
      * @return list of group entry names.
      **/
-    virtual QStringList entryList() const = 0;
+    virtual TQStringList entryList() const = 0;
 
     /**
      * @return the configuration object for a given entry in this group
      * The object is owned by CryptoConfigGroup, don't delete it.
      * Groups cannot be nested, so all entries returned here are pure entries, no groups.
      */
-    virtual CryptoConfigEntry* entry( const QString& name ) const = 0;
+    virtual CryptoConfigEntry* entry( const TQString& name ) const = 0;
   };
 
   /**
@@ -300,17 +300,17 @@ namespace Kleo {
     /**
      * Return the internal name of this component
      */
-    virtual QString name() const = 0;
+    virtual TQString name() const = 0;
 
     /**
      * Return the name of the icon for this component
      */
-    virtual QString iconName() const = 0;
+    virtual TQString iconName() const = 0;
 
     /**
      * Return user-visible description of this component
      */
-    virtual QString description() const = 0;
+    virtual TQString description() const = 0;
 
     /**
      * Returns the list of groups that are known about.
@@ -318,13 +318,13 @@ namespace Kleo {
      * @return list of group names. One of them can be "<nogroup>", which is the group where all
      * "toplevel" options (belonging to no group) are.
      */
-    virtual QStringList groupList() const = 0;
+    virtual TQStringList groupList() const = 0;
 
     /**
      * @return the configuration object for a given group
      * The object is owned by CryptoConfigComponent, don't delete it.
      */
-    virtual CryptoConfigGroup* group( const QString& name ) const = 0;
+    virtual CryptoConfigGroup* group( const TQString& name ) const = 0;
 
   };
 
@@ -341,13 +341,13 @@ namespace Kleo {
      * Use @ref component() to retrieve more information about each one.
      * @return list of component names.
      **/
-    virtual QStringList componentList() const = 0;
+    virtual TQStringList componentList() const = 0;
 
     /**
      * @return the configuration object for a given component
      * The object is owned by CryptoConfig, don't delete it.
      */
-    virtual CryptoConfigComponent* component( const QString& name ) const = 0;
+    virtual CryptoConfigComponent* component( const TQString& name ) const = 0;
 
     /**
      * Convenience method to get hold of a single configuration entry when
@@ -357,7 +357,7 @@ namespace Kleo {
      * @return the configuration object for a single configuration entry, 0 if not found.
      * The object is owned by CryptoConfig, don't delete it.
      */
-    CryptoConfigEntry* entry( const QString& componentName, const QString& groupName, const QString& entryName ) const {
+    CryptoConfigEntry* entry( const TQString& componentName, const TQString& groupName, const TQString& entryName ) const {
       const Kleo::CryptoConfigComponent* comp = component( componentName );
       const Kleo::CryptoConfigGroup* group = comp ? comp->group( groupName ) : 0;
       return group ? group->entry( entryName ) : 0;
diff --git a/certmanager/lib/kleo/decryptjob.h b/certmanager/lib/kleo/decryptjob.h
index e882152a0..8351a1ff6 100644
--- a/certmanager/lib/kleo/decryptjob.h
+++ b/certmanager/lib/kleo/decryptjob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 namespace GpgME {
   class Error;
@@ -54,15 +54,15 @@ namespace Kleo {
      signals to suitable slots and then start the decryption with a
      call to start(). This call might fail, in which case the
      DecryptJob instance will have scheduled it's own destruction with
-     a call to QObject::deleteLater().
+     a call to TQObject::deleteLater().
 
      After result() is emitted, the DecryptJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class DecryptJob : public Job {
     Q_OBJECT
   protected:
-    DecryptJob( QObject * parent, const char * name );
+    DecryptJob( TQObject * parent, const char * name );
   public:
     ~DecryptJob();
 
@@ -70,13 +70,13 @@ namespace Kleo {
        Starts the decryption operation. \a cipherText is the data to
        decrypt.
     */
-    virtual GpgME::Error start( const QByteArray & cipherText ) = 0;
+    virtual GpgME::Error start( const TQByteArray & cipherText ) = 0;
 
-    virtual GpgME::DecryptionResult exec( const QByteArray & cipherText,
-					  QByteArray & plainText ) = 0;
+    virtual GpgME::DecryptionResult exec( const TQByteArray & cipherText,
+					  TQByteArray & plainText ) = 0;
 
   signals:
-    void result( const GpgME::DecryptionResult & result, const QByteArray & plainText );
+    void result( const GpgME::DecryptionResult & result, const TQByteArray & plainText );
   };
 
 }
diff --git a/certmanager/lib/kleo/decryptverifyjob.h b/certmanager/lib/kleo/decryptverifyjob.h
index f7cdb81a1..e220670c6 100644
--- a/certmanager/lib/kleo/decryptverifyjob.h
+++ b/certmanager/lib/kleo/decryptverifyjob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 #include <utility>
 
@@ -57,15 +57,15 @@ namespace Kleo {
      signals to suitable slots and then start the operation with a
      call to start(). This call might fail, in which case the
      DecryptVerifyJob instance will have scheduled it's own destruction with
-     a call to QObject::deleteLater().
+     a call to TQObject::deleteLater().
 
      After result() is emitted, the DecryptVerifyJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class DecryptVerifyJob : public Job {
     Q_OBJECT
   protected:
-    DecryptVerifyJob( QObject * parent, const char * name );
+    DecryptVerifyJob( TQObject * parent, const char * name );
   public:
     ~DecryptVerifyJob();
 
@@ -73,16 +73,16 @@ namespace Kleo {
        Starts the combined decryption and verification operation.
        \a cipherText is the data to decrypt and later verify.
     */
-    virtual GpgME::Error start( const QByteArray & cipherText ) = 0;
+    virtual GpgME::Error start( const TQByteArray & cipherText ) = 0;
 
     /** Synchronous equivalent of start() */
     virtual std::pair<GpgME::DecryptionResult,GpgME::VerificationResult>
-      exec( const QByteArray & cipherText, QByteArray & plainText ) = 0;
+      exec( const TQByteArray & cipherText, TQByteArray & plainText ) = 0;
 
   signals:
     void result( const GpgME::DecryptionResult & decryptionresult,
 		 const GpgME::VerificationResult & verificationresult,
-		 const QByteArray & plainText );
+		 const TQByteArray & plainText );
   };
 
 }
diff --git a/certmanager/lib/kleo/deletejob.h b/certmanager/lib/kleo/deletejob.h
index fd70ec513..f5d5f111b 100644
--- a/certmanager/lib/kleo/deletejob.h
+++ b/certmanager/lib/kleo/deletejob.h
@@ -50,15 +50,15 @@ namespace Kleo {
      signals to suitable slots and then start the delete with a call
      to start(). This call might fail, in which case the DeleteJob
      instance will have scheduled it's own destruction with a call to
-     QObject::deleteLater().
+     TQObject::deleteLater().
 
      After result() is emitted, the DeleteJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class DeleteJob : public Job {
     Q_OBJECT
   protected:
-    DeleteJob( QObject * parent, const char * name );
+    DeleteJob( TQObject * parent, const char * name );
   public:
     ~DeleteJob();
 
diff --git a/certmanager/lib/kleo/dn.cpp b/certmanager/lib/kleo/dn.cpp
index 9ba2209fb..61693aff2 100644
--- a/certmanager/lib/kleo/dn.cpp
+++ b/certmanager/lib/kleo/dn.cpp
@@ -43,8 +43,8 @@
 #include <kconfig.h>
 #include <klocale.h>
 
-#include <qstringlist.h>
-#include <qvaluevector.h>
+#include <tqstringlist.h>
+#include <tqvaluevector.h>
 
 #include <iostream>
 #include <iterator>
@@ -230,9 +230,9 @@ parse_dn_part (DnPair *array, const unsigned char *string)
 static Kleo::DN::Attribute::List
 parse_dn( const unsigned char * string ) {
   if ( !string )
-    return QValueVector<Kleo::DN::Attribute>();
+    return TQValueVector<Kleo::DN::Attribute>();
 
-  QValueVector<Kleo::DN::Attribute> result;
+  TQValueVector<Kleo::DN::Attribute> result;
   while (*string)
     {
       while (*string == ' ')
@@ -245,8 +245,8 @@ parse_dn( const unsigned char * string ) {
       if (!string)
 	goto failure;
       if ( pair.key && pair.value )
-	result.push_back( Kleo::DN::Attribute( QString::fromUtf8( pair.key ),
-					       QString::fromUtf8( pair.value ) ) );
+	result.push_back( Kleo::DN::Attribute( TQString::fromUtf8( pair.key ),
+					       TQString::fromUtf8( pair.value ) ) );
       free( pair.key );
       free( pair.value );
 
@@ -260,18 +260,18 @@ parse_dn( const unsigned char * string ) {
   return result;
 
 failure:
-  return QValueVector<Kleo::DN::Attribute>();
+  return TQValueVector<Kleo::DN::Attribute>();
 }
 
-static QValueVector<Kleo::DN::Attribute>
-parse_dn( const QString & dn ) {
+static TQValueVector<Kleo::DN::Attribute>
+parse_dn( const TQString & dn ) {
   return parse_dn( (const unsigned char*)dn.utf8().data() );
 }
 
-static QString dn_escape( const QString & s ) {
-    QString result;
+static TQString dn_escape( const TQString & s ) {
+    TQString result;
     for ( unsigned int i = 0, end = s.length() ; i != end ; ++i ) {
-        const QChar ch = s[i];
+        const TQChar ch = s[i];
         switch ( ch.unicode() ) {
         case ',':
         case '+':
@@ -290,9 +290,9 @@ static QString dn_escape( const QString & s ) {
 }
 
 static QString
-serialise( const QValueVector<Kleo::DN::Attribute> & dn ) {
-  QStringList result;
-  for ( QValueVector<Kleo::DN::Attribute>::const_iterator it = dn.begin() ; it != dn.end() ; ++it )
+serialise( const TQValueVector<Kleo::DN::Attribute> & dn ) {
+  TQStringList result;
+  for ( TQValueVector<Kleo::DN::Attribute>::const_iterator it = dn.begin() ; it != dn.end() ; ++it )
     if ( !(*it).name().isEmpty() && !(*it).value().isEmpty() )
       result.push_back( (*it).name().stripWhiteSpace() + '=' + dn_escape( (*it).value().stripWhiteSpace() ) );
   return result.join( "," );
@@ -300,7 +300,7 @@ serialise( const QValueVector<Kleo::DN::Attribute> & dn ) {
 
 static Kleo::DN::Attribute::List
 reorder_dn( const Kleo::DN::Attribute::List & dn ) {
-  const QStringList & attrOrder = Kleo::DNAttributeMapper::instance()->attributeOrder();
+  const TQStringList & attrOrder = Kleo::DNAttributeMapper::instance()->attributeOrder();
 
   Kleo::DN::Attribute::List unknownEntries;
   Kleo::DN::Attribute::List result;
@@ -313,7 +313,7 @@ reorder_dn( const Kleo::DN::Attribute::List & dn ) {
       unknownEntries.push_back( *it );
 
   // process the known attrs in the desired order
-  for ( QStringList::const_iterator oit = attrOrder.begin() ; oit != attrOrder.end() ; ++oit )
+  for ( TQStringList::const_iterator oit = attrOrder.begin() ; oit != attrOrder.end() ; ++oit )
     if ( *oit == "_X_" ) {
       // insert the unknown attrs
       std::copy( unknownEntries.begin(), unknownEntries.end(),
@@ -339,7 +339,7 @@ Kleo::DN::DN() {
   d->ref();
 }
 
-Kleo::DN::DN( const QString & dn ) {
+Kleo::DN::DN( const TQString & dn ) {
   d = new Private();
   d->ref();
   d->attributes = parse_dn( dn );
@@ -376,20 +376,20 @@ const Kleo::DN & Kleo::DN::operator=( const DN & that ) {
   return *this;
 }
 
-QString Kleo::DN::prettyDN() const {
+TQString Kleo::DN::prettyDN() const {
   if ( !d )
-    return QString::null;
+    return TQString::null;
   if ( d->reorderedAttributes.empty() )
     d->reorderedAttributes = reorder_dn( d->attributes );
   return serialise( d->reorderedAttributes );
 }
 
-QString Kleo::DN::dn() const {
-  return d ? serialise( d->attributes ) : QString::null ;
+TQString Kleo::DN::dn() const {
+  return d ? serialise( d->attributes ) : TQString::null ;
 }
 
 // static
-QString Kleo::DN::escape( const QString & value ) {
+TQString Kleo::DN::escape( const TQString & value ) {
     return dn_escape( value );
 }
 
@@ -411,18 +411,18 @@ void Kleo::DN::append( const Attribute & attr ) {
   d->reorderedAttributes.clear();
 }
 
-QString Kleo::DN::operator[]( const QString & attr ) const {
+TQString Kleo::DN::operator[]( const TQString & attr ) const {
   if ( !d )
-    return QString::null;
-  const QString attrUpper = attr.upper();
-  for ( QValueVector<Attribute>::const_iterator it = d->attributes.begin() ;
+    return TQString::null;
+  const TQString attrUpper = attr.upper();
+  for ( TQValueVector<Attribute>::const_iterator it = d->attributes.begin() ;
 	it != d->attributes.end() ; ++it )
     if ( (*it).name() == attrUpper )
       return (*it).value();
-  return QString::null;
+  return TQString::null;
 }
 
-static QValueVector<Kleo::DN::Attribute> empty;
+static TQValueVector<Kleo::DN::Attribute> empty;
 
 Kleo::DN::const_iterator Kleo::DN::begin() const {
   return d ? d->attributes.begin() : empty.begin() ;
@@ -476,7 +476,7 @@ class Kleo::DNAttributeMapper::Private {
 public:
   Private();
   std::map<const char*,const char*,ltstr> map;
-  QStringList attributeOrder;
+  TQStringList attributeOrder;
 };
 
 Kleo::DNAttributeMapper::Private::Private()
@@ -505,26 +505,26 @@ const Kleo::DNAttributeMapper * Kleo::DNAttributeMapper::instance() {
   return mSelf;
 }
 
-QString Kleo::DNAttributeMapper::name2label( const QString & s ) const {
+TQString Kleo::DNAttributeMapper::name2label( const TQString & s ) const {
   const std::map<const char*,const char*,ltstr>::const_iterator it
     = d->map.find( s.stripWhiteSpace().upper().latin1() );
   if ( it == d->map.end() )
-    return QString::null;
+    return TQString::null;
   return i18n( it->second );
 }
 
-QStringList Kleo::DNAttributeMapper::names() const {
-  QStringList result;
+TQStringList Kleo::DNAttributeMapper::names() const {
+  TQStringList result;
   for ( std::map<const char*,const char*,ltstr>::const_iterator it = d->map.begin() ; it != d->map.end() ; ++it )
     result.push_back( it->first );
   return result;
 }
 
-const QStringList & Kleo::DNAttributeMapper::attributeOrder() const {
+const TQStringList & Kleo::DNAttributeMapper::attributeOrder() const {
   return d->attributeOrder;
 }
 
-void Kleo::DNAttributeMapper::setAttributeOrder( const QStringList & order ) {
+void Kleo::DNAttributeMapper::setAttributeOrder( const TQStringList & order ) {
   d->attributeOrder = order;
   if ( order.empty() )
     std::copy( defaultOrder, defaultOrder + sizeof defaultOrder / sizeof *defaultOrder,
@@ -533,6 +533,6 @@ void Kleo::DNAttributeMapper::setAttributeOrder( const QStringList & order ) {
   config.writeEntry( "AttributeOrder", order );
 }
 
-Kleo::DNAttributeOrderConfigWidget * Kleo::DNAttributeMapper::configWidget( QWidget * parent, const char * name ) const {
+Kleo::DNAttributeOrderConfigWidget * Kleo::DNAttributeMapper::configWidget( TQWidget * parent, const char * name ) const {
   return new DNAttributeOrderConfigWidget( mSelf, parent, name );
 }
diff --git a/certmanager/lib/kleo/dn.h b/certmanager/lib/kleo/dn.h
index 12bf9dc03..440bb4b0b 100644
--- a/certmanager/lib/kleo/dn.h
+++ b/certmanager/lib/kleo/dn.h
@@ -33,8 +33,8 @@
 #ifndef __KLEO_DN_H__
 #define __KLEO_DN_H__
 
-#include <qstring.h>
-#include <qvaluevector.h>
+#include <tqstring.h>
+#include <tqvaluevector.h>
 #include <kdepimmacros.h>
 
 class QStringList;
@@ -55,14 +55,14 @@ namespace Kleo {
   public:
     static const DNAttributeMapper * instance();
 
-    QString name2label( const QString & s ) const;
-    QStringList names() const;
+    TQString name2label( const TQString & s ) const;
+    TQStringList names() const;
 
-    const QStringList & attributeOrder() const;
+    const TQStringList & attributeOrder() const;
 
-    void setAttributeOrder( const QStringList & order );
+    void setAttributeOrder( const TQStringList & order );
 
-    DNAttributeOrderConfigWidget * configWidget( QWidget * parent=0, const char * name=0 ) const;
+    DNAttributeOrderConfigWidget * configWidget( TQWidget * parent=0, const char * name=0 ) const;
 
   private:
     class Private;
@@ -76,11 +76,11 @@ namespace Kleo {
   class KDE_EXPORT DN  {
   public:
     class Attribute;
-    typedef QValueVector<Attribute> AttributeList;
+    typedef TQValueVector<Attribute> AttributeList;
     typedef AttributeList::const_iterator const_iterator;
 
     DN();
-    DN( const QString & dn );
+    DN( const TQString & dn );
     DN( const char * utf8DN );
     DN( const DN & other );
     ~DN();
@@ -88,15 +88,15 @@ namespace Kleo {
     const DN & operator=( const DN & other );
 
     /** @return the value in rfc-2253-escaped form */
-    static QString escape( const QString & value );
+    static TQString escape( const TQString & value );
 
     /** @return the DN in a reordered form, according to the settings in
 	the [DN] group of the application's config file */
-    QString prettyDN() const;
+    TQString prettyDN() const;
     /** @return the DN in the original form */
-    QString dn() const;
+    TQString dn() const;
 
-    QString operator[]( const QString & attr ) const;
+    TQString operator[]( const TQString & attr ) const;
 
     void append( const Attribute & attr );
 
@@ -114,7 +114,7 @@ namespace Kleo {
   public:
     typedef DN::AttributeList List;
 
-    Attribute( const QString & name=QString::null, const QString & value=QString::null )
+    Attribute( const TQString & name=TQString::null, const TQString & value=TQString::null )
       : mName( name.upper() ), mValue( value ) {}
     Attribute( const Attribute & other )
       : mName( other.name() ), mValue( other.value() ) {}
@@ -127,14 +127,14 @@ namespace Kleo {
       return *this;
     }
 
-    const QString & name() const { return mName; }
-    const QString & value() const { return mValue; }
+    const TQString & name() const { return mName; }
+    const TQString & value() const { return mValue; }
 
-    void setValue( const QString & value ) { mValue = value; }
+    void setValue( const TQString & value ) { mValue = value; }
     
   private:
-    QString mName;
-    QString mValue;
+    TQString mName;
+    TQString mValue;
   };
 
 }
diff --git a/certmanager/lib/kleo/downloadjob.h b/certmanager/lib/kleo/downloadjob.h
index 006ab8ebd..6fa5a3e4b 100644
--- a/certmanager/lib/kleo/downloadjob.h
+++ b/certmanager/lib/kleo/downloadjob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 namespace GpgME {
   class Error;
@@ -53,15 +53,15 @@ namespace Kleo {
      signals to suitable slots and then start the download with a call
      to start(). This call might fail, in which case the DownloadJob
      instance will have scheduled it's own destruction with a call to
-     QObject::deleteLater().
+     TQObject::deleteLater().
 
      After result() is emitted, the DownloadJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class DownloadJob : public Job {
     Q_OBJECT
   protected:
-    DownloadJob( QObject * parent, const char * name );
+    DownloadJob( TQObject * parent, const char * name );
   public:
     ~DownloadJob();
 
@@ -72,10 +72,10 @@ namespace Kleo {
        only empty strings or anything other than fingerprints, the
        result is undefined.
     */
-    virtual GpgME::Error start( const QStringList & fingerprints ) = 0;
+    virtual GpgME::Error start( const TQStringList & fingerprints ) = 0;
 
   signals:
-    void result( const GpgME::Error & result, const QByteArray & keyData );
+    void result( const GpgME::Error & result, const TQByteArray & keyData );
   };
 
 }
diff --git a/certmanager/lib/kleo/encryptjob.h b/certmanager/lib/kleo/encryptjob.h
index 02144656f..9c3b77df2 100644
--- a/certmanager/lib/kleo/encryptjob.h
+++ b/certmanager/lib/kleo/encryptjob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 #include <vector>
 
@@ -56,15 +56,15 @@ namespace Kleo {
      signals to suitable slots and then start the encryption with a
      call to start(). This call might fail, in which case the
      EncryptJob instance will have scheduled it's own destruction with
-     a call to QObject::deleteLater().
+     a call to TQObject::deleteLater().
 
      After result() is emitted, the EncryptJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class EncryptJob : public Job {
     Q_OBJECT
   protected:
-    EncryptJob( QObject * parent, const char * name );
+    EncryptJob( TQObject * parent, const char * name );
   public:
     ~EncryptJob();
 
@@ -77,14 +77,14 @@ namespace Kleo {
        without further checks.
     */
     virtual GpgME::Error start( const std::vector<GpgME::Key> & recipients,
-				const QByteArray & plainText, bool alwaysTrust=false ) = 0;
+				const TQByteArray & plainText, bool alwaysTrust=false ) = 0;
 
     virtual GpgME::EncryptionResult exec( const std::vector<GpgME::Key> & recipients,
-					  const QByteArray & plainText,
-					  bool alwaysTrust, QByteArray & cipherText ) = 0;
+					  const TQByteArray & plainText,
+					  bool alwaysTrust, TQByteArray & cipherText ) = 0;
 
   signals:
-    void result( const GpgME::EncryptionResult & result, const QByteArray & cipherText );
+    void result( const GpgME::EncryptionResult & result, const TQByteArray & cipherText );
   };
 
 }
diff --git a/certmanager/lib/kleo/enum.cpp b/certmanager/lib/kleo/enum.cpp
index efa4cfaa3..ca842807f 100644
--- a/certmanager/lib/kleo/enum.cpp
+++ b/certmanager/lib/kleo/enum.cpp
@@ -34,8 +34,8 @@
 
 #include <klocale.h>
 
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 
 static const struct {
   Kleo::CryptoMessageFormat format;
@@ -67,34 +67,34 @@ const char * Kleo::cryptoMessageFormatToString( Kleo::CryptoMessageFormat f ) {
   return 0;
 }
 
-QStringList Kleo::cryptoMessageFormatsToStringList( unsigned int f ) {
-  QStringList result;
+TQStringList Kleo::cryptoMessageFormatsToStringList( unsigned int f ) {
+  TQStringList result;
   for ( unsigned int i = 0 ; i < numCryptoMessageFormats ; ++i )
     if ( f & cryptoMessageFormats[i].format )
       result.push_back( cryptoMessageFormats[i].configName );
   return result;
 }
 
-QString Kleo::cryptoMessageFormatToLabel( Kleo::CryptoMessageFormat f ) {
+TQString Kleo::cryptoMessageFormatToLabel( Kleo::CryptoMessageFormat f ) {
   if ( f == AutoFormat )
     return i18n("Any");
   for ( unsigned int i = 0 ; i < numCryptoMessageFormats ; ++i )
     if ( f == cryptoMessageFormats[i].format )
       return i18n( cryptoMessageFormats[i].displayName );
-  return QString::null;
+  return TQString::null;
 }
 
-Kleo::CryptoMessageFormat Kleo::stringToCryptoMessageFormat( const QString & s ) {
-  const QString t = s.lower();
+Kleo::CryptoMessageFormat Kleo::stringToCryptoMessageFormat( const TQString & s ) {
+  const TQString t = s.lower();
   for ( unsigned int i = 0 ; i < numCryptoMessageFormats ; ++i )
     if ( t == cryptoMessageFormats[i].configName )
       return cryptoMessageFormats[i].format;
   return AutoFormat;
 }
 
-unsigned int Kleo::stringListToCryptoMessageFormats( const QStringList & sl ) {
+unsigned int Kleo::stringListToCryptoMessageFormats( const TQStringList & sl ) {
   unsigned int result = 0;
-  for ( QStringList::const_iterator it = sl.begin() ; it != sl.end() ; ++it )
+  for ( TQStringList::const_iterator it = sl.begin() ; it != sl.end() ; ++it )
     result |= stringToCryptoMessageFormat( *it );
   return result;
 }
@@ -120,7 +120,7 @@ const char* Kleo::encryptionPreferenceToString( EncryptionPreference pref )
   return 0; // keep the compiler happy
 }
 
-Kleo::EncryptionPreference Kleo::stringToEncryptionPreference( const QString& str )
+Kleo::EncryptionPreference Kleo::stringToEncryptionPreference( const TQString& str )
 {
   if ( str == "never" )
     return NeverEncrypt;
@@ -135,7 +135,7 @@ Kleo::EncryptionPreference Kleo::stringToEncryptionPreference( const QString& st
   return UnknownPreference;
 }
 
-QString Kleo::encryptionPreferenceToLabel( EncryptionPreference pref )
+TQString Kleo::encryptionPreferenceToLabel( EncryptionPreference pref )
 {
   switch( pref ) {
   case NeverEncrypt:
@@ -172,7 +172,7 @@ const char* Kleo::signingPreferenceToString( SigningPreference pref )
   return 0; // keep the compiler happy
 }
 
-Kleo::SigningPreference Kleo::stringToSigningPreference( const QString& str )
+Kleo::SigningPreference Kleo::stringToSigningPreference( const TQString& str )
 {
   if ( str == "never" )
     return NeverSign;
@@ -187,7 +187,7 @@ Kleo::SigningPreference Kleo::stringToSigningPreference( const QString& str )
   return UnknownSigningPreference;
 }
 
-QString Kleo::signingPreferenceToLabel( SigningPreference pref )
+TQString Kleo::signingPreferenceToLabel( SigningPreference pref )
 {
   switch( pref ) {
   case NeverSign:
diff --git a/certmanager/lib/kleo/enum.h b/certmanager/lib/kleo/enum.h
index 29f8e2a66..bf4a44a60 100644
--- a/certmanager/lib/kleo/enum.h
+++ b/certmanager/lib/kleo/enum.h
@@ -50,12 +50,12 @@ namespace Kleo {
     AutoFormat = AnyOpenPGP|AnySMIME
   };
 
-  KDE_EXPORT QString cryptoMessageFormatToLabel( CryptoMessageFormat f );
+  KDE_EXPORT TQString cryptoMessageFormatToLabel( CryptoMessageFormat f );
 
   KDE_EXPORT const char * cryptoMessageFormatToString( CryptoMessageFormat f );
-  KDE_EXPORT QStringList cryptoMessageFormatsToStringList( unsigned int f );
-  KDE_EXPORT CryptoMessageFormat stringToCryptoMessageFormat( const QString & s );
-  KDE_EXPORT unsigned int stringListToCryptoMessageFormats( const QStringList & sl );
+  KDE_EXPORT TQStringList cryptoMessageFormatsToStringList( unsigned int f );
+  KDE_EXPORT CryptoMessageFormat stringToCryptoMessageFormat( const TQString & s );
+  KDE_EXPORT unsigned int stringListToCryptoMessageFormats( const TQStringList & sl );
 
   enum Action {
     Conflict, DoIt, DontDoIt, Ask, AskOpportunistic, Impossible
@@ -71,9 +71,9 @@ namespace Kleo {
     MaxEncryptionPreference = AskWheneverPossible
   };
 
-  KDE_EXPORT QString encryptionPreferenceToLabel( EncryptionPreference pref );
+  KDE_EXPORT TQString encryptionPreferenceToLabel( EncryptionPreference pref );
   KDE_EXPORT const char* encryptionPreferenceToString( EncryptionPreference pref );
-  KDE_EXPORT EncryptionPreference stringToEncryptionPreference( const QString& str );
+  KDE_EXPORT EncryptionPreference stringToEncryptionPreference( const TQString& str );
 
   enum SigningPreference {
     UnknownSigningPreference = 0,
@@ -85,9 +85,9 @@ namespace Kleo {
     MaxSigningPreference = AskSigningWheneverPossible
   };
 
-  KDE_EXPORT QString signingPreferenceToLabel( SigningPreference pref ) KDE_EXPORT;
+  KDE_EXPORT TQString signingPreferenceToLabel( SigningPreference pref ) KDE_EXPORT;
   KDE_EXPORT const char* signingPreferenceToString( SigningPreference pref ) KDE_EXPORT;
-  KDE_EXPORT SigningPreference stringToSigningPreference( const QString& str );
+  KDE_EXPORT SigningPreference stringToSigningPreference( const TQString& str );
 }
 
 #endif // __KLEO_CRYPTOBACKEND_H__
diff --git a/certmanager/lib/kleo/exportjob.h b/certmanager/lib/kleo/exportjob.h
index d6a0db185..9e84c1351 100644
--- a/certmanager/lib/kleo/exportjob.h
+++ b/certmanager/lib/kleo/exportjob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 namespace GpgME {
   class Error;
@@ -53,15 +53,15 @@ namespace Kleo {
      signals to suitable slots and then start the export with a call
      to start(). This call might fail, in which case the ExportJob
      instance will have scheduled it's own destruction with a call to
-     QObject::deleteLater().
+     TQObject::deleteLater().
 
      After result() is emitted, the ExportJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class ExportJob : public Job {
     Q_OBJECT
   protected:
-    ExportJob( QObject * parent, const char * name );
+    ExportJob( TQObject * parent, const char * name );
   public:
     ~ExportJob();
 
@@ -71,10 +71,10 @@ namespace Kleo {
        ignored. If \a patterns is empty or contains only empty
        strings, all available keys are exported.
     */
-    virtual GpgME::Error start( const QStringList & patterns ) = 0;
+    virtual GpgME::Error start( const TQStringList & patterns ) = 0;
 
   signals:
-    void result( const GpgME::Error & result, const QByteArray & keyData );
+    void result( const GpgME::Error & result, const TQByteArray & keyData );
   };
 
 }
diff --git a/certmanager/lib/kleo/hierarchicalkeylistjob.cpp b/certmanager/lib/kleo/hierarchicalkeylistjob.cpp
index a7a66b2fe..c9a9ffcec 100644
--- a/certmanager/lib/kleo/hierarchicalkeylistjob.cpp
+++ b/certmanager/lib/kleo/hierarchicalkeylistjob.cpp
@@ -40,8 +40,8 @@
 
 #include <klocale.h>
 
-#include <qstringlist.h>
-#include <qtl.h>
+#include <tqstringlist.h>
+#include <tqtl.h>
 
 #include <gpgmepp/key.h>
 #include <gpgmepp/context.h>
@@ -72,7 +72,7 @@ Kleo::HierarchicalKeyListJob::~HierarchicalKeyListJob() {
 
 }
 
-GpgME::Error Kleo::HierarchicalKeyListJob::start( const QStringList & patterns, bool secretOnly ) {
+GpgME::Error Kleo::HierarchicalKeyListJob::start( const TQStringList & patterns, bool secretOnly ) {
   if ( secretOnly || patterns.empty() )
     return gpg_err_make( GPG_ERR_SOURCE_GPGME, GPG_ERR_UNSUPPORTED_OPERATION );
   qCopy( patterns.begin(), patterns.end(),
@@ -83,7 +83,7 @@ GpgME::Error Kleo::HierarchicalKeyListJob::start( const QStringList & patterns,
   return err;
 }
 
-GpgME::KeyListResult Kleo::HierarchicalKeyListJob::exec( const QStringList &, bool,
+GpgME::KeyListResult Kleo::HierarchicalKeyListJob::exec( const TQStringList &, bool,
 							 std::vector<GpgME::Key> & keys ) {
   keys.clear();
   return GpgME::KeyListResult( gpg_err_make( GPG_ERR_SOURCE_GPGME, GPG_ERR_UNSUPPORTED_OPERATION ) );
@@ -107,7 +107,7 @@ void Kleo::HierarchicalKeyListJob::slotCancel() {
 void Kleo::HierarchicalKeyListJob::slotResult( const GpgME::KeyListResult & res ) {
   mJob = 0;
   mIntermediateResult.mergeWith( res );
-  std::set<QString> tmp;
+  std::set<TQString> tmp;
   std::set_difference( mNextSet.begin(), mNextSet.end(),
 		       mScheduledSet.begin(), mScheduledSet.end(),
 		       std::inserter( tmp, tmp.begin() ) );
@@ -142,11 +142,11 @@ GpgME::Error Kleo::HierarchicalKeyListJob::startAJob() {
   assert( mJob ); // FIXME: we need a way to generate errors ourselves,
 		  // but I don't like the dependency on gpg-error :/
 
-  connect( mJob, SIGNAL(nextKey(const GpgME::Key&)), SLOT(slotNextKey(const GpgME::Key&)) );
-  connect( mJob, SIGNAL(result(const GpgME::KeyListResult&)), SLOT(slotResult(const GpgME::KeyListResult&)) );
+  connect( mJob, TQT_SIGNAL(nextKey(const GpgME::Key&)), TQT_SLOT(slotNextKey(const GpgME::Key&)) );
+  connect( mJob, TQT_SIGNAL(result(const GpgME::KeyListResult&)), TQT_SLOT(slotResult(const GpgME::KeyListResult&)) );
 
-  QStringList patterns;
-  for ( std::set<QString>::const_iterator it = mNextSet.begin() ; it != mNextSet.end() ; ++it )
+  TQStringList patterns;
+  for ( std::set<TQString>::const_iterator it = mNextSet.begin() ; it != mNextSet.end() ; ++it )
     patterns.push_back( *it );
 
   mScheduledSet.insert( mNextSet.begin(), mNextSet.end() );
diff --git a/certmanager/lib/kleo/hierarchicalkeylistjob.h b/certmanager/lib/kleo/hierarchicalkeylistjob.h
index a91ff6dc0..c4f7fe047 100644
--- a/certmanager/lib/kleo/hierarchicalkeylistjob.h
+++ b/certmanager/lib/kleo/hierarchicalkeylistjob.h
@@ -39,8 +39,8 @@
 
 #include <gpgmepp/keylistresult.h>
 
-#include <qcstring.h>
-#include <qguardedptr.h>
+#include <tqcstring.h>
+#include <tqguardedptr.h>
 
 #include <set>
 
@@ -63,10 +63,10 @@ namespace Kleo {
      suitable slots and then start the keylisting with a call to
      start(). This call might fail, in which case the
      HierarchicalKeyListJob instance will have scheduled it's own
-     destruction with a call to QObject::deleteLater().
+     destruction with a call to TQObject::deleteLater().
 
      After result() is emitted, the HierarchicalKeyListJob will
-     schedule its own destruction by calling QObject::deleteLater().
+     schedule its own destruction by calling TQObject::deleteLater().
   */
   class KDE_EXPORT HierarchicalKeyListJob : public KeyListJob {
     Q_OBJECT
@@ -84,9 +84,9 @@ namespace Kleo {
        The \a secretOnly parameter is ignored by
        HierarchicalKeyListJob and must be set to false.
     */
-    GpgME::Error start( const QStringList & patterns, bool secretOnly=false );
+    GpgME::Error start( const TQStringList & patterns, bool secretOnly=false );
 
-    GpgME::KeyListResult exec( const QStringList & patterns, bool secretOnly,
+    GpgME::KeyListResult exec( const TQStringList & patterns, bool secretOnly,
 			       std::vector<GpgME::Key> & keys );
 
   private slots:
@@ -104,11 +104,11 @@ namespace Kleo {
     const bool mIncludeSigs;
     const bool mValidating;
     bool mTruncated;
-    std::set<QString> mSentSet; // keys already sent (prevent duplicates even if the backend should return them)
-    std::set<QString> mScheduledSet; // keys already scheduled (by starting a job for them)
-    std::set<QString> mNextSet; // keys to schedule for the next iteraton
+    std::set<TQString> mSentSet; // keys already sent (prevent duplicates even if the backend should return them)
+    std::set<TQString> mScheduledSet; // keys already scheduled (by starting a job for them)
+    std::set<TQString> mNextSet; // keys to schedule for the next iteraton
     GpgME::KeyListResult mIntermediateResult;
-    QGuardedPtr<KeyListJob> mJob;
+    TQGuardedPtr<KeyListJob> mJob;
   };
 
 }
diff --git a/certmanager/lib/kleo/importjob.h b/certmanager/lib/kleo/importjob.h
index 10aa90383..9c446457f 100644
--- a/certmanager/lib/kleo/importjob.h
+++ b/certmanager/lib/kleo/importjob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 namespace GpgME {
   class Error;
@@ -54,15 +54,15 @@ namespace Kleo {
      signals to suitable slots and then start the import with a call
      to start(). This call might fail, in which case the ImportJob
      instance will have scheduled it's own destruction with a call to
-     QObject::deleteLater().
+     TQObject::deleteLater().
 
      After result() is emitted, the ImportJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class ImportJob : public Job {
     Q_OBJECT
   protected:
-    ImportJob( QObject * parent, const char * name );
+    ImportJob( TQObject * parent, const char * name );
   public:
     ~ImportJob();
 
@@ -70,9 +70,9 @@ namespace Kleo {
        Starts the importing operation. \a keyData contains the data to
        import from.
     */
-    virtual GpgME::Error start( const QByteArray & keyData ) = 0;
+    virtual GpgME::Error start( const TQByteArray & keyData ) = 0;
 
-    virtual GpgME::ImportResult exec( const QByteArray & keyData ) = 0;
+    virtual GpgME::ImportResult exec( const TQByteArray & keyData ) = 0;
 
   signals:
     void result( const GpgME::ImportResult & result );
diff --git a/certmanager/lib/kleo/job.cpp b/certmanager/lib/kleo/job.cpp
index 77881d737..c5371b646 100644
--- a/certmanager/lib/kleo/job.cpp
+++ b/certmanager/lib/kleo/job.cpp
@@ -52,31 +52,31 @@
 #include "refreshkeysjob.h"
 #include "specialjob.h"
 
-#include <qapplication.h>
+#include <tqapplication.h>
 #include <kdebug.h>
 
-Kleo::Job::Job( QObject * parent, const char * name )
-  : QObject( parent, name )
+Kleo::Job::Job( TQObject * parent, const char * name )
+  : TQObject( parent, name )
 {
   if ( qApp )
-    connect( qApp, SIGNAL(aboutToQuit()), SLOT(slotCancel()) );
+    connect( qApp, TQT_SIGNAL(aboutToQuit()), TQT_SLOT(slotCancel()) );
 }
 
 Kleo::Job::~Job() {
 
 }
 
-void Kleo::Job::showErrorDialog( QWidget *, const QString & ) const {
+void Kleo::Job::showErrorDialog( TQWidget *, const TQString & ) const {
   kdDebug() << "Kleo::Job::showErrorDialog() should be reimplemented in Kleo::Job subclasses!" << endl;
 }
 
-QString Kleo::Job::auditLogAsHtml() const {
+TQString Kleo::Job::auditLogAsHtml() const {
     kdDebug() << "Kleo::Job::auditLogAsHtml() should be reimplemented in Kleo::Job subclasses!" << endl;
-    return QString();
+    return TQString();
 }
 
 #define make_job_subclass(x) \
-  Kleo::x::x( QObject * parent, const char * name ) : Job( parent, name ) {} \
+  Kleo::x::x( TQObject * parent, const char * name ) : Job( parent, name ) {} \
   Kleo::x::~x() {}
 
 make_job_subclass(KeyListJob)
diff --git a/certmanager/lib/kleo/job.h b/certmanager/lib/kleo/job.h
index ae65008b0..57d0592d6 100644
--- a/certmanager/lib/kleo/job.h
+++ b/certmanager/lib/kleo/job.h
@@ -33,8 +33,8 @@
 #ifndef __KLEO_JOB_H__
 #define __KLEO_JOB_H__
 
-#include <qobject.h>
-#include <qstring.h>
+#include <tqobject.h>
+#include <tqstring.h>
 
 class QWidget;
 
@@ -57,22 +57,22 @@ namespace Kleo {
      signal of subclasses will still be emitted, though, and will
      carry the information that the operation was canceled.
   */
-  class Job : public QObject {
+  class Job : public TQObject {
     Q_OBJECT
   protected:
-    Job( QObject * parent, const char * name );
+    Job( TQObject * parent, const char * name );
   public:
     ~Job();
 
-    virtual void showErrorDialog( QWidget * parent=0, const QString & caption=QString::null ) const;
+    virtual void showErrorDialog( TQWidget * parent=0, const TQString & caption=TQString::null ) const;
 
-    virtual QString auditLogAsHtml() const;
+    virtual TQString auditLogAsHtml() const;
 
   public slots:
     virtual void slotCancel() = 0;
 
   signals:
-    void progress( const QString & what, int current, int total );
+    void progress( const TQString & what, int current, int total );
     void done();
   };
 
diff --git a/certmanager/lib/kleo/kconfigbasedkeyfilter.cpp b/certmanager/lib/kleo/kconfigbasedkeyfilter.cpp
index 89d18e799..7cf0bd551 100644
--- a/certmanager/lib/kleo/kconfigbasedkeyfilter.cpp
+++ b/certmanager/lib/kleo/kconfigbasedkeyfilter.cpp
@@ -52,14 +52,14 @@ static const struct {
   { "ultimate",  GpgME::Key::Ultimate,  GpgME::UserID::Ultimate  },
 };
 
-static GpgME::Key::OwnerTrust map2OwnerTrust( const QString & s ) {
+static GpgME::Key::OwnerTrust map2OwnerTrust( const TQString & s ) {
   for ( unsigned int i = 0 ; i < sizeof ownerTrustAndValidityMap / sizeof *ownerTrustAndValidityMap ; ++i )
     if ( s.lower() == ownerTrustAndValidityMap[i].name )
       return ownerTrustAndValidityMap[i].trust;
   return ownerTrustAndValidityMap[0].trust;
 }
 
-static GpgME::UserID::Validity map2Validity( const QString & s ) {
+static GpgME::UserID::Validity map2Validity( const TQString & s ) {
   for ( unsigned int i = 0 ; i < sizeof ownerTrustAndValidityMap / sizeof *ownerTrustAndValidityMap ; ++i )
     if ( s.lower() == ownerTrustAndValidityMap[i].name )
       return ownerTrustAndValidityMap[i].validity;
@@ -132,7 +132,7 @@ Kleo::KConfigBasedKeyFilter::KConfigBasedKeyFilter( const KConfigBase & config )
     { "is-at-most-", IsAtMost },
   };
   for ( unsigned int i = 0 ; i < sizeof prefixMap / sizeof *prefixMap ; ++i ) {
-    const QString key = QString( prefixMap[i].prefix ) + "ownertrust";
+    const TQString key = TQString( prefixMap[i].prefix ) + "ownertrust";
     if ( config.hasKey( key ) ) {
       mOwnerTrust = prefixMap[i].state;
       mOwnerTrustReferenceLevel = map2OwnerTrust( config.readEntry( key ) );
@@ -141,7 +141,7 @@ Kleo::KConfigBasedKeyFilter::KConfigBasedKeyFilter( const KConfigBase & config )
     }
   }
   for ( unsigned int i = 0 ; i < sizeof prefixMap / sizeof *prefixMap ; ++i ) {
-    const QString key = QString( prefixMap[i].prefix ) + "validity";
+    const TQString key = TQString( prefixMap[i].prefix ) + "validity";
     if ( config.hasKey( key ) ) {
       mValidity = prefixMap[i].state;
       mValidityReferenceLevel = map2Validity( config.readEntry( key ) );
@@ -226,14 +226,14 @@ bool Kleo::KConfigBasedKeyFilter::matches( const GpgME::Key & key ) const {
   return true;
 }
 
-static inline QFont resizedFont( QFont font, int pointSize, bool strike ) {
+static inline TQFont resizedFont( TQFont font, int pointSize, bool strike ) {
   font.setPointSize( pointSize );
   if ( strike )
     font.setStrikeOut( true );
   return font;
 }
 
-static inline QFont adapt( QFont font, bool it, bool b, bool strike ) {
+static inline TQFont adapt( TQFont font, bool it, bool b, bool strike ) {
   if ( it )
     font.setItalic( true );
   if ( b )
@@ -243,7 +243,7 @@ static inline QFont adapt( QFont font, bool it, bool b, bool strike ) {
   return font;
 }
 
-QFont Kleo::KConfigBasedKeyFilter::font( const QFont & f ) const {
+TQFont Kleo::KConfigBasedKeyFilter::font( const TQFont & f ) const {
   if ( mUseFullFont )
     return resizedFont( mFont, f.pointSize(), mStrikeOut );
   else
diff --git a/certmanager/lib/kleo/kconfigbasedkeyfilter.h b/certmanager/lib/kleo/kconfigbasedkeyfilter.h
index 42c083080..8d77b3913 100644
--- a/certmanager/lib/kleo/kconfigbasedkeyfilter.h
+++ b/certmanager/lib/kleo/kconfigbasedkeyfilter.h
@@ -35,9 +35,9 @@
 
 #include "keyfilter.h"
 
-#include <qfont.h>
-#include <qstring.h>
-#include <qcolor.h>
+#include <tqfont.h>
+#include <tqstring.h>
+#include <tqcolor.h>
 
 #include <gpgmepp/key.h>
 
@@ -53,22 +53,22 @@ namespace Kleo {
 
     unsigned int specificity() const { return mSpecificity; }
 
-    QColor fgColor() const { return mFgColor; }
-    QColor bgColor() const { return mBgColor; }
-    QFont  font( const QFont & ) const;
-    QString name() const { return mName; }
-    QString icon() const { return mIcon; }
+    TQColor fgColor() const { return mFgColor; }
+    TQColor bgColor() const { return mBgColor; }
+    TQFont  font( const TQFont & ) const;
+    TQString name() const { return mName; }
+    TQString icon() const { return mIcon; }
 
   private:
-    QColor mFgColor, mBgColor;
-    QString mName;
-    QString mIcon;
+    TQColor mFgColor, mBgColor;
+    TQString mName;
+    TQString mIcon;
     unsigned int mSpecificity;
     bool mItalic;
     bool mBold;
     bool mStrikeOut;
     bool mUseFullFont;
-    QFont mFont;
+    TQFont mFont;
 
     enum TriState {
       DoesNotMatter = 0,
diff --git a/certmanager/lib/kleo/keyfilter.h b/certmanager/lib/kleo/keyfilter.h
index f10fba9bf..e8d8eb1f1 100644
--- a/certmanager/lib/kleo/keyfilter.h
+++ b/certmanager/lib/kleo/keyfilter.h
@@ -56,11 +56,11 @@ namespace Kleo {
 
     // not sure if we want these here, but for the time being, it's
     // the easiest way:
-    virtual QColor fgColor() const = 0;
-    virtual QColor bgColor() const = 0;
-    virtual QFont  font( const QFont & ) const = 0;
-    virtual QString name() const = 0;
-    virtual QString icon() const = 0;
+    virtual TQColor fgColor() const = 0;
+    virtual TQColor bgColor() const = 0;
+    virtual TQFont  font( const TQFont & ) const = 0;
+    virtual TQString name() const = 0;
+    virtual TQString icon() const = 0;
   };
 
 }
diff --git a/certmanager/lib/kleo/keyfiltermanager.cpp b/certmanager/lib/kleo/keyfiltermanager.cpp
index 14932801c..53493ab80 100644
--- a/certmanager/lib/kleo/keyfiltermanager.cpp
+++ b/certmanager/lib/kleo/keyfiltermanager.cpp
@@ -41,10 +41,10 @@
 
 #include <kconfig.h>
 
-#include <qapplication.h>
-#include <qregexp.h>
-#include <qstringlist.h>
-#include <qvaluevector.h>
+#include <tqapplication.h>
+#include <tqregexp.h>
+#include <tqstringlist.h>
+#include <tqvaluevector.h>
 
 #include <algorithm>
 
@@ -61,19 +61,19 @@ struct Kleo::KeyFilterManager::Private {
     filters.clear();
   }
 
-  QValueVector<KeyFilter*> filters;
+  TQValueVector<KeyFilter*> filters;
 };
 
 Kleo::KeyFilterManager * Kleo::KeyFilterManager::mSelf = 0;
 
-Kleo::KeyFilterManager::KeyFilterManager( QObject * parent, const char * name )
-  : QObject( parent, name ), d( 0 )
+Kleo::KeyFilterManager::KeyFilterManager( TQObject * parent, const char * name )
+  : TQObject( parent, name ), d( 0 )
 {
   mSelf = this;
   d = new Private();
   // ### DF: doesn't a KStaticDeleter work more reliably?
   if ( qApp )
-    connect( qApp, SIGNAL(aboutToQuit()), SLOT(deleteLater()) );
+    connect( qApp, TQT_SIGNAL(aboutToQuit()), TQT_SLOT(deleteLater()) );
   reload();
 }
 
@@ -91,7 +91,7 @@ Kleo::KeyFilterManager * Kleo::KeyFilterManager::instance() {
 }
 
 const Kleo::KeyFilter * Kleo::KeyFilterManager::filterMatching( const GpgME::Key & key ) const {
-  for ( QValueVector<KeyFilter*>::const_iterator it = d->filters.begin() ; it != d->filters.end() ; ++it )
+  for ( TQValueVector<KeyFilter*>::const_iterator it = d->filters.begin() ; it != d->filters.end() ; ++it )
     if ( (*it)->matches( key ) )
       return *it;
   return 0;
@@ -107,8 +107,8 @@ void Kleo::KeyFilterManager::reload() {
   KConfig * config = Kleo::CryptoBackendFactory::instance()->configObject();
   if ( !config )
     return;
-  const QStringList groups = config->groupList().grep( QRegExp( "^Key Filter #\\d+$" ) );
-  for ( QStringList::const_iterator it = groups.begin() ; it != groups.end() ; ++it ) {
+  const TQStringList groups = config->groupList().grep( TQRegExp( "^Key Filter #\\d+$" ) );
+  for ( TQStringList::const_iterator it = groups.begin() ; it != groups.end() ; ++it ) {
     const KConfigGroup cfg( config, *it );
     d->filters.push_back( new KConfigBasedKeyFilter( cfg ) );
   }
diff --git a/certmanager/lib/kleo/keyfiltermanager.h b/certmanager/lib/kleo/keyfiltermanager.h
index 25353d71a..662dfdb82 100644
--- a/certmanager/lib/kleo/keyfiltermanager.h
+++ b/certmanager/lib/kleo/keyfiltermanager.h
@@ -33,7 +33,7 @@
 #ifndef __KLEO_KEYFILTERMANAGER_H__
 #define __KLEO_KEYFILTERMANAGER_H__
 
-#include <qobject.h>
+#include <tqobject.h>
 #include <kdepimmacros.h>
 namespace GpgME {
   class Key;
@@ -45,10 +45,10 @@ namespace Kleo {
 
 namespace Kleo {
 
-  class KDE_EXPORT KeyFilterManager : public QObject {
+  class KDE_EXPORT KeyFilterManager : public TQObject {
     Q_OBJECT
   protected:
-    KeyFilterManager( QObject * parent=0, const char * name=0 );
+    KeyFilterManager( TQObject * parent=0, const char * name=0 );
     ~KeyFilterManager();
 
   public:
diff --git a/certmanager/lib/kleo/keygenerationjob.h b/certmanager/lib/kleo/keygenerationjob.h
index f78152c5c..384d43065 100644
--- a/certmanager/lib/kleo/keygenerationjob.h
+++ b/certmanager/lib/kleo/keygenerationjob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 namespace GpgME {
   class Error;
@@ -53,15 +53,15 @@ namespace Kleo {
      signals to suitable slots and then start the key generation with
      a call to start(). This call might fail, in which case the
      KeyGenerationJob instance will have scheduled it's own
-     destruction with a call to QObject::deleteLater().
+     destruction with a call to TQObject::deleteLater().
 
      After result() is emitted, the KeyGenerationJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class KeyGenerationJob : public Job {
     Q_OBJECT
   protected:
-    KeyGenerationJob( QObject * parent, const char * name );
+    KeyGenerationJob( TQObject * parent, const char * name );
   public:
     ~KeyGenerationJob();
 
@@ -70,10 +70,10 @@ namespace Kleo {
        backend-specific string containing the paramaters of the key to
        create (length, capabilities, etc).
     */
-    virtual GpgME::Error start( const QString & parameters ) = 0;
+    virtual GpgME::Error start( const TQString & parameters ) = 0;
 
   signals:
-    void result( const GpgME::KeyGenerationResult & result, const QByteArray & pubKeyData );
+    void result( const GpgME::KeyGenerationResult & result, const TQByteArray & pubKeyData );
   };
 
 }
diff --git a/certmanager/lib/kleo/keylistjob.h b/certmanager/lib/kleo/keylistjob.h
index c419ad47d..9d566bcbc 100644
--- a/certmanager/lib/kleo/keylistjob.h
+++ b/certmanager/lib/kleo/keylistjob.h
@@ -55,17 +55,17 @@ namespace Kleo {
      and result() signals to suitable slots and then start the key
      listing with a call to start(). This call might fail, in which
      case the KeylistJob instance will have schedules it's own
-     destruction with a call to QObject::deleteLater().
+     destruction with a call to TQObject::deleteLater().
 
      During keylisting, you will receive new key objects through the
      nextKey() signal as they arrive. After result() is emitted, the
      KeyListJob will schedule it's own destruction by calling
-     QObject::deleteLater().
+     TQObject::deleteLater().
   */
   class KeyListJob : public Job {
     Q_OBJECT
   protected:
-    KeyListJob( QObject * parent, const char * name );
+    KeyListJob( TQObject * parent, const char * name );
 
   public:
    ~KeyListJob();
@@ -82,9 +82,9 @@ namespace Kleo {
        also available are returned. Use this if you need to select a
        key for signing.
     */
-    virtual GpgME::Error start( const QStringList & patterns, bool secretOnly=false ) = 0;
+    virtual GpgME::Error start( const TQStringList & patterns, bool secretOnly=false ) = 0;
 
-    virtual GpgME::KeyListResult exec( const QStringList & patterns, bool secretOnly, std::vector<GpgME::Key> & keys ) = 0;
+    virtual GpgME::KeyListResult exec( const TQStringList & patterns, bool secretOnly, std::vector<GpgME::Key> & keys ) = 0;
 
   signals:
     void nextKey( const GpgME::Key & key );
diff --git a/certmanager/lib/kleo/multideletejob.cpp b/certmanager/lib/kleo/multideletejob.cpp
index 32596e78f..bd4766475 100644
--- a/certmanager/lib/kleo/multideletejob.cpp
+++ b/certmanager/lib/kleo/multideletejob.cpp
@@ -102,7 +102,7 @@ GpgME::Error Kleo::MultiDeleteJob::startAJob() {
   assert( mJob ); // FIXME: we need a way to generate errors ourselves,
 		  // but I don't like the dependency on gpg-error :/
 
-  connect( mJob, SIGNAL(result(const GpgME::Error&)), SLOT(slotResult(const GpgME::Error&)) );
+  connect( mJob, TQT_SIGNAL(result(const GpgME::Error&)), TQT_SLOT(slotResult(const GpgME::Error&)) );
 
   return mJob->start( *mIt, mAllowSecretKeyDeletion );
 }
diff --git a/certmanager/lib/kleo/multideletejob.h b/certmanager/lib/kleo/multideletejob.h
index 5b995adaf..9bc5d05a6 100644
--- a/certmanager/lib/kleo/multideletejob.h
+++ b/certmanager/lib/kleo/multideletejob.h
@@ -37,7 +37,7 @@
 #include <kleo/cryptobackend.h>
 
 #include <kdepimmacros.h>
-#include <qguardedptr.h>
+#include <tqguardedptr.h>
 
 #include <vector>
 
@@ -59,10 +59,10 @@ namespace Kleo {
      connect the progress() and result() signals to suitable slots and
      then start the delete with a call to start(). This call might
      fail, in which case the MultiDeleteJob instance will have scheduled
-     it's own destruction with a call to QObject::deleteLater().
+     it's own destruction with a call to TQObject::deleteLater().
 
      After result() is emitted, the MultiDeleteJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class KDE_EXPORT MultiDeleteJob : public Job {
     Q_OBJECT
@@ -90,7 +90,7 @@ namespace Kleo {
 
   private:
     const CryptoBackend::Protocol * mProtocol;
-    QGuardedPtr<DeleteJob> mJob;
+    TQGuardedPtr<DeleteJob> mJob;
     std::vector<GpgME::Key> mKeys;
     std::vector<GpgME::Key>::const_iterator mIt;
     bool mAllowSecretKeyDeletion;
diff --git a/certmanager/lib/kleo/refreshkeysjob.h b/certmanager/lib/kleo/refreshkeysjob.h
index dcf9cd516..5ace60b6e 100644
--- a/certmanager/lib/kleo/refreshkeysjob.h
+++ b/certmanager/lib/kleo/refreshkeysjob.h
@@ -54,15 +54,15 @@ namespace Kleo {
      signals to suitable slots and then start the key refresh with a
      call to start(). This call might fail, in which case the
      RefreshKeysJob instance will have scheduled its own destruction
-     with a call to QObject::deleteLater().
+     with a call to TQObject::deleteLater().
 
      After result() is emitted, the KeyListJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class RefreshKeysJob : public Job {
     Q_OBJECT
   protected:
-    RefreshKeysJob( QObject * parent, const char * name );
+    RefreshKeysJob( TQObject * parent, const char * name );
 
   public:
    ~RefreshKeysJob();
@@ -79,7 +79,7 @@ namespace Kleo {
        also available are returned. Use this if you need to select a
        key for signing.
     */
-    virtual GpgME::Error start( const QStringList & patterns ) = 0;
+    virtual GpgME::Error start( const TQStringList & patterns ) = 0;
 
   signals:
     void result( const GpgME::Error & error );
diff --git a/certmanager/lib/kleo/signencryptjob.h b/certmanager/lib/kleo/signencryptjob.h
index 42d3a179f..5e12723ef 100644
--- a/certmanager/lib/kleo/signencryptjob.h
+++ b/certmanager/lib/kleo/signencryptjob.h
@@ -36,7 +36,7 @@
 #include <gpgmepp/context.h> // for Context::SignatureMode (or should
 			     // we roll our own enum here?)
 #include "job.h"
-#include <qcstring.h>
+#include <tqcstring.h>
 
 #include <vector>
 #include <utility>
@@ -59,15 +59,15 @@ namespace Kleo {
      signals to suitable slots and then start the operation with a
      call to start(). This call might fail, in which case the
      SignEncryptJob instance will have scheduled it's own destruction
-     with a call to QObject::deleteLater().
+     with a call to TQObject::deleteLater().
 
      After result() is emitted, the SignEncryptJob will schedule it's
-     own destruction by calling QObject::deleteLater().
+     own destruction by calling TQObject::deleteLater().
   */
   class SignEncryptJob : public Job {
     Q_OBJECT
   protected:
-    SignEncryptJob( QObject * parent, const char * name );
+    SignEncryptJob( TQObject * parent, const char * name );
   public:
     ~SignEncryptJob();
 
@@ -83,19 +83,19 @@ namespace Kleo {
     */
     virtual GpgME::Error start( const std::vector<GpgME::Key> & signers,
 				const std::vector<GpgME::Key> & recipients,
-				const QByteArray & plainText,
+				const TQByteArray & plainText,
 				bool alwaysTrust=false ) = 0;
 
     virtual std::pair<GpgME::SigningResult,GpgME::EncryptionResult>
       exec( const std::vector<GpgME::Key> & signers,
 	    const std::vector<GpgME::Key> & recipients,
-	    const QByteArray & plainText,
-	    bool alwaysTrust, QByteArray & cipherText ) = 0;
+	    const TQByteArray & plainText,
+	    bool alwaysTrust, TQByteArray & cipherText ) = 0;
 
   signals:
     void result( const GpgME::SigningResult & signingresult,
 		 const GpgME::EncryptionResult & encryptionresult,
-		 const QByteArray & cipherText );
+		 const TQByteArray & cipherText );
   };
 
 }
diff --git a/certmanager/lib/kleo/signjob.h b/certmanager/lib/kleo/signjob.h
index 17ea3d947..677aedcf0 100644
--- a/certmanager/lib/kleo/signjob.h
+++ b/certmanager/lib/kleo/signjob.h
@@ -36,7 +36,7 @@
 #include <gpgmepp/context.h> // for Context::SignatureMode (or should
 			     // we roll our own enum here?)
 #include "job.h"
-#include <qcstring.h>
+#include <tqcstring.h>
 
 #include <vector>
 
@@ -57,15 +57,15 @@ namespace Kleo {
      suitable slots and then start the signing with a call to
      start(). This call might fail, in which case the SignJob instance
      will have scheduled it's own destruction with a call to
-     QObject::deleteLater().
+     TQObject::deleteLater().
 
      After result() is emitted, the SignJob will schedule it's own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
   */
   class SignJob : public Job {
     Q_OBJECT
   protected:
-    SignJob( QObject * parent, const char * name );
+    SignJob( TQObject * parent, const char * name );
   public:
     ~SignJob();
 
@@ -74,15 +74,15 @@ namespace Kleo {
        sign \a plainText with. Empty (null) keys are ignored.
     */
     virtual GpgME::Error start( const std::vector<GpgME::Key> & signers,
-				const QByteArray & plainText,
+				const TQByteArray & plainText,
 				GpgME::Context::SignatureMode mode ) = 0;
     virtual GpgME::SigningResult exec( const std::vector<GpgME::Key> & signers,
-				       const QByteArray & plainText,
+				       const TQByteArray & plainText,
 				       GpgME::Context::SignatureMode mode,
-				       QByteArray & signature ) = 0;
+				       TQByteArray & signature ) = 0;
 
   signals:
-    void result( const GpgME::SigningResult & result, const QByteArray & signature );
+    void result( const GpgME::SigningResult & result, const TQByteArray & signature );
   };
 
 }
diff --git a/certmanager/lib/kleo/specialjob.h b/certmanager/lib/kleo/specialjob.h
index e7280b0a5..04867c32b 100644
--- a/certmanager/lib/kleo/specialjob.h
+++ b/certmanager/lib/kleo/specialjob.h
@@ -49,10 +49,10 @@ namespace Kleo {
      signals to suitable slots and then start the job with a call to
      start(). This call might fail, in which case the SpecialJob
      instance will have schedules its own destruction with a call to
-     QObject::deleteLater().
+     TQObject::deleteLater().
 
      After result() is emitted, the SpecialJob will schedule its own
-     destruction by calling QObject::deleteLater().
+     destruction by calling TQObject::deleteLater().
 
      Parameters are set using the Qt property system. More general, or
      constructor parameters are given in the call to
@@ -65,7 +65,7 @@ namespace Kleo {
   class SpecialJob : public Job {
     Q_OBJECT
   protected:
-    SpecialJob( QObject * parent, const char * name );
+    SpecialJob( TQObject * parent, const char * name );
 
   public:
    ~SpecialJob();
@@ -78,7 +78,7 @@ namespace Kleo {
     virtual GpgME::Error exec() = 0;
 
   signals:
-    void result( const GpgME::Error & result, const QVariant & data );
+    void result( const GpgME::Error & result, const TQVariant & data );
   };
 
 }
diff --git a/certmanager/lib/kleo/verifydetachedjob.h b/certmanager/lib/kleo/verifydetachedjob.h
index f50fda546..58ff64732 100644
--- a/certmanager/lib/kleo/verifydetachedjob.h
+++ b/certmanager/lib/kleo/verifydetachedjob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 namespace GpgME {
   class Error;
@@ -54,15 +54,15 @@ namespace Kleo {
      signals to suitable slots and then start the verification with a
      call to start(). This call might fail, in which case the
      VerifyDetachedJob instance will have scheduled it's own
-     destruction with a call to QObject::deleteLater().
+     destruction with a call to TQObject::deleteLater().
 
      After result() is emitted, the VerifyDetachedJob will schedule
-     it's own destruction by calling QObject::deleteLater().
+     it's own destruction by calling TQObject::deleteLater().
   */
   class VerifyDetachedJob : public Job {
     Q_OBJECT
   protected:
-    VerifyDetachedJob( QObject * parent, const char * name );
+    VerifyDetachedJob( TQObject * parent, const char * name );
   public:
     ~VerifyDetachedJob();
 
@@ -71,11 +71,11 @@ namespace Kleo {
        signature data, while \a signedData contains the data over
        which the signature was made.
     */
-    virtual GpgME::Error start( const QByteArray & signature,
-				const QByteArray & signedData ) = 0;
+    virtual GpgME::Error start( const TQByteArray & signature,
+				const TQByteArray & signedData ) = 0;
 
-    virtual GpgME::VerificationResult exec( const QByteArray & signature,
-					    const QByteArray & signedData ) = 0;
+    virtual GpgME::VerificationResult exec( const TQByteArray & signature,
+					    const TQByteArray & signedData ) = 0;
 
   signals:
     void result( const GpgME::VerificationResult & result );
diff --git a/certmanager/lib/kleo/verifyopaquejob.h b/certmanager/lib/kleo/verifyopaquejob.h
index b38b18de1..58c452b7c 100644
--- a/certmanager/lib/kleo/verifyopaquejob.h
+++ b/certmanager/lib/kleo/verifyopaquejob.h
@@ -35,7 +35,7 @@
 
 #include "job.h"
 
-#include <qcstring.h>
+#include <tqcstring.h>
 
 namespace GpgME {
   class Error;
@@ -54,15 +54,15 @@ namespace Kleo {
      signals to suitable slots and then start the verification with a
      call to start(). This call might fail, in which case the
      VerifyOpaqueJob instance will have scheduled it's own
-     destruction with a call to QObject::deleteLater().
+     destruction with a call to TQObject::deleteLater().
 
      After result() is emitted, the VerifyOpaqueJob will schedule
-     it's own destruction by calling QObject::deleteLater().
+     it's own destruction by calling TQObject::deleteLater().
   */
   class VerifyOpaqueJob : public Job {
     Q_OBJECT
   protected:
-    VerifyOpaqueJob( QObject * parent, const char * name );
+    VerifyOpaqueJob( TQObject * parent, const char * name );
   public:
     ~VerifyOpaqueJob();
 
@@ -71,13 +71,13 @@ namespace Kleo {
        signature data, while \a signedData contains the data over
        which the signature was made.
     */
-    virtual GpgME::Error start( const QByteArray & signedData ) = 0;
+    virtual GpgME::Error start( const TQByteArray & signedData ) = 0;
 
     /** Synchronous version of @ref start */
-    virtual GpgME::VerificationResult exec( const QByteArray & signedData, QByteArray & plainText ) = 0;
+    virtual GpgME::VerificationResult exec( const TQByteArray & signedData, TQByteArray & plainText ) = 0;
 
   signals:
-    void result( const GpgME::VerificationResult & result, const QByteArray & plainText );
+    void result( const GpgME::VerificationResult & result, const TQByteArray & plainText );
   };
 
 }