Trinity Qt initial conversion

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

1 files changed, 193 insertions, 193 deletions

diff --git a/kopete/protocols/jabber/libiris/iris/jabber/s5b.cpp b/kopete/protocols/jabber/libiris/iris/jabber/s5b.cpp
index f48da694..df753925 100644
--- a/kopete/protocols/jabber/libiris/iris/jabber/s5b.cpp
+++ b/kopete/protocols/jabber/libiris/iris/jabber/s5b.cpp
@@ -22,8 +22,8 @@
 
 #include"s5b.h"
 
-#include<qtimer.h>
-#include<qguardedptr.h>
+#include<tqtimer.h>
+#include<tqguardedptr.h>
 #include<stdlib.h>
 #include<qca.h>
 #include"xmpp_xmlcommon.h"
@@ -46,9 +46,9 @@
 
 namespace XMPP {
 
-static QString makeKey(const QString &sid, const Jid &initiator, const Jid &target)
+static TQString makeKey(const TQString &sid, const Jid &initiator, const Jid &target)
 {
-	QString str = sid + initiator.full() + target.full();
+	TQString str = sid + initiator.full() + target.full();
 	return QCA::SHA1::hashToString(str.utf8());
 }
 
@@ -70,7 +70,7 @@ public:
 	enum { Unknown, Fast, NotFast };
 	S5BManager *m;
 	int state;
-	QString sid, key, out_key, out_id, in_id;
+	TQString sid, key, out_key, out_id, in_id;
 	Jid self, peer;
 	StreamHostList in_hosts;
 	JT_S5B *task, *proxy_task;
@@ -94,9 +94,9 @@ public:
 	~Item();
 
 	void reset();
-	void startInitiator(const QString &_sid, const Jid &_self, const Jid &_peer, bool fast, bool udp);
-	void startTarget(const QString &_sid, const Jid &_self, const Jid &_peer, const StreamHostList &hosts, const QString &iq_id, bool fast, bool udp);
-	void handleFast(const StreamHostList &hosts, const QString &iq_id);
+	void startInitiator(const TQString &_sid, const Jid &_self, const Jid &_peer, bool fast, bool udp);
+	void startTarget(const TQString &_sid, const Jid &_self, const Jid &_peer, const StreamHostList &hosts, const TQString &iq_id, bool fast, bool udp);
+	void handleFast(const StreamHostList &hosts, const TQString &iq_id);
 
 	void doOutgoing();
 	void doIncoming();
@@ -137,7 +137,7 @@ S5BDatagram::S5BDatagram()
 	_dest = 0;
 }
 
-S5BDatagram::S5BDatagram(int source, int dest, const QByteArray &data)
+S5BDatagram::S5BDatagram(int source, int dest, const TQByteArray &data)
 {
 	_source = source;
 	_dest = dest;
@@ -154,7 +154,7 @@ int S5BDatagram::destPort() const
 	return _dest;
 }
 
-QByteArray S5BDatagram::data() const
+TQByteArray S5BDatagram::data() const
 {
 	return _buf;
 }
@@ -170,7 +170,7 @@ public:
 	SocksUDP *su;
 	int state;
 	Jid peer;
-	QString sid;
+	TQString sid;
 	bool remote;
 	bool switched;
 	bool notifyRead, notifyClose;
@@ -178,13 +178,13 @@ public:
 	S5BRequest req;
 	Jid proxy;
 	Mode mode;
-	QPtrList<S5BDatagram> dglist;
+	TQPtrList<S5BDatagram> dglist;
 };
 
 static int id_conn = 0;
 static int num_conn = 0;
 
-S5BConnection::S5BConnection(S5BManager *m, QObject *parent)
+S5BConnection::S5BConnection(S5BManager *m, TQObject *parent)
 :ByteStream(parent)
 {
 	d = new Private;
@@ -229,7 +229,7 @@ void S5BConnection::reset(bool clear)
 	}
 	d->state = Idle;
 	d->peer = Jid();
-	d->sid = QString();
+	d->sid = TQString();
 	d->remote = false;
 	d->switched = false;
 	d->notifyRead = false;
@@ -246,7 +246,7 @@ void S5BConnection::setProxy(const Jid &proxy)
 	d->proxy = proxy;
 }
 
-void S5BConnection::connectToJid(const Jid &peer, const QString &sid, Mode m)
+void S5BConnection::connectToJid(const Jid &peer, const TQString &sid, Mode m)
 {
 	reset(true);
 	if(!d->m->isAcceptableSID(peer, sid))
@@ -294,7 +294,7 @@ Jid S5BConnection::peer() const
 	return d->peer;
 }
 
-QString S5BConnection::sid() const
+TQString S5BConnection::sid() const
 {
 	return d->sid;
 }
@@ -322,18 +322,18 @@ bool S5BConnection::isOpen() const
 		return false;
 }
 
-void S5BConnection::write(const QByteArray &buf)
+void S5BConnection::write(const TQByteArray &buf)
 {
 	if(d->state == Active && d->mode == Stream)
 		d->sc->write(buf);
 }
 
-QByteArray S5BConnection::read(int bytes)
+TQByteArray S5BConnection::read(int bytes)
 {
 	if(d->sc)
 		return d->sc->read(bytes);
 	else
-		return QByteArray();
+		return TQByteArray();
 }
 
 int S5BConnection::bytesAvailable() const
@@ -354,10 +354,10 @@ int S5BConnection::bytesToWrite() const
 
 void S5BConnection::writeDatagram(const S5BDatagram &i)
 {
-	QByteArray buf(i.data().size() + 4);
+	TQByteArray buf(i.data().size() + 4);
 	ushort ssp = htons(i.sourcePort());
 	ushort sdp = htons(i.destPort());
-	QByteArray data = i.data();
+	TQByteArray data = i.data();
 	memcpy(buf.data(), &ssp, 2);
 	memcpy(buf.data() + 2, &sdp, 2);
 	memcpy(buf.data() + 4, data.data(), data.size());
@@ -393,15 +393,15 @@ void S5BConnection::man_waitForAccept(const S5BRequest &r)
 void S5BConnection::man_clientReady(SocksClient *sc, SocksUDP *sc_udp)
 {
 	d->sc = sc;
-	connect(d->sc, SIGNAL(connectionClosed()), SLOT(sc_connectionClosed()));
-	connect(d->sc, SIGNAL(delayedCloseFinished()), SLOT(sc_delayedCloseFinished()));
-	connect(d->sc, SIGNAL(readyRead()), SLOT(sc_readyRead()));
-	connect(d->sc, SIGNAL(bytesWritten(int)), SLOT(sc_bytesWritten(int)));
-	connect(d->sc, SIGNAL(error(int)), SLOT(sc_error(int)));
+	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)));
 
 	if(sc_udp) {
 		d->su = sc_udp;
-		connect(d->su, SIGNAL(packetReady(const QByteArray &)), SLOT(su_packetReady(const QByteArray &)));
+		connect(d->su, TQT_SIGNAL(packetReady(const TQByteArray &)), TQT_SLOT(su_packetReady(const TQByteArray &)));
 	}
 
 	d->state = Active;
@@ -424,7 +424,7 @@ void S5BConnection::man_clientReady(SocksClient *sc, SocksUDP *sc_udp)
 		d->notifyClose = true;
 	}
 	if(d->notifyRead || d->notifyClose)
-		QTimer::singleShot(0, this, SLOT(doPending()));
+		TQTimer::singleShot(0, this, TQT_SLOT(doPending()));
 	connected();
 }
 
@@ -432,14 +432,14 @@ void S5BConnection::doPending()
 {
 	if(d->notifyRead) {
 		if(d->notifyClose)
-			QTimer::singleShot(0, this, SLOT(doPending()));
+			TQTimer::singleShot(0, this, TQT_SLOT(doPending()));
 		sc_readyRead();
 	}
 	else if(d->notifyClose)
 		sc_connectionClosed();
 }
 
-void S5BConnection::man_udpReady(const QByteArray &buf)
+void S5BConnection::man_udpReady(const TQByteArray &buf)
 {
 	handleUDP(buf);
 }
@@ -503,12 +503,12 @@ void S5BConnection::sc_error(int)
 	error(ErrSocket);
 }
 
-void S5BConnection::su_packetReady(const QByteArray &buf)
+void S5BConnection::su_packetReady(const TQByteArray &buf)
 {
 	handleUDP(buf);
 }
 
-void S5BConnection::handleUDP(const QByteArray &buf)
+void S5BConnection::handleUDP(const TQByteArray &buf)
 {
 	// must be at least 4 bytes, to accomodate virtual ports
 	if(buf.size() < 4)
@@ -519,14 +519,14 @@ void S5BConnection::handleUDP(const QByteArray &buf)
 	memcpy(&sdp, buf.data() + 2, 2);
 	int source = ntohs(ssp);
 	int dest = ntohs(sdp);
-	QByteArray data(buf.size() - 4);
+	TQByteArray data(buf.size() - 4);
 	memcpy(data.data(), buf.data() + 4, data.size());
 	d->dglist.append(new S5BDatagram(source, dest, data));
 
 	datagramReady();
 }
 
-void S5BConnection::sendUDP(const QByteArray &buf)
+void S5BConnection::sendUDP(const TQByteArray &buf)
 {
 	if(d->su)
 		d->su->write(buf);
@@ -554,13 +554,13 @@ public:
 
 	S5BConnection *c;
 	Item *i;
-	QString sid;
+	TQString sid;
 	JT_S5B *query;
 	StreamHost proxyInfo;
-	QGuardedPtr<S5BServer> relatedServer;
+	TQGuardedPtr<S5BServer> relatedServer;
 
 	bool udp_init;
-	QHostAddress udp_addr;
+	TQHostAddress udp_addr;
 	int udp_port;
 };
 
@@ -569,13 +569,13 @@ class S5BManager::Private
 public:
 	Client *client;
 	S5BServer *serv;
-	QPtrList<Entry> activeList;
+	TQPtrList<Entry> activeList;
 	S5BConnectionList incomingConns;
 	JT_PushS5B *ps;
 };
 
 S5BManager::S5BManager(Client *parent)
-:QObject(parent)
+:TQObject(parent)
 {
 	// S5B needs SHA1
 	if(!QCA::isSupported(QCA::CAP_SHA1))
@@ -587,9 +587,9 @@ S5BManager::S5BManager(Client *parent)
 	d->activeList.setAutoDelete(true);
 
 	d->ps = new JT_PushS5B(d->client->rootTask());
-	connect(d->ps, SIGNAL(incoming(const S5BRequest &)), SLOT(ps_incoming(const S5BRequest &)));
-	connect(d->ps, SIGNAL(incomingUDPSuccess(const Jid &, const QString &)), SLOT(ps_incomingUDPSuccess(const Jid &, const QString &)));
-	connect(d->ps, SIGNAL(incomingActivate(const Jid &, const QString &, const Jid &)), SLOT(ps_incomingActivate(const Jid &, const QString &, const Jid &)));
+	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 &)));
 }
 
 S5BManager::~S5BManager()
@@ -697,7 +697,7 @@ void S5BManager::ps_incoming(const S5BRequest &req)
 	incomingReady();
 }
 
-void S5BManager::ps_incomingUDPSuccess(const Jid &from, const QString &key)
+void S5BManager::ps_incomingUDPSuccess(const Jid &from, const TQString &key)
 {
 	Entry *e = findEntryByHash(key);
 	if(e && e->i) {
@@ -708,38 +708,38 @@ void S5BManager::ps_incomingUDPSuccess(const Jid &from, const QString &key)
 	}
 }
 
-void S5BManager::ps_incomingActivate(const Jid &from, const QString &sid, const Jid &streamHost)
+void S5BManager::ps_incomingActivate(const Jid &from, const TQString &sid, const Jid &streamHost)
 {
 	Entry *e = findEntryBySID(from, sid);
 	if(e && e->i)
 		e->i->incomingActivate(streamHost);
 }
 
-void S5BManager::doSuccess(const Jid &peer, const QString &id, const Jid &streamHost)
+void S5BManager::doSuccess(const Jid &peer, const TQString &id, const Jid &streamHost)
 {
 	d->ps->respondSuccess(peer, id, streamHost);
 }
 
-void S5BManager::doError(const Jid &peer, const QString &id, int code, const QString &str)
+void S5BManager::doError(const Jid &peer, const TQString &id, int code, const TQString &str)
 {
 	d->ps->respondError(peer, id, code, str);
 }
 
-void S5BManager::doActivate(const Jid &peer, const QString &sid, const Jid &streamHost)
+void S5BManager::doActivate(const Jid &peer, const TQString &sid, const Jid &streamHost)
 {
 	d->ps->sendActivate(peer, sid, streamHost);
 }
 
-QString S5BManager::genUniqueSID(const Jid &peer) const
+TQString S5BManager::genUniqueSID(const Jid &peer) const
 {
 	// get unused key
-	QString sid;
+	TQString sid;
 	do {
 		sid = "s5b_";
 		for(int i = 0; i < 4; ++i) {
 			int word = rand() & 0xffff;
 			for(int n = 0; n < 4; ++n) {
-				QString s;
+				TQString s;
 				s.sprintf("%x", (word >> (n * 4)) & 0xf);
 				sid.append(s);
 			}
@@ -748,10 +748,10 @@ QString S5BManager::genUniqueSID(const Jid &peer) const
 	return sid;
 }
 
-bool S5BManager::isAcceptableSID(const Jid &peer, const QString &sid) const
+bool S5BManager::isAcceptableSID(const Jid &peer, const TQString &sid) const
 {
-	QString key = makeKey(sid, d->client->jid(), peer);
-	QString key_out = makeKey(sid, peer, d->client->jid());
+	TQString key = makeKey(sid, d->client->jid(), peer);
+	TQString key_out = makeKey(sid, peer, d->client->jid());
 
 	// if we have a server, then check through it
 	if(d->serv) {
@@ -765,9 +765,9 @@ bool S5BManager::isAcceptableSID(const Jid &peer, const QString &sid) const
 	return true;
 }
 
-S5BConnection *S5BManager::findIncoming(const Jid &from, const QString &sid) const
+S5BConnection *S5BManager::findIncoming(const Jid &from, const TQString &sid) const
 {
-	QPtrListIterator<S5BConnection> it(d->incomingConns);
+	TQPtrListIterator<S5BConnection> it(d->incomingConns);
 	for(S5BConnection *c; (c = it.current()); ++it) {
 		if(c->d->peer.compare(from) && c->d->sid == sid)
 			return c;
@@ -777,7 +777,7 @@ S5BConnection *S5BManager::findIncoming(const Jid &from, const QString &sid) con
 
 S5BManager::Entry *S5BManager::findEntry(S5BConnection *c) const
 {
-	QPtrListIterator<Entry> it(d->activeList);
+	TQPtrListIterator<Entry> it(d->activeList);
 	for(Entry *e; (e = it.current()); ++it) {
 		if(e->c == c)
 			return e;
@@ -787,7 +787,7 @@ S5BManager::Entry *S5BManager::findEntry(S5BConnection *c) const
 
 S5BManager::Entry *S5BManager::findEntry(Item *i) const
 {
-	QPtrListIterator<Entry> it(d->activeList);
+	TQPtrListIterator<Entry> it(d->activeList);
 	for(Entry *e; (e = it.current()); ++it) {
 		if(e->i == i)
 			return e;
@@ -795,9 +795,9 @@ S5BManager::Entry *S5BManager::findEntry(Item *i) const
 	return 0;
 }
 
-S5BManager::Entry *S5BManager::findEntryByHash(const QString &key) const
+S5BManager::Entry *S5BManager::findEntryByHash(const TQString &key) const
 {
-	QPtrListIterator<Entry> it(d->activeList);
+	TQPtrListIterator<Entry> it(d->activeList);
 	for(Entry *e; (e = it.current()); ++it) {
 		if(e->i && e->i->key == key)
 			return e;
@@ -805,9 +805,9 @@ S5BManager::Entry *S5BManager::findEntryByHash(const QString &key) const
 	return 0;
 }
 
-S5BManager::Entry *S5BManager::findEntryBySID(const Jid &peer, const QString &sid) const
+S5BManager::Entry *S5BManager::findEntryBySID(const Jid &peer, const TQString &sid) const
 {
-	QPtrListIterator<Entry> it(d->activeList);
+	TQPtrListIterator<Entry> it(d->activeList);
 	for(Entry *e; (e = it.current()); ++it) {
 		if(e->i && e->i->peer.compare(peer) && e->sid == sid)
 			return e;
@@ -815,10 +815,10 @@ S5BManager::Entry *S5BManager::findEntryBySID(const Jid &peer, const QString &si
 	return 0;
 }
 
-S5BManager::Entry *S5BManager::findServerEntryByHash(const QString &key) const
+S5BManager::Entry *S5BManager::findServerEntryByHash(const TQString &key) const
 {
-	const QPtrList<S5BManager> &manList = d->serv->managerList();
-	QPtrListIterator<S5BManager> it(manList);
+	const TQPtrList<S5BManager> &manList = d->serv->managerList();
+	TQPtrListIterator<S5BManager> it(manList);
 	for(S5BManager *m; (m = it.current()); ++it) {
 		Entry *e = m->findEntryByHash(key);
 		if(e)
@@ -827,14 +827,14 @@ S5BManager::Entry *S5BManager::findServerEntryByHash(const QString &key) const
 	return 0;
 }
 
-bool S5BManager::srv_ownsHash(const QString &key) const
+bool S5BManager::srv_ownsHash(const TQString &key) const
 {
 	if(findEntryByHash(key))
 		return true;
 	return false;
 }
 
-void S5BManager::srv_incomingReady(SocksClient *sc, const QString &key)
+void S5BManager::srv_incomingReady(SocksClient *sc, const TQString &key)
 {
 	Entry *e = findEntryByHash(key);
 	if(!e->i->allowIncoming) {
@@ -850,7 +850,7 @@ void S5BManager::srv_incomingReady(SocksClient *sc, const QString &key)
 	e->i->setIncomingClient(sc);
 }
 
-void S5BManager::srv_incomingUDP(bool init, const QHostAddress &addr, int port, const QString &key, const QByteArray &data)
+void S5BManager::srv_incomingUDP(bool init, const TQHostAddress &addr, int port, const TQString &key, const TQByteArray &data)
 {
 	Entry *e = findEntryByHash(key);
 	if(!e->c->d->mode != S5BConnection::Datagram)
@@ -935,7 +935,7 @@ void S5BManager::con_unlink(S5BConnection *c)
 	d->activeList.removeRef(e);
 }
 
-void S5BManager::con_sendUDP(S5BConnection *c, const QByteArray &buf)
+void S5BManager::con_sendUDP(S5BConnection *c, const TQByteArray &buf)
 {
 	Entry *e = findEntry(c);
 	if(!e)
@@ -1007,12 +1007,12 @@ void S5BManager::entryContinue(Entry *e)
 	e->i = new Item(this);
 	e->i->proxy = e->proxyInfo;
 
-	connect(e->i, SIGNAL(accepted()), SLOT(item_accepted()));
-	connect(e->i, SIGNAL(tryingHosts(const StreamHostList &)), SLOT(item_tryingHosts(const StreamHostList &)));
-	connect(e->i, SIGNAL(proxyConnect()), SLOT(item_proxyConnect()));
-	connect(e->i, SIGNAL(waitingForActivation()), SLOT(item_waitingForActivation()));
-	connect(e->i, SIGNAL(connected()), SLOT(item_connected()));
-	connect(e->i, SIGNAL(error(int)), SLOT(item_error(int)));
+	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)));
 
 	if(e->c->isRemote()) {
 		const S5BRequest &req = e->c->d->req;
@@ -1026,7 +1026,7 @@ void S5BManager::entryContinue(Entry *e)
 
 void S5BManager::queryProxy(Entry *e)
 {
-	QGuardedPtr<QObject> self = this;
+	TQGuardedPtr<TQObject> self = this;
 	e->c->proxyQuery(); // signal
 	if(!self)
 		return;
@@ -1035,7 +1035,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, SIGNAL(finished()), SLOT(query_finished()));
+	connect(e->query, TQT_SIGNAL(finished()), TQT_SLOT(query_finished()));
 	e->query->requestProxyInfo(e->c->d->proxy);
 	e->query->go(true);
 }
@@ -1045,7 +1045,7 @@ void S5BManager::query_finished()
 	JT_S5B *query = (JT_S5B *)sender();
 	Entry *e;
 	bool found = false;
-	QPtrListIterator<Entry> it(d->activeList);
+	TQPtrListIterator<Entry> it(d->activeList);
 	for(; (e = it.current()); ++it) {
 		if(e->query == query) {
 			found = true;
@@ -1071,7 +1071,7 @@ void S5BManager::query_finished()
 #endif
 	}
 
-	QGuardedPtr<QObject> self = this;
+	TQGuardedPtr<TQObject> self = this;
 	e->c->proxyResult(query->success()); // signal
 	if(!self)
 		return;
@@ -1101,7 +1101,7 @@ bool S5BManager::targetShouldOfferProxy(Entry *e)
 //----------------------------------------------------------------------------
 // S5BManager::Item
 //----------------------------------------------------------------------------
-S5BManager::Item::Item(S5BManager *manager) : QObject(0)
+S5BManager::Item::Item(S5BManager *manager) : TQObject(0)
 {
 	m = manager;
 	task = 0;
@@ -1159,7 +1159,7 @@ void S5BManager::Item::reset()
 	udp = false;
 }
 
-void S5BManager::Item::startInitiator(const QString &_sid, const Jid &_self, const Jid &_peer, bool fast, bool _udp)
+void S5BManager::Item::startInitiator(const TQString &_sid, const Jid &_self, const Jid &_peer, bool fast, bool _udp)
 {
 	sid = _sid;
 	self = _self;
@@ -1176,7 +1176,7 @@ void S5BManager::Item::startInitiator(const QString &_sid, const Jid &_self, con
 	doOutgoing();
 }
 
-void S5BManager::Item::startTarget(const QString &_sid, const Jid &_self, const Jid &_peer, const StreamHostList &hosts, const QString &iq_id, bool _fast, bool _udp)
+void S5BManager::Item::startTarget(const TQString &_sid, const Jid &_self, const Jid &_peer, const StreamHostList &hosts, const TQString &iq_id, bool _fast, bool _udp)
 {
 	sid = _sid;
 	peer = _peer;
@@ -1197,11 +1197,11 @@ void S5BManager::Item::startTarget(const QString &_sid, const Jid &_self, const
 	doIncoming();
 }
 
-void S5BManager::Item::handleFast(const StreamHostList &hosts, const QString &iq_id)
+void S5BManager::Item::handleFast(const StreamHostList &hosts, const TQString &iq_id)
 {
 	targetMode = Fast;
 
-	QGuardedPtr<QObject> self = this;
+	TQGuardedPtr<TQObject> self = this;
 	accepted();
 	if(!self)
 		return;
@@ -1222,8 +1222,8 @@ void S5BManager::Item::doOutgoing()
 	StreamHostList hosts;
 	S5BServer *serv = m->server();
 	if(serv && serv->isActive() && !haveHost(in_hosts, m->client()->jid())) {
-		QStringList hostList = serv->hostList();
-		for(QStringList::ConstIterator it = hostList.begin(); it != hostList.end(); ++it) {
+		TQStringList hostList = serv->hostList();
+		for(TQStringList::ConstIterator it = hostList.begin(); it != hostList.end(); ++it) {
 			StreamHost h;
 			h.setJid(m->client()->jid());
 			h.setHost(*it);
@@ -1245,7 +1245,7 @@ void S5BManager::Item::doOutgoing()
 	allowIncoming = true;
 
 	task = new JT_S5B(m->client()->rootTask());
-	connect(task, SIGNAL(finished()), SLOT(jt_finished()));
+	connect(task, TQT_SIGNAL(finished()), TQT_SLOT(jt_finished()));
 	task->request(peer, sid, hosts, state == Initiator ? wantFast : false, udp);
 	out_id = task->id();
 	task->go(true);
@@ -1291,9 +1291,9 @@ void S5BManager::Item::doIncoming()
 	}
 
 	conn = new S5BConnector;
-	connect(conn, SIGNAL(result(bool)), SLOT(conn_result(bool)));
+	connect(conn, TQT_SIGNAL(result(bool)), TQT_SLOT(conn_result(bool)));
 
-	QGuardedPtr<QObject> self = this;
+	TQGuardedPtr<TQObject> self = this;
 	tryingHosts(list);
 	if(!self)
 		return;
@@ -1307,9 +1307,9 @@ void S5BManager::Item::setIncomingClient(SocksClient *sc)
 	printf("S5BManager::Item: %s [%s] successful incoming connection\n", peer.full().latin1(), sid.latin1());
 #endif
 
-	connect(sc, SIGNAL(readyRead()), SLOT(sc_readyRead()));
-	connect(sc, SIGNAL(bytesWritten(int)), SLOT(sc_bytesWritten(int)));
-	connect(sc, SIGNAL(error(int)), SLOT(sc_error(int)));
+	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)));
 
 	client = sc;
 	allowIncoming = false;
@@ -1335,7 +1335,7 @@ void S5BManager::Item::jt_finished()
 	if(state == Initiator) {
 		if(targetMode == Unknown) {
 			targetMode = NotFast;
-			QGuardedPtr<QObject> self = this;
+			TQGuardedPtr<TQObject> self = this;
 			accepted();
 			if(!self)
 				return;
@@ -1387,11 +1387,11 @@ void S5BManager::Item::jt_finished()
 #endif
 			// connect to the proxy
 			proxy_conn = new S5BConnector;
-			connect(proxy_conn, SIGNAL(result(bool)), SLOT(proxy_result(bool)));
+			connect(proxy_conn, TQT_SIGNAL(result(bool)), TQT_SLOT(proxy_result(bool)));
 			StreamHostList list;
 			list += proxy;
 
-			QGuardedPtr<QObject> self = this;
+			TQGuardedPtr<TQObject> self = this;
 			proxyConnect();
 			if(!self)
 				return;
@@ -1441,9 +1441,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, SIGNAL(readyRead()), SLOT(sc_readyRead()));
-		connect(sc, SIGNAL(bytesWritten(int)), SLOT(sc_bytesWritten(int)));
-		connect(sc, SIGNAL(error(int)), SLOT(sc_error(int)));
+		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)));
 
 		m->doSuccess(peer, in_id, h.jid());
 
@@ -1492,9 +1492,9 @@ void S5BManager::Item::proxy_result(bool b)
 		delete proxy_conn;
 		proxy_conn = 0;
 
-		connect(sc, SIGNAL(readyRead()), SLOT(sc_readyRead()));
-		connect(sc, SIGNAL(bytesWritten(int)), SLOT(sc_bytesWritten(int)));
-		connect(sc, SIGNAL(error(int)), SLOT(sc_error(int)));
+		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)));
 
 		client = sc;
 		client_udp = sc_udp;
@@ -1504,7 +1504,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, SIGNAL(finished()), SLOT(proxy_finished()));
+		connect(proxy_task, TQT_SIGNAL(finished()), TQT_SLOT(proxy_finished()));
 		proxy_task->requestActivation(proxy.jid(), sid, peer);
 		proxy_task->go(true);
 	}
@@ -1608,7 +1608,7 @@ void S5BManager::Item::tryActivation()
 			printf("sending extra CR\n");
 #endif
 			// must send [CR] to activate target streamhost
-			QByteArray a(1);
+			TQByteArray a(1);
 			a[0] = '\r';
 			client->write(a);
 		}
@@ -1617,12 +1617,12 @@ void S5BManager::Item::tryActivation()
 
 void S5BManager::Item::checkForActivation()
 {
-	QPtrList<SocksClient> clientList;
+	TQPtrList<SocksClient> clientList;
 	if(client)
 		clientList.append(client);
 	if(client_out)
 		clientList.append(client_out);
-	QPtrListIterator<SocksClient> it(clientList);
+	TQPtrListIterator<SocksClient> it(clientList);
 	for(SocksClient *sc; (sc = it.current()); ++it) {
 #ifdef S5B_DEBUG
 		printf("checking for activation\n");
@@ -1641,7 +1641,7 @@ void S5BManager::Item::checkForActivation()
 #endif
 				if(sc->bytesAvailable() >= 1) {
 					clientList.removeRef(sc);
-					QByteArray a = sc->read(1);
+					TQByteArray a = sc->read(1);
 					if(a[0] != '\r') {
 						delete sc;
 						return;
@@ -1752,13 +1752,13 @@ public:
 	SocksClient *client;
 	SocksUDP *client_udp;
 	StreamHost host;
-	QString key;
+	TQString key;
 	bool udp;
 	int udp_tries;
-	QTimer t;
+	TQTimer t;
 	Jid jid;
 
-	Item(const Jid &self, const StreamHost &_host, const QString &_key, bool _udp) : QObject(0)
+	Item(const Jid &self, const StreamHost &_host, const TQString &_key, bool _udp) : TQObject(0)
 	{
 		jid = self;
 		host = _host;
@@ -1766,9 +1766,9 @@ public:
 		udp = _udp;
 		client = new SocksClient;
 		client_udp = 0;
-		connect(client, SIGNAL(connected()), SLOT(sc_connected()));
-		connect(client, SIGNAL(error(int)), SLOT(sc_error(int)));
-		connect(&t, SIGNAL(timeout()), SLOT(trySendUDP()));
+		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()));
 	}
 
 	~Item()
@@ -1826,8 +1826,8 @@ private slots:
 		}
 
 		// send initialization with our JID
-		QCString cs = jid.full().utf8();
-		QByteArray a(cs.length());
+		TQCString cs = jid.full().utf8();
+		TQByteArray a(cs.length());
 		memcpy(a.data(), cs.data(), a.size());
 		client_udp->write(a);
 		++udp_tries;
@@ -1857,20 +1857,20 @@ class S5BConnector::Private
 public:
 	SocksClient *active;
 	SocksUDP *active_udp;
-	QPtrList<Item> itemList;
-	QString key;
+	TQPtrList<Item> itemList;
+	TQString key;
 	StreamHost activeHost;
-	QTimer t;
+	TQTimer t;
 };
 
-S5BConnector::S5BConnector(QObject *parent)
-:QObject(parent)
+S5BConnector::S5BConnector(TQObject *parent)
+:TQObject(parent)
 {
 	d = new Private;
 	d->active = 0;
 	d->active_udp = 0;
 	d->itemList.setAutoDelete(true);
-	connect(&d->t, SIGNAL(timeout()), SLOT(t_timeout()));
+	connect(&d->t, TQT_SIGNAL(timeout()), TQT_SLOT(t_timeout()));
 }
 
 S5BConnector::~S5BConnector()
@@ -1889,7 +1889,7 @@ void S5BConnector::reset()
 	d->itemList.clear();
 }
 
-void S5BConnector::start(const Jid &self, const StreamHostList &hosts, const QString &key, bool udp, int timeout)
+void S5BConnector::start(const Jid &self, const StreamHostList &hosts, const TQString &key, bool udp, int timeout)
 {
 	reset();
 
@@ -1898,7 +1898,7 @@ void S5BConnector::start(const Jid &self, const StreamHostList &hosts, const QSt
 #endif
 	for(StreamHostList::ConstIterator it = hosts.begin(); it != hosts.end(); ++it) {
 		Item *i = new Item(self, *it, key, udp);
-		connect(i, SIGNAL(result(bool)), SLOT(item_result(bool)));
+		connect(i, TQT_SIGNAL(result(bool)), TQT_SLOT(item_result(bool)));
 		d->itemList.append(i);
 		i->start();
 	}
@@ -1964,7 +1964,7 @@ void S5BConnector::t_timeout()
 void S5BConnector::man_udpSuccess(const Jid &streamHost)
 {
 	// was anyone sending to this streamhost?
-	QPtrListIterator<Item> it(d->itemList);
+	TQPtrListIterator<Item> it(d->itemList);
 	for(Item *i; (i = it.current()); ++it) {
 		if(i->host.jid().compare(streamHost) && i->client_udp) {
 			i->udpSuccess();
@@ -1981,17 +1981,17 @@ class S5BServer::Item : public QObject
 	Q_OBJECT
 public:
 	SocksClient *client;
-	QString host;
-	QTimer expire;
+	TQString host;
+	TQTimer expire;
 
-	Item(SocksClient *c) : QObject(0)
+	Item(SocksClient *c) : TQObject(0)
 	{
 		client = c;
-		connect(client, SIGNAL(incomingMethods(int)), SLOT(sc_incomingMethods(int)));
-		connect(client, SIGNAL(incomingConnectRequest(const QString &, int)), SLOT(sc_incomingConnectRequest(const QString &, int)));
-		connect(client, SIGNAL(error(int)), SLOT(sc_error(int)));
+		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(&expire, SIGNAL(timeout()), SLOT(doError()));
+		connect(&expire, TQT_SIGNAL(timeout()), TQT_SLOT(doError()));
 		resetExpiration();
 	}
 
@@ -2025,7 +2025,7 @@ private slots:
 			doError();
 	}
 
-	void sc_incomingConnectRequest(const QString &_host, int port)
+	void sc_incomingConnectRequest(const TQString &_host, int port)
 	{
 		if(port == 0) {
 			host = _host;
@@ -2046,18 +2046,18 @@ class S5BServer::Private
 {
 public:
 	SocksServer serv;
-	QStringList hostList;
-	QPtrList<S5BManager> manList;
-	QPtrList<Item> itemList;
+	TQStringList hostList;
+	TQPtrList<S5BManager> manList;
+	TQPtrList<Item> itemList;
 };
 
-S5BServer::S5BServer(QObject *parent)
-:QObject(parent)
+S5BServer::S5BServer(TQObject *parent)
+:TQObject(parent)
 {
 	d = new Private;
 	d->itemList.setAutoDelete(true);
-	connect(&d->serv, SIGNAL(incomingReady()), SLOT(ss_incomingReady()));
-	connect(&d->serv, SIGNAL(incomingUDP(const QString &, int, const QHostAddress &, int, const QByteArray &)), SLOT(ss_incomingUDP(const QString &, int, const QHostAddress &, int, const QByteArray &)));
+	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 &)));
 }
 
 S5BServer::~S5BServer()
@@ -2082,12 +2082,12 @@ void S5BServer::stop()
 	d->serv.stop();
 }
 
-void S5BServer::setHostList(const QStringList &list)
+void S5BServer::setHostList(const TQStringList &list)
 {
 	d->hostList = list;
 }
 
-QStringList S5BServer::hostList() const
+TQStringList S5BServer::hostList() const
 {
 	return d->hostList;
 }
@@ -2103,16 +2103,16 @@ 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, SIGNAL(result(bool)), SLOT(item_result(bool)));
+	connect(i, TQT_SIGNAL(result(bool)), TQT_SLOT(item_result(bool)));
 	d->itemList.append(i);
 }
 
-void S5BServer::ss_incomingUDP(const QString &host, int port, const QHostAddress &addr, int sourcePort, const QByteArray &data)
+void S5BServer::ss_incomingUDP(const TQString &host, int port, const TQHostAddress &addr, int sourcePort, const TQByteArray &data)
 {
 	if(port != 0 || port != 1)
 		return;
 
-	QPtrListIterator<S5BManager> it(d->manList);
+	TQPtrListIterator<S5BManager> it(d->manList);
 	for(S5BManager *m; (m = it.current()); ++it) {
 		if(m->srv_ownsHash(host)) {
 			m->srv_incomingUDP(port == 1 ? true : false, addr, sourcePort, host, data);
@@ -2134,11 +2134,11 @@ void S5BServer::item_result(bool b)
 
 	SocksClient *c = i->client;
 	i->client = 0;
-	QString key = i->host;
+	TQString key = i->host;
 	d->itemList.removeRef(i);
 
 	// find the appropriate manager for this incoming connection
-	QPtrListIterator<S5BManager> it(d->manList);
+	TQPtrListIterator<S5BManager> it(d->manList);
 	for(S5BManager *m; (m = it.current()); ++it) {
 		if(m->srv_ownsHash(key)) {
 			m->srv_incomingReady(c, key);
@@ -2162,18 +2162,18 @@ void S5BServer::unlink(S5BManager *m)
 
 void S5BServer::unlinkAll()
 {
-	QPtrListIterator<S5BManager> it(d->manList);
+	TQPtrListIterator<S5BManager> it(d->manList);
 	for(S5BManager *m; (m = it.current()); ++it)
 		m->srv_unlink();
 	d->manList.clear();
 }
 
-const QPtrList<S5BManager> & S5BServer::managerList() const
+const TQPtrList<S5BManager> & S5BServer::managerList() const
 {
 	return d->manList;
 }
 
-void S5BServer::writeUDP(const QHostAddress &addr, int port, const QByteArray &data)
+void S5BServer::writeUDP(const TQHostAddress &addr, int port, const TQByteArray &data)
 {
 	d->serv.writeUDP(addr, port, data);
 }
@@ -2184,12 +2184,12 @@ void S5BServer::writeUDP(const QHostAddress &addr, int port, const QByteArray &d
 class JT_S5B::Private
 {
 public:
-	QDomElement iq;
+	TQDomElement iq;
 	Jid to;
 	Jid streamHost;
 	StreamHost proxyInfo;
 	int mode;
-	QTimer t;
+	TQTimer t;
 };
 
 JT_S5B::JT_S5B(Task *parent)
@@ -2197,7 +2197,7 @@ JT_S5B::JT_S5B(Task *parent)
 {
 	d = new Private;
 	d->mode = -1;
-	connect(&d->t, SIGNAL(timeout()), SLOT(t_timeout()));
+	connect(&d->t, TQT_SIGNAL(timeout()), TQT_SLOT(t_timeout()));
 }
 
 JT_S5B::~JT_S5B()
@@ -2205,32 +2205,32 @@ JT_S5B::~JT_S5B()
 	delete d;
 }
 
-void JT_S5B::request(const Jid &to, const QString &sid, const StreamHostList &hosts, bool fast, bool udp)
+void JT_S5B::request(const Jid &to, const TQString &sid, const StreamHostList &hosts, bool fast, bool udp)
 {
 	d->mode = 0;
 
-	QDomElement iq;
+	TQDomElement iq;
 	d->to = to;
 	iq = createIQ(doc(), "set", to.full(), id());
-	QDomElement query = doc()->createElement("query");
+	TQDomElement query = doc()->createElement("query");
 	query.setAttribute("xmlns", "http://jabber.org/protocol/bytestreams");
 	query.setAttribute("sid", sid);
 	query.setAttribute("mode", udp ? "udp" : "tcp" );
 	iq.appendChild(query);
 	for(StreamHostList::ConstIterator it = hosts.begin(); it != hosts.end(); ++it) {
-		QDomElement shost = doc()->createElement("streamhost");
+		TQDomElement shost = doc()->createElement("streamhost");
 		shost.setAttribute("jid", (*it).jid().full());
 		shost.setAttribute("host", (*it).host());
-		shost.setAttribute("port", QString::number((*it).port()));
+		shost.setAttribute("port", TQString::number((*it).port()));
 		if((*it).isProxy()) {
-			QDomElement p = doc()->createElement("proxy");
+			TQDomElement p = doc()->createElement("proxy");
 			p.setAttribute("xmlns", "http://affinix.com/jabber/stream");
 			shost.appendChild(p);
 		}
 		query.appendChild(shost);
 	}
 	if(fast) {
-		QDomElement e = doc()->createElement("fast");
+		TQDomElement e = doc()->createElement("fast");
 		e.setAttribute("xmlns", "http://affinix.com/jabber/stream");
 		query.appendChild(e);
 	}
@@ -2241,27 +2241,27 @@ void JT_S5B::requestProxyInfo(const Jid &to)
 {
 	d->mode = 1;
 
-	QDomElement iq;
+	TQDomElement iq;
 	d->to = to;
 	iq = createIQ(doc(), "get", to.full(), id());
-	QDomElement query = doc()->createElement("query");
+	TQDomElement query = doc()->createElement("query");
 	query.setAttribute("xmlns", "http://jabber.org/protocol/bytestreams");
 	iq.appendChild(query);
 	d->iq = iq;
 }
 
-void JT_S5B::requestActivation(const Jid &to, const QString &sid, const Jid &target)
+void JT_S5B::requestActivation(const Jid &to, const TQString &sid, const Jid &target)
 {
 	d->mode = 2;
 
-	QDomElement iq;
+	TQDomElement iq;
 	d->to = to;
 	iq = createIQ(doc(), "set", to.full(), id());
-	QDomElement query = doc()->createElement("query");
+	TQDomElement query = doc()->createElement("query");
 	query.setAttribute("xmlns", "http://jabber.org/protocol/bytestreams");
 	query.setAttribute("sid", sid);
 	iq.appendChild(query);
-	QDomElement act = doc()->createElement("activate");
+	TQDomElement act = doc()->createElement("activate");
 	act.appendChild(doc()->createTextNode(target.full()));
 	query.appendChild(act);
 	d->iq = iq;
@@ -2279,7 +2279,7 @@ void JT_S5B::onDisconnect()
 	d->t.stop();
 }
 
-bool JT_S5B::take(const QDomElement &x)
+bool JT_S5B::take(const TQDomElement &x)
 {
 	if(d->mode == -1)
 		return false;
@@ -2290,11 +2290,11 @@ bool JT_S5B::take(const QDomElement &x)
 	d->t.stop();
 
 	if(x.attribute("type") == "result") {
-		QDomElement q = queryTag(x);
+		TQDomElement q = queryTag(x);
 		if(d->mode == 0) {
 			d->streamHost = "";
 			if(!q.isNull()) {
-				QDomElement shost = q.elementsByTagName("streamhost-used").item(0).toElement();
+				TQDomElement shost = q.elementsByTagName("streamhost-used").item(0).toElement();
 				if(!shost.isNull())
 					d->streamHost = shost.attribute("jid");
 			}
@@ -2303,11 +2303,11 @@ bool JT_S5B::take(const QDomElement &x)
 		}
 		else if(d->mode == 1) {
 			if(!q.isNull()) {
-				QDomElement shost = q.elementsByTagName("streamhost").item(0).toElement();
+				TQDomElement shost = q.elementsByTagName("streamhost").item(0).toElement();
 				if(!shost.isNull()) {
 					Jid j = shost.attribute("jid");
 					if(j.isValid()) {
-						QString host = shost.attribute("host");
+						TQString host = shost.attribute("host");
 						if(!host.isEmpty()) {
 							int port = shost.attribute("port").toInt();
 							StreamHost h;
@@ -2367,11 +2367,11 @@ int JT_PushS5B::priority() const
 	return 1;
 }
 
-bool JT_PushS5B::take(const QDomElement &e)
+bool JT_PushS5B::take(const TQDomElement &e)
 {
 	// look for udpsuccess
 	if(e.tagName() == "message") {
-		QDomElement x = e.elementsByTagName("udpsuccess").item(0).toElement();
+		TQDomElement x = e.elementsByTagName("udpsuccess").item(0).toElement();
 		if(!x.isNull() && x.attribute("xmlns") == "http://jabber.org/protocol/bytestreams") {
 			incomingUDPSuccess(Jid(x.attribute("from")), x.attribute("dstaddr"));
 			return true;
@@ -2393,22 +2393,22 @@ bool JT_PushS5B::take(const QDomElement &e)
 		return false;
 
 	Jid from(e.attribute("from"));
-	QDomElement q = queryTag(e);
-	QString sid = q.attribute("sid");
+	TQDomElement q = queryTag(e);
+	TQString sid = q.attribute("sid");
 
 	StreamHostList hosts;
-	QDomNodeList nl = q.elementsByTagName("streamhost");
+	TQDomNodeList nl = q.elementsByTagName("streamhost");
 	for(uint n = 0; n < nl.count(); ++n) {
-		QDomElement shost = nl.item(n).toElement();
+		TQDomElement shost = nl.item(n).toElement();
 		if(hosts.count() < MAXSTREAMHOSTS) {
 			Jid j = shost.attribute("jid");
 			if(!j.isValid())
 				continue;
-			QString host = shost.attribute("host");
+			TQString host = shost.attribute("host");
 			if(host.isEmpty())
 				continue;
 			int port = shost.attribute("port").toInt();
-			QDomElement p = shost.elementsByTagName("proxy").item(0).toElement();
+			TQDomElement p = shost.elementsByTagName("proxy").item(0).toElement();
 			bool isProxy = false;
 			if(!p.isNull() && p.attribute("xmlns") == "http://affinix.com/jabber/stream")
 				isProxy = true;
@@ -2423,7 +2423,7 @@ bool JT_PushS5B::take(const QDomElement &e)
 	}
 
 	bool fast = false;
-	QDomElement t;
+	TQDomElement t;
 	t = q.elementsByTagName("fast").item(0).toElement();
 	if(!t.isNull() && t.attribute("xmlns") == "http://affinix.com/jabber/stream")
 		fast = true;
@@ -2440,43 +2440,43 @@ bool JT_PushS5B::take(const QDomElement &e)
 	return true;
 }
 
-void JT_PushS5B::respondSuccess(const Jid &to, const QString &id, const Jid &streamHost)
+void JT_PushS5B::respondSuccess(const Jid &to, const TQString &id, const Jid &streamHost)
 {
-	QDomElement iq = createIQ(doc(), "result", to.full(), id);
-	QDomElement query = doc()->createElement("query");
+	TQDomElement iq = createIQ(doc(), "result", to.full(), id);
+	TQDomElement query = doc()->createElement("query");
 	query.setAttribute("xmlns", "http://jabber.org/protocol/bytestreams");
 	iq.appendChild(query);
-	QDomElement shost = doc()->createElement("streamhost-used");
+	TQDomElement shost = doc()->createElement("streamhost-used");
 	shost.setAttribute("jid", streamHost.full());
 	query.appendChild(shost);
 	send(iq);
 }
 
-void JT_PushS5B::respondError(const Jid &to, const QString &id, int code, const QString &str)
+void JT_PushS5B::respondError(const Jid &to, const TQString &id, int code, const TQString &str)
 {
-	QDomElement iq = createIQ(doc(), "error", to.full(), id);
-	QDomElement err = textTag(doc(), "error", str);
-	err.setAttribute("code", QString::number(code));
+	TQDomElement iq = createIQ(doc(), "error", to.full(), id);
+	TQDomElement err = textTag(doc(), "error", str);
+	err.setAttribute("code", TQString::number(code));
 	iq.appendChild(err);
 	send(iq);
 }
 
-void JT_PushS5B::sendUDPSuccess(const Jid &to, const QString &dstaddr)
+void JT_PushS5B::sendUDPSuccess(const Jid &to, const TQString &dstaddr)
 {
-	QDomElement m = doc()->createElement("message");
+	TQDomElement m = doc()->createElement("message");
 	m.setAttribute("to", to.full());
-	QDomElement u = doc()->createElement("udpsuccess");
+	TQDomElement u = doc()->createElement("udpsuccess");
 	u.setAttribute("xmlns", "http://jabber.org/protocol/bytestreams");
 	u.setAttribute("dstaddr", dstaddr);
 	m.appendChild(u);
 	send(m);
 }
 
-void JT_PushS5B::sendActivate(const Jid &to, const QString &sid, const Jid &streamHost)
+void JT_PushS5B::sendActivate(const Jid &to, const TQString &sid, const Jid &streamHost)
 {
-	QDomElement m = doc()->createElement("message");
+	TQDomElement m = doc()->createElement("message");
 	m.setAttribute("to", to.full());
-	QDomElement act = doc()->createElement("activate");
+	TQDomElement act = doc()->createElement("activate");
 	act.setAttribute("xmlns", "http://affinix.com/jabber/stream");
 	act.setAttribute("sid", sid);
 	act.setAttribute("jid", streamHost.full());
@@ -2498,7 +2498,7 @@ const Jid & StreamHost::jid() const
 	return j;
 }
 
-const QString & StreamHost::host() const
+const TQString & StreamHost::host() const
 {
 	return v_host;
 }
@@ -2518,7 +2518,7 @@ void StreamHost::setJid(const Jid &_j)
 	j = _j;
 }
 
-void StreamHost::setHost(const QString &host)
+void StreamHost::setHost(const TQString &host)
 {
 	v_host = host;
 }