Trinity Qt initial conversion

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

84 files changed, 1059 insertions, 1059 deletions

diff --git a/kopete/protocols/yahoo/libkyahoo/bytestream.cpp b/kopete/protocols/yahoo/libkyahoo/bytestream.cpp
index ad299bf8..8ca3a4cd 100644
--- a/kopete/protocols/yahoo/libkyahoo/bytestream.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/bytestream.cpp
@@ -36,7 +36,7 @@
 //!
 //! The signals connectionClosed(), delayedCloseFinished(), readyRead(),
 //! bytesWritten(), and error() serve the exact same function as those from
-//! <A HREF="http://doc.trolltech.com/3.1/qsocket.html">QSocket</A>.
+//! <A HREF="http://doc.trolltech.com/3.1/tqsocket.html">TQSocket</A>.
 //!
 //! The simplest way to create a ByteStream is to reimplement isOpen(), close(),
 //! and tryWrite().  Call appendRead() whenever you want to make data available for
@@ -60,13 +60,13 @@ class ByteStream::Private
 public:
 	Private() {}
 
-	QByteArray readBuf, writeBuf;
+	TQByteArray readBuf, writeBuf;
 };
 
 //!
 //! Constructs a ByteStream object with parent \a parent.
-ByteStream::ByteStream(QObject *parent)
-:QObject(parent)
+ByteStream::ByteStream(TQObject *parent)
+:TQObject(parent)
 {
 // 	kdDebug(14181) << k_funcinfo << endl;
 	d = new Private;
@@ -97,7 +97,7 @@ void ByteStream::close()
 
 //!
 //! Writes array \a a to the stream.
-void ByteStream::write(const QByteArray &a)
+void ByteStream::write(const TQByteArray &a)
 {
 // 	kdDebug(14181) << k_funcinfo << "[data size: " << a.size() << "]" << endl;
 	
@@ -115,7 +115,7 @@ void ByteStream::write(const QByteArray &a)
 //!
 //! Reads bytes \a bytes of data from the stream and returns them as an array.  If \a bytes is 0, then
 //! \a read will return all available data.
-QByteArray ByteStream::read(int bytes)
+TQByteArray ByteStream::read(int bytes)
 {
 // 	kdDebug(14181) << k_funcinfo << " " << bytes <<" [bytes]"<< endl;
 	return takeRead(bytes);
@@ -138,11 +138,11 @@ int ByteStream::bytesToWrite() const
 
 //!
 //! Writes string \a cs to the stream.
-void ByteStream::write(const QCString &cs)
+void ByteStream::write(const TQCString &cs)
 {
 // 	kdDebug(14181) << k_funcinfo << "[data size: " << cs.length() << "]" << endl;
 	
-	QByteArray block(cs.length());
+	TQByteArray block(cs.length());
 	memcpy(block.data(), cs.data(), block.size());
 	write(block);
 }
@@ -163,7 +163,7 @@ void ByteStream::clearWriteBuffer()
 
 //!
 //! Appends \a block to the end of the read buffer.
-void ByteStream::appendRead(const QByteArray &block)
+void ByteStream::appendRead(const TQByteArray &block)
 {
 // 	kdDebug(14181) << k_funcinfo << endl;
 	appendArray(&d->readBuf, block);
@@ -171,7 +171,7 @@ void ByteStream::appendRead(const QByteArray &block)
 
 //!
 //! Appends \a block to the end of the write buffer.
-void ByteStream::appendWrite(const QByteArray &block)
+void ByteStream::appendWrite(const TQByteArray &block)
 {
 // 	kdDebug(14181) << k_funcinfo << "[data size: " << block.size() << "]" << endl;
 	
@@ -182,7 +182,7 @@ void ByteStream::appendWrite(const QByteArray &block)
 //! Returns \a size bytes from the start of the read buffer.
 //! If \a size is 0, then all available data will be returned.
 //! If \a del is TRUE, then the bytes are also removed.
-QByteArray ByteStream::takeRead(int size, bool del)
+TQByteArray ByteStream::takeRead(int size, bool del)
 {
 // 	kdDebug(14181) << k_funcinfo << "[data size: " << size << "][ delete :" << del << " ]" << endl;
 	return takeArray(&d->readBuf, size, del);
@@ -192,7 +192,7 @@ QByteArray ByteStream::takeRead(int size, bool del)
 //! Returns \a size bytes from the start of the write buffer.
 //! If \a size is 0, then all available data will be returned.
 //! If \a del is TRUE, then the bytes are also removed.
-QByteArray ByteStream::takeWrite(int size, bool del)
+TQByteArray ByteStream::takeWrite(int size, bool del)
 {
 // 	kdDebug(14181) << k_funcinfo << "[data size: " << size << "][ delete :" << del << " ]" << endl;
 	return takeArray(&d->writeBuf, size, del);
@@ -200,14 +200,14 @@ QByteArray ByteStream::takeWrite(int size, bool del)
 
 //!
 //! Returns a reference to the read buffer.
-QByteArray & ByteStream::readBuf()
+TQByteArray & ByteStream::readBuf()
 {
 	return d->readBuf;
 }
 
 //!
 //! Returns a reference to the write buffer.
-QByteArray & ByteStream::writeBuf()
+TQByteArray & ByteStream::writeBuf()
 {
 // 	kdDebug(14181) << k_funcinfo << endl;
 	return d->writeBuf;
@@ -224,7 +224,7 @@ int ByteStream::tryWrite()
 
 //!
 //! Append array \a b to the end of the array pointed to by \a a.
-void ByteStream::appendArray(QByteArray *a, const QByteArray &b)
+void ByteStream::appendArray(TQByteArray *a, const TQByteArray &b)
 {
 // 	kdDebug(14181) << k_funcinfo << endl;
 	int oldsize = a->size();
@@ -236,11 +236,11 @@ void ByteStream::appendArray(QByteArray *a, const QByteArray &b)
 //! Returns \a size bytes from the start of the array pointed to by \a from.
 //! If \a size is 0, then all available data will be returned.
 //! If \a del is TRUE, then the bytes are also removed.
-QByteArray ByteStream::takeArray(QByteArray *from, int size, bool del)
+TQByteArray ByteStream::takeArray(TQByteArray *from, int size, bool del)
 {
 // 	kdDebug(14181) << k_funcinfo << "[int size] : " << size << " [bool del] " << del << endl;
 	
-	QByteArray a;
+	TQByteArray a;
 	if(size == 0) {
 		a = from->copy();
 		if(del)
diff --git a/kopete/protocols/yahoo/libkyahoo/bytestream.h b/kopete/protocols/yahoo/libkyahoo/bytestream.h
index 1c2dfa15..a990a940 100644
--- a/kopete/protocols/yahoo/libkyahoo/bytestream.h
+++ b/kopete/protocols/yahoo/libkyahoo/bytestream.h
@@ -21,8 +21,8 @@
 #ifndef CS_BYTESTREAM_H
 #define CS_BYTESTREAM_H
 
-#include <qobject.h>
-#include <qcstring.h>
+#include <tqobject.h>
+#include <tqcstring.h>
 
 // CS_NAMESPACE_BEGIN
 
@@ -32,20 +32,20 @@ class ByteStream : public QObject
 	Q_OBJECT
 public:
 	enum Error { ErrRead, ErrWrite, ErrCustom = 10 };
-	ByteStream(QObject *parent=0);
+	ByteStream(TQObject *parent=0);
 	virtual ~ByteStream()=0;
 
 	virtual bool isOpen() const;
 	virtual void close();
-	virtual void write(const QByteArray &);
-	virtual QByteArray read(int bytes=0);
+	virtual void write(const TQByteArray &);
+	virtual TQByteArray read(int bytes=0);
 	virtual int bytesAvailable() const;
 	virtual int bytesToWrite() const;
 
-	void write(const QCString &);
+	void write(const TQCString &);
 
-	static void appendArray(QByteArray *a, const QByteArray &b);
-	static QByteArray takeArray(QByteArray *from, int size=0, bool del=true);
+	static void appendArray(TQByteArray *a, const TQByteArray &b);
+	static TQByteArray takeArray(TQByteArray *from, int size=0, bool del=true);
 
 signals:
 	void connectionClosed();
@@ -57,12 +57,12 @@ signals:
 protected:
 	void clearReadBuffer();
 	void clearWriteBuffer();
-	void appendRead(const QByteArray &);
-	void appendWrite(const QByteArray &);
-	QByteArray takeRead(int size=0, bool del=true);
-	QByteArray takeWrite(int size=0, bool del=true);
-	QByteArray & readBuf();
-	QByteArray & writeBuf();
+	void appendRead(const TQByteArray &);
+	void appendWrite(const TQByteArray &);
+	TQByteArray takeRead(int size=0, bool del=true);
+	TQByteArray takeWrite(int size=0, bool del=true);
+	TQByteArray & readBuf();
+	TQByteArray & writeBuf();
 	virtual int tryWrite();
 
 private:
diff --git a/kopete/protocols/yahoo/libkyahoo/changestatustask.cpp b/kopete/protocols/yahoo/libkyahoo/changestatustask.cpp
index 3d73920c..1943aa6b 100644
--- a/kopete/protocols/yahoo/libkyahoo/changestatustask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/changestatustask.cpp
@@ -69,7 +69,7 @@ void ChangeStatusTask::sendVisibility( Visibility visible )
 	send( t );
 }
 
-void ChangeStatusTask::setMessage( const QString &msg )
+void ChangeStatusTask::setMessage( const TQString &msg )
 {
 	m_message = msg;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/changestatustask.h b/kopete/protocols/yahoo/libkyahoo/changestatustask.h
index 22c48031..a70007df 100644
--- a/kopete/protocols/yahoo/libkyahoo/changestatustask.h
+++ b/kopete/protocols/yahoo/libkyahoo/changestatustask.h
@@ -35,12 +35,12 @@ public:
 
 	virtual void onGo();
 
-	void setMessage( const QString &msg );
+	void setMessage( const TQString &msg );
 	void setStatus( Yahoo::Status status );
 	void setType( Yahoo::StatusType type );
 private:
 	enum Visibility { Visible = 1, Invisible = 2 };
-	QString m_message;
+	TQString m_message;
 	Yahoo::Status m_status;
 	Yahoo::StatusType m_type;
 
diff --git a/kopete/protocols/yahoo/libkyahoo/chatsessiontask.cpp b/kopete/protocols/yahoo/libkyahoo/chatsessiontask.cpp
index cacd7f80..3be83a79 100644
--- a/kopete/protocols/yahoo/libkyahoo/chatsessiontask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/chatsessiontask.cpp
@@ -21,7 +21,7 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
+#include <tqstring.h>
 #include <kdebug.h>
 
 ChatSessionTask::ChatSessionTask(Task* parent) : Task(parent)
@@ -55,7 +55,7 @@ void ChatSessionTask::onGo()
 	setSuccess();
 }
 
-void ChatSessionTask::setTarget( const QString &to )
+void ChatSessionTask::setTarget( const TQString &to )
 {
 	m_target = to;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/chatsessiontask.h b/kopete/protocols/yahoo/libkyahoo/chatsessiontask.h
index 964ff411..fc5e02ce 100644
--- a/kopete/protocols/yahoo/libkyahoo/chatsessiontask.h
+++ b/kopete/protocols/yahoo/libkyahoo/chatsessiontask.h
@@ -35,10 +35,10 @@ public:
 	
 	virtual void onGo();
 	
-	void setTarget( const QString &to );
+	void setTarget( const TQString &to );
 	void setType( Type type );
 private:
-	QString m_target;
+	TQString m_target;
 	Type m_type;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/client.cpp b/kopete/protocols/yahoo/libkyahoo/client.cpp
index 710da771..d2a4b8dd 100644
--- a/kopete/protocols/yahoo/libkyahoo/client.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/client.cpp
@@ -19,8 +19,8 @@
     *************************************************************************
 */
 
-#include <qtimer.h>
-#include <qpixmap.h>
+#include <tqtimer.h>
+#include <tqpixmap.h>
 
 #include <kdebug.h>
 #include <ksocketbase.h>
@@ -67,13 +67,13 @@ public:
 	ClientStream *stream;
 	int id_seed;
 	Task *root;
-	QString host, user, pass;
+	TQString host, user, pass;
 	uint port;
 	bool active;
 	YahooBuddyIconLoader *iconLoader;
 	int error;
-	QString errorString;
-	QString errorInformation;
+	TQString errorString;
+	TQString errorInformation;
 
 	// tasks
 	bool tasksInitialized;
@@ -92,19 +92,19 @@ public:
 
 	// Connection data
 	uint sessionID;
-	QString yCookie;
-	QString tCookie;
-	QString cCookie;
+	TQString yCookie;
+	TQString tCookie;
+	TQString cCookie;
 	Yahoo::Status status;
 	Yahoo::Status statusOnConnect;
-	QString statusMessageOnConnect;
+	TQString statusMessageOnConnect;
 	Yahoo::PictureStatus pictureFlag;
 	int pictureChecksum;
 	bool buddyListReady;
-	QStringList pictureRequestQueue;
+	TQStringList pictureRequestQueue;
 };
 
-Client::Client(QObject *par) :QObject(par, "yahooclient")
+Client::Client(TQObject *par) :TQObject(par, "yahooclient")
 {
 	d = new ClientPrivate;
 /*	d->tzoffset = 0;*/
@@ -122,18 +122,18 @@ Client::Client(QObject *par) :QObject(par, "yahooclient")
 	d->buddyListReady = false;
 	m_connector = 0L;
 
-	m_pingTimer = new QTimer( this );
-	QObject::connect( m_pingTimer, SIGNAL( timeout() ), this, SLOT( sendPing() ) );
+	m_pingTimer = new TQTimer( this );
+	TQObject::connect( m_pingTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( sendPing() ) );
 
-	QObject::connect( d->loginTask, SIGNAL( haveSessionID( uint ) ), SLOT( lt_gotSessionID( uint ) ) );
-	QObject::connect( d->loginTask, SIGNAL( buddyListReady() ), SLOT( processPictureQueue() ) );
-	QObject::connect( d->loginTask, SIGNAL( loginResponse( int, const QString& ) ),
-				SLOT( slotLoginResponse( int, const QString& ) ) );
-	QObject::connect( d->loginTask, SIGNAL( haveCookies() ), SLOT( slotGotCookies() ) );
-	QObject::connect( d->listTask, SIGNAL( gotBuddy(const QString &, const QString &, const QString &) ),
-					SIGNAL( gotBuddy(const QString &, const QString &, const QString &) ) );
-	QObject::connect( d->listTask, SIGNAL( stealthStatusChanged( const QString&, Yahoo::StealthStatus ) ),
-					SIGNAL( stealthStatusChanged( const QString&, Yahoo::StealthStatus ) ) );
+	TQObject::connect( d->loginTask, TQT_SIGNAL( haveSessionID( uint ) ), TQT_SLOT( lt_gotSessionID( uint ) ) );
+	TQObject::connect( d->loginTask, TQT_SIGNAL( buddyListReady() ), TQT_SLOT( processPictureQueue() ) );
+	TQObject::connect( d->loginTask, TQT_SIGNAL( loginResponse( int, const TQString& ) ),
+				TQT_SLOT( slotLoginResponse( int, const TQString& ) ) );
+	TQObject::connect( d->loginTask, TQT_SIGNAL( haveCookies() ), TQT_SLOT( slotGotCookies() ) );
+	TQObject::connect( d->listTask, TQT_SIGNAL( gotBuddy(const TQString &, const TQString &, const TQString &) ),
+					TQT_SIGNAL( gotBuddy(const TQString &, const TQString &, const TQString &) ) );
+	TQObject::connect( d->listTask, TQT_SIGNAL( stealthStatusChanged( const TQString&, Yahoo::StealthStatus ) ),
+					TQT_SIGNAL( stealthStatusChanged( const TQString&, Yahoo::StealthStatus ) ) );
 }
 
 Client::~Client()
@@ -144,7 +144,7 @@ Client::~Client()
 	delete d;
 }
 
-void Client::connect( const QString &host, const uint port, const QString &userId, const QString &pass )
+void Client::connect( const TQString &host, const uint port, const TQString &userId, const TQString &pass )
 {
 	kdDebug(YAHOO_GEN_DEBUG) << k_funcinfo << endl;
 	d->host = host;
@@ -156,10 +156,10 @@ void Client::connect( const QString &host, const uint port, const QString &userI
 	m_connector = new KNetworkConnector;
 	m_connector->setOptHostPort( host, port );
 	d->stream = new ClientStream( m_connector, this );
-	QObject::connect( d->stream, SIGNAL( connected() ), this, SLOT( cs_connected() ) );
-	QObject::connect( d->stream, SIGNAL( error(int) ), this, SLOT( streamError(int) ) );
-	QObject::connect( d->stream, SIGNAL( readyRead() ), this, SLOT( streamReadyRead() ) );
-	QObject::connect( d->stream, SIGNAL( connectionClosed() ), this, SLOT( streamDisconnected() ) );
+	TQObject::connect( d->stream, TQT_SIGNAL( connected() ), this, TQT_SLOT( cs_connected() ) );
+	TQObject::connect( d->stream, TQT_SIGNAL( error(int) ), this, TQT_SLOT( streamError(int) ) );
+	TQObject::connect( d->stream, TQT_SIGNAL( readyRead() ), this, TQT_SLOT( streamReadyRead() ) );
+	TQObject::connect( d->stream, TQT_SIGNAL( connectionClosed() ), this, TQT_SLOT( streamDisconnected() ) );
 
 	d->stream->connectToServer( host, false );
 }
@@ -193,7 +193,7 @@ void Client::close()
 		deleteTasks();
 	d->loginTask->reset();
 	if( d->stream ) {
-		QObject::disconnect( d->stream, SIGNAL( readyRead() ), this, SLOT( streamReadyRead() ) );
+		TQObject::disconnect( d->stream, TQT_SIGNAL( readyRead() ), this, TQT_SLOT( streamReadyRead() ) );
 		d->stream->deleteLater();
 	}
 	d->stream = 0L;
@@ -209,12 +209,12 @@ int Client::error()
 	return d->error;
 }
 
-QString Client::errorString()
+TQString Client::errorString()
 {
 	return d->errorString;
 }
 
-QString Client::errorInformation()
+TQString Client::errorInformation()
 {
 	return d->errorInformation;
 }
@@ -223,7 +223,7 @@ QString Client::errorInformation()
 void Client::streamError( int error )
 {
 	kdDebug(YAHOO_RAW_DEBUG) << "CLIENT ERROR (Error " <<  error << ")" << endl;
-	QString msg;
+	TQString msg;
 
 	d->active = false;
 
@@ -265,7 +265,7 @@ void Client::lt_loginFinished()
 	slotLoginResponse( d->loginTask->statusCode(), d->loginTask->statusString() );
 }
 
-void Client::slotLoginResponse( int response, const QString &msg )
+void Client::slotLoginResponse( int response, const TQString &msg )
 {
 	if( response == Yahoo::LoginOk )
 	{
@@ -273,7 +273,7 @@ void Client::slotLoginResponse( int response, const QString &msg )
 				d->statusOnConnect == Yahoo::StatusInvisible) ||
 				!d->statusMessageOnConnect.isEmpty() )
 			changeStatus( d->statusOnConnect, d->statusMessageOnConnect, Yahoo::StatusTypeAway );
-		d->statusMessageOnConnect = QString::null;
+		d->statusMessageOnConnect = TQString::null;
 		setStatus( d->statusOnConnect );
 		/* only send a ping every hour. we get disconnected otherwise */
 		m_pingTimer->start( 60 * 60 * 1000 );
@@ -306,7 +306,7 @@ void Client::slotGotCookies()
 // INTERNALS //
 
 // ***** Messaging handling *****
-void Client::sendTyping( const QString &who, bool typing )
+void Client::sendTyping( const TQString &who, bool typing )
 {
 	SendNotifyTask *snt = new SendNotifyTask( d->root );
 	snt->setTarget( who );
@@ -315,7 +315,7 @@ void Client::sendTyping( const QString &who, bool typing )
 	snt->go( true );
 }
 
-void Client::sendWebcamInvite( const QString &who )
+void Client::sendWebcamInvite( const TQString &who )
 {
 	if( !d->webcamTask->transmitting() )
 		d->webcamTask->registerWebcam();
@@ -323,7 +323,7 @@ void Client::sendWebcamInvite( const QString &who )
 	d->webcamTask->addPendingInvitation( who );
 }
 
-void Client::sendMessage( const QString &to, const QString &msg )
+void Client::sendMessage( const TQString &to, const TQString &msg )
 {
 	SendMessageTask *smt = new SendMessageTask( d->root );
 	smt->setTarget( to );
@@ -332,7 +332,7 @@ void Client::sendMessage( const QString &to, const QString &msg )
 	smt->go( true );
 }
 
-void Client::setChatSessionState( const QString &to, bool close )
+void Client::setChatSessionState( const TQString &to, bool close )
 {
 	ChatSessionTask *cst = new ChatSessionTask( d->root );
 	cst->setTarget( to );
@@ -340,24 +340,24 @@ void Client::setChatSessionState( const QString &to, bool close )
 	cst->go( true );
 }
 
-void Client::sendBuzz( const QString &to )
+void Client::sendBuzz( const TQString &to )
 {
 	SendMessageTask *smt = new SendMessageTask( d->root );
 	smt->setTarget( to );
-	smt->setText( QString::fromLatin1( "<ding>" ) );
+	smt->setText( TQString::fromLatin1( "<ding>" ) );
 	smt->setPicureFlag( pictureFlag() );
 	smt->go( true );
 }
 
-void Client::sendFile( unsigned int transferId, const QString &to, const QString &msg, KURL url )
+void Client::sendFile( unsigned int transferId, const TQString &to, const TQString &msg, KURL url )
 {
 	SendFileTask *sft = new SendFileTask( d->root );
 
-	QObject::connect( sft, SIGNAL(complete(unsigned int)), SIGNAL(fileTransferComplete(unsigned int)) );
-	QObject::connect( sft, SIGNAL(bytesProcessed(unsigned int, unsigned int)), SIGNAL(fileTransferBytesProcessed(unsigned int, unsigned int)) );
-	QObject::connect( sft, SIGNAL(error(unsigned int, int, const QString &)), SIGNAL(fileTransferError(unsigned int, int, const QString &)) );
+	TQObject::connect( sft, TQT_SIGNAL(complete(unsigned int)), TQT_SIGNAL(fileTransferComplete(unsigned int)) );
+	TQObject::connect( sft, TQT_SIGNAL(bytesProcessed(unsigned int, unsigned int)), TQT_SIGNAL(fileTransferBytesProcessed(unsigned int, unsigned int)) );
+	TQObject::connect( sft, TQT_SIGNAL(error(unsigned int, int, const TQString &)), TQT_SIGNAL(fileTransferError(unsigned int, int, const TQString &)) );
 
-	QObject::connect( this, SIGNAL(fileTransferCanceled( unsigned int )), sft, SLOT(canceled( unsigned int )) );
+	TQObject::connect( this, TQT_SIGNAL(fileTransferCanceled( unsigned int )), sft, TQT_SLOT(canceled( unsigned int )) );
 
 	sft->setTarget( to );
 	sft->setMessage( msg );
@@ -366,14 +366,14 @@ void Client::sendFile( unsigned int transferId, const QString &to, const QString
 	sft->go( true );
 }
 
-void Client::receiveFile( unsigned int transferId, const QString &userId, KURL remoteURL, KURL localURL )
+void Client::receiveFile( unsigned int transferId, const TQString &userId, KURL remoteURL, KURL localURL )
 {
 	ReceiveFileTask *rft = new ReceiveFileTask( d->root );
 
-	QObject::connect( rft, SIGNAL(complete(unsigned int)), SIGNAL(fileTransferComplete(unsigned int)) );
-	QObject::connect( rft, SIGNAL(bytesProcessed(unsigned int, unsigned int)), SIGNAL(fileTransferBytesProcessed(unsigned int, unsigned int)) );
-	QObject::connect( rft, SIGNAL(error(unsigned int, int, const QString &)), SIGNAL(fileTransferError(unsigned int, int, const QString &)) );
-	QObject::connect( this, SIGNAL(fileTransferCanceled( unsigned int )), rft, SLOT(canceled( unsigned int )) );
+	TQObject::connect( rft, TQT_SIGNAL(complete(unsigned int)), TQT_SIGNAL(fileTransferComplete(unsigned int)) );
+	TQObject::connect( rft, TQT_SIGNAL(bytesProcessed(unsigned int, unsigned int)), TQT_SIGNAL(fileTransferBytesProcessed(unsigned int, unsigned int)) );
+	TQObject::connect( rft, TQT_SIGNAL(error(unsigned int, int, const TQString &)), TQT_SIGNAL(fileTransferError(unsigned int, int, const TQString &)) );
+	TQObject::connect( this, TQT_SIGNAL(fileTransferCanceled( unsigned int )), rft, TQT_SLOT(canceled( unsigned int )) );
 
 	rft->setRemoteUrl( remoteURL );
 	rft->setLocalUrl( localURL );
@@ -386,7 +386,7 @@ void Client::receiveFile( unsigned int transferId, const QString &userId, KURL r
 	rft->go( true );
 }
 
-void Client::rejectFile( const QString &userId, KURL remoteURL )
+void Client::rejectFile( const TQString &userId, KURL remoteURL )
 {
 	if( remoteURL.url().startsWith( "http://" ) )
 		return;
@@ -404,7 +404,7 @@ void Client::cancelFileTransfer( unsigned int transferId )
 	emit fileTransferCanceled( transferId );
 }
 
-void Client::changeStatus( Yahoo::Status status, const QString &message, Yahoo::StatusType type )
+void Client::changeStatus( Yahoo::Status status, const TQString &message, Yahoo::StatusType type )
 {
 	kdDebug(YAHOO_RAW_DEBUG) << "status: " << status
 					<< " message: " << message
@@ -416,12 +416,12 @@ void Client::changeStatus( Yahoo::Status status, const QString &message, Yahoo::
 	cst->go( true );
 
 	if( status == Yahoo::StatusInvisible )
-		stealthContact( QString(), Yahoo::StealthOnline, Yahoo::StealthClear );
+		stealthContact( TQString(), Yahoo::StealthOnline, Yahoo::StealthClear );
 
 	setStatus( status );
 }
 
-void Client::sendAuthReply( const QString &userId, bool accept, const QString &msg )
+void Client::sendAuthReply( const TQString &userId, bool accept, const TQString &msg )
 {
 	SendAuthRespTask *sarp = new SendAuthRespTask( d->root );
 	sarp->setGranted( accept );
@@ -444,7 +444,7 @@ void Client::sendPing()
 
 // ***** Contactlist handling *****
 
-void Client::stealthContact(QString const &userId, Yahoo::StealthMode mode, Yahoo::StealthStatus state)
+void Client::stealthContact(TQString const &userId, Yahoo::StealthMode mode, Yahoo::StealthStatus state)
 {
 	StealthTask *st = new StealthTask( d->root );
 	st->setTarget( userId );
@@ -453,12 +453,12 @@ void Client::stealthContact(QString const &userId, Yahoo::StealthMode mode, Yaho
 	st->go( true );
 }
 
-void Client::addBuddy( const QString &userId, const QString &group, const QString &message )
+void Client::addBuddy( const TQString &userId, const TQString &group, const TQString &message )
 {
 	ModifyBuddyTask *mbt = new ModifyBuddyTask( d->root );
 
-	QObject::connect(mbt, SIGNAL(buddyAddResult( const QString &, const QString &, bool )),
-			 SIGNAL(buddyAddResult( const QString &, const QString &, bool)));
+	TQObject::connect(mbt, TQT_SIGNAL(buddyAddResult( const TQString &, const TQString &, bool )),
+			 TQT_SIGNAL(buddyAddResult( const TQString &, const TQString &, bool)));
 
 	mbt->setType( ModifyBuddyTask::AddBuddy );
 	mbt->setTarget( userId );
@@ -467,12 +467,12 @@ void Client::addBuddy( const QString &userId, const QString &group, const QStrin
 	mbt->go( true );
 }
 
-void Client::removeBuddy( const QString &userId, const QString &group )
+void Client::removeBuddy( const TQString &userId, const TQString &group )
 {
 	ModifyBuddyTask *mbt = new ModifyBuddyTask( d->root );
 
-	QObject::connect(mbt, SIGNAL(buddyRemoveResult( const QString &, const QString &, bool )),
-			 SIGNAL(buddyRemoveResult( const QString &, const QString &, bool)));
+	TQObject::connect(mbt, TQT_SIGNAL(buddyRemoveResult( const TQString &, const TQString &, bool )),
+			 TQT_SIGNAL(buddyRemoveResult( const TQString &, const TQString &, bool)));
 
 	mbt->setType( ModifyBuddyTask::RemoveBuddy );
 	mbt->setTarget( userId );
@@ -480,12 +480,12 @@ void Client::removeBuddy( const QString &userId, const QString &group )
 	mbt->go( true );
 }
 
-void Client::moveBuddy( const QString &userId, const QString &oldGroup, const QString &newGroup )
+void Client::moveBuddy( const TQString &userId, const TQString &oldGroup, const TQString &newGroup )
 {
 	ModifyBuddyTask *mbt = new ModifyBuddyTask( d->root );
 
-	QObject::connect(mbt, SIGNAL(buddyChangeGroupResult( const QString &, const QString &, bool )),
-			 SIGNAL(buddyChangeGroupResult( const QString &, const QString &, bool)));
+	TQObject::connect(mbt, TQT_SIGNAL(buddyChangeGroupResult( const TQString &, const TQString &, bool )),
+			 TQT_SIGNAL(buddyChangeGroupResult( const TQString &, const TQString &, bool)));
 
 	mbt->setType( ModifyBuddyTask::MoveBuddy );
 	mbt->setTarget( userId );
@@ -511,11 +511,11 @@ void Client::processPictureQueue()
 
 	if( !d->pictureRequestQueue.isEmpty() )
 	{
-		QTimer::singleShot( 1000, this, SLOT(processPictureQueue()) );
+		TQTimer::singleShot( 1000, this, TQT_SLOT(processPictureQueue()) );
 	}
 }
 
-void Client::requestPicture( const QString &userId )
+void Client::requestPicture( const TQString &userId )
 {
 	if( !d->buddyListReady )
 	{
@@ -528,16 +528,16 @@ void Client::requestPicture( const QString &userId )
 	rpt->go( true );
 }
 
-void Client::downloadPicture(  const QString &userId, KURL url, int checksum )
+void Client::downloadPicture(  const TQString &userId, KURL url, int checksum )
 {
 	if( !d->iconLoader )
 	{
 		d->iconLoader = new YahooBuddyIconLoader( this );
-		QObject::connect( d->iconLoader, SIGNAL(fetchedBuddyIcon(const QString&, const QByteArray &, int )),
-				SIGNAL(pictureDownloaded(const QString&, const QByteArray &,  int ) ) );
+		TQObject::connect( d->iconLoader, TQT_SIGNAL(fetchedBuddyIcon(const TQString&, const TQByteArray &, int )),
+				TQT_SIGNAL(pictureDownloaded(const TQString&, const TQByteArray &,  int ) ) );
 	}
 
-	d->iconLoader->fetchBuddyIcon( QString(userId), KURL(url), checksum );
+	d->iconLoader->fetchBuddyIcon( TQString(userId), KURL(url), checksum );
 }
 
 void Client::uploadPicture( KURL url )
@@ -553,7 +553,7 @@ void Client::uploadPicture( KURL url )
 	spt->go( true );
 }
 
-void Client::sendPictureChecksum( const QString &userId, int checksum )
+void Client::sendPictureChecksum( const TQString &userId, int checksum )
 {
 	kdDebug(YAHOO_RAW_DEBUG) << "checksum: " << checksum << endl;
 	SendPictureTask *spt = new SendPictureTask( d->root );
@@ -564,7 +564,7 @@ void Client::sendPictureChecksum( const QString &userId, int checksum )
 	spt->go( true );
 }
 
-void Client::sendPictureInformation( const QString &userId, const QString &url, int checksum )
+void Client::sendPictureInformation( const TQString &userId, const TQString &url, int checksum )
 {
 	kdDebug(YAHOO_RAW_DEBUG) << "checksum: " << checksum << endl;
 	SendPictureTask *spt = new SendPictureTask( d->root );
@@ -590,17 +590,17 @@ void Client::setPictureStatus( Yahoo::PictureStatus status )
 
 // ***** Webcam handling *****
 
-void Client::requestWebcam( const QString &userId )
+void Client::requestWebcam( const TQString &userId )
 {
 	d->webcamTask->requestWebcam( userId );
 }
 
-void Client::closeWebcam( const QString &userId )
+void Client::closeWebcam( const TQString &userId )
 {
 	d->webcamTask->closeWebcam( userId );
 }
 
-void Client::sendWebcamImage( const QByteArray &ar )
+void Client::sendWebcamImage( const TQByteArray &ar )
 {
 	d->webcamTask->sendWebcamImage( ar );
 }
@@ -611,38 +611,38 @@ void Client::closeOutgoingWebcam()
 }
 
 
-void Client::grantWebcamAccess( const QString &userId )
+void Client::grantWebcamAccess( const TQString &userId )
 {
 	d->webcamTask->grantAccess( userId );
 }
 
 // ***** Conferences *****
-void Client::inviteConference( const QString &room, const QStringList &members, const QString &msg )
+void Client::inviteConference( const TQString &room, const TQStringList &members, const TQString &msg )
 {
 	d->conferenceTask->inviteConference( room, members, msg );
 }
 
-void Client::addInviteConference( const QString &room, const QStringList &who, const QStringList &members, const QString &msg )
+void Client::addInviteConference( const TQString &room, const TQStringList &who, const TQStringList &members, const TQString &msg )
 {
 	d->conferenceTask->addInvite( room, who, members, msg );
 }
 
-void Client::joinConference( const QString &room, const QStringList &members )
+void Client::joinConference( const TQString &room, const TQStringList &members )
 {
 	d->conferenceTask->joinConference( room, members );
 }
 
-void Client::declineConference( const QString &room, const QStringList &members, const QString &msg )
+void Client::declineConference( const TQString &room, const TQStringList &members, const TQString &msg )
 {
 	d->conferenceTask->declineConference( room, members, msg );
 }
 
-void Client::leaveConference( const QString &room, const QStringList &members )
+void Client::leaveConference( const TQString &room, const TQStringList &members )
 {
 	d->conferenceTask->leaveConference( room, members );
 }
 
-void Client::sendConferenceMessage( const QString &room, const QStringList &members, const QString &msg )
+void Client::sendConferenceMessage( const TQString &room, const TQStringList &members, const TQString &msg )
 {
 	d->conferenceTask->sendMessage( room, members, msg );
 }
@@ -658,8 +658,8 @@ void Client::saveYABEntry( YABEntry &entry )
 	ModifyYABTask *myt = new ModifyYABTask( d->root );
 	myt->setAction( ModifyYABTask::EditEntry );
 	myt->setEntry( entry );
-	QObject::connect( myt, SIGNAL(gotEntry( YABEntry * )), this, SIGNAL( gotYABEntry( YABEntry * ) ) );
-	QObject::connect( myt, SIGNAL(error( YABEntry *, const QString &)), this, SIGNAL(modifyYABEntryError( YABEntry *, const QString & )));
+	TQObject::connect( myt, TQT_SIGNAL(gotEntry( YABEntry * )), this, TQT_SIGNAL( gotYABEntry( YABEntry * ) ) );
+	TQObject::connect( myt, TQT_SIGNAL(error( YABEntry *, const TQString &)), this, TQT_SIGNAL(modifyYABEntryError( YABEntry *, const TQString & )));
 	myt->go(true);
 }
 
@@ -668,8 +668,8 @@ void Client::addYABEntry(  YABEntry &entry )
 	ModifyYABTask *myt = new ModifyYABTask( d->root );
 	myt->setAction( ModifyYABTask::AddEntry );
 	myt->setEntry( entry );
-	QObject::connect( myt, SIGNAL(gotEntry( YABEntry * )), this, SIGNAL( gotYABEntry( YABEntry * ) ) );
-	QObject::connect( myt, SIGNAL(error( YABEntry *, const QString &)), this, SIGNAL(modifyYABEntryError( YABEntry *, const QString & )));
+	TQObject::connect( myt, TQT_SIGNAL(gotEntry( YABEntry * )), this, TQT_SIGNAL( gotYABEntry( YABEntry * ) ) );
+	TQObject::connect( myt, TQT_SIGNAL(error( YABEntry *, const TQString &)), this, TQT_SIGNAL(modifyYABEntryError( YABEntry *, const TQString & )));
 	myt->go(true);
 }
 
@@ -697,7 +697,7 @@ void Client::joinYahooChatRoom( const Yahoo::ChatRoom &room )
 	d->yahooChatTask->joinRoom( room );
 }
 
-void Client::sendYahooChatMessage( const QString &msg, const QString &handle )
+void Client::sendYahooChatMessage( const TQString &msg, const TQString &handle )
 {
 	d->yahooChatTask->sendYahooChatMessage( msg, handle );
 }
@@ -708,21 +708,21 @@ void Client::leaveChat()
 }
 
 // ***** other *****
-void Client::notifyError( const QString &info, const QString & errorString, LogLevel level )
+void Client::notifyError( const TQString &info, const TQString & errorString, LogLevel level )
 {
-	kdDebug(YAHOO_RAW_DEBUG) << QString::fromLatin1("\nThe following error occurred: %1\n    Reason: %2\n    LogLevel: %3")
+	kdDebug(YAHOO_RAW_DEBUG) << TQString::fromLatin1("\nThe following error occurred: %1\n    Reason: %2\n    LogLevel: %3")
 		.arg(info).arg(errorString).arg(level) << endl;
 	d->errorString = errorString;
 	d->errorInformation = info;
 	emit error( level );
 }
 
-QString Client::userId()
+TQString Client::userId()
 {
 	return d->user;
 }
 
-void Client::setUserId( const QString & userId )
+void Client::setUserId( const TQString & userId )
 {
 	d->user = userId;
 }
@@ -743,22 +743,22 @@ void Client::setStatusOnConnect( Yahoo::Status status )
 	d->statusOnConnect = status;
 }
 
-void Client::setStatusMessageOnConnect( const QString &msg )
+void Client::setStatusMessageOnConnect( const TQString &msg )
 {
 	d->statusMessageOnConnect = msg;
 }
 
-void Client::setVerificationWord( const QString &word )
+void Client::setVerificationWord( const TQString &word )
 {
 	d->loginTask->setVerificationWord( word );
 }
 
-QString Client::password()
+TQString Client::password()
 {
 	return d->pass;
 }
 
-QString Client::host()
+TQString Client::host()
 {
 	return d->host;
 }
@@ -788,17 +788,17 @@ void Client::setPictureChecksum( int cs )
 	d->pictureChecksum = cs;
 }
 
-QString Client::yCookie()
+TQString Client::yCookie()
 {
 	return d->yCookie;
 }
 
-QString Client::tCookie()
+TQString Client::tCookie()
 {
 	return d->tCookie;
 }
 
-QString Client::cCookie()
+TQString Client::cCookie()
 {
 	return d->cCookie;
 }
@@ -823,7 +823,7 @@ void Client::send( Transfer* request )
 	d->stream->write( request );
 }
 
-void Client::debug(const QString &str)
+void Client::debug(const TQString &str)
 {
        qDebug( "CLIENT: %s", str.ascii() );
 }
@@ -839,104 +839,104 @@ void Client::initTasks()
 		return;
 
 	d->statusTask = new StatusNotifierTask( d->root );
-	QObject::connect( d->statusTask, SIGNAL( statusChanged(const QString&,int,const QString&,int,int,int) ),
-				SIGNAL( statusChanged(const QString&,int,const QString&,int,int,int) ) );
-	QObject::connect( d->statusTask, SIGNAL( stealthStatusChanged( const QString&, Yahoo::StealthStatus ) ),
-				SIGNAL( stealthStatusChanged( const QString&, Yahoo::StealthStatus ) ) );
-	QObject::connect( d->statusTask, SIGNAL( loginResponse( int, const QString& ) ),
-				SLOT( slotLoginResponse( int, const QString& ) ) );
-	QObject::connect( d->statusTask, SIGNAL( authorizationRejected( const QString&, const QString& ) ),
-				SIGNAL( authorizationRejected( const QString&, const QString& ) ) );
-	QObject::connect( d->statusTask, SIGNAL( authorizationAccepted( const QString& ) ),
-				SIGNAL( authorizationAccepted( const QString& ) ) );
-	QObject::connect( d->statusTask, SIGNAL( gotAuthorizationRequest( const QString &, const QString &, const QString & ) ),
-				SIGNAL( gotAuthorizationRequest( const QString &, const QString &, const QString & ) ) );
+	TQObject::connect( d->statusTask, TQT_SIGNAL( statusChanged(const TQString&,int,const TQString&,int,int,int) ),
+				TQT_SIGNAL( statusChanged(const TQString&,int,const TQString&,int,int,int) ) );
+	TQObject::connect( d->statusTask, TQT_SIGNAL( stealthStatusChanged( const TQString&, Yahoo::StealthStatus ) ),
+				TQT_SIGNAL( stealthStatusChanged( const TQString&, Yahoo::StealthStatus ) ) );
+	TQObject::connect( d->statusTask, TQT_SIGNAL( loginResponse( int, const TQString& ) ),
+				TQT_SLOT( slotLoginResponse( int, const TQString& ) ) );
+	TQObject::connect( d->statusTask, TQT_SIGNAL( authorizationRejected( const TQString&, const TQString& ) ),
+				TQT_SIGNAL( authorizationRejected( const TQString&, const TQString& ) ) );
+	TQObject::connect( d->statusTask, TQT_SIGNAL( authorizationAccepted( const TQString& ) ),
+				TQT_SIGNAL( authorizationAccepted( const TQString& ) ) );
+	TQObject::connect( d->statusTask, TQT_SIGNAL( gotAuthorizationRequest( const TQString &, const TQString &, const TQString & ) ),
+				TQT_SIGNAL( gotAuthorizationRequest( const TQString &, const TQString &, const TQString & ) ) );
 
 	d->mailTask = new MailNotifierTask( d->root );
-	QObject::connect( d->mailTask, SIGNAL( mailNotify(const QString&, const QString&, int) ),
-				SIGNAL( mailNotify(const QString&, const QString&, int) ) );
+	TQObject::connect( d->mailTask, TQT_SIGNAL( mailNotify(const TQString&, const TQString&, int) ),
+				TQT_SIGNAL( mailNotify(const TQString&, const TQString&, int) ) );
 
 	d->messageReceiverTask = new MessageReceiverTask( d->root );
-	QObject::connect( d->messageReceiverTask, SIGNAL( gotIm(const QString&, const QString&, long, int) ),
-				SIGNAL( gotIm(const QString&, const QString&, long, int) ) );
-	QObject::connect( d->messageReceiverTask, SIGNAL( systemMessage(const QString&) ),
-				SIGNAL( systemMessage(const QString&) ) );
-	QObject::connect( d->messageReceiverTask, SIGNAL( gotTypingNotify(const QString &, int) ),
-				SIGNAL( typingNotify(const QString &, int) ) );
-	QObject::connect( d->messageReceiverTask, SIGNAL( gotBuzz( const QString &, long ) ),
-				SIGNAL( gotBuzz( const QString &, long ) ) );
-	QObject::connect( d->messageReceiverTask, SIGNAL( gotWebcamInvite(const QString &) ),
-				SIGNAL( gotWebcamInvite(const QString &) ) );
+	TQObject::connect( d->messageReceiverTask, TQT_SIGNAL( gotIm(const TQString&, const TQString&, long, int) ),
+				TQT_SIGNAL( gotIm(const TQString&, const TQString&, long, int) ) );
+	TQObject::connect( d->messageReceiverTask, TQT_SIGNAL( systemMessage(const TQString&) ),
+				TQT_SIGNAL( systemMessage(const TQString&) ) );
+	TQObject::connect( d->messageReceiverTask, TQT_SIGNAL( gotTypingNotify(const TQString &, int) ),
+				TQT_SIGNAL( typingNotify(const TQString &, int) ) );
+	TQObject::connect( d->messageReceiverTask, TQT_SIGNAL( gotBuzz( const TQString &, long ) ),
+				TQT_SIGNAL( gotBuzz( const TQString &, long ) ) );
+	TQObject::connect( d->messageReceiverTask, TQT_SIGNAL( gotWebcamInvite(const TQString &) ),
+				TQT_SIGNAL( gotWebcamInvite(const TQString &) ) );
 
 	d->pictureNotifierTask = new PictureNotifierTask( d->root );
-	QObject::connect( d->pictureNotifierTask, SIGNAL( pictureStatusNotify( const QString &, int ) ),
-				SIGNAL( pictureStatusNotify( const QString &, int ) ) );
-	QObject::connect( d->pictureNotifierTask, SIGNAL( pictureChecksumNotify( const QString &, int ) ),
-				SIGNAL( pictureChecksumNotify( const QString &, int ) ) );
-	QObject::connect( d->pictureNotifierTask, SIGNAL( pictureInfoNotify( const QString &, KURL, int ) ),
-				SIGNAL( pictureInfoNotify( const QString &, KURL, int ) ) );
-	QObject::connect( d->pictureNotifierTask, SIGNAL( pictureRequest( const QString & ) ),
-				SIGNAL( pictureRequest( const QString & ) ) );
-	QObject::connect( d->pictureNotifierTask, SIGNAL( pictureUploaded( const QString &, int ) ),
-				SIGNAL( pictureUploaded( const QString &, int ) ) );
+	TQObject::connect( d->pictureNotifierTask, TQT_SIGNAL( pictureStatusNotify( const TQString &, int ) ),
+				TQT_SIGNAL( pictureStatusNotify( const TQString &, int ) ) );
+	TQObject::connect( d->pictureNotifierTask, TQT_SIGNAL( pictureChecksumNotify( const TQString &, int ) ),
+				TQT_SIGNAL( pictureChecksumNotify( const TQString &, int ) ) );
+	TQObject::connect( d->pictureNotifierTask, TQT_SIGNAL( pictureInfoNotify( const TQString &, KURL, int ) ),
+				TQT_SIGNAL( pictureInfoNotify( const TQString &, KURL, int ) ) );
+	TQObject::connect( d->pictureNotifierTask, TQT_SIGNAL( pictureRequest( const TQString & ) ),
+				TQT_SIGNAL( pictureRequest( const TQString & ) ) );
+	TQObject::connect( d->pictureNotifierTask, TQT_SIGNAL( pictureUploaded( const TQString &, int ) ),
+				TQT_SIGNAL( pictureUploaded( const TQString &, int ) ) );
 
 	d->webcamTask = new WebcamTask( d->root );
-	QObject::connect( d->webcamTask, SIGNAL( webcamImageReceived( const QString &, const QPixmap &) ),
-				SIGNAL( webcamImageReceived( const QString &, const QPixmap &) ) );
-	QObject::connect( d->webcamTask, SIGNAL( webcamNotAvailable( const QString & ) ),
-				SIGNAL( webcamNotAvailable( const QString & ) ) );
-	QObject::connect( d->webcamTask, SIGNAL( webcamClosed( const QString &, int ) ),
-				SIGNAL( webcamClosed( const QString &, int ) ) );
-	QObject::connect( d->webcamTask, SIGNAL( webcamPaused(const QString&) ),
-				SIGNAL( webcamPaused(const QString&) ) );
-	QObject::connect( d->webcamTask, SIGNAL( readyForTransmission() ),
-				SIGNAL( webcamReadyForTransmission() ) );
-	QObject::connect( d->webcamTask, SIGNAL( stopTransmission() ),
-				SIGNAL( webcamStopTransmission() ) );
-	QObject::connect( d->webcamTask, SIGNAL( viewerJoined( const QString &) ),
-				SIGNAL( webcamViewerJoined( const QString &) ) );
-	QObject::connect( d->webcamTask, SIGNAL( viewerLeft( const QString &) ),
-				SIGNAL( webcamViewerLeft( const QString &) ) );
-	QObject::connect( d->webcamTask, SIGNAL( viewerRequest( const QString &) ),
-				SIGNAL( webcamViewerRequest( const QString &) ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( webcamImageReceived( const TQString &, const TQPixmap &) ),
+				TQT_SIGNAL( webcamImageReceived( const TQString &, const TQPixmap &) ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( webcamNotAvailable( const TQString & ) ),
+				TQT_SIGNAL( webcamNotAvailable( const TQString & ) ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( webcamClosed( const TQString &, int ) ),
+				TQT_SIGNAL( webcamClosed( const TQString &, int ) ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( webcamPaused(const TQString&) ),
+				TQT_SIGNAL( webcamPaused(const TQString&) ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( readyForTransmission() ),
+				TQT_SIGNAL( webcamReadyForTransmission() ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( stopTransmission() ),
+				TQT_SIGNAL( webcamStopTransmission() ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( viewerJoined( const TQString &) ),
+				TQT_SIGNAL( webcamViewerJoined( const TQString &) ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( viewerLeft( const TQString &) ),
+				TQT_SIGNAL( webcamViewerLeft( const TQString &) ) );
+	TQObject::connect( d->webcamTask, TQT_SIGNAL( viewerRequest( const TQString &) ),
+				TQT_SIGNAL( webcamViewerRequest( const TQString &) ) );
 
 	d->conferenceTask = new ConferenceTask( d->root );
-	QObject::connect( d->conferenceTask, SIGNAL( gotInvite( const QString &, const QString &, const QString &, const QStringList & ) ),
-				SIGNAL( gotConferenceInvite( const QString &, const QString &, const QString &, const QStringList & ) ) );
-	QObject::connect( d->conferenceTask, SIGNAL( gotMessage( const QString &, const QString &, const QString & ) ),
-				SIGNAL( gotConferenceMessage( const QString &, const QString &, const QString & ) ) );
-	QObject::connect( d->conferenceTask, SIGNAL( userJoined( const QString &, const QString & ) ),
-				SIGNAL( confUserJoined( const QString &, const QString & ) ) );
-	QObject::connect( d->conferenceTask, SIGNAL( userLeft( const QString &, const QString & ) ),
-				SIGNAL( confUserLeft( const QString &, const QString & ) ) );
-	QObject::connect( d->conferenceTask, SIGNAL( userDeclined( const QString &, const QString &, const QString & ) ),
-				SIGNAL( confUserDeclined( const QString &, const QString &, const QString & ) ) );
+	TQObject::connect( d->conferenceTask, TQT_SIGNAL( gotInvite( const TQString &, const TQString &, const TQString &, const TQStringList & ) ),
+				TQT_SIGNAL( gotConferenceInvite( const TQString &, const TQString &, const TQString &, const TQStringList & ) ) );
+	TQObject::connect( d->conferenceTask, TQT_SIGNAL( gotMessage( const TQString &, const TQString &, const TQString & ) ),
+				TQT_SIGNAL( gotConferenceMessage( const TQString &, const TQString &, const TQString & ) ) );
+	TQObject::connect( d->conferenceTask, TQT_SIGNAL( userJoined( const TQString &, const TQString & ) ),
+				TQT_SIGNAL( confUserJoined( const TQString &, const TQString & ) ) );
+	TQObject::connect( d->conferenceTask, TQT_SIGNAL( userLeft( const TQString &, const TQString & ) ),
+				TQT_SIGNAL( confUserLeft( const TQString &, const TQString & ) ) );
+	TQObject::connect( d->conferenceTask, TQT_SIGNAL( userDeclined( const TQString &, const TQString &, const TQString & ) ),
+				TQT_SIGNAL( confUserDeclined( const TQString &, const TQString &, const TQString & ) ) );
 
 	d->yabTask = new YABTask( d->root );
-	QObject::connect( d->yabTask, SIGNAL( gotEntry( YABEntry * ) ),
-				SIGNAL( gotYABEntry( YABEntry * ) ) );
-	QObject::connect( d->yabTask, SIGNAL( gotRevision( long, bool ) ),
-				SIGNAL( gotYABRevision( long, bool ) ) );
+	TQObject::connect( d->yabTask, TQT_SIGNAL( gotEntry( YABEntry * ) ),
+				TQT_SIGNAL( gotYABEntry( YABEntry * ) ) );
+	TQObject::connect( d->yabTask, TQT_SIGNAL( gotRevision( long, bool ) ),
+				TQT_SIGNAL( gotYABRevision( long, bool ) ) );
 
 	d->fileTransferTask = new FileTransferNotifierTask( d->root );
-	QObject::connect( d->fileTransferTask, SIGNAL(incomingFileTransfer( const QString &, const QString &,
-					long, const QString &, const QString &, unsigned long, const QPixmap & )),
-				SIGNAL(incomingFileTransfer( const QString &, const QString &,
-					long, const QString &, const QString &, unsigned long, const QPixmap & )) );
+	TQObject::connect( d->fileTransferTask, TQT_SIGNAL(incomingFileTransfer( const TQString &, const TQString &,
+					long, const TQString &, const TQString &, unsigned long, const TQPixmap & )),
+				TQT_SIGNAL(incomingFileTransfer( const TQString &, const TQString &,
+					long, const TQString &, const TQString &, unsigned long, const TQPixmap & )) );
 
 	d->yahooChatTask = new YahooChatTask( d->root );
-	QObject::connect( d->yahooChatTask, SIGNAL(gotYahooChatCategories( const QDomDocument & )),
-				SIGNAL(gotYahooChatCategories( const QDomDocument & )) );
-	QObject::connect( d->yahooChatTask, SIGNAL(gotYahooChatRooms( const Yahoo::ChatCategory &, const QDomDocument & )),
-				SIGNAL(gotYahooChatRooms( const Yahoo::ChatCategory &, const QDomDocument & )) );
-	QObject::connect( d->yahooChatTask, SIGNAL(chatRoomJoined( int , int , const QString &, const QString & ) ),
-				SIGNAL(chatRoomJoined( int , int , const QString &, const QString & ) ) );
-	QObject::connect( d->yahooChatTask, SIGNAL(chatBuddyHasJoined( const QString &, const QString &, bool  ) ),
-				SIGNAL(chatBuddyHasJoined( const QString &, const QString &, bool  ) ) );
-	QObject::connect( d->yahooChatTask, SIGNAL(chatBuddyHasLeft(QString,QString) ),
-				SIGNAL(chatBuddyHasLeft(QString,QString) ) );
-	QObject::connect( d->yahooChatTask, SIGNAL(chatMessageReceived( const QString &, const QString &, const QString & ) ),
-				SIGNAL(chatMessageReceived( const QString &, const QString &, const QString & ) ) );
+	TQObject::connect( d->yahooChatTask, TQT_SIGNAL(gotYahooChatCategories( const TQDomDocument & )),
+				TQT_SIGNAL(gotYahooChatCategories( const TQDomDocument & )) );
+	TQObject::connect( d->yahooChatTask, TQT_SIGNAL(gotYahooChatRooms( const Yahoo::ChatCategory &, const TQDomDocument & )),
+				TQT_SIGNAL(gotYahooChatRooms( const Yahoo::ChatCategory &, const TQDomDocument & )) );
+	TQObject::connect( d->yahooChatTask, TQT_SIGNAL(chatRoomJoined( int , int , const TQString &, const TQString & ) ),
+				TQT_SIGNAL(chatRoomJoined( int , int , const TQString &, const TQString & ) ) );
+	TQObject::connect( d->yahooChatTask, TQT_SIGNAL(chatBuddyHasJoined( const TQString &, const TQString &, bool  ) ),
+				TQT_SIGNAL(chatBuddyHasJoined( const TQString &, const TQString &, bool  ) ) );
+	TQObject::connect( d->yahooChatTask, TQT_SIGNAL(chatBuddyHasLeft(TQString,TQString) ),
+				TQT_SIGNAL(chatBuddyHasLeft(TQString,TQString) ) );
+	TQObject::connect( d->yahooChatTask, TQT_SIGNAL(chatMessageReceived( const TQString &, const TQString &, const TQString & ) ),
+				TQT_SIGNAL(chatMessageReceived( const TQString &, const TQString &, const TQString & ) ) );
 }
 
 void Client::deleteTasks()
diff --git a/kopete/protocols/yahoo/libkyahoo/client.h b/kopete/protocols/yahoo/libkyahoo/client.h
index f4a3fef5..662c81ff 100644
--- a/kopete/protocols/yahoo/libkyahoo/client.h
+++ b/kopete/protocols/yahoo/libkyahoo/client.h
@@ -22,7 +22,7 @@
 #ifndef LIBYAHOO_CLIENT_H
 #define LIBYAHOO_CLIENT_H
 
-#include <qobject.h>
+#include <tqobject.h>
 #include <kurl.h>
 
 #include "transfer.h"
@@ -52,14 +52,14 @@ Q_OBJECT
 
 		enum LogLevel { Debug, Info, Notice, Warning, Error, Critical };
 
-		Client(QObject *parent=0);
+		Client(TQObject *parent=0);
 		~Client();
 
 		/**
 		 * Set the Yahoo Id of the account
 		 * @param username The Yahoo Id
 		 */
-		void setUserId( const QString& userName );
+		void setUserId( const TQString& userName );
 
 		/**
 		 * Set the picture checksum
@@ -76,7 +76,7 @@ Q_OBJECT
 		 * @param userId The yahoo ID that will be connected.
 		 * @param pass The password.
 		 */
-		void connect( const QString &host, const uint port, const QString &userId, const QString &pass );
+		void connect( const TQString &host, const uint port, const TQString &userId, const TQString &pass );
 
 		/** Cancel active login attemps	 */
 		void cancelConnect();
@@ -88,10 +88,10 @@ Q_OBJECT
 		int error();
 
 		/** Returns a description of the error */
-		QString errorString();
+		TQString errorString();
 
 		/** Returns information about what went wrong */
-		QString errorInformation();
+		TQString errorInformation();
 
 		/**
 		 * Specifies the status we connect with.
@@ -107,10 +107,10 @@ Q_OBJECT
 		 * will change the status message after the login.
 		 * @param msg the status message to connect with
 		 */
-		void setStatusMessageOnConnect( const QString &msg );
+		void setStatusMessageOnConnect( const TQString &msg );
 
 		/** Accessors needed for login */
-		QString host();
+		TQString host();
 		int port();
 
 		/**
@@ -118,27 +118,27 @@ Q_OBJECT
 		 * @param to the buddy that should be notified
 		 * @param typing true if there is typing activity, false if not
 		 */
-		void sendTyping( const QString &to, bool typing );
+		void sendTyping( const TQString &to, bool typing );
 
 		/**
 		 * Send a Message
 		 * @param to the buddy that should receive the message
 		 * @param msg the message
 		 */
-		void sendMessage( const QString &to, const QString &msg );
+		void sendMessage( const TQString &to, const TQString &msg );
 
 		/**
 		 * Register / Unregister a chatsession
 		 * @param to the buddy, the chatsession belongs to
 		 * @param close if true, the chatsession will be closed, if false, it will be opened
 		 */
-		void setChatSessionState( const QString &to, bool close );
+		void setChatSessionState( const TQString &to, bool close );
 
 		/**
 		 * Send a Buzz
 		 * @param to the buddy that should receive the buzz
 		 */
-		void sendBuzz( const QString &to );
+		void sendBuzz( const TQString &to );
 
 		/**
 		 * Change our status
@@ -146,14 +146,14 @@ Q_OBJECT
 		 * @param message the status message that will be set
 		 * @param type Yahoo::StatusTypeAvailable means that the user is available, Yahoo::StatusTypeAway means that the user is away from the keyboard
 		 */
-		void changeStatus(Yahoo::Status status, const QString &message, Yahoo::StatusType type);
+		void changeStatus(Yahoo::Status status, const TQString &message, Yahoo::StatusType type);
 
 		/**
 		 * Set the verification word that is needed for a account verification after
 		 * too many wrong login attempts.
 		 * @param word the verification word
 		 */
-		void setVerificationWord( const QString &word );
+		void setVerificationWord( const TQString &word );
 
 		/**
 		 * Add a buddy to the contact list
@@ -161,14 +161,14 @@ Q_OBJECT
 		 * @param group the group where the buddy will be placed
 		 * @param message the message that will be sent to the buddy along the authorization request
 		 */
-		void addBuddy( const QString &userId, const QString &group, const QString &message = QString::fromLatin1("Please add me")  );
+		void addBuddy( const TQString &userId, const TQString &group, const TQString &message = TQString::fromLatin1("Please add me")  );
 
 		/**
 		 * Remove a buddy from the contact list
 		 * @param userId the yahoo ID of the buddy that should be removed
 		 * @param group the group where the buddy belongs to
 		 */
-		void removeBuddy( const QString &userId, const QString &group );
+		void removeBuddy( const TQString &userId, const TQString &group );
 
 		/**
 		 * Move a buddy into another group
@@ -176,7 +176,7 @@ Q_OBJECT
 		 * @param oldGroup the group where the buddy belongs to
 		 * @param newGroup the group where the buddy will be placed
 		 */
-		void moveBuddy( const QString &userId, const QString &oldGroup, const QString &newGroup );
+		void moveBuddy( const TQString &userId, const TQString &oldGroup, const TQString &newGroup );
 
 		/**
 		 * Change the stealth status of a buddy
@@ -184,13 +184,13 @@ Q_OBJECT
 		 * @param mode defines the Stealth mode that is changed. That can be "Appear Offline", "Appear Online" or "Apper permanently offline"
 		 * @param state the status of the specified Stealth mode. Active, Not Active or Clear
 		 */
-		void stealthContact( QString const &userId, Yahoo::StealthMode mode, Yahoo::StealthStatus state );
+		void stealthContact( TQString const &userId, Yahoo::StealthMode mode, Yahoo::StealthStatus state );
 
 		/**
 		 * Request the buddy's picture
 		 * @param userId the yahoo ID of the buddy
 		 */
-		void requestPicture( const QString &userId );
+		void requestPicture( const TQString &userId );
 
 		/**
 		 * Download the buddy's picture
@@ -198,7 +198,7 @@ Q_OBJECT
 		 * @param url the url of the picture
 		 * @param checksum the checksum of the picture
 		 */
-		void downloadPicture( const QString &userId, KURL url, int checksum );
+		void downloadPicture( const TQString &userId, KURL url, int checksum );
 
 		/**
 		 * Send our picture
@@ -211,7 +211,7 @@ Q_OBJECT
 		 * @param userId the yahoo ID of the buddy. Can be a null string if the picture has changed.
 		 * @param checksum the checksum of the picture
 		 */
-		void sendPictureChecksum( const QString &userId, int checksum );
+		void sendPictureChecksum( const TQString &userId, int checksum );
 
 		/**
 		 * Send information about our picture
@@ -219,7 +219,7 @@ Q_OBJECT
 		 * @param url the url of our picture
 		 * @param checksum the checksum of the picture
 		 */
-		void sendPictureInformation( const QString &userId, const QString &url, int checksum );
+		void sendPictureInformation( const TQString &userId, const TQString &url, int checksum );
 
 		/**
 		 * Notify the buddies about our new status
@@ -231,25 +231,25 @@ Q_OBJECT
 		 * Send a response to the webcam invite ( Accept / Decline )
 		 * @param userId the yahoo ID of the sender
 		 */
-		void requestWebcam( const QString &userId );
+		void requestWebcam( const TQString &userId );
 
 		/**
 		 * Stop receiving of webcam
 		 * @param userId the yahoo ID of the sender
 		 */
-		void closeWebcam( const QString &userId );
+		void closeWebcam( const TQString &userId );
 
 		/**
 		 * Invite the user to view your Webcam
 		 * @param userId the yahoo ID of the receiver
 		 */
-		void sendWebcamInvite( const QString &userId );
+		void sendWebcamInvite( const TQString &userId );
 
 		/**
 		 * transmit a new image to the watchers
 		 * @param image the image data
 		 */
-		void sendWebcamImage( const QByteArray &image );
+		void sendWebcamImage( const TQByteArray &image );
 
 		/** Stop the webcam transmission */
 		void closeOutgoingWebcam();
@@ -258,7 +258,7 @@ Q_OBJECT
 		 * Allow a buddy to watch the cam
 		 * @param userId the yahoo ID of the receiver
 		 */
-		void grantWebcamAccess( const QString &userId );
+		void grantWebcamAccess( const TQString &userId );
 
 		/**
 		 * Invite buddies to a conference
@@ -266,7 +266,7 @@ Q_OBJECT
 		 * @param members a list of members that are invited to the conference
 		 * @param msg the invite message
 		 */
-		void inviteConference( const QString &room, const QStringList &members, const QString &msg );
+		void inviteConference( const TQString &room, const TQStringList &members, const TQString &msg );
 
 		/**
 		 * Invite buddies to a already existing conference
@@ -275,14 +275,14 @@ Q_OBJECT
 		 * @param members a list of members that are already in the conference
 		 * @param msg the invite message
 		 */
-		void addInviteConference( const QString &room, const QStringList &who, const QStringList &members, const QString &msg );
+		void addInviteConference( const TQString &room, const TQStringList &who, const TQStringList &members, const TQString &msg );
 
 		/**
 		 * Join a conference
 		 * @param room the name of the conference
 		 * @param members a list of members that are already in the conference
 		 */
-		void joinConference( const QString &room, const QStringList &members );
+		void joinConference( const TQString &room, const TQStringList &members );
 
 		/**
 		 * Decline to join a conference
@@ -290,14 +290,14 @@ Q_OBJECT
 		 * @param members a list of members that are in the conference
 		 * @param msg the reason why we don't want to join
 		 */
-		void declineConference( const QString &room, const QStringList &members, const QString &msg );
+		void declineConference( const TQString &room, const TQStringList &members, const TQString &msg );
 
 		/**
 		 * Leave the conference
 		 * @param room the name of the conference
 		 * @param members a list of members that are in the conference
 		 */
-		void leaveConference( const QString &room, const QStringList &members );
+		void leaveConference( const TQString &room, const TQStringList &members );
 
 		/**
 		 * Send a message to the conference
@@ -305,7 +305,7 @@ Q_OBJECT
 		 * @param members a list of members that are in the conference
 		 * @param msg the message
 		 */
-		void sendConferenceMessage( const QString &room, const QStringList &members, const QString &msg );
+		void sendConferenceMessage( const TQString &room, const TQStringList &members, const TQString &msg );
 
 		/**
 		 * Send a authorization request response
@@ -313,7 +313,7 @@ Q_OBJECT
 		 * @param accept true, if the user is allowed to see our status, false if not
 		 * @param msg the reason for our decision
 		 */
-		void sendAuthReply( const QString &userId, bool accept, const QString &msg );
+		void sendAuthReply( const TQString &userId, bool accept, const TQString &msg );
 
 		/**
 		 * Fetches all entries of the YAB
@@ -347,7 +347,7 @@ Q_OBJECT
 		 * @param msg a description of the file to be sent
 		 * @param url the location of the file to be sent
 		 */
-		void sendFile( unsigned int transferId, const QString &userId, const QString &msg, KURL url );
+		void sendFile( unsigned int transferId, const TQString &userId, const TQString &msg, KURL url );
 
 		/**
 		 * Receive a file from a buddy
@@ -356,14 +356,14 @@ Q_OBJECT
 		 * @param remoteURL the url of the file
 		 * @param localURL the location where the file should be stored
 		 */
-		void receiveFile( unsigned int transferId, const QString &userId, KURL remoteURL, KURL localURL );
+		void receiveFile( unsigned int transferId, const TQString &userId, KURL remoteURL, KURL localURL );
 
 		/**
 		 * Reject a file offered by a buddy
 		 * @param userId yahoo ID of the sender
 		 * @param remoteURL the url of the file
 		 */
-		void rejectFile( const QString &userId, KURL remoteURL );
+		void rejectFile( const TQString &userId, KURL remoteURL );
 
 		/**
 		 * Canceled a filetransfer
@@ -394,7 +394,7 @@ Q_OBJECT
 		/**
 		 * Send a chat message
 		 */
-		void sendYahooChatMessage( const QString &msg, const QString &handle );
+		void sendYahooChatMessage( const TQString &msg, const TQString &handle );
 
 		/*************
 		  INTERNAL (FOR USE BY TASKS) METHODS
@@ -408,13 +408,13 @@ Q_OBJECT
 		/**
 		 * Print a debug statement
 		 */
-		void debug( const QString &str );
+		void debug( const TQString &str );
 
 		/** The current user's user ID */
-		QString userId();
+		TQString userId();
 
 		/** The current user's password */
-		QString password();
+		TQString password();
 
 		/** current Session ID */
 		uint sessionID();
@@ -445,20 +445,20 @@ Q_OBJECT
 		/**
 		 * Accessors to the cookies
 		 */
-		QString yCookie();
-		QString tCookie();
-		QString cCookie();
+		TQString yCookie();
+		TQString tCookie();
+		TQString cCookie();
 
 		/**
 		 * Error
 		 */
-		void notifyError( const QString &info, const QString &errorString, LogLevel level );
+		void notifyError( const TQString &info, const TQString &errorString, LogLevel level );
 	signals:
 		/** CONNECTION EVENTS */
 		/**
 		 * Notifies that the login process has succeeded.
 		 */
-		void loggedIn( int, const QString& );
+		void loggedIn( int, const TQString& );
 
 		/**
 		 * Notifies that the login process has failed
@@ -482,91 +482,91 @@ Q_OBJECT
 		/**
 		 * Notifies about our buddies and groups
 		 */
-		void gotBuddy( const QString &, const QString &, const QString & );
+		void gotBuddy( const TQString &, const TQString &, const TQString & );
 		/**
 		 * Notifies about adding buddies
 		 */
-		void buddyAddResult( const QString &, const QString &, bool );
+		void buddyAddResult( const TQString &, const TQString &, bool );
 		/**
 		 * Notifies about removing buddies
 		 */
-		void buddyRemoveResult( const QString &, const QString &, bool );
+		void buddyRemoveResult( const TQString &, const TQString &, bool );
 		/**
 		 * Notifies about buddies changing groups
 		 */
-		void buddyChangeGroupResult( const QString &, const QString &, bool );
+		void buddyChangeGroupResult( const TQString &, const TQString &, bool );
 		/**
 		 * Notifies about the status of online buddies
 		 */
-		void statusChanged( const QString&, int, const QString&, int, int, int );
+		void statusChanged( const TQString&, int, const TQString&, int, int, int );
 		/**
 		 * Notifies about the stealth status of buddies
 		 */
-		void stealthStatusChanged( const QString &, Yahoo::StealthStatus );
+		void stealthStatusChanged( const TQString &, Yahoo::StealthStatus );
 		/**
 		 * Notifies about mails
 		 */
-		void mailNotify( const QString&, const QString&, int );
+		void mailNotify( const TQString&, const TQString&, int );
 		/**
 		 * We got a new message
 		 */
-		void gotIm( const QString&, const QString&, long, int );
+		void gotIm( const TQString&, const TQString&, long, int );
 		/**
 		 * We got a new system message
 		 */
-		void systemMessage( const QString& );
+		void systemMessage( const TQString& );
 		/**
 		 * The buddy is typing a message
 		 */
-		void typingNotify( const QString &, int );
+		void typingNotify( const TQString &, int );
 		/**
 		 * The buddy has invited us to view his webcam
 		 */
-		void gotWebcamInvite(const QString &);
+		void gotWebcamInvite(const TQString &);
 		/**
 		 * Notifies about a BUZZ notification
 		 */
-		void gotBuzz( const QString &, long );
+		void gotBuzz( const TQString &, long );
 		/**
 		 * Notifies about a changed picture status
 		 */
-		void pictureStatusNotify( const QString &, int );
+		void pictureStatusNotify( const TQString &, int );
 		/**
 		 * Notifies about a picture checksum
 		 */
-		void pictureChecksumNotify( const QString &, int );
+		void pictureChecksumNotify( const TQString &, int );
 		/**
 		 * Notifies about a picture
 		 */
-		void pictureInfoNotify( const QString &, KURL, int );
+		void pictureInfoNotify( const TQString &, KURL, int );
 		/**
 		 * The iconLoader has successfully downloaded a picutre
 		 */
-		void pictureDownloaded( const QString &, const QByteArray &, int );
+		void pictureDownloaded( const TQString &, const TQByteArray &, int );
 		/**
 		 * A Buddy asks for our picture
 		 */
-		void pictureRequest( const QString & );
+		void pictureRequest( const TQString & );
 		/**
 		 * Information about the picture upload
 		 */
-		void pictureUploaded( const QString &, int );
+		void pictureUploaded( const TQString &, int );
 		/**
 		 * We've received a webcam image from a buddy
 		 */
-		void webcamImageReceived( const QString &, const QPixmap &);
+		void webcamImageReceived( const TQString &, const TQPixmap &);
 		/**
 		 * The requested Webcam is not available
 		 */
-		void webcamNotAvailable( const QString & );
+		void webcamNotAvailable( const TQString & );
 		/**
 		 * The connection to the webcam was closed
 		 */
-		void webcamClosed( const QString &, int );
+		void webcamClosed( const TQString &, int );
 		/**
 		 * The webcamtransmission is paused
 		 */
-		void webcamPaused(const QString&);
+		void webcamPaused(const TQString&);
 		/**
 		 * The webcam connection is ready for transmission
 		 */
@@ -578,47 +578,47 @@ Q_OBJECT
 		/**
 		 * A new buddy watches the cam
 		 */
-		void webcamViewerJoined( const QString & );
+		void webcamViewerJoined( const TQString & );
 		/**
 		 * A buddy no longer watches the cam
 		 */
-		void webcamViewerLeft( const QString & );
+		void webcamViewerLeft( const TQString & );
 		/**
 		 * A buddy wants to watch the cam
 		 */
-		void webcamViewerRequest( const QString & );
+		void webcamViewerRequest( const TQString & );
 		/**
 		 * A buddy invited us to a conference
 		 */
-		void gotConferenceInvite( const QString &, const QString &, const QString &, const QStringList & );
+		void gotConferenceInvite( const TQString &, const TQString &, const TQString &, const TQStringList & );
 		/**
 		 * A conference message was received
 		 */
-		void gotConferenceMessage( const QString &, const QString &, const QString & );
+		void gotConferenceMessage( const TQString &, const TQString &, const TQString & );
 		/**
 		 * A buddy joined the conference
 		 */
-		void confUserJoined( const QString &, const QString & );
+		void confUserJoined( const TQString &, const TQString & );
 		/**
 		 * A buddy left the conference
 		 */
-		void confUserLeft( const QString &, const QString & );
+		void confUserLeft( const TQString &, const TQString & );
 		/**
 		 * A buddy declined to join the conference
 		 */
-		void confUserDeclined( const QString &, const QString &, const QString & );
+		void confUserDeclined( const TQString &, const TQString &, const TQString & );
 		/**
 		 * A buddy accepted our authorization request
 		 */
-		void authorizationAccepted( const QString & );
+		void authorizationAccepted( const TQString & );
 		/**
 		 * A buddy rejected our authorization request
 		 */
-		void authorizationRejected( const QString &, const QString & );
+		void authorizationRejected( const TQString &, const TQString & );
 		/**
 		 * A buddy requests authorization
 		 */
-		void gotAuthorizationRequest( const QString &, const QString &, const QString & );
+		void gotAuthorizationRequest( const TQString &, const TQString &, const TQString & );
 		/**
 		 * A revision of the Yahoo Addressbook was received
 		 */
@@ -630,7 +630,7 @@ Q_OBJECT
 		/**
 		 * An error occurred while saving a Yahoo Addressbook entry
 		 */
-		void modifyYABEntryError( YABEntry *, const QString & );
+		void modifyYABEntryError( YABEntry *, const TQString & );
 		/**
 		 * number of Bytes transferred for FileTransfer id
 		 */
@@ -642,7 +642,7 @@ Q_OBJECT
 		/**
 		 * An error occurred during the filetransfer
 		 */
-		void fileTransferError( unsigned int, int, const QString & );
+		void fileTransferError( unsigned int, int, const TQString & );
 		/**
 		 * filetransfer canceled
 		 */
@@ -650,32 +650,32 @@ Q_OBJECT
 		/**
 		 * A buddy is trying to send us a file
 		 */
-		void incomingFileTransfer( const QString &, const QString &, long, const QString &,
-			const QString &, unsigned long, const QPixmap & );
+		void incomingFileTransfer( const TQString &, const TQString &, long, const TQString &,
+			const TQString &, unsigned long, const TQPixmap & );
 		/**
 		 * We have received the list of yahoo chat categories
 		 */
-		void gotYahooChatCategories( const QDomDocument & );
+		void gotYahooChatCategories( const TQDomDocument & );
 		/**
 		 * We have received the list of chatrooms for the categories
 		 */
-		void gotYahooChatRooms( const Yahoo::ChatCategory &, const QDomDocument & );
+		void gotYahooChatRooms( const Yahoo::ChatCategory &, const TQDomDocument & );
 		/**
 		 * We have joined a chatroom
 		 */
-		void chatRoomJoined( int, int, const QString &, const QString & );
+		void chatRoomJoined( int, int, const TQString &, const TQString & );
 		/**
 		 * A buddy has joined a chatroom
 		 */
-		void chatBuddyHasJoined( const QString &, const QString &, bool );
+		void chatBuddyHasJoined( const TQString &, const TQString &, bool );
 		/**
 		 * A buddy has left a chatroom
 		 */
-		void chatBuddyHasLeft( const QString &, const QString & );
+		void chatBuddyHasLeft( const TQString &, const TQString & );
 		/**
 		 * We have received a message in a chatroom
 		 */
-		void chatMessageReceived( const QString &, const QString &, const QString & );
+		void chatMessageReceived( const TQString &, const TQString &, const TQString & );
 	protected slots:
 		// INTERNAL, FOR USE BY TASKS' finished() SIGNALS //
 		void lt_loginFinished();
@@ -687,7 +687,7 @@ Q_OBJECT
 		/**
 		 * Used by tasks to identify a response to a login attempt
 		 */
-		void slotLoginResponse( int, const QString& );
+		void slotLoginResponse( int, const TQString& );
 
 		/**
 		 * Used by the client stream to notify errors to upper layers.
@@ -726,7 +726,7 @@ Q_OBJECT
 		ClientPrivate* d;
 		KNetworkConnector *m_connector;
 
-		QTimer *m_pingTimer;
+		TQTimer *m_pingTimer;
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/conferencetask.cpp b/kopete/protocols/yahoo/libkyahoo/conferencetask.cpp
index 9ab0d4c1..59d3b3fa 100644
--- a/kopete/protocols/yahoo/libkyahoo/conferencetask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/conferencetask.cpp
@@ -19,8 +19,8 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 #include <kdebug.h>
 
 ConferenceTask::ConferenceTask(Task* parent) : Task(parent)
@@ -78,16 +78,16 @@ void ConferenceTask::parseInvitation( YMSGTransfer *t )
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
 	int i = 0;
-	QString who = t->firstParam( 50 );
-	QString room = t->firstParam( 57 );
-	bool utf = QString( t->firstParam( 97 ) ).toInt() == 1;
-	QString msg;
+	TQString who = t->firstParam( 50 );
+	TQString room = t->firstParam( 57 );
+	bool utf = TQString( t->firstParam( 97 ) ).toInt() == 1;
+	TQString msg;
 	if( utf )
-		msg = QString::fromUtf8( t->firstParam( 58 ) );
+		msg = TQString::fromUtf8( t->firstParam( 58 ) );
 	else
 		msg = t->firstParam( 58 );
 
-	QStringList members;
+	TQStringList members;
 	for( i = 0; i < t->paramCount( 52 ); ++i )
 		members.append( t->nthParam( 52, i ) );
 	for( i = 0; i < t->paramCount( 53 ); ++i )
@@ -103,12 +103,12 @@ void ConferenceTask::parseMessage( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString room = t->firstParam( 57 );
-	QString from = t->firstParam( 3 );
-	bool utf = QString( t->firstParam( 97 ) ).toInt() == 1;
-	QString msg;
+	TQString room = t->firstParam( 57 );
+	TQString from = t->firstParam( 3 );
+	bool utf = TQString( t->firstParam( 97 ) ).toInt() == 1;
+	TQString msg;
 	if( utf )
-		msg = QString::fromUtf8( t->firstParam( 14 ) );
+		msg = TQString::fromUtf8( t->firstParam( 14 ) );
 	else
 		msg = t->firstParam( 14 );
 
@@ -120,8 +120,8 @@ void ConferenceTask::parseUserJoined( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString room = t->firstParam( 57 );
-	QString who = t->firstParam( 53 );
+	TQString room = t->firstParam( 57 );
+	TQString who = t->firstParam( 53 );
 
 	if( !who.isEmpty() && !room.isEmpty() )
 		emit userJoined( who, room );
@@ -131,8 +131,8 @@ void ConferenceTask::parseUserLeft( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString room = t->firstParam( 57 );
-	QString who = t->firstParam( 56 );
+	TQString room = t->firstParam( 57 );
+	TQString who = t->firstParam( 56 );
 
 	if( !who.isEmpty() && !room.isEmpty() )
 		emit userLeft( who, room );
@@ -142,15 +142,15 @@ void ConferenceTask::parseUserDeclined( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString room = t->firstParam( 57 );
-	QString who = t->firstParam( 54 );
-	QString msg = t->firstParam( 14 );
+	TQString room = t->firstParam( 57 );
+	TQString who = t->firstParam( 54 );
+	TQString msg = t->firstParam( 14 );
 
 	if( !who.isEmpty() && !room.isEmpty() )
 		emit userDeclined( who, room, msg );
 }
 
-void ConferenceTask::inviteConference( const QString &room, const QStringList &members, const QString &msg )
+void ConferenceTask::inviteConference( const TQString &room, const TQStringList &members, const TQString &msg )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
@@ -161,14 +161,14 @@ void ConferenceTask::inviteConference( const QString &room, const QStringList &m
 	t->setParam( 57, room.local8Bit() );
 	t->setParam( 58, msg.local8Bit() );
 	t->setParam( 97, 1 );
-	for( QStringList::const_iterator it = members.begin(); it != members.end(); ++it )
+	for( TQStringList::const_iterator it = members.begin(); it != members.end(); ++it )
 		t->setParam( 52, (*it).local8Bit() );
 	t->setParam( 13, "0" );
 
 	send( t );
 }
 
-void ConferenceTask::addInvite( const QString &room, const QStringList &who, const QStringList &members, const QString &msg )
+void ConferenceTask::addInvite( const TQString &room, const TQStringList &who, const TQStringList &members, const TQString &msg )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
@@ -176,15 +176,15 @@ void ConferenceTask::addInvite( const QString &room, const QStringList &who, con
 	t->setId( client()->sessionID() );
 	t->setParam( 1, client()->userId().local8Bit() );
 
-	QString whoList = who.first();
+	TQString whoList = who.first();
 	for( int i = 1; i < who.size(); i++ )
-		whoList += QString(",%1").arg( who[i] );
+		whoList += TQString(",%1").arg( who[i] );
 	t->setParam( 51, whoList.local8Bit() );
 
 	t->setParam( 57, room.local8Bit() );
 	t->setParam( 58, msg.local8Bit() );
 	t->setParam( 97, 1 );
-	for( QStringList::const_iterator it = members.begin(); it != members.end(); ++it )
+	for( TQStringList::const_iterator it = members.begin(); it != members.end(); ++it )
 	{
 		t->setParam( 52, (*it).local8Bit() );
 		t->setParam( 53, (*it).local8Bit() );	// Note: this field should only be set if the buddy has already joined the conference, but no harm is done this way
@@ -194,28 +194,28 @@ void ConferenceTask::addInvite( const QString &room, const QStringList &who, con
 	send( t );
 }
 
-void ConferenceTask::joinConference( const QString &room, const QStringList &members )
+void ConferenceTask::joinConference( const TQString &room, const TQStringList &members )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
 	YMSGTransfer *t = new YMSGTransfer(Yahoo::ServiceConfLogon);
 	t->setId( client()->sessionID() );
 	t->setParam( 1, client()->userId().local8Bit() );
-	for( QStringList::const_iterator it = members.begin(); it != members.end(); ++it )
+	for( TQStringList::const_iterator it = members.begin(); it != members.end(); ++it )
 		t->setParam( 3, (*it).local8Bit() );
 	t->setParam( 57, room.local8Bit() );
 
 	send( t );
 }
 
-void ConferenceTask::declineConference( const QString &room, const QStringList &members, const QString &msg )
+void ConferenceTask::declineConference( const TQString &room, const TQStringList &members, const TQString &msg )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
 	YMSGTransfer *t = new YMSGTransfer(Yahoo::ServiceConfDecline);
 	t->setId( client()->sessionID() );
 	t->setParam( 1, client()->userId().local8Bit() );
-	for( QStringList::const_iterator it = members.begin(); it != members.end(); ++it )
+	for( TQStringList::const_iterator it = members.begin(); it != members.end(); ++it )
 		t->setParam( 3, (*it).local8Bit() );
 	t->setParam( 57, room.local8Bit() );
 	t->setParam( 14, msg.utf8() );
@@ -223,28 +223,28 @@ void ConferenceTask::declineConference( const QString &room, const QStringList &
 
 	send( t );
 }
-void ConferenceTask::leaveConference( const QString &room, const QStringList &members )
+void ConferenceTask::leaveConference( const TQString &room, const TQStringList &members )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
 	YMSGTransfer *t = new YMSGTransfer(Yahoo::ServiceConfLogoff);
 	t->setId( client()->sessionID() );
 	t->setParam( 1, client()->userId().local8Bit() );
-	for( QStringList::const_iterator it = members.begin(); it != members.end(); ++it )
+	for( TQStringList::const_iterator it = members.begin(); it != members.end(); ++it )
 		t->setParam( 3, (*it).local8Bit() );
 	t->setParam( 57, room.local8Bit() );
 
 	send( t );
 }
 
-void ConferenceTask::sendMessage( const QString &room, const QStringList &members, const QString &msg )
+void ConferenceTask::sendMessage( const TQString &room, const TQStringList &members, const TQString &msg )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
 	YMSGTransfer *t = new YMSGTransfer(Yahoo::ServiceConfMsg);
 	t->setId( client()->sessionID() );
 	t->setParam( 1, client()->userId().local8Bit() );
-	for( QStringList::const_iterator it = members.begin(); it != members.end(); ++it )
+	for( TQStringList::const_iterator it = members.begin(); it != members.end(); ++it )
 		t->setParam( 53, (*it).local8Bit() );
 	t->setParam( 57, room.local8Bit() );
 	t->setParam( 14, msg.utf8() );
diff --git a/kopete/protocols/yahoo/libkyahoo/conferencetask.h b/kopete/protocols/yahoo/libkyahoo/conferencetask.h
index f8a101c5..5f027c0f 100644
--- a/kopete/protocols/yahoo/libkyahoo/conferencetask.h
+++ b/kopete/protocols/yahoo/libkyahoo/conferencetask.h
@@ -34,18 +34,18 @@ public:
 	bool take(Transfer *transfer);
 	bool forMe( const Transfer* transfer ) const;
 
-	void joinConference( const QString &room, const QStringList &members );
-	void declineConference( const QString &room, const QStringList &members, const QString &msg );
-	void leaveConference( const QString &room, const QStringList &members );
-	void sendMessage( const QString &room, const QStringList &members, const QString &msg );
-	void inviteConference( const QString &room, const QStringList &members, const QString &msg );
-	void addInvite( const QString &room, const QStringList &who, const QStringList &members, const QString &msg );
+	void joinConference( const TQString &room, const TQStringList &members );
+	void declineConference( const TQString &room, const TQStringList &members, const TQString &msg );
+	void leaveConference( const TQString &room, const TQStringList &members );
+	void sendMessage( const TQString &room, const TQStringList &members, const TQString &msg );
+	void inviteConference( const TQString &room, const TQStringList &members, const TQString &msg );
+	void addInvite( const TQString &room, const TQStringList &who, const TQStringList &members, const TQString &msg );
 signals:
-	void gotInvite( const QString &who, const QString &room, const QString &msg, const QStringList &members);
-	void gotMessage( const QString &who, const QString &room, const QString &msg );
-	void userJoined( const QString &who, const QString &room );
-	void userLeft( const QString &who, const QString &room );
-	void userDeclined( const QString &who, const QString &room, const QString &msg );
+	void gotInvite( const TQString &who, const TQString &room, const TQString &msg, const TQStringList &members);
+	void gotMessage( const TQString &who, const TQString &room, const TQString &msg );
+	void userJoined( const TQString &who, const TQString &room );
+	void userLeft( const TQString &who, const TQString &room );
+	void userDeclined( const TQString &who, const TQString &room, const TQString &msg );
 private:
 	void parseInvitation( YMSGTransfer *transfer );
 	void parseMessage( YMSGTransfer *transfer );
diff --git a/kopete/protocols/yahoo/libkyahoo/connector.cpp b/kopete/protocols/yahoo/libkyahoo/connector.cpp
index 773f8757..cc7dcfa3 100644
--- a/kopete/protocols/yahoo/libkyahoo/connector.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/connector.cpp
@@ -20,8 +20,8 @@
 
 #include "connector.h"
 
-Connector::Connector(QObject *parent)
-:QObject(parent)
+Connector::Connector(TQObject *parent)
+:TQObject(parent)
 {
 	setPeerAddressNone();
 }
@@ -35,7 +35,7 @@ bool Connector::havePeerAddress() const
 	return haveaddr;
 }
 
-QHostAddress Connector::peerAddress() const
+TQHostAddress Connector::peerAddress() const
 {
 	return addr;
 }
@@ -48,11 +48,11 @@ Q_UINT16 Connector::peerPort() const
 void Connector::setPeerAddressNone()
 {
 	haveaddr = false;
-	addr = QHostAddress();
+	addr = TQHostAddress();
 	port = 0;
 }
 
-void Connector::setPeerAddress(const QHostAddress &_addr, Q_UINT16 _port)
+void Connector::setPeerAddress(const TQHostAddress &_addr, Q_UINT16 _port)
 {
 	haveaddr = true;
 	addr = _addr;
diff --git a/kopete/protocols/yahoo/libkyahoo/connector.h b/kopete/protocols/yahoo/libkyahoo/connector.h
index dea818fb..02b47019 100644
--- a/kopete/protocols/yahoo/libkyahoo/connector.h
+++ b/kopete/protocols/yahoo/libkyahoo/connector.h
@@ -22,8 +22,8 @@
 #define LIBKYAHOO_CONNECTOR_H
 
 
-#include <qobject.h>
-#include "qhostaddress.h"
+#include <tqobject.h>
+#include "tqhostaddress.h"
 
 class ByteStream;
 
@@ -31,15 +31,15 @@ class Connector : public QObject
 {
 	Q_OBJECT
 public:
-	Connector(QObject *parent=0);
+	Connector(TQObject *parent=0);
 	virtual ~Connector();
 
-	virtual void connectToServer(const QString &server)=0;
+	virtual void connectToServer(const TQString &server)=0;
 	virtual ByteStream *stream() const=0;
 	virtual void done()=0;
 
 	bool havePeerAddress() const;
-	QHostAddress peerAddress() const;
+	TQHostAddress peerAddress() const;
 	Q_UINT16 peerPort() const;
 
 signals:
@@ -48,11 +48,11 @@ signals:
 
 protected:
 	void setPeerAddressNone();
-	void setPeerAddress(const QHostAddress &addr, Q_UINT16 port);
+	void setPeerAddress(const TQHostAddress &addr, Q_UINT16 port);
 
 private:
 	bool haveaddr;
-	QHostAddress addr;
+	TQHostAddress addr;
 	Q_UINT16 port;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/coreprotocol.cpp b/kopete/protocols/yahoo/libkyahoo/coreprotocol.cpp
index 2c73ef2b..573c5ccf 100644
--- a/kopete/protocols/yahoo/libkyahoo/coreprotocol.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/coreprotocol.cpp
@@ -22,9 +22,9 @@
 #include <string.h>
 #include <iostream>
 
-#include <qdatastream.h>
-#include <qdatetime.h>
-#include <qtextstream.h>
+#include <tqdatastream.h>
+#include <tqdatetime.h>
+#include <tqtextstream.h>
 
 #include <kdebug.h>
 #include <kurl.h>
@@ -33,7 +33,7 @@
 #include "ymsgprotocol.h"
 #include "ymsgtransfer.h"
 
-CoreProtocol::CoreProtocol() : QObject()
+CoreProtocol::CoreProtocol() : TQObject()
 {
 	m_YMSGProtocol = new YMSGProtocol( this, "ymsgprotocol" );
 }
@@ -47,7 +47,7 @@ int CoreProtocol::state()
 	return m_state;
 }
 
-void CoreProtocol::addIncomingData( const QByteArray & incomingBytes )
+void CoreProtocol::addIncomingData( const TQByteArray & incomingBytes )
 {
 	// store locally
 	int oldsize = m_in.size();
@@ -75,7 +75,7 @@ void CoreProtocol::addIncomingData( const QByteArray & incomingBytes )
 			//m_in.remove( 0, parsedBytes );
 
 			// copy the unparsed bytes into a new qbytearray and replace m_in with that
-                        QByteArray remainder( size - parsedBytes );
+                        TQByteArray remainder( size - parsedBytes );
                         memcpy( remainder.data(), m_in.data() + parsedBytes, remainder.size() );
                         m_in = remainder;
 		}
@@ -112,7 +112,7 @@ Transfer* CoreProtocol::incomingTransfer()
 	}
 }
 
-void cp_dump( const QByteArray &bytes )
+void cp_dump( const TQByteArray &bytes )
 {
 #ifdef YAHOO_COREPROTOCOL_DEBUG
 	kdDebug(YAHOO_RAW_DEBUG) << " contains " << bytes.count() << " bytes" << endl;
@@ -133,11 +133,11 @@ void CoreProtocol::outgoingTransfer( Transfer* outgoing )
 	{
 		kdDebug(YAHOO_RAW_DEBUG) << " got YMSGTransfer" << endl;
 		YMSGTransfer *yt = (YMSGTransfer *) outgoing;
-		QByteArray bytesOut = yt->serialize();
+		TQByteArray bytesOut = yt->serialize();
 
-		//QTextStream dout( bytesOut, QIODevice::WriteOnly );
-		//dout.setEncoding( QTextStream::Latin1 );
-		//dout.setByteOrder( QDataStream::LittleEndian );
+		//TQTextStream dout( bytesOut, TQIODevice::WriteOnly );
+		//dout.setEncoding( TQTextStream::Latin1 );
+		//dout.setByteOrder( TQDataStream::LittleEndian );
 		//dout << bytesOut;
 		//kdDebug(YAHOO_RAW_DEBUG) << " " << bytesOut;
 		emit outgoingData( bytesOut );
@@ -149,7 +149,7 @@ void CoreProtocol::outgoingTransfer( Transfer* outgoing )
 
 
 
-int CoreProtocol::wireToTransfer( const QByteArray& wire )
+int CoreProtocol::wireToTransfer( const TQByteArray& wire )
 {
 	kdDebug(YAHOO_GEN_DEBUG) << k_funcinfo << endl;
 	// processing incoming data and reassembling it into transfers
@@ -163,8 +163,8 @@ int CoreProtocol::wireToTransfer( const QByteArray& wire )
 		return bytesParsed;
 	}
 
-	QByteArray tempWire = wire;
-	QDataStream din( tempWire, IO_ReadOnly );
+	TQByteArray tempWire = wire;
+	TQDataStream din( tempWire, IO_ReadOnly );
 
 	// look at first four bytes and decide what to do with the chunk
 	if ( okToProceed( din ) )
@@ -194,8 +194,8 @@ int CoreProtocol::wireToTransfer( const QByteArray& wire )
 		else
 		{
 			kdDebug(YAHOO_RAW_DEBUG) << " - not a valid YMSG packet. Trying to recover." << endl;
-			QTextStream s( wire, IO_ReadOnly );
-			QString remaining = s.read();
+			TQTextStream s( wire, IO_ReadOnly );
+			TQString remaining = s.read();
 			int pos = remaining.find( "YMSG", bytesParsed );
 			if( pos >= 0 )
 			{
@@ -217,12 +217,12 @@ void CoreProtocol::reset()
 	m_in.resize( 0 );
 }
 
-void CoreProtocol::slotOutgoingData( const QByteArray &out )
+void CoreProtocol::slotOutgoingData( const TQByteArray &out )
 {
 	qDebug( "%s", out.data() );
 }
 
-bool CoreProtocol::okToProceed( QDataStream &din)
+bool CoreProtocol::okToProceed( TQDataStream &din)
 {
 	if ( din.atEnd() )
 	{
diff --git a/kopete/protocols/yahoo/libkyahoo/coreprotocol.h b/kopete/protocols/yahoo/libkyahoo/coreprotocol.h
index 6432093c..c1c05d89 100644
--- a/kopete/protocols/yahoo/libkyahoo/coreprotocol.h
+++ b/kopete/protocols/yahoo/libkyahoo/coreprotocol.h
@@ -22,7 +22,7 @@
 #ifndef YAHOO_CORE_PROTOCOL_H
 #define YAHOO_CORE_PROTOCOL_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 class Transfer;
 class YMSGProtocol;
@@ -47,7 +47,7 @@ public:
 	 * This requires parsing out each FLAP, etc. from the incoming data
 	 * @param incomingBytes Raw data in wire format.
 	 */
-	void addIncomingData( const QByteArray& incomingBytes );
+	void addIncomingData( const TQByteArray& incomingBytes );
 
 	/**
 	 * @return the incoming transfer or 0 if none is available.
@@ -69,7 +69,7 @@ signals:
 	/**
 	 * Emitted as the core protocol converts fields to wire ready data
 	 */
-	void outgoingData( const QByteArray& );
+	void outgoingData( const TQByteArray& );
 
 	/**
 	 * Emitted when there is incoming data, parsed into a Transfer
@@ -79,21 +79,21 @@ protected slots:
 	/**
 	 * Just a debug method to test emitting to the socket, atm - should go to the ClientStream
 	 */
-	void slotOutgoingData( const QByteArray & );
+	void slotOutgoingData( const TQByteArray & );
 
 protected:
 	/**
 	 * Check that there is data to read, and set the protocol's state if there isn't any.
 	 */
-	bool okToProceed( QDataStream & );
+	bool okToProceed( TQDataStream & );
 	/**
 	 * Convert incoming wire data into a Transfer object and queue it
 	 * @return number of bytes from the input that were parsed into a Transfer
 	 */
-	int wireToTransfer( const QByteArray& wire );
+	int wireToTransfer( const TQByteArray& wire );
 
 private:
-	QByteArray m_in;	// buffer containing unprocessed bytes we received
+	TQByteArray m_in;	// buffer containing unprocessed bytes we received
 	int m_error;
 	Transfer* m_inTransfer; // the transfer that is being received
 	int m_state;		// represents the protocol's overall state
diff --git a/kopete/protocols/yahoo/libkyahoo/filetransfernotifiertask.cpp b/kopete/protocols/yahoo/libkyahoo/filetransfernotifiertask.cpp
index e011dfeb..fd9657f7 100644
--- a/kopete/protocols/yahoo/libkyahoo/filetransfernotifiertask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/filetransfernotifiertask.cpp
@@ -20,8 +20,8 @@
 #include "yahootypes.h"
 #include "client.h"
 
-#include <qstring.h>
-#include <qpixmap.h>
+#include <tqstring.h>
+#include <tqpixmap.h>
 #include <kdebug.h>
 //#include <kcodecs.h>
 
@@ -76,12 +76,12 @@ void FileTransferNotifierTask::parseFileTransfer( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString from;		/* key = 4  */
-	QString to;		/* key = 5  */
-	QString url;		/* key = 20  */
+	TQString from;		/* key = 4  */
+	TQString to;		/* key = 5  */
+	TQString url;		/* key = 20  */
 	long expires;		/* key = 38  */
-	QString msg;		/* key = 14  */
-	QString filename;	/* key = 27  */
+	TQString msg;		/* key = 14  */
+	TQString filename;	/* key = 27  */
 	unsigned long size;	/* key = 28  */
 
 	from = t->firstParam( 4 );
@@ -108,22 +108,22 @@ void FileTransferNotifierTask::parseFileTransfer( YMSGTransfer *t )
         unsigned int right = url.findRev( '?' );
 	filename = url.mid( left, right - left );
 
-	emit incomingFileTransfer( from, url, expires, msg, filename, size, QPixmap() );
+	emit incomingFileTransfer( from, url, expires, msg, filename, size, TQPixmap() );
 }
 
 void FileTransferNotifierTask::parseFileTransfer7( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString from;		/* key = 4  */
-	QString to;		/* key = 5  */
-	QString url;		/* key = 20  */
+	TQString from;		/* key = 4  */
+	TQString to;		/* key = 5  */
+	TQString url;		/* key = 20  */
 	long expires;		/* key = 38  */
-	QString msg;		/* key = 14  */
-	QString filename;	/* key = 27  */
+	TQString msg;		/* key = 14  */
+	TQString filename;	/* key = 27  */
 	unsigned long size;	/* key = 28  */
-	QByteArray preview;	/* key = 267 */
-	QPixmap previewPixmap;
+	TQByteArray preview;	/* key = 267 */
+	TQPixmap previewPixmap;
 
 	if( t->firstParam( 222 ).toInt() == 2 )
 		return;					// user cancelled the file transfer
@@ -137,7 +137,7 @@ void FileTransferNotifierTask::parseFileTransfer7( YMSGTransfer *t )
 	size = t->firstParam( 28 ).toULong();
 
 	// FIXME (same)
-	//preview = QByteArray::fromBase64( t->firstParam( 267 ) );
+	//preview = TQByteArray::fromBase64( t->firstParam( 267 ) );
 
 	if( preview.size() > 0 )
 	{
diff --git a/kopete/protocols/yahoo/libkyahoo/filetransfernotifiertask.h b/kopete/protocols/yahoo/libkyahoo/filetransfernotifiertask.h
index 24b684f4..d5f6c7f2 100644
--- a/kopete/protocols/yahoo/libkyahoo/filetransfernotifiertask.h
+++ b/kopete/protocols/yahoo/libkyahoo/filetransfernotifiertask.h
@@ -39,8 +39,8 @@ public:
 protected:
 	virtual bool forMe( const Transfer *transfer ) const;
 signals:
-	void incomingFileTransfer( const QString &who, const QString &url, long expires, const QString &msg ,
-	const QString &fname, unsigned long size, const QPixmap &preview );
+	void incomingFileTransfer( const TQString &who, const TQString &url, long expires, const TQString &msg ,
+	const TQString &fname, unsigned long size, const TQPixmap &preview );
 private:
 	void parseFileTransfer( YMSGTransfer *transfer );
 	void parseFileTransfer7( YMSGTransfer *transfer );
diff --git a/kopete/protocols/yahoo/libkyahoo/inputprotocolbase.cpp b/kopete/protocols/yahoo/libkyahoo/inputprotocolbase.cpp
index eca3318a..15c3b078 100644
--- a/kopete/protocols/yahoo/libkyahoo/inputprotocolbase.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/inputprotocolbase.cpp
@@ -19,8 +19,8 @@
 #include "inputprotocolbase.h"
 
 
-InputProtocolBase::InputProtocolBase(QObject *parent, const char *name)
- : QObject(parent, name)
+InputProtocolBase::InputProtocolBase(TQObject *parent, const char *name)
+ : TQObject(parent, name)
 {
 }
 
@@ -34,13 +34,13 @@ uint InputProtocolBase::state() const
 	return m_state;
 }
 
-bool InputProtocolBase::readString( QString &message )
+bool InputProtocolBase::readString( TQString &message )
 {
 	uint len;
-	QCString rawData;
+	TQCString rawData;
 	if ( !safeReadBytes( rawData, len ) )
 		return false;
-	message = QString::fromUtf8( rawData.data(), len - 1 );
+	message = TQString::fromUtf8( rawData.data(), len - 1 );
 	return true;
 }
 
@@ -61,7 +61,7 @@ bool InputProtocolBase::okToProceed()
 }
 
 // FIXME: need to be checked
-bool InputProtocolBase::safeReadBytes( QCString & data, uint & len )
+bool InputProtocolBase::safeReadBytes( TQCString & data, uint & len )
 {
 	// read the length of the bytes
 	Q_UINT32 val;
@@ -72,7 +72,7 @@ bool InputProtocolBase::safeReadBytes( QCString & data, uint & len )
 	if ( val > 1024 )
 		return false;
 	//qDebug( "EventProtocol::safeReadBytes() - expecting %i bytes", val );
-	QCString temp( val );
+	TQCString temp( val );
 	if ( val != 0 )
 	{
 		if ( !okToProceed() )
diff --git a/kopete/protocols/yahoo/libkyahoo/inputprotocolbase.h b/kopete/protocols/yahoo/libkyahoo/inputprotocolbase.h
index 18a3dab3..e236bc68 100644
--- a/kopete/protocols/yahoo/libkyahoo/inputprotocolbase.h
+++ b/kopete/protocols/yahoo/libkyahoo/inputprotocolbase.h
@@ -19,7 +19,7 @@
 #ifndef INPUTPROTOCOLBASE_H
 #define INPUTPROTOCOLBASE_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 class Transfer;
 /**
@@ -32,7 +32,7 @@ class InputProtocolBase : public QObject
 Q_OBJECT
 public:
 	enum EventProtocolState { Success, NeedMore, OutOfSync, ProtocolError };
-	InputProtocolBase(QObject *parent = 0, const char *name = 0);
+	InputProtocolBase(TQObject *parent = 0, const char *name = 0);
 	~InputProtocolBase();
 	/**
 	 * Returns a value describing the state of the object.  
@@ -45,13 +45,13 @@ public:
 	 * @param bytes this will be set to the number of bytes that were successfully parsed.  It is no indication of the success of the whole procedure
 	 * @return On success, a Transfer object that the caller is responsible for deleting.  It will be either an EventTransfer or a Response, delete as appropriate.  On failure, returns 0.
 	 */
-	virtual Transfer * parse( const QByteArray &, uint & bytes ) = 0 ;
+	virtual Transfer * parse( const TQByteArray &, uint & bytes ) = 0 ;
 protected:
 	/**
 	 * Reads an arbitrary string
 	 * updates the bytes parsed counter
 	 */
-	bool readString( QString &message );
+	bool readString( TQString &message );
 	/**
 	 * Check that there is data to read, and set the protocol's state if there isn't any.
 	 */
@@ -61,12 +61,12 @@ protected:
 	 * updates the bytes parsed counter
 	 * @return false if the string was broken or there was no data available at all
 	 */
-	bool safeReadBytes( QCString & data, uint & len );
+	bool safeReadBytes( TQCString & data, uint & len );
 	
 protected:
 	uint m_state;
 	uint m_bytes;
-	QDataStream *m_din;
+	TQDataStream *m_din;
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/listtask.cpp b/kopete/protocols/yahoo/libkyahoo/listtask.cpp
index b1e35940..d299f963 100644
--- a/kopete/protocols/yahoo/libkyahoo/listtask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/listtask.cpp
@@ -14,8 +14,8 @@
     *************************************************************************
 */
 
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 
 #include "listtask.h"
 #include "transfer.h"
@@ -64,8 +64,8 @@ void ListTask::parseBuddyList( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString group;
-	QString buddy;
+	TQString group;
+	TQString buddy;
 	// We need some low-level parsing here
 
 	// FIXME same: need to check
@@ -90,7 +90,7 @@ void ListTask::parseBuddyList( YMSGTransfer *t )
 		case 301:
 			if( p.second == "319"){
 				kdDebug(YAHOO_RAW_DEBUG) << k_funcinfo << "Parsed buddy: " << buddy << " in group " << group << endl;
-				emit gotBuddy( buddy, QString(), group );
+				emit gotBuddy( buddy, TQString(), group );
 			}
 		}
 	}
@@ -100,11 +100,11 @@ void ListTask::parseStealthList( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString raw;
+	TQString raw;
 	raw = t->firstParam( 185 );
 
-	const QStringList buddies = QStringList::split( ',', raw );
-	for ( QStringList::ConstIterator it = buddies.begin(); it != buddies.end(); ++it )
+	const TQStringList buddies = TQStringList::split( ',', raw );
+	for ( TQStringList::ConstIterator it = buddies.begin(); it != buddies.end(); ++it )
 	{
 		emit stealthStatusChanged( *it, Yahoo::StealthActive );
 	}
diff --git a/kopete/protocols/yahoo/libkyahoo/listtask.h b/kopete/protocols/yahoo/libkyahoo/listtask.h
index cc058004..514df17e 100644
--- a/kopete/protocols/yahoo/libkyahoo/listtask.h
+++ b/kopete/protocols/yahoo/libkyahoo/listtask.h
@@ -39,8 +39,8 @@ protected:
 	void parseBuddyList( YMSGTransfer *transfer );
 	void parseStealthList( YMSGTransfer *transfer );
 signals:
-	void gotBuddy(const QString&, const QString&, const QString&);
-	void stealthStatusChanged( const QString&, Yahoo::StealthStatus );
+	void gotBuddy(const TQString&, const TQString&, const TQString&);
+	void stealthStatusChanged( const TQString&, Yahoo::StealthStatus );
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/logintask.cpp b/kopete/protocols/yahoo/libkyahoo/logintask.cpp
index d3b5be7b..3c3127b2 100644
--- a/kopete/protocols/yahoo/libkyahoo/logintask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/logintask.cpp
@@ -25,7 +25,7 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
+#include <tqstring.h>
 #include <kdebug.h>
 #include <stdlib.h>
 
@@ -179,10 +179,10 @@ void LoginTask::sendAuthResp(YMSGTransfer* t)
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString sn = t->firstParam( 1 );
-	QString seed = t->firstParam( 94 );
+	TQString sn = t->firstParam( 1 );
+	TQString seed = t->firstParam( 94 );
 	m_challengeString = seed;
-	QString version_s = t->firstParam( 13 );
+	TQString version_s = t->firstParam( 13 );
 	m_sessionID = t->id();
 	int version = version_s.toInt();
 
@@ -205,23 +205,23 @@ void LoginTask::sendAuthResp(YMSGTransfer* t)
 	emit haveSessionID( m_sessionID );
 }
 
-void LoginTask::sendAuthSixteenStage1(const QString& sn, const QString& seed)
+void LoginTask::sendAuthSixteenStage1(const TQString& sn, const TQString& seed)
 {
-	const QString YahooTokenUrl = "https://login.yahoo.com/config/pwtoken_get?src=ymsgr&ts=&login=%1&passwd=%2&chal=%3";
+	const TQString YahooTokenUrl = "https://login.yahoo.com/config/pwtoken_get?src=ymsgr&ts=&login=%1&passwd=%2&chal=%3";
 	kdDebug(YAHOO_RAW_DEBUG) << "seed:" << seed << endl;
-	m_stage1Data= QString::null;
+	m_stage1Data= TQString::null;
 	/* construct a URL from the seed and request tokens */
-	QByteArray encodedUrl;
-	QString fullUrl = YahooTokenUrl.arg(sn, client()->password(), seed);
+	TQByteArray encodedUrl;
+	TQString fullUrl = YahooTokenUrl.arg(sn, client()->password(), seed);
 	KURL tokenUrl(fullUrl);
 	KIO::Job* job = KIO::get(tokenUrl, true, false);
-	connect(job, SIGNAL(data(KIO::Job*, const QByteArray&)),
-	        this, SLOT(handleAuthSixteenStage1Data(KIO::Job*, const QByteArray&)));
-	connect(job, SIGNAL(result(KIO::Job*)),
-	        this, SLOT(handleAuthSixteenStage1Result(KIO::Job*)));
+	connect(job, TQT_SIGNAL(data(KIO::Job*, const TQByteArray&)),
+	        this, TQT_SLOT(handleAuthSixteenStage1Data(KIO::Job*, const TQByteArray&)));
+	connect(job, TQT_SIGNAL(result(KIO::Job*)),
+	        this, TQT_SLOT(handleAuthSixteenStage1Result(KIO::Job*)));
 }
 
-void LoginTask::handleAuthSixteenStage1Data(KIO::Job* job, const QByteArray& data)
+void LoginTask::handleAuthSixteenStage1Data(KIO::Job* job, const TQByteArray& data)
 {
 	kdDebug(YAHOO_RAW_DEBUG) << "data:" << data << endl;
 	m_stage1Data.append(data);
@@ -230,12 +230,12 @@ void LoginTask::handleAuthSixteenStage1Data(KIO::Job* job, const QByteArray& dat
 void LoginTask::handleAuthSixteenStage1Result(KIO::Job* job)
 {
 	int responseNumber = -1;
-	QString token;
+	TQString token;
 	int error = job->error();
 	kdDebug(YAHOO_RAW_DEBUG) << "error:" << error << endl;
 	if (error == 0)
 	{
-		QStringList responses = QStringList::split("\r\n", m_stage1Data);
+		TQStringList responses = TQStringList::split("\r\n", m_stage1Data);
 		responseNumber = responses[0].toInt();
 		if (responses.count() >= 3)
 		{
@@ -250,26 +250,26 @@ void LoginTask::handleAuthSixteenStage1Result(KIO::Job* job)
 			{
 			case -1:
 				/* error in the received stream */
-				emit loginResponse(Yahoo::LoginSock, QString());
+				emit loginResponse(Yahoo::LoginSock, TQString());
 				kdDebug(YAHOO_RAW_DEBUG) << "unknown error logging in" << endl;
 				break;
 			case 1212:
 				/* password incorrect */
-				emit loginResponse(Yahoo::LoginPasswd, QString());
+				emit loginResponse(Yahoo::LoginPasswd, TQString());
 				kdDebug(YAHOO_RAW_DEBUG) << "password incorrect" << endl;
 				break;
 			case 1213:
 				/* security lock */
-				emit loginResponse(Yahoo::LoginLock, QString());
+				emit loginResponse(Yahoo::LoginLock, TQString());
 				break;
 			case 1235:
 				/* username does not exist */
-				emit loginResponse(Yahoo::LoginUname, QString());
+				emit loginResponse(Yahoo::LoginUname, TQString());
 				kdDebug(YAHOO_RAW_DEBUG) << "user does not exist" << endl;
 				break;
 			case 1214:
 			case 1236:
-				emit loginResponse(Yahoo::LoginVerify, QString());
+				emit loginResponse(Yahoo::LoginVerify, TQString());
 				break;
 			case 100: /* username or password missing */
 				/*FIXME handle this */
@@ -287,21 +287,21 @@ void LoginTask::handleAuthSixteenStage1Result(KIO::Job* job)
 	}
 }
 
-void LoginTask::sendAuthSixteenStage2(const QString& token)
+void LoginTask::sendAuthSixteenStage2(const TQString& token)
 {
-	const QString YahooLoginUrl = "https://login.yahoo.com/config/pwtoken_login?src=ymsgr&ts=&token=%1";
+	const TQString YahooLoginUrl = "https://login.yahoo.com/config/pwtoken_login?src=ymsgr&ts=&token=%1";
 	kdDebug(YAHOO_RAW_DEBUG) << "token:" << token << endl;
-	m_stage2Data = QString::null;
-	QString fullUrl = YahooLoginUrl.arg(token);
+	m_stage2Data = TQString::null;
+	TQString fullUrl = YahooLoginUrl.arg(token);
 	KURL loginUrl(fullUrl);
 	KIO::Job* job = KIO::get(loginUrl, true, false);
-	connect(job, SIGNAL(data(KIO::Job*, const QByteArray&)),
-	        this, SLOT(handleAuthSixteenStage2Data(KIO::Job*, const QByteArray&)));
-	connect(job, SIGNAL(result(KIO::Job*)),
-	        this, SLOT(handleAuthSixteenStage2Result(KIO::Job*)));
+	connect(job, TQT_SIGNAL(data(KIO::Job*, const TQByteArray&)),
+	        this, TQT_SLOT(handleAuthSixteenStage2Data(KIO::Job*, const TQByteArray&)));
+	connect(job, TQT_SIGNAL(result(KIO::Job*)),
+	        this, TQT_SLOT(handleAuthSixteenStage2Result(KIO::Job*)));
 }
 
-void LoginTask::handleAuthSixteenStage2Data(KIO::Job*, const QByteArray& data)
+void LoginTask::handleAuthSixteenStage2Data(KIO::Job*, const TQByteArray& data)
 {
 	kdDebug(YAHOO_RAW_DEBUG) << "data:" << data << endl;
 	m_stage2Data.append(data);
@@ -309,13 +309,13 @@ void LoginTask::handleAuthSixteenStage2Data(KIO::Job*, const QByteArray& data)
 
 void LoginTask::handleAuthSixteenStage2Result(KIO::Job* job)
 {
-	QString crumb;
+	TQString crumb;
 	int responseNumber = -1;
 	int error = job->error();
 	kdDebug(YAHOO_RAW_DEBUG) << "error:" << error << endl;
 	if (error == 0)
 	{
-		QStringList responses = QStringList::split("\r\n", m_stage2Data);
+		TQStringList responses = TQStringList::split("\r\n", m_stage2Data);
 		kdDebug(YAHOO_RAW_DEBUG) << responses << endl;
 		responseNumber = responses[0].toInt();
 		if (responseNumber == 0)
@@ -331,10 +331,10 @@ void LoginTask::handleAuthSixteenStage2Result(KIO::Job* job)
 			switch(responseNumber)
 			{
 			case -1:
-				emit loginResponse(Yahoo::LoginSock, QString());
+				emit loginResponse(Yahoo::LoginSock, TQString());
 				break;
 			case 100:
-				emit loginResponse(Yahoo::LoginSock, QString());
+				emit loginResponse(Yahoo::LoginSock, TQString());
 				break;
 			default: /* try to login anyways */
 				break;
@@ -342,22 +342,22 @@ void LoginTask::handleAuthSixteenStage2Result(KIO::Job* job)
 		}
 		else
 		{
-			QString cryptString = crumb;
+			TQString cryptString = crumb;
 			cryptString.append(m_challengeString);
 			sendAuthSixteenStage3(cryptString);
 		}
 	}
 }
 
-void LoginTask::sendAuthSixteenStage3(const QString& cryptString)
+void LoginTask::sendAuthSixteenStage3(const TQString& cryptString)
 {
 	kdDebug(YAHOO_RAW_DEBUG) << " with crypt string" << cryptString << endl;
 
-	//QByteArray cryptStringHash = QCryptographicHash::hash( cryptString.toAscii(),
+	//TQByteArray cryptStringHash = QCryptographicHash::hash( cryptString.toAscii(),
 	//                                                       QCryptographicHash::Md5 );
 	//cryptStringHash = cryptStringHash.toBase64();
 
-	QString cryptStringHash = KMD5( cryptString.ascii() ).base64Digest();
+	TQString cryptStringHash = KMD5( cryptString.ascii() ).base64Digest();
 
 	cryptStringHash = cryptStringHash.replace('+', '.');
 	cryptStringHash = cryptStringHash.replace('/', '_');
@@ -379,7 +379,7 @@ void LoginTask::sendAuthSixteenStage3(const QString& cryptString)
 
 }
 
-void LoginTask::sendAuthResp_pre_0x0b(const QString &/*sn*/, const QString &/*seed*/)
+void LoginTask::sendAuthResp_pre_0x0b(const TQString &/*sn*/, const TQString &/*seed*/)
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 }
@@ -392,7 +392,7 @@ void LoginTask::handleAuthResp(YMSGTransfer *t)
 	{
 		case( Yahoo::ServiceList ):
 			kdDebug(YAHOO_RAW_DEBUG) << "Emitting Signal" << endl;
-			emit loginResponse( Yahoo::LoginOk, QString() );
+			emit loginResponse( Yahoo::LoginOk, TQString() );
 		break;
 		case( Yahoo::ServiceAuthResp ):
 			kdDebug(YAHOO_RAW_DEBUG) << "Emitting Signal" << endl;
@@ -415,7 +415,7 @@ void LoginTask::parseCookies( YMSGTransfer *t )
 
 	for( int i = 0; i < t->paramCount( 59 ); ++i)
 	{
-		QString cookie;
+		TQString cookie;
 		cookie = t->nthParam( 59, i );
         	if( cookie.startsWith( "Y" ) )
 		{
@@ -435,27 +435,27 @@ void LoginTask::parseCookies( YMSGTransfer *t )
 		emit haveCookies();
 }
 
-void LoginTask::setVerificationWord( const QString &word )
+void LoginTask::setVerificationWord( const TQString &word )
 {
 	m_verificationWord = word;
 }
 
-const QString& LoginTask::yCookie()
+const TQString& LoginTask::yCookie()
 {
 	return m_yCookie;
 }
 
-const QString& LoginTask::tCookie()
+const TQString& LoginTask::tCookie()
 {
 	return m_tCookie;
 }
 
-const QString& LoginTask::cCookie()
+const TQString& LoginTask::cCookie()
 {
 	return m_cCookie;
 }
 
-const QString& LoginTask::loginCookie()
+const TQString& LoginTask::loginCookie()
 {
 	return m_loginCookie;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/logintask.h b/kopete/protocols/yahoo/libkyahoo/logintask.h
index a3701692..563cd3a4 100644
--- a/kopete/protocols/yahoo/libkyahoo/logintask.h
+++ b/kopete/protocols/yahoo/libkyahoo/logintask.h
@@ -47,47 +47,47 @@ public:
 
 	void reset();
 	void setStateOnConnect( Yahoo::Status status );
-	void setVerificationWord( const QString &word );
+	void setVerificationWord( const TQString &word );
 
-	const QString &yCookie();
-	const QString &cCookie();
-	const QString &tCookie();
-	const QString &loginCookie();
+	const TQString &yCookie();
+	const TQString &cCookie();
+	const TQString &tCookie();
+	const TQString &loginCookie();
 protected:
 	virtual bool forMe( const Transfer* transfer ) const;
 	enum State { InitialState, SentVerify, GotVerifyACK, SentAuth, GotAuthACK, SentAuthResp };
 	void sendVerify();
 	void sendAuth(YMSGTransfer* transfer);
 	void sendAuthResp(YMSGTransfer* transfer);
-	void sendAuthResp_0x0b(const QString &sn, const QString &seed, uint sessionID);
-	void sendAuthResp_pre_0x0b(const QString &sn, const QString &seed);
+	void sendAuthResp_0x0b(const TQString &sn, const TQString &seed, uint sessionID);
+	void sendAuthResp_pre_0x0b(const TQString &sn, const TQString &seed);
 	void handleAuthResp(YMSGTransfer *transfer);
 	void parseCookies( YMSGTransfer *transfer );
-	void sendAuthSixteenStage1(const QString& sn, const QString& seed);
-	void sendAuthSixteenStage2(const QString& token);
-	void sendAuthSixteenStage3(const QString& cryptString);
+	void sendAuthSixteenStage1(const TQString& sn, const TQString& seed);
+	void sendAuthSixteenStage2(const TQString& token);
+	void sendAuthSixteenStage3(const TQString& cryptString);
 protected slots:
-	void handleAuthSixteenStage1Data(KIO::Job*, const QByteArray& data);
+	void handleAuthSixteenStage1Data(KIO::Job*, const TQByteArray& data);
 	void handleAuthSixteenStage1Result(KIO::Job*);
-	void handleAuthSixteenStage2Data(KIO::Job*, const QByteArray& data);
+	void handleAuthSixteenStage2Data(KIO::Job*, const TQByteArray& data);
 	void handleAuthSixteenStage2Result(KIO::Job*);
 
 signals:
 	void haveSessionID( uint );
 	void haveCookies();
-	void loginResponse( int, const QString& );
+	void loginResponse( int, const TQString& );
 	void buddyListReady();
 private:
 	State mState;
 	Yahoo::Status m_stateOnConnect;
-	QString m_yCookie;
-	QString m_tCookie;
-	QString m_cCookie;
-	QString m_loginCookie;
-	QString m_verificationWord;
-	QString m_stage1Data;
-	QString m_stage2Data;
-	QString m_challengeString;
+	TQString m_yCookie;
+	TQString m_tCookie;
+	TQString m_cCookie;
+	TQString m_loginCookie;
+	TQString m_verificationWord;
+	TQString m_stage1Data;
+	TQString m_stage2Data;
+	TQString m_challengeString;
 	uint m_sessionID;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/logofftask.cpp b/kopete/protocols/yahoo/libkyahoo/logofftask.cpp
index 0531283b..4816ba44 100644
--- a/kopete/protocols/yahoo/libkyahoo/logofftask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/logofftask.cpp
@@ -19,7 +19,7 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
+#include <tqstring.h>
 #include <kdebug.h>
 
 LogoffTask::LogoffTask(Task* parent) : Task(parent)
diff --git a/kopete/protocols/yahoo/libkyahoo/mailnotifiertask.cpp b/kopete/protocols/yahoo/libkyahoo/mailnotifiertask.cpp
index 1d637877..de6a1080 100644
--- a/kopete/protocols/yahoo/libkyahoo/mailnotifiertask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/mailnotifiertask.cpp
@@ -14,7 +14,7 @@
     *************************************************************************
 */
 
-#include <qstring.h>
+#include <tqstring.h>
 
 #include "mailnotifiertask.h"
 #include "transfer.h"
@@ -62,15 +62,15 @@ void MailNotifierTask::parseMail( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString count = t->firstParam( 9 );
-	QString mail = t->firstParam( 42 );
-	QString from = t->firstParam( 43 );
-	QString subject = t->firstParam( 18 );
+	TQString count = t->firstParam( 9 );
+	TQString mail = t->firstParam( 42 );
+	TQString from = t->firstParam( 43 );
+	TQString subject = t->firstParam( 18 );
 
 	if( !mail.isEmpty() && !from.isEmpty() && !subject.isEmpty() )
-		emit mailNotify( QString::fromLatin1( "%1 <%2>").arg( from, mail ), subject, count.toInt() );
+		emit mailNotify( TQString::fromLatin1( "%1 <%2>").arg( from, mail ), subject, count.toInt() );
 	else
-		emit mailNotify( QString(), QString(), count.toInt());
+		emit mailNotify( TQString(), TQString(), count.toInt());
 }
 
 #include "mailnotifiertask.moc"
diff --git a/kopete/protocols/yahoo/libkyahoo/mailnotifiertask.h b/kopete/protocols/yahoo/libkyahoo/mailnotifiertask.h
index 1564eb16..d2c03bdd 100644
--- a/kopete/protocols/yahoo/libkyahoo/mailnotifiertask.h
+++ b/kopete/protocols/yahoo/libkyahoo/mailnotifiertask.h
@@ -38,7 +38,7 @@ protected:
 	virtual bool forMe( const Transfer *transfer ) const;
 	void parseMail( YMSGTransfer *transfer );
 signals:
-	void mailNotify(const QString&, const QString&, int);
+	void mailNotify(const TQString&, const TQString&, int);
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/messagereceivertask.cpp b/kopete/protocols/yahoo/libkyahoo/messagereceivertask.cpp
index 698552a3..769b4abe 100644
--- a/kopete/protocols/yahoo/libkyahoo/messagereceivertask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/messagereceivertask.cpp
@@ -14,7 +14,7 @@
     *************************************************************************
 */
 
-#include <qstring.h>
+#include <tqstring.h>
 
 #include "messagereceivertask.h"
 #include "transfer.h"
@@ -73,12 +73,12 @@ void MessageReceiverTask::parseMessage( YMSGTransfer *t )
 	int cnt = t->paramCount( 5 );
 	for( int i = 0; i < cnt; ++i )
 	{
-		QString to = t->nthParam( 5, i );
-		QString timestamp = t->nthParamSeparated( 15, i, 4 );
-		QString utf8 = t->nthParamSeparated( 97, i, 4 );
-		QString from = t->nthParamSeparated( 1, i, 4 ).isEmpty() ? t->nthParam( 4, i ) : t->nthParamSeparated( 1, i, 4 );
-		QString msg = t->nthParamSeparated( 14, i, 4 );
-		QString sysmsg = t->nthParamSeparated( 16, i, 4 );
+		TQString to = t->nthParam( 5, i );
+		TQString timestamp = t->nthParamSeparated( 15, i, 4 );
+		TQString utf8 = t->nthParamSeparated( 97, i, 4 );
+		TQString from = t->nthParamSeparated( 1, i, 4 ).isEmpty() ? t->nthParam( 4, i ) : t->nthParamSeparated( 1, i, 4 );
+		TQString msg = t->nthParamSeparated( 14, i, 4 );
+		TQString sysmsg = t->nthParamSeparated( 16, i, 4 );
 
 		// The arrangement of the key->value pairs is different when there is only one message in the packet.
 		// Separating by key "5" (sender) doesn't work in that case, because the "1" and "4" keys are sent before the "5" key
@@ -98,7 +98,7 @@ void MessageReceiverTask::parseMessage( YMSGTransfer *t )
 		}
 
 		if( utf8.startsWith( "1" ) )
-			msg = QString::fromUtf8( msg.latin1() );
+			msg = TQString::fromUtf8( msg.latin1() );
 
 		if( t->service() == Yahoo::ServiceSysMessage )
 			emit systemMessage( sysmsg );
@@ -116,11 +116,11 @@ void MessageReceiverTask::parseNotify( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString from = t->firstParam( 4 );
-	//QString to = t->firstParam( 5 );
-	QString type = t->firstParam( 49 );
-	QString stat = t->firstParam( 13 );
-	QString ind = t->firstParam( 14 );
+	TQString from = t->firstParam( 4 );
+	//TQString to = t->firstParam( 5 );
+	TQString type = t->firstParam( 49 );
+	TQString stat = t->firstParam( 13 );
+	TQString ind = t->firstParam( 14 );
 
 	if( type.startsWith( "TYPING" ) )
 		emit gotTypingNotify( from, stat.toInt() );
diff --git a/kopete/protocols/yahoo/libkyahoo/messagereceivertask.h b/kopete/protocols/yahoo/libkyahoo/messagereceivertask.h
index 6ff26bca..89536443 100644
--- a/kopete/protocols/yahoo/libkyahoo/messagereceivertask.h
+++ b/kopete/protocols/yahoo/libkyahoo/messagereceivertask.h
@@ -39,11 +39,11 @@ protected:
 	void parseMessage( YMSGTransfer *transfer );
 	void parseNotify( YMSGTransfer *transfer );
 signals:
-	void gotIm(const QString&, const QString&, long, int);
-	void gotBuzz( const QString &who, long tm );
-	void systemMessage(const QString&);
-	void gotTypingNotify(const QString &, int);
-	void gotWebcamInvite(const QString &);
+	void gotIm(const TQString&, const TQString&, long, int);
+	void gotBuzz( const TQString &who, long tm );
+	void systemMessage(const TQString&);
+	void gotTypingNotify(const TQString &, int);
+	void gotWebcamInvite(const TQString &);
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/modifybuddytask.cpp b/kopete/protocols/yahoo/libkyahoo/modifybuddytask.cpp
index 018d0e84..e83b1e4b 100644
--- a/kopete/protocols/yahoo/libkyahoo/modifybuddytask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/modifybuddytask.cpp
@@ -139,22 +139,22 @@ void ModifyBuddyTask::moveBuddy()
 	send( mov );
 }
 
-void ModifyBuddyTask::setTarget( const QString &target )
+void ModifyBuddyTask::setTarget( const TQString &target )
 {
 	m_target = target;
 }
 
-void ModifyBuddyTask::setMessage( const QString &text )
+void ModifyBuddyTask::setMessage( const TQString &text )
 {
 	m_message = text;
 }
 
-void ModifyBuddyTask::setGroup( const QString &group )
+void ModifyBuddyTask::setGroup( const TQString &group )
 {
 	m_group = group;
 }
 
-void ModifyBuddyTask::setOldGroup( const QString &old )
+void ModifyBuddyTask::setOldGroup( const TQString &old )
 {
 	m_oldGroup = old;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/modifybuddytask.h b/kopete/protocols/yahoo/libkyahoo/modifybuddytask.h
index 4b135f93..f3ceb73c 100644
--- a/kopete/protocols/yahoo/libkyahoo/modifybuddytask.h
+++ b/kopete/protocols/yahoo/libkyahoo/modifybuddytask.h
@@ -37,15 +37,15 @@ public:
 	bool take(Transfer *transfer);
 
 	void setType( Type type );
-	void setMessage( const QString &text );
-	void setTarget( const QString &target );
-	void setGroup( const QString &group );
-	void setOldGroup( const QString &group );
+	void setMessage( const TQString &text );
+	void setTarget( const TQString &target );
+	void setGroup( const TQString &group );
+	void setOldGroup( const TQString &group );
 
 signals:
-	void buddyAddResult( const QString &, const QString &, bool );
-	void buddyRemoveResult( const QString &, const QString &, bool );
-	void buddyChangeGroupResult( const QString &, const QString &, bool );
+	void buddyAddResult( const TQString &, const TQString &, bool );
+	void buddyRemoveResult( const TQString &, const TQString &, bool );
+	void buddyChangeGroupResult( const TQString &, const TQString &, bool );
 
 protected:
 	virtual bool forMe( const Transfer *transfer ) const;
@@ -55,10 +55,10 @@ private:
 	void removeBuddy();
 	void moveBuddy();
 
-	QString m_message;
-	QString m_target;
-	QString m_group;
-	QString m_oldGroup;
+	TQString m_message;
+	TQString m_target;
+	TQString m_group;
+	TQString m_oldGroup;
 	Type m_type;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/modifyyabtask.cpp b/kopete/protocols/yahoo/libkyahoo/modifyyabtask.cpp
index 825f958d..1264272a 100644
--- a/kopete/protocols/yahoo/libkyahoo/modifyyabtask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/modifyyabtask.cpp
@@ -21,9 +21,9 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
-#include <qdatastream.h>
-#include <qdom.h>
+#include <tqstring.h>
+#include <tqdatastream.h>
+#include <tqdom.h>
 #include <klocale.h>
 #include <kio/global.h>
 #include <kio/job.h>
@@ -45,9 +45,9 @@ ModifyYABTask::~ModifyYABTask()
 void ModifyYABTask::onGo()
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
-	m_socket = new KBufferedSocket( "address.yahoo.com", QString::number(80) );
-	connect( m_socket, SIGNAL( connected( const KResolverEntry& ) ), this, SLOT( connectSucceeded() ) );
-	connect( m_socket, SIGNAL( gotError(int) ), this, SLOT( connectFailed(int) ) );
+	m_socket = new KBufferedSocket( "address.yahoo.com", TQString::number(80) );
+	connect( m_socket, TQT_SIGNAL( connected( const KResolverEntry& ) ), this, TQT_SLOT( connectSucceeded() ) );
+	connect( m_socket, TQT_SIGNAL( gotError(int) ), this, TQT_SLOT( connectFailed(int) ) );
 
 	m_socket->connect();
 }
@@ -59,15 +59,15 @@ void ModifyYABTask::setAction( Action action )
 
 void ModifyYABTask::setEntry( const YABEntry &entry )
 {
-	QDomDocument doc("");
-	QDomElement root = doc.createElement( "ab" );
-	QDomProcessingInstruction instr = doc.createProcessingInstruction("xml","version=\"1.0\" encoding=\"UTF-8\" ");
+	TQDomDocument doc("");
+	TQDomElement root = doc.createElement( "ab" );
+	TQDomProcessingInstruction instr = doc.createProcessingInstruction("xml","version=\"1.0\" encoding=\"UTF-8\" ");
   	doc.appendChild(instr);
 	root.setAttribute( "k", client()->userId() );
 	root.setAttribute( "cc", "1" );
 	doc.appendChild( root );
 
-	QDomElement contact = doc.createElement( "ct" );
+	TQDomElement contact = doc.createElement( "ct" );
 	entry.fillQDomElement( contact );
 	switch( m_action )
 	{
@@ -91,7 +91,7 @@ void ModifyYABTask::connectFailed( int i)
 {
 	m_socket->close();
 	client()->notifyError( i18n( "An error occurred while saving the address book entry." ),
-			QString( "%1 - %2").arg(i).arg(static_cast<const KBufferedSocket*>( sender() )->errorString()), Client::Error );
+			TQString( "%1 - %2").arg(i).arg(static_cast<const KBufferedSocket*>( sender() )->errorString()), Client::Error );
 }
 
 void ModifyYABTask::connectSucceeded()
@@ -99,7 +99,7 @@ void ModifyYABTask::connectSucceeded()
 	kdDebug(YAHOO_RAW_DEBUG) ;
 	KBufferedSocket* socket = const_cast<KBufferedSocket*>( static_cast<const KBufferedSocket*>( sender() ) );
 
-	QString header = QString::fromLatin1("POST /yab/us?v=XM&prog=ymsgr&.intl=us&sync=1&tags=short&noclear=1& HTTP/1.1\r\n"
+	TQString header = TQString::fromLatin1("POST /yab/us?v=XM&prog=ymsgr&.intl=us&sync=1&tags=short&noclear=1& HTTP/1.1\r\n"
 			"Cookie: Y=%1; T=%2; C=%3 ;B=fckeert1kk1nl&b=2\r\n"
 			"User-Agent: Mozilla/4.0 (compatible; MSIE 5.5)\r\n"
 			"Host: address.yahoo.com\r\n"
@@ -108,9 +108,9 @@ void ModifyYABTask::connectSucceeded()
 			.arg(client()->yCookie()).arg(client()->tCookie())
 			.arg(client()->cCookie()).arg(m_postData.utf8().size());
 
-	QByteArray buffer;
-	QByteArray paket;
-	QDataStream stream( buffer, IO_WriteOnly );
+	TQByteArray buffer;
+	TQByteArray paket;
+	TQDataStream stream( buffer, IO_WriteOnly );
 	stream.writeRawBytes( header.local8Bit(), header.length() );
 	stream.writeRawBytes( m_postData.utf8(), m_postData.utf8().size() );
 
@@ -123,24 +123,24 @@ void ModifyYABTask::connectSucceeded()
 		return;
 	}
 
-	connect( m_socket, SIGNAL( readyRead() ), this, SLOT( slotRead() ) );
+	connect( m_socket, TQT_SIGNAL( readyRead() ), this, TQT_SLOT( slotRead() ) );
 }
 
 void ModifyYABTask::slotRead()
 {
 	KBufferedSocket* socket = const_cast<KBufferedSocket*>( static_cast<const KBufferedSocket*>( sender() ) );
-	QByteArray ar( socket->bytesAvailable() );
+	TQByteArray ar( socket->bytesAvailable() );
 	socket->readBlock( ar.data (), ar.size () );
-	QString data( ar );
+	TQString data( ar );
 	data = data.right( data.length() - data.find("<?xml") );
 
 	if( m_data.find("</ab>") < 0 )
 		return;						// Need more data
 
 	m_socket->close();
-	QDomDocument doc;
-	QDomNodeList list;
-	QDomElement e;
+	TQDomDocument doc;
+	TQDomNodeList list;
+	TQDomElement e;
 	int it = 0;
 
 	doc.setContent( m_data );
diff --git a/kopete/protocols/yahoo/libkyahoo/modifyyabtask.h b/kopete/protocols/yahoo/libkyahoo/modifyyabtask.h
index cb9acde8..543b582c 100644
--- a/kopete/protocols/yahoo/libkyahoo/modifyyabtask.h
+++ b/kopete/protocols/yahoo/libkyahoo/modifyyabtask.h
@@ -46,7 +46,7 @@ public:
 signals:
 	void gotEntry( YABEntry * );
 	void gotRevision( long rev, bool merged );
-	void error( YABEntry *, const QString &);
+	void error( YABEntry *, const TQString &);
 private slots:
 	void connectSucceeded();
 	void connectFailed( int );
@@ -54,8 +54,8 @@ private slots:
 private:
 	KIO::TransferJob *m_transferJob;
 	KNetwork::KBufferedSocket *m_socket;
-	QString m_postData;
-	QString m_data;
+	TQString m_postData;
+	TQString m_data;
 	Action m_action;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/oscartypes.h b/kopete/protocols/yahoo/libkyahoo/oscartypes.h
index 74ee818e..70d19c9a 100644
--- a/kopete/protocols/yahoo/libkyahoo/oscartypes.h
+++ b/kopete/protocols/yahoo/libkyahoo/oscartypes.h
@@ -19,7 +19,7 @@
 #ifndef OSCARTYPES_H
 #define OSCARTYPES_H
 
-#include <qglobal.h>
+#include <tqglobal.h>
 
 namespace Yahoo
 {
diff --git a/kopete/protocols/yahoo/libkyahoo/picturenotifiertask.cpp b/kopete/protocols/yahoo/libkyahoo/picturenotifiertask.cpp
index b88b99c6..d924b3a6 100644
--- a/kopete/protocols/yahoo/libkyahoo/picturenotifiertask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/picturenotifiertask.cpp
@@ -20,7 +20,7 @@
 #include "yahootypes.h"
 #include "client.h"
 
-#include <qstringlist.h>
+#include <tqstringlist.h>
 #include <kdebug.h>
 #include <klocale.h>
 
@@ -119,7 +119,7 @@ void PictureNotifierTask::parsePicture( YMSGTransfer *t )
 
 	QString	nick;		/* key = 4 */
 	int type;		/* key = 13: 1 = request, 2 = notification, 0 = Just changed */
-	QString url;		/* key = 20 */
+	TQString url;		/* key = 20 */
 	int checksum;		/* key = 192  */
 
 	nick = t->firstParam( 4 );
@@ -139,8 +139,8 @@ void PictureNotifierTask::parsePictureUploadResponse( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString url;
-	QString error;
+	TQString url;
+	TQString error;
 	int expires;
 
 	url = t->firstParam( 20 );
diff --git a/kopete/protocols/yahoo/libkyahoo/picturenotifiertask.h b/kopete/protocols/yahoo/libkyahoo/picturenotifiertask.h
index 1a6536af..851c8b9c 100644
--- a/kopete/protocols/yahoo/libkyahoo/picturenotifiertask.h
+++ b/kopete/protocols/yahoo/libkyahoo/picturenotifiertask.h
@@ -42,11 +42,11 @@ protected:
 	void parsePicture( YMSGTransfer *transfer );
 	void parsePictureUploadResponse( YMSGTransfer *transfer );
 signals:
-	void pictureStatusNotify( const QString &, int );
-	void pictureChecksumNotify( const QString &, int );
-	void pictureInfoNotify( const QString &, KURL, int );
-	void pictureRequest( const QString & );
-	void pictureUploaded( const QString &, int );
+	void pictureStatusNotify( const TQString &, int );
+	void pictureChecksumNotify( const TQString &, int );
+	void pictureInfoNotify( const TQString &, KURL, int );
+	void pictureRequest( const TQString & );
+	void pictureUploaded( const TQString &, int );
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/pingtask.cpp b/kopete/protocols/yahoo/libkyahoo/pingtask.cpp
index c8a97cd7..c453ff9d 100644
--- a/kopete/protocols/yahoo/libkyahoo/pingtask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/pingtask.cpp
@@ -21,7 +21,7 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
+#include <tqstring.h>
 #include <kdebug.h>
 
 PingTask::PingTask(Task* parent) : Task(parent)
diff --git a/kopete/protocols/yahoo/libkyahoo/receivefiletask.cpp b/kopete/protocols/yahoo/libkyahoo/receivefiletask.cpp
index 3bca2217..ec2e9f5f 100644
--- a/kopete/protocols/yahoo/libkyahoo/receivefiletask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/receivefiletask.cpp
@@ -20,8 +20,8 @@
 #include "yahootypes.h"
 #include "client.h"
 
-#include <qtimer.h>
-#include <qfile.h>
+#include <tqtimer.h>
+#include <tqfile.h>
 #include <kdebug.h>
 #include <klocale.h>
 #include <kio/global.h>
@@ -49,7 +49,7 @@ void ReceiveFileTask::onGo()
 	switch( m_type )
 	{
 	case FileTransferAccept:
-		m_file = new QFile( m_localUrl.path() );
+		m_file = new TQFile( m_localUrl.path() );
 		if( !m_file->open( IO_WriteOnly ) )
 		{
 			emit error( m_transferId, KIO::ERR_CANNOT_OPEN_FOR_WRITING, i18n("Could not open file for writing.") );
@@ -58,8 +58,8 @@ void ReceiveFileTask::onGo()
 			return;
 		}
 		m_transferJob = KIO::get( m_remoteUrl, false, false );
-		QObject::connect( m_transferJob, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotComplete( KIO::Job* ) ) );
-		QObject::connect( m_transferJob, SIGNAL( data( KIO::Job*, const QByteArray & ) ), this, SLOT( slotData( KIO::Job*, const QByteArray & ) ) );
+		TQObject::connect( m_transferJob, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( slotComplete( KIO::Job* ) ) );
+		TQObject::connect( m_transferJob, TQT_SIGNAL( data( KIO::Job*, const TQByteArray & ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray & ) ) );
 		delete t;
 		break;
 	case FileTransfer7Accept:
@@ -120,7 +120,7 @@ bool ReceiveFileTask::forMe( const Transfer *transfer ) const
 		return false;
 }
 
-void ReceiveFileTask::slotData( KIO::Job *job, const QByteArray& data )
+void ReceiveFileTask::slotData( KIO::Job *job, const TQByteArray& data )
 {
 	Q_UNUSED( job );
 	kdDebug(YAHOO_GEN_DEBUG) << k_funcinfo << endl;
@@ -168,7 +168,7 @@ void ReceiveFileTask::parseFileTransfer7Info( YMSGTransfer *transfer )
 	}
 	else if( transfer->firstParam( 249 ).toInt() == 3 )
 	{
-		m_file = new QFile( m_localUrl.path() );
+		m_file = new TQFile( m_localUrl.path() );
 		if( !m_file->open( IO_WriteOnly ) )
 		{
 			emit error( m_transferId, KIO::ERR_CANNOT_OPEN_FOR_WRITING, i18n("Could not open file for writing.") );
@@ -187,19 +187,19 @@ void ReceiveFileTask::parseFileTransfer7Info( YMSGTransfer *transfer )
 
 		send( t );
 		// The server expects a HTTP HEAD command prior to the GET
-		m_mimetypeJob = KIO::mimetype(QString::fromLatin1("http://%1/relay?token=%2&sender=%3&recver=%4")
-				.arg( QString(transfer->firstParam( 250 )) ).arg( QString(transfer->firstParam( 251 )) ).arg(m_userId).arg(client()->userId()), false);
+		m_mimetypeJob = KIO::mimetype(TQString::fromLatin1("http://%1/relay?token=%2&sender=%3&recver=%4")
+				.arg( TQString(transfer->firstParam( 250 )) ).arg( TQString(transfer->firstParam( 251 )) ).arg(m_userId).arg(client()->userId()), false);
 		m_mimetypeJob->addMetaData("cookies", "manual");
-		m_mimetypeJob->addMetaData("setcookies", QString::fromLatin1("Cookie: T=%1; path=/; domain=.yahoo.com; Y=%2; C=%3;")
+		m_mimetypeJob->addMetaData("setcookies", TQString::fromLatin1("Cookie: T=%1; path=/; domain=.yahoo.com; Y=%2; C=%3;")
 				.arg(client()->tCookie()).arg(client()->yCookie()).arg(client()->cCookie()) );
 
 
-		m_transferJob = KIO::get( QString::fromLatin1("http://%1/relay?token=%2&sender=%3&recver=%4")
-				.arg( QString(transfer->firstParam( 250 )) ).arg( QString(transfer->firstParam( 251 )) ).arg(m_userId).arg(client()->userId()), false, false );
-		QObject::connect( m_transferJob, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotComplete( KIO::Job* ) ) );
-		QObject::connect( m_transferJob, SIGNAL( data( KIO::Job*, const QByteArray & ) ), this, SLOT( slotData( KIO::Job*, const QByteArray & ) ) );
+		m_transferJob = KIO::get( TQString::fromLatin1("http://%1/relay?token=%2&sender=%3&recver=%4")
+				.arg( TQString(transfer->firstParam( 250 )) ).arg( TQString(transfer->firstParam( 251 )) ).arg(m_userId).arg(client()->userId()), false, false );
+		TQObject::connect( m_transferJob, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( slotComplete( KIO::Job* ) ) );
+		TQObject::connect( m_transferJob, TQT_SIGNAL( data( KIO::Job*, const TQByteArray & ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray & ) ) );
 		m_transferJob->addMetaData("cookies", "manual");
- 		m_transferJob->addMetaData("setcookies", QString::fromLatin1("Cookie: T=%1; path=/; domain=.yahoo.com; Y=%2;  path=/; domain=.yahoo.com;")
+ 		m_transferJob->addMetaData("setcookies", TQString::fromLatin1("Cookie: T=%1; path=/; domain=.yahoo.com; Y=%2;  path=/; domain=.yahoo.com;")
  				.arg(client()->tCookie()).arg(client()->yCookie()) );
 	}
 }
@@ -224,7 +224,7 @@ void ReceiveFileTask::setType( Type type )
 	m_type = type;
 }
 
-void ReceiveFileTask::setUserId( const QString &userId )
+void ReceiveFileTask::setUserId( const TQString &userId )
 {
 	m_userId = userId;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/receivefiletask.h b/kopete/protocols/yahoo/libkyahoo/receivefiletask.h
index 01644178..103f3230 100644
--- a/kopete/protocols/yahoo/libkyahoo/receivefiletask.h
+++ b/kopete/protocols/yahoo/libkyahoo/receivefiletask.h
@@ -45,10 +45,10 @@ public:
 
 	void setRemoteUrl( KURL url );
 	void setLocalUrl( KURL url );
-	void setFileName( const QString &filename );
+	void setFileName( const TQString &filename );
 	void setTransferId( unsigned int transferId );
 	void setType( Type type );
-	void setUserId( const QString & userId );
+	void setUserId( const TQString & userId );
 
 	bool take(Transfer *transfer);
 
@@ -58,10 +58,10 @@ protected:
 signals:
 	void bytesProcessed( unsigned int, unsigned int );
 	void complete( unsigned int );
-	void error( unsigned int, int, const QString & );
+	void error( unsigned int, int, const TQString & );
 
 private slots:
-	void slotData( KIO::Job *job, const QByteArray &data );
+	void slotData( KIO::Job *job, const TQByteArray &data );
 	void slotComplete( KIO::Job *job );
 	void canceled( unsigned int );
 
@@ -70,9 +70,9 @@ private:
 
 	KURL m_remoteUrl;
 	KURL m_localUrl;
-	QString m_fileName;
-	QString m_userId;
-	QFile *m_file;
+	TQString m_fileName;
+	TQString m_userId;
+	TQFile *m_file;
 	KIO::TransferJob *m_transferJob;
 	KIO::MimetypeJob *m_mimetypeJob;
 	unsigned int m_transferId;
diff --git a/kopete/protocols/yahoo/libkyahoo/requestpicturetask.cpp b/kopete/protocols/yahoo/libkyahoo/requestpicturetask.cpp
index 27a35430..55fb046e 100644
--- a/kopete/protocols/yahoo/libkyahoo/requestpicturetask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/requestpicturetask.cpp
@@ -43,7 +43,7 @@ void RequestPictureTask::onGo()
 	setSuccess();
 }
 
-void RequestPictureTask::setTarget( const QString &target )
+void RequestPictureTask::setTarget( const TQString &target )
 {
 	m_target = target;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/requestpicturetask.h b/kopete/protocols/yahoo/libkyahoo/requestpicturetask.h
index 8a96f6e7..05c192cd 100644
--- a/kopete/protocols/yahoo/libkyahoo/requestpicturetask.h
+++ b/kopete/protocols/yahoo/libkyahoo/requestpicturetask.h
@@ -33,9 +33,9 @@ public:
 
 	virtual void onGo();
 
-	void setTarget( const QString &target );
+	void setTarget( const TQString &target );
 private:
-	QString m_target;
+	TQString m_target;
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/safedelete.cpp b/kopete/protocols/yahoo/libkyahoo/safedelete.cpp
index 2b6b09cf..0b12c370 100644
--- a/kopete/protocols/yahoo/libkyahoo/safedelete.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/safedelete.cpp
@@ -19,7 +19,7 @@
 
 #include "safedelete.h"
 
-#include <qtimer.h>
+#include <tqtimer.h>
 
 //----------------------------------------------------------------------------
 // SafeDelete
@@ -35,7 +35,7 @@ SafeDelete::~SafeDelete()
 		lock->dying();
 }
 
-void SafeDelete::deleteLater(QObject *o)
+void SafeDelete::deleteLater(TQObject *o)
 {
 	if(!lock)
 		deleteSingle(o);
@@ -54,17 +54,17 @@ void SafeDelete::deleteAll()
 	if(list.isEmpty())
 		return;
 
-	QObjectListIt it(list);
-        for(QObject *o; (o = it.current()); ++it)
+	TQObjectListIt it(list);
+        for(TQObject *o; (o = it.current()); ++it)
 		deleteSingle(o);
 
 	list.clear();
 }
 
-void SafeDelete::deleteSingle(QObject *o)
+void SafeDelete::deleteSingle(TQObject *o)
 {
 #if QT_VERSION < 0x030000
-	// roll our own QObject::deleteLater()
+	// roll our own TQObject::deleteLater()
 	SafeDeleteLater *sdl = SafeDeleteLater::ensureExists();
 	sdl->deleteItLater(o);
 #else
@@ -117,7 +117,7 @@ SafeDeleteLater::SafeDeleteLater()
 {
 	list.setAutoDelete(true);
 	self = this;
-	QTimer::singleShot(0, this, SLOT(explode()));
+	TQTimer::singleShot(0, this, TQT_SLOT(explode()));
 }
 
 SafeDeleteLater::~SafeDeleteLater()
@@ -126,7 +126,7 @@ SafeDeleteLater::~SafeDeleteLater()
 	self = 0;
 }
 
-void SafeDeleteLater::deleteItLater(QObject *o)
+void SafeDeleteLater::deleteItLater(TQObject *o)
 {
 	list.append(o);
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/safedelete.h b/kopete/protocols/yahoo/libkyahoo/safedelete.h
index fd2ef937..ded0cb31 100644
--- a/kopete/protocols/yahoo/libkyahoo/safedelete.h
+++ b/kopete/protocols/yahoo/libkyahoo/safedelete.h
@@ -20,8 +20,8 @@
 #ifndef SAFEDELETE_H
 #define SAFEDELETE_H
 
-#include<qobject.h>
-#include<qobjectlist.h>
+#include<tqobject.h>
+#include<tqobjectlist.h>
 
 class SafeDelete;
 class SafeDeleteLock
@@ -43,13 +43,13 @@ public:
 	SafeDelete();
 	~SafeDelete();
 
-	void deleteLater(QObject *o);
+	void deleteLater(TQObject *o);
 
-	// same as QObject::deleteLater()
-	static void deleteSingle(QObject *o);
+	// same as TQObject::deleteLater()
+	static void deleteSingle(TQObject *o);
 
 private:
-	QObjectList list;
+	TQObjectList list;
 	void deleteAll();
 
 	friend class SafeDeleteLock;
@@ -62,7 +62,7 @@ class SafeDeleteLater : public QObject
 	Q_OBJECT
 public:
 	static SafeDeleteLater *ensureExists();
-	void deleteItLater(QObject *o);
+	void deleteItLater(TQObject *o);
 
 private slots:
 	void explode();
@@ -71,7 +71,7 @@ private:
 	SafeDeleteLater();
 	~SafeDeleteLater();
 
-	QObjectList list;
+	TQObjectList list;
 	friend class SafeDelete;
 	static SafeDeleteLater *self;
 };
diff --git a/kopete/protocols/yahoo/libkyahoo/sendauthresptask.cpp b/kopete/protocols/yahoo/libkyahoo/sendauthresptask.cpp
index 28dfc664..34e94c69 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendauthresptask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/sendauthresptask.cpp
@@ -20,7 +20,7 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
+#include <tqstring.h>
 #include <kdebug.h>
 
 SendAuthRespTask::SendAuthRespTask(Task* parent) : Task(parent)
@@ -59,12 +59,12 @@ void SendAuthRespTask::setGranted( bool granted )
 	m_granted = granted;
 }
 
-void SendAuthRespTask::setTarget( const QString &to )
+void SendAuthRespTask::setTarget( const TQString &to )
 {
 	m_target = to;
 }
 
-void SendAuthRespTask::setMessage( const QString &msg )
+void SendAuthRespTask::setMessage( const TQString &msg )
 {
 	m_msg = msg;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/sendauthresptask.h b/kopete/protocols/yahoo/libkyahoo/sendauthresptask.h
index fed15168..953dabc3 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendauthresptask.h
+++ b/kopete/protocols/yahoo/libkyahoo/sendauthresptask.h
@@ -35,12 +35,12 @@ public:
 	virtual void onGo();
 
 	void setGranted( bool );
-	void setTarget( const QString &to );
-	void setMessage( const QString &msg );
+	void setTarget( const TQString &to );
+	void setMessage( const TQString &msg );
 private:
-	QString m_target;
+	TQString m_target;
 	bool m_granted;
-	QString m_msg;
+	TQString m_msg;
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/sendfiletask.cpp b/kopete/protocols/yahoo/libkyahoo/sendfiletask.cpp
index 5cdcf5c3..48af8684 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendfiletask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/sendfiletask.cpp
@@ -19,8 +19,8 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
-#include <qtimer.h>
+#include <tqstring.h>
+#include <tqtimer.h>
 #include <kapplication.h> // for random()
 #include <kdebug.h>
 #include <klocale.h>
@@ -35,7 +35,7 @@ SendFileTask::SendFileTask(Task* parent) : Task(parent)
 	m_transmitted = 0;
 	m_socket = 0;
 
-	QTime epoch(0, 0, 0);
+	TQTime epoch(0, 0, 0);
 }
 
 SendFileTask::~SendFileTask()
@@ -132,7 +132,7 @@ void SendFileTask::sendFileTransferInfo()
 {
 	kdDebug(YAHOO_GEN_DEBUG) << k_funcinfo << endl;
 
-	KResolverResults results = KResolver::resolve("filetransfer.msg.yahoo.com", QString::number(80));
+	KResolverResults results = KResolver::resolve("filetransfer.msg.yahoo.com", TQString::number(80));
 	if(results.count() > 0)
 	{
 		m_relayHost = results.first().address().toString();
@@ -175,10 +175,10 @@ void SendFileTask::parseTransferAccept(const Transfer *transfer)
 	m_token = KURL::encode_string(t->firstParam(251));
 	kdDebug(YAHOO_RAW_DEBUG) << "Token: " << m_token << endl;
 
-	m_socket = new KStreamSocket( m_relayHost, QString::number(80) );
+	m_socket = new KStreamSocket( m_relayHost, TQString::number(80) );
 	m_socket->setBlocking( true );
-	connect( m_socket, SIGNAL( connected( const KResolverEntry& ) ), this, SLOT( connectSucceeded() ) );
-	connect( m_socket, SIGNAL( gotError(int) ), this, SLOT( connectFailed(int) ) );
+	connect( m_socket, TQT_SIGNAL( connected( const KResolverEntry& ) ), this, TQT_SLOT( connectSucceeded() ) );
+	connect( m_socket, TQT_SIGNAL( gotError(int) ), this, TQT_SLOT( connectFailed(int) ) );
 
 	m_socket->connect();
 
@@ -186,7 +186,7 @@ void SendFileTask::parseTransferAccept(const Transfer *transfer)
 
 void SendFileTask::connectFailed( int i )
 {
-	QString err = KSocketBase::errorString(m_socket->error());
+	TQString err = KSocketBase::errorString(m_socket->error());
 	kdDebug(YAHOO_RAW_DEBUG) << i << ": " << err << endl;
 	emit error( m_transferId, i, err );
 	setError();
@@ -196,8 +196,8 @@ void SendFileTask::connectSucceeded()
 {
 	kdDebug(YAHOO_GEN_DEBUG) << k_funcinfo << endl;
 
-	QByteArray buffer;
-	QDataStream stream( buffer, IO_WriteOnly );
+	TQByteArray buffer;
+	TQDataStream stream( buffer, IO_WriteOnly );
 
 	if ( m_file.open(IO_ReadOnly ) )
 	{
@@ -212,7 +212,7 @@ void SendFileTask::connectSucceeded()
 	}
 
 	kdDebug(YAHOO_RAW_DEBUG) << k_funcinfo << "Sizes: File (" << m_url << "): " << m_file.size() << endl;
-	QString header =
+	TQString header =
 		"POST /relay?token=" + m_token +
 		"&sender=" + client()->userId() +
 		"&recver=" + m_target + " HTTP/1.1\r\n"
@@ -220,7 +220,7 @@ void SendFileTask::connectSucceeded()
 		"Cache-Control: no-cache\r\n"
 		"Cookie: T=" + client()->tCookie() + "; Y=" + client()->yCookie() + "\r\n"
 		"Host: " + m_relayHost + "\r\n"
-		"Content-Length: " + QString::number(m_file.size()) + "\r\n"
+		"Content-Length: " + TQString::number(m_file.size()) + "\r\n"
 		"Connection: Close\r\n\r\n";
 	kdDebug() << header << endl;
 	stream.writeRawBytes( header.local8Bit(), header.length() );
@@ -232,7 +232,7 @@ void SendFileTask::connectSucceeded()
 	}
 	else
 	{
-		connect( m_socket, SIGNAL(readyWrite()), this, SLOT(transmitData()) );
+		connect( m_socket, TQT_SIGNAL(readyWrite()), this, TQT_SLOT(transmitData()) );
 		m_socket->enableWrite( true );
 	}
 }
@@ -271,12 +271,12 @@ void SendFileTask::transmitData()
 		m_socket->enableWrite( true );
 	}
 }
-void SendFileTask::setTarget( const QString &to )
+void SendFileTask::setTarget( const TQString &to )
 {
 	m_target = to;
 }
 
-void SendFileTask::setMessage( const QString &msg )
+void SendFileTask::setMessage( const TQString &msg )
 {
 	m_msg = msg;
 }
@@ -303,11 +303,11 @@ void SendFileTask::canceled( unsigned int id )
 	setError();
 }
 
-QString SendFileTask::newYahooTransferId()
+TQString SendFileTask::newYahooTransferId()
 {
 	// Adapted from libpurple/protocols/yahoo/yahoo_filexfer.c yahoo_xfer_new_xfer_id()
 
-	QString newId;
+	TQString newId;
 
 	for(int i = 0; i < 22; i++)
 	{
diff --git a/kopete/protocols/yahoo/libkyahoo/sendfiletask.h b/kopete/protocols/yahoo/libkyahoo/sendfiletask.h
index 83a205e2..1da3a7ae 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendfiletask.h
+++ b/kopete/protocols/yahoo/libkyahoo/sendfiletask.h
@@ -19,7 +19,7 @@
 
 #include "task.h"
 #include <kurl.h>
-#include <qfile.h>
+#include <tqfile.h>
 
 class QString;
 namespace KNetwork{
@@ -40,15 +40,15 @@ public:
 	
 	bool take(Transfer *transfer);
 
-	void setTarget( const QString &to );
-	void setMessage( const QString &msg );
+	void setTarget( const TQString &to );
+	void setMessage( const TQString &msg );
 	void setFileUrl( KURL url );
 	void setTransferId( unsigned int transferId );
 
 signals:
 	void bytesProcessed( unsigned int, unsigned int );
 	void complete( unsigned int );
-	void error( unsigned int, int, const QString & );
+	void error( unsigned int, int, const TQString & );
 
 	void declined();
 
@@ -58,7 +58,7 @@ protected:
 	void parseFileTransfer( const Transfer *transfer );
 	void parseTransferAccept(const Transfer *transfer);
 
-	QString newYahooTransferId();
+	TQString newYahooTransferId();
 
 private slots:
 	void connectSucceeded();
@@ -67,17 +67,17 @@ private slots:
 	void canceled( unsigned int );
 
 private:
-	QString m_msg;
-	QString m_target;
+	TQString m_msg;
+	TQString m_target;
 	KURL m_url;
-	QFile m_file;
+	TQFile m_file;
 	unsigned int m_transferId;
 	unsigned int m_transmitted;
 	KNetwork::KStreamSocket *m_socket;
 
-	QString m_relayHost;
-	QString m_token;
-	QString m_yahooTransferId;
+	TQString m_relayHost;
+	TQString m_token;
+	TQString m_yahooTransferId;
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/sendmessagetask.cpp b/kopete/protocols/yahoo/libkyahoo/sendmessagetask.cpp
index bb6e4802..828c6832 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendmessagetask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/sendmessagetask.cpp
@@ -19,7 +19,7 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
+#include <tqstring.h>
 #include <kdebug.h>
 #include <klocale.h>
 
@@ -64,12 +64,12 @@ void SendMessageTask::onGo()
 	setSuccess();
 }
 
-void SendMessageTask::setTarget( const QString &to )
+void SendMessageTask::setTarget( const TQString &to )
 {
 	m_target = to;
 }
 
-void SendMessageTask::setText( const QString &text )
+void SendMessageTask::setText( const TQString &text )
 {
 	m_text = text;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/sendmessagetask.h b/kopete/protocols/yahoo/libkyahoo/sendmessagetask.h
index b4c31efe..eef62c13 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendmessagetask.h
+++ b/kopete/protocols/yahoo/libkyahoo/sendmessagetask.h
@@ -32,12 +32,12 @@ public:
 	
 	virtual void onGo();
 	
-	void setText( const QString &text );
-	void setTarget( const QString &to );
+	void setText( const TQString &text );
+	void setTarget( const TQString &to );
 	void setPicureFlag( int flag );
 private:
-	QString m_text;
-	QString m_target;
+	TQString m_text;
+	TQString m_target;
 	int m_pictureFlag;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/sendnotifytask.cpp b/kopete/protocols/yahoo/libkyahoo/sendnotifytask.cpp
index ed424bd3..638a1811 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendnotifytask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/sendnotifytask.cpp
@@ -72,7 +72,7 @@ void SendNotifyTask::setType( Type type )
 	m_type = type;
 }
 
-void SendNotifyTask::setTarget( const QString &to )
+void SendNotifyTask::setTarget( const TQString &to )
 {
 	m_target = to;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/sendnotifytask.h b/kopete/protocols/yahoo/libkyahoo/sendnotifytask.h
index 67c0547a..2fee8fc6 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendnotifytask.h
+++ b/kopete/protocols/yahoo/libkyahoo/sendnotifytask.h
@@ -37,10 +37,10 @@ public:
 	virtual void onGo();
 
 	void setType( Type type );
-	void setTarget( const QString &to );
+	void setTarget( const TQString &to );
 	void setState( State );
 private:
-	QString m_target;
+	TQString m_target;
 	Type m_type;
 	State m_state;
 };
diff --git a/kopete/protocols/yahoo/libkyahoo/sendpicturetask.cpp b/kopete/protocols/yahoo/libkyahoo/sendpicturetask.cpp
index 84edecaa..ab10873a 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendpicturetask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/sendpicturetask.cpp
@@ -19,9 +19,9 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
-#include <qfile.h>
-#include <qdatastream.h>
+#include <tqstring.h>
+#include <tqfile.h>
+#include <tqdatastream.h>
 #include <kio/global.h>
 #include <kio/job.h>
 #include <kio/jobclasses.h>
@@ -64,10 +64,10 @@ void SendPictureTask::onGo()
 void SendPictureTask::initiateUpload()
 {
 	kdDebug(YAHOO_GEN_DEBUG) << k_funcinfo << endl;
-	m_socket = new KBufferedSocket( "filetransfer.msg.yahoo.com", QString::number(80) );
-	connect( m_socket, SIGNAL( connected( const KResolverEntry& ) ), this, SLOT( connectSucceeded() ) );
-	connect( m_socket, SIGNAL( gotError(int) ), this, SLOT( connectFailed(int) ) );
-	connect( m_socket, SIGNAL( readyRead() ), this, SLOT( readResult() ) );
+	m_socket = new KBufferedSocket( "filetransfer.msg.yahoo.com", TQString::number(80) );
+	connect( m_socket, TQT_SIGNAL( connected( const KResolverEntry& ) ), this, TQT_SLOT( connectSucceeded() ) );
+	connect( m_socket, TQT_SIGNAL( gotError(int) ), this, TQT_SLOT( connectFailed(int) ) );
+	connect( m_socket, TQT_SIGNAL( readyRead() ), this, TQT_SLOT( readResult() ) );
 
 	m_socket->connect();
 }
@@ -76,7 +76,7 @@ void SendPictureTask::connectFailed( int i)
 {
 	kdDebug(YAHOO_RAW_DEBUG) << i << ": " << static_cast<const KBufferedSocket*>( sender() )->errorString() << endl;
 
-	client()->notifyError(i18n("The picture was not successfully uploaded"), QString("%1 - %2").arg(i).arg(static_cast<const KBufferedSocket*>( sender() )->errorString()), Client::Error );
+	client()->notifyError(i18n("The picture was not successfully uploaded"), TQString("%1 - %2").arg(i).arg(static_cast<const KBufferedSocket*>( sender() )->errorString()), Client::Error );
 	setError();
 }
 
@@ -85,7 +85,7 @@ void SendPictureTask::connectSucceeded()
 	kdDebug(YAHOO_GEN_DEBUG) << k_funcinfo << endl;
 	YMSGTransfer t(Yahoo::ServicePictureUpload);
 
-	QFile file( m_path );
+	TQFile file( m_path );
 
 	t.setId( client()->sessionID() );
 	t.setParam( 1, client()->userId().local8Bit());
@@ -94,9 +94,9 @@ void SendPictureTask::connectSucceeded()
 	t.setParam( 28, file.size() );
 	t.setParam( 27, m_fileName.local8Bit() );
 	t.setParam( 14, "" );
-	QByteArray buffer;
-	QByteArray paket;
-	QDataStream stream( buffer, IO_WriteOnly );
+	TQByteArray buffer;
+	TQByteArray paket;
+	TQDataStream stream( buffer, IO_WriteOnly );
 
 	if ( file.open( IO_ReadOnly ) )
 	{
@@ -111,7 +111,7 @@ void SendPictureTask::connectSucceeded()
 
 	paket = t.serialize();
 	kdDebug(YAHOO_RAW_DEBUG) << "Sizes: File (" << m_path << "): " << file.size() << " - paket: " << paket.size() << endl;
-	QString header = QString::fromLatin1("POST /notifyft HTTP/1.1\r\n"
+	TQString header = TQString::fromLatin1("POST /notifyft HTTP/1.1\r\n"
 			"Cookie: Y=%1; T=%2; C=%3 ;\r\n"
 			"User-Agent: Mozilla/4.0 (compatible; MSIE 5.5)\r\n"
 			"Host: filetransfer.msg.yahoo.com\r\n"
@@ -142,7 +142,7 @@ void SendPictureTask::readResult()
 
 	// FIXME: to check
 // 	m_socket->enableRead( false );
-// 	QByteArray buf;
+// 	TQByteArray buf;
 // 	buf.resize( m_socket->bytesAvailable() );
 // 	m_socket->read( buf.data(), m_socket->bytesAvailable() );
 //
@@ -158,9 +158,9 @@ void SendPictureTask::readResult()
 // 	}
 
 	// from original file
-	QByteArray ar( m_socket->bytesAvailable() );
+	TQByteArray ar( m_socket->bytesAvailable() );
         m_socket->readBlock ( ar.data (), ar.size () );
-        QString buf( ar );
+        TQString buf( ar );
 
         m_socket->close();
         if( buf.find( "error", 0, false ) >= 0 )
@@ -227,12 +227,12 @@ void SendPictureTask::setType( Type type )
 	m_type = type;
 }
 
-void SendPictureTask::setTarget( const QString &to )
+void SendPictureTask::setTarget( const TQString &to )
 {
 	m_target = to;
 }
 
-void SendPictureTask::setFilename( const QString &filename )
+void SendPictureTask::setFilename( const TQString &filename )
 {
 	m_fileName = filename;
 }
@@ -242,7 +242,7 @@ void SendPictureTask::setFilesize( int filesize )
 	m_fileSize = filesize;
 }
 
-void SendPictureTask::setPath( const QString &path )
+void SendPictureTask::setPath( const TQString &path )
 {
 	m_path = path;
 }
@@ -257,7 +257,7 @@ void SendPictureTask::setStatus( int status )
 	m_status = status;
 }
 
-void SendPictureTask::setUrl( const QString &url )
+void SendPictureTask::setUrl( const TQString &url )
 {
 	m_url = url;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/sendpicturetask.h b/kopete/protocols/yahoo/libkyahoo/sendpicturetask.h
index b4d0d27e..3a3e1437 100644
--- a/kopete/protocols/yahoo/libkyahoo/sendpicturetask.h
+++ b/kopete/protocols/yahoo/libkyahoo/sendpicturetask.h
@@ -44,13 +44,13 @@ public:
 	virtual void onGo();
 
 	void setType( Type type );
-	void setTarget( const QString &to );
-	void setFilename( const QString & );
+	void setTarget( const TQString &to );
+	void setFilename( const TQString & );
 	void setFilesize( int );
-	void setPath( const QString & );
+	void setPath( const TQString & );
 	void setChecksum( int );
 	void setStatus( int );
-	void setUrl( const QString & );
+	void setUrl( const TQString & );
 private:
 	void initiateUpload();
 	void sendChecksum();
@@ -62,15 +62,15 @@ private slots:
 	void readResult();
 private:
 	Type m_type;
-	QString m_target;
-	QString m_fileName;
+	TQString m_target;
+	TQString m_fileName;
 	int m_fileSize;
-	QString m_path;
+	TQString m_path;
 	int m_checksum;
 	int m_status;
-	QString m_url;
+	TQString m_url;
 	int m_transmitted;
-	QFile *m_file;
+	TQFile *m_file;
 	KNetwork::KBufferedSocket *m_socket;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/statusnotifiertask.cpp b/kopete/protocols/yahoo/libkyahoo/statusnotifiertask.cpp
index c7fcaeac..35796666 100644
--- a/kopete/protocols/yahoo/libkyahoo/statusnotifiertask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/statusnotifiertask.cpp
@@ -19,8 +19,8 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 #include <kdebug.h>
 #include <klocale.h>
 
@@ -84,14 +84,14 @@ void StatusNotifierTask::parseStatus( YMSGTransfer* t )
 	if( t->status() == Yahoo::StatusDisconnected &&
 		t->service() == Yahoo::ServiceLogoff )
 	{
-		emit loginResponse( Yahoo::LoginDupl, QString() );
+		emit loginResponse( Yahoo::LoginDupl, TQString() );
 	}
 
 	QString	myNick;		/* key = 1 */
-	QString customError;	/* key = 16  */
-	QString nick;		/* key = 7  */
+	TQString customError;	/* key = 16  */
+	TQString nick;		/* key = 7  */
 	int state;		/* key = 10  */
-	QString message;	/* key = 19  */
+	TQString message;	/* key = 19  */
 	int flags;		/* key = 13  */
 	int away;		/* key = 47  */
 	int idle;		/* key = 137 */
@@ -114,12 +114,12 @@ void StatusNotifierTask::parseStatus( YMSGTransfer* t )
 		utf = t->nthParamSeparated( 97, i, 7 ).toInt() == 1;
 		pictureChecksum = t->nthParamSeparated( 192, i, 7 ).toInt();
 		if( utf )
-			message = QString::fromUtf8( t->nthParamSeparated( 19, i, 7 ) );
+			message = TQString::fromUtf8( t->nthParamSeparated( 19, i, 7 ) );
 		else
 			message = t->nthParamSeparated( 19, i, 7 );
 
 		if( t->service() == Yahoo::ServiceLogoff || ( state != 0 && flags == 0 ) )
-			emit statusChanged( nick, Yahoo::StatusOffline, QString(), 0, 0, 0 );
+			emit statusChanged( nick, Yahoo::StatusOffline, TQString(), 0, 0, 0 );
 		else
 			emit statusChanged( nick, state, message, away, idle, pictureChecksum );
 	}
@@ -129,15 +129,15 @@ void StatusNotifierTask::parseAuthorization( YMSGTransfer* t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString nick;		/* key = 4  */
-	QString msg;		/* key = 14  */
+	TQString nick;		/* key = 4  */
+	TQString msg;		/* key = 14  */
 	int state;		/* key = 13  */
 	bool utf;		/* key = 97 */
 
 	utf = t->firstParam( 97 ).toInt() == 1;
 	nick = t->firstParam( 4 );
 	if( utf )
-		msg = QString::fromUtf8( t->firstParam( 14 ) );
+		msg = TQString::fromUtf8( t->firstParam( 14 ) );
 	else
 		msg = t->firstParam( 14 );
 	state = t->firstParam( 13 ).toInt();
@@ -152,11 +152,11 @@ void StatusNotifierTask::parseAuthorization( YMSGTransfer* t )
 	}
 	else	// This is a request
 	{
-		QString fname = t->firstParam( 216 );
-		QString lname = t->firstParam( 254 );
-		QString name;
+		TQString fname = t->firstParam( 216 );
+		TQString lname = t->firstParam( 254 );
+		TQString name;
 		if( !fname.isEmpty() || !lname.isEmpty() )
-			name = QString("%1 %2").arg(fname).arg(lname);
+			name = TQString("%1 %2").arg(fname).arg(lname);
 
 		kdDebug(YAHOO_RAW_DEBUG) << "Emitting gotAuthorizationRequest( " << nick<< ", " << msg << ", " << name << " )" << endl;
 		emit gotAuthorizationRequest( nick, msg, name );
@@ -167,7 +167,7 @@ void StatusNotifierTask::parseStealthStatus( YMSGTransfer* t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString nick;		/* key = 7  */
+	TQString nick;		/* key = 7  */
 	int state;		/* key = 31  */
 
 	nick = t->firstParam( 7 );
diff --git a/kopete/protocols/yahoo/libkyahoo/statusnotifiertask.h b/kopete/protocols/yahoo/libkyahoo/statusnotifiertask.h
index 5cc63d8a..2400363b 100644
--- a/kopete/protocols/yahoo/libkyahoo/statusnotifiertask.h
+++ b/kopete/protocols/yahoo/libkyahoo/statusnotifiertask.h
@@ -41,12 +41,12 @@ protected:
 	void parseStealthStatus( YMSGTransfer *transfer );
 	void parseAuthorization( YMSGTransfer *transfer );
 signals:
-	void statusChanged( const QString &nick, int state, const QString &message, int away, int idle, int pictureChecksum );
-	void stealthStatusChanged( const QString&, Yahoo::StealthStatus );
-	void loginResponse( int, const QString& );
-	void authorizationAccepted( const QString & );
-	void authorizationRejected( const QString &, const QString & );
-	void gotAuthorizationRequest( const QString &, const QString &, const QString & );
+	void statusChanged( const TQString &nick, int state, const TQString &message, int away, int idle, int pictureChecksum );
+	void stealthStatusChanged( const TQString&, Yahoo::StealthStatus );
+	void loginResponse( int, const TQString& );
+	void authorizationAccepted( const TQString & );
+	void authorizationRejected( const TQString &, const TQString & );
+	void gotAuthorizationRequest( const TQString &, const TQString &, const TQString & );
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/stealthtask.cpp b/kopete/protocols/yahoo/libkyahoo/stealthtask.cpp
index 89474ab4..6eba854a 100644
--- a/kopete/protocols/yahoo/libkyahoo/stealthtask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/stealthtask.cpp
@@ -19,7 +19,7 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
+#include <tqstring.h>
 
 StealthTask::StealthTask(Task* parent) : Task(parent)
 {
@@ -65,7 +65,7 @@ void StealthTask::onGo()
 	setSuccess();
 }
 
-void StealthTask::setTarget( const QString &to )
+void StealthTask::setTarget( const TQString &to )
 {
 	m_target = to;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/stealthtask.h b/kopete/protocols/yahoo/libkyahoo/stealthtask.h
index 6c33da1e..5659e110 100644
--- a/kopete/protocols/yahoo/libkyahoo/stealthtask.h
+++ b/kopete/protocols/yahoo/libkyahoo/stealthtask.h
@@ -34,11 +34,11 @@ public:
 	
 	virtual void onGo();
 
-	void setTarget( const QString &to );
+	void setTarget( const TQString &to );
 	void setState( Yahoo::StealthStatus state );
 	void setMode( Yahoo::StealthMode mode );
 private:
-	QString m_target;
+	TQString m_target;
 	Yahoo::StealthMode m_mode;
 	Yahoo::StealthStatus m_state;
 };
diff --git a/kopete/protocols/yahoo/libkyahoo/stream.cpp b/kopete/protocols/yahoo/libkyahoo/stream.cpp
index 8173281c..82d6fe52 100644
--- a/kopete/protocols/yahoo/libkyahoo/stream.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/stream.cpp
@@ -19,8 +19,8 @@
 
 #include "stream.h"
 
-Stream::Stream(QObject *parent)
-:QObject(parent)
+Stream::Stream(TQObject *parent)
+:TQObject(parent)
 {
 }
 
diff --git a/kopete/protocols/yahoo/libkyahoo/stream.h b/kopete/protocols/yahoo/libkyahoo/stream.h
index 71bcae5c..c7f9eeae 100644
--- a/kopete/protocols/yahoo/libkyahoo/stream.h
+++ b/kopete/protocols/yahoo/libkyahoo/stream.h
@@ -18,7 +18,7 @@
     *************************************************************************
 */
 
-#include <qobject.h>
+#include <tqobject.h>
 
 #ifndef YAHOO_STREAM_H
 #define YAHOO_STREAM_H
@@ -43,12 +43,12 @@ public:
 		SystemShutdown
 	};
 
-	Stream(QObject *parent=0);
+	Stream(TQObject *parent=0);
 	virtual ~Stream();
 
 	virtual void close()=0;
 	virtual int errorCondition() const=0;
-	virtual QString errorText() const=0;
+	virtual TQString errorText() const=0;
 
 	/**
 	 * Are there any messages waiting to be read
diff --git a/kopete/protocols/yahoo/libkyahoo/task.cpp b/kopete/protocols/yahoo/libkyahoo/task.cpp
index f3d1a98c..b604219b 100644
--- a/kopete/protocols/yahoo/libkyahoo/task.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/task.cpp
@@ -17,7 +17,7 @@
     *************************************************************************
 */
 
-#include <qtimer.h>
+#include <tqtimer.h>
 
 #include "client.h"
 #include "transfer.h"
@@ -30,10 +30,10 @@ class Task::TaskPrivate
 public:
 	TaskPrivate() {}
 
-	QString id;
+	TQString id;
 	bool success;
 	int statusCode;
-	QString statusString;
+	TQString statusString;
 	Client *client;
 	bool insignificant, deleteme, autoDelete;
 	bool done;
@@ -41,22 +41,22 @@ public:
 };
 
 Task::Task(Task *parent)
-:QObject(parent)
+:TQObject(parent)
 {
 	init();
 	d->transfer = 0;
 	d->client = parent->client();
 	//d->id = client()->genUniqueId();
-	connect(d->client, SIGNAL(disconnected()), SLOT(clientDisconnected()));
+	connect(d->client, TQT_SIGNAL(disconnected()), TQT_SLOT(clientDisconnected()));
 }
 
 Task::Task(Client *parent, bool)
-:QObject(0)
+:TQObject(0)
 {
 	init();
 
 	d->client = parent;
-	connect(d->client, SIGNAL(disconnected()), SLOT(clientDisconnected()));
+	connect(d->client, TQT_SIGNAL(disconnected()), TQT_SLOT(clientDisconnected()));
 }
 
 Task::~Task()
@@ -77,7 +77,7 @@ void Task::init()
 
 Task *Task::parent() const
 {
-	return (Task *)QObject::parent();
+	return (Task *)TQObject::parent();
 }
 
 Client *Task::client() const
@@ -95,7 +95,7 @@ void Task::setTransfer( Transfer * transfer )
 	d->transfer = transfer;
 }
 
-QString Task::id() const
+TQString Task::id() const
 {
 	return d->id;
 }
@@ -110,7 +110,7 @@ int Task::statusCode() const
 	return d->statusCode;
 }
 
-const QString & Task::statusString() const
+const TQString & Task::statusString() const
 {
 	return d->statusString;
 }
@@ -124,16 +124,16 @@ void Task::go(bool autoDelete)
 
 bool Task::take( Transfer * transfer)
 {
-	const QObjectList *p = children();
+	const TQObjectList *p = children();
 	if(!p)
 		return false;
 
 	// pass along the transfer to our children
-	QObjectListIt it(*p);
+	TQObjectListIt it(*p);
 	Task *t;
 	for(; it.current(); ++it)
 	{
-		QObject *obj = it.current();
+		TQObject *obj = it.current();
 		if(!obj->inherits("Task"))
 			continue;
 
@@ -172,7 +172,7 @@ void Task::onDisconnect()
 		d->statusString = tr("Disconnected");
 
 		// delay this so that tasks that react don't block the shutdown
-		QTimer::singleShot(0, this, SLOT(done()));
+		TQTimer::singleShot(0, this, TQT_SLOT(done()));
 	}
 }
 
@@ -181,7 +181,7 @@ void Task::send( Transfer * request )
 	client()->send( request );
 }
 
-void Task::setSuccess(int code, const QString &str)
+void Task::setSuccess(int code, const TQString &str)
 {
 	if(!d->done) {
 		d->success = true;
@@ -191,7 +191,7 @@ void Task::setSuccess(int code, const QString &str)
 	}
 }
 
-void Task::setError(int code, const QString &str)
+void Task::setError(int code, const TQString &str)
 {
 	if(!d->done) {
 		d->success = false;
@@ -228,7 +228,7 @@ void Task::clientDisconnected()
 // void Task::debug(const char *fmt, ...)
 // {
 // 	char *buf;
-// 	QString str;
+// 	TQString str;
 // 	int size = 1024;
 // 	int r;
 //
@@ -240,7 +240,7 @@ void Task::clientDisconnected()
 // 		va_end(ap);
 //
 // 		if(r != -1)
-// 			str = QString(buf);
+// 			str = TQString(buf);
 //
 // 		delete [] buf;
 //
@@ -250,9 +250,9 @@ void Task::clientDisconnected()
 // 	debug(str);
 // }
 
-void Task::debug(const QString &str)
+void Task::debug(const TQString &str)
 {
-	client()->debug(QString("%1: ").arg(className()) + str);
+	client()->debug(TQString("%1: ").arg(className()) + str);
 }
 
 bool Task::forMe( const Transfer * transfer ) const
diff --git a/kopete/protocols/yahoo/libkyahoo/task.h b/kopete/protocols/yahoo/libkyahoo/task.h
index a1a64e45..00cdb18f 100644
--- a/kopete/protocols/yahoo/libkyahoo/task.h
+++ b/kopete/protocols/yahoo/libkyahoo/task.h
@@ -20,7 +20,7 @@
 #ifndef YAHOO_TASK_H
 #define YAHOO_TASK_H
 
-#include <qobject.h>
+#include <tqobject.h>
 
 class QString;
 
@@ -40,11 +40,11 @@ public:
 	Client *client() const;
 	Transfer *transfer() const;
 	
-	QString id() const;
+	TQString id() const;
 
 	bool success() const;
 	int statusCode() const;
-	const QString & statusString() const;
+	const TQString & statusString() const;
 
 	void go( bool autoDelete=false  );
 	/** 
@@ -61,10 +61,10 @@ protected:
 	virtual void onGo();
 	virtual void onDisconnect();
 	void send( Transfer * request );
-	void setSuccess( int code=0, const QString &str="" );
-	void setError( int code=0, const QString &str="" );
+	void setSuccess( int code=0, const TQString &str="" );
+	void setError( int code=0, const TQString &str="" );
 // 	void debug( const char *, ... );
-	void debug( const QString & );
+	void debug( const TQString & );
 	/**
 	 * Used in take() to check if the offered transfer is for this Task
 	 * @return true if this Task should take the Transfer.  Default impl always returns false.
@@ -73,7 +73,7 @@ protected:
 	/**
 	 * Creates a transfer with the given command and field list
 	 */
-	//void createTransfer( const QString & command, const Field::FieldList fields );
+	//void createTransfer( const TQString & command, const Field::FieldList fields );
 	/**
 	 * Direct setter for Tasks which don't have any fields
 	 */
diff --git a/kopete/protocols/yahoo/libkyahoo/tests/clientstream_test.cpp b/kopete/protocols/yahoo/libkyahoo/tests/clientstream_test.cpp
index a52b1f56..efcd63cf 100644
--- a/kopete/protocols/yahoo/libkyahoo/tests/clientstream_test.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/tests/clientstream_test.cpp
@@ -5,7 +5,7 @@
 #include "../ymsgtransfer.h"
 #include "../yahootypes.h"
 
-ClientStreamTest::ClientStreamTest(int argc, char ** argv) : QApplication( argc, argv )
+ClientStreamTest::ClientStreamTest(int argc, char ** argv) : TQApplication( argc, argv )
 {
 	// set up client stream
 	myConnector = new KNetworkConnector( 0 );
@@ -13,12 +13,12 @@ ClientStreamTest::ClientStreamTest(int argc, char ** argv) : QApplication( argc,
 	myConnector->setOptHostPort( "scs.msg.yahoo.com", 5050 );
 	myTestObject = new ClientStream( myConnector, myConnector);
 	// notify when the transport layer is connected
-	connect( myTestObject, SIGNAL( connected() ), SLOT( slotConnected() ) );
+	connect( myTestObject, TQT_SIGNAL( connected() ), TQT_SLOT( slotConnected() ) );
 	// notify and start sending
-	//connect( myTestObject, SIGNAL( warning(int) ), SLOT( slotWarning(int) ) );
+	//connect( myTestObject, TQT_SIGNAL( warning(int) ), TQT_SLOT( slotWarning(int) ) );
 
 	// do test once the event loop is running
-	QTimer::singleShot( 0, this, SLOT( slotDoTest() ) );
+	TQTimer::singleShot( 0, this, TQT_SLOT( slotDoTest() ) );
 	connected = false;
 }
 
@@ -30,7 +30,7 @@ ClientStreamTest::~ClientStreamTest()
 
 void ClientStreamTest::slotDoTest()
 {
-	QString server = QString::fromLatin1("scs.msg.yahoo.com");
+	TQString server = TQString::fromLatin1("scs.msg.yahoo.com");
 	// connect to server
 	kdDebug(14180) << k_funcinfo << " connecting to server" << endl;
 	myTestObject->connectToServer( server, true ); // fine up to here...
diff --git a/kopete/protocols/yahoo/libkyahoo/tests/clientstream_test.h b/kopete/protocols/yahoo/libkyahoo/tests/clientstream_test.h
index ef367cec..8842fcc2 100644
--- a/kopete/protocols/yahoo/libkyahoo/tests/clientstream_test.h
+++ b/kopete/protocols/yahoo/libkyahoo/tests/clientstream_test.h
@@ -10,9 +10,9 @@
 #ifndef clientstream_test_h
 #define clientstream_test_h
 
-#include <qglobal.h>
-#include <qapplication.h>
-#include <qtimer.h>
+#include <tqglobal.h>
+#include <tqapplication.h>
+#include <tqtimer.h>
 
 #include "yahooclientstream.h"
 #include "yahooconnector.h"
diff --git a/kopete/protocols/yahoo/libkyahoo/tests/logintest.cpp b/kopete/protocols/yahoo/libkyahoo/tests/logintest.cpp
index 8778d9da..5e9b04a5 100644
--- a/kopete/protocols/yahoo/libkyahoo/tests/logintest.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/tests/logintest.cpp
@@ -23,7 +23,7 @@
 #include "../ymsgtransfer.h"
 #include "../yahootypes.h"
 
-LoginTest::LoginTest(int argc, char ** argv) : QApplication( argc, argv )
+LoginTest::LoginTest(int argc, char ** argv) : TQApplication( argc, argv )
 {
 	// set up client stream
 	myConnector = new KNetworkConnector( 0 );
@@ -33,7 +33,7 @@ LoginTest::LoginTest(int argc, char ** argv) : QApplication( argc, argv )
 	// notify when the transport layer is connected
 	myClient = new Client();
 	// do test once the event loop is running
-	QTimer::singleShot( 0, this, SLOT( slotDoTest() ) );
+	TQTimer::singleShot( 0, this, TQT_SLOT( slotDoTest() ) );
 	connected = false;
 }
 
@@ -46,11 +46,11 @@ LoginTest::~LoginTest()
 
 void LoginTest::slotDoTest()
 {
-	QString server = QString::fromLatin1("scs.msg.yahoo.com");
+	TQString server = TQString::fromLatin1("scs.msg.yahoo.com");
 	// connect to server
 	kdDebug(14180) << k_funcinfo << " connecting to server" << endl;
 	
-	connect( myClient, SIGNAL( connected() ), SLOT( slotConnected() ) );
+	connect( myClient, TQT_SIGNAL( connected() ), TQT_SLOT( slotConnected() ) );
 	myClient->start( server, 5050, "duncanmacvicar", "**********" );
 	myClient->connectToServer( myClientStream, server, true );
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/tests/logintest.h b/kopete/protocols/yahoo/libkyahoo/tests/logintest.h
index 12274843..68a40b24 100644
--- a/kopete/protocols/yahoo/libkyahoo/tests/logintest.h
+++ b/kopete/protocols/yahoo/libkyahoo/tests/logintest.h
@@ -21,9 +21,9 @@
 #ifndef logintest_h
 #define logintest_h
 
-#include <qglobal.h>
-#include <qapplication.h>
-#include <qtimer.h>
+#include <tqglobal.h>
+#include <tqapplication.h>
+#include <tqtimer.h>
 
 #include "client.h"
 #include "coreprotocol.h"
diff --git a/kopete/protocols/yahoo/libkyahoo/webcamtask.cpp b/kopete/protocols/yahoo/libkyahoo/webcamtask.cpp
index fe3c6d7c..2ad978f2 100644
--- a/kopete/protocols/yahoo/libkyahoo/webcamtask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/webcamtask.cpp
@@ -21,10 +21,10 @@
 #include "yahootypes.h"
 #include "client.h"
 
-#include <qbuffer.h>
-#include <qfile.h>
-#include <qtimer.h>
-#include <qpixmap.h>
+#include <tqbuffer.h>
+#include <tqfile.h>
+#include <tqtimer.h>
+#include <tqpixmap.h>
 #include <ktempfile.h>
 #include <kprocess.h>
 #include <kstreamsocket.h>
@@ -73,7 +73,7 @@ bool WebcamTask::forMe( const Transfer* transfer ) const
 		return false;
 }
 
-void WebcamTask::requestWebcam( const QString &who )
+void WebcamTask::requestWebcam( const TQString &who )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
@@ -108,12 +108,12 @@ void WebcamTask::parseWebcamInformation( YMSGTransfer *t )
 
 	kdDebug(YAHOO_RAW_DEBUG) << "Got WebcamInformation: Sender: " << info.sender << " Server: " << info.server << " Key: " << info.key << endl;
 
-	KStreamSocket *socket = new KStreamSocket( info.server, QString::number(5100) );
+	KStreamSocket *socket = new KStreamSocket( info.server, TQString::number(5100) );
 	socketMap[socket] = info;
 	socket->enableRead( true );
-	connect( socket, SIGNAL( connected( const KResolverEntry& ) ), this, SLOT( slotConnectionStage1Established() ) );
-	connect( socket, SIGNAL( gotError(int) ), this, SLOT( slotConnectionFailed(int) ) );
-	connect( socket, SIGNAL( readyRead() ), this, SLOT( slotRead() ) );
+	connect( socket, TQT_SIGNAL( connected( const KResolverEntry& ) ), this, TQT_SLOT( slotConnectionStage1Established() ) );
+	connect( socket, TQT_SIGNAL( gotError(int) ), this, TQT_SLOT( slotConnectionFailed(int) ) );
+	connect( socket, TQT_SIGNAL( readyRead() ), this, TQT_SLOT( slotRead() ) );
 
 	socket->connect();
 }
@@ -124,23 +124,23 @@ void WebcamTask::slotConnectionStage1Established()
 	if( !socket )
 		return;
 	kdDebug(YAHOO_RAW_DEBUG) << "Webcam connection Stage1 to the user " << socketMap[socket].sender << " established." << endl;
-	disconnect( socket, SIGNAL( connected( const KResolverEntry& ) ), this, SLOT( slotConnectionStage1Established() ) );
-	disconnect( socket, SIGNAL( gotError(int) ), this, SLOT( slotConnectionFailed(int) ) );
+	disconnect( socket, TQT_SIGNAL( connected( const KResolverEntry& ) ), this, TQT_SLOT( slotConnectionStage1Established() ) );
+	disconnect( socket, TQT_SIGNAL( gotError(int) ), this, TQT_SLOT( slotConnectionFailed(int) ) );
 	socketMap[socket].status = ConnectedStage1;
 
 
-	QByteArray buffer;
-	QDataStream stream( buffer, IO_WriteOnly );
-	QString s;
+	TQByteArray buffer;
+	TQDataStream stream( buffer, IO_WriteOnly );
+	TQString s;
 	if( socketMap[socket].direction == Incoming )
 	{
-		socket->writeBlock( QCString("<RVWCFG>").data(), 8 );
-		s = QString("g=%1\r\n").arg(socketMap[socket].sender);
+		socket->writeBlock( TQCString("<RVWCFG>").data(), 8 );
+		s = TQString("g=%1\r\n").arg(socketMap[socket].sender);
 	}
 	else
 	{
-		socket->writeBlock( QCString("<RUPCFG>").data(), 8 );
-		s = QString("f=1\r\n");
+		socket->writeBlock( TQCString("<RUPCFG>").data(), 8 );
+		s = TQString("f=1\r\n");
 	}
 
 	// Header: 08 00 01 00 00 00 00
@@ -157,21 +157,21 @@ void WebcamTask::slotConnectionStage2Established()
 		return;
 
 	kdDebug(YAHOO_RAW_DEBUG) << "Webcam connection Stage2 to the user " << socketMap[socket].sender << " established." << endl;
-	disconnect( socket, SIGNAL( connected( const KResolverEntry& ) ), this, SLOT( slotConnectionStage2Established() ) );
-	disconnect( socket, SIGNAL( gotError(int) ), this, SLOT( slotConnectionFailed(int) ) );
+	disconnect( socket, TQT_SIGNAL( connected( const KResolverEntry& ) ), this, TQT_SLOT( slotConnectionStage2Established() ) );
+	disconnect( socket, TQT_SIGNAL( gotError(int) ), this, TQT_SLOT( slotConnectionFailed(int) ) );
 	socketMap[socket].status = ConnectedStage2;
 
-	QByteArray buffer;
-	QDataStream stream( buffer, IO_WriteOnly );
-	QString s;
+	TQByteArray buffer;
+	TQDataStream stream( buffer, IO_WriteOnly );
+	TQString s;
 
 
 	if( socketMap[socket].direction == Incoming )
 	{
 		// Send <REQIMG>-Packet
-		socket->writeBlock( QCString("<REQIMG>").data(), 8 );
+		socket->writeBlock( TQCString("<REQIMG>").data(), 8 );
 		// Send request information
-		s = QString("a=2\r\nc=us\r\ne=21\r\nu=%1\r\nt=%2\r\ni=\r\ng=%3\r\no=w-2-5-1\r\np=1")
+		s = TQString("a=2\r\nc=us\r\ne=21\r\nu=%1\r\nt=%2\r\ni=\r\ng=%3\r\no=w-2-5-1\r\np=1")
 			.arg(client()->userId()).arg(socketMap[socket].key).arg(socketMap[socket].sender);
 		// Header: 08 00 01 00 00 00 00
 		stream << (Q_INT8)0x08 << (Q_INT8)0x00 << (Q_INT8)0x01 << (Q_INT8)0x00 << (Q_INT32)s.length();
@@ -179,9 +179,9 @@ void WebcamTask::slotConnectionStage2Established()
 	else
 	{
 		// Send <REQIMG>-Packet
-		socket->writeBlock( QCString("<SNDIMG>").data(), 8 );
+		socket->writeBlock( TQCString("<SNDIMG>").data(), 8 );
 		// Send request information
-		s = QString("a=2\r\nc=us\r\nu=%1\r\nt=%2\r\ni=%3\r\no=w-2-5-1\r\np=2\r\nb=KopeteWebcam\r\nd=\r\n")
+		s = TQString("a=2\r\nc=us\r\nu=%1\r\nt=%2\r\ni=%3\r\no=w-2-5-1\r\np=2\r\nb=KopeteWebcam\r\nd=\r\n")
 		.arg(client()->userId()).arg(socketMap[socket].key).arg(socket->localAddress().nodeName());
 		// Header: 08 00 05 00 00 00 00	01 00 00 00 01
 		stream << (Q_INT8)0x0d << (Q_INT8)0x00 << (Q_INT8)0x05 << (Q_INT8)0x00 << (Q_INT32)s.length()
@@ -197,7 +197,7 @@ void WebcamTask::slotConnectionFailed( int error )
 	KStreamSocket* socket = const_cast<KStreamSocket*>( dynamic_cast<const KStreamSocket*>( sender() ) );
 	kdDebug(YAHOO_RAW_DEBUG) << "Webcam connection to the user " << socketMap[socket].sender << " failed. Error " << error << " - " << socket->errorString() << endl;
         client()->notifyError( i18n("Webcam connection to the user %1 could not be established.\n\nPlease relogin and try again.")
-                        .arg(socketMap[socket].sender), QString("%1 - %2").arg(error).arg( socket->errorString()), Client::Error );
+                        .arg(socketMap[socket].sender), TQString("%1 - %2").arg(error).arg( socket->errorString()), Client::Error );
         socketMap.remove( socket );
         socket->deleteLater();
 }
@@ -211,7 +211,7 @@ void WebcamTask::slotRead()
 	switch( socketMap[socket].status )
 	{
 		case ConnectedStage1:
-			disconnect( socket, SIGNAL( readyRead() ), this, SLOT( slotRead() ) );
+			disconnect( socket, TQT_SIGNAL( readyRead() ), this, TQT_SLOT( slotRead() ) );
 			connectStage2( socket );
 		break;
 		case ConnectedStage2:
@@ -226,13 +226,13 @@ void WebcamTask::slotRead()
 void WebcamTask::connectStage2( KStreamSocket *socket )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
-	QByteArray data( socket->bytesAvailable() );
+	TQByteArray data( socket->bytesAvailable() );
 	socket->readBlock ( data.data (), data.size () );
 	kdDebug(YAHOO_RAW_DEBUG) << "Magic Byte:" << data[2] << endl;
 
 	socketMap[socket].status = ConnectedStage2;
 
-	QString server;
+	TQString server;
 	int i = 4;
 	KStreamSocket *newSocket;
 	switch( (const char)data[2] )
@@ -252,16 +252,16 @@ void WebcamTask::connectStage2( KStreamSocket *socket )
 		}
 
 		kdDebug(YAHOO_RAW_DEBUG) << "Connecting to " << server << endl;
-		newSocket = new KStreamSocket( server, QString::number(5100) );
+		newSocket = new KStreamSocket( server, TQString::number(5100) );
 		socketMap[newSocket] = socketMap[socket];
 		newSocket->enableRead( true );
-		connect( newSocket, SIGNAL( connected( const KResolverEntry& ) ), this, SLOT( slotConnectionStage2Established() ) );
-		connect( newSocket, SIGNAL( gotError(int) ), this, SLOT( slotConnectionFailed(int) ) );
-		connect( newSocket, SIGNAL( readyRead() ), this, SLOT( slotRead() ) );
+		connect( newSocket, TQT_SIGNAL( connected( const KResolverEntry& ) ), this, TQT_SLOT( slotConnectionStage2Established() ) );
+		connect( newSocket, TQT_SIGNAL( gotError(int) ), this, TQT_SLOT( slotConnectionFailed(int) ) );
+		connect( newSocket, TQT_SIGNAL( readyRead() ), this, TQT_SLOT( slotRead() ) );
 		if( socketMap[newSocket].direction == Outgoing )
 		{
 			newSocket->enableWrite( true );
-			connect( newSocket, SIGNAL( readyWrite() ), this, SLOT( transmitWebcamImage() ) );
+			connect( newSocket, TQT_SIGNAL( readyWrite() ), this, TQT_SLOT( transmitWebcamImage() ) );
 		}
 
 		newSocket->connect();
@@ -275,7 +275,7 @@ void WebcamTask::connectStage2( KStreamSocket *socket )
 
 void WebcamTask::processData( KStreamSocket *socket )
 {
-	QByteArray data( socket->bytesAvailable() );
+	TQByteArray data( socket->bytesAvailable() );
 
 	socket->readBlock ( data.data (), data.size () );
 
@@ -288,7 +288,7 @@ void WebcamTask::processData( KStreamSocket *socket )
 	parseData( data, socket );
 }
 
-void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
+void WebcamTask::parseData( TQByteArray &data, KStreamSocket *socket )
 {
 	int headerLength = 0;
 	int read = 0;
@@ -310,7 +310,7 @@ void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
 			kdDebug() << data[8] << data[9] << data[10] << data[11] << data[12] << endl;
 			info->timestamp = yahoo_get32(data.data() + 9);
 			kdDebug(YAHOO_RAW_DEBUG) << "PacketType: " << data[8] << " reason: " << info->reason << " timestamp: " << info->timestamp << endl;
-			QStringList::iterator it;
+			TQStringList::iterator it;
 			switch( data[8] )
 			{
 				case 0x00:
@@ -384,8 +384,8 @@ void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
 		{
 			// More headers to read
 			kdDebug(YAHOO_RAW_DEBUG) << "More data to read..." << endl;
-			QByteArray newData( data.size() - headerLength );
-			QDataStream stream( newData, IO_WriteOnly );
+			TQByteArray newData( data.size() - headerLength );
+			TQDataStream stream( newData, IO_WriteOnly );
 			stream.writeRawBytes( data.data() + headerLength, data.size() - headerLength );
 			parseData( newData, socket );
 			return;
@@ -408,7 +408,7 @@ void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
 	if( !info->buffer )
 	{
 		kdDebug(YAHOO_RAW_DEBUG) << "Buffer created" << endl;
-		info->buffer = new QBuffer();
+		info->buffer = new TQBuffer();
 		info->buffer->open( IO_WriteOnly );
 	}
 
@@ -419,7 +419,7 @@ void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
 	if( info->buffer->size() >= static_cast<uint>(info->dataLength) )
 	{
 		info->buffer->close();
-		QString who;
+		TQString who;
 		switch( info->type )
 		{
 		case UserRequest:
@@ -450,7 +450,7 @@ void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
 		break;
 		case Image:
 			{
-			QPixmap webcamImage;
+			TQPixmap webcamImage;
 			//webcamImage.loadFromData( info->buffer->buffer() );
 
 			// FIXME (same)
@@ -466,7 +466,7 @@ void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
 
 			KTempFile jpcTmpImageFile;
                         KTempFile bmpTmpImageFile;
-                        QFile *file = jpcTmpImageFile.file();
+                        TQFile *file = jpcTmpImageFile.file();
                         file->writeBlock((info->buffer->buffer()).data(), info->buffer->size());
                         file->close();
 
@@ -485,8 +485,8 @@ void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
 				/******* UPTO THIS POINT ******/
 				emit webcamImageReceived( info->sender, webcamImage );
 			}
-			QFile::remove(jpcTmpImageFile.name());
-                        QFile::remove(bmpTmpImageFile.name());
+			TQFile::remove(jpcTmpImageFile.name());
+                        TQFile::remove(bmpTmpImageFile.name());
 
 			kdDebug(YAHOO_RAW_DEBUG) << "Image Received. Size: " << webcamImage.size() << endl;
 			}
@@ -503,8 +503,8 @@ void WebcamTask::parseData( QByteArray &data, KStreamSocket *socket )
 	{
 		// More headers to read
 		kdDebug(YAHOO_RAW_DEBUG) << "More data to read..." << data.size() - read << endl;
-		QByteArray newData( data.size() - read );
-		QDataStream stream( newData, IO_WriteOnly );
+		TQByteArray newData( data.size() - read );
+		TQDataStream stream( newData, IO_WriteOnly );
 		stream.writeRawBytes( data.data() + read, data.size() - read );
 		parseData( newData, socket );
 	}
@@ -520,7 +520,7 @@ void WebcamTask::cleanUpConnection( KStreamSocket *socket )
 	delete socket;
 }
 
-void WebcamTask::closeWebcam( const QString & who )
+void WebcamTask::closeWebcam( const TQString & who )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 	SocketInfoMap::Iterator it;
@@ -552,14 +552,14 @@ void WebcamTask::registerWebcam()
 	send( t );
 }
 
-void WebcamTask::addPendingInvitation( const QString &userId )
+void WebcamTask::addPendingInvitation( const TQString &userId )
 {
 	kdDebug(YAHOO_RAW_DEBUG) << "Inviting " << userId << " to watch the webcam." << endl;
 	pendingInvitations.append( userId );
 	accessGranted.append( userId );
 }
 
-void WebcamTask::grantAccess( const QString &userId )
+void WebcamTask::grantAccess( const TQString &userId )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 	KStreamSocket *socket = 0L;
@@ -577,9 +577,9 @@ void WebcamTask::grantAccess( const QString &userId )
 		kdDebug(YAHOO_RAW_DEBUG) << "Error. No outgoing socket found." << endl;
 		return;
 	}
-	QByteArray ar;
-	QDataStream stream( ar, IO_WriteOnly );
-	QString user = QString("u=%1").arg(userId);
+	TQByteArray ar;
+	TQDataStream stream( ar, IO_WriteOnly );
+	TQString user = TQString("u=%1").arg(userId);
 
 	stream << (Q_INT8)0x0d << (Q_INT8)0x00 << (Q_INT8)0x05 << (Q_INT8)0x00 << (Q_INT32)user.length()
 	<< (Q_INT8)0x00 << (Q_INT8)0x00 << (Q_INT8)0x00 << (Q_INT8)0x00 << (Q_INT8)0x01;
@@ -635,11 +635,11 @@ void WebcamTask::sendEmptyWebcamImage()
 	pictureBuffer.resize( 0 );
 	transmissionPending = true;
 
-	QTimer::singleShot( 1000, this, SLOT(sendEmptyWebcamImage()) );
+	TQTimer::singleShot( 1000, this, TQT_SLOT(sendEmptyWebcamImage()) );
 
 }
 
-void WebcamTask::sendWebcamImage( const QByteArray &image )
+void WebcamTask::sendWebcamImage( const TQByteArray &image )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 	pictureBuffer = image;
@@ -687,8 +687,8 @@ void WebcamTask::transmitWebcamImage()
 	}
 
 	socket->enableWrite( false );
-	QByteArray buffer;
-	QDataStream stream( buffer, IO_WriteOnly );
+	TQByteArray buffer;
+	TQDataStream stream( buffer, IO_WriteOnly );
 	stream << (Q_INT8)0x0d << (Q_INT8)0x00 << (Q_INT8)0x05 << (Q_INT8)0x00 << (Q_INT32)pictureBuffer.size()
 			<< (Q_INT8)0x02 << (Q_INT32)timestamp++;
 	socket->writeBlock( buffer.data(), buffer.size() );
diff --git a/kopete/protocols/yahoo/libkyahoo/webcamtask.h b/kopete/protocols/yahoo/libkyahoo/webcamtask.h
index 23639b8d..d84b6374 100644
--- a/kopete/protocols/yahoo/libkyahoo/webcamtask.h
+++ b/kopete/protocols/yahoo/libkyahoo/webcamtask.h
@@ -18,9 +18,9 @@
 #define WEBCAMTASK_H
 
 #include "task.h"
-#include <qmap.h>
-#include <qpixmap.h>
-#include <qstringlist.h>
+#include <tqmap.h>
+#include <tqpixmap.h>
+#include <tqstringlist.h>
 
 class QString;
 class YMSGTransfer;
@@ -46,10 +46,10 @@ struct YahooWebcamInformation
 	Q_INT32		dataLength;
 	Q_INT32		timestamp;
 	bool		headerRead;
-	QBuffer 	*buffer;
+	TQBuffer 	*buffer;
 };
 
-typedef QMap< KStreamSocket *, YahooWebcamInformation > SocketInfoMap;
+typedef TQMap< KStreamSocket *, YahooWebcamInformation > SocketInfoMap;
 
 /**
 @author André Duffeck
@@ -65,24 +65,24 @@ public:
 
 	bool transmitting() { return transmittingData; }
 
-	void requestWebcam( const QString &who );
-	void closeWebcam( const QString &who );
+	void requestWebcam( const TQString &who );
+	void closeWebcam( const TQString &who );
 
 	void registerWebcam();
-	void sendWebcamImage( const QByteArray &image );
-	void addPendingInvitation( const QString &userId );
-	void grantAccess( const QString &userId );
+	void sendWebcamImage( const TQByteArray &image );
+	void addPendingInvitation( const TQString &userId );
+	void grantAccess( const TQString &userId );
 	void closeOutgoingWebcam();
 signals:
-	void webcamNotAvailable( const QString & );
-	void webcamClosed( const QString &, int );
-	void webcamPaused( const QString& );
-	void webcamImageReceived( const QString &, const QPixmap &);
+	void webcamNotAvailable( const TQString & );
+	void webcamClosed( const TQString &, int );
+	void webcamPaused( const TQString& );
+	void webcamImageReceived( const TQString &, const TQPixmap &);
 	void readyForTransmission();
 	void stopTransmission();
-	void viewerJoined( const QString & );
-	void viewerLeft( const QString & );
-	void viewerRequest( const QString & );
+	void viewerJoined( const TQString & );
+	void viewerLeft( const TQString & );
+	void viewerRequest( const TQString & );
 private slots:
 	void slotConnectionStage1Established();
 	void slotConnectionStage2Established();
@@ -94,19 +94,19 @@ protected:
 	virtual bool forMe( const Transfer* transfer ) const;
 private:
 	void parseWebcamInformation( YMSGTransfer *transfer );
-	void parseData( QByteArray &data, KStreamSocket *socket );
+	void parseData( TQByteArray &data, KStreamSocket *socket );
 
 	void connectStage2( KStreamSocket *socket );
 	void processData( KStreamSocket *socket );
 	void cleanUpConnection( KStreamSocket *socket );
 
-	QString keyPending;	// the buddy we have requested the webcam from
+	TQString keyPending;	// the buddy we have requested the webcam from
 	SocketInfoMap socketMap;
 	bool transmittingData;
-	QStringList pendingInvitations;
-	QStringList accessGranted;
+	TQStringList pendingInvitations;
+	TQStringList accessGranted;
 	int timestamp;
-	QByteArray pictureBuffer;
+	TQByteArray pictureBuffer;
 	bool transmissionPending;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/yabentry.cpp b/kopete/protocols/yahoo/libkyahoo/yabentry.cpp
index d726d6d6..b9a4d72b 100644
--- a/kopete/protocols/yahoo/libkyahoo/yabentry.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/yabentry.cpp
@@ -16,7 +16,7 @@
 
 #include "yabentry.h"
 
-void YABEntry::fromQDomElement( const QDomElement &e )
+void YABEntry::fromQDomElement( const TQDomElement &e )
 {
 	yahooId = e.attribute("yi");
 	YABId = e.attribute("id", "-1").toInt();
@@ -47,10 +47,10 @@ void YABEntry::fromQDomElement( const QDomElement &e )
 	privateState = e.attribute("hs");
 	privateZIP = e.attribute("hz");
 	privateCountry = e.attribute("hn");
-	QString birtday = e.attribute("bi");
-	birthday = QDate( birtday.section('/',2,2).toInt(), birtday.section('/',1,1).toInt(), birtday.section('/',0,0).toInt() );
-	QString an = e.attribute("an");
-	anniversary = QDate( an.section('/',2,2).toInt(), an.section('/',1,1).toInt(), an.section('/',0,0).toInt() );
+	TQString birtday = e.attribute("bi");
+	birthday = TQDate( birtday.section('/',2,2).toInt(), birtday.section('/',1,1).toInt(), birtday.section('/',0,0).toInt() );
+	TQString an = e.attribute("an");
+	anniversary = TQDate( an.section('/',2,2).toInt(), an.section('/',1,1).toInt(), an.section('/',0,0).toInt() );
 	additional1 = e.attribute("c1");
 	additional2 = e.attribute("c2");
 	additional3 = e.attribute("c3");
@@ -65,7 +65,7 @@ void YABEntry::fromQDomElement( const QDomElement &e )
 	imSkype = e.attribute("imk");
 }
 
-void YABEntry::fromQDomDocument( const QDomDocument &d )
+void YABEntry::fromQDomDocument( const TQDomDocument &d )
 {
 	kdDebug() << d.toString() <<
 		d.elementsByTagName("yi").item(0).toElement().text() << endl;
@@ -97,10 +97,10 @@ void YABEntry::fromQDomDocument( const QDomDocument &d )
 	privateState = d.elementsByTagName("hs").item(0).toElement().text();
 	privateZIP = d.elementsByTagName("hz").item(0).toElement().text();
 	privateCountry = d.elementsByTagName("hn").item(0).toElement().text();
-	QString birtday = d.elementsByTagName("bi").item(0).toElement().text();
-	birthday = QDate( birtday.section('/',2,2).toInt(), birtday.section('/',1,1).toInt(), birtday.section('/',0,0).toInt() );
-	QString an = d.elementsByTagName("an").item(0).toElement().text();
-	anniversary = QDate( an.section('/',2,2).toInt(), an.section('/',1,1).toInt(), an.section('/',0,0).toInt() );
+	TQString birtday = d.elementsByTagName("bi").item(0).toElement().text();
+	birthday = TQDate( birtday.section('/',2,2).toInt(), birtday.section('/',1,1).toInt(), birtday.section('/',0,0).toInt() );
+	TQString an = d.elementsByTagName("an").item(0).toElement().text();
+	anniversary = TQDate( an.section('/',2,2).toInt(), an.section('/',1,1).toInt(), an.section('/',0,0).toInt() );
 	additional1 = d.elementsByTagName("c1").item(0).toElement().text();
 	additional2 = d.elementsByTagName("c2").item(0).toElement().text();
 	additional3 = d.elementsByTagName("c3").item(0).toElement().text();
@@ -115,7 +115,7 @@ void YABEntry::fromQDomDocument( const QDomDocument &d )
 	imSkype = d.elementsByTagName("imk").item(0).toElement().text();
 }
 
-void YABEntry::fillQDomElement( QDomElement &e ) const
+void YABEntry::fillQDomElement( TQDomElement &e ) const
 {
 	e.setAttribute( "yi", yahooId );
 	e.setAttribute( "id", YABId );
@@ -135,24 +135,24 @@ void YABEntry::fillQDomElement( QDomElement &e ) const
 	e.setAttribute( "pu", privateURL );
 	e.setAttribute( "ti", title );
 	e.setAttribute( "co", corporation );
-	e.setAttribute( "wa", QString( workAdress ).replace( '\n', "&#xd;&#xa;" ) );
+	e.setAttribute( "wa", TQString( workAdress ).replace( '\n', "&#xd;&#xa;" ) );
 	e.setAttribute( "wc", workCity );
 	e.setAttribute( "ws", workState );
 	e.setAttribute( "wz", workZIP );
 	e.setAttribute( "wn", workCountry );
 	e.setAttribute( "wu", workURL );
-	e.setAttribute( "ha", QString( privateAdress ).replace( '\n', "&#xd;&#xa;" ) );
+	e.setAttribute( "ha", TQString( privateAdress ).replace( '\n', "&#xd;&#xa;" ) );
 	e.setAttribute( "hc", privateCity );
 	e.setAttribute( "hs", privateState );
 	e.setAttribute( "hz", privateZIP );
 	e.setAttribute( "hn", privateCountry );
-	e.setAttribute( "bi", QString("%1/%2/%3").arg( birthday.day() ).arg( birthday.month() ).arg( birthday.year() ) );
-	e.setAttribute( "an", QString("%1/%2/%3").arg( anniversary.day() ).arg( anniversary.month() ).arg( anniversary.year() ) );
+	e.setAttribute( "bi", TQString("%1/%2/%3").arg( birthday.day() ).arg( birthday.month() ).arg( birthday.year() ) );
+	e.setAttribute( "an", TQString("%1/%2/%3").arg( anniversary.day() ).arg( anniversary.month() ).arg( anniversary.year() ) );
 	e.setAttribute( "c1", additional1 );
 	e.setAttribute( "c2", additional2 );
 	e.setAttribute( "c3", additional3 );
 	e.setAttribute( "c4", additional4 );
-	e.setAttribute( "cm", QString( notes ).replace( '\n', "&#xd;&#xa;" ) );
+	e.setAttribute( "cm", TQString( notes ).replace( '\n', "&#xd;&#xa;" ) );
 	e.setAttribute( "ima", imAIM );
 	e.setAttribute( "img", imGoogleTalk );
 	e.setAttribute( "imq", imICQ );
diff --git a/kopete/protocols/yahoo/libkyahoo/yabentry.h b/kopete/protocols/yahoo/libkyahoo/yabentry.h
index da042032..35620911 100644
--- a/kopete/protocols/yahoo/libkyahoo/yabentry.h
+++ b/kopete/protocols/yahoo/libkyahoo/yabentry.h
@@ -17,8 +17,8 @@
 #define YABEntry_H
 
 #include <kdebug.h>
-#include <qdatetime.h>
-#include <qdom.h>
+#include <tqdatetime.h>
+#include <tqdom.h>
 
 struct YABEntry
 {
@@ -81,9 +81,9 @@ struct YABEntry
 	QString		additional4;
 
 	
-	void fromQDomElement( const QDomElement &e );
-	void fromQDomDocument( const QDomDocument &e );
-	void fillQDomElement( QDomElement &e ) const;
+	void fromQDomElement( const TQDomElement &e );
+	void fromQDomDocument( const TQDomDocument &e );
+	void fillQDomElement( TQDomElement &e ) const;
 
 	void dump() const;
 };
diff --git a/kopete/protocols/yahoo/libkyahoo/yabtask.cpp b/kopete/protocols/yahoo/libkyahoo/yabtask.cpp
index 3cc66dba..1066640e 100644
--- a/kopete/protocols/yahoo/libkyahoo/yabtask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/yabtask.cpp
@@ -20,8 +20,8 @@
 #include "ymsgtransfer.h"
 #include "yahootypes.h"
 #include "client.h"
-#include <qstring.h>
-#include <qdatastream.h>
+#include <tqstring.h>
+#include <tqdatastream.h>
 #include <kio/global.h>
 #include <kio/job.h>
 #include <kio/jobclasses.h>
@@ -66,7 +66,7 @@ void YABTask::parseContactDetails( YMSGTransfer* t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString from;		/* key = 7  */
+	TQString from;		/* key = 7  */
 	int count;
 
 	from = t->firstParam( 4 );
@@ -74,12 +74,12 @@ void YABTask::parseContactDetails( YMSGTransfer* t )
 
 	for( int i = 0; i < count; i++ )
 	{
-		QString who = t->nthParam( 5, i );
-		QString s = t->nthParamSeparated( 280, i, 5 );
+		TQString who = t->nthParam( 5, i );
+		TQString s = t->nthParamSeparated( 280, i, 5 );
 		if( s.isEmpty() )
 			continue;
 
-		QDomDocument doc;
+		TQDomDocument doc;
 		doc.setContent( s );
 		YABEntry *entry = new YABEntry;
 		entry->fromQDomDocument( doc );
@@ -93,19 +93,19 @@ void YABTask::parseContactDetails( YMSGTransfer* t )
 void YABTask::getAllEntries( long lastMerge, long lastRemoteRevision )
 {
 	kdDebug(YAHOO_RAW_DEBUG) << "LastMerge: " << lastMerge << " LastRemoteRevision: " << lastRemoteRevision << endl;
-	m_data = QString::null;
-	QString url = QString::fromLatin1("http://address.yahoo.com/yab/us?v=XM&prog=ymsgr&.intl=us&diffs=1&t=%1&tags=short&rt=%2&prog-ver=%3")
+	m_data = TQString::null;
+	TQString url = TQString::fromLatin1("http://address.yahoo.com/yab/us?v=XM&prog=ymsgr&.intl=us&diffs=1&t=%1&tags=short&rt=%2&prog-ver=%3")
 		.arg( lastMerge ).arg( lastRemoteRevision ).arg( YMSG_PROGRAM_VERSION_STRING );
 
 	m_transferJob = KIO::get( url , false, false );
 	m_transferJob->addMetaData("cookies", "manual");
-	m_transferJob->addMetaData("setcookies", QString::fromLatin1("Cookie: Y=%1; T=%2; C=%3;")
+	m_transferJob->addMetaData("setcookies", TQString::fromLatin1("Cookie: Y=%1; T=%2; C=%3;")
 				.arg(client()->yCookie()).arg(client()->tCookie()).arg(client()->cCookie()) );
-	connect( m_transferJob, SIGNAL( data( KIO::Job *, const QByteArray & ) ), this, SLOT( slotData( KIO::Job*, const QByteArray & ) ) );
-	connect( m_transferJob, SIGNAL( result( KIO::Job *) ), this, SLOT( slotResult( KIO::Job* ) ) );
+	connect( m_transferJob, TQT_SIGNAL( data( KIO::Job *, const TQByteArray & ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray & ) ) );
+	connect( m_transferJob, TQT_SIGNAL( result( KIO::Job *) ), this, TQT_SLOT( slotResult( KIO::Job* ) ) );
 }
 
-void YABTask::slotData( KIO::Job* /*job*/, const QByteArray &info  )
+void YABTask::slotData( KIO::Job* /*job*/, const TQByteArray &info  )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 	m_data += info;
@@ -121,9 +121,9 @@ void YABTask::slotResult( KIO::Job* job )
 	else
 	{
 		kdDebug(YAHOO_RAW_DEBUG) << "Server side addressbook retrieved." << endl;
-		QDomDocument doc;
-		QDomNodeList list;
-		QDomElement e;
+		TQDomDocument doc;
+		TQDomNodeList list;
+		TQDomElement e;
 		int it = 0;
 
 		kdDebug(YAHOO_RAW_DEBUG) << m_data << endl;
diff --git a/kopete/protocols/yahoo/libkyahoo/yabtask.h b/kopete/protocols/yahoo/libkyahoo/yabtask.h
index fe9cae3c..3086a01a 100644
--- a/kopete/protocols/yahoo/libkyahoo/yabtask.h
+++ b/kopete/protocols/yahoo/libkyahoo/yabtask.h
@@ -49,11 +49,11 @@ protected:
 	virtual bool forMe( const Transfer* transfer ) const;
 	void parseContactDetails( YMSGTransfer* t );
 private slots:
-	void slotData( KIO::Job*, const QByteArray & );
+	void slotData( KIO::Job*, const TQByteArray & );
 	void slotResult( KIO::Job* );
 private:
 	KIO::TransferJob *m_transferJob;
-	QString m_data;
+	TQString m_data;
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/yahoobuddyiconloader.cpp b/kopete/protocols/yahoo/libkyahoo/yahoobuddyiconloader.cpp
index 5e704efa..025386f0 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahoobuddyiconloader.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/yahoobuddyiconloader.cpp
@@ -16,7 +16,7 @@
 #include "yahoobuddyiconloader.h"
 
 // QT Includes
-#include <qfile.h>
+#include <tqfile.h>
 
 // KDE Includes
 #include <kdebug.h>
@@ -40,17 +40,17 @@ YahooBuddyIconLoader::~YahooBuddyIconLoader()
 {
 }
 
-void YahooBuddyIconLoader::fetchBuddyIcon( const QString &who, KURL url, int checksum )
+void YahooBuddyIconLoader::fetchBuddyIcon( const TQString &who, KURL url, int checksum )
 {
 	kdDebug(YAHOO_RAW_DEBUG) << k_funcinfo << url << endl;
 	KIO::TransferJob *transfer;
-	QString Url = url.url();
-	QString ext = Url.left( Url.findRev( "?" ) );
+	TQString Url = url.url();
+	TQString ext = Url.left( Url.findRev( "?" ) );
 	ext = ext.right( ext.length() - ext.findRev( "." ) );
 
 	transfer = KIO::get( url, false, false );
-	connect( transfer, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotComplete( KIO::Job* ) ) );
-	connect( transfer, SIGNAL( data( KIO::Job*, const QByteArray& ) ), this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );
+	connect( transfer, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( slotComplete( KIO::Job* ) ) );
+	connect( transfer, TQT_SIGNAL( data( KIO::Job*, const TQByteArray& ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray& ) ) );
 
 	m_jobs[transfer].url = url;
 	m_jobs[transfer].who = who;
@@ -58,7 +58,7 @@ void YahooBuddyIconLoader::fetchBuddyIcon( const QString &who, KURL url, int che
 
 }
 
-void YahooBuddyIconLoader::slotData( KIO::Job *job, const QByteArray& data )
+void YahooBuddyIconLoader::slotData( KIO::Job *job, const TQByteArray& data )
 {
 	kdDebug(YAHOO_GEN_DEBUG) << k_funcinfo << endl;
 
diff --git a/kopete/protocols/yahoo/libkyahoo/yahoobuddyiconloader.h b/kopete/protocols/yahoo/libkyahoo/yahoobuddyiconloader.h
index 76f70cdc..f200725d 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahoobuddyiconloader.h
+++ b/kopete/protocols/yahoo/libkyahoo/yahoobuddyiconloader.h
@@ -17,9 +17,9 @@
 #define	YAHOOBUDDYICONLOADER_
 
 // QT Includes
-#include <qobject.h>
-#include <qstring.h>
-#include <qmap.h>
+#include <tqobject.h>
+#include <tqstring.h>
+#include <tqmap.h>
 
 // KDE Includes
 #include <kurl.h>
@@ -33,9 +33,9 @@ namespace KIO {
 
 struct IconLoadJob {
 	KURL url;
-	QString who;
+	TQString who;
 	int checksum;
-	QByteArray icon;
+	TQByteArray icon;
 };
 
 /**
@@ -55,21 +55,21 @@ public:
 	/**
 	 *	Add a BuddyIcon for download.
 	 */
-	void fetchBuddyIcon( const QString &who, KURL url, int checksum );
+	void fetchBuddyIcon( const TQString &who, KURL url, int checksum );
 
 signals:
 	/**
 	 * 	The account can connect to this signal and append the icon
 	 * 	stored in 'file' to the appropriate contact
 	 */
-	void fetchedBuddyIcon( const QString &who, const QByteArray &icon, int checksum );
+	void fetchedBuddyIcon( const TQString &who, const TQByteArray &icon, int checksum );
 
 private slots:
-	void slotData( KIO::Job *job, const QByteArray &data );
+	void slotData( KIO::Job *job, const TQByteArray &data );
 	void slotComplete( KIO::Job *job );
 
 private:
-	typedef QMap< KIO::TransferJob *, IconLoadJob > TransferJobMap;
+	typedef TQMap< KIO::TransferJob *, IconLoadJob > TransferJobMap;
 	TransferJobMap m_jobs;
 	Client *m_client;
 };
diff --git a/kopete/protocols/yahoo/libkyahoo/yahoobytestream.cpp b/kopete/protocols/yahoo/libkyahoo/yahoobytestream.cpp
index b0d1cbb9..028396c2 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahoobytestream.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/yahoobytestream.cpp
@@ -15,14 +15,14 @@
     *************************************************************************
 */
 
-#include <qobject.h>
+#include <tqobject.h>
 #include <kbufferedsocket.h>
 #include <kdebug.h>
 #include <kresolver.h>
 
 #include "yahoobytestream.h"
 
-KNetworkByteStream::KNetworkByteStream( QObject *parent )
+KNetworkByteStream::KNetworkByteStream( TQObject *parent )
  : ByteStream ( parent )
 {
 	kdDebug( 14181 ) << "Instantiating new KNetwork byte stream." << endl;
@@ -36,14 +36,14 @@ KNetworkByteStream::KNetworkByteStream( QObject *parent )
 	mSocket->enableRead( true );
 
 	// connect signals and slots
-	QObject::connect( mSocket, SIGNAL ( gotError ( int ) ), this, SLOT ( slotError ( int ) ) );
-	QObject::connect( mSocket, SIGNAL ( connected ( const KResolverEntry& ) ), this, SLOT ( slotConnected () ) );
-	QObject::connect( mSocket, SIGNAL ( closed () ), this, SLOT ( slotConnectionClosed () ) );
-	QObject::connect( mSocket, SIGNAL ( readyRead () ), this, SLOT ( slotReadyRead () ) );
-	QObject::connect( mSocket, SIGNAL ( bytesWritten ( int ) ), this, SLOT ( slotBytesWritten ( int ) ) );
+	TQObject::connect( mSocket, TQT_SIGNAL ( gotError ( int ) ), this, TQT_SLOT ( slotError ( int ) ) );
+	TQObject::connect( mSocket, TQT_SIGNAL ( connected ( const KResolverEntry& ) ), this, TQT_SLOT ( slotConnected () ) );
+	TQObject::connect( mSocket, TQT_SIGNAL ( closed () ), this, TQT_SLOT ( slotConnectionClosed () ) );
+	TQObject::connect( mSocket, TQT_SIGNAL ( readyRead () ), this, TQT_SLOT ( slotReadyRead () ) );
+	TQObject::connect( mSocket, TQT_SIGNAL ( bytesWritten ( int ) ), this, TQT_SLOT ( slotBytesWritten ( int ) ) );
 }
 
-bool KNetworkByteStream::connect( QString host, QString service )
+bool KNetworkByteStream::connect( TQString host, TQString service )
 {
 	kdDebug( 14181 ) << "Connecting to " << host << ", service " << service << endl;
 
@@ -68,7 +68,7 @@ void KNetworkByteStream::close ()
 int KNetworkByteStream::tryWrite ()
 {
 	// send all data from the buffers to the socket
-	QByteArray writeData = takeWrite();
+	TQByteArray writeData = takeWrite();
 	kdDebug( 14181 ) << "[writeData.size() = " << writeData.size() << "]" << endl;
 
 	socket()->writeBlock( writeData.data(), writeData.size () );
@@ -113,7 +113,7 @@ void KNetworkByteStream::slotReadyRead()
 {
 	kdDebug( 14181 );
 	// stuff all available data into our buffers
-	QByteArray readBuffer;
+	TQByteArray readBuffer;
 	readBuffer.resize( socket()->bytesAvailable () );
 
 	socket()->readBlock( readBuffer.data (), readBuffer.size () );
diff --git a/kopete/protocols/yahoo/libkyahoo/yahoobytestream.h b/kopete/protocols/yahoo/libkyahoo/yahoobytestream.h
index d48bcf36..5f7f0206 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahoobytestream.h
+++ b/kopete/protocols/yahoo/libkyahoo/yahoobytestream.h
@@ -34,11 +34,11 @@ class KNetworkByteStream : public ByteStream
 Q_OBJECT
 
 public:
-	KNetworkByteStream ( QObject *parent = 0 );
+	KNetworkByteStream ( TQObject *parent = 0 );
 
 	~KNetworkByteStream ();
 
-	bool connect ( QString host, QString service );
+	bool connect ( TQString host, TQString service );
 	virtual bool isOpen () const;
 	virtual void close ();
 
diff --git a/kopete/protocols/yahoo/libkyahoo/yahoochattask.cpp b/kopete/protocols/yahoo/libkyahoo/yahoochattask.cpp
index 56834a83..1c9528ff 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahoochattask.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/yahoochattask.cpp
@@ -25,7 +25,7 @@
 #include <kio/global.h>
 #include <kio/job.h>
 #include <kio/jobclasses.h>
-#include <qdom.h>
+#include <tqdom.h>
 
 YahooChatTask::YahooChatTask(Task* parent) : Task(parent)
 {
@@ -95,11 +95,11 @@ void YahooChatTask::getYahooChatCategories()
 	transfer->addMetaData( "UserAgent", "Mozilla/4.0 (compatible; MSIE 5.5)");
 	transfer->addMetaData( "no-cache", "true" );
 	transfer->addMetaData( "cookies", "manual" );
-	transfer->addMetaData("setcookies", QString("Cookie: %1; %2; %3").arg(client()->tCookie(), client()->yCookie()) );
+	transfer->addMetaData("setcookies", TQString("Cookie: %1; %2; %3").arg(client()->tCookie(), client()->yCookie()) );
 
 
-	connect( transfer, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotCategoriesComplete( KIO::Job* ) ) );
-	connect( transfer, SIGNAL( data( KIO::Job*, const QByteArray& ) ), this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );
+	connect( transfer, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( slotCategoriesComplete( KIO::Job* ) ) );
+	connect( transfer, TQT_SIGNAL( data( KIO::Job*, const TQByteArray& ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray& ) ) );
 }
 
 void YahooChatTask::getYahooChatRooms( const Yahoo::ChatCategory &category )
@@ -107,20 +107,20 @@ void YahooChatTask::getYahooChatRooms( const Yahoo::ChatCategory &category )
 	kdDebug(YAHOO_RAW_DEBUG) << "Category Id: " << category.id << endl;
 	KIO::TransferJob *transfer;
 
-	transfer = KIO::get( KURL(QString("http://insider.msg.yahoo.com/ycontent/?chatroom_%1=0").arg( category.id )), false, false );
+	transfer = KIO::get( KURL(TQString("http://insider.msg.yahoo.com/ycontent/?chatroom_%1=0").arg( category.id )), false, false );
 	transfer->addMetaData( "UserAgent", "Mozilla/4.0 (compatible; MSIE 5.5)");
 	transfer->addMetaData( "no-cache", "true" );
 	transfer->addMetaData( "cookies", "manual" );
-	transfer->addMetaData("setcookies", QString("Cookie: %1; %2; %3").arg(client()->tCookie(), client()->yCookie()) );
+	transfer->addMetaData("setcookies", TQString("Cookie: %1; %2; %3").arg(client()->tCookie(), client()->yCookie()) );
 
 
-	connect( transfer, SIGNAL( result( KIO::Job* ) ), this, SLOT( slotChatRoomsComplete( KIO::Job* ) ) );
-	connect( transfer, SIGNAL( data( KIO::Job*, const QByteArray& ) ), this, SLOT( slotData( KIO::Job*, const QByteArray& ) ) );
+	connect( transfer, TQT_SIGNAL( result( KIO::Job* ) ), this, TQT_SLOT( slotChatRoomsComplete( KIO::Job* ) ) );
+	connect( transfer, TQT_SIGNAL( data( KIO::Job*, const TQByteArray& ) ), this, TQT_SLOT( slotData( KIO::Job*, const TQByteArray& ) ) );
 
 	m_jobs[ transfer ].category = category;
 }
 
-void YahooChatTask::slotData( KIO::Job *job, const QByteArray& data)
+void YahooChatTask::slotData( KIO::Job *job, const TQByteArray& data)
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 	// FIXME (same)
@@ -139,7 +139,7 @@ void YahooChatTask::slotCategoriesComplete( KIO::Job *job )
 	}
 	else
 	{
-		QDomDocument doc;
+		TQDomDocument doc;
 		doc.setContent( m_jobs[ transfer ].data );
 		emit gotYahooChatCategories( doc );
 	}
@@ -159,7 +159,7 @@ void YahooChatTask::slotChatRoomsComplete( KIO::Job *job )
 	}
 	else
 	{
-		QDomDocument doc;
+		TQDomDocument doc;
 		doc.setContent( m_jobs[ transfer ].data );
 // 		kdDebug(YAHOO_RAW_DEBUG) << doc.toString();
 		emit gotYahooChatRooms( m_jobs[ transfer ].category, doc );
@@ -188,7 +188,7 @@ void YahooChatTask::joinRoom( const Yahoo::ChatRoom &room )
 	send( t );
 }
 
-void YahooChatTask::sendYahooChatMessage( const QString &msg, const QString &handle )
+void YahooChatTask::sendYahooChatMessage( const TQString &msg, const TQString &handle )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 	if( !m_loggedIn )
@@ -214,7 +214,7 @@ void YahooChatTask::login()
 	YMSGTransfer *t = new YMSGTransfer(Yahoo::ServiceChatOnline);
 	t->setId( client()->sessionID() );
 	t->setParam( 1, client()->userId().local8Bit() );
-	t->setParam( 135, QString("ym%1").arg(YMSG_PROGRAM_VERSION_STRING).local8Bit() );
+	t->setParam( 135, TQString("ym%1").arg(YMSG_PROGRAM_VERSION_STRING).local8Bit() );
 
 	send( t );
 }
@@ -232,11 +232,11 @@ void YahooChatTask::logout()
 
 void YahooChatTask::parseLoginResponse( YMSGTransfer *t )
 {
-	if( !QString(t->firstParam( 1 )).startsWith( client()->userId().local8Bit() ) )
+	if( !TQString(t->firstParam( 1 )).startsWith( client()->userId().local8Bit() ) )
 		return;
 	m_loggedIn = true;
 
-	QValueList< Yahoo::ChatRoom >::iterator it;
+	TQValueList< Yahoo::ChatRoom >::iterator it;
 	for ( it = m_pendingJoins.begin(); it != m_pendingJoins.end(); ++it )
 	//for( int i = 0; i < m_pendingJoins.size(); ++i )
 	{
@@ -255,10 +255,10 @@ void YahooChatTask::parseJoin( YMSGTransfer *t )
 {
 	int room;
 	int category;
-	QString handle;
-	QString comment;
+	TQString handle;
+	TQString comment;
 	bool suppressJoinNotification = false;
-	QString error;
+	TQString error;
 
 	room = t->firstParam( 129 ).toInt();
 	category = t->firstParam( 128 ).toInt();
@@ -296,7 +296,7 @@ void YahooChatTask::parseJoin( YMSGTransfer *t )
 		emit chatRoomJoined( room, category, comment, handle );
 	}
 
-	QString nick;
+	TQString nick;
 	for( int i = 0; i < t->paramCount( 109 ); ++i )
 	{
 		nick = t->nthParam( 109 , i );
@@ -308,9 +308,9 @@ void YahooChatTask::parseChatMessage( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString handle;
-	QString msg;
-	QString nick;
+	TQString handle;
+	TQString msg;
+	TQString nick;
 
 	handle = t->firstParam( 104 );
 	for( int i = 0; i < t->paramCount( 109 ); ++i )
@@ -325,8 +325,8 @@ void YahooChatTask::parseChatExit( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString handle;
-	QString nick;
+	TQString handle;
+	TQString nick;
 
 	handle = t->firstParam( 104 );
 	for( int i = 0; i < t->paramCount( 109 ); ++i )
@@ -340,7 +340,7 @@ void YahooChatTask::parseLogout( YMSGTransfer *t )
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
-	QString nick = t->firstParam( 1 );
+	TQString nick = t->firstParam( 1 );
 	if( nick == client()->userId() )
 		m_loggedIn = false;
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/yahoochattask.h b/kopete/protocols/yahoo/libkyahoo/yahoochattask.h
index 310b174d..3de4cbd4 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahoochattask.h
+++ b/kopete/protocols/yahoo/libkyahoo/yahoochattask.h
@@ -20,9 +20,9 @@
 
 #include "task.h"
 #include "yahootypes.h"
-#include <qmap.h>
-#include <qvaluelist.h>
-#include <qpair.h>
+#include <tqmap.h>
+#include <tqvaluelist.h>
+#include <tqpair.h>
 
 class QDomDocument;
 class YMSGTransfer;
@@ -31,7 +31,7 @@ namespace KIO {
 }
 
 struct YahooChatJob {
-	QByteArray data;
+	TQByteArray data;
 	Yahoo::ChatCategory category;
 };
 
@@ -54,18 +54,18 @@ public:
 
 	void joinRoom( const Yahoo::ChatRoom &room );
 
-	void sendYahooChatMessage( const QString &msg, const QString &handle );
+	void sendYahooChatMessage( const TQString &msg, const TQString &handle );
 
 	void logout();
 
 signals:
-	void gotYahooChatCategories( const QDomDocument & );
-	void gotYahooChatRooms( const Yahoo::ChatCategory &, const QDomDocument & );
+	void gotYahooChatCategories( const TQDomDocument & );
+	void gotYahooChatRooms( const Yahoo::ChatCategory &, const TQDomDocument & );
 
-	void chatRoomJoined( int roomId, int categoryId, const QString &comment, const QString &handle );
-	void chatBuddyHasJoined( const QString &nick, const QString &handle, bool suppressNotification );
-	void chatBuddyHasLeft( const QString &nick, const QString &handle );
-	void chatMessageReceived( const QString &nick, const QString &message, const QString &handle );
+	void chatRoomJoined( int roomId, int categoryId, const TQString &comment, const TQString &handle );
+	void chatBuddyHasJoined( const TQString &nick, const TQString &handle, bool suppressNotification );
+	void chatBuddyHasLeft( const TQString &nick, const TQString &handle );
+	void chatMessageReceived( const TQString &nick, const TQString &message, const TQString &handle );
 private:
 	void login();
 	void parseLoginResponse( YMSGTransfer *t );
@@ -75,12 +75,12 @@ private:
 	void parseLogout( YMSGTransfer * );
 
 private slots:
-	void slotData( KIO::Job *, const QByteArray & );
+	void slotData( KIO::Job *, const TQByteArray & );
 	void slotCategoriesComplete( KIO::Job * );
 	void slotChatRoomsComplete( KIO::Job * );
 private:
-	QMap< KIO::Job *, YahooChatJob > m_jobs;
-	QValueList< Yahoo::ChatRoom > m_pendingJoins;
+	TQMap< KIO::Job *, YahooChatJob > m_jobs;
+	TQValueList< Yahoo::ChatRoom > m_pendingJoins;
 	bool m_loggedIn;
 };
 
diff --git a/kopete/protocols/yahoo/libkyahoo/yahooclientstream.cpp b/kopete/protocols/yahoo/libkyahoo/yahooclientstream.cpp
index 3279bbd0..34eb649e 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahooclientstream.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/yahooclientstream.cpp
@@ -20,11 +20,11 @@
 
 
 
-#include <qapplication.h>  // for qdebug
-#include <qguardedptr.h>
-#include <qobject.h>
-#include <qptrqueue.h>
-#include <qtimer.h>
+#include <tqapplication.h>  // for qdebug
+#include <tqguardedptr.h>
+#include <tqobject.h>
+#include <tqptrqueue.h>
+#include <tqtimer.h>
 
 #include <kdebug.h>
 
@@ -36,7 +36,7 @@
 #include "yahooclientstream.h"
 #include "yahootypes.h"
 
-void cs_dump( const QByteArray &bytes );
+void cs_dump( const TQByteArray &bytes );
 
 enum {
 	Idle,
@@ -58,9 +58,9 @@ public:
 		conn = 0;
 		bs = 0;
 
-		username = QString::null;
-		password = QString::null;
-		server = QString::null;
+		username = TQString::null;
+		password = TQString::null;
+		server = TQString::null;
 		haveLocalAddr = false;
 		doBinding = true;
 
@@ -73,12 +73,12 @@ public:
 		newTransfers = false;
 	}
 
-	QString username;
-	QString password;
-	QString server;
+	TQString username;
+	TQString password;
+	TQString server;
 	bool doAuth; //send the initial login sequences to get the cookie
 	bool haveLocalAddr;
-	QHostAddress localAddr;
+	TQHostAddress localAddr;
 	Q_UINT16 localPort;
 	bool doBinding;
 
@@ -86,7 +86,7 @@ public:
 	ByteStream *bs;
 	CoreProtocol client;
 
-	QString defRealm;
+	TQString defRealm;
 
 	int mode;
 	int state;
@@ -94,28 +94,28 @@ public:
 	bool newTransfers;
 
 	int errCond;
-	QString errText;
+	TQString errText;
 
-	QPtrQueue<Transfer> in;
+	TQPtrQueue<Transfer> in;
 
-	QTimer noopTimer; // used to send icq keepalive
+	TQTimer noopTimer; // used to send icq keepalive
 	int noop_time;
 };
 
-ClientStream::ClientStream(Connector *conn, QObject *parent)
+ClientStream::ClientStream(Connector *conn, TQObject *parent)
 :Stream(parent), d(new Private())
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
 	d->mode = Client;
 	d->conn = conn;
-	connect( d->conn, SIGNAL(connected()), SLOT(cr_connected()) );
-	connect( d->conn, SIGNAL(error()), SLOT(cr_error()) );
-	connect( &d->client, SIGNAL( outgoingData( const QByteArray& ) ), SLOT ( cp_outgoingData( const QByteArray & ) ) );
-	connect( &d->client, SIGNAL( incomingData() ), SLOT ( cp_incomingData() ) );
+	connect( d->conn, TQT_SIGNAL(connected()), TQT_SLOT(cr_connected()) );
+	connect( d->conn, TQT_SIGNAL(error()), TQT_SLOT(cr_error()) );
+	connect( &d->client, TQT_SIGNAL( outgoingData( const TQByteArray& ) ), TQT_SLOT ( cp_outgoingData( const TQByteArray & ) ) );
+	connect( &d->client, TQT_SIGNAL( incomingData() ), TQT_SLOT ( cp_incomingData() ) );
 
 	d->noop_time = 0;
-	connect(&d->noopTimer, SIGNAL(timeout()), SLOT(doNoop()));
+	connect(&d->noopTimer, TQT_SIGNAL(timeout()), TQT_SLOT(doNoop()));
 }
 
 ClientStream::~ClientStream()
@@ -148,7 +148,7 @@ void ClientStream::reset(bool all)
 		d->in.clear();
 }
 
-void ClientStream::connectToServer(const QString& server, bool auth)
+void ClientStream::connectToServer(const TQString& server, bool auth)
 {
 	kdDebug(YAHOO_RAW_DEBUG) ;
 	reset(true);
@@ -203,7 +203,7 @@ void ClientStream::setNoopTime(int mills)
 	d->noopTimer.start(d->noop_time);
 }
 
-void ClientStream::setLocalAddr(const QHostAddress &addr, Q_UINT16 port)
+void ClientStream::setLocalAddr(const TQHostAddress &addr, Q_UINT16 port)
 {
 	d->haveLocalAddr = true;
 	d->localAddr = addr;
@@ -215,7 +215,7 @@ int ClientStream::errorCondition() const
 	return d->errCond;
 }
 
-QString ClientStream::errorText() const
+TQString ClientStream::errorText() const
 {
 	return d->errText;
 }
@@ -253,7 +253,7 @@ void ClientStream::write( Transfer *request )
 	d->client.outgoingTransfer( request );
 }
 
-void cs_dump( const QByteArray &bytes )
+void cs_dump( const TQByteArray &bytes )
 {
 #if 0
 	qDebug( "contains: %i bytes ", bytes.count() );
@@ -295,7 +295,7 @@ void cs_dump( const QByteArray &bytes )
 	Q_UNUSED( bytes );
 }
 
-void ClientStream::cp_outgoingData( const QByteArray& outgoingBytes )
+void ClientStream::cp_outgoingData( const TQByteArray& outgoingBytes )
 {
 	if ( !d->bs )
 		return;
@@ -327,15 +327,15 @@ void ClientStream::cr_connected()
 	kdDebug(YAHOO_RAW_DEBUG) ;
 
 	d->bs = d->conn->stream();
-	connect(d->bs, SIGNAL(connectionClosed()), SLOT(bs_connectionClosed()));
-	connect(d->bs, SIGNAL(delayedCloseFinished()), SLOT(bs_delayedCloseFinished()));
-	connect(d->bs, SIGNAL(readyRead()), SLOT(bs_readyRead()));
-	connect(d->bs, SIGNAL(bytesWritten(int)), SLOT(bs_bytesWritten(int)));
-	connect(d->bs, SIGNAL(error(int)), SLOT(bs_error(int)));
+	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(readyRead()), TQT_SLOT(bs_readyRead()));
+	connect(d->bs, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(bs_bytesWritten(int)));
+	connect(d->bs, TQT_SIGNAL(error(int)), TQT_SLOT(bs_error(int)));
 
-	QByteArray spare = d->bs->read();
+	TQByteArray spare = d->bs->read();
 
-	QGuardedPtr<QObject> self = this;
+	TQGuardedPtr<TQObject> self = this;
 	emit connected();
 	if(!self)
 		return;
@@ -368,11 +368,11 @@ void ClientStream::bs_error(int)
 void ClientStream::bs_readyRead()
 {
 // 	kdDebug(YAHOO_RAW_DEBUG) ;
-	QByteArray a;
+	TQByteArray a;
 	//qDebug( "size of storage for incoming data is %i bytes.", a.size() );
 	a = d->bs->read();
 
-	//QCString cs(a.data(), a.size()+1);
+	//TQCString cs(a.data(), a.size()+1);
 	//qDebug("ClientStream: recv: %d [%s]\n", a.size(), cs.data());
 	//kdDebug(YAHOO_RAW_DEBUG) << " recv: " << a.size()  <<" bytes";
 	//cs_dump( a );
@@ -399,7 +399,7 @@ void ClientStream::processNext()
 {
 	if( !d->in.isEmpty() )
 	{
-		QTimer::singleShot(0, this, SLOT(doReadyRead()));
+		TQTimer::singleShot(0, this, TQT_SLOT(doReadyRead()));
 	}
 }
 
diff --git a/kopete/protocols/yahoo/libkyahoo/yahooclientstream.h b/kopete/protocols/yahoo/libkyahoo/yahooclientstream.h
index 01ca6a2a..6efc307f 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahooclientstream.h
+++ b/kopete/protocols/yahoo/libkyahoo/yahooclientstream.h
@@ -71,19 +71,19 @@ public:
 		BindConflict                // resource in-use
 	};
 
-	explicit ClientStream(Connector *conn, QObject *parent=0);
+	explicit ClientStream(Connector *conn, TQObject *parent=0);
 	~ClientStream();
 
-	void connectToServer(const QString& server, bool auth=true);
+	void connectToServer(const TQString& server, bool auth=true);
 	void accept(); // server
 	bool isActive() const;
 	bool isAuthenticated() const;
 
 	// login params
-	void setUsername(const QString &s);
-	void setPassword(const QString &s);
+	void setUsername(const TQString &s);
+	void setPassword(const TQString &s);
 
-	void setLocalAddr(const QHostAddress &addr, Q_UINT16 port);
+	void setLocalAddr(const TQHostAddress &addr, Q_UINT16 port);
 
 	void close();
 
@@ -103,10 +103,10 @@ public:
 	void write( Transfer* request );
 
 	int errorCondition() const;
-	QString errorText() const;
+	TQString errorText() const;
 
 	// extrahttp://bugs.kde.org/show_bug.cgi?id=85158
-/*#	void writeDirect(const QString &s); // must be for debug testing*/
+/*#	void writeDirect(const TQString &s); // must be for debug testing*/
 	void setNoopTime(int mills);
 
 signals:
@@ -124,7 +124,7 @@ private slots:
 	/**
 	 * collects wire ready outgoing data from the core protocol and sends
 	 */
-	void cp_outgoingData( const QByteArray& );
+	void cp_outgoingData( const TQByteArray& );
 	/**
 	 * collects parsed incoming data as a transfer from the core protocol and queues
 	 */
diff --git a/kopete/protocols/yahoo/libkyahoo/yahooconnector.cpp b/kopete/protocols/yahoo/libkyahoo/yahooconnector.cpp
index fce630db..9b7c8d8a 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahooconnector.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/yahooconnector.cpp
@@ -25,7 +25,7 @@
 #include "yahoobytestream.h"
 #include "yahootypes.h"
 
-KNetworkConnector::KNetworkConnector( QObject *parent )
+KNetworkConnector::KNetworkConnector( TQObject *parent )
 		: Connector( parent )
 {
 	kdDebug( YAHOO_RAW_DEBUG ) << "New KNetwork connector." << endl;
@@ -34,8 +34,8 @@ KNetworkConnector::KNetworkConnector( QObject *parent )
 
 	mByteStream = new KNetworkByteStream( this );
 
-	connect( mByteStream, SIGNAL ( connected () ), this, SLOT ( slotConnected () ) );
-	connect( mByteStream, SIGNAL ( error ( int ) ), this, SLOT ( slotError ( int ) ) );
+	connect( mByteStream, TQT_SIGNAL ( connected () ), this, TQT_SLOT ( slotConnected () ) );
+	connect( mByteStream, TQT_SIGNAL ( error ( int ) ), this, TQT_SLOT ( slotError ( int ) ) );
 	mPort = 5510;
 }
 
@@ -44,7 +44,7 @@ KNetworkConnector::~KNetworkConnector()
 	delete mByteStream;
 }
 
-void KNetworkConnector::connectToServer( const QString &server )
+void KNetworkConnector::connectToServer( const TQString &server )
 {
 	Q_UNUSED( server );
 	kdDebug( YAHOO_RAW_DEBUG ) << "Initiating connection to " << mHost << endl;
@@ -53,7 +53,7 @@ void KNetworkConnector::connectToServer( const QString &server )
 
 	mErrorCode = KNetwork::KSocketBase::NoError;
 
-	if ( !mByteStream->connect( mHost, QString::number (mPort) ) )
+	if ( !mByteStream->connect( mHost, TQString::number (mPort) ) )
 	{
 		// Houston, we have a problem
 		mErrorCode = mByteStream->socket()->error();
@@ -67,7 +67,7 @@ void KNetworkConnector::slotConnected()
 
 	// FIXME: setPeerAddress() is something different, find out correct usage later
 	//KInetSocketAddress inetAddress = mStreamSocket->address().asInet().makeIPv6 ();
-	//setPeerAddress ( QHostAddress ( inetAddress.ipAddress().addr () ), inetAddress.port () );
+	//setPeerAddress ( TQHostAddress ( inetAddress.ipAddress().addr () ), inetAddress.port () );
 
 	emit connected ();
 }
@@ -97,7 +97,7 @@ void KNetworkConnector::done()
 	mByteStream->close ();
 }
 
-void KNetworkConnector::setOptHostPort( const QString &host, Q_UINT16 port )
+void KNetworkConnector::setOptHostPort( const TQString &host, Q_UINT16 port )
 {
 	kdDebug ( YAHOO_RAW_DEBUG ) << "Manually specifying host " << host << " and port " << port << endl;
 
diff --git a/kopete/protocols/yahoo/libkyahoo/yahooconnector.h b/kopete/protocols/yahoo/libkyahoo/yahooconnector.h
index 10c86ce0..b4758e72 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahooconnector.h
+++ b/kopete/protocols/yahoo/libkyahoo/yahooconnector.h
@@ -36,15 +36,15 @@ class KNetworkConnector : public Connector
 Q_OBJECT
 
 public:
-	KNetworkConnector( QObject *parent = 0 );
+	KNetworkConnector( TQObject *parent = 0 );
 
 	virtual ~KNetworkConnector();
 
-	virtual void connectToServer( const QString &server );
+	virtual void connectToServer( const TQString &server );
 	virtual ByteStream *stream() const;
 	virtual void done();
 
-	void setOptHostPort( const QString &host, Q_UINT16 port );
+	void setOptHostPort( const TQString &host, Q_UINT16 port );
 
 	int errorCode();
 
@@ -53,7 +53,7 @@ private slots:
 	void slotError( int );
 
 private:
-	QString mHost;
+	TQString mHost;
 	Q_UINT16 mPort;
 	int mErrorCode;
 
diff --git a/kopete/protocols/yahoo/libkyahoo/yahootypes.h b/kopete/protocols/yahoo/libkyahoo/yahootypes.h
index 244d4022..0e8858c5 100644
--- a/kopete/protocols/yahoo/libkyahoo/yahootypes.h
+++ b/kopete/protocols/yahoo/libkyahoo/yahootypes.h
@@ -18,8 +18,8 @@
 #ifndef YAHOOTYPESH
 #define YAHOOTYPESH
 
-#include <qglobal.h>
-#include <qstring.h>
+#include <tqglobal.h>
+#include <tqstring.h>
 
 const int YAHOO_RAW_DEBUG = 14181;
 const int YAHOO_GEN_DEBUG = 14180;
@@ -172,13 +172,13 @@ namespace Yahoo
 	typedef Q_UINT32 DWORD;
 
 	struct ChatRoom {
-		QString name;
-		QString topic;
+		TQString name;
+		TQString topic;
 		int id;
 	};
 
 	struct ChatCategory {
-		QString name;
+		TQString name;
 		int id;
 	};
 }
diff --git a/kopete/protocols/yahoo/libkyahoo/ymsgprotocol.cpp b/kopete/protocols/yahoo/libkyahoo/ymsgprotocol.cpp
index ce2c65eb..b1e6e4e3 100644
--- a/kopete/protocols/yahoo/libkyahoo/ymsgprotocol.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/ymsgprotocol.cpp
@@ -16,16 +16,16 @@
     *************************************************************************
 */
 
-//#include <QDataStream>
-//#include <QMap>
-//#include <QObject>
-//#include <QStringList>
+//#include <TQDataStream>
+//#include <TQMap>
+//#include <TQObject>
+//#include <TQStringList>
 
-//#include <qcstring.h>
-#include <qdatastream.h>
-#include <qmap.h>
-#include <qobject.h>
-#include <qstringlist.h>
+//#include <tqcstring.h>
+#include <tqdatastream.h>
+#include <tqmap.h>
+#include <tqobject.h>
+#include <tqstringlist.h>
 
 
 #include <kdebug.h>
@@ -36,7 +36,7 @@
 
 using namespace Yahoo;
 
-YMSGProtocol::YMSGProtocol(QObject *parent, const char *name)
+YMSGProtocol::YMSGProtocol(TQObject *parent, const char *name)
  : InputProtocolBase(parent, name)
 {
 }
@@ -45,7 +45,7 @@ YMSGProtocol::~YMSGProtocol()
 {
 }
 
-Transfer* YMSGProtocol::parse( const QByteArray & packet, uint& bytes )
+Transfer* YMSGProtocol::parse( const TQByteArray & packet, uint& bytes )
 {
 	/*
 	<------- 4B -------><------- 4B -------><---2B--->
@@ -71,7 +71,7 @@ Transfer* YMSGProtocol::parse( const QByteArray & packet, uint& bytes )
 	int servicenum;
 	int version1, version2;
 
-	QMap<QString, QString> params;
+	TQMap<TQString, TQString> params;
 
 	// Skip the YMSG header
 	pos += 4;
@@ -381,13 +381,13 @@ Transfer* YMSGProtocol::parse( const QByteArray & packet, uint& bytes )
 	t->setStatus(status);
 	t->setPacketLength(len);
 
-        QString d = QString::fromAscii( packet.data() + pos, packet.size() - pos );
-        QStringList list = QStringList::split( "\xc0\x80", d );
+        TQString d = TQString::fromAscii( packet.data() + pos, packet.size() - pos );
+        TQStringList list = TQStringList::split( "\xc0\x80", d );
         for( int i = 0; i+1 < list.size() && pos+1 < len+20; i += 2 ) {
-                QString key = list[i];
-                QString value = QString::fromUtf8( list[i+1].ascii() );
+                TQString key = list[i];
+                TQString value = TQString::fromUtf8( list[i+1].ascii() );
                 pos += key.utf8().length() + value.utf8().length() + 4;
-                t->setParam( QString(key).toInt(), value.utf8() );
+                t->setParam( TQString(key).toInt(), value.utf8() );
                 kdDebug(YAHOO_RAW_DEBUG) << k_funcinfo << "Key: " << key << " Value: " << value << endl;
         }
 
diff --git a/kopete/protocols/yahoo/libkyahoo/ymsgprotocol.h b/kopete/protocols/yahoo/libkyahoo/ymsgprotocol.h
index 230745ef..a3ac04a6 100644
--- a/kopete/protocols/yahoo/libkyahoo/ymsgprotocol.h
+++ b/kopete/protocols/yahoo/libkyahoo/ymsgprotocol.h
@@ -28,7 +28,7 @@ Q_OBJECT
 public:
 
 
-	YMSGProtocol( QObject *parent = 0, const char *name = 0 );
+	YMSGProtocol( TQObject *parent = 0, const char *name = 0 );
 	~YMSGProtocol();
 
 	/**
@@ -38,7 +38,7 @@ public:
 	 * @param bytes An integer used to return the number of bytes read.
 	 * @return A pointer to an EventTransfer object if successful, otherwise 0.  The caller is responsible for deleting this object.
 	 */
-	Transfer * parse( const QByteArray &, uint & bytes );
+	Transfer * parse( const TQByteArray &, uint & bytes );
 };
 
 #endif
diff --git a/kopete/protocols/yahoo/libkyahoo/ymsgtransfer.cpp b/kopete/protocols/yahoo/libkyahoo/ymsgtransfer.cpp
index 233b0c85..dcee98d9 100644
--- a/kopete/protocols/yahoo/libkyahoo/ymsgtransfer.cpp
+++ b/kopete/protocols/yahoo/libkyahoo/ymsgtransfer.cpp
@@ -24,10 +24,10 @@
 #include "yahootypes.h"
 #include "kdebug.h"
 
-#include <qdatastream.h>
-#include <qmap.h>
-#include <qstring.h>
-#include <qstringlist.h>
+#include <tqdatastream.h>
+#include <tqmap.h>
+#include <tqstring.h>
+#include <tqstringlist.h>
 
 
 using namespace Yahoo;
@@ -143,7 +143,7 @@ int YMSGTransfer::paramCount( int index ) const
 }
 
 
-QCString YMSGTransfer::nthParam( int index, int occurrence ) const
+TQCString YMSGTransfer::nthParam( int index, int occurrence ) const
 {
 	int cnt = 0;
 	for (ParamList::ConstIterator it = d->data.constBegin(); it !=  d->data.constEnd(); ++it)
@@ -151,10 +151,10 @@ QCString YMSGTransfer::nthParam( int index, int occurrence ) const
 		if( (*it).first == index && cnt++ == occurrence)
 			return (*it).second;
 	}
-	return QCString();
+	return TQCString();
 }
 
-QCString YMSGTransfer::nthParamSeparated( int index, int occurrence, int separator ) const
+TQCString YMSGTransfer::nthParamSeparated( int index, int occurrence, int separator ) const
 {
 
 	int cnt = -1;
@@ -165,27 +165,27 @@ QCString YMSGTransfer::nthParamSeparated( int index, int occurrence, int separat
 		if( (*it).first == index && cnt == occurrence)
 			return (*it).second;
 	}
-	return QCString();
+	return TQCString();
 }
 
-QCString YMSGTransfer::firstParam( int index ) const
+TQCString YMSGTransfer::firstParam( int index ) const
 {
 	for (ParamList::ConstIterator it = d->data.constBegin(); it !=  d->data.constEnd(); ++it)
 	{
 		if( (*it).first == index )
 			return (*it).second;
 	}
-	return QCString();
+	return TQCString();
 }
 
-void YMSGTransfer::setParam(int index, const QCString &data)
+void YMSGTransfer::setParam(int index, const TQCString &data)
 {
 	d->data.append( Param( index, data ) );
 }
 
 void YMSGTransfer::setParam( int index, int data )
 {
-	d->data.append( Param( index, QString::number( data ).local8Bit() ) );
+	d->data.append( Param( index, TQString::number( data ).local8Bit() ) );
 }
 
 int YMSGTransfer::length() const
@@ -193,7 +193,7 @@ int YMSGTransfer::length() const
 	int len = 0;
 	for (ParamList::ConstIterator it = d->data.constBegin(); it !=  d->data.constEnd(); ++it)
 	{
-		len += QString::number( (*it).first ).length();
+		len += TQString::number( (*it).first ).length();
 		len += 2;
 		len += (*it).second.length();
 		len += 2;
@@ -202,7 +202,7 @@ int YMSGTransfer::length() const
 }
 
 
-QByteArray YMSGTransfer::serialize() const
+TQByteArray YMSGTransfer::serialize() const
 {
 	/*
 	<------- 4B -------><------- 4B -------><---2B--->
@@ -218,9 +218,9 @@ QByteArray YMSGTransfer::serialize() const
 	*/
 
 	int pos = 0;
-	QStringList::ConstIterator listIt = 0;
-	QByteArray buffer;
-	QDataStream stream( buffer, IO_WriteOnly );
+	TQStringList::ConstIterator listIt = 0;
+	TQByteArray buffer;
+	TQDataStream stream( buffer, IO_WriteOnly );
 
 	stream << (Q_INT8)'Y' << (Q_INT8)'M' << (Q_INT8)'S' << (Q_INT8)'G';
 	if( d->service == Yahoo::ServicePictureUpload )
@@ -239,7 +239,7 @@ QByteArray YMSGTransfer::serialize() const
  	for (ParamList::ConstIterator it = d->data.constBegin(); it !=  d->data.constEnd(); ++it)
 	{
  		kdDebug(YAHOO_RAW_DEBUG) << " Serializing key " << (*it).first << " value " << (*it).second << endl;
-		stream.writeRawBytes ( QString::number( (*it).first ).local8Bit(), QString::number( (*it).first ).length() );
+		stream.writeRawBytes ( TQString::number( (*it).first ).local8Bit(), TQString::number( (*it).first ).length() );
 		stream << (Q_INT8)0xc0 << (Q_INT8)0x80;
 		stream.writeRawBytes( (*it).second, (*it).second.length() );
 		stream << (Q_INT8)0xc0 << (Q_INT8)0x80;
diff --git a/kopete/protocols/yahoo/libkyahoo/ymsgtransfer.h b/kopete/protocols/yahoo/libkyahoo/ymsgtransfer.h
index 662ca4d2..0b157792 100644
--- a/kopete/protocols/yahoo/libkyahoo/ymsgtransfer.h
+++ b/kopete/protocols/yahoo/libkyahoo/ymsgtransfer.h
@@ -25,13 +25,13 @@
 
 #include "yahootypes.h"
 
-#include <qpair.h>
-#include <qvaluelist.h>
+#include <tqpair.h>
+#include <tqvaluelist.h>
 
 class YMSGTransferPrivate;
 
-typedef QPair< int, QCString > Param;
-typedef QValueList< Param > ParamList;
+typedef QPair< int, TQCString > Param;
+typedef TQValueList< Param > ParamList;
 
 /**
 @author Duncan Mac-Vicar Prett
@@ -60,15 +60,15 @@ public:
 
 
 	ParamList paramList() const;
-	QCString firstParam( int index ) const;
-	QCString nthParam( int index, int occurrence ) const;
-	QCString nthParamSeparated( int index, int occurrence, int separator ) const;
+	TQCString firstParam( int index ) const;
+	TQCString nthParam( int index, int occurrence ) const;
+	TQCString nthParamSeparated( int index, int occurrence, int separator ) const;
 	int paramCount( int index ) const;
 
 
-	void setParam(int index, const QCString &data);
+	void setParam(int index, const TQCString &data);
 	void setParam(int index, int data);
-	QByteArray serialize() const;
+	TQByteArray serialize() const;
 
 	int length() const;
 private: