Trinity Qt initial conversion

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

47 files changed, 929 insertions, 929 deletions

diff --git a/kresources/scalix/kabc/contact.cpp b/kresources/scalix/kabc/contact.cpp
index 156ae01a..06c67442 100644
--- a/kresources/scalix/kabc/contact.cpp
+++ b/kresources/scalix/kabc/contact.cpp
@@ -18,7 +18,7 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#include <qdom.h>
+#include <tqdom.h>
 
 #include <libkdepim/distributionlist.h>
 #include <kstaticdeleter.h>
@@ -27,24 +27,24 @@
 
 using namespace Scalix;
 
-static QMap<QString, QString> *s_distListMap = 0;
-static KStaticDeleter< QMap<QString, QString> > sd;
+static TQMap<TQString, TQString> *s_distListMap = 0;
+static KStaticDeleter< TQMap<TQString, TQString> > sd;
 
-static QString custom( const QString &name, const KABC::Addressee &addr, const QString &defaultValue = QString() )
+static TQString custom( const TQString &name, const KABC::Addressee &addr, const TQString &defaultValue = TQString() )
 {
-  const QString value = addr.custom( "Scalix", name );
+  const TQString value = addr.custom( "Scalix", name );
   if ( value.isEmpty() )
     return defaultValue;
   else
     return value;
 }
 
-static void setCustom( const QString &name, const QString &value, KABC::Addressee &addr )
+static void setCustom( const TQString &name, const TQString &value, KABC::Addressee &addr )
 {
   addr.insertCustom( "Scalix", name, value );
 }
 
-QString Contact::toXml( const KABC::Addressee &addr )
+TQString Contact::toXml( const KABC::Addressee &addr )
 {
   /**
    * Handle distribution lists.
@@ -53,13 +53,13 @@ QString Contact::toXml( const KABC::Addressee &addr )
     if ( s_distListMap )
       return (*s_distListMap)[ addr.uid() ];
     else
-      return QString();
+      return TQString();
   }
 
   /**
    * Handle normal contacts.
    */
-  QString xml;
+  TQString xml;
   xml += "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
   xml += "<contact>\n";
 
@@ -86,9 +86,9 @@ QString Contact::toXml( const KABC::Addressee &addr )
   xml += "<company_name>" + addr.organization() + "</company_name>\n";
   xml += "<job_title>" + addr.title() + "</job_title>\n";
 
-  QStringList emails = addr.emails();
+  TQStringList emails = addr.emails();
   for ( uint i = 0; i < 3; ++i ) {
-    QString type, address, comment, display;
+    TQString type, address, comment, display;
 
     if ( i < emails.count() ) {
       type = "SMTP";
@@ -103,19 +103,19 @@ QString Contact::toXml( const KABC::Addressee &addr )
         comment = addr.formattedName();
         display = emails[ i ];
       } else {
-        comment = custom( QString( "email%1_address_with_comment" ).arg( i + 1 ), addr );
-        display = custom( QString( "email%1_display_name" ).arg( i + 1 ), addr );
+        comment = custom( TQString( "email%1_address_with_comment" ).arg( i + 1 ), addr );
+        display = custom( TQString( "email%1_display_name" ).arg( i + 1 ), addr );
       }
     }
 
-    xml += QString( "<email%1_address_type>" ).arg( i + 1 ) + type +
-           QString( "</email%1_address_type>" ).arg( i + 1 ) +"\n";
-    xml += QString( "<email%1_address>" ).arg( i + 1 ) + address +
-           QString( "</email%1_address>" ).arg( i + 1 ) +"\n";
-    xml += QString( "<email%1_address_with_comment>" ).arg( i + 1 ) + comment +
-           QString( "</email%1_address_with_comment>" ).arg( i + 1 ) + "\n";
-    xml += QString( "<email%1_display_name>" ).arg( i + 1 ) + display +
-           QString( "</email%1_display_name>" ).arg( i + 1 ) + "\n";
+    xml += TQString( "<email%1_address_type>" ).arg( i + 1 ) + type +
+           TQString( "</email%1_address_type>" ).arg( i + 1 ) +"\n";
+    xml += TQString( "<email%1_address>" ).arg( i + 1 ) + address +
+           TQString( "</email%1_address>" ).arg( i + 1 ) +"\n";
+    xml += TQString( "<email%1_address_with_comment>" ).arg( i + 1 ) + comment +
+           TQString( "</email%1_address_with_comment>" ).arg( i + 1 ) + "\n";
+    xml += TQString( "<email%1_display_name>" ).arg( i + 1 ) + display +
+           TQString( "</email%1_display_name>" ).arg( i + 1 ) + "\n";
   }
 
   KABC::PhoneNumber phone = addr.phoneNumber( KABC::PhoneNumber::Home );
@@ -176,22 +176,22 @@ QString Contact::toXml( const KABC::Addressee &addr )
   return xml;
 }
 
-KABC::Addressee Contact::fromXml( const QString &xml )
+KABC::Addressee Contact::fromXml( const TQString &xml )
 {
-  QDomDocument document;
+  TQDomDocument document;
 
-  QString errorMsg;
+  TQString errorMsg;
   int errorLine, errorColumn;
   if ( !document.setContent( xml, true, &errorMsg, &errorLine, &errorColumn ) ) {
     qDebug( "Error parsing XML in Scalix::Contact::fromXml: %s (%d,%d)", errorMsg.latin1(), errorLine, errorColumn );
     return KABC::Addressee();
   }
 
-  QDomElement contactElement = document.documentElement();
+  TQDomElement contactElement = document.documentElement();
   if ( contactElement.tagName() != "contact" ) {
     if ( contactElement.tagName() == "distlist" ) {
-      const QDomNodeList names = contactElement.elementsByTagName( "display_name" );
-      const QString listName = ( names.count() == 1 ? names.item( 0 ).toElement().text() : "Scalix Dummy List" );
+      const TQDomNodeList names = contactElement.elementsByTagName( "display_name" );
+      const TQString listName = ( names.count() == 1 ? names.item( 0 ).toElement().text() : "Scalix Dummy List" );
 
       /**
        * As we can't provide distribution list functionality we store the entry
@@ -201,7 +201,7 @@ KABC::Addressee Contact::fromXml( const QString &xml )
       list.setName( listName );
 
       if ( !s_distListMap )
-        sd.setObject( s_distListMap, new QMap<QString, QString>() );
+        sd.setObject( s_distListMap, new TQMap<TQString, TQString>() );
 
       s_distListMap->insert( list.uid(), xml );
 
@@ -212,7 +212,7 @@ KABC::Addressee Contact::fromXml( const QString &xml )
     }
   }
 
-  QString emails[ 3 ];
+  TQString emails[ 3 ];
   KABC::Address homeAddress( KABC::Address::Home );
   KABC::Address workAddress( KABC::Address::Work );
   KABC::Address otherAddress( KABC::Address::Dom );
@@ -220,9 +220,9 @@ KABC::Addressee Contact::fromXml( const QString &xml )
   KABC::Addressee addr;
   setCustom( "comes_from_scalix", "true", addr );
 
-  QDomNode node = contactElement.firstChild();
+  TQDomNode node = contactElement.firstChild();
   while ( !node.isNull() ) {
-    QDomElement element = node.toElement();
+    TQDomElement element = node.toElement();
     if ( !element.isNull() ) {
       if ( element.tagName() == "direct_ref" )
         addr.setUid( element.text() );
@@ -235,7 +235,7 @@ KABC::Addressee Contact::fromXml( const QString &xml )
       else if ( element.tagName() == "send_rich_info" )
         setCustom( "send_rich_info", element.text(), addr );
       else if ( element.tagName() == "last_modification_time" )
-        addr.setRevision( QDateTime::fromString( element.text(), Qt::ISODate ) );
+        addr.setRevision( TQDateTime::fromString( element.text(), Qt::ISODate ) );
 
       // name
       else if ( element.tagName() == "display_name_prefix" )
@@ -352,7 +352,7 @@ KABC::Addressee Contact::fromXml( const QString &xml )
         addr.insertCustom( "KADDRESSBOOK", "X-SpousesName", element.text() );
 
       else if ( element.tagName() == "bday" )
-        addr.setBirthday( QDateTime::fromString( element.text(), Qt::ISODate ) );
+        addr.setBirthday( TQDateTime::fromString( element.text(), Qt::ISODate ) );
       else if ( element.tagName() == "anniversary" )
         addr.insertCustom( "KADDRESSBOOK", "X-Anniversary", element.text() );
       else
diff --git a/kresources/scalix/kabc/contact.h b/kresources/scalix/kabc/contact.h
index d73765ed..ad095a8d 100644
--- a/kresources/scalix/kabc/contact.h
+++ b/kresources/scalix/kabc/contact.h
@@ -28,8 +28,8 @@ namespace Scalix {
 class Contact
 {
   public:
-    static QString toXml( const KABC::Addressee &addr );
-    static KABC::Addressee fromXml( const QString &xml );
+    static TQString toXml( const KABC::Addressee &addr );
+    static KABC::Addressee fromXml( const TQString &xml );
 };
 
 }
diff --git a/kresources/scalix/kabc/resourcescalix.cpp b/kresources/scalix/kabc/resourcescalix.cpp
index 6cbf1083..31ccdf2c 100644
--- a/kresources/scalix/kabc/resourcescalix.cpp
+++ b/kresources/scalix/kabc/resourcescalix.cpp
@@ -44,11 +44,11 @@
 #include <kapplication.h>
 #include <dcopclient.h>
 
-#include <qobject.h>
-#include <qtimer.h>
-#include <qstring.h>
-#include <qfile.h>
-#include <qapplication.h>
+#include <tqobject.h>
+#include <tqtimer.h>
+#include <tqstring.h>
+#include <tqfile.h>
+#include <tqapplication.h>
 
 #include <assert.h>
 
@@ -64,7 +64,7 @@ class ScalixFactory : public KRES::PluginFactoryBase
       return new KABC::ResourceScalix( config );
     }
 
-    KRES::ConfigWidget *configWidget( QWidget* )
+    KRES::ConfigWidget *configWidget( TQWidget* )
     {
       return 0;
     }
@@ -80,7 +80,7 @@ static const char* s_inlineMimeType = "application/scalix-properties";
 KABC::ResourceScalix::ResourceScalix( const KConfig *config )
   : KPIM::ResourceABC( config ),
     Scalix::ResourceScalixBase( "ResourceScalix-KABC" ),
-    mCachedSubresource( QString::null ), mLocked( false )
+    mCachedSubresource( TQString::null ), mLocked( false )
 {
   setType( "scalix" );
 }
@@ -95,8 +95,8 @@ KABC::ResourceScalix::~ResourceScalix()
 }
 
 void KABC::ResourceScalix::loadSubResourceConfig( KConfig& config,
-                                                 const QString& name,
-                                                 const QString& label,
+                                                 const TQString& name,
+                                                 const TQString& label,
                                                  bool writable )
 {
   KConfigGroup group( &config, name );
@@ -111,11 +111,11 @@ bool KABC::ResourceScalix::doOpen()
   KConfig config( configFile() );
 
   // Read the calendar entries
-  QValueList<KMailICalIface::SubResource> subResources;
+  TQValueList<KMailICalIface::SubResource> subResources;
   if ( !kmailSubresources( subResources, s_kmailContentsType ) )
     return false;
   mSubResources.clear();
-  QValueList<KMailICalIface::SubResource>::ConstIterator it;
+  TQValueList<KMailICalIface::SubResource>::ConstIterator it;
   for ( it = subResources.begin(); it != subResources.end(); ++it ) {
     loadSubResourceConfig( config, (*it).location, (*it).label, (*it).writable );
   }
@@ -149,12 +149,12 @@ KABC::Ticket * KABC::ResourceScalix::requestSaveTicket()
 void KABC::ResourceScalix::releaseSaveTicket( Ticket* ticket )
 {
   mLocked = false;
-  mCachedSubresource = QString::null;
+  mCachedSubresource = TQString::null;
   delete ticket;
 }
 
-QString KABC::ResourceScalix::loadContact( const QString& contactData,
-                                          const QString& subResource,
+TQString KABC::ResourceScalix::loadContact( const TQString& contactData,
+                                          const TQString& subResource,
                                           Q_UINT32 sernum,
                                           KMailICalIface::StorageFormat )
 {
@@ -168,7 +168,7 @@ QString KABC::ResourceScalix::loadContact( const QString& contactData,
   return addr.uid();
 }
 
-bool KABC::ResourceScalix::loadSubResource( const QString& subResource )
+bool KABC::ResourceScalix::loadSubResource( const TQString& subResource )
 {
   bool scalixcontacts = loadSubResourceHelper( subResource, s_attachmentMimeTypeContact, KMailICalIface::StorageXML );
   bool scalixdistlists = loadSubResourceHelper( subResource, s_attachmentMimeTypeDistList, KMailICalIface::StorageXML );
@@ -176,7 +176,7 @@ bool KABC::ResourceScalix::loadSubResource( const QString& subResource )
   return scalixcontacts && scalixdistlists && vcardstyle;
 }
 
-bool KABC::ResourceScalix::loadSubResourceHelper( const QString& subResource,
+bool KABC::ResourceScalix::loadSubResourceHelper( const TQString& subResource,
                                                  const char* mimetype,
                                                  KMailICalIface::StorageFormat format )
 {
@@ -204,7 +204,7 @@ bool KABC::ResourceScalix::loadSubResourceHelper( const QString& subResource,
   }
 
   for ( int startIndex = 0; startIndex < count; startIndex += nbMessages ) {
-    QMap<Q_UINT32, QString> lst;
+    TQMap<Q_UINT32, TQString> lst;
 
     if ( !kmailIncidences( lst, mimetype, subResource, startIndex, nbMessages ) ) {
       kdError() << "Communication problem in ResourceScalix::load()\n";
@@ -213,7 +213,7 @@ bool KABC::ResourceScalix::loadSubResourceHelper( const QString& subResource,
       return false;
     }
 
-    for( QMap<Q_UINT32, QString>::ConstIterator it = lst.begin(); it != lst.end(); ++it ) {
+    for( TQMap<Q_UINT32, TQString>::ConstIterator it = lst.begin(); it != lst.end(); ++it ) {
       loadContact( it.data(), subResource, it.key(), format );
     }
     if ( progressId ) {
@@ -263,24 +263,24 @@ bool KABC::ResourceScalix::save( Ticket* )
 
 namespace Scalix {
 struct AttachmentList {
-  QStringList attachmentURLs;
-  QStringList attachmentNames;
-  QStringList attachmentMimeTypes;
-  QStringList deletedAttachments;
-  QValueList<KTempFile *> tempFiles;
+  TQStringList attachmentURLs;
+  TQStringList attachmentNames;
+  TQStringList attachmentMimeTypes;
+  TQStringList deletedAttachments;
+  TQValueList<KTempFile *> tempFiles;
 
-  void addAttachment( const QString& url, const QString& name, const QString& mimetype ) {
+  void addAttachment( const TQString& url, const TQString& name, const TQString& mimetype ) {
     attachmentURLs.append( url );
     attachmentNames.append( name );
     attachmentMimeTypes.append( mimetype );
   }
 
-  void updatePictureAttachment( const QImage& image, const QString& name );
-  void updateAttachment( const QByteArray& data, const QString& name, const char* mimetype );
+  void updatePictureAttachment( const TQImage& image, const TQString& name );
+  void updateAttachment( const TQByteArray& data, const TQString& name, const char* mimetype );
 };
 } // namespace
 
-void AttachmentList::updatePictureAttachment( const QImage& image, const QString& name )
+void AttachmentList::updatePictureAttachment( const TQImage& image, const TQString& name )
 {
   assert( !name.isEmpty() );
   if ( !image.isNull() ) {
@@ -296,7 +296,7 @@ void AttachmentList::updatePictureAttachment( const QImage& image, const QString
   }
 }
 
-void AttachmentList::updateAttachment( const QByteArray& data, const QString& name, const char* mimetype )
+void AttachmentList::updateAttachment( const TQByteArray& data, const TQString& name, const char* mimetype )
 {
   assert( !name.isEmpty() );
   if ( !data.isNull() ) {
@@ -314,8 +314,8 @@ void AttachmentList::updateAttachment( const QByteArray& data, const QString& na
 
 bool KABC::ResourceScalix::kmailUpdateAddressee( const Addressee& addr )
 {
-  const QString uid = addr.uid();
-  QString subResource;
+  const TQString uid = addr.uid();
+  TQString subResource;
   Q_UINT32 sernum;
   if ( mUidMap.find( uid ) != mUidMap.end() ) {
     subResource = mUidMap[ uid ].resource();
@@ -340,11 +340,11 @@ bool KABC::ResourceScalix::kmailUpdateAddressee( const Addressee& addr )
   }
 
   AttachmentList att;
-  QString subject = addr.formattedName();
+  TQString subject = addr.formattedName();
 
-  QString mimetype = s_inlineMimeType;
+  TQString mimetype = s_inlineMimeType;
 
-  QString data = Contact::toXml( addr );
+  TQString data = Contact::toXml( addr );
 
   CustomHeaderMap customHeaders;
   customHeaders.insert( "X-Scalix-Class", "IPM.Contact" );
@@ -365,7 +365,7 @@ bool KABC::ResourceScalix::kmailUpdateAddressee( const Addressee& addr )
     const_cast<Addressee&>(addr).setChanged( false );
   }
 
-  for( QValueList<KTempFile *>::Iterator it = att.tempFiles.begin(); it != att.tempFiles.end(); ++it ) {
+  for( TQValueList<KTempFile *>::Iterator it = att.tempFiles.begin(); it != att.tempFiles.end(); ++it ) {
     (*it)->setAutoDelete( true );
     delete (*it);
   }
@@ -374,7 +374,7 @@ bool KABC::ResourceScalix::kmailUpdateAddressee( const Addressee& addr )
 
 void KABC::ResourceScalix::insertAddressee( const Addressee& addr )
 {
-  const QString uid = addr.uid();
+  const TQString uid = addr.uid();
   //kdDebug(5650) << k_funcinfo << uid << endl;
   bool ok = false;
   if ( mUidMap.contains( uid ) ) {
@@ -391,10 +391,10 @@ void KABC::ResourceScalix::insertAddressee( const Addressee& addr )
 
 void KABC::ResourceScalix::removeAddressee( const Addressee& addr )
 {
-  const QString uid = addr.uid();
+  const TQString uid = addr.uid();
   if ( mUidMap.find( uid ) == mUidMap.end() ) return;
   //kdDebug(5650) << k_funcinfo << uid << endl;
-  const QString resource = mUidMap[ uid ].resource();
+  const TQString resource = mUidMap[ uid ].resource();
   if ( !subresourceWritable( resource ) ) {
     kdWarning() << "Wow! Something tried to delete a non-writable addressee! Fix this caller: " << kdBacktrace() << endl;
     return;
@@ -412,18 +412,18 @@ void KABC::ResourceScalix::removeAddressee( const Addressee& addr )
  * These are the DCOP slots that KMail call to notify when something
  * changed.
  */
-bool KABC::ResourceScalix::fromKMailAddIncidence( const QString& type,
-                                                 const QString& subResource,
+bool KABC::ResourceScalix::fromKMailAddIncidence( const TQString& type,
+                                                 const TQString& subResource,
                                                  Q_UINT32 sernum,
                                                  int format,
-                                                 const QString& contactXML )
+                                                 const TQString& contactXML )
 {
   // Check if this is a contact
   if( type != s_kmailContentsType || !subresourceActive( subResource ) )
     return false;
 
   // Load contact to find the UID
-  const QString uid = loadContact( contactXML, subResource, sernum,
+  const TQString uid = loadContact( contactXML, subResource, sernum,
       ( KMailICalIface::StorageFormat )format );
 
   //kdDebug(5650) << k_funcinfo << uid << endl;
@@ -440,9 +440,9 @@ bool KABC::ResourceScalix::fromKMailAddIncidence( const QString& type,
   return true;
 }
 
-void KABC::ResourceScalix::fromKMailDelIncidence( const QString& type,
-                                                 const QString& subResource,
-                                                 const QString& uid )
+void KABC::ResourceScalix::fromKMailDelIncidence( const TQString& type,
+                                                 const TQString& subResource,
+                                                 const TQString& uid )
 {
   // Check if this is a contact
   if( type != s_kmailContentsType || !subresourceActive( subResource ) )
@@ -464,8 +464,8 @@ void KABC::ResourceScalix::fromKMailDelIncidence( const QString& type,
   }
 }
 
-void KABC::ResourceScalix::fromKMailRefresh( const QString& type,
-                                            const QString& /*subResource*/ )
+void KABC::ResourceScalix::fromKMailRefresh( const TQString& type,
+                                            const TQString& /*subResource*/ )
 {
   // Check if this is a contact
   if( type != s_kmailContentsType ) return;
@@ -476,9 +476,9 @@ void KABC::ResourceScalix::fromKMailRefresh( const QString& type,
   addressBook()->emitAddressBookChanged();
 }
 
-void KABC::ResourceScalix::fromKMailAddSubresource( const QString& type,
-                                                   const QString& subResource,
-                                                   const QString& label,
+void KABC::ResourceScalix::fromKMailAddSubresource( const TQString& type,
+                                                   const TQString& subResource,
+                                                   const TQString& label,
                                                    bool writable )
 {
   if( type != s_kmailContentsType ) return;
@@ -495,8 +495,8 @@ void KABC::ResourceScalix::fromKMailAddSubresource( const QString& type,
   emit signalSubresourceAdded( this, type, subResource );
 }
 
-void KABC::ResourceScalix::fromKMailDelSubresource( const QString& type,
-                                                   const QString& subResource )
+void KABC::ResourceScalix::fromKMailDelSubresource( const TQString& type,
+                                                   const TQString& subResource )
 {
   if( type != s_kmailContentsType ) return;
 
@@ -513,7 +513,7 @@ void KABC::ResourceScalix::fromKMailDelSubresource( const QString& type,
 
   // Make a list of all uids to remove
   Scalix::UidMap::ConstIterator mapIt;
-  QStringList uids;
+  TQStringList uids;
   for ( mapIt = mUidMap.begin(); mapIt != mUidMap.end(); ++mapIt )
     if ( mapIt.data().resource() == subResource )
       // We have a match
@@ -521,7 +521,7 @@ void KABC::ResourceScalix::fromKMailDelSubresource( const QString& type,
 
   // Finally delete all the incidences
   if ( !uids.isEmpty() ) {
-    QStringList::ConstIterator it;
+    TQStringList::ConstIterator it;
     for ( it = uids.begin(); it != uids.end(); ++it ) {
       mAddrMap.remove( *it );
       mUidMap.remove( *it );
@@ -535,13 +535,13 @@ void KABC::ResourceScalix::fromKMailDelSubresource( const QString& type,
 
 
 
-void KABC::ResourceScalix::fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                                    const QString& /* type */,
-                                                    const QString& folder )
+void KABC::ResourceScalix::fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                                    const TQString& /* type */,
+                                                    const TQString& folder )
 {
   // FIXME
   KMailICalIface::StorageFormat format = KMailICalIface::StorageXML;
-  for( QMap<Q_UINT32, QString>::ConstIterator it = map.begin(); it != map.end(); ++it ) {
+  for( TQMap<Q_UINT32, TQString>::ConstIterator it = map.begin(); it != map.end(); ++it ) {
     loadContact( it.data(), folder, it.key(), format );
   }
   if ( !addressBook() ){
@@ -550,12 +550,12 @@ void KABC::ResourceScalix::fromKMailAsyncLoadResult( const QMap<Q_UINT32, QStrin
     addressBook()->emitAddressBookChanged();
 }
 
-QStringList KABC::ResourceScalix::subresources() const
+TQStringList KABC::ResourceScalix::subresources() const
 {
   return mSubResources.keys();
 }
 
-bool KABC::ResourceScalix::subresourceActive( const QString& subresource ) const
+bool KABC::ResourceScalix::subresourceActive( const TQString& subresource ) const
 {
   if ( mSubResources.contains( subresource ) ) {
     return mSubResources[ subresource ].active();
@@ -567,7 +567,7 @@ bool KABC::ResourceScalix::subresourceActive( const QString& subresource ) const
   return true;
 }
 
-bool KABC::ResourceScalix::subresourceWritable( const QString& subresource ) const
+bool KABC::ResourceScalix::subresourceWritable( const TQString& subresource ) const
 {
   if ( mSubResources.contains( subresource ) ) {
     return mSubResources[ subresource ].writable();
@@ -575,7 +575,7 @@ bool KABC::ResourceScalix::subresourceWritable( const QString& subresource ) con
   return false; //better a safe default
 }
 
-int KABC::ResourceScalix::subresourceCompletionWeight( const QString& subresource ) const
+int KABC::ResourceScalix::subresourceCompletionWeight( const TQString& subresource ) const
 {
   if ( mSubResources.contains( subresource ) ) {
     return mSubResources[ subresource ].completionWeight();
@@ -586,17 +586,17 @@ int KABC::ResourceScalix::subresourceCompletionWeight( const QString& subresourc
   return 80;
 }
 
-QString KABC::ResourceScalix::subresourceLabel( const QString& subresource ) const
+TQString KABC::ResourceScalix::subresourceLabel( const TQString& subresource ) const
 {
   if ( mSubResources.contains( subresource ) ) {
     return mSubResources[ subresource ].label();
   }
 
   kdDebug(5650) << "subresourceLabel( " << subresource << " ): not found!\n";
-  return QString::null;
+  return TQString::null;
 }
 
-void KABC::ResourceScalix::setSubresourceCompletionWeight( const QString& subresource, int completionWeight )
+void KABC::ResourceScalix::setSubresourceCompletionWeight( const TQString& subresource, int completionWeight )
 {
   if ( mSubResources.contains( subresource ) ) {
     mSubResources[ subresource ].setCompletionWeight( completionWeight );
@@ -605,17 +605,17 @@ void KABC::ResourceScalix::setSubresourceCompletionWeight( const QString& subres
   }
 }
 
-QMap<QString, QString> KABC::ResourceScalix::uidToResourceMap() const
+TQMap<TQString, TQString> KABC::ResourceScalix::uidToResourceMap() const
 {
   // TODO: Couldn't this be made simpler?
-  QMap<QString, QString> map;
+  TQMap<TQString, TQString> map;
   Scalix::UidMap::ConstIterator mapIt;
   for ( mapIt = mUidMap.begin(); mapIt != mUidMap.end(); ++mapIt )
     map[ mapIt.key() ] = mapIt.data().resource();
   return map;
 }
 
-void KABC::ResourceScalix::setSubresourceActive( const QString &subresource, bool active )
+void KABC::ResourceScalix::setSubresourceActive( const TQString &subresource, bool active )
 {
   if ( mSubResources.contains( subresource ) ) {
     mSubResources[ subresource ].setActive( active );
diff --git a/kresources/scalix/kabc/resourcescalix.h b/kresources/scalix/kabc/resourcescalix.h
index 10d3d8aa..25eca7e4 100644
--- a/kresources/scalix/kabc/resourcescalix.h
+++ b/kresources/scalix/kabc/resourcescalix.h
@@ -107,61 +107,61 @@ public:
   virtual void removeAddressee( const Addressee& addr );
 
   // Listen to KMail changes in the amount of sub resources
-  void fromKMailAddSubresource( const QString& type, const QString& id,
-                                const QString& label, bool writable );
-  void fromKMailDelSubresource( const QString& type, const QString& id );
+  void fromKMailAddSubresource( const TQString& type, const TQString& id,
+                                const TQString& label, bool writable );
+  void fromKMailDelSubresource( const TQString& type, const TQString& id );
 
-  bool fromKMailAddIncidence( const QString& type, const QString& resource,
-                              Q_UINT32 sernum, int format, const QString& contact );
-  void fromKMailDelIncidence( const QString& type, const QString& resource,
-                              const QString& contact );
-  void fromKMailRefresh( const QString& type, const QString& resource );
+  bool fromKMailAddIncidence( const TQString& type, const TQString& resource,
+                              Q_UINT32 sernum, int format, const TQString& contact );
+  void fromKMailDelIncidence( const TQString& type, const TQString& resource,
+                              const TQString& contact );
+  void fromKMailRefresh( const TQString& type, const TQString& resource );
 
-  void fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                 const QString& type,
-                                 const QString& folder );
+  void fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                 const TQString& type,
+                                 const TQString& folder );
 
   /// Return the list of subresources.
-  QStringList subresources() const;
+  TQStringList subresources() const;
 
   /// Is this subresource active?
-  bool subresourceActive( const QString& ) const;
+  bool subresourceActive( const TQString& ) const;
   /// Is this subresource writabel?
-  bool subresourceWritable( const QString& ) const;
+  bool subresourceWritable( const TQString& ) const;
 
-  virtual void setSubresourceActive( const QString &, bool );
+  virtual void setSubresourceActive( const TQString &, bool );
 
   /// Completion weight for a given subresource
-  virtual int subresourceCompletionWeight( const QString& ) const;
+  virtual int subresourceCompletionWeight( const TQString& ) const;
 
   /// Label for a given subresource
-  virtual QString subresourceLabel( const QString& ) const;
+  virtual TQString subresourceLabel( const TQString& ) const;
 
   /// Set completion weight for a given subresource
-  virtual void setSubresourceCompletionWeight( const QString&, int );
+  virtual void setSubresourceCompletionWeight( const TQString&, int );
 
   /// Give the uidmap. Used for ordered searching
-  QMap<QString, QString> uidToResourceMap() const;
+  TQMap<TQString, TQString> uidToResourceMap() const;
 
 protected:
   bool kmailUpdateAddressee( const Addressee& );
 
   void doClose();
 
-  void loadSubResourceConfig( KConfig& config, const QString& name,
-                              const QString& label, bool writable );
-  bool loadSubResource( const QString& subResource );
-  bool loadSubResourceHelper( const QString& subResource, const char* mimetype, KMailICalIface::StorageFormat format );
-  QString loadContact( const QString& contactData, const QString& subResource,
+  void loadSubResourceConfig( KConfig& config, const TQString& name,
+                              const TQString& label, bool writable );
+  bool loadSubResource( const TQString& subResource );
+  bool loadSubResourceHelper( const TQString& subResource, const char* mimetype, KMailICalIface::StorageFormat format );
+  TQString loadContact( const TQString& contactData, const TQString& subResource,
                        Q_UINT32 sernum, const KMailICalIface::StorageFormat format );
 
-  QString configFile() const {
+  TQString configFile() const {
     return Scalix::ResourceScalixBase::configFile( "kabc" );
   }
 
   // The list of subresources
   Scalix::ResourceMap mSubResources;
-  QString mCachedSubresource;
+  TQString mCachedSubresource;
   bool mLocked;
 };
 
diff --git a/kresources/scalix/kabc/resourcescalix_plugin.cpp b/kresources/scalix/kabc/resourcescalix_plugin.cpp
index 95bc28be..a5f289a7 100644
--- a/kresources/scalix/kabc/resourcescalix_plugin.cpp
+++ b/kresources/scalix/kabc/resourcescalix_plugin.cpp
@@ -43,7 +43,7 @@ class ScalixFactory : public KRES::PluginFactoryBase
       return new KABC::ResourceScalix( config );
     }
 
-    KRES::ConfigWidget *configWidget( QWidget* )
+    KRES::ConfigWidget *configWidget( TQWidget* )
     {
       return 0;
     }
diff --git a/kresources/scalix/kcal/resourcescalix.cpp b/kresources/scalix/kcal/resourcescalix.cpp
index 9a8beeb9..d2849e86 100644
--- a/kresources/scalix/kcal/resourcescalix.cpp
+++ b/kresources/scalix/kcal/resourcescalix.cpp
@@ -43,9 +43,9 @@
 #include <kmainwindow.h>
 #include <klocale.h>
 
-#include <qobject.h>
-#include <qtimer.h>
-#include <qapplication.h>
+#include <tqobject.h>
+#include <tqtimer.h>
+#include <tqapplication.h>
 
 #include <assert.h>
 
@@ -63,11 +63,11 @@ static const char* incidenceInlineMimeType = "text/calendar";
 
 ResourceScalix::ResourceScalix( const KConfig *config )
   : ResourceCalendar( config ), ResourceScalixBase( "ResourceScalix-libkcal" ),
-    mCalendar( QString::fromLatin1("UTC") ), mOpen( false )
+    mCalendar( TQString::fromLatin1("UTC") ), mOpen( false )
 {
   setType( "scalix" );
-  connect( &mResourceChangedTimer, SIGNAL( timeout() ),
-           this, SLOT( slotEmitResourceChanged() ) );
+  connect( &mResourceChangedTimer, TQT_SIGNAL( timeout() ),
+           this, TQT_SLOT( slotEmitResourceChanged() ) );
 }
 
 ResourceScalix::~ResourceScalix()
@@ -80,8 +80,8 @@ ResourceScalix::~ResourceScalix()
 }
 
 void ResourceScalix::loadSubResourceConfig( KConfig& config,
-                                           const QString& name,
-                                           const QString& label,
+                                           const TQString& name,
+                                           const TQString& label,
                                            bool writable,
                                            ResourceMap& subResource )
 {
@@ -94,11 +94,11 @@ bool ResourceScalix::openResource( KConfig& config, const char* contentType,
                                   ResourceMap& map )
 {
   // Read the subresource entries from KMail
-  QValueList<KMailICalIface::SubResource> subResources;
+  TQValueList<KMailICalIface::SubResource> subResources;
   if ( !kmailSubresources( subResources, contentType ) )
     return false;
   map.clear();
-  QValueList<KMailICalIface::SubResource>::ConstIterator it;
+  TQValueList<KMailICalIface::SubResource>::ConstIterator it;
   for ( it = subResources.begin(); it != subResources.end(); ++it )
     loadSubResourceConfig( config, (*it).location, (*it).label, (*it).writable, map );
   return true;
@@ -142,7 +142,7 @@ void ResourceScalix::doClose()
   closeResource( config, mJournalSubResources );
 }
 
-bool ResourceScalix::loadSubResource( const QString& subResource,
+bool ResourceScalix::loadSubResource( const TQString& subResource,
                                      const char* mimetype )
 {
   int count = 0;
@@ -156,10 +156,10 @@ bool ResourceScalix::loadSubResource( const QString& subResource,
 
   const int nbMessages = 200; // read 200 mails at a time (see kabc resource)
 
-  const QString labelTxt = !strcmp(mimetype, "application/x-vnd.kolab.task") ? i18n( "Loading tasks..." )
+  const TQString labelTxt = !strcmp(mimetype, "application/x-vnd.kolab.task") ? i18n( "Loading tasks..." )
                            : !strcmp(mimetype, "application/x-vnd.kolab.journal") ? i18n( "Loading journals..." )
                            : i18n( "Loading events..." );
-  const bool useProgress = qApp && qApp->type() != QApplication::Tty && count > mProgressDialogIncidenceLimit;
+  const bool useProgress = qApp && qApp->type() != TQApplication::Tty && count > mProgressDialogIncidenceLimit;
   if ( useProgress )
     (void)::Observer::self(); // ensure kio_uiserver is running
   UIServer_stub uiserver( "kio_uiserver", "UIServer" );
@@ -172,7 +172,7 @@ bool ResourceScalix::loadSubResource( const QString& subResource,
   }
 
   for ( int startIndex = 0; startIndex < count; startIndex += nbMessages ) {
-    QMap<Q_UINT32, QString> lst;
+    TQMap<Q_UINT32, TQString> lst;
     if ( !kmailIncidences( lst, mimetype, subResource, startIndex, nbMessages ) ) {
       kdError(5650) << "Communication problem in ResourceScalix::load()\n";
       if ( progressId )
@@ -182,7 +182,7 @@ bool ResourceScalix::loadSubResource( const QString& subResource,
 
     { // for RAII scoping below
       TemporarySilencer t( this );
-      for( QMap<Q_UINT32, QString>::ConstIterator it = lst.begin(); it != lst.end(); ++it ) {
+      for( TQMap<Q_UINT32, TQString>::ConstIterator it = lst.begin(); it != lst.end(); ++it ) {
         addIncidence( mimetype, it.data(), subResource, it.key() );
       }
     }
@@ -238,7 +238,7 @@ bool ResourceScalix::loadAllJournals()
   return doLoadAll( mJournalSubResources, incidenceInlineMimeType );
 }
 
-void ResourceScalix::removeIncidences( const QCString& incidenceType )
+void ResourceScalix::removeIncidences( const TQCString& incidenceType )
 {
   Scalix::UidMap::Iterator mapIt = mUidMap.begin();
   while ( mapIt != mUidMap.end() )
@@ -250,7 +250,7 @@ void ResourceScalix::removeIncidences( const QCString& incidenceType )
 
     // A  faster but hackish way would probably be to check the type of the resource,
     // like mEventSubResources.find( it.data().resource() ) != mEventSubResources.end() ?
-    const QString& uid = it.key();
+    const TQString& uid = it.key();
     if ( incidenceType == "Event" && mCalendar.event( uid ) )
       mUidMap.remove( it );
     else if ( incidenceType == "Todo" && mCalendar.todo( uid ) )
@@ -269,12 +269,12 @@ void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* incidencebase )
 {
   if ( incidencebase->isReadOnly() ) return; // Should not happen (TM)
   incidencebase->setSyncStatus( KCal::Event::SYNCMOD );
-  incidencebase->setLastModified( QDateTime::currentDateTime() );
+  incidencebase->setLastModified( TQDateTime::currentDateTime() );
   // we should probably update the revision number here,
   // or internally in the Event itself when certain things change.
   // need to verify with ical documentation.
 
-  const QString uid = incidencebase->uid();
+  const TQString uid = incidencebase->uid();
 
   if ( mUidsPendingUpdate.contains( uid ) || mUidsPendingAdding.contains( uid ) ) {
     /* We are currently processing this event ( removing and readding or
@@ -284,7 +284,7 @@ void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* incidencebase )
     return;
   }
 
-  QString subResource;
+  TQString subResource;
   Q_UINT32 sernum = 0;
   if ( mUidMap.contains( uid ) ) {
     subResource = mUidMap[ uid ].resource();
@@ -294,7 +294,7 @@ void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* incidencebase )
   sendKMailUpdate( incidencebase, subResource, sernum );
 }
 
-void ResourceScalix::resolveConflict( KCal::Incidence* inc, const QString& subresource, Q_UINT32 sernum )
+void ResourceScalix::resolveConflict( KCal::Incidence* inc, const TQString& subresource, Q_UINT32 sernum )
 {
     if ( ! inc )
         return;
@@ -310,7 +310,7 @@ void ResourceScalix::resolveConflict( KCal::Incidence* inc, const QString& subre
         KIncidenceChooser* ch = new KIncidenceChooser();
         ch->setIncidence( local ,inc );
         if ( KIncidenceChooser::chooseMode == KIncidenceChooser::ask ) {
-            connect ( this, SIGNAL( useGlobalMode() ), ch, SLOT (  useGlobalMode() ) );
+            connect ( this, TQT_SIGNAL( useGlobalMode() ), ch, TQT_SLOT (  useGlobalMode() ) );
             if ( ch->exec() )
                 if ( KIncidenceChooser::chooseMode != KIncidenceChooser::ask )
                     emit useGlobalMode() ;
@@ -343,8 +343,8 @@ void ResourceScalix::resolveConflict( KCal::Incidence* inc, const QString& subre
       mSilent = silent;
   }
 }
-void ResourceScalix::addIncidence( const char* mimetype, const QString& data,
-                                  const QString& subResource, Q_UINT32 sernum )
+void ResourceScalix::addIncidence( const char* mimetype, const TQString& data,
+                                  const TQString& subResource, Q_UINT32 sernum )
 {
   // This uses pointer comparison, so it only works if we use the static
   // objects defined in the top of the file
@@ -353,12 +353,12 @@ void ResourceScalix::addIncidence( const char* mimetype, const QString& data,
 }
 
 
-bool ResourceScalix::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const QString& subresource,
+bool ResourceScalix::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const TQString& subresource,
                                      Q_UINT32 sernum )
 {
-  const QString& type = incidencebase->type();
+  const TQString& type = incidencebase->type();
   const char* mimetype = 0;
-  QString data;
+  TQString data;
   if ( type == "Event" ) {
     mimetype = incidenceInlineMimeType;
     data = mFormat.createScheduleMessage( static_cast<KCal::Event *>(incidencebase),
@@ -385,7 +385,7 @@ bool ResourceScalix::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const
   else if ( type == "Todo" )
     customHeaders.insert( "X-Scalix-Class", "IPM.Task" );
 
-  QString subject = incidence->summary();
+  TQString subject = incidence->summary();
 
   // behold, sernum is an in-parameter
   const bool rc = kmailUpdate( subresource, sernum, data, mimetype, subject, customHeaders );
@@ -396,17 +396,17 @@ bool ResourceScalix::sendKMailUpdate( KCal::IncidenceBase* incidencebase, const
   return rc;
 }
 
-bool ResourceScalix::addIncidence( KCal::Incidence* incidence, const QString& _subresource,
+bool ResourceScalix::addIncidence( KCal::Incidence* incidence, const TQString& _subresource,
                                   Q_UINT32 sernum )
 {
   Q_ASSERT( incidence );
   if ( !incidence ) return false;
-  const QString &uid = incidence->uid();
-  QString subResource = _subresource;
+  const TQString &uid = incidence->uid();
+  TQString subResource = _subresource;
 
   Scalix::ResourceMap *map = &mEventSubResources; // don't use a ref here!
 
-  const QString& type = incidence->type();
+  const TQString& type = incidence->type();
   if ( type == "Event" )
     map = &mEventSubResources;
   else if ( type == "Todo" )
@@ -507,14 +507,14 @@ bool ResourceScalix::addEvent( KCal::Event* event )
   if ( mUidMap.contains( event->uid() ) )
     return true; //noop
   else
-    return addIncidence( event, QString::null, 0 );
+    return addIncidence( event, TQString::null, 0 );
 }
 
 bool ResourceScalix::deleteIncidence( KCal::Incidence* incidence )
 {
   if ( incidence->isReadOnly() ) return false;
 
-  const QString uid = incidence->uid();
+  const TQString uid = incidence->uid();
   if( !mUidMap.contains( uid ) ) return false; // Odd
   /* The user told us to delete, tell KMail */
   if ( !mSilent ) {
@@ -535,7 +535,7 @@ bool ResourceScalix::deleteEvent( KCal::Event* event )
   return deleteIncidence( event );
 }
 
-KCal::Event* ResourceScalix::event( const QString& uid )
+KCal::Event* ResourceScalix::event( const TQString& uid )
 {
   return mCalendar.event(uid);
 }
@@ -545,20 +545,20 @@ KCal::Event::List ResourceScalix::rawEvents( EventSortField sortField, SortDirec
   return mCalendar.rawEvents( sortField, sortDirection );
 }
 
-KCal::Event::List ResourceScalix::rawEventsForDate( const QDate& date,
+KCal::Event::List ResourceScalix::rawEventsForDate( const TQDate& date,
                                                    EventSortField sortField,
                                                    SortDirection sortDirection )
 {
   return mCalendar.rawEventsForDate( date, sortField, sortDirection );
 }
 
-KCal::Event::List ResourceScalix::rawEventsForDate( const QDateTime& qdt )
+KCal::Event::List ResourceScalix::rawEventsForDate( const TQDateTime& qdt )
 {
   return mCalendar.rawEventsForDate( qdt );
 }
 
-KCal::Event::List ResourceScalix::rawEvents( const QDate& start,
-                                            const QDate& end,
+KCal::Event::List ResourceScalix::rawEvents( const TQDate& start,
+                                            const TQDate& end,
                                             bool inclusive )
 {
   return mCalendar.rawEvents( start, end, inclusive );
@@ -569,7 +569,7 @@ bool ResourceScalix::addTodo( KCal::Todo* todo )
   if ( mUidMap.contains( todo->uid() ) )
     return true; //noop
   else
-    return addIncidence( todo, QString::null, 0 );
+    return addIncidence( todo, TQString::null, 0 );
 }
 
 bool ResourceScalix::deleteTodo( KCal::Todo* todo )
@@ -577,7 +577,7 @@ bool ResourceScalix::deleteTodo( KCal::Todo* todo )
   return deleteIncidence( todo );
 }
 
-KCal::Todo* ResourceScalix::todo( const QString& uid )
+KCal::Todo* ResourceScalix::todo( const TQString& uid )
 {
   return mCalendar.todo( uid );
 }
@@ -587,7 +587,7 @@ KCal::Todo::List ResourceScalix::rawTodos( TodoSortField sortField, SortDirectio
   return mCalendar.rawTodos( sortField, sortDirection );
 }
 
-KCal::Todo::List ResourceScalix::rawTodosForDate( const QDate& date )
+KCal::Todo::List ResourceScalix::rawTodosForDate( const TQDate& date )
 {
   return mCalendar.rawTodosForDate( date );
 }
@@ -597,7 +597,7 @@ bool ResourceScalix::addJournal( KCal::Journal* journal )
   if ( mUidMap.contains( journal->uid() ) )
     return true; //noop
   else
-    return addIncidence( journal, QString::null, 0 );
+    return addIncidence( journal, TQString::null, 0 );
 }
 
 bool ResourceScalix::deleteJournal( KCal::Journal* journal )
@@ -605,7 +605,7 @@ bool ResourceScalix::deleteJournal( KCal::Journal* journal )
   return deleteIncidence( journal );
 }
 
-KCal::Journal* ResourceScalix::journal( const QString& uid )
+KCal::Journal* ResourceScalix::journal( const TQString& uid )
 {
   return mCalendar.journal(uid);
 }
@@ -615,33 +615,33 @@ KCal::Journal::List ResourceScalix::rawJournals( JournalSortField sortField, Sor
   return mCalendar.rawJournals( sortField, sortDirection );
 }
 
-KCal::Journal::List ResourceScalix::rawJournalsForDate( const QDate &date )
+KCal::Journal::List ResourceScalix::rawJournalsForDate( const TQDate &date )
 {
   return mCalendar.rawJournalsForDate( date );
 }
 
-KCal::Alarm::List ResourceScalix::alarms( const QDateTime& from,
-                                         const QDateTime& to )
+KCal::Alarm::List ResourceScalix::alarms( const TQDateTime& from,
+                                         const TQDateTime& to )
 {
   return mCalendar.alarms( from, to );
 }
 
-KCal::Alarm::List ResourceScalix::alarmsTo( const QDateTime& to )
+KCal::Alarm::List ResourceScalix::alarmsTo( const TQDateTime& to )
 {
   return mCalendar.alarmsTo(to);
 }
 
-void ResourceScalix::setTimeZoneId( const QString& tzid )
+void ResourceScalix::setTimeZoneId( const TQString& tzid )
 {
   mCalendar.setTimeZoneId( tzid );
   mFormat.setTimeZone( mCalendar.timeZoneId(), !mCalendar.isLocalTime() );
 }
 
-bool ResourceScalix::fromKMailAddIncidence( const QString& type,
-                                           const QString& subResource,
+bool ResourceScalix::fromKMailAddIncidence( const TQString& type,
+                                           const TQString& subResource,
                                            Q_UINT32 sernum,
                                            int /*format*/,
-                                           const QString& data )
+                                           const TQString& data )
 {
   bool rc = true;
   TemporarySilencer t( this ); // RAII
@@ -660,9 +660,9 @@ bool ResourceScalix::fromKMailAddIncidence( const QString& type,
   return rc;
 }
 
-void ResourceScalix::fromKMailDelIncidence( const QString& type,
-                                           const QString& subResource,
-                                           const QString& uid )
+void ResourceScalix::fromKMailDelIncidence( const TQString& type,
+                                           const TQString& subResource,
+                                           const TQString& uid )
 {
   if ( type != kmailCalendarContentsType && type != kmailTodoContentsType
        && type != kmailJournalContentsType )
@@ -688,8 +688,8 @@ void ResourceScalix::fromKMailDelIncidence( const QString& type,
   }
 }
 
-void ResourceScalix::fromKMailRefresh( const QString& type,
-                                      const QString& /*subResource*/ )
+void ResourceScalix::fromKMailRefresh( const TQString& type,
+                                      const TQString& /*subResource*/ )
 {
   // TODO: Only load the specified subResource
   if ( type == "Calendar" )
@@ -703,9 +703,9 @@ void ResourceScalix::fromKMailRefresh( const QString& type,
   mResourceChangedTimer.changeInterval( 100 );
 }
 
-void ResourceScalix::fromKMailAddSubresource( const QString& type,
-                                             const QString& subResource,
-                                             const QString& label,
+void ResourceScalix::fromKMailAddSubresource( const TQString& type,
+                                             const TQString& subResource,
+                                             const TQString& label,
                                              bool writable )
 {
   ResourceMap* map = 0;
@@ -736,8 +736,8 @@ void ResourceScalix::fromKMailAddSubresource( const QString& type,
   emit signalSubresourceAdded( this, type, subResource, label );
 }
 
-void ResourceScalix::fromKMailDelSubresource( const QString& type,
-                                             const QString& subResource )
+void ResourceScalix::fromKMailDelSubresource( const TQString& type,
+                                             const TQString& subResource )
 {
   ResourceMap* map = subResourceMap( type );
   if ( !map ) // not ours
@@ -755,7 +755,7 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
 
   // Make a list of all uids to remove
   Scalix::UidMap::ConstIterator mapIt;
-  QStringList uids;
+  TQStringList uids;
   for ( mapIt = mUidMap.begin(); mapIt != mUidMap.end(); ++mapIt )
     if ( mapIt.data().resource() == subResource )
       // We have a match
@@ -764,7 +764,7 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
   // Finally delete all the incidences
   if ( !uids.isEmpty() ) {
     TemporarySilencer t( this );
-    QStringList::ConstIterator it;
+    TQStringList::ConstIterator it;
     for ( it = uids.begin(); it != uids.end(); ++it ) {
       KCal::Incidence* incidence = mCalendar.incidence( *it );
       if( incidence )
@@ -776,7 +776,7 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
   emit signalSubresourceRemoved( this, type, subResource );
 }
 
-QStringList ResourceScalix::subresources() const
+TQStringList ResourceScalix::subresources() const
 {
   // Workaround: The ResourceView in KOrganizer wants to know this
   // before it opens the resource :-( Make sure we are open
@@ -787,7 +787,7 @@ QStringList ResourceScalix::subresources() const
 }
 
 const QString
-ResourceScalix::labelForSubresource( const QString& subresource ) const
+ResourceScalix::labelForSubresource( const TQString& subresource ) const
 {
   if ( mEventSubResources.contains( subresource ) )
     return mEventSubResources[ subresource ].label();
@@ -798,28 +798,28 @@ ResourceScalix::labelForSubresource( const QString& subresource ) const
   return subresource;
 }
 
-QString ResourceScalix::subresourceIdentifier( Incidence *incidence )
+TQString ResourceScalix::subresourceIdentifier( Incidence *incidence )
 {
-  QString uid = incidence->uid();
+  TQString uid = incidence->uid();
   if ( mUidMap.contains( uid ) )
     return mUidMap[ uid ].resource();
   else
     if ( mNewIncidencesMap.contains( uid ) )
       return mNewIncidencesMap[ uid ];
     else
-      return QString();
+      return TQString();
 }
 
-void ResourceScalix::fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                              const QString& type,
-                                              const QString& folder )
+void ResourceScalix::fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                              const TQString& type,
+                                              const TQString& folder )
 {
   TemporarySilencer t( this );
-  for( QMap<Q_UINT32, QString>::ConstIterator it = map.begin(); it != map.end(); ++it )
+  for( TQMap<Q_UINT32, TQString>::ConstIterator it = map.begin(); it != map.end(); ++it )
     addIncidence( type.latin1(), it.data(), folder, it.key() );
 }
 
-bool ResourceScalix::subresourceActive( const QString& subresource ) const
+bool ResourceScalix::subresourceActive( const TQString& subresource ) const
 {
   // Workaround: The ResourceView in KOrganizer wants to know this
   // before it opens the resource :-( Make sure we are open
@@ -838,7 +838,7 @@ bool ResourceScalix::subresourceActive( const QString& subresource ) const
   return true;
 }
 
-void ResourceScalix::setSubresourceActive( const QString &subresource, bool v )
+void ResourceScalix::setSubresourceActive( const TQString &subresource, bool v )
 {
   ResourceMap *map = 0;
 
@@ -869,7 +869,7 @@ KABC::Lock* ResourceScalix::lock()
 }
 
 
-Scalix::ResourceMap* ResourceScalix::subResourceMap( const QString& contentsType )
+Scalix::ResourceMap* ResourceScalix::subResourceMap( const TQString& contentsType )
 {
   if ( contentsType == kmailCalendarContentsType ) {
     return &mEventSubResources;
diff --git a/kresources/scalix/kcal/resourcescalix.h b/kresources/scalix/kcal/resourcescalix.h
index 0c845a6c..223161b4 100644
--- a/kresources/scalix/kcal/resourcescalix.h
+++ b/kresources/scalix/kcal/resourcescalix.h
@@ -34,7 +34,7 @@
 #ifndef KCAL_RESOURCESCALIX_H
 #define KCAL_RESOURCESCALIX_H
 
-#include <qtimer.h>
+#include <tqtimer.h>
 
 #include <kdepimmacros.h>
 #include <libkcal/calendarlocal.h>
@@ -71,63 +71,63 @@ public:
   // The libkcal functions. See the resource for descriptions
   bool addEvent( KCal::Event* anEvent );
   bool deleteEvent( KCal::Event* );
-  KCal::Event* event( const QString &UniqueStr );
+  KCal::Event* event( const TQString &UniqueStr );
   KCal::Event::List rawEvents( EventSortField sortField = EventSortUnsorted, SortDirection sortDirection = SortDirectionAscending );
   KCal::Event::List rawEventsForDate(
-    const QDate& date,
+    const TQDate& date,
     EventSortField sortField=EventSortUnsorted,
     SortDirection sortDirection=SortDirectionAscending );
-  KCal::Event::List rawEventsForDate( const QDateTime& qdt );
-  KCal::Event::List rawEvents( const QDate& start, const QDate& end,
+  KCal::Event::List rawEventsForDate( const TQDateTime& qdt );
+  KCal::Event::List rawEvents( const TQDate& start, const TQDate& end,
                                bool inclusive = false );
 
   bool addTodo( KCal::Todo* todo );
   bool deleteTodo( KCal::Todo* );
-  KCal::Todo* todo( const QString& uid );
+  KCal::Todo* todo( const TQString& uid );
   KCal::Todo::List rawTodos( TodoSortField sortField = TodoSortUnsorted, SortDirection sortDirection = SortDirectionAscending );
-  KCal::Todo::List rawTodosForDate( const QDate& date );
+  KCal::Todo::List rawTodosForDate( const TQDate& date );
 
   bool addJournal( KCal::Journal* );
   bool deleteJournal( KCal::Journal* );
-  KCal::Journal* journal( const QString& uid );
+  KCal::Journal* journal( const TQString& uid );
   KCal::Journal::List rawJournals( JournalSortField sortField = JournalSortUnsorted, SortDirection sortDirection = SortDirectionAscending );
-  KCal::Journal::List rawJournalsForDate( const QDate &date );
+  KCal::Journal::List rawJournalsForDate( const TQDate &date );
 
-  KCal::Alarm::List alarms( const QDateTime& from, const QDateTime& to );
-  KCal::Alarm::List alarmsTo( const QDateTime& to );
+  KCal::Alarm::List alarms( const TQDateTime& from, const TQDateTime& to );
+  KCal::Alarm::List alarmsTo( const TQDateTime& to );
 
-  void setTimeZoneId( const QString& tzid );
+  void setTimeZoneId( const TQString& tzid );
 
   bool deleteIncidence( KCal::Incidence* i );
 
   /// The ResourceScalixBase methods called by KMail
-  bool fromKMailAddIncidence( const QString& type, const QString& subResource,
-                              Q_UINT32 sernum, int format, const QString& data );
-  void fromKMailDelIncidence( const QString& type, const QString& subResource,
-                              const QString& uid );
-  void fromKMailRefresh( const QString& type, const QString& subResource );
+  bool fromKMailAddIncidence( const TQString& type, const TQString& subResource,
+                              Q_UINT32 sernum, int format, const TQString& data );
+  void fromKMailDelIncidence( const TQString& type, const TQString& subResource,
+                              const TQString& uid );
+  void fromKMailRefresh( const TQString& type, const TQString& subResource );
 
   /// Listen to KMail changes in the amount of sub resources
-  void fromKMailAddSubresource( const QString& type, const QString& subResource,
-                                const QString& label, bool writable );
-  void fromKMailDelSubresource( const QString& type, const QString& subResource );
+  void fromKMailAddSubresource( const TQString& type, const TQString& subResource,
+                                const TQString& label, bool writable );
+  void fromKMailDelSubresource( const TQString& type, const TQString& subResource );
 
-  void fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                 const QString& type,
-                                 const QString& folder );
+  void fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                 const TQString& type,
+                                 const TQString& folder );
 
   /** Return the list of subresources. */
-  QStringList subresources() const;
+  TQStringList subresources() const;
 
   /** Is this subresource active? */
-  bool subresourceActive( const QString& ) const;
+  bool subresourceActive( const TQString& ) const;
   /** (De)activate the subresource */
-  virtual void setSubresourceActive( const QString &, bool );
+  virtual void setSubresourceActive( const TQString &, bool );
 
   /** What is the label for this subresource? */
-  virtual const QString labelForSubresource( const QString& resource ) const;
+  virtual const TQString labelForSubresource( const TQString& resource ) const;
 
-  virtual QString subresourceIdentifier( Incidence *incidence );
+  virtual TQString subresourceIdentifier( Incidence *incidence );
 
   KABC::Lock* lock();
 
@@ -137,20 +137,20 @@ protected slots:
    void slotEmitResourceChanged();
 
 private:
-  void removeIncidences( const QCString& incidenceType );
-  void resolveConflict( KCal::Incidence*, const QString& subresource, Q_UINT32 sernum );
+  void removeIncidences( const TQCString& incidenceType );
+  void resolveConflict( KCal::Incidence*, const TQString& subresource, Q_UINT32 sernum );
 
-  void addIncidence( const char* mimetype, const QString& xml,
-                     const QString& subResource, Q_UINT32 sernum );
+  void addIncidence( const char* mimetype, const TQString& xml,
+                     const TQString& subResource, Q_UINT32 sernum );
 
-  bool addIncidence( KCal::Incidence* i, const QString& subresource,
+  bool addIncidence( KCal::Incidence* i, const TQString& subresource,
                      Q_UINT32 sernum );
 /*
-  void addEvent( const QString& xml, const QString& subresource,
+  void addEvent( const TQString& xml, const TQString& subresource,
                  Q_UINT32 sernum );
-  void addTodo( const QString& xml, const QString& subresource,
+  void addTodo( const TQString& xml, const TQString& subresource,
                 Q_UINT32 sernum );
-  void addJournal( const QString& xml, const QString& subresource,
+  void addJournal( const TQString& xml, const TQString& subresource,
                    Q_UINT32 sernum );
 */
 
@@ -165,18 +165,18 @@ private:
 
   bool openResource( KConfig& config, const char* contentType,
                      Scalix::ResourceMap& map );
-  void loadSubResourceConfig( KConfig& config, const QString& name,
-                              const QString& label, bool writable,
+  void loadSubResourceConfig( KConfig& config, const TQString& name,
+                              const TQString& label, bool writable,
                               Scalix::ResourceMap& subResource );
-  bool loadSubResource( const QString& subResource, const char* mimetype );
+  bool loadSubResource( const TQString& subResource, const char* mimetype );
 
-  QString configFile() const {
+  TQString configFile() const {
     return ResourceScalixBase::configFile( "kcal" );
   }
 
-  Scalix::ResourceMap* subResourceMap( const QString& contentsType );
+  Scalix::ResourceMap* subResourceMap( const TQString& contentsType );
 
-  bool sendKMailUpdate( KCal::IncidenceBase* incidence, const QString& _subresource,
+  bool sendKMailUpdate( KCal::IncidenceBase* incidence, const TQString& _subresource,
                         Q_UINT32 sernum );
 
 
@@ -186,8 +186,8 @@ private:
   Scalix::ResourceMap mEventSubResources, mTodoSubResources, mJournalSubResources;
 
   bool mOpen; // If the resource is open, this is true
-  QDict<KCal::IncidenceBase> mPendingUpdates;
-  QTimer mResourceChangedTimer;
+  TQDict<KCal::IncidenceBase> mPendingUpdates;
+  TQTimer mResourceChangedTimer;
   ICalFormat mFormat;
 
   /**
@@ -197,7 +197,7 @@ private:
 
     We can't trust on mUidMap here, because it contains only non-pending uids.
    */
-  QMap<QString, QString> mNewIncidencesMap;
+  TQMap<TQString, TQString> mNewIncidencesMap;
   int mProgressDialogIncidenceLimit;
 };
 
diff --git a/kresources/scalix/kcal/resourcescalix_plugin.cpp b/kresources/scalix/kcal/resourcescalix_plugin.cpp
index 53ac6705..a36f5bf2 100644
--- a/kresources/scalix/kcal/resourcescalix_plugin.cpp
+++ b/kresources/scalix/kcal/resourcescalix_plugin.cpp
@@ -41,7 +41,7 @@ public:
     return new KCal::ResourceScalix( config );
   }
 
-  KRES::ConfigWidget *configWidget( QWidget* )
+  KRES::ConfigWidget *configWidget( TQWidget* )
   {
     return 0;
   }
diff --git a/kresources/scalix/kioslave/scalix.cpp b/kresources/scalix/kioslave/scalix.cpp
index 199bd098..043b0f4a 100644
--- a/kresources/scalix/kioslave/scalix.cpp
+++ b/kresources/scalix/kioslave/scalix.cpp
@@ -18,8 +18,8 @@
     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
 
-#include <qapplication.h>
-#include <qeventloop.h>
+#include <tqapplication.h>
+#include <tqeventloop.h>
 
 #include <kapplication.h>
 #include <kcmdlineargs.h>
@@ -62,7 +62,7 @@ int kdemain( int argc, char **argv )
   return 0;
 }
 
-Scalix::Scalix( const QCString &protocol, const QCString &pool, const QCString &app )
+Scalix::Scalix( const TQCString &protocol, const TQCString &pool, const TQCString &app )
   : SlaveBase( protocol, pool, app )
 {
 }
@@ -71,7 +71,7 @@ void Scalix::get( const KURL &url )
 {
   mimeType( "text/plain" );
 
-  QString path = url.path();
+  TQString path = url.path();
 
   if ( path.contains( "/freebusy/" ) ) {
     retrieveFreeBusy( url );
@@ -82,7 +82,7 @@ void Scalix::get( const KURL &url )
 
 void Scalix::put( const KURL& url, int, bool, bool )
 {
-  QString path = url.path();
+  TQString path = url.path();
 
   if ( path.contains( "/freebusy/" ) ) {
     publishFreeBusy( url );
@@ -99,27 +99,27 @@ void Scalix::retrieveFreeBusy( const KURL &url )
    */
 
   // Extract user@domain (e.g. everything between '/freebusy/' and '.ifb')
-  const QString requestUser = url.path().mid( 10, url.path().length() - 14 );
+  const TQString requestUser = url.path().mid( 10, url.path().length() - 14 );
 
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
 
-  const QString argument = QString( "BEGIN:VFREEBUSY\nATTENDEE:MAILTO:%1\nEND:VFREEBUSY" ).arg( requestUser );
-  const QString command = QString( "X-GET-ICAL-FREEBUSY {%1}" ).arg( argument.length() );
+  const TQString argument = TQString( "BEGIN:VFREEBUSY\nATTENDEE:MAILTO:%1\nEND:VFREEBUSY" ).arg( requestUser );
+  const TQString command = TQString( "X-GET-ICAL-FREEBUSY {%1}" ).arg( argument.length() );
 
   stream << (int) 'X' << 'E' << command << argument;
 
-  QString imapUrl = QString( "imap://%1@%3/" ).arg( url.pass().isEmpty() ?
+  TQString imapUrl = TQString( "imap://%1@%3/" ).arg( url.pass().isEmpty() ?
                                                    url.user() : url.user() + ":" + url.pass() )
                                                 .arg( url.host() );
 
-  mFreeBusyData = QString();
+  mFreeBusyData = TQString();
 
   KIO::SimpleJob *job = KIO::special( imapUrl, packedArgs, false );
-  connect( job, SIGNAL( infoMessage( KIO::Job*, const QString& ) ),
-           this, SLOT( slotInfoMessage( KIO::Job*, const QString& ) ) );
-  connect( job, SIGNAL( result( KIO::Job* ) ),
-           this, SLOT( slotRetrieveResult( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( infoMessage( KIO::Job*, const TQString& ) ),
+           this, TQT_SLOT( slotInfoMessage( KIO::Job*, const TQString& ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ),
+           this, TQT_SLOT( slotRetrieveResult( KIO::Job* ) ) );
 
   qApp->eventLoop()->enterLoop();
 }
@@ -130,8 +130,8 @@ void Scalix::publishFreeBusy( const KURL &url )
    * The url is of the following form:
    *  scalix://user:password@host/freebusy/path/to/calendar/user@domain
    */
-  QString requestUser, calendar;
-  QString path = url.path();
+  TQString requestUser, calendar;
+  TQString path = url.path();
 
   // extract user name
   int lastSlash = path.findRev( '/' );
@@ -149,11 +149,11 @@ void Scalix::publishFreeBusy( const KURL &url )
   };
 
   // read freebusy information
-  QByteArray data;
+  TQByteArray data;
   while ( true ) {
     dataReq();
 
-    QByteArray buffer;
+    TQByteArray buffer;
     const int newSize = readData(buffer);
     if ( newSize < 0 ) {
       // read error: network in unknown state so disconnect
@@ -169,26 +169,26 @@ void Scalix::publishFreeBusy( const KURL &url )
     memcpy( data.data() + oldSize, buffer.data(), buffer.size() );
   }
 
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
 
-  const QString argument = QString::fromUtf8( data );
-  const QString command = QString( "X-PUT-ICAL-FREEBUSY Calendar {%1}" ).arg( argument.length() );
+  const TQString argument = TQString::fromUtf8( data );
+  const TQString command = TQString( "X-PUT-ICAL-FREEBUSY Calendar {%1}" ).arg( argument.length() );
 
   stream << (int) 'X' << 'E' << command << argument;
 
-  QString imapUrl = QString( "imap://%1@%3/" ).arg( url.pass().isEmpty() ?
+  TQString imapUrl = TQString( "imap://%1@%3/" ).arg( url.pass().isEmpty() ?
                                                    url.user() : url.user() + ":" + url.pass() )
                                                 .arg( url.host() );
 
   KIO::SimpleJob *job = KIO::special( imapUrl, packedArgs, false );
-  connect( job, SIGNAL( result( KIO::Job* ) ),
-           this, SLOT( slotPublishResult( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ),
+           this, TQT_SLOT( slotPublishResult( KIO::Job* ) ) );
 
   qApp->eventLoop()->enterLoop();
 }
 
-void Scalix::slotInfoMessage( KIO::Job *job, const QString &data )
+void Scalix::slotInfoMessage( KIO::Job *job, const TQString &data )
 {
   if ( job->error() ) {
     // error is handled in slotResult
diff --git a/kresources/scalix/kioslave/scalix.h b/kresources/scalix/kioslave/scalix.h
index 3697c49d..25a2fdea 100644
--- a/kresources/scalix/kioslave/scalix.h
+++ b/kresources/scalix/kioslave/scalix.h
@@ -24,14 +24,14 @@
 #include <kio/job.h>
 #include <kio/slavebase.h>
 
-#include <qobject.h>
+#include <tqobject.h>
 
-class Scalix : public QObject, public KIO::SlaveBase
+class Scalix : public TQObject, public KIO::SlaveBase
 {
   Q_OBJECT
 
   public:
-    Scalix( const QCString &protocol, const QCString &pool, const QCString &app );
+    Scalix( const TQCString &protocol, const TQCString &pool, const TQCString &app );
 
     void get( const KURL &url );
     void put( const KURL &url, int permissions, bool overwrite, bool resume );
@@ -39,13 +39,13 @@ class Scalix : public QObject, public KIO::SlaveBase
   private slots:
     void slotRetrieveResult( KIO::Job* );
     void slotPublishResult( KIO::Job* );
-    void slotInfoMessage( KIO::Job*, const QString& );
+    void slotInfoMessage( KIO::Job*, const TQString& );
 
   private:
     void retrieveFreeBusy( const KURL& );
     void publishFreeBusy( const KURL& );
 
-    QString mFreeBusyData;
+    TQString mFreeBusyData;
 };
 
 #endif
diff --git a/kresources/scalix/knotes/resourcescalix.cpp b/kresources/scalix/knotes/resourcescalix.cpp
index e43a9a91..2b789528 100644
--- a/kresources/scalix/knotes/resourcescalix.cpp
+++ b/kresources/scalix/knotes/resourcescalix.cpp
@@ -49,7 +49,7 @@ static const char* inlineMimeType = "text/calendar";
 
 ResourceScalix::ResourceScalix( const KConfig *config )
   : ResourceNotes( config ), ResourceScalixBase( "ResourceScalix-KNotes" ),
-    mCalendar( QString::fromLatin1("UTC") )
+    mCalendar( TQString::fromLatin1("UTC") )
 {
   setType( "scalix" );
 }
@@ -64,15 +64,15 @@ bool ResourceScalix::doOpen()
   config.setGroup( configGroupName );
 
   // Get the list of Notes folders from KMail
-  QValueList<KMailICalIface::SubResource> subResources;
+  TQValueList<KMailICalIface::SubResource> subResources;
   if ( !kmailSubresources( subResources, kmailContentsType ) )
     return false;
 
   // Make the resource map from the folder list
-  QValueList<KMailICalIface::SubResource>::ConstIterator it;
+  TQValueList<KMailICalIface::SubResource>::ConstIterator it;
   mSubResources.clear();
   for ( it = subResources.begin(); it != subResources.end(); ++it ) {
-    const QString subResource = (*it).location;
+    const TQString subResource = (*it).location;
     const bool active = config.readBoolEntry( subResource, true );
     mSubResources[ subResource ] = Scalix::SubResource( active, (*it).writable, (*it).label );
   }
@@ -89,8 +89,8 @@ void ResourceScalix::doClose()
     config.writeEntry( it.key(), it.data().active() );
 }
 
-bool ResourceScalix::loadSubResource( const QString& subResource,
-                                     const QString &mimetype )
+bool ResourceScalix::loadSubResource( const TQString& subResource,
+                                     const TQString &mimetype )
 {
   // Get the list of journals
   int count = 0;
@@ -99,7 +99,7 @@ bool ResourceScalix::loadSubResource( const QString& subResource,
     return false;
   }
 
-  QMap<Q_UINT32, QString> lst;
+  TQMap<Q_UINT32, TQString> lst;
   if( !kmailIncidences( lst, mimetype, subResource, 0, count ) ) {
     kdError(5500) << "Communication problem in "
                   << "ResourceScalix::getIncidenceList()\n";
@@ -111,7 +111,7 @@ bool ResourceScalix::loadSubResource( const QString& subResource,
   // Populate with the new entries
   const bool silent = mSilent;
   mSilent = true;
-  QMap<Q_UINT32, QString>::Iterator it;
+  TQMap<Q_UINT32, TQString>::Iterator it;
   for ( it = lst.begin(); it != lst.end(); ++it ) {
     KCal::Journal* journal = addNote( it.data(), subResource, it.key(), mimetype );
     if ( !journal )
@@ -137,7 +137,7 @@ bool ResourceScalix::load()
       // This subResource is disabled
       continue;
 
-    QString mimetype = inlineMimeType;
+    TQString mimetype = inlineMimeType;
     rc &= loadSubResource( itR.key(), mimetype );
     mimetype = attachmentMimeType;
     rc &= loadSubResource( itR.key(), mimetype );
@@ -154,11 +154,11 @@ bool ResourceScalix::save()
 
 bool ResourceScalix::addNote( KCal::Journal* journal )
 {
-  return addNote( journal, QString::null, 0 );
+  return addNote( journal, TQString::null, 0 );
 }
 
-KCal::Journal* ResourceScalix::addNote( const QString& data, const QString& subresource,
-                             Q_UINT32 sernum, const QString& )
+KCal::Journal* ResourceScalix::addNote( const TQString& data, const TQString& subresource,
+                             Q_UINT32 sernum, const TQString& )
 {
   KCal::Journal* journal = 0;
     // FIXME: This does not take into account the time zone!
@@ -175,7 +175,7 @@ KCal::Journal* ResourceScalix::addNote( const QString& data, const QString& subr
 }
 
 bool ResourceScalix::addNote( KCal::Journal* journal,
-                             const QString& subresource, Q_UINT32 sernum )
+                             const TQString& subresource, Q_UINT32 sernum )
 {
   kdDebug(5500) << "ResourceScalix::addNote( KCal::Journal*, '" << subresource << "', " << sernum << " )\n";
 
@@ -185,14 +185,14 @@ bool ResourceScalix::addNote( KCal::Journal* journal,
   bool newNote = subresource.isEmpty();
   mCalendar.addJournal( journal );
 
-  QString resource =
+  TQString resource =
     newNote ? findWritableResource( mSubResources ) : subresource;
   if ( resource.isEmpty() ) // canceled
     return false;
 
   if ( !mSilent ) {
     KCal::ICalFormat formatter;
-    const QString xml = formatter.toString( journal );
+    const TQString xml = formatter.toString( journal );
     kdDebug(5500) << k_funcinfo << "XML string:\n" << xml << endl;
 
     if( !kmailUpdate( resource, sernum, xml, attachmentMimeType, journal->uid() ) ) {
@@ -211,7 +211,7 @@ bool ResourceScalix::addNote( KCal::Journal* journal,
 
 bool ResourceScalix::deleteNote( KCal::Journal* journal )
 {
-  const QString uid = journal->uid();
+  const TQString uid = journal->uid();
   if ( !mUidMap.contains( uid ) )
     // Odd
     return false;
@@ -226,20 +226,20 @@ bool ResourceScalix::deleteNote( KCal::Journal* journal )
   return true;
 }
 
-KCal::Alarm::List ResourceScalix::alarms( const QDateTime& from, const QDateTime& to )
+KCal::Alarm::List ResourceScalix::alarms( const TQDateTime& from, const TQDateTime& to )
 {
     KCal::Alarm::List alarms;
     KCal::Journal::List notes = mCalendar.journals();
     KCal::Journal::List::ConstIterator note;
     for ( note = notes.begin(); note != notes.end(); ++note )
     {
-        QDateTime preTime = from.addSecs( -1 );
+        TQDateTime preTime = from.addSecs( -1 );
         KCal::Alarm::List::ConstIterator it;
         for( it = (*note)->alarms().begin(); it != (*note)->alarms().end(); ++it )
         {
             if ( (*it)->enabled() )
             {
-                QDateTime dt = (*it)->nextRepetition( preTime );
+                TQDateTime dt = (*it)->nextRepetition( preTime );
                 if ( dt.isValid() && dt <= to )
                     alarms.append( *it );
             }
@@ -251,7 +251,7 @@ KCal::Alarm::List ResourceScalix::alarms( const QDateTime& from, const QDateTime
 
 void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* i )
 {
-  QString subResource;
+  TQString subResource;
   Q_UINT32 sernum;
   if ( mUidMap.contains( i->uid() ) ) {
     subResource = mUidMap[ i->uid() ].resource();
@@ -265,7 +265,7 @@ void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* i )
 
   KCal::Journal* journal = dynamic_cast<KCal::Journal*>( i );
   KCal::ICalFormat formatter;
-  const QString xml = formatter.toString( journal );
+  const TQString xml = formatter.toString( journal );
   if( !xml.isEmpty() && kmailUpdate( subResource, sernum, xml, attachmentMimeType, journal->uid() ) )
     mUidMap[ i->uid() ] = StorageReference( subResource, sernum );
 }
@@ -274,18 +274,18 @@ void ResourceScalix::incidenceUpdated( KCal::IncidenceBase* i )
  * These are the DCOP slots that KMail call to notify when something
  * changed.
  */
-bool ResourceScalix::fromKMailAddIncidence( const QString& type,
-                                           const QString& subResource,
+bool ResourceScalix::fromKMailAddIncidence( const TQString& type,
+                                           const TQString& subResource,
                                            Q_UINT32 sernum,
                                            int,
-                                           const QString& note )
+                                           const TQString& note )
 {
   // Check if this is a note
   if( type != kmailContentsType ) return false;
 
   const bool silent = mSilent;
   mSilent = true;
-  QString mimetype = inlineMimeType;
+  TQString mimetype = inlineMimeType;
   KCal::Journal* journal = addNote( note, subResource, sernum, mimetype );
   if ( journal )
     manager()->registerNote( this, journal );
@@ -293,9 +293,9 @@ bool ResourceScalix::fromKMailAddIncidence( const QString& type,
   return true;
 }
 
-void ResourceScalix::fromKMailDelIncidence( const QString& type,
-                                           const QString& /*subResource*/,
-                                           const QString& uid )
+void ResourceScalix::fromKMailDelIncidence( const TQString& type,
+                                           const TQString& /*subResource*/,
+                                           const TQString& uid )
 {
   // Check if this is a note
   if( type != kmailContentsType ) return;
@@ -311,16 +311,16 @@ void ResourceScalix::fromKMailDelIncidence( const QString& type,
   mSilent = silent;
 }
 
-void ResourceScalix::fromKMailRefresh( const QString& type,
-                                      const QString& /*subResource*/ )
+void ResourceScalix::fromKMailRefresh( const TQString& type,
+                                      const TQString& /*subResource*/ )
 {
   if ( type == kmailContentsType )
     load(); // ### should call loadSubResource(subResource) probably
 }
 
-void ResourceScalix::fromKMailAddSubresource( const QString& type,
-                                             const QString& subResource,
-                                             const QString& mimetype,
+void ResourceScalix::fromKMailAddSubresource( const TQString& type,
+                                             const TQString& subResource,
+                                             const TQString& mimetype,
                                              bool writable )
 {
   if ( type != kmailContentsType )
@@ -340,8 +340,8 @@ void ResourceScalix::fromKMailAddSubresource( const QString& type,
   emit signalSubresourceAdded( this, type, subResource );
 }
 
-void ResourceScalix::fromKMailDelSubresource( const QString& type,
-                                             const QString& subResource )
+void ResourceScalix::fromKMailDelSubresource( const TQString& type,
+                                             const TQString& subResource )
 {
   if ( type != configGroupName )
     // Not ours
@@ -361,7 +361,7 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
 
   // Make a list of all uids to remove
   Scalix::UidMap::ConstIterator mapIt;
-  QStringList uids;
+  TQStringList uids;
   for ( mapIt = mUidMap.begin(); mapIt != mUidMap.end(); ++mapIt )
     if ( mapIt.data().resource() == subResource )
       // We have a match
@@ -371,7 +371,7 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
   if ( !uids.isEmpty() ) {
     const bool silent = mSilent;
     mSilent = true;
-    QStringList::ConstIterator it;
+    TQStringList::ConstIterator it;
     for ( it = uids.begin(); it != uids.end(); ++it ) {
       KCal::Journal* j = mCalendar.journal( *it );
       if( j )
@@ -383,17 +383,17 @@ void ResourceScalix::fromKMailDelSubresource( const QString& type,
   emit signalSubresourceRemoved( this, type, subResource );
 }
 
-void ResourceScalix::fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                              const QString& type,
-                                              const QString& folder )
+void ResourceScalix::fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                              const TQString& type,
+                                              const TQString& folder )
 {
   // We are only interested in notes
   if ( ( type != attachmentMimeType ) && ( type != inlineMimeType ) ) return;
   // Populate with the new entries
   const bool silent = mSilent;
   mSilent = true;
-  QString mimetype = inlineMimeType;
-  for( QMap<Q_UINT32, QString>::ConstIterator it = map.begin(); it != map.end(); ++it ) {
+  TQString mimetype = inlineMimeType;
+  for( TQMap<Q_UINT32, TQString>::ConstIterator it = map.begin(); it != map.end(); ++it ) {
     KCal::Journal* journal = addNote( it.data(), folder, it.key(), mimetype );
     if ( !journal )
       kdDebug(5500) << "loading note " << it.key() << " failed" << endl;
@@ -404,12 +404,12 @@ void ResourceScalix::fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& ma
 }
 
 
-QStringList ResourceScalix::subresources() const
+TQStringList ResourceScalix::subresources() const
 {
   return mSubResources.keys();
 }
 
-bool ResourceScalix::subresourceActive( const QString& res ) const
+bool ResourceScalix::subresourceActive( const TQString& res ) const
 {
   if ( mSubResources.contains( res ) ) {
     return mSubResources[ res ].active();
diff --git a/kresources/scalix/knotes/resourcescalix.h b/kresources/scalix/knotes/resourcescalix.h
index a26bd197..cb0c50fb 100644
--- a/kresources/scalix/knotes/resourcescalix.h
+++ b/kresources/scalix/knotes/resourcescalix.h
@@ -73,46 +73,46 @@ public:
 
   bool deleteNote( KCal::Journal* );
 
-  KCal::Alarm::List alarms( const QDateTime& from, const QDateTime& to );
+  KCal::Alarm::List alarms( const TQDateTime& from, const TQDateTime& to );
 
   /// Reimplemented from IncidenceBase::Observer to know when a note was changed
   void incidenceUpdated( KCal::IncidenceBase* );
 
   /// The ResourceScalixBase methods called by KMail
-  bool fromKMailAddIncidence( const QString& type, const QString& resource,
-                              Q_UINT32 sernum, int format, const QString& note );
-  void fromKMailDelIncidence( const QString& type, const QString& resource,
-                              const QString& uid );
-  void fromKMailRefresh( const QString& type, const QString& resource );
+  bool fromKMailAddIncidence( const TQString& type, const TQString& resource,
+                              Q_UINT32 sernum, int format, const TQString& note );
+  void fromKMailDelIncidence( const TQString& type, const TQString& resource,
+                              const TQString& uid );
+  void fromKMailRefresh( const TQString& type, const TQString& resource );
 
   /// Listen to KMail changes in the amount of sub resources
-  void fromKMailAddSubresource( const QString& type, const QString& resource,
-                                const QString& label, bool writable );
-  void fromKMailDelSubresource( const QString& type, const QString& resource );
+  void fromKMailAddSubresource( const TQString& type, const TQString& resource,
+                                const TQString& label, bool writable );
+  void fromKMailDelSubresource( const TQString& type, const TQString& resource );
 
-  void fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                 const QString& type,
-                                 const QString& folder );
+  void fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                 const TQString& type,
+                                 const TQString& folder );
 
   /** Return the list of subresources. */
-  QStringList subresources() const;
+  TQStringList subresources() const;
 
   /** Is this subresource active? */
-  bool subresourceActive( const QString& ) const;
+  bool subresourceActive( const TQString& ) const;
 
 signals:
-  void signalSubresourceAdded( Resource*, const QString&, const QString& );
-  void signalSubresourceRemoved( Resource*, const QString&, const QString& );
+  void signalSubresourceAdded( Resource*, const TQString&, const TQString& );
+  void signalSubresourceRemoved( Resource*, const TQString&, const TQString& );
 
 private:
-  bool addNote( KCal::Journal* journal, const QString& resource,
+  bool addNote( KCal::Journal* journal, const TQString& resource,
                 Q_UINT32 sernum );
-  KCal::Journal* addNote( const QString& data, const QString& subresource,
-                          Q_UINT32 sernum, const QString &mimetype );
+  KCal::Journal* addNote( const TQString& data, const TQString& subresource,
+                          Q_UINT32 sernum, const TQString &mimetype );
 
-  bool loadSubResource( const QString& resource, const QString& mimetype );
+  bool loadSubResource( const TQString& resource, const TQString& mimetype );
 
-  QString configFile() const {
+  TQString configFile() const {
     return ResourceScalixBase::configFile( "knotes" );
   }
 
diff --git a/kresources/scalix/knotes/resourcescalix_plugin.cpp b/kresources/scalix/knotes/resourcescalix_plugin.cpp
index a83bbd74..222d5ed6 100644
--- a/kresources/scalix/knotes/resourcescalix_plugin.cpp
+++ b/kresources/scalix/knotes/resourcescalix_plugin.cpp
@@ -41,7 +41,7 @@ public:
     return new Scalix::ResourceScalix( config );
   }
 
-  KRES::ConfigWidget *configWidget( QWidget* )
+  KRES::ConfigWidget *configWidget( TQWidget* )
   {
     return 0;
   }
diff --git a/kresources/scalix/scalixadmin/delegatedialog.cpp b/kresources/scalix/scalixadmin/delegatedialog.cpp
index 3dc0412a..661f5743 100644
--- a/kresources/scalix/scalixadmin/delegatedialog.cpp
+++ b/kresources/scalix/scalixadmin/delegatedialog.cpp
@@ -18,11 +18,11 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#include <qcheckbox.h>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qlineedit.h>
-#include <qtoolbutton.h>
+#include <tqcheckbox.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqlineedit.h>
+#include <tqtoolbutton.h>
 
 #include <klocale.h>
 
@@ -31,24 +31,24 @@
 
 #include "delegatedialog.h"
 
-DelegateDialog::DelegateDialog( QWidget *parent )
+DelegateDialog::DelegateDialog( TQWidget *parent )
   : KDialogBase( parent, "", true, "", Ok | Cancel, Ok, true )
 {
-  QWidget *page = new QWidget( this );
-  QGridLayout *layout = new QGridLayout( page, 5, 3, 11, 6 );
+  TQWidget *page = new TQWidget( this );
+  TQGridLayout *layout = new TQGridLayout( page, 5, 3, 11, 6 );
 
-  QLabel *label = new QLabel( i18n( "User:" ), page );
+  TQLabel *label = new TQLabel( i18n( "User:" ), page );
   layout->addWidget( label, 0, 0 );
 
-  mEmail = new QLineEdit( page );
+  mEmail = new TQLineEdit( page );
   layout->addWidget( mEmail, 0, 1 );
 
-  QToolButton *emailSelector = new QToolButton( page );
+  TQToolButton *emailSelector = new TQToolButton( page );
   emailSelector->setUsesTextLabel( true );
   emailSelector->setTextLabel( i18n( "..." ) );
   layout->addWidget( emailSelector, 0, 2 );
 
-  QValueList<Scalix::DelegateTypes> types;
+  TQValueList<Scalix::DelegateTypes> types;
   types << Scalix::SendOnBehalfOf;
   types << Scalix::SeePrivate;
   types << Scalix::GetMeetings;
@@ -56,14 +56,14 @@ DelegateDialog::DelegateDialog( QWidget *parent )
 
   int row = 1;
   for ( uint i = 0; i < types.count(); ++i ) {
-    QCheckBox *box = new QCheckBox( Scalix::Delegate::rightsAsString( types[ i ] ), page );
+    TQCheckBox *box = new TQCheckBox( Scalix::Delegate::rightsAsString( types[ i ] ), page );
     layout->addMultiCellWidget( box, row, row, 1, 2 );
 
     mRights.insert( types[ i ], box );
     row++;
   }
 
-  connect( emailSelector, SIGNAL( clicked() ), SLOT( selectEmail() ) );
+  connect( emailSelector, TQT_SIGNAL( clicked() ), TQT_SLOT( selectEmail() ) );
 
   setMainWidget( page );
 }
@@ -72,7 +72,7 @@ void DelegateDialog::setDelegate( const Scalix::Delegate &delegate )
 {
   mEmail->setText( delegate.email() );
 
-  QMap<int, QCheckBox*>::Iterator it;
+  TQMap<int, TQCheckBox*>::Iterator it;
   for ( it = mRights.begin(); it != mRights.end(); ++it )
     it.data()->setChecked( delegate.rights() & it.key() );
 }
@@ -81,7 +81,7 @@ Scalix::Delegate DelegateDialog::delegate() const
 {
   int rights = 0;
 
-  QMap<int, QCheckBox*>::ConstIterator it;
+  TQMap<int, TQCheckBox*>::ConstIterator it;
   for ( it = mRights.begin(); it != mRights.end(); ++it )
     if ( it.data()->isChecked() )
       rights |= it.key();
@@ -95,7 +95,7 @@ void DelegateDialog::selectEmail()
   if ( !dlg.exec() )
     return;
 
-  const QString email = dlg.selectedUser();
+  const TQString email = dlg.selectedUser();
   if ( email.isEmpty() )
     return;
 
diff --git a/kresources/scalix/scalixadmin/delegatedialog.h b/kresources/scalix/scalixadmin/delegatedialog.h
index b5503a4f..3d712d8e 100644
--- a/kresources/scalix/scalixadmin/delegatedialog.h
+++ b/kresources/scalix/scalixadmin/delegatedialog.h
@@ -21,7 +21,7 @@
 #ifndef DELEGATEDIALOG_H
 #define DELEGATEDIALOG_H
 
-#include <qmap.h>
+#include <tqmap.h>
 
 #include <kdialogbase.h>
 
@@ -37,7 +37,7 @@ class DelegateDialog : public KDialogBase
   Q_OBJECT
 
   public:
-    DelegateDialog( QWidget *parent = 0 );
+    DelegateDialog( TQWidget *parent = 0 );
 
     void setDelegate( const Scalix::Delegate &delegate );
     Scalix::Delegate delegate() const;
@@ -46,8 +46,8 @@ class DelegateDialog : public KDialogBase
     void selectEmail();
 
   private:
-    QLineEdit *mEmail;
-    QMap<int, QCheckBox*> mRights;
+    TQLineEdit *mEmail;
+    TQMap<int, TQCheckBox*> mRights;
 };
 
 #endif
diff --git a/kresources/scalix/scalixadmin/delegatemanager.h b/kresources/scalix/scalixadmin/delegatemanager.h
index f27b79a1..7f5e2e5a 100644
--- a/kresources/scalix/scalixadmin/delegatemanager.h
+++ b/kresources/scalix/scalixadmin/delegatemanager.h
@@ -21,8 +21,8 @@
 #ifndef DELEGATEMANAGER_H
 #define DELEGATEMANAGER_H
 
-#include <qobject.h>
-#include <qstringlist.h>
+#include <tqobject.h>
+#include <tqstringlist.h>
 
 #include "jobs.h"
 
diff --git a/kresources/scalix/scalixadmin/delegatepage.cpp b/kresources/scalix/scalixadmin/delegatepage.cpp
index f9a9b8e7..03347290 100644
--- a/kresources/scalix/scalixadmin/delegatepage.cpp
+++ b/kresources/scalix/scalixadmin/delegatepage.cpp
@@ -18,8 +18,8 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#include <qlayout.h>
-#include <qpushbutton.h>
+#include <tqlayout.h>
+#include <tqpushbutton.h>
 
 #include <kinputdialog.h>
 #include <klocale.h>
@@ -34,29 +34,29 @@
 
 #include "delegatepage.h"
 
-DelegatePage::DelegatePage( QWidget *parent )
-  : QWidget( parent )
+DelegatePage::DelegatePage( TQWidget *parent )
+  : TQWidget( parent )
 {
-  QGridLayout *layout = new QGridLayout( this, 2, 3, 11, 6 );
+  TQGridLayout *layout = new TQGridLayout( this, 2, 3, 11, 6 );
 
   mView = new DelegateView( &mManager, this );
   layout->addMultiCellWidget( mView, 0, 0, 0, 2 );
 
-  mAddButton = new QPushButton( i18n( "Add Delegate..." ), this );
+  mAddButton = new TQPushButton( i18n( "Add Delegate..." ), this );
   layout->addWidget( mAddButton, 1, 0 );
 
-  mEditButton = new QPushButton( i18n( "Edit Delegate..." ), this );
+  mEditButton = new TQPushButton( i18n( "Edit Delegate..." ), this );
   mEditButton->setEnabled( false );
   layout->addWidget( mEditButton, 1, 1 );
 
-  mRemoveButton = new QPushButton( i18n( "Remove Delegate" ), this );
+  mRemoveButton = new TQPushButton( i18n( "Remove Delegate" ), this );
   mRemoveButton->setEnabled( false );
   layout->addWidget( mRemoveButton, 1, 2 );
 
-  connect( mView, SIGNAL( selectionChanged() ), SLOT( selectionChanged() ) );
-  connect( mAddButton, SIGNAL( clicked() ), SLOT( addDelegate() ) );
-  connect( mEditButton, SIGNAL( clicked() ), SLOT( editDelegate() ) );
-  connect( mRemoveButton, SIGNAL( clicked() ), SLOT( removeDelegate() ) );
+  connect( mView, TQT_SIGNAL( selectionChanged() ), TQT_SLOT( selectionChanged() ) );
+  connect( mAddButton, TQT_SIGNAL( clicked() ), TQT_SLOT( addDelegate() ) );
+  connect( mEditButton, TQT_SIGNAL( clicked() ), TQT_SLOT( editDelegate() ) );
+  connect( mRemoveButton, TQT_SIGNAL( clicked() ), TQT_SLOT( removeDelegate() ) );
 
   loadAllDelegates();
 }
@@ -69,7 +69,7 @@ void DelegatePage::loadAllDelegates()
 {
   Scalix::GetDelegatesJob *job = Scalix::getDelegates( Settings::self()->globalSlave(),
                                                        Settings::self()->accountUrl() );
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( allDelegates( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( allDelegates( KIO::Job* ) ) );
 }
 
 void DelegatePage::addDelegate()
@@ -88,7 +88,7 @@ void DelegatePage::addDelegate()
   Scalix::SetDelegateJob *job = Scalix::setDelegate( Settings::self()->globalSlave(),
                                                      Settings::self()->accountUrl(),
                                                      delegate.email(), delegate.rights() );
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( delegateAdded( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( delegateAdded( KIO::Job* ) ) );
 }
 
 void DelegatePage::editDelegate()
@@ -113,7 +113,7 @@ void DelegatePage::editDelegate()
   Scalix::SetDelegateJob *job = Scalix::setDelegate( Settings::self()->globalSlave(),
                                                      Settings::self()->accountUrl(),
                                                      delegate.email(), delegate.rights() );
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( delegateAdded( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( delegateAdded( KIO::Job* ) ) );
 }
 
 void DelegatePage::removeDelegate()
@@ -124,7 +124,7 @@ void DelegatePage::removeDelegate()
 
   Scalix::DeleteDelegateJob *job = Scalix::deleteDelegate( Settings::self()->globalSlave(),
                                                            Settings::self()->accountUrl(), delegate.email() );
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( delegateRemoved( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( delegateRemoved( KIO::Job* ) ) );
 }
 
 void DelegatePage::allDelegates( KIO::Job *job )
diff --git a/kresources/scalix/scalixadmin/delegatepage.h b/kresources/scalix/scalixadmin/delegatepage.h
index 243c0f0d..edaad8e7 100644
--- a/kresources/scalix/scalixadmin/delegatepage.h
+++ b/kresources/scalix/scalixadmin/delegatepage.h
@@ -21,7 +21,7 @@
 #ifndef DELEGATEPAGE_H
 #define DELEGATEPAGE_H
 
-#include <qwidget.h>
+#include <tqwidget.h>
 
 #include "delegatemanager.h"
 
@@ -33,7 +33,7 @@ class DelegatePage : public QWidget
   Q_OBJECT
 
   public:
-    DelegatePage( QWidget *parent = 0 );
+    DelegatePage( TQWidget *parent = 0 );
     ~DelegatePage();
 
   private slots:
@@ -49,9 +49,9 @@ class DelegatePage : public QWidget
     void selectionChanged();
 
   private:
-    QPushButton *mAddButton;
-    QPushButton *mEditButton;
-    QPushButton *mRemoveButton;
+    TQPushButton *mAddButton;
+    TQPushButton *mEditButton;
+    TQPushButton *mRemoveButton;
 
     DelegateManager mManager;
     DelegateView *mView;
diff --git a/kresources/scalix/scalixadmin/delegateview.cpp b/kresources/scalix/scalixadmin/delegateview.cpp
index 9ea16cf1..e253f1f3 100644
--- a/kresources/scalix/scalixadmin/delegateview.cpp
+++ b/kresources/scalix/scalixadmin/delegateview.cpp
@@ -27,8 +27,8 @@
 class DelegateItem : public QListViewItem
 {
   public:
-    DelegateItem( QListView *parent, const Scalix::Delegate &delegate )
-      : QListViewItem( parent ), mDelegate( delegate )
+    DelegateItem( TQListView *parent, const Scalix::Delegate &delegate )
+      : TQListViewItem( parent ), mDelegate( delegate )
     {
       setText( 0, mDelegate.email() );
       setText( 1, Scalix::Delegate::rightsAsString( mDelegate.rights() ) );
@@ -40,7 +40,7 @@ class DelegateItem : public QListViewItem
     Scalix::Delegate mDelegate;
 };
 
-DelegateView::DelegateView( DelegateManager *manager, QWidget *parent )
+DelegateView::DelegateView( DelegateManager *manager, TQWidget *parent )
   : KListView( parent ), mManager( manager )
 {
   addColumn( i18n( "Delegate" ) );
@@ -48,7 +48,7 @@ DelegateView::DelegateView( DelegateManager *manager, QWidget *parent )
   setFullWidth( true );
   setAllColumnsShowFocus( true );
 
-  connect( mManager, SIGNAL( changed() ), SLOT( delegateChanged() ) );
+  connect( mManager, TQT_SIGNAL( changed() ), TQT_SLOT( delegateChanged() ) );
 
   delegateChanged();
 }
diff --git a/kresources/scalix/scalixadmin/delegateview.h b/kresources/scalix/scalixadmin/delegateview.h
index 61725be2..1e9e6300 100644
--- a/kresources/scalix/scalixadmin/delegateview.h
+++ b/kresources/scalix/scalixadmin/delegateview.h
@@ -34,7 +34,7 @@ class DelegateView : public KListView
   Q_OBJECT
 
   public:
-    DelegateView( DelegateManager *manager, QWidget *parent = 0 );
+    DelegateView( DelegateManager *manager, TQWidget *parent = 0 );
 
     Scalix::Delegate selectedDelegate() const;
 
diff --git a/kresources/scalix/scalixadmin/jobs.cpp b/kresources/scalix/scalixadmin/jobs.cpp
index c463463d..f1bce9f2 100644
--- a/kresources/scalix/scalixadmin/jobs.cpp
+++ b/kresources/scalix/scalixadmin/jobs.cpp
@@ -30,7 +30,7 @@ Delegate::Delegate()
 {
 }
 
-Delegate::Delegate( const QString &email, int rights )
+Delegate::Delegate( const TQString &email, int rights )
   : mEmail( email ), mRights( rights )
 {
 }
@@ -40,7 +40,7 @@ bool Delegate::isValid() const
   return ( !mEmail.isEmpty() && mRights != -1 );
 }
 
-QString Delegate::email() const
+TQString Delegate::email() const
 {
   return mEmail;
 }
@@ -50,9 +50,9 @@ int Delegate::rights() const
   return mRights;
 }
 
-QString Delegate::rightsAsString( int rights )
+TQString Delegate::rightsAsString( int rights )
 {
-  QStringList rightNames;
+  TQStringList rightNames;
 
   if ( rights & SendOnBehalfOf )
     rightNames.append( i18n( "Send on behalf of" ) );
@@ -68,21 +68,21 @@ QString Delegate::rightsAsString( int rights )
 
 
 SetPasswordJob* Scalix::setPassword( KIO::Slave* slave, const KURL& url,
-                                     const QString &oldPassword, const QString& newPassword )
+                                     const TQString &oldPassword, const TQString& newPassword )
 {
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
   stream << (int)'X' << (int)'N'
-         << QString( "X-SCALIX-PASSWORD" ) << QString( "%1 %2" ).arg( oldPassword ).arg( newPassword );
+         << TQString( "X-SCALIX-PASSWORD" ) << TQString( "%1 %2" ).arg( oldPassword ).arg( newPassword );
 
   SetPasswordJob* job = new SetPasswordJob( url, packedArgs, false );
   KIO::Scheduler::assignJobToSlave( slave, job );
   return job;
 }
 
-SetDelegateJob* Scalix::setDelegate( KIO::Slave* slave, const KURL& url, const QString& email, int params )
+SetDelegateJob* Scalix::setDelegate( KIO::Slave* slave, const KURL& url, const TQString& email, int params )
 {
-  QStringList types;
+  TQStringList types;
   if ( params & SendOnBehalfOf )
     types.append( "SOBO" );
   if ( params & SeePrivate )
@@ -92,22 +92,22 @@ SetDelegateJob* Scalix::setDelegate( KIO::Slave* slave, const KURL& url, const Q
   if ( params & InsteadOfMe )
     types.append( "INSTEADOFME" );
 
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
   stream << (int)'X' << (int)'N'
-         << QString( "X-SET-DELEGATE" ) << QString( "%1 %2" ).arg( email ).arg( types.join( " " ) );
+         << TQString( "X-SET-DELEGATE" ) << TQString( "%1 %2" ).arg( email ).arg( types.join( " " ) );
 
   SetDelegateJob* job = new SetDelegateJob( url, packedArgs, false );
   KIO::Scheduler::assignJobToSlave( slave, job );
   return job;
 }
 
-DeleteDelegateJob* Scalix::deleteDelegate( KIO::Slave* slave, const KURL& url, const QString& email )
+DeleteDelegateJob* Scalix::deleteDelegate( KIO::Slave* slave, const KURL& url, const TQString& email )
 {
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
   stream << (int)'X' << (int)'N'
-         << QString( "X-DELETE-DELEGATE" ) << email;
+         << TQString( "X-DELETE-DELEGATE" ) << email;
 
   DeleteDelegateJob* job = new DeleteDelegateJob( url, packedArgs, false );
   KIO::Scheduler::assignJobToSlave( slave, job );
@@ -116,33 +116,33 @@ DeleteDelegateJob* Scalix::deleteDelegate( KIO::Slave* slave, const KURL& url, c
 
 GetDelegatesJob* Scalix::getDelegates( KIO::Slave* slave, const KURL& url )
 {
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
-  stream << (int)'X' << (int)'N' << QString( "X-GET-DELEGATES" ) << QString();
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
+  stream << (int)'X' << (int)'N' << TQString( "X-GET-DELEGATES" ) << TQString();
 
   GetDelegatesJob* job = new GetDelegatesJob( url, packedArgs, false );
   KIO::Scheduler::assignJobToSlave( slave, job );
   return job;
 }
 
-AddOtherUserJob* Scalix::addOtherUser( KIO::Slave* slave, const KURL& url, const QString& email )
+AddOtherUserJob* Scalix::addOtherUser( KIO::Slave* slave, const KURL& url, const TQString& email )
 {
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
   stream << (int)'X' << (int)'N'
-         << QString( "X-ADD-OTHER-USER" ) << email;
+         << TQString( "X-ADD-OTHER-USER" ) << email;
 
   AddOtherUserJob* job = new AddOtherUserJob( url, packedArgs, false );
   KIO::Scheduler::assignJobToSlave( slave, job );
   return job;
 }
 
-DeleteOtherUserJob* Scalix::deleteOtherUser( KIO::Slave* slave, const KURL& url, const QString& email )
+DeleteOtherUserJob* Scalix::deleteOtherUser( KIO::Slave* slave, const KURL& url, const TQString& email )
 {
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
   stream << (int)'X' << (int)'N'
-         << QString( "X-DELETE-OTHER-USER" ) << email;
+         << TQString( "X-DELETE-OTHER-USER" ) << email;
 
   DeleteOtherUserJob* job = new DeleteOtherUserJob( url, packedArgs, false );
   KIO::Scheduler::assignJobToSlave( slave, job );
@@ -151,25 +151,25 @@ DeleteOtherUserJob* Scalix::deleteOtherUser( KIO::Slave* slave, const KURL& url,
 
 GetOtherUsersJob* Scalix::getOtherUsers( KIO::Slave* slave, const KURL& url )
 {
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
   stream << (int)'X' << (int)'N'
-         << QString( "X-GET-OTHER-USERS" ) << QString();
+         << TQString( "X-GET-OTHER-USERS" ) << TQString();
 
   GetOtherUsersJob* job = new GetOtherUsersJob( url, packedArgs, false );
   KIO::Scheduler::assignJobToSlave( slave, job );
   return job;
 }
 
-SetOutOfOfficeJob* Scalix::setOutOfOffice( KIO::Slave* slave, const KURL& url, bool enabled, const QString& msg )
+SetOutOfOfficeJob* Scalix::setOutOfOffice( KIO::Slave* slave, const KURL& url, bool enabled, const TQString& msg )
 {
-  const QString argument = msg;
-  const QString command = QString( "X-SET-OUT-OF-OFFICE %1 %2 {%3}" ).arg( enabled ? "ENABLED" : "DISABLED" )
+  const TQString argument = msg;
+  const TQString command = TQString( "X-SET-OUT-OF-OFFICE %1 %2 {%3}" ).arg( enabled ? "ENABLED" : "DISABLED" )
                                                 .arg( "UTF-8" )
                                                 .arg( msg.utf8().length() );
 
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
   stream << (int) 'X' << (int)'E' << command << argument;
 
   SetOutOfOfficeJob* job = new SetOutOfOfficeJob( url, packedArgs, false );
@@ -179,36 +179,36 @@ SetOutOfOfficeJob* Scalix::setOutOfOffice( KIO::Slave* slave, const KURL& url, b
 
 GetOutOfOfficeJob* Scalix::getOutOfOffice( KIO::Slave* slave, const KURL& url )
 {
-  QByteArray packedArgs;
-  QDataStream stream( packedArgs, IO_WriteOnly );
+  TQByteArray packedArgs;
+  TQDataStream stream( packedArgs, IO_WriteOnly );
   stream << (int)'X' << (int)'N'
-         << QString( "X-GET-OUT-OF-OFFICE" ) << QString();
+         << TQString( "X-GET-OUT-OF-OFFICE" ) << TQString();
 
   GetOutOfOfficeJob* job = new GetOutOfOfficeJob( url, packedArgs, false );
   KIO::Scheduler::assignJobToSlave( slave, job );
   return job;
 }
 
-SetPasswordJob::SetPasswordJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+SetPasswordJob::SetPasswordJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
 }
 
-SetDelegateJob::SetDelegateJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+SetDelegateJob::SetDelegateJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
 }
 
-DeleteDelegateJob::DeleteDelegateJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+DeleteDelegateJob::DeleteDelegateJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
 }
 
-GetDelegatesJob::GetDelegatesJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+GetDelegatesJob::GetDelegatesJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
-  connect( this, SIGNAL( infoMessage( KIO::Job*, const QString& ) ),
-           this, SLOT( slotInfoMessage( KIO::Job*, const QString& ) ) );
+  connect( this, TQT_SIGNAL( infoMessage( KIO::Job*, const TQString& ) ),
+           this, TQT_SLOT( slotInfoMessage( KIO::Job*, const TQString& ) ) );
 }
 
 Delegate::List GetDelegatesJob::delegates() const
@@ -216,21 +216,21 @@ Delegate::List GetDelegatesJob::delegates() const
   return mDelegates;
 }
 
-void GetDelegatesJob::slotInfoMessage( KIO::Job*, const QString &data )
+void GetDelegatesJob::slotInfoMessage( KIO::Job*, const TQString &data )
 {
   /**
    * The passed data have the following form:
    *
    * "user1@host.com:right1,right2,right4 user2@host.com:right3,right5"
    */
-  QStringList delegates = QStringList::split( ' ', data );
+  TQStringList delegates = TQStringList::split( ' ', data );
   for ( uint i = 0; i < delegates.count(); ++i ) {
-    QStringList delegate = QStringList::split( ':', delegates[ i ] );
+    TQStringList delegate = TQStringList::split( ':', delegates[ i ] );
 
-    const QString email = delegate[ 0 ];
+    const TQString email = delegate[ 0 ];
     int rights = 0;
 
-    QStringList rightsList = QStringList::split( ',', delegate[ 1 ] );
+    TQStringList rightsList = TQStringList::split( ',', delegate[ 1 ] );
     for ( uint j = 0; j < rightsList.count(); ++j ) {
       if ( rightsList[ j ] == "SOBO" )
         rights |= SendOnBehalfOf;
@@ -246,43 +246,43 @@ void GetDelegatesJob::slotInfoMessage( KIO::Job*, const QString &data )
   }
 }
 
-AddOtherUserJob::AddOtherUserJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+AddOtherUserJob::AddOtherUserJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
 }
 
-DeleteOtherUserJob::DeleteOtherUserJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+DeleteOtherUserJob::DeleteOtherUserJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
 }
 
-GetOtherUsersJob::GetOtherUsersJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+GetOtherUsersJob::GetOtherUsersJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
-  connect( this, SIGNAL( infoMessage( KIO::Job*, const QString& ) ),
-           this, SLOT( slotInfoMessage( KIO::Job*, const QString& ) ) );
+  connect( this, TQT_SIGNAL( infoMessage( KIO::Job*, const TQString& ) ),
+           this, TQT_SLOT( slotInfoMessage( KIO::Job*, const TQString& ) ) );
 }
 
-QStringList GetOtherUsersJob::otherUsers() const
+TQStringList GetOtherUsersJob::otherUsers() const
 {
   return mOtherUsers;
 }
 
-void GetOtherUsersJob::slotInfoMessage( KIO::Job*, const QString &data )
+void GetOtherUsersJob::slotInfoMessage( KIO::Job*, const TQString &data )
 {
-  mOtherUsers = QStringList::split( ' ', data );
+  mOtherUsers = TQStringList::split( ' ', data );
 }
 
-SetOutOfOfficeJob::SetOutOfOfficeJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+SetOutOfOfficeJob::SetOutOfOfficeJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
 }
 
-GetOutOfOfficeJob::GetOutOfOfficeJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo )
+GetOutOfOfficeJob::GetOutOfOfficeJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo )
   : KIO::SimpleJob( url, KIO::CMD_SPECIAL, packedArgs, showProgressInfo )
 {
-  connect( this, SIGNAL( infoMessage( KIO::Job*, const QString& ) ),
-           this, SLOT( slotInfoMessage( KIO::Job*, const QString& ) ) );
+  connect( this, TQT_SIGNAL( infoMessage( KIO::Job*, const TQString& ) ),
+           this, TQT_SLOT( slotInfoMessage( KIO::Job*, const TQString& ) ) );
 }
 
 bool GetOutOfOfficeJob::enabled() const
@@ -290,14 +290,14 @@ bool GetOutOfOfficeJob::enabled() const
   return mEnabled;
 }
 
-QString GetOutOfOfficeJob::message() const
+TQString GetOutOfOfficeJob::message() const
 {
   return mMessage;
 }
 
-void GetOutOfOfficeJob::slotInfoMessage( KIO::Job*, const QString &data )
+void GetOutOfOfficeJob::slotInfoMessage( KIO::Job*, const TQString &data )
 {
-  const QStringList fields = QStringList::split( '^', data );
+  const TQStringList fields = TQStringList::split( '^', data );
 
   mEnabled = ( fields[ 0 ] == "ENABLED" );
   mMessage = fields[ 1 ];
diff --git a/kresources/scalix/scalixadmin/jobs.h b/kresources/scalix/scalixadmin/jobs.h
index 3b5a1b81..24ce1c02 100644
--- a/kresources/scalix/scalixadmin/jobs.h
+++ b/kresources/scalix/scalixadmin/jobs.h
@@ -46,37 +46,37 @@ namespace Scalix {
   class Delegate
   {
     public:
-      typedef QValueList<Delegate> List;
+      typedef TQValueList<Delegate> List;
 
       Delegate();
-      Delegate( const QString &email, int rights );
+      Delegate( const TQString &email, int rights );
 
       bool isValid() const;
 
-      QString email() const;
+      TQString email() const;
       int rights() const;
 
-      static QString rightsAsString( int rights );
+      static TQString rightsAsString( int rights );
 
     private:
-      QString mEmail;
+      TQString mEmail;
       int mRights;
   };
 
   /**
    * Sets/Changes the password of the user encoded in @p url.
    */
-  SetPasswordJob* setPassword( KIO::Slave* slave, const KURL& url, const QString& oldPassword, const QString& newPassword );
+  SetPasswordJob* setPassword( KIO::Slave* slave, const KURL& url, const TQString& oldPassword, const TQString& newPassword );
 
   /**
    * Adds a delegate represented by @p email with the given @p params for the user encoded in @p url.
    */
-  SetDelegateJob* setDelegate( KIO::Slave* slave, const KURL& url, const QString& email, int params );
+  SetDelegateJob* setDelegate( KIO::Slave* slave, const KURL& url, const TQString& email, int params );
 
   /**
    * Deletes the delegate represented by @p email for the user encoded in @p url.
    */
-  DeleteDelegateJob* deleteDelegate( KIO::Slave* slave, const KURL& url, const QString& email );
+  DeleteDelegateJob* deleteDelegate( KIO::Slave* slave, const KURL& url, const TQString& email );
 
   /**
    * Retrieves the delegates for the user encoded in @p url.
@@ -86,12 +86,12 @@ namespace Scalix {
   /**
    * Adds the mailbox of another user represented by @p email to the users 'Other Users' namespace.
    */
-  AddOtherUserJob* addOtherUser( KIO::Slave* slave, const KURL& url, const QString& email );
+  AddOtherUserJob* addOtherUser( KIO::Slave* slave, const KURL& url, const TQString& email );
 
   /**
    * Deletes the mailbox of another user represented by @p email from the users 'Other Users' namespace.
    */
-  DeleteOtherUserJob* deleteOtherUser( KIO::Slave* slave, const KURL& url, const QString& email );
+  DeleteOtherUserJob* deleteOtherUser( KIO::Slave* slave, const KURL& url, const TQString& email );
 
   /**
    * Retrieves the list of all other users.
@@ -104,7 +104,7 @@ namespace Scalix {
    * @param enabled Whether the out-of-office functionality is enabled.
    * @param msg The out-of-office message.
    */
-  SetOutOfOfficeJob* setOutOfOffice( KIO::Slave* slave, const KURL& url, bool enabled, const QString& msg );
+  SetOutOfOfficeJob* setOutOfOffice( KIO::Slave* slave, const KURL& url, bool enabled, const TQString& msg );
 
   /**
    * Retrieves the out-of-office data.
@@ -115,19 +115,19 @@ namespace Scalix {
   class SetPasswordJob : public KIO::SimpleJob
   {
     public:
-      SetPasswordJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      SetPasswordJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
   };
 
   class SetDelegateJob : public KIO::SimpleJob
   {
     public:
-      SetDelegateJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      SetDelegateJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
   };
 
   class DeleteDelegateJob : public KIO::SimpleJob
   {
     public:
-      DeleteDelegateJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      DeleteDelegateJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
   };
 
   class GetDelegatesJob : public KIO::SimpleJob
@@ -135,12 +135,12 @@ namespace Scalix {
     Q_OBJECT
 
     public:
-      GetDelegatesJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      GetDelegatesJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
 
       Delegate::List delegates() const;
 
     private slots:
-      void slotInfoMessage( KIO::Job*, const QString& );
+      void slotInfoMessage( KIO::Job*, const TQString& );
 
     private:
       Delegate::List mDelegates;
@@ -149,13 +149,13 @@ namespace Scalix {
   class AddOtherUserJob : public KIO::SimpleJob
   {
     public:
-      AddOtherUserJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      AddOtherUserJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
   };
 
   class DeleteOtherUserJob : public KIO::SimpleJob
   {
     public:
-      DeleteOtherUserJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      DeleteOtherUserJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
   };
 
   class GetOtherUsersJob : public KIO::SimpleJob
@@ -163,21 +163,21 @@ namespace Scalix {
     Q_OBJECT
 
     public:
-      GetOtherUsersJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      GetOtherUsersJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
 
-      QStringList otherUsers() const;
+      TQStringList otherUsers() const;
 
     private slots:
-      void slotInfoMessage( KIO::Job*, const QString& );
+      void slotInfoMessage( KIO::Job*, const TQString& );
 
     private:
-      QStringList mOtherUsers;
+      TQStringList mOtherUsers;
   };
 
   class SetOutOfOfficeJob : public KIO::SimpleJob
   {
     public:
-      SetOutOfOfficeJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      SetOutOfOfficeJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
   };
 
   class GetOutOfOfficeJob : public KIO::SimpleJob
@@ -185,17 +185,17 @@ namespace Scalix {
     Q_OBJECT
 
     public:
-      GetOutOfOfficeJob( const KURL& url, const QByteArray &packedArgs, bool showProgressInfo );
+      GetOutOfOfficeJob( const KURL& url, const TQByteArray &packedArgs, bool showProgressInfo );
 
       bool enabled() const;
-      QString message() const;
+      TQString message() const;
 
     private slots:
-      void slotInfoMessage( KIO::Job*, const QString& );
+      void slotInfoMessage( KIO::Job*, const TQString& );
 
     private:
       bool mEnabled;
-      QString mMessage;
+      TQString mMessage;
   };
 }
 
diff --git a/kresources/scalix/scalixadmin/ldapdialog.cpp b/kresources/scalix/scalixadmin/ldapdialog.cpp
index be624f13..6af08c4d 100644
--- a/kresources/scalix/scalixadmin/ldapdialog.cpp
+++ b/kresources/scalix/scalixadmin/ldapdialog.cpp
@@ -24,7 +24,7 @@
 
 #include "ldapdialog.h"
 
-LdapDialog::LdapDialog( QWidget *parent )
+LdapDialog::LdapDialog( TQWidget *parent )
   : KDialogBase( parent, "", true, "", Ok | Cancel, Ok, true )
 {
   setCaption( i18n( "User Account Selection" ) );
@@ -37,7 +37,7 @@ LdapDialog::LdapDialog( QWidget *parent )
   resize( 400, 250 );
 }
 
-QString LdapDialog::selectedUser() const
+TQString LdapDialog::selectedUser() const
 {
   return mView->selectedUser();
 }
diff --git a/kresources/scalix/scalixadmin/ldapdialog.h b/kresources/scalix/scalixadmin/ldapdialog.h
index 6b326f55..9d822af1 100644
--- a/kresources/scalix/scalixadmin/ldapdialog.h
+++ b/kresources/scalix/scalixadmin/ldapdialog.h
@@ -27,9 +27,9 @@ class LdapView;
 class LdapDialog : public KDialogBase
 {
   public:
-    LdapDialog( QWidget *parent = 0 );
+    LdapDialog( TQWidget *parent = 0 );
 
-    QString selectedUser() const;
+    TQString selectedUser() const;
 
 
   private:
diff --git a/kresources/scalix/scalixadmin/ldapview.cpp b/kresources/scalix/scalixadmin/ldapview.cpp
index 660f1944..0e40f3ae 100644
--- a/kresources/scalix/scalixadmin/ldapview.cpp
+++ b/kresources/scalix/scalixadmin/ldapview.cpp
@@ -29,8 +29,8 @@
 class LdapItem : public QListViewItem
 {
   public:
-    LdapItem( QListView *parent, const QString &text, const QString &email )
-      : QListViewItem( parent )
+    LdapItem( TQListView *parent, const TQString &text, const TQString &email )
+      : TQListViewItem( parent )
     {
       setText( 0, text );
       setText( 1, email );
@@ -38,7 +38,7 @@ class LdapItem : public QListViewItem
 };
 
 
-LdapView::LdapView( QWidget *parent )
+LdapView::LdapView( TQWidget *parent )
   : KListView( parent )
 {
   addColumn( i18n( "User" ) );
@@ -52,14 +52,14 @@ LdapView::LdapView( QWidget *parent )
   mClient->setBindDN( Settings::self()->ldapBindDn() );
   mClient->setPwdBindDN( Settings::self()->ldapPassword() );
 
-  QStringList attrs;
+  TQStringList attrs;
   attrs << "surname" << "mail";
   mClient->setAttrs( attrs );
 
-  connect( mClient, SIGNAL( result( const KABC::LdapObject& ) ),
-           this, SLOT( entryAdded( const KABC::LdapObject& ) ) );
-  connect( mClient, SIGNAL( error( const QString& ) ),
-           this, SLOT( error( const QString& ) ) );
+  connect( mClient, TQT_SIGNAL( result( const KABC::LdapObject& ) ),
+           this, TQT_SLOT( entryAdded( const KABC::LdapObject& ) ) );
+  connect( mClient, TQT_SIGNAL( error( const TQString& ) ),
+           this, TQT_SLOT( error( const TQString& ) ) );
 }
 
 LdapView::~LdapView()
@@ -68,16 +68,16 @@ LdapView::~LdapView()
   delete mClient;
 }
 
-QString LdapView::selectedUser() const
+TQString LdapView::selectedUser() const
 {
-  QListViewItem *item = selectedItem();
+  TQListViewItem *item = selectedItem();
   if ( !item )
-    return QString();
+    return TQString();
   else
     return item->text( 1 );
 }
 
-void LdapView::setQuery( const QString &query )
+void LdapView::setQuery( const TQString &query )
 {
   clear();
   mClient->startQuery( query );
@@ -85,13 +85,13 @@ void LdapView::setQuery( const QString &query )
 
 void LdapView::entryAdded( const KABC::LdapObject &obj )
 {
-  const QString text = QString( "%1 (%2)" ).arg( obj.attrs[ "surname" ].first() )
+  const TQString text = TQString( "%1 (%2)" ).arg( obj.attrs[ "surname" ].first() )
                                            .arg( obj.attrs[ "mail" ].first() );
 
   new LdapItem( this, text, obj.attrs[ "mail" ].first() );
 }
 
-void LdapView::error( const QString &msg )
+void LdapView::error( const TQString &msg )
 {
   KMessageBox::error( this, msg );
 }
diff --git a/kresources/scalix/scalixadmin/ldapview.h b/kresources/scalix/scalixadmin/ldapview.h
index 0acb3602..4616e11c 100644
--- a/kresources/scalix/scalixadmin/ldapview.h
+++ b/kresources/scalix/scalixadmin/ldapview.h
@@ -32,17 +32,17 @@ class LdapView : public KListView
   Q_OBJECT
 
   public:
-    LdapView( QWidget *parent = 0 );
+    LdapView( TQWidget *parent = 0 );
     ~LdapView();
 
-    QString selectedUser() const;
+    TQString selectedUser() const;
 
   public slots:
-    void setQuery( const QString &query );
+    void setQuery( const TQString &query );
 
   private slots:
     void entryAdded( const KABC::LdapObject& );
-    void error( const QString& );
+    void error( const TQString& );
 
   private:
     KABC::LdapClient *mClient;
diff --git a/kresources/scalix/scalixadmin/mainwindow.cpp b/kresources/scalix/scalixadmin/mainwindow.cpp
index e6cac550..4f3dbf94 100644
--- a/kresources/scalix/scalixadmin/mainwindow.cpp
+++ b/kresources/scalix/scalixadmin/mainwindow.cpp
@@ -18,7 +18,7 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#include <qvbox.h>
+#include <tqvbox.h>
 
 #include <kglobal.h>
 #include <kiconloader.h>
@@ -37,8 +37,8 @@ MainWindow::MainWindow()
 {
   KJanusWidget *wdg = new KJanusWidget( this, "", KJanusWidget::IconList );
 
-  QPixmap icon = KGlobal::iconLoader()->loadIcon( "folder_yellow", KIcon::Desktop );
-  QVBox *page = wdg->addVBoxPage( i18n( "Other Accounts" ), i18n( "Register other accounts" ), icon );
+  TQPixmap icon = KGlobal::iconLoader()->loadIcon( "folder_yellow", KIcon::Desktop );
+  TQVBox *page = wdg->addVBoxPage( i18n( "Other Accounts" ), i18n( "Register other accounts" ), icon );
   new OtherUserPage( page );
 
   icon = KGlobal::iconLoader()->loadIcon( "edu_languages", KIcon::Desktop );
diff --git a/kresources/scalix/scalixadmin/otherusermanager.cpp b/kresources/scalix/scalixadmin/otherusermanager.cpp
index b5b3d3cc..a3c19de1 100644
--- a/kresources/scalix/scalixadmin/otherusermanager.cpp
+++ b/kresources/scalix/scalixadmin/otherusermanager.cpp
@@ -28,7 +28,7 @@ OtherUserManager::~OtherUserManager()
 {
 }
 
-void OtherUserManager::addOtherUser( const QString &email )
+void OtherUserManager::addOtherUser( const TQString &email )
 {
   if ( !mOtherUsers.contains( email ) ) {
     mOtherUsers.append( email );
@@ -43,7 +43,7 @@ void OtherUserManager::clear()
   emit changed();
 }
 
-QStringList OtherUserManager::otherUsers() const
+TQStringList OtherUserManager::otherUsers() const
 {
   return mOtherUsers;
 }
diff --git a/kresources/scalix/scalixadmin/otherusermanager.h b/kresources/scalix/scalixadmin/otherusermanager.h
index 6f7f9ac7..90d7195a 100644
--- a/kresources/scalix/scalixadmin/otherusermanager.h
+++ b/kresources/scalix/scalixadmin/otherusermanager.h
@@ -21,8 +21,8 @@
 #ifndef OTHERUSERMANAGER_H
 #define OTHERUSERMANAGER_H
 
-#include <qobject.h>
-#include <qstringlist.h>
+#include <tqobject.h>
+#include <tqstringlist.h>
 
 class OtherUserManager : public QObject
 {
@@ -32,16 +32,16 @@ class OtherUserManager : public QObject
     OtherUserManager();
     ~OtherUserManager();
 
-    void addOtherUser( const QString &email );
+    void addOtherUser( const TQString &email );
     void clear();
 
-    QStringList otherUsers() const;
+    TQStringList otherUsers() const;
 
   signals:
     void changed();
 
   private:
-    QStringList mOtherUsers;
+    TQStringList mOtherUsers;
 };
 
 #endif
diff --git a/kresources/scalix/scalixadmin/otheruserpage.cpp b/kresources/scalix/scalixadmin/otheruserpage.cpp
index ae12290c..8570cab0 100644
--- a/kresources/scalix/scalixadmin/otheruserpage.cpp
+++ b/kresources/scalix/scalixadmin/otheruserpage.cpp
@@ -18,9 +18,9 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#include <qapplication.h>
-#include <qlayout.h>
-#include <qpushbutton.h>
+#include <tqapplication.h>
+#include <tqlayout.h>
+#include <tqpushbutton.h>
 
 #include <dcopref.h>
 #include <kdcopservicestarter.h>
@@ -37,24 +37,24 @@
 
 #include "otheruserpage.h"
 
-OtherUserPage::OtherUserPage( QWidget *parent )
-  : QWidget( parent )
+OtherUserPage::OtherUserPage( TQWidget *parent )
+  : TQWidget( parent )
 {
-  QGridLayout *layout = new QGridLayout( this, 2, 2, 11, 6 );
+  TQGridLayout *layout = new TQGridLayout( this, 2, 2, 11, 6 );
 
   mView = new OtherUserView( &mManager, this );
   layout->addMultiCellWidget( mView, 0, 0, 0, 1 );
 
-  mAddButton = new QPushButton( i18n( "Add Account..." ), this );
+  mAddButton = new TQPushButton( i18n( "Add Account..." ), this );
   layout->addWidget( mAddButton, 1, 0 );
 
-  mDeleteButton = new QPushButton( i18n( "Remove Account" ), this );
+  mDeleteButton = new TQPushButton( i18n( "Remove Account" ), this );
   mDeleteButton->setEnabled( false );
   layout->addWidget( mDeleteButton, 1, 1 );
 
-  connect( mView, SIGNAL( selectionChanged() ), SLOT( selectionChanged() ) );
-  connect( mAddButton, SIGNAL( clicked() ), SLOT( addUser() ) );
-  connect( mDeleteButton, SIGNAL( clicked() ), SLOT( removeUser() ) );
+  connect( mView, TQT_SIGNAL( selectionChanged() ), TQT_SLOT( selectionChanged() ) );
+  connect( mAddButton, TQT_SIGNAL( clicked() ), TQT_SLOT( addUser() ) );
+  connect( mDeleteButton, TQT_SIGNAL( clicked() ), TQT_SLOT( removeUser() ) );
 
   loadAllUsers();
 }
@@ -67,7 +67,7 @@ void OtherUserPage::loadAllUsers()
 {
   Scalix::GetOtherUsersJob *job = Scalix::getOtherUsers( Settings::self()->globalSlave(),
                                                          Settings::self()->accountUrl() );
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( allUsers( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( allUsers( KIO::Job* ) ) );
 }
 
 void OtherUserPage::addUser()
@@ -76,24 +76,24 @@ void OtherUserPage::addUser()
   if ( !dlg.exec() )
     return;
 
-  const QString email = dlg.selectedUser();
+  const TQString email = dlg.selectedUser();
   if ( email.isEmpty() )
     return;
 
   Scalix::AddOtherUserJob *job = Scalix::addOtherUser( Settings::self()->globalSlave(),
                                                        Settings::self()->accountUrl(), email );
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( userAdded( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( userAdded( KIO::Job* ) ) );
 }
 
 void OtherUserPage::removeUser()
 {
-  const QString email = mView->selectedUser();
+  const TQString email = mView->selectedUser();
   if ( email.isEmpty() )
     return;
 
   Scalix::DeleteOtherUserJob *job = Scalix::deleteOtherUser( Settings::self()->globalSlave(),
                                                              Settings::self()->accountUrl(), email );
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( userRemoved( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( userRemoved( KIO::Job* ) ) );
 }
 
 void OtherUserPage::allUsers( KIO::Job *job )
@@ -105,7 +105,7 @@ void OtherUserPage::allUsers( KIO::Job *job )
 
   mManager.clear();
 
-  const QStringList users = userJob->otherUsers();
+  const TQStringList users = userJob->otherUsers();
   for ( uint i = 0; i < users.count(); ++i )
     mManager.addOtherUser( users[ i ] );
 
@@ -139,18 +139,18 @@ void OtherUserPage::selectionChanged()
 
 void OtherUserPage::updateKmail()
 {
-  QMessageBox *msg = new QMessageBox( qApp->mainWidget() );
+  TQMessageBox *msg = new TQMessageBox( qApp->mainWidget() );
   msg->setText( i18n( "Updating account..." ) );
   msg->show();
   qApp->processEvents();
   sleep( 1 );
   qApp->processEvents();
 
-  QString error;
-  QCString dcopService;
+  TQString error;
+  TQCString dcopService;
   int result = KDCOPServiceStarter::self()->
-    findServiceFor( "DCOP/ResourceBackend/IMAP", QString::null,
-                    QString::null, &error, &dcopService );
+    findServiceFor( "DCOP/ResourceBackend/IMAP", TQString::null,
+                    TQString::null, &error, &dcopService );
   if ( result != 0 ) {
     KMessageBox::error( 0, i18n( "Unable to start KMail to trigger account update with Scalix server" ) );
     delete msg;
@@ -160,12 +160,12 @@ void OtherUserPage::updateKmail()
   DCOPRef ref( dcopService, "KMailIface" );
 
   // loop until dcop iface is set up correctly
-  QStringList list;
+  TQStringList list;
   while ( list.isEmpty() ) {
     ref.call( "accounts()" ).get( list );
   }
 
-  ref.call( "checkAccount(QString)", i18n( "Scalix Server" ) );
+  ref.call( "checkAccount(TQString)", i18n( "Scalix Server" ) );
 
   delete msg;
 }
diff --git a/kresources/scalix/scalixadmin/otheruserpage.h b/kresources/scalix/scalixadmin/otheruserpage.h
index f847a05d..50e9292c 100644
--- a/kresources/scalix/scalixadmin/otheruserpage.h
+++ b/kresources/scalix/scalixadmin/otheruserpage.h
@@ -21,7 +21,7 @@
 #ifndef OTHERUSERPAGE_H
 #define OTHERUSERPAGE_H
 
-#include <qwidget.h>
+#include <tqwidget.h>
 
 #include "otherusermanager.h"
 
@@ -33,7 +33,7 @@ class OtherUserPage : public QWidget
   Q_OBJECT
 
   public:
-    OtherUserPage( QWidget *parent = 0 );
+    OtherUserPage( TQWidget *parent = 0 );
     ~OtherUserPage();
 
   private slots:
@@ -50,8 +50,8 @@ class OtherUserPage : public QWidget
   private:
     void updateKmail();
 
-    QPushButton *mAddButton;
-    QPushButton *mDeleteButton;
+    TQPushButton *mAddButton;
+    TQPushButton *mDeleteButton;
 
     OtherUserManager mManager;
     OtherUserView *mView;
diff --git a/kresources/scalix/scalixadmin/otheruserview.cpp b/kresources/scalix/scalixadmin/otheruserview.cpp
index 70bc9e3d..19b9c3b6 100644
--- a/kresources/scalix/scalixadmin/otheruserview.cpp
+++ b/kresources/scalix/scalixadmin/otheruserview.cpp
@@ -27,43 +27,43 @@
 class OtherUserItem : public QListViewItem
 {
   public:
-    OtherUserItem( QListView *parent, const QString &user )
-      : QListViewItem( parent ), mUser( user )
+    OtherUserItem( TQListView *parent, const TQString &user )
+      : TQListViewItem( parent ), mUser( user )
     {
       setText( 0, mUser );
     }
 
-    QString user() const { return mUser; }
+    TQString user() const { return mUser; }
 
   private:
-    QString mUser;
+    TQString mUser;
 };
 
-OtherUserView::OtherUserView( OtherUserManager *manager, QWidget *parent )
+OtherUserView::OtherUserView( OtherUserManager *manager, TQWidget *parent )
   : KListView( parent ), mManager( manager )
 {
   addColumn( i18n( "Registered Accounts" ) );
   setFullWidth( true );
 
-  connect( mManager, SIGNAL( changed() ), SLOT( userChanged() ) );
+  connect( mManager, TQT_SIGNAL( changed() ), TQT_SLOT( userChanged() ) );
 
   userChanged();
 }
 
-QString OtherUserView::selectedUser() const
+TQString OtherUserView::selectedUser() const
 {
   OtherUserItem *item = dynamic_cast<OtherUserItem*>( selectedItem() );
   if ( item )
     return item->user();
 
-  return QString();
+  return TQString();
 }
 
 void OtherUserView::userChanged()
 {
   clear();
 
-  QStringList users = mManager->otherUsers();
+  TQStringList users = mManager->otherUsers();
   for ( uint i = 0; i < users.count(); ++i )
     new OtherUserItem( this, users[ i ] );
 }
diff --git a/kresources/scalix/scalixadmin/otheruserview.h b/kresources/scalix/scalixadmin/otheruserview.h
index 6eacc93c..def14a84 100644
--- a/kresources/scalix/scalixadmin/otheruserview.h
+++ b/kresources/scalix/scalixadmin/otheruserview.h
@@ -30,9 +30,9 @@ class OtherUserView : public KListView
   Q_OBJECT
 
   public:
-    OtherUserView( OtherUserManager *manager, QWidget *parent = 0 );
+    OtherUserView( OtherUserManager *manager, TQWidget *parent = 0 );
 
-    QString selectedUser() const;
+    TQString selectedUser() const;
 
   private slots:
     void userChanged();
diff --git a/kresources/scalix/scalixadmin/outofofficepage.cpp b/kresources/scalix/scalixadmin/outofofficepage.cpp
index 0b8d3f80..e1e331fc 100644
--- a/kresources/scalix/scalixadmin/outofofficepage.cpp
+++ b/kresources/scalix/scalixadmin/outofofficepage.cpp
@@ -18,12 +18,12 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#include <qbuttongroup.h>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qpushbutton.h>
-#include <qradiobutton.h>
-#include <qtextedit.h>
+#include <tqbuttongroup.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqpushbutton.h>
+#include <tqradiobutton.h>
+#include <tqtextedit.h>
 
 #include <klocale.h>
 #include <kmessagebox.h>
@@ -33,20 +33,20 @@
 
 #include "outofofficepage.h"
 
-OutOfOfficePage::OutOfOfficePage( QWidget *parent )
-  : QWidget( parent )
+OutOfOfficePage::OutOfOfficePage( TQWidget *parent )
+  : TQWidget( parent )
 {
-  QGridLayout *layout = new QGridLayout( this, 4, 2, 11, 6 );
+  TQGridLayout *layout = new TQGridLayout( this, 4, 2, 11, 6 );
 
-  QButtonGroup *group = new QButtonGroup( 1, Qt::Vertical, this );
+  TQButtonGroup *group = new TQButtonGroup( 1, Qt::Vertical, this );
 
-  mDisabled = new QRadioButton( i18n( "I am in the office" ), group );
+  mDisabled = new TQRadioButton( i18n( "I am in the office" ), group );
   mDisabled->setChecked( true );
-  mEnabled = new QRadioButton( i18n( "I am out of the office" ), group );
+  mEnabled = new TQRadioButton( i18n( "I am out of the office" ), group );
 
-  mLabel = new QLabel( i18n( "Auto-reply once to each sender with the following text:" ), this );
-  mMessage = new QTextEdit( this );
-  mSaveButton = new QPushButton( i18n( "Save" ), this );
+  mLabel = new TQLabel( i18n( "Auto-reply once to each sender with the following text:" ), this );
+  mMessage = new TQTextEdit( this );
+  mSaveButton = new TQPushButton( i18n( "Save" ), this );
 
   layout->addMultiCellWidget( group, 0, 0, 0, 1 );
   layout->addMultiCellWidget( mLabel, 1, 1, 0, 1 );
@@ -55,10 +55,10 @@ OutOfOfficePage::OutOfOfficePage( QWidget *parent )
 
   statusChanged();
 
-  connect( mEnabled, SIGNAL( toggled( bool ) ), this, SLOT( statusChanged() ) );
-  connect( mEnabled, SIGNAL( toggled( bool ) ), this, SLOT( changed() ) );
-  connect( mSaveButton, SIGNAL( clicked() ), this, SLOT( store() ) );
-  connect( mMessage, SIGNAL( textChanged() ), this, SLOT( changed() ) );
+  connect( mEnabled, TQT_SIGNAL( toggled( bool ) ), this, TQT_SLOT( statusChanged() ) );
+  connect( mEnabled, TQT_SIGNAL( toggled( bool ) ), this, TQT_SLOT( changed() ) );
+  connect( mSaveButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( store() ) );
+  connect( mMessage, TQT_SIGNAL( textChanged() ), this, TQT_SLOT( changed() ) );
 
   load();
 }
@@ -71,7 +71,7 @@ void OutOfOfficePage::load()
 {
   Scalix::GetOutOfOfficeJob *job = Scalix::getOutOfOffice( Settings::self()->globalSlave(),
                                                            Settings::self()->accountUrl() );
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( loaded( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( loaded( KIO::Job* ) ) );
 }
 
 void OutOfOfficePage::loaded( KIO::Job* job )
@@ -98,7 +98,7 @@ void OutOfOfficePage::store()
                                                            mEnabled->isChecked(),
                                                            mMessage->text() );
 
-  connect( job, SIGNAL( result( KIO::Job* ) ), SLOT( stored( KIO::Job* ) ) );
+  connect( job, TQT_SIGNAL( result( KIO::Job* ) ), TQT_SLOT( stored( KIO::Job* ) ) );
 
   mSaveButton->setEnabled( false );
 }
diff --git a/kresources/scalix/scalixadmin/outofofficepage.h b/kresources/scalix/scalixadmin/outofofficepage.h
index cc5b2591..cd5f0491 100644
--- a/kresources/scalix/scalixadmin/outofofficepage.h
+++ b/kresources/scalix/scalixadmin/outofofficepage.h
@@ -21,7 +21,7 @@
 #ifndef OUTOFOFFICEPAGE_H
 #define OUTOFOFFICEPAGE_H
 
-#include <qwidget.h>
+#include <tqwidget.h>
 
 class QLabel;
 class QPushButton;
@@ -33,7 +33,7 @@ class OutOfOfficePage : public QWidget
   Q_OBJECT
 
   public:
-    OutOfOfficePage( QWidget *parent = 0 );
+    OutOfOfficePage( TQWidget *parent = 0 );
     ~OutOfOfficePage();
 
   private slots:
@@ -45,11 +45,11 @@ class OutOfOfficePage : public QWidget
     void changed();
 
   private:
-    QRadioButton *mEnabled;
-    QRadioButton *mDisabled;
-    QLabel *mLabel;
-    QTextEdit *mMessage;
-    QPushButton *mSaveButton;
+    TQRadioButton *mEnabled;
+    TQRadioButton *mDisabled;
+    TQLabel *mLabel;
+    TQTextEdit *mMessage;
+    TQPushButton *mSaveButton;
 
     bool mChanged;
 };
diff --git a/kresources/scalix/scalixadmin/passwordpage.cpp b/kresources/scalix/scalixadmin/passwordpage.cpp
index 7d418234..facc2917 100644
--- a/kresources/scalix/scalixadmin/passwordpage.cpp
+++ b/kresources/scalix/scalixadmin/passwordpage.cpp
@@ -18,11 +18,11 @@
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
-#include <qapplication.h>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qlineedit.h>
-#include <qpushbutton.h>
+#include <tqapplication.h>
+#include <tqlabel.h>
+#include <tqlayout.h>
+#include <tqlineedit.h>
+#include <tqpushbutton.h>
 
 #include <kconfig.h>
 #include <klocale.h>
@@ -35,36 +35,36 @@
 
 #include "passwordpage.h"
 
-PasswordPage::PasswordPage( QWidget *parent )
-  : QWidget( parent ), mJob( 0 )
+PasswordPage::PasswordPage( TQWidget *parent )
+  : TQWidget( parent ), mJob( 0 )
 {
-  QGridLayout *layout = new QGridLayout( this, 2, 3, 11, 6 );
+  TQGridLayout *layout = new TQGridLayout( this, 2, 3, 11, 6 );
 
-  QLabel *label = new QLabel( i18n( "New password:" ), this );
+  TQLabel *label = new TQLabel( i18n( "New password:" ), this );
   layout->addWidget( label, 0, 0 );
 
-  mPassword = new QLineEdit( this );
-  mPassword->setEchoMode( QLineEdit::Password );
+  mPassword = new TQLineEdit( this );
+  mPassword->setEchoMode( TQLineEdit::Password );
   label->setBuddy( mPassword );
   layout->addWidget( mPassword, 0, 1 );
 
-  label = new QLabel( i18n( "Retype new password:" ), this );
+  label = new TQLabel( i18n( "Retype new password:" ), this );
   layout->addWidget( label, 1, 0 );
 
-  mPasswordRetype = new QLineEdit( this );
-  mPasswordRetype->setEchoMode( QLineEdit::Password );
+  mPasswordRetype = new TQLineEdit( this );
+  mPasswordRetype->setEchoMode( TQLineEdit::Password );
   label->setBuddy( mPasswordRetype );
   layout->addWidget( mPasswordRetype, 1, 1 );
 
-  mButton = new QPushButton( i18n( "Change" ), this );
+  mButton = new TQPushButton( i18n( "Change" ), this );
   mButton->setEnabled( false );
   layout->addWidget( mButton, 2, 1 );
 
   layout->setRowSpacing( 3, 1 );
 
-  connect( mPassword, SIGNAL( textChanged( const QString& ) ), this, SLOT( textChanged() ) );
-  connect( mPasswordRetype, SIGNAL( textChanged( const QString& ) ), this, SLOT( textChanged() ) );
-  connect( mButton, SIGNAL( clicked() ), this, SLOT( buttonClicked() ) );
+  connect( mPassword, TQT_SIGNAL( textChanged( const TQString& ) ), this, TQT_SLOT( textChanged() ) );
+  connect( mPasswordRetype, TQT_SIGNAL( textChanged( const TQString& ) ), this, TQT_SLOT( textChanged() ) );
+  connect( mButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( buttonClicked() ) );
 }
 
 void PasswordPage::buttonClicked()
@@ -77,7 +77,7 @@ void PasswordPage::buttonClicked()
 
     mJob = Scalix::setPassword( Settings::self()->globalSlave(), Settings::self()->accountUrl(),
                                 Settings::self()->accountPassword(), mPassword->text() );
-    connect( mJob, SIGNAL( result( KIO::Job* ) ), this, SLOT( finished( KIO::Job* ) ) );
+    connect( mJob, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( finished( KIO::Job* ) ) );
 
     updateState( true );
   } else {
@@ -120,7 +120,7 @@ void PasswordPage::finished( KIO::Job* job )
 
   // Update configuration files to the new password as well
 
-  const QString newPassword = mPassword->text();
+  const TQString newPassword = mPassword->text();
 
   { // ScalixAdmin config
     KConfig config( "scalixadminrc" );
@@ -138,8 +138,8 @@ void PasswordPage::finished( KIO::Job* job )
     KConfig config( "kmailrc" );
 
     // Try to find account group for Scalix
-    QString scalixAccount;
-    const QStringList groupList = config.groupList();
+    TQString scalixAccount;
+    const TQStringList groupList = config.groupList();
     for ( uint i = 0; i < groupList.count(); ++i ) {
       if ( groupList[ i ].startsWith( "Account " ) ) {
         KConfigGroup group( &config, groupList[ i ] );
@@ -173,13 +173,13 @@ void PasswordPage::finished( KIO::Job* job )
           if ( !wallet->hasFolder( "kmail" ) )
             wallet->createFolder( "kmail" );
           wallet->setFolder( "kmail" );
-          wallet->writePassword( "account-" + QString::number( accountId ), newPassword );
+          wallet->writePassword( "account-" + TQString::number( accountId ), newPassword );
         }
       } else {
         group.writeEntry( "pass", KStringHandler::obscure( newPassword ) );
       }
 
-      KConfigGroup fileGroup( &config, QString( "Folder-%1" ).arg( group.readNumEntry( "Folder" ) ) );
+      KConfigGroup fileGroup( &config, TQString( "Folder-%1" ).arg( group.readNumEntry( "Folder" ) ) );
       fileGroup.writeEntry( "pass", KStringHandler::obscure( newPassword ) );
     }
   }
diff --git a/kresources/scalix/scalixadmin/passwordpage.h b/kresources/scalix/scalixadmin/passwordpage.h
index a397be41..b4cf3da0 100644
--- a/kresources/scalix/scalixadmin/passwordpage.h
+++ b/kresources/scalix/scalixadmin/passwordpage.h
@@ -21,7 +21,7 @@
 #ifndef PASSWORDPAGE_H
 #define PASSWORDPAGE_H
 
-#include <qwidget.h>
+#include <tqwidget.h>
 
 class QLineEdit;
 class QPushButton;
@@ -35,7 +35,7 @@ class PasswordPage : public QWidget
   Q_OBJECT
 
   public:
-    PasswordPage( QWidget *parent = 0 );
+    PasswordPage( TQWidget *parent = 0 );
 
   private slots:
     void buttonClicked();
@@ -45,9 +45,9 @@ class PasswordPage : public QWidget
   private:
     void updateState( bool );
 
-    QLineEdit *mPassword;
-    QLineEdit *mPasswordRetype;
-    QPushButton *mButton;
+    TQLineEdit *mPassword;
+    TQLineEdit *mPasswordRetype;
+    TQPushButton *mButton;
 
     KIO::Job *mJob;
 };
diff --git a/kresources/scalix/scalixadmin/settings.cpp b/kresources/scalix/scalixadmin/settings.cpp
index 2f6b49ba..52f72296 100644
--- a/kresources/scalix/scalixadmin/settings.cpp
+++ b/kresources/scalix/scalixadmin/settings.cpp
@@ -71,7 +71,7 @@ KURL Settings::accountUrl() const
   return url;
 }
 
-QString Settings::accountPassword() const
+TQString Settings::accountPassword() const
 {
   KConfig config( "scalixadminrc" );
   KConfigGroup group( &config, "Account" );
@@ -84,50 +84,50 @@ KIO::Slave* Settings::globalSlave() const
   return mSlave;
 }
 
-QString Settings::rulesWizardUrl() const
+TQString Settings::rulesWizardUrl() const
 {
   KConfig config( "scalixadminrc" );
   KConfigGroup group( &config, "Misc" );
 
-  QString url = group.readEntry( "rulesWizardUrl" );
+  TQString url = group.readEntry( "rulesWizardUrl" );
   if ( url.isEmpty() ) {
     KConfigGroup group( &config, "Account" );
-    url = QString( "http://%1/Scalix/rw/?username=%2" ).arg( group.readEntry( "host" ) )
+    url = TQString( "http://%1/Scalix/rw/?username=%2" ).arg( group.readEntry( "host" ) )
                                                        .arg( group.readEntry( "user" ) );
   }
 
   return url;
 }
 
-QString Settings::ldapHost() const
+TQString Settings::ldapHost() const
 {
   KConfig config( "scalixadminrc" );
   KConfigGroup group( &config, "LDAP" );
   return group.readEntry( "host" );
 }
 
-QString Settings::ldapPort() const
+TQString Settings::ldapPort() const
 {
   KConfig config( "scalixadminrc" );
   KConfigGroup group( &config, "LDAP" );
   return group.readEntry( "port" );
 }
 
-QString Settings::ldapBase() const
+TQString Settings::ldapBase() const
 {
   KConfig config( "scalixadminrc" );
   KConfigGroup group( &config, "LDAP" );
   return group.readEntry( "base" );
 }
 
-QString Settings::ldapBindDn() const
+TQString Settings::ldapBindDn() const
 {
   KConfig config( "scalixadminrc" );
   KConfigGroup group( &config, "LDAP" );
   return group.readEntry( "bindDn" );
 }
 
-QString Settings::ldapPassword() const
+TQString Settings::ldapPassword() const
 {
   KConfig config( "scalixadminrc" );
   KConfigGroup group( &config, "LDAP" );
diff --git a/kresources/scalix/scalixadmin/settings.h b/kresources/scalix/scalixadmin/settings.h
index 17ed9a2c..1e36833a 100644
--- a/kresources/scalix/scalixadmin/settings.h
+++ b/kresources/scalix/scalixadmin/settings.h
@@ -34,17 +34,17 @@ class Settings
 
     KIO::MetaData accountData() const;
     KURL accountUrl() const;
-    QString accountPassword() const;
+    TQString accountPassword() const;
 
     KIO::Slave *globalSlave() const;
 
-    QString rulesWizardUrl() const;
+    TQString rulesWizardUrl() const;
 
-    QString ldapHost() const;
-    QString ldapPort() const;
-    QString ldapBase() const;
-    QString ldapBindDn() const;
-    QString ldapPassword() const;
+    TQString ldapHost() const;
+    TQString ldapPort() const;
+    TQString ldapBase() const;
+    TQString ldapBindDn() const;
+    TQString ldapPassword() const;
 
   private:
     Settings();
diff --git a/kresources/scalix/shared/kmailconnection.cpp b/kresources/scalix/shared/kmailconnection.cpp
index af32cd74..b4b4b9eb 100644
--- a/kresources/scalix/shared/kmailconnection.cpp
+++ b/kresources/scalix/shared/kmailconnection.cpp
@@ -46,7 +46,7 @@ using namespace Scalix;
 
 
 KMailConnection::KMailConnection( ResourceScalixBase* resource,
-                                  const QCString& objId )
+                                  const TQCString& objId )
   : DCOPObject( objId ), mResource( resource ), mKMailIcalIfaceStub( 0 )
 {
   // Make the connection to KMail ready
@@ -55,8 +55,8 @@ KMailConnection::KMailConnection( ResourceScalixBase* resource,
   mDCOPClient->registerAs( objId, true );
 
   kapp->dcopClient()->setNotifications( true );
-  connect( kapp->dcopClient(), SIGNAL( applicationRemoved( const QCString& ) ),
-           this, SLOT( unregisteredFromDCOP( const QCString& ) ) );
+  connect( kapp->dcopClient(), TQT_SIGNAL( applicationRemoved( const TQCString& ) ),
+           this, TQT_SLOT( unregisteredFromDCOP( const TQCString& ) ) );
 }
 
 KMailConnection::~KMailConnection()
@@ -68,15 +68,15 @@ KMailConnection::~KMailConnection()
   mDCOPClient = 0;
 }
 
-static const QCString dcopObjectId = "KMailICalIface";
+static const TQCString dcopObjectId = "KMailICalIface";
 bool KMailConnection::connectToKMail()
 {
   if ( !mKMailIcalIfaceStub ) {
-    QString error;
-    QCString dcopService;
+    TQString error;
+    TQCString dcopService;
     int result = KDCOPServiceStarter::self()->
-      findServiceFor( "DCOP/ResourceBackend/IMAP", QString::null,
-                      QString::null, &error, &dcopService );
+      findServiceFor( "DCOP/ResourceBackend/IMAP", TQString::null,
+                      TQString::null, &error, &dcopService );
     if ( result != 0 ) {
       kdError(5650) << "Couldn't connect to the IMAP resource backend\n";
       // TODO: You might want to show "error" (if not empty) here,
@@ -88,34 +88,34 @@ bool KMailConnection::connectToKMail()
                                                    dcopService, dcopObjectId );
 
     // Attach to the KMail signals
-    if ( !connectKMailSignal( "incidenceAdded(QString,QString,Q_UINT32,int,QString)",
-                              "fromKMailAddIncidence(QString,QString,Q_UINT32,int,QString)" ) )
+    if ( !connectKMailSignal( "incidenceAdded(TQString,TQString,Q_UINT32,int,TQString)",
+                              "fromKMailAddIncidence(TQString,TQString,Q_UINT32,int,TQString)" ) )
       kdError(5650) << "DCOP connection to incidenceAdded failed" << endl;
-    if ( !connectKMailSignal( "incidenceDeleted(QString,QString,QString)",
-                              "fromKMailDelIncidence(QString,QString,QString)" ) )
+    if ( !connectKMailSignal( "incidenceDeleted(TQString,TQString,TQString)",
+                              "fromKMailDelIncidence(TQString,TQString,TQString)" ) )
       kdError(5650) << "DCOP connection to incidenceDeleted failed" << endl;
-    if ( !connectKMailSignal( "signalRefresh(QString,QString)",
-                              "fromKMailRefresh(QString,QString)" ) )
+    if ( !connectKMailSignal( "signalRefresh(TQString,TQString)",
+                              "fromKMailRefresh(TQString,TQString)" ) )
       kdError(5650) << "DCOP connection to signalRefresh failed" << endl;
-    if ( !connectKMailSignal( "subresourceAdded( QString, QString, QString )",
-                              "fromKMailAddSubresource( QString, QString, QString )" ) )
+    if ( !connectKMailSignal( "subresourceAdded( TQString, TQString, TQString )",
+                              "fromKMailAddSubresource( TQString, TQString, TQString )" ) )
       kdError(5650) << "DCOP connection to subresourceAdded failed" << endl;
-    if ( !connectKMailSignal( "subresourceDeleted(QString,QString)",
-                              "fromKMailDelSubresource(QString,QString)" ) )
+    if ( !connectKMailSignal( "subresourceDeleted(TQString,TQString)",
+                              "fromKMailDelSubresource(TQString,TQString)" ) )
       kdError(5650) << "DCOP connection to subresourceDeleted failed" << endl;
-    if ( !connectKMailSignal( "asyncLoadResult(QMap<Q_UINT32, QString>, QString, QString)",
-                              "fromKMailAsyncLoadResult(QMap<Q_UINT32, QString>, QString, QString)" ) )
+    if ( !connectKMailSignal( "asyncLoadResult(TQMap<Q_UINT32, TQString>, TQString, TQString)",
+                              "fromKMailAsyncLoadResult(TQMap<Q_UINT32, TQString>, TQString, TQString)" ) )
       kdError(5650) << "DCOP connection to asyncLoadResult failed" << endl;
   }
 
   return ( mKMailIcalIfaceStub != 0 );
 }
 
-bool KMailConnection::fromKMailAddIncidence( const QString& type,
-                                             const QString& folder,
+bool KMailConnection::fromKMailAddIncidence( const TQString& type,
+                                             const TQString& folder,
                                              Q_UINT32 sernum,
                                              int format,
-                                             const QString& data )
+                                             const TQString& data )
 {
   if ( format != KMailICalIface::StorageXML
       && format != KMailICalIface::StorageIcalVcard )
@@ -125,25 +125,25 @@ bool KMailConnection::fromKMailAddIncidence( const QString& type,
   return mResource->fromKMailAddIncidence( type, folder, sernum, format, data );
 }
 
-void KMailConnection::fromKMailDelIncidence( const QString& type,
-                                             const QString& folder,
-                                             const QString& xml )
+void KMailConnection::fromKMailDelIncidence( const TQString& type,
+                                             const TQString& folder,
+                                             const TQString& xml )
 {
 //   kdDebug(5650) << "KMailConnection::fromKMailDelIncidence( " << type << ", "
 //                 << folder << ", " << uid << " )\n";
   mResource->fromKMailDelIncidence( type, folder, xml );
 }
 
-void KMailConnection::fromKMailRefresh( const QString& type, const QString& folder )
+void KMailConnection::fromKMailRefresh( const TQString& type, const TQString& folder )
 {
 //   kdDebug(5650) << "KMailConnection::fromKMailRefresh( " << type << ", "
 //                 << folder << " )\n";
   mResource->fromKMailRefresh( type, folder );
 }
 
-void KMailConnection::fromKMailAddSubresource( const QString& type,
-                                               const QString& resource,
-                                               const QString& label )
+void KMailConnection::fromKMailAddSubresource( const TQString& type,
+                                               const TQString& resource,
+                                               const TQString& label )
 {
 //   kdDebug(5650) << "KMailConnection::fromKMailAddSubresource( " << type << ", "
 //                 << resource << " )\n";
@@ -156,30 +156,30 @@ void KMailConnection::fromKMailAddSubresource( const QString& type,
   mResource->fromKMailAddSubresource( type, resource, label, writable );
 }
 
-void KMailConnection::fromKMailDelSubresource( const QString& type,
-                                               const QString& resource )
+void KMailConnection::fromKMailDelSubresource( const TQString& type,
+                                               const TQString& resource )
 {
 //   kdDebug(5650) << "KMailConnection::fromKMailDelSubresource( " << type << ", "
 //                 << resource << " )\n";
   mResource->fromKMailDelSubresource( type, resource );
 }
 
-void KMailConnection::fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                                const QString& type,
-                                                const QString& folder )
+void KMailConnection::fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                                const TQString& type,
+                                                const TQString& folder )
 {
   mResource->fromKMailAsyncLoadResult( map, type, folder );
 }
 
-bool KMailConnection::connectKMailSignal( const QCString& signal,
-                                          const QCString& method )
+bool KMailConnection::connectKMailSignal( const TQCString& signal,
+                                          const TQCString& method )
 {
   return connectDCOPSignal( "kmail", dcopObjectId, signal, method, false )
     && connectDCOPSignal( "kontact", dcopObjectId, signal, method, false );
 }
 
-bool KMailConnection::kmailSubresources( QValueList<KMailICalIface::SubResource>& lst,
-                                         const QString& contentsType )
+bool KMailConnection::kmailSubresources( TQValueList<KMailICalIface::SubResource>& lst,
+                                         const TQString& contentsType )
 {
   if ( !connectToKMail() )
     return false;
@@ -189,8 +189,8 @@ bool KMailConnection::kmailSubresources( QValueList<KMailICalIface::SubResource>
 }
 
 bool KMailConnection::kmailIncidencesCount( int& count,
-                                            const QString& mimetype,
-                                            const QString& resource )
+                                            const TQString& mimetype,
+                                            const TQString& resource )
 {
   if ( !connectToKMail() )
     return false;
@@ -199,9 +199,9 @@ bool KMailConnection::kmailIncidencesCount( int& count,
   return mKMailIcalIfaceStub->ok();
 }
 
-bool KMailConnection::kmailIncidences( QMap<Q_UINT32, QString>& lst,
-                                       const QString& mimetype,
-                                       const QString& resource,
+bool KMailConnection::kmailIncidences( TQMap<Q_UINT32, TQString>& lst,
+                                       const TQString& mimetype,
+                                       const TQString& resource,
                                        int startIndex,
                                        int nbMessages )
 {
@@ -214,9 +214,9 @@ bool KMailConnection::kmailIncidences( QMap<Q_UINT32, QString>& lst,
 
 
 bool KMailConnection::kmailGetAttachment( KURL& url,
-                                          const QString& resource,
+                                          const TQString& resource,
                                           Q_UINT32 sernum,
-                                          const QString& filename )
+                                          const TQString& filename )
 {
   if ( !connectToKMail() )
     return false;
@@ -225,7 +225,7 @@ bool KMailConnection::kmailGetAttachment( KURL& url,
   return mKMailIcalIfaceStub->ok();
 }
 
-bool KMailConnection::kmailDeleteIncidence( const QString& resource,
+bool KMailConnection::kmailDeleteIncidence( const TQString& resource,
                                             Q_UINT32 sernum )
 {
   return connectToKMail()
@@ -233,15 +233,15 @@ bool KMailConnection::kmailDeleteIncidence( const QString& resource,
     && mKMailIcalIfaceStub->ok();
 }
 
-bool KMailConnection::kmailUpdate( const QString& resource,
+bool KMailConnection::kmailUpdate( const TQString& resource,
                                    Q_UINT32& sernum,
-                                   const QString& subject,
-                                   const QString& plainTextBody,
-                                   const QMap<QCString, QString>& customHeaders,
-                                   const QStringList& attachmentURLs,
-                                   const QStringList& attachmentMimetypes,
-                                   const QStringList& attachmentNames,
-                                   const QStringList& deletedAttachments )
+                                   const TQString& subject,
+                                   const TQString& plainTextBody,
+                                   const TQMap<TQCString, TQString>& customHeaders,
+                                   const TQStringList& attachmentURLs,
+                                   const TQStringList& attachmentMimetypes,
+                                   const TQStringList& attachmentNames,
+                                   const TQStringList& deletedAttachments )
 {
   //kdDebug(5006) << kdBacktrace() << endl;
   if ( connectToKMail() ) {
@@ -254,7 +254,7 @@ bool KMailConnection::kmailUpdate( const QString& resource,
 }
 
 bool KMailConnection::kmailStorageFormat( KMailICalIface::StorageFormat& type,
-                                          const QString& folder )
+                                          const TQString& folder )
 {
   bool ok = connectToKMail();
   type = mKMailIcalIfaceStub->storageFormat( folder );
@@ -262,13 +262,13 @@ bool KMailConnection::kmailStorageFormat( KMailICalIface::StorageFormat& type,
 }
 
 
-bool KMailConnection::kmailTriggerSync( const QString &contentsType )
+bool KMailConnection::kmailTriggerSync( const TQString &contentsType )
 {
   bool ok = connectToKMail();
   return ok && mKMailIcalIfaceStub->triggerSync( contentsType );
 }
 
-void KMailConnection::unregisteredFromDCOP( const QCString& appId )
+void KMailConnection::unregisteredFromDCOP( const TQCString& appId )
 {
   if ( mKMailIcalIfaceStub && mKMailIcalIfaceStub->app() == appId ) {
     // Delete the stub so that the next time we need to talk to kmail,
diff --git a/kresources/scalix/shared/kmailconnection.h b/kresources/scalix/shared/kmailconnection.h
index ea57857a..bd02d7bb 100644
--- a/kresources/scalix/shared/kmailconnection.h
+++ b/kresources/scalix/shared/kmailconnection.h
@@ -47,24 +47,24 @@ class ResourceScalixBase;
 /**
   This class provides the kmail connectivity for IMAP resources.
 */
-class KMailConnection : public QObject, public DCOPObject {
+class KMailConnection : public TQObject, public DCOPObject {
   Q_OBJECT
   K_DCOP
 
   // These are the methods called by KMail when the resource changes
 k_dcop:
-  bool fromKMailAddIncidence( const QString& type, const QString& resource,
-                              Q_UINT32 sernum, int format, const QString& xml );
-  void fromKMailDelIncidence( const QString& type, const QString& resource,
-                              const QString& xml );
-  void fromKMailRefresh( const QString& type, const QString& resource );
-  void fromKMailAddSubresource( const QString& type, const QString& resource, const QString& label );
-  void fromKMailDelSubresource( const QString& type, const QString& resource );
-  void fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map, const QString& type,
-                                 const QString& folder );
+  bool fromKMailAddIncidence( const TQString& type, const TQString& resource,
+                              Q_UINT32 sernum, int format, const TQString& xml );
+  void fromKMailDelIncidence( const TQString& type, const TQString& resource,
+                              const TQString& xml );
+  void fromKMailRefresh( const TQString& type, const TQString& resource );
+  void fromKMailAddSubresource( const TQString& type, const TQString& resource, const TQString& label );
+  void fromKMailDelSubresource( const TQString& type, const TQString& resource );
+  void fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map, const TQString& type,
+                                 const TQString& folder );
 
 public:
-  KMailConnection( ResourceScalixBase* resource, const QCString& objId );
+  KMailConnection( ResourceScalixBase* resource, const TQCString& objId );
   virtual ~KMailConnection();
 
   /**
@@ -73,39 +73,39 @@ public:
   bool connectToKMail();
 
   // Call the DCOP methods
-  bool kmailSubresources( QValueList<KMailICalIface::SubResource>& lst,
-                          const QString& contentsType );
+  bool kmailSubresources( TQValueList<KMailICalIface::SubResource>& lst,
+                          const TQString& contentsType );
   bool kmailIncidencesCount( int& count,
-                             const QString& mimetype,
-                             const QString& resource );
-  bool kmailIncidences( QMap<Q_UINT32, QString>& lst, const QString& mimetype,
-                        const QString& resource,
+                             const TQString& mimetype,
+                             const TQString& resource );
+  bool kmailIncidences( TQMap<Q_UINT32, TQString>& lst, const TQString& mimetype,
+                        const TQString& resource,
                         int startIndex,
                         int nbMessages );
 
-  bool kmailGetAttachment( KURL& url, const QString& resource, Q_UINT32 sernum,
-                           const QString& filename );
-  bool kmailDeleteIncidence( const QString& resource, Q_UINT32 sernum );
-  bool kmailUpdate( const QString& resource,
+  bool kmailGetAttachment( KURL& url, const TQString& resource, Q_UINT32 sernum,
+                           const TQString& filename );
+  bool kmailDeleteIncidence( const TQString& resource, Q_UINT32 sernum );
+  bool kmailUpdate( const TQString& resource,
                     Q_UINT32& sernum,
-                    const QString& subject,
-                    const QString& plainTextBody,
-                    const QMap<QCString, QString>& customHeaders,
-                    const QStringList& attachmentURLs,
-                    const QStringList& attachmentMimetypes,
-                    const QStringList& attachmentNames,
-                    const QStringList& deletedAttachments );
+                    const TQString& subject,
+                    const TQString& plainTextBody,
+                    const TQMap<TQCString, TQString>& customHeaders,
+                    const TQStringList& attachmentURLs,
+                    const TQStringList& attachmentMimetypes,
+                    const TQStringList& attachmentNames,
+                    const TQStringList& deletedAttachments );
 
-  bool kmailStorageFormat( KMailICalIface::StorageFormat& type, const QString& folder);
+  bool kmailStorageFormat( KMailICalIface::StorageFormat& type, const TQString& folder);
 
-  bool kmailTriggerSync( const QString& contentsType );
+  bool kmailTriggerSync( const TQString& contentsType );
 
 private slots:
-  virtual void unregisteredFromDCOP( const QCString& );
+  virtual void unregisteredFromDCOP( const TQCString& );
 
 private:
   /** Connect a signal from KMail to a local slot. */
-  bool connectKMailSignal( const QCString&, const QCString& );
+  bool connectKMailSignal( const TQCString&, const TQCString& );
 
   ResourceScalixBase* mResource;
   DCOPClient* mDCOPClient;
diff --git a/kresources/scalix/shared/resourcescalixbase.cpp b/kresources/scalix/shared/resourcescalixbase.cpp
index e91e5878..e239bfb3 100644
--- a/kresources/scalix/shared/resourcescalixbase.cpp
+++ b/kresources/scalix/shared/resourcescalixbase.cpp
@@ -41,19 +41,19 @@
 #include <kurl.h>
 #include <ktempfile.h>
 #include <kmessagebox.h>
-#include <qtextstream.h>
+#include <tqtextstream.h>
 #include <kdebug.h>
 
 using namespace Scalix;
 
 static unsigned int uniquifier = 0;
 
-ResourceScalixBase::ResourceScalixBase( const QCString& objId )
+ResourceScalixBase::ResourceScalixBase( const TQCString& objId )
   : mSilent( false )
 {
   KGlobal::locale()->insertCatalogue( "kres_scalix" );
   KGlobal::locale()->insertCatalogue( "libkcal" );
-  QString uniqueObjId = QString( objId ) + QString::number( uniquifier++ );
+  TQString uniqueObjId = TQString( objId ) + TQString::number( uniquifier++ );
   mConnection = new KMailConnection( this, uniqueObjId.utf8() );
 }
 
@@ -63,62 +63,62 @@ ResourceScalixBase::~ResourceScalixBase()
 }
 
 
-bool ResourceScalixBase::kmailSubresources( QValueList<KMailICalIface::SubResource>& lst,
-                                           const QString& contentsType ) const
+bool ResourceScalixBase::kmailSubresources( TQValueList<KMailICalIface::SubResource>& lst,
+                                           const TQString& contentsType ) const
 {
   return mConnection->kmailSubresources( lst, contentsType );
 }
 
-bool ResourceScalixBase::kmailTriggerSync( const QString& contentsType ) const
+bool ResourceScalixBase::kmailTriggerSync( const TQString& contentsType ) const
 {
   return mConnection->kmailTriggerSync( contentsType );
 }
 
 
 bool ResourceScalixBase::kmailIncidencesCount( int &count,
-                                              const QString& mimetype,
-                                              const QString& resource ) const
+                                              const TQString& mimetype,
+                                              const TQString& resource ) const
 {
   return mConnection->kmailIncidencesCount( count, mimetype, resource );
 }
 
-bool ResourceScalixBase::kmailIncidences( QMap<Q_UINT32, QString>& lst,
-                                         const QString& mimetype,
-                                         const QString& resource,
+bool ResourceScalixBase::kmailIncidences( TQMap<Q_UINT32, TQString>& lst,
+                                         const TQString& mimetype,
+                                         const TQString& resource,
                                          int startIndex,
                                          int nbMessages ) const
 {
   return mConnection->kmailIncidences( lst, mimetype, resource, startIndex, nbMessages );
 }
 
-bool ResourceScalixBase::kmailGetAttachment( KURL& url, const QString& resource,
+bool ResourceScalixBase::kmailGetAttachment( KURL& url, const TQString& resource,
                                             Q_UINT32 sernum,
-                                            const QString& filename ) const
+                                            const TQString& filename ) const
 {
   return mConnection->kmailGetAttachment( url, resource, sernum, filename );
 }
 
-bool ResourceScalixBase::kmailDeleteIncidence( const QString& resource,
+bool ResourceScalixBase::kmailDeleteIncidence( const TQString& resource,
                                               Q_UINT32 sernum )
 {
   return mSilent || mConnection->kmailDeleteIncidence( resource, sernum );
 }
 
-bool ResourceScalixBase::kmailUpdate( const QString& resource,
+bool ResourceScalixBase::kmailUpdate( const TQString& resource,
                                      Q_UINT32& sernum,
-                                     const QString& xml,
-                                     const QString& mimetype,
-                                     const QString& subject,
+                                     const TQString& xml,
+                                     const TQString& mimetype,
+                                     const TQString& subject,
                                      const CustomHeaderMap& _customHeaders,
-                                     const QStringList& _attachmentURLs,
-                                     const QStringList& _attachmentMimetypes,
-                                     const QStringList& _attachmentNames,
-                                     const QStringList& deletedAttachments )
+                                     const TQStringList& _attachmentURLs,
+                                     const TQStringList& _attachmentMimetypes,
+                                     const TQStringList& _attachmentNames,
+                                     const TQStringList& deletedAttachments )
 {
   if ( mSilent )
     return true;
 
-  QString subj = subject;
+  TQString subj = subject;
   if ( subj.isEmpty() )
     subj = i18n("Internal kolab data: Do not delete this mail.");
 
@@ -127,10 +127,10 @@ bool ResourceScalixBase::kmailUpdate( const QString& resource,
     _attachmentURLs, _attachmentMimetypes, _attachmentNames, deletedAttachments );
 }
 
-QString ResourceScalixBase::configFile( const QString& type ) const
+TQString ResourceScalixBase::configFile( const TQString& type ) const
 {
   return locateLocal( "config",
-                      QString( "kresources/scalix/%1rc" ).arg( type ) );
+                      TQString( "kresources/scalix/%1rc" ).arg( type ) );
 }
 
 bool ResourceScalixBase::connectToKMail() const
@@ -138,12 +138,12 @@ bool ResourceScalixBase::connectToKMail() const
   return mConnection->connectToKMail();
 }
 
-QString ResourceScalixBase::findWritableResource( const ResourceMap& resources )
+TQString ResourceScalixBase::findWritableResource( const ResourceMap& resources )
 {
   // I have to use the label (shown in the dialog) as key here. But given how the
   // label is made up, it should be unique. If it's not, well the dialog would suck anyway...
-  QMap<QString, QString> possible;
-  QStringList labels;
+  TQMap<TQString, TQString> possible;
+  TQStringList labels;
   ResourceMap::ConstIterator it;
   for ( it = resources.begin(); it != resources.end(); ++it ) {
     if ( it.data().writable() && it.data().active() ) {
@@ -155,23 +155,23 @@ QString ResourceScalixBase::findWritableResource( const ResourceMap& resources )
   if ( possible.isEmpty() ) { // None found!!
     kdWarning(5650) << "No writable resource found!" << endl;
     KMessageBox::error( 0, i18n( "No writable resource was found, saving will not be possible. Reconfigure KMail first." ) );
-    return QString::null;
+    return TQString::null;
   }
   if ( possible.count() == 1 )
     // Just one found
     return possible.begin().data(); // yes this is the subresource key, i.e. location
 
   // Several found, ask the user
-  QString chosenLabel = KPIM::FolderSelectDialog::getItem( i18n( "Select Resource Folder" ),
+  TQString chosenLabel = KPIM::FolderSelectDialog::getItem( i18n( "Select Resource Folder" ),
                                                            i18n( "You have more than one writable resource folder. "
                                                                  "Please select the one you want to write to." ),
                                                            possible.keys() );
   if ( chosenLabel.isEmpty() ) // cancelled
-    return QString::null;
+    return TQString::null;
   return possible[chosenLabel];
 }
 
-KMailICalIface::StorageFormat ResourceScalixBase::kmailStorageFormat( const QString &folder ) const
+KMailICalIface::StorageFormat ResourceScalixBase::kmailStorageFormat( const TQString &folder ) const
 {
   KMailICalIface::StorageFormat format = (KMailICalIface::StorageFormat) 3;
   mConnection->kmailStorageFormat( format, folder );
diff --git a/kresources/scalix/shared/resourcescalixbase.h b/kresources/scalix/shared/resourcescalixbase.h
index 3c32c1df..f1aefc19 100644
--- a/kresources/scalix/shared/resourcescalixbase.h
+++ b/kresources/scalix/shared/resourcescalixbase.h
@@ -33,9 +33,9 @@
 #ifndef RESOURCESCALIXBASE_H
 #define RESOURCESCALIXBASE_H
 
-#include <qstring.h>
-#include <qmap.h>
-#include <qstringlist.h>
+#include <tqstring.h>
+#include <tqmap.h>
+#include <tqstringlist.h>
 
 #include "subresource.h"
 #include <kmail/kmailicalIface.h>
@@ -72,30 +72,30 @@ class KMailConnection;
 */
 class ResourceScalixBase {
 public:
-  ResourceScalixBase( const QCString& objId );
+  ResourceScalixBase( const TQCString& objId );
   virtual ~ResourceScalixBase();
 
   // These are the methods called by KMail when the resource changes
-  virtual bool fromKMailAddIncidence( const QString& type,
-                                      const QString& resource,
+  virtual bool fromKMailAddIncidence( const TQString& type,
+                                      const TQString& resource,
                                       Q_UINT32 sernum,
                                       int format,
-                                      const QString& data ) = 0;
-  virtual void fromKMailDelIncidence( const QString& type,
-                                      const QString& resource,
-                                      const QString& xml ) = 0;
-  virtual void fromKMailRefresh( const QString& type,
-                                 const QString& resource ) = 0;
-  virtual void fromKMailAddSubresource( const QString& type,
-                                        const QString& resource,
-                                        const QString& label,
+                                      const TQString& data ) = 0;
+  virtual void fromKMailDelIncidence( const TQString& type,
+                                      const TQString& resource,
+                                      const TQString& xml ) = 0;
+  virtual void fromKMailRefresh( const TQString& type,
+                                 const TQString& resource ) = 0;
+  virtual void fromKMailAddSubresource( const TQString& type,
+                                        const TQString& resource,
+                                        const TQString& label,
                                         bool writable ) = 0;
-  virtual void fromKMailDelSubresource( const QString& type,
-                                        const QString& resource ) = 0;
+  virtual void fromKMailDelSubresource( const TQString& type,
+                                        const TQString& resource ) = 0;
 
-  virtual void fromKMailAsyncLoadResult( const QMap<Q_UINT32, QString>& map,
-                                         const QString& type,
-                                         const QString& folder ) = 0;
+  virtual void fromKMailAsyncLoadResult( const TQMap<Q_UINT32, TQString>& map,
+                                         const TQString& type,
+                                         const TQString& folder ) = 0;
 protected:
   /// Do the connection to KMail.
   bool connectToKMail() const;
@@ -103,58 +103,58 @@ protected:
   // These are the KMail dcop function connections. The docs here say
   // "Get", which here means that the first argument is the return arg
 
-  /// List all folders with a certain contentsType. Returns a QMap with
+  /// List all folders with a certain contentsType. Returns a TQMap with
   /// resourcename/writable pairs
-  bool kmailSubresources( QValueList<KMailICalIface::SubResource>& lst,
-                          const QString& contentsType ) const;
+  bool kmailSubresources( TQValueList<KMailICalIface::SubResource>& lst,
+                          const TQString& contentsType ) const;
 
   /// Get the number of messages in this folder.
   /// Used to iterate over kmailIncidences by chunks
-  bool kmailIncidencesCount( int& count, const QString& mimetype,
-                             const QString& resource ) const;
+  bool kmailIncidencesCount( int& count, const TQString& mimetype,
+                             const TQString& resource ) const;
 
   /// Get the mimetype attachments from a chunk of messages from this folder.
-  /// Returns a QMap with serialNumber/attachment pairs.
-  bool kmailIncidences( QMap<Q_UINT32, QString>& lst, const QString& mimetype,
-                        const QString& resource,
+  /// Returns a TQMap with serialNumber/attachment pairs.
+  bool kmailIncidences( TQMap<Q_UINT32, TQString>& lst, const TQString& mimetype,
+                        const TQString& resource,
                         int startIndex,
                         int nbMessages ) const;
 
-  bool kmailTriggerSync( const QString& contentType ) const;
+  bool kmailTriggerSync( const TQString& contentType ) const;
 
 public: // for Contact
   /// Get an attachment from a mail. Returns a URL to it. This can
   /// be called by the resource after obtaining the incidence.
   /// The resource must delete the temp file.
-  bool kmailGetAttachment( KURL& url, const QString& resource,
+  bool kmailGetAttachment( KURL& url, const TQString& resource,
                            Q_UINT32 sernum,
-                           const QString& filename ) const;
+                           const TQString& filename ) const;
 
 protected:
   /// Delete an incidence.
-  bool kmailDeleteIncidence( const QString& resource, Q_UINT32 sernum );
+  bool kmailDeleteIncidence( const TQString& resource, Q_UINT32 sernum );
 
-  KMailICalIface::StorageFormat kmailStorageFormat( const QString& folder ) const;
+  KMailICalIface::StorageFormat kmailStorageFormat( const TQString& folder ) const;
 
-  typedef QMap<QCString, QString> CustomHeaderMap;
+  typedef TQMap<TQCString, TQString> CustomHeaderMap;
 
   /// Update an incidence. The list of attachments are URLs.
   /// The parameter sernum is updated with the right KMail serial number
-  bool kmailUpdate( const QString& resource, Q_UINT32& sernum,
-                    const QString& xml,
-                    const QString& mimetype,
-                    const QString& subject,
+  bool kmailUpdate( const TQString& resource, Q_UINT32& sernum,
+                    const TQString& xml,
+                    const TQString& mimetype,
+                    const TQString& subject,
                     const CustomHeaderMap& customHeaders = CustomHeaderMap(),
-                    const QStringList& attachmentURLs = QStringList(),
-                    const QStringList& attachmentMimetypes = QStringList(),
-                    const QStringList& attachmentNames = QStringList(),
-                    const QStringList& deletedAttachments = QStringList() );
+                    const TQStringList& attachmentURLs = TQStringList(),
+                    const TQStringList& attachmentMimetypes = TQStringList(),
+                    const TQStringList& attachmentNames = TQStringList(),
+                    const TQStringList& deletedAttachments = TQStringList() );
 
   /// Get the full path of the config file.
-  QString configFile( const QString& type ) const;
+  TQString configFile( const TQString& type ) const;
 
   /// If only one of these is writable, return that. Otherwise return null.
-  QString findWritableResource( const ResourceMap& resources );
+  TQString findWritableResource( const ResourceMap& resources );
 
   bool mSilent;
 
@@ -167,9 +167,9 @@ protected:
 
   /// This is used to distinguish operations triggered by the user,
   /// from operations triggered by KMail
-  QStringList mUidsPendingAdding;
-  QStringList mUidsPendingDeletion;
-  QStringList mUidsPendingUpdate;
+  TQStringList mUidsPendingAdding;
+  TQStringList mUidsPendingDeletion;
+  TQStringList mUidsPendingUpdate;
 
 private:
   mutable KMailConnection* mConnection;
diff --git a/kresources/scalix/shared/scalixbase.cpp b/kresources/scalix/shared/scalixbase.cpp
index ab38500e..8fb5177b 100644
--- a/kresources/scalix/shared/scalixbase.cpp
+++ b/kresources/scalix/shared/scalixbase.cpp
@@ -36,14 +36,14 @@
 #include <libkcal/journal.h>
 #include <libkdepim/kpimprefs.h>
 #include <kdebug.h>
-#include <qfile.h>
+#include <tqfile.h>
 
 using namespace Scalix;
 
 
-ScalixBase::ScalixBase( const QString& tz )
-  : mCreationDate( QDateTime::currentDateTime() ),
-    mLastModified( QDateTime::currentDateTime() ),
+ScalixBase::ScalixBase( const TQString& tz )
+  : mCreationDate( TQDateTime::currentDateTime() ),
+    mLastModified( TQDateTime::currentDateTime() ),
     mSensitivity( Public ), mTimeZoneId( tz ),
     mHasPilotSyncId( false ),  mHasPilotSyncStatus( false )
 {
@@ -88,20 +88,20 @@ void ScalixBase::setFields( const KABC::Addressee* addressee )
   setCategories( addressee->categories().join( "," ) );
 
   // Set creation-time and last-modification-time
-  const QString creationString = addressee->custom( "KOLAB", "CreationDate" );
+  const TQString creationString = addressee->custom( "KOLAB", "CreationDate" );
   kdDebug(5006) << "Creation time string: " << creationString << endl;
-  QDateTime creationDate;
+  TQDateTime creationDate;
   if ( creationString.isEmpty() ) {
-    creationDate = QDateTime::currentDateTime();
+    creationDate = TQDateTime::currentDateTime();
     kdDebug(5006) << "Creation date set to current time\n";
   }
   else {
     creationDate = stringToDateTime( creationString );
     kdDebug(5006) << "Creation date loaded\n";
   }
-  QDateTime modified = addressee->revision();
+  TQDateTime modified = addressee->revision();
   if ( !modified.isValid() )
-    modified = QDateTime::currentDateTime();
+    modified = TQDateTime::currentDateTime();
   setLastModified( modified );
   if ( modified < creationDate ) {
     // It's not possible that the modification date is earlier than creation
@@ -109,7 +109,7 @@ void ScalixBase::setFields( const KABC::Addressee* addressee )
     kdDebug(5006) << "Creation date set to modification date\n";
   }
   setCreationDate( creationDate );
-  const QString newCreationDate = dateTimeToString( creationDate );
+  const TQString newCreationDate = dateTimeToString( creationDate );
   if ( creationString != newCreationDate ) {
     // We modified the creation date, so store it for future reference
     const_cast<KABC::Addressee*>( addressee )
@@ -135,7 +135,7 @@ void ScalixBase::saveTo( KABC::Addressee* addressee ) const
 {
   addressee->setUid( uid() );
   addressee->setNote( body() );
-  addressee->setCategories( QStringList::split( ',', categories() ) );
+  addressee->setCategories( TQStringList::split( ',', categories() ) );
   addressee->setRevision( lastModified() );
   addressee->insertCustom( "KOLAB", "CreationDate",
                            dateTimeToString( creationDate() ) );
@@ -155,52 +155,52 @@ void ScalixBase::saveTo( KABC::Addressee* addressee ) const
   // TODO: Attachments
 }
 
-void ScalixBase::setUid( const QString& uid )
+void ScalixBase::setUid( const TQString& uid )
 {
   mUid = uid;
 }
 
-QString ScalixBase::uid() const
+TQString ScalixBase::uid() const
 {
   return mUid;
 }
 
-void ScalixBase::setBody( const QString& body )
+void ScalixBase::setBody( const TQString& body )
 {
   mBody = body;
 }
 
-QString ScalixBase::body() const
+TQString ScalixBase::body() const
 {
   return mBody;
 }
 
-void ScalixBase::setCategories( const QString& categories )
+void ScalixBase::setCategories( const TQString& categories )
 {
   mCategories = categories;
 }
 
-QString ScalixBase::categories() const
+TQString ScalixBase::categories() const
 {
   return mCategories;
 }
 
-void ScalixBase::setCreationDate( const QDateTime& date )
+void ScalixBase::setCreationDate( const TQDateTime& date )
 {
   mCreationDate = date;
 }
 
-QDateTime ScalixBase::creationDate() const
+TQDateTime ScalixBase::creationDate() const
 {
   return mCreationDate;
 }
 
-void ScalixBase::setLastModified( const QDateTime& date )
+void ScalixBase::setLastModified( const TQDateTime& date )
 {
   mLastModified = date;
 }
 
-QDateTime ScalixBase::lastModified() const
+TQDateTime ScalixBase::lastModified() const
 {
   return mLastModified;
 }
@@ -247,14 +247,14 @@ int ScalixBase::pilotSyncStatus() const
   return mPilotSyncStatus;
 }
 
-bool ScalixBase::loadEmailAttribute( QDomElement& element, Email& email )
+bool ScalixBase::loadEmailAttribute( TQDomElement& element, Email& email )
 {
-  for ( QDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling() ) {
+  for ( TQDomNode n = element.firstChild(); !n.isNull(); n = n.nextSibling() ) {
     if ( n.isComment() )
       continue;
     if ( n.isElement() ) {
-      QDomElement e = n.toElement();
-      QString tagName = e.tagName();
+      TQDomElement e = n.toElement();
+      TQString tagName = e.tagName();
 
       if ( tagName == "display-name" )
         email.displayName = e.text();
@@ -270,18 +270,18 @@ bool ScalixBase::loadEmailAttribute( QDomElement& element, Email& email )
   return true;
 }
 
-void ScalixBase::saveEmailAttribute( QDomElement& element, const Email& email,
-                                    const QString& tagName ) const
+void ScalixBase::saveEmailAttribute( TQDomElement& element, const Email& email,
+                                    const TQString& tagName ) const
 {
-  QDomElement e = element.ownerDocument().createElement( tagName );
+  TQDomElement e = element.ownerDocument().createElement( tagName );
   element.appendChild( e );
   writeString( e, "display-name", email.displayName );
   writeString( e, "smtp-address", email.smtpAddress );
 }
 
-bool ScalixBase::loadAttribute( QDomElement& element )
+bool ScalixBase::loadAttribute( TQDomElement& element )
 {
-  QString tagName = element.tagName();
+  TQString tagName = element.tagName();
 
   if ( tagName == "uid" )
     setUid( element.text() );
@@ -308,7 +308,7 @@ bool ScalixBase::loadAttribute( QDomElement& element )
   return true;
 }
 
-bool ScalixBase::saveAttributes( QDomElement& element ) const
+bool ScalixBase::saveAttributes( TQDomElement& element ) const
 {
   writeString( element, "product-id", productID() );
   writeString( element, "uid", uid() );
@@ -319,17 +319,17 @@ bool ScalixBase::saveAttributes( QDomElement& element ) const
                dateTimeToString( lastModified() ) );
   writeString( element, "sensitivity", sensitivityToString( sensitivity() ) );
   if ( hasPilotSyncId() )
-    writeString( element, "pilot-sync-id", QString::number( pilotSyncId() ) );
+    writeString( element, "pilot-sync-id", TQString::number( pilotSyncId() ) );
   if ( hasPilotSyncStatus() )
-    writeString( element, "pilot-sync-status", QString::number( pilotSyncStatus() ) );
+    writeString( element, "pilot-sync-status", TQString::number( pilotSyncStatus() ) );
   return true;
 }
 
-bool ScalixBase::load( const QString& xml )
+bool ScalixBase::load( const TQString& xml )
 {
-  QString errorMsg;
+  TQString errorMsg;
   int errorLine, errorColumn;
-  QDomDocument document;
+  TQDomDocument document;
   bool ok = document.setContent( xml, &errorMsg, &errorLine, &errorColumn );
 
   if ( !ok ) {
@@ -342,11 +342,11 @@ bool ScalixBase::load( const QString& xml )
   return loadXML( document );
 }
 
-bool ScalixBase::load( QFile& xml )
+bool ScalixBase::load( TQFile& xml )
 {
-  QString errorMsg;
+  TQString errorMsg;
   int errorLine, errorColumn;
-  QDomDocument document;
+  TQDomDocument document;
   bool ok = document.setContent( &xml, &errorMsg, &errorLine, &errorColumn );
 
   if ( !ok ) {
@@ -359,41 +359,41 @@ bool ScalixBase::load( QFile& xml )
   return loadXML( document );
 }
 
-QDomDocument ScalixBase::domTree()
+TQDomDocument ScalixBase::domTree()
 {
-  QDomDocument document;
+  TQDomDocument document;
 
-  QString p = "version=\"1.0\" encoding=\"UTF-8\"";
+  TQString p = "version=\"1.0\" encoding=\"UTF-8\"";
   document.appendChild(document.createProcessingInstruction( "xml", p ) );
 
   return document;
 }
 
 
-QString ScalixBase::dateTimeToString( const QDateTime& time )
+TQString ScalixBase::dateTimeToString( const TQDateTime& time )
 {
   return time.toString( Qt::ISODate ) + 'Z';
 }
 
-QString ScalixBase::dateToString( const QDate& date )
+TQString ScalixBase::dateToString( const TQDate& date )
 {
   return date.toString( Qt::ISODate );
 }
 
-QDateTime ScalixBase::stringToDateTime( const QString& _date )
+TQDateTime ScalixBase::stringToDateTime( const TQString& _date )
 {
-  QString date( _date );
+  TQString date( _date );
   if ( date.endsWith( "Z" ) )
     date.truncate( date.length() - 1 );
-  return QDateTime::fromString( date, Qt::ISODate );
+  return TQDateTime::fromString( date, Qt::ISODate );
 }
 
-QDate ScalixBase::stringToDate( const QString& date )
+TQDate ScalixBase::stringToDate( const TQString& date )
 {
-  return QDate::fromString( date, Qt::ISODate );
+  return TQDate::fromString( date, Qt::ISODate );
 }
 
-QString ScalixBase::sensitivityToString( Sensitivity s )
+TQString ScalixBase::sensitivityToString( Sensitivity s )
 {
   switch( s ) {
   case Private: return "private";
@@ -404,7 +404,7 @@ QString ScalixBase::sensitivityToString( Sensitivity s )
   return "What what what???";
 }
 
-ScalixBase::Sensitivity ScalixBase::stringToSensitivity( const QString& s )
+ScalixBase::Sensitivity ScalixBase::stringToSensitivity( const TQString& s )
 {
   if ( s == "private" )
     return Private;
@@ -413,34 +413,34 @@ ScalixBase::Sensitivity ScalixBase::stringToSensitivity( const QString& s )
   return Public;
 }
 
-QString ScalixBase::colorToString( const QColor& color )
+TQString ScalixBase::colorToString( const TQColor& color )
 {
   // Color is in the format "#RRGGBB"
   return color.name();
 }
 
-QColor ScalixBase::stringToColor( const QString& s )
+TQColor ScalixBase::stringToColor( const TQString& s )
 {
-  return QColor( s );
+  return TQColor( s );
 }
 
-void ScalixBase::writeString( QDomElement& element, const QString& tag,
-                             const QString& tagString )
+void ScalixBase::writeString( TQDomElement& element, const TQString& tag,
+                             const TQString& tagString )
 {
   if ( !tagString.isEmpty() ) {
-    QDomElement e = element.ownerDocument().createElement( tag );
-    QDomText t = element.ownerDocument().createTextNode( tagString );
+    TQDomElement e = element.ownerDocument().createElement( tag );
+    TQDomText t = element.ownerDocument().createTextNode( tagString );
     e.appendChild( t );
     element.appendChild( e );
   }
 }
 
-QDateTime ScalixBase::localToUTC( const QDateTime& time ) const
+TQDateTime ScalixBase::localToUTC( const TQDateTime& time ) const
 {
   return KPimPrefs::localTimeToUtc( time, mTimeZoneId );
 }
 
-QDateTime ScalixBase::utcToLocal( const QDateTime& time ) const
+TQDateTime ScalixBase::utcToLocal( const TQDateTime& time ) const
 {
   return KPimPrefs::utcToLocalTime( time, mTimeZoneId );
 }
diff --git a/kresources/scalix/shared/scalixbase.h b/kresources/scalix/shared/scalixbase.h
index efed7e27..739a2615 100644
--- a/kresources/scalix/shared/scalixbase.h
+++ b/kresources/scalix/shared/scalixbase.h
@@ -33,9 +33,9 @@
 #ifndef SCALIXBASE_H
 #define SCALIXBASE_H
 
-#include <qdom.h>
-#include <qdatetime.h>
-#include <qcolor.h>
+#include <tqdom.h>
+#include <tqdatetime.h>
+#include <tqcolor.h>
 
 class QFile;
 
@@ -53,38 +53,38 @@ class ScalixBase {
 public:
   struct Email {
   public:
-    Email( const QString& name = QString::null,
-           const QString& email = QString::null )
+    Email( const TQString& name = TQString::null,
+           const TQString& email = TQString::null )
       : displayName( name ), smtpAddress( email )
     {
     }
 
-    QString displayName;
-    QString smtpAddress;
+    TQString displayName;
+    TQString smtpAddress;
   };
 
   enum Sensitivity { Public = 0, Private = 1, Confidential = 2 };
 
-  explicit ScalixBase( const QString& timezone = QString::null );
+  explicit ScalixBase( const TQString& timezone = TQString::null );
   virtual ~ScalixBase();
 
   // Return a string identifying this type
-  virtual QString type() const = 0;
+  virtual TQString type() const = 0;
 
-  virtual void setUid( const QString& uid );
-  virtual QString uid() const;
+  virtual void setUid( const TQString& uid );
+  virtual TQString uid() const;
 
-  virtual void setBody( const QString& body );
-  virtual QString body() const;
+  virtual void setBody( const TQString& body );
+  virtual TQString body() const;
 
-  virtual void setCategories( const QString& categories );
-  virtual QString categories() const;
+  virtual void setCategories( const TQString& categories );
+  virtual TQString categories() const;
 
-  virtual void setCreationDate( const QDateTime& date );
-  virtual QDateTime creationDate() const;
+  virtual void setCreationDate( const TQDateTime& date );
+  virtual TQDateTime creationDate() const;
 
-  virtual void setLastModified( const QDateTime& date );
-  virtual QDateTime lastModified() const;
+  virtual void setLastModified( const TQDateTime& date );
+  virtual TQDateTime lastModified() const;
 
   virtual void setSensitivity( Sensitivity sensitivity );
   virtual Sensitivity sensitivity() const;
@@ -98,28 +98,28 @@ public:
   virtual int pilotSyncStatus() const;
 
   // String - Date conversion methods
-  static QString dateTimeToString( const QDateTime& time );
-  static QString dateToString( const QDate& date );
-  static QDateTime stringToDateTime( const QString& time );
-  static QDate stringToDate( const QString& date );
+  static TQString dateTimeToString( const TQDateTime& time );
+  static TQString dateToString( const TQDate& date );
+  static TQDateTime stringToDateTime( const TQString& time );
+  static TQDate stringToDate( const TQString& date );
 
   // String - Sensitivity conversion methods
-  static QString sensitivityToString( Sensitivity );
-  static Sensitivity stringToSensitivity( const QString& );
+  static TQString sensitivityToString( Sensitivity );
+  static Sensitivity stringToSensitivity( const TQString& );
 
   // String - Color conversion methods
-  static QString colorToString( const QColor& );
-  static QColor stringToColor( const QString& );
+  static TQString colorToString( const TQColor& );
+  static TQColor stringToColor( const TQString& );
 
   // Load this object by reading the XML file
-  bool load( const QString& xml );
-  bool load( QFile& xml );
+  bool load( const TQString& xml );
+  bool load( TQFile& xml );
 
   // Load this QDomDocument
-  virtual bool loadXML( const QDomDocument& xml ) = 0;
+  virtual bool loadXML( const TQDomDocument& xml ) = 0;
 
   // Serialize this object to an XML string
-  virtual QString saveXML() const = 0;
+  virtual TQString saveXML() const = 0;
 
 protected:
   /// Read all known fields from this ical incidence
@@ -135,35 +135,35 @@ protected:
   void saveTo( KABC::Addressee* ) const;
 
   // This just makes the initial dom tree with version and doctype
-  static QDomDocument domTree();
+  static TQDomDocument domTree();
 
-  bool loadEmailAttribute( QDomElement& element, Email& email );
+  bool loadEmailAttribute( TQDomElement& element, Email& email );
 
-  void saveEmailAttribute( QDomElement& element, const Email& email,
-                           const QString& tagName = "email" ) const;
+  void saveEmailAttribute( TQDomElement& element, const Email& email,
+                           const TQString& tagName = "email" ) const;
 
   // Load the attributes of this class
-  virtual bool loadAttribute( QDomElement& );
+  virtual bool loadAttribute( TQDomElement& );
 
   // Save the attributes of this class
-  virtual bool saveAttributes( QDomElement& ) const;
+  virtual bool saveAttributes( TQDomElement& ) const;
 
   // Return the product ID
-  virtual QString productID() const = 0;
+  virtual TQString productID() const = 0;
 
   // Write a string tag
-  static void writeString( QDomElement&, const QString&, const QString& );
+  static void writeString( TQDomElement&, const TQString&, const TQString& );
 
-  QDateTime localToUTC( const QDateTime& time ) const;
-  QDateTime utcToLocal( const QDateTime& time ) const;
+  TQDateTime localToUTC( const TQDateTime& time ) const;
+  TQDateTime utcToLocal( const TQDateTime& time ) const;
 
-  QString mUid;
-  QString mBody;
-  QString mCategories;
-  QDateTime mCreationDate;
-  QDateTime mLastModified;
+  TQString mUid;
+  TQString mBody;
+  TQString mCategories;
+  TQDateTime mCreationDate;
+  TQDateTime mLastModified;
   Sensitivity mSensitivity;
-  QString mTimeZoneId;
+  TQString mTimeZoneId;
 
   // KPilot synchronization stuff
   bool mHasPilotSyncId,  mHasPilotSyncStatus;
diff --git a/kresources/scalix/shared/subresource.cpp b/kresources/scalix/shared/subresource.cpp
index 6653e0f0..0acfb081 100644
--- a/kresources/scalix/shared/subresource.cpp
+++ b/kresources/scalix/shared/subresource.cpp
@@ -35,7 +35,7 @@
 
 using namespace Scalix;
 
-SubResource::SubResource( bool active, bool writable, const QString& label,
+SubResource::SubResource( bool active, bool writable, const TQString& label,
                           int completionWeight )
   : mActive( active ),  mWritable( writable ), mLabel( label ),
     mCompletionWeight( completionWeight )
@@ -66,12 +66,12 @@ bool SubResource::writable() const
   return mWritable;
 }
 
-void SubResource::setLabel( const QString& label )
+void SubResource::setLabel( const TQString& label )
 {
   mLabel = label;
 }
 
-QString SubResource::label() const
+TQString SubResource::label() const
 {
   return mLabel;
 }
@@ -86,7 +86,7 @@ int SubResource::completionWeight() const
   return mCompletionWeight;
 }
 
-StorageReference::StorageReference( const QString& resource, Q_UINT32 sernum )
+StorageReference::StorageReference( const TQString& resource, Q_UINT32 sernum )
   : mResource( resource ), mSerialNumber( sernum )
 {
 }
@@ -95,12 +95,12 @@ StorageReference::~StorageReference()
 {
 }
 
-void StorageReference::setResource( const QString& resource )
+void StorageReference::setResource( const TQString& resource )
 {
   mResource = resource;
 }
 
-QString StorageReference::resource() const
+TQString StorageReference::resource() const
 {
   return mResource;
 }
diff --git a/kresources/scalix/shared/subresource.h b/kresources/scalix/shared/subresource.h
index 3cfc4429..f7898c14 100644
--- a/kresources/scalix/shared/subresource.h
+++ b/kresources/scalix/shared/subresource.h
@@ -34,8 +34,8 @@
 #ifndef SUBRESOURCE_H
 #define SUBRESOURCE_H
 
-#include <qstring.h>
-#include <qmap.h>
+#include <tqstring.h>
+#include <tqmap.h>
 
 
 namespace Scalix {
@@ -49,7 +49,7 @@ public:
   // This is just for QMap
   SubResource() {}
 
-  SubResource( bool active, bool writable, const QString& label,
+  SubResource( bool active, bool writable, const TQString& label,
                int completionWeight = 100 );
   virtual ~SubResource();
 
@@ -59,8 +59,8 @@ public:
   virtual void setWritable( bool writable );
   virtual bool writable() const;
 
-  virtual void setLabel( const QString& label );
-  virtual QString label() const;
+  virtual void setLabel( const TQString& label );
+  virtual TQString label() const;
 
   virtual void setCompletionWeight( int completionWeight );
   virtual int completionWeight() const;
@@ -68,7 +68,7 @@ public:
 private:
   bool mActive;   // Controlled by the applications
   bool mWritable; // Set if the KMail folder is writable
-  QString mLabel; // The GUI name of this resource
+  TQString mLabel; // The GUI name of this resource
 
   // This is just for the abc plugin. But as long as only this is here,
   // it's just as cheap to have it in here as making a d-pointer that
@@ -77,7 +77,7 @@ private:
   int mCompletionWeight;
 };
 
-typedef QMap<QString, SubResource> ResourceMap;
+typedef TQMap<TQString, SubResource> ResourceMap;
 
 /**
  * This class is used to store a mapping from the XML UID to the KMail
@@ -89,21 +89,21 @@ public:
   // Just for QMap
   StorageReference() {}
 
-  StorageReference( const QString& resource, Q_UINT32 sernum );
+  StorageReference( const TQString& resource, Q_UINT32 sernum );
   virtual ~StorageReference();
 
-  virtual void setResource( const QString& resource );
-  virtual QString resource() const;
+  virtual void setResource( const TQString& resource );
+  virtual TQString resource() const;
 
   virtual void setSerialNumber( Q_UINT32 serialNumber );
   virtual Q_UINT32 serialNumber() const;
 
 private:
-  QString mResource;
+  TQString mResource;
   Q_UINT32 mSerialNumber;
 };
 
-typedef QMap<QString, StorageReference> UidMap;
+typedef TQMap<TQString, StorageReference> UidMap;
 
 }