Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
(cherry picked from commit 1329ec6abbcb7b79cd960e0ca138f16598d5f11f)

10 files changed, 159 insertions, 159 deletions

diff --git a/kopete/protocols/jabber/libiris/iris/jabber/filetransfer.cpp b/kopete/protocols/jabber/libiris/iris/jabber/filetransfer.cpp
index 107d082b..4b0e35ad 100644
--- a/kopete/protocols/jabber/libiris/iris/jabber/filetransfer.cpp
+++ b/kopete/protocols/jabber/libiris/iris/jabber/filetransfer.cpp
@@ -115,7 +115,7 @@ void FileTransfer::sendFile(const Jid &to, const TQString &fname, TQ_LLONG size,
 	d->id = d->m->link(this);
 
 	d->ft = new JT_FT(d->m->client()->rootTask());
-	connect(d->ft, TQT_SIGNAL(finished()), TQT_SLOT(ft_finished()));
+	connect(d->ft, TQ_SIGNAL(finished()), TQ_SLOT(ft_finished()));
 	TQStringList list;
 	list += "http://jabber.org/protocol/bytestreams";
 	d->ft->request(to, d->id, fname, size, desc, list);
@@ -228,10 +228,10 @@ void FileTransfer::ft_finished()
 			d->length = d->size - d->rangeOffset;
 		d->streamType = ft->streamType();
 		d->c = d->m->client()->s5bManager()->createConnection();
-		connect(d->c, TQT_SIGNAL(connected()), TQT_SLOT(s5b_connected()));
-		connect(d->c, TQT_SIGNAL(connectionClosed()), TQT_SLOT(s5b_connectionClosed()));
-		connect(d->c, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(s5b_bytesWritten(int)));
-		connect(d->c, TQT_SIGNAL(error(int)), TQT_SLOT(s5b_error(int)));
+		connect(d->c, TQ_SIGNAL(connected()), TQ_SLOT(s5b_connected()));
+		connect(d->c, TQ_SIGNAL(connectionClosed()), TQ_SLOT(s5b_connectionClosed()));
+		connect(d->c, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(s5b_bytesWritten(int)));
+		connect(d->c, TQ_SIGNAL(error(int)), TQ_SLOT(s5b_error(int)));
 
 		if(d->proxy.isValid())
 			d->c->setProxy(d->proxy);
@@ -250,14 +250,14 @@ void FileTransfer::ft_finished()
 void FileTransfer::takeConnection(S5BConnection *c)
 {
 	d->c = c;
-	connect(d->c, TQT_SIGNAL(connected()), TQT_SLOT(s5b_connected()));
-	connect(d->c, TQT_SIGNAL(connectionClosed()), TQT_SLOT(s5b_connectionClosed()));
-	connect(d->c, TQT_SIGNAL(readyRead()), TQT_SLOT(s5b_readyRead()));
-	connect(d->c, TQT_SIGNAL(error(int)), TQT_SLOT(s5b_error(int)));
+	connect(d->c, TQ_SIGNAL(connected()), TQ_SLOT(s5b_connected()));
+	connect(d->c, TQ_SIGNAL(connectionClosed()), TQ_SLOT(s5b_connectionClosed()));
+	connect(d->c, TQ_SIGNAL(readyRead()), TQ_SLOT(s5b_readyRead()));
+	connect(d->c, TQ_SIGNAL(error(int)), TQ_SLOT(s5b_error(int)));
 	if(d->proxy.isValid())
 		d->c->setProxy(d->proxy);
 	accepted();
-	TQTimer::singleShot(0, this, TQT_SLOT(doAccept()));
+	TQTimer::singleShot(0, this, TQ_SLOT(doAccept()));
 }
 
 void FileTransfer::s5b_connected()
@@ -338,7 +338,7 @@ FileTransferManager::FileTransferManager(Client *client)
 	d->client = client;
 
 	d->pft = new JT_PushFT(d->client->rootTask());
-	connect(d->pft, TQT_SIGNAL(incoming(const FTRequest &)), TQT_SLOT(pft_incoming(const FTRequest &)));
+	connect(d->pft, TQ_SIGNAL(incoming(const FTRequest &)), TQ_SLOT(pft_incoming(const FTRequest &)));
 }
 
 FileTransferManager::~FileTransferManager()
diff --git a/kopete/protocols/jabber/libiris/iris/jabber/s5b.cpp b/kopete/protocols/jabber/libiris/iris/jabber/s5b.cpp
index 8f2e01b6..971af3a4 100644
--- a/kopete/protocols/jabber/libiris/iris/jabber/s5b.cpp
+++ b/kopete/protocols/jabber/libiris/iris/jabber/s5b.cpp
@@ -394,15 +394,15 @@ void S5BConnection::man_waitForAccept(const S5BRequest &r)
 void S5BConnection::man_clientReady(SocksClient *sc, SocksUDP *sc_udp)
 {
 	d->sc = sc;
-	connect(d->sc, TQT_SIGNAL(connectionClosed()), TQT_SLOT(sc_connectionClosed()));
-	connect(d->sc, TQT_SIGNAL(delayedCloseFinished()), TQT_SLOT(sc_delayedCloseFinished()));
-	connect(d->sc, TQT_SIGNAL(readyRead()), TQT_SLOT(sc_readyRead()));
-	connect(d->sc, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(sc_bytesWritten(int)));
-	connect(d->sc, TQT_SIGNAL(error(int)), TQT_SLOT(sc_error(int)));
+	connect(d->sc, TQ_SIGNAL(connectionClosed()), TQ_SLOT(sc_connectionClosed()));
+	connect(d->sc, TQ_SIGNAL(delayedCloseFinished()), TQ_SLOT(sc_delayedCloseFinished()));
+	connect(d->sc, TQ_SIGNAL(readyRead()), TQ_SLOT(sc_readyRead()));
+	connect(d->sc, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(sc_bytesWritten(int)));
+	connect(d->sc, TQ_SIGNAL(error(int)), TQ_SLOT(sc_error(int)));
 
 	if(sc_udp) {
 		d->su = sc_udp;
-		connect(d->su, TQT_SIGNAL(packetReady(const TQByteArray &)), TQT_SLOT(su_packetReady(const TQByteArray &)));
+		connect(d->su, TQ_SIGNAL(packetReady(const TQByteArray &)), TQ_SLOT(su_packetReady(const TQByteArray &)));
 	}
 
 	d->state = Active;
@@ -425,7 +425,7 @@ void S5BConnection::man_clientReady(SocksClient *sc, SocksUDP *sc_udp)
 		d->notifyClose = true;
 	}
 	if(d->notifyRead || d->notifyClose)
-		TQTimer::singleShot(0, this, TQT_SLOT(doPending()));
+		TQTimer::singleShot(0, this, TQ_SLOT(doPending()));
 	connected();
 }
 
@@ -433,7 +433,7 @@ void S5BConnection::doPending()
 {
 	if(d->notifyRead) {
 		if(d->notifyClose)
-			TQTimer::singleShot(0, this, TQT_SLOT(doPending()));
+			TQTimer::singleShot(0, this, TQ_SLOT(doPending()));
 		sc_readyRead();
 	}
 	else if(d->notifyClose)
@@ -588,9 +588,9 @@ S5BManager::S5BManager(Client *parent)
 	d->activeList.setAutoDelete(true);
 
 	d->ps = new JT_PushS5B(d->client->rootTask());
-	connect(d->ps, TQT_SIGNAL(incoming(const S5BRequest &)), TQT_SLOT(ps_incoming(const S5BRequest &)));
-	connect(d->ps, TQT_SIGNAL(incomingUDPSuccess(const Jid &, const TQString &)), TQT_SLOT(ps_incomingUDPSuccess(const Jid &, const TQString &)));
-	connect(d->ps, TQT_SIGNAL(incomingActivate(const Jid &, const TQString &, const Jid &)), TQT_SLOT(ps_incomingActivate(const Jid &, const TQString &, const Jid &)));
+	connect(d->ps, TQ_SIGNAL(incoming(const S5BRequest &)), TQ_SLOT(ps_incoming(const S5BRequest &)));
+	connect(d->ps, TQ_SIGNAL(incomingUDPSuccess(const Jid &, const TQString &)), TQ_SLOT(ps_incomingUDPSuccess(const Jid &, const TQString &)));
+	connect(d->ps, TQ_SIGNAL(incomingActivate(const Jid &, const TQString &, const Jid &)), TQ_SLOT(ps_incomingActivate(const Jid &, const TQString &, const Jid &)));
 }
 
 S5BManager::~S5BManager()
@@ -1008,12 +1008,12 @@ void S5BManager::entryContinue(Entry *e)
 	e->i = new Item(this);
 	e->i->proxy = e->proxyInfo;
 
-	connect(e->i, TQT_SIGNAL(accepted()), TQT_SLOT(item_accepted()));
-	connect(e->i, TQT_SIGNAL(tryingHosts(const StreamHostList &)), TQT_SLOT(item_tryingHosts(const StreamHostList &)));
-	connect(e->i, TQT_SIGNAL(proxyConnect()), TQT_SLOT(item_proxyConnect()));
-	connect(e->i, TQT_SIGNAL(waitingForActivation()), TQT_SLOT(item_waitingForActivation()));
-	connect(e->i, TQT_SIGNAL(connected()), TQT_SLOT(item_connected()));
-	connect(e->i, TQT_SIGNAL(error(int)), TQT_SLOT(item_error(int)));
+	connect(e->i, TQ_SIGNAL(accepted()), TQ_SLOT(item_accepted()));
+	connect(e->i, TQ_SIGNAL(tryingHosts(const StreamHostList &)), TQ_SLOT(item_tryingHosts(const StreamHostList &)));
+	connect(e->i, TQ_SIGNAL(proxyConnect()), TQ_SLOT(item_proxyConnect()));
+	connect(e->i, TQ_SIGNAL(waitingForActivation()), TQ_SLOT(item_waitingForActivation()));
+	connect(e->i, TQ_SIGNAL(connected()), TQ_SLOT(item_connected()));
+	connect(e->i, TQ_SIGNAL(error(int)), TQ_SLOT(item_error(int)));
 
 	if(e->c->isRemote()) {
 		const S5BRequest &req = e->c->d->req;
@@ -1036,7 +1036,7 @@ void S5BManager::queryProxy(Entry *e)
 	printf("querying proxy: [%s]\n", e->c->d->proxy.full().latin1());
 #endif
 	e->query = new JT_S5B(d->client->rootTask());
-	connect(e->query, TQT_SIGNAL(finished()), TQT_SLOT(query_finished()));
+	connect(e->query, TQ_SIGNAL(finished()), TQ_SLOT(query_finished()));
 	e->query->requestProxyInfo(e->c->d->proxy);
 	e->query->go(true);
 }
@@ -1246,7 +1246,7 @@ void S5BManager::Item::doOutgoing()
 	allowIncoming = true;
 
 	task = new JT_S5B(m->client()->rootTask());
-	connect(task, TQT_SIGNAL(finished()), TQT_SLOT(jt_finished()));
+	connect(task, TQ_SIGNAL(finished()), TQ_SLOT(jt_finished()));
 	task->request(peer, sid, hosts, state == Initiator ? wantFast : false, udp);
 	out_id = task->id();
 	task->go(true);
@@ -1292,7 +1292,7 @@ void S5BManager::Item::doIncoming()
 	}
 
 	conn = new S5BConnector;
-	connect(conn, TQT_SIGNAL(result(bool)), TQT_SLOT(conn_result(bool)));
+	connect(conn, TQ_SIGNAL(result(bool)), TQ_SLOT(conn_result(bool)));
 
 	TQGuardedPtr<TQObject> self = this;
 	tryingHosts(list);
@@ -1308,9 +1308,9 @@ void S5BManager::Item::setIncomingClient(SocksClient *sc)
 	printf("S5BManager::Item: %s [%s] successful incoming connection\n", peer.full().latin1(), sid.latin1());
 #endif
 
-	connect(sc, TQT_SIGNAL(readyRead()), TQT_SLOT(sc_readyRead()));
-	connect(sc, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(sc_bytesWritten(int)));
-	connect(sc, TQT_SIGNAL(error(int)), TQT_SLOT(sc_error(int)));
+	connect(sc, TQ_SIGNAL(readyRead()), TQ_SLOT(sc_readyRead()));
+	connect(sc, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(sc_bytesWritten(int)));
+	connect(sc, TQ_SIGNAL(error(int)), TQ_SLOT(sc_error(int)));
 
 	client = sc;
 	allowIncoming = false;
@@ -1388,7 +1388,7 @@ void S5BManager::Item::jt_finished()
 #endif
 			// connect to the proxy
 			proxy_conn = new S5BConnector;
-			connect(proxy_conn, TQT_SIGNAL(result(bool)), TQT_SLOT(proxy_result(bool)));
+			connect(proxy_conn, TQ_SIGNAL(result(bool)), TQ_SLOT(proxy_result(bool)));
 			StreamHostList list;
 			list += proxy;
 
@@ -1442,9 +1442,9 @@ void S5BManager::Item::conn_result(bool b)
 		printf("S5BManager::Item: %s [%s] successful outgoing connection\n", peer.full().latin1(), sid.latin1());
 #endif
 
-		connect(sc, TQT_SIGNAL(readyRead()), TQT_SLOT(sc_readyRead()));
-		connect(sc, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(sc_bytesWritten(int)));
-		connect(sc, TQT_SIGNAL(error(int)), TQT_SLOT(sc_error(int)));
+		connect(sc, TQ_SIGNAL(readyRead()), TQ_SLOT(sc_readyRead()));
+		connect(sc, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(sc_bytesWritten(int)));
+		connect(sc, TQ_SIGNAL(error(int)), TQ_SLOT(sc_error(int)));
 
 		m->doSuccess(peer, in_id, h.jid());
 
@@ -1493,9 +1493,9 @@ void S5BManager::Item::proxy_result(bool b)
 		delete proxy_conn;
 		proxy_conn = 0;
 
-		connect(sc, TQT_SIGNAL(readyRead()), TQT_SLOT(sc_readyRead()));
-		connect(sc, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(sc_bytesWritten(int)));
-		connect(sc, TQT_SIGNAL(error(int)), TQT_SLOT(sc_error(int)));
+		connect(sc, TQ_SIGNAL(readyRead()), TQ_SLOT(sc_readyRead()));
+		connect(sc, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(sc_bytesWritten(int)));
+		connect(sc, TQ_SIGNAL(error(int)), TQ_SLOT(sc_error(int)));
 
 		client = sc;
 		client_udp = sc_udp;
@@ -1505,7 +1505,7 @@ void S5BManager::Item::proxy_result(bool b)
 		printf("activating proxy stream\n");
 #endif
 		proxy_task = new JT_S5B(m->client()->rootTask());
-		connect(proxy_task, TQT_SIGNAL(finished()), TQT_SLOT(proxy_finished()));
+		connect(proxy_task, TQ_SIGNAL(finished()), TQ_SLOT(proxy_finished()));
 		proxy_task->requestActivation(proxy.jid(), sid, peer);
 		proxy_task->go(true);
 	}
@@ -1768,9 +1768,9 @@ public:
 		udp = _udp;
 		client = new SocksClient;
 		client_udp = 0;
-		connect(client, TQT_SIGNAL(connected()), TQT_SLOT(sc_connected()));
-		connect(client, TQT_SIGNAL(error(int)), TQT_SLOT(sc_error(int)));
-		connect(&t, TQT_SIGNAL(timeout()), TQT_SLOT(trySendUDP()));
+		connect(client, TQ_SIGNAL(connected()), TQ_SLOT(sc_connected()));
+		connect(client, TQ_SIGNAL(error(int)), TQ_SLOT(sc_error(int)));
+		connect(&t, TQ_SIGNAL(timeout()), TQ_SLOT(trySendUDP()));
 	}
 
 	~Item()
@@ -1872,7 +1872,7 @@ S5BConnector::S5BConnector(TQObject *parent)
 	d->active = 0;
 	d->active_udp = 0;
 	d->itemList.setAutoDelete(true);
-	connect(&d->t, TQT_SIGNAL(timeout()), TQT_SLOT(t_timeout()));
+	connect(&d->t, TQ_SIGNAL(timeout()), TQ_SLOT(t_timeout()));
 }
 
 S5BConnector::~S5BConnector()
@@ -1900,7 +1900,7 @@ void S5BConnector::start(const Jid &self, const StreamHostList &hosts, const TQS
 #endif
 	for(StreamHostList::ConstIterator it = hosts.begin(); it != hosts.end(); ++it) {
 		Item *i = new Item(self, *it, key, udp);
-		connect(i, TQT_SIGNAL(result(bool)), TQT_SLOT(item_result(bool)));
+		connect(i, TQ_SIGNAL(result(bool)), TQ_SLOT(item_result(bool)));
 		d->itemList.append(i);
 		i->start();
 	}
@@ -1990,11 +1990,11 @@ public:
 	Item(SocksClient *c) : TQObject(0)
 	{
 		client = c;
-		connect(client, TQT_SIGNAL(incomingMethods(int)), TQT_SLOT(sc_incomingMethods(int)));
-		connect(client, TQT_SIGNAL(incomingConnectRequest(const TQString &, int)), TQT_SLOT(sc_incomingConnectRequest(const TQString &, int)));
-		connect(client, TQT_SIGNAL(error(int)), TQT_SLOT(sc_error(int)));
+		connect(client, TQ_SIGNAL(incomingMethods(int)), TQ_SLOT(sc_incomingMethods(int)));
+		connect(client, TQ_SIGNAL(incomingConnectRequest(const TQString &, int)), TQ_SLOT(sc_incomingConnectRequest(const TQString &, int)));
+		connect(client, TQ_SIGNAL(error(int)), TQ_SLOT(sc_error(int)));
 
-		connect(&expire, TQT_SIGNAL(timeout()), TQT_SLOT(doError()));
+		connect(&expire, TQ_SIGNAL(timeout()), TQ_SLOT(doError()));
 		resetExpiration();
 	}
 
@@ -2059,8 +2059,8 @@ S5BServer::S5BServer(TQObject *parent)
 {
 	d = new Private;
 	d->itemList.setAutoDelete(true);
-	connect(&d->serv, TQT_SIGNAL(incomingReady()), TQT_SLOT(ss_incomingReady()));
-	connect(&d->serv, TQT_SIGNAL(incomingUDP(const TQString &, int, const TQHostAddress &, int, const TQByteArray &)), TQT_SLOT(ss_incomingUDP(const TQString &, int, const TQHostAddress &, int, const TQByteArray &)));
+	connect(&d->serv, TQ_SIGNAL(incomingReady()), TQ_SLOT(ss_incomingReady()));
+	connect(&d->serv, TQ_SIGNAL(incomingUDP(const TQString &, int, const TQHostAddress &, int, const TQByteArray &)), TQ_SLOT(ss_incomingUDP(const TQString &, int, const TQHostAddress &, int, const TQByteArray &)));
 }
 
 S5BServer::~S5BServer()
@@ -2106,7 +2106,7 @@ void S5BServer::ss_incomingReady()
 #ifdef S5B_DEBUG
 	printf("S5BServer: incoming connection from %s:%d\n", i->client->peerAddress().toString().latin1(), i->client->peerPort());
 #endif
-	connect(i, TQT_SIGNAL(result(bool)), TQT_SLOT(item_result(bool)));
+	connect(i, TQ_SIGNAL(result(bool)), TQ_SLOT(item_result(bool)));
 	d->itemList.append(i);
 }
 
@@ -2200,7 +2200,7 @@ JT_S5B::JT_S5B(Task *parent)
 {
 	d = new Private;
 	d->mode = -1;
-	connect(&d->t, TQT_SIGNAL(timeout()), TQT_SLOT(t_timeout()));
+	connect(&d->t, TQ_SIGNAL(timeout()), TQ_SLOT(t_timeout()));
 }
 
 JT_S5B::~JT_S5B()
diff --git a/kopete/protocols/jabber/libiris/iris/jabber/xmpp_ibb.cpp b/kopete/protocols/jabber/libiris/iris/jabber/xmpp_ibb.cpp
index aaf3e4cd..ed6c44c7 100644
--- a/kopete/protocols/jabber/libiris/iris/jabber/xmpp_ibb.cpp
+++ b/kopete/protocols/jabber/libiris/iris/jabber/xmpp_ibb.cpp
@@ -110,7 +110,7 @@ void IBBConnection::connectToJid(const Jid &peer, const TQDomElement &comment)
 	d->m->client()->debug(dstr);
 
 	d->j = new JT_IBB(d->m->client()->rootTask());
-	connect(d->j, TQT_SIGNAL(finished()), TQT_SLOT(ibb_finished()));
+	connect(d->j, TQ_SIGNAL(finished()), TQ_SLOT(ibb_finished()));
 	d->j->request(d->peer, comment);
 	d->j->go(true);
 }
@@ -270,7 +270,7 @@ void IBBConnection::ibb_finished()
 			}
 
 			if(!d->sendbuf.isEmpty() || d->closePending)
-				TQTimer::singleShot(IBB_PACKET_DELAY, this, TQT_SLOT(trySend()));
+				TQTimer::singleShot(IBB_PACKET_DELAY, this, TQ_SLOT(trySend()));
 		}
 	}
 	else {
@@ -326,7 +326,7 @@ void IBBConnection::trySend()
 
 	d->blockSize = a.size();
 	d->j = new JT_IBB(d->m->client()->rootTask());
-	connect(d->j, TQT_SIGNAL(finished()), TQT_SLOT(ibb_finished()));
+	connect(d->j, TQ_SIGNAL(finished()), TQ_SLOT(ibb_finished()));
 	d->j->sendData(d->peer, d->sid, a, doClose);
 	d->j->go(true);
 }
@@ -353,8 +353,8 @@ IBBManager::IBBManager(Client *parent)
 	d->client = parent;
 	
 	d->ibb = new JT_IBB(d->client->rootTask(), true);
-	connect(d->ibb, TQT_SIGNAL(incomingRequest(const Jid &, const TQString &, const TQDomElement &)), TQT_SLOT(ibb_incomingRequest(const Jid &, const TQString &, const TQDomElement &)));
-	connect(d->ibb, TQT_SIGNAL(incomingData(const Jid &, const TQString &, const TQString &, const TQByteArray &, bool)), TQT_SLOT(ibb_incomingData(const Jid &, const TQString &, const TQString &, const TQByteArray &, bool)));
+	connect(d->ibb, TQ_SIGNAL(incomingRequest(const Jid &, const TQString &, const TQDomElement &)), TQ_SLOT(ibb_incomingRequest(const Jid &, const TQString &, const TQDomElement &)));
+	connect(d->ibb, TQ_SIGNAL(incomingData(const Jid &, const TQString &, const TQString &, const TQByteArray &, bool)), TQ_SLOT(ibb_incomingData(const Jid &, const TQString &, const TQString &, const TQByteArray &, bool)));
 }
 
 IBBManager::~IBBManager()
diff --git a/kopete/protocols/jabber/libiris/iris/jabber/xmpp_jidlink.cpp b/kopete/protocols/jabber/libiris/iris/jabber/xmpp_jidlink.cpp
index 5139dffd..7cfecda0 100644
--- a/kopete/protocols/jabber/libiris/iris/jabber/xmpp_jidlink.cpp
+++ b/kopete/protocols/jabber/libiris/iris/jabber/xmpp_jidlink.cpp
@@ -105,18 +105,18 @@ void JidLink::link()
 {
 	if(d->type == DTCP) {
 		S5BConnection *c = (S5BConnection *)d->bs;
-		connect(c, TQT_SIGNAL(connected()), TQT_SLOT(dtcp_connected()));
-		connect(c, TQT_SIGNAL(accepted()), TQT_SLOT(dtcp_accepted()));
+		connect(c, TQ_SIGNAL(connected()), TQ_SLOT(dtcp_connected()));
+		connect(c, TQ_SIGNAL(accepted()), TQ_SLOT(dtcp_accepted()));
 	}
 	else {
 		IBBConnection *c = (IBBConnection *)d->bs;
-		connect(c, TQT_SIGNAL(connected()), TQT_SLOT(ibb_connected()));
+		connect(c, TQ_SIGNAL(connected()), TQ_SLOT(ibb_connected()));
 	}
 
-	connect(d->bs, TQT_SIGNAL(connectionClosed()), TQT_SLOT(bs_connectionClosed()));
-	connect(d->bs, TQT_SIGNAL(error(int)), TQT_SLOT(bs_error(int)));
-	connect(d->bs, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(bs_bytesWritten(int)));
-	connect(d->bs, TQT_SIGNAL(readyRead()), TQT_SLOT(bs_readyRead()));
+	connect(d->bs, TQ_SIGNAL(connectionClosed()), TQ_SLOT(bs_connectionClosed()));
+	connect(d->bs, TQ_SIGNAL(error(int)), TQ_SLOT(bs_error(int)));
+	connect(d->bs, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(bs_bytesWritten(int)));
+	connect(d->bs, TQ_SIGNAL(readyRead()), TQ_SLOT(bs_readyRead()));
 }
 
 void JidLink::unlink()
@@ -129,7 +129,7 @@ void JidLink::accept()
 	if(d->state != WaitingForAccept)
 		return;
 
-	TQTimer::singleShot(0, this, TQT_SLOT(doRealAccept()));
+	TQTimer::singleShot(0, this, TQ_SLOT(doRealAccept()));
 }
 
 void JidLink::doRealAccept()
diff --git a/kopete/protocols/jabber/libiris/iris/xmpp-core/connector.cpp b/kopete/protocols/jabber/libiris/iris/xmpp-core/connector.cpp
index a27811ec..493d887d 100644
--- a/kopete/protocols/jabber/libiris/iris/xmpp-core/connector.cpp
+++ b/kopete/protocols/jabber/libiris/iris/xmpp-core/connector.cpp
@@ -231,9 +231,9 @@ AdvancedConnector::AdvancedConnector(TQObject *parent)
 #ifdef NO_NDNS
 	d->qdns = 0;
 #else
-	connect(&d->dns, TQT_SIGNAL(resultsReady()), TQT_SLOT(dns_done()));
+	connect(&d->dns, TQ_SIGNAL(resultsReady()), TQ_SLOT(dns_done()));
 #endif
-	connect(&d->srv, TQT_SIGNAL(resultsReady()), TQT_SLOT(srv_done()));
+	connect(&d->srv, TQ_SIGNAL(resultsReady()), TQ_SLOT(srv_done()));
 	d->opt_probe = false;
 	d->opt_ssl = false;
 	cleanup();
@@ -326,10 +326,10 @@ void AdvancedConnector::connectToServer(const TQString &server)
 
 		HttpPoll *s = new HttpPoll;
 		d->bs = s;
-		connect(s, TQT_SIGNAL(connected()), TQT_SLOT(bs_connected()));
-		connect(s, TQT_SIGNAL(syncStarted()), TQT_SLOT(http_syncStarted()));
-		connect(s, TQT_SIGNAL(syncFinished()), TQT_SLOT(http_syncFinished()));
-		connect(s, TQT_SIGNAL(error(int)), TQT_SLOT(bs_error(int)));
+		connect(s, TQ_SIGNAL(connected()), TQ_SLOT(bs_connected()));
+		connect(s, TQ_SIGNAL(syncStarted()), TQ_SLOT(http_syncStarted()));
+		connect(s, TQ_SIGNAL(syncFinished()), TQ_SLOT(http_syncFinished()));
+		connect(s, TQ_SIGNAL(error(int)), TQ_SLOT(bs_error(int)));
 		if(!d->proxy.user().isEmpty())
 			s->setAuth(d->proxy.user(), d->proxy.pass());
 		s->setPollInterval(d->proxy.pollInterval());
@@ -389,7 +389,7 @@ void AdvancedConnector::do_resolve()
 #ifdef NO_NDNS
 	printf("resolving (aaaa=%d)\n", d->aaaa);
 	d->qdns = new TQDns;
-	connect(d->qdns, TQT_SIGNAL(resultsReady()), TQT_SLOT(dns_done()));
+	connect(d->qdns, TQ_SIGNAL(resultsReady()), TQ_SLOT(dns_done()));
 	if(d->aaaa)
 		d->qdns->setRecordType(TQDns::Aaaa); // IPv6
 	else
@@ -502,8 +502,8 @@ void AdvancedConnector::do_connect()
 #endif
 		BSocket *s = new BSocket;
 		d->bs = s;
-		connect(s, TQT_SIGNAL(connected()), TQT_SLOT(bs_connected()));
-		connect(s, TQT_SIGNAL(error(int)), TQT_SLOT(bs_error(int)));
+		connect(s, TQ_SIGNAL(connected()), TQ_SLOT(bs_connected()));
+		connect(s, TQ_SIGNAL(error(int)), TQ_SLOT(bs_error(int)));
 		s->connectToHost(d->host, d->port);
 	}
 	else if(t == Proxy::HttpConnect) {
@@ -512,8 +512,8 @@ void AdvancedConnector::do_connect()
 #endif
 		HttpConnect *s = new HttpConnect;
 		d->bs = s;
-		connect(s, TQT_SIGNAL(connected()), TQT_SLOT(bs_connected()));
-		connect(s, TQT_SIGNAL(error(int)), TQT_SLOT(bs_error(int)));
+		connect(s, TQ_SIGNAL(connected()), TQ_SLOT(bs_connected()));
+		connect(s, TQ_SIGNAL(error(int)), TQ_SLOT(bs_error(int)));
 		if(!d->proxy.user().isEmpty())
 			s->setAuth(d->proxy.user(), d->proxy.pass());
 		s->connectToHost(d->proxy.host(), d->proxy.port(), d->host, d->port);
@@ -524,8 +524,8 @@ void AdvancedConnector::do_connect()
 #endif
 		SocksClient *s = new SocksClient;
 		d->bs = s;
-		connect(s, TQT_SIGNAL(connected()), TQT_SLOT(bs_connected()));
-		connect(s, TQT_SIGNAL(error(int)), TQT_SLOT(bs_error(int)));
+		connect(s, TQ_SIGNAL(connected()), TQ_SLOT(bs_connected()));
+		connect(s, TQ_SIGNAL(error(int)), TQ_SLOT(bs_error(int)));
 		if(!d->proxy.user().isEmpty())
 			s->setAuth(d->proxy.user(), d->proxy.pass());
 		s->connectToHost(d->proxy.host(), d->proxy.port(), d->host, d->port);
diff --git a/kopete/protocols/jabber/libiris/iris/xmpp-core/securestream.cpp b/kopete/protocols/jabber/libiris/iris/xmpp-core/securestream.cpp
index 84b387e8..14ff7019 100644
--- a/kopete/protocols/jabber/libiris/iris/xmpp-core/securestream.cpp
+++ b/kopete/protocols/jabber/libiris/iris/xmpp-core/securestream.cpp
@@ -132,11 +132,11 @@ public:
 		type = TLS;
 		p.tls = t;
 		init();
-		connect(p.tls, TQT_SIGNAL(handshaken()), TQT_SLOT(tls_handshaken()));
-		connect(p.tls, TQT_SIGNAL(readyRead()), TQT_SLOT(tls_readyRead()));
-		connect(p.tls, TQT_SIGNAL(readyReadOutgoing(int)), TQT_SLOT(tls_readyReadOutgoing(int)));
-		connect(p.tls, TQT_SIGNAL(closed()), TQT_SLOT(tls_closed()));
-		connect(p.tls, TQT_SIGNAL(error(int)), TQT_SLOT(tls_error(int)));
+		connect(p.tls, TQ_SIGNAL(handshaken()), TQ_SLOT(tls_handshaken()));
+		connect(p.tls, TQ_SIGNAL(readyRead()), TQ_SLOT(tls_readyRead()));
+		connect(p.tls, TQ_SIGNAL(readyReadOutgoing(int)), TQ_SLOT(tls_readyReadOutgoing(int)));
+		connect(p.tls, TQ_SIGNAL(closed()), TQ_SLOT(tls_closed()));
+		connect(p.tls, TQ_SIGNAL(error(int)), TQ_SLOT(tls_error(int)));
 	}
 
 	SecureLayer(TQCA::SASL *s)
@@ -144,9 +144,9 @@ public:
 		type = SASL;
 		p.sasl = s;
 		init();
-		connect(p.sasl, TQT_SIGNAL(readyRead()), TQT_SLOT(sasl_readyRead()));
-		connect(p.sasl, TQT_SIGNAL(readyReadOutgoing(int)), TQT_SLOT(sasl_readyReadOutgoing(int)));
-		connect(p.sasl, TQT_SIGNAL(error(int)), TQT_SLOT(sasl_error(int)));
+		connect(p.sasl, TQ_SIGNAL(readyRead()), TQ_SLOT(sasl_readyRead()));
+		connect(p.sasl, TQ_SIGNAL(readyReadOutgoing(int)), TQ_SLOT(sasl_readyReadOutgoing(int)));
+		connect(p.sasl, TQ_SIGNAL(error(int)), TQ_SLOT(sasl_error(int)));
 	}
 
 #ifdef USE_TLSHANDLER
@@ -155,11 +155,11 @@ public:
 		type = TLSH;
 		p.tlsHandler = t;
 		init();
-		connect(p.tlsHandler, TQT_SIGNAL(success()), TQT_SLOT(tlsHandler_success()));
-		connect(p.tlsHandler, TQT_SIGNAL(fail()), TQT_SLOT(tlsHandler_fail()));
-		connect(p.tlsHandler, TQT_SIGNAL(closed()), TQT_SLOT(tlsHandler_closed()));
-		connect(p.tlsHandler, TQT_SIGNAL(readyRead(const TQByteArray &)), TQT_SLOT(tlsHandler_readyRead(const TQByteArray &)));
-		connect(p.tlsHandler, TQT_SIGNAL(readyReadOutgoing(const TQByteArray &, int)), TQT_SLOT(tlsHandler_readyReadOutgoing(const TQByteArray &, int)));
+		connect(p.tlsHandler, TQ_SIGNAL(success()), TQ_SLOT(tlsHandler_success()));
+		connect(p.tlsHandler, TQ_SIGNAL(fail()), TQ_SLOT(tlsHandler_fail()));
+		connect(p.tlsHandler, TQ_SIGNAL(closed()), TQ_SLOT(tlsHandler_closed()));
+		connect(p.tlsHandler, TQ_SIGNAL(readyRead(const TQByteArray &)), TQ_SLOT(tlsHandler_readyRead(const TQByteArray &)));
+		connect(p.tlsHandler, TQ_SIGNAL(readyReadOutgoing(const TQByteArray &, int)), TQ_SLOT(tlsHandler_readyReadOutgoing(const TQByteArray &, int)));
 	}
 #endif
 
@@ -349,8 +349,8 @@ SecureStream::SecureStream(ByteStream *s)
 	d = new Private;
 
 	d->bs = s;
-	connect(d->bs, TQT_SIGNAL(readyRead()), TQT_SLOT(bs_readyRead()));
-	connect(d->bs, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(bs_bytesWritten(int)));
+	connect(d->bs, TQ_SIGNAL(readyRead()), TQ_SLOT(bs_readyRead()));
+	connect(d->bs, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(bs_bytesWritten(int)));
 
 	d->layers.setAutoDelete(true);
 	d->pending = 0;
@@ -365,11 +365,11 @@ SecureStream::~SecureStream()
 
 void SecureStream::linkLayer(TQObject *s)
 {
-	connect(s, TQT_SIGNAL(tlsHandshaken()), TQT_SLOT(layer_tlsHandshaken()));
-	connect(s, TQT_SIGNAL(tlsClosed(const TQByteArray &)), TQT_SLOT(layer_tlsClosed(const TQByteArray &)));
-	connect(s, TQT_SIGNAL(readyRead(const TQByteArray &)), TQT_SLOT(layer_readyRead(const TQByteArray &)));
-	connect(s, TQT_SIGNAL(needWrite(const TQByteArray &)), TQT_SLOT(layer_needWrite(const TQByteArray &)));
-	connect(s, TQT_SIGNAL(error(int)), TQT_SLOT(layer_error(int)));
+	connect(s, TQ_SIGNAL(tlsHandshaken()), TQ_SLOT(layer_tlsHandshaken()));
+	connect(s, TQ_SIGNAL(tlsClosed(const TQByteArray &)), TQ_SLOT(layer_tlsClosed(const TQByteArray &)));
+	connect(s, TQ_SIGNAL(readyRead(const TQByteArray &)), TQ_SLOT(layer_readyRead(const TQByteArray &)));
+	connect(s, TQ_SIGNAL(needWrite(const TQByteArray &)), TQ_SLOT(layer_needWrite(const TQByteArray &)));
+	connect(s, TQ_SIGNAL(error(int)), TQ_SLOT(layer_error(int)));
 }
 
 int SecureStream::calcPrebytes() const
diff --git a/kopete/protocols/jabber/libiris/iris/xmpp-core/stream.cpp b/kopete/protocols/jabber/libiris/iris/xmpp-core/stream.cpp
index e0d09d8e..18b19688 100644
--- a/kopete/protocols/jabber/libiris/iris/xmpp-core/stream.cpp
+++ b/kopete/protocols/jabber/libiris/iris/xmpp-core/stream.cpp
@@ -618,11 +618,11 @@ ClientStream::ClientStream(Connector *conn, TLSHandler *tlsHandler, TQObject *pa
 	d = new Private;
 	d->mode = Client;
 	d->conn = conn;
-	connect(d->conn, TQT_SIGNAL(connected()), TQT_SLOT(cr_connected()));
-	connect(d->conn, TQT_SIGNAL(error()), TQT_SLOT(cr_error()));
+	connect(d->conn, TQ_SIGNAL(connected()), TQ_SLOT(cr_connected()));
+	connect(d->conn, TQ_SIGNAL(error()), TQ_SLOT(cr_error()));
 
 	d->noop_time = 0;
-	connect(&d->noopTimer, TQT_SIGNAL(timeout()), TQT_SLOT(doNoop()));
+	connect(&d->noopTimer, TQ_SIGNAL(timeout()), TQ_SLOT(doNoop()));
 
 	d->tlsHandler = tlsHandler;
 }
@@ -633,18 +633,18 @@ ClientStream::ClientStream(const TQString &host, const TQString &defRealm, ByteS
 	d = new Private;
 	d->mode = Server;
 	d->bs = bs;
-	connect(d->bs, TQT_SIGNAL(connectionClosed()), TQT_SLOT(bs_connectionClosed()));
-	connect(d->bs, TQT_SIGNAL(delayedCloseFinished()), TQT_SLOT(bs_delayedCloseFinished()));
-	connect(d->bs, TQT_SIGNAL(error(int)), TQT_SLOT(bs_error(int)));
+	connect(d->bs, TQ_SIGNAL(connectionClosed()), TQ_SLOT(bs_connectionClosed()));
+	connect(d->bs, TQ_SIGNAL(delayedCloseFinished()), TQ_SLOT(bs_delayedCloseFinished()));
+	connect(d->bs, TQ_SIGNAL(error(int)), TQ_SLOT(bs_error(int)));
 
 	TQByteArray spare = d->bs->read();
 
 	d->ss = new SecureStream(d->bs);
-	connect(d->ss, TQT_SIGNAL(readyRead()), TQT_SLOT(ss_readyRead()));
-	connect(d->ss, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(ss_bytesWritten(int)));
-	connect(d->ss, TQT_SIGNAL(tlsHandshaken()), TQT_SLOT(ss_tlsHandshaken()));
-	connect(d->ss, TQT_SIGNAL(tlsClosed()), TQT_SLOT(ss_tlsClosed()));
-	connect(d->ss, TQT_SIGNAL(error(int)), TQT_SLOT(ss_error(int)));
+	connect(d->ss, TQ_SIGNAL(readyRead()), TQ_SLOT(ss_readyRead()));
+	connect(d->ss, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(ss_bytesWritten(int)));
+	connect(d->ss, TQ_SIGNAL(tlsHandshaken()), TQ_SLOT(ss_tlsHandshaken()));
+	connect(d->ss, TQ_SIGNAL(tlsClosed()), TQ_SLOT(ss_tlsClosed()));
+	connect(d->ss, TQ_SIGNAL(error(int)), TQ_SLOT(ss_error(int)));
 
 	d->server = host;
 	d->defRealm = defRealm;
@@ -940,17 +940,17 @@ void ClientStream::write(const Stanza &s)
 void ClientStream::cr_connected()
 {
 	d->bs = d->conn->stream();
-	connect(d->bs, TQT_SIGNAL(connectionClosed()), TQT_SLOT(bs_connectionClosed()));
-	connect(d->bs, TQT_SIGNAL(delayedCloseFinished()), TQT_SLOT(bs_delayedCloseFinished()));
+	connect(d->bs, TQ_SIGNAL(connectionClosed()), TQ_SLOT(bs_connectionClosed()));
+	connect(d->bs, TQ_SIGNAL(delayedCloseFinished()), TQ_SLOT(bs_delayedCloseFinished()));
 
 	TQByteArray spare = d->bs->read();
 
 	d->ss = new SecureStream(d->bs);
-	connect(d->ss, TQT_SIGNAL(readyRead()), TQT_SLOT(ss_readyRead()));
-	connect(d->ss, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(ss_bytesWritten(int)));
-	connect(d->ss, TQT_SIGNAL(tlsHandshaken()), TQT_SLOT(ss_tlsHandshaken()));
-	connect(d->ss, TQT_SIGNAL(tlsClosed()), TQT_SLOT(ss_tlsClosed()));
-	connect(d->ss, TQT_SIGNAL(error(int)), TQT_SLOT(ss_error(int)));
+	connect(d->ss, TQ_SIGNAL(readyRead()), TQ_SLOT(ss_readyRead()));
+	connect(d->ss, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(ss_bytesWritten(int)));
+	connect(d->ss, TQ_SIGNAL(tlsHandshaken()), TQ_SLOT(ss_tlsHandshaken()));
+	connect(d->ss, TQ_SIGNAL(tlsClosed()), TQ_SLOT(ss_tlsClosed()));
+	connect(d->ss, TQ_SIGNAL(error(int)), TQ_SLOT(ss_error(int)));
 
 	//d->client.startDialbackOut("andbit.net", "im.pyxa.org");
 	//d->client.startServerOut(d->server);
@@ -1163,10 +1163,10 @@ void ClientStream::srvProcessNext()
 			else if(need == CoreProtocol::NSASLMechs) {
 				if(!d->sasl) {
 					d->sasl = new TQCA::SASL;
-					connect(d->sasl, TQT_SIGNAL(authCheck(const TQString &, const TQString &)), TQT_SLOT(sasl_authCheck(const TQString &, const TQString &)));
-					connect(d->sasl, TQT_SIGNAL(nextStep(const TQByteArray &)), TQT_SLOT(sasl_nextStep(const TQByteArray &)));
-					connect(d->sasl, TQT_SIGNAL(authenticated()), TQT_SLOT(sasl_authenticated()));
-					connect(d->sasl, TQT_SIGNAL(error(int)), TQT_SLOT(sasl_error(int)));
+					connect(d->sasl, TQ_SIGNAL(authCheck(const TQString &, const TQString &)), TQ_SLOT(sasl_authCheck(const TQString &, const TQString &)));
+					connect(d->sasl, TQ_SIGNAL(nextStep(const TQByteArray &)), TQ_SLOT(sasl_nextStep(const TQByteArray &)));
+					connect(d->sasl, TQ_SIGNAL(authenticated()), TQ_SLOT(sasl_authenticated()));
+					connect(d->sasl, TQ_SIGNAL(error(int)), TQ_SLOT(sasl_error(int)));
 
 					//d->sasl->setAllowAnonymous(false);
 					//d->sasl->setRequirePassCredentials(true);
@@ -1258,7 +1258,7 @@ void ClientStream::srvProcessNext()
 			}
 			case CoreProtocol::ESASLSuccess: {
 				printf("Break SASL Success\n");
-				disconnect(d->sasl, TQT_SIGNAL(error(int)), this, TQT_SLOT(sasl_error(int)));
+				disconnect(d->sasl, TQ_SIGNAL(error(int)), this, TQ_SLOT(sasl_error(int)));
 				TQByteArray a = d->srv.spare;
 				d->ss->setLayerSASL(d->sasl, a);
 				break;
@@ -1324,7 +1324,7 @@ void ClientStream::processNext()
 			//if(!d->in_rrsig && !d->in.isEmpty()) {
 			if(!d->in.isEmpty()) {
 				//d->in_rrsig = true;
-				TQTimer::singleShot(0, this, TQT_SLOT(doReadyRead()));
+				TQTimer::singleShot(0, this, TQ_SLOT(doReadyRead()));
 			}
 
 			if(cont)
@@ -1480,11 +1480,11 @@ bool ClientStream::handleNeed()
 			}
 
 			d->sasl = new TQCA::SASL;
-			connect(d->sasl, TQT_SIGNAL(clientFirstStep(const TQString &, const TQByteArray *)), TQT_SLOT(sasl_clientFirstStep(const TQString &, const TQByteArray *)));
-			connect(d->sasl, TQT_SIGNAL(nextStep(const TQByteArray &)), TQT_SLOT(sasl_nextStep(const TQByteArray &)));
-			connect(d->sasl, TQT_SIGNAL(needParams(bool, bool, bool, bool)), TQT_SLOT(sasl_needParams(bool, bool, bool, bool)));
-			connect(d->sasl, TQT_SIGNAL(authenticated()), TQT_SLOT(sasl_authenticated()));
-			connect(d->sasl, TQT_SIGNAL(error(int)), TQT_SLOT(sasl_error(int)));
+			connect(d->sasl, TQ_SIGNAL(clientFirstStep(const TQString &, const TQByteArray *)), TQ_SLOT(sasl_clientFirstStep(const TQString &, const TQByteArray *)));
+			connect(d->sasl, TQ_SIGNAL(nextStep(const TQByteArray &)), TQ_SLOT(sasl_nextStep(const TQByteArray &)));
+			connect(d->sasl, TQ_SIGNAL(needParams(bool, bool, bool, bool)), TQ_SLOT(sasl_needParams(bool, bool, bool, bool)));
+			connect(d->sasl, TQ_SIGNAL(authenticated()), TQ_SLOT(sasl_authenticated()));
+			connect(d->sasl, TQ_SIGNAL(error(int)), TQ_SLOT(sasl_error(int)));
 
 			if(d->haveLocalAddr)
 				d->sasl->setLocalAddr(d->localAddr, d->localPort);
@@ -1531,7 +1531,7 @@ bool ClientStream::handleNeed()
 		}
 		case CoreProtocol::NSASLLayer: {
 			// SecureStream will handle the errors from this point
-			disconnect(d->sasl, TQT_SIGNAL(error(int)), this, TQT_SLOT(sasl_error(int)));
+			disconnect(d->sasl, TQ_SIGNAL(error(int)), this, TQ_SLOT(sasl_error(int)));
 			d->ss->setLayerSASL(d->sasl, d->client.spare);
 			if(d->sasl_ssf > 0) {
 				TQGuardedPtr<TQObject> self = this;
diff --git a/kopete/protocols/jabber/libiris/iris/xmpp-core/tlshandler.cpp b/kopete/protocols/jabber/libiris/iris/xmpp-core/tlshandler.cpp
index 86092bad..51e75bbf 100644
--- a/kopete/protocols/jabber/libiris/iris/xmpp-core/tlshandler.cpp
+++ b/kopete/protocols/jabber/libiris/iris/xmpp-core/tlshandler.cpp
@@ -53,11 +53,11 @@ TQCATLSHandler::TQCATLSHandler(TQCA::TLS *parent)
 {
 	d = new Private;
 	d->tls = parent;
-	connect(d->tls, TQT_SIGNAL(handshaken()), TQT_SLOT(tls_handshaken()));
-	connect(d->tls, TQT_SIGNAL(readyRead()), TQT_SLOT(tls_readyRead()));
-	connect(d->tls, TQT_SIGNAL(readyReadOutgoing(int)), TQT_SLOT(tls_readyReadOutgoing(int)));
-	connect(d->tls, TQT_SIGNAL(closed()), TQT_SLOT(tls_closed()));
-	connect(d->tls, TQT_SIGNAL(error(int)), TQT_SLOT(tls_error(int)));
+	connect(d->tls, TQ_SIGNAL(handshaken()), TQ_SLOT(tls_handshaken()));
+	connect(d->tls, TQ_SIGNAL(readyRead()), TQ_SLOT(tls_readyRead()));
+	connect(d->tls, TQ_SIGNAL(readyReadOutgoing(int)), TQ_SLOT(tls_readyReadOutgoing(int)));
+	connect(d->tls, TQ_SIGNAL(closed()), TQ_SLOT(tls_closed()));
+	connect(d->tls, TQ_SIGNAL(error(int)), TQ_SLOT(tls_error(int)));
 	d->state = 0;
 	d->err = -1;
 }
@@ -88,7 +88,7 @@ void TQCATLSHandler::startClient(const TQString &host)
 	d->state = 0;
 	d->err = -1;
 	if(!d->tls->startClient(host))
-		TQTimer::singleShot(0, this, TQT_SIGNAL(fail()));
+		TQTimer::singleShot(0, this, TQ_SIGNAL(fail()));
 }
 
 void TQCATLSHandler::write(const TQByteArray &a)
diff --git a/kopete/protocols/jabber/libiris/iris/xmpp-im/client.cpp b/kopete/protocols/jabber/libiris/iris/xmpp-im/client.cpp
index 08c5c415..f03ab71b 100644
--- a/kopete/protocols/jabber/libiris/iris/xmpp-im/client.cpp
+++ b/kopete/protocols/jabber/libiris/iris/xmpp-im/client.cpp
@@ -50,8 +50,8 @@
 //!  Session::Session()
 //!  {
 //!    client = new Client;
-//!    connect(client, TQT_SIGNAL(handshaken()), TQT_SLOT(clientHandshaken()));
-//!    connect(client, TQT_SIGNAL(authFinished(bool, int, const TQString &)), TQT_SLOT(authFinished(bool, int, const TQString &)));
+//!    connect(client, TQ_SIGNAL(handshaken()), TQ_SLOT(clientHandshaken()));
+//!    connect(client, TQ_SIGNAL(authFinished(bool, int, const TQString &)), TQ_SLOT(authFinished(bool, int, const TQString &)));
 //!    client->connectToHost("jabber.org");
 //!  }
 //!
@@ -162,10 +162,10 @@ Client::Client(TQObject *par)
 	d->stream = 0;
 
 	d->s5bman = new S5BManager(this);
-	connect(d->s5bman, TQT_SIGNAL(incomingReady()), TQT_SLOT(s5b_incomingReady()));
+	connect(d->s5bman, TQ_SIGNAL(incomingReady()), TQ_SLOT(s5b_incomingReady()));
 
 	d->ibbman = new IBBManager(this);
-	connect(d->ibbman, TQT_SIGNAL(incomingReady()), TQT_SLOT(ibb_incomingReady()));
+	connect(d->ibbman, TQ_SIGNAL(incomingReady()), TQ_SLOT(ibb_incomingReady()));
 
 	d->jlman = new JidLinkManager(this);
 
@@ -188,14 +188,14 @@ Client::~Client()
 void Client::connectToServer(ClientStream *s, const Jid &j, bool auth)
 {
 	d->stream = s;
-	//connect(d->stream, TQT_SIGNAL(connected()), TQT_SLOT(streamConnected()));
-	//connect(d->stream, TQT_SIGNAL(handshaken()), TQT_SLOT(streamHandshaken()));
-	connect(d->stream, TQT_SIGNAL(error(int)), TQT_SLOT(streamError(int)));
-	//connect(d->stream, TQT_SIGNAL(sslCertificateReady(const TQSSLCert &)), TQT_SLOT(streamSSLCertificateReady(const TQSSLCert &)));
-	connect(d->stream, TQT_SIGNAL(readyRead()), TQT_SLOT(streamReadyRead()));
-	//connect(d->stream, TQT_SIGNAL(closeFinished()), TQT_SLOT(streamCloseFinished()));
-	connect(d->stream, TQT_SIGNAL(incomingXml(const TQString &)), TQT_SLOT(streamIncomingXml(const TQString &)));
-	connect(d->stream, TQT_SIGNAL(outgoingXml(const TQString &)), TQT_SLOT(streamOutgoingXml(const TQString &)));
+	//connect(d->stream, TQ_SIGNAL(connected()), TQ_SLOT(streamConnected()));
+	//connect(d->stream, TQ_SIGNAL(handshaken()), TQ_SLOT(streamHandshaken()));
+	connect(d->stream, TQ_SIGNAL(error(int)), TQ_SLOT(streamError(int)));
+	//connect(d->stream, TQ_SIGNAL(sslCertificateReady(const TQSSLCert &)), TQ_SLOT(streamSSLCertificateReady(const TQSSLCert &)));
+	connect(d->stream, TQ_SIGNAL(readyRead()), TQ_SLOT(streamReadyRead()));
+	//connect(d->stream, TQ_SIGNAL(closeFinished()), TQ_SLOT(streamCloseFinished()));
+	connect(d->stream, TQ_SIGNAL(incomingXml(const TQString &)), TQ_SLOT(streamIncomingXml(const TQString &)));
+	connect(d->stream, TQ_SIGNAL(outgoingXml(const TQString &)), TQ_SLOT(streamOutgoingXml(const TQString &)));
 
 	d->stream->connectToServer(j, auth);
 }
@@ -213,14 +213,14 @@ void Client::start(const TQString &host, const TQString &user, const TQString &p
 	d->resourceList += Resource(resource(), stat);
 
 	JT_PushPresence *pp = new JT_PushPresence(rootTask());
-	connect(pp, TQT_SIGNAL(subscription(const Jid &, const TQString &)), TQT_SLOT(ppSubscription(const Jid &, const TQString &)));
-	connect(pp, TQT_SIGNAL(presence(const Jid &, const Status &)), TQT_SLOT(ppPresence(const Jid &, const Status &)));
+	connect(pp, TQ_SIGNAL(subscription(const Jid &, const TQString &)), TQ_SLOT(ppSubscription(const Jid &, const TQString &)));
+	connect(pp, TQ_SIGNAL(presence(const Jid &, const Status &)), TQ_SLOT(ppPresence(const Jid &, const Status &)));
 
 	JT_PushMessage *pm = new JT_PushMessage(rootTask());
-	connect(pm, TQT_SIGNAL(message(const Message &)), TQT_SLOT(pmMessage(const Message &)));
+	connect(pm, TQ_SIGNAL(message(const Message &)), TQ_SLOT(pmMessage(const Message &)));
 
 	JT_PushRoster *pr = new JT_PushRoster(rootTask());
-	connect(pr, TQT_SIGNAL(roster(const Roster &)), TQT_SLOT(prRoster(const Roster &)));
+	connect(pr, TQ_SIGNAL(roster(const Roster &)), TQ_SLOT(prRoster(const Roster &)));
 
 	new JT_ServInfo(rootTask());
 	new PongServer(rootTask());
@@ -884,7 +884,7 @@ void Client::rosterRequest()
 		return;
 
 	JT_Roster *r = new JT_Roster(rootTask());
-	connect(r, TQT_SIGNAL(finished()), TQT_SLOT(slotRosterRequestFinished()));
+	connect(r, TQ_SIGNAL(finished()), TQ_SLOT(slotRosterRequestFinished()));
 	r->get();
 	d->roster.flagAllForDelete(); // mod_groups patch
 	r->go(true);
@@ -1163,7 +1163,7 @@ Task::Task(Task *parent)
 
 	d->client = parent->client();
 	d->id = client()->genUniqueId();
-	connect(d->client, TQT_SIGNAL(disconnected()), TQT_SLOT(clientDisconnected()));
+	connect(d->client, TQ_SIGNAL(disconnected()), TQ_SLOT(clientDisconnected()));
 }
 
 Task::Task(Client *parent, bool)
@@ -1172,7 +1172,7 @@ Task::Task(Client *parent, bool)
 	init();
 
 	d->client = parent;
-	connect(d->client, TQT_SIGNAL(disconnected()), TQT_SLOT(clientDisconnected()));
+	connect(d->client, TQ_SIGNAL(disconnected()), TQ_SLOT(clientDisconnected()));
 }
 
 Task::~Task()
@@ -1276,7 +1276,7 @@ void Task::onDisconnect()
 		d->statusString = tr("Disconnected");
 
 		// delay this so that tasks that react don't block the shutdown
-		TQTimer::singleShot(0, this, TQT_SLOT(done()));
+		TQTimer::singleShot(0, this, TQ_SLOT(done()));
 	}
 }
 
diff --git a/kopete/protocols/jabber/libiris/iris/xmpp-im/xmpp_tasks.cpp b/kopete/protocols/jabber/libiris/iris/xmpp-im/xmpp_tasks.cpp
index c331e123..e7e929ab 100644
--- a/kopete/protocols/jabber/libiris/iris/xmpp-im/xmpp_tasks.cpp
+++ b/kopete/protocols/jabber/libiris/iris/xmpp-im/xmpp_tasks.cpp
@@ -270,7 +270,7 @@ void JT_UnRegister::onGo()
 
 	d->jt_reg = new JT_Register(this);
 	d->jt_reg->getForm(d->j);
-	connect(d->jt_reg, TQT_SIGNAL(finished()), TQT_SLOT(getFormFinished()));
+	connect(d->jt_reg, TQ_SIGNAL(finished()), TQ_SLOT(getFormFinished()));
 	d->jt_reg->go(false);
 }
 
@@ -279,7 +279,7 @@ void JT_UnRegister::getFormFinished()
 	disconnect(d->jt_reg, 0, this, 0);
 
 	d->jt_reg->unreg(d->j);
-	connect(d->jt_reg, TQT_SIGNAL(finished()), TQT_SLOT(unregFinished()));
+	connect(d->jt_reg, TQ_SIGNAL(finished()), TQ_SLOT(unregFinished()));
 	d->jt_reg->go(false);
 }