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

1 files changed, 382 insertions, 382 deletions

diff --git a/src/svnfrontend/svnactions.cpp b/src/svnfrontend/svnactions.cpp
index 082666f..390f480 100644
--- a/src/svnfrontend/svnactions.cpp
+++ b/src/svnfrontend/svnactions.cpp
@@ -75,22 +75,22 @@
 #include <krun.h>
 #include <kstdguiitem.h>
 
-#include <qstring.h>
-#include <qmap.h>
-#include <qpushbutton.h>
-#include <qlayout.h>
-#include <qvaluelist.h>
-#include <qvbox.h>
-#include <qstylesheet.h>
-#include <qregexp.h>
-#include <qimage.h>
-#include <qthread.h>
-#include <qtimer.h>
-#include <qlistview.h>
-#include <qfileinfo.h>
+#include <tqstring.h>
+#include <tqmap.h>
+#include <tqpushbutton.h>
+#include <tqlayout.h>
+#include <tqvaluelist.h>
+#include <tqvbox.h>
+#include <tqstylesheet.h>
+#include <tqregexp.h>
+#include <tqimage.h>
+#include <tqthread.h>
+#include <tqtimer.h>
+#include <tqlistview.h>
+#include <tqfileinfo.h>
 #include <sys/time.h>
 #include <unistd.h>
-#include <qguardedptr.h>
+#include <tqguardedptr.h>
 
 // wait not longer than 10 seconds for a thread
 #define MAX_THREAD_WAITTIME 10000
@@ -116,15 +116,15 @@ public:
             delete m_LogDialog;
         }
 
-        QMap<KProcess*,QStringList>::iterator it;
+        TQMap<KProcess*,TQStringList>::iterator it;
         for (it=m_tempfilelist.begin();it!=m_tempfilelist.end();++it) {
-            for (QStringList::iterator it2 = (*it).begin();
+            for (TQStringList::iterator it2 = (*it).begin();
                 it2 != (*it).end();++it2) {
                 ::unlink((*it2).ascii());
             }
         }
         for (it=m_tempdirlist.begin();it!=m_tempdirlist.end();++it) {
-            for (QStringList::iterator it2 = (*it).begin();
+            for (TQStringList::iterator it2 = (*it).begin();
                 it2 != (*it).end();++it2) {
                 KIO::NetAccess::del((*it2),0);
             }
@@ -136,9 +136,9 @@ public:
     bool isExternalDiff()
     {
         if (Kdesvnsettings::use_external_diff()) {
-            QString edisp = Kdesvnsettings::external_diff_display();
-            QStringList wlist = QStringList::split(" ",edisp);
-            if (wlist.count()>=3 && edisp.find("%1")!=-1 && edisp.find("%2")!=-1) {
+            TQString edisp = Kdesvnsettings::external_diff_display();
+            TQStringList wlist = TQStringList::split(" ",edisp);
+            if (wlist.count()>=3 && edisp.tqfind("%1")!=-1 && edisp.tqfind("%2")!=-1) {
                 return true;
             }
         }
@@ -180,17 +180,17 @@ public:
     /// \todo as persistent cache (sqlite?)
     helpers::itemCache<svn::InfoEntry> m_InfoCache;
 
-    QMap<KProcess*,QStringList> m_tempfilelist;
-    QMap<KProcess*,QStringList> m_tempdirlist;
+    TQMap<KProcess*,TQStringList> m_tempfilelist;
+    TQMap<KProcess*,TQStringList> m_tempdirlist;
 
-    QTimer m_ThreadCheckTimer;
-    QTimer m_UpdateCheckTimer;
-    QTime m_UpdateCheckTick;
-    QGuardedPtr<DiffBrowser> m_DiffBrowserPtr;
-    QGuardedPtr<KDialogBase> m_DiffDialog;
-    QGuardedPtr<SvnLogDlgImp> m_LogDialog;
+    TQTimer m_ThreadCheckTimer;
+    TQTimer m_UpdateCheckTimer;
+    TQTime m_UpdateCheckTick;
+    TQGuardedPtr<DiffBrowser> m_DiffBrowserPtr;
+    TQGuardedPtr<KDialogBase> m_DiffDialog;
+    TQGuardedPtr<SvnLogDlgImp> m_LogDialog;
 
-    QMap<QString,QString> m_contextData;
+    TQMap<TQString,TQString> m_contextData;
 
     bool runblocked;
 };
@@ -199,19 +199,19 @@ public:
 #define EMIT_REFRESH emit sigRefreshAll()
 #define DIALOGS_SIZES "display_dialogs_sizes"
 
-SvnActions::SvnActions(ItemDisplay *parent, const char *name,bool processes_blocked)
-    : QObject(parent?parent->realWidget():0, name),SimpleLogCb()
+SvnActions::SvnActions(ItemDisplay *tqparent, const char *name,bool processes_blocked)
+    : TQObject(tqparent?tqparent->realWidget():0, name),SimpleLogCb()
 {
     m_CThread = 0;
     m_UThread = 0;
     m_FCThread = 0;
     m_Data = new SvnActionsData();
-    m_Data->m_ParentList = parent;
+    m_Data->m_ParentList = tqparent;
     m_Data->m_SvnContextListener = new CContextListener(this);
     m_Data->runblocked = processes_blocked;
-    connect(m_Data->m_SvnContextListener,SIGNAL(sendNotify(const QString&)),this,SLOT(slotNotifyMessage(const QString&)));
-    connect(&(m_Data->m_ThreadCheckTimer),SIGNAL(timeout()),this,SLOT(checkModthread()));
-    connect(&(m_Data->m_UpdateCheckTimer),SIGNAL(timeout()),this,SLOT(checkUpdateThread()));
+    connect(m_Data->m_SvnContextListener,TQT_SIGNAL(sendNotify(const TQString&)),this,TQT_SLOT(slotNotifyMessage(const TQString&)));
+    connect(&(m_Data->m_ThreadCheckTimer),TQT_SIGNAL(timeout()),this,TQT_SLOT(checkModthread()));
+    connect(&(m_Data->m_UpdateCheckTimer),TQT_SIGNAL(timeout()),this,TQT_SLOT(checkUpdateThread()));
 }
 
 svn::Client* SvnActions::svnclient()
@@ -224,7 +224,7 @@ SvnActions::~SvnActions()
     killallThreads();
 }
 
-void SvnActions::slotNotifyMessage(const QString&aMsg)
+void SvnActions::slotNotifyMessage(const TQString&aMsg)
 {
     emit sendNotify(aMsg);
 }
@@ -239,7 +239,7 @@ void SvnActions::reInitClient()
     m_Data->m_Svnclient->setContext(m_Data->m_CurrentContext);
 }
 
-template<class T> KDialogBase* SvnActions::createDialog(T**ptr,const QString&_head,bool OkCancel,const char*name,bool showHelp,bool modal,const KGuiItem&u1)
+template<class T> KDialogBase* SvnActions::createDialog(T**ptr,const TQString&_head,bool OkCancel,const char*name,bool showHelp,bool modal,const KGuiItem&u1)
 {
     int buttons = KDialogBase::Ok;
     if (OkCancel) {
@@ -252,18 +252,18 @@ template<class T> KDialogBase* SvnActions::createDialog(T**ptr,const QString&_he
         buttons = buttons|KDialogBase::User1;
     }
     KDialogBase * dlg = new KDialogBase(
-        modal?KApplication::activeModalWidget():0, // parent
+        modal?TQT_TQWIDGET(TQT_TQWIDGET(KApplication::activeModalWidget())):0, // tqparent
         name, // name
         modal, // modal
         _head, // caption
-        buttons, // buttonmask
+        buttons, // buttontqmask
         KDialogBase::Ok, // defaultButton
         false , // separator
         (u1.text().isEmpty()?KGuiItem():u1) //user1
                                        );
 
     if (!dlg) return dlg;
-    QWidget* Dialog1Layout = dlg->makeVBoxMainWidget();
+    TQWidget* Dialog1Layout = dlg->makeVBoxMainWidget();
     *ptr = new T(Dialog1Layout);
     dlg->resize(dlg->configDialogSize(*(Kdesvnsettings::self()->config()),name?name:DIALOGS_SIZES));
     return dlg;
@@ -279,8 +279,8 @@ void SvnActions::makeLog(const svn::Revision&start,const svn::Revision&end,const
     }
 }
 
-svn::SharedPointer<svn::LogEntriesMap> SvnActions::getLog(const svn::Revision&start,const svn::Revision&end,const svn::Revision&peg,const QString&which,bool list_files,
-        int limit,QWidget*parent)
+svn::SharedPointer<svn::LogEntriesMap> SvnActions::getLog(const svn::Revision&start,const svn::Revision&end,const svn::Revision&peg,const TQString&which,bool list_files,
+        int limit,TQWidget*tqparent)
 {
     svn::SharedPointer<svn::LogEntriesMap> logs = new svn::LogEntriesMap;
     if (!m_Data->m_CurrentContext) return 0;
@@ -289,9 +289,9 @@ svn::SharedPointer<svn::LogEntriesMap> SvnActions::getLog(const svn::Revision&st
 
     kdDebug()<<"Get logs for "<< which<<endl;
     try {
-        StopDlg sdlg(m_Data->m_SvnContextListener,(parent?parent:m_Data->m_ParentList->realWidget()),0,"Logs",
+        StopDlg sdlg(m_Data->m_SvnContextListener,(tqparent?tqparent:m_Data->m_ParentList->realWidget()),0,"Logs",
             i18n("Getting logs - hit cancel for abort"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         if (doNetworking()) {
             m_Data->m_Svnclient->log(which,start,end,*logs,peg,list_files,!follow,limit);
         } else {
@@ -303,7 +303,7 @@ svn::SharedPointer<svn::LogEntriesMap> SvnActions::getLog(const svn::Revision&st
                 m_Data->m_Svnclient->log(which,start,end,*logs,peg,list_files,!follow,limit);
             } else {
                 svn::cache::ReposLog rl(m_Data->m_Svnclient,e.reposRoot());
-                QString s1,s2,what;
+                TQString s1,s2,what;
                 s1=e.url().mid(e.reposRoot().length());
                 if (which==".") {
                     what=s1;
@@ -325,7 +325,7 @@ svn::SharedPointer<svn::LogEntriesMap> SvnActions::getLog(const svn::Revision&st
     return logs;
 }
 
-bool SvnActions::getSingleLog(svn::LogEntry&t,const svn::Revision&r,const QString&what,const svn::Revision&peg,QString&root)
+bool SvnActions::getSingleLog(svn::LogEntry&t,const svn::Revision&r,const TQString&what,const svn::Revision&peg,TQString&root)
 {
     bool res = false;
 
@@ -345,7 +345,7 @@ bool SvnActions::getSingleLog(svn::LogEntry&t,const svn::Revision&r,const QStrin
         svn::LogEntriesMap _m;
         try {
             svn::cache::ReposLog rl(m_Data->m_Svnclient ,root);
-            if (rl.isValid() && rl.simpleLog(_m,r,r,true) && _m.find(r.revnum())!=_m.end() ) {
+            if (rl.isValid() && rl.simpleLog(_m,r,r,true) && _m.tqfind(r.revnum())!=_m.end() ) {
                 t = _m[r.revnum()];
                 res = true;
             }
@@ -357,7 +357,7 @@ bool SvnActions::getSingleLog(svn::LogEntry&t,const svn::Revision&r,const QStrin
     if (!res) {
         svn::SharedPointer<svn::LogEntriesMap> log = getLog(r,r,peg,root,true,1);
         if (log) {
-            if (log->find(r.revnum())!=log->end()) {
+            if (log->tqfind(r.revnum())!=log->end()) {
                 t = (*log)[r.revnum()];
                 res = true;
             }
@@ -366,12 +366,12 @@ bool SvnActions::getSingleLog(svn::LogEntry&t,const svn::Revision&r,const QStrin
     return res;
 }
 
-bool SvnActions::singleInfo(const QString&what,const svn::Revision&_rev,svn::InfoEntry&target,const svn::Revision&_peg)
+bool SvnActions::singleInfo(const TQString&what,const svn::Revision&_rev,svn::InfoEntry&target,const svn::Revision&_peg)
 {
-    QString url;
-    QString ex;
-    QString cacheKey;
-    QTime d; d.start();
+    TQString url;
+    TQString ex;
+    TQString cacheKey;
+    TQTime d; d.start();
     svn::Revision rev = _rev;
     svn::Revision peg = _peg;
     if (!m_Data->m_CurrentContext) return false;
@@ -379,14 +379,14 @@ bool SvnActions::singleInfo(const QString&what,const svn::Revision&_rev,svn::Inf
         // working copy
         // url = svn::Wc::getUrl(what);
         url = what;
-        if (url.find("@")!=-1) {
+        if (url.tqfind("@")!=-1) {
             url+="@BASE";
         }
         peg = svn::Revision::UNDEFINED;
         cacheKey=url;
     } else {
         KURL _uri = what;
-        QString prot = svn::Url::transformProtokoll(_uri.protocol());
+        TQString prot = svn::Url::transformProtokoll(_uri.protocol());
         _uri.setProtocol(prot);
         url = _uri.prettyURL();
         if (peg==svn::Revision::UNDEFINED)
@@ -428,24 +428,24 @@ bool SvnActions::singleInfo(const QString&what,const svn::Revision&_rev,svn::Inf
     return true;
 }
 
-void SvnActions::makeTree(const QString&what,const svn::Revision&_rev,const svn::Revision&startr,const svn::Revision&endr)
+void SvnActions::makeTree(const TQString&what,const svn::Revision&_rev,const svn::Revision&startr,const svn::Revision&endr)
 {
     svn::InfoEntry info;
     if (!singleInfo(what,_rev,info)) {
         return;
     }
-    QString reposRoot = info.reposRoot();
+    TQString reposRoot = info.reposRoot();
 
     bool restartCache = (m_FCThread && m_FCThread->running());
     if (restartCache) {
         stopFillCache();
     }
     kdDebug()<<"Logs for "<<reposRoot<<endl;
-    QWidget*disp;
-    KDialogBase dlg(m_Data->m_ParentList->realWidget(),"historylist",true,i18n("History of %1").arg(info.url().mid(reposRoot.length())),
+    TQWidget*disp;
+    KDialogBase dlg(m_Data->m_ParentList->realWidget(),"historylist",true,i18n("History of %1").tqarg(info.url().mid(reposRoot.length())),
         KDialogBase::Ok,
         KDialogBase::Ok,true);
-    QWidget* Dialog1Layout = dlg.makeVBoxMainWidget();
+    TQWidget* Dialog1Layout = dlg.makeVBoxMainWidget();
 
     RevisionTree rt(m_Data->m_Svnclient,m_Data->m_SvnContextListener,reposRoot,
             startr,endr,
@@ -454,15 +454,15 @@ void SvnActions::makeTree(const QString&what,const svn::Revision&_rev,const svn:
         disp = rt.getView();
         if (disp) {
             connect(
-                disp,SIGNAL(makeNorecDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*)),
-                this,SLOT(makeNorecDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*))
+                disp,TQT_SIGNAL(makeNorecDiff(const TQString&,const svn::Revision&,const TQString&,const svn::Revision&,TQWidget*)),
+                this,TQT_SLOT(makeNorecDiff(const TQString&,const svn::Revision&,const TQString&,const svn::Revision&,TQWidget*))
             );
             connect(
-                disp,SIGNAL(makeRecDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*)),
-                this,SLOT(makeDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*))
+                disp,TQT_SIGNAL(makeRecDiff(const TQString&,const svn::Revision&,const TQString&,const svn::Revision&,TQWidget*)),
+                this,TQT_SLOT(makeDiff(const TQString&,const svn::Revision&,const TQString&,const svn::Revision&,TQWidget*))
                    );
-            connect(disp,SIGNAL(makeCat(const svn::Revision&, const QString&,const QString&,const svn::Revision&,QWidget*)),
-                this,SLOT(slotMakeCat(const svn::Revision&,const QString&,const QString&,const svn::Revision&,QWidget*)));
+            connect(disp,TQT_SIGNAL(makeCat(const svn::Revision&, const TQString&,const TQString&,const svn::Revision&,TQWidget*)),
+                this,TQT_SLOT(slotMakeCat(const svn::Revision&,const TQString&,const TQString&,const svn::Revision&,TQWidget*)));
             dlg.resize(dlg.configDialogSize(*(Kdesvnsettings::self()->config()),"revisiontree_dlg"));
             dlg.exec();
             dlg.saveDialogSize(*(Kdesvnsettings::self()->config()),"revisiontree_dlg",false);
@@ -473,23 +473,23 @@ void SvnActions::makeTree(const QString&what,const svn::Revision&_rev,const svn:
     }
 }
 
-void SvnActions::makeLog(const svn::Revision&start,const svn::Revision&end,const svn::Revision&peg,const QString&which,bool list_files,int limit)
+void SvnActions::makeLog(const svn::Revision&start,const svn::Revision&end,const svn::Revision&peg,const TQString&which,bool list_files,int limit)
 {
     svn::InfoEntry info;
     if (!singleInfo(which,start,info)) {
         return;
     }
-    QString reposRoot = info.reposRoot();
+    TQString reposRoot = info.reposRoot();
     kdDebug()<<"getting logs..."<<endl;
     svn::SharedPointer<svn::LogEntriesMap> logs = getLog(start,end,peg,which,list_files,limit);
     if (!logs) return;
-    bool need_modal = m_Data->runblocked||KApplication::activeModalWidget()!=0;
+    bool need_modal = m_Data->runblocked||TQT_TQWIDGET(KApplication::activeModalWidget())!=0;
     if (need_modal||!m_Data->m_LogDialog) {
         m_Data->m_LogDialog=new SvnLogDlgImp(this,0,"logdialog",need_modal);
-        connect(m_Data->m_LogDialog,SIGNAL(makeDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*)),
-                 this,SLOT(makeDiff(const QString&,const svn::Revision&,const QString&,const svn::Revision&,QWidget*)));
-        connect(m_Data->m_LogDialog,SIGNAL(makeCat(const svn::Revision&, const QString&,const QString&,const svn::Revision&,QWidget*)),
-                 this,SLOT(slotMakeCat(const svn::Revision&,const QString&,const QString&,const svn::Revision&,QWidget*)));
+        connect(m_Data->m_LogDialog,TQT_SIGNAL(makeDiff(const TQString&,const svn::Revision&,const TQString&,const svn::Revision&,TQWidget*)),
+                 this,TQT_SLOT(makeDiff(const TQString&,const svn::Revision&,const TQString&,const svn::Revision&,TQWidget*)));
+        connect(m_Data->m_LogDialog,TQT_SIGNAL(makeCat(const svn::Revision&, const TQString&,const TQString&,const svn::Revision&,TQWidget*)),
+                 this,TQT_SLOT(slotMakeCat(const svn::Revision&,const TQString&,const TQString&,const svn::Revision&,TQWidget*)));
     }
 
     if (m_Data->m_LogDialog) {
@@ -516,19 +516,19 @@ void SvnActions::makeBlame(const svn::Revision&start, const svn::Revision&end, S
     if (k) makeBlame(start,end,k->fullName(),m_Data->m_ParentList->realWidget());
 }
 
-void SvnActions::makeBlame(const svn::Revision&start, const svn::Revision&end,const QString&k,QWidget*_p,const svn::Revision&_peg,SimpleLogCb*_acb)
+void SvnActions::makeBlame(const svn::Revision&start, const svn::Revision&end,const TQString&k,TQWidget*_p,const svn::Revision&_peg,SimpleLogCb*_acb)
 {
     if (!m_Data->m_CurrentContext) return;
     svn::AnnotatedFile blame;
-    QString ex;
+    TQString ex;
     svn::Path p(k);
-    QWidget*_parent = _p?_p:m_Data->m_ParentList->realWidget();
+    TQWidget*_tqparent = _p?_p:m_Data->m_ParentList->realWidget();
     svn::Revision peg = _peg==svn::Revision::UNDEFINED?end:_peg;
 
     try {
-        CursorStack a(Qt::BusyCursor);
-        StopDlg sdlg(m_Data->m_SvnContextListener,_parent,0,"Annotate",i18n("Annotate lines - hit cancel for abort"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        CursorStack a(TQt::BusyCursor);
+        StopDlg sdlg(m_Data->m_SvnContextListener,_tqparent,0,"Annotate",i18n("Annotate lines - hit cancel for abort"));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->annotate(blame,p,start,end,peg);
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
@@ -543,18 +543,18 @@ void SvnActions::makeBlame(const svn::Revision&start, const svn::Revision&end,co
     BlameDisplay_impl::displayBlame(_acb?_acb:this,k,blame,_p,"blame_dlg");
 }
 
-bool SvnActions::makeGet(const svn::Revision&start, const QString&what, const QString&target,
-    const svn::Revision&peg,QWidget*_dlgparent)
+bool SvnActions::makeGet(const svn::Revision&start, const TQString&what, const TQString&target,
+    const svn::Revision&peg,TQWidget*_dlgtqparent)
 {
     if (!m_Data->m_CurrentContext) return false;
-    CursorStack a(Qt::BusyCursor);
-    QWidget*dlgp=_dlgparent?_dlgparent:m_Data->m_ParentList->realWidget();
-    QString ex;
+    CursorStack a(TQt::BusyCursor);
+    TQWidget*dlgp=_dlgtqparent?_dlgtqparent:m_Data->m_ParentList->realWidget();
+    TQString ex;
     svn::Path p(what);
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,dlgp,
             0,"Content get",i18n("Getting content - hit cancel for abort"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->get(p,target,start,peg);
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
@@ -567,11 +567,11 @@ bool SvnActions::makeGet(const svn::Revision&start, const QString&what, const QS
     return true;
 }
 
-void SvnActions::slotMakeCat(const svn::Revision&start, const QString&what, const QString&disp,const svn::Revision&peg,QWidget*_dlgparent)
+void SvnActions::slotMakeCat(const svn::Revision&start, const TQString&what, const TQString&disp,const svn::Revision&peg,TQWidget*_dlgtqparent)
 {
     KTempFile content;
     content.setAutoDelete(true);
-    if (!makeGet(start,what,content.name(),peg,_dlgparent)) {
+    if (!makeGet(start,what,content.name(),peg,_dlgtqparent)) {
         return;
     }
     EMIT_FINISHED;
@@ -594,27 +594,27 @@ void SvnActions::slotMakeCat(const svn::Revision&start, const QString&what, cons
         return;
     }
     KTextBrowser*ptr;
-    QFile file(content.name());
+    TQFile file(content.name());
     file.open( IO_ReadOnly );
-    QByteArray co = file.readAll();
+    TQByteArray co = file.readAll();
 
     if (co.size()) {
-        KDialogBase*dlg = createDialog(&ptr,QString(i18n("Content of %1")).arg(disp),false,"cat_display_dlg");
+        KDialogBase*dlg = createDialog(&ptr,TQString(i18n("Content of %1")).tqarg(disp),false,"cat_display_dlg");
         if (dlg) {
             ptr->setFont(KGlobalSettings::fixedFont());
-            ptr->setWordWrap(QTextEdit::NoWrap);
-            ptr->setText(QString::FROMUTF8(co,co.size()));
+            ptr->setWordWrap(TQTextEdit::NoWrap);
+            ptr->setText(TQString::FROMUTF8(co,co.size()));
             dlg->exec();
             dlg->saveDialogSize(*(Kdesvnsettings::self()->config()),"cat_display_dlg",false);
             delete dlg;
         }
     } else {
-        KMessageBox::information(_dlgparent?_dlgparent:m_Data->m_ParentList->realWidget(),
+        KMessageBox::information(_dlgtqparent?_dlgtqparent:m_Data->m_ParentList->realWidget(),
                                  i18n("Got no content."));
     }
 }
 
-bool SvnActions::makeMkdir(const QStringList&which,const QString&logMessage)
+bool SvnActions::makeMkdir(const TQStringList&which,const TQString&logMessage)
 {
     if (!m_Data->m_CurrentContext||which.count()<1) return false;
     svn::Targets targets(which);
@@ -627,35 +627,35 @@ bool SvnActions::makeMkdir(const QStringList&which,const QString&logMessage)
     return true;
 }
 
-QString SvnActions::makeMkdir(const QString&parentDir)
+TQString SvnActions::makeMkdir(const TQString&tqparentDir)
 {
-    if (!m_Data->m_CurrentContext) return QString::null;
-    QString ex;
+    if (!m_Data->m_CurrentContext) return TQString();
+    TQString ex;
     bool isOk=false;
-    ex = KInputDialog::getText(i18n("New folder"),i18n("Enter folder name:"),QString::null,&isOk);
+    ex = KInputDialog::getText(i18n("New folder"),i18n("Enter folder name:"),TQString(),&isOk);
     if (!isOk) {
-        return QString::null;
+        return TQString();
     }
-    svn::Path target(parentDir);
+    svn::Path target(tqparentDir);
     target.addComponent(ex);
     ex = "";
 
-    QString logMessage=QString::null;
+    TQString logMessage=TQString();
     try {
         m_Data->m_Svnclient->mkdir(target,logMessage);
     }catch (const svn::Exception&e) {
         emit clientException(e.msg());
-        return QString::null;
+        return TQString();
     }
 
     ex = target.path();
     return ex;
 }
 
-QString SvnActions::getInfo(QPtrList<SvnItem> lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive,bool all)
+TQString SvnActions::getInfo(TQPtrList<SvnItem> lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive,bool all)
 {
-    QStringList l;
-    QString res = "";
+    TQStringList l;
+    TQString res = "";
     SvnItem*item;
     for (item=lst.first();item;item=lst.next()) {
         if (all) res+="<h4 align=\"center\">"+item->fullName()+"</h4>";
@@ -664,36 +664,36 @@ QString SvnActions::getInfo(QPtrList<SvnItem> lst,const svn::Revision&rev,const
     return res;
 }
 
-QString SvnActions::getInfo(const QString& _what,const svn::Revision&rev,const svn::Revision&peg,bool recursive,bool all)
+TQString SvnActions::getInfo(const TQString& _what,const svn::Revision&rev,const svn::Revision&peg,bool recursive,bool all)
 {
-    if (!m_Data->m_CurrentContext) return QString::null;
-    QString ex;
+    if (!m_Data->m_CurrentContext) return TQString();
+    TQString ex;
     svn::InfoEntries entries;
     if (recursive) {
         try {
             StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,"Details",
                          i18n("Retrieving infos - hit cancel for abort"));
-            connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+            connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
             svn::InfoEntries e;
             entries = (m_Data->m_Svnclient->info(_what+
-                    (_what.find("@")>-1&&!svn::Url::isValid(_what)?"@BASE":""),recursive?svn::DepthInfinity:svn::DepthEmpty,rev,peg));
+                    (_what.tqfind("@")>-1&&!svn::Url::isValid(_what)?"@BASE":""),recursive?svn::DepthInfinity:svn::DepthEmpty,rev,peg));
         } catch (const svn::Exception&e) {
             emit clientException(e.msg());
-            return QString::null;
+            return TQString();
         }
     } else {
         svn::InfoEntry info;
         if (!singleInfo(_what,rev,info,peg)) {
-            return QString::null;
+            return TQString();
         }
         entries.append(info);
     }
     //if (!all) EMIT_FINISHED;
-    QString text = "";
+    TQString text = "";
     svn::InfoEntries::const_iterator it;
-    static QString rb = "<tr><td><nobr><font color=\"black\">";
-    static QString re = "</font></nobr></td></tr>\n";
-    static QString cs = "</font></nobr>:</td><td><nobr><font color=\"black\">";
+    static TQString rb = "<tr><td><nobr><font color=\"black\">";
+    static TQString re = "</font></nobr></td></tr>\n";
+    static TQString cs = "</font></nobr>:</td><td><nobr><font color=\"black\">";
     unsigned int val = 0;
     for (it=entries.begin();it!=entries.end();++it) {
         if (val>0) {
@@ -791,7 +791,7 @@ QString SvnActions::getInfo(const QString& _what,const svn::Revision&rev,const s
                 text+=rb+i18n("Lock comment")+cs+
                     (*it).lockEntry().Comment()+re;
             } else {
-                svn::SharedPointer<svn::Status> d;
+                svn::SharedPointer<svn::tqStatus> d;
                 if (checkReposLockCache(_what,d)&& d && d->lockEntry().Locked()) {
                     text+=rb+i18n("Lock token")+cs+(d->lockEntry().Token())+re;
                     text+=rb+i18n("Owner")+cs+(d->lockEntry().Owner())+re;
@@ -808,13 +808,13 @@ QString SvnActions::getInfo(const QString& _what,const svn::Revision&rev,const s
     return text;
 }
 
-void SvnActions::makeInfo(QPtrList<SvnItem> lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive)
+void SvnActions::makeInfo(TQPtrList<SvnItem> lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive)
 {
-    QStringList l;
-    QString res = "<html><head></head><body>";
+    TQStringList l;
+    TQString res = "<html><head></head><body>";
     SvnItem*item;
     for (item=lst.first();item;item=lst.next()) {
-        QString text = getInfo(item->fullName(),rev,peg,recursive,true);
+        TQString text = getInfo(item->fullName(),rev,peg,recursive,true);
         if (!text.isEmpty()) {
             res+="<h4 align=\"center\">"+item->fullName()+"</h4>";
             res+=text;
@@ -822,7 +822,7 @@ void SvnActions::makeInfo(QPtrList<SvnItem> lst,const svn::Revision&rev,const sv
     }
     res+="</body></html>";
     KTextBrowser*ptr;
-    KDialogBase*dlg = createDialog(&ptr,QString(i18n("Infolist")),false,"info_dialog");
+    KDialogBase*dlg = createDialog(&ptr,TQString(i18n("Infolist")),false,"info_dialog");
     if (dlg) {
         ptr->setText(res);
         dlg->exec();
@@ -831,11 +831,11 @@ void SvnActions::makeInfo(QPtrList<SvnItem> lst,const svn::Revision&rev,const sv
     }
 }
 
-void SvnActions::makeInfo(const QStringList&lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive)
+void SvnActions::makeInfo(const TQStringList&lst,const svn::Revision&rev,const svn::Revision&peg,bool recursive)
 {
-    QString text = "";
+    TQString text = "";
     for (unsigned int i=0; i < lst.count();++i) {
-        QString res = getInfo(lst[i],rev,peg,recursive,true);
+        TQString res = getInfo(lst[i],rev,peg,recursive,true);
         if (!res.isEmpty()) {
             text+="<h4 align=\"center\">"+lst[i]+"</h4>";
             text+=res;
@@ -843,7 +843,7 @@ void SvnActions::makeInfo(const QStringList&lst,const svn::Revision&rev,const sv
     }
     text = "<html><head></head><body>"+text+"</body></html>";
     KTextBrowser*ptr;
-    KDialogBase*dlg = createDialog(&ptr,QString(i18n("Infolist")),false,"info_dialog");
+    KDialogBase*dlg = createDialog(&ptr,TQString(i18n("Infolist")),false,"info_dialog");
     if (dlg) {
         ptr->setText(text);
         dlg->exec();
@@ -858,33 +858,33 @@ void SvnActions::makeInfo(const QStringList&lst,const svn::Revision&rev,const sv
  */
 void SvnActions::slotProperties()
 {
-    /// @todo remove reference to parentlist
+    /// @todo remove reference to tqparentlist
     if (!m_Data->m_CurrentContext) return;
     if (!m_Data->m_ParentList) return;
     SvnItem*k = m_Data->m_ParentList->Selected();
     if (!k) return;
     PropertiesDlg dlg(k,svnclient(),
         m_Data->m_ParentList->isWorkingCopy()?svn::Revision::WORKING:svn::Revision::HEAD);
-    connect(&dlg,SIGNAL(clientException(const QString&)),m_Data->m_ParentList->realWidget(),SLOT(slotClientException(const QString&)));
+    connect(&dlg,TQT_SIGNAL(clientException(const TQString&)),m_Data->m_ParentList->realWidget(),TQT_SLOT(slotClientException(const TQString&)));
     dlg.resize(dlg.configDialogSize(*(Kdesvnsettings::self()->config()), "properties_dlg"));
-    if (dlg.exec()!=QDialog::Accepted) {
+    if (dlg.exec()!=TQDialog::Accepted) {
         return;
     }
     dlg.saveDialogSize(*(Kdesvnsettings::self()->config()),"properties_dlg",false);
-    QString ex;
+    TQString ex;
     svn::PropertiesMap setList;
-    QValueList<QString> delList;
+    TQValueList<TQString> delList;
     dlg.changedItems(setList,delList);
     changeProperties(setList,delList,k->fullName());
-    k->refreshStatus();
+    k->refreshtqStatus();
     EMIT_FINISHED;
 }
 
-bool SvnActions::changeProperties(const svn::PropertiesMap&setList,const QValueList<QString>&delList,const QString&path)
+bool SvnActions::changeProperties(const svn::PropertiesMap&setList,const TQValueList<TQString>&delList,const TQString&path)
 {
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,"Applying properties","<center>Applying<br>hit cancel for abort</center>");
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         unsigned int pos;
         for (pos = 0; pos<delList.size();++pos) {
             m_Data->m_Svnclient->propdel(delList[pos],svn::Path(path));
@@ -908,10 +908,10 @@ void SvnActions::slotCommit()
     if (!m_Data->m_CurrentContext||!m_Data->m_ParentList->isWorkingCopy()) {
         return;
     }
-    QPtrList<SvnItem> which;
+    TQPtrList<SvnItem> which;
     m_Data->m_ParentList->SelectionList(&which);
     SvnItem*cur;
-    QPtrListIterator<SvnItem> liter(which);
+    TQPtrListIterator<SvnItem> liter(which);
 
     svn::Pathes targets;
     if (which.count()==0) {
@@ -940,7 +940,7 @@ bool SvnActions::makeCommit(const svn::Targets&targets)
     svn::Targets _targets;
     svn::Pathes _deldir;
     bool review = Kdesvnsettings::review_commit();
-    QString msg,_p;
+    TQString msg,_p;
 
     if (!doNetworking()) {
         emit clientException(i18n("Not commiting because networking is disabled"));
@@ -963,7 +963,7 @@ bool SvnActions::makeCommit(const svn::Targets&targets)
         for (unsigned j = 0; j < targets.size(); ++j) {
             svn::Revision where = svn::Revision::HEAD;
             try {
-                StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Status / List"),i18n("Creating list / check status"));
+                StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("tqStatus / List"),i18n("Creating list / check status"));
                 _Cache = m_Data->m_Svnclient->status(targets.target(j).path(),svn::DepthInfinity,false,false,false,where);
             } catch (const svn::Exception&e) {
                 emit clientException(e.msg());
@@ -972,18 +972,18 @@ bool SvnActions::makeCommit(const svn::Targets&targets)
             for (unsigned int i = 0; i < _Cache.count();++i) {
                 _p = _Cache[i]->path();
                 if (_Cache[i]->isRealVersioned()&& (
-                    _Cache[i]->textStatus()==svn_wc_status_modified||
-                    _Cache[i]->textStatus()==svn_wc_status_added||
-                    _Cache[i]->textStatus()==svn_wc_status_replaced||
-                    _Cache[i]->textStatus()==svn_wc_status_deleted||
-                    _Cache[i]->propStatus()==svn_wc_status_modified
+                    _Cache[i]->texttqStatus()==svn_wc_status_modified||
+                    _Cache[i]->texttqStatus()==svn_wc_status_added||
+                    _Cache[i]->texttqStatus()==svn_wc_status_replaced||
+                    _Cache[i]->texttqStatus()==svn_wc_status_deleted||
+                    _Cache[i]->proptqStatus()==svn_wc_status_modified
                 ) ) {
-                    if (_Cache[i]->textStatus()==svn_wc_status_deleted) {
+                    if (_Cache[i]->texttqStatus()==svn_wc_status_deleted) {
                         _check.append(Logmsg_impl::logActionEntry(_p,i18n("Delete"),Logmsg_impl::logActionEntry::DELETE));
                     } else {
                         _check.append(Logmsg_impl::logActionEntry(_p,i18n("Commit"),Logmsg_impl::logActionEntry::COMMIT));
                     }
-                } else if (_Cache[i]->textStatus()==svn_wc_status_missing) {
+                } else if (_Cache[i]->texttqStatus()==svn_wc_status_missing) {
                     _uncheck.append(Logmsg_impl::logActionEntry(_p,i18n("Delete and Commit"),Logmsg_impl::logActionEntry::MISSING_DELETE));
                 } else if (!_Cache[i]->isVersioned()) {
                     _uncheck.append(Logmsg_impl::logActionEntry(_p,i18n("Add and Commit"),Logmsg_impl::logActionEntry::ADD_COMMIT));
@@ -998,7 +998,7 @@ bool SvnActions::makeCommit(const svn::Targets&targets)
         svn::Pathes _add,_commit,_delete;
         for (unsigned int i=0; i < _result.count();++i) {
             if (_result[i]._kind==Logmsg_impl::logActionEntry::DELETE) {
-                QFileInfo fi(_result[i]._name);
+                TQFileInfo fi(_result[i]._name);
                 if (fi.isDir()) {
                     depth = svn::DepthInfinity;
                 }
@@ -1024,14 +1024,14 @@ bool SvnActions::makeCommit(const svn::Targets&targets)
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Commiting"),
             i18n("Commiting - hit cancel for abort"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         nnum = m_Data->m_Svnclient->commit(_targets,msg,depth,keeplocks);
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
         return false;
     }
     EMIT_REFRESH;
-    emit sendNotify(i18n("Committed revision %1.").arg(nnum.toString()));
+    emit sendNotify(i18n("Committed revision %1.").tqarg(nnum.toString()));
     return true;
 }
 
@@ -1050,23 +1050,23 @@ void SvnActions::receivedStderr(KProcess*proc,char*buff,int len)
     if (!proc || !buff || len == 0) {
         return;
     }
-    QString msg(QCString(buff,len));
+    TQString msg(TQCString(buff,len));
     emit sendNotify(msg);
 }
 
 void SvnActions::procClosed(KProcess*proc)
 {
     if (!proc) return;
-    QMap<KProcess*,QStringList>::iterator it;
-    if ( (it=m_Data->m_tempfilelist.find(proc))!=m_Data->m_tempfilelist.end()) {
-        for (QStringList::iterator it2 = (*it).begin();
+    TQMap<KProcess*,TQStringList>::iterator it;
+    if ( (it=m_Data->m_tempfilelist.tqfind(proc))!=m_Data->m_tempfilelist.end()) {
+        for (TQStringList::iterator it2 = (*it).begin();
             it2 != (*it).end();++it2) {
                 ::unlink((*it2).ascii());
         }
         m_Data->m_tempfilelist.erase(it);
     }
-    if ( (it=m_Data->m_tempdirlist.find(proc))!=m_Data->m_tempdirlist.end()) {
-        for (QStringList::iterator it2 = (*it).begin();
+    if ( (it=m_Data->m_tempdirlist.tqfind(proc))!=m_Data->m_tempdirlist.end()) {
+        for (TQStringList::iterator it2 = (*it).begin();
             it2 != (*it).end();++it2) {
                 KIO::NetAccess::del((*it2),0);
         }
@@ -1075,7 +1075,7 @@ void SvnActions::procClosed(KProcess*proc)
     delete proc;
 }
 
-bool SvnActions::get(const QString&what,const QString& to,const svn::Revision&rev,const svn::Revision&peg,QWidget*p)
+bool SvnActions::get(const TQString&what,const TQString& to,const svn::Revision&rev,const svn::Revision&peg,TQWidget*p)
 {
     svn::Revision _peg = peg;
     if (_peg == svn::Revision::UNDEFINED) {
@@ -1085,7 +1085,7 @@ bool SvnActions::get(const QString&what,const QString& to,const svn::Revision&re
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,p?p:m_Data->m_ParentList->realWidget(),0,"Downloading",
         i18n("Download - hit cancel for abort"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->get(svn::Path(what),
             to,rev,_peg);
     } catch (const svn::Exception&e) {
@@ -1096,19 +1096,19 @@ bool SvnActions::get(const QString&what,const QString& to,const svn::Revision&re
 }
 
 /*!
-    \fn SvnActions::makeDiff(const QString&,const svn::Revision&start,const svn::Revision&end)
+    \fn SvnActions::makeDiff(const TQString&,const svn::Revision&start,const svn::Revision&end)
  */
-void SvnActions::makeDiff(const QString&what,const svn::Revision&start,const svn::Revision&end,const svn::Revision&_peg,bool isDir)
+void SvnActions::makeDiff(const TQString&what,const svn::Revision&start,const svn::Revision&end,const svn::Revision&_peg,bool isDir)
 {
     makeDiff(what,start,what,end,_peg,isDir,m_Data->m_ParentList->realWidget());
 }
 
-void SvnActions::makeDiff(const QString&p1,const svn::Revision&start,const QString&p2,const svn::Revision&end)
+void SvnActions::makeDiff(const TQString&p1,const svn::Revision&start,const TQString&p2,const svn::Revision&end)
 {
-    makeDiff(p1,start,p2,end,(QWidget*)0);
+    makeDiff(p1,start,p2,end,(TQWidget*)0);
 }
 
-void SvnActions::makeDiff(const QString&p1,const svn::Revision&start,const QString&p2,const svn::Revision&end,QWidget*p)
+void SvnActions::makeDiff(const TQString&p1,const svn::Revision&start,const TQString&p2,const svn::Revision&end,TQWidget*p)
 {
     if (!doNetworking()&&start!=svn::Revision::BASE && end!=svn::Revision::WORKING) {
         emit sendNotify(i18n("Can not do this diff because networking is disabled."));
@@ -1126,21 +1126,21 @@ void SvnActions::makeDiff(const QString&p1,const svn::Revision&start,const QStri
     makeDiffinternal(p1,start,p2,end,p);
 }
 
-void SvnActions::makeDiffExternal(const QString&p1,const svn::Revision&start,const QString&p2,const svn::Revision&end,const svn::Revision&_peg,
-                                  bool isDir,QWidget*p,bool rec)
+void SvnActions::makeDiffExternal(const TQString&p1,const svn::Revision&start,const TQString&p2,const svn::Revision&end,const svn::Revision&_peg,
+                                  bool isDir,TQWidget*p,bool rec)
 {
-    QString edisp = Kdesvnsettings::external_diff_display();
-    QStringList wlist = QStringList::split(" ",edisp);
-    QFileInfo f1(p1);
-    QFileInfo f2(p2);
-    KTempFile tfile(QString::null,f1.fileName()+"-"+start.toString()),tfile2(QString::null,f2.fileName()+"-"+end.toString());
-    QString s1 = f1.fileName()+"-"+start.toString();
-    QString s2 = f2.fileName()+"-"+end.toString();
+    TQString edisp = Kdesvnsettings::external_diff_display();
+    TQStringList wlist = TQStringList::split(" ",edisp);
+    TQFileInfo f1(p1);
+    TQFileInfo f2(p2);
+    KTempFile tfile(TQString(),f1.fileName()+"-"+start.toString()),tfile2(TQString(),f2.fileName()+"-"+end.toString());
+    TQString s1 = f1.fileName()+"-"+start.toString();
+    TQString s2 = f2.fileName()+"-"+end.toString();
     KTempDir tdir1;
     tdir1.setAutoDelete(true);
     tfile.setAutoDelete(true);
     tfile2.setAutoDelete(true);
-    QString first,second;
+    TQString first,second;
     svn::Revision peg = _peg;
 
     if (start != svn::Revision::WORKING) {
@@ -1184,7 +1184,7 @@ void SvnActions::makeDiffExternal(const QString&p1,const svn::Revision&start,con
         }
     }
     KProcess*proc = new KProcess();
-    for ( QStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
+    for ( TQStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
         if (*it=="%1") {
             *proc<<first;
         } else if (*it=="%2") {
@@ -1193,9 +1193,9 @@ void SvnActions::makeDiffExternal(const QString&p1,const svn::Revision&start,con
             *proc << *it;
         }
     }
-    connect(proc,SIGNAL(processExited(KProcess*)),this,SLOT(procClosed(KProcess*)));
-    connect(proc,SIGNAL(receivedStderr(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
-    connect(proc,SIGNAL(receivedStdout(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
+    connect(proc,TQT_SIGNAL(processExited(KProcess*)),this,TQT_SLOT(procClosed(KProcess*)));
+    connect(proc,TQT_SIGNAL(receivedStderr(KProcess*,char*,int)),this,TQT_SLOT(receivedStderr(KProcess*,char*,int)));
+    connect(proc,TQT_SIGNAL(receivedStdout(KProcess*,char*,int)),this,TQT_SLOT(receivedStderr(KProcess*,char*,int)));
     if (proc->start(m_Data->runblocked?KProcess::Block:KProcess::NotifyOnExit,KProcess::All)) {
         if (!m_Data->runblocked) {
             if (!isDir) {
@@ -1216,7 +1216,7 @@ void SvnActions::makeDiffExternal(const QString&p1,const svn::Revision&start,con
     return;
 }
 
-void SvnActions::makeDiff(const QString&p1,const svn::Revision&start,const QString&p2,const svn::Revision&end,const svn::Revision&_peg,bool isDir,QWidget*p)
+void SvnActions::makeDiff(const TQString&p1,const svn::Revision&start,const TQString&p2,const svn::Revision&end,const svn::Revision&_peg,bool isDir,TQWidget*p)
 {
     if (m_Data->isExternalDiff()) {
         kdDebug()<<"External diff 2..."<<endl;
@@ -1226,16 +1226,16 @@ void SvnActions::makeDiff(const QString&p1,const svn::Revision&start,const QStri
     }
 }
 
-void SvnActions::makeDiffinternal(const QString&p1,const svn::Revision&r1,const QString&p2,const svn::Revision&r2,QWidget*p,const svn::Revision&_peg)
+void SvnActions::makeDiffinternal(const TQString&p1,const svn::Revision&r1,const TQString&p2,const svn::Revision&r2,TQWidget*p,const svn::Revision&_peg)
 {
     if (!m_Data->m_CurrentContext) return;
-    QByteArray ex;
+    TQByteArray ex;
     KTempDir tdir;
     tdir.setAutoDelete(true);
-    QString tn = QString("%1/%2").arg(tdir.name()).arg("/svndiff");
+    TQString tn = TQString("%1/%2").tqarg(tdir.name()).tqarg("/svndiff");
     bool ignore_content = Kdesvnsettings::diff_ignore_content();
-    QWidget*parent = p?p:m_Data->m_ParentList->realWidget();
-    QStringList extraOptions;
+    TQWidget*tqparent = p?p:m_Data->m_ParentList->realWidget();
+    TQStringList extraOptions;
     if (Kdesvnsettings::diff_ignore_spaces())
     {
         extraOptions.append("-b");
@@ -1247,9 +1247,9 @@ void SvnActions::makeDiffinternal(const QString&p1,const svn::Revision&r1,const
     svn::Revision peg = _peg==svn::Revision::UNDEFINED?r2:_peg;
 
     try {
-        StopDlg sdlg(m_Data->m_SvnContextListener,parent,0,"Diffing",
+        StopDlg sdlg(m_Data->m_SvnContextListener,tqparent,0,"Diffing",
             i18n("Diffing - hit cancel for abort"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         if (p1==p2 && (r1.isRemote()||r2.isRemote())) {
             kdDebug()<<"Pegged diff"<<endl;
             ex = m_Data->m_Svnclient->diff_peg(svn::Path(tn),
@@ -1273,7 +1273,7 @@ void SvnActions::makeDiffinternal(const QString&p1,const svn::Revision&r1,const
     dispDiff(ex);
 }
 
-void SvnActions::makeNorecDiff(const QString&p1,const svn::Revision&r1,const QString&p2,const svn::Revision&r2,QWidget*_p)
+void SvnActions::makeNorecDiff(const TQString&p1,const svn::Revision&r1,const TQString&p2,const svn::Revision&r2,TQWidget*_p)
 {
     if (!m_Data->m_CurrentContext) return;
     if (m_Data->isExternalDiff()) {
@@ -1283,7 +1283,7 @@ void SvnActions::makeNorecDiff(const QString&p1,const svn::Revision&r1,const QSt
         }
         return;
     }
-    QStringList extraOptions;
+    TQStringList extraOptions;
     if (Kdesvnsettings::diff_ignore_spaces())
     {
         extraOptions.append("-b");
@@ -1292,15 +1292,15 @@ void SvnActions::makeNorecDiff(const QString&p1,const svn::Revision&r1,const QSt
     {
         extraOptions.append("-w");
     }
-    QByteArray ex;
+    TQByteArray ex;
     KTempDir tdir;
     tdir.setAutoDelete(true);
     kdDebug()<<"Non recourse diff"<<endl;
-    QString tn = QString("%1/%2").arg(tdir.name()).arg("/svndiff");
+    TQString tn = TQString("%1/%2").tqarg(tdir.name()).tqarg("/svndiff");
     bool ignore_content = Kdesvnsettings::diff_ignore_content();
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,_p?_p:m_Data->m_ParentList->realWidget(),0,"Diffing","Diffing - hit cancel for abort");
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         ex = m_Data->m_Svnclient->diff(svn::Path(tn),
             svn::Path(p1),svn::Path(p2),svn::Path(),
             r1, r2,
@@ -1318,22 +1318,22 @@ void SvnActions::makeNorecDiff(const QString&p1,const svn::Revision&r1,const QSt
     dispDiff(ex);
 }
 
-void SvnActions::dispDiff(const QByteArray&ex)
+void SvnActions::dispDiff(const TQByteArray&ex)
 {
-    QString what = Kdesvnsettings::external_diff_display();
+    TQString what = Kdesvnsettings::external_diff_display();
     int r = KProcess::Stdin|KProcess::Stderr;
 
-    if (Kdesvnsettings::use_external_diff() && (what.find("%1")==-1 || what.find("%2")==-1)) {
-        QStringList wlist = QStringList::split(" ",what);
+    if (Kdesvnsettings::use_external_diff() && (what.tqfind("%1")==-1 || what.tqfind("%2")==-1)) {
+        TQStringList wlist = TQStringList::split(" ",what);
         KProcess*proc = new KProcess();
         bool fname_used = false;
         KTempFile tfile;
         tfile.setAutoDelete(false);
 
-        for ( QStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
+        for ( TQStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
             if (*it=="%f") {
                 fname_used = true;
-                QDataStream*ds = tfile.dataStream();
+                TQDataStream*ds = tfile.dataStream();
                 ds->writeRawBytes(ex,ex.size());
                 tfile.close();
                 *proc<<tfile.name();
@@ -1342,10 +1342,10 @@ void SvnActions::dispDiff(const QByteArray&ex)
             }
         }
 
-        connect(proc,SIGNAL(processExited(KProcess*)),this,SLOT(procClosed(KProcess*)));
-        connect(proc,SIGNAL(receivedStderr(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
+        connect(proc,TQT_SIGNAL(processExited(KProcess*)),this,TQT_SLOT(procClosed(KProcess*)));
+        connect(proc,TQT_SIGNAL(receivedStderr(KProcess*,char*,int)),this,TQT_SLOT(receivedStderr(KProcess*,char*,int)));
         if (!fname_used) {
-            connect(proc,SIGNAL(wroteStdin(KProcess*)),this,SLOT(wroteStdin(KProcess*)));
+            connect(proc,TQT_SIGNAL(wroteStdin(KProcess*)),this,TQT_SLOT(wroteStdin(KProcess*)));
         }
         if (proc->start(KProcess::NotifyOnExit,fname_used?KProcess::Stderr:(KProcess::Communication)r)) {
             if (!fname_used) proc->writeStdin(ex,ex.size());
@@ -1356,24 +1356,24 @@ void SvnActions::dispDiff(const QByteArray&ex)
         }
         delete proc;
     }
-    bool need_modal = m_Data->runblocked||KApplication::activeModalWidget()!=0;
+    bool need_modal = m_Data->runblocked||TQT_TQWIDGET(KApplication::activeModalWidget())!=0;
     if (need_modal||!m_Data->m_DiffBrowserPtr||!m_Data->m_DiffDialog) {
         DiffBrowser*ptr;
 
         if (!need_modal && m_Data->m_DiffBrowserPtr) {
             delete m_Data->m_DiffBrowserPtr;
         }
-        KDialogBase*dlg = createDialog(&ptr,QString(i18n("Diff display")),false,
+        KDialogBase*dlg = createDialog(&ptr,TQString(i18n("Diff display")),false,
                                         "diff_display",false,need_modal,
                                       KStdGuiItem::saveAs());
         if (dlg) {
-            QWidget*wd = dlg->mainWidget();
+            TQWidget*wd = dlg->mainWidget();
             if (wd) {
                 EncodingSelector_impl * ls = new EncodingSelector_impl("",wd);
-                QObject::connect(ls,SIGNAL(TextCodecChanged(const QString&)),
-                                 ptr,SLOT(slotTextCodecChanged(const QString&)));
+                TQObject::connect(ls,TQT_SIGNAL(TextCodecChanged(const TQString&)),
+                                 ptr,TQT_SLOT(slotTextCodecChanged(const TQString&)));
             }
-            QObject::connect(dlg,SIGNAL(user1Clicked()),ptr,SLOT(saveDiff()));
+            TQObject::connect(dlg,TQT_SIGNAL(user1Clicked()),ptr,TQT_SLOT(saveDiff()));
             ptr->setText(ex);
             if (need_modal) {
                 ptr->setFocus();
@@ -1398,18 +1398,18 @@ void SvnActions::dispDiff(const QByteArray&ex)
 
 
 /*!
-    \fn SvnActions::makeUpdate(const QString&what,const svn::Revision&rev,bool recurse)
+    \fn SvnActions::makeUpdate(const TQString&what,const svn::Revision&rev,bool recurse)
  */
-void SvnActions::makeUpdate(const QStringList&what,const svn::Revision&rev,bool recurse)
+void SvnActions::makeUpdate(const TQStringList&what,const svn::Revision&rev,bool recurse)
 {
     if (!m_Data->m_CurrentContext) return;
-    QString ex;
+    TQString ex;
     svn::Revisions ret;
     stopCheckUpdateThread();
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,"Making update",
             i18n("Making update - hit cancel for abort"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         svn::Targets pathes(what);
         ret = m_Data->m_Svnclient->update(pathes,rev, recurse?svn::DepthInfinity:svn::DepthFiles,false,false,true);
     } catch (const svn::Exception&e) {
@@ -1439,7 +1439,7 @@ void SvnActions::prepareUpdate(bool ask)
     SvnItemList k;
     m_Data->m_ParentList->SelectionList(&k);
 
-    QStringList what;
+    TQStringList what;
     if (k.count()==0) {
         what.append(m_Data->m_ParentList->baseUri());
     } else {
@@ -1453,20 +1453,20 @@ void SvnActions::prepareUpdate(bool ask)
     svn::Revision r(svn::Revision::HEAD);
     if (ask) {
         Rangeinput_impl*rdlg;
-        KDialog*dlg = createDialog(&rdlg,QString(i18n("Revisions")),true);
+        KDialog*dlg = createDialog(&rdlg,TQString(i18n("Revisions")),true);
         if (!dlg) {
             return;
         }
         rdlg->setStartOnly(true);
-        /* just here cause layout has changed meanwhile */
-        dlg->resize( QSize(120,60).expandedTo(dlg->minimumSizeHint()) );
+        /* just here cause tqlayout has changed meanwhile */
+        dlg->resize( TQSize(120,60).expandedTo(dlg->tqminimumSizeHint()) );
         int result;
-        if ((result=dlg->exec())==QDialog::Accepted) {
+        if ((result=dlg->exec())==TQDialog::Accepted) {
             Rangeinput_impl::revision_range range = rdlg->getRange();
             r=range.first;
         }
         delete dlg;
-        if (result!=QDialog::Accepted) return;
+        if (result!=TQDialog::Accepted) return;
     }
     makeUpdate(what,r,true);
 }
@@ -1498,20 +1498,20 @@ void SvnActions::makeAdd(bool rec)
 {
     if (!m_Data->m_CurrentContext) return;
     if (!m_Data->m_ParentList) return;
-    QPtrList<SvnItem> lst;
+    TQPtrList<SvnItem> lst;
     m_Data->m_ParentList->SelectionList(&lst);
     if (lst.count()==0) {
         KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("Which files or directories should I add?"));
         return;
     }
-    QValueList<svn::Path> items;
+    TQValueList<svn::Path> items;
     SvnItemListIterator liter(lst);
     SvnItem*cur;
     while ((cur=liter.current())!=0){
         ++liter;
         if (cur->isVersioned()) {
             KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("<center>The entry<br>%1<br>is versioned - break.</center>")
-                .arg(cur->fullName()));
+                .tqarg(cur->fullName()));
             return;
         }
         items.push_back(svn::Path(cur->fullName()));
@@ -1521,29 +1521,29 @@ void SvnActions::makeAdd(bool rec)
 #if 0
     while ((cur=liter.current())!=0){
         ++liter;
-        //cur->refreshStatus();
+        //cur->refreshtqStatus();
 
-        //emit sigRefreshCurrent(static_cast<FileListViewItem*>(cur->parent()));
+        //emit sigRefreshCurrent(static_cast<FileListViewItem*>(cur->tqparent()));
     }
 #else
     emit sigRefreshCurrent(0);
 #endif
 }
 
-bool SvnActions::addItems(const QStringList&w,svn::Depth depth)
+bool SvnActions::addItems(const TQStringList&w,svn::Depth depth)
 {
-    QValueList<svn::Path> items;
+    TQValueList<svn::Path> items;
     for (unsigned int i = 0; i<w.count();++i) {
         items.push_back(w[i]);
     }
     return addItems(items,depth);
 }
 
-bool SvnActions::addItems(const QValueList<svn::Path> &items,svn::Depth depth)
+bool SvnActions::addItems(const TQValueList<svn::Path> &items,svn::Depth depth)
 {
-    QString ex;
+    TQString ex;
     try {
-        QValueList<svn::Path>::const_iterator piter;
+        TQValueList<svn::Path>::const_iterator piter;
         for (piter=items.begin();piter!=items.end();++piter) {
             m_Data->m_Svnclient->add((*piter),depth);
         }
@@ -1554,7 +1554,7 @@ bool SvnActions::addItems(const QValueList<svn::Path> &items,svn::Depth depth)
     return true;
 }
 
-bool SvnActions::makeDelete(const QStringList&w)
+bool SvnActions::makeDelete(const TQStringList&w)
 {
     int answer = KMessageBox::questionYesNoList(0,i18n("Really delete these entries?"),w,i18n("Delete from repository"));
     if (answer!=KMessageBox::Yes) {
@@ -1573,7 +1573,7 @@ bool SvnActions::makeDelete(const QStringList&w)
 bool SvnActions::makeDelete(const svn::Pathes&items)
 {
     if (!m_Data->m_CurrentContext) return false;
-    QString ex;
+    TQString ex;
     try {
         svn::Targets target(items);
         m_Data->m_Svnclient->remove(target,false);
@@ -1610,7 +1610,7 @@ void SvnActions::CheckoutExport(bool _exp)
     CheckoutInfo_impl*ptr;
     KDialogBase * dlg = createDialog(&ptr,(_exp?i18n("Export repository"):i18n("Checkout a repository")),true,"checkout_export_dialog");
     if (dlg) {
-        if (dlg->exec()==QDialog::Accepted) {
+        if (dlg->exec()==TQDialog::Accepted) {
             svn::Revision r = ptr->toRevision();
             bool openit = ptr->openAfterJob();
             bool ignoreExternal=ptr->ignoreExternals();
@@ -1626,7 +1626,7 @@ void SvnActions::CheckoutExport(bool _exp)
     }
 }
 
-void SvnActions::CheckoutExport(const QString&what,bool _exp,bool urlisTarget)
+void SvnActions::CheckoutExport(const TQString&what,bool _exp,bool urlisTarget)
 {
     CheckoutInfo_impl*ptr;
     KDialog * dlg = createDialog(&ptr,_exp?i18n("Export a repository"):i18n("Checkout a repository"),true);
@@ -1636,7 +1636,7 @@ void SvnActions::CheckoutExport(const QString&what,bool _exp,bool urlisTarget)
         } else {
             ptr->setTargetUrl(what);
         }
-        if (dlg->exec()==QDialog::Accepted) {
+        if (dlg->exec()==TQDialog::Accepted) {
             svn::Revision r = ptr->toRevision();
             bool openIt = ptr->openAfterJob();
             bool ignoreExternal = ptr->ignoreExternals();
@@ -1654,7 +1654,7 @@ void SvnActions::CheckoutExportCurrent(bool _exp)
         KMessageBox::error(m_Data->m_ParentList->realWidget(),_exp?i18n("Exporting a file?"):i18n("Checking out a file?"));
         return;
     }
-    QString what;
+    TQString what;
     if (!k) {
         what = m_Data->m_ParentList->baseUri();
     } else {
@@ -1663,7 +1663,7 @@ void SvnActions::CheckoutExportCurrent(bool _exp)
     CheckoutExport(what,_exp);
 }
 
-bool SvnActions::makeCheckout(const QString&rUrl,const QString&tPath,const svn::Revision&r,const svn::Revision&_peg,
+bool SvnActions::makeCheckout(const TQString&rUrl,const TQString&tPath,const svn::Revision&r,const svn::Revision&_peg,
                               svn::Depth depth,
                               // kind of operation
                               bool _exp,
@@ -1673,11 +1673,11 @@ bool SvnActions::makeCheckout(const QString&rUrl,const QString&tPath,const svn::
                               bool ignoreExternal,
                               // overwrite/force not versioned items
                               bool overwrite,
-                              QWidget*_p
+                              TQWidget*_p
                              )
 {
-    QString fUrl = rUrl;
-    QString ex;
+    TQString fUrl = rUrl;
+    TQString ex;
     while (fUrl.endsWith("/")) {
         fUrl.truncate(fUrl.length()-1);
     }
@@ -1689,10 +1689,10 @@ bool SvnActions::makeCheckout(const QString&rUrl,const QString&tPath,const svn::
     if (!_exp||!m_Data->m_CurrentContext) reInitClient();
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,_p?_p:m_Data->m_ParentList->realWidget(),0,_exp?i18n("Export"):i18n("Checkout"),_exp?i18n("Exporting"):i18n("Checking out"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         if (_exp) {
             /// @todo setup parameter for export operation
-            m_Data->m_Svnclient->doExport(svn::Path(fUrl),p,r,peg,overwrite,QString::null,ignoreExternal,depth);
+            m_Data->m_Svnclient->doExport(svn::Path(fUrl),p,r,peg,overwrite,TQString(),ignoreExternal,depth);
         } else {
             m_Data->m_Svnclient->checkout(fUrl,p,r,peg,depth,ignoreExternal,overwrite);
         }
@@ -1712,16 +1712,16 @@ bool SvnActions::makeCheckout(const QString&rUrl,const QString&tPath,const svn::
 void SvnActions::slotRevert()
 {
     if (!m_Data->m_ParentList||!m_Data->m_ParentList->isWorkingCopy()) return;
-    QPtrList<SvnItem> lst;
+    TQPtrList<SvnItem> lst;
     m_Data->m_ParentList->SelectionList(&lst);
-    QStringList displist;
+    TQStringList displist;
     SvnItemListIterator liter(lst);
     SvnItem*cur;
     if (lst.count()>0) {
         while ((cur=liter.current())!=0){
             if (!cur->isVersioned()) {
                 KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("<center>The entry<br>%1<br>is not versioned - break.</center>")
-                    .arg(cur->fullName()));
+                    .tqarg(cur->fullName()));
                 return;
             }
             displist.append(cur->fullName());
@@ -1734,7 +1734,7 @@ void SvnActions::slotRevert()
     EMIT_REFRESH;
 }
 
-void SvnActions::slotRevertItems(const QStringList&displist)
+void SvnActions::slotRevertItems(const TQStringList&displist)
 {
     if (!m_Data->m_CurrentContext) return;
     if (displist.count()==0) {
@@ -1748,21 +1748,21 @@ void SvnActions::slotRevertItems(const QStringList&displist)
         return;
     }
     ptr->setDispList(displist);
-    if (dlg->exec()!=QDialog::Accepted) {
+    if (dlg->exec()!=TQDialog::Accepted) {
         delete dlg;
         return;
     }
     depth = ptr->getDepth();
 
-    QValueList<svn::Path> items;
+    TQValueList<svn::Path> items;
     for (unsigned j = 0; j<displist.count();++j) {
         items.push_back(svn::Path((*(displist.at(j)))));
     }
-    QString ex;
+    TQString ex;
 
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Revert"),i18n("Reverting items"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         svn::Targets target(items);
         m_Data->m_Svnclient->revert(target,depth);
     } catch (const svn::Exception&e) {
@@ -1777,18 +1777,18 @@ void SvnActions::slotRevertItems(const QStringList&displist)
     EMIT_FINISHED;
 }
 
-bool SvnActions::makeSwitch(const QString&rUrl,const QString&tPath,const svn::Revision&r,svn::Depth depth,const svn::Revision&peg,bool stickydepth,bool ignore_externals,bool allow_unversioned)
+bool SvnActions::makeSwitch(const TQString&rUrl,const TQString&tPath,const svn::Revision&r,svn::Depth depth,const svn::Revision&peg,bool stickydepth,bool ignore_externals,bool allow_unversioned)
 {
     if (!m_Data->m_CurrentContext) return false;
-    QString fUrl = rUrl;
-    QString ex;
+    TQString fUrl = rUrl;
+    TQString ex;
     while (fUrl.endsWith("/")) {
         fUrl.truncate(fUrl.length()-1);
     }
     svn::Path p(tPath);
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Switch url"),i18n("Switching url"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->doSwitch(p,fUrl,r,depth,peg,stickydepth,ignore_externals,allow_unversioned);
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
@@ -1798,12 +1798,12 @@ bool SvnActions::makeSwitch(const QString&rUrl,const QString&tPath,const svn::Re
     return true;
 }
 
-bool SvnActions::makeRelocate(const QString&fUrl,const QString&tUrl,const QString&path,bool rec)
+bool SvnActions::makeRelocate(const TQString&fUrl,const TQString&tUrl,const TQString&path,bool rec)
 {
     if (!m_Data->m_CurrentContext) return false;
-    QString _f = fUrl;
-    QString _t = tUrl;
-    QString ex;
+    TQString _f = fUrl;
+    TQString _t = tUrl;
+    TQString ex;
     while (_f.endsWith("/")) {
         _f.truncate(_f.length()-1);
     }
@@ -1813,7 +1813,7 @@ bool SvnActions::makeRelocate(const QString&fUrl,const QString&tUrl,const QStrin
     svn::Path p(path);
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Relocate url"),i18n("Relocate repository to new URL"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->relocate(p,_f,_t,rec);
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
@@ -1828,7 +1828,7 @@ void SvnActions::slotSwitch()
     if (!m_Data->m_CurrentContext) return;
     if (!m_Data->m_ParentList||!m_Data->m_ParentList->isWorkingCopy()) return;
 
-    QPtrList<SvnItem> lst;
+    TQPtrList<SvnItem> lst;
     m_Data->m_ParentList->SelectionList(&lst);
 
     if (lst.count()>1) {
@@ -1842,7 +1842,7 @@ void SvnActions::slotSwitch()
         KMessageBox::error(0,i18n("Error getting entry to switch"));
         return;
     }
-    QString path,what;
+    TQString path,what;
     path = k->fullName();
     what = k->Url();
     if (makeSwitch(path,what)) {
@@ -1850,7 +1850,7 @@ void SvnActions::slotSwitch()
     }
 }
 
-bool SvnActions::makeSwitch(const QString&path,const QString&what)
+bool SvnActions::makeSwitch(const TQString&path,const TQString&what)
 {
     CheckoutInfo_impl*ptr;
     KDialogBase * dlg = createDialog(&ptr,i18n("Switch url"),true,"switch_url_dlg");
@@ -1860,7 +1860,7 @@ bool SvnActions::makeSwitch(const QString&path,const QString&what)
         ptr->disableAppend(true);
         ptr->disableTargetDir(true);
         ptr->disableOpen(true);
-        if (dlg->exec()==QDialog::Accepted) {
+        if (dlg->exec()==TQDialog::Accepted) {
             svn::Revision r = ptr->toRevision();
             done = makeSwitch(ptr->reposURL(),path,r,ptr->getDepth(),r,true,ptr->ignoreExternals(),ptr->overwrite());
         }
@@ -1870,12 +1870,12 @@ bool SvnActions::makeSwitch(const QString&path,const QString&what)
     return done;
 }
 
-bool SvnActions::makeCleanup(const QString&path)
+bool SvnActions::makeCleanup(const TQString&path)
 {
     if (!m_Data->m_CurrentContext) return false;
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Cleanup"),i18n("Cleaning up folder"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->cleanup(svn::Path(path));
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
@@ -1884,12 +1884,12 @@ bool SvnActions::makeCleanup(const QString&path)
     return true;
 }
 
-void SvnActions::slotResolved(const QString&path)
+void SvnActions::slotResolved(const TQString&path)
 {
     if (!m_Data->m_CurrentContext) return;
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Resolve"),i18n("Marking resolved"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->resolve(svn::Path(path),svn::DepthEmpty);
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
@@ -1898,11 +1898,11 @@ void SvnActions::slotResolved(const QString&path)
     m_Data->m_conflictCache.deleteKey(path,false);
 }
 
-void SvnActions::slotResolve(const QString&p)
+void SvnActions::slotResolve(const TQString&p)
 {
     if (!m_Data->m_CurrentContext) return;
-    QString eresolv = Kdesvnsettings::conflict_resolver();
-    QStringList wlist = QStringList::split(" ",eresolv);
+    TQString eresolv = Kdesvnsettings::conflict_resolver();
+    TQStringList wlist = TQStringList::split(" ",eresolv);
     if (wlist.size()==0) {
         return;
     }
@@ -1911,8 +1911,8 @@ void SvnActions::slotResolve(const QString&p)
     if (!singleInfo(p,svn::Revision::UNDEFINED,i1)) {
         return;
     }
-    QFileInfo fi(p);
-    QString base = fi.dirPath(true);
+    TQFileInfo fi(p);
+    TQString base = fi.dirPath(true);
     kdDebug()<<i1.conflictNew()<<" "
             <<i1.conflictOld()<<" "
             <<i1.conflictWrk()<<" "
@@ -1925,7 +1925,7 @@ void SvnActions::slotResolve(const QString&p)
     }
 
     KProcess*proc = new KProcess();
-    for ( QStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
+    for ( TQStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
         if (*it=="%o"||*it=="%l") {
             *proc<<(base+"/"+i1.conflictOld());
         } else if (*it=="%m" || *it=="%w") {
@@ -1938,9 +1938,9 @@ void SvnActions::slotResolve(const QString&p)
             *proc << *it;
         }
     }
-    connect(proc,SIGNAL(processExited(KProcess*)),this,SLOT(procClosed(KProcess*)));
-    connect(proc,SIGNAL(receivedStderr(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
-    connect(proc,SIGNAL(receivedStdout(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
+    connect(proc,TQT_SIGNAL(processExited(KProcess*)),this,TQT_SLOT(procClosed(KProcess*)));
+    connect(proc,TQT_SIGNAL(receivedStderr(KProcess*,char*,int)),this,TQT_SLOT(receivedStderr(KProcess*,char*,int)));
+    connect(proc,TQT_SIGNAL(receivedStdout(KProcess*,char*,int)),this,TQT_SLOT(receivedStderr(KProcess*,char*,int)));
     if (proc->start(m_Data->runblocked?KProcess::Block:KProcess::NotifyOnExit,KProcess::All)) {
         return;
     } else {
@@ -1950,13 +1950,13 @@ void SvnActions::slotResolve(const QString&p)
     return;
 }
 
-void SvnActions::slotImport(const QString&path,const QString&target,const QString&message,svn::Depth depth,
+void SvnActions::slotImport(const TQString&path,const TQString&target,const TQString&message,svn::Depth depth,
                             bool noIgnore,bool noUnknown)
 {
     if (!m_Data->m_CurrentContext) return;
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Import"),i18n("Importing items"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->import(svn::Path(path),target,message,depth,noIgnore,noUnknown);
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
@@ -1964,14 +1964,14 @@ void SvnActions::slotImport(const QString&path,const QString&target,const QStrin
     }
 }
 
-void SvnActions::slotMergeExternal(const QString&_src1,const QString&_src2, const QString&_target,
+void SvnActions::slotMergeExternal(const TQString&_src1,const TQString&_src2, const TQString&_target,
                 const svn::Revision&rev1,const svn::Revision&rev2,const svn::Revision&_peg,bool rec)
 {
     KTempDir tdir1;
     tdir1.setAutoDelete(true);
-    QString src1 = _src1;
-    QString src2 = _src2;
-    QString target = _target;
+    TQString src1 = _src1;
+    TQString src2 = _src2;
+    TQString target = _target;
     bool singleMerge = false;
 
     if (rev1 == rev2 && (src2.isEmpty() || src1==src2) ) {
@@ -1992,8 +1992,8 @@ void SvnActions::slotMergeExternal(const QString&_src1,const QString&_src2, cons
         return;
     }
 
-    QFileInfo f1(src1);
-    QFileInfo f2(src2);
+    TQFileInfo f1(src1);
+    TQFileInfo f2(src2);
     bool isDir = true;
 
     svn::InfoEntry i1,i2;
@@ -2012,16 +2012,16 @@ void SvnActions::slotMergeExternal(const QString&_src1,const QString&_src2, cons
         }
     }
 
-    QFileInfo ti(target);
+    TQFileInfo ti(target);
 
     if (ti.isDir()!=isDir) {
         emit clientException(i18n("Target for merge must same type like sources!"));
         return;
     }
 
-    QString s1 = f1.fileName()+"-"+rev1.toString();
-    QString s2 = f2.fileName()+"-"+rev2.toString();
-    QString first,second,out;
+    TQString s1 = f1.fileName()+"-"+rev1.toString();
+    TQString s2 = f2.fileName()+"-"+rev2.toString();
+    TQString first,second,out;
     if (rev1 != svn::Revision::WORKING) {
         first = tdir1.name()+"/"+s1;
     } else {
@@ -2035,7 +2035,7 @@ void SvnActions::slotMergeExternal(const QString&_src1,const QString&_src2, cons
         }
     } else {
         // only two-way  merge
-        second = QString::null;
+        second = TQString();
     }
     if (second == first) {
         KMessageBox::error(m_Data->m_ParentList->realWidget(),i18n("Both entries seems to be the same, won't do a merge."));
@@ -2074,10 +2074,10 @@ void SvnActions::slotMergeExternal(const QString&_src1,const QString&_src2, cons
             }
         }
     }
-    QString edisp = Kdesvnsettings::external_merge_program();
-    QStringList wlist = QStringList::split(" ",edisp);
+    TQString edisp = Kdesvnsettings::external_merge_program();
+    TQStringList wlist = TQStringList::split(" ",edisp);
     KProcess*proc = new KProcess();
-    for ( QStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
+    for ( TQStringList::Iterator it = wlist.begin();it!=wlist.end();++it) {
         if (*it=="%s1") {
             *proc<<first;
         } else if (*it=="%s2") {
@@ -2088,8 +2088,8 @@ void SvnActions::slotMergeExternal(const QString&_src1,const QString&_src2, cons
             *proc << *it;
         }
     }
-    connect(proc,SIGNAL(processExited(KProcess*)),this,SLOT(procClosed(KProcess*)));
-    connect(proc,SIGNAL(receivedStderr(KProcess*,char*,int)),this,SLOT(receivedStderr(KProcess*,char*,int)));
+    connect(proc,TQT_SIGNAL(processExited(KProcess*)),this,TQT_SLOT(procClosed(KProcess*)));
+    connect(proc,TQT_SIGNAL(receivedStderr(KProcess*,char*,int)),this,TQT_SLOT(receivedStderr(KProcess*,char*,int)));
     if (proc->start(m_Data->runblocked?KProcess::Block:KProcess::NotifyOnExit,KProcess::Stderr)) {
         if (!m_Data->runblocked) {
             tdir1.setAutoDelete(false);
@@ -2102,19 +2102,19 @@ void SvnActions::slotMergeExternal(const QString&_src1,const QString&_src2, cons
     delete proc;
 }
 
-void SvnActions::slotMergeWcRevisions(const QString&_entry,const svn::Revision&rev1,
+void SvnActions::slotMergeWcRevisions(const TQString&_entry,const svn::Revision&rev1,
                                        const svn::Revision&rev2,
                                        bool rec,bool ancestry,bool forceIt,bool dry)
 {
     slotMerge(_entry,_entry,_entry,rev1,rev2,svn::Revision::UNDEFINED,rec,ancestry,forceIt,dry);
 }
 
-void SvnActions::slotMerge(const QString&src1,const QString&src2, const QString&target,
+void SvnActions::slotMerge(const TQString&src1,const TQString&src2, const TQString&target,
                             const svn::Revision&rev1,const svn::Revision&rev2,const svn::Revision&_peg,
                             bool rec,bool ancestry,bool forceIt,bool dry)
 {
     if (!m_Data->m_CurrentContext) return;
-    QString s2;
+    TQString s2;
 
     svn::Revision peg = svn::Revision::HEAD;
     svn::Revision tpeg;
@@ -2147,7 +2147,7 @@ void SvnActions::slotMerge(const QString&src1,const QString&src2, const QString&
     }
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Merge"),i18n("Merging items"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         if (pegged_merge) {
             m_Data->m_Svnclient->merge_peg(p1,ranges,svn::Revision::HEAD,svn::Path(target),rec?svn::DepthUnknown:svn::DepthFiles,
                                             ancestry,dry,forceIt,false);
@@ -2163,33 +2163,33 @@ void SvnActions::slotMerge(const QString&src1,const QString&src2, const QString&
 }
 
 /*!
-    \fn SvnActions::slotCopyMove(bool,const QString&,const QString&)
+    \fn SvnActions::slotCopyMove(bool,const TQString&,const TQString&)
  */
-bool SvnActions::makeMove(const QString&Old,const QString&New,bool force)
+bool SvnActions::makeMove(const TQString&Old,const TQString&New,bool force)
 {
     if (!m_Data->m_CurrentContext) return false;
     svn::Revision nnum;
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Move"),i18n("Moving/Rename item "));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         nnum = m_Data->m_Svnclient->move(svn::Path(Old),svn::Path(New),force);
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
         return false;
     }
     if (nnum != svn::Revision::UNDEFINED) {
-        emit sendNotify(i18n("Committed revision %1.").arg(nnum.toString()));
+        emit sendNotify(i18n("Committed revision %1.").tqarg(nnum.toString()));
     }
     EMIT_REFRESH;
     return true;
 }
 
-bool SvnActions::makeMove(const KURL::List&Old,const QString&New,bool force)
+bool SvnActions::makeMove(const KURL::List&Old,const TQString&New,bool force)
 {
     svn::Revision nnum;
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Move"),i18n("Moving entries"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         KURL::List::ConstIterator it = Old.begin();
         bool local = false;
 
@@ -2211,12 +2211,12 @@ bool SvnActions::makeMove(const KURL::List&Old,const QString&New,bool force)
     return true;
 }
 
-bool SvnActions::makeCopy(const QString&Old,const QString&New,const svn::Revision&rev)
+bool SvnActions::makeCopy(const TQString&Old,const TQString&New,const svn::Revision&rev)
 {
     if (!m_Data->m_CurrentContext) return false;
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Copy / Move"),i18n("Copy or Moving entries"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         m_Data->m_Svnclient->copy(svn::Path(Old),rev,svn::Path(New));
     } catch (const svn::Exception&e) {
         emit clientException(e.msg());
@@ -2226,7 +2226,7 @@ bool SvnActions::makeCopy(const QString&Old,const QString&New,const svn::Revisio
     return true;
 }
 
-bool SvnActions::makeCopy(const KURL::List&Old,const QString&New,const svn::Revision&rev)
+bool SvnActions::makeCopy(const KURL::List&Old,const TQString&New,const svn::Revision&rev)
 {
     KURL::List::ConstIterator it = Old.begin();
     svn::Pathes p;
@@ -2241,7 +2241,7 @@ bool SvnActions::makeCopy(const KURL::List&Old,const QString&New,const svn::Revi
 
     try {
         StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Copy / Move"),i18n("Copy or Moving entries"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         KURL::List::ConstIterator it = Old.begin();
         m_Data->m_Svnclient->copy(t,rev,rev,svn::Path(New),true);
     } catch (const svn::Exception&e) {
@@ -2252,11 +2252,11 @@ bool SvnActions::makeCopy(const KURL::List&Old,const QString&New,const svn::Revi
 }
 
 /*!
-    \fn SvnActions::makeLock(const QStringList&)
+    \fn SvnActions::makeLock(const TQStringList&)
  */
-void SvnActions::makeLock(const QStringList&what,const QString&_msg,bool breakit)
+void SvnActions::makeLock(const TQStringList&what,const TQString&_msg,bool breakit)
 {
-    QValueList<svn::Path> targets;
+    TQValueList<svn::Path> targets;
     for (unsigned int i = 0; i<what.count();++i) {
         targets.push_back(svn::Path((*(what.at(i)))));
     }
@@ -2271,11 +2271,11 @@ void SvnActions::makeLock(const QStringList&what,const QString&_msg,bool breakit
 
 
 /*!
-    \fn SvnActions::makeUnlock(const QStringList&)
+    \fn SvnActions::makeUnlock(const TQStringList&)
  */
-void SvnActions::makeUnlock(const QStringList&what,bool breakit)
+void SvnActions::makeUnlock(const TQStringList&what,bool breakit)
 {
-    QValueList<svn::Path> targets;
+    TQValueList<svn::Path> targets;
     if (!m_Data->m_CurrentContext) return;
     for (unsigned int i = 0; i<what.count();++i) {
         targets.push_back(svn::Path((*(what.at(i)))));
@@ -2295,22 +2295,22 @@ void SvnActions::makeUnlock(const QStringList&what,bool breakit)
 
 
 /*!
-    \fn SvnActions::makeStatus(const QString&what, svn::StatusEntries&dlist)
+    \fn SvnActions::maketqStatus(const TQString&what, svn::StatusEntries&dlist)
  */
-bool SvnActions::makeStatus(const QString&what, svn::StatusEntries&dlist, svn::Revision&where,bool rec,bool all)
+bool SvnActions::maketqStatus(const TQString&what, svn::StatusEntries&dlist, svn::Revision&where,bool rec,bool all)
 {
     bool display_ignores = Kdesvnsettings::display_ignored_files();
-    return makeStatus(what,dlist,where,rec,all,display_ignores);
+    return maketqStatus(what,dlist,where,rec,all,display_ignores);
 }
 
-bool SvnActions::makeStatus(const QString&what, svn::StatusEntries&dlist, svn::Revision&where,bool rec,bool all,bool display_ignores,bool updates)
+bool SvnActions::maketqStatus(const TQString&what, svn::StatusEntries&dlist, svn::Revision&where,bool rec,bool all,bool display_ignores,bool updates)
 {
     bool disp_remote_details = Kdesvnsettings::details_on_remote_listing();
-    QString ex;
+    TQString ex;
     svn::Depth _d=rec?svn::DepthInfinity:svn::DepthImmediates;
     try {
-        StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("Status / List"),i18n("Creating list / check status"));
-        connect(this,SIGNAL(sigExtraLogMsg(const QString&)),&sdlg,SLOT(slotExtraMessage(const QString&)));
+        StopDlg sdlg(m_Data->m_SvnContextListener,m_Data->m_ParentList->realWidget(),0,i18n("tqStatus / List"),i18n("Creating list / check status"));
+        connect(this,TQT_SIGNAL(sigExtraLogMsg(const TQString&)),&sdlg,TQT_SLOT(slotExtraMessage(const TQString&)));
         //                                      rec all  up     noign
         dlist = m_Data->m_Svnclient->status(what,_d,all,updates,display_ignores,where,disp_remote_details,false);
     } catch (const svn::Exception&e) {
@@ -2320,13 +2320,13 @@ bool SvnActions::makeStatus(const QString&what, svn::StatusEntries&dlist, svn::R
     return true;
 }
 
-void SvnActions::checkAddItems(const QString&path,bool print_error_box)
+void SvnActions::checkAddItems(const TQString&path,bool print_error_box)
 {
     svn::StatusEntries dlist;
     svn::StatusEntries rlist;
-    QStringList displist;
+    TQStringList displist;
     svn::Revision where = svn::Revision::HEAD;
-    if (!makeStatus(path,dlist,where,true,true,false,false)) {
+    if (!maketqStatus(path,dlist,where,true,true,false,false)) {
         return;
     }
     for (unsigned int i = 0; i<dlist.size();++i) {
@@ -2342,14 +2342,14 @@ void SvnActions::checkAddItems(const QString&path,bool print_error_box)
         KDialogBase * dlg = createDialog(&ptr,i18n("Add unversioned items"),true,"add_items_dlg");
         ptr->addColumn("Item");
         for (unsigned j = 0; j<displist.size();++j) {
-            QCheckListItem * n = new QCheckListItem(ptr,displist[j],QCheckListItem::CheckBox);
+            TQCheckListItem * n = new TQCheckListItem(ptr,displist[j],TQCheckListItem::CheckBox);
             n->setOn(true);
         }
-        if (dlg->exec()==QDialog::Accepted) {
-            QListViewItemIterator it(ptr);
+        if (dlg->exec()==TQDialog::Accepted) {
+            TQListViewItemIterator it(ptr);
             displist.clear();
             while(it.current()) {
-                QCheckListItem*t = (QCheckListItem*)it.current();
+                TQCheckListItem*t = (TQCheckListItem*)it.current();
                 if (t->isOn()) {
                     displist.append(t->text());
                 }
@@ -2402,7 +2402,7 @@ void SvnActions::stopFillCache()
         }
         delete m_FCThread;
         m_FCThread = 0;
-        emit sigCacheStatus(-1,-1);
+        emit sigCachetqStatus(-1,-1);
     }
 }
 
@@ -2423,7 +2423,7 @@ void SvnActions::killallThreads()
     stopFillCache();
 }
 
-bool SvnActions::createModifiedCache(const QString&what)
+bool SvnActions::createModifiedCache(const TQString&what)
 {
     stopCheckModThread();
     m_Data->m_Cache.clear();
@@ -2446,14 +2446,14 @@ void SvnActions::checkModthread()
     for (unsigned int i = 0; i < m_CThread->getList().count();++i) {
         svn::StatusPtr ptr = m_CThread->getList()[i];
         if (m_CThread->getList()[i]->isRealVersioned()&& (
-            m_CThread->getList()[i]->textStatus()==svn_wc_status_modified||
-            m_CThread->getList()[i]->textStatus()==svn_wc_status_added||
-            m_CThread->getList()[i]->textStatus()==svn_wc_status_deleted||
-            m_CThread->getList()[i]->textStatus()==svn_wc_status_replaced||
-            m_CThread->getList()[i]->propStatus()==svn_wc_status_modified
+            m_CThread->getList()[i]->texttqStatus()==svn_wc_status_modified||
+            m_CThread->getList()[i]->texttqStatus()==svn_wc_status_added||
+            m_CThread->getList()[i]->texttqStatus()==svn_wc_status_deleted||
+            m_CThread->getList()[i]->texttqStatus()==svn_wc_status_replaced||
+            m_CThread->getList()[i]->proptqStatus()==svn_wc_status_modified
          ) ) {
             m_Data->m_Cache.insertKey(ptr,ptr->path());
-        } else if (m_CThread->getList()[i]->textStatus()==svn_wc_status_conflicted) {
+        } else if (m_CThread->getList()[i]->texttqStatus()==svn_wc_status_conflicted) {
             m_Data->m_conflictCache.insertKey(ptr,ptr->path());
         }
     }
@@ -2478,11 +2478,11 @@ void SvnActions::checkUpdateThread()
     bool newer=false;
     for (unsigned int i = 0; i < m_UThread->getList().count();++i) {
         svn::StatusPtr ptr = m_UThread->getList()[i];
-        if (ptr->validReposStatus()) {
+        if (ptr->validRepostqStatus()) {
             m_Data->m_UpdateCache.insertKey(ptr,ptr->path());
-            ptr->textStatus();
-            ptr->propStatus();
-            if (!(ptr->validLocalStatus())) {
+            ptr->texttqStatus();
+            ptr->proptqStatus();
+            if (!(ptr->validLocaltqStatus())) {
                 newer = true;
             }
         }
@@ -2500,7 +2500,7 @@ void SvnActions::checkUpdateThread()
     m_UThread = 0;
 }
 
-void SvnActions::getaddedItems(const QString&path,svn::StatusEntries&target)
+void SvnActions::getaddedItems(const TQString&path,svn::StatusEntries&target)
 {
     helpers::ValidRemoteOnly vro;
     m_Data->m_UpdateCache.listsubs_if(path,vro);
@@ -2514,7 +2514,7 @@ bool SvnActions::checkUpdatesRunning()
 
 void SvnActions::addModifiedCache(const svn::StatusPtr&what)
 {
-    if (what->textStatus()==svn_wc_status_conflicted) {
+    if (what->texttqStatus()==svn_wc_status_conflicted) {
         m_Data->m_conflictCache.insertKey(what,what->path());
     } else {
         m_Data->m_Cache.insertKey(what,what->path());
@@ -2522,35 +2522,35 @@ void SvnActions::addModifiedCache(const svn::StatusPtr&what)
     }
 }
 
-void SvnActions::deleteFromModifiedCache(const QString&what)
+void SvnActions::deleteFromModifiedCache(const TQString&what)
 {
     m_Data->m_Cache.deleteKey(what,true);
     m_Data->m_conflictCache.deleteKey(what,true);
     //m_Data->m_Cache.dump_tree();
 }
 
-bool SvnActions::checkModifiedCache(const QString&path)
+bool SvnActions::checkModifiedCache(const TQString&path)
 {
     return m_Data->m_Cache.find(path);
 }
 
-bool SvnActions::checkReposLockCache(const QString&path)
+bool SvnActions::checkReposLockCache(const TQString&path)
 {
     return m_Data->m_repoLockCache.findSingleValid(path,false);
 }
 
-bool SvnActions::checkReposLockCache(const QString&path,svn::SharedPointer<svn::Status>&t)
+bool SvnActions::checkReposLockCache(const TQString&path,svn::SharedPointer<svn::tqStatus>&t)
 {
-    /// @todo create a method where svn::Status* will be a parameter so no copy is needed but just reading content
+    /// @todo create a method where svn::tqStatus* will be a parameter so no copy is needed but just reading content
     return m_Data->m_repoLockCache.findSingleValid(path,t);
 }
 
-bool SvnActions::checkConflictedCache(const QString&path)
+bool SvnActions::checkConflictedCache(const TQString&path)
 {
     return m_Data->m_conflictCache.find(path);
 }
 
-void SvnActions::startFillCache(const QString&path)
+void SvnActions::startFillCache(const TQString&path)
 {
     stopFillCache();
     svn::InfoEntry e;
@@ -2590,7 +2590,7 @@ bool SvnActions::doNetworking()
     return !is_url;
 }
 
-void SvnActions::customEvent(QCustomEvent * e)
+void SvnActions::customEvent(TQCustomEvent * e)
 {
     if (e->type()==EVENT_LOGCACHE_FINISHED) {
         emit sendNotify(i18n("Filling log cache in background finished."));
@@ -2599,14 +2599,14 @@ void SvnActions::customEvent(QCustomEvent * e)
         return;
     } else if (e&&e->type()==EVENT_LOGCACHE_STATUS && m_FCThread && m_FCThread->running()) {
         FillCacheStatusEvent*fev=(FillCacheStatusEvent*)e;
-        emit sigCacheStatus(fev->current(),fev->max());
+        emit sigCachetqStatus(fev->current(),fev->max());
     }
 }
 
 /*!
-    \fn SvnActions::createUpdateCache(const QString&what)
+    \fn SvnActions::createUpdateCache(const TQString&what)
  */
-bool SvnActions::createUpdateCache(const QString&what)
+bool SvnActions::createUpdateCache(const TQString&what)
 {
     clearUpdateCache();
     m_Data->m_repoLockCache.clear();
@@ -2624,25 +2624,25 @@ bool SvnActions::createUpdateCache(const QString&what)
     return true;
 }
 
-bool SvnActions::checkUpdateCache(const QString&path)const
+bool SvnActions::checkUpdateCache(const TQString&path)const
 {
     return m_Data->m_UpdateCache.find(path);
 }
 
-void SvnActions::removeFromUpdateCache(const QStringList&what,bool exact_only)
+void SvnActions::removeFromUpdateCache(const TQStringList&what,bool exact_only)
 {
     for (unsigned int i = 0; i < what.count(); ++i) {
         m_Data->m_UpdateCache.deleteKey(what[i],exact_only);
     }
 }
 
-bool SvnActions::isUpdated(const QString&path)const
+bool SvnActions::isUpdated(const TQString&path)const
 {
-    svn::SharedPointer<svn::Status> d;
+    svn::SharedPointer<svn::tqStatus> d;
     return m_Data->m_UpdateCache.findSingleValid(path,d);
 }
 
-bool SvnActions::getUpdated(const QString&path,svn::SharedPointer<svn::Status>&d)const
+bool SvnActions::getUpdated(const TQString&path,svn::SharedPointer<svn::tqStatus>&d)const
 {
     return m_Data->m_UpdateCache.findSingleValid(path,d);
 }
@@ -2653,19 +2653,19 @@ void SvnActions::clearUpdateCache()
 }
 
 /*!
-    \fn SvnActions::makeIgnoreEntry(const QString&which)
+    \fn SvnActions::makeIgnoreEntry(const TQString&which)
  */
 bool SvnActions::makeIgnoreEntry(SvnItem*which,bool unignore)
 {
     if (!which) return false;
-    QString parentName = which->getParentDir();
-    if (parentName.isEmpty()) return false;
-    QString name = which->shortName();
-    QString ex;
-    svn::Path p(parentName);
+    TQString tqparentName = which->getParentDir();
+    if (tqparentName.isEmpty()) return false;
+    TQString name = which->shortName();
+    TQString ex;
+    svn::Path p(tqparentName);
     svn::Revision r(svn_opt_revision_unspecified);
 
-    QPair<QLONG,svn::PathPropertiesMapList> pmp;
+    TQPair<TQLONG,svn::PathPropertiesMapList> pmp;
     try {
         pmp = m_Data->m_Svnclient->propget("svn:ignore",p,r,r);
     } catch (const svn::Exception&e) {
@@ -2673,14 +2673,14 @@ bool SvnActions::makeIgnoreEntry(SvnItem*which,bool unignore)
         return false;
     }
     svn::PathPropertiesMapList pm = pmp.second;
-    QString data = "";
+    TQString data = "";
     if (pm.size()>0) {
         svn::PropertiesMap&mp = pm[0].second;
         data = mp["svn:ignore"];
     }
     bool result = false;
-    QStringList lst = QStringList::split("\n",data);
-    QStringList::iterator it = lst.find(name);
+    TQStringList lst = TQStringList::split("\n",data);
+    TQStringList::iterator it = lst.tqfind(name);
     if (it != lst.end()) {
         if (unignore) {
             lst.erase(it);
@@ -2704,12 +2704,12 @@ bool SvnActions::makeIgnoreEntry(SvnItem*which,bool unignore)
     return result;
 }
 
-svn::PathPropertiesMapListPtr SvnActions::propList(const QString&which,const svn::Revision&where,bool cacheOnly)
+svn::PathPropertiesMapListPtr SvnActions::propList(const TQString&which,const svn::Revision&where,bool cacheOnly)
 {
     svn::PathPropertiesMapListPtr pm;
     if (!which.isEmpty()) {
-        QString fk=where.toString()+"/"+which;
-        QString ex;
+        TQString fk=where.toString()+"/"+which;
+        TQString ex;
         svn::Path p(which);
 
         if (where != svn::Revision::WORKING)
@@ -2738,10 +2738,10 @@ svn::PathPropertiesMapListPtr SvnActions::propList(const QString&which,const svn
 bool SvnActions::isLockNeeded(SvnItem*which,const svn::Revision&where)
 {
     if (!which) return false;
-    QString ex;
+    TQString ex;
     svn::Path p(which->fullName());
 
-    QPair<QLONG,svn::PathPropertiesMapList> pmp;
+    TQPair<TQLONG,svn::PathPropertiesMapList> pmp;
     try {
         pmp = m_Data->m_Svnclient->propget("svn:needs-lock",p,where,where);
     } catch (const svn::Exception&e) {
@@ -2752,30 +2752,30 @@ bool SvnActions::isLockNeeded(SvnItem*which,const svn::Revision&where)
     svn::PathPropertiesMapList pm = pmp.second;
     if (pm.size()>0) {
         svn::PropertiesMap&mp = pm[0].second;
-        if (mp.find("svn:needs-lock")!=mp.end()) {
+        if (mp.tqfind("svn:needs-lock")!=mp.end()) {
             return true;
         }
     }
     return false;
 }
 
-QString SvnActions::searchProperty(QString&Store, const QString&property, const QString&start,const svn::Revision&where,bool up)
+TQString SvnActions::searchProperty(TQString&Store, const TQString&property, const TQString&start,const svn::Revision&where,bool up)
 {
     svn::Path pa(start);
     kdDebug()<<"Url? "<<pa.isUrl()<<endl;
     svn::InfoEntry inf;
 
     if (!singleInfo(start,where,inf)) {
-        return QString::null;
+        return TQString();
     }
     while(pa.length()>0) {
         svn::PathPropertiesMapListPtr pm = propList(pa,where,false);
         if (!pm) {
-            return QString::null;
+            return TQString();
         }
         if (pm->size()>0) {
             svn::PropertiesMap&mp = (*pm)[0].second;
-            if (mp.find(property)!=mp.end()) {
+            if (mp.tqfind(property)!=mp.end()) {
                 Store=mp[property];
                 return pa;
             }
@@ -2792,13 +2792,13 @@ QString SvnActions::searchProperty(QString&Store, const QString&property, const
             break;
         }
     }
-    return QString::null;
+    return TQString();
 }
 
-bool SvnActions::makeList(const QString&url,svn::DirEntries&dlist,svn::Revision&where,bool rec)
+bool SvnActions::makeList(const TQString&url,svn::DirEntries&dlist,svn::Revision&where,bool rec)
 {
     if (!m_Data->m_CurrentContext) return false;
-    QString ex;
+    TQString ex;
     try {
         dlist = m_Data->m_Svnclient->list(url,where,where,rec?svn::DepthInfinity:svn::DepthEmpty,false);
     } catch (const svn::Exception&e) {
@@ -2811,10 +2811,10 @@ bool SvnActions::makeList(const QString&url,svn::DirEntries&dlist,svn::Revision&
 /*!
     \fn SvnActions::isLocalWorkingCopy(const KURL&url)
  */
-bool SvnActions::isLocalWorkingCopy(const KURL&url,QString&_baseUri)
+bool SvnActions::isLocalWorkingCopy(const KURL&url,TQString&_baseUri)
 {
     if (url.isEmpty()||!url.isLocalFile()) return false;
-    QString cleanpath = url.path();
+    TQString cleanpath = url.path();
     while (cleanpath.endsWith("/")) {
         cleanpath.truncate(cleanpath.length()-1);
     }
@@ -2836,7 +2836,7 @@ bool SvnActions::isLocalWorkingCopy(const KURL&url,QString&_baseUri)
     return true;
 }
 
-void SvnActions::slotExtraLogMsg(const QString&msg)
+void SvnActions::slotExtraLogMsg(const TQString&msg)
 {
     emit sigExtraLogMsg(msg);
 }
@@ -2847,10 +2847,10 @@ void SvnActions::slotCancel(bool how)
     m_Data->m_SvnContextListener->setCanceled(how);
 }
 
-void SvnActions::setContextData(const QString&aKey,const QString&aValue)
+void SvnActions::setContextData(const TQString&aKey,const TQString&aValue)
 {
     if (aValue.isNull()) {
-        QMap<QString,QString>::iterator it = m_Data->m_contextData.find(aKey);
+        TQMap<TQString,TQString>::iterator it = m_Data->m_contextData.tqfind(aKey);
         if (it!=m_Data->m_contextData.end()) {
             m_Data->m_contextData.remove(it);
         }
@@ -2864,12 +2864,12 @@ void SvnActions::clearContextData()
     m_Data->m_contextData.clear();
 }
 
-QString SvnActions::getContextData(const QString&aKey)const
+TQString SvnActions::getContextData(const TQString&aKey)const
 {
-    if (m_Data->m_contextData.find(aKey)!=m_Data->m_contextData.end()) {
+    if (m_Data->m_contextData.tqfind(aKey)!=m_Data->m_contextData.end()) {
         return m_Data->m_contextData[aKey];
     }
-    return QString::null;
+    return TQString();
 }
 
 bool SvnActions::threadRunning(ThreadType which)