Port kdesvn to TQt4

This enables compilation under both Qt3 and Qt4


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

6 files changed, 211 insertions, 211 deletions

diff --git a/src/kiosvn/kiobytestream.cpp b/src/kiosvn/kiobytestream.cpp
index ff10a6a..81c6fc8 100644
--- a/src/kiosvn/kiobytestream.cpp
+++ b/src/kiosvn/kiobytestream.cpp
@@ -19,7 +19,7 @@
  ***************************************************************************/
 #include "kiobytestream.h"
 
-KioByteStream::KioByteStream(StreamWrittenCb*aCb,const QString&filename)
+KioByteStream::KioByteStream(StreamWrittenCb*aCb,const TQString&filename)
     : svn::stream::SvnStream(false,true,0L),
     m_Cb(aCb),m_Written(0),
     m_mimeSend(false),m_Filename(filename)
diff --git a/src/kiosvn/kiobytestream.h b/src/kiosvn/kiobytestream.h
index 8e62155..2fe8e57 100644
--- a/src/kiosvn/kiobytestream.h
+++ b/src/kiosvn/kiobytestream.h
@@ -25,8 +25,8 @@
 #include <kio/global.h>
 #include <kmimetype.h>
 #include <kmimemagic.h>
-#include <qbuffer.h>
-#include <qdatetime.h>
+#include <tqbuffer.h>
+#include <tqdatetime.h>
 
 class StreamWrittenCb
 {
@@ -34,7 +34,7 @@ public:
     StreamWrittenCb(){}
     virtual ~StreamWrittenCb(){}
     virtual void streamWritten(const KIO::filesize_t current) = 0;
-    virtual void streamPushData(QByteArray)=0;
+    virtual void streamPushData(TQByteArray)=0;
     virtual void streamSendMime(KMimeMagicResult*mt)=0;
     virtual void streamTotalSizeNull()=0;
 };
@@ -45,7 +45,7 @@ public:
 class KioByteStream : public svn::stream::SvnStream
 {
 public:
-    KioByteStream(StreamWrittenCb*,const QString&filename);
+    KioByteStream(StreamWrittenCb*,const TQString&filename);
 
     ~KioByteStream();
 
@@ -58,9 +58,9 @@ protected:
     StreamWrittenCb*m_Cb;
     KIO::filesize_t m_Written;
     bool m_mimeSend;
-    QString m_Filename;
-    QByteArray array;
-    QTime m_MessageTick;
+    TQString m_Filename;
+    TQByteArray array;
+    TQTime m_MessageTick;
 };
 
 #endif
diff --git a/src/kiosvn/kiolistener.cpp b/src/kiosvn/kiolistener.cpp
index f3b7b68..28536d7 100644
--- a/src/kiosvn/kiolistener.cpp
+++ b/src/kiosvn/kiolistener.cpp
@@ -50,27 +50,27 @@ bool KioListener::contextCancel()
 
 
 /*!
-    \fn KioListener::contextGetLogMessage (QString & msg)
+    \fn KioListener::contextGetLogMessage (TQString & msg)
  */
