TQt4 port piklab

This enables compilation under both Qt3 and Qt4


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

1 files changed, 95 insertions, 103 deletions

diff --git a/src/common/global/purl.cpp b/src/common/global/purl.cpp
index 6db2914..aeae543 100644
--- a/src/common/global/purl.cpp
+++ b/src/common/global/purl.cpp
@@ -8,14 +8,12 @@
  ***************************************************************************/
 #include "purl.h"
 
-#include <qfileinfo.h>
-#include <qdatetime.h>
-#include <qdir.h>
-#include <qregexp.h>
-#include <qmap.h>
-#if QT_VERSION<0x040000
-#  include <qnetwork.h>
-#endif
+#include <tqfileinfo.h>
+#include <tqdatetime.h>
+#include <tqdir.h>
+#include <tqregexp.h>
+#include <tqmap.h>
+#  include <tqnetwork.h>
 
 #include "common/common/synchronous.h"
 #include "process.h"
@@ -27,38 +25,38 @@
 #endif
 
 //-----------------------------------------------------------------------------
-PURL::Http::Http(const QString &hostname)
-  : QHttp(hostname)
+PURL::Http::Http(const TQString &hostname)
+  : TQHttp(hostname)
 {
-  connect(this, SIGNAL(responseHeaderReceived(const QHttpResponseHeader &)),
-          SLOT(responseHeaderReceivedSlot(const QHttpResponseHeader &)));
+  connect(this, TQT_SIGNAL(responseHeaderReceived(const TQHttpResponseHeader &)),
+          TQT_SLOT(responseHeaderReceivedSlot(const TQHttpResponseHeader &)));
 }
 
 //-----------------------------------------------------------------------------
 class PURL::Private
 {
 public:
-  QString convertWindowsFilepath(const QString &filepath);
+  TQString convertWindowsFilepath(const TQString &filepath);
 
 private:
-  QMap<char, QString>    _winDrives;  // drive -> unix path
-  QMap<QString, QString> _winPaths;   // windows path -> unix path
-
-  QString getWindowsDrivePath(char drive);
-  bool checkCachedPath(QString &filepath) const;
-  QString cachePath(const QString &origin, const QString &filepath);
-  QString convertWindowsShortFilepath(const QString &filepath);
-  QString findName(const QString &path, const QString &name);
-  static QString findName(const QString &filepath);
+  TQMap<char, TQString>    _winDrives;  // drive -> unix path
+  TQMap<TQString, TQString> _winPaths;   // windows path -> unix path
+
+  TQString getWindowsDrivePath(char drive);
+  bool checkCachedPath(TQString &filepath) const;
+  TQString cachePath(const TQString &origin, const TQString &filepath);
+  TQString convertWindowsShortFilepath(const TQString &filepath);
+  TQString findName(const TQString &path, const TQString &name);
+  static TQString findName(const TQString &filepath);
 };
 
-QString PURL::Private::getWindowsDrivePath(char drive)
+TQString PURL::Private::getWindowsDrivePath(char drive)
 {
 #if defined(Q_OS_UNIX)
-  if ( !_winDrives.contains(drive) ) {
-    QStringList args;
+  if ( !_winDrives.tqcontains(drive) ) {
+    TQStringList args;
     args += "-u";
-    QString s;
+    TQString s;
     s += drive;
     args += s + ":\\";
     ::Process::StringOutput process;
@@ -66,71 +64,67 @@ QString PURL::Private::getWindowsDrivePath(char drive)
     ::Process::State state = ::Process::runSynchronously(process, ::Process::Start, 3000);
     if ( state!=::Process::Exited ) qWarning("Error running \"winepath\" with \"%s\" (%i)", args.join(" ").latin1(), state);
     s = process.sout() + process.serr();
-    QDir dir(s.stripWhiteSpace());
+    TQDir dir(s.stripWhiteSpace());
     _winDrives[drive] = dir.canonicalPath();
   }
   return _winDrives[drive];
 #else
-  return QString("%1:\\").arg(drive);
+  return TQString("%1:\\").tqarg(drive);
 #endif
 }
 
-bool PURL::Private::checkCachedPath(QString &filepath) const
+bool PURL::Private::checkCachedPath(TQString &filepath) const
 {
-  if ( !_winPaths.contains(filepath) ) return false;
+  if ( !_winPaths.tqcontains(filepath) ) return false;
   filepath = _winPaths[filepath];
   return true;
 }
 
-QString PURL::Private::cachePath(const QString &origin, const QString &filepath)
+TQString PURL::Private::cachePath(const TQString &origin, const TQString &filepath)
 {
   _winPaths[origin] = filepath;
   return filepath;
 }
 
-QString PURL::Private::convertWindowsFilepath(const QString &filepath)
+TQString PURL::Private::convertWindowsFilepath(const TQString &filepath)
 {
   // appears to be an absolute windows path
   if ( filepath[0]=='\\' ) {
-    QString tmp = filepath;
+    TQString tmp = filepath;
     if ( checkCachedPath(tmp) ) return tmp;
-    return cachePath(filepath, convertWindowsShortFilepath(tmp.replace('\\', "/")));
+    return cachePath(filepath, convertWindowsShortFilepath(tmp.tqreplace('\\', "/")));
   }
   // appears to be a windows path with a drive
   if ( (filepath.length()>=2 && filepath[0].isLetter() && filepath[1]==':') ) {
-    QString tmp = filepath;
+    TQString tmp = filepath;
     if ( checkCachedPath(tmp) ) return tmp;
-#if QT_VERSION<0x040000
-    tmp = getWindowsDrivePath(filepath[0]) + tmp.mid(2).replace('\\', "/");
-#else
-    tmp = getWindowsDrivePath(filepath[0].toLatin1()) + tmp.mid(2).replace('\\', "/");
-#endif
+    tmp = getWindowsDrivePath(filepath[0]) + tmp.mid(2).tqreplace('\\', "/");
     return cachePath(filepath, convertWindowsShortFilepath(tmp));
   }
   return filepath;
 }
 
-QString PURL::Private::findName(const QString &path, const QString &name)
+TQString PURL::Private::findName(const TQString &path, const TQString &name)
 {
-  QString filepath = path + '/' + name;
+  TQString filepath = path + '/' + name;
   if ( checkCachedPath(filepath) ) return filepath;
   return cachePath(filepath, findName(filepath));
 }
 
-QString PURL::Private::findName(const QString &filepath)
+TQString PURL::Private::findName(const TQString &filepath)
 {
-  QFileInfo finfo(filepath);
+  TQFileInfo finfo(filepath);
   if ( finfo.exists() || !finfo.dir().exists() ) return finfo.filePath();
-  QStringList list = finfo.dir().entryList(QDir::All, QDir::Name);
+  TQStringList list = finfo.dir().entryList(TQDir::All, TQDir::Name);
   // find if name is just in a different case
   for (uint j=0; j<uint(list.count()); j++) {
     if ( list[j].lower()!=finfo.fileName().lower() ) continue;
     return finfo.dirPath() + '/' + list[j];
   }
   // find if name is a shorted filename
-  QRegExp rexp("([^~]+)~(\\d+).*");
+  TQRegExp rexp("([^~]+)~(\\d+).*");
   if ( !rexp.exactMatch(finfo.fileName()) ) return finfo.filePath();
-  QString start = rexp.cap(1).lower();
+  TQString start = rexp.cap(1).lower();
   uint index = rexp.cap(2).toUInt();
   uint k = 0;
   for (uint j = 0; j<uint(list.count()); j++) {
@@ -141,18 +135,18 @@ QString PURL::Private::findName(const QString &filepath)
   return finfo.filePath();
 }
 
-QString PURL::Private::convertWindowsShortFilepath(const QString &filepath)
+TQString PURL::Private::convertWindowsShortFilepath(const TQString &filepath)
 {
-  // apparently "winepath" cannot do that for us and it is a real pain too...
+  // aptqparently "winepath" cannot do that for us and it is a real pain too...
   // we assume filepath is an absolute unix path
   // first see if we know the dirpath
-  QFileInfo finfo(filepath);
-  QString path = finfo.dirPath();
+  TQFileInfo finfo(filepath);
+  TQString path = finfo.dirPath();
   if ( checkCachedPath(path) ) return findName(path, finfo.fileName());
 
   // otherwise go down the path
-  QStringList names = QStringList::split('/', filepath);
-  QString tmp;
+  TQStringList names = TQStringList::split('/', filepath);
+  TQString tmp;
   for (uint i=0; i<uint(names.count()); i++)
     tmp = findName(tmp, names[i]);
   if ( filepath.endsWith("/") ) tmp += "/";
@@ -162,17 +156,17 @@ QString PURL::Private::convertWindowsShortFilepath(const QString &filepath)
 //-----------------------------------------------------------------------------
 PURL::Private *PURL::Base::_private = 0;
 
-PURL::Base::Base(const QString &filepath)
+PURL::Base::Base(const TQString &filepath)
   : _relative(true)
 {
   if ( !filepath.isEmpty() ) {
     if ( _private==0 ) _private = new Private;
 #if defined(Q_OS_UNIX)
-    QString tmp = _private->convertWindowsFilepath(filepath);
+    TQString tmp = _private->convertWindowsFilepath(filepath);
 #else
-    QString tmp = filepath;
+    TQString tmp = filepath;
 #endif
-    if ( tmp.startsWith("~") ) tmp = QDir::homeDirPath() + tmp.mid(1);
+    if ( tmp.startsWith("~") ) tmp = TQDir::homeDirPath() + tmp.mid(1);
     _relative = Q3Url::isRelativeUrl(tmp);
 #if defined(Q_OS_UNIX)
     if ( !tmp.startsWith("/") ) tmp = '/' + tmp;
@@ -203,13 +197,13 @@ bool PURL::Base::operator ==(const Base &url) const
   return _url==url._url;
 }
 
-QString PURL::Base::path(SeparatorType type) const
+TQString PURL::Base::path(SeparatorType type) const
 {
 #if defined(NO_KDE)
-  QString s = _url.dirPath();
+  TQString s = _url.dirPath();
   if ( !s.isEmpty() && !s.endsWith("/") ) s += '/';
 #else
-  QString s = _url.directory(false, false);
+  TQString s = _url.directory(false, false);
 #endif
   if ( type==WindowsSeparator ) {
     for (uint i=0; i<uint(s.length()); i++)
@@ -218,13 +212,13 @@ QString PURL::Base::path(SeparatorType type) const
   return s;
 }
 
-QString PURL::Base::unterminatedPath(SeparatorType type) const
+TQString PURL::Base::unterminatedPath(SeparatorType type) const
 {
 #if defined(NO_KDE)
-  QString s = _url.dirPath();
+  TQString s = _url.dirPath();
   if ( s.endsWith("/") ) s = s.mid(0, s.length()-1);
 #else
-  QString s = _url.directory(true, false);
+  TQString s = _url.directory(true, false);
 #endif
   if ( type==WindowsSeparator ) {
     for (uint i=0; i<uint(s.length()); i++)
@@ -233,10 +227,10 @@ QString PURL::Base::unterminatedPath(SeparatorType type) const
   return s;
 }
 
-QString PURL::Base::pretty() const
+TQString PURL::Base::pretty() const
 {
 #if defined(NO_KDE)
-  QString s = _url.toString();
+  TQString s = _url.toString();
   if ( s.startsWith("://") ) return s.mid(3);
   return s;
 #else
@@ -256,26 +250,24 @@ bool PURL::Base::isInto(const Directory &dir) const
 
 bool PURL::Base::httpUrlExists(bool *ok) const
 {
-#if QT_VERSION<0x040000
   qInitNetworkProtocols();
-#endif
   if (ok) *ok = false;
   Http http(_url.host());
   Synchronous sync(500);
-  QObject::connect(&http, SIGNAL(done(bool)), &sync, SLOT(done()));
-  QFileInfo info(_url.fileName(false));
+  TQObject::connect(&http, TQT_SIGNAL(done(bool)), &sync, TQT_SLOT(done()));
+  TQFileInfo info(_url.fileName(false));
   http.head(_url.path());
   if ( !sync.enterLoop() ) return false; // timeout
-  if ( http.error()!=QHttp::NoError ) return false;
+  if ( http.error()!=TQHttp::NoError ) return false;
   if (ok ) *ok = true;
   return ( http._header.statusCode()==200 );
 }
 
-bool PURL::Base::exists(QDateTime *lastModified) const
+bool PURL::Base::exists(TQDateTime *lastModified) const
 {
   if ( isEmpty() ) return false;
   if ( isLocal() ) {
-    QFileInfo fi(_url.path());
+    TQFileInfo fi(_url.path());
     if (lastModified) *lastModified = fi.lastModified();
     return fi.exists();
   }
@@ -283,13 +275,13 @@ bool PURL::Base::exists(QDateTime *lastModified) const
 #if !defined(NO_KDE)
   if (lastModified) {
     KIO::UDSEntry uds;
-    if ( !KIO::NetAccess::stat(_url, uds, qApp->mainWidget()) ) return false;
+    if ( !KIO::NetAccess::stat(_url, uds, tqApp->mainWidget()) ) return false;
     KFileItem item(uds, _url);
     lastModified->setTime_t(item.time(KIO::UDS_MODIFICATION_TIME));
     return true;
   } else {
     // assume file exists if ioslave cannot tell...
-    return KIO::NetAccess::exists(_url, true, qApp->mainWidget());
+    return KIO::NetAccess::exists(_url, true, tqApp->mainWidget());
   }
 #else
   if (lastModified) lastModified->setTime_t(0);
@@ -299,62 +291,62 @@ bool PURL::Base::exists(QDateTime *lastModified) const
 }
 
 //----------------------------------------------------------------------------
-PURL::Url PURL::Url::fromPathOrUrl(const QString &s)
+PURL::Url PURL::Url::fromPathOrUrl(const TQString &s)
 {
   KURL kurl = KURL::fromPathOrURL(s);
   if ( !kurl.protocol().isEmpty() && kurl.protocol()!="file" && kurl.protocol().length()!=1 ) return kurl;
   return Url(s.startsWith("file://") ? s.mid(7) : s);
 }
 
-PURL::Url::Url(const Directory &dir, const QString &filename, FileType type)
+PURL::Url::Url(const Directory &dir, const TQString &filename, FileType type)
   : Base(dir.path() + '/' + addExtension(filename, type))
 {}
 
-PURL::Url::Url(const Directory &dir, const QString &filepath)
+PURL::Url::Url(const Directory &dir, const TQString &filepath)
   : Base(dir.path() + '/' + filepath)
 {}
 
 PURL::FileType PURL::Url::fileType() const
 {
-  QFileInfo info(filename());
+  TQFileInfo info(filename());
   FOR_EACH(FileType, type)
     for (uint i=0; type.data().extensions[i]; i++)
       if ( info.extension(false).lower()==type.data().extensions[i] ) return type;
   return Unknown;
 }
 
-QString PURL::Url::basename() const
+TQString PURL::Url::basename() const
 {
-  QFileInfo info(_url.fileName(false));
+  TQFileInfo info(_url.fileName(false));
   return info.baseName(true);
 }
 
-QString PURL::Url::filename() const
+TQString PURL::Url::filename() const
 {
-  QFileInfo info(_url.fileName(false));
+  TQFileInfo info(_url.fileName(false));
   return info.fileName();
 }
 
-QString PURL::Url::filepath(SeparatorType type) const
+TQString PURL::Url::filepath(SeparatorType type) const
 {
   return path(type) + filename();
 }
 
-PURL::Url PURL::Url::toExtension(const QString &extension) const
+PURL::Url PURL::Url::toExtension(const TQString &extension) const
 {
-  QFileInfo info(filename());
+  TQFileInfo info(filename());
   return Url(directory().path() + info.baseName(true) + '.' + extension);
 }
 
-PURL::Url PURL::Url::appendExtension(const QString &extension) const
+PURL::Url PURL::Url::appendExtension(const TQString &extension) const
 {
-  QFileInfo info(filename());
+  TQFileInfo info(filename());
   return Url(directory().path() + info.fileName() + '.' + extension);
 }
 
-QString PURL::Url::relativeTo(const Directory &dir, SeparatorType type) const
+TQString PURL::Url::relativeTo(const Directory &dir, SeparatorType type) const
 {
-  QString s = filepath(type);
+  TQString s = filepath(type);
   if ( !isInto(dir) ) return s;
   return s.right(s.length() - dir.path(type).length());
 }
@@ -368,7 +360,7 @@ PURL::Url PURL::Url::toAbsolute(const Directory &dir) const
 bool PURL::findExistingUrl(Url &url)
 {
   if ( url.exists() ) return true;
-  QFileInfo info(url.filename());
+  TQFileInfo info(url.filename());
   Url tmp = url.toExtension(info.extension(false).upper());
   if ( !tmp.exists() ) {
     tmp = url.toExtension(info.extension(false).lower());
@@ -388,35 +380,35 @@ PURL::UrlList::UrlList(const KURL::List &list)
 #endif
 
 //-----------------------------------------------------------------------------
-PURL::Directory::Directory(const QString &path)
-  : Base(path.isEmpty() ? QString::null : path + '/')
+PURL::Directory::Directory(const TQString &path)
+  : Base(path.isEmpty() ? TQString() : path + '/')
 {}
 
 PURL::Directory PURL::Directory::up() const
 {
-  QDir dir(path());
+  TQDir dir(path());
   dir.cdUp();
   return PURL::Directory(dir.path());
 }
 
-PURL::Directory PURL::Directory::down(const QString &subPath) const
+PURL::Directory PURL::Directory::down(const TQString &subPath) const
 {
-  Q_ASSERT( QDir::isRelativePath(subPath) );
-  QDir dir(path());
+  Q_ASSERT( TQDir::isRelativePath(subPath) );
+  TQDir dir(path());
   dir.cd(subPath);
   return PURL::Directory(dir.path());
 }
 
-QStringList PURL::Directory::files(const QString &filter) const
+TQStringList PURL::Directory::files(const TQString &filter) const
 {
-  QDir dir(path());
-  return dir.entryList(filter, QDir::Files);
+  TQDir dir(path());
+  return dir.entryList(filter, TQDir::Files);
 }
 
-PURL::Url PURL::Directory::findMatchingFilename(const QString &filename) const
+PURL::Url PURL::Directory::findMatchingFilename(const TQString &filename) const
 {
-  QDir dir(path());
-  QStringList files = dir.entryList(QDir::Files);
+  TQDir dir(path());
+  TQStringList files = dir.entryList(TQDir::Files);
   for (uint i=0; i<uint(files.count()); i++)
     if ( files[i].lower()==filename.lower() ) return Url(*this, files[i]);
   return Url(*this, filename);
@@ -424,5 +416,5 @@ PURL::Url PURL::Directory::findMatchingFilename(const QString &filename) const
 
 PURL::Directory PURL::Directory::current()
 {
-  return QDir::currentDirPath();
+  return TQDir::currentDirPath();
 }