Rename METHOD, SIGNAL, SLOT to TQ_METHOD, TQ_SIGNAL, TQ_SLOT

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>

21 files changed, 222 insertions, 222 deletions

diff --git a/src/kernel/ntqobjectdefs.h b/src/kernel/ntqobjectdefs.h
index fac233ce3..ba5e12b88 100644
--- a/src/kernel/ntqobjectdefs.h
+++ b/src/kernel/ntqobjectdefs.h
@@ -122,29 +122,29 @@ private:								\
 #endif
 
 // macro for naming members
-#ifdef METHOD
-#undef METHOD
+#ifdef TQ_METHOD
+#undef TQ_METHOD
 #endif
-#ifdef SLOT
-#undef SLOT
+#ifdef TQ_SLOT
+#undef TQ_SLOT
 #endif
-#ifdef SIGNAL
-#undef SIGNAL
+#ifdef TQ_SIGNAL
+#undef TQ_SIGNAL
 #endif
 
 #if defined(_OLD_CPP_)
-#define METHOD(a)	"0""a"
-#define SLOT(a)		"1""a"
-#define SIGNAL(a)	"2""a"
+#define TQ_METHOD(a)	"0""a"
+#define TQ_SLOT(a)		"1""a"
+#define TQ_SIGNAL(a)	"2""a"
 #else
-#define METHOD(a)	"0"#a
-#define SLOT(a)		"1"#a
-#define SIGNAL(a)	"2"#a
+#define TQ_METHOD(a)	"0"#a
+#define TQ_SLOT(a)		"1"#a
+#define TQ_SIGNAL(a)	"2"#a
 #endif
 
-#define TQMETHOD_CODE	0			// member type codes
-#define TQSLOT_CODE	1
-#define TQSIGNAL_CODE	2
+#define TQ_METHOD_CODE	0			// member type codes
+#define TQ_SLOT_CODE	1
+#define TQ_SIGNAL_CODE	2
 
 class TQObject;
 class TQMetaObject;
diff --git a/src/kernel/qaccel.cpp b/src/kernel/qaccel.cpp
index ffd253934..76181cca9 100644
--- a/src/kernel/qaccel.cpp
+++ b/src/kernel/qaccel.cpp
@@ -73,7 +73,7 @@
     \code
 	TQPushButton p( "&Exit", parent ); // automatic shortcut ALT+Key_E
 	TQPopupMenu *fileMenu = new fileMenu( parent );
-	fileMenu->insertItem( "Undo", parent, SLOT(undo()), CTRL+Key_Z );
+	fileMenu->insertItem( "Undo", parent, TQ_SLOT(undo()), CTRL+Key_Z );
     \endcode
 
     A TQAccel contains a list of accelerator items that can be
@@ -131,7 +131,7 @@
 	TQAccel *a = new TQAccel( myWindow );	   // create accels for myWindow
 	a->connectItem( a->insertItem(Key_P+CTRL), // adds Ctrl+P accelerator
 			myWindow,		   // connected to myWindow's
-			SLOT(printDoc()) );	   // printDoc() slot
+			TQ_SLOT(printDoc()) );	   // printDoc() slot
     \endcode
 
     \sa TQKeyEvent TQWidget::keyPressEvent() TQMenuData::setAccel()
@@ -781,7 +781,7 @@ void TQAccel::setItemEnabled( int id, bool enable )
     receiver.
 
     \code
-	a->connectItem( 201, mainView, SLOT(quit()) );
+	a->connectItem( 201, mainView, TQ_SLOT(quit()) );
     \endcode
 
     Of course, you can also send a signal as \a member.
@@ -917,7 +917,7 @@ TQString TQAccel::keyToString( TQKeySequence k )
 
   \code
     TQPopupMenu *file = new TQPopupMenu( this );
-    file->insertItem( p1, tr("&Open..."), this, SLOT(open()),
+    file->insertItem( p1, tr("&Open..."), this, TQ_SLOT(open()),
 		      TQAccel::stringToKey(tr("Ctrl+O", "File|Open")) );
   \endcode
 
diff --git a/src/kernel/qaccessible.cpp b/src/kernel/qaccessible.cpp
index d87b8e689..f99543593 100644
--- a/src/kernel/qaccessible.cpp
+++ b/src/kernel/qaccessible.cpp
@@ -304,7 +304,7 @@ public:
     void addObject(TQObject *object, TQAccessibleInterface *iface)
     {
         insert(object, iface);
-        connect(object, SIGNAL(destroyed(TQObject*)), this, SLOT(removeObject(TQObject*)));
+        connect(object, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(removeObject(TQObject*)));
     }
 
 public slots:
diff --git a/src/kernel/qapplication.cpp b/src/kernel/qapplication.cpp
index d67b34dd0..68e81d0f9 100644
--- a/src/kernel/qapplication.cpp
+++ b/src/kernel/qapplication.cpp
@@ -2318,7 +2318,7 @@ TQFontMetrics TQApplication::fontMetrics()
   Example:
   \code
     TQPushButton *quitButton = new TQPushButton( "Quit" );
-    connect( quitButton, SIGNAL(clicked()), tqApp, SLOT(quit()) );
+    connect( quitButton, TQ_SIGNAL(clicked()), tqApp, TQ_SLOT(quit()) );
   \endcode
 
   \sa exit() aboutToQuit() lastWindowClosed() TQAction
@@ -2340,10 +2340,10 @@ void TQApplication::quit()
   \code
     // the "Quit" menu entry should try to close all windows
     TQPopupMenu* file = new TQPopupMenu( this );
-    file->insertItem( "&Quit", tqApp, SLOT(closeAllWindows()), CTRL+Key_Q );
+    file->insertItem( "&Quit", tqApp, TQ_SLOT(closeAllWindows()), CTRL+Key_Q );
 
     // when the last window is closed, the application should quit
-    connect( tqApp, SIGNAL( lastWindowClosed() ), tqApp, SLOT( quit() ) );
+    connect( tqApp, TQ_SIGNAL( lastWindowClosed() ), tqApp, TQ_SLOT( quit() ) );
   \endcode
 
   The windows are closed in random order, until one window does not
diff --git a/src/kernel/qapplication_x11.cpp b/src/kernel/qapplication_x11.cpp
index ef52e5a32..e224f17ad 100644
--- a/src/kernel/qapplication_x11.cpp
+++ b/src/kernel/qapplication_x11.cpp
@@ -6263,7 +6263,7 @@ public:
 	: TQObject(0,0)
 	{
 	    TQSocketNotifier* sn = new TQSocketNotifier( socket, TQSocketNotifier::Read, this );
-	    connect( sn, SIGNAL( activated(int) ), this, SLOT( socketActivated(int) ) );
+	    connect( sn, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( socketActivated(int) ) );
 	}
 
 public slots:
diff --git a/src/kernel/qasyncio.cpp b/src/kernel/qasyncio.cpp
index bf5890ac1..c4811e758 100644
--- a/src/kernel/qasyncio.cpp
+++ b/src/kernel/qasyncio.cpp
@@ -320,9 +320,9 @@ void TQIODeviceSource::rewind()
 TQDataPump::TQDataPump(TQDataSource* data_source, TQDataSink* data_sink) :
     source(data_source), sink(data_sink)
 {
-    source->connect(this, SLOT(kickStart()));
-    sink->connect(this, SLOT(kickStart()));
-    connect(&timer, SIGNAL(timeout()), this, SLOT(tryToPump()));
+    source->connect(this, TQ_SLOT(kickStart()));
+    sink->connect(this, TQ_SLOT(kickStart()));
+    connect(&timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(tryToPump()));
     timer.start(0, TRUE);
 }
 
diff --git a/src/kernel/qguardedptr.cpp b/src/kernel/qguardedptr.cpp
index 803e75e18..5102d094b 100644
--- a/src/kernel/qguardedptr.cpp
+++ b/src/kernel/qguardedptr.cpp
@@ -199,7 +199,7 @@ TQGuardedPtrPrivate::TQGuardedPtrPrivate( TQObject* o)
     : TQObject(0, "_ptrpriv" ), obj( o )
 {
     if ( obj )
-	connect( obj, SIGNAL( destroyed() ), this, SLOT( objectDestroyed() ) );
+	connect( obj, TQ_SIGNAL( destroyed() ), this, TQ_SLOT( objectDestroyed() ) );
 }
 
 
@@ -212,12 +212,12 @@ void TQGuardedPtrPrivate::reconnect( TQObject *o )
     if ( obj == o )
 	return;
     if ( obj )
-	disconnect( obj, SIGNAL( destroyed() ),
-		    this, SLOT( objectDestroyed() ) );
+	disconnect( obj, TQ_SIGNAL( destroyed() ),
+		    this, TQ_SLOT( objectDestroyed() ) );
     obj = o;
     if ( obj )
-	connect( obj, SIGNAL( destroyed() ),
-		 this, SLOT( objectDestroyed() ) );
+	connect( obj, TQ_SIGNAL( destroyed() ),
+		 this, TQ_SLOT( objectDestroyed() ) );
 }
 
 void TQGuardedPtrPrivate::objectDestroyed()
diff --git a/src/kernel/qkeysequence.cpp b/src/kernel/qkeysequence.cpp
index e9fe43134..c679bb52b 100644
--- a/src/kernel/qkeysequence.cpp
+++ b/src/kernel/qkeysequence.cpp
@@ -227,7 +227,7 @@ TQKeySequence::TQKeySequence()
 
     \code
 	TQPopupMenu *file = new TQPopupMenu( this );
-	file->insertItem( tr("&Open..."), this, SLOT(open()),
+	file->insertItem( tr("&Open..."), this, TQ_SLOT(open()),
 			  TQKeySequence( tr("Ctrl+O", "File|Open") ) );
     \endcode
 
diff --git a/src/kernel/qmovie.cpp b/src/kernel/qmovie.cpp
index 3b98849e1..79218badd 100644
--- a/src/kernel/qmovie.cpp
+++ b/src/kernel/qmovie.cpp
@@ -234,7 +234,7 @@ TQMoviePrivate::TQMoviePrivate(TQDataSource* src, TQMovie* movie, int bufsize) :
 {
     frametimer = new TQTimer(this);
     pump = src ? new TQDataPump(src, this) : 0;
-    TQObject::connect(frametimer, SIGNAL(timeout()), this, SLOT(refresh()));
+    TQObject::connect(frametimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(refresh()));
     dirty_cache = FALSE;
     source = src;
     buffer = 0;
@@ -993,7 +993,7 @@ void TQMovie::setSpeed(int percent)
 */
 void TQMovie::connectResize(TQObject* receiver, const char *member)
 {
-    TQObject::connect(d, SIGNAL(sizeChanged(const TQSize&)), receiver, member);
+    TQObject::connect(d, TQ_SIGNAL(sizeChanged(const TQSize&)), receiver, member);
 }
 
 /*!
@@ -1002,7 +1002,7 @@ void TQMovie::connectResize(TQObject* receiver, const char *member)
 */
 void TQMovie::disconnectResize(TQObject* receiver, const char *member)
 {
-    TQObject::disconnect(d, SIGNAL(sizeChanged(const TQSize&)), receiver, member);
+    TQObject::disconnect(d, TQ_SIGNAL(sizeChanged(const TQSize&)), receiver, member);
 }
 
 /*!
@@ -1017,7 +1017,7 @@ void TQMovie::disconnectResize(TQObject* receiver, const char *member)
 */
 void TQMovie::connectUpdate(TQObject* receiver, const char *member)
 {
-    TQObject::connect(d, SIGNAL(areaChanged(const TQRect&)), receiver, member);
+    TQObject::connect(d, TQ_SIGNAL(areaChanged(const TQRect&)), receiver, member);
 }
 
 /*!
@@ -1026,7 +1026,7 @@ void TQMovie::connectUpdate(TQObject* receiver, const char *member)
 */
 void TQMovie::disconnectUpdate(TQObject* receiver, const char *member)
 {
-    TQObject::disconnect(d, SIGNAL(areaChanged(const TQRect&)), receiver, member);
+    TQObject::disconnect(d, TQ_SIGNAL(areaChanged(const TQRect&)), receiver, member);
 }
 
 /*!
@@ -1063,7 +1063,7 @@ void TQMovie::disconnectUpdate(TQObject* receiver, const char *member)
 */
 void TQMovie::connectStatus(TQObject* receiver, const char *member)
 {
-    TQObject::connect(d, SIGNAL(dataStatus(int)), receiver, member);
+    TQObject::connect(d, TQ_SIGNAL(dataStatus(int)), receiver, member);
 }
 
 /*!
@@ -1072,7 +1072,7 @@ void TQMovie::connectStatus(TQObject* receiver, const char *member)
 */
 void TQMovie::disconnectStatus(TQObject* receiver, const char *member)
 {
-    TQObject::disconnect(d, SIGNAL(dataStatus(int)), receiver, member);
+    TQObject::disconnect(d, TQ_SIGNAL(dataStatus(int)), receiver, member);
 }
 
 
diff --git a/src/kernel/qnetworkprotocol.cpp b/src/kernel/qnetworkprotocol.cpp
index 1adfa9455..27b6dff44 100644
--- a/src/kernel/qnetworkprotocol.cpp
+++ b/src/kernel/qnetworkprotocol.cpp
@@ -399,38 +399,38 @@ TQNetworkProtocol::TQNetworkProtocol()
 {
     d = new TQNetworkProtocolPrivate( this );
 
-    connect( d->opStartTimer, SIGNAL( timeout() ),
-	     this, SLOT( startOps() ) );
-    connect( d->removeTimer, SIGNAL( timeout() ),
-	     this, SLOT( removeMe() ) );
+    connect( d->opStartTimer, TQ_SIGNAL( timeout() ),
+	     this, TQ_SLOT( startOps() ) );
+    connect( d->removeTimer, TQ_SIGNAL( timeout() ),
+	     this, TQ_SLOT( removeMe() ) );
 
     if ( url() ) {
-	connect( this, SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
-		 url(), SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ) );
-	connect( this, SIGNAL( finished(TQNetworkOperation*) ),
-		 url(), SIGNAL( finished(TQNetworkOperation*) ) );
-	connect( this, SIGNAL( start(TQNetworkOperation*) ),
-		 url(), SIGNAL( start(TQNetworkOperation*) ) );
-	connect( this, SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
-		 url(), SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ) );
-	connect( this, SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
-		 url(), SLOT( addEntry(const TQValueList<TQUrlInfo>&) ) );
-	connect( this, SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ),
-		 url(), SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ) );
-	connect( this, SIGNAL( removed(TQNetworkOperation*) ),
-		 url(), SIGNAL( removed(TQNetworkOperation*) ) );
-	connect( this, SIGNAL( itemChanged(TQNetworkOperation*) ),
-		 url(), SIGNAL( itemChanged(TQNetworkOperation*) ) );
-	connect( this, SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
-		 url(), SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
-	connect( this, SIGNAL( connectionStateChanged(int,const TQString&) ),
-		 url(), SIGNAL( connectionStateChanged(int,const TQString&) ) );
+	connect( this, TQ_SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( finished(TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( start(TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( start(TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
+		 url(), TQ_SLOT( addEntry(const TQValueList<TQUrlInfo>&) ) );
+	connect( this, TQ_SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( removed(TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( removed(TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( itemChanged(TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( itemChanged(TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( connectionStateChanged(int,const TQString&) ),
+		 url(), TQ_SIGNAL( connectionStateChanged(int,const TQString&) ) );
     }
 
-    connect( this, SIGNAL( finished(TQNetworkOperation*) ),
-	     this, SLOT( processNextOperation(TQNetworkOperation*) ) );
-    connect( this, SIGNAL( newChild(const TQUrlInfo&,TQNetworkOperation*) ),
-	     this, SLOT( emitNewChildren(const TQUrlInfo&,TQNetworkOperation*) ) );
+    connect( this, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+	     this, TQ_SLOT( processNextOperation(TQNetworkOperation*) ) );
+    connect( this, TQ_SIGNAL( newChild(const TQUrlInfo&,TQNetworkOperation*) ),
+	     this, TQ_SLOT( emitNewChildren(const TQUrlInfo&,TQNetworkOperation*) ) );
 
 }
 
@@ -452,26 +452,26 @@ TQNetworkProtocol::~TQNetworkProtocol()
 void TQNetworkProtocol::setUrl( TQUrlOperator *u )
 {
     if ( url() ) {
-	disconnect( this, SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
-		    url(), SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ) );
-	disconnect( this, SIGNAL( finished(TQNetworkOperation*) ),
-		    url(), SIGNAL( finished(TQNetworkOperation*) ) );
-	disconnect( this, SIGNAL( start(TQNetworkOperation*) ),
-		    url(), SIGNAL( start(TQNetworkOperation*) ) );
-	disconnect( this, SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
-		    url(), SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ) );
-	disconnect( this, SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
-		    url(), SLOT( addEntry(const TQValueList<TQUrlInfo>&) ) );
-	disconnect( this, SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ),
-		    url(), SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ) );
-	disconnect( this, SIGNAL( removed(TQNetworkOperation*) ),
-		    url(), SIGNAL( removed(TQNetworkOperation*) ) );
-	disconnect( this, SIGNAL( itemChanged(TQNetworkOperation*) ),
-		    url(), SIGNAL( itemChanged(TQNetworkOperation*) ) );
-	disconnect( this, SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
-		    url(), SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
-	disconnect( this, SIGNAL( connectionStateChanged(int,const TQString&) ),
-		    url(), SIGNAL( connectionStateChanged(int,const TQString&) ) );
+	disconnect( this, TQ_SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
+		    url(), TQ_SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ) );
+	disconnect( this, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+		    url(), TQ_SIGNAL( finished(TQNetworkOperation*) ) );
+	disconnect( this, TQ_SIGNAL( start(TQNetworkOperation*) ),
+		    url(), TQ_SIGNAL( start(TQNetworkOperation*) ) );
+	disconnect( this, TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
+		    url(), TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ) );
+	disconnect( this, TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
+		    url(), TQ_SLOT( addEntry(const TQValueList<TQUrlInfo>&) ) );
+	disconnect( this, TQ_SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ),
+		    url(), TQ_SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ) );
+	disconnect( this, TQ_SIGNAL( removed(TQNetworkOperation*) ),
+		    url(), TQ_SIGNAL( removed(TQNetworkOperation*) ) );
+	disconnect( this, TQ_SIGNAL( itemChanged(TQNetworkOperation*) ),
+		    url(), TQ_SIGNAL( itemChanged(TQNetworkOperation*) ) );
+	disconnect( this, TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
+		    url(), TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
+	disconnect( this, TQ_SIGNAL( connectionStateChanged(int,const TQString&) ),
+		    url(), TQ_SIGNAL( connectionStateChanged(int,const TQString&) ) );
     }
 
 
@@ -483,26 +483,26 @@ void TQNetworkProtocol::setUrl( TQUrlOperator *u )
     d->url = u;
 
     if ( url() ) {
-	connect( this, SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
-		 url(), SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ) );
-	connect( this, SIGNAL( finished(TQNetworkOperation*) ),
-		 url(), SIGNAL( finished(TQNetworkOperation*) ) );
-	connect( this, SIGNAL( start(TQNetworkOperation*) ),
-		 url(), SIGNAL( start(TQNetworkOperation*) ) );
-	connect( this, SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
-		 url(), SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ) );
-	connect( this, SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
-		 url(), SLOT( addEntry(const TQValueList<TQUrlInfo>&) ) );
-	connect( this, SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ),
-		 url(), SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ) );
-	connect( this, SIGNAL( removed(TQNetworkOperation*) ),
-		 url(), SIGNAL( removed(TQNetworkOperation*) ) );
-	connect( this, SIGNAL( itemChanged(TQNetworkOperation*) ),
-		 url(), SIGNAL( itemChanged(TQNetworkOperation*) ) );
-	connect( this, SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
-		 url(), SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
-	connect( this, SIGNAL( connectionStateChanged(int,const TQString&) ),
-		 url(), SIGNAL( connectionStateChanged(int,const TQString&) ) );
+	connect( this, TQ_SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( finished(TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( start(TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( start(TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( newChildren(const TQValueList<TQUrlInfo>&,TQNetworkOperation*) ),
+		 url(), TQ_SLOT( addEntry(const TQValueList<TQUrlInfo>&) ) );
+	connect( this, TQ_SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( createdDirectory(const TQUrlInfo&,TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( removed(TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( removed(TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( itemChanged(TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( itemChanged(TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
+		 url(), TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
+	connect( this, TQ_SIGNAL( connectionStateChanged(int,const TQString&) ),
+		 url(), TQ_SIGNAL( connectionStateChanged(int,const TQString&) ) );
     }
 
     if ( !d->opInProgress && !d->operationQueue.isEmpty() )
@@ -1018,8 +1018,8 @@ TQNetworkOperation::TQNetworkOperation( TQNetworkProtocol::Operation operation,
 {
     d = new TQNetworkOperationPrivate;
     d->deleteTimer = new TQTimer( this );
-    connect( d->deleteTimer, SIGNAL( timeout() ),
-	     this, SLOT( deleteMe() ) );
+    connect( d->deleteTimer, TQ_SIGNAL( timeout() ),
+	     this, TQ_SLOT( deleteMe() ) );
     d->operation = operation;
     d->state = TQNetworkProtocol::StWaiting;
     d->args[ 0 ] = arg0;
@@ -1047,8 +1047,8 @@ TQNetworkOperation::TQNetworkOperation( TQNetworkProtocol::Operation operation,
 {
     d = new TQNetworkOperationPrivate;
     d->deleteTimer = new TQTimer( this );
-    connect( d->deleteTimer, SIGNAL( timeout() ),
-	     this, SLOT( deleteMe() ) );
+    connect( d->deleteTimer, TQ_SIGNAL( timeout() ),
+	     this, TQ_SLOT( deleteMe() ) );
     d->operation = operation;
     d->state = TQNetworkProtocol::StWaiting;
     d->args[ 0 ] = TQString::null;
diff --git a/src/kernel/qobject.cpp b/src/kernel/qobject.cpp
index 28a820277..e931cdbe7 100644
--- a/src/kernel/qobject.cpp
+++ b/src/kernel/qobject.cpp
@@ -389,7 +389,7 @@ TQMetaCallEvent::~TQMetaCallEvent()
 
 
 //
-// Remove white space from SIGNAL and SLOT names.
+// Remove white space from TQ_SIGNAL and TQ_SLOT names.
 // Internal for TQObject::connect() and TQObject::disconnect()
 //
 
@@ -1755,14 +1755,14 @@ void TQObject::installEventFilter( const TQObject *obj )
 	int c = eventFilters->findRef( obj );
 	if ( c >= 0 )
 	    eventFilters->take( c );
-	disconnect( obj, SIGNAL(destroyed(TQObject*)),
-		    this, SLOT(cleanupEventFilter(TQObject*)) );
+	disconnect( obj, TQ_SIGNAL(destroyed(TQObject*)),
+		    this, TQ_SLOT(cleanupEventFilter(TQObject*)) );
     } else {
 	eventFilters = new TQObjectList;
 	TQ_CHECK_PTR( eventFilters );
     }
     eventFilters->insert( 0, obj );
-    connect( obj, SIGNAL(destroyed(TQObject*)), this, SLOT(cleanupEventFilter(TQObject*)) );
+    connect( obj, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(cleanupEventFilter(TQObject*)) );
 }
 
 /*!
@@ -1785,8 +1785,8 @@ void TQObject::removeEventFilter( const TQObject *obj )
 	    delete eventFilters;
 	    eventFilters = 0;			// reset event filter list
 	}
-	disconnect( obj,  SIGNAL(destroyed(TQObject*)),
-		    this, SLOT(cleanupEventFilter(TQObject*)) );
+	disconnect( obj,  TQ_SIGNAL(destroyed(TQObject*)),
+		    this, TQ_SLOT(cleanupEventFilter(TQObject*)) );
     }
 }
 
@@ -1801,12 +1801,12 @@ static bool check_signal_macro( const TQObject *sender, const char *signal,
 				const char *func, const char *op )
 {
     int sigcode = (int)(*signal) - '0';
-    if ( sigcode != TQSIGNAL_CODE ) {
-	if ( sigcode == TQSLOT_CODE )
+    if ( sigcode != TQ_SIGNAL_CODE ) {
+	if ( sigcode == TQ_SLOT_CODE )
 	    tqWarning( "TQObject::%s: Attempt to %s non-signal %s::%s",
 		     func, op, sender->className(), signal+1 );
 	else
-	    tqWarning( "TQObject::%s: Use the SIGNAL macro to %s %s::%s",
+	    tqWarning( "TQObject::%s: Use the TQ_SIGNAL macro to %s %s::%s",
 		     func, op, sender->className(), signal );
 	return FALSE;
     }
@@ -1816,8 +1816,8 @@ static bool check_signal_macro( const TQObject *sender, const char *signal,
 static bool check_member_code( int code, const TQObject *object,
 			       const char *member, const char *func )
 {
-    if ( code != TQSLOT_CODE && code != TQSIGNAL_CODE ) {
-	tqWarning( "TQObject::%s: Use the SLOT or SIGNAL macro to "
+    if ( code != TQ_SLOT_CODE && code != TQ_SIGNAL_CODE ) {
+	tqWarning( "TQObject::%s: Use the TQ_SLOT or TQ_SIGNAL macro to "
 		 "%s %s::%s", func, func, object->className(), member );
 	return FALSE;
     }
@@ -1829,8 +1829,8 @@ static void err_member_notfound( int code, const TQObject *object,
 {
     const char *type = 0;
     switch ( code ) {
-	case TQSLOT_CODE:   type = "slot";   break;
-	case TQSIGNAL_CODE: type = "signal"; break;
+	case TQ_SLOT_CODE:   type = "slot";   break;
+	case TQ_SIGNAL_CODE: type = "signal"; break;
     }
     if ( strchr(member,')') == 0 )		// common typing mistake
 	tqWarning( "TQObject::%s: Parentheses expected, %s %s::%s",
@@ -1866,10 +1866,10 @@ static void err_info_about_candidates( int code,
 	}
 	const TQMetaData *rm = 0;
 	switch ( code ) {
-	case TQSLOT_CODE:
+	case TQ_SLOT_CODE:
 	    rm = mo->slot( mo->findSlot( newname, TRUE ), TRUE );
 	    break;
-	case TQSIGNAL_CODE:
+	case TQ_SIGNAL_CODE:
 	    rm = mo->signal( mo->findSignal( newname, TRUE ), TRUE );
 	    break;
 	}
@@ -2031,21 +2031,21 @@ TQCString TQObject::normalizeSignalSlot( const char *signalSlot )
     \a receiver, and returns TRUE if the connection succeeds; otherwise
     returns FALSE.
 
-    You must use the SIGNAL() and SLOT() macros when specifying the \a signal
+    You must use the TQ_SIGNAL() and TQ_SLOT() macros when specifying the \a signal
     and the \a member, for example:
     \code
     TQLabel     *label  = new TQLabel;
     TQScrollBar *scroll = new TQScrollBar;
-    TQObject::connect( scroll, SIGNAL(valueChanged(int)),
-                      label,  SLOT(setNum(int)) );
+    TQObject::connect( scroll, TQ_SIGNAL(valueChanged(int)),
+                      label,  TQ_SLOT(setNum(int)) );
     \endcode
 
     This example ensures that the label always displays the current
     scroll bar value. Note that the signal and slots parameters must not
     contain any variable names, only the type. E.g. the following would
     not work and return FALSE:
-    TQObject::connect( scroll, SIGNAL(valueChanged(int v)),
-                      label,  SLOT(setNum(int v)) );
+    TQObject::connect( scroll, TQ_SIGNAL(valueChanged(int v)),
+                      label,  TQ_SLOT(setNum(int v)) );
 
     A signal can also be connected to another signal:
 
@@ -2066,7 +2066,7 @@ TQCString TQObject::normalizeSignalSlot( const char *signalSlot )
     MyWidget::MyWidget()
     {
 	aButton = new TQPushButton( this );
-	connect( aButton, SIGNAL(clicked()), SIGNAL(myUsefulSignal()) );
+	connect( aButton, TQ_SIGNAL(clicked()), TQ_SIGNAL(myUsefulSignal()) );
     }
     \endcode
 
@@ -2124,8 +2124,8 @@ bool TQObject::connect( const TQObject *sender,	const char *signal,
 
     if ( signal_index < 0  ) {			// no such signal
 #if defined(QT_CHECK_RANGE)
-	err_member_notfound( TQSIGNAL_CODE, sender, signal, "connect" );
-	err_info_about_candidates( TQSIGNAL_CODE, smeta, signal, "connect" );
+	err_member_notfound( TQ_SIGNAL_CODE, sender, signal, "connect" );
+	err_info_about_candidates( TQ_SIGNAL_CODE, smeta, signal, "connect" );
 	err_info_about_objects( "connect", sender, receiver );
 #endif
 	return FALSE;
@@ -2148,7 +2148,7 @@ bool TQObject::connect( const TQObject *sender,	const char *signal,
     TQMetaObject *rmeta = r->metaObject();
     int member_index = -1;
     switch ( membcode ) {			// get receiver member
-	case TQSLOT_CODE:
+	case TQ_SLOT_CODE:
 	    member_index = rmeta->findSlot( member, TRUE );
 	    if ( member_index < 0 ) {		// normalize and retry
 		nw_member = qt_rmWS(member);	// remove whitespace
@@ -2156,7 +2156,7 @@ bool TQObject::connect( const TQObject *sender,	const char *signal,
 		member_index = rmeta->findSlot( member, TRUE );
 	    }
 	    break;
-	case TQSIGNAL_CODE:
+	case TQ_SIGNAL_CODE:
 	    member_index = rmeta->findSignal( member, TRUE );
 	    if ( member_index < 0 ) {		// normalize and retry
 		nw_member = qt_rmWS(member);	// remove whitespace
@@ -2181,7 +2181,7 @@ bool TQObject::connect( const TQObject *sender,	const char *signal,
 		 r->className(), member );
 	return FALSE;
     } else {
-	const TQMetaData *rm = membcode == TQSLOT_CODE ?
+	const TQMetaData *rm = membcode == TQ_SLOT_CODE ?
 			      rmeta->slot( member_index, TRUE ) :
 			      rmeta->signal( member_index, TRUE );
 	if ( rm ) {
@@ -2240,10 +2240,10 @@ void TQObject::connectInternal( const TQObject *sender, int signal_index, const
     const TQMetaData *rm = 0;
 
     switch ( membcode ) {			// get receiver member
-	case TQSLOT_CODE:
+	case TQ_SLOT_CODE:
 	    rm = rmeta->slot( member_index, TRUE );
 	    break;
-	case TQSIGNAL_CODE:
+	case TQ_SIGNAL_CODE:
 	    rm = rmeta->signal( member_index, TRUE );
 	    break;
     }
@@ -2312,11 +2312,11 @@ void TQObject::connectInternal( const TQObject *sender, int signal_index, const
        \endcode
     \i Disconnect everything connected to a specific signal:
        \code
-       disconnect( myObject, SIGNAL(mySignal()), 0, 0 );
+       disconnect( myObject, TQ_SIGNAL(mySignal()), 0, 0 );
        \endcode
        equivalent to the non-static overloaded function
        \code
-       myObject->disconnect( SIGNAL(mySignal()) );
+       myObject->disconnect( TQ_SIGNAL(mySignal()) );
        \endcode
     \i Disconnect a specific receiver:
        \code
@@ -2376,7 +2376,7 @@ bool TQObject::disconnect( const TQObject *sender,   const char *signal,
 	TQMetaObject *rmeta = r->metaObject();
 
 	switch ( membcode ) {			// get receiver member
-	case TQSLOT_CODE:
+	case TQ_SLOT_CODE:
 	    member_index = rmeta->findSlot( member, TRUE );
 	    if ( member_index < 0 ) {		// normalize and retry
 		nw_member = qt_rmWS(member);	// remove whitespace
@@ -2384,7 +2384,7 @@ bool TQObject::disconnect( const TQObject *sender,   const char *signal,
 		member_index = rmeta->findSlot( member, TRUE );
 	    }
 	    break;
-	case TQSIGNAL_CODE:
+	case TQ_SIGNAL_CODE:
 	    member_index = rmeta->findSignal( member, TRUE );
 	    if ( member_index < 0 ) {		// normalize and retry
 		nw_member = qt_rmWS(member);	// remove whitespace
@@ -2436,7 +2436,7 @@ bool TQObject::disconnect( const TQObject *sender,   const char *signal,
 	/* compatibility and safety: If a receiver has several slots
 	 * with the same name, disconnect them all*/
 	bool res = FALSE;
-	if ( membcode == TQSLOT_CODE && r ) {
+	if ( membcode == TQ_SLOT_CODE && r ) {
 	    TQMetaObject * rmeta = r->metaObject();
 	    do {
 		int mi = rmeta->findSlot( member );
@@ -2780,7 +2780,7 @@ void TQObject::activate_signal( TQConnectionList *clist, TQUObject *o )
 	    sol->ref();
 	    sol->currentSender = this;
 	}
-	if ( c->memberType() == TQSIGNAL_CODE ) {
+	if ( c->memberType() == TQ_SIGNAL_CODE ) {
 	    if ((d->disableThreadPostedEvents) || 
 	        (object->d->disableThreadPostedEvents) || 
 	        (currentThread && currentThread->threadPostedEventsDisabled()) || 
@@ -2853,7 +2853,7 @@ void TQObject::activate_signal( TQConnectionList *clist, TQUObject *o )
 		sol->ref();
 		sol->currentSender = this;
 	    }
-	    if ( c->memberType() == TQSIGNAL_CODE ) {
+	    if ( c->memberType() == TQ_SIGNAL_CODE ) {
 		if ((d->disableThreadPostedEvents) || 
 		    (object->d->disableThreadPostedEvents) || 
 		    (currentThread && currentThread->threadPostedEventsDisabled()) || 
diff --git a/src/kernel/qobjectcleanuphandler.cpp b/src/kernel/qobjectcleanuphandler.cpp
index f9f5d3e2f..8523e4add 100644
--- a/src/kernel/qobjectcleanuphandler.cpp
+++ b/src/kernel/qobjectcleanuphandler.cpp
@@ -122,7 +122,7 @@ TQObject* TQObjectCleanupHandler::add( TQObject* object )
 	cleanupObjects = new TQObjectList;
  	cleanupObjects->setAutoDelete( TRUE );
     }
-    connect( object, SIGNAL(destroyed(TQObject*)), this, SLOT(objectDestroyed(TQObject*)) );
+    connect( object, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(objectDestroyed(TQObject*)) );
     cleanupObjects->insert( 0, object );
     return object;
 }
@@ -137,7 +137,7 @@ void TQObjectCleanupHandler::remove( TQObject *object )
 	return;
     if ( cleanupObjects->findRef( object ) >= 0 ) {
 	(void) cleanupObjects->take();
-	disconnect( object, SIGNAL(destroyed(TQObject*)), this, SLOT(objectDestroyed(TQObject*)) );
+	disconnect( object, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(objectDestroyed(TQObject*)) );
     }
 }
 
diff --git a/src/kernel/qprocess.cpp b/src/kernel/qprocess.cpp
index 13fb195e3..f052c9cb8 100644
--- a/src/kernel/qprocess.cpp
+++ b/src/kernel/qprocess.cpp
@@ -130,7 +130,7 @@
     \skipto proc = new TQProcess( this );
     \printline proc = new TQProcess( this );
     \skipto proc->addArgument( "uic" );
-    \printuntil this, SLOT(readFromStdout()) );
+    \printuntil this, TQ_SLOT(readFromStdout()) );
     \skipto if ( !proc->start() ) {
     \printuntil // error handling
     \skipto }
@@ -621,8 +621,8 @@ bool TQProcess::launch( const TQByteArray& buf, TQStringList *env )
 {
     if ( start( env ) ) {
 	if ( !buf.isEmpty() ) {
-	    connect( this, SIGNAL(wroteToStdin()),
-		    this, SLOT(closeStdinLaunch()) );
+	    connect( this, TQ_SIGNAL(wroteToStdin()),
+		    this, TQ_SLOT(closeStdinLaunch()) );
 	    writeToStdin( buf );
 	} else {
 	    closeStdin();
@@ -645,8 +645,8 @@ bool TQProcess::launch( const TQString& buf, TQStringList *env )
 {
     if ( start( env ) ) {
 	if ( !buf.isEmpty() ) {
-	    connect( this, SIGNAL(wroteToStdin()),
-		    this, SLOT(closeStdinLaunch()) );
+	    connect( this, TQ_SIGNAL(wroteToStdin()),
+		    this, TQ_SLOT(closeStdinLaunch()) );
 	    writeToStdin( buf );
 	} else {
 	    closeStdin();
@@ -664,8 +664,8 @@ bool TQProcess::launch( const TQString& buf, TQStringList *env )
 */
 void TQProcess::closeStdinLaunch()
 {
-    disconnect( this, SIGNAL(wroteToStdin()),
-	    this, SLOT(closeStdinLaunch()) );
+    disconnect( this, TQ_SIGNAL(wroteToStdin()),
+	    this, TQ_SLOT(closeStdinLaunch()) );
     closeStdin();
     emit launchFinished();
 }
@@ -751,8 +751,8 @@ void TQProcess::connectNotify( const char * signal )
     tqDebug( "TQProcess::connectNotify(): signal %s has been connected", signal );
 #endif
     if ( !ioRedirection )
-	if ( qstrcmp( signal, SIGNAL(readyReadStdout()) )==0 ||
-		qstrcmp( signal, SIGNAL(readyReadStderr()) )==0
+	if ( qstrcmp( signal, TQ_SIGNAL(readyReadStdout()) )==0 ||
+		qstrcmp( signal, TQ_SIGNAL(readyReadStderr()) )==0
 	   ) {
 #if defined(QT_QPROCESS_DEBUG)
 	    tqDebug( "TQProcess::connectNotify(): set ioRedirection to TRUE" );
@@ -760,14 +760,14 @@ void TQProcess::connectNotify( const char * signal )
 	    setIoRedirection( TRUE );
 	    return;
 	}
-    if ( !notifyOnExit && qstrcmp( signal, SIGNAL(processExited()) )==0 ) {
+    if ( !notifyOnExit && qstrcmp( signal, TQ_SIGNAL(processExited()) )==0 ) {
 #if defined(QT_QPROCESS_DEBUG)
 	tqDebug( "TQProcess::connectNotify(): set notifyOnExit to TRUE" );
 #endif
 	setNotifyOnExit( TRUE );
 	return;
     }
-    if ( !wroteToStdinConnected && qstrcmp( signal, SIGNAL(wroteToStdin()) )==0 ) {
+    if ( !wroteToStdinConnected && qstrcmp( signal, TQ_SIGNAL(wroteToStdin()) )==0 ) {
 #if defined(QT_QPROCESS_DEBUG)
 	tqDebug( "TQProcess::connectNotify(): set wroteToStdinConnected to TRUE" );
 #endif
@@ -781,21 +781,21 @@ void TQProcess::connectNotify( const char * signal )
 void TQProcess::disconnectNotify( const char * )
 {
     if ( ioRedirection &&
-	    receivers( SIGNAL(readyReadStdout()) ) ==0 &&
-	    receivers( SIGNAL(readyReadStderr()) ) ==0
+	    receivers( TQ_SIGNAL(readyReadStdout()) ) ==0 &&
+	    receivers( TQ_SIGNAL(readyReadStderr()) ) ==0
 	    ) {
 #if defined(QT_QPROCESS_DEBUG)
 	tqDebug( "TQProcess::disconnectNotify(): set ioRedirection to FALSE" );
 #endif
 	setIoRedirection( FALSE );
     }
-    if ( notifyOnExit && receivers( SIGNAL(processExited()) ) == 0 ) {
+    if ( notifyOnExit && receivers( TQ_SIGNAL(processExited()) ) == 0 ) {
 #if defined(QT_QPROCESS_DEBUG)
 	tqDebug( "TQProcess::disconnectNotify(): set notifyOnExit to FALSE" );
 #endif
 	setNotifyOnExit( FALSE );
     }
-    if ( wroteToStdinConnected && receivers( SIGNAL(wroteToStdin()) ) == 0 ) {
+    if ( wroteToStdinConnected && receivers( TQ_SIGNAL(wroteToStdin()) ) == 0 ) {
 #if defined(QT_QPROCESS_DEBUG)
 	tqDebug( "TQProcess::disconnectNotify(): set wroteToStdinConnected to FALSE" );
 #endif
diff --git a/src/kernel/qprocess_unix.cpp b/src/kernel/qprocess_unix.cpp
index f41923fd2..6d0f27abf 100644
--- a/src/kernel/qprocess_unix.cpp
+++ b/src/kernel/qprocess_unix.cpp
@@ -277,8 +277,8 @@ TQProcessManager::TQProcessManager() : sn(0)
 #endif
 	sn = new TQSocketNotifier( sigchldFd[1],
 		TQSocketNotifier::Read, this );
-	connect( sn, SIGNAL(activated(int)),
-		this, SLOT(sigchldHnd(int)) );
+	connect( sn, TQ_SIGNAL(activated(int)),
+		this, TQ_SLOT(sigchldHnd(int)) );
 	sn->setEnabled( TRUE );
     }
 
@@ -352,7 +352,7 @@ void TQProcessManager::remove( TQProc *p )
 void TQProcessManager::cleanup()
 {
     if ( procList->count() == 0 ) {
-	TQTimer::singleShot( 0, this, SLOT(removeMe()) );
+	TQTimer::singleShot( 0, this, TQ_SLOT(removeMe()) );
     }
 }
 
@@ -944,8 +944,8 @@ bool TQProcess::start( TQStringList *env )
 	fcntl(d->proc->socketStdin, F_SETFL, originalFlags | O_NONBLOCK);
 
 	d->notifierStdin = new TQSocketNotifier( sStdin[1], TQSocketNotifier::Write );
-	connect( d->notifierStdin, SIGNAL(activated(int)),
-		this, SLOT(socketWrite(int)) );
+	connect( d->notifierStdin, TQ_SIGNAL(activated(int)),
+		this, TQ_SLOT(socketWrite(int)) );
 	// setup notifiers for the sockets
 	if ( !d->stdinBuf.isEmpty() ) {
 	    d->notifierStdin->setEnabled( TRUE );
@@ -955,8 +955,8 @@ bool TQProcess::start( TQStringList *env )
 	::close( sStdout[1] );
 	d->proc->socketStdout = sStdout[0];
 	d->notifierStdout = new TQSocketNotifier( sStdout[0], TQSocketNotifier::Read );
-	connect( d->notifierStdout, SIGNAL(activated(int)),
-		this, SLOT(socketRead(int)) );
+	connect( d->notifierStdout, TQ_SIGNAL(activated(int)),
+		this, TQ_SLOT(socketRead(int)) );
 	if ( ioRedirection )
 	    d->notifierStdout->setEnabled( TRUE );
     }
@@ -964,8 +964,8 @@ bool TQProcess::start( TQStringList *env )
 	::close( sStderr[1] );
 	d->proc->socketStderr = sStderr[0];
 	d->notifierStderr = new TQSocketNotifier( sStderr[0], TQSocketNotifier::Read );
-	connect( d->notifierStderr, SIGNAL(activated(int)),
-		this, SLOT(socketRead(int)) );
+	connect( d->notifierStderr, TQ_SIGNAL(activated(int)),
+		this, TQ_SLOT(socketRead(int)) );
 	if ( ioRedirection )
 	    d->notifierStderr->setEnabled( TRUE );
     }
@@ -1028,7 +1028,7 @@ void TQProcess::tryTerminate() const
     is to do something like this:
     \code
 	process->tryTerminate();
-	TQTimer::singleShot( 5000, process, SLOT( kill() ) );
+	TQTimer::singleShot( 5000, process, TQ_SLOT( kill() ) );
     \endcode
 
     This tries to terminate the process the nice way. If the process
diff --git a/src/kernel/qsignal.cpp b/src/kernel/qsignal.cpp
index 53b0a62a0..f9c6c233a 100644
--- a/src/kernel/qsignal.cpp
+++ b/src/kernel/qsignal.cpp
@@ -147,9 +147,9 @@ bool TQSignal::connect( const TQObject *receiver, const char *member )
 #ifndef TQT_NO_VARIANT
     if ( intSignature( member ) )
 #endif
-	return TQObject::connect( (TQObject *)this, SIGNAL(intSignal(int)), receiver, member );
+	return TQObject::connect( (TQObject *)this, TQ_SIGNAL(intSignal(int)), receiver, member );
 #ifndef TQT_NO_VARIANT
-    return TQObject::connect( (TQObject *)this, SIGNAL(signal(const TQVariant&)),
+    return TQObject::connect( (TQObject *)this, TQ_SIGNAL(signal(const TQVariant&)),
 			     receiver, member );
 #endif
 }
@@ -167,9 +167,9 @@ bool TQSignal::disconnect( const TQObject *receiver, const char *member )
 #ifndef TQT_NO_VARIANT
     if ( intSignature( member ) )
 #endif
-	return TQObject::disconnect( (TQObject *)this, SIGNAL(intSignal(int)), receiver, member );
+	return TQObject::disconnect( (TQObject *)this, TQ_SIGNAL(intSignal(int)), receiver, member );
 #ifndef TQT_NO_VARIANT
-    return TQObject::disconnect( (TQObject *)this, SIGNAL(signal(const TQVariant&)),
+    return TQObject::disconnect( (TQObject *)this, TQ_SIGNAL(signal(const TQVariant&)),
 				receiver, member );
 #endif
 }
diff --git a/src/kernel/qsignalmapper.cpp b/src/kernel/qsignalmapper.cpp
index ce6f21759..8efd27371 100644
--- a/src/kernel/qsignalmapper.cpp
+++ b/src/kernel/qsignalmapper.cpp
@@ -158,7 +158,7 @@ TQSignalMapperRec* TQSignalMapper::getRec( const TQObject* sender )
     if (!rec) {
 	rec = new TQSignalMapperRec;
 	d->dict.insert( (void*)sender, rec );
-	connect( sender, SIGNAL(destroyed()), this, SLOT(removeMapping()) );
+	connect( sender, TQ_SIGNAL(destroyed()), this, TQ_SLOT(removeMapping()) );
     }
     return rec;
 }
diff --git a/src/kernel/qsound_x11.cpp b/src/kernel/qsound_x11.cpp
index e3a727f8b..2eaf0b46b 100644
--- a/src/kernel/qsound_x11.cpp
+++ b/src/kernel/qsound_x11.cpp
@@ -120,8 +120,8 @@ TQAuServerNAS::TQAuServerNAS(TQObject* parent) :
 	// Ask TQt for async messages...
 	sn=new TQSocketNotifier(AuServerConnectionNumber(nas),
 		TQSocketNotifier::Read);
-	TQObject::connect(sn, SIGNAL(activated(int)),
-		this, SLOT(dataReceived()));
+	TQObject::connect(sn, TQ_SIGNAL(activated(int)),
+		this, TQ_SLOT(dataReceived()));
     } else {
 	sn = 0;
     }
@@ -223,8 +223,8 @@ void TQAuServerNAS::stop(TQSound* s)
 
 void TQAuServerNAS::init(TQSound* s)
 {
-    connect(s, SIGNAL(destroyed(TQObject *)),
-	    this, SLOT(soundDestroyed(TQObject *)));
+    connect(s, TQ_SIGNAL(destroyed(TQObject *)),
+	    this, TQ_SLOT(soundDestroyed(TQObject *)));
 
     if ( nas ) {
         AuBucketID b_id =
diff --git a/src/kernel/qtimer.cpp b/src/kernel/qtimer.cpp
index 0c70113f4..f7736c028 100644
--- a/src/kernel/qtimer.cpp
+++ b/src/kernel/qtimer.cpp
@@ -62,7 +62,7 @@
     Example:
     \code
 	TQTimer *timer = new TQTimer( myObject );
-	connect( timer, SIGNAL(timeout()), myObject, SLOT(timerDone()) );
+	connect( timer, TQ_SIGNAL(timeout()), myObject, TQ_SLOT(timerDone()) );
 	timer->start( 2000, TRUE ); // 2 seconds single-shot timer
     \endcode
 
@@ -77,7 +77,7 @@
     user interface:
     \code
 	TQTimer *t = new TQTimer( myObject );
-	connect( t, SIGNAL(timeout()), SLOT(processOneThing()) );
+	connect( t, TQ_SIGNAL(timeout()), TQ_SLOT(processOneThing()) );
 	t->start( 0, FALSE );
     \endcode
 
@@ -308,7 +308,7 @@ bool TQSingleShotTimer::event( TQEvent * )
 	int main( int argc, char **argv )
 	{
 	    TQApplication a( argc, argv );
-	    TQTimer::singleShot( 10*60*1000, &a, SLOT(quit()) );
+	    TQTimer::singleShot( 10*60*1000, &a, TQ_SLOT(quit()) );
 		... // create and show your widgets
 	    return a.exec();
 	}
diff --git a/src/kernel/qurloperator.cpp b/src/kernel/qurloperator.cpp
index 1defadc97..ca508c48c 100644
--- a/src/kernel/qurloperator.cpp
+++ b/src/kernel/qurloperator.cpp
@@ -600,23 +600,23 @@ TQPtrList<TQNetworkOperation> TQUrlOperator::copy( const TQString &from, const T
     if ( gProt && (gProt->supportedOperations()&TQNetworkProtocol::OpGet) &&
 	 pProt && (pProt->supportedOperations()&TQNetworkProtocol::OpPut) ) {
 
-	connect( gProt, SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
-		 this, SLOT( copyGotData(const TQByteArray&,TQNetworkOperation*) ) );
-	connect( gProt, SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
-		 this, SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
-	connect( gProt, SIGNAL( finished(TQNetworkOperation*) ),
-		 this, SLOT( continueCopy(TQNetworkOperation*) ) );
-	connect( gProt, SIGNAL( finished(TQNetworkOperation*) ),
-		 this, SIGNAL( finished(TQNetworkOperation*) ) );
-	connect( gProt, SIGNAL( connectionStateChanged(int,const TQString&) ),
-		 this, SIGNAL( connectionStateChanged(int,const TQString&) ) );
-
-	connect( pProt, SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
-		 this, SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
-	connect( pProt, SIGNAL( finished(TQNetworkOperation*) ),
-		 this, SIGNAL( finished(TQNetworkOperation*) ) );
-	connect( pProt, SIGNAL( finished(TQNetworkOperation*) ),
-		 this, SLOT( finishedCopy() ) );
+	connect( gProt, TQ_SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
+		 this, TQ_SLOT( copyGotData(const TQByteArray&,TQNetworkOperation*) ) );
+	connect( gProt, TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
+		 this, TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
+	connect( gProt, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+		 this, TQ_SLOT( continueCopy(TQNetworkOperation*) ) );
+	connect( gProt, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+		 this, TQ_SIGNAL( finished(TQNetworkOperation*) ) );
+	connect( gProt, TQ_SIGNAL( connectionStateChanged(int,const TQString&) ),
+		 this, TQ_SIGNAL( connectionStateChanged(int,const TQString&) ) );
+
+	connect( pProt, TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ),
+		 this, TQ_SIGNAL( dataTransferProgress(int,int,TQNetworkOperation*) ) );
+	connect( pProt, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+		 this, TQ_SIGNAL( finished(TQNetworkOperation*) ) );
+	connect( pProt, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+		 this, TQ_SLOT( finishedCopy() ) );
 
 	TQNetworkOperation *opGet = new TQNetworkOperation( TQNetworkProtocol::OpGet, frm, TQString::null, TQString::null );
 	ops.append( opGet );
@@ -935,8 +935,8 @@ void TQUrlOperator::getNetworkProtocol()
 
     d->networkProtocol = (TQNetworkProtocol *)p;
     d->networkProtocol->setUrl( this );
-    connect( d->networkProtocol, SIGNAL( itemChanged(TQNetworkOperation*) ),
-	     this, SLOT( slotItemChanged(TQNetworkOperation*) ) );
+    connect( d->networkProtocol, TQ_SIGNAL( itemChanged(TQNetworkOperation*) ),
+	     this, TQ_SLOT( slotItemChanged(TQNetworkOperation*) ) );
 }
 
 /*!
@@ -1121,10 +1121,10 @@ void TQUrlOperator::continueCopy( TQNetworkOperation *op )
 	    deleteOperation( rm );
 	}
     }
-    disconnect( gProt, SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
-		this, SLOT( copyGotData(const TQByteArray&,TQNetworkOperation*) ) );
-    disconnect( gProt, SIGNAL( finished(TQNetworkOperation*) ),
-		this, SLOT( continueCopy(TQNetworkOperation*) ) );
+    disconnect( gProt, TQ_SIGNAL( data(const TQByteArray&,TQNetworkOperation*) ),
+		this, TQ_SLOT( copyGotData(const TQByteArray&,TQNetworkOperation*) ) );
+    disconnect( gProt, TQ_SIGNAL( finished(TQNetworkOperation*) ),
+		this, TQ_SLOT( continueCopy(TQNetworkOperation*) ) );
 }
 
 /*!
diff --git a/src/kernel/qwidget.cpp b/src/kernel/qwidget.cpp
index 4885346d7..0e9c606af 100644
--- a/src/kernel/qwidget.cpp
+++ b/src/kernel/qwidget.cpp
@@ -3203,15 +3203,15 @@ void TQWidget::setFocusProxy( TQWidget * w )
     createExtra();
 
     if ( extra->focus_proxy ) {
-	disconnect( extra->focus_proxy, SIGNAL(destroyed()),
-		    this, SLOT(focusProxyDestroyed()) );
+	disconnect( extra->focus_proxy, TQ_SIGNAL(destroyed()),
+		    this, TQ_SLOT(focusProxyDestroyed()) );
 	extra->focus_proxy = 0;
     }
 
     if ( w ) {
 	setFocusPolicy( w->focusPolicy() );
-	connect( w, SIGNAL(destroyed()),
-		 this, SLOT(focusProxyDestroyed()) );
+	connect( w, TQ_SIGNAL(destroyed()),
+		 this, TQ_SLOT(focusProxyDestroyed()) );
     }
     extra->focus_proxy = w;
 }
@@ -4338,7 +4338,7 @@ bool TQWidget::close( bool alsoDelete )
     if ( !deleted && !isHidden() )
 	hide();
     if ( checkLastWindowClosed
-	 && tqApp->receivers(SIGNAL(lastWindowClosed())) ) {
+	 && tqApp->receivers(TQ_SIGNAL(lastWindowClosed())) ) {
 	/* if there is no non-withdrawn top level window left (except
 	   the desktop, popups, or dialogs with parents), we emit the
 	   lastWindowClosed signal */
diff --git a/src/kernel/qwidget_x11.cpp b/src/kernel/qwidget_x11.cpp
index 3d64b6fe2..a5919b839 100644
--- a/src/kernel/qwidget_x11.cpp
+++ b/src/kernel/qwidget_x11.cpp
@@ -2968,10 +2968,10 @@ void TQWidget::changeInputContext( const TQString& identifierName )
     TQInputContext *qic = TQInputContextFactory::create( identifierName, icWidget );
     *qicp = qic;
     if ( qic ) {
-	TQObject::connect( qic, SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)),
-			  tqApp, SLOT(postIMEvent(TQObject *,TQIMEvent *)) );
-	TQObject::connect( qic, SIGNAL(deletionRequested()),
-			  icWidget, SLOT(destroyInputContext()) );
+	TQObject::connect( qic, TQ_SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)),
+			  tqApp, TQ_SLOT(postIMEvent(TQObject *,TQIMEvent *)) );
+	TQObject::connect( qic, TQ_SIGNAL(deletionRequested()),
+			  icWidget, TQ_SLOT(destroyInputContext()) );
     }
 }
 
@@ -3007,10 +3007,10 @@ void TQWidget::createInputContext()
 
 	*qicp = qic;
 	if ( qic ) {
-	    TQObject::connect( qic, SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)),
-			      tqApp, SLOT(postIMEvent(TQObject *,TQIMEvent *)) );
-	    TQObject::connect( qic, SIGNAL(deletionRequested()),
-			      icWidget, SLOT(destroyInputContext()) );
+	    TQObject::connect( qic, TQ_SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)),
+			      tqApp, TQ_SLOT(postIMEvent(TQObject *,TQIMEvent *)) );
+	    TQObject::connect( qic, TQ_SIGNAL(deletionRequested()),
+			      icWidget, TQ_SLOT(destroyInputContext()) );
   	}
     }
 #endif // TQT_NO_IM