Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

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

24 files changed, 406 insertions, 406 deletions

diff --git a/kopete/protocols/irc/ircaccount.cpp b/kopete/protocols/irc/ircaccount.cpp
index ab7ba892..5175865a 100644
--- a/kopete/protocols/irc/ircaccount.cpp
+++ b/kopete/protocols/irc/ircaccount.cpp
@@ -82,36 +82,36 @@ IRCAccount::IRCAccount(IRCProtocol *protocol, const TQString &accountId, const T
 	TQString version=i18n("Kopete IRC Plugin %1 [http://trinitydesktop.org]").arg(kapp->aboutData()->version());
 	m_engine->setVersionString( version  );
 
-	TQObject::connect(m_engine, TQT_SIGNAL(successfullyChangedNick(const TQString &, const TQString &)),
-			this, TQT_SLOT(successfullyChangedNick(const TQString &, const TQString &)));
+	TQObject::connect(m_engine, TQ_SIGNAL(successfullyChangedNick(const TQString &, const TQString &)),
+			this, TQ_SLOT(successfullyChangedNick(const TQString &, const TQString &)));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingFailedServerPassword()),
-			this, TQT_SLOT(slotFailedServerPassword()));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingFailedServerPassword()),
+			this, TQ_SLOT(slotFailedServerPassword()));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingNickInUse(const TQString &)),
-			this, TQT_SLOT(slotNickInUseAlert( const TQString &)) );
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingNickInUse(const TQString &)),
+			this, TQ_SLOT(slotNickInUseAlert( const TQString &)) );
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingFailedNickOnLogin(const TQString &)),
-			this, TQT_SLOT(slotNickInUse( const TQString &)) );
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingFailedNickOnLogin(const TQString &)),
+			this, TQ_SLOT(slotNickInUse( const TQString &)) );
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingJoinedChannel(const TQString &, const TQString &)),
-		this, TQT_SLOT(slotJoinedUnknownChannel(const TQString &, const TQString &)));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingJoinedChannel(const TQString &, const TQString &)),
+		this, TQ_SLOT(slotJoinedUnknownChannel(const TQString &, const TQString &)));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingCtcpReply(const TQString &, const TQString &, const TQString &)),
-			this, TQT_SLOT( slotNewCtcpReply(const TQString&, const TQString &, const TQString &)));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingCtcpReply(const TQString &, const TQString &, const TQString &)),
+			this, TQ_SLOT( slotNewCtcpReply(const TQString&, const TQString &, const TQString &)));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(statusChanged(KIRC::Engine::Status)),
-			 this, TQT_SLOT(engineStatusChanged(KIRC::Engine::Status)));
+	TQObject::connect(m_engine, TQ_SIGNAL(statusChanged(KIRC::Engine::Status)),
+			 this, TQ_SLOT(engineStatusChanged(KIRC::Engine::Status)));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingServerLoadTooHigh()),
-		this, TQT_SLOT(slotServerBusy()));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingServerLoadTooHigh()),
+		this, TQ_SLOT(slotServerBusy()));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingNoSuchNickname(const TQString &)),
-			 this, TQT_SLOT(slotNoSuchNickname(const TQString &)));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingNoSuchNickname(const TQString &)),
+			 this, TQ_SLOT(slotNoSuchNickname(const TQString &)));
 
 	mAwayAction = new Kopete::AwayAction ( i18n("Set Away"),
 		m_protocol->m_UserStatusAway.iconFor( this ), 0, this,
-		TQT_SLOT(slotGoAway( const TQString & )), this );
+		TQ_SLOT(slotGoAway( const TQString & )), this );
 
 	currentHost = 0;
 
@@ -208,9 +208,9 @@ IRCAccount::IRCAccount(IRCProtocol *protocol, const TQString &accountId, const T
 	m_myServer = m_contactManager->myServer();
 
 	m_joinChannelAction = new TDEAction ( i18n("Join Channel..."), TQString(), 0, this,
-				TQT_SLOT(slotJoinChannel()), this);
+				TQ_SLOT(slotJoinChannel()), this);
 	m_searchChannelAction = new TDEAction ( i18n("Search Channels..."), TQString(), 0, this,
-				TQT_SLOT(slotSearchChannels()), this);
+				TQ_SLOT(slotSearchChannels()), this);
 }
 
 IRCAccount::~IRCAccount()
@@ -426,12 +426,12 @@ TDEActionMenu *IRCAccount::actionMenu()
 	mActionMenu->popupMenu()->insertSeparator();
 	mActionMenu->insert(m_joinChannelAction);
 	mActionMenu->insert(m_searchChannelAction);
-	mActionMenu->insert( new TDEAction ( i18n("Show Server Window"), TQString(), 0, this, TQT_SLOT(slotShowServerWindow()), mActionMenu ) );
+	mActionMenu->insert( new TDEAction ( i18n("Show Server Window"), TQString(), 0, this, TQ_SLOT(slotShowServerWindow()), mActionMenu ) );
 
 	if( m_engine->isConnected() && m_engine->useSSL() )
 	{
 		mActionMenu->insert( new TDEAction ( i18n("Show Security Information"), "", 0, m_engine,
-			TQT_SLOT(showInfoDialog()), mActionMenu ) );
+			TQ_SLOT(showInfoDialog()), mActionMenu ) );
 	}
 
 	return mActionMenu;
@@ -534,7 +534,7 @@ void IRCAccount::engineStatusChanged(KIRC::Engine::Status newStatus)
 			// after the 001 is sent, you need to wait until all the init junk is done.
 			// Unfortunatly, there is no way for us to know when it is done (it could be
 			// spewing out any number of replies), so just try delaying it
-			TQTimer::singleShot( 250, this, TQT_SLOT( slotPerformOnConnectCommands() ) );
+			TQTimer::singleShot( 250, this, TQ_SLOT( slotPerformOnConnectCommands() ) );
 		}
 		break;
 	case KIRC::Engine::Closing:
@@ -598,7 +598,7 @@ void IRCAccount::slotSearchChannels()
 	{
 		m_channelList = new ChannelListDialog( m_engine,
 			i18n("Channel List for %1").arg( m_engine->currentHost() ), this,
-			TQT_SLOT( slotJoinNamedChannel( const TQString & ) ) );
+			TQ_SLOT( slotJoinNamedChannel( const TQString & ) ) );
 	}
 	else
 		m_channelList->clear();
@@ -889,7 +889,7 @@ IRCContact *IRCAccount::getContact(KIRC::EntityPtr entity, Kopete::MetaContact *
 		m_contacts.append(contact);
 	}
 
-	TQObject::connect(contact, TQT_SIGNAL(destroyed(IRCContact *)), TQT_SLOT(destroyed(IRCContact *)));
+	TQObject::connect(contact, TQ_SIGNAL(destroyed(IRCContact *)), TQ_SLOT(destroyed(IRCContact *)));
 	return contact;
 }
 
diff --git a/kopete/protocols/irc/ircaddcontactpage.cpp b/kopete/protocols/irc/ircaddcontactpage.cpp
index ec8f61e3..44e20c33 100644
--- a/kopete/protocols/irc/ircaddcontactpage.cpp
+++ b/kopete/protocols/irc/ircaddcontactpage.cpp
@@ -38,11 +38,11 @@ IRCAddContactPage::IRCAddContactPage( TQWidget *parent, IRCAccount *a ) : AddCon
 	mSearch = new ChannelList( (TQWidget*)ircdata->hbox, a->engine() );
 	mAccount = a;
 
-	connect( mSearch, TQT_SIGNAL( channelSelected( const TQString & ) ),
-		this, TQT_SLOT( slotChannelSelected( const TQString & ) ) );
+	connect( mSearch, TQ_SIGNAL( channelSelected( const TQString & ) ),
+		this, TQ_SLOT( slotChannelSelected( const TQString & ) ) );
 
-	connect( mSearch, TQT_SIGNAL( channelDoubleClicked( const TQString & ) ),
-		this, TQT_SLOT( slotChannelDoubleClicked( const TQString & ) ) );
+	connect( mSearch, TQ_SIGNAL( channelDoubleClicked( const TQString & ) ),
+		this, TQ_SLOT( slotChannelDoubleClicked( const TQString & ) ) );
 }
 
 IRCAddContactPage::~IRCAddContactPage()
diff --git a/kopete/protocols/irc/ircchannelcontact.cpp b/kopete/protocols/irc/ircchannelcontact.cpp
index c11aec03..1ac0a4b8 100644
--- a/kopete/protocols/irc/ircchannelcontact.cpp
+++ b/kopete/protocols/irc/ircchannelcontact.cpp
@@ -50,20 +50,20 @@ IRCChannelContact::IRCChannelContact(IRCContactManager *contactManager, const TQ
 	KIRC::Engine *engine = kircEngine();
 
 	mInfoTimer = new TQTimer( this );
-	TQObject::connect(mInfoTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT( slotUpdateInfo() ) );
+	TQObject::connect(mInfoTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT( slotUpdateInfo() ) );
 
-	TQObject::connect(engine, TQT_SIGNAL(incomingUserIsAway(const TQString &, const TQString &)),
-		this, TQT_SLOT(slotIncomingUserIsAway(const TQString &, const TQString &)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingUserIsAway(const TQString &, const TQString &)),
+		this, TQ_SLOT(slotIncomingUserIsAway(const TQString &, const TQString &)));
 
-	TQObject::connect(engine, TQT_SIGNAL(incomingListedChan(const TQString &, uint, const TQString &)),
-		this, TQT_SLOT(slotChannelListed(const TQString &, uint, const TQString &)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingListedChan(const TQString &, uint, const TQString &)),
+		this, TQ_SLOT(slotChannelListed(const TQString &, uint, const TQString &)));
 
 	actionJoin = 0L;
-	actionModeT = new TDEToggleAction(i18n("Only Operators Can Change &Topic"), 0, this, TQT_SLOT(slotModeChanged()), this );
-	actionModeN = new TDEToggleAction(i18n("&No Outside Messages"), 0, this, TQT_SLOT(slotModeChanged()), this );
-	actionModeS = new TDEToggleAction(i18n("&Secret"), 0, this, TQT_SLOT(slotModeChanged()), this );
-	actionModeM = new TDEToggleAction(i18n("&Moderated"), 0, this, TQT_SLOT(slotModeChanged()), this );
-	actionModeI = new TDEToggleAction(i18n("&Invite Only"), 0, this, TQT_SLOT(slotModeChanged()), this );
+	actionModeT = new TDEToggleAction(i18n("Only Operators Can Change &Topic"), 0, this, TQ_SLOT(slotModeChanged()), this );
+	actionModeN = new TDEToggleAction(i18n("&No Outside Messages"), 0, this, TQ_SLOT(slotModeChanged()), this );
+	actionModeS = new TDEToggleAction(i18n("&Secret"), 0, this, TQ_SLOT(slotModeChanged()), this );
+	actionModeM = new TDEToggleAction(i18n("&Moderated"), 0, this, TQ_SLOT(slotModeChanged()), this );
+	actionModeI = new TDEToggleAction(i18n("&Invite Only"), 0, this, TQ_SLOT(slotModeChanged()), this );
 	actionHomePage = 0L;
 
 	updateStatus();
@@ -261,7 +261,7 @@ void IRCChannelContact::slotAddNicknames()
 		mJoinedNicks.pop_front();
 	}
 
-	TQTimer::singleShot( 0, this, TQT_SLOT( slotAddNicknames() ) );
+	TQTimer::singleShot( 0, this, TQ_SLOT( slotAddNicknames() ) );
 }
 
 void IRCChannelContact::channelTopic(const TQString &topic)
@@ -303,9 +303,9 @@ void IRCChannelContact::join()
 
 	if (manager()) {
 		connect(manager(),
-			TQT_SIGNAL(onlineStatusChanged(Kopete::Contact *, const Kopete::OnlineStatus &,
+			TQ_SIGNAL(onlineStatusChanged(Kopete::Contact *, const Kopete::OnlineStatus &,
 					const Kopete::OnlineStatus &)),
-			TQT_SLOT(slotOnlineStatusChanged(Kopete::Contact *, const Kopete::OnlineStatus &,
+			TQ_SLOT(slotOnlineStatusChanged(Kopete::Contact *, const Kopete::OnlineStatus &,
 					const Kopete::OnlineStatus &)));
 	}
 }
@@ -658,15 +658,15 @@ TQPtrList<TDEAction> *IRCChannelContact::customContextMenuActions()
 	TQPtrList<TDEAction> *mCustomActions = new TQPtrList<TDEAction>();
 	if( !actionJoin )
 	{
-		actionJoin = new TDEAction(i18n("&Join"), 0, this, TQT_SLOT(join()), this, "actionJoin");
-		actionPart = new TDEAction(i18n("&Part"), 0, this, TQT_SLOT(partAction()), this, "actionPart");
-		actionTopic = new TDEAction(i18n("Change &Topic..."), 0, this, TQT_SLOT(setTopic()), this, "actionTopic");
+		actionJoin = new TDEAction(i18n("&Join"), 0, this, TQ_SLOT(join()), this, "actionJoin");
+		actionPart = new TDEAction(i18n("&Part"), 0, this, TQ_SLOT(partAction()), this, "actionPart");
+		actionTopic = new TDEAction(i18n("Change &Topic..."), 0, this, TQ_SLOT(setTopic()), this, "actionTopic");
 		actionModeMenu = new TDEActionMenu(i18n("Channel Modes"), 0, this, "actionModeMenu");
 
 		if( !property(m_protocol->propHomepage).value().isNull() )
 		{
 			actionHomePage = new TDEAction( i18n("Visit &Homepage"), 0, this,
-				TQT_SLOT(slotHomepage()), this, "actionHomepage");
+				TQ_SLOT(slotHomepage()), this, "actionHomepage");
 		}
 		else if( actionHomePage )
 		{
@@ -681,8 +681,8 @@ TQPtrList<TDEAction> *IRCChannelContact::customContextMenuActions()
 		actionModeMenu->setEnabled( true );
 
 		codecAction = new KCodecAction( i18n("&Encoding"), 0, this, "selectcharset" );
-		connect( codecAction, TQT_SIGNAL( activated( const TQTextCodec * ) ),
-			this, TQT_SLOT( setCodec( const TQTextCodec *) ) );
+		connect( codecAction, TQ_SIGNAL( activated( const TQTextCodec * ) ),
+			this, TQ_SLOT( setCodec( const TQTextCodec *) ) );
 		codecAction->setCodec( codec() );
 	}
 
diff --git a/kopete/protocols/irc/irccontact.cpp b/kopete/protocols/irc/irccontact.cpp
index 1df631f9..3532cb4c 100644
--- a/kopete/protocols/irc/irccontact.cpp
+++ b/kopete/protocols/irc/irccontact.cpp
@@ -53,22 +53,22 @@ IRCContact::IRCContact(IRCContactManager *contactManager, const TQString &nick,
 	setProperty( Kopete::Global::Properties::self()->nickName(), m_nickName );
 
 	// IRCContactManager stuff
-	TQObject::connect(contactManager, TQT_SIGNAL(privateMessage(IRCContact *, IRCContact *, const TQString &)),
-			this, TQT_SLOT(privateMessage(IRCContact *, IRCContact *, const TQString &)));
+	TQObject::connect(contactManager, TQ_SIGNAL(privateMessage(IRCContact *, IRCContact *, const TQString &)),
+			this, TQ_SLOT(privateMessage(IRCContact *, IRCContact *, const TQString &)));
 
 	// Kopete::ChatSessionManager stuff
 	mMyself.append( static_cast<Kopete::Contact*>( this ) );
 
 	// KIRC stuff
-	TQObject::connect(engine, TQT_SIGNAL(incomingNickChange(const TQString &, const TQString &)),
-			this, TQT_SLOT( slotNewNickChange(const TQString&, const TQString&)));
-	TQObject::connect(engine, TQT_SIGNAL(successfullyChangedNick(const TQString &, const TQString &)),
-			this, TQT_SLOT(slotNewNickChange(const TQString &, const TQString &)));
-	TQObject::connect(engine, TQT_SIGNAL(incomingQuitIRC(const TQString &, const TQString &)),
-			this, TQT_SLOT( slotUserDisconnected(const TQString&, const TQString&)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingNickChange(const TQString &, const TQString &)),
+			this, TQ_SLOT( slotNewNickChange(const TQString&, const TQString&)));
+	TQObject::connect(engine, TQ_SIGNAL(successfullyChangedNick(const TQString &, const TQString &)),
+			this, TQ_SLOT(slotNewNickChange(const TQString &, const TQString &)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingQuitIRC(const TQString &, const TQString &)),
+			this, TQ_SLOT( slotUserDisconnected(const TQString&, const TQString&)));
 
-	TQObject::connect(engine, TQT_SIGNAL(statusChanged(KIRC::Engine::Status)),
-			this, TQT_SLOT(updateStatus()));
+	TQObject::connect(engine, TQ_SIGNAL(statusChanged(KIRC::Engine::Status)),
+			this, TQ_SLOT(updateStatus()));
 
 	engine->setCodec( m_nickName, codec() );
 }
@@ -159,10 +159,10 @@ Kopete::ChatSession *IRCContact::manager(Kopete::Contact::CanCreateFlags canCrea
 		m_chatSession = Kopete::ChatSessionManager::self()->create(account->myself(), mMyself, account->protocol());
 		m_chatSession->setDisplayName(caption());
 
-		TQObject::connect(m_chatSession, TQT_SIGNAL(messageSent(Kopete::Message&, Kopete::ChatSession *)),
-			this, TQT_SLOT(slotSendMsg(Kopete::Message&, Kopete::ChatSession *)));
-		TQObject::connect(m_chatSession, TQT_SIGNAL(closing(Kopete::ChatSession *)),
-			this, TQT_SLOT(chatSessionDestroyed()));
+		TQObject::connect(m_chatSession, TQ_SIGNAL(messageSent(Kopete::Message&, Kopete::ChatSession *)),
+			this, TQ_SLOT(slotSendMsg(Kopete::Message&, Kopete::ChatSession *)));
+		TQObject::connect(m_chatSession, TQ_SIGNAL(closing(Kopete::ChatSession *)),
+			this, TQ_SLOT(chatSessionDestroyed()));
 
 		initConversation();
 	}
diff --git a/kopete/protocols/irc/irccontactmanager.cpp b/kopete/protocols/irc/irccontactmanager.cpp
index 10ae8a69..7f6c5625 100644
--- a/kopete/protocols/irc/irccontactmanager.cpp
+++ b/kopete/protocols/irc/irccontactmanager.cpp
@@ -48,23 +48,23 @@ IRCContactManager::IRCContactManager(const TQString &nickName, IRCAccount *accou
 //	m->setTemporary( true );
 	m_myServer = new IRCServerContact(this, account->networkName(), m);
 
-	TQObject::connect(account->engine(), TQT_SIGNAL(incomingMessage(const TQString &, const TQString &, const TQString &)),
-			this, TQT_SLOT(slotNewMessage(const TQString &, const TQString &, const TQString &)));
+	TQObject::connect(account->engine(), TQ_SIGNAL(incomingMessage(const TQString &, const TQString &, const TQString &)),
+			this, TQ_SLOT(slotNewMessage(const TQString &, const TQString &, const TQString &)));
 
-	TQObject::connect(account->engine(), TQT_SIGNAL(incomingPrivMessage(const TQString &, const TQString &, const TQString &)),
-			this, TQT_SLOT(slotNewPrivMessage(const TQString &, const TQString &, const TQString &)));
+	TQObject::connect(account->engine(), TQ_SIGNAL(incomingPrivMessage(const TQString &, const TQString &, const TQString &)),
+			this, TQ_SLOT(slotNewPrivMessage(const TQString &, const TQString &, const TQString &)));
 
-	TQObject::connect(account->engine(), TQT_SIGNAL(incomingNickChange(const TQString &, const TQString &)),
-			this, TQT_SLOT( slotNewNickChange(const TQString&, const TQString&)));
+	TQObject::connect(account->engine(), TQ_SIGNAL(incomingNickChange(const TQString &, const TQString &)),
+			this, TQ_SLOT( slotNewNickChange(const TQString&, const TQString&)));
 
-	TQObject::connect(account->engine(), TQT_SIGNAL(successfullyChangedNick(const TQString &, const TQString &)),
-			this, TQT_SLOT( slotNewNickChange(const TQString &, const TQString &)));
+	TQObject::connect(account->engine(), TQ_SIGNAL(successfullyChangedNick(const TQString &, const TQString &)),
+			this, TQ_SLOT( slotNewNickChange(const TQString &, const TQString &)));
 
-	TQObject::connect(account->engine(), TQT_SIGNAL(incomingUserOnline(const TQString &)),
-			this, TQT_SLOT( slotIsonRecieved()));
+	TQObject::connect(account->engine(), TQ_SIGNAL(incomingUserOnline(const TQString &)),
+			this, TQ_SLOT( slotIsonRecieved()));
 
-	TQObject::connect(Kopete::ContactList::self(), TQT_SIGNAL(metaContactAdded( Kopete::MetaContact * )),
-			this, TQT_SLOT( slotContactAdded( Kopete::MetaContact* )));
+	TQObject::connect(Kopete::ContactList::self(), TQ_SIGNAL(metaContactAdded( Kopete::MetaContact * )),
+			this, TQ_SLOT( slotContactAdded( Kopete::MetaContact* )));
 
 	socketTimeout = 15000;
 	TQString timeoutPath = locate( "config", "tdeioslaverc" );
@@ -75,8 +75,8 @@ IRCContactManager::IRCContactManager(const TQString &nickName, IRCAccount *accou
 	}
 
 	m_NotifyTimer = new TQTimer(this);
-	TQObject::connect(m_NotifyTimer, TQT_SIGNAL(timeout()),
-			this, TQT_SLOT(checkOnlineNotifyList()));
+	TQObject::connect(m_NotifyTimer, TQ_SIGNAL(timeout()),
+			this, TQ_SLOT(checkOnlineNotifyList()));
 	m_NotifyTimer->start(30000); // check online every 30sec
 
 	new IRCSignalHandler(this);
@@ -155,8 +155,8 @@ IRCChannelContact *IRCContactManager::findChannel(const TQString &name, Kopete::
 
 		channel = new IRCChannelContact(this, name, m);
 		m_channels.insert( name, channel );
-		TQObject::connect(channel, TQT_SIGNAL(contactDestroyed(Kopete::Contact *)),
-			this, TQT_SLOT(unregister(Kopete::Contact *)));
+		TQObject::connect(channel, TQ_SIGNAL(contactDestroyed(Kopete::Contact *)),
+			this, TQ_SLOT(unregister(Kopete::Contact *)));
 	}
 
 	return channel;
@@ -193,8 +193,8 @@ IRCUserContact *IRCContactManager::findUser(const TQString &name, Kopete::MetaCo
 
 		user = new IRCUserContact(this, name, m);
 		m_users.insert( name, user );
-		TQObject::connect(user, TQT_SIGNAL(contactDestroyed(Kopete::Contact *)),
-				this, TQT_SLOT(unregister(Kopete::Contact *)));
+		TQObject::connect(user, TQ_SIGNAL(contactDestroyed(Kopete::Contact *)),
+				this, TQ_SLOT(unregister(Kopete::Contact *)));
 	}
 
 	return user;
@@ -279,7 +279,7 @@ void IRCContactManager::checkOnlineNotifyList()
 	{
 		isonRecieved = false;
 		m_account->engine()->ison( m_NotifyList );
-		//TQTimer::singleShot( socketTimeout, this, TQT_SLOT( slotIsonTimeout() ) );
+		//TQTimer::singleShot( socketTimeout, this, TQ_SLOT( slotIsonTimeout() ) );
 	}
 }
 
diff --git a/kopete/protocols/irc/ircprotocol.cpp b/kopete/protocols/irc/ircprotocol.cpp
index 6229a294..a74ae8d4 100644
--- a/kopete/protocols/irc/ircprotocol.cpp
+++ b/kopete/protocols/irc/ircprotocol.cpp
@@ -169,77 +169,77 @@ IRCProtocol::IRCProtocol( TQObject *parent, const char *name, const TQStringList
 	addAddressBookField("messaging/irc", Kopete::Plugin::MakeIndexField);
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("raw"),
-		TQT_SLOT( slotRawCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotRawCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /raw <text> - Sends the text in raw form to the server."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("quote"),
-		TQT_SLOT( slotQuoteCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotQuoteCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /quote <text> - Sends the text in quoted form to the server."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("ctcp"),
-		TQT_SLOT( slotCtcpCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotCtcpCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /ctcp <nick> <message> - Send the CTCP message to nick<action>."), 2 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("ping"),
-		TQT_SLOT( slotPingCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotPingCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /ping <nickname> - Alias for /CTCP <nickname> PING."), 1, 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("motd"),
-		TQT_SLOT( slotMotdCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotMotdCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /motd [<server>] - Shows the message of the day for the current or the given server.") );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("list"),
-		TQT_SLOT( slotListCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotListCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /list - List the public channels on the server.") );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("join"),
-		TQT_SLOT( slotJoinCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotJoinCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /join <#channel 1> [<password>] - Joins the specified channel."), 1, 2 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("topic"),
-		TQT_SLOT( slotTopicCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotTopicCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /topic [<topic>] - Sets and/or displays the topic for the active channel.") );
 
 	//FIXME: Update help text
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("whois"),
-		TQT_SLOT( slotWhoisCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotWhoisCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /whois <nickname> - Display whois info on this user."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("whowas"),
-		TQT_SLOT( slotWhoWasCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotWhoWasCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /whowas <nickname> - Display whowas info on this user."), 1, 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("who"),
-		TQT_SLOT( slotWhoCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotWhoCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /who <nickname|channel> - Display who info on this user/channel."), 1, 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("query"),
-		TQT_SLOT( slotQueryCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotQueryCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /query <nickname> [<message>] - Open a private chat with this user."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("mode"),
-		TQT_SLOT( slotModeCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotModeCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /mode <channel> <modes> - Set modes on the given channel."), 2 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("nick"),
-		TQT_SLOT( slotNickCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotNickCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /nick <nickname> - Change your nickname to the given one."), 1, 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("me"),
-		TQT_SLOT( slotMeCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotMeCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /me <action> - Do something."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("ame"),
-		TQT_SLOT( slotAllMeCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotAllMeCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /ame <action> - Do something in every open chat."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("kick"),
-		TQT_SLOT( slotKickCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotKickCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /kick <nickname> [<reason>] - Kick someone from the channel (requires operator status).")
 		, 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("ban"),
-		TQT_SLOT( slotBanCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotBanCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /ban <mask> - Add someone to this channel's ban list. (requires operator status)."),
 		1, 1 );
 
@@ -248,33 +248,33 @@ IRCProtocol::IRCProtocol( TQObject *parent, const char *name, const TQStringList
 		i18n("USAGE: /bannick <nickname> - Add someone to this channel's ban list. Uses the hostmask nickname!*@* (requires operator status)."), Kopete::CommandHandler::SystemAlias, 1, 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("op"),
-		TQT_SLOT( slotOpCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotOpCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /op <nickname 1> [<nickname 2> <...>] - Give channel operator status to someone (requires operator status)."),
 		1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("deop"),
-		TQT_SLOT( slotDeopCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotDeopCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /deop <nickname> [<nickname 2> <...>]- Remove channel operator status from someone (requires operator status)."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("voice"),
-		TQT_SLOT( slotVoiceCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotVoiceCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /voice <nickname> [<nickname 2> <...>]- Give channel voice status to someone (requires operator status)."),
 		1);
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("devoice"),
-		TQT_SLOT( slotDevoiceCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotDevoiceCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /devoice <nickname> [<nickname 2> <...>]- Remove channel voice status from someone (requires operator status)."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("quit"),
-		TQT_SLOT( slotQuitCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotQuitCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /quit [<reason>] - Disconnect from IRC, optionally leaving a message.") );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("part"),
-		TQT_SLOT( slotPartCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotPartCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /part [<reason>] - Part from a channel, optionally leaving a message.") );
 
 	Kopete::CommandHandler::commandHandler()->registerCommand( this, TQString::fromLatin1("invite"),
-		TQT_SLOT( slotInviteCommand( const TQString &, Kopete::ChatSession*) ),
+		TQ_SLOT( slotInviteCommand( const TQString &, Kopete::ChatSession*) ),
 		i18n("USAGE: /invite <nickname> [<channel>] - Invite a user to join a channel."), 1 );
 
 	Kopete::CommandHandler::commandHandler()->registerAlias( this, TQString::fromLatin1("j"),
@@ -286,11 +286,11 @@ IRCProtocol::IRCProtocol( TQObject *parent, const char *name, const TQStringList
 		TQString::fromLatin1("query %s"),
 		i18n("USAGE: /msg <nickname> [<message>] - Alias for QUERY <nickname> <message>."), Kopete::CommandHandler::SystemAlias, 1 );
 
-	TQObject::connect( Kopete::ChatSessionManager::self(), TQT_SIGNAL(aboutToDisplay(Kopete::Message &)),
-		this, TQT_SLOT(slotMessageFilter(Kopete::Message &)) );
+	TQObject::connect( Kopete::ChatSessionManager::self(), TQ_SIGNAL(aboutToDisplay(Kopete::Message &)),
+		this, TQ_SLOT(slotMessageFilter(Kopete::Message &)) );
 
-	TQObject::connect( Kopete::ChatSessionManager::self(), TQT_SIGNAL( viewCreated( KopeteView* ) ),
-		this, TQT_SLOT( slotViewCreated( KopeteView* ) ) );
+	TQObject::connect( Kopete::ChatSessionManager::self(), TQ_SIGNAL( viewCreated( KopeteView* ) ),
+		this, TQ_SLOT( slotViewCreated( KopeteView* ) ) );
 
 	setCapabilities( Kopete::Protocol::RichBFormatting | Kopete::Protocol::RichUFormatting | Kopete::Protocol::RichColor );
 
@@ -774,24 +774,24 @@ void IRCProtocol::editNetworks( const TQString &networkName )
 		netConf->upButton->setIconSet( SmallIconSet( "go-up" )  );
 		netConf->downButton->setIconSet( SmallIconSet( "go-down" ) );
 
-		connect( netConf->networkList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkConfig() ) );
-		connect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
-		connect( netConf, TQT_SIGNAL( accepted() ), this, TQT_SLOT( slotSaveNetworkConfig() ) );
-		connect( netConf, TQT_SIGNAL( rejected() ), this, TQT_SLOT( slotReadNetworks() ) );
-		connect( netConf->upButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotMoveServerUp() ) );
-		connect( netConf->downButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotMoveServerDown() ) );
-		connect( netConf->removeNetwork, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotDeleteNetwork() ) );
-		connect( netConf->removeHost, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotDeleteHost() ) );
-		connect( netConf->newHost, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotNewHost() ) );
-		connect( netConf->newNetwork, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotNewNetwork() ) );
-		connect( netConf->renameNetwork, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotRenameNetwork() ) );
-		connect( netConf->port, TQT_SIGNAL( valueChanged( int ) ), this, TQT_SLOT( slotHostPortChanged( int ) ) );
-		connect( netConf->networkList, TQT_SIGNAL( doubleClicked ( TQListBoxItem * )), TQT_SLOT(slotRenameNetwork()));
+		connect( netConf->networkList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkConfig() ) );
+		connect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
+		connect( netConf, TQ_SIGNAL( accepted() ), this, TQ_SLOT( slotSaveNetworkConfig() ) );
+		connect( netConf, TQ_SIGNAL( rejected() ), this, TQ_SLOT( slotReadNetworks() ) );
+		connect( netConf->upButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotMoveServerUp() ) );
+		connect( netConf->downButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotMoveServerDown() ) );
+		connect( netConf->removeNetwork, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotDeleteNetwork() ) );
+		connect( netConf->removeHost, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotDeleteHost() ) );
+		connect( netConf->newHost, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotNewHost() ) );
+		connect( netConf->newNetwork, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotNewNetwork() ) );
+		connect( netConf->renameNetwork, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotRenameNetwork() ) );
+		connect( netConf->port, TQ_SIGNAL( valueChanged( int ) ), this, TQ_SLOT( slotHostPortChanged( int ) ) );
+		connect( netConf->networkList, TQ_SIGNAL( doubleClicked ( TQListBoxItem * )), TQ_SLOT(slotRenameNetwork()));
 				
 	}
 
-	disconnect( netConf->networkList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkConfig() ) );
-	disconnect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+	disconnect( netConf->networkList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkConfig() ) );
+	disconnect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 
 	netConf->networkList->clear();
 
@@ -803,8 +803,8 @@ void IRCProtocol::editNetworks( const TQString &networkName )
 
 	netConf->networkList->sort();
 
-	connect( netConf->networkList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkConfig() ) );
-	connect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+	connect( netConf->networkList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkConfig() ) );
+	connect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 
 	if( !networkName.isEmpty() )
 		netConf->networkList->setSelected( netConf->networkList->findItem( networkName ), true );
@@ -830,10 +830,10 @@ void IRCProtocol::slotUpdateNetworkConfig()
 			netConf->hostList->insertItem( (*it)->host + TQString::fromLatin1(":") + TQString::number((*it)->port) );
 
 		// prevent nested event loop crash
-		disconnect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+		disconnect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 		netConf->hostList->setSelected( 0, true );
 		slotUpdateNetworkHostConfig();
-		connect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+		connect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 	}
 
 	// record the current selection
@@ -873,9 +873,9 @@ void IRCProtocol::slotHostPortChanged( int value )
 {
 	TQString entryText = m_uiCurrentHostSelection + TQString::fromLatin1(":") + TQString::number( value );
 	// changeItem causes a take() and insert, and we don't want a selectionChanged() signal that sets all this off again.
-	disconnect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+	disconnect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 	netConf->hostList->changeItem( entryText, netConf->hostList->currentItem() );
-	connect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+	connect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 }
 
 void IRCProtocol::slotUpdateNetworkHostConfig()
@@ -891,9 +891,9 @@ void IRCProtocol::slotUpdateNetworkHostConfig()
 		{
 			netConf->host->setText( host->host );
 			netConf->password->setText( host->password );
-			disconnect( netConf->port, TQT_SIGNAL( valueChanged( int ) ), this, TQT_SLOT( slotHostPortChanged( int ) ) );
+			disconnect( netConf->port, TQ_SIGNAL( valueChanged( int ) ), this, TQ_SLOT( slotHostPortChanged( int ) ) );
 			netConf->port->setValue( host->port );
-			connect( netConf->port, TQT_SIGNAL( valueChanged( int ) ), this, TQT_SLOT( slotHostPortChanged( int ) ) );
+			connect( netConf->port, TQ_SIGNAL( valueChanged( int ) ), this, TQ_SLOT( slotHostPortChanged( int ) ) );
 			netConf->useSSL->setChecked( host->ssl );
 
 			netConf->upButton->setEnabled( netConf->hostList->currentItem() > 0 );
@@ -903,12 +903,12 @@ void IRCProtocol::slotUpdateNetworkHostConfig()
 	else
 	{
 		m_uiCurrentHostSelection = TQString();
-		disconnect( netConf->port, TQT_SIGNAL( valueChanged( int ) ), this, TQT_SLOT( slotHostPortChanged( int ) ) );
+		disconnect( netConf->port, TQ_SIGNAL( valueChanged( int ) ), this, TQ_SLOT( slotHostPortChanged( int ) ) );
 		netConf->host->clear();
 		netConf->password->clear();
 		netConf->port->setValue( 6667 );
 		netConf->useSSL->setChecked( false );
-		connect( netConf->port, TQT_SIGNAL( valueChanged( int ) ), this, TQT_SLOT( slotHostPortChanged( int ) ) );
+		connect( netConf->port, TQ_SIGNAL( valueChanged( int ) ), this, TQ_SLOT( slotHostPortChanged( int ) ) );
 	}
 }
 
@@ -921,8 +921,8 @@ void IRCProtocol::slotDeleteNetwork()
 		.arg(network), i18n("Deleting Network"),
 		KGuiItem(i18n("&Delete Network"),"edit-delete"), TQString::fromLatin1("AskIRCDeleteNetwork") ) == KMessageBox::Continue )
 	{
-		disconnect( netConf->networkList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkConfig() ) );
-		disconnect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+		disconnect( netConf->networkList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkConfig() ) );
+		disconnect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 		IRCNetwork *net = m_networks[ network ];
 		for( TQValueList<IRCHost*>::iterator it = net->hosts.begin(); it != net->hosts.end(); ++it )
 		{
@@ -932,8 +932,8 @@ void IRCProtocol::slotDeleteNetwork()
 		m_networks.remove( network );
 		delete net;
 		netConf->networkList->removeItem( netConf->networkList->currentItem() );
- 		connect( netConf->networkList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkConfig() ) );
-		connect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+ 		connect( netConf->networkList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkConfig() ) );
+		connect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 		slotUpdateNetworkHostConfig();
 
 	}
@@ -950,11 +950,11 @@ void IRCProtocol::slotDeleteHost()
 		IRCHost *host = m_hosts[ hostName ];
 		if ( host )
 		{
-			disconnect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+			disconnect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 			TQString entryText = host->host + TQString::fromLatin1(":") + TQString::number(host->port);
 			TQListBoxItem * justAdded = netConf->hostList->findItem( entryText );
 			netConf->hostList->removeItem( netConf->hostList->index( justAdded ) );
-			connect( netConf->hostList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotUpdateNetworkHostConfig() ) );
+			connect( netConf->hostList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotUpdateNetworkHostConfig() ) );
 
 			// remove from network as well
 			IRCNetwork *net = m_networks[ m_uiCurrentNetworkSelection ];
diff --git a/kopete/protocols/irc/ircservercontact.cpp b/kopete/protocols/irc/ircservercontact.cpp
index 7c7a9d50..0f9189f0 100644
--- a/kopete/protocols/irc/ircservercontact.cpp
+++ b/kopete/protocols/irc/ircservercontact.cpp
@@ -35,33 +35,33 @@ IRCServerContact::IRCServerContact(IRCContactManager *contactManager, const TQSt
 {
 	KIRC::Engine *engine = kircEngine();
 
-	TQObject::connect(engine, TQT_SIGNAL(internalError(KIRC::Engine::Error, KIRC::Message &)),
-			this, TQT_SLOT(engineInternalError(KIRC::Engine::Error, KIRC::Message &)));
+	TQObject::connect(engine, TQ_SIGNAL(internalError(KIRC::Engine::Error, KIRC::Message &)),
+			this, TQ_SLOT(engineInternalError(KIRC::Engine::Error, KIRC::Message &)));
 /*
 	//FIXME: Have some kind of a debug option for raw input/ouput display??
-	TQObject::connect(engine, TQT_SIGNAL(sentMessage(KIRC::Message &)),
-			this, TQT_SLOT(engineSentMessage(KIRC::Message &)));
-	TQObject::connect(engine, TQT_SIGNAL(receivedMessage(KIRC::Message &)),
-			this, TQT_SLOT(engineReceivedMessage(KIRC::Message &)));
+	TQObject::connect(engine, TQ_SIGNAL(sentMessage(KIRC::Message &)),
+			this, TQ_SLOT(engineSentMessage(KIRC::Message &)));
+	TQObject::connect(engine, TQ_SIGNAL(receivedMessage(KIRC::Message &)),
+			this, TQ_SLOT(engineReceivedMessage(KIRC::Message &)));
 */
 
-	TQObject::connect(engine, TQT_SIGNAL(incomingNotice(const TQString &, const TQString &)),
-			this, TQT_SLOT(slotIncomingNotice(const TQString &, const TQString &)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingNotice(const TQString &, const TQString &)),
+			this, TQ_SLOT(slotIncomingNotice(const TQString &, const TQString &)));
 
-	TQObject::connect(engine, TQT_SIGNAL(incomingCannotSendToChannel(const TQString &, const TQString &)),
-			this, TQT_SLOT(slotCannotSendToChannel(const TQString &, const TQString &)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingCannotSendToChannel(const TQString &, const TQString &)),
+			this, TQ_SLOT(slotCannotSendToChannel(const TQString &, const TQString &)));
 
-	TQObject::connect(engine, TQT_SIGNAL(incomingUnknown(const TQString &)),
-			this, TQT_SLOT(slotIncomingUnknown(const TQString &)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingUnknown(const TQString &)),
+			this, TQ_SLOT(slotIncomingUnknown(const TQString &)));
 
-	TQObject::connect(engine, TQT_SIGNAL(incomingConnectString(const TQString &)),
-			this, TQT_SLOT(slotIncomingConnect(const TQString &)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingConnectString(const TQString &)),
+			this, TQ_SLOT(slotIncomingConnect(const TQString &)));
 
-	TQObject::connect(engine, TQT_SIGNAL(incomingMotd(const TQString &)),
-			this, TQT_SLOT(slotIncomingMotd(const TQString &)));
+	TQObject::connect(engine, TQ_SIGNAL(incomingMotd(const TQString &)),
+			this, TQ_SLOT(slotIncomingMotd(const TQString &)));
 
-	TQObject::connect(Kopete::ChatSessionManager::self(), TQT_SIGNAL(viewCreated(KopeteView*)),
-			this, TQT_SLOT(slotViewCreated(KopeteView*)) );
+	TQObject::connect(Kopete::ChatSessionManager::self(), TQ_SIGNAL(viewCreated(KopeteView*)),
+			this, TQ_SLOT(slotViewCreated(KopeteView*)) );
 
 	updateStatus();
 }
@@ -206,7 +206,7 @@ void IRCServerContact::slotDumpMessages()
 	{
 		manager()->appendMessage( mMsgBuffer.front() );
 		mMsgBuffer.pop_front();
-		TQTimer::singleShot( 0, this, TQT_SLOT( slotDumpMessages() ) );
+		TQTimer::singleShot( 0, this, TQ_SLOT( slotDumpMessages() ) );
 	}
 }
 
@@ -214,7 +214,7 @@ void IRCServerContact::slotViewCreated( KopeteView *v )
 {
 	kdDebug(14121) << k_funcinfo << "Created: " << v << ", mgr: " << v->msgManager() << ", Mine: " << m_chatSession << endl;
 	if (m_chatSession && v->msgManager() == m_chatSession)
-		TQTimer::singleShot(500, this, TQT_SLOT(slotDumpMessages()));
+		TQTimer::singleShot(500, this, TQ_SLOT(slotDumpMessages()));
 }
 
 #include "ircservercontact.moc"
diff --git a/kopete/protocols/irc/ircsignalhandler.cpp b/kopete/protocols/irc/ircsignalhandler.cpp
index db0acec2..cdc73665 100644
--- a/kopete/protocols/irc/ircsignalhandler.cpp
+++ b/kopete/protocols/irc/ircsignalhandler.cpp
@@ -29,101 +29,101 @@ IRCSignalHandler::IRCSignalHandler(IRCContactManager *m)
 	KIRC::Engine *m_engine = static_cast<IRCAccount*>( manager->mySelf()->account() )->engine();
 
 	//Channel Connections to ourself
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingNamesList(const TQString &, const TQStringList &)),
-		this, TQT_SLOT(slotNamesList(const TQString &, const TQStringList &)));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingNamesList(const TQString &, const TQStringList &)),
+		this, TQ_SLOT(slotNamesList(const TQString &, const TQStringList &)));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingEndOfNames(const TQString &)),
-		this, TQT_SLOT(slotEndOfNames(const TQString &)));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingEndOfNames(const TQString &)),
+		this, TQ_SLOT(slotEndOfNames(const TQString &)));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingTopicUser(const TQString &, const TQString &, const TQDateTime &)),
-		this, TQT_SLOT(slotTopicUser(const TQString&,const TQString&,const TQDateTime&)));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingTopicUser(const TQString &, const TQString &, const TQDateTime &)),
+		this, TQ_SLOT(slotTopicUser(const TQString&,const TQString&,const TQDateTime&)));
 
 	//Channel String mappings
-	map<IRCChannelContact>( m, TQT_SIGNAL(incomingFailedChankey(const TQString &)),
+	map<IRCChannelContact>( m, TQ_SIGNAL(incomingFailedChankey(const TQString &)),
 		&IRCChannelContact::failedChankey );
 
-	map<IRCChannelContact>( m, TQT_SIGNAL(incomingFailedChanFull(const TQString &)),
+	map<IRCChannelContact>( m, TQ_SIGNAL(incomingFailedChanFull(const TQString &)),
 		&IRCChannelContact::failedChanInvite );
 
-	map<IRCChannelContact>( m, TQT_SIGNAL(incomingFailedChanInvite(const TQString &)),
+	map<IRCChannelContact>( m, TQ_SIGNAL(incomingFailedChanInvite(const TQString &)),
 		&IRCChannelContact::failedChanInvite );
 
-	map<IRCChannelContact>( m, TQT_SIGNAL(incomingFailedChanBanned(const TQString &)),
+	map<IRCChannelContact>( m, TQ_SIGNAL(incomingFailedChanBanned(const TQString &)),
 		&IRCChannelContact::failedChanBanned );
 
-	mapSingle<IRCChannelContact>( m, TQT_SIGNAL(incomingJoinedChannel(const TQString &, const TQString &)),
+	mapSingle<IRCChannelContact>( m, TQ_SIGNAL(incomingJoinedChannel(const TQString &, const TQString &)),
 		&IRCChannelContact::userJoinedChannel );
 
-	mapSingle<IRCChannelContact>( m, TQT_SIGNAL(incomingExistingTopic(const TQString &, const TQString &)),
+	mapSingle<IRCChannelContact>( m, TQ_SIGNAL(incomingExistingTopic(const TQString &, const TQString &)),
 		&IRCChannelContact::channelTopic );
 
-	mapSingle<IRCChannelContact>( m, TQT_SIGNAL(incomingChannelHomePage(const TQString &, const TQString &)),
+	mapSingle<IRCChannelContact>( m, TQ_SIGNAL(incomingChannelHomePage(const TQString &, const TQString &)),
 		&IRCChannelContact::channelHomePage );
 
 	mapDouble<IRCChannelContact>( m,
-		TQT_SIGNAL(incomingPartedChannel(const TQString &, const TQString &,const TQString &)),
+		TQ_SIGNAL(incomingPartedChannel(const TQString &, const TQString &,const TQString &)),
 		&IRCChannelContact::userPartedChannel );
 
 	mapDouble<IRCChannelContact>( m,
-		TQT_SIGNAL(incomingTopicChange(const TQString &, const TQString &,const TQString &)),
+		TQ_SIGNAL(incomingTopicChange(const TQString &, const TQString &,const TQString &)),
 		&IRCChannelContact::topicChanged );
 
 	mapDouble<IRCChannelContact>( m,
-		TQT_SIGNAL(incomingChannelModeChange(const TQString &, const TQString &,const TQString &)),
+		TQ_SIGNAL(incomingChannelModeChange(const TQString &, const TQString &,const TQString &)),
 		&IRCChannelContact::incomingModeChange );
 
 	mapDouble<IRCChannelContact>( m,
-		TQT_SIGNAL(incomingChannelMode(const TQString &, const TQString &,const TQString &)),
+		TQ_SIGNAL(incomingChannelMode(const TQString &, const TQString &,const TQString &)),
 		&IRCChannelContact::incomingChannelMode );
 
 	mapTriple<IRCChannelContact>( m,
-		TQT_SIGNAL(incomingKick(const TQString &, const TQString &,const TQString &,const TQString &)),
+		TQ_SIGNAL(incomingKick(const TQString &, const TQString &,const TQString &,const TQString &)),
 		&IRCChannelContact::userKicked );
 
 	//User connections to ourself
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingWhoIsIdle(const TQString &, unsigned long )),
-			this, TQT_SLOT(slotNewWhoIsIdle(const TQString &, unsigned long )));
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingWhoIsIdle(const TQString &, unsigned long )),
+			this, TQ_SLOT(slotNewWhoIsIdle(const TQString &, unsigned long )));
 
-	TQObject::connect(m_engine, TQT_SIGNAL(incomingWhoReply(const TQString &, const TQString &, const TQString &,
+	TQObject::connect(m_engine, TQ_SIGNAL(incomingWhoReply(const TQString &, const TQString &, const TQString &,
 		const TQString &, const TQString &, bool, const TQString &, uint, const TQString & )),
-		this, TQT_SLOT( slotNewWhoReply(const TQString &, const TQString &, const TQString &, const TQString &,
+		this, TQ_SLOT( slotNewWhoReply(const TQString &, const TQString &, const TQString &, const TQString &,
 		const TQString &, bool, const TQString &, uint, const TQString &)));
 
 	//User signal mappings
-	map<IRCUserContact>( m, TQT_SIGNAL(incomingUserOnline( const TQString & )), &IRCUserContact::userOnline );
+	map<IRCUserContact>( m, TQ_SIGNAL(incomingUserOnline( const TQString & )), &IRCUserContact::userOnline );
 
-	map<IRCUserContact>( m, TQT_SIGNAL(incomingWhoIsOperator( const TQString & )), &IRCUserContact::newWhoIsOperator );
+	map<IRCUserContact>( m, TQ_SIGNAL(incomingWhoIsOperator( const TQString & )), &IRCUserContact::newWhoIsOperator );
 
-	map<IRCUserContact>( m, TQT_SIGNAL(incomingWhoIsIdentified( const TQString & )), &IRCUserContact::newWhoIsIdentified );
+	map<IRCUserContact>( m, TQ_SIGNAL(incomingWhoIsIdentified( const TQString & )), &IRCUserContact::newWhoIsIdentified );
 
-	map<IRCUserContact>( m, TQT_SIGNAL(incomingEndOfWhois( const TQString & )), &IRCUserContact::whoIsComplete );
+	map<IRCUserContact>( m, TQ_SIGNAL(incomingEndOfWhois( const TQString & )), &IRCUserContact::whoIsComplete );
 
-	map<IRCUserContact>( m, TQT_SIGNAL(incomingEndOfWhoWas( const TQString & )), &IRCUserContact::whoWasComplete );
+	map<IRCUserContact>( m, TQ_SIGNAL(incomingEndOfWhoWas( const TQString & )), &IRCUserContact::whoWasComplete );
 
-	mapSingle<IRCUserContact>( m, TQT_SIGNAL(incomingUserIsAway( const TQString &, const TQString & )),
+	mapSingle<IRCUserContact>( m, TQ_SIGNAL(incomingUserIsAway( const TQString &, const TQString & )),
 		&IRCUserContact::incomingUserIsAway );
 
-	mapSingle<IRCUserContact>( m, TQT_SIGNAL(incomingWhoIsChannels( const TQString &, const TQString & )),
+	mapSingle<IRCUserContact>( m, TQ_SIGNAL(incomingWhoIsChannels( const TQString &, const TQString & )),
 		&IRCUserContact::newWhoIsChannels );
 
 	mapDouble<IRCUserContact>( m,
-		TQT_SIGNAL(incomingWhoIsServer(const TQString &, const TQString &, const TQString &)),
+		TQ_SIGNAL(incomingWhoIsServer(const TQString &, const TQString &, const TQString &)),
 		&IRCUserContact::newWhoIsServer );
 
 	mapDouble<IRCUserContact>( m,
-		TQT_SIGNAL(incomingPrivAction(const TQString &, const TQString &, const TQString &)),
+		TQ_SIGNAL(incomingPrivAction(const TQString &, const TQString &, const TQString &)),
 		&IRCUserContact::newAction );
 
 	mapDouble<IRCChannelContact>( m,
-		TQT_SIGNAL(incomingAction(const TQString &, const TQString &, const TQString &)),
+		TQ_SIGNAL(incomingAction(const TQString &, const TQString &, const TQString &)),
 		&IRCChannelContact::newAction );
 
 	mapTriple<IRCUserContact>( m,
-		TQT_SIGNAL(incomingWhoIsUser(const TQString &, const TQString &, const TQString &, const TQString &)),
+		TQ_SIGNAL(incomingWhoIsUser(const TQString &, const TQString &, const TQString &, const TQString &)),
 		&IRCUserContact::newWhoIsUser );
 
 	mapTriple<IRCUserContact>( m,
-		TQT_SIGNAL(incomingWhoWasUser(const TQString &, const TQString &, const TQString &, const TQString &)),
+		TQ_SIGNAL(incomingWhoWasUser(const TQString &, const TQString &, const TQString &, const TQString &)),
 		&IRCUserContact::newWhoIsUser );
 }
 
diff --git a/kopete/protocols/irc/ircsignalhandler.h b/kopete/protocols/irc/ircsignalhandler.h
index 50331f70..f975c2b7 100644
--- a/kopete/protocols/irc/ircsignalhandler.h
+++ b/kopete/protocols/irc/ircsignalhandler.h
@@ -294,7 +294,7 @@ class IRCSignalHandler : public TQObject
 			mappings.append(mapping);
 			TQObject::connect( static_cast<IRCAccount*>( m->mySelf()->account() )->engine(), signal,
 				new QMember( mapping, this),
-				TQT_SLOT( slotEmit( const TQString &) )
+				TQ_SLOT( slotEmit( const TQString &) )
 			);
 		}
 
@@ -306,7 +306,7 @@ class IRCSignalHandler : public TQObject
 			mappings.append(mapping);
 			TQObject::connect( static_cast<IRCAccount*>( m->mySelf()->account() )->engine(), signal,
 				new QMemberSingle( mapping, this),
-				TQT_SLOT( slotEmit( const TQString &, const TQString &) )
+				TQ_SLOT( slotEmit( const TQString &, const TQString &) )
 			);
 		}
 
@@ -318,7 +318,7 @@ class IRCSignalHandler : public TQObject
 			mappings.append(mapping);
 			TQObject::connect( static_cast<IRCAccount*>( m->mySelf()->account() )->engine(), signal,
 				new QMemberDouble( mapping, this),
-				TQT_SLOT( slotEmit( const TQString &, const TQString &,const TQString &) )
+				TQ_SLOT( slotEmit( const TQString &, const TQString &,const TQString &) )
 			);
 		}
 
@@ -331,7 +331,7 @@ class IRCSignalHandler : public TQObject
 			mappings.append(mapping);
 			TQObject::connect( static_cast<IRCAccount*>( m->mySelf()->account() )->engine(), signal,
 				new QMemberTriple( mapping, this),
-				TQT_SLOT( slotEmit( const TQString &, const TQString &,const TQString &,const TQString &) )
+				TQ_SLOT( slotEmit( const TQString &, const TQString &,const TQString &,const TQString &) )
 			);
 		}
 };
diff --git a/kopete/protocols/irc/irctransferhandler.cpp b/kopete/protocols/irc/irctransferhandler.cpp
index fd004985..6846bea1 100644
--- a/kopete/protocols/irc/irctransferhandler.cpp
+++ b/kopete/protocols/irc/irctransferhandler.cpp
@@ -41,13 +41,13 @@ KIRC::TransferHandler *IRCTransferHandler::handler()
 
 IRCTransferHandler::IRCTransferHandler()
 {
-	connect(handler(), TQT_SIGNAL(transferCreated(KIRC::Transfer *)),
-		this, TQT_SLOT(transferCreated(KIRC::Transfer *)));
+	connect(handler(), TQ_SIGNAL(transferCreated(KIRC::Transfer *)),
+		this, TQ_SLOT(transferCreated(KIRC::Transfer *)));
 
-	connect(Kopete::TransferManager::transferManager(), TQT_SIGNAL(accepted(Kopete::Transfer *, const TQString &)),
-		this, TQT_SLOT(transferAccepted(Kopete::Transfer *, const TQString&)));
-	connect( Kopete::TransferManager::transferManager(), TQT_SIGNAL(refused(const Kopete::FileTransferInfo &)),
-		this, TQT_SLOT(transferRefused(const Kopete::FileTransferInfo &)));
+	connect(Kopete::TransferManager::transferManager(), TQ_SIGNAL(accepted(Kopete::Transfer *, const TQString &)),
+		this, TQ_SLOT(transferAccepted(Kopete::Transfer *, const TQString&)));
+	connect( Kopete::TransferManager::transferManager(), TQ_SIGNAL(refused(const Kopete::FileTransferInfo &)),
+		this, TQ_SLOT(transferRefused(const Kopete::FileTransferInfo &)));
 }
 
 void IRCTransferHandler::transferCreated(KIRC::Transfer *t)
@@ -121,8 +121,8 @@ void IRCTransferHandler::connectKopeteTransfer(Kopete::Transfer *kt, KIRC::Trans
 //		case KIRC::Transfer::Chat:
 		case KIRC::Transfer::FileOutgoing:
 		case KIRC::Transfer::FileIncoming:
-			connect(t , TQT_SIGNAL(fileSizeAcknowledge(unsigned int)),
-				kt, TQT_SLOT(slotProcessed(unsigned int)));
+			connect(t , TQ_SIGNAL(fileSizeAcknowledge(unsigned int)),
+				kt, TQ_SLOT(slotProcessed(unsigned int)));
 			break;
 		default:
 			kdDebug(14120) << k_funcinfo << "Unknown transfer connections for type" << endl;
@@ -130,16 +130,16 @@ void IRCTransferHandler::connectKopeteTransfer(Kopete::Transfer *kt, KIRC::Trans
 			return;
 		}
 
-		connect(t , TQT_SIGNAL(complete()),
-			kt, TQT_SLOT(slotComplete()));
+		connect(t , TQ_SIGNAL(complete()),
+			kt, TQ_SLOT(slotComplete()));
 
-//		connect(kt , TQT_SIGNAL(transferCanceled()),
-//			t, TQT_SLOT(abort()));
-//		connect(kt,  TQT_SIGNAL(destroyed()),
-//			t, TQT_SLOT(slotKopeteTransferDestroyed()));
+//		connect(kt , TQ_SIGNAL(transferCanceled()),
+//			t, TQ_SLOT(abort()));
+//		connect(kt,  TQ_SIGNAL(destroyed()),
+//			t, TQ_SLOT(slotKopeteTransferDestroyed()));
 
-		connect(kt, TQT_SIGNAL(result(TDEIO::Job *)),
-			this , TQT_SLOT(tdeioresult(TDEIO::Job *)));
+		connect(kt, TQ_SIGNAL(result(TDEIO::Job *)),
+			this , TQ_SLOT(tdeioresult(TDEIO::Job *)));
 
 		t->initiate();
 	}
diff --git a/kopete/protocols/irc/ircusercontact.cpp b/kopete/protocols/irc/ircusercontact.cpp
index 1254b9d9..0e7f8760 100644
--- a/kopete/protocols/irc/ircusercontact.cpp
+++ b/kopete/protocols/irc/ircusercontact.cpp
@@ -41,10 +41,10 @@ IRCUserContact::IRCUserContact(IRCContactManager *contactManager, const TQString
 
 	mOnlineTimer = new TQTimer( this );
 
-	TQObject::connect(mOnlineTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT( slotUserOffline() ) );
+	TQObject::connect(mOnlineTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT( slotUserOffline() ) );
 
-	TQObject::connect(kircEngine(), TQT_SIGNAL(incomingChannelModeChange(const TQString&, const TQString&, const TQString&)),
-		this, TQT_SLOT(slotIncomingModeChange(const TQString&,const TQString&, const TQString&)));
+	TQObject::connect(kircEngine(), TQ_SIGNAL(incomingChannelModeChange(const TQString&, const TQString&, const TQString&)),
+		this, TQ_SLOT(slotIncomingModeChange(const TQString&,const TQString&, const TQString&)));
 
 	mInfo.isOperator = false;
 	mInfo.isIdentified = false;
@@ -246,7 +246,7 @@ void IRCUserContact::slotBanHost()
 	if (mInfo.hostName.isEmpty()) {
 		if (kircEngine()->isConnected()) {
 			kircEngine()->whois(m_nickName);
-			TQTimer::singleShot( 750, this, TQT_SLOT( slotBanHostOnce() ) );
+			TQTimer::singleShot( 750, this, TQ_SLOT( slotBanHostOnce() ) );
 		}
 	} else {
 		slotBanHostOnce();
@@ -270,7 +270,7 @@ void IRCUserContact::slotBanUserHost()
 	if (mInfo.hostName.isEmpty()) {
 		if (kircEngine()->isConnected()) {
 			kircEngine()->whois(m_nickName);
-			TQTimer::singleShot( 750, this, TQT_SLOT( slotBanUserHostOnce() ) );
+			TQTimer::singleShot( 750, this, TQ_SLOT( slotBanUserHostOnce() ) );
 		}
 	} else {
 		slotBanUserHostOnce();
@@ -294,7 +294,7 @@ void IRCUserContact::slotBanDomain()
 	if (mInfo.hostName.isEmpty()) {
 		if (kircEngine()->isConnected()) {
 			kircEngine()->whois(m_nickName);
-			TQTimer::singleShot( 750, this, TQT_SLOT( slotBanDomainOnce() ) );
+			TQTimer::singleShot( 750, this, TQ_SLOT( slotBanDomainOnce() ) );
 		}
 	} else {
 		slotBanDomainOnce();
@@ -320,7 +320,7 @@ void IRCUserContact::slotBanUserDomain()
 	if (mInfo.hostName.isEmpty()) {
 		if (kircEngine()->isConnected()) {
 			kircEngine()->whois(m_nickName);
-			TQTimer::singleShot( 750, this, TQT_SLOT( slotBanUserDomainOnce() ) );
+			TQTimer::singleShot( 750, this, TQ_SLOT( slotBanUserDomainOnce() ) );
 		}
 	} else {
 		slotBanUserDomainOnce();
@@ -537,38 +537,38 @@ TQPtrList<TDEAction> *IRCUserContact::customContextMenuActions( Kopete::ChatSess
 		{
 			actionCtcpMenu = new TDEActionMenu(i18n("C&TCP"), 0, this );
 			actionCtcpMenu->insert( new TDEAction(i18n("&Version"), 0, this,
-				TQT_SLOT(slotCtcpVersion()), actionCtcpMenu) );
+				TQ_SLOT(slotCtcpVersion()), actionCtcpMenu) );
 			actionCtcpMenu->insert(  new TDEAction(i18n("&Ping"), 0, this,
-				TQT_SLOT(slotCtcpPing()), actionCtcpMenu) );
+				TQ_SLOT(slotCtcpPing()), actionCtcpMenu) );
 
 			actionModeMenu = new TDEActionMenu(i18n("&Modes"), 0, this, "actionModeMenu");
 			actionModeMenu->insert( new TDEAction(i18n("&Op"), 0, this,
-				TQT_SLOT(slotOp()), actionModeMenu, "actionOp") );
+				TQ_SLOT(slotOp()), actionModeMenu, "actionOp") );
 			actionModeMenu->insert( new TDEAction(i18n("&Deop"), 0, this,
-				TQT_SLOT(slotDeop()), actionModeMenu, "actionDeop") );
+				TQ_SLOT(slotDeop()), actionModeMenu, "actionDeop") );
 			actionModeMenu->insert( new TDEAction(i18n("&Voice"), 0, this,
-				TQT_SLOT(slotVoice()), actionModeMenu, "actionVoice") );
+				TQ_SLOT(slotVoice()), actionModeMenu, "actionVoice") );
 			actionModeMenu->insert( new TDEAction(i18n("Devoice"), 0, this,
-				TQT_SLOT(slotDevoice()), actionModeMenu, "actionDevoice") );
+				TQ_SLOT(slotDevoice()), actionModeMenu, "actionDevoice") );
 			actionModeMenu->setEnabled( false );
 
-			actionKick = new TDEAction(i18n("&Kick"), 0, this, TQT_SLOT(slotKick()), this);
+			actionKick = new TDEAction(i18n("&Kick"), 0, this, TQ_SLOT(slotKick()), this);
 			actionKick->setEnabled( false );
 
 			actionBanMenu = new TDEActionMenu(i18n("&Ban"), 0, this, "actionBanMenu");
 			actionBanMenu->insert( new TDEAction(i18n("Host (*!*@host.domain.net)"), 0, this,
-				TQT_SLOT(slotBanHost()), actionBanMenu ) );
+				TQ_SLOT(slotBanHost()), actionBanMenu ) );
 			actionBanMenu->insert( new TDEAction(i18n("Domain (*!*@*.domain.net)"), 0, this,
-				TQT_SLOT(slotBanDomain()), actionBanMenu ) );
+				TQ_SLOT(slotBanDomain()), actionBanMenu ) );
 			actionBanMenu->insert( new TDEAction(i18n("User@Host (*!*user@host.domain.net)"), 0, this,
-				 TQT_SLOT(slotBanUserHost()), actionBanMenu ) );
+				 TQ_SLOT(slotBanUserHost()), actionBanMenu ) );
 			actionBanMenu->insert( new TDEAction(i18n("User@Domain (*!*user@*.domain.net)"), 0, this,
-				 TQT_SLOT(slotBanUserDomain()), actionBanMenu ) );
+				 TQ_SLOT(slotBanUserDomain()), actionBanMenu ) );
 			actionBanMenu->setEnabled( false );
 
 			codecAction = new KCodecAction( i18n("&Encoding"), 0, this, "selectcharset" );
-			connect( codecAction, TQT_SIGNAL( activated( const TQTextCodec * ) ),
-				this, TQT_SLOT( setCodec( const TQTextCodec *) ) );
+			connect( codecAction, TQ_SIGNAL( activated( const TQTextCodec * ) ),
+				this, TQ_SLOT( setCodec( const TQTextCodec *) ) );
 			codecAction->setCodec( codec() );
 		}
 
diff --git a/kopete/protocols/irc/kcodecaction.cpp b/kopete/protocols/irc/kcodecaction.cpp
index 8d864078..71cffe43 100644
--- a/kopete/protocols/irc/kcodecaction.cpp
+++ b/kopete/protocols/irc/kcodecaction.cpp
@@ -23,8 +23,8 @@
 KCodecAction::KCodecAction( const TQString &text, const TDEShortcut &cut,
 		TQObject *parent, const char *name ) : TDESelectAction( text, "", cut, parent, name )
 {
-	TQObject::connect( this, TQT_SIGNAL( activated( const TQString & ) ),
-			this, TQT_SLOT( slotActivated( const TQString & ) ) );
+	TQObject::connect( this, TQ_SIGNAL( activated( const TQString & ) ),
+			this, TQ_SLOT( slotActivated( const TQString & ) ) );
 
 	setItems( KCodecAction::supportedEncodings() );
 }
diff --git a/kopete/protocols/irc/libkirc/kircengine.cpp b/kopete/protocols/irc/libkirc/kircengine.cpp
index d2f35f72..464e8883 100644
--- a/kopete/protocols/irc/libkirc/kircengine.cpp
+++ b/kopete/protocols/irc/libkirc/kircengine.cpp
@@ -110,9 +110,9 @@ void Engine::setUseSSL( bool useSSL )
 			m_sock = new KSSLSocket;
 			m_sock->setSocketFlags( KExtendedSocket::inetSocket );
 
-			connect(m_sock, TQT_SIGNAL(certificateAccepted()), TQT_SLOT(slotConnected()));
-			connect(m_sock, TQT_SIGNAL(certificateRejected()), TQT_SLOT(slotConnectionClosed()));
-			connect(m_sock, TQT_SIGNAL(sslFailure()),          TQT_SLOT(slotConnectionClosed()));
+			connect(m_sock, TQ_SIGNAL(certificateAccepted()), TQ_SLOT(slotConnected()));
+			connect(m_sock, TQ_SIGNAL(certificateRejected()), TQ_SLOT(slotConnectionClosed()));
+			connect(m_sock, TQ_SIGNAL(sslFailure()),          TQ_SLOT(slotConnectionClosed()));
 		}
 		else
 		#else
@@ -124,12 +124,12 @@ void Engine::setUseSSL( bool useSSL )
 			m_sock = new KExtendedSocket;
 			m_sock->setSocketFlags( KExtendedSocket::inputBufferedSocket | KExtendedSocket::inetSocket );
 
-			connect(m_sock, TQT_SIGNAL(connectionSuccess()),   TQT_SLOT(slotConnected()));
-			connect(m_sock, TQT_SIGNAL(connectionFailed(int)), TQT_SLOT(error(int)));
+			connect(m_sock, TQ_SIGNAL(connectionSuccess()),   TQ_SLOT(slotConnected()));
+			connect(m_sock, TQ_SIGNAL(connectionFailed(int)), TQ_SLOT(error(int)));
 		}
 
-		connect(m_sock, TQT_SIGNAL(closed(int)), TQT_SLOT(slotConnectionClosed()));
-		connect(m_sock, TQT_SIGNAL(readyRead()), TQT_SLOT(slotReadyRead()));
+		connect(m_sock, TQ_SIGNAL(closed(int)), TQ_SLOT(slotConnectionClosed()));
+		connect(m_sock, TQ_SIGNAL(readyRead()), TQ_SLOT(slotReadyRead()));
 	}
 }
 
@@ -393,7 +393,7 @@ void Engine::slotReadyRead()
 			emit internalError(ParsingFailed, msg);
 		}
 
-		TQTimer::singleShot( 0, this, TQT_SLOT( slotReadyRead() ) );
+		TQTimer::singleShot( 0, this, TQ_SLOT( slotReadyRead() ) );
 	}
 
 	if(m_sock->socketStatus() != KExtendedSocket::connected)
@@ -474,7 +474,7 @@ EntityPtr Engine::getEntity(const TQString &name)
 		m_entities.append(entity);
 	}
 
-	connect(entity, TQT_SIGNAL(destroyed(KIRC::Entity *)), TQT_SLOT(destroyed(KIRC::Entity *)));
+	connect(entity, TQ_SIGNAL(destroyed(KIRC::Entity *)), TQ_SLOT(destroyed(KIRC::Entity *)));
 	return EntityPtr(entity);
 }
 
diff --git a/kopete/protocols/irc/libkirc/kircengine_commands.cpp b/kopete/protocols/irc/libkirc/kircengine_commands.cpp
index 8aa5916e..7044bebc 100644
--- a/kopete/protocols/irc/libkirc/kircengine_commands.cpp
+++ b/kopete/protocols/irc/libkirc/kircengine_commands.cpp
@@ -27,19 +27,19 @@ using namespace KIRC;
 
 void Engine::bindCommands()
 {
-	bind("ERROR",	this, TQT_SLOT(error(KIRC::Message &)),	0, 0);
-	bind("JOIN",	this, TQT_SLOT(join(KIRC::Message &)),	0, 1);
-	bind("KICK",	this, TQT_SLOT(kick(KIRC::Message &)),	2, 2);
-	bind("NICK",	this, TQT_SLOT(nick(KIRC::Message &)),	0, 0);
-	bind("MODE",	this, TQT_SLOT(mode(KIRC::Message &)),	1, 1);
-	bind("NOTICE",	this, TQT_SLOT(notice(KIRC::Message &)),	1, 1);
-	bind("PART",	this, TQT_SLOT(part(KIRC::Message &)),	1, 1);
-	bind("PING",	this, TQT_SLOT(ping(KIRC::Message &)),	0, 0);
-	bind("PONG",	this, TQT_SLOT(pong(KIRC::Message &)),	0, 0);
-	bind("PRIVMSG",	this, TQT_SLOT(privmsg(KIRC::Message &)),	1, 1);
-	bind("QUIT",	this, TQT_SLOT(quit(KIRC::Message &)),	0, 0);
-//	bind("SQUIT",	this, TQT_SLOT(squit(KIRC::Message &)),	1, 1);
-	bind("TOPIC",	this, TQT_SLOT(topic(KIRC::Message &)),	1, 1);
+	bind("ERROR",	this, TQ_SLOT(error(KIRC::Message &)),	0, 0);
+	bind("JOIN",	this, TQ_SLOT(join(KIRC::Message &)),	0, 1);
+	bind("KICK",	this, TQ_SLOT(kick(KIRC::Message &)),	2, 2);
+	bind("NICK",	this, TQ_SLOT(nick(KIRC::Message &)),	0, 0);
+	bind("MODE",	this, TQ_SLOT(mode(KIRC::Message &)),	1, 1);
+	bind("NOTICE",	this, TQ_SLOT(notice(KIRC::Message &)),	1, 1);
+	bind("PART",	this, TQ_SLOT(part(KIRC::Message &)),	1, 1);
+	bind("PING",	this, TQ_SLOT(ping(KIRC::Message &)),	0, 0);
+	bind("PONG",	this, TQ_SLOT(pong(KIRC::Message &)),	0, 0);
+	bind("PRIVMSG",	this, TQ_SLOT(privmsg(KIRC::Message &)),	1, 1);
+	bind("QUIT",	this, TQ_SLOT(quit(KIRC::Message &)),	0, 0);
+//	bind("SQUIT",	this, TQ_SLOT(squit(KIRC::Message &)),	1, 1);
+	bind("TOPIC",	this, TQ_SLOT(topic(KIRC::Message &)),	1, 1);
 }
 
 void Engine::away(bool isAway, const TQString &awayMessage)
diff --git a/kopete/protocols/irc/libkirc/kircengine_ctcp.cpp b/kopete/protocols/irc/libkirc/kircengine_ctcp.cpp
index 0159f790..14462f1b 100644
--- a/kopete/protocols/irc/libkirc/kircengine_ctcp.cpp
+++ b/kopete/protocols/irc/libkirc/kircengine_ctcp.cpp
@@ -35,30 +35,30 @@ using namespace KIRC;
 
 void Engine::bindCtcp()
 {
-	bindCtcpQuery("ACTION",		this, TQT_SLOT(CtcpQuery_action(KIRC::Message &)),
+	bindCtcpQuery("ACTION",		this, TQ_SLOT(CtcpQuery_action(KIRC::Message &)),
 		-1,	-1);
-	bindCtcpQuery("CLIENTINFO",	this, TQT_SLOT(CtcpQuery_clientinfo(KIRC::Message &)),
+	bindCtcpQuery("CLIENTINFO",	this, TQ_SLOT(CtcpQuery_clientinfo(KIRC::Message &)),
 		-1,	1);
-	bindCtcpQuery("DCC",		this, TQT_SLOT(CtcpQuery_dcc(KIRC::Message &)),
+	bindCtcpQuery("DCC",		this, TQ_SLOT(CtcpQuery_dcc(KIRC::Message &)),
 		4,	5);
-	bindCtcpQuery("FINGER",		this, TQT_SLOT(CtcpQuery_finger(KIRC::Message &)),
+	bindCtcpQuery("FINGER",		this, TQ_SLOT(CtcpQuery_finger(KIRC::Message &)),
 		-1,	0);
-	bindCtcpQuery("PING",		this, TQT_SLOT(CtcpQuery_ping(KIRC::Message &)),
+	bindCtcpQuery("PING",		this, TQ_SLOT(CtcpQuery_ping(KIRC::Message &)),
 		1,	1);
-	bindCtcpQuery("SOURCE",		this, TQT_SLOT(CtcpQuery_source(KIRC::Message &)),
+	bindCtcpQuery("SOURCE",		this, TQ_SLOT(CtcpQuery_source(KIRC::Message &)),
 		-1,	0);
-	bindCtcpQuery("TIME",		this, TQT_SLOT(CtcpQuery_time(KIRC::Message &)),
+	bindCtcpQuery("TIME",		this, TQ_SLOT(CtcpQuery_time(KIRC::Message &)),
 		-1,	0);
-	bindCtcpQuery("USERINFO",	this, TQT_SLOT(CtcpQuery_userinfo(KIRC::Message &)),
+	bindCtcpQuery("USERINFO",	this, TQ_SLOT(CtcpQuery_userinfo(KIRC::Message &)),
 		-1,	0);
-	bindCtcpQuery("VERSION",	this, TQT_SLOT(CtcpQuery_version(KIRC::Message &)),
+	bindCtcpQuery("VERSION",	this, TQ_SLOT(CtcpQuery_version(KIRC::Message &)),
 		-1,	0);
 
-	bindCtcpReply("ERRMSG",		this, TQT_SLOT(CtcpReply_errmsg(KIRC::Message &)),
+	bindCtcpReply("ERRMSG",		this, TQ_SLOT(CtcpReply_errmsg(KIRC::Message &)),
 		1,	-1);
-	bindCtcpReply("PING",		this, TQT_SLOT(CtcpReply_ping(KIRC::Message &)),
+	bindCtcpReply("PING",		this, TQ_SLOT(CtcpReply_ping(KIRC::Message &)),
 		1,	1,	"");
-	bindCtcpReply("VERSION",	this, TQT_SLOT(CtcpReply_version(KIRC::Message &)),
+	bindCtcpReply("VERSION",	this, TQ_SLOT(CtcpReply_version(KIRC::Message &)),
 		-1,	-1,	"");
 }
 
diff --git a/kopete/protocols/irc/libkirc/kircengine_numericreplies.cpp b/kopete/protocols/irc/libkirc/kircengine_numericreplies.cpp
index 67d3a842..4118fe23 100644
--- a/kopete/protocols/irc/libkirc/kircengine_numericreplies.cpp
+++ b/kopete/protocols/irc/libkirc/kircengine_numericreplies.cpp
@@ -31,69 +31,69 @@ using namespace KIRC;
 
 void Engine::bindNumericReplies()
 {
-	bind(1, this, TQT_SLOT(numericReply_001(KIRC::Message &)), 1, 1);
-	bind(2, this, TQT_SLOT(numericReply_002(KIRC::Message &)), 1, 1);
-	bind(3, this, TQT_SLOT(numericReply_003(KIRC::Message &)), 1, 1);
-	bind(4, this, TQT_SLOT(numericReply_004(KIRC::Message &)), 5, 5);
-	bind(5, this, TQT_SLOT(numericReply_004(KIRC::Message &)), 1, 1);
-
-	bind(250, this, TQT_SLOT(numericReply_250(KIRC::Message &)));
-	bind(251, this, TQT_SLOT(numericReply_251(KIRC::Message &)));
-	bind(252, this, TQT_SLOT(numericReply_252(KIRC::Message &)), 2, 2);
-	bind(253, this, TQT_SLOT(numericReply_253(KIRC::Message &)), 2, 2);
-	bind(254, this, TQT_SLOT(numericReply_254(KIRC::Message &)), 2, 2);
-	bind(255, this, TQT_SLOT(numericReply_255(KIRC::Message &)), 1, 1); // incomingConnectString
-
-	bind(263, this, TQT_SLOT(numericReply_263(KIRC::Message &))); // incomingServerLoadTooHigh
-	bind(265, this, TQT_SLOT(numericReply_265(KIRC::Message &)));
-	bind(266, this, TQT_SLOT(numericReply_266(KIRC::Message &)));
-
-	bind(301, this, TQT_SLOT(numericReply_301(KIRC::Message &)), 2, 2);
-	bind(303, this, TQT_SLOT(numericReply_303(KIRC::Message &)), 1, 1);
-	bind(305, this, TQT_SLOT(ignoreMessage(KIRC::Message &)), 0, 0 ); // You are no longer marked as away
-	bind(306, this, TQT_SLOT(ignoreMessage(KIRC::Message &)), 0, 0 ); // You are marked as away
-	bind(307, this, TQT_SLOT(numericReply_307(KIRC::Message &)), 1, 1);
-	bind(311, this, TQT_SLOT(numericReply_311(KIRC::Message &)), 5, 5);
-	bind(312, this, TQT_SLOT(numericReply_312(KIRC::Message &)), 3, 3);
-	bind(313, this, TQT_SLOT(numericReply_313(KIRC::Message &)), 2, 2);
-	bind(314, this, TQT_SLOT(numericReply_314(KIRC::Message &)), 5, 5);
-	bind(315, this, TQT_SLOT(numericReply_315(KIRC::Message &)), 2, 2);
-	bind(317, this, TQT_SLOT(numericReply_317(KIRC::Message &)), 3, 4);
-	bind(318, this, TQT_SLOT(numericReply_318(KIRC::Message &)), 2, 2);
-	bind(319, this, TQT_SLOT(numericReply_319(KIRC::Message &)), 2, 2);
-	bind(320, this, TQT_SLOT(numericReply_320(KIRC::Message &)), 2, 2);
-	bind(321, this, TQT_SLOT(ignoreMessage(KIRC::Message &)), 0, 0 );
-	bind(322, this, TQT_SLOT(numericReply_322(KIRC::Message &)), 3, 3);
-	bind(323, this, TQT_SLOT(numericReply_323(KIRC::Message &)), 1, 1);
-	bind(324, this, TQT_SLOT(numericReply_324(KIRC::Message &)), 2, 4);
-	bind(328, this, TQT_SLOT(numericReply_328(KIRC::Message &)), 2, 2);
-	bind(329, this, TQT_SLOT(numericReply_329(KIRC::Message &)), 3, 3);
-	bind(330, this, TQT_SLOT(ignoreMessage(KIRC::Message &)), 0, 0); // ???
-	bind(331, this, TQT_SLOT(numericReply_331(KIRC::Message &)), 2, 2);
-	bind(332, this, TQT_SLOT(numericReply_332(KIRC::Message &)), 2, 2);
-	bind(333, this, TQT_SLOT(numericReply_333(KIRC::Message &)), 4, 4);
-	bind(352, this, TQT_SLOT(numericReply_352(KIRC::Message &)), 5, 10);
-	bind(353, this, TQT_SLOT(numericReply_353(KIRC::Message &)), 3, 3);
-	bind(366, this, TQT_SLOT(numericReply_366(KIRC::Message &)), 2, 2);
-	bind(369, this, TQT_SLOT(numericReply_369(KIRC::Message &)), 2, 2);
-	bind(372, this, TQT_SLOT(numericReply_372(KIRC::Message &)), 1, 1);
-	bind(375, this, TQT_SLOT(ignoreMessage(KIRC::Message&)), 0, 0 );
-	bind(376, this, TQT_SLOT(ignoreMessage(KIRC::Message&)), 0, 0 );
-
-	bind(401, this, TQT_SLOT(numericReply_401(KIRC::Message &)), 2, 2); // incomingNoNickChan
-//	bind(404, this, TQT_SLOT(numericReply_404(KIRC::Message &)), 2, 2); // incomingCannotSendToChannel
-	bind(406, this, TQT_SLOT(numericReply_406(KIRC::Message &)), 2, 2); // incomingWasNoNick
-	bind(422, this, TQT_SLOT(numericReply_422(KIRC::Message &)), 1, 1);
-	bind(433, this, TQT_SLOT(numericReply_433(KIRC::Message &)), 2, 2);
-//	bind(442, this, TQT_SLOT(numericReply_442(KIRC::Message &)), 2, 2); // incomingCannotSendToChannel
-	bind(464, this, TQT_SLOT(numericReply_464(KIRC::Message &)), 1, 1);
-	bind(471, this, TQT_SLOT(numericReply_471(KIRC::Message &)), 2, 2);
-	bind(473, this, TQT_SLOT(numericReply_473(KIRC::Message &)), 2, 2);
-	bind(474, this, TQT_SLOT(numericReply_474(KIRC::Message &)), 2, 2);
-	bind(475, this, TQT_SLOT(numericReply_475(KIRC::Message &)), 2, 2);
+	bind(1, this, TQ_SLOT(numericReply_001(KIRC::Message &)), 1, 1);
+	bind(2, this, TQ_SLOT(numericReply_002(KIRC::Message &)), 1, 1);
+	bind(3, this, TQ_SLOT(numericReply_003(KIRC::Message &)), 1, 1);
+	bind(4, this, TQ_SLOT(numericReply_004(KIRC::Message &)), 5, 5);
+	bind(5, this, TQ_SLOT(numericReply_004(KIRC::Message &)), 1, 1);
+
+	bind(250, this, TQ_SLOT(numericReply_250(KIRC::Message &)));
+	bind(251, this, TQ_SLOT(numericReply_251(KIRC::Message &)));
+	bind(252, this, TQ_SLOT(numericReply_252(KIRC::Message &)), 2, 2);
+	bind(253, this, TQ_SLOT(numericReply_253(KIRC::Message &)), 2, 2);
+	bind(254, this, TQ_SLOT(numericReply_254(KIRC::Message &)), 2, 2);
+	bind(255, this, TQ_SLOT(numericReply_255(KIRC::Message &)), 1, 1); // incomingConnectString
+
+	bind(263, this, TQ_SLOT(numericReply_263(KIRC::Message &))); // incomingServerLoadTooHigh
+	bind(265, this, TQ_SLOT(numericReply_265(KIRC::Message &)));
+	bind(266, this, TQ_SLOT(numericReply_266(KIRC::Message &)));
+
+	bind(301, this, TQ_SLOT(numericReply_301(KIRC::Message &)), 2, 2);
+	bind(303, this, TQ_SLOT(numericReply_303(KIRC::Message &)), 1, 1);
+	bind(305, this, TQ_SLOT(ignoreMessage(KIRC::Message &)), 0, 0 ); // You are no longer marked as away
+	bind(306, this, TQ_SLOT(ignoreMessage(KIRC::Message &)), 0, 0 ); // You are marked as away
+	bind(307, this, TQ_SLOT(numericReply_307(KIRC::Message &)), 1, 1);
+	bind(311, this, TQ_SLOT(numericReply_311(KIRC::Message &)), 5, 5);
+	bind(312, this, TQ_SLOT(numericReply_312(KIRC::Message &)), 3, 3);
+	bind(313, this, TQ_SLOT(numericReply_313(KIRC::Message &)), 2, 2);
+	bind(314, this, TQ_SLOT(numericReply_314(KIRC::Message &)), 5, 5);
+	bind(315, this, TQ_SLOT(numericReply_315(KIRC::Message &)), 2, 2);
+	bind(317, this, TQ_SLOT(numericReply_317(KIRC::Message &)), 3, 4);
+	bind(318, this, TQ_SLOT(numericReply_318(KIRC::Message &)), 2, 2);
+	bind(319, this, TQ_SLOT(numericReply_319(KIRC::Message &)), 2, 2);
+	bind(320, this, TQ_SLOT(numericReply_320(KIRC::Message &)), 2, 2);
+	bind(321, this, TQ_SLOT(ignoreMessage(KIRC::Message &)), 0, 0 );
+	bind(322, this, TQ_SLOT(numericReply_322(KIRC::Message &)), 3, 3);
+	bind(323, this, TQ_SLOT(numericReply_323(KIRC::Message &)), 1, 1);
+	bind(324, this, TQ_SLOT(numericReply_324(KIRC::Message &)), 2, 4);
+	bind(328, this, TQ_SLOT(numericReply_328(KIRC::Message &)), 2, 2);
+	bind(329, this, TQ_SLOT(numericReply_329(KIRC::Message &)), 3, 3);
+	bind(330, this, TQ_SLOT(ignoreMessage(KIRC::Message &)), 0, 0); // ???
+	bind(331, this, TQ_SLOT(numericReply_331(KIRC::Message &)), 2, 2);
+	bind(332, this, TQ_SLOT(numericReply_332(KIRC::Message &)), 2, 2);
+	bind(333, this, TQ_SLOT(numericReply_333(KIRC::Message &)), 4, 4);
+	bind(352, this, TQ_SLOT(numericReply_352(KIRC::Message &)), 5, 10);
+	bind(353, this, TQ_SLOT(numericReply_353(KIRC::Message &)), 3, 3);
+	bind(366, this, TQ_SLOT(numericReply_366(KIRC::Message &)), 2, 2);
+	bind(369, this, TQ_SLOT(numericReply_369(KIRC::Message &)), 2, 2);
+	bind(372, this, TQ_SLOT(numericReply_372(KIRC::Message &)), 1, 1);
+	bind(375, this, TQ_SLOT(ignoreMessage(KIRC::Message&)), 0, 0 );
+	bind(376, this, TQ_SLOT(ignoreMessage(KIRC::Message&)), 0, 0 );
+
+	bind(401, this, TQ_SLOT(numericReply_401(KIRC::Message &)), 2, 2); // incomingNoNickChan
+//	bind(404, this, TQ_SLOT(numericReply_404(KIRC::Message &)), 2, 2); // incomingCannotSendToChannel
+	bind(406, this, TQ_SLOT(numericReply_406(KIRC::Message &)), 2, 2); // incomingWasNoNick
+	bind(422, this, TQ_SLOT(numericReply_422(KIRC::Message &)), 1, 1);
+	bind(433, this, TQ_SLOT(numericReply_433(KIRC::Message &)), 2, 2);
+//	bind(442, this, TQ_SLOT(numericReply_442(KIRC::Message &)), 2, 2); // incomingCannotSendToChannel
+	bind(464, this, TQ_SLOT(numericReply_464(KIRC::Message &)), 1, 1);
+	bind(471, this, TQ_SLOT(numericReply_471(KIRC::Message &)), 2, 2);
+	bind(473, this, TQ_SLOT(numericReply_473(KIRC::Message &)), 2, 2);
+	bind(474, this, TQ_SLOT(numericReply_474(KIRC::Message &)), 2, 2);
+	bind(475, this, TQ_SLOT(numericReply_475(KIRC::Message &)), 2, 2);
 
 	//Freenode seems to use this for a non-RFC compliant purpose, as does Unreal
-	bind(477, this, TQT_SLOT(emitSuffix(KIRC::Message&)),0,0);
+	bind(477, this, TQ_SLOT(emitSuffix(KIRC::Message&)),0,0);
 }
 
 /* 001: "Welcome to the Internet Relay Network <nick>!<user>@<host>"
diff --git a/kopete/protocols/irc/libkirc/kircmessageredirector.cpp b/kopete/protocols/irc/libkirc/kircmessageredirector.cpp
index 2e1d0b4c..4eecdd6c 100644
--- a/kopete/protocols/irc/libkirc/kircmessageredirector.cpp
+++ b/kopete/protocols/irc/libkirc/kircmessageredirector.cpp
@@ -32,7 +32,7 @@ MessageRedirector::MessageRedirector(KIRC::Engine *engine,
 
 bool MessageRedirector::connect(TQObject *object, const char *member)
 {
-	return TQObject::connect(this, TQT_SIGNAL(redirect(KIRC::Message &)),
+	return TQObject::connect(this, TQ_SIGNAL(redirect(KIRC::Message &)),
 					object, member);
 }
 
diff --git a/kopete/protocols/irc/libkirc/kircmessageredirector.h b/kopete/protocols/irc/libkirc/kircmessageredirector.h
index 2c3f9e37..489ab412 100644
--- a/kopete/protocols/irc/libkirc/kircmessageredirector.h
+++ b/kopete/protocols/irc/libkirc/kircmessageredirector.h
@@ -48,9 +48,9 @@ public:
 	/**
 	 * Connects the given object member signal/slot to this message redirector.
 	 * The member signal slot should be looking like:
-	 * TQT_SIGNAL(mysignal(KIRC::Message &msg))
+	 * TQ_SIGNAL(mysignal(KIRC::Message &msg))
 	 * or
-	 * TQT_SIGNAL(myslot(KIRC::Message &msg))
+	 * TQ_SIGNAL(myslot(KIRC::Message &msg))
 	 */
 	bool connect(TQObject *object, const char *member);
 
diff --git a/kopete/protocols/irc/libkirc/kirctransfer.cpp b/kopete/protocols/irc/libkirc/kirctransfer.cpp
index cbcb6682..50e96ce8 100644
--- a/kopete/protocols/irc/libkirc/kirctransfer.cpp
+++ b/kopete/protocols/irc/libkirc/kirctransfer.cpp
@@ -81,11 +81,11 @@ Transfer::Transfer(	Engine *engine, TQString nick,// TQString nick_peer_adress
 	else if(!properites["hostAddress"].isNull() && !properites["hostPort"].isNull())
 		setSocket(new KExtendedSocket(properites["hostAddress"], properites["hostPort"]));
 
-	connect(this, TQT_SIGNAL(complete()),
-		this, TQT_SLOT(closeSocket()));
+	connect(this, TQ_SIGNAL(complete()),
+		this, TQ_SLOT(closeSocket()));
 
-	connect(this, TQT_SIGNAL(abort(TQString)),
-		this, TQT_SLOT(closeSocket()));
+	connect(this, TQ_SIGNAL(abort(TQString)),
+		this, TQ_SLOT(closeSocket()));
 }
 */
 Transfer::~Transfer()
@@ -134,39 +134,39 @@ bool Transfer::initiate()
 
 	m_file.setName(m_fileName);
 
-	connect(this, TQT_SIGNAL(complete()),
-		this, TQT_SLOT(closeSocket()));
-	connect(this, TQT_SIGNAL(abort(TQString)),
-		this, TQT_SLOT(closeSocket()));
+	connect(this, TQ_SIGNAL(complete()),
+		this, TQ_SLOT(closeSocket()));
+	connect(this, TQ_SIGNAL(abort(TQString)),
+		this, TQ_SLOT(closeSocket()));
 
-//	connect(m_socket, TQT_SIGNAL(connectionClosed()),
-//		this, TQT_SLOT(slotConnectionClosed()));
-//	connect(m_socket, TQT_SIGNAL(delayedCloseFinished()),
-//		this, TQT_SLOT(slotConnectionClosed()));
-	connect(m_socket, TQT_SIGNAL(error(int)), // FIXME: connection failed: No such signal KExtendedSocket::error(int)
-		this, TQT_SLOT(slotError(int)));
+//	connect(m_socket, TQ_SIGNAL(connectionClosed()),
+//		this, TQ_SLOT(slotConnectionClosed()));
+//	connect(m_socket, TQ_SIGNAL(delayedCloseFinished()),
+//		this, TQ_SLOT(slotConnectionClosed()));
+	connect(m_socket, TQ_SIGNAL(error(int)), // FIXME: connection failed: No such signal KExtendedSocket::error(int)
+		this, TQ_SLOT(slotError(int)));
 
 	switch( m_type )
 	{
 	case Chat:
 		kdDebug(14121) << k_funcinfo << "Stting up a chat." << endl;
-		connect(m_socket, TQT_SIGNAL(readyRead()),
-			this, TQT_SLOT(readyReadFileIncoming()));
+		connect(m_socket, TQ_SIGNAL(readyRead()),
+			this, TQ_SLOT(readyReadFileIncoming()));
 		break;
 	case FileIncoming:
 		kdDebug(14121) << k_funcinfo << "Stting up an incoming file transfer." << endl;
 		m_file.open(IO_WriteOnly);
-		connect(m_socket, TQT_SIGNAL(readyRead()),
-			this, TQT_SLOT(readyReadFileIncoming()));
+		connect(m_socket, TQ_SIGNAL(readyRead()),
+			this, TQ_SLOT(readyReadFileIncoming()));
 		break;
 	case FileOutgoing:
 		kdDebug(14121) << k_funcinfo << "Stting up an outgoing file transfer." << endl;
 		m_file.open(IO_ReadOnly);
-		connect(m_socket, TQT_SIGNAL(readyRead()),
-			this, TQT_SLOT(readyReadFileOutgoing()));
+		connect(m_socket, TQ_SIGNAL(readyRead()),
+			this, TQ_SLOT(readyReadFileOutgoing()));
 //		timer = new TQTimer(this);
-//		connect(timer, TQT_SIGNAL(timeout()),
-//			this, TQT_SLOT(writeFileOutgoing()));
+//		connect(timer, TQ_SIGNAL(timeout()),
+//			this, TQ_SLOT(writeFileOutgoing()));
 //		timer->start(1000, false);
 		writeFileOutgoing(); // send a first packet.
 		break;
@@ -190,8 +190,8 @@ bool Transfer::initiate()
 	// As far as I understand, buffer (socket buffer at least) should be flushed while event-looping.
 	// But I'm not really sure of this, so I force the flush.
 	timer = new TQTimer(this);
-	connect(timer, TQT_SIGNAL(timeout()),
-		this, TQT_SLOT(flush()));
+	connect(timer, TQ_SIGNAL(timeout()),
+		this, TQ_SLOT(flush()));
 	timer->start(1000, FALSE); // flush the streams at every seconds
 
 	return true;
diff --git a/kopete/protocols/irc/libkirc/kirctransferserver.cpp b/kopete/protocols/irc/libkirc/kirctransferserver.cpp
index 25b41ff9..b7c0917d 100644
--- a/kopete/protocols/irc/libkirc/kirctransferserver.cpp
+++ b/kopete/protocols/irc/libkirc/kirctransferserver.cpp
@@ -68,8 +68,8 @@ bool TransferServer::initServer()
 {
 	if (!m_socket)
 	{
-		TQObject::connect(this, TQT_SIGNAL(incomingNewTransfer(Transfer *)),
-				TransferHandler::self(), TQT_SIGNAL(transferCreated(Transfer *)));
+		TQObject::connect(this, TQ_SIGNAL(incomingNewTransfer(Transfer *)),
+				TransferHandler::self(), TQ_SIGNAL(transferCreated(Transfer *)));
 
 		m_socket = new KExtendedSocket();
 
@@ -83,10 +83,10 @@ bool TransferServer::initServer()
 		if (!m_socket->setTimeout(2*60)) // FIXME: allow configuration of this.
 			kdDebug(14120) << k_funcinfo << "Failed to set timeout." << endl;
 
-		TQObject::connect(m_socket, TQT_SIGNAL(readyAccept()),
-				this, TQT_SLOT(readyAccept()));
-		TQObject::connect(m_socket, TQT_SIGNAL(connectionFailed(int)),
-				this, TQT_SLOT(connectionFailed(int)));
+		TQObject::connect(m_socket, TQ_SIGNAL(readyAccept()),
+				this, TQ_SLOT(readyAccept()));
+		TQObject::connect(m_socket, TQ_SIGNAL(connectionFailed(int)),
+				this, TQ_SLOT(connectionFailed(int)));
 
 		m_socket->listen(m_backlog);
 		m_socket->setBlockingMode(true);
@@ -137,14 +137,14 @@ void Transfer::initClient()
 {
 	if(!m_socket)
 	{
-		connect(m_socket, TQT_SIGNAL(connectionClosed()),
-			this, TQT_SLOT(slotConnectionClosed()));
-		connect(m_socket, TQT_SIGNAL(delayedCloseFinished()),
-			this, TQT_SLOT(slotConnectionClosed()));
-		connect(m_socket, TQT_SIGNAL(error(int)),
-			this, TQT_SLOT(slotError(int)));
-		connect(m_socket, TQT_SIGNAL(readyRead()),
-			this, TQT_SLOT(readyReadFileOut));
+		connect(m_socket, TQ_SIGNAL(connectionClosed()),
+			this, TQ_SLOT(slotConnectionClosed()));
+		connect(m_socket, TQ_SIGNAL(delayedCloseFinished()),
+			this, TQ_SLOT(slotConnectionClosed()));
+		connect(m_socket, TQ_SIGNAL(error(int)),
+			this, TQ_SLOT(slotError(int)));
+		connect(m_socket, TQ_SIGNAL(readyRead()),
+			this, TQ_SLOT(readyReadFileOut));
 
 		m_socket->enableRead( true );
 		m_socket->enableWrite( true );
diff --git a/kopete/protocols/irc/libkirc/ksslsocket.cpp b/kopete/protocols/irc/libkirc/ksslsocket.cpp
index a1781c24..82440bbb 100644
--- a/kopete/protocols/irc/libkirc/ksslsocket.cpp
+++ b/kopete/protocols/irc/libkirc/ksslsocket.cpp
@@ -52,9 +52,9 @@ KSSLSocket::KSSLSocket() : KExtendedSocket()
 	setBlockingMode(false);
 
 	//Connect internal slots
-	TQObject::connect( this, TQT_SIGNAL(connectionSuccess()), this, TQT_SLOT(slotConnected()) );
-	TQObject::connect( this, TQT_SIGNAL(closed(int)), this, TQT_SLOT(slotDisconnected()) );
-	TQObject::connect( this, TQT_SIGNAL(connectionFailed(int)), this, TQT_SLOT(slotDisconnected()));
+	TQObject::connect( this, TQ_SIGNAL(connectionSuccess()), this, TQ_SLOT(slotConnected()) );
+	TQObject::connect( this, TQ_SIGNAL(closed(int)), this, TQ_SLOT(slotDisconnected()) );
+	TQObject::connect( this, TQ_SIGNAL(connectionFailed(int)), this, TQ_SLOT(slotDisconnected()));
 }
 
 KSSLSocket::~KSSLSocket()
@@ -148,11 +148,11 @@ void KSSLSocket::slotConnected()
 	}
 
 	//Disconnect the KExtSocket notifier slot, we use our own
-	TQObject::disconnect( readNotifier(), TQT_SIGNAL(activated( int )),
-			this, TQT_SLOT(socketActivityRead()) );
+	TQObject::disconnect( readNotifier(), TQ_SIGNAL(activated( int )),
+			this, TQ_SLOT(socketActivityRead()) );
 
-	TQObject::connect( readNotifier(), TQT_SIGNAL(activated( int )),
-			this, TQT_SLOT(slotReadData()) );
+	TQObject::connect( readNotifier(), TQ_SIGNAL(activated( int )),
+			this, TQ_SLOT(slotReadData()) );
 
 	readNotifier()->setEnabled(true);
 
diff --git a/kopete/protocols/irc/ui/channellist.cpp b/kopete/protocols/irc/ui/channellist.cpp
index 9ee7bbcb..fdff5512 100644
--- a/kopete/protocols/irc/ui/channellist.cpp
+++ b/kopete/protocols/irc/ui/channellist.cpp
@@ -213,21 +213,21 @@ ChannelList::ChannelList( TQWidget* parent, KIRC::Engine *engine )
 	mChannelList->header()->setLabel( 2, i18n( "Topic" ) );
 
 	// signals and slots connections
-	connect( mChannelList, TQT_SIGNAL( doubleClicked(TQListViewItem*) ),
-		this, TQT_SLOT( slotItemDoubleClicked(TQListViewItem*) ) );
+	connect( mChannelList, TQ_SIGNAL( doubleClicked(TQListViewItem*) ),
+		this, TQ_SLOT( slotItemDoubleClicked(TQListViewItem*) ) );
 
-	connect( mSearchButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( search() ) );
+	connect( mSearchButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( search() ) );
 
-	connect( mChannelList, TQT_SIGNAL( selectionChanged( TQListViewItem*) ), this,
-		TQT_SLOT( slotItemSelected( TQListViewItem *) ) );
+	connect( mChannelList, TQ_SIGNAL( selectionChanged( TQListViewItem*) ), this,
+		TQ_SLOT( slotItemSelected( TQListViewItem *) ) );
 
-	connect( m_engine, TQT_SIGNAL( incomingListedChan( const TQString &, uint, const TQString & ) ),
-		this, TQT_SLOT( slotChannelListed( const TQString &, uint, const TQString & ) ) );
+	connect( m_engine, TQ_SIGNAL( incomingListedChan( const TQString &, uint, const TQString & ) ),
+		this, TQ_SLOT( slotChannelListed( const TQString &, uint, const TQString & ) ) );
 
-	connect( m_engine, TQT_SIGNAL( incomingEndOfList() ), this, TQT_SLOT( slotListEnd() ) );
+	connect( m_engine, TQ_SIGNAL( incomingEndOfList() ), this, TQ_SLOT( slotListEnd() ) );
 
-	connect( m_engine, TQT_SIGNAL( statusChanged(KIRC::Engine::Status) ),
-			this, TQT_SLOT( slotStatusChanged(KIRC::Engine::Status) ) );
+	connect( m_engine, TQ_SIGNAL( statusChanged(KIRC::Engine::Status) ),
+			this, TQ_SLOT( slotStatusChanged(KIRC::Engine::Status) ) );
 
 	show();
 }
@@ -328,7 +328,7 @@ void ChannelList::slotSearchCache()
 	{
 		checkSearchResult( cacheIterator.key(), cacheIterator.data().first, cacheIterator.data().second );
 		++cacheIterator;
-		TQTimer::singleShot( 0, this, TQT_SLOT( slotSearchCache() ) );
+		TQTimer::singleShot( 0, this, TQ_SLOT( slotSearchCache() ) );
 	}
 	else
 	{
diff --git a/kopete/protocols/irc/ui/channellistdialog.cpp b/kopete/protocols/irc/ui/channellistdialog.cpp
index e344d227..cd127147 100644
--- a/kopete/protocols/irc/ui/channellistdialog.cpp
+++ b/kopete/protocols/irc/ui/channellistdialog.cpp
@@ -30,11 +30,11 @@ ChannelListDialog::ChannelListDialog(KIRC::Engine *engine, const TQString &capti
 	m_engine = engine;
 	m_list = new ChannelList( this, engine );
 
-	connect( m_list, TQT_SIGNAL( channelDoubleClicked( const TQString & ) ),
+	connect( m_list, TQ_SIGNAL( channelDoubleClicked( const TQString & ) ),
 		target, slotJoinChan );
 
-	connect( m_list, TQT_SIGNAL( channelDoubleClicked( const TQString & ) ),
-		this, TQT_SLOT( slotChannelDoubleClicked( const TQString & ) ) );
+	connect( m_list, TQ_SIGNAL( channelDoubleClicked( const TQString & ) ),
+		this, TQ_SLOT( slotChannelDoubleClicked( const TQString & ) ) );
 
 	new TQHBoxLayout( m_list, 0, spacingHint() );
 
diff --git a/kopete/protocols/irc/ui/irceditaccountwidget.cpp b/kopete/protocols/irc/ui/irceditaccountwidget.cpp
index 2304bcd5..db0443f2 100644
--- a/kopete/protocols/irc/ui/irceditaccountwidget.cpp
+++ b/kopete/protocols/irc/ui/irceditaccountwidget.cpp
@@ -106,21 +106,21 @@ IRCEditAccountWidget::IRCEditAccountWidget(IRCProtocol *proto, IRCAccount *ident
 		}
 	}
 
-	connect( commandList, TQT_SIGNAL( contextMenu( TDEListView *, TQListViewItem *, const TQPoint & ) ),
-		this, TQT_SLOT( slotCommandContextMenu( TDEListView *, TQListViewItem *, const TQPoint & ) ) );
+	connect( commandList, TQ_SIGNAL( contextMenu( TDEListView *, TQListViewItem *, const TQPoint & ) ),
+		this, TQ_SLOT( slotCommandContextMenu( TDEListView *, TQListViewItem *, const TQPoint & ) ) );
 
-	connect( ctcpList, TQT_SIGNAL( contextMenu( TDEListView *, TQListViewItem *, const TQPoint & ) ),
-		this, TQT_SLOT( slotCtcpContextMenu( TDEListView *, TQListViewItem *, const TQPoint & ) ) );
+	connect( ctcpList, TQ_SIGNAL( contextMenu( TDEListView *, TQListViewItem *, const TQPoint & ) ),
+		this, TQ_SLOT( slotCtcpContextMenu( TDEListView *, TQListViewItem *, const TQPoint & ) ) );
 
-	connect( addButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotAddCommand() ) );
-	connect( editButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT(slotEditNetworks() ) );
-	connect( addReply, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotAddCtcp() ) );
+	connect( addButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotAddCommand() ) );
+	connect( editButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT(slotEditNetworks() ) );
+	connect( addReply, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotAddCtcp() ) );
 
-	connect( network, TQT_SIGNAL( activated( const TQString & ) ),
-		this, TQT_SLOT( slotUpdateNetworkDescription( const TQString &) ) );
+	connect( network, TQ_SIGNAL( activated( const TQString & ) ),
+		this, TQ_SLOT( slotUpdateNetworkDescription( const TQString &) ) );
 
-	connect( IRCProtocol::protocol(), TQT_SIGNAL( networkConfigUpdated( const TQString & ) ),
-		this, TQT_SLOT( slotUpdateNetworks( const TQString & ) ) );
+	connect( IRCProtocol::protocol(), TQ_SIGNAL( networkConfigUpdated( const TQString & ) ),
+		this, TQ_SLOT( slotUpdateNetworks( const TQString & ) ) );
 
 	slotUpdateNetworks( TQString() );
 }