Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

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

36 files changed, 333 insertions, 333 deletions

diff --git a/kopete/protocols/oscar/aim/aimaccount.cpp b/kopete/protocols/oscar/aim/aimaccount.cpp
index 82b9a29c..4a34b369 100644
--- a/kopete/protocols/oscar/aim/aimaccount.cpp
+++ b/kopete/protocols/oscar/aim/aimaccount.cpp
@@ -95,8 +95,8 @@ Kopete::ChatSession* AIMMyselfContact::manager( Kopete::Contact::CanCreateFlags
         session = new AIMChatSession( this, chatMembers, account()->protocol(), exchange, room );
         session->setEngine( m_acct->engine() );
 
-        connect( session, TQT_SIGNAL( messageSent( Kopete::Message&, Kopete::ChatSession* ) ),
-                 this, TQT_SLOT( sendMessage( Kopete::Message&, Kopete::ChatSession* ) ) );
+        connect( session, TQ_SIGNAL( messageSent( Kopete::Message&, Kopete::ChatSession* ) ),
+                 this, TQ_SLOT( sendMessage( Kopete::Message&, Kopete::ChatSession* ) ) );
         m_chatRoomSessions.append( session );
     }
     return session;
@@ -214,20 +214,20 @@ AIMAccount::AIMAccount(Kopete::Protocol *parent, TQString accountID, const char
     m_joinChatDialog = 0;
 	m_visibilityDialog = 0;
 	TQObject::connect( Kopete::ContactList::self(),
-	                  TQT_SIGNAL( globalIdentityChanged( const TQString&, const TQVariant& ) ),
+	                  TQ_SIGNAL( globalIdentityChanged( const TQString&, const TQVariant& ) ),
 	                  this,
-	                  TQT_SLOT( slotGlobalIdentityChanged( const TQString&, const TQVariant& ) ) );
+	                  TQ_SLOT( slotGlobalIdentityChanged( const TQString&, const TQVariant& ) ) );
 
-    TQObject::connect( engine(), TQT_SIGNAL( chatRoomConnected( WORD, const TQString& ) ),
-                      this, TQT_SLOT( connectedToChatRoom( WORD, const TQString& ) ) );
+    TQObject::connect( engine(), TQ_SIGNAL( chatRoomConnected( WORD, const TQString& ) ),
+                      this, TQ_SLOT( connectedToChatRoom( WORD, const TQString& ) ) );
 
-    TQObject::connect( engine(), TQT_SIGNAL( userJoinedChat( Oscar::WORD, const TQString&, const TQString& ) ),
-                      this, TQT_SLOT( userJoinedChat( Oscar::WORD, const TQString&, const TQString& ) ) );
+    TQObject::connect( engine(), TQ_SIGNAL( userJoinedChat( Oscar::WORD, const TQString&, const TQString& ) ),
+                      this, TQ_SLOT( userJoinedChat( Oscar::WORD, const TQString&, const TQString& ) ) );
 
-    TQObject::connect( engine(), TQT_SIGNAL( userLeftChat( Oscar::WORD, const TQString&, const TQString& ) ),
-                      this, TQT_SLOT( userLeftChat( Oscar::WORD, const TQString&, const TQString& ) ) );
+    TQObject::connect( engine(), TQ_SIGNAL( userLeftChat( Oscar::WORD, const TQString&, const TQString& ) ),
+                      this, TQ_SLOT( userLeftChat( Oscar::WORD, const TQString&, const TQString& ) ) );
 
-	TQObject::connect( this, TQT_SIGNAL( buddyIconChanged() ), this, TQT_SLOT( slotBuddyIconChanged() ) );
+	TQObject::connect( this, TQ_SIGNAL( buddyIconChanged() ), this, TQ_SLOT( slotBuddyIconChanged() ) );
 
 }
 
@@ -309,30 +309,30 @@ TDEActionMenu* AIMAccount::actionMenu()
 			i18n( "%2 <%1>" ).arg( accountId(), accountNick ));
 
 	mActionMenu->insert( new TDEAction( i18n("Online"), p->statusOnline.iconFor( this ), 0, this,
-	             TQT_SLOT( slotGoOnline() ), mActionMenu, "AIMAccount::mActionOnline") );
+	             TQ_SLOT( slotGoOnline() ), mActionMenu, "AIMAccount::mActionOnline") );
 
 	TDEAction* mActionAway = new Kopete::AwayAction(i18n("Away"), p->statusAway.iconFor( this ), 0, this,
-	             TQT_SLOT(slotGoAway( const TQString & )), this, "AIMAccount::mActionNA" );
+	             TQ_SLOT(slotGoAway( const TQString & )), this, "AIMAccount::mActionNA" );
 	mActionAway->setEnabled( isConnected() );
 	mActionMenu->insert( mActionAway );
 
 	TDEAction* mActionOffline = new TDEAction( i18n("Offline"), p->statusOffline.iconFor(this), 0, this,
-	             TQT_SLOT( slotGoOffline() ), mActionMenu, "AIMAccount::mActionOffline");
+	             TQ_SLOT( slotGoOffline() ), mActionMenu, "AIMAccount::mActionOffline");
 
 	mActionMenu->insert( mActionOffline );
 	mActionMenu->popupMenu()->insertSeparator();
 
     TDEAction* m_joinChatAction = new TDEAction( i18n( "Join Chat..." ), TQString(),  0,  this,
-                                             TQT_SLOT( slotJoinChat() ), mActionMenu, "join_a_chat" );
+                                             TQ_SLOT( slotJoinChat() ), mActionMenu, "join_a_chat" );
 
 	mActionMenu->insert( new TDEToggleAction( i18n( "Set Visibility..." ), 0, 0,
-	                                       this, TQT_SLOT( slotSetVisiblility() ), this,
+	                                       this, TQ_SLOT( slotSetVisiblility() ), this,
 	                                       "AIMAccount::mActionSetVisibility") );
 
     mActionMenu->insert( m_joinChatAction );
     
     TDEAction* m_editInfoAction = new TDEAction( i18n( "Edit User Info..." ), "identity", 0,
-                                             this, TQT_SLOT( slotEditInfo() ), mActionMenu, "actionEditInfo");
+                                             this, TQ_SLOT( slotEditInfo() ), mActionMenu, "actionEditInfo");
     
     mActionMenu->insert( m_editInfoAction );
 
@@ -415,10 +415,10 @@ void AIMAccount::slotGlobalIdentityChanged( const TQString& key, const TQVariant
 void AIMAccount::slotBuddyIconChanged()
 {
 	// need to disconnect because we could end up with many connections
-	TQObject::disconnect( engine(), TQT_SIGNAL( iconServerConnected() ), this, TQT_SLOT( slotBuddyIconChanged() ) );
+	TQObject::disconnect( engine(), TQ_SIGNAL( iconServerConnected() ), this, TQ_SLOT( slotBuddyIconChanged() ) );
 	if ( !engine()->isActive() )
 	{
-		TQObject::connect( engine(), TQT_SIGNAL( iconServerConnected() ), this, TQT_SLOT( slotBuddyIconChanged() ) );
+		TQObject::connect( engine(), TQ_SIGNAL( iconServerConnected() ), this, TQ_SLOT( slotBuddyIconChanged() ) );
 		return;
 	}
 	
@@ -520,8 +520,8 @@ void AIMAccount::slotJoinChat()
     if ( !m_joinChatDialog )
     {
         m_joinChatDialog = new AIMJoinChatUI( this, false, Kopete::UI::Global::mainWidget() );
-	    TQObject::connect( m_joinChatDialog, TQT_SIGNAL( closing( int ) ),
-	                      this, TQT_SLOT( joinChatDialogClosed( int ) ) );
+	    TQObject::connect( m_joinChatDialog, TQ_SIGNAL( closing( int ) ),
+	                      this, TQ_SLOT( joinChatDialogClosed( int ) ) );
         TQValueList<int> list = engine()->chatExchangeList();
         m_joinChatDialog->setExchangeList( list );
         m_joinChatDialog->show();
@@ -794,8 +794,8 @@ void AIMAccount::slotSetVisiblility()
 	if ( !m_visibilityDialog )
 	{
 		m_visibilityDialog = new OscarVisibilityDialog( engine(), Kopete::UI::Global::mainWidget() );
-		TQObject::connect( m_visibilityDialog, TQT_SIGNAL( closing() ),
-		                  this, TQT_SLOT( slotVisibilityDialogClosed() ) );
+		TQObject::connect( m_visibilityDialog, TQ_SIGNAL( closing() ),
+		                  this, TQ_SLOT( slotVisibilityDialogClosed() ) );
 		
 		//add all contacts;
 		OscarVisibilityDialog::ContactMap contactMap;
diff --git a/kopete/protocols/oscar/aim/aimcontact.cpp b/kopete/protocols/oscar/aim/aimcontact.cpp
index 12eb4bd2..0d42c8ce 100644
--- a/kopete/protocols/oscar/aim/aimcontact.cpp
+++ b/kopete/protocols/oscar/aim/aimcontact.cpp
@@ -58,21 +58,21 @@ AIMContact::AIMContact( Kopete::Account* account, const TQString& name, Kopete::
 	// Set the last autoresponse time to the current time yesterday
 	m_lastAutoresponseTime = TQDateTime::currentDateTime().addDays(-1);
 
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( receivedUserInfo( const TQString&, const UserDetails& ) ),
-	                  this, TQT_SLOT( userInfoUpdated( const TQString&, const UserDetails& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( userIsOffline( const TQString& ) ),
-	                  this, TQT_SLOT( userOffline( const TQString& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( receivedAwayMessage( const TQString&, const TQString& ) ),
-	                  this, TQT_SLOT( updateAwayMessage( const TQString&, const TQString& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( receivedProfile( const TQString&, const TQString& ) ),
-	                  this, TQT_SLOT( updateProfile( const TQString&, const TQString& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( userWarned( const TQString&, TQ_UINT16, TQ_UINT16 ) ),
-	                  this, TQT_SLOT( gotWarning( const TQString&, TQ_UINT16, TQ_UINT16 ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( haveIconForContact( const TQString&, TQByteArray ) ),
-	                  this, TQT_SLOT( haveIcon( const TQString&, TQByteArray ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( iconServerConnected() ),
-	                  this, TQT_SLOT( requestBuddyIcon() ) );
-	TQObject::connect( this, TQT_SIGNAL( featuresUpdated() ), this, TQT_SLOT( updateFeatures() ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( receivedUserInfo( const TQString&, const UserDetails& ) ),
+	                  this, TQ_SLOT( userInfoUpdated( const TQString&, const UserDetails& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( userIsOffline( const TQString& ) ),
+	                  this, TQ_SLOT( userOffline( const TQString& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( receivedAwayMessage( const TQString&, const TQString& ) ),
+	                  this, TQ_SLOT( updateAwayMessage( const TQString&, const TQString& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( receivedProfile( const TQString&, const TQString& ) ),
+	                  this, TQ_SLOT( updateProfile( const TQString&, const TQString& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( userWarned( const TQString&, TQ_UINT16, TQ_UINT16 ) ),
+	                  this, TQ_SLOT( gotWarning( const TQString&, TQ_UINT16, TQ_UINT16 ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( haveIconForContact( const TQString&, TQByteArray ) ),
+	                  this, TQ_SLOT( haveIcon( const TQString&, TQByteArray ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( iconServerConnected() ),
+	                  this, TQ_SLOT( requestBuddyIcon() ) );
+	TQObject::connect( this, TQ_SIGNAL( featuresUpdated() ), this, TQ_SLOT( updateFeatures() ) );
 }
 
 AIMContact::~AIMContact()
@@ -90,12 +90,12 @@ TQPtrList<TDEAction> *AIMContact::customContextMenuActions()
 	TQPtrList<TDEAction> *actionCollection = new TQPtrList<TDEAction>();
 	if ( !m_warnUserAction )
 	{
-		m_warnUserAction = new TDEAction( i18n( "&Warn User" ), 0, this, TQT_SLOT( warnUser() ), this, "warnAction" );
+		m_warnUserAction = new TDEAction( i18n( "&Warn User" ), 0, this, TQ_SLOT( warnUser() ), this, "warnAction" );
 	}
 	m_actionVisibleTo = new TDEToggleAction(i18n("Always &Visible To"), "", 0,
-	                                      this, TQT_SLOT(slotVisibleTo()), this, "actionVisibleTo");
+	                                      this, TQ_SLOT(slotVisibleTo()), this, "actionVisibleTo");
 	m_actionInvisibleTo = new TDEToggleAction(i18n("Always &Invisible To"), "", 0,
-	                                        this, TQT_SLOT(slotInvisibleTo()), this, "actionInvisibleTo");
+	                                        this, TQ_SLOT(slotInvisibleTo()), this, "actionInvisibleTo");
 	
 	bool on = account()->isConnected();
 
@@ -162,7 +162,7 @@ void AIMContact::slotUserInfo()
 		m_infoDialog = new AIMUserInfoDialog( this, static_cast<AIMAccount*>( account() ), false, Kopete::UI::Global::mainWidget(), 0 );
 		if( !m_infoDialog )
 			return;
-		connect( m_infoDialog, TQT_SIGNAL( finished() ), this, TQT_SLOT( closeUserInfoDialog() ) );
+		connect( m_infoDialog, TQ_SIGNAL( finished() ), this, TQ_SLOT( closeUserInfoDialog() ) );
 		m_infoDialog->show();
 		if ( mAccount->isConnected() )
 		{
@@ -240,7 +240,7 @@ void AIMContact::userInfoUpdated( const TQString& contact, const UserDetails& de
 
 		int time = ( TDEApplication::random() % 10 ) * 1000;
 		kdDebug(OSCAR_ICQ_DEBUG) << k_funcinfo << "updating buddy icon in " << time/1000 << " seconds" << endl;
-		TQTimer::singleShot( time, this, TQT_SLOT( requestBuddyIcon() ) );
+		TQTimer::singleShot( time, this, TQ_SLOT( requestBuddyIcon() ) );
 	}
 
 	OscarContact::userInfoUpdated( contact, details );
diff --git a/kopete/protocols/oscar/aim/aimjoinchat.cpp b/kopete/protocols/oscar/aim/aimjoinchat.cpp
index 667a926d..36a79613 100644
--- a/kopete/protocols/oscar/aim/aimjoinchat.cpp
+++ b/kopete/protocols/oscar/aim/aimjoinchat.cpp
@@ -41,8 +41,8 @@ AIMJoinChatUI::AIMJoinChatUI( AIMAccount* account,  bool modal,
 
     setMainWidget( m_joinUI  );
 
-    TQObject::connect( this, TQT_SIGNAL( user1Clicked() ), this, TQT_SLOT( joinChat() ) );
-    TQObject::connect( this, TQT_SIGNAL( cancelClicked() ), this, TQT_SLOT( closeClicked() ) );
+    TQObject::connect( this, TQ_SIGNAL( user1Clicked() ), this, TQ_SLOT( joinChat() ) );
+    TQObject::connect( this, TQ_SIGNAL( cancelClicked() ), this, TQ_SLOT( closeClicked() ) );
 }
 
 AIMJoinChatUI::~AIMJoinChatUI()
diff --git a/kopete/protocols/oscar/aim/aimuserinfo.cpp b/kopete/protocols/oscar/aim/aimuserinfo.cpp
index 46d6db03..561eef41 100644
--- a/kopete/protocols/oscar/aim/aimuserinfo.cpp
+++ b/kopete/protocols/oscar/aim/aimuserinfo.cpp
@@ -50,10 +50,10 @@ AIMUserInfoDialog::AIMUserInfoDialog( Kopete::Contact *c, AIMAccount *acc, bool
 	mMainWidget = new AIMUserInfoWidget(this, "aimuserinfowidget");
 	setMainWidget(mMainWidget);
 
-	TQObject::connect(this, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotSaveClicked()));
-	TQObject::connect(this, TQT_SIGNAL(user1Clicked()), this, TQT_SLOT(slotUpdateClicked()));
-	TQObject::connect(this, TQT_SIGNAL(cancelClicked()), this, TQT_SLOT(slotCloseClicked()));
-	TQObject::connect(c, TQT_SIGNAL(updatedProfile()), this, TQT_SLOT(slotUpdateProfile()));
+	TQObject::connect(this, TQ_SIGNAL(okClicked()), this, TQ_SLOT(slotSaveClicked()));
+	TQObject::connect(this, TQ_SIGNAL(user1Clicked()), this, TQ_SLOT(slotUpdateClicked()));
+	TQObject::connect(this, TQ_SIGNAL(cancelClicked()), this, TQ_SLOT(slotCloseClicked()));
+	TQObject::connect(c, TQ_SIGNAL(updatedProfile()), this, TQ_SLOT(slotUpdateProfile()));
 
 	mMainWidget->txtScreenName->setText( c->contactId() );
 
@@ -100,11 +100,11 @@ AIMUserInfoDialog::AIMUserInfoDialog( Kopete::Contact *c, AIMAccount *acc, bool
 		userInfoView->setTextFormat(AutoText);
 		userInfoView->setNotifyClick(true);
 		TQObject::connect(
-			userInfoView, TQT_SIGNAL(urlClick(const TQString&)),
-			this, TQT_SLOT(slotUrlClicked(const TQString&)));
+			userInfoView, TQ_SIGNAL(urlClick(const TQString&)),
+			this, TQ_SLOT(slotUrlClicked(const TQString&)));
 		TQObject::connect(
-			userInfoView, TQT_SIGNAL(mailClick(const TQString&, const TQString&)),
-			this, TQT_SLOT(slotMailClicked(const TQString&, const TQString&)));
+			userInfoView, TQ_SIGNAL(mailClick(const TQString&, const TQString&)),
+			this, TQ_SLOT(slotMailClicked(const TQString&, const TQString&)));
 		showButton(Cancel, false);
 		setButtonText(Ok, i18n("&Close"));
 		setEscapeButton(Ok);
@@ -115,7 +115,7 @@ AIMUserInfoDialog::AIMUserInfoDialog( Kopete::Contact *c, AIMAccount *acc, bool
 			// Update the user view to indicate that we're requesting the user's profile
 			userInfoView->setText(i18n("Requesting User Profile, please wait..."));
 		}
-		TQTimer::singleShot(0, this, TQT_SLOT(slotUpdateProfile()));
+		TQTimer::singleShot(0, this, TQ_SLOT(slotUpdateProfile()));
 	}
 }
 
diff --git a/kopete/protocols/oscar/aim/ui/aimeditaccountwidget.cpp b/kopete/protocols/oscar/aim/ui/aimeditaccountwidget.cpp
index 8ea32a3b..7a8a499e 100644
--- a/kopete/protocols/oscar/aim/ui/aimeditaccountwidget.cpp
+++ b/kopete/protocols/oscar/aim/ui/aimeditaccountwidget.cpp
@@ -80,7 +80,7 @@ AIMEditAccountWidget::AIMEditAccountWidget( AIMProtocol *protocol,
 		// Global Identity
 		mGui->mGlobalIdentity->setChecked( account->configGroup()->readBoolEntry("ExcludeGlobalIdentity", false) );
     }
-	TQObject::connect( mGui->buttonRegister, TQT_SIGNAL( clicked() ), this, TQT_SLOT( slotOpenRegister() ) );
+	TQObject::connect( mGui->buttonRegister, TQ_SIGNAL( clicked() ), this, TQ_SLOT( slotOpenRegister() ) );
 
 	/* Set tab order to password custom widget correctly */
 	TQWidget::setTabOrder( mGui->edtAccountId, mGui->mPasswordWidget->mRemembered );
diff --git a/kopete/protocols/oscar/icq/icqaccount.cpp b/kopete/protocols/oscar/icq/icqaccount.cpp
index f5c6b9ea..01892598 100644
--- a/kopete/protocols/oscar/icq/icqaccount.cpp
+++ b/kopete/protocols/oscar/icq/icqaccount.cpp
@@ -43,9 +43,9 @@
 
 ICQMyselfContact::ICQMyselfContact( ICQAccount *acct ) : OscarMyselfContact( acct )
 {
-	TQObject::connect( acct->engine(), TQT_SIGNAL( loggedIn() ), this, TQT_SLOT( fetchShortInfo() ) );
-	TQObject::connect( acct->engine(), TQT_SIGNAL( receivedIcqShortInfo( const TQString& ) ),
-	                  this, TQT_SLOT( receivedShortInfo( const TQString& ) ) );
+	TQObject::connect( acct->engine(), TQ_SIGNAL( loggedIn() ), this, TQ_SLOT( fetchShortInfo() ) );
+	TQObject::connect( acct->engine(), TQ_SIGNAL( receivedIcqShortInfo( const TQString& ) ),
+	                  this, TQ_SLOT( receivedShortInfo( const TQString& ) ) );
 }
 
 void ICQMyselfContact::userInfoUpdated()
@@ -88,10 +88,10 @@ ICQAccount::ICQAccount(Kopete::Protocol *parent, TQString accountID, const char
 	mHideIP = configGroup()->readBoolEntry( "HideIP", true );
 	mInitialStatusMessage = TQString();
 
-	TQObject::connect( Kopete::ContactList::self(), TQT_SIGNAL( globalIdentityChanged( const TQString&, const TQVariant& ) ),
-	                  this, TQT_SLOT( slotGlobalIdentityChanged( const TQString&, const TQVariant& ) ) );
+	TQObject::connect( Kopete::ContactList::self(), TQ_SIGNAL( globalIdentityChanged( const TQString&, const TQVariant& ) ),
+	                  this, TQ_SLOT( slotGlobalIdentityChanged( const TQString&, const TQVariant& ) ) );
 
-	TQObject::connect( this, TQT_SIGNAL( buddyIconChanged() ), this, TQT_SLOT( slotBuddyIconChanged() ) );
+	TQObject::connect( this, TQ_SIGNAL( buddyIconChanged() ), this, TQ_SLOT( slotBuddyIconChanged() ) );
 
 	//setIgnoreUnknownContacts(pluginData(protocol(), "IgnoreUnknownContacts").toUInt() == 1);
 
@@ -129,15 +129,15 @@ TDEActionMenu* ICQAccount::actionMenu()
 	TDEToggleAction* actionInvisible =
 	    new TDEToggleAction( i18n( "In&visible" ),
 	                       ICQ::Presence( presence().type(), ICQ::Presence::Invisible ).toOnlineStatus().iconFor( this ),
-	                       0, this, TQT_SLOT( slotToggleInvisible() ), this );
+	                       0, this, TQ_SLOT( slotToggleInvisible() ), this );
 	actionInvisible->setChecked( presence().visibility() == ICQ::Presence::Invisible );
 	actionMenu->insert( actionInvisible );
 
 	actionMenu->popupMenu()->insertSeparator();
 	actionMenu->insert( new TDEToggleAction( i18n( "Set Visibility..." ), 0, 0,
-	                                       this, TQT_SLOT( slotSetVisiblility() ), this,
+	                                       this, TQ_SLOT( slotSetVisiblility() ), this,
 	                                       "ICQAccount::mActionSetVisibility") );
-	//actionMenu->insert( new TDEToggleAction( i18n( "Send &SMS..." ), 0, 0, this, TQT_SLOT( slotSendSMS() ), this, "ICQAccount::mActionSendSMS") );
+	//actionMenu->insert( new TDEToggleAction( i18n( "Send &SMS..." ), 0, 0, this, TQ_SLOT( slotSendSMS() ), this, "ICQAccount::mActionSendSMS") );
 
 	return actionMenu;
 }
@@ -231,8 +231,8 @@ void ICQAccount::slotSetVisiblility()
 	if ( !m_visibilityDialog )
 	{
 		m_visibilityDialog = new OscarVisibilityDialog( engine(), Kopete::UI::Global::mainWidget() );
-		TQObject::connect( m_visibilityDialog, TQT_SIGNAL( closing() ),
-		                  this, TQT_SLOT( slotVisibilityDialogClosed() ) );
+		TQObject::connect( m_visibilityDialog, TQ_SIGNAL( closing() ),
+		                  this, TQ_SLOT( slotVisibilityDialogClosed() ) );
 		
 		//add all contacts;
 		OscarVisibilityDialog::ContactMap contactMap;
@@ -417,10 +417,10 @@ void ICQAccount::slotGlobalIdentityChanged( const TQString& key, const TQVariant
 void ICQAccount::slotBuddyIconChanged()
 {
 	// need to disconnect because we could end up with many connections
-	TQObject::disconnect( engine(), TQT_SIGNAL( iconServerConnected() ), this, TQT_SLOT( slotBuddyIconChanged() ) );
+	TQObject::disconnect( engine(), TQ_SIGNAL( iconServerConnected() ), this, TQ_SLOT( slotBuddyIconChanged() ) );
 	if ( !engine()->isActive() )
 	{
-		TQObject::connect( engine(), TQT_SIGNAL( iconServerConnected() ), this, TQT_SLOT( slotBuddyIconChanged() ) );
+		TQObject::connect( engine(), TQ_SIGNAL( iconServerConnected() ), this, TQ_SLOT( slotBuddyIconChanged() ) );
 		return;
 	}
 	
diff --git a/kopete/protocols/oscar/icq/icqcontact.cpp b/kopete/protocols/oscar/icq/icqcontact.cpp
index 01c0e43d..2758d2c4 100644
--- a/kopete/protocols/oscar/icq/icqcontact.cpp
+++ b/kopete/protocols/oscar/icq/icqcontact.cpp
@@ -66,28 +66,28 @@ ICQContact::ICQContact( ICQAccount *account, const TQString &name, Kopete::MetaC
 	else
 		setOnlineStatus( ICQ::Presence( ICQ::Presence::Offline, ICQ::Presence::Visible ).toOnlineStatus() );
 
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( loggedIn() ), this, TQT_SLOT( loggedIn() ) );
-	//TQObject::connect( mAccount->engine(), TQT_SIGNAL( userIsOnline( const TQString& ) ), this, TQT_SLOT( userOnline( const TQString&, UserDetails ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( userIsOffline( const TQString& ) ), this, TQT_SLOT( userOffline( const TQString& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( authRequestReceived( const TQString&, const TQString& ) ),
-	                  this, TQT_SLOT( slotGotAuthRequest( const TQString&, const TQString& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( authReplyReceived( const TQString&, const TQString&, bool ) ),
-	                  this, TQT_SLOT( slotGotAuthReply(const TQString&, const TQString&, bool ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( receivedIcqShortInfo( const TQString& ) ),
-	                  this, TQT_SLOT( receivedShortInfo( const TQString& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( receivedIcqLongInfo( const TQString& ) ),
-	                  this, TQT_SLOT( receivedLongInfo( const TQString& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( receivedUserInfo( const TQString&, const UserDetails& ) ),
-	                  this, TQT_SLOT( userInfoUpdated( const TQString&, const UserDetails& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( receivedAwayMessage( const TQString&, const TQString& ) ),
-	                  this, TQT_SLOT( receivedStatusMessage( const TQString&, const TQString& ) ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( receivedAwayMessage( const Oscar::Message& ) ),
-	                  this, TQT_SLOT( receivedStatusMessage( const Oscar::Message& ) ) );
-	TQObject::connect( this, TQT_SIGNAL( featuresUpdated() ), this, TQT_SLOT( updateFeatures() ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( iconServerConnected() ),
-	                  this, TQT_SLOT( requestBuddyIcon() ) );
-	TQObject::connect( mAccount->engine(), TQT_SIGNAL( haveIconForContact( const TQString&, TQByteArray ) ),
-	                  this, TQT_SLOT( haveIcon( const TQString&, TQByteArray ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( loggedIn() ), this, TQ_SLOT( loggedIn() ) );
+	//TQObject::connect( mAccount->engine(), TQ_SIGNAL( userIsOnline( const TQString& ) ), this, TQ_SLOT( userOnline( const TQString&, UserDetails ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( userIsOffline( const TQString& ) ), this, TQ_SLOT( userOffline( const TQString& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( authRequestReceived( const TQString&, const TQString& ) ),
+	                  this, TQ_SLOT( slotGotAuthRequest( const TQString&, const TQString& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( authReplyReceived( const TQString&, const TQString&, bool ) ),
+	                  this, TQ_SLOT( slotGotAuthReply(const TQString&, const TQString&, bool ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( receivedIcqShortInfo( const TQString& ) ),
+	                  this, TQ_SLOT( receivedShortInfo( const TQString& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( receivedIcqLongInfo( const TQString& ) ),
+	                  this, TQ_SLOT( receivedLongInfo( const TQString& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( receivedUserInfo( const TQString&, const UserDetails& ) ),
+	                  this, TQ_SLOT( userInfoUpdated( const TQString&, const UserDetails& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( receivedAwayMessage( const TQString&, const TQString& ) ),
+	                  this, TQ_SLOT( receivedStatusMessage( const TQString&, const TQString& ) ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( receivedAwayMessage( const Oscar::Message& ) ),
+	                  this, TQ_SLOT( receivedStatusMessage( const Oscar::Message& ) ) );
+	TQObject::connect( this, TQ_SIGNAL( featuresUpdated() ), this, TQ_SLOT( updateFeatures() ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( iconServerConnected() ),
+	                  this, TQ_SLOT( requestBuddyIcon() ) );
+	TQObject::connect( mAccount->engine(), TQ_SIGNAL( haveIconForContact( const TQString&, TQByteArray ) ),
+	                  this, TQ_SLOT( haveIcon( const TQString&, TQByteArray ) ) );
 
 }
 
@@ -193,7 +193,7 @@ void ICQContact::userInfoUpdated( const TQString& contact, const UserDetails& de
 				int time = ( TDEApplication::random() % 10 ) * 1000;
 				kdDebug(OSCAR_ICQ_DEBUG) << k_funcinfo << "updating buddy icon in "
 				                         << time/1000 << " seconds" << endl;
-				TQTimer::singleShot( time, this, TQT_SLOT( requestBuddyIcon() ) );
+				TQTimer::singleShot( time, this, TQ_SLOT( requestBuddyIcon() ) );
 			}
 		}
 	}
@@ -237,7 +237,7 @@ void ICQContact::loggedIn()
 		m_requestingNickname = true;
 		int time = ( TDEApplication::random() % 20 ) * 1000;
 		kdDebug(OSCAR_ICQ_DEBUG) << k_funcinfo << "updating nickname in " << time/1000 << " seconds" << endl;
-		TQTimer::singleShot( time, this, TQT_SLOT( requestShortInfo() ) );
+		TQTimer::singleShot( time, this, TQ_SLOT( requestShortInfo() ) );
 	}
 
 }
@@ -298,7 +298,7 @@ void ICQContact::slotGotAuthRequest( const TQString& contact, const TQString& re
 
 	ICQAuthReplyDialog *replyDialog = new ICQAuthReplyDialog();
 
-	connect( replyDialog, TQT_SIGNAL( okClicked() ), this, TQT_SLOT( slotAuthReplyDialogOkClicked() ) );
+	connect( replyDialog, TQ_SIGNAL( okClicked() ), this, TQ_SLOT( slotAuthReplyDialogOkClicked() ) );
 	replyDialog->setUser( property( Kopete::Global::Properties::self()->nickName() ).value().toString() );
 	replyDialog->setRequestReason( reason );
 	replyDialog->setModal( TRUE );
@@ -685,12 +685,12 @@ TQPtrList<TDEAction> *ICQContact::customContextMenuActions()
 	if(actionReadAwayMessage==0)
 	{
 		actionReadAwayMessage = new TDEAction(awTxt, awIcn, 0,
-			this, TQT_SLOT(slotReadAwayMessage()), this, "actionReadAwayMessage");
+			this, TQ_SLOT(slotReadAwayMessage()), this, "actionReadAwayMessage");
 		*/
 		actionRequestAuth = new TDEAction(i18n("&Request Authorization"), "mail-reply-sender", 0,
-			this, TQT_SLOT(slotRequestAuth()), this, "actionRequestAuth");
+			this, TQ_SLOT(slotRequestAuth()), this, "actionRequestAuth");
 		actionSendAuth = new TDEAction(i18n("&Grant Authorization"), "mail-forward", 0,
-			this, TQT_SLOT(slotSendAuth()), this, "actionSendAuth");
+			this, TQ_SLOT(slotSendAuth()), this, "actionSendAuth");
 		/*
 	}
 	else
@@ -701,11 +701,11 @@ TQPtrList<TDEAction> *ICQContact::customContextMenuActions()
 
 */
 	m_actionIgnore = new TDEToggleAction(i18n("&Ignore"), "", 0,
-	                                   this, TQT_SLOT(slotIgnore()), this, "actionIgnore");
+	                                   this, TQ_SLOT(slotIgnore()), this, "actionIgnore");
 	m_actionVisibleTo = new TDEToggleAction(i18n("Always &Visible To"), "", 0,
-	                                      this, TQT_SLOT(slotVisibleTo()), this, "actionVisibleTo");
+	                                      this, TQ_SLOT(slotVisibleTo()), this, "actionVisibleTo");
 	m_actionInvisibleTo = new TDEToggleAction(i18n("Always &Invisible To"), "", 0,
-	                                        this, TQT_SLOT(slotInvisibleTo()), this, "actionInvisibleTo");
+	                                        this, TQ_SLOT(slotInvisibleTo()), this, "actionInvisibleTo");
 
 	bool on = account()->isConnected();
 	if ( m_ssiItem.waitingAuth() )
@@ -717,7 +717,7 @@ TQPtrList<TDEAction> *ICQContact::customContextMenuActions()
 
 
     m_selectEncoding = new TDEAction( i18n( "Select Encoding..." ), "charset", 0,
-                                    this, TQT_SLOT( changeContactEncoding() ), this, "changeEncoding" );
+                                    this, TQ_SLOT( changeContactEncoding() ), this, "changeEncoding" );
 
 /*
 	actionReadAwayMessage->setEnabled(status != OSCAR_OFFLINE && status != OSCAR_ONLINE);
@@ -748,7 +748,7 @@ TQPtrList<TDEAction> *ICQContact::customContextMenuActions()
 void ICQContact::slotUserInfo()
 {
 	m_infoWidget = new ICQUserInfoWidget( Kopete::UI::Global::mainWidget(), "icq info" );
-	TQObject::connect( m_infoWidget, TQT_SIGNAL( finished() ), this, TQT_SLOT( closeUserInfoDialog() ) );
+	TQObject::connect( m_infoWidget, TQ_SIGNAL( finished() ), this, TQ_SLOT( closeUserInfoDialog() ) );
 	m_infoWidget->setContact( this );
 	m_infoWidget->show();
 	if ( account()->isConnected() )
@@ -768,8 +768,8 @@ void ICQContact::changeContactEncoding()
         return;
 
     m_oesd = new OscarEncodingSelectionDialog( Kopete::UI::Global::mainWidget(), property(mProtocol->contactEncoding).value().toInt() );
-    connect( m_oesd, TQT_SIGNAL( closing( int ) ),
-             this, TQT_SLOT( changeEncodingDialogClosed( int ) ) );
+    connect( m_oesd, TQ_SIGNAL( closing( int ) ),
+             this, TQ_SLOT( changeEncodingDialogClosed( int ) ) );
     m_oesd->show();
 }
 
@@ -827,7 +827,7 @@ void ICQContact::slotReadAwayMessage()
 		awayMessageDialog = new ICQReadAway(this, 0L, "awayMessageDialog");
 		if(!awayMessageDialog)
 			return;
-		TQObject::connect(awayMessageDialog, TQT_SIGNAL(closing()), this, TQT_SLOT(slotCloseAwayMessageDialog()));
+		TQObject::connect(awayMessageDialog, TQ_SIGNAL(closing()), this, TQ_SLOT(slotCloseAwayMessageDialog()));
 		awayMessageDialog->show();
 	}
 	else
diff --git a/kopete/protocols/oscar/icq/icqreadaway.cpp b/kopete/protocols/oscar/icq/icqreadaway.cpp
index 8686c8d8..361e13d2 100644
--- a/kopete/protocols/oscar/icq/icqreadaway.cpp
+++ b/kopete/protocols/oscar/icq/icqreadaway.cpp
@@ -47,19 +47,19 @@ ICQReadAway::ICQReadAway(ICQContact *c, TQWidget *parent, const char* name)
 	awayMessageBrowser->setText(mContact->awayMessage());
 
 	TQObject::connect(
-		awayMessageBrowser, TQT_SIGNAL(urlClick(const TQString&)),
-		this, TQT_SLOT(slotUrlClicked(const TQString&)));
+		awayMessageBrowser, TQ_SIGNAL(urlClick(const TQString&)),
+		this, TQ_SLOT(slotUrlClicked(const TQString&)));
 	TQObject::connect(
-		awayMessageBrowser, TQT_SIGNAL(mailClick(const TQString&, const TQString&)),
-		this, TQT_SLOT(slotMailClicked(const TQString&, const TQString&)));
+		awayMessageBrowser, TQ_SIGNAL(mailClick(const TQString&, const TQString&)),
+		this, TQ_SLOT(slotMailClicked(const TQString&, const TQString&)));
 
-	connect(this, TQT_SIGNAL(user1Clicked()),
-		this, TQT_SLOT(slotFetchAwayMessage()));
-	connect(this, TQT_SIGNAL(closeClicked()),
-		this, TQT_SLOT(slotCloseClicked()));
+	connect(this, TQ_SIGNAL(user1Clicked()),
+		this, TQ_SLOT(slotFetchAwayMessage()));
+	connect(this, TQ_SIGNAL(closeClicked()),
+		this, TQ_SLOT(slotCloseClicked()));
 
-	connect(c, TQT_SIGNAL(awayMessageChanged()),
-		this, TQT_SLOT(slotAwayMessageChanged()));
+	connect(c, TQ_SIGNAL(awayMessageChanged()),
+		this, TQ_SLOT(slotAwayMessageChanged()));
 
 	slotFetchAwayMessage();
 }
diff --git a/kopete/protocols/oscar/icq/ui/icqaddcontactpage.cpp b/kopete/protocols/oscar/icq/ui/icqaddcontactpage.cpp
index 687de1b2..022b99a5 100644
--- a/kopete/protocols/oscar/icq/ui/icqaddcontactpage.cpp
+++ b/kopete/protocols/oscar/icq/ui/icqaddcontactpage.cpp
@@ -48,7 +48,7 @@ ICQAddContactPage::ICQAddContactPage(ICQAccount *owner, TQWidget *parent, const
 
 	(new TQVBoxLayout(this))->setAutoAdd(true);
 	addUI = new icqAddUI(this);
-	connect( addUI->searchButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( showSearchDialog() ) );
+	connect( addUI->searchButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( showSearchDialog() ) );
 }
 
 ICQAddContactPage::~ICQAddContactPage()
@@ -109,7 +109,7 @@ void ICQAddContactPage::showSearchDialog()
 	{
 		m_searchDialog = new ICQSearchDialog( mAccount, this, "icqSearchDialog" );
 		m_searchDialog->show();
-		connect( m_searchDialog, TQT_SIGNAL( finished() ), this, TQT_SLOT( searchDialogDestroyed() ) );
+		connect( m_searchDialog, TQ_SIGNAL( finished() ), this, TQ_SLOT( searchDialogDestroyed() ) );
 	}
 }
 
diff --git a/kopete/protocols/oscar/icq/ui/icqeditaccountwidget.cpp b/kopete/protocols/oscar/icq/ui/icqeditaccountwidget.cpp
index e3b40b3b..17865d36 100644
--- a/kopete/protocols/oscar/icq/ui/icqeditaccountwidget.cpp
+++ b/kopete/protocols/oscar/icq/ui/icqeditaccountwidget.cpp
@@ -99,7 +99,7 @@ ICQEditAccountWidget::ICQEditAccountWidget(ICQProtocol *protocol,
 		                              4 );
 	}
 
-	TQObject::connect(mAccountSettings->buttonRegister, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotOpenRegister()));
+	TQObject::connect(mAccountSettings->buttonRegister, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotOpenRegister()));
 
 	/* Set tab order to password custom widget correctly */
 	TQWidget::setTabOrder( mAccountSettings->edtAccountId, mAccountSettings->mPasswordWidget->mRemembered );
diff --git a/kopete/protocols/oscar/icq/ui/icqsearchdialog.cpp b/kopete/protocols/oscar/icq/ui/icqsearchdialog.cpp
index 9a212447..ec1e7e55 100644
--- a/kopete/protocols/oscar/icq/ui/icqsearchdialog.cpp
+++ b/kopete/protocols/oscar/icq/ui/icqsearchdialog.cpp
@@ -47,14 +47,14 @@ ICQSearchDialog::ICQSearchDialog( ICQAccount* account, TQWidget* parent, const c
 	m_account = account;
 	m_searchUI = new ICQSearchBase( this, name );
 	setMainWidget( m_searchUI );
-	connect( m_searchUI->searchButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( startSearch() ) );
-	connect( m_searchUI->searchResults, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( resultSelectionChanged() ) );
-	connect( m_searchUI->addButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( addContact() ) );
-	connect( m_searchUI->clearButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( clearResults() ) );
-	connect( m_searchUI->stopButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( stopSearch() ) );
-	connect( m_searchUI->closeButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( closeDialog() ) );
-	connect( m_searchUI->userInfoButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( userInfo() ) );
-	connect( m_searchUI->newSearchButton, TQT_SIGNAL( clicked() ), this, TQT_SLOT( newSearch() ) );
+	connect( m_searchUI->searchButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( startSearch() ) );
+	connect( m_searchUI->searchResults, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( resultSelectionChanged() ) );
+	connect( m_searchUI->addButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( addContact() ) );
+	connect( m_searchUI->clearButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( clearResults() ) );
+	connect( m_searchUI->stopButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( stopSearch() ) );
+	connect( m_searchUI->closeButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( closeDialog() ) );
+	connect( m_searchUI->userInfoButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( userInfo() ) );
+	connect( m_searchUI->newSearchButton, TQ_SIGNAL( clicked() ), this, TQ_SLOT( newSearch() ) );
 	
 	ICQProtocol *p = ICQProtocol::protocol();
 	p->fillComboFromTable( m_searchUI->gender, p->genders() );
@@ -91,10 +91,10 @@ void ICQSearchDialog::startSearch()
 		m_searchUI->searchButton->setEnabled( false );
 		m_searchUI->newSearchButton->setEnabled( false );
 	
-		connect( m_account->engine(), TQT_SIGNAL( gotSearchResults( const ICQSearchResult& ) ),
-				this, TQT_SLOT( newResult( const ICQSearchResult& ) ) );
-		connect( m_account->engine(), TQT_SIGNAL( endOfSearch( int ) ),
-				this, TQT_SLOT( searchFinished( int ) ) );
+		connect( m_account->engine(), TQ_SIGNAL( gotSearchResults( const ICQSearchResult& ) ),
+				this, TQ_SLOT( newResult( const ICQSearchResult& ) ) );
+		connect( m_account->engine(), TQ_SIGNAL( endOfSearch( int ) ),
+				this, TQ_SLOT( searchFinished( int ) ) );
 
 		const TQWidget* currentPage = m_searchUI->tabWidget3->currentPage();
 
@@ -159,10 +159,10 @@ void ICQSearchDialog::startSearch()
 
 void ICQSearchDialog::stopSearch()
 {
-	disconnect( m_account->engine(), TQT_SIGNAL( gotSearchResults( const ICQSearchResult& ) ),
-	         this, TQT_SLOT( newResult( const ICQSearchResult& ) ) );
-	disconnect( m_account->engine(), TQT_SIGNAL( endOfSearch( int ) ),
-	         this, TQT_SLOT( searchFinished( int ) ) );
+	disconnect( m_account->engine(), TQ_SIGNAL( gotSearchResults( const ICQSearchResult& ) ),
+	         this, TQ_SLOT( newResult( const ICQSearchResult& ) ) );
+	disconnect( m_account->engine(), TQ_SIGNAL( endOfSearch( int ) ),
+	         this, TQ_SLOT( searchFinished( int ) ) );
 
 	m_searchUI->stopButton->setEnabled( false );
 	m_searchUI->searchButton->setEnabled( true );
@@ -203,7 +203,7 @@ void ICQSearchDialog::userInfo()
 									NULL);
 	
 		m_infoWidget = new ICQUserInfoWidget( Kopete::UI::Global::mainWidget(), "icq info" );
-		TQObject::connect( m_infoWidget, TQT_SIGNAL( finished() ), this, TQT_SLOT( closeUserInfo() ) );
+		TQObject::connect( m_infoWidget, TQ_SIGNAL( finished() ), this, TQ_SLOT( closeUserInfo() ) );
 	
 		m_infoWidget->setContact( m_contact );
 		m_infoWidget->setModal(true);
diff --git a/kopete/protocols/oscar/icq/ui/icquserinfowidget.cpp b/kopete/protocols/oscar/icq/ui/icquserinfowidget.cpp
index 4126a3ec..aa793b62 100644
--- a/kopete/protocols/oscar/icq/ui/icquserinfowidget.cpp
+++ b/kopete/protocols/oscar/icq/ui/icquserinfowidget.cpp
@@ -78,16 +78,16 @@ ICQUserInfoWidget::ICQUserInfoWidget( TQWidget * parent, const char * name )
 void ICQUserInfoWidget::setContact( ICQContact* contact )
 {
 	m_contact = contact;
-	TQObject::connect( contact, TQT_SIGNAL( haveBasicInfo( const ICQGeneralUserInfo& ) ),
-	                  this, TQT_SLOT( fillBasicInfo( const ICQGeneralUserInfo& ) ) );
-	TQObject::connect( contact, TQT_SIGNAL( haveWorkInfo( const ICQWorkUserInfo& ) ),
-	                  this, TQT_SLOT( fillWorkInfo( const ICQWorkUserInfo& ) ) );
-	TQObject::connect( contact, TQT_SIGNAL( haveEmailInfo( const ICQEmailInfo& ) ),
-	                  this, TQT_SLOT( fillEmailInfo( const ICQEmailInfo& ) ) );
-	TQObject::connect( contact, TQT_SIGNAL( haveMoreInfo( const ICQMoreUserInfo& ) ),
-	                  this, TQT_SLOT( fillMoreInfo( const ICQMoreUserInfo& ) ) );
-	TQObject::connect( contact, TQT_SIGNAL( haveInterestInfo( const ICQInterestInfo& ) ),
-	                  this, TQT_SLOT( fillInterestInfo( const ICQInterestInfo& ) ) );
+	TQObject::connect( contact, TQ_SIGNAL( haveBasicInfo( const ICQGeneralUserInfo& ) ),
+	                  this, TQ_SLOT( fillBasicInfo( const ICQGeneralUserInfo& ) ) );
+	TQObject::connect( contact, TQ_SIGNAL( haveWorkInfo( const ICQWorkUserInfo& ) ),
+	                  this, TQ_SLOT( fillWorkInfo( const ICQWorkUserInfo& ) ) );
+	TQObject::connect( contact, TQ_SIGNAL( haveEmailInfo( const ICQEmailInfo& ) ),
+	                  this, TQ_SLOT( fillEmailInfo( const ICQEmailInfo& ) ) );
+	TQObject::connect( contact, TQ_SIGNAL( haveMoreInfo( const ICQMoreUserInfo& ) ),
+	                  this, TQ_SLOT( fillMoreInfo( const ICQMoreUserInfo& ) ) );
+	TQObject::connect( contact, TQ_SIGNAL( haveInterestInfo( const ICQInterestInfo& ) ),
+	                  this, TQ_SLOT( fillInterestInfo( const ICQInterestInfo& ) ) );
 }
 
 void ICQUserInfoWidget::fillBasicInfo( const ICQGeneralUserInfo& ui )
diff --git a/kopete/protocols/oscar/liboscar/aimlogintask.cpp b/kopete/protocols/oscar/liboscar/aimlogintask.cpp
index 1f7ff117..d8712416 100644
--- a/kopete/protocols/oscar/liboscar/aimlogintask.cpp
+++ b/kopete/protocols/oscar/liboscar/aimlogintask.cpp
@@ -43,7 +43,7 @@ void AimLoginTask::onGo()
 	//send Snac 17,06
 	sendAuthStringRequest();
 	//when we have the authKey, login
-	connect( this, TQT_SIGNAL( haveAuthKey() ), this, TQT_SLOT( sendLoginRequest() ) );
+	connect( this, TQ_SIGNAL( haveAuthKey() ), this, TQ_SLOT( sendLoginRequest() ) );
 }
 
 bool AimLoginTask::forMe( Transfer* transfer ) const
diff --git a/kopete/protocols/oscar/liboscar/client.cpp b/kopete/protocols/oscar/liboscar/client.cpp
index 10fec375..5f487058 100644
--- a/kopete/protocols/oscar/liboscar/client.cpp
+++ b/kopete/protocols/oscar/liboscar/client.cpp
@@ -165,10 +165,10 @@ Client::Client( TQObject* parent )
 	d->awayMsgRequestTimer = new TQTimer();
 	d->codecProvider = &defaultCodecProvider;
 
-	connect( this, TQT_SIGNAL( redirectionFinished( WORD ) ),
-	         this, TQT_SLOT( checkRedirectionQueue( WORD ) ) );
-	connect( d->awayMsgRequestTimer, TQT_SIGNAL( timeout() ),
-	         this, TQT_SLOT( nextICQAwayMessageRequest() ) );
+	connect( this, TQ_SIGNAL( redirectionFinished( WORD ) ),
+	         this, TQ_SLOT( checkRedirectionQueue( WORD ) ) );
+	connect( d->awayMsgRequestTimer, TQ_SIGNAL( timeout() ),
+	         this, TQ_SLOT( nextICQAwayMessageRequest() ) );
 }
 
 Client::~Client()
@@ -194,10 +194,10 @@ void Client::connectToServer( Connection *c, const TQString& server, bool auth )
 	if ( auth == true )
 	{
 		m_loginTask = new StageOneLoginTask( c->rootTask() );
-		connect( m_loginTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( lt_loginFinished() ) );
+		connect( m_loginTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( lt_loginFinished() ) );
 	}
 
-	connect( c, TQT_SIGNAL( socketError( int, const TQString& ) ), this, TQT_SLOT( determineDisconnection( int, const TQString& ) ) );
+	connect( c, TQ_SIGNAL( socketError( int, const TQString& ) ), this, TQ_SLOT( determineDisconnection( int, const TQString& ) ) );
 	c->connectToServer(server, auth);
 }
 
@@ -343,7 +343,7 @@ void Client::lt_loginFinished()
 		kdDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "stage two done. setting up services" << endl;
 		initializeStaticTasks();
 		ServiceSetupTask* ssTask = new ServiceSetupTask( d->connections.defaultConnection()->rootTask() );
-		connect( ssTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( serviceSetupFinished() ) );
+		connect( ssTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( serviceSetupFinished() ) );
 		ssTask->go( true ); //fire and forget
 		m_loginTaskTwo->deleteLater();
 		m_loginTaskTwo = 0;
@@ -351,7 +351,7 @@ void Client::lt_loginFinished()
 	else if ( d->stage == ClientPrivate::StageOne )
 	{
 		kdDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "stage one login done" << endl;
-		disconnect( m_loginTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( lt_loginFinished() ) );
+		disconnect( m_loginTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( lt_loginFinished() ) );
 
 		if ( m_loginTask->statusCode() == 0 ) //we can start stage two
 		{
@@ -362,7 +362,7 @@ void Client::lt_loginFinished()
 			d->port = m_loginTask->bosPort().toUInt();
 			d->cookie = m_loginTask->loginCookie();
 			close();
-			TQTimer::singleShot( 100, this, TQT_SLOT(startStageTwo() ) );
+			TQTimer::singleShot( 100, this, TQ_SLOT(startStageTwo() ) );
 		}
 		else
 		{
@@ -385,11 +385,11 @@ void Client::startStageTwo()
 	//create the new login task
 	m_loginTaskTwo = new StageTwoLoginTask( c->rootTask() );
 	m_loginTaskTwo->setCookie( d->cookie );
-	TQObject::connect( m_loginTaskTwo, TQT_SIGNAL( finished() ), this, TQT_SLOT( lt_loginFinished() ) );
+	TQObject::connect( m_loginTaskTwo, TQ_SIGNAL( finished() ), this, TQ_SLOT( lt_loginFinished() ) );
 
 
 	//connect
-	TQObject::connect( c, TQT_SIGNAL( connected() ), this, TQT_SLOT( streamConnected() ) );
+	TQObject::connect( c, TQ_SIGNAL( connected() ), this, TQ_SLOT( streamConnected() ) );
 	connectToServer( c, d->host, false ) ;
 
 }
@@ -412,8 +412,8 @@ void Client::serviceSetupFinished()
 		}
 
 		OfflineMessagesTask *offlineMsgTask = new OfflineMessagesTask( c->rootTask() );
-		connect( offlineMsgTask, TQT_SIGNAL( receivedOfflineMessage(const Oscar::Message& ) ),
-				this, TQT_SIGNAL( messageReceived(const Oscar::Message& ) ) );
+		connect( offlineMsgTask, TQ_SIGNAL( receivedOfflineMessage(const Oscar::Message& ) ),
+				this, TQ_SIGNAL( messageReceived(const Oscar::Message& ) ) );
 		offlineMsgTask->go( true );
 	}
 
@@ -628,34 +628,34 @@ void Client::initializeStaticTasks()
 	d->typingNotifyTask = new TypingNotifyTask( c->rootTask() );
 	d->ssiModifyTask = new SSIModifyTask( c->rootTask(), true );
 
-	connect( d->onlineNotifier, TQT_SIGNAL( userIsOnline( const TQString&, const UserDetails& ) ),
-	         this, TQT_SIGNAL( receivedUserInfo( const TQString&, const UserDetails& ) ) );
-	connect( d->onlineNotifier, TQT_SIGNAL( userIsOffline( const TQString&, const UserDetails& ) ),
-	         this, TQT_SLOT( offlineUser( const TQString&, const UserDetails & ) ) );
+	connect( d->onlineNotifier, TQ_SIGNAL( userIsOnline( const TQString&, const UserDetails& ) ),
+	         this, TQ_SIGNAL( receivedUserInfo( const TQString&, const UserDetails& ) ) );
+	connect( d->onlineNotifier, TQ_SIGNAL( userIsOffline( const TQString&, const UserDetails& ) ),
+	         this, TQ_SLOT( offlineUser( const TQString&, const UserDetails & ) ) );
 
-	connect( d->ownStatusTask, TQT_SIGNAL( gotInfo() ), this, TQT_SLOT( haveOwnUserInfo() ) );
-	connect( d->ownStatusTask, TQT_SIGNAL( buddyIconUploadRequested() ), this,
-	         TQT_SIGNAL( iconNeedsUploading() ) );
+	connect( d->ownStatusTask, TQ_SIGNAL( gotInfo() ), this, TQ_SLOT( haveOwnUserInfo() ) );
+	connect( d->ownStatusTask, TQ_SIGNAL( buddyIconUploadRequested() ), this,
+	         TQ_SIGNAL( iconNeedsUploading() ) );
 
-	connect( d->messageReceiverTask, TQT_SIGNAL( receivedMessage( const Oscar::Message& ) ),
-	         this, TQT_SLOT( receivedMessage( const Oscar::Message& ) ) );
+	connect( d->messageReceiverTask, TQ_SIGNAL( receivedMessage( const Oscar::Message& ) ),
+	         this, TQ_SLOT( receivedMessage( const Oscar::Message& ) ) );
 
-	connect( d->ssiAuthTask, TQT_SIGNAL( authRequested( const TQString&, const TQString& ) ),
-	         this, TQT_SIGNAL( authRequestReceived( const TQString&, const TQString& ) ) );
-	connect( d->ssiAuthTask, TQT_SIGNAL( authReplied( const TQString&, const TQString&, bool ) ),
-	         this, TQT_SIGNAL( authReplyReceived( const TQString&, const TQString&, bool ) ) );
+	connect( d->ssiAuthTask, TQ_SIGNAL( authRequested( const TQString&, const TQString& ) ),
+	         this, TQ_SIGNAL( authRequestReceived( const TQString&, const TQString& ) ) );
+	connect( d->ssiAuthTask, TQ_SIGNAL( authReplied( const TQString&, const TQString&, bool ) ),
+	         this, TQ_SIGNAL( authReplyReceived( const TQString&, const TQString&, bool ) ) );
 
-	connect( d->icqInfoTask, TQT_SIGNAL( receivedInfoFor( const TQString&, unsigned int ) ),
-	         this, TQT_SLOT( receivedIcqInfo( const TQString&, unsigned int ) ) );
+	connect( d->icqInfoTask, TQ_SIGNAL( receivedInfoFor( const TQString&, unsigned int ) ),
+	         this, TQ_SLOT( receivedIcqInfo( const TQString&, unsigned int ) ) );
 
-	connect( d->userInfoTask, TQT_SIGNAL( receivedProfile( const TQString&, const TQString& ) ),
-	         this, TQT_SIGNAL( receivedProfile( const TQString&, const TQString& ) ) );
-	connect( d->userInfoTask, TQT_SIGNAL( receivedAwayMessage( const TQString&, const TQString& ) ),
-	         this, TQT_SIGNAL( receivedAwayMessage( const TQString&, const TQString& ) ) );
-	connect( d->typingNotifyTask, TQT_SIGNAL( typingStarted( const TQString& ) ),
-	         this, TQT_SIGNAL( userStartedTyping( const TQString& ) ) );
-	connect( d->typingNotifyTask, TQT_SIGNAL( typingFinished( const TQString& ) ),
-	         this, TQT_SIGNAL( userStoppedTyping( const TQString& ) ) );
+	connect( d->userInfoTask, TQ_SIGNAL( receivedProfile( const TQString&, const TQString& ) ),
+	         this, TQ_SIGNAL( receivedProfile( const TQString&, const TQString& ) ) );
+	connect( d->userInfoTask, TQ_SIGNAL( receivedAwayMessage( const TQString&, const TQString& ) ),
+	         this, TQ_SIGNAL( receivedAwayMessage( const TQString&, const TQString& ) ) );
+	connect( d->typingNotifyTask, TQ_SIGNAL( typingStarted( const TQString& ) ),
+	         this, TQ_SIGNAL( userStartedTyping( const TQString& ) ) );
+	connect( d->typingNotifyTask, TQ_SIGNAL( typingFinished( const TQString& ) ),
+	         this, TQ_SIGNAL( userStoppedTyping( const TQString& ) ) );
 }
 
 void Client::removeGroup( const TQString& groupName )
@@ -808,8 +808,8 @@ void Client::sendWarning( const TQString& contact, bool anonymous )
 	WarningTask* warnTask = new WarningTask( c->rootTask() );
 	warnTask->setContact( contact );
 	warnTask->setAnonymous( anonymous );
-	TQObject::connect( warnTask, TQT_SIGNAL( userWarned( const TQString&, TQ_UINT16, TQ_UINT16 ) ),
-	                  this, TQT_SIGNAL( userWarned( const TQString&, TQ_UINT16, TQ_UINT16 ) ) );
+	TQObject::connect( warnTask, TQ_SIGNAL( userWarned( const TQString&, TQ_UINT16, TQ_UINT16 ) ),
+	                  this, TQ_SIGNAL( userWarned( const TQString&, TQ_UINT16, TQ_UINT16 ) ) );
 	warnTask->go( true );
 }
 
@@ -974,9 +974,9 @@ void Client::whitePagesSearch( const ICQWPSearchInfo& info )
 	if ( !c )
 		return;
 	UserSearchTask* ust = new UserSearchTask( c->rootTask() );
-	connect( ust, TQT_SIGNAL( foundUser( const ICQSearchResult& ) ),
-	         this, TQT_SIGNAL( gotSearchResults( const ICQSearchResult& ) ) );
-	connect( ust, TQT_SIGNAL( searchFinished( int ) ), this, TQT_SIGNAL( endOfSearch( int ) ) );
+	connect( ust, TQ_SIGNAL( foundUser( const ICQSearchResult& ) ),
+	         this, TQ_SIGNAL( gotSearchResults( const ICQSearchResult& ) ) );
+	connect( ust, TQ_SIGNAL( searchFinished( int ) ), this, TQ_SIGNAL( endOfSearch( int ) ) );
 	ust->go( true ); //onGo does nothing in this task. This is just here so autodelete works
 	ust->searchWhitePages( info );
 }
@@ -987,9 +987,9 @@ void Client::uinSearch( const TQString& uin )
 	if ( !c )
 		return;
 	UserSearchTask* ust = new UserSearchTask( c->rootTask() );
-	connect( ust, TQT_SIGNAL( foundUser( const ICQSearchResult& ) ),
-	         this, TQT_SIGNAL( gotSearchResults( const ICQSearchResult& ) ) );
-	connect( ust, TQT_SIGNAL( searchFinished( int ) ), this, TQT_SIGNAL( endOfSearch( int ) ) );
+	connect( ust, TQ_SIGNAL( foundUser( const ICQSearchResult& ) ),
+	         this, TQ_SIGNAL( gotSearchResults( const ICQSearchResult& ) ) );
+	connect( ust, TQ_SIGNAL( searchFinished( int ) ), this, TQ_SIGNAL( endOfSearch( int ) ) );
 	ust->go( true ); //onGo does nothing in this task. This is just here so autodelete works
 	ust->searchUserByUIN( uin );
 }
@@ -1079,8 +1079,8 @@ void Client::requestBuddyIcon( const TQString& user, const TQByteArray& hash, BY
 		return;
 
 	BuddyIconTask* bit = new BuddyIconTask( c->rootTask() );
-	connect( bit, TQT_SIGNAL( haveIcon( const TQString&, TQByteArray ) ),
-	         this, TQT_SIGNAL( haveIconForContact( const TQString&, TQByteArray ) ) );
+	connect( bit, TQ_SIGNAL( haveIcon( const TQString&, TQByteArray ) ),
+	         this, TQ_SIGNAL( haveIconForContact( const TQString&, TQByteArray ) ) );
 	bit->requestIconFor( user );
 	bit->setHashType( hashType );
 	bit->setHash( hash );
@@ -1118,8 +1118,8 @@ void Client::requestServerRedirect( WORD family, WORD exchange,
         srt->setChatRoom( room );
     }
 
-	connect( srt, TQT_SIGNAL( haveServer( const TQString&, const TQByteArray&, WORD ) ),
-	         this, TQT_SLOT( haveServerForRedirect( const TQString&, const TQByteArray&, WORD ) ) );
+	connect( srt, TQ_SIGNAL( haveServer( const TQString&, const TQByteArray&, WORD ) ),
+	         this, TQ_SLOT( haveServerForRedirect( const TQString&, const TQByteArray&, WORD ) ) );
 	srt->setService( family );
 	srt->go( true );
 }
@@ -1147,11 +1147,11 @@ void Client::haveServerForRedirect( const TQString& host, const TQByteArray& coo
 	//create the new login task
 	m_loginTaskTwo = new StageTwoLoginTask( c->rootTask() );
 	m_loginTaskTwo->setCookie( cookie );
-	TQObject::connect( m_loginTaskTwo, TQT_SIGNAL( finished() ), this, TQT_SLOT( serverRedirectFinished() ) );
+	TQObject::connect( m_loginTaskTwo, TQ_SIGNAL( finished() ), this, TQ_SLOT( serverRedirectFinished() ) );
 
 	//connect
 	connectToServer( c, d->host, false );
-  	TQObject::connect( c, TQT_SIGNAL( connected() ), this, TQT_SLOT( streamConnected() ) );
+  	TQObject::connect( c, TQ_SIGNAL( connected() ), this, TQ_SLOT( streamConnected() ) );
 
     if ( srt )
         d->connections.addChatInfoForConnection( c, srt->chatExchange(), srt->chatRoomName() );
@@ -1177,8 +1177,8 @@ void Client::serverRedirectFinished()
 
 	if ( d->currentRedirect == 0x000D )
 	{
-		connect( this, TQT_SIGNAL( chatNavigationConnected() ),
-				 this, TQT_SLOT( requestChatNavLimits() ) );
+		connect( this, TQ_SIGNAL( chatNavigationConnected() ),
+				 this, TQ_SLOT( requestChatNavLimits() ) );
 		emit chatNavigationConnected();
 	}
 
@@ -1199,12 +1199,12 @@ void Client::serverRedirectFinished()
         {
             kdDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "setting up chat connection" << endl;
             ChatServiceTask* cst = new ChatServiceTask( c->rootTask(), exchange, roomName );
-            connect( cst, TQT_SIGNAL( userJoinedChat( Oscar::WORD, const TQString&, const TQString& ) ),
-                     this, TQT_SIGNAL( userJoinedChat( Oscar::WORD, const TQString&, const TQString& ) ) );
-            connect( cst, TQT_SIGNAL( userLeftChat( Oscar::WORD, const TQString&, const TQString& ) ),
-                     this, TQT_SIGNAL( userLeftChat( Oscar::WORD, const TQString&, const TQString& ) ) );
-            connect( cst, TQT_SIGNAL( newChatMessage( const Oscar::Message& ) ),
-                     this, TQT_SIGNAL( messageReceived( const Oscar::Message& ) ) );
+            connect( cst, TQ_SIGNAL( userJoinedChat( Oscar::WORD, const TQString&, const TQString& ) ),
+                     this, TQ_SIGNAL( userJoinedChat( Oscar::WORD, const TQString&, const TQString& ) ) );
+            connect( cst, TQ_SIGNAL( userLeftChat( Oscar::WORD, const TQString&, const TQString& ) ),
+                     this, TQ_SIGNAL( userLeftChat( Oscar::WORD, const TQString&, const TQString& ) ) );
+            connect( cst, TQ_SIGNAL( newChatMessage( const Oscar::Message& ) ),
+                     this, TQ_SIGNAL( messageReceived( const Oscar::Message& ) ) );
         }
         emit chatRoomConnected( exchange, roomName );
     }
@@ -1235,8 +1235,8 @@ void Client::requestChatNavLimits()
 	kdDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "requesting chat nav service limits" << endl;
 	ChatNavServiceTask* cnst = new ChatNavServiceTask( c->rootTask() );
     cnst->setRequestType( ChatNavServiceTask::Limits );
-    TQObject::connect( cnst, TQT_SIGNAL( haveChatExchanges( const TQValueList<int>& ) ),
-                      this, TQT_SLOT( setChatExchangeList( const TQValueList<int>& ) ) );
+    TQObject::connect( cnst, TQ_SIGNAL( haveChatExchanges( const TQValueList<int>& ) ),
+                      this, TQ_SLOT( setChatExchangeList( const TQValueList<int>& ) ) );
 	cnst->go( true ); //autodelete
 
 }
@@ -1283,8 +1283,8 @@ void Client::joinChatRoom( const TQString& roomName, int exchange )
     kdDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "joining the chat room '" << roomName
                              << "' on exchange " << exchange << endl;
     ChatNavServiceTask* cnst = new ChatNavServiceTask( c->rootTask() );
-    connect( cnst, TQT_SIGNAL( connectChat( WORD, TQByteArray, WORD, const TQString& ) ),
-             this, TQT_SLOT( setupChatConnection( WORD, TQByteArray, WORD, const TQString& ) ) );
+    connect( cnst, TQ_SIGNAL( connectChat( WORD, TQByteArray, WORD, const TQString& ) ),
+             this, TQ_SLOT( setupChatConnection( WORD, TQByteArray, WORD, const TQString& ) ) );
     cnst->createRoom( exchange, roomName );
 
 }
diff --git a/kopete/protocols/oscar/liboscar/connection.cpp b/kopete/protocols/oscar/liboscar/connection.cpp
index 1cdebe01..fbfa65d9 100644
--- a/kopete/protocols/oscar/liboscar/connection.cpp
+++ b/kopete/protocols/oscar/liboscar/connection.cpp
@@ -77,14 +77,14 @@ Connection::~Connection()
 void Connection::setClient( Client* c )
 {
 	d->client = c;
-	connect( c, TQT_SIGNAL( loggedIn() ), this, TQT_SLOT( loggedIn() ) );
+	connect( c, TQ_SIGNAL( loggedIn() ), this, TQ_SLOT( loggedIn() ) );
 }
 
 void Connection::connectToServer( const TQString& host, bool auth )
 {
-	connect( d->clientStream, TQT_SIGNAL( error( int ) ), this, TQT_SLOT( streamSocketError( int ) ) );
-	connect( d->clientStream, TQT_SIGNAL( readyRead() ), this, TQT_SLOT( streamReadyRead() ) );
-	connect( d->clientStream, TQT_SIGNAL( connected() ), this, TQT_SIGNAL( connected() ) );
+	connect( d->clientStream, TQ_SIGNAL( error( int ) ), this, TQ_SLOT( streamSocketError( int ) ) );
+	connect( d->clientStream, TQ_SIGNAL( readyRead() ), this, TQ_SLOT( streamReadyRead() ) );
+	connect( d->clientStream, TQ_SIGNAL( connected() ), this, TQ_SIGNAL( connected() ) );
 	d->clientStream->connectToServer( host, auth );
 }
 
diff --git a/kopete/protocols/oscar/liboscar/logintask.cpp b/kopete/protocols/oscar/liboscar/logintask.cpp
index 91bb2434..2206d1a0 100644
--- a/kopete/protocols/oscar/liboscar/logintask.cpp
+++ b/kopete/protocols/oscar/liboscar/logintask.cpp
@@ -63,7 +63,7 @@ bool StageOneLoginTask::take( Transfer* transfer )
 			m_closeTask = new CloseConnectionTask( client()->rootTask() );
 			
 			//connect finished signal
-			connect( m_closeTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( closeTaskFinished() ) );
+			connect( m_closeTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( closeTaskFinished() ) );
 			m_icqTask->go( true );
 		}
 		else
@@ -80,7 +80,7 @@ bool StageOneLoginTask::take( Transfer* transfer )
 			send( ft );
 			
 			m_aimTask = new AimLoginTask( client()->rootTask() );
-			connect( m_aimTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( aimTaskFinished() ) );
+			connect( m_aimTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( aimTaskFinished() ) );
 			m_aimTask->go( true );
 		}
 		return true;
@@ -145,8 +145,8 @@ StageTwoLoginTask::StageTwoLoginTask( Task* parent )
 	m_versionTask = new ServerVersionsTask( rootTask );
 	m_rateTask = new RateInfoTask( rootTask );
 	
-	TQObject::connect( m_versionTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( versionTaskFinished() ) );
-	TQObject::connect( m_rateTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( rateTaskFinished() ) );
+	TQObject::connect( m_versionTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( versionTaskFinished() ) );
+	TQObject::connect( m_rateTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( rateTaskFinished() ) );
 }
 
 StageTwoLoginTask::~StageTwoLoginTask()
diff --git a/kopete/protocols/oscar/liboscar/oscarbytestream.cpp b/kopete/protocols/oscar/liboscar/oscarbytestream.cpp
index 22f55500..03fd80bc 100644
--- a/kopete/protocols/oscar/liboscar/oscarbytestream.cpp
+++ b/kopete/protocols/oscar/liboscar/oscarbytestream.cpp
@@ -38,11 +38,11 @@ KNetworkByteStream::KNetworkByteStream( TQObject *parent, const char */*name*/ )
 	mSocket->enableRead( true );
 
 	// connect signals and slots
-	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 ) ) );
+	TQObject::connect( mSocket, TQ_SIGNAL ( gotError ( int ) ), this, TQ_SLOT ( slotError ( int ) ) );
+	TQObject::connect( mSocket, TQ_SIGNAL ( connected ( const KResolverEntry& ) ), this, TQ_SLOT ( slotConnected () ) );
+	TQObject::connect( mSocket, TQ_SIGNAL ( closed () ), this, TQ_SLOT ( slotConnectionClosed () ) );
+	TQObject::connect( mSocket, TQ_SIGNAL ( readyRead () ), this, TQ_SLOT ( slotReadyRead () ) );
+	TQObject::connect( mSocket, TQ_SIGNAL ( bytesWritten ( int ) ), this, TQ_SLOT ( slotBytesWritten ( int ) ) );
 }
 
 bool KNetworkByteStream::connect( TQString host, TQString service )
diff --git a/kopete/protocols/oscar/liboscar/oscarclientstream.cpp b/kopete/protocols/oscar/liboscar/oscarclientstream.cpp
index 793608d6..59bfcc11 100644
--- a/kopete/protocols/oscar/liboscar/oscarclientstream.cpp
+++ b/kopete/protocols/oscar/liboscar/oscarclientstream.cpp
@@ -112,13 +112,13 @@ ClientStream::ClientStream(Connector *conn, TQObject *parent)
 	d = new Private;
 	d->mode = ClientMode;
 	d->conn = conn;
-	connect( d->conn, TQT_SIGNAL(connected()), TQT_SLOT(cr_connected()) );
-	connect( d->conn, TQT_SIGNAL(error()), TQT_SLOT(cr_error()) );
-	connect( &d->client, TQT_SIGNAL( outgoingData( const TQByteArray& ) ), TQT_SLOT ( cp_outgoingData( const TQByteArray & ) ) );
-	connect( &d->client, TQT_SIGNAL( incomingData() ), TQT_SLOT ( cp_incomingData() ) );
+	connect( d->conn, TQ_SIGNAL(connected()), TQ_SLOT(cr_connected()) );
+	connect( d->conn, TQ_SIGNAL(error()), TQ_SLOT(cr_error()) );
+	connect( &d->client, TQ_SIGNAL( outgoingData( const TQByteArray& ) ), TQ_SLOT ( cp_outgoingData( const TQByteArray & ) ) );
+	connect( &d->client, TQ_SIGNAL( incomingData() ), TQ_SLOT ( cp_incomingData() ) );
 
 	d->noop_time = 0;
-	connect(&d->noopTimer, TQT_SIGNAL(timeout()), TQT_SLOT(doNoop()));
+	connect(&d->noopTimer, TQ_SIGNAL(timeout()), TQ_SLOT(doNoop()));
 }
 
 ClientStream::~ClientStream()
@@ -329,11 +329,11 @@ void ClientStream::cp_incomingData()
 void ClientStream::cr_connected()
 {
 	d->bs = d->conn->stream();
-	connect(d->bs, TQT_SIGNAL(connectionClosed()), TQT_SLOT(bs_connectionClosed()));
-	connect(d->bs, TQT_SIGNAL(delayedCloseFinished()), TQT_SLOT(bs_delayedCloseFinished()));
-	connect(d->bs, 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)));
+	connect(d->bs, TQ_SIGNAL(connectionClosed()), TQ_SLOT(bs_connectionClosed()));
+	connect(d->bs, TQ_SIGNAL(delayedCloseFinished()), TQ_SLOT(bs_delayedCloseFinished()));
+	connect(d->bs, TQ_SIGNAL(readyRead()), TQ_SLOT(bs_readyRead()));
+	connect(d->bs, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(bs_bytesWritten(int)));
+	connect(d->bs, TQ_SIGNAL(error(int)), TQ_SLOT(bs_error(int)));
 
 	d->state = Active;
 	if ( d->noop_time )
@@ -408,7 +408,7 @@ void ClientStream::processNext()
 {
 	if( !d->in.isEmpty() ) 
 	{
-		TQTimer::singleShot(0, this, TQT_SLOT(doReadyRead()));
+		TQTimer::singleShot(0, this, TQ_SLOT(doReadyRead()));
 	}
 }
 
diff --git a/kopete/protocols/oscar/liboscar/oscarconnector.cpp b/kopete/protocols/oscar/liboscar/oscarconnector.cpp
index 7bbe38e5..10d54957 100644
--- a/kopete/protocols/oscar/liboscar/oscarconnector.cpp
+++ b/kopete/protocols/oscar/liboscar/oscarconnector.cpp
@@ -33,8 +33,8 @@ KNetworkConnector::KNetworkConnector( TQObject *parent, const char */*name*/ )
 
 	mByteStream = new KNetworkByteStream( this );
 
-	connect( mByteStream, TQT_SIGNAL ( connected () ), this, TQT_SLOT ( slotConnected () ) );
-	connect( mByteStream, TQT_SIGNAL ( error ( int ) ), this, TQT_SLOT ( slotError ( int ) ) );
+	connect( mByteStream, TQ_SIGNAL ( connected () ), this, TQ_SLOT ( slotConnected () ) );
+	connect( mByteStream, TQ_SIGNAL ( error ( int ) ), this, TQ_SLOT ( slotError ( int ) ) );
 	mPort = 0;
 }
 
diff --git a/kopete/protocols/oscar/liboscar/rateclass.cpp b/kopete/protocols/oscar/liboscar/rateclass.cpp
index 9f0a7601..66958a8a 100644
--- a/kopete/protocols/oscar/liboscar/rateclass.cpp
+++ b/kopete/protocols/oscar/liboscar/rateclass.cpp
@@ -194,7 +194,7 @@ void RateClass::setupTimer()
 		}
 		else
 		{
-			TQTimer::singleShot( ttns, this, TQT_SLOT( slotSend() ) ); //or send later
+			TQTimer::singleShot( ttns, this, TQ_SLOT( slotSend() ) ); //or send later
 		}
 	}
 }
diff --git a/kopete/protocols/oscar/liboscar/rateclassmanager.cpp b/kopete/protocols/oscar/liboscar/rateclassmanager.cpp
index 75a30f63..65f37648 100644
--- a/kopete/protocols/oscar/liboscar/rateclassmanager.cpp
+++ b/kopete/protocols/oscar/liboscar/rateclassmanager.cpp
@@ -60,7 +60,7 @@ void RateClassManager::reset()
 
 void RateClassManager::registerClass( RateClass* rc )
 {
-	TQObject::connect( rc, TQT_SIGNAL( dataReady( Transfer* ) ), this, TQT_SLOT( transferReady( Transfer* ) ) );
+	TQObject::connect( rc, TQ_SIGNAL( dataReady( Transfer* ) ), this, TQ_SLOT( transferReady( Transfer* ) ) );
 	d->classList.append( rc );
 }
 
diff --git a/kopete/protocols/oscar/liboscar/rateinfotask.cpp b/kopete/protocols/oscar/liboscar/rateinfotask.cpp
index b918fe48..8ece4bd2 100644
--- a/kopete/protocols/oscar/liboscar/rateinfotask.cpp
+++ b/kopete/protocols/oscar/liboscar/rateinfotask.cpp
@@ -32,7 +32,7 @@ using namespace Oscar;
 RateInfoTask::RateInfoTask( Task* parent )
 		: Task( parent )
 {
-	connect( this, TQT_SIGNAL( gotRateLimits() ), this, TQT_SLOT( sendRateInfoAck() ) );
+	connect( this, TQ_SIGNAL( gotRateLimits() ), this, TQ_SLOT( sendRateInfoAck() ) );
 }
 
 
diff --git a/kopete/protocols/oscar/liboscar/safedelete.cpp b/kopete/protocols/oscar/liboscar/safedelete.cpp
index 9de147f0..2b466e68 100644
--- a/kopete/protocols/oscar/liboscar/safedelete.cpp
+++ b/kopete/protocols/oscar/liboscar/safedelete.cpp
@@ -110,7 +110,7 @@ SafeDeleteLater::SafeDeleteLater()
 {
 	list.setAutoDelete(true);
 	self = this;
-	TQTimer::singleShot(0, this, TQT_SLOT(explode()));
+	TQTimer::singleShot(0, this, TQ_SLOT(explode()));
 }
 
 SafeDeleteLater::~SafeDeleteLater()
diff --git a/kopete/protocols/oscar/liboscar/servicesetuptask.cpp b/kopete/protocols/oscar/liboscar/servicesetuptask.cpp
index af4dd08c..20aac363 100644
--- a/kopete/protocols/oscar/liboscar/servicesetuptask.cpp
+++ b/kopete/protocols/oscar/liboscar/servicesetuptask.cpp
@@ -47,14 +47,14 @@ ServiceSetupTask::ServiceSetupTask( Task* parent )
 	m_ssiListTask = new SSIListTask( parent );
 	m_ssiActivateTask = new SSIActivateTask( parent );
 
-	TQObject::connect( m_ssiListTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( childTaskFinished() ) );
-	TQObject::connect( m_ssiParamTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( childTaskFinished() ) );
-	TQObject::connect( m_prmTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( childTaskFinished() ) );
-	TQObject::connect( m_icbmTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( childTaskFinished() ) );
-	TQObject::connect( m_blmLimitsTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( childTaskFinished() ) );
-	TQObject::connect( m_profileTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( childTaskFinished() ) );
-	TQObject::connect( m_locRightsTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( childTaskFinished() ) );
-	TQObject::connect( m_ssiActivateTask, TQT_SIGNAL( finished() ), this, TQT_SLOT( childTaskFinished() ) );
+	TQObject::connect( m_ssiListTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( childTaskFinished() ) );
+	TQObject::connect( m_ssiParamTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( childTaskFinished() ) );
+	TQObject::connect( m_prmTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( childTaskFinished() ) );
+	TQObject::connect( m_icbmTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( childTaskFinished() ) );
+	TQObject::connect( m_blmLimitsTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( childTaskFinished() ) );
+	TQObject::connect( m_profileTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( childTaskFinished() ) );
+	TQObject::connect( m_locRightsTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( childTaskFinished() ) );
+	TQObject::connect( m_ssiActivateTask, TQ_SIGNAL( finished() ), this, TQ_SLOT( childTaskFinished() ) );
 }
 
 
diff --git a/kopete/protocols/oscar/liboscar/ssilisttask.cpp b/kopete/protocols/oscar/liboscar/ssilisttask.cpp
index 55236339..963682b3 100644
--- a/kopete/protocols/oscar/liboscar/ssilisttask.cpp
+++ b/kopete/protocols/oscar/liboscar/ssilisttask.cpp
@@ -26,9 +26,9 @@
 SSIListTask::SSIListTask( Task* parent ) : Task( parent )
 {
 	m_ssiManager = client()->ssiManager();
-	TQObject::connect( this, TQT_SIGNAL( newContact( const Oscar::SSI& ) ), m_ssiManager, TQT_SLOT( newContact( const Oscar::SSI& ) ) );
-	TQObject::connect( this, TQT_SIGNAL( newGroup( const Oscar::SSI& ) ), m_ssiManager, TQT_SLOT( newGroup( const Oscar::SSI& ) ) );
-	TQObject::connect( this, TQT_SIGNAL( newItem( const Oscar::SSI& ) ), m_ssiManager, TQT_SLOT( newItem( const Oscar::SSI& ) ) );
+	TQObject::connect( this, TQ_SIGNAL( newContact( const Oscar::SSI& ) ), m_ssiManager, TQ_SLOT( newContact( const Oscar::SSI& ) ) );
+	TQObject::connect( this, TQ_SIGNAL( newGroup( const Oscar::SSI& ) ), m_ssiManager, TQ_SLOT( newGroup( const Oscar::SSI& ) ) );
+	TQObject::connect( this, TQ_SIGNAL( newItem( const Oscar::SSI& ) ), m_ssiManager, TQ_SLOT( newItem( const Oscar::SSI& ) ) );
 }
 
 
diff --git a/kopete/protocols/oscar/liboscar/task.cpp b/kopete/protocols/oscar/liboscar/task.cpp
index d7634210..c27f6434 100644
--- a/kopete/protocols/oscar/liboscar/task.cpp
+++ b/kopete/protocols/oscar/liboscar/task.cpp
@@ -46,7 +46,7 @@ Task::Task(Task *parent)
 {
 	init();
 	d->client = parent->client();
-	connect(d->client, TQT_SIGNAL(disconnected()), TQT_SLOT(clientDisconnected()));
+	connect(d->client, TQ_SIGNAL(disconnected()), TQ_SLOT(clientDisconnected()));
 }
 
 Task::Task(Connection* parent, bool)
@@ -54,7 +54,7 @@ Task::Task(Connection* parent, bool)
 {
 	init();
 	d->client = parent;
-	connect(d->client, TQT_SIGNAL(disconnected()), TQT_SLOT(clientDisconnected()));
+	connect(d->client, TQ_SIGNAL(disconnected()), TQ_SLOT(clientDisconnected()));
 }
 
 Task::~Task()
@@ -173,7 +173,7 @@ void Task::onDisconnect()
 		d->statusString = tr("Disconnected");
 
 		// delay this so that tasks that react don't block the shutdown
-		TQTimer::singleShot(0, this, TQT_SLOT(done()));
+		TQTimer::singleShot(0, this, TQ_SLOT(done()));
 	}
 }
 
diff --git a/kopete/protocols/oscar/liboscar/tests/clientstream_test.cpp b/kopete/protocols/oscar/liboscar/tests/clientstream_test.cpp
index 77563c05..070e69cc 100644
--- a/kopete/protocols/oscar/liboscar/tests/clientstream_test.cpp
+++ b/kopete/protocols/oscar/liboscar/tests/clientstream_test.cpp
@@ -10,12 +10,12 @@ ClientStreamTest::ClientStreamTest(int argc, char ** argv) : TQApplication( argc
 	myConnector->setOptHostPort( "login.oscar.aol.com", 5190 );
 	myTestObject = new ClientStream( myConnector, myConnector);
 	// notify when the transport layer is connected
-	connect( myTestObject, TQT_SIGNAL( connected() ), TQT_SLOT( slotConnected() ) );
+	connect( myTestObject, TQ_SIGNAL( connected() ), TQ_SLOT( slotConnected() ) );
 	// notify and start sending
-	//connect( myTestObject, TQT_SIGNAL( warning(int) ), TQT_SLOT( slotWarning(int) ) );
+	//connect( myTestObject, TQ_SIGNAL( warning(int) ), TQ_SLOT( slotWarning(int) ) );
 
 	// do test once the event loop is running
-	TQTimer::singleShot( 0, this, TQT_SLOT( slotDoTest() ) );
+	TQTimer::singleShot( 0, this, TQ_SLOT( slotDoTest() ) );
 	connected = false;
 }
 
diff --git a/kopete/protocols/oscar/liboscar/tests/logintest.cpp b/kopete/protocols/oscar/liboscar/tests/logintest.cpp
index d1025059..4cba0a56 100644
--- a/kopete/protocols/oscar/liboscar/tests/logintest.cpp
+++ b/kopete/protocols/oscar/liboscar/tests/logintest.cpp
@@ -10,13 +10,13 @@ LoginTest::LoginTest(int argc, char ** argv) : TQApplication( argc, argv )
 	myTestObject = new ClientStream( myConnector, myConnector);
 	
 	// notify when the transport layer is connected
-	//connect( myTestObject, TQT_SIGNAL( connected() ), TQT_SLOT( slotConnected() ) );
+	//connect( myTestObject, TQ_SIGNAL( connected() ), TQ_SLOT( slotConnected() ) );
 	myClient = new Client();
 	
 	myConnection = new Connection( myConnector, myTestObject, "AUTHORIZER" );
 	myConnection->setClient( myClient );
 	// do test once the event loop is running
-	TQTimer::singleShot( 0, this, TQT_SLOT( slotDoTest() ) );
+	TQTimer::singleShot( 0, this, TQ_SLOT( slotDoTest() ) );
 	connected = false;
 }
 
diff --git a/kopete/protocols/oscar/liboscar/tests/ssigrouptest.cpp b/kopete/protocols/oscar/liboscar/tests/ssigrouptest.cpp
index 410b6021..a8e667a3 100644
--- a/kopete/protocols/oscar/liboscar/tests/ssigrouptest.cpp
+++ b/kopete/protocols/oscar/liboscar/tests/ssigrouptest.cpp
@@ -10,13 +10,13 @@ LoginTest::LoginTest(int argc, char ** argv) : TQApplication( argc, argv )
 	myTestObject = new ClientStream( myConnector, myConnector);
 	
 	// notify when the transport layer is connected
-	//connect( myTestObject, TQT_SIGNAL( connected() ), TQT_SLOT( slotConnected() ) );
+	//connect( myTestObject, TQ_SIGNAL( connected() ), TQ_SLOT( slotConnected() ) );
 	myClient = new Client();
 	
 	myConnection = new Connection( myConnector, myTestObject, "AUTHORIZER" );
 	myConnection->setClient( myClient );
 	// do test once the event loop is running
-	TQTimer::singleShot( 0, this, TQT_SLOT( slotDoTest() ) );
+	TQTimer::singleShot( 0, this, TQ_SLOT( slotDoTest() ) );
 	connected = false;
 }
 
@@ -36,7 +36,7 @@ void LoginTest::slotDoTest()
 	myClient->setIsIcq( true );
 	myClient->start( server, 5190, "userid", "password" );
 	myClient->connectToServer( myConnection, server, true );
-	TQTimer::singleShot( 10000, this, TQT_SLOT(runAddGroupTest() ) );
+	TQTimer::singleShot( 10000, this, TQ_SLOT(runAddGroupTest() ) );
 	connected = true;
 }
 
@@ -59,7 +59,7 @@ void LoginTest::runAddGroupTest()
 	tqDebug( "running ssi group add test" );
 	TQString group = TQString::fromLatin1( "dummygroup" );
 	myClient->addGroup( group );
-	TQTimer::singleShot( 5000, this, TQT_SLOT( runDelGroupTest() ) );
+	TQTimer::singleShot( 5000, this, TQ_SLOT( runDelGroupTest() ) );
 }
 
 void LoginTest::runDelGroupTest()
diff --git a/kopete/protocols/oscar/liboscar/tests/tdeunittest.cpp b/kopete/protocols/oscar/liboscar/tests/tdeunittest.cpp
index d634f5b9..0c917fd2 100644
--- a/kopete/protocols/oscar/liboscar/tests/tdeunittest.cpp
+++ b/kopete/protocols/oscar/liboscar/tests/tdeunittest.cpp
@@ -51,7 +51,7 @@ void KUnitTest::registerTests()
 
 KUnitTest::KUnitTest()
 {
-    TQTimer::singleShot( 0, this, TQT_SLOT(checkRun()) );
+    TQTimer::singleShot( 0, this, TQ_SLOT(checkRun()) );
 
     m_tests.setAutoDelete( TRUE );
 //    m_qtests.setAutoDelete( TRUE );
@@ -153,8 +153,8 @@ int KUnitTest::runTests()
 //void KUnitTest::addTester( TQTester *test )
 //{
 //    m_qtests.insert( test, test );
-//    connect( test, TQT_SIGNAL(destroyed(TQObject*)),
-//             TQT_SLOT(qtesterDone(TQObject* )) );
+//    connect( test, TQ_SIGNAL(destroyed(TQObject*)),
+//             TQ_SLOT(qtesterDone(TQObject* )) );
 //}
 
 void KUnitTest::qtesterDone( TQObject *obj )
diff --git a/kopete/protocols/oscar/liboscar/tests/userinfotest.cpp b/kopete/protocols/oscar/liboscar/tests/userinfotest.cpp
index 8d75b79d..2c9fd0a9 100644
--- a/kopete/protocols/oscar/liboscar/tests/userinfotest.cpp
+++ b/kopete/protocols/oscar/liboscar/tests/userinfotest.cpp
@@ -10,13 +10,13 @@ LoginTest::LoginTest(int argc, char ** argv) : TQApplication( argc, argv )
 	myTestObject = new ClientStream( myConnector, myConnector);
 	
 	// notify when the transport layer is connected
-	//connect( myTestObject, TQT_SIGNAL( connected() ), TQT_SLOT( slotConnected() ) );
+	//connect( myTestObject, TQ_SIGNAL( connected() ), TQ_SLOT( slotConnected() ) );
 	myClient = new Client();
 	
 	myConnection = new Connection( myConnector, myTestObject, "AUTHORIZER" );
 	myConnection->setClient( myClient );
 	// do test once the event loop is running
-	TQTimer::singleShot( 0, this, TQT_SLOT( slotDoTest() ) );
+	TQTimer::singleShot( 0, this, TQ_SLOT( slotDoTest() ) );
 	connected = false;
 }
 
@@ -36,8 +36,8 @@ void LoginTest::slotDoTest()
 	myClient->setIsIcq( true );
 	myClient->start( server, 5190, "userid", "password" );
 	myClient->connectToServer( myConnection, server, true );
-	//TQObject::connect( myClient, TQT_SIGNAL( userIsOnline( const TQString& ) ), this, TQT_SLOT( runUserInfoTest()));
-	//TQTimer::singleShot( 6000, this, TQT_SLOT(runUserInfoTest() ) );
+	//TQObject::connect( myClient, TQ_SIGNAL( userIsOnline( const TQString& ) ), this, TQ_SLOT( runUserInfoTest()));
+	//TQTimer::singleShot( 6000, this, TQ_SLOT(runUserInfoTest() ) );
 	connected = true;
 }
 
diff --git a/kopete/protocols/oscar/oscaraccount.cpp b/kopete/protocols/oscar/oscaraccount.cpp
index 6bb0edb9..683d92b2 100644
--- a/kopete/protocols/oscar/oscaraccount.cpp
+++ b/kopete/protocols/oscar/oscaraccount.cpp
@@ -113,19 +113,19 @@ OscarAccount::OscarAccount(Kopete::Protocol *parent, const TQString &accountID,
 
 	d->engine->setCodecProvider( d );
     d->olnscDialog = 0L;
-    TQObject::connect( d->engine, TQT_SIGNAL( loggedIn() ), this, TQT_SLOT( loginActions() ) );
-	TQObject::connect( d->engine, TQT_SIGNAL( messageReceived( const Oscar::Message& ) ),
-	                  this, TQT_SLOT( messageReceived(const Oscar::Message& ) ) );
-	TQObject::connect( d->engine, TQT_SIGNAL( socketError( int, const TQString& ) ),
-	                  this, TQT_SLOT( slotSocketError( int, const TQString& ) ) );
-	TQObject::connect( d->engine, TQT_SIGNAL( taskError( const Oscar::SNAC&, int, bool ) ),
-	                  this, TQT_SLOT( slotTaskError( const Oscar::SNAC&, int, bool ) ) );
-	TQObject::connect( d->engine, TQT_SIGNAL( userStartedTyping( const TQString& ) ),
-	                  this, TQT_SLOT( userStartedTyping( const TQString& ) ) );
-	TQObject::connect( d->engine, TQT_SIGNAL( userStoppedTyping( const TQString& ) ),
-	                  this, TQT_SLOT( userStoppedTyping( const TQString& ) ) );
-	TQObject::connect( d->engine, TQT_SIGNAL( iconNeedsUploading() ),
-	                  this, TQT_SLOT( slotSendBuddyIcon() ) );
+    TQObject::connect( d->engine, TQ_SIGNAL( loggedIn() ), this, TQ_SLOT( loginActions() ) );
+	TQObject::connect( d->engine, TQ_SIGNAL( messageReceived( const Oscar::Message& ) ),
+	                  this, TQ_SLOT( messageReceived(const Oscar::Message& ) ) );
+	TQObject::connect( d->engine, TQ_SIGNAL( socketError( int, const TQString& ) ),
+	                  this, TQ_SLOT( slotSocketError( int, const TQString& ) ) );
+	TQObject::connect( d->engine, TQ_SIGNAL( taskError( const Oscar::SNAC&, int, bool ) ),
+	                  this, TQ_SLOT( slotTaskError( const Oscar::SNAC&, int, bool ) ) );
+	TQObject::connect( d->engine, TQ_SIGNAL( userStartedTyping( const TQString& ) ),
+	                  this, TQ_SLOT( userStartedTyping( const TQString& ) ) );
+	TQObject::connect( d->engine, TQ_SIGNAL( userStoppedTyping( const TQString& ) ),
+	                  this, TQ_SLOT( userStoppedTyping( const TQString& ) ) );
+	TQObject::connect( d->engine, TQ_SIGNAL( iconNeedsUploading() ),
+	                  this, TQ_SLOT( slotSendBuddyIcon() ) );
 }
 
 OscarAccount::~OscarAccount()
@@ -144,18 +144,18 @@ void OscarAccount::logOff( Kopete::Account::DisconnectReason reason )
 	kdDebug(OSCAR_GEN_DEBUG) << k_funcinfo << "accountId='" << accountId() << "'" << endl;
 	//disconnect the signals
 	Kopete::ContactList* kcl = Kopete::ContactList::self();
-	TQObject::disconnect( kcl, TQT_SIGNAL( groupRenamed( Kopete::Group*,  const TQString& ) ),
-	                     this, TQT_SLOT( kopeteGroupRenamed( Kopete::Group*, const TQString& ) ) );
-	TQObject::disconnect( kcl, TQT_SIGNAL( groupRemoved( Kopete::Group* ) ),
-	                     this, TQT_SLOT( kopeteGroupRemoved( Kopete::Group* ) ) );
-	TQObject::disconnect( d->engine->ssiManager(), TQT_SIGNAL( contactAdded( const Oscar::SSI& ) ),
-	                     this, TQT_SLOT( ssiContactAdded( const Oscar::SSI& ) ) );
-	TQObject::disconnect( d->engine->ssiManager(), TQT_SIGNAL( groupAdded( const Oscar::SSI& ) ),
-	                     this, TQT_SLOT( ssiGroupAdded( const Oscar::SSI& ) ) );
-	TQObject::disconnect( d->engine->ssiManager(), TQT_SIGNAL( groupUpdated( const Oscar::SSI& ) ),
-	                     this, TQT_SLOT( ssiGroupUpdated( const Oscar::SSI& ) ) );
-	TQObject::disconnect( d->engine->ssiManager(), TQT_SIGNAL( contactUpdated( const Oscar::SSI& ) ),
-	                     this, TQT_SLOT( ssiContactUpdated( const Oscar::SSI& ) ) );
+	TQObject::disconnect( kcl, TQ_SIGNAL( groupRenamed( Kopete::Group*,  const TQString& ) ),
+	                     this, TQ_SLOT( kopeteGroupRenamed( Kopete::Group*, const TQString& ) ) );
+	TQObject::disconnect( kcl, TQ_SIGNAL( groupRemoved( Kopete::Group* ) ),
+	                     this, TQ_SLOT( kopeteGroupRemoved( Kopete::Group* ) ) );
+	TQObject::disconnect( d->engine->ssiManager(), TQ_SIGNAL( contactAdded( const Oscar::SSI& ) ),
+	                     this, TQ_SLOT( ssiContactAdded( const Oscar::SSI& ) ) );
+	TQObject::disconnect( d->engine->ssiManager(), TQ_SIGNAL( groupAdded( const Oscar::SSI& ) ),
+	                     this, TQ_SLOT( ssiGroupAdded( const Oscar::SSI& ) ) );
+	TQObject::disconnect( d->engine->ssiManager(), TQ_SIGNAL( groupUpdated( const Oscar::SSI& ) ),
+	                     this, TQ_SLOT( ssiGroupUpdated( const Oscar::SSI& ) ) );
+	TQObject::disconnect( d->engine->ssiManager(), TQ_SIGNAL( contactUpdated( const Oscar::SSI& ) ),
+	                     this, TQ_SLOT( ssiContactUpdated( const Oscar::SSI& ) ) );
 
 	d->engine->close();
 	myself()->setOnlineStatus( Kopete::OnlineStatus::Offline );
@@ -198,10 +198,10 @@ void OscarAccount::processSSIList()
 {
 	//disconnect signals so we don't attempt to add things to SSI!
 	Kopete::ContactList* kcl = Kopete::ContactList::self();
-	TQObject::disconnect( kcl, TQT_SIGNAL( groupRenamed( Kopete::Group*,  const TQString& ) ),
-	                     this, TQT_SLOT( kopeteGroupRenamed( Kopete::Group*, const TQString& ) ) );
-	TQObject::disconnect( kcl, TQT_SIGNAL( groupRemoved( Kopete::Group* ) ),
-	                     this, TQT_SLOT( kopeteGroupRemoved( Kopete::Group* ) ) );
+	TQObject::disconnect( kcl, TQ_SIGNAL( groupRenamed( Kopete::Group*,  const TQString& ) ),
+	                     this, TQ_SLOT( kopeteGroupRenamed( Kopete::Group*, const TQString& ) ) );
+	TQObject::disconnect( kcl, TQ_SIGNAL( groupRemoved( Kopete::Group* ) ),
+	                     this, TQ_SLOT( kopeteGroupRemoved( Kopete::Group* ) ) );
 
 	kdDebug(OSCAR_RAW_DEBUG) << k_funcinfo << endl;
 
@@ -248,18 +248,18 @@ void OscarAccount::processSSIList()
 			addContact( ( *bit ).name(), TQString(), group, Kopete::Account::DontChangeKABC );
 	}
 
-	TQObject::connect( kcl, TQT_SIGNAL( groupRenamed( Kopete::Group*,  const TQString& ) ),
-	                  this, TQT_SLOT( kopeteGroupRenamed( Kopete::Group*, const TQString& ) ) );
-	TQObject::connect( kcl, TQT_SIGNAL( groupRemoved( Kopete::Group* ) ),
-	                  this, TQT_SLOT( kopeteGroupRemoved( Kopete::Group* ) ) );
-	TQObject::connect( listManager, TQT_SIGNAL( contactAdded( const Oscar::SSI& ) ),
-	                  this, TQT_SLOT( ssiContactAdded( const Oscar::SSI& ) ) );
-	TQObject::connect( listManager, TQT_SIGNAL( groupAdded( const Oscar::SSI& ) ),
-	                  this, TQT_SLOT( ssiGroupAdded( const Oscar::SSI& ) ) );
-	TQObject::connect( listManager, TQT_SIGNAL( groupUpdated( const Oscar::SSI& ) ),
-	                  this, TQT_SLOT( ssiGroupUpdated( const Oscar::SSI& ) ) );
-	TQObject::connect( listManager, TQT_SIGNAL( contactUpdated( const Oscar::SSI& ) ),
-	                  this, TQT_SLOT( ssiContactUpdated( const Oscar::SSI& ) ) );
+	TQObject::connect( kcl, TQ_SIGNAL( groupRenamed( Kopete::Group*,  const TQString& ) ),
+	                  this, TQ_SLOT( kopeteGroupRenamed( Kopete::Group*, const TQString& ) ) );
+	TQObject::connect( kcl, TQ_SIGNAL( groupRemoved( Kopete::Group* ) ),
+	                  this, TQ_SLOT( kopeteGroupRemoved( Kopete::Group* ) ) );
+	TQObject::connect( listManager, TQ_SIGNAL( contactAdded( const Oscar::SSI& ) ),
+	                  this, TQ_SLOT( ssiContactAdded( const Oscar::SSI& ) ) );
+	TQObject::connect( listManager, TQ_SIGNAL( groupAdded( const Oscar::SSI& ) ),
+	                  this, TQ_SLOT( ssiGroupAdded( const Oscar::SSI& ) ) );
+	TQObject::connect( listManager, TQ_SIGNAL( groupUpdated( const Oscar::SSI& ) ),
+	                  this, TQ_SLOT( ssiGroupUpdated( const Oscar::SSI& ) ) );
+	TQObject::connect( listManager, TQ_SIGNAL( contactUpdated( const Oscar::SSI& ) ),
+	                  this, TQ_SLOT( ssiContactUpdated( const Oscar::SSI& ) ) );
 
     //TODO: check the kopete contact list and handle non server side contacts appropriately.
     TQDict<Kopete::Contact> nonServerContacts = contacts();
@@ -280,8 +280,8 @@ void OscarAccount::processSSIList()
     if ( !nonServerContactList.isEmpty() && showMissingContactsDialog )
     {
         d->olnscDialog = new OscarListNonServerContacts( Kopete::UI::Global::mainWidget() );
-        TQObject::connect( d->olnscDialog, TQT_SIGNAL( closing() ),
-                          this, TQT_SLOT( nonServerAddContactDialogClosed() ) );
+        TQObject::connect( d->olnscDialog, TQ_SIGNAL( closing() ),
+                          this, TQ_SLOT( nonServerAddContactDialogClosed() ) );
         d->olnscDialog->addContacts( nonServerContactList );
         d->olnscDialog->show();
     }
@@ -781,7 +781,7 @@ void OscarAccount::slotTaskError( const Oscar::SNAC& s, int code, bool fatal )
 void OscarAccount::slotSendBuddyIcon()
 {
 	//need to disconnect because we could end up with many connections
-	TQObject::disconnect( engine(), TQT_SIGNAL( iconServerConnected() ), this, TQT_SLOT( slotSendBuddyIcon() ) );
+	TQObject::disconnect( engine(), TQ_SIGNAL( iconServerConnected() ), this, TQ_SLOT( slotSendBuddyIcon() ) );
 	TQString photoPath = myself()->property( Kopete::Global::Properties::self()->photo() ).value().toString();
 	if ( photoPath.isEmpty() )
 		return;
@@ -794,8 +794,8 @@ void OscarAccount::slotSendBuddyIcon()
 		if ( !engine()->hasIconConnection() )
 		{
 			//will send icon when we connect to icon server
-			TQObject::connect( engine(), TQT_SIGNAL( iconServerConnected() ),
-			                  this, TQT_SLOT( slotSendBuddyIcon() ) );
+			TQObject::connect( engine(), TQ_SIGNAL( iconServerConnected() ),
+			                  this, TQ_SLOT( slotSendBuddyIcon() ) );
 			return;
 		}
 		TQByteArray imageData = iconFile.readAll();
diff --git a/kopete/protocols/oscar/oscarcontact.cpp b/kopete/protocols/oscar/oscarcontact.cpp
index 512b65ff..45874477 100644
--- a/kopete/protocols/oscar/oscarcontact.cpp
+++ b/kopete/protocols/oscar/oscarcontact.cpp
@@ -51,7 +51,7 @@ OscarContact::OscarContact( Kopete::Account* account, const TQString& name,
 	mName = name;
 	mMsgManager = 0L;
 	m_ssiItem = ssiItem;
-	connect( this, TQT_SIGNAL( updatedSSI() ), this, TQT_SLOT( updateSSIItem() ) );
+	connect( this, TQ_SIGNAL( updatedSSI() ), this, TQ_SLOT( updateSSIItem() ) );
 }
 
 OscarContact::~OscarContact()
@@ -105,15 +105,15 @@ Kopete::ChatSession* OscarContact::manager( CanCreateFlags canCreate )
 		mMsgManager = Kopete::ChatSessionManager::self()->create(account()->myself(), theContact, protocol());
 
 		// This is for when the user types a message and presses send
-		connect(mMsgManager, TQT_SIGNAL( messageSent( Kopete::Message&, Kopete::ChatSession * ) ),
-		        this, TQT_SLOT( slotSendMsg( Kopete::Message&, Kopete::ChatSession * ) ) );
+		connect(mMsgManager, TQ_SIGNAL( messageSent( Kopete::Message&, Kopete::ChatSession * ) ),
+		        this, TQ_SLOT( slotSendMsg( Kopete::Message&, Kopete::ChatSession * ) ) );
 
 		// For when the message manager is destroyed
-		connect(mMsgManager, TQT_SIGNAL( destroyed() ),
-		        this, TQT_SLOT( chatSessionDestroyed() ) );
+		connect(mMsgManager, TQ_SIGNAL( destroyed() ),
+		        this, TQ_SLOT( chatSessionDestroyed() ) );
 
-		connect(mMsgManager, TQT_SIGNAL( myselfTyping( bool ) ),
-		        this, TQT_SLOT( slotTyping( bool ) ) );
+		connect(mMsgManager, TQ_SIGNAL( myselfTyping( bool ) ),
+		        this, TQ_SLOT( slotTyping( bool ) ) );
 	}
 	return mMsgManager;
 }
diff --git a/kopete/protocols/oscar/oscarmyselfcontact.cpp b/kopete/protocols/oscar/oscarmyselfcontact.cpp
index e5f1cd9e..78a01433 100644
--- a/kopete/protocols/oscar/oscarmyselfcontact.cpp
+++ b/kopete/protocols/oscar/oscarmyselfcontact.cpp
@@ -27,7 +27,7 @@
 OscarMyselfContact::OscarMyselfContact( OscarAccount* account )
 : Kopete::Contact( account, account->accountId(), Kopete::ContactList::self()->myself() )
 {
-	TQObject::connect( account->engine(), TQT_SIGNAL( haveOwnInfo() ), this, TQT_SLOT( userInfoUpdated() ) );
+	TQObject::connect( account->engine(), TQ_SIGNAL( haveOwnInfo() ), this, TQ_SLOT( userInfoUpdated() ) );
 }
 
 OscarMyselfContact::~OscarMyselfContact()
diff --git a/kopete/protocols/oscar/oscarversionupdater.cpp b/kopete/protocols/oscar/oscarversionupdater.cpp
index 16149c18..6da4b0e0 100644
--- a/kopete/protocols/oscar/oscarversionupdater.cpp
+++ b/kopete/protocols/oscar/oscarversionupdater.cpp
@@ -71,10 +71,10 @@ bool OscarVersionUpdater::update( unsigned int stamp )
 		mTransferJob = TDEIO::get ( url );
 		kdDebug(OSCAR_GEN_DEBUG) << k_funcinfo << "Download version info from server."<< endl;
 		
-		connect ( mTransferJob, TQT_SIGNAL ( result ( TDEIO::Job* ) ),
-		          this, TQT_SLOT ( slotTransferResult ( TDEIO::Job* ) ) );
-		connect ( mTransferJob, TQT_SIGNAL ( data ( TDEIO::Job*, const TQByteArray& ) ),
-		          this, TQT_SLOT ( slotTransferData ( TDEIO::Job*, const TQByteArray& ) ) );
+		connect ( mTransferJob, TQ_SIGNAL ( result ( TDEIO::Job* ) ),
+		          this, TQ_SLOT ( slotTransferResult ( TDEIO::Job* ) ) );
+		connect ( mTransferJob, TQ_SIGNAL ( data ( TDEIO::Job*, const TQByteArray& ) ),
+		          this, TQ_SLOT ( slotTransferData ( TDEIO::Job*, const TQByteArray& ) ) );
 	}
 	return isUpdating;
 }
diff --git a/kopete/protocols/oscar/oscarvisibilitydialog.cpp b/kopete/protocols/oscar/oscarvisibilitydialog.cpp
index 235693e1..c82d0a86 100644
--- a/kopete/protocols/oscar/oscarvisibilitydialog.cpp
+++ b/kopete/protocols/oscar/oscarvisibilitydialog.cpp
@@ -32,14 +32,14 @@ OscarVisibilityDialog::OscarVisibilityDialog( Client* client, TQWidget* parent )
 	m_visibilityUI = new OscarVisibilityBase( this );
 	setMainWidget( m_visibilityUI );
 	
-	TQObject::connect(m_visibilityUI->visibleAdd, TQT_SIGNAL(clicked()),
-	                 this, TQT_SLOT(slotAddToVisible()));
-	TQObject::connect(m_visibilityUI->visibleRemove, TQT_SIGNAL(clicked()),
-	                 this, TQT_SLOT(slotRemoveFromVisible()));
-	TQObject::connect(m_visibilityUI->invisibleAdd, TQT_SIGNAL(clicked()),
-	                 this, TQT_SLOT(slotAddToInvisible()));
-	TQObject::connect(m_visibilityUI->invisibleRemove, TQT_SIGNAL(clicked()),
-	                 this, TQT_SLOT(slotRemoveFromInvisible()));
+	TQObject::connect(m_visibilityUI->visibleAdd, TQ_SIGNAL(clicked()),
+	                 this, TQ_SLOT(slotAddToVisible()));
+	TQObject::connect(m_visibilityUI->visibleRemove, TQ_SIGNAL(clicked()),
+	                 this, TQ_SLOT(slotRemoveFromVisible()));
+	TQObject::connect(m_visibilityUI->invisibleAdd, TQ_SIGNAL(clicked()),
+	                 this, TQ_SLOT(slotAddToInvisible()));
+	TQObject::connect(m_visibilityUI->invisibleRemove, TQ_SIGNAL(clicked()),
+	                 this, TQ_SLOT(slotRemoveFromInvisible()));
 }
 
 void OscarVisibilityDialog::addContacts( const ContactMap& contacts )