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, 47 insertions, 47 deletions

diff --git a/src/svnfrontend/graphtree/revisiontree.cpp b/src/svnfrontend/graphtree/revisiontree.cpp
index bb64cf7..a334a0c 100644
--- a/src/svnfrontend/graphtree/revisiontree.cpp
+++ b/src/svnfrontend/graphtree/revisiontree.cpp
@@ -38,12 +38,12 @@
 #include <kmdcodec.h>
 #include <kmessagebox.h>
 
-#include <qwidget.h>
-#include <qdatetime.h>
-#include <qlabel.h>
-#include <qfile.h>
-#include <qtextstream.h>
-#include <qregexp.h>
+#include <tqwidget.h>
+#include <tqdatetime.h>
+#include <tqlabel.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+#include <tqregexp.h>
 
 #define INTERNALCOPY 1
 #define INTERNALRENAME 2
@@ -54,21 +54,21 @@ public:
     RtreeData();
     virtual ~RtreeData();
 
-    QMap<long,eLog_Entry> m_History;
+    TQMap<long,eLog_Entry> m_History;
 
     svn::LogEntriesMap m_OldHistory;
 
     long max_rev,min_rev;
     KProgressDialog*progress;
-    QTime m_stopTick;
+    TQTime m_stopTick;
 
-    QWidget*dlgParent;
+    TQWidget*dlgParent;
     RevTreeWidget*m_TreeDisplay;
 
     svn::Client*m_Client;
-    QObject* m_Listener;
+    TQObject* m_Listener;
 
-    bool getLogs(const QString&,const svn::Revision&startr,const svn::Revision&endr,const QString&origin);
+    bool getLogs(const TQString&,const svn::Revision&startr,const svn::Revision&endr,const TQString&origin);
 };
 
 RtreeData::RtreeData()
@@ -86,13 +86,13 @@ RtreeData::~RtreeData()
     delete progress;
 }
 
-bool RtreeData::getLogs(const QString&reposRoot,const svn::Revision&startr,const svn::Revision&endr,const QString&origin)
+bool RtreeData::getLogs(const TQString&reposRoot,const svn::Revision&startr,const svn::Revision&endr,const TQString&origin)
 {
     if (!m_Listener||!m_Client) {
         return false;
     }
     try {
-        CursorStack a(Qt::BusyCursor);
+        CursorStack a(TQt::BusyCursor);
         StopDlg sdlg(m_Listener,dlgParent,
                      0,"Logs",i18n("Getting logs - hit cancel for abort"));
         if (svn::Url::isLocal(reposRoot) ) {
@@ -104,31 +104,31 @@ bool RtreeData::getLogs(const QString&reposRoot,const svn::Revision&startr,const
             } else if (Kdesvnsettings::network_on()) {
                 m_Client->log(reposRoot,endr,startr,m_OldHistory,startr,true,false,0);
             } else {
-                KMessageBox::error(0,i18n("Could not retrieve logs, reason:\n%1").arg(i18n("No logcache possible due broken database and networking not allowed.")));
+                KMessageBox::error(0,i18n("Could not retrieve logs, reason:\n%1").tqarg(i18n("No logcache possible due broken database and networking not allowed.")));
                 return false;
             }
         }
     } catch (const svn::Exception&ce) {
         kdDebug()<<ce.msg() << endl;
-        KMessageBox::error(0,i18n("Could not retrieve logs, reason:\n%1").arg(ce.msg()));
+        KMessageBox::error(0,i18n("Could not retrieve logs, reason:\n%1").tqarg(ce.msg()));
         return false;
     }
     return true;
 }
 
 RevisionTree::RevisionTree(svn::Client*aClient,
-    QObject*aListener,
-    const QString& reposRoot,
+    TQObject*aListener,
+    const TQString& reposRoot,
     const svn::Revision&startr,const svn::Revision&endr,
-    const QString&origin,
+    const TQString&origin,
     const svn::Revision& baserevision,
-    QWidget*treeParent,QWidget*parent)
+    TQWidget*treeParent,TQWidget*tqparent)
     :m_InitialRevsion(0),m_Path(origin),m_Valid(false)
 {
     m_Data = new RtreeData;
     m_Data->m_Client=aClient;
     m_Data->m_Listener=aListener;
-    m_Data->dlgParent=parent;
+    m_Data->dlgParent=tqparent;
 
     if (!m_Data->getLogs(reposRoot,startr,endr,origin)) {
         return;
@@ -138,7 +138,7 @@ RevisionTree::RevisionTree(svn::Client*aClient,
     kdDebug()<<"Origin: "<<origin << endl;
 
     m_Data->progress=new KProgressDialog(
-        parent,"progressdlg",i18n("Scanning logs"),i18n("Scanning the logs for %1").arg(origin),true);
+        tqparent,"progressdlg",i18n("Scanning logs"),i18n("Scanning the logs for %1").tqarg(origin),true);
     m_Data->progress->setMinimumDuration(100);
     m_Data->progress->show();
     m_Data->progress->setAllowCancel(true);
@@ -206,7 +206,7 @@ RevisionTree::~RevisionTree()
     delete m_Data;
 }
 
-bool RevisionTree::isDeleted(long revision,const QString&path)
+bool RevisionTree::isDeleted(long revision,const TQString&path)
 {
     for (unsigned i = 0;i<m_Data->m_History[revision].changedPaths.count();++i) {
         if (isParent(m_Data->m_History[revision].changedPaths[i].path,path) &&
@@ -221,8 +221,8 @@ bool RevisionTree::topDownScan()
 {
     m_Data->progress->progressBar()->setTotalSteps(m_Data->max_rev-m_Data->min_rev);
     bool cancel=false;
-    QString label;
-    QString olabel = m_Data->progress->labelText();
+    TQString label;
+    TQString olabel = m_Data->progress->labelText();
     for (long j=m_Data->max_rev;j>=m_Data->min_rev;--j) {
         m_Data->progress->progressBar()->setProgress(m_Data->max_rev-j);
         kapp->processEvents();
@@ -237,7 +237,7 @@ bool RevisionTree::topDownScan()
                     break;
                 }
                 label = i18n("%1<br>Check change entry %2 of %3")
-                        .arg(olabel).arg(i).arg(m_Data->m_OldHistory[j].changedPaths.count());
+                        .tqarg(olabel).tqarg(i).tqarg(m_Data->m_OldHistory[j].changedPaths.count());
                 m_Data->progress->setLabel(label);
                 kapp->processEvents();
             }
@@ -247,8 +247,8 @@ bool RevisionTree::topDownScan()
             {
                 if (!m_Data->m_OldHistory[j].changedPaths[i].copyFromPath.isEmpty()) {
                     if (m_InitialRevsion<m_Data->m_OldHistory[j].revision) {
-                        QString tmpPath = m_Path;
-                        QString r = m_Path.mid(m_Data->m_OldHistory[j].changedPaths[i].path.length());
+                        TQString tmpPath = m_Path;
+                        TQString r = m_Path.mid(m_Data->m_OldHistory[j].changedPaths[i].path.length());
                         m_Path=m_Data->m_OldHistory[j].changedPaths[i].copyFromPath;
                         m_Path+=r;
                     }
@@ -278,13 +278,13 @@ bool RevisionTree::topDownScan()
                     cancel=true;
                     break;
                 }
-                label = i18n("%1<br>Check change entry %2 of %3").arg(olabel).arg(i).arg(m_Data->m_OldHistory[j].changedPaths.count());
+                label = i18n("%1<br>Check change entry %2 of %3").tqarg(olabel).tqarg(i).tqarg(m_Data->m_OldHistory[j].changedPaths.count());
                 m_Data->progress->setLabel(label);
                 kapp->processEvents();
             }
             if (!m_Data->m_OldHistory[j].changedPaths[i].copyFromPath.isEmpty()) {
                 long r = m_Data->m_OldHistory[j].changedPaths[i].copyFromRevision;
-                QString sourcepath = m_Data->m_OldHistory[j].changedPaths[i].copyFromPath;
+                TQString sourcepath = m_Data->m_OldHistory[j].changedPaths[i].copyFromPath;
                 char a = m_Data->m_OldHistory[j].changedPaths[i].action;
                 if (m_Data->m_OldHistory[j].changedPaths[i].path.isEmpty()) {
                     kdDebug()<<"Empty entry! rev " << j << " source " << sourcepath << endl;
@@ -331,11 +331,11 @@ bool RevisionTree::topDownScan()
                     cancel=true;
                     break;
                 }
-                label = i18n("%1<br>Check change entry %2 of %3").arg(olabel).arg(i).arg(m_Data->m_OldHistory[j].changedPaths.count());
+                label = i18n("%1<br>Check change entry %2 of %3").tqarg(olabel).tqarg(i).tqarg(m_Data->m_OldHistory[j].changedPaths.count());
                 m_Data->progress->setLabel(label);
                 kapp->processEvents();
             }
-            m_Data->m_History[j].addCopyTo(m_Data->m_OldHistory[j].changedPaths[i].path,QString::null,-1,m_Data->m_OldHistory[j].changedPaths[i].action);
+            m_Data->m_History[j].addCopyTo(m_Data->m_OldHistory[j].changedPaths[i].path,TQString(),-1,m_Data->m_OldHistory[j].changedPaths[i].action);
         }
         m_Data->m_History[j].author=m_Data->m_OldHistory[j].author;
         m_Data->m_History[j].date=m_Data->m_OldHistory[j].date;
@@ -346,10 +346,10 @@ bool RevisionTree::topDownScan()
     return !cancel;
 }
 
-bool RevisionTree::isParent(const QString&_par,const QString&tar)
+bool RevisionTree::isParent(const TQString&_par,const TQString&tar)
 {
     if (_par==tar) return true;
-    QString par = _par+(_par.endsWith("/")?"":"/");
+    TQString par = _par+(_par.endsWith("/")?"":"/");
     return tar.startsWith(par);
 }
 
@@ -358,22 +358,22 @@ bool RevisionTree::isValid()const
     return m_Valid;
 }
 
-static QString uniqueNodeName(long rev,const QString&path)
+static TQString uniqueNodeName(long rev,const TQString&path)
 {
-    QString res = KCodecs::base64Encode(path.local8Bit(),false);
-    res.replace("\"","_quot_");
-    res.replace(" ","_space_");
-    QString n; n.sprintf("%05ld",rev);
-    res = "\""+n+QString("_%1\"").arg(res);
+    TQString res = KCodecs::base64Encode(path.local8Bit(),false);
+    res.tqreplace("\"","_quot_");
+    res.tqreplace(" ","_space_");
+    TQString n; n.sprintf("%05ld",rev);
+    res = "\""+n+TQString("_%1\"").tqarg(res);
     return res;
 }
 
-bool RevisionTree::bottomUpScan(long startrev,unsigned recurse,const QString&_path,long _last)
+bool RevisionTree::bottomUpScan(long startrev,unsigned recurse,const TQString&_path,long _last)
 {
 #define REVENTRY m_Data->m_History[j]
 #define FORWARDENTRY m_Data->m_History[j].changedPaths[i]
 
-    QString path = _path;
+    TQString path = _path;
     long lastrev = _last;
     /* this is required if an item will modified AND copied at same revision.*/
     long trev = -1;
@@ -396,7 +396,7 @@ bool RevisionTree::bottomUpScan(long startrev,unsigned recurse,const QString&_pa
             if (!isParent(FORWARDENTRY.path,path)) {
                 continue;
             }
-            QString n1,n2;
+            TQString n1,n2;
             if (isParent(FORWARDENTRY.path,path)) {
                 bool get_out = false;
                 if (FORWARDENTRY.path!=path) {
@@ -407,12 +407,12 @@ bool RevisionTree::bottomUpScan(long startrev,unsigned recurse,const QString&_pa
                 if (FORWARDENTRY.action==INTERNALCOPY ||
                     FORWARDENTRY.action==INTERNALRENAME ) {
                     bool ren = FORWARDENTRY.action==INTERNALRENAME;
-                    QString tmpPath = path;
-                    QString recPath;
+                    TQString tmpPath = path;
+                    TQString recPath;
                     if (FORWARDENTRY.copyToPath.length()==0) {
                         continue;
                     }
-                    QString r = path.mid(FORWARDENTRY.path.length());
+                    TQString r = path.mid(FORWARDENTRY.path.length());
                     recPath= FORWARDENTRY.copyToPath;
                     recPath+=r;
                     n1 = uniqueNodeName(lastrev,tmpPath);
@@ -521,12 +521,12 @@ bool RevisionTree::bottomUpScan(long startrev,unsigned recurse,const QString&_pa
     return !cancel;
 }
 
-QWidget*RevisionTree::getView()
+TQWidget*RevisionTree::getView()
 {
     return m_Data->m_TreeDisplay;
 }
 
-void RevisionTree::fillItem(long rev,int pathIndex,const QString&nodeName,const QString&path)
+void RevisionTree::fillItem(long rev,int pathIndex,const TQString&nodeName,const TQString&path)
 {
     m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].name=path;
     m_Data->m_TreeDisplay->m_RevGraphView->m_Tree[nodeName].rev = rev;