TQt4 port kvirc

This enables compilation under both Qt3 and Qt4


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

1 files changed, 104 insertions, 103 deletions

diff --git a/src/kvilib/core/kvi_qstring.h b/src/kvilib/core/kvi_qstring.h
index c82063e9..d5addebf 100644
--- a/src/kvilib/core/kvi_qstring.h
+++ b/src/kvilib/core/kvi_qstring.h
@@ -1,5 +1,5 @@
-#ifndef _KVI_QSTRING_H_
-#define _KVI_QSTRING_H_
+#ifndef _KVI_TQSTRING_H_
+#define _KVI_TQSTRING_H_
 
 //=============================================================================
 //
@@ -27,7 +27,7 @@
 
 //=============================================================================
 //
-// Helper functions for the QString class
+// Helper functions for the TQString class
 //
 //=============================================================================
 
@@ -36,109 +36,110 @@
 #include "kvi_stdarg.h"
 #include "kvi_qcstring.h"
 
-#include <qstring.h>
+#include <tqstring.h>
+#include <tqregexp.h>
 
 ///
-/// \namespace KviQString
+/// \namespace KviTQString
 ///
-/// \brief A namespace for QString helper functions
+/// \brief A namespace for TQString helper functions
 ///
 /// This namespace contains several helper functions
-/// that are used when dealing with QString.
+/// that are used when dealing with TQString.
 ///
-namespace KviQString
+namespace KviTQString
 {
-	extern KVILIB_API QString makeSizeReadable(size_t size);
-	extern KVILIB_API bool equalCS(const QString &sz1,const QString &sz2);
-	extern KVILIB_API bool equalCI(const QString &sz1,const QString &sz2);
-	extern KVILIB_API bool equalCS(const QString &sz1,const char * sz2);
-	extern KVILIB_API bool equalCI(const QString &sz1,const char * sz2);
+	extern KVILIB_API TQString makeSizeReadable(size_t size);
+	extern KVILIB_API bool equalCS(const TQString &sz1,const TQString &sz2);
+	extern KVILIB_API bool equalCI(const TQString &sz1,const TQString &sz2);
+	extern KVILIB_API bool equalCS(const TQString &sz1,const char * sz2);
+	extern KVILIB_API bool equalCI(const TQString &sz1,const char * sz2);
 	// sz2 is assumed to be null terminated here!
-	extern KVILIB_API bool equalCI(const QString &sz1,const QChar * sz2);
-	inline bool equalCS(const char * sz1,const QString &sz2)
+	extern KVILIB_API bool equalCI(const TQString &sz1,const TQChar * sz2);
+	inline bool equalCS(const char * sz1,const TQString &sz2)
 		{ return equalCS(sz2,sz1); };
-	inline bool equalCI(const char * sz1,const QString &sz2)
+	inline bool equalCI(const char * sz1,const TQString &sz2)
 		{ return equalCI(sz2,sz1); };
 	// sz1 is assumed to be null terminated here!
-	inline bool equalCI(const QChar * sz1,const QString &sz2)
+	inline bool equalCI(const TQChar * sz1,const TQString &sz2)
 		{ return equalCI(sz2,sz1); };
 
-	extern KVILIB_API bool equalCSN(const QString &sz1,const QString &sz2,unsigned int len);
-	extern KVILIB_API bool equalCIN(const QString &sz1,const QString &sz2,unsigned int len);
-	extern KVILIB_API bool equalCSN(const QString &sz1,const char * sz2,unsigned int len);
-	extern KVILIB_API bool equalCIN(const QString &sz1,const char * sz2,unsigned int len);
+	extern KVILIB_API bool equalCSN(const TQString &sz1,const TQString &sz2,unsigned int len);
+	extern KVILIB_API bool equalCIN(const TQString &sz1,const TQString &sz2,unsigned int len);
+	extern KVILIB_API bool equalCSN(const TQString &sz1,const char * sz2,unsigned int len);
+	extern KVILIB_API bool equalCIN(const TQString &sz1,const char * sz2,unsigned int len);
 	// sz2 is assumed to be null terminated here!
-	extern KVILIB_API bool equalCIN(const QString &sz1,const QChar * sz2,unsigned int len);
-	inline bool equalCSN(const char * sz1,const QString &sz2,unsigned int len)
+	extern KVILIB_API bool equalCIN(const TQString &sz1,const TQChar * sz2,unsigned int len);
+	inline bool equalCSN(const char * sz1,const TQString &sz2,unsigned int len)
 		{ return equalCSN(sz2,sz1,len); };
-	inline bool equalCIN(const char * sz1,const QString &sz2,unsigned int len)
+	inline bool equalCIN(const char * sz1,const TQString &sz2,unsigned int len)
 		{ return equalCIN(sz2,sz1,len); };
 	// sz1 is assumed to be null terminated here!
-	inline bool equalCIN(const QChar * sz1,const QString &sz2,unsigned int len)
+	inline bool equalCIN(const TQChar * sz1,const TQString &sz2,unsigned int len)
 		{ return equalCIN(sz2,sz1,len); };
 
 	//note that greater here means that come AFTER in the alphabetic order
 	// return < 0 ---> str1 < str2
 	// return = 0 ---> str1 = str2
 	// return > 0 ---> str1 > str2
-	extern KVILIB_API int cmpCI(const QString &sz1,const QString &sz2);
-	extern KVILIB_API int cmpCIN(const QString &sz1,const QString &sz2,unsigned int len);
-	extern KVILIB_API int cmpCS(const QString &sz1,const QString &sz2);
+	extern KVILIB_API int cmpCI(const TQString &sz1,const TQString &sz2);
+	extern KVILIB_API int cmpCIN(const TQString &sz1,const TQString &sz2,unsigned int len);
+	extern KVILIB_API int cmpCS(const TQString &sz1,const TQString &sz2);
 
-	extern KVILIB_API void detach(QString &sz);
+	extern KVILIB_API void detach(TQString &sz);
 
-	// this makes the QString sz appear as a null terminated array
-	// it MAY RETURN 0 when the QString is null!
-	extern KVILIB_API const QChar * nullTerminatedArray(const QString &sz);
+	// this makes the TQString sz appear as a null terminated array
+	// it MAY RETURN 0 when the TQString is null!
+	extern KVILIB_API const TQChar * nullTerminatedArray(const TQString &sz);
 
-	inline bool lastCharIs(QString &szString,const QChar &c)
+	inline bool lastCharIs(TQString &szString,const TQChar &c)
 					{ return szString.endsWith(c); };
 
-	extern KVILIB_API void ensureLastCharIs(QString &szString,const QChar &c);
+	extern KVILIB_API void ensureLastCharIs(TQString &szString,const TQChar &c);
 
 	// wild expression matching
-	extern KVILIB_API bool matchWildExpressionsCI(const QString &szM1,const QString &szM2);
+	extern KVILIB_API bool matchWildExpressionsCI(const TQString &szM1,const TQString &szM2);
 	// wild or regexp matching
-	extern KVILIB_API bool matchStringCI(const QString &szExp,const QString &szStr,bool bIsRegExp = false,bool bExact = false);
-	extern KVILIB_API bool matchStringCS(const QString &szExp,const QString &szStr,bool bIsRegExp = false,bool bExact = false);
+	extern KVILIB_API bool matchStringCI(const TQString &szExp,const TQString &szStr,bool bIsRegExp = false,bool bExact = false);
+	extern KVILIB_API bool matchStringCS(const TQString &szExp,const TQString &szStr,bool bIsRegExp = false,bool bExact = false);
 
-	extern KVILIB_API void vsprintf(QString &s,const QString &szFmt,kvi_va_list list);
-	extern KVILIB_API QString & sprintf(QString &s,const QString &szFmt,...);
-	extern KVILIB_API void stripRightWhiteSpace(QString &s);
-	extern KVILIB_API void stripLeft(QString &s,const QChar &c);
-	extern KVILIB_API void stripRight(QString &s,const QChar &c);
-	extern KVILIB_API void appendFormatted(QString &s,const QString &szFmt,...);
-	extern KVILIB_API void appendNumber(QString &s,double dReal);
-	extern KVILIB_API void appendNumber(QString &s,kvi_i64_t iInteger);
-	extern KVILIB_API void appendNumber(QString &s,int iInteger);
-	extern KVILIB_API void appendNumber(QString &s,unsigned int uInteger);
-	extern KVILIB_API void appendNumber(QString &s,kvi_u64_t uInteger);
+	extern KVILIB_API void vsprintf(TQString &s,const TQString &szFmt,kvi_va_list list);
+	extern KVILIB_API TQString & sprintf(TQString &s,const TQString &szFmt,...);
+	extern KVILIB_API void stripRightWhiteSpace(TQString &s);
+	extern KVILIB_API void stripLeft(TQString &s,const TQChar &c);
+	extern KVILIB_API void stripRight(TQString &s,const TQChar &c);
+	extern KVILIB_API void appendFormatted(TQString &s,const TQString &szFmt,...);
+	extern KVILIB_API void appendNumber(TQString &s,double dReal);
+	extern KVILIB_API void appendNumber(TQString &s,kvi_i64_t iInteger);
+	extern KVILIB_API void appendNumber(TQString &s,int iInteger);
+	extern KVILIB_API void appendNumber(TQString &s,unsigned int uInteger);
+	extern KVILIB_API void appendNumber(TQString &s,kvi_u64_t uInteger);
 	
-	extern KVILIB_API void cutFromFirst(QString &s,const QChar &c,bool bIncluded = true);
-	extern KVILIB_API void cutFromLast(QString &s,const QChar &c,bool bIncluded = true);
-	extern KVILIB_API void cutToFirst(QString &s,const QChar &c,bool bIncluded = true,bool bClearIfNotFound = false);
-	extern KVILIB_API void cutToLast(QString &s,const QChar &c,bool bIncluded = true,bool bClearIfNotFound = false);
-	extern KVILIB_API void cutFromFirst(QString &s,const QString &c,bool bIncluded = true);
-	extern KVILIB_API void cutFromLast(QString &s,const QString &c,bool bIncluded = true);
-	extern KVILIB_API void cutToFirst(QString &s,const QString &c,bool bIncluded = true,bool bClearIfNotFound = false);
-	extern KVILIB_API void cutToLast(QString &s,const QString &c,bool bIncluded = true,bool bClearIfNotFound = false);
+	extern KVILIB_API void cutFromFirst(TQString &s,const TQChar &c,bool bIncluded = true);
+	extern KVILIB_API void cutFromLast(TQString &s,const TQChar &c,bool bIncluded = true);
+	extern KVILIB_API void cutToFirst(TQString &s,const TQChar &c,bool bIncluded = true,bool bClearIfNotFound = false);
+	extern KVILIB_API void cutToLast(TQString &s,const TQChar &c,bool bIncluded = true,bool bClearIfNotFound = false);
+	extern KVILIB_API void cutFromFirst(TQString &s,const TQString &c,bool bIncluded = true);
+	extern KVILIB_API void cutFromLast(TQString &s,const TQString &c,bool bIncluded = true);
+	extern KVILIB_API void cutToFirst(TQString &s,const TQString &c,bool bIncluded = true,bool bClearIfNotFound = false);
+	extern KVILIB_API void cutToLast(TQString &s,const TQString &c,bool bIncluded = true,bool bClearIfNotFound = false);
 	
-	extern KVILIB_API QString upperISO88591(const QString &szSrc);
-	extern KVILIB_API QString lowerISO88591(const QString &szSrc);
-	extern KVILIB_API QString getToken(QString &szString,const QChar &sep);
+	extern KVILIB_API TQString upperISO88591(const TQString &szSrc);
+	extern KVILIB_API TQString lowerISO88591(const TQString &szSrc);
+	extern KVILIB_API TQString getToken(TQString &szString,const TQChar &sep);
 	
-	extern KVILIB_API void transliterate(QString &s,const QString &szToFind,const QString &szReplacement);
+	extern KVILIB_API void transliterate(TQString &s,const TQString &szToFind,const TQString &szReplacement);
 
-	extern KVILIB_API void bufferToHex(QString &szRetBuffer,const unsigned char * buffer,unsigned int len);
+	extern KVILIB_API void bufferToHex(TQString &szRetBuffer,const unsigned char * buffer,unsigned int len);
 
-	// a global empty string (note that this is ALSO NULL under Qt 3.x)
-	extern KVILIB_API const QString empty;
+	// a global empty string (note that this is ALSO NULL under TQt 3.x)
+	extern KVILIB_API const TQString empty;
 
 	///
-	/// A portability wrapper which with Qt3 and Qt4.
+	/// A portability wrapper which with TQt3 and TQt4.
 	/// Returns a lowcase version of the parameter string.
 	///
-	inline QString toLower(const QString &s)
+	inline TQString toLower(const TQString &s)
 	{
 #ifdef COMPILE_USE_QT4
 		return s.toLower();
@@ -147,97 +148,97 @@ namespace KviQString
 #endif
 	}
 	
-	inline int find(const QString &s,QChar c,int index = 0,bool cs = true)
+	inline int tqfind(const TQString &s,TQChar c,int index = 0,bool cs = true)
 	{
 #ifdef COMPILE_USE_QT4
-		return s.indexOf(c,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+		return s.indexOf(c,index,cs ? TQt::CaseSensitive : TQt::CaseInsensitive);
 #else
-		return s.find(c,index,cs);
+		return s.tqfind(c,index,cs);
 #endif
 	}
 
-	inline int find(const QString &s,char c,int index = 0,bool cs = true)
+	inline int tqfind(const TQString &s,char c,int index = 0,bool cs = true)
 	{
 #ifdef COMPILE_USE_QT4
-		return s.indexOf(c,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+		return s.indexOf(c,index,cs ? TQt::CaseSensitive : TQt::CaseInsensitive);
 #else
-		return s.find(c,index,cs);
+		return s.tqfind(c,index,cs);
 #endif
 	}
 
-	inline int find(const QString &s,const QString & str,int index = 0,bool cs = true)
+	inline int tqfind(const TQString &s,const TQString & str,int index = 0,bool cs = true)
 	{
 #ifdef COMPILE_USE_QT4
-		return s.indexOf(str,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+		return s.indexOf(str,index,cs ? TQt::CaseSensitive : TQt::CaseInsensitive);
 #else
-		return s.find(str,index,cs);
+		return s.tqfind(str,index,cs);
 #endif
 	}
 
-	inline int find(const QString &s,const QRegExp & rx,int index = 0)
+	inline int tqfind(const TQString &s,const TQRegExp & rx,int index = 0)
 	{
 #ifdef COMPILE_USE_QT4
 		return s.indexOf(rx,index);
 #else
-		return s.find(rx,index);
+		return s.tqfind(rx,index);
 #endif
 	}
 
-	inline int find(const QString &s,const char * str,int index = 0)
+	inline int tqfind(const TQString &s,const char * str,int index = 0)
 	{
 #ifdef COMPILE_USE_QT4
-		return s.indexOf(QString(str),index);
+		return s.indexOf(TQString(str),index);
 #else
-		return s.find(str,index);
+		return s.tqfind(str,index);
 #endif
 	}
 
-	inline int findRev(const QString &s,QChar c,int index = -1,bool cs = true)
+	inline int tqfindRev(const TQString &s,TQChar c,int index = -1,bool cs = true)
 	{
 #ifdef COMPILE_USE_QT4
-		return s.lastIndexOf(c,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+		return s.lastIndexOf(c,index,cs ? TQt::CaseSensitive : TQt::CaseInsensitive);
 #else
-		return s.findRev(c,index,cs);
+		return s.tqfindRev(c,index,cs);
 #endif
 	}
 
-	inline int findRev(const QString &s,char c,int index = -1,bool cs = true)
+	inline int tqfindRev(const TQString &s,char c,int index = -1,bool cs = true)
 	{
 #ifdef COMPILE_USE_QT4
-		return s.lastIndexOf(c,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+		return s.lastIndexOf(c,index,cs ? TQt::CaseSensitive : TQt::CaseInsensitive);
 #else
-		return s.findRev(c,index,cs);
+		return s.tqfindRev(c,index,cs);
 #endif
 	}
 
-	inline int findRev(const QString &s,const QString & str,int index = -1,bool cs = true)
+	inline int tqfindRev(const TQString &s,const TQString & str,int index = -1,bool cs = true)
 	{
 #ifdef COMPILE_USE_QT4
-		return s.lastIndexOf(str,index,cs ? Qt::CaseSensitive : Qt::CaseInsensitive);
+		return s.lastIndexOf(str,index,cs ? TQt::CaseSensitive : TQt::CaseInsensitive);
 #else
-		return s.findRev(str,index,cs);
+		return s.tqfindRev(str,index,cs);
 #endif
 	}
 
-	inline int findRev(const QString &s,const QRegExp & rx,int index = -1)
+	inline int tqfindRev(const TQString &s,const TQRegExp & rx,int index = -1)
 	{
 #ifdef COMPILE_USE_QT4
 		return s.lastIndexOf(rx,index);
 #else
-		return s.findRev(rx,index);
+		return s.tqfindRev(rx,index);
 #endif
 	}
 
-	inline int findRev(const QString &s,const char * str,int index = -1)
+	inline int tqfindRev(const TQString &s,const char * str,int index = -1)
 	{
 #ifdef COMPILE_USE_QT4
-		return s.lastIndexOf(QString(str),index);
+		return s.lastIndexOf(TQString(str),index);
 #else
-		return s.findRev(str,index);
+		return s.tqfindRev(str,index);
 #endif
 	}
 
-	inline QString trimmed(const QString &s)
+	inline TQString trimmed(const TQString &s)
 	{
 #ifdef COMPILE_USE_QT4
 		return s.trimmed();
@@ -246,16 +247,16 @@ namespace KviQString
 #endif
 	}
 
-	// WARNING: DO NOT USE CONSTRUCTS LIKE char * c = KviQString::toUtf8(something).data();
+	// WARNING: DO NOT USE CONSTRUCTS LIKE char * c = KviTQString::toUtf8(something).data();
 	//          They are dangerous since with many compilers the returned string gets destroyed
-	//          at the end of the instruction and the c pointer gets thus invalidated.
+	//          at the end of the instruction and the c pointer gets thus tqinvalidated.
 	//          Use
-	//           KviQCString tmp = KviQString::toUtf8(something);
+	//           KviTQCString tmp = KviTQString::toUtf8(something);
 	//           char * c = tmp.data(); 
 	//          instead.
 	//          Yes, I know that it sucks, but it's the only way to
 	//          transit to qt 4.x more or less cleanly...
-	inline KviQCString toUtf8(const QString &s)
+	inline KviTQCString toUtf8(const TQString &s)
 	{
 #ifdef COMPILE_USE_QT4
 		return s.toUtf8();
@@ -264,12 +265,12 @@ namespace KviQString
 #endif
 	}
 
-	inline KviQCString toLocal8Bit(const QString &s)
+	inline KviTQCString toLocal8Bit(const TQString &s)
 	{
 		return s.local8Bit();
 	}
 	
-	inline kvi_i64_t toI64(QString &szNumber,bool * bOk)
+	inline kvi_i64_t toI64(TQString &szNumber,bool * bOk)
 	{
 #if SIZEOF_LONG_INT == 8
 		return szNumber.toLong(bOk);
@@ -278,7 +279,7 @@ namespace KviQString
 #endif
 	}
 	
-	inline kvi_u64_t toU64(QString &szNumber,bool * bOk)
+	inline kvi_u64_t toU64(TQString &szNumber,bool * bOk)
 	{
 #if SIZEOF_LONG_INT == 8
 		return szNumber.toULong(bOk);
@@ -288,6 +289,6 @@ namespace KviQString
 	}
 };
 
-// QT4SUX: Because QString::null is gone. QString() is SLOWER than QString::null since it invokes a constructor and destructor.
+// QT4SUX: Because TQString() is gone. TQString() is SLOWER than TQString() since it invokes a constructor and destructor.
 
-#endif //!_KVI_QSTRING_H_
+#endif //!_KVI_TQSTRING_H_