-bool KioListener::contextGetLogMessage (QString & msg,const svn::CommitItemList&_items)
+bool KioListener::contextGetLogMessage (TQString & msg,const svn::CommitItemList&_items)
 {
 #if 1
-    QByteArray reply;
-    QByteArray params;
-    QCString replyType;
-    QDataStream stream(params,IO_WriteOnly);
+    TQByteArray reply;
+    TQByteArray params;
+    TQCString replyType;
+    TQDataStream stream(params,IO_WriteOnly);
 
     if (_items.count()>0) {
-        QMap<QString,QString> list;
+        TQMap<TQString,TQString> list;
         for (unsigned i = 0;i<_items.count();++i) {
             if (_items[i].path().isEmpty()) {
-                list[_items[i].url()]=QChar(_items[i].actionType());
+                list[_items[i].url()]=TQChar(_items[i].actionType());
             } else {
-                list[_items[i].path()]=QChar(_items[i].actionType());
+                list[_items[i].path()]=TQChar(_items[i].actionType());
             }
         }
         stream << list;
-        if (!par->dcopClient()->call("kded","kdesvnd","get_logmsg(QMap<QString,QString>)",params,replyType,reply)) {
+        if (!par->dcopClient()->call("kded","kdesvnd","get_logmsg(TQMap<TQString,TQString>)",params,replyType,reply)) {
             msg = "Communication with dcop failed";
             kdWarning()<<msg<<endl;
             return false;
@@ -83,13 +83,13 @@ bool KioListener::contextGetLogMessage (QString & msg,const svn::CommitItemList&
         }
     }
 
-    if (replyType!="QStringList") {
+    if (replyType!=TQSTRINGLIST_OBJECT_NAME_STRING) {
         msg = "Wrong reply type";
         kdWarning()<<msg<<endl;
         return false;
     }
-    QDataStream stream2(reply,IO_ReadOnly);
-    QStringList lt;
+    TQDataStream stream2(reply,IO_ReadOnly);
+    TQStringList lt;
     stream2>>lt;
     if (lt.count()!=1) {
         msg = "Wrong or missing log (may cancel pressed).";
@@ -110,15 +110,15 @@ void KioListener::contextNotify (const char * path,svn_wc_notify_action_t action
     if (par->wasKilled()) {
         return;
     }
-    QString userstring;
+    TQString userstring;
 
     switch(action) {
         case svn_wc_notify_add:
         {
             if (mime_type && (svn_mime_type_is_binary (mime_type)))
-                userstring = i18n( "A (bin) %1" ).arg( path );
+                userstring = i18n( "A (bin) %1" ).tqarg( path );
             else
-                userstring = i18n( "A %1" ).arg( path );
+                userstring = i18n( "A %1" ).tqarg( path );
             break;
         }
         break;
@@ -126,33 +126,33 @@ void KioListener::contextNotify (const char * path,svn_wc_notify_action_t action
             break;
         case svn_wc_notify_delete: //delete
             m_HasChanges = TRUE;
-            userstring = i18n( "D %1" ).arg( path );
+            userstring = i18n( "D %1" ).tqarg( path );
             break;
         case svn_wc_notify_restore : //restore
-            userstring=i18n( "Restored %1." ).arg( path );
+            userstring=i18n( "Restored %1." ).tqarg( path );
             break;
         case svn_wc_notify_revert : //revert
-            userstring=i18n( "Reverted %1." ).arg( path );
+            userstring=i18n( "Reverted %1." ).tqarg( path );
             break;
         case svn_wc_notify_failed_revert: //failed revert
-            userstring=i18n( "Failed to revert %1.\nTry updating instead." ).arg( path );
+            userstring=i18n( "Failed to revert %1.\nTry updating instead." ).tqarg( path );
             break;
         case svn_wc_notify_resolved: //resolved
-            userstring=i18n( "Resolved conflicted state of %1." ).arg( path );
+            userstring=i18n( "Resolved conflicted state of %1." ).tqarg( path );
             break;
         case svn_wc_notify_skip: //skip
             if ( content_state == svn_wc_notify_state_missing )
-                userstring=i18n("Skipped missing target %1.").arg( path );
+                userstring=i18n("Skipped missing target %1.").tqarg( path );
             else
-                userstring=i18n("Skipped %1.").arg( path );
+                userstring=i18n("Skipped %1.").tqarg( path );
             break;
         case svn_wc_notify_update_delete: //update_delete
             m_HasChanges = TRUE;
-            userstring=i18n( "D %1" ).arg( path );
+            userstring=i18n( "D %1" ).tqarg( path );
             break;
         case svn_wc_notify_update_add: //update_add
             m_HasChanges = TRUE;
-            userstring=i18n( "A %1" ).arg( path );
+            userstring=i18n( "A %1" ).tqarg( path );
             break;
         case svn_wc_notify_update_update: //update_update
             {
@@ -187,7 +187,7 @@ void KioListener::contextNotify (const char * path,svn_wc_notify_action_t action
                                     || content_state == svn_wc_notify_state_unknown)
                                 && (prop_state == svn_wc_notify_state_unchanged
                                     || prop_state == svn_wc_notify_state_unknown)))
-                        userstring += QString( " " ) + path;
+                        userstring += TQString( " " ) + path;
                 }
                 break;
             }
@@ -195,13 +195,13 @@ void KioListener::contextNotify (const char * path,svn_wc_notify_action_t action
             {
                 if (!m_External) {
                     if (SVN_IS_VALID_REVNUM(revision)) {
-                        userstring = i18n("Finished at revision %1.").arg(revision);
+                        userstring = i18n("Finished at revision %1.").tqarg(revision);
                     } else {
                         userstring = i18n("Finished.");
                     }
                 } else {
                     if (SVN_IS_VALID_REVNUM(revision)) {
-                        userstring = i18n("Finished external at revision %1.").arg(revision);
+                        userstring = i18n("Finished external at revision %1.").tqarg(revision);
                     } else {
                         userstring = i18n("Finished external.");
                     }
@@ -212,30 +212,30 @@ void KioListener::contextNotify (const char * path,svn_wc_notify_action_t action
             break;
         case svn_wc_notify_update_external: //update_external
             m_External = TRUE;
-            userstring = i18n("Fetching external item into %1." ).arg( path );
+            userstring = i18n("Fetching external item into %1." ).tqarg( path );
             break;
         case svn_wc_notify_status_completed: //status_completed
             if (SVN_IS_VALID_REVNUM (revision))
-                userstring = i18n( "Status against revision: %1.").arg( revision );
+                userstring = i18n( "tqStatus against revision: %1.").tqarg( revision );
             break;
         case svn_wc_notify_status_external: //status_external
-             userstring = i18n("Performing status on external item at %1.").arg( path );
+             userstring = i18n("Performing status on external item at %1.").tqarg( path );
             break;
         case svn_wc_notify_commit_modified: //commit_modified
-            userstring = i18n( "Sending %1.").arg( path );
+            userstring = i18n( "Sending %1.").tqarg( path );
             break;
         case svn_wc_notify_commit_added: //commit_added
             if (mime_type && svn_mime_type_is_binary (mime_type)) {
-                userstring = i18n( "Adding (bin) %1.").arg( path );
+                userstring = i18n( "Adding (bin) %1.").tqarg( path );
             } else {
-                userstring = i18n( "Adding %1.").arg( path );
+                userstring = i18n( "Adding %1.").tqarg( path );
             }
             break;
         case svn_wc_notify_commit_deleted: //commit_deleted
-            userstring = i18n( "Deleting %1.").arg( path );
+            userstring = i18n( "Deleting %1.").tqarg( path );
             break;
         case svn_wc_notify_commit_replaced: //commit_replaced
-            userstring = i18n( "Replacing %1.").arg( path );
+            userstring = i18n( "Replacing %1.").tqarg( path );
             break;
         case svn_wc_notify_commit_postfix_txdelta: //commit_postfix_txdelta
             if (!m_FirstTxDelta) {
@@ -253,14 +253,14 @@ void KioListener::contextNotify (const char * path,svn_wc_notify_action_t action
         default:
             break;
     }
-    par->setMetaData(QString::number(counter()).rightJustify( 10,'0' )+ "path" , QString::FROMUTF8( path ));
-    par->setMetaData(QString::number( counter() ).rightJustify( 10,'0' )+ "action", QString::number( action ));
-    par->setMetaData(QString::number( counter() ).rightJustify( 10,'0' )+ "kind", QString::number( kind ));
-    par->setMetaData(QString::number( counter() ).rightJustify( 10,'0' )+ "mime_t", QString::FROMUTF8( mime_type ));
-    par->setMetaData(QString::number( counter() ).rightJustify( 10,'0' )+ "content", QString::number( content_state ));
-    par->setMetaData(QString::number( counter() ).rightJustify( 10,'0' )+ "prop", QString::number( prop_state ));
-    par->setMetaData(QString::number( counter() ).rightJustify( 10,'0' )+ "rev", QString::number( revision ));
-    par->setMetaData(QString::number( counter() ).rightJustify( 10,'0' )+ "string", userstring );
+    par->setMetaData(TQString::number(counter()).rightJustify( 10,'0' )+ "path" , TQString::FROMUTF8( path ));
+    par->setMetaData(TQString::number( counter() ).rightJustify( 10,'0' )+ "action", TQString::number( action ));
+    par->setMetaData(TQString::number( counter() ).rightJustify( 10,'0' )+ "kind", TQString::number( kind ));
+    par->setMetaData(TQString::number( counter() ).rightJustify( 10,'0' )+ "mime_t", TQString::FROMUTF8( mime_type ));
+    par->setMetaData(TQString::number( counter() ).rightJustify( 10,'0' )+ "content", TQString::number( content_state ));
+    par->setMetaData(TQString::number( counter() ).rightJustify( 10,'0' )+ "prop", TQString::number( prop_state ));
+    par->setMetaData(TQString::number( counter() ).rightJustify( 10,'0' )+ "rev", TQString::number( revision ));
+    par->setMetaData(TQString::number( counter() ).rightJustify( 10,'0' )+ "string", userstring );
     incCounter();
 }
 
@@ -272,16 +272,16 @@ void KioListener::contextNotify (const svn_wc_notify_t *action)
             action->content_state,action->prop_state,action->revision);
 //        return;
 //    }
-//    QString aString = NotifyAction(action->action);
+//    TQString aString = NotifyAction(action->action);
 }
 
 svn::ContextListener::SslServerTrustAnswer
 KioListener::contextSslServerTrustPrompt (const SslServerTrustData & data, apr_uint32_t & acceptedFailures)
 {
-    QByteArray reply;
-    QByteArray params;
-    QCString replyType;
-    QDataStream stream(params,IO_WriteOnly);
+    TQByteArray reply;
+    TQByteArray params;
+    TQCString replyType;
+    TQDataStream stream(params,IO_WriteOnly);
     stream << data.hostname
         << data.fingerprint
         << data.validFrom
@@ -290,7 +290,7 @@ KioListener::contextSslServerTrustPrompt (const SslServerTrustData & data, apr_u
         << data.realm;
 
     if (!par->dcopClient()->call("kded","kdesvnd",
-        "get_sslaccept(QString,QString,QString,QString,QString,QString)",
+        "get_sslaccept(TQString,TQString,TQString,TQString,TQString,TQString)",
         params,replyType,reply)) {
         kdWarning()<<"Communication with dcop failed"<<endl;
         return DONT_ACCEPT;
@@ -299,7 +299,7 @@ KioListener::contextSslServerTrustPrompt (const SslServerTrustData & data, apr_u
         kdWarning()<<"Wrong reply type"<<endl;
         return DONT_ACCEPT;
     }
-    QDataStream stream2(reply,IO_ReadOnly);
+    TQDataStream stream2(reply,IO_ReadOnly);
     int res;
     stream2>>res;
     switch (res) {
@@ -318,27 +318,27 @@ KioListener::contextSslServerTrustPrompt (const SslServerTrustData & data, apr_u
     return ACCEPT_TEMPORARILY;
 }
 
-bool KioListener::contextLoadSslClientCertPw(QString&password,const QString&realm)
+bool KioListener::contextLoadSslClientCertPw(TQString&password,const TQString&realm)
 {
     return PwStorage::self()->getCertPw(realm,password);
 }
 
-bool KioListener::contextSslClientCertPrompt (QString & certFile)
+bool KioListener::contextSslClientCertPrompt (TQString & certFile)
 {
-    QByteArray reply;
-    QByteArray params;
-    QCString replyType;
+    TQByteArray reply;
+    TQByteArray params;
+    TQCString replyType;
     if (!par->dcopClient()->call("kded","kdesvnd",
         "get_sslclientcertfile()",
         params,replyType,reply)) {
         kdWarning()<<"Communication with dcop failed"<<endl;
         return false;
     }
-    if (replyType!="QString") {
+    if (replyType!=TQSTRING_OBJECT_NAME_STRING) {
         kdWarning()<<"Wrong reply type"<<endl;
         return false;
     }
-    QDataStream stream2(reply,IO_ReadOnly);
+    TQDataStream stream2(reply,IO_ReadOnly);
     stream2>>certFile;
     if (certFile.isEmpty()) {
         return false;
@@ -346,43 +346,43 @@ bool KioListener::contextSslClientCertPrompt (QString & certFile)
     return true;
 }
 
-bool KioListener::contextSslClientCertPwPrompt (QString & password,
-                                   const QString & realm, bool & maySave)
+bool KioListener::contextSslClientCertPwPrompt (TQString & password,
+                                   const TQString & realm, bool & maySave)
 {
     return false;
 }
 
-bool KioListener::contextGetSavedLogin (const QString & realm,QString & username,QString & password)
+bool KioListener::contextGetSavedLogin (const TQString & realm,TQString & username,TQString & password)
 {
     PwStorage::self()->getLogin(realm,username,password);
     return true;
 }
 
-bool KioListener::contextGetCachedLogin (const QString & realm,QString & username,QString & password)
+bool KioListener::contextGetCachedLogin (const TQString & realm,TQString & username,TQString & password)
 {
     return true;
 }
 
-bool KioListener::contextGetLogin (const QString & realm, QString & username, QString & password, bool & maySave)
+bool KioListener::contextGetLogin (const TQString & realm, TQString & username, TQString & password, bool & maySave)
 {
-    QByteArray reply;
-    QByteArray params;
-    QCString replyType;
+    TQByteArray reply;
+    TQByteArray params;
+    TQCString replyType;
 
-    QDataStream stream(params,IO_WriteOnly);
+    TQDataStream stream(params,IO_WriteOnly);
     stream << realm;
     stream << username;
 
-    if (!par->dcopClient()->call("kded","kdesvnd","get_login(QString,QString)",params,replyType,reply)) {
+    if (!par->dcopClient()->call("kded","kdesvnd","get_login(TQString,TQString)",params,replyType,reply)) {
         kdWarning()<<"Communication with dcop failed"<<endl;
         return false;
     }
-    if (replyType!="QStringList") {
+    if (replyType!=TQSTRINGLIST_OBJECT_NAME_STRING) {
         kdWarning()<<"Wrong reply type"<<endl;
         return false;
     }
-    QDataStream stream2(reply,IO_ReadOnly);
-    QStringList lt;
+    TQDataStream stream2(reply,IO_ReadOnly);
+    TQStringList lt;
     stream2>>lt;
     if (lt.count()!=3) {
         kdDebug()<<"Wrong or missing auth list (may cancel pressed)." << endl;
diff --git a/src/kiosvn/kiolistener.h b/src/kiosvn/kiolistener.h
index 96a1629..fea9cc2 100644
--- a/src/kiosvn/kiolistener.h
+++ b/src/kiosvn/kiolistener.h
@@ -37,12 +37,12 @@ public:
     virtual ~KioListener();
 
     /* context-listener methods */
-    virtual bool contextGetLogin (const QString & realm,
-                     QString & username,
-                     QString & password,
+    virtual bool contextGetLogin (const TQString & realm,
+                     TQString & username,
+                     TQString & password,
                      bool & maySave);
-    virtual bool contextGetSavedLogin (const QString & realm,QString & username,QString & password);
-    virtual bool contextGetCachedLogin (const QString & realm,QString & username,QString & password);
+    virtual bool contextGetSavedLogin (const TQString & realm,TQString & username,TQString & password);
+    virtual bool contextGetCachedLogin (const TQString & realm,TQString & username,TQString & password);
 
     virtual void contextNotify (const char *path,
                    svn_wc_notify_action_t action,
@@ -54,13 +54,13 @@ public:
     virtual void contextNotify (const svn_wc_notify_t *action);
 
     virtual bool contextCancel();
-    virtual bool contextGetLogMessage (QString & msg,const svn::CommitItemList&);
+    virtual bool contextGetLogMessage (TQString & msg,const svn::CommitItemList&);
     virtual SslServerTrustAnswer contextSslServerTrustPrompt (const SslServerTrustData & data,
                                  apr_uint32_t & acceptedFailures);
-    virtual bool contextSslClientCertPrompt (QString & certFile);
-    virtual bool contextSslClientCertPwPrompt (QString & password,
-                                   const QString & realm, bool & maySave);
-    virtual bool contextLoadSslClientCertPw(QString&password,const QString&realm);
+    virtual bool contextSslClientCertPrompt (TQString & certFile);
+    virtual bool contextSslClientCertPwPrompt (TQString & password,
+                                   const TQString & realm, bool & maySave);
+    virtual bool contextLoadSslClientCertPw(TQString&password,const TQString&realm);
     /* context listener virtuals end */
     unsigned int counter()const{return m_notifyCounter;}
     void incCounter(){++m_notifyCounter;}
diff --git a/src/kiosvn/kiosvn.cpp b/src/kiosvn/kiosvn.cpp
index 667d456..b71a1d8 100644
--- a/src/kiosvn/kiosvn.cpp
+++ b/src/kiosvn/kiosvn.cpp
@@ -50,10 +50,10 @@
 #include <ktempdir.h>
 #include <ksock.h>
 #include <dcopclient.h>
-#include <qcstring.h>
+#include <tqcstring.h>
 #include <kmimetype.h>
 #include <krun.h>
-#include <qtextstream.h>
+#include <tqtextstream.h>
 
 #include <stdlib.h>
 #include <math.h>
@@ -118,27 +118,27 @@ KioSvnData::~KioSvnData()
 
 svn::Revision KioSvnData::urlToRev(const KURL&url)
 {
-    QMap<QString,QString> q = url.queryItems();
+    TQMap<TQString,TQString> q = url.queryItems();
 
     /* we try to check if it is ssh and try to get a password for it */
-    QString proto = url.protocol();
+    TQString proto = url.protocol();
 
-    if (proto.find("ssh")!=-1) {
+    if (proto.tqfind("ssh")!=-1) {
         SshAgent ag;
         ag.addSshIdentities();
     }
 
     svn::Revision rev,tmp;
     rev = svn::Revision::UNDEFINED;
-    if (q.find("rev")!=q.end()) {
-        QString v = q["rev"];
+    if (q.tqfind("rev")!=q.end()) {
+        TQString v = q["rev"];
         m_Svnclient->url2Revision(v,rev,tmp);
     }
     return rev;
 }
 
 
-kio_svnProtocol::kio_svnProtocol(const QCString &pool_socket, const QCString &app_socket)
+kio_svnProtocol::kio_svnProtocol(const TQCString &pool_socket, const TQCString &app_socket)
     : SlaveBase("kio_ksvn", pool_socket, app_socket),StreamWrittenCb()
 {
     m_pData=new KioSvnData(this);
@@ -163,8 +163,8 @@ int kdemain(int argc, char **argv)
     kdDebug()<<"kdemain" << endl;
     KInstance instance( "kio_ksvn" );
    // start the kdesvnd DCOP service
-    QString error;
-    QCString appId;
+    TQString error;
+    TQCString appId;
 
     kdDebug(7101) << "*** Starting kio_ksvn " << endl;
 
@@ -197,7 +197,7 @@ void kio_svnProtocol::listDir(const KURL&url)
     try {
         dlist = m_pData->m_Svnclient->list(makeSvnUrl(url),rev,rev,svn::DepthImmediates,false);
     } catch (const svn::ClientException&e) {
-        QString ex = e.msg();
+        TQString ex = e.msg();
         kdDebug()<<ex<<endl;
         error(KIO::ERR_CANNOT_ENTER_DIRECTORY,ex);
         return;
@@ -208,7 +208,7 @@ void kio_svnProtocol::listDir(const KURL&url)
         if (!dlist[i] || dlist[i]->name().isEmpty()) {
             continue;
         }
-        QDateTime dt = svn::DateTime(dlist[i]->time());
+        TQDateTime dt = svn::DateTime(dlist[i]->time());
         if (createUDSEntry(dlist[i]->name(),
             dlist[i]->lastAuthor(),
             dlist[i]->size(),
@@ -236,7 +236,7 @@ void kio_svnProtocol::stat(const KURL& url)
     try {
          e = m_pData->m_Svnclient->info(makeSvnUrl(url),svn::DepthEmpty,rev,peg);
     } catch  (const svn::ClientException&e) {
-        QString ex = e.msg();
+        TQString ex = e.msg();
         kdDebug()<<ex<<endl;
         error( KIO::ERR_SLAVE_DEFINED,ex);
         return;
@@ -249,7 +249,7 @@ void kio_svnProtocol::stat(const KURL& url)
     }
 
     KIO::UDSEntry entry;
-    QDateTime dt;
+    TQDateTime dt;
     if (dummy) {
         createUDSEntry(url.filename(),"",0,true,dt.toTime_t(),entry);
     } else {
@@ -279,14 +279,14 @@ void kio_svnProtocol::get(const KURL& url)
     try {
         m_pData->m_Svnclient->cat(dstream,makeSvnUrl(url),rev,rev);
     } catch (const svn::ClientException&e) {
-        QString ex = e.msg();
+        TQString ex = e.msg();
         kdDebug()<<ex<<endl;
         error( KIO::ERR_SLAVE_DEFINED,"Subversion error "+ex);
         finished();
         return;
     }
     totalSize(dstream.written());
-    data(QByteArray()); // empty array means we're done sending the data
+    data(TQByteArray()); // empty array means we're done sending the data
     finished();
 }
 
@@ -310,7 +310,7 @@ void kio_svnProtocol::mkdir(const KURL &url, int)
 void kio_svnProtocol::mkdir(const KURL::List &urls, int)
 {
     svn::Pathes p;
-    for ( QValueListConstIterator<KURL> it = urls.begin(); it != urls.end() ; ++it ) {
+    for ( TQValueListConstIterator<KURL> it = urls.begin(); it != urls.end() ; ++it ) {
         p.append((*it).path());
     }
     try {
@@ -325,7 +325,7 @@ void kio_svnProtocol::mkdir(const KURL::List &urls, int)
 void kio_svnProtocol::rename(const KURL&src,const KURL&target,bool force)
 {
     kdDebug()<<"kio_svn::rename "<< src << " to " << target <<  endl;
-    QString msg;
+    TQString msg;
     m_pData->m_CurrentContext->setLogMessage(getDefaultLog());
     try {
         m_pData->m_Svnclient->move(makeSvnUrl(src),makeSvnUrl(target),force);
@@ -371,7 +371,7 @@ void kio_svnProtocol::del(const KURL&src,bool isfile)
         svn::Targets target(makeSvnUrl(src));
         m_pData->m_Svnclient->remove(target,false);
     } catch (const svn::ClientException&e) {
-        QString ex = e.msg();
+        TQString ex = e.msg();
         kdDebug()<<ex<<endl;
         error( KIO::ERR_SLAVE_DEFINED,ex);
     }
@@ -379,7 +379,7 @@ void kio_svnProtocol::del(const KURL&src,bool isfile)
     finished();
 }
 
-bool kio_svnProtocol::getLogMsg(QString&t)
+bool kio_svnProtocol::getLogMsg(TQString&t)
 {
     svn::CommitItemList _items;
     return m_pData->m_Listener.contextGetLogMessage(t,_items);
@@ -403,10 +403,10 @@ bool kio_svnProtocol::checkWc(const KURL&url)
     return false;
 }
 
-QString kio_svnProtocol::makeSvnUrl(const KURL&url,bool check_Wc)
+TQString kio_svnProtocol::makeSvnUrl(const KURL&url,bool check_Wc)
 {
-    QString res;
-    QString proto = svn::Url::transformProtokoll(url.protocol());
+    TQString res;
+    TQString proto = svn::Url::transformProtokoll(url.protocol());
     if (proto=="file" && check_Wc)
     {
         if (checkWc(url))
@@ -415,22 +415,22 @@ QString kio_svnProtocol::makeSvnUrl(const KURL&url,bool check_Wc)
         }
     }
 
-    QStringList s = QStringList::split("://",res);
-    QString base = url.path();
-    QString host = url.host();
-    QString user = (url.hasUser()?url.user()+(url.hasPass()?":"+url.pass():""):"");
+    TQStringList s = TQStringList::split("://",res);
+    TQString base = url.path();
+    TQString host = url.host();
+    TQString user = (url.hasUser()?url.user()+(url.hasPass()?":"+url.pass():""):"");
     if (host.isEmpty()) {
         res=proto+"://"+base;
     } else {
         res = proto+"://"+(user.isEmpty()?"":user+"@")+host+base;
     }
     if (base.isEmpty()) {
-        throw svn::ClientException(QString("'")+res+QString("' is not a valid subversion url"));
+        throw svn::ClientException(TQString("'")+res+TQString("' is not a valid subversion url"));
     }
     return res;
 }
 
-bool kio_svnProtocol::createUDSEntry( const QString& filename, const QString& user, long long int size, bool isdir, time_t mtime, KIO::UDSEntry& entry)
+bool kio_svnProtocol::createUDSEntry( const TQString& filename, const TQString& user, long long int size, bool isdir, time_t mtime, KIO::UDSEntry& entry)
 {
 #if 0
         kdDebug() << "MTime : " << ( long )mtime << endl;
@@ -467,10 +467,10 @@ bool kio_svnProtocol::createUDSEntry( const QString& filename, const QString& us
         return true;
 }
 
-void kio_svnProtocol::special(const QByteArray& data)
+void kio_svnProtocol::special(const TQByteArray& data)
 {
     kdDebug()<<"kio_svnProtocol::special"<<endl;
-    QDataStream stream(data,IO_ReadOnly);
+    TQDataStream stream(data,IO_ReadOnly);
     int tmp;
     stream >> tmp;
     kdDebug() << "kio_svnProtocol::special " << tmp << endl;
@@ -479,7 +479,7 @@ void kio_svnProtocol::special(const QByteArray& data)
         {
             KURL repository, wc;
             int revnumber;
-            QString revkind;
+            TQString revkind;
             stream >> repository;
             stream >> wc;
             stream >> revnumber;
@@ -492,7 +492,7 @@ void kio_svnProtocol::special(const QByteArray& data)
         {
             KURL wc;
             int revnumber;
-            QString revkind;
+            TQString revkind;
             stream >> wc;
             stream >> revnumber;
             stream >> revkind;
@@ -516,7 +516,7 @@ void kio_svnProtocol::special(const QByteArray& data)
         {
             kdDebug(0) << "kio_svnProtocol LOG" << endl;
             int revstart, revend;
-            QString revkindstart, revkindend;
+            TQString revkindstart, revkindend;
             KURL::List targets;
             stream >> revstart;
             stream >> revkindstart;
@@ -605,7 +605,7 @@ void kio_svnProtocol::special(const QByteArray& data)
             KURL wc,url;
             bool recurse;
             int revnumber;
-            QString revkind;
+            TQString revkind;
             stream >> wc;
             stream >> url;
             stream >> recurse;
@@ -620,7 +620,7 @@ void kio_svnProtocol::special(const QByteArray& data)
             KURL url1,url2;
             int rev1, rev2;
             bool recurse;
-            QString revkind1, revkind2;
+            TQString revkind1, revkind2;
             stream >> url1;
             stream >> url2;
             stream >> rev1;
@@ -637,7 +637,7 @@ void kio_svnProtocol::special(const QByteArray& data)
     finished();
 }
 
-void kio_svnProtocol::update(const KURL&url,int revnumber,const QString&revkind)
+void kio_svnProtocol::update(const KURL&url,int revnumber,const TQString&revkind)
 {
     svn::Revision where(revnumber,revkind);
     /* update is always local - so make a path instead URI */
@@ -664,22 +664,22 @@ void kio_svnProtocol::status(const KURL&wc,bool cR,bool rec)
         error(KIO::ERR_SLAVE_DEFINED,e.msg());
         return;
     }
-    kdDebug()<<"Status got " << dlist.count() << " entries." << endl;
+    kdDebug()<<"tqStatus got " << dlist.count() << " entries." << endl;
     for (unsigned j=0;j<dlist.count();++j) {
         if (!dlist[j]) {
             continue;
         }
-        //QDataStream stream(params, IO_WriteOnly);
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+"path",dlist[j]->path());
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+"text",QString::number(dlist[j]->textStatus()));
-        setMetaData(QString::number(m_pData->m_Listener.counter() ).rightJustify( 10,'0' )+ "prop",
-                    QString::number(dlist[j]->propStatus()));
-        setMetaData(QString::number(m_pData->m_Listener.counter() ).rightJustify( 10,'0' )+ "reptxt",
-                    QString::number(dlist[j]->reposTextStatus()));
-        setMetaData(QString::number(m_pData->m_Listener.counter() ).rightJustify( 10,'0' )+ "repprop",
-                    QString::number(dlist[j]->reposPropStatus()));
-        setMetaData(QString::number(m_pData->m_Listener.counter() ).rightJustify( 10,'0' )+ "rev",
-                    QString::number(dlist[j]->entry().cmtRev()));
+        //TQDataStream stream(params, IO_WriteOnly);
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+"path",dlist[j]->path());
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+"text",TQString::number(dlist[j]->texttqStatus()));
+        setMetaData(TQString::number(m_pData->m_Listener.counter() ).rightJustify( 10,'0' )+ "prop",
+                    TQString::number(dlist[j]->proptqStatus()));
+        setMetaData(TQString::number(m_pData->m_Listener.counter() ).rightJustify( 10,'0' )+ "reptxt",
+                    TQString::number(dlist[j]->reposTexttqStatus()));
+        setMetaData(TQString::number(m_pData->m_Listener.counter() ).rightJustify( 10,'0' )+ "repprop",
+                    TQString::number(dlist[j]->reposProptqStatus()));
+        setMetaData(TQString::number(m_pData->m_Listener.counter() ).rightJustify( 10,'0' )+ "rev",
+                    TQString::number(dlist[j]->entry().cmtRev()));
         m_pData->m_Listener.incCounter();
     }
 }
@@ -687,23 +687,23 @@ void kio_svnProtocol::status(const KURL&wc,bool cR,bool rec)
 void kio_svnProtocol::commit(const KURL::List&url)
 {
     /// @todo replace with direct call to kdesvn?
-    QByteArray reply;
-    QByteArray params;
-    QCString replyType;
-    QString msg;
+    TQByteArray reply;
+    TQByteArray params;
+    TQCString replyType;
+    TQString msg;
 
     if (!dcopClient()->call("kded","kdesvnd","get_logmsg()",params,replyType,reply)) {
         msg = "Communication with dcop failed";
         kdWarning()<<msg<<endl;
         return;
     }
-    if (replyType!="QStringList") {
+    if (replyType!=TQSTRINGLIST_OBJECT_NAME_STRING) {
         msg = "Wrong reply type";
         kdWarning()<<msg<<endl;
         return;
     }
-    QDataStream stream2(reply,IO_ReadOnly);
-    QStringList lt;
+    TQDataStream stream2(reply,IO_ReadOnly);
+    TQStringList lt;
     stream2>>lt;
     if (lt.count()!=1) {
         msg = "Wrong or missing log (may cancel pressed).";
@@ -711,7 +711,7 @@ void kio_svnProtocol::commit(const KURL::List&url)
         return;
     }
     msg = lt[0];
-    QValueList<svn::Path> targets;
+    TQValueList<svn::Path> targets;
     for (unsigned j=0; j<url.count();++j) {
         targets.push_back(svn::Path(url[j].path()));
     }
@@ -722,25 +722,25 @@ void kio_svnProtocol::commit(const KURL::List&url)
         error(KIO::ERR_SLAVE_DEFINED,e.msg());
     }
     for (unsigned j=0;j<url.count();++j) {
-        QString userstring;
+        TQString userstring;
         if (nnum!=svn::Revision::UNDEFINED) {
-            userstring = i18n( "Committed revision %1." ).arg(nnum.toString());
+            userstring = i18n( "Committed revision %1." ).tqarg(nnum.toString());
         } else {
             userstring = i18n ( "Nothing to commit." );
         }
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "path", url[j].path() );
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "action", "0" );
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "kind", "0" );
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "mime_t", "" );
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "content", "0" );
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "prop", "0" );
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "rev" , QString::number(nnum) );
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "string", userstring );
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "path", url[j].path() );
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "action", "0" );
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "kind", "0" );
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "mime_t", "" );
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "content", "0" );
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "prop", "0" );
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "rev" , TQString::number(nnum) );
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "string", userstring );
         m_pData->m_Listener.incCounter();
     }
 }
 
-void kio_svnProtocol::checkout(const KURL&src,const KURL&target,const int rev, const QString&revstring)
+void kio_svnProtocol::checkout(const KURL&src,const KURL&target,const int rev, const TQString&revstring)
 {
     svn::Revision where(rev,revstring);
     svn::Revision peg = svn::Revision::UNDEFINED;
@@ -753,7 +753,7 @@ void kio_svnProtocol::checkout(const KURL&src,const KURL&target,const int rev, c
     }
 }
 
-void kio_svnProtocol::svnlog(int revstart,const QString&revstringstart,int revend, const QString&revstringend, const KURL::List&urls)
+void kio_svnProtocol::svnlog(int revstart,const TQString&revstringstart,int revend, const TQString&revstringend, const KURL::List&urls)
 {
     svn::Revision start(revstart,revstringstart);
     svn::Revision end(revend,revstringend);
@@ -768,33 +768,33 @@ void kio_svnProtocol::svnlog(int revstart,const QString&revstringstart,int reven
             break;
         }
         if (!logs) {
-            setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify(10,'0')+"path",urls[j].path());
-            setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify(10,'0')+"string",
+            setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify(10,'0')+"path",urls[j].path());
+            setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify(10,'0')+"string",
                 i18n("Empty logs"));
             m_pData->m_Listener.incCounter();
             continue;
         }
         for (unsigned int i = 0; i < logs->count();++i) {
-            setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "path",urls[j].path());
-            setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "rev",
-                QString::number( (*logs)[i].revision));
-            setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+"author",
+            setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "path",urls[j].path());
+            setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "rev",
+                TQString::number( (*logs)[i].revision));
+            setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+"author",
                 (*logs)[i].author);
-            setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+"logmessage",
+            setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+"logmessage",
                 (*logs)[i].message);
             m_pData->m_Listener.incCounter();
             for (unsigned z = 0; z<(*logs)[i].changedPaths.count();++z) {
-                setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "rev",
-                    QString::number( (*logs)[i].revision));
-                setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "path",urls[j].path());
-                setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "loggedpath",
+                setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "rev",
+                    TQString::number( (*logs)[i].revision));
+                setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "path",urls[j].path());
+                setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "loggedpath",
                     (*logs)[i].changedPaths[z].path);
-                setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "loggedaction",
-                    QChar((*logs)[i].changedPaths[z].action));
-                setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "loggedcopyfrompath",
+                setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "loggedaction",
+                    TQChar((*logs)[i].changedPaths[z].action));
+                setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "loggedcopyfrompath",
                     (*logs)[i].changedPaths[z].copyFromPath);
-                setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "loggedcopyfromrevision",
-                    QString::number((*logs)[i].changedPaths[z].copyFromRevision));
+                setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "loggedcopyfromrevision",
+                    TQString::number((*logs)[i].changedPaths[z].copyFromRevision));
                 m_pData->m_Listener.incCounter();
             }
         }
@@ -803,7 +803,7 @@ void kio_svnProtocol::svnlog(int revstart,const QString&revstringstart,int reven
 
 void kio_svnProtocol::revert(const KURL::List&l)
 {
-    QValueList<svn::Path> list;
+    TQValueList<svn::Path> list;
     for (unsigned j=0; j<l.count();++j) {
         list.append(svn::Path(l[j].path()));
     }
@@ -815,7 +815,7 @@ void kio_svnProtocol::revert(const KURL::List&l)
     }
 }
 
-void kio_svnProtocol::wc_switch(const KURL&wc,const KURL&target,bool rec,int rev,const QString&revstring)
+void kio_svnProtocol::wc_switch(const KURL&wc,const KURL&target,bool rec,int rev,const TQString&revstring)
 {
     svn::Revision where(rev,revstring);
     svn::Path wc_path(wc.path());
@@ -826,15 +826,15 @@ void kio_svnProtocol::wc_switch(const KURL&wc,const KURL&target,bool rec,int rev
     }
 }
 
-void kio_svnProtocol::diff(const KURL&uri1,const KURL&uri2,int rnum1,const QString&rstring1,int rnum2, const QString&rstring2,bool rec)
+void kio_svnProtocol::diff(const KURL&uri1,const KURL&uri2,int rnum1,const TQString&rstring1,int rnum2, const TQString&rstring2,bool rec)
 {
-    QByteArray ex;
+    TQByteArray ex;
     /// @todo read settings for diff (ignore contentype)
     try {
         svn::Revision r1(rnum1,rstring1);
         svn::Revision r2(rnum2,rstring2);
-        QString u1 = makeSvnUrl(uri1,true);
-        QString u2 = makeSvnUrl(uri2,true);
+        TQString u1 = makeSvnUrl(uri1,true);
+        TQString u2 = makeSvnUrl(uri2,true);
         KTempDir tdir;
         kdDebug() << "kio_ksvn::diff : " << u1 << " at revision " << r1.toString() << " with "
             << u2 << " at revision " << r2.toString()
@@ -847,10 +847,10 @@ void kio_svnProtocol::diff(const KURL&uri1,const KURL&uri2,int rnum1,const QStri
         error(KIO::ERR_SLAVE_DEFINED,e.msg());
         return;
     }
-    QString out = QString::FROMUTF8(ex);
-    QTextIStream stream(&out);
+    TQString out = TQString::FROMUTF8(ex);
+    TQTextIStream stream(&out);
     while (!stream.atEnd()) {
-        setMetaData(QString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "diffresult",stream.readLine());
+        setMetaData(TQString::number(m_pData->m_Listener.counter()).rightJustify( 10,'0' )+ "diffresult",stream.readLine());
         m_pData->m_Listener.incCounter();
     }
 }
@@ -858,9 +858,9 @@ void kio_svnProtocol::diff(const KURL&uri1,const KURL&uri2,int rnum1,const QStri
 void kio_svnProtocol::import(const KURL& repos, const KURL& wc)
 {
     try {
-        QString target = makeSvnUrl(repos);
-        QString path = wc.path();
-        m_pData->m_Svnclient->import(svn::Path(path),target,QString::null,svn::DepthInfinity,false,false);
+        TQString target = makeSvnUrl(repos);
+        TQString path = wc.path();
+        m_pData->m_Svnclient->import(svn::Path(path),target,TQString(),svn::DepthInfinity,false,false);
     } catch (const svn::ClientException&e) {
         error(KIO::ERR_SLAVE_DEFINED,e.msg());
         return;
@@ -870,7 +870,7 @@ void kio_svnProtocol::import(const KURL& repos, const KURL& wc)
 
 void kio_svnProtocol::add(const KURL& wc)
 {
-    QString path = wc.path();
+    TQString path = wc.path();
     try {
                                                /* rec */
         m_pData->m_Svnclient->add(svn::Path(path),svn::DepthInfinity);
@@ -884,7 +884,7 @@ void kio_svnProtocol::add(const KURL& wc)
 void kio_svnProtocol::wc_delete(const KURL::List&l)
 {
     svn::Pathes p;
-    for ( QValueListConstIterator<KURL> it = l.begin(); it != l.end() ; ++it ) {
+    for ( TQValueListConstIterator<KURL> it = l.begin(); it != l.end() ; ++it ) {
         p.append((*it).path());
     }
     try {
@@ -920,7 +920,7 @@ void kio_svnProtocol::streamSendMime(KMimeMagicResult* mt)
     }
 }
 
-void kio_svnProtocol::streamPushData(QByteArray array)
+void kio_svnProtocol::streamPushData(TQByteArray array)
 {
     data(array);
 }
@@ -941,9 +941,9 @@ void kio_svnProtocol::streamTotalSizeNull()
 /*!
     \fn kio_svnProtocol::getDefaultLog()
  */
-QString kio_svnProtocol::getDefaultLog()
+TQString kio_svnProtocol::getDefaultLog()
 {
-    QString res = QString::null;
+    TQString res = TQString();
     Kdesvnsettings::self()->readConfig();
     if (Kdesvnsettings::kio_use_standard_logmsg()) {
         res = Kdesvnsettings::kio_standard_logmsg();
diff --git a/src/kiosvn/kiosvn.h b/src/kiosvn/kiosvn.h
index a3383e1..a77094e 100644
--- a/src/kiosvn/kiosvn.h
+++ b/src/kiosvn/kiosvn.h
@@ -22,8 +22,8 @@
 
 #include "kiobytestream.h"
 
-#include <qstring.h>
-#include <qcstring.h>
+#include <tqstring.h>
+#include <tqcstring.h>
 #include <kurl.h>
 
 #include <kio/global.h>
@@ -31,7 +31,7 @@
 
 
 #include <sys/stat.h>
-#include <qvaluelist.h>
+#include <tqvaluelist.h>
 
 namespace KIO
 {
@@ -44,7 +44,7 @@ class KioSvnData;
 class kio_svnProtocol : public KIO::SlaveBase,public StreamWrittenCb
 {
 public:
-    kio_svnProtocol(const QCString &pool_socket, const QCString &app_socket);
+    kio_svnProtocol(const TQCString &pool_socket, const TQCString &app_socket);
     virtual ~kio_svnProtocol();
     virtual void listDir (const KURL&url);
     virtual void stat(const KURL& url);
@@ -54,26 +54,26 @@ public:
     virtual void rename(const KURL&src,const KURL&target,bool force);
     virtual void del(const KURL&url,bool isfile);
     virtual void copy(const KURL&src,const KURL&dest,int permissions,bool overwrite);
-    virtual void checkout(const KURL&src,const KURL&target,const int rev, const QString&revstring);
-    virtual void svnlog(int,const QString&,int, const QString&, const KURL::List&);
+    virtual void checkout(const KURL&src,const KURL&target,const int rev, const TQString&revstring);
+    virtual void svnlog(int,const TQString&,int, const TQString&, const KURL::List&);
     virtual void revert(const KURL::List&);
-    virtual void wc_switch(const KURL&,const KURL&,bool,int,const QString&);
-    virtual void diff(const KURL&,const KURL&,int,const QString&,int, const QString&,bool);
+    virtual void wc_switch(const KURL&,const KURL&,bool,int,const TQString&);
+    virtual void diff(const KURL&,const KURL&,int,const TQString&,int, const TQString&,bool);
     virtual void import( const KURL& repos, const KURL& wc);
     virtual void add(const KURL& wc);
     virtual void wc_delete(const KURL::List&);
-    virtual void special(const QByteArray& data);
+    virtual void special(const TQByteArray& data);
     virtual void wc_resolve(const KURL&,bool);
     /* looked on kio::svn from kdesdk */
     enum KSVN_METHOD {
-        /* KURL repository, KURL target, int revnumber, QString revkind */
+        /* KURL repository, KURL target, int revnumber, TQString revkind */
         SVN_CHECKOUT = 1,
-        /* KURL wc, int revnumber, QString revkind */
+        /* KURL wc, int revnumber, TQString revkind */
         /* refkind may empty or HEAD or START, will get parsed if revnumber is -1 */
         SVN_UPDATE = 2,
         /* KURL::List */
         SVN_COMMIT = 3,
-        /* int revstart, QString revstartstring, int revend, QString revendstring, KURL::List */
+        /* int revstart, TQString revstartstring, int revend, TQString revendstring, KURL::List */
         SVN_LOG=4,
         SVN_IMPORT=5,
         /* KURL */
@@ -88,31 +88,31 @@ public:
         SVN_MKDIR=10,
         /* KURL, bool */
         SVN_RESOLVE=11,
-        /* KURL working copy, KURL new_repository_url, bool recurse, int rev, QString revstring */
+        /* KURL working copy, KURL new_repository_url, bool recurse, int rev, TQString revstring */
         SVN_SWITCH=12,
-        /* KURL uri1, KURL uri2, int r1, QString rstring1, int r2, QString rstring 2, bool recursive */
+        /* KURL uri1, KURL uri2, int r1, TQString rstring1, int r2, TQString rstring 2, bool recursive */
         SVN_DIFF=13
     };
 
     void contextProgress(long long int current, long long int max);
     virtual void streamWritten(const KIO::filesize_t current);
-    virtual void streamPushData(QByteArray);
+    virtual void streamPushData(TQByteArray);
     virtual void streamSendMime(KMimeMagicResult*mt);
     virtual void streamTotalSizeNull();
 
 protected:
     virtual void commit(const KURL::List&);
     virtual void status(const KURL&,bool,bool);
-    virtual void update(const KURL&,int,const QString&);
+    virtual void update(const KURL&,int,const TQString&);
 
 private:
     KioSvnData*m_pData;
-    bool createUDSEntry( const QString& filename, const QString& user, long long int size, bool isdir, time_t mtime, KIO::UDSEntry& entry);
-    QString makeSvnUrl(const KURL&url,bool check_wc=true);
+    bool createUDSEntry( const TQString& filename, const TQString& user, long long int size, bool isdir, time_t mtime, KIO::UDSEntry& entry);
+    TQString makeSvnUrl(const KURL&url,bool check_wc=true);
     bool checkWc(const KURL&url);
-    bool getLogMsg(QString&);
+    bool getLogMsg(TQString&);
 protected:
-    QString getDefaultLog();
+    TQString getDefaultLog();
 };
 
 }