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

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

5 files changed, 115 insertions, 115 deletions

diff --git a/src/network/qdns.cpp b/src/network/qdns.cpp
index d259cc0e4..b1eeaa53f 100644
--- a/src/network/qdns.cpp
+++ b/src/network/qdns.cpp
@@ -942,15 +942,15 @@ TQDnsManager::TQDnsManager()
 
     TQTimer * sweepTimer = new TQTimer( this );
     sweepTimer->start( 1000 * 60 * 3 );
-    connect( sweepTimer, SIGNAL(timeout()),
-	     this, SLOT(cleanCache()) );
+    connect( sweepTimer, TQ_SIGNAL(timeout()),
+	     this, TQ_SLOT(cleanCache()) );
 
     TQSocketNotifier * rn4 = new TQSocketNotifier( ipv4Socket->socket(),
 						 TQSocketNotifier::Read,
 						 this, "dns IPv4 socket watcher" );
     ipv4Socket->setAddressReusable( FALSE );
     ipv4Socket->setBlocking( FALSE );
-    connect( rn4, SIGNAL(activated(int)), SLOT(answer()) );
+    connect( rn4, TQ_SIGNAL(activated(int)), TQ_SLOT(answer()) );
 
 #if !defined (TQT_NO_IPV6)
     // Don't connect the IPv6 socket notifier if the host does not
@@ -963,7 +963,7 @@ TQDnsManager::TQDnsManager()
 	ipv6support = TRUE;
 	ipv6Socket->setAddressReusable( FALSE );
 	ipv6Socket->setBlocking( FALSE );
-	connect( rn6, SIGNAL(activated(int)), SLOT(answer()) );
+	connect( rn6, TQ_SIGNAL(activated(int)), TQ_SLOT(answer()) );
     }
 #endif
 
@@ -1169,7 +1169,7 @@ void TQDnsManager::transmitQuery( int i )
 	tqDebug( "DNS Manager: giving up on query 0x%04x", q->id );
 #endif
 	delete q;
-	TQTimer::singleShot( 0, TQDnsManager::manager(), SLOT(cleanCache()) );
+	TQTimer::singleShot( 0, TQDnsManager::manager(), TQ_SLOT(cleanCache()) );
 	// and don't process anything more
 	return;
     }
@@ -1265,7 +1265,7 @@ void TQDnsManager::transmitQuery( int i )
 	tqDebug( "DNS Manager: no DNS server found on query 0x%04x", q->id );
 #endif
 	delete q;
-	TQTimer::singleShot( 1000*10, TQDnsManager::manager(), SLOT(cleanCache()) );
+	TQTimer::singleShot( 1000*10, TQDnsManager::manager(), TQ_SLOT(cleanCache()) );
 	// and don't process anything more
 	return;
     }
@@ -1467,9 +1467,9 @@ TQPtrList<TQDnsRR> * TQDnsDomain::cached( const TQDns * r )
 			// timeouts: we make sure to use high timeouts
 			// and few tramsissions.
 			query->step = ns->count();
-			TQObject::connect( query, SIGNAL(timeout()),
+			TQObject::connect( query, TQ_SIGNAL(timeout()),
 					  TQDnsManager::manager(),
-					  SLOT(retransmit()) );
+					  TQ_SLOT(retransmit()) );
 			TQDnsManager::manager()->transmitQuery( query );
 		    }
 		}
@@ -1519,8 +1519,8 @@ TQPtrList<TQDnsRR> * TQDnsDomain::cached( const TQDns * r )
 		query->t = r->recordType();
 		query->l = s;
 		query->dns->replace( (void*)r, (void*)r );
-		TQObject::connect( query, SIGNAL(timeout()),
-				  TQDnsManager::manager(), SLOT(retransmit()) );
+		TQObject::connect( query, TQ_SIGNAL(timeout()),
+				  TQDnsManager::manager(), TQ_SLOT(retransmit()) );
 		TQDnsManager::manager()->transmitQuery( query );
 	    } else if ( q < m->queries.size() ) {
 		// if we've found an earlier query for the same
@@ -1908,8 +1908,8 @@ void TQDns::setStartQueryTimer()
     {
 	// start the query the next time we enter event loop
 	d->queryTimer = new TQTimer( this );
-	connect( d->queryTimer, SIGNAL(timeout()),
-		 this, SLOT(startQuery()) );
+	connect( d->queryTimer, TQ_SIGNAL(timeout()),
+		 this, TQ_SLOT(startQuery()) );
 	d->queryTimer->start( 0, TRUE );
     }
 }
@@ -2278,7 +2278,7 @@ TQString TQDns::canonicalName() const
 */
 void TQDns::connectNotify( const char *signal )
 {
-    if ( d->noEventLoop && qstrcmp(signal,SIGNAL(resultsReady()) )==0 ) {
+    if ( d->noEventLoop && qstrcmp(signal,TQ_SIGNAL(resultsReady()) )==0 ) {
 	doSynchronousLookup();
     }
 }
diff --git a/src/network/qftp.cpp b/src/network/qftp.cpp
index f31029321..797392cc4 100644
--- a/src/network/qftp.cpp
+++ b/src/network/qftp.cpp
@@ -297,16 +297,16 @@ TQFtpDTP::TQFtpDTP( TQFtpPI *p, TQObject *parent, const char *name ) :
 {
     clearData();
 
-    connect( &socket, SIGNAL( connected() ),
-	     SLOT( socketConnected() ) );
-    connect( &socket, SIGNAL( readyRead() ),
-	     SLOT( socketReadyRead() ) );
-    connect( &socket, SIGNAL( error(int) ),
-	     SLOT( socketError(int) ) );
-    connect( &socket, SIGNAL( connectionClosed() ),
-	     SLOT( socketConnectionClosed() ) );
-    connect( &socket, SIGNAL( bytesWritten(int) ),
-	     SLOT( socketBytesWritten(int) ) );
+    connect( &socket, TQ_SIGNAL( connected() ),
+	     TQ_SLOT( socketConnected() ) );
+    connect( &socket, TQ_SIGNAL( readyRead() ),
+	     TQ_SLOT( socketReadyRead() ) );
+    connect( &socket, TQ_SIGNAL( error(int) ),
+	     TQ_SLOT( socketError(int) ) );
+    connect( &socket, TQ_SIGNAL( connectionClosed() ),
+	     TQ_SLOT( socketConnectionClosed() ) );
+    connect( &socket, TQ_SIGNAL( bytesWritten(int) ),
+	     TQ_SLOT( socketBytesWritten(int) ) );
 }
 
 void TQFtpDTP::setData( TQByteArray *ba )
@@ -637,21 +637,21 @@ TQFtpPI::TQFtpPI( TQObject *parent ) :
     waitForDtpToConnect( FALSE ),
     waitForDtpToClose( FALSE )
 {
-    connect( &commandSocket, SIGNAL(hostFound()),
-	    SLOT(hostFound()) );
-    connect( &commandSocket, SIGNAL(connected()),
-	    SLOT(connected()) );
-    connect( &commandSocket, SIGNAL(connectionClosed()),
-	    SLOT(connectionClosed()) );
-    connect( &commandSocket, SIGNAL(delayedCloseFinished()),
-	    SLOT(delayedCloseFinished()) );
-    connect( &commandSocket, SIGNAL(readyRead()),
-	    SLOT(readyRead()) );
-    connect( &commandSocket, SIGNAL(error(int)),
-	    SLOT(error(int)) );
+    connect( &commandSocket, TQ_SIGNAL(hostFound()),
+	    TQ_SLOT(hostFound()) );
+    connect( &commandSocket, TQ_SIGNAL(connected()),
+	    TQ_SLOT(connected()) );
+    connect( &commandSocket, TQ_SIGNAL(connectionClosed()),
+	    TQ_SLOT(connectionClosed()) );
+    connect( &commandSocket, TQ_SIGNAL(delayedCloseFinished()),
+	    TQ_SLOT(delayedCloseFinished()) );
+    connect( &commandSocket, TQ_SIGNAL(readyRead()),
+	    TQ_SLOT(readyRead()) );
+    connect( &commandSocket, TQ_SIGNAL(error(int)),
+	    TQ_SLOT(error(int)) );
 
-    connect( &dtp, SIGNAL(connectState(int)),
-	     SLOT(dtpConnectState(int)) );
+    connect( &dtp, TQ_SIGNAL(connectState(int)),
+	     TQ_SLOT(dtpConnectState(int)) );
 }
 
 void TQFtpPI::connectToHost( const TQString &host, TQ_UINT16 port )
@@ -1251,21 +1251,21 @@ void TQFtp::init()
     TQFtpPrivate *d = ::d( this );
     d->errorString = tr( "Unknown error" );
 
-    connect( &d->pi, SIGNAL(connectState(int)),
-	    SLOT(piConnectState(int)) );
-    connect( &d->pi, SIGNAL(finished(const TQString&)),
-	    SLOT(piFinished(const TQString&)) );
-    connect( &d->pi, SIGNAL(error(int,const TQString&)),
-	    SLOT(piError(int,const TQString&)) );
-    connect( &d->pi, SIGNAL(rawFtpReply(int,const TQString&)),
-	    SLOT(piFtpReply(int,const TQString&)) );
+    connect( &d->pi, TQ_SIGNAL(connectState(int)),
+	    TQ_SLOT(piConnectState(int)) );
+    connect( &d->pi, TQ_SIGNAL(finished(const TQString&)),
+	    TQ_SLOT(piFinished(const TQString&)) );
+    connect( &d->pi, TQ_SIGNAL(error(int,const TQString&)),
+	    TQ_SLOT(piError(int,const TQString&)) );
+    connect( &d->pi, TQ_SIGNAL(rawFtpReply(int,const TQString&)),
+	    TQ_SLOT(piFtpReply(int,const TQString&)) );
 
-    connect( &d->pi.dtp, SIGNAL(readyRead()),
-	    SIGNAL(readyRead()) );
-    connect( &d->pi.dtp, SIGNAL(dataTransferProgress(int,int)),
-	    SIGNAL(dataTransferProgress(int,int)) );
-    connect( &d->pi.dtp, SIGNAL(listInfo(const TQUrlInfo&)),
-	    SIGNAL(listInfo(const TQUrlInfo&)) );
+    connect( &d->pi.dtp, TQ_SIGNAL(readyRead()),
+	    TQ_SIGNAL(readyRead()) );
+    connect( &d->pi.dtp, TQ_SIGNAL(dataTransferProgress(int,int)),
+	    TQ_SIGNAL(dataTransferProgress(int,int)) );
+    connect( &d->pi.dtp, TQ_SIGNAL(listInfo(const TQUrlInfo&)),
+	    TQ_SIGNAL(listInfo(const TQUrlInfo&)) );
 }
 
 /*!
@@ -1963,7 +1963,7 @@ int TQFtp::addCommand( TQFtpCommand *cmd )
 
     if ( d->pending.count() == 1 )
 	// don't emit the commandStarted() signal before the id is returned
-	TQTimer::singleShot( 0, this, SLOT(startNextCommand()) );
+	TQTimer::singleShot( 0, this, TQ_SLOT(startNextCommand()) );
 
     return cmd->id;
 }
@@ -2020,7 +2020,7 @@ void TQFtp::piFinished( const TQString& )
 
     if ( c->command == Close ) {
 	// The order of in which the slots are called is arbitrary, so
-	// disconnect the SIGNAL-SIGNAL temporary to make sure that we
+	// disconnect the TQ_SIGNAL-TQ_SIGNAL temporary to make sure that we
 	// don't get the commandFinished() signal before the stateChanged()
 	// signal.
 	if ( d->state != TQFtp::Unconnected ) {
@@ -2197,16 +2197,16 @@ bool TQFtp::checkConnection( TQNetworkOperation *op )
 {
     TQFtpPrivate *d = ::d( this );
     if ( state() == Unconnected && !d->npWaitForLoginDone ) {
-	connect( this, SIGNAL(listInfo(const TQUrlInfo&)),
-		this, SLOT(npListInfo(const TQUrlInfo&)) );
-	connect( this, SIGNAL(done(bool)),
-		this, SLOT(npDone(bool)) );
-	connect( this, SIGNAL(stateChanged(int)),
-		this, SLOT(npStateChanged(int)) );
-	connect( this, SIGNAL(dataTransferProgress(int,int)),
-		this, SLOT(npDataTransferProgress(int,int)) );
-	connect( this, SIGNAL(readyRead()),
-		this, SLOT(npReadyRead()) );
+	connect( this, TQ_SIGNAL(listInfo(const TQUrlInfo&)),
+		this, TQ_SLOT(npListInfo(const TQUrlInfo&)) );
+	connect( this, TQ_SIGNAL(done(bool)),
+		this, TQ_SLOT(npDone(bool)) );
+	connect( this, TQ_SIGNAL(stateChanged(int)),
+		this, TQ_SLOT(npStateChanged(int)) );
+	connect( this, TQ_SIGNAL(dataTransferProgress(int,int)),
+		this, TQ_SLOT(npDataTransferProgress(int,int)) );
+	connect( this, TQ_SIGNAL(readyRead()),
+		this, TQ_SLOT(npReadyRead()) );
 
 	d->npWaitForLoginDone = TRUE;
 	switch ( op->operation() ) {
@@ -2321,16 +2321,16 @@ void TQFtp::npDone( bool err )
     d->npWaitForLoginDone = FALSE;
 
     if ( state() == Unconnected ) {
-	disconnect( this, SIGNAL(listInfo(const TQUrlInfo&)),
-		    this, SLOT(npListInfo(const TQUrlInfo&)) );
-	disconnect( this, SIGNAL(done(bool)),
-		    this, SLOT(npDone(bool)) );
-	disconnect( this, SIGNAL(stateChanged(int)),
-		    this, SLOT(npStateChanged(int)) );
-	disconnect( this, SIGNAL(dataTransferProgress(int,int)),
-		    this, SLOT(npDataTransferProgress(int,int)) );
-	disconnect( this, SIGNAL(readyRead()),
-		    this, SLOT(npReadyRead()) );
+	disconnect( this, TQ_SIGNAL(listInfo(const TQUrlInfo&)),
+		    this, TQ_SLOT(npListInfo(const TQUrlInfo&)) );
+	disconnect( this, TQ_SIGNAL(done(bool)),
+		    this, TQ_SLOT(npDone(bool)) );
+	disconnect( this, TQ_SIGNAL(stateChanged(int)),
+		    this, TQ_SLOT(npStateChanged(int)) );
+	disconnect( this, TQ_SIGNAL(dataTransferProgress(int,int)),
+		    this, TQ_SLOT(npDataTransferProgress(int,int)) );
+	disconnect( this, TQ_SIGNAL(readyRead()),
+		    this, TQ_SLOT(npReadyRead()) );
     }
 
     // emit the finished() signal at the very end to avoid reentrance problems
diff --git a/src/network/qhttp.cpp b/src/network/qhttp.cpp
index 393cc18c0..d08f10f24 100644
--- a/src/network/qhttp.cpp
+++ b/src/network/qhttp.cpp
@@ -1225,18 +1225,18 @@ void TQHttp::init()
     d = new TQHttpPrivate;
     d->errorString = tr( "Unknown error" );
 
-    connect( &d->socket, SIGNAL( connected() ),
-	    this, SLOT( slotConnected() ) );
-    connect( &d->socket, SIGNAL( connectionClosed() ),
-	    this, SLOT( slotClosed() ) );
-    connect( &d->socket, SIGNAL( delayedCloseFinished() ),
-	    this, SLOT( slotClosed() ) );
-    connect( &d->socket, SIGNAL( readyRead() ),
-	    this, SLOT( slotReadyRead() ) );
-    connect( &d->socket, SIGNAL( error(int) ),
-	    this, SLOT( slotError(int) ) );
-    connect( &d->socket, SIGNAL( bytesWritten(int) ),
-	    this, SLOT( slotBytesWritten(int) ) );
+    connect( &d->socket, TQ_SIGNAL( connected() ),
+	    this, TQ_SLOT( slotConnected() ) );
+    connect( &d->socket, TQ_SIGNAL( connectionClosed() ),
+	    this, TQ_SLOT( slotClosed() ) );
+    connect( &d->socket, TQ_SIGNAL( delayedCloseFinished() ),
+	    this, TQ_SLOT( slotClosed() ) );
+    connect( &d->socket, TQ_SIGNAL( readyRead() ),
+	    this, TQ_SLOT( slotReadyRead() ) );
+    connect( &d->socket, TQ_SIGNAL( error(int) ),
+	    this, TQ_SLOT( slotError(int) ) );
+    connect( &d->socket, TQ_SIGNAL( bytesWritten(int) ),
+	    this, TQ_SLOT( slotBytesWritten(int) ) );
 
     d->idleTimer = startTimer( 0 );
 }
@@ -1778,7 +1778,7 @@ int TQHttp::addRequest( TQHttpRequest *req )
 
     if ( d->pending.count() == 1 )
 	// don't emit the requestStarted() signal before the id is returned
-	TQTimer::singleShot( 0, this, SLOT(startNextRequest()) );
+	TQTimer::singleShot( 0, this, TQ_SLOT(startNextRequest()) );
 
     return req->id;
 }
@@ -2231,12 +2231,12 @@ int TQHttp::supportedOperations() const
 */
 void TQHttp::operationGet( TQNetworkOperation *op )
 {
-    connect( this, SIGNAL(readyRead(const TQHttpResponseHeader&)),
-	    this, SLOT(clientReply(const TQHttpResponseHeader&)) );
-    connect( this, SIGNAL(done(bool)),
-	    this, SLOT(clientDone(bool)) );
-    connect( this, SIGNAL(stateChanged(int)),
-	    this, SLOT(clientStateChanged(int)) );
+    connect( this, TQ_SIGNAL(readyRead(const TQHttpResponseHeader&)),
+	    this, TQ_SLOT(clientReply(const TQHttpResponseHeader&)) );
+    connect( this, TQ_SIGNAL(done(bool)),
+	    this, TQ_SLOT(clientDone(bool)) );
+    connect( this, TQ_SIGNAL(stateChanged(int)),
+	    this, TQ_SLOT(clientStateChanged(int)) );
 
     bytesRead = 0;
     op->setState( StInProgress );
@@ -2251,12 +2251,12 @@ void TQHttp::operationGet( TQNetworkOperation *op )
 */
 void TQHttp::operationPut( TQNetworkOperation *op )
 {
-    connect( this, SIGNAL(readyRead(const TQHttpResponseHeader&)),
-	    this, SLOT(clientReply(const TQHttpResponseHeader&)) );
-    connect( this, SIGNAL(done(bool)),
-	    this, SLOT(clientDone(bool)) );
-    connect( this, SIGNAL(stateChanged(int)),
-	    this, SLOT(clientStateChanged(int)) );
+    connect( this, TQ_SIGNAL(readyRead(const TQHttpResponseHeader&)),
+	    this, TQ_SLOT(clientReply(const TQHttpResponseHeader&)) );
+    connect( this, TQ_SIGNAL(done(bool)),
+	    this, TQ_SLOT(clientDone(bool)) );
+    connect( this, TQ_SIGNAL(stateChanged(int)),
+	    this, TQ_SLOT(clientStateChanged(int)) );
 
     bytesRead = 0;
     op->setState( StInProgress );
@@ -2307,12 +2307,12 @@ void TQHttp::clientReply( const TQHttpResponseHeader &rep )
 
 void TQHttp::clientDone( bool err )
 {
-    disconnect( this, SIGNAL(readyRead(const TQHttpResponseHeader&)),
-	    this, SLOT(clientReply(const TQHttpResponseHeader&)) );
-    disconnect( this, SIGNAL(done(bool)),
-	    this, SLOT(clientDone(bool)) );
-    disconnect( this, SIGNAL(stateChanged(int)),
-	    this, SLOT(clientStateChanged(int)) );
+    disconnect( this, TQ_SIGNAL(readyRead(const TQHttpResponseHeader&)),
+	    this, TQ_SLOT(clientReply(const TQHttpResponseHeader&)) );
+    disconnect( this, TQ_SIGNAL(done(bool)),
+	    this, TQ_SLOT(clientDone(bool)) );
+    disconnect( this, TQ_SIGNAL(stateChanged(int)),
+	    this, TQ_SLOT(clientStateChanged(int)) );
 
     if ( err ) {
 	TQNetworkOperation *op = operationInProgress();
diff --git a/src/network/qserversocket.cpp b/src/network/qserversocket.cpp
index 8fd1b7bfb..44728d742 100644
--- a/src/network/qserversocket.cpp
+++ b/src/network/qserversocket.cpp
@@ -173,8 +173,8 @@ void TQServerSocket::init( const TQHostAddress & address, TQ_UINT16 port, int ba
     {
 	d->n = new TQSocketNotifier( d->s->socket(), TQSocketNotifier::Read,
 				    this, "accepting new connections" );
-	connect( d->n, SIGNAL(activated(int)),
-		 this, SLOT(incomingConnection(int)) );
+	connect( d->n, TQ_SIGNAL(activated(int)),
+		 this, TQ_SLOT(incomingConnection(int)) );
     } else {
 	tqWarning( "TQServerSocket: failed to bind or listen to the socket" );
 	delete d->s;
@@ -290,8 +290,8 @@ void TQServerSocket::setSocket( int socket )
     d->s = new TQSocketDevice( socket, TQSocketDevice::Stream );
     d->n = new TQSocketNotifier( d->s->socket(), TQSocketNotifier::Read,
 	       this, "accepting new connections" );
-    connect( d->n, SIGNAL(activated(int)),
-	     this, SLOT(incomingConnection(int)) );
+    connect( d->n, TQ_SIGNAL(activated(int)),
+	     this, TQ_SLOT(incomingConnection(int)) );
 }
 
 #endif //TQT_NO_NETWORK
diff --git a/src/network/qsocket.cpp b/src/network/qsocket.cpp
index a612867be..381a1a8e6 100644
--- a/src/network/qsocket.cpp
+++ b/src/network/qsocket.cpp
@@ -217,9 +217,9 @@ void TQSocketPrivate::setSocketDevice( TQSocket *q, TQSocketDevice *device )
     wsn = new TQSocketNotifier( socket->socket(),
 			       TQSocketNotifier::Write, q, "write" );
 
-    TQObject::connect( rsn, SIGNAL(activated(int)), q, SLOT(sn_read()) );
+    TQObject::connect( rsn, TQ_SIGNAL(activated(int)), q, TQ_SLOT(sn_read()) );
     rsn->setEnabled( FALSE );
-    TQObject::connect( wsn, SIGNAL(activated(int)), q, SLOT(sn_write()) );
+    TQObject::connect( wsn, TQ_SIGNAL(activated(int)), q, TQ_SLOT(sn_write()) );
     wsn->setEnabled( FALSE );
 }
 
@@ -424,10 +424,10 @@ void TQSocket::connectToHost( const TQString &host, TQ_UINT16 port )
     // try if the address is already available (for faster connecting...)
     tryConnecting();
     if ( d->state == HostLookup ) {
-	connect( d->dns4, SIGNAL(resultsReady()),
-		 this, SLOT(tryConnecting()) );
-	connect( d->dns6, SIGNAL(resultsReady()),
-		 this, SLOT(tryConnecting()) );
+	connect( d->dns4, TQ_SIGNAL(resultsReady()),
+		 this, TQ_SLOT(tryConnecting()) );
+	connect( d->dns6, TQ_SIGNAL(resultsReady()),
+		 this, TQ_SLOT(tryConnecting()) );
     }
 }
 
@@ -1364,7 +1364,7 @@ void TQSocket::tryConnection()
 	emit connected();
     } else {
 	d->state = Idle;
-	TQTimer::singleShot( 0, this, SLOT(emitErrorConnectionRefused()) );
+	TQTimer::singleShot( 0, this, TQ_SLOT(emitErrorConnectionRefused()) );
 	return;
     }
 }