Automated update from Qt3

30 files changed, 361 insertions, 361 deletions

diff --git a/src/tools/ntqbuffer.h b/src/tools/ntqbuffer.h
index 7ab32039..e50f1917 100644
--- a/src/tools/ntqbuffer.h
+++ b/src/tools/ntqbuffer.h
@@ -65,11 +65,11 @@ public:
     Offset at() const;
     bool  at( Offset );
 
-    Q_LONG	  readBlock( char *p, Q_ULONG );
-    Q_LONG	  writeBlock( const char *p, Q_ULONG );
-    Q_LONG	  writeBlock( const TQByteArray& data )
+    TQ_LONG	  readBlock( char *p, TQ_ULONG );
+    TQ_LONG	  writeBlock( const char *p, TQ_ULONG );
+    TQ_LONG	  writeBlock( const TQByteArray& data )
 	      { return TQIODevice::writeBlock(data); }
-    Q_LONG	  readLine( char *p, Q_ULONG );
+    TQ_LONG	  readLine( char *p, TQ_ULONG );
 
     int	  getch();
     int	  putch( int );
diff --git a/src/tools/ntqcstring.h b/src/tools/ntqcstring.h
index 7c60c1f4..0bcdffa5 100644
--- a/src/tools/ntqcstring.h
+++ b/src/tools/ntqcstring.h
@@ -98,7 +98,7 @@ Q_EXPORT inline int cstrncmp( const char *str1, const char *str2, uint len )
 
 // tqChecksum: Internet checksum
 
-Q_EXPORT Q_UINT16 tqChecksum( const char *s, uint len );
+Q_EXPORT TQ_UINT16 tqChecksum( const char *s, uint len );
 
 /*****************************************************************************
   TQByteArray class
diff --git a/src/tools/ntqdatastream.h b/src/tools/ntqdatastream.h
index 1031f3bf..3c2df147 100644
--- a/src/tools/ntqdatastream.h
+++ b/src/tools/ntqdatastream.h
@@ -72,34 +72,34 @@ public:
     int		 version() const;
     void	 setVersion( int );
 
-    TQDataStream &operator>>( Q_INT8 &i );
-    TQDataStream &operator>>( Q_UINT8 &i );
-    TQDataStream &operator>>( Q_INT16 &i );
-    TQDataStream &operator>>( Q_UINT16 &i );
-    TQDataStream &operator>>( Q_INT32 &i );
-    TQDataStream &operator>>( Q_UINT32 &i );
-    TQDataStream &operator>>( Q_INT64 &i );
-    TQDataStream &operator>>( Q_UINT64 &i );
+    TQDataStream &operator>>( TQ_INT8 &i );
+    TQDataStream &operator>>( TQ_UINT8 &i );
+    TQDataStream &operator>>( TQ_INT16 &i );
+    TQDataStream &operator>>( TQ_UINT16 &i );
+    TQDataStream &operator>>( TQ_INT32 &i );
+    TQDataStream &operator>>( TQ_UINT32 &i );
+    TQDataStream &operator>>( TQ_INT64 &i );
+    TQDataStream &operator>>( TQ_UINT64 &i );
 #if !defined(Q_OS_WIN64)
-    TQDataStream &operator>>( Q_LONG &i );
-    TQDataStream &operator>>( Q_ULONG &i );
+    TQDataStream &operator>>( TQ_LONG &i );
+    TQDataStream &operator>>( TQ_ULONG &i );
 #endif
 
     TQDataStream &operator>>( float &f );
     TQDataStream &operator>>( double &f );
     TQDataStream &operator>>( char *&str );
 
-    TQDataStream &operator<<( Q_INT8 i );
-    TQDataStream &operator<<( Q_UINT8 i );
-    TQDataStream &operator<<( Q_INT16 i );
-    TQDataStream &operator<<( Q_UINT16 i );
-    TQDataStream &operator<<( Q_INT32 i );
-    TQDataStream &operator<<( Q_UINT32 i );
-    TQDataStream &operator<<( Q_INT64 i );
-    TQDataStream &operator<<( Q_UINT64 i );
+    TQDataStream &operator<<( TQ_INT8 i );
+    TQDataStream &operator<<( TQ_UINT8 i );
+    TQDataStream &operator<<( TQ_INT16 i );
+    TQDataStream &operator<<( TQ_UINT16 i );
+    TQDataStream &operator<<( TQ_INT32 i );
+    TQDataStream &operator<<( TQ_UINT32 i );
+    TQDataStream &operator<<( TQ_INT64 i );
+    TQDataStream &operator<<( TQ_UINT64 i );
 #if !defined(Q_OS_WIN64)
-    TQDataStream &operator<<( Q_LONG i );
-    TQDataStream &operator<<( Q_ULONG i );
+    TQDataStream &operator<<( TQ_LONG i );
+    TQDataStream &operator<<( TQ_ULONG i );
 #endif
     TQDataStream &operator<<( float f );
     TQDataStream &operator<<( double f );
@@ -155,38 +155,38 @@ inline int TQDataStream::version() const
 inline void TQDataStream::setVersion( int v )
 { ver = v; }
 
-inline TQDataStream &TQDataStream::operator>>( Q_UINT8 &i )
-{ return *this >> (Q_INT8&)i; }
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT8 &i )
+{ return *this >> (TQ_INT8&)i; }
 
-inline TQDataStream &TQDataStream::operator>>( Q_UINT16 &i )
-{ return *this >> (Q_INT16&)i; }
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT16 &i )
+{ return *this >> (TQ_INT16&)i; }
 
-inline TQDataStream &TQDataStream::operator>>( Q_UINT32 &i )
-{ return *this >> (Q_INT32&)i; }
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT32 &i )
+{ return *this >> (TQ_INT32&)i; }
 
-inline TQDataStream &TQDataStream::operator>>( Q_UINT64 &i )
-{ return *this >> (Q_INT64&)i; }
+inline TQDataStream &TQDataStream::operator>>( TQ_UINT64 &i )
+{ return *this >> (TQ_INT64&)i; }
 
 #if !defined(Q_OS_WIN64)
-inline TQDataStream &TQDataStream::operator>>( Q_ULONG &i )
-{ return *this >> (Q_LONG&)i; }
+inline TQDataStream &TQDataStream::operator>>( TQ_ULONG &i )
+{ return *this >> (TQ_LONG&)i; }
 #endif
 
-inline TQDataStream &TQDataStream::operator<<( Q_UINT8 i )
-{ return *this << (Q_INT8)i; }
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT8 i )
+{ return *this << (TQ_INT8)i; }
 
-inline TQDataStream &TQDataStream::operator<<( Q_UINT16 i )
-{ return *this << (Q_INT16)i; }
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT16 i )
+{ return *this << (TQ_INT16)i; }
 
-inline TQDataStream &TQDataStream::operator<<( Q_UINT32 i )
-{ return *this << (Q_INT32)i; }
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT32 i )
+{ return *this << (TQ_INT32)i; }
 
-inline TQDataStream &TQDataStream::operator<<( Q_UINT64 i )
-{ return *this << (Q_INT64)i; }
+inline TQDataStream &TQDataStream::operator<<( TQ_UINT64 i )
+{ return *this << (TQ_INT64)i; }
 
 #if !defined(Q_OS_WIN64)
-inline TQDataStream &TQDataStream::operator<<( Q_ULONG i )
-{ return *this << (Q_LONG)i; }
+inline TQDataStream &TQDataStream::operator<<( TQ_ULONG i )
+{ return *this << (TQ_LONG)i; }
 #endif
 
 #endif // QT_NO_DATASTREAM
diff --git a/src/tools/ntqfile.h b/src/tools/ntqfile.h
index 829ae91d..c007d5cb 100644
--- a/src/tools/ntqfile.h
+++ b/src/tools/ntqfile.h
@@ -84,12 +84,12 @@ public:
     bool	at( Offset );
     bool	atEnd() const;
 
-    Q_LONG	readBlock( char *data, Q_ULONG len );
-    Q_LONG	writeBlock( const char *data, Q_ULONG len );
-    Q_LONG	writeBlock( const TQByteArray& data )
+    TQ_LONG	readBlock( char *data, TQ_ULONG len );
+    TQ_LONG	writeBlock( const char *data, TQ_ULONG len );
+    TQ_LONG	writeBlock( const TQByteArray& data )
 		      { return TQIODevice::writeBlock(data); }
-    Q_LONG	readLine( char *data, Q_ULONG maxlen );
-    Q_LONG	readLine( TQString &, Q_ULONG maxlen );
+    TQ_LONG	readLine( char *data, TQ_ULONG maxlen );
+    TQ_LONG	readLine( TQString &, TQ_ULONG maxlen );
 
     int		getch();
     int		putch( int );
diff --git a/src/tools/ntqglobal.h b/src/tools/ntqglobal.h
index b2a6413a..de5ed88e 100644
--- a/src/tools/ntqglobal.h
+++ b/src/tools/ntqglobal.h
@@ -712,40 +712,40 @@ typedef int			INT32;		// 32 bit signed
 typedef unsigned int		UINT32;		// 32 bit unsigned
 #endif
 
-typedef signed char		Q_INT8;		// 8 bit signed
-typedef unsigned char		Q_UINT8;	// 8 bit unsigned
-typedef short			Q_INT16;	// 16 bit signed
-typedef unsigned short		Q_UINT16;	// 16 bit unsigned
-typedef int			Q_INT32;	// 32 bit signed
-typedef unsigned int		Q_UINT32;	// 32 bit unsigned
+typedef signed char		TQ_INT8;		// 8 bit signed
+typedef unsigned char		TQ_UINT8;	// 8 bit unsigned
+typedef short			TQ_INT16;	// 16 bit signed
+typedef unsigned short		TQ_UINT16;	// 16 bit unsigned
+typedef int			TQ_INT32;	// 32 bit signed
+typedef unsigned int		TQ_UINT32;	// 32 bit unsigned
 #if defined(Q_OS_WIN64)
-typedef __int64			Q_LONG;		// word up to 64 bit signed
-typedef unsigned __int64	Q_ULONG;	// word up to 64 bit unsigned
+typedef __int64			TQ_LONG;		// word up to 64 bit signed
+typedef unsigned __int64	TQ_ULONG;	// word up to 64 bit unsigned
 #else
-typedef long			Q_LONG;		// word up to 64 bit signed
-typedef unsigned long		Q_ULONG;	// word up to 64 bit unsigned
+typedef long			TQ_LONG;		// word up to 64 bit signed
+typedef unsigned long		TQ_ULONG;	// word up to 64 bit unsigned
 #endif
 #if defined(Q_OS_WIN) && !defined(Q_CC_GNU)
 #  define TQ_INT64_C(c) 		c ## i64	// signed 64 bit constant
 #  define TQ_UINT64_C(c)		c ## ui64	// unsigned 64 bit constant
-typedef __int64			Q_INT64;	// 64 bit signed
-typedef unsigned __int64	Q_UINT64;	// 64 bit unsigned
+typedef __int64			TQ_INT64;	// 64 bit signed
+typedef unsigned __int64	TQ_UINT64;	// 64 bit unsigned
 #else
 #  define TQ_INT64_C(c) 		c ## LL		// signed 64 bit constant
 #  define TQ_UINT64_C(c)		c ## ULL	// unsigned 64 bit constant
-typedef long long		Q_INT64;	// 64 bit signed
-typedef unsigned long long	Q_UINT64;	// 64 bit unsigned
+typedef long long		TQ_INT64;	// 64 bit signed
+typedef unsigned long long	TQ_UINT64;	// 64 bit unsigned
 #endif
-typedef Q_INT64			Q_LLONG;	// signed long long
-typedef Q_UINT64		Q_ULLONG;	// unsigned long long
+typedef TQ_INT64			TQ_LLONG;	// signed long long
+typedef TQ_UINT64		TQ_ULLONG;	// unsigned long long
 
 #if defined(Q_OS_MACX) && !defined(QT_LARGEFILE_SUPPORT)
 #  define QT_LARGEFILE_SUPPORT 64
 #endif
 #if defined(QT_LARGEFILE_SUPPORT)
-    typedef Q_ULLONG TQtOffset;
+    typedef TQ_ULLONG TQtOffset;
 #else
-    typedef Q_ULONG TQtOffset;
+    typedef TQ_ULONG TQtOffset;
 #endif
 
 
diff --git a/src/tools/ntqiodevice.h b/src/tools/ntqiodevice.h
index 33516d07..d014265c 100644
--- a/src/tools/ntqiodevice.h
+++ b/src/tools/ntqiodevice.h
@@ -92,9 +92,9 @@ class Q_EXPORT TQIODevice
 {
 public:
 #if defined(QT_ABI_QT4)
-    typedef Q_LLONG Offset;
+    typedef TQ_LLONG Offset;
 #else
-    typedef Q_ULONG Offset;
+    typedef TQ_ULONG Offset;
 #endif
 
     TQIODevice();
@@ -131,10 +131,10 @@ public:
     virtual bool atEnd()  const;
     bool	 reset() { return at(0); }
 
-    virtual Q_LONG readBlock( char *data, Q_ULONG maxlen ) = 0;
-    virtual Q_LONG writeBlock( const char *data, Q_ULONG len ) = 0;
-    virtual Q_LONG readLine( char *data, Q_ULONG maxlen );
-    Q_LONG writeBlock( const TQByteArray& data );
+    virtual TQ_LONG readBlock( char *data, TQ_ULONG maxlen ) = 0;
+    virtual TQ_LONG writeBlock( const char *data, TQ_ULONG len ) = 0;
+    virtual TQ_LONG readLine( char *data, TQ_ULONG maxlen );
+    TQ_LONG writeBlock( const TQByteArray& data );
     virtual TQByteArray readAll();
 
     virtual int	 getch() = 0;
diff --git a/src/tools/ntqlocale.h b/src/tools/ntqlocale.h
index 231203f4..5cfaa32c 100644
--- a/src/tools/ntqlocale.h
+++ b/src/tools/ntqlocale.h
@@ -452,29 +452,29 @@ public:
     ushort toUShort(const TQString &s, bool *ok = 0) const;
     int toInt(const TQString &s, bool *ok = 0) const;
     uint toUInt(const TQString &s, bool *ok = 0) const;
-    Q_LONG toLong(const TQString &s, bool *ok = 0) const;
-    Q_ULONG toULong(const TQString &s, bool *ok = 0) const;
-    Q_LLONG toLongLong(const TQString &s, bool *ok = 0) const;
-    Q_ULLONG toULongLong(const TQString &s, bool *ok = 0) const;
+    TQ_LONG toLong(const TQString &s, bool *ok = 0) const;
+    TQ_ULONG toULong(const TQString &s, bool *ok = 0) const;
+    TQ_LLONG toLongLong(const TQString &s, bool *ok = 0) const;
+    TQ_ULLONG toULongLong(const TQString &s, bool *ok = 0) const;
     float toFloat(const TQString &s, bool *ok = 0) const;
     double toDouble(const TQString &s, bool *ok = 0) const;
 
     TQString toString(short i) const
-    { return toString((Q_LLONG)i); }
+    { return toString((TQ_LLONG)i); }
     TQString toString(ushort i) const
-    { return toString((Q_ULLONG)i); }
+    { return toString((TQ_ULLONG)i); }
     TQString toString(int i) const
-    { return toString((Q_LLONG)i); }
+    { return toString((TQ_LLONG)i); }
     TQString toString(uint i) const
-    { return toString((Q_ULLONG)i); }
+    { return toString((TQ_ULLONG)i); }
 #if !defined(Q_OS_WIN64)
-    TQString toString(Q_LONG i) const
-    { return toString((Q_LLONG)i); }
-    TQString toString(Q_ULONG i) const
-    { return toString((Q_ULLONG)i); }
+    TQString toString(TQ_LONG i) const
+    { return toString((TQ_LLONG)i); }
+    TQString toString(TQ_ULONG i) const
+    { return toString((TQ_ULLONG)i); }
 #endif
-    TQString toString(Q_LLONG i) const;
-    TQString toString(Q_ULLONG i) const;
+    TQString toString(TQ_LLONG i) const;
+    TQString toString(TQ_ULLONG i) const;
     TQString toString(float i, char f = 'g', int prec = 6) const
     { return toString((double) i, f, prec); }
     TQString toString(double i, char f = 'g', int prec = 6) const;
diff --git a/src/tools/ntqmap.h b/src/tools/ntqmap.h
index 02dd289c..c8d97fd5 100644
--- a/src/tools/ntqmap.h
+++ b/src/tools/ntqmap.h
@@ -849,9 +849,9 @@ Q_INLINE_TEMPLATES void TQMap<Key,T>::detachInternal()
 template<class Key, class T>
 Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQMap<Key,T>& m ) {
     m.clear();
-    Q_UINT32 c;
+    TQ_UINT32 c;
     s >> c;
-    for( Q_UINT32 i = 0; i < c; ++i ) {
+    for( TQ_UINT32 i = 0; i < c; ++i ) {
 	Key k; T t;
 	s >> k >> t;
 	m.insert( k, t );
@@ -864,7 +864,7 @@ Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQMap<Key,T>& m )
 
 template<class Key, class T>
 Q_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQMap<Key,T>& m ) {
-    s << (Q_UINT32)m.size();
+    s << (TQ_UINT32)m.size();
     TQMapConstIterator<Key,T> it = m.begin();
     for( ; it != m.end(); ++it )
 	s << it.key() << it.data();
diff --git a/src/tools/ntqstring.h b/src/tools/ntqstring.h
index 54fb170a..29704e71 100644
--- a/src/tools/ntqstring.h
+++ b/src/tools/ntqstring.h
@@ -435,8 +435,8 @@ public:
 
     TQString arg( long a, int fieldWidth = 0, int base = 10 ) const;
     TQString arg( ulong a, int fieldWidth = 0, int base = 10 ) const;
-    TQString arg( Q_LLONG a, int fieldwidth=0, int base=10 ) const;
-    TQString arg( Q_ULLONG a, int fieldwidth=0, int base=10 ) const;
+    TQString arg( TQ_LLONG a, int fieldwidth=0, int base=10 ) const;
+    TQString arg( TQ_ULLONG a, int fieldwidth=0, int base=10 ) const;
     TQString arg( int a, int fieldWidth = 0, int base = 10 ) const;
     TQString arg( uint a, int fieldWidth = 0, int base = 10 ) const;
     TQString arg( short a, int fieldWidth = 0, int base = 10 ) const;
@@ -600,8 +600,8 @@ public:
     uint        toUInt( bool *ok=0, int base=10 )       const;
     long        toLong( bool *ok=0, int base=10 )       const;
     ulong       toULong( bool *ok=0, int base=10 )      const;
-    Q_LLONG     toLongLong( bool *ok=0, int base=10 )   const;
-    Q_ULLONG    toULongLong( bool *ok=0, int base=10 )  const;
+    TQ_LLONG     toLongLong( bool *ok=0, int base=10 )   const;
+    TQ_ULLONG    toULongLong( bool *ok=0, int base=10 )  const;
     float       toFloat( bool *ok=0 )   const;
     double      toDouble( bool *ok=0 )  const;
 
@@ -611,15 +611,15 @@ public:
     TQString    &setNum( uint, int base=10 );
     TQString    &setNum( long, int base=10 );
     TQString    &setNum( ulong, int base=10 );
-    TQString    &setNum( Q_LLONG, int base=10 );
-    TQString    &setNum( Q_ULLONG, int base=10 );
+    TQString    &setNum( TQ_LLONG, int base=10 );
+    TQString    &setNum( TQ_ULLONG, int base=10 );
     TQString    &setNum( float, char f='g', int prec=6 );
     TQString    &setNum( double, char f='g', int prec=6 );
 
     static TQString number( long, int base=10 );
     static TQString number( ulong, int base=10);
-    static TQString number( Q_LLONG, int base=10 );
-    static TQString number( Q_ULLONG, int base=10);
+    static TQString number( TQ_LLONG, int base=10 );
+    static TQString number( TQ_ULLONG, int base=10);
     static TQString number( int, int base=10 );
     static TQString number( uint, int base=10);
     static TQString number( double, char f='g', int prec=6 );
@@ -955,31 +955,31 @@ inline TQString &TQString::prepend( const std::string& s )
 #endif
 
 inline TQString &TQString::setNum( short n, int base )
-{ return setNum((Q_LLONG)n, base); }
+{ return setNum((TQ_LLONG)n, base); }
 
 inline TQString &TQString::setNum( ushort n, int base )
-{ return setNum((Q_ULLONG)n, base); }
+{ return setNum((TQ_ULLONG)n, base); }
 
 inline TQString &TQString::setNum( int n, int base )
-{ return setNum((Q_LLONG)n, base); }
+{ return setNum((TQ_LLONG)n, base); }
 
 inline TQString &TQString::setNum( uint n, int base )
-{ return setNum((Q_ULLONG)n, base); }
+{ return setNum((TQ_ULLONG)n, base); }
 
 inline TQString &TQString::setNum( float n, char f, int prec )
 { return setNum((double)n,f,prec); }
 
 inline TQString TQString::arg( int a, int fieldWidth, int base ) const
-{ return arg( (Q_LLONG)a, fieldWidth, base ); }
+{ return arg( (TQ_LLONG)a, fieldWidth, base ); }
 
 inline TQString TQString::arg( uint a, int fieldWidth, int base ) const
-{ return arg( (Q_ULLONG)a, fieldWidth, base ); }
+{ return arg( (TQ_ULLONG)a, fieldWidth, base ); }
 
 inline TQString TQString::arg( short a, int fieldWidth, int base ) const
-{ return arg( (Q_LLONG)a, fieldWidth, base ); }
+{ return arg( (TQ_LLONG)a, fieldWidth, base ); }
 
 inline TQString TQString::arg( ushort a, int fieldWidth, int base ) const
-{ return arg( (Q_ULLONG)a, fieldWidth, base ); }
+{ return arg( (TQ_ULLONG)a, fieldWidth, base ); }
 
 inline TQString TQString::arg( const TQString& a1, const TQString& a2 ) const {
     return multiArg( 2, a1, a2 );
diff --git a/src/tools/ntqvaluelist.h b/src/tools/ntqvaluelist.h
index 91a437a9..91d50c94 100644
--- a/src/tools/ntqvaluelist.h
+++ b/src/tools/ntqvaluelist.h
@@ -640,9 +640,9 @@ template <class T>
 Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueList<T>& l )
 {
     l.clear();
-    Q_UINT32 c;
+    TQ_UINT32 c;
     s >> c;
-    for( Q_UINT32 i = 0; i < c; ++i )
+    for( TQ_UINT32 i = 0; i < c; ++i )
     {
 	T t;
 	s >> t;
@@ -656,7 +656,7 @@ Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueList<T>& l
 template <class T>
 Q_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQValueList<T>& l )
 {
-    s << (Q_UINT32)l.size();
+    s << (TQ_UINT32)l.size();
     TQValueListConstIterator<T> it = l.begin();
     for( ; it != l.end(); ++it )
 	s << *it;
diff --git a/src/tools/ntqvaluevector.h b/src/tools/ntqvaluevector.h
index 02a15111..6a50230e 100644
--- a/src/tools/ntqvaluevector.h
+++ b/src/tools/ntqvaluevector.h
@@ -547,10 +547,10 @@ template<class T>
 Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueVector<T>& v )
 {
     v.clear();
-    Q_UINT32 c;
+    TQ_UINT32 c;
     s >> c;
     v.resize( c );
-    for( Q_UINT32 i = 0; i < c; ++i )
+    for( TQ_UINT32 i = 0; i < c; ++i )
     {
 	T t;
 	s >> t;
@@ -562,7 +562,7 @@ Q_INLINE_TEMPLATES TQDataStream& operator>>( TQDataStream& s, TQValueVector<T>&
 template<class T>
 Q_INLINE_TEMPLATES TQDataStream& operator<<( TQDataStream& s, const TQValueVector<T>& v )
 {
-    s << (Q_UINT32)v.size();
+    s << (TQ_UINT32)v.size();
     // ### use typename TQValueVector<T>::const_iterator once all supported
     // ### compilers know about the 'typename' keyword.
     const T* it = v.begin();
diff --git a/src/tools/qbitarray.cpp b/src/tools/qbitarray.cpp
index 49074ad9..ec850327 100644
--- a/src/tools/qbitarray.cpp
+++ b/src/tools/qbitarray.cpp
@@ -632,7 +632,7 @@ TQBitArray operator^( const TQBitArray &a1, const TQBitArray &a2 )
 #ifndef QT_NO_DATASTREAM
 TQDataStream &operator<<( TQDataStream &s, const TQBitArray &a )
 {
-    Q_UINT32 len = a.size();
+    TQ_UINT32 len = a.size();
     s << len;					// write size of array
     if ( len > 0 )				// write data
 	s.writeRawBytes( a.data(), a.TQByteArray::size() );
@@ -649,7 +649,7 @@ TQDataStream &operator<<( TQDataStream &s, const TQBitArray &a )
 
 TQDataStream &operator>>( TQDataStream &s, TQBitArray &a )
 {
-    Q_UINT32 len;
+    TQ_UINT32 len;
     s >> len;					// read size of array
     if ( !a.resize( (uint)len ) ) {		// resize array
 #if defined(QT_CHECK_NULL)
diff --git a/src/tools/qbuffer.cpp b/src/tools/qbuffer.cpp
index 34230980..0afa52ae 100644
--- a/src/tools/qbuffer.cpp
+++ b/src/tools/qbuffer.cpp
@@ -285,7 +285,7 @@ bool TQBuffer::at( Offset pos )
   \reimp
 */
 
-Q_LONG TQBuffer::readBlock( char *p, Q_ULONG len )
+TQ_LONG TQBuffer::readBlock( char *p, TQ_ULONG len )
 {
 #if defined(QT_CHECK_STATE)
     if ( !p ) {
@@ -314,7 +314,7 @@ Q_LONG TQBuffer::readBlock( char *p, Q_ULONG len )
 }
 
 /*!
-    \overload Q_LONG TQBuffer::writeBlock( const TQByteArray& data )
+    \overload TQ_LONG TQBuffer::writeBlock( const TQByteArray& data )
 
     This convenience function is the same as calling
     \c{writeBlock( data.data(), data.size() )} with \a data.
@@ -330,7 +330,7 @@ Q_LONG TQBuffer::readBlock( char *p, Q_ULONG len )
     \sa readBlock()
 */
 
-Q_LONG TQBuffer::writeBlock( const char *p, Q_ULONG len )
+TQ_LONG TQBuffer::writeBlock( const char *p, TQ_ULONG len )
 {
     if ( len == 0 )
         return 0;
@@ -352,7 +352,7 @@ Q_LONG TQBuffer::writeBlock( const char *p, Q_ULONG len )
     }
 #endif
     if ( ioIndex + len > a_len ) {              // overflow
-        Q_ULONG new_len = a_len + a_inc*((ioIndex+len-a_len)/a_inc+1);
+        TQ_ULONG new_len = a_len + a_inc*((ioIndex+len-a_len)/a_inc+1);
         if ( !a.resize( new_len ) ) {           // could not resize
 #if defined(QT_CHECK_NULL)
             tqWarning( "TQBuffer::writeBlock: Memory allocation error" );
@@ -376,7 +376,7 @@ Q_LONG TQBuffer::writeBlock( const char *p, Q_ULONG len )
   \reimp
 */
 
-Q_LONG TQBuffer::readLine( char *p, Q_ULONG maxlen )
+TQ_LONG TQBuffer::readLine( char *p, TQ_ULONG maxlen )
 {
 #if defined(QT_CHECK_NULL)
     if ( p == 0 ) {
@@ -396,7 +396,7 @@ Q_LONG TQBuffer::readLine( char *p, Q_ULONG maxlen )
 #endif
     if ( maxlen == 0 )
         return 0;
-    Q_ULONG start = ioIndex;
+    TQ_ULONG start = ioIndex;
     char *d = a.data() + ioIndex;
     maxlen--;                                   // make room for 0-terminator
     if ( a.size() - ioIndex < maxlen )
diff --git a/src/tools/qcstring.cpp b/src/tools/qcstring.cpp
index f6f4f1ff..a3bea8ff 100644
--- a/src/tools/qcstring.cpp
+++ b/src/tools/qcstring.cpp
@@ -268,7 +268,7 @@ int tqstrnicmp( const char *str1, const char *str2, uint len )
 }
 
 
-static Q_UINT16 crc_tbl[16];
+static TQ_UINT16 crc_tbl[16];
 static bool   crc_tbl_init = FALSE;
 
 static void createCRC16Table()			// build CRC16 lookup table
@@ -308,7 +308,7 @@ static void createCRC16Table()			// build CRC16 lookup table
     The checksum is independent of the byte order (endianness).
 */
 
-Q_UINT16 tqChecksum( const char *data, uint len )
+TQ_UINT16 tqChecksum( const char *data, uint len )
 {
     if ( !crc_tbl_init ) {			// create lookup table
 
@@ -322,7 +322,7 @@ Q_UINT16 tqChecksum( const char *data, uint len )
 	    crc_tbl_init = TRUE;
 	}
     }
-    register Q_UINT16 crc = 0xffff;
+    register TQ_UINT16 crc = 0xffff;
     uchar c;
     uchar *p = (uchar *)data;
     while ( len-- ) {
@@ -544,7 +544,7 @@ TQDataStream &operator<<( TQDataStream &s, const TQByteArray &a )
 
 TQDataStream &operator>>( TQDataStream &s, TQByteArray &a )
 {
-    Q_UINT32 len;
+    TQ_UINT32 len;
     s >> len;					// read size of array
     if ( len == 0 || s.eof() ) {		// end of file reached
 	a.resize( 0 );
@@ -2315,7 +2315,7 @@ TQDataStream &operator<<( TQDataStream &s, const TQCString &str )
 TQDataStream &operator>>( TQDataStream &s, TQCString &str )
 {
     str.detach();
-    Q_UINT32 len;
+    TQ_UINT32 len;
     s >> len;					// read size of string
     if ( len == 0 || s.eof() ) {		// end of file reached
 	str.resize( 0 );
diff --git a/src/tools/qdatastream.cpp b/src/tools/qdatastream.cpp
index 1af0d649..33cec9b3 100644
--- a/src/tools/qdatastream.cpp
+++ b/src/tools/qdatastream.cpp
@@ -83,7 +83,7 @@
     file.open( IO_WriteOnly );
     TQDataStream stream( &file ); // we will serialize the data into the file
     stream << "the answer is";   // serialize a string
-    stream << (Q_INT32)42;       // serialize an integer
+    stream << (TQ_INT32)42;       // serialize an integer
     \endcode
 
     Example (read binary data from a stream):
@@ -92,7 +92,7 @@
     file.open( IO_ReadOnly );
     TQDataStream stream( &file );  // read the data serialized from the file
     TQString str;
-    Q_INT32 a;
+    TQ_INT32 a;
     stream >> str >> a;           // extract "the answer is" and 42
     \endcode
 
@@ -139,8 +139,8 @@
     TQDataStream stream( &file );
 
     // Write a header with a "magic number" and a version
-    stream << (Q_UINT32)0xA0B0C0D0;
-    stream << (Q_INT32)123;
+    stream << (TQ_UINT32)0xA0B0C0D0;
+    stream << (TQ_INT32)123;
 
     // Write the data
     stream << [lots of interesting data]
@@ -154,13 +154,13 @@
     TQDataStream stream( &file );
 
     // Read and check the header
-    Q_UINT32 magic;
+    TQ_UINT32 magic;
     stream >> magic;
     if ( magic != 0xA0B0C0D0 )
 	return XXX_BAD_FILE_FORMAT;
 
     // Read the version
-    Q_INT32 version;
+    TQ_INT32 version;
     stream >> version;
     if ( version < 100 )
 	return XXX_BAD_FILE_TOO_OLD;
@@ -193,11 +193,11 @@
 
     A similar pair of functions is readBytes() and writeBytes(). These
     differ from their \e raw counterparts as follows: readBytes()
-    reads a Q_UINT32 which is taken to be the length of the data to be
+    reads a TQ_UINT32 which is taken to be the length of the data to be
     read, then that number of bytes is read into the preallocated
-    char*; writeBytes() writes a Q_UINT32 containing the length of the
+    char*; writeBytes() writes a TQ_UINT32 containing the length of the
     data, followed by the data. Notice that any encoding/decoding of
-    the data (apart from the length Q_UINT32) must be done by you.
+    the data (apart from the length TQ_UINT32) must be done by you.
 
     \sa TQTextStream TQVariant
 */
@@ -491,7 +491,7 @@ void TQDataStream::setByteOrder( int bo )
 extern "C" long long __strtoll( const char *, char**, int );
 #endif
 
-static Q_INT64 read_int_ascii( TQDataStream *s )
+static TQ_INT64 read_int_ascii( TQDataStream *s )
 {
     register int n = 0;
     char buf[40];
@@ -522,7 +522,7 @@ static Q_INT64 read_int_ascii( TQDataStream *s )
 }
 
 /*!
-    \overload TQDataStream &TQDataStream::operator>>( Q_UINT8 &i )
+    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT8 &i )
 
     Reads an unsigned byte from the stream into \a i, and returns a
     reference to the stream.
@@ -533,25 +533,25 @@ static Q_INT64 read_int_ascii( TQDataStream *s )
     reference to the stream.
 */
 
-TQDataStream &TQDataStream::operator>>( Q_INT8 &i )
+TQDataStream &TQDataStream::operator>>( TQ_INT8 &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
-	i = (Q_INT8)dev->getch();
+	i = (TQ_INT8)dev->getch();
 	if ( i == '\\' ) {			// read octal code
 	    char buf[4];
 	    dev->readBlock( buf, 3 );
 	    i = (buf[2] & 0x07)+((buf[1] & 0x07) << 3)+((buf[0] & 0x07) << 6);
 	}
     } else {					// data or text
-	i = (Q_INT8)dev->getch();
+	i = (TQ_INT8)dev->getch();
     }
     return *this;
 }
 
 
 /*!
-    \overload TQDataStream &TQDataStream::operator>>( Q_UINT16 &i )
+    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT16 &i )
 
     Reads an unsigned 16-bit integer from the stream into \a i, and
     returns a reference to the stream.
@@ -564,13 +564,13 @@ TQDataStream &TQDataStream::operator>>( Q_INT8 &i )
     returns a reference to the stream.
 */
 
-TQDataStream &TQDataStream::operator>>( Q_INT16 &i )
+TQDataStream &TQDataStream::operator>>( TQ_INT16 &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
-	i = (Q_INT16)read_int_ascii( this );
+	i = (TQ_INT16)read_int_ascii( this );
     } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&i, sizeof(Q_INT16) );
+	dev->readBlock( (char *)&i, sizeof(TQ_INT16) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[2];
@@ -583,7 +583,7 @@ TQDataStream &TQDataStream::operator>>( Q_INT16 &i )
 
 
 /*!
-    \overload TQDataStream &TQDataStream::operator>>( Q_UINT32 &i )
+    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT32 &i )
 
     Reads an unsigned 32-bit integer from the stream into \a i, and
     returns a reference to the stream.
@@ -596,13 +596,13 @@ TQDataStream &TQDataStream::operator>>( Q_INT16 &i )
     returns a reference to the stream.
 */
 
-TQDataStream &TQDataStream::operator>>( Q_INT32 &i )
+TQDataStream &TQDataStream::operator>>( TQ_INT32 &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
-	i = (Q_INT32)read_int_ascii( this );
+	i = (TQ_INT32)read_int_ascii( this );
     } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&i, sizeof(Q_INT32) );
+	dev->readBlock( (char *)&i, sizeof(TQ_INT32) );
     } else {					// swap bytes
 	uchar *p = (uchar *)(&i);
 	char b[4];
@@ -616,7 +616,7 @@ TQDataStream &TQDataStream::operator>>( Q_INT32 &i )
 }
 
 /*!
-    \overload TQDataStream &TQDataStream::operator>>( Q_UINT64 &i )
+    \overload TQDataStream &TQDataStream::operator>>( TQ_UINT64 &i )
 
     Reads an unsigned 64-bit integer from the stream, into \a i, and
     returns a reference to the stream.
@@ -629,17 +629,17 @@ TQDataStream &TQDataStream::operator>>( Q_INT32 &i )
     returns a reference to the stream.
 */
 
-TQDataStream &TQDataStream::operator>>( Q_INT64 &i )
+TQDataStream &TQDataStream::operator>>( TQ_INT64 &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
 	i = read_int_ascii( this );
     } else if ( version() < 6 ) {
-	Q_UINT32 i1, i2;
+	TQ_UINT32 i1, i2;
 	*this >> i2 >> i1;
-	i = ((Q_UINT64)i1 << 32) + i2;
+	i = ((TQ_UINT64)i1 << 32) + i2;
     } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&i, sizeof(Q_INT64) );
+	dev->readBlock( (char *)&i, sizeof(TQ_INT64) );
     } else {					// swap bytes
 	uchar *p = (uchar *)(&i);
 	char b[8];
@@ -658,7 +658,7 @@ TQDataStream &TQDataStream::operator>>( Q_INT64 &i )
 
 
 /*!
-    \overload TQDataStream &TQDataStream::operator>>( Q_ULONG &i )
+    \overload TQDataStream &TQDataStream::operator>>( TQ_ULONG &i )
 
     Reads an unsigned integer of the system's word length from the
     stream, into \a i, and returns a reference to the stream.
@@ -673,18 +673,18 @@ TQDataStream &TQDataStream::operator>>( Q_INT64 &i )
 
 */
 
-TQDataStream &TQDataStream::operator>>( Q_LONG &i )
+TQDataStream &TQDataStream::operator>>( TQ_LONG &i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
-	i = (Q_LONG)read_int_ascii( this );
+	i = (TQ_LONG)read_int_ascii( this );
     } else if ( noswap ) {			// no conversion needed
-	dev->readBlock( (char *)&i, sizeof(Q_LONG) );
+	dev->readBlock( (char *)&i, sizeof(TQ_LONG) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
-	char b[sizeof(Q_LONG)];
-	dev->readBlock( b, sizeof(Q_LONG) );
-	for ( int j = sizeof(Q_LONG); j;  )
+	char b[sizeof(TQ_LONG)];
+	dev->readBlock( b, sizeof(TQ_LONG) );
+	for ( int j = sizeof(TQ_LONG); j;  )
 	    *p++ = b[--j];
     }
     return *this;
@@ -793,7 +793,7 @@ TQDataStream &TQDataStream::operator>>( char *&s )
 
     The \a l parameter will be set to the length of the buffer.
 
-    The serialization format is a Q_UINT32 length specifier first,
+    The serialization format is a TQ_UINT32 length specifier first,
     then \a l bytes of data. Note that the data is \e not encoded.
 
     \sa readRawBytes(), writeBytes()
@@ -802,7 +802,7 @@ TQDataStream &TQDataStream::operator>>( char *&s )
 TQDataStream &TQDataStream::readBytes( char *&s, uint &l )
 {
     CHECK_STREAM_PRECOND
-    Q_UINT32 len;
+    TQ_UINT32 len;
     *this >> len;				// first read length spec
     l = (uint)len;
     if ( len == 0 || eof() ) {
@@ -831,10 +831,10 @@ TQDataStream &TQDataStream::readRawBytes( char *s, uint len )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
-	register Q_INT8 *p = (Q_INT8*)s;
+	register TQ_INT8 *p = (TQ_INT8*)s;
 	if ( version() < 4 ) {
 	    while ( len-- ) {
-		Q_INT32 tmp;
+		TQ_INT32 tmp;
 		*this >> tmp;
 		*p++ = tmp;
 	    }
@@ -855,7 +855,7 @@ TQDataStream &TQDataStream::readRawBytes( char *s, uint len )
 
 
 /*!
-    \overload TQDataStream &TQDataStream::operator<<( Q_UINT8 i )
+    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT8 i )
 
     Writes an unsigned byte, \a i, to the stream and returns a
     reference to the stream.
@@ -866,7 +866,7 @@ TQDataStream &TQDataStream::readRawBytes( char *s, uint len )
     to the stream.
 */
 
-TQDataStream &TQDataStream::operator<<( Q_INT8 i )
+TQDataStream &TQDataStream::operator<<( TQ_INT8 i )
 {
     CHECK_STREAM_PRECOND
     if ( printable && (i == '\\' || !isprint((uchar) i)) ) {
@@ -885,7 +885,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT8 i )
 
 
 /*!
-    \overload TQDataStream &TQDataStream::operator<<( Q_UINT16 i )
+    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT16 i )
 
     Writes an unsigned 16-bit integer, \a i, to the stream and returns
     a reference to the stream.
@@ -898,7 +898,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT8 i )
     reference to the stream.
 */
 
-TQDataStream &TQDataStream::operator<<( Q_INT16 i )
+TQDataStream &TQDataStream::operator<<( TQ_INT16 i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
@@ -906,7 +906,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT16 i )
 	sprintf( buf, "%d\n", i );
 	dev->writeBlock( buf, strlen(buf) );
     } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&i, sizeof(Q_INT16) );
+	dev->writeBlock( (char *)&i, sizeof(TQ_INT16) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[2];
@@ -924,7 +924,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT16 i )
     reference to the stream.
 */
 
-TQDataStream &TQDataStream::operator<<( Q_INT32 i )
+TQDataStream &TQDataStream::operator<<( TQ_INT32 i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
@@ -932,7 +932,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT32 i )
 	sprintf( buf, "%d\n", i );
 	dev->writeBlock( buf, strlen(buf) );
     } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&i, sizeof(Q_INT32) );
+	dev->writeBlock( (char *)&i, sizeof(TQ_INT32) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[4];
@@ -946,7 +946,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT32 i )
 }
 
 /*!
-    \overload TQDataStream &TQDataStream::operator<<( Q_UINT64 i )
+    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT64 i )
 
     Writes an unsigned 64-bit integer, \a i, to the stream and returns a
     reference to the stream.
@@ -959,7 +959,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT32 i )
     reference to the stream.
 */
 
-TQDataStream &TQDataStream::operator<<( Q_INT64 i )
+TQDataStream &TQDataStream::operator<<( TQ_INT64 i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
@@ -971,11 +971,11 @@ TQDataStream &TQDataStream::operator<<( Q_INT64 i )
 #endif
 	dev->writeBlock( buf, strlen(buf) );
     } else if ( version() < 6 ) {
-	Q_UINT32 i1 = i & 0xffffffff;
-	Q_UINT32 i2 = i >> 32;
+	TQ_UINT32 i1 = i & 0xffffffff;
+	TQ_UINT32 i2 = i >> 32;
 	*this << i2 << i1;
     } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&i, sizeof(Q_INT64) );
+	dev->writeBlock( (char *)&i, sizeof(TQ_INT64) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
 	char b[8];
@@ -993,7 +993,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT64 i )
 }
 
 /*!
-    \overload TQDataStream &TQDataStream::operator<<( Q_ULONG i )
+    \overload TQDataStream &TQDataStream::operator<<( TQ_ULONG i )
 
     Writes an unsigned integer \a i, of the system's word length, to
     the stream and returns a reference to the stream.
@@ -1007,7 +1007,7 @@ TQDataStream &TQDataStream::operator<<( Q_INT64 i )
     stream and returns a reference to the stream.
 */
 
-TQDataStream &TQDataStream::operator<<( Q_LONG i )
+TQDataStream &TQDataStream::operator<<( TQ_LONG i )
 {
     CHECK_STREAM_PRECOND
     if ( printable ) {				// printable data
@@ -1015,13 +1015,13 @@ TQDataStream &TQDataStream::operator<<( Q_LONG i )
 	sprintf( buf, "%ld\n", i );
 	dev->writeBlock( buf, strlen(buf) );
     } else if ( noswap ) {			// no conversion needed
-	dev->writeBlock( (char *)&i, sizeof(Q_LONG) );
+	dev->writeBlock( (char *)&i, sizeof(TQ_LONG) );
     } else {					// swap bytes
 	register uchar *p = (uchar *)(&i);
-	char b[sizeof(Q_LONG)];
-	for ( int j = sizeof(Q_LONG); j;  )
+	char b[sizeof(TQ_LONG)];
+	for ( int j = sizeof(TQ_LONG); j;  )
 	    b[--j] = *p++;
-	dev->writeBlock( b, sizeof(Q_LONG) );
+	dev->writeBlock( b, sizeof(TQ_LONG) );
     }
     return *this;
 }
@@ -1029,10 +1029,10 @@ TQDataStream &TQDataStream::operator<<( Q_LONG i )
 
 
 /*!
-    \overload TQDataStream &TQDataStream::operator<<( Q_UINT32 i )
+    \overload TQDataStream &TQDataStream::operator<<( TQ_UINT32 i )
 
     Writes an unsigned integer, \a i, to the stream as a 32-bit
-    unsigned integer (Q_UINT32). Returns a reference to the stream.
+    unsigned integer (TQ_UINT32). Returns a reference to the stream.
 */
 
 /*!
@@ -1112,11 +1112,11 @@ TQDataStream &TQDataStream::operator<<( double f )
 TQDataStream &TQDataStream::operator<<( const char *s )
 {
     if ( !s ) {
-	*this << (Q_UINT32)0;
+	*this << (TQ_UINT32)0;
 	return *this;
     }
     uint len = tqstrlen( s ) + 1;			// also write null terminator
-    *this << (Q_UINT32)len;			// write length specifier
+    *this << (TQ_UINT32)len;			// write length specifier
     return writeRawBytes( s, len );
 }
 
@@ -1125,7 +1125,7 @@ TQDataStream &TQDataStream::operator<<( const char *s )
     Writes the length specifier \a len and the buffer \a s to the
     stream and returns a reference to the stream.
 
-    The \a len is serialized as a Q_UINT32, followed by \a len bytes
+    The \a len is serialized as a TQ_UINT32, followed by \a len bytes
     from \a s. Note that the data is \e not encoded.
 
     \sa writeRawBytes(), readBytes()
@@ -1134,7 +1134,7 @@ TQDataStream &TQDataStream::operator<<( const char *s )
 TQDataStream &TQDataStream::writeBytes(const char *s, uint len)
 {
     CHECK_STREAM_PRECOND
-    *this << (Q_UINT32)len;			// write length specifier
+    *this << (TQ_UINT32)len;			// write length specifier
     if ( len )
 	writeRawBytes( s, len );
     return *this;
@@ -1157,7 +1157,7 @@ TQDataStream &TQDataStream::writeRawBytes( const char *s, uint len )
 	    while ( len-- )
 		*this << *p++;
 	} else {
-	    register Q_INT8 *p = (Q_INT8*)s;
+	    register TQ_INT8 *p = (TQ_INT8*)s;
 	    while ( len-- )
 		*this << *p++;
 	}
diff --git a/src/tools/qdatetime.cpp b/src/tools/qdatetime.cpp
index 00eba97d..6a8d45e2 100644
--- a/src/tools/qdatetime.cpp
+++ b/src/tools/qdatetime.cpp
@@ -2523,7 +2523,7 @@ TQDateTime TQDateTime::fromString( const TQString& s, TQt::DateFormat f )
 
 TQDataStream &operator<<( TQDataStream &s, const TQDate &d )
 {
-    return s << (Q_UINT32)(d.jd);
+    return s << (TQ_UINT32)(d.jd);
 }
 
 /*!
@@ -2536,7 +2536,7 @@ TQDataStream &operator<<( TQDataStream &s, const TQDate &d )
 
 TQDataStream &operator>>( TQDataStream &s, TQDate &d )
 {
-    Q_UINT32 jd;
+    TQ_UINT32 jd;
     s >> jd;
     d.jd = jd;
     return s;
@@ -2552,7 +2552,7 @@ TQDataStream &operator>>( TQDataStream &s, TQDate &d )
 
 TQDataStream &operator<<( TQDataStream &s, const TQTime &t )
 {
-    return s << (Q_UINT32)(t.ds);
+    return s << (TQ_UINT32)(t.ds);
 }
 
 /*!
@@ -2565,7 +2565,7 @@ TQDataStream &operator<<( TQDataStream &s, const TQTime &t )
 
 TQDataStream &operator>>( TQDataStream &s, TQTime &t )
 {
-    Q_UINT32 ds;
+    TQ_UINT32 ds;
     s >> ds;
     t.ds = ds;
     return s;
diff --git a/src/tools/qfile.cpp b/src/tools/qfile.cpp
index eee25683..47f77b5e 100644
--- a/src/tools/qfile.cpp
+++ b/src/tools/qfile.cpp
@@ -150,7 +150,7 @@ extern bool qt_file_access( const TQString& fn, int t );
 */
 
 /*!
-    \fn Q_LONG TQFile::writeBlock( const TQByteArray& data )
+    \fn TQ_LONG TQFile::writeBlock( const TQByteArray& data )
 
     \overload
 */
@@ -366,7 +366,7 @@ bool TQFile::atEnd() const
     \sa readBlock(), TQTextStream::readLine()
 */
 
-Q_LONG TQFile::readLine( char *p, Q_ULONG maxlen )
+TQ_LONG TQFile::readLine( char *p, TQ_ULONG maxlen )
 {
     if ( maxlen == 0 )				// application bug?
 	return 0;
@@ -381,7 +381,7 @@ Q_LONG TQFile::readLine( char *p, Q_ULONG maxlen )
 	return -1;
     }
 #endif
-    Q_LONG nread;				// number of bytes read
+    TQ_LONG nread;				// number of bytes read
     if ( isRaw() ) {				// raw file
 	nread = TQIODevice::readLine( p, maxlen );
     } else {					// buffered file
@@ -419,10 +419,10 @@ Q_LONG TQFile::readLine( char *p, Q_ULONG maxlen )
     \sa readBlock(), TQTextStream::readLine()
 */
 
-Q_LONG TQFile::readLine( TQString& s, Q_ULONG maxlen )
+TQ_LONG TQFile::readLine( TQString& s, TQ_ULONG maxlen )
 {
     TQByteArray ba(maxlen);
-    Q_LONG l = readLine(ba.data(),maxlen);
+    TQ_LONG l = readLine(ba.data(),maxlen);
     if ( l >= 0 ) {
 	ba.truncate(l);
 	s = TQString(ba);
diff --git a/src/tools/qfile_unix.cpp b/src/tools/qfile_unix.cpp
index 90decadb..9aa4b1f6 100644
--- a/src/tools/qfile_unix.cpp
+++ b/src/tools/qfile_unix.cpp
@@ -553,7 +553,7 @@ bool TQFile::at( Offset pos )
   readBlock() solved this problem.
 */
 
-Q_LONG TQFile::readBlock( char *p, Q_ULONG len )
+TQ_LONG TQFile::readBlock( char *p, TQ_ULONG len )
 {
     if ( !len ) // nothing to do
 	return 0;
@@ -572,7 +572,7 @@ Q_LONG TQFile::readBlock( char *p, Q_ULONG len )
 	return -1;
     }
 #endif
-    Q_ULONG nread = 0;					// number of bytes read
+    TQ_ULONG nread = 0;					// number of bytes read
     if ( !ungetchBuffer.isEmpty() ) {
 	// need to add these to the returned string.
 	uint l = ungetchBuffer.length();
@@ -622,7 +622,7 @@ Q_LONG TQFile::readBlock( char *p, Q_ULONG len )
   \sa readBlock()
 */
 
-Q_LONG TQFile::writeBlock( const char *p, Q_ULONG len )
+TQ_LONG TQFile::writeBlock( const char *p, TQ_ULONG len )
 {
     if ( !len ) // nothing to do
 	return 0;
@@ -641,7 +641,7 @@ Q_LONG TQFile::writeBlock( const char *p, Q_ULONG len )
 	return -1;
     }
 #endif
-    Q_ULONG nwritten;				// number of bytes written
+    TQ_ULONG nwritten;				// number of bytes written
     if ( isRaw() )				// raw file
 	nwritten = ::write( fd, (void *)p, len );
     else					// buffered file
diff --git a/src/tools/qgarray.cpp b/src/tools/qgarray.cpp
index 31e88179..f2b41e50 100644
--- a/src/tools/qgarray.cpp
+++ b/src/tools/qgarray.cpp
@@ -324,13 +324,13 @@ bool TQGArray::fill( const char *d, int len, uint sz )
     if ( sz == 1 )				// 8 bit elements
 	memset( data(), *d, len );
     else if ( sz == 4 ) {			// 32 bit elements
-	register Q_INT32 *x = (Q_INT32*)data();
-	Q_INT32 v = *((Q_INT32*)d);
+	register TQ_INT32 *x = (TQ_INT32*)data();
+	TQ_INT32 v = *((TQ_INT32*)d);
 	while ( len-- )
 	    *x++ = v;
     } else if ( sz == 2 ) {			// 16 bit elements
-	register Q_INT16 *x = (Q_INT16*)data();
-	Q_INT16 v = *((Q_INT16*)d);
+	register TQ_INT16 *x = (TQ_INT16*)data();
+	TQ_INT16 v = *((TQ_INT16*)d);
 	while ( len-- )
 	    *x++ = v;
     } else {					// any other size elements
@@ -619,8 +619,8 @@ int TQGArray::find( const char *d, uint index, uint sz ) const
 	    }
 	    break;
 	case 2: {				// 16 bit elements
-	    register Q_INT16 *x = (Q_INT16*)(data() + index);
-	    Q_INT16 v = *((Q_INT16*)d);
+	    register TQ_INT16 *x = (TQ_INT16*)(data() + index);
+	    TQ_INT16 v = *((TQ_INT16*)d);
 	    for ( i=index; i<shd->len; i+=2 ) {
 		if ( *x++ == v )
 		    break;
@@ -629,8 +629,8 @@ int TQGArray::find( const char *d, uint index, uint sz ) const
 	    }
 	    break;
 	case 4: {				// 32 bit elements
-	    register Q_INT32 *x = (Q_INT32*)(data() + index);
-	    Q_INT32 v = *((Q_INT32*)d);
+	    register TQ_INT32 *x = (TQ_INT32*)(data() + index);
+	    TQ_INT32 v = *((TQ_INT32*)d);
 	    for ( i=index; i<shd->len; i+=4 ) {
 		if ( *x++ == v )
 		    break;
@@ -672,8 +672,8 @@ int TQGArray::contains( const char *d, uint sz ) const
 	    }
 	    break;
 	case 2: {				// 16 bit elements
-	    register Q_INT16 *x = (Q_INT16*)data();
-	    Q_INT16 v = *((Q_INT16*)d);
+	    register TQ_INT16 *x = (TQ_INT16*)data();
+	    TQ_INT16 v = *((TQ_INT16*)d);
 	    i /= 2;
 	    while ( i-- ) {
 		if ( *x++ == v )
@@ -682,8 +682,8 @@ int TQGArray::contains( const char *d, uint sz ) const
 	    }
 	    break;
 	case 4: {				// 32 bit elements
-	    register Q_INT32 *x = (Q_INT32*)data();
-	    Q_INT32 v = *((Q_INT32*)d);
+	    register TQ_INT32 *x = (TQ_INT32*)data();
+	    TQ_INT32 v = *((TQ_INT32*)d);
 	    i /= 4;
 	    while ( i-- ) {
 		if ( *x++ == v )
diff --git a/src/tools/qgdict.cpp b/src/tools/qgdict.cpp
index 22574524..e794a43f 100644
--- a/src/tools/qgdict.cpp
+++ b/src/tools/qgdict.cpp
@@ -934,7 +934,7 @@ TQDataStream &TQGDict::read( TQDataStream &s )
 		break;
 	    case IntKey:
 		{
-		    Q_UINT32 k;
+		    TQ_UINT32 k;
 		    s >> k;
 		    read( s, d );
 		    look_int( k, d, op_insert );
@@ -942,7 +942,7 @@ TQDataStream &TQGDict::read( TQDataStream &s )
 		break;
 	    case PtrKey:
 		{
-		    Q_UINT32 k;
+		    TQ_UINT32 k;
 		    s >> k;
 		    read( s, d );
 		    // ### cannot insert 0 - this renders the thing
@@ -977,10 +977,10 @@ TQDataStream& TQGDict::write( TQDataStream &s ) const
 		    s << ((TQAsciiBucket*)n)->getKey();
 		    break;
 		case IntKey:
-		    s << (Q_UINT32)((TQIntBucket*)n)->getKey();
+		    s << (TQ_UINT32)((TQIntBucket*)n)->getKey();
 		    break;
 		case PtrKey:
-		    s << (Q_UINT32)0; // ### cannot serialize a pointer
+		    s << (TQ_UINT32)0; // ### cannot serialize a pointer
 		    break;
 	    }
 	    write( s, n->getData() );		// write data
diff --git a/src/tools/qglobal.cpp b/src/tools/qglobal.cpp
index 296e600f..07074c9f 100644
--- a/src/tools/qglobal.cpp
+++ b/src/tools/qglobal.cpp
@@ -113,7 +113,7 @@ bool tqSysInfo( int *wordSize, bool *bigEndian )
     }
 
     si_wordSize = 0;
-    Q_ULONG n = (Q_ULONG)(~0);
+    TQ_ULONG n = (TQ_ULONG)(~0);
     while ( n ) {				// detect word size
 	si_wordSize++;
 	n /= 2;
@@ -128,8 +128,8 @@ bool tqSysInfo( int *wordSize, bool *bigEndian )
 #endif
 	return FALSE;
     }
-    if ( sizeof(Q_INT8) != 1 || sizeof(Q_INT16) != 2 || sizeof(Q_INT32) != 4 ||
-	 sizeof(Q_ULONG)*8 != si_wordSize || sizeof(float) != 4 || sizeof(double) != 8 ) {
+    if ( sizeof(TQ_INT8) != 1 || sizeof(TQ_INT16) != 2 || sizeof(TQ_INT32) != 4 ||
+	 sizeof(TQ_ULONG)*8 != si_wordSize || sizeof(float) != 4 || sizeof(double) != 8 ) {
 #if defined(QT_CHECK_RANGE)
 	tqFatal( "qSysInfo: Unsupported system data type size" );
 #endif
diff --git a/src/tools/qgpluginmanager.cpp b/src/tools/qgpluginmanager.cpp
index ac8a2eeb..8e2ea9a0 100644
--- a/src/tools/qgpluginmanager.cpp
+++ b/src/tools/qgpluginmanager.cpp
@@ -136,8 +136,8 @@ public:
       efficiency.
     */
     union {
-	Q_UINT8 b[52];
-	Q_UINT32 w[13];
+	TQ_UINT8 b[52];
+	TQ_UINT32 w[13];
     };
 
     TQCoMatrix() { memset( b, 0, 52 ); }
diff --git a/src/tools/qiodevice.cpp b/src/tools/qiodevice.cpp
index 6e584ec4..4f89ddea 100644
--- a/src/tools/qiodevice.cpp
+++ b/src/tools/qiodevice.cpp
@@ -611,7 +611,7 @@ bool TQIODevice::atEnd() const
 
 
 /*!
-    \fn int TQIODevice::readBlock( char *data, Q_ULONG maxlen )
+    \fn int TQIODevice::readBlock( char *data, TQ_ULONG maxlen )
 
     Reads at most \a maxlen bytes from the I/O device into \a data and
     returns the number of bytes actually read.
@@ -671,7 +671,7 @@ TQByteArray TQIODevice::readAll()
 }
 
 /*!
-    \fn int TQIODevice::writeBlock( const char *data, Q_ULONG len )
+    \fn int TQIODevice::writeBlock( const char *data, TQ_ULONG len )
 
     Writes \a len bytes from \a data to the I/O device and returns the
     number of bytes actually written.
@@ -689,7 +689,7 @@ TQByteArray TQIODevice::readAll()
     This convenience function is the same as calling writeBlock(
     data.data(), data.size() ).
 */
-Q_LONG TQIODevice::writeBlock( const TQByteArray& data )
+TQ_LONG TQIODevice::writeBlock( const TQByteArray& data )
 {
     return writeBlock( data.data(), data.size() );
 }
@@ -708,7 +708,7 @@ Q_LONG TQIODevice::writeBlock( const TQByteArray& data )
     \sa readBlock(), TQTextStream::readLine()
 */
 
-Q_LONG TQIODevice::readLine( char *data, Q_ULONG maxlen )
+TQ_LONG TQIODevice::readLine( char *data, TQ_ULONG maxlen )
 {
     if ( maxlen == 0 )				// application bug?
 	return 0;
diff --git a/src/tools/qlocale.cpp b/src/tools/qlocale.cpp
index 3dabc3ee..2b9a10bc 100644
--- a/src/tools/qlocale.cpp
+++ b/src/tools/qlocale.cpp
@@ -163,8 +163,8 @@ static char *_qdtoa(double d, int mode, int ndigits, int *decpt,
                         int *sign, char **rve, char **digits_str);
 static double qstrtod(const char *s00, char const **se, bool *ok);
 #endif
-static Q_LLONG qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok);
-static Q_ULLONG qstrtoull(const char *nptr, const char **endptr, register int base, bool *ok);
+static TQ_LLONG qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok);
+static TQ_ULLONG qstrtoull(const char *nptr, const char **endptr, register int base, bool *ok);
 
 static inline bool compareBits(double d1, double d2)
 {
@@ -2677,7 +2677,7 @@ TQString TQLocale::countryToString(Country country)
 
 short TQLocale::toShort(const TQString &s, bool *ok) const
 {
-    Q_LLONG i = toLongLong(s, ok);
+    TQ_LLONG i = toLongLong(s, ok);
     if (i < SHRT_MIN || i > SHRT_MAX) {
         if (ok != 0)
             *ok = FALSE;
@@ -2700,7 +2700,7 @@ short TQLocale::toShort(const TQString &s, bool *ok) const
 
 ushort TQLocale::toUShort(const TQString &s, bool *ok) const
 {
-    Q_ULLONG i = toULongLong(s, ok);
+    TQ_ULLONG i = toULongLong(s, ok);
     if (i > USHRT_MAX) {
         if (ok != 0)
             *ok = FALSE;
@@ -2723,7 +2723,7 @@ ushort TQLocale::toUShort(const TQString &s, bool *ok) const
 
 int TQLocale::toInt(const TQString &s, bool *ok) const
 {
-    Q_LLONG i = toLongLong(s, ok);
+    TQ_LLONG i = toLongLong(s, ok);
     if (i < INT_MIN || i > INT_MAX) {
         if (ok != 0)
             *ok = FALSE;
@@ -2746,7 +2746,7 @@ int TQLocale::toInt(const TQString &s, bool *ok) const
 
 uint TQLocale::toUInt(const TQString &s, bool *ok) const
 {
-    Q_ULLONG i = toULongLong(s, ok);
+    TQ_ULLONG i = toULongLong(s, ok);
     if (i > UINT_MAX) {
         if (ok != 0)
             *ok = FALSE;
@@ -2767,15 +2767,15 @@ uint TQLocale::toUInt(const TQString &s, bool *ok) const
     \sa toString()
 */
 
-Q_LONG TQLocale::toLong(const TQString &s, bool *ok) const
+TQ_LONG TQLocale::toLong(const TQString &s, bool *ok) const
 {
-    Q_LLONG i = toLongLong(s, ok);
+    TQ_LLONG i = toLongLong(s, ok);
     if (i < LONG_MIN || i > LONG_MAX) {
         if (ok != 0)
             *ok = FALSE;
         return 0;
     }
-    return (Q_LONG) i;
+    return (TQ_LONG) i;
 }
 
 /*!
@@ -2790,15 +2790,15 @@ Q_LONG TQLocale::toLong(const TQString &s, bool *ok) const
     \sa toString()
 */
 
-Q_ULONG TQLocale::toULong(const TQString &s, bool *ok) const
+TQ_ULONG TQLocale::toULong(const TQString &s, bool *ok) const
 {
-    Q_ULLONG i = toULongLong(s, ok);
+    TQ_ULLONG i = toULongLong(s, ok);
     if (i > ULONG_MAX) {
         if (ok != 0)
             *ok = FALSE;
         return 0;
     }
-    return (Q_ULONG) i;
+    return (TQ_ULONG) i;
 }
 
 /*!
@@ -2814,7 +2814,7 @@ Q_ULONG TQLocale::toULong(const TQString &s, bool *ok) const
 */
 
 
-Q_LLONG TQLocale::toLongLong(const TQString &s, bool *ok) const
+TQ_LLONG TQLocale::toLongLong(const TQString &s, bool *ok) const
 {
     return d->stringToLongLong(s, 0, ok, TQLocalePrivate::ParseGroupSeparators);
 }
@@ -2832,7 +2832,7 @@ Q_LLONG TQLocale::toLongLong(const TQString &s, bool *ok) const
 */
 
 
-Q_ULLONG TQLocale::toULongLong(const TQString &s, bool *ok) const
+TQ_ULLONG TQLocale::toULongLong(const TQString &s, bool *ok) const
 {
     return d->stringToUnsLongLong(s, 0, ok, TQLocalePrivate::ParseGroupSeparators);
 }
@@ -2912,7 +2912,7 @@ double TQLocale::toDouble(const TQString &s, bool *ok) const
     \sa toLongLong()
 */
 
-TQString TQLocale::toString(Q_LLONG i) const
+TQString TQLocale::toString(TQ_LLONG i) const
 {
     return d->longLongToString(i, -1, 10, -1, TQLocalePrivate::ThousandsGroup);
 }
@@ -2923,7 +2923,7 @@ TQString TQLocale::toString(Q_LLONG i) const
     \sa toULongLong()
 */
 
-TQString TQLocale::toString(Q_ULLONG i) const
+TQString TQLocale::toString(TQ_ULLONG i) const
 {
     return d->unsLongLongToString(i, -1, 10, -1, TQLocalePrivate::ThousandsGroup);
 }
@@ -3033,7 +3033,7 @@ TQLocale TQLocale::system()
 */
 
 /*!
-\fn TQString TQLocale::toString(Q_LONG i) const
+\fn TQString TQLocale::toString(TQ_LONG i) const
 
 \overload
 
@@ -3041,7 +3041,7 @@ TQLocale TQLocale::system()
 */
 
 /*!
-\fn TQString TQLocale::toString(Q_ULONG i) const
+\fn TQString TQLocale::toString(TQ_ULONG i) const
 
 \overload
 
@@ -3075,7 +3075,7 @@ static char digitToCLocale(TQChar zero, TQChar d)
     return TQChar(0);
 }
 
-static TQString qulltoa(Q_ULLONG l, int base, const TQLocalePrivate &locale)
+static TQString qulltoa(TQ_ULLONG l, int base, const TQLocalePrivate &locale)
 {
     TQChar buff[65]; // length of MAX_ULLONG in base 2
     TQChar *p = buff + 65;
@@ -3107,7 +3107,7 @@ static TQString qulltoa(Q_ULLONG l, int base, const TQLocalePrivate &locale)
     return TQString(p, 65 - (p - buff));
 }
 
-static TQString qlltoa(Q_LLONG l, int base, const TQLocalePrivate &locale)
+static TQString qlltoa(TQ_LLONG l, int base, const TQLocalePrivate &locale)
 {
     return qulltoa(l < 0 ? -l : l, base, locale);
 }
@@ -3368,7 +3368,7 @@ TQString TQLocalePrivate::doubleToString(double d,
     return num_str;
 }
 
-TQString TQLocalePrivate::longLongToString(Q_LLONG l, int precision,
+TQString TQLocalePrivate::longLongToString(TQ_LLONG l, int precision,
                                             int base, int width,
                                             unsigned flags) const
 {
@@ -3453,7 +3453,7 @@ TQString TQLocalePrivate::longLongToString(Q_LLONG l, int precision,
     return num_str;
 }
 
-TQString TQLocalePrivate::unsLongLongToString(Q_ULLONG l, int precision,
+TQString TQLocalePrivate::unsLongLongToString(TQ_ULLONG l, int precision,
                                             int base, int width,
                                             unsigned flags) const
 {
@@ -3703,7 +3703,7 @@ double TQLocalePrivate::stringToDouble(TQString num,
         return d;
 }
 
-Q_LLONG TQLocalePrivate::stringToLongLong(TQString num, int base,
+TQ_LLONG TQLocalePrivate::stringToLongLong(TQString num, int base,
                                     bool *ok,
                                     GroupSeparatorMode group_sep_mode) const
 {
@@ -3716,7 +3716,7 @@ Q_LLONG TQLocalePrivate::stringToLongLong(TQString num, int base,
     bool _ok;
     const char *endptr;
     const char *num_buff = num.latin1();
-    Q_LLONG l = qstrtoll(num_buff, &endptr, base, &_ok);
+    TQ_LLONG l = qstrtoll(num_buff, &endptr, base, &_ok);
 
     if (!_ok || *endptr != '\0') {
         if (ok != 0)
@@ -3729,7 +3729,7 @@ Q_LLONG TQLocalePrivate::stringToLongLong(TQString num, int base,
     return l;
 }
 
-Q_ULLONG TQLocalePrivate::stringToUnsLongLong(TQString num, int base,
+TQ_ULLONG TQLocalePrivate::stringToUnsLongLong(TQString num, int base,
                                     bool *ok,
                                     GroupSeparatorMode group_sep_mode) const
 {
@@ -3742,7 +3742,7 @@ Q_ULLONG TQLocalePrivate::stringToUnsLongLong(TQString num, int base,
     bool _ok;
     const char *endptr;
     const char *num_buff = num.latin1();
-    Q_ULLONG l = qstrtoull(num_buff, &endptr, base, &_ok);
+    TQ_ULLONG l = qstrtoull(num_buff, &endptr, base, &_ok);
 
     if (!_ok || *endptr != '\0') {
         if (ok != 0)
@@ -3792,17 +3792,17 @@ Q_ULLONG TQLocalePrivate::stringToUnsLongLong(TQString num, int base,
 //  "$FreeBSD: src/lib/libc/stdlib/strtoull.c,v 1.5.2.1 2001/03/02 09:45:20 obrien Exp $";
 
 /*
- * Convert a string to an Q_ULLONG integer.
+ * Convert a string to an TQ_ULLONG integer.
  *
  * Ignores `locale' stuff.  Assumes that the upper and lower case
  * alphabets and digits are each contiguous.
  */
-static Q_ULLONG qstrtoull(const char *nptr, const char **endptr, register int base, bool *ok)
+static TQ_ULLONG qstrtoull(const char *nptr, const char **endptr, register int base, bool *ok)
 {
     register const char *s = nptr;
-    register Q_ULLONG acc;
+    register TQ_ULLONG acc;
     register unsigned char c;
-    register Q_ULLONG qbase, cutoff;
+    register TQ_ULLONG qbase, cutoff;
     register int neg, any, cutlim;
 
     if (ok != 0)
@@ -3835,8 +3835,8 @@ static Q_ULLONG qstrtoull(const char *nptr, const char **endptr, register int ba
     if (base == 0)
         base = c == '0' ? 8 : 10;
     qbase = (unsigned)base;
-    cutoff = (Q_ULLONG)ULLONG_MAX / qbase;
-    cutlim = (Q_ULLONG)ULLONG_MAX % qbase;
+    cutoff = (TQ_ULLONG)ULLONG_MAX / qbase;
+    cutlim = (TQ_ULLONG)ULLONG_MAX % qbase;
     for (acc = 0, any = 0;; c = *s++) {
         if (!isascii(c))
             break;
@@ -3873,17 +3873,17 @@ static Q_ULLONG qstrtoull(const char *nptr, const char **endptr, register int ba
 
 
 /*
- * Convert a string to a Q_LLONG integer.
+ * Convert a string to a TQ_LLONG integer.
  *
  * Ignores `locale' stuff.  Assumes that the upper and lower case
  * alphabets and digits are each contiguous.
  */
-static Q_LLONG qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok)
+static TQ_LLONG qstrtoll(const char *nptr, const char **endptr, register int base, bool *ok)
 {
     register const char *s;
-    register Q_ULLONG acc;
+    register TQ_ULLONG acc;
     register unsigned char c;
-    register Q_ULLONG qbase, cutoff;
+    register TQ_ULLONG qbase, cutoff;
     register int neg, any, cutlim;
 
     if (ok != 0)
@@ -3934,7 +3934,7 @@ static Q_LLONG qstrtoll(const char *nptr, const char **endptr, register int base
      * overflow.
      */
     qbase = (unsigned)base;
-    cutoff = neg ? (Q_ULLONG)-(LLONG_MIN + LLONG_MAX) + LLONG_MAX
+    cutoff = neg ? (TQ_ULLONG)-(LLONG_MIN + LLONG_MAX) + LLONG_MAX
         : LLONG_MAX;
     cutlim = cutoff % qbase;
     cutoff /= qbase;
@@ -4075,8 +4075,8 @@ __RCSID("$NetBSD: strtod.c,v 1.26 1998/02/03 18:44:21 perry Exp $");
 #define VAX
 #endif
 
-#define Long        Q_INT32
-#define ULong        Q_UINT32
+#define Long        TQ_INT32
+#define ULong        TQ_UINT32
 
 #define MALLOC malloc
 #define CONST const
diff --git a/src/tools/qlocale_p.h b/src/tools/qlocale_p.h
index 1b80a4c8..dbe14ca0 100644
--- a/src/tools/qlocale_p.h
+++ b/src/tools/qlocale_p.h
@@ -67,8 +67,8 @@ public:
     TQString infinity() const;
     TQString nan() const;
 
-    Q_UINT32 languageId() const { return m_language_id; }
-    Q_UINT32 countryId() const { return m_country_id; }
+    TQ_UINT32 languageId() const { return m_language_id; }
+    TQ_UINT32 countryId() const { return m_country_id; }
 
     bool isDigit(TQChar d) const;
 
@@ -102,23 +102,23 @@ public:
 			   DoubleForm form = DFSignificantDigits,
 			   int width = -1,
 			   unsigned flags = NoFlags) const;
-    TQString longLongToString(Q_LLONG l, int precision = -1,
+    TQString longLongToString(TQ_LLONG l, int precision = -1,
 			     int base = 10,
 			     int width = -1,
 			     unsigned flags = NoFlags) const;
-    TQString unsLongLongToString(Q_ULLONG l, int precision = -1,
+    TQString unsLongLongToString(TQ_ULLONG l, int precision = -1,
 				int base = 10,
 				int width = -1,
 				unsigned flags = NoFlags) const;
     double stringToDouble(TQString num, bool *ok, GroupSeparatorMode group_sep_mode) const;
-    Q_LLONG stringToLongLong(TQString num, int base, bool *ok, GroupSeparatorMode group_sep_mode) const;
-    Q_ULLONG stringToUnsLongLong(TQString num, int base, bool *ok, GroupSeparatorMode group_sep_mode) const;
+    TQ_LLONG stringToLongLong(TQString num, int base, bool *ok, GroupSeparatorMode group_sep_mode) const;
+    TQ_ULLONG stringToUnsLongLong(TQString num, int base, bool *ok, GroupSeparatorMode group_sep_mode) const;
     bool removeGroupSeparators(TQString &num_str) const;
     bool numberToCLocale(TQString &locale_num, GroupSeparatorMode group_sep_mode) const;
 
-    Q_UINT32 m_language_id, m_country_id;
+    TQ_UINT32 m_language_id, m_country_id;
 
-    Q_UINT16 m_decimal, m_group, m_list, m_percent,
+    TQ_UINT16 m_decimal, m_group, m_list, m_percent,
 	m_zero, m_minus, m_exponential;
 
     static const TQString m_infinity;
diff --git a/src/tools/qstring.cpp b/src/tools/qstring.cpp
index bb521868..86ba4246 100644
--- a/src/tools/qstring.cpp
+++ b/src/tools/qstring.cpp
@@ -642,7 +642,7 @@ const TQString &TQChar::decomposition() const
     pos+=2;
 
     TQString s;
-    Q_UINT16 c;
+    TQ_UINT16 c;
     while ( (c = TQUnicodeTables::decomposition_map[pos++]) != 0 )
 	s += TQChar( c );
     // ### In 4.0, return s, and not shared_decomp.  shared_decomp
@@ -926,17 +926,17 @@ class TQLigature
 public:
     TQLigature( TQChar c );
 
-    Q_UINT16 first() { cur = ligatures; return cur ? *cur : 0; }
-    Q_UINT16 next() { return cur && *cur ? *(cur++) : 0; }
-    Q_UINT16 current() { return cur ? *cur : 0; }
+    TQ_UINT16 first() { cur = ligatures; return cur ? *cur : 0; }
+    TQ_UINT16 next() { return cur && *cur ? *(cur++) : 0; }
+    TQ_UINT16 current() { return cur ? *cur : 0; }
 
     int match(TQString & str, unsigned int index);
     TQChar head();
     TQChar::Decomposition tag();
 
 private:
-    Q_UINT16 *ligatures;
-    Q_UINT16 *cur;
+    TQ_UINT16 *ligatures;
+    TQ_UINT16 *cur;
 };
 
 TQLigature::TQLigature( TQChar c )
@@ -947,7 +947,7 @@ TQLigature::TQLigature( TQChar c )
     else
     {
 	pos = TQUnicodeTables::ligature_info[(pos<<8)+c.cell()];
-	ligatures = (Q_UINT16 *)&(TQUnicodeTables::ligature_map[pos]);
+	ligatures = (TQ_UINT16 *)&(TQUnicodeTables::ligature_map[pos]);
     }
     cur = ligatures;
 }
@@ -974,8 +974,8 @@ int TQLigature::match(TQString & str, unsigned int index)
 
     if(!current()) return 0;
 
-    Q_UINT16 lig = current() + 2;
-    Q_UINT16 ch;
+    TQ_UINT16 lig = current() + 2;
+    TQ_UINT16 ch;
 
     while ((i < str.length()) && (ch = TQUnicodeTables::decomposition_map[lig])) {
 	if (str[(int)i] != TQChar(ch))
@@ -2076,7 +2076,7 @@ TQString TQString::arg( const TQString& a, int fieldWidth ) const
 */
 TQString TQString::arg( long a, int fieldWidth, int base ) const
 {
-    return arg((Q_LLONG)a, fieldWidth, base);
+    return arg((TQ_LLONG)a, fieldWidth, base);
 }
 
 /*!
@@ -2088,7 +2088,7 @@ TQString TQString::arg( long a, int fieldWidth, int base ) const
 */
 TQString TQString::arg( ulong a, int fieldWidth, int base ) const
 {
-    return arg((Q_ULLONG)a, fieldWidth, base);
+    return arg((TQ_ULLONG)a, fieldWidth, base);
 }
 
 /*!
@@ -2098,7 +2098,7 @@ TQString TQString::arg( ulong a, int fieldWidth, int base ) const
     be between 2 and 36. If \a base is 10, the '%L' syntax can be used
     to produce localized strings.
 */
-TQString TQString::arg( Q_LLONG a, int fieldWidth, int base ) const
+TQString TQString::arg( TQ_LLONG a, int fieldWidth, int base ) const
 {
     ArgEscapeData d = findArgEscapes(*this);
 
@@ -2128,7 +2128,7 @@ TQString TQString::arg( Q_LLONG a, int fieldWidth, int base ) const
     be between 2 and 36. If \a base is 10, the '%L' syntax can be used
     to produce localized strings.
 */
-TQString TQString::arg( Q_ULLONG a, int fieldWidth, int base ) const
+TQString TQString::arg( TQ_ULLONG a, int fieldWidth, int base ) const
 {
     ArgEscapeData d = findArgEscapes(*this);
 
@@ -2557,13 +2557,13 @@ TQString &TQString::sprintf( const char* cformat, ... )
 	switch (*c) {
 	    case 'd':
 	    case 'i': {
-	    	Q_LLONG i;
+	    	TQ_LLONG i;
 		switch (length_mod) {
 		    case lm_none: i = va_arg(ap, int); break;
 		    case lm_hh: i = va_arg(ap, int); break;
 		    case lm_h: i = va_arg(ap, int); break;
 		    case lm_l: i = va_arg(ap, long int); break;
-		    case lm_ll: i = va_arg(ap, Q_LLONG); break;
+		    case lm_ll: i = va_arg(ap, TQ_LLONG); break;
 		    case lm_j: i = va_arg(ap, long int); break;
 		    case lm_z: i = va_arg(ap, size_t); break;
 		    case lm_t: i = va_arg(ap, int); break;
@@ -2577,13 +2577,13 @@ TQString &TQString::sprintf( const char* cformat, ... )
 	    case 'u':
 	    case 'x':
 	    case 'X': {
-	    	Q_ULLONG u;
+	    	TQ_ULLONG u;
 		switch (length_mod) {
 		    case lm_none: u = va_arg(ap, unsigned int); break;
 		    case lm_hh: u = va_arg(ap, unsigned int); break;
 		    case lm_h: u = va_arg(ap, unsigned int); break;
 		    case lm_l: u = va_arg(ap, unsigned long int); break;
-		    case lm_ll: u = va_arg(ap, Q_ULLONG); break;
+		    case lm_ll: u = va_arg(ap, TQ_ULLONG); break;
                     default: u = 0; break;
 		}
 
@@ -2656,11 +2656,11 @@ TQString &TQString::sprintf( const char* cformat, ... )
 		break;
 	    }
 	    case 'p': {
-		Q_ULLONG i;
+		TQ_ULLONG i;
 #ifdef Q_OS_WIN64
-	    	i = (Q_ULLONG) va_arg(ap, void*);
+	    	i = (TQ_ULLONG) va_arg(ap, void*);
 #else
-		i = (Q_ULONG) va_arg(ap, void*);
+		i = (TQ_ULONG) va_arg(ap, void*);
 #endif
 
 #ifdef Q_OS_WIN32
@@ -2691,7 +2691,7 @@ TQString &TQString::sprintf( const char* cformat, ... )
 			break;
 		    }
 		    case lm_ll: {
-		    	Q_LLONG *n = va_arg(ap, Q_LLONG*);
+		    	TQ_LLONG *n = va_arg(ap, TQ_LLONG*);
 			volatile uint tmp = result.length(); // egcs-2.91.66 gets internal
 			*n = tmp;			     // compiler error without volatile
 			break;
@@ -4697,7 +4697,7 @@ int TQString::contains( const TQRegExp &rx ) const
 
 long TQString::toLong( bool *ok, int base ) const
 {
-    Q_LLONG v = toLongLong( ok, base );
+    TQ_LLONG v = toLongLong( ok, base );
     if ( v < LONG_MIN || v > LONG_MAX ) {
 	if ( ok )
 	    *ok = FALSE;
@@ -4731,7 +4731,7 @@ long TQString::toLong( bool *ok, int base ) const
     \sa number()
 */
 
-Q_LLONG TQString::toLongLong( bool *ok, int base ) const
+TQ_LLONG TQString::toLongLong( bool *ok, int base ) const
 {
 #if defined(QT_CHECK_RANGE)
     if ( base != 0 && (base < 2 || base > 36) ) {
@@ -4742,7 +4742,7 @@ Q_LLONG TQString::toLongLong( bool *ok, int base ) const
 
     bool my_ok;
     TQLocale def_locale;
-    Q_LLONG result = def_locale.d->stringToLongLong(*this, base, &my_ok, TQLocalePrivate::FailOnGroupSeparators);
+    TQ_LLONG result = def_locale.d->stringToLongLong(*this, base, &my_ok, TQLocalePrivate::FailOnGroupSeparators);
     if (my_ok) {
     	if (ok != 0)
 	    *ok = TRUE;
@@ -4787,7 +4787,7 @@ Q_LLONG TQString::toLongLong( bool *ok, int base ) const
 
 ulong TQString::toULong( bool *ok, int base ) const
 {
-    Q_ULLONG v = toULongLong( ok, base );
+    TQ_ULLONG v = toULongLong( ok, base );
     if ( v > ULONG_MAX ) {
 	if ( ok )
 	    *ok = FALSE;
@@ -4821,7 +4821,7 @@ ulong TQString::toULong( bool *ok, int base ) const
     \sa number()
 */
 
-Q_ULLONG TQString::toULongLong( bool *ok, int base ) const
+TQ_ULLONG TQString::toULongLong( bool *ok, int base ) const
 {
 #if defined(QT_CHECK_RANGE)
     if ( base != 0 && (base < 2 || base > 36) ) {
@@ -4832,7 +4832,7 @@ Q_ULLONG TQString::toULongLong( bool *ok, int base ) const
 
     bool my_ok;
     TQLocale def_locale;
-    Q_ULLONG result = def_locale.d->stringToUnsLongLong(*this, base, &my_ok, TQLocalePrivate::FailOnGroupSeparators);
+    TQ_ULLONG result = def_locale.d->stringToUnsLongLong(*this, base, &my_ok, TQLocalePrivate::FailOnGroupSeparators);
     if (my_ok) {
     	if (ok != 0)
 	    *ok = TRUE;
@@ -4879,7 +4879,7 @@ Q_ULLONG TQString::toULongLong( bool *ok, int base ) const
 
 short TQString::toShort( bool *ok, int base ) const
 {
-    Q_LLONG v = toLongLong( ok, base );
+    TQ_LLONG v = toLongLong( ok, base );
     if ( v < SHRT_MIN || v > SHRT_MAX ) {
 	if ( ok )
 	    *ok = FALSE;
@@ -4916,7 +4916,7 @@ short TQString::toShort( bool *ok, int base ) const
 
 ushort TQString::toUShort( bool *ok, int base ) const
 {
-    Q_ULLONG v = toULongLong( ok, base );
+    TQ_ULLONG v = toULongLong( ok, base );
     if ( v > USHRT_MAX ) {
 	if ( ok )
 	    *ok = FALSE;
@@ -4961,7 +4961,7 @@ ushort TQString::toUShort( bool *ok, int base ) const
 
 int TQString::toInt( bool *ok, int base ) const
 {
-    Q_LLONG v = toLongLong( ok, base );
+    TQ_LLONG v = toLongLong( ok, base );
     if ( v < INT_MIN || v > INT_MAX ) {
 	if ( ok )
 	    *ok = FALSE;
@@ -4997,7 +4997,7 @@ int TQString::toInt( bool *ok, int base ) const
 
 uint TQString::toUInt( bool *ok, int base ) const
 {
-    Q_ULLONG v = toULongLong( ok, base );
+    TQ_ULLONG v = toULongLong( ok, base );
     if ( v > UINT_MAX ) {
 	if ( ok )
 	    *ok = FALSE;
@@ -5149,7 +5149,7 @@ float TQString::toFloat( bool *ok ) const
     \endcode
 */
 
-TQString &TQString::setNum( Q_LLONG n, int base )
+TQString &TQString::setNum( TQ_LLONG n, int base )
 {
 #if defined(QT_CHECK_RANGE)
     if ( base < 2 || base > 36 ) {
@@ -5171,7 +5171,7 @@ TQString &TQString::setNum( Q_LLONG n, int base )
     The base is 10 by default and must be between 2 and 36.
 */
 
-TQString &TQString::setNum( Q_ULLONG n, int base )
+TQString &TQString::setNum( TQ_ULLONG n, int base )
 {
 #if defined(QT_CHECK_RANGE)
     if ( base < 2 || base > 36 ) {
@@ -5192,7 +5192,7 @@ TQString &TQString::setNum( Q_ULLONG n, int base )
 // ### 4.0: inline
 TQString &TQString::setNum( long n, int base )
 {
-    return setNum( (Q_LLONG)n, base );
+    return setNum( (TQ_LLONG)n, base );
 }
 
 /*!
@@ -5203,7 +5203,7 @@ TQString &TQString::setNum( long n, int base )
 // ### 4.0: inline
 TQString &TQString::setNum( ulong n, int base )
 {
-    return setNum( (Q_ULLONG)n, base );
+    return setNum( (TQ_ULLONG)n, base );
 }
 
 /*!
@@ -5343,7 +5343,7 @@ TQString TQString::number( ulong n, int base )
 
     \sa setNum()
 */
-TQString TQString::number( Q_LLONG n, int base )
+TQString TQString::number( TQ_LLONG n, int base )
 {
     TQString s;
     s.setNum( n, base );
@@ -5355,7 +5355,7 @@ TQString TQString::number( Q_LLONG n, int base )
 
     \sa setNum()
 */
-TQString TQString::number( Q_ULLONG n, int base )
+TQString TQString::number( TQ_ULLONG n, int base )
 {
     TQString s;
     s.setNum( n, base );
@@ -6846,7 +6846,7 @@ TQDataStream &operator<<( TQDataStream &s, const TQString &str )
 		delete [] b;
 	} else {
 	    // write null marker
-	    s << (Q_UINT32)0xffffffff;
+	    s << (TQ_UINT32)0xffffffff;
 	}
     }
     return s;
@@ -6873,7 +6873,7 @@ TQDataStream &operator>>( TQDataStream &s, TQString &str )
 	str = TQString( l );
     }
     else {
-	Q_UINT32 bytes = 0;
+	TQ_UINT32 bytes = 0;
 	s >> bytes;                                     // read size of string
 	if ( bytes == 0xffffffff ) {                    // null string
 	    str = TQString::null;
diff --git a/src/tools/qtextstream.cpp b/src/tools/qtextstream.cpp
index e5ccf8ba..6a0e1d6b 100644
--- a/src/tools/qtextstream.cpp
+++ b/src/tools/qtextstream.cpp
@@ -299,8 +299,8 @@ public:
     Offset  size() const;
     Offset  at()   const;
     bool  at( Offset pos );
-    Q_LONG readBlock( char *p, Q_ULONG len );
-    Q_LONG writeBlock( const char *p, Q_ULONG len );
+    TQ_LONG readBlock( char *p, TQ_ULONG len );
+    TQ_LONG writeBlock( const char *p, TQ_ULONG len );
     int   getch();
     int   putch( int ch );
     int   ungetch( int ch );
@@ -396,7 +396,7 @@ bool TQStringBuffer::at( Offset pos )
 }
 
 
-Q_LONG TQStringBuffer::readBlock( char *p, Q_ULONG len )
+TQ_LONG TQStringBuffer::readBlock( char *p, TQ_ULONG len )
 {
 #if defined(QT_CHECK_STATE)
     TQ_CHECK_PTR( p );
@@ -423,7 +423,7 @@ Q_LONG TQStringBuffer::readBlock( char *p, Q_ULONG len )
     return len;
 }
 
-Q_LONG TQStringBuffer::writeBlock( const char *p, Q_ULONG len )
+TQ_LONG TQStringBuffer::writeBlock( const char *p, TQ_ULONG len )
 {
 #if defined(QT_CHECK_NULL)
     if ( p == 0 && len != 0 )
diff --git a/src/tools/qunicodetables.cpp b/src/tools/qunicodetables.cpp
index abcfadf7..8e9b5c1d 100644
--- a/src/tools/qunicodetables.cpp
+++ b/src/tools/qunicodetables.cpp
@@ -239,7 +239,7 @@ print "#ifndef QT_NO_UNICODETABLES\n\n";
 # Print pages...
 #
 
-print "const Q_UINT8 TQUnicodeTables::unicode_info[] = {";
+print "const TQ_UINT8 TQUnicodeTables::unicode_info[] = {";
 print $rowtable_txt;
 $size += 256;
 print "\n\n";
@@ -252,7 +252,7 @@ print "// $size bytes\n\n";
 $rowtable_txt = "";
 $row_txt = "";
 $table_txt =
-    "const Q_UINT16 TQUnicodeTables::decomposition_map[] = {\n    0,\n";
+    "const TQ_UINT16 TQUnicodeTables::decomposition_map[] = {\n    0,\n";
 $pos = 1;
 for $row ( 0..255 ) {
     $nonzero=0;
@@ -286,7 +286,7 @@ for $row ( 0..255 ) {
 #
 print "$table_txt\n};\n\n";
 
-print "const Q_UINT16 TQUnicodeTables::decomposition_info[] = {";
+print "const TQ_UINT16 TQUnicodeTables::decomposition_info[] = {";
 print "$rowtable_txt\n";
 $size += 512;
 print $row_txt;
@@ -302,7 +302,7 @@ $pos = 1;
 $rowtable_txt = "";
 $row_txt = "";
 $table_txt =
-    "const Q_UINT16 TQUnicodeTables::ligature_map[] = {\n    0,\n";
+    "const TQ_UINT16 TQUnicodeTables::ligature_map[] = {\n    0,\n";
 for $lig_row ( 0..255 ) {
     $nonzero=0;
     $txt = "";
@@ -350,7 +350,7 @@ for $lig_row ( 0..255 ) {
 # Print ligature tables
 #
 print "$table_txt\n};\n\n";
-print "const Q_UINT16 TQUnicodeTables::ligature_info[] = {";
+print "const TQ_UINT16 TQUnicodeTables::ligature_info[] = {";
 print "$rowtable_txt\n\n";
 $size+=512;
 print $row_txt;
@@ -392,7 +392,7 @@ for $dir_row ( 0..255 ) {
 
 # Print pages...
 #
-print "const Q_UINT8 TQUnicodeTables::direction_info[] = {";
+print "const TQ_UINT8 TQUnicodeTables::direction_info[] = {";
 print "$rowtable_txt\n\n";
 $size+=256;
 print $row_txt;
@@ -427,7 +427,7 @@ for $combining_row ( 0..255 ) {
 
 # Print pages...
 #
-print "const Q_UINT8 TQUnicodeTables::combining_info[] = {";
+print "const TQ_UINT8 TQUnicodeTables::combining_info[] = {";
 print "$rowtable_txt\n\n";
 $size+=256;
 print $row_txt;
@@ -478,7 +478,7 @@ for $row ( 0..255 ) {
 
 # Print pages...
 #
-print "const Q_UINT16 TQUnicodeTables::case_info[] = {";
+print "const TQ_UINT16 TQUnicodeTables::case_info[] = {";
 print "$rowtable_txt\n\n";
 $size+=512;
 print $row_txt;
@@ -522,7 +522,7 @@ for $row ( 0..255 ) {
 
 # Print pages...
 #
-print "const Q_INT8 TQUnicodeTables::decimal_info[] = {";
+print "const TQ_INT8 TQUnicodeTables::decimal_info[] = {";
 print "$rowtable_txt\n\n";
 $size+=512;
 print $row_txt;
@@ -560,7 +560,7 @@ for $row ( 0..255 ) {
 
 # Print pages...
 #
-print "const Q_UINT8 TQUnicodeTables::line_break_info[] = {";
+print "const TQ_UINT8 TQUnicodeTables::line_break_info[] = {";
 print "$rowtable_txt\n\n";
 $size+=512;
 print $row_txt;
@@ -581,7 +581,7 @@ __END__
 
 #ifndef QT_NO_UNICODETABLES
 
-const Q_UINT8 TQUnicodeTables::unicode_info[] = {
+const TQ_UINT8 TQUnicodeTables::unicode_info[] = {
     1, 2, 3, 4, 5, 6, 7, 8,
     9, 10, 11, 12, 13, 14, 15, 16,
     17, 18, 19, 20, 21, 22, 23, 24,
@@ -2401,7 +2401,7 @@ const Q_UINT8 TQUnicodeTables::unicode_info[] = {
 
 // 14080 bytes
 
-const Q_UINT16 TQUnicodeTables::decomposition_map[] = {
+const TQ_UINT16 TQUnicodeTables::decomposition_map[] = {
     0,
     3, 0x00A0, 0x0020, 0,
     16, 0x00A8, 0x0020, 0x0308, 0,
@@ -6003,7 +6003,7 @@ const Q_UINT16 TQUnicodeTables::decomposition_map[] = {
 
 };
 
-const Q_UINT16 TQUnicodeTables::decomposition_info[] = {
+const TQ_UINT16 TQUnicodeTables::decomposition_info[] = {
     1, 2, 3, 4, 5, 6, 7, 8,
     8, 9, 10, 11, 12, 13, 14, 15,
     16, 8, 8, 8, 8, 8, 8, 8,
@@ -7261,7 +7261,7 @@ const Q_UINT16 TQUnicodeTables::decomposition_info[] = {
 
 // 67552 bytes
 
-const Q_UINT16 TQUnicodeTables::ligature_map[] = {
+const TQ_UINT16 TQUnicodeTables::ligature_map[] = {
     0,
     5567, 0,
     5552, 0,
@@ -7682,7 +7682,7 @@ const Q_UINT16 TQUnicodeTables::ligature_map[] = {
 
 };
 
-const Q_UINT16 TQUnicodeTables::ligature_info[] = {
+const TQ_UINT16 TQUnicodeTables::ligature_info[] = {
     1, 2, 3, 4, 5, 6, 7, 8,
     8, 9, 10, 11, 12, 13, 8, 14,
     15, 8, 8, 8, 8, 8, 8, 8,
@@ -8446,7 +8446,7 @@ const Q_UINT16 TQUnicodeTables::ligature_info[] = {
 
 // 14586 bytes
 
-const Q_UINT8 TQUnicodeTables::direction_info[] = {
+const TQ_UINT8 TQUnicodeTables::direction_info[] = {
     1, 2, 3, 4, 5, 6, 7, 8,
     2, 9, 10, 11, 12, 13, 14, 15,
     16, 2, 2, 2, 2, 2, 17, 18,
@@ -9804,7 +9804,7 @@ const Q_UINT8 TQUnicodeTables::direction_info[] = {
 
 // 25082 bytes
 
-const Q_UINT8 TQUnicodeTables::combining_info[] = {
+const TQ_UINT8 TQUnicodeTables::combining_info[] = {
     1, 1, 1, 2, 3, 4, 5, 6,
     1, 7, 8, 9, 10, 11, 12, 13,
     14, 1, 1, 1, 1, 1, 1, 15,
@@ -10502,7 +10502,7 @@ const Q_UINT8 TQUnicodeTables::combining_info[] = {
 
 // 30458 bytes
 
-const Q_UINT16 TQUnicodeTables::case_info[] = {
+const TQ_UINT16 TQUnicodeTables::case_info[] = {
     1, 2, 3, 4, 5, 6, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0,
@@ -10902,7 +10902,7 @@ const Q_UINT16 TQUnicodeTables::case_info[] = {
 };
 // 36602 bytes
 
-const Q_INT8 TQUnicodeTables::decimal_info[] = {
+const TQ_INT8 TQUnicodeTables::decimal_info[] = {
     1, 0, 0, 0, 0, 0, 2, 0,
     0, 3, 3, 4, 3, 5, 6, 7,
     8, 0, 0, 9, 0, 0, 0, 10,
@@ -11405,7 +11405,7 @@ const Q_INT8 TQUnicodeTables::decimal_info[] = {
 
 #ifdef QT_NO_UNICODETABLES
 
-const Q_UINT8 TQUnicodeTables::latin1_line_break_info[] = {
+const TQ_UINT8 TQUnicodeTables::latin1_line_break_info[] = {
     19, 19, 19, 19, 19, 19, 19, 19,
     19, 15, 23, 19, 21, 22, 19, 19,
     19, 19, 19, 19, 19, 19, 19, 19,
@@ -11442,7 +11442,7 @@ const Q_UINT8 TQUnicodeTables::latin1_line_break_info[] = {
 
 #else
 
-const Q_UINT8 TQUnicodeTables::line_break_info[] = {
+const TQ_UINT8 TQUnicodeTables::line_break_info[] = {
     1, 2, 3, 4, 5, 6, 7, 8,
     2, 9, 10, 11, 12, 13, 14, 15,
     16, 17, 2, 18, 2, 2, 19, 20,
@@ -12937,7 +12937,7 @@ const Q_UINT8 TQUnicodeTables::line_break_info[] = {
 
 
 #ifndef QT_NO_UNICODETABLES
-const Q_UINT16 TQUnicodeTables::symmetricPairs[] = {
+const TQ_UINT16 TQUnicodeTables::symmetricPairs[] = {
     0x0028, 0x0029, 0x003C, 0x003E, 0x005B, 0x005D, 0x007B, 0x007D,
     0x00AB, 0x00BB, 0x2039, 0x203A, 0x2045, 0x2046, 0x207D, 0x207E,
     0x208D, 0x208E, 0x2208, 0x220B, 0x2209, 0x220C, 0x220A, 0x220D,
@@ -12990,7 +12990,7 @@ const int TQUnicodeTables::symmetricPairsSize =
   only include info for the first unicode range (latin1) when building
   without unicode tables.
 */
-const Q_UINT8 TQUnicodeTables::unicode_info[] = {
+const TQ_UINT8 TQUnicodeTables::unicode_info[] = {
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
     10, 10, 10, 10, 10, 10, 10, 10,
diff --git a/src/tools/qunicodetables_p.h b/src/tools/qunicodetables_p.h
index 07d4a599..7cc4cc6e 100644
--- a/src/tools/qunicodetables_p.h
+++ b/src/tools/qunicodetables_p.h
@@ -61,21 +61,21 @@
 
 class TQUnicodeTables {
 public:
-    static const Q_UINT8 unicode_info[];
+    static const TQ_UINT8 unicode_info[];
 #ifndef QT_NO_UNICODETABLES
-    static const Q_UINT16 decomposition_map[];
-    static const Q_UINT16 decomposition_info[];
-    static const Q_UINT16 ligature_map[];
-    static const Q_UINT16 ligature_info[];
-    static const Q_UINT8 direction_info[];
-    static const Q_UINT8 combining_info[];
-    static const Q_UINT16 case_info[];
-    static const Q_INT8 decimal_info[];
-    static const Q_UINT16 symmetricPairs[];
+    static const TQ_UINT16 decomposition_map[];
+    static const TQ_UINT16 decomposition_info[];
+    static const TQ_UINT16 ligature_map[];
+    static const TQ_UINT16 ligature_info[];
+    static const TQ_UINT8 direction_info[];
+    static const TQ_UINT8 combining_info[];
+    static const TQ_UINT16 case_info[];
+    static const TQ_INT8 decimal_info[];
+    static const TQ_UINT16 symmetricPairs[];
     static const int symmetricPairsSize;
-    static const Q_UINT8 line_break_info[];
+    static const TQ_UINT8 line_break_info[];
 #else
-    static const Q_UINT8 latin1_line_break_info[];
+    static const TQ_UINT8 latin1_line_break_info[];
 #endif
     static const unsigned char otherScripts[];
     static const unsigned char indicScripts[];
@@ -117,7 +117,7 @@ inline TQChar lower( const TQChar &c )
     uc += c.cell();
     if (TQUnicodeTables::unicode_info[uc] != TQChar::Letter_Uppercase || !ci)
 	return c;
-    Q_UINT16 lower = TQUnicodeTables::case_info[(ci<<8)+cell];
+    TQ_UINT16 lower = TQUnicodeTables::case_info[(ci<<8)+cell];
     return lower ? TQChar(lower) : c;
 #else
     if ( c.row() )
@@ -136,7 +136,7 @@ inline TQChar upper( const TQChar &c )
     uc += c.cell();
     if (TQUnicodeTables::unicode_info[uc] != TQChar::Letter_Lowercase || !ci)
 	return c;
-    Q_UINT16 upper = TQUnicodeTables::case_info[(ci<<8)+cell];
+    TQ_UINT16 upper = TQUnicodeTables::case_info[(ci<<8)+cell];
     return upper ? TQChar(upper) : c;
 #else
     if ( c.row() )
diff --git a/src/tools/quuid.cpp b/src/tools/quuid.cpp
index 64ec7a3b..36472176 100644
--- a/src/tools/quuid.cpp
+++ b/src/tools/quuid.cpp
@@ -209,11 +209,11 @@ TQString TQUuid::toString() const
 */
 TQDataStream &operator<<( TQDataStream &s, const TQUuid &id )
 {
-    s << (Q_UINT32)id.data1;
-    s << (Q_UINT16)id.data2;
-    s << (Q_UINT16)id.data3;
+    s << (TQ_UINT32)id.data1;
+    s << (TQ_UINT16)id.data2;
+    s << (TQ_UINT16)id.data3;
     for (int i = 0; i < 8; i++ )
-	s << (Q_UINT8)id.data4[i];
+	s << (TQ_UINT8)id.data4[i];
     return s;
 }
 
@@ -223,9 +223,9 @@ TQDataStream &operator<<( TQDataStream &s, const TQUuid &id )
 */
 TQDataStream &operator>>( TQDataStream &s, TQUuid &id )
 {
-    Q_UINT32 u32;
-    Q_UINT16 u16;
-    Q_UINT8 u8;
+    TQ_UINT32 u32;
+    TQ_UINT16 u16;
+    TQ_UINT8 u8;
     s >> u32;
     id.data1 = u32;
     s >> u16;