Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Signed-off-by: Michele Calgaro <[email protected]>
(cherry picked from commit 1329ec6abbcb7b79cd960e0ca138f16598d5f11f)

30 files changed, 252 insertions, 252 deletions

diff --git a/kopete/protocols/groupwise/gwaccount.cpp b/kopete/protocols/groupwise/gwaccount.cpp
index e5d016de..14489141 100644
--- a/kopete/protocols/groupwise/gwaccount.cpp
+++ b/kopete/protocols/groupwise/gwaccount.cpp
@@ -74,17 +74,17 @@ GroupWiseAccount::GroupWiseAccount( GroupWiseProtocol *parent, const TQString& a
 	myself()->setOnlineStatus( GroupWiseProtocol::protocol()->groupwiseOffline );
 
 	// Contact list management
-	TQObject::connect( Kopete::ContactList::self(), TQT_SIGNAL( groupRenamed( Kopete::Group *, const TQString & ) ),
-			TQT_SLOT( slotKopeteGroupRenamed( Kopete::Group * ) ) );
-	TQObject::connect( Kopete::ContactList::self(), TQT_SIGNAL( groupRemoved( Kopete::Group * ) ),
-			TQT_SLOT( slotKopeteGroupRemoved( Kopete::Group * ) ) );
+	TQObject::connect( Kopete::ContactList::self(), TQ_SIGNAL( groupRenamed( Kopete::Group *, const TQString & ) ),
+			TQ_SLOT( slotKopeteGroupRenamed( Kopete::Group * ) ) );
+	TQObject::connect( Kopete::ContactList::self(), TQ_SIGNAL( groupRemoved( Kopete::Group * ) ),
+			TQ_SLOT( slotKopeteGroupRemoved( Kopete::Group * ) ) );
 
 	m_actionAutoReply = new TDEAction ( i18n( "&Set Auto-Reply..." ), TQString(), 0, this,
-			TQT_SLOT( slotSetAutoReply() ), this, "actionSetAutoReply");
+			TQ_SLOT( slotSetAutoReply() ), this, "actionSetAutoReply");
 	m_actionJoinChatRoom = new TDEAction ( i18n( "&Join Channel..." ), TQString(), 0, this,
-										 TQT_SLOT( slotJoinChatRoom() ), this, "actionJoinChatRoom");
+										 TQ_SLOT( slotJoinChatRoom() ), this, "actionJoinChatRoom");
 	m_actionManagePrivacy = new TDEAction ( i18n( "&Manage Privacy..." ), TQString(), 0, this,
-			TQT_SLOT( slotPrivacy() ), this, "actionPrivacy");
+			TQ_SLOT( slotPrivacy() ), this, "actionPrivacy");
 			
 	m_connector = 0;
 	m_TQCATLS = 0;
@@ -113,7 +113,7 @@ TDEActionMenu* GroupWiseAccount::actionMenu()
 	/* Used for debugging */
 	/*
 	theActionMenu->insert( new TDEAction ( "Test rtfize()", TQString(), 0, this,
-		TQT_SLOT( slotTestRTFize() ), this,
+		TQ_SLOT( slotTestRTFize() ), this,
 		"actionTestRTFize") );
 	*/
 	return m_actionMenu;
@@ -178,8 +178,8 @@ GroupWiseChatSession * GroupWiseAccount::chatSession( Kopete::ContactPtrList oth
 			m_chatSessions.append( chatSession );
 			// listen for the message manager telling us that the user
 			//has left the conference so we remove it from our map
-			TQObject::connect( chatSession, TQT_SIGNAL( leavingConference( GroupWiseChatSession * ) ),
-							TQT_SLOT( slotLeavingConference( GroupWiseChatSession * ) ) );
+			TQObject::connect( chatSession, TQ_SIGNAL( leavingConference( GroupWiseChatSession * ) ),
+							TQ_SLOT( slotLeavingConference( GroupWiseChatSession * ) ) );
 			break;
 		}
 		//kdDebug( GROUPWISE_DEBUG_GLOBAL ) << k_funcinfo <<
@@ -268,80 +268,80 @@ void GroupWiseAccount::performConnectWithPassword( const TQString &password )
 	m_tlsHandler = new TQCATLSHandler( m_TQCATLS );
 	m_clientStream = new ClientStream( m_connector, m_tlsHandler, 0);
 
-	TQObject::connect( m_connector, TQT_SIGNAL( error() ), this, TQT_SLOT( slotConnError() ) );
-	TQObject::connect( m_connector, TQT_SIGNAL( connected() ), this, TQT_SLOT( slotConnConnected() ) );
+	TQObject::connect( m_connector, TQ_SIGNAL( error() ), this, TQ_SLOT( slotConnError() ) );
+	TQObject::connect( m_connector, TQ_SIGNAL( connected() ), this, TQ_SLOT( slotConnConnected() ) );
 
-	TQObject::connect (m_clientStream, TQT_SIGNAL (connectionClosed()),
-				this, TQT_SLOT (slotCSDisconnected()));
-	TQObject::connect (m_clientStream, TQT_SIGNAL (delayedCloseFinished()),
-				this, TQT_SLOT (slotCSDisconnected()));
+	TQObject::connect (m_clientStream, TQ_SIGNAL (connectionClosed()),
+				this, TQ_SLOT (slotCSDisconnected()));
+	TQObject::connect (m_clientStream, TQ_SIGNAL (delayedCloseFinished()),
+				this, TQ_SLOT (slotCSDisconnected()));
 	// Notify us when the transport layer is connected
-	TQObject::connect( m_clientStream, TQT_SIGNAL( connected() ), TQT_SLOT( slotCSConnected() ) );
+	TQObject::connect( m_clientStream, TQ_SIGNAL( connected() ), TQ_SLOT( slotCSConnected() ) );
 	// it's necessary to catch this signal and tell the TLS handler to proceed
 	// even if we don't check cert validity
-	TQObject::connect( m_tlsHandler, TQT_SIGNAL(tlsHandshaken()), TQT_SLOT( slotTLSHandshaken()) );
+	TQObject::connect( m_tlsHandler, TQ_SIGNAL(tlsHandshaken()), TQ_SLOT( slotTLSHandshaken()) );
 	// starts the client once the security layer is up, but see below
-	TQObject::connect( m_clientStream, TQT_SIGNAL( securityLayerActivated(int) ), TQT_SLOT( slotTLSReady(int) ) );
+	TQObject::connect( m_clientStream, TQ_SIGNAL( securityLayerActivated(int) ), TQ_SLOT( slotTLSReady(int) ) );
 	// we could handle login etc in start(), in which case we would emit this signal after that
-	//TQObject::connect (jabberClientStream, TQT_SIGNAL (authenticated()),
-	//			this, TQT_SLOT (slotCSAuthenticated ()));
+	//TQObject::connect (jabberClientStream, TQ_SIGNAL (authenticated()),
+	//			this, TQ_SLOT (slotCSAuthenticated ()));
 	// we could also get do the actual login in response to this..
-	//TQObject::connect (m_clientStream, TQT_SIGNAL (needAuthParams(bool, bool, bool)),
-	//			this, TQT_SLOT (slotCSNeedAuthParams (bool, bool, bool)));
+	//TQObject::connect (m_clientStream, TQ_SIGNAL (needAuthParams(bool, bool, bool)),
+	//			this, TQ_SLOT (slotCSNeedAuthParams (bool, bool, bool)));
 
 	// not implemented: warning
-	TQObject::connect( m_clientStream, TQT_SIGNAL( warning(int) ), TQT_SLOT( slotCSWarning(int) ) );
+	TQObject::connect( m_clientStream, TQ_SIGNAL( warning(int) ), TQ_SLOT( slotCSWarning(int) ) );
 	// not implemented: error
-	TQObject::connect( m_clientStream, TQT_SIGNAL( error(int) ), TQT_SLOT( slotCSError(int) ) );
+	TQObject::connect( m_clientStream, TQ_SIGNAL( error(int) ), TQ_SLOT( slotCSError(int) ) );
 
 	m_client = new Client( 0, CMSGPRES_GW_6_5 );
 
 	// NB these are prefixed with TQObject:: to avoid any chance of a clash with our connect() methods.
 	// we connected successfully
-	TQObject::connect( m_client, TQT_SIGNAL( loggedIn() ), TQT_SLOT( slotLoggedIn() ) );
+	TQObject::connect( m_client, TQ_SIGNAL( loggedIn() ), TQ_SLOT( slotLoggedIn() ) );
 	// or connection failed
-	TQObject::connect( m_client, TQT_SIGNAL( loginFailed() ), TQT_SLOT( slotLoginFailed() ) );
+	TQObject::connect( m_client, TQ_SIGNAL( loginFailed() ), TQ_SLOT( slotLoginFailed() ) );
 	// folder listed
-	TQObject::connect( m_client, TQT_SIGNAL( folderReceived( const FolderItem & ) ), TQT_SLOT( receiveFolder( const FolderItem & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( folderReceived( const FolderItem & ) ), TQ_SLOT( receiveFolder( const FolderItem & ) ) );
 	// contact listed
-	TQObject::connect( m_client, TQT_SIGNAL( contactReceived( const ContactItem & ) ), TQT_SLOT( receiveContact( const ContactItem & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( contactReceived( const ContactItem & ) ), TQ_SLOT( receiveContact( const ContactItem & ) ) );
 	// contact details listed
-	TQObject::connect( m_client, TQT_SIGNAL( contactUserDetailsReceived( const GroupWise::ContactDetails & ) ), TQT_SLOT( receiveContactUserDetails( const GroupWise::ContactDetails & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( contactUserDetailsReceived( const GroupWise::ContactDetails & ) ), TQ_SLOT( receiveContactUserDetails( const GroupWise::ContactDetails & ) ) );
 	// contact status changed
-	TQObject::connect( m_client, TQT_SIGNAL( statusReceived( const TQString &, TQ_UINT16, const TQString & ) ), TQT_SLOT( receiveStatus( const TQString &, TQ_UINT16 , const TQString & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( statusReceived( const TQString &, TQ_UINT16, const TQString & ) ), TQ_SLOT( receiveStatus( const TQString &, TQ_UINT16 , const TQString & ) ) );
 	// incoming message
-	TQObject::connect( m_client, TQT_SIGNAL( messageReceived( const ConferenceEvent & ) ), TQT_SLOT( handleIncomingMessage( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( messageReceived( const ConferenceEvent & ) ), TQ_SLOT( handleIncomingMessage( const ConferenceEvent & ) ) );
 	// auto reply to one of our messages because the recipient is away
-	TQObject::connect( m_client, TQT_SIGNAL( autoReplyReceived( const ConferenceEvent & ) ), TQT_SLOT( handleIncomingMessage( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( autoReplyReceived( const ConferenceEvent & ) ), TQ_SLOT( handleIncomingMessage( const ConferenceEvent & ) ) );
 
-	TQObject::connect( m_client, TQT_SIGNAL( ourStatusChanged( GroupWise::Status, const TQString &, const TQString & ) ), TQT_SLOT( changeOurStatus( GroupWise::Status, const TQString &, const TQString & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( ourStatusChanged( GroupWise::Status, const TQString &, const TQString & ) ), TQ_SLOT( changeOurStatus( GroupWise::Status, const TQString &, const TQString & ) ) );
 	// conference events
 	TQObject::connect( m_client,
-		TQT_SIGNAL( conferenceCreated( const int, const GroupWise::ConferenceGuid & ) ),
-		TQT_SIGNAL( conferenceCreated( const int, const GroupWise::ConferenceGuid & ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( conferenceCreationFailed( const int,  const int ) ), TQT_SIGNAL( conferenceCreationFailed( const int,  const int ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( invitationReceived( const ConferenceEvent & ) ), TQT_SLOT( receiveInvitation( const ConferenceEvent & ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( conferenceLeft( const ConferenceEvent & ) ), TQT_SLOT( receiveConferenceLeft( const ConferenceEvent & ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( conferenceJoinNotifyReceived( const ConferenceEvent & ) ), TQT_SLOT( receiveConferenceJoinNotify( const ConferenceEvent & ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( inviteNotifyReceived( const ConferenceEvent & ) ), TQT_SLOT( receiveInviteNotify( const ConferenceEvent & ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( invitationDeclined( const ConferenceEvent & ) ), TQT_SLOT( receiveInviteDeclined( const ConferenceEvent & ) ) );
+		TQ_SIGNAL( conferenceCreated( const int, const GroupWise::ConferenceGuid & ) ),
+		TQ_SIGNAL( conferenceCreated( const int, const GroupWise::ConferenceGuid & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( conferenceCreationFailed( const int,  const int ) ), TQ_SIGNAL( conferenceCreationFailed( const int,  const int ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( invitationReceived( const ConferenceEvent & ) ), TQ_SLOT( receiveInvitation( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( conferenceLeft( const ConferenceEvent & ) ), TQ_SLOT( receiveConferenceLeft( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( conferenceJoinNotifyReceived( const ConferenceEvent & ) ), TQ_SLOT( receiveConferenceJoinNotify( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( inviteNotifyReceived( const ConferenceEvent & ) ), TQ_SLOT( receiveInviteNotify( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( invitationDeclined( const ConferenceEvent & ) ), TQ_SLOT( receiveInviteDeclined( const ConferenceEvent & ) ) );
 
-	TQObject::connect( m_client, TQT_SIGNAL( conferenceJoined( const GroupWise::ConferenceGuid &, const TQStringList &, const TQStringList &  ) ), TQT_SLOT( receiveConferenceJoin( const GroupWise::ConferenceGuid &, const TQStringList & , const TQStringList & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( conferenceJoined( const GroupWise::ConferenceGuid &, const TQStringList &, const TQStringList &  ) ), TQ_SLOT( receiveConferenceJoin( const GroupWise::ConferenceGuid &, const TQStringList & , const TQStringList & ) ) );
 
 	// typing events
-	TQObject::connect( m_client, TQT_SIGNAL( contactTyping( const ConferenceEvent & ) ),
-								TQT_SIGNAL( contactTyping( const ConferenceEvent & ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( contactNotTyping( const ConferenceEvent & ) ),
-								TQT_SIGNAL( contactNotTyping( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( contactTyping( const ConferenceEvent & ) ),
+								TQ_SIGNAL( contactTyping( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( contactNotTyping( const ConferenceEvent & ) ),
+								TQ_SIGNAL( contactNotTyping( const ConferenceEvent & ) ) );
 	// misc
-	TQObject::connect( m_client, TQT_SIGNAL( accountDetailsReceived( const GroupWise::ContactDetails &) ), TQT_SLOT( receiveAccountDetails( const GroupWise::ContactDetails & ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( connectedElsewhere() ), TQT_SLOT( slotConnectedElsewhere() ) );
+	TQObject::connect( m_client, TQ_SIGNAL( accountDetailsReceived( const GroupWise::ContactDetails &) ), TQ_SLOT( receiveAccountDetails( const GroupWise::ContactDetails & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( connectedElsewhere() ), TQ_SLOT( slotConnectedElsewhere() ) );
 	// privacy - contacts can't connect directly to this signal because myself() is initialised before m_client
-	TQObject::connect( m_client->privacyManager(), TQT_SIGNAL( privacyChanged( const TQString &, bool ) ), TQT_SIGNAL( privacyChanged( const TQString &, bool ) ) );
+	TQObject::connect( m_client->privacyManager(), TQ_SIGNAL( privacyChanged( const TQString &, bool ) ), TQ_SIGNAL( privacyChanged( const TQString &, bool ) ) );
 
 	// GW7
-	TQObject::connect( m_client, TQT_SIGNAL( broadcastReceived( const ConferenceEvent & ) ), TQT_SLOT( handleIncomingMessage( const ConferenceEvent & ) ) );
-	TQObject::connect( m_client, TQT_SIGNAL( systemBroadcastReceived( const ConferenceEvent & ) ), TQT_SLOT( handleIncomingMessage( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( broadcastReceived( const ConferenceEvent & ) ), TQ_SLOT( handleIncomingMessage( const ConferenceEvent & ) ) );
+	TQObject::connect( m_client, TQ_SIGNAL( systemBroadcastReceived( const ConferenceEvent & ) ), TQ_SLOT( handleIncomingMessage( const ConferenceEvent & ) ) );
 
 	struct utsname utsBuf;
 	uname (&utsBuf);
@@ -358,7 +358,7 @@ void GroupWiseAccount::performConnectWithPassword( const TQString &password )
 	myself()->setOnlineStatus( protocol()->groupwiseConnecting );
 	m_client->connectToServer( m_clientStream, dn, true );
 
-    TQObject::connect( m_client, TQT_SIGNAL( messageSendingFailed() ), TQT_SLOT( slotMessageSendingFailed() ) );
+    TQObject::connect( m_client, TQ_SIGNAL( messageSendingFailed() ), TQ_SLOT( slotMessageSendingFailed() ) );
 }
 
 void GroupWiseAccount::slotMessageSendingFailed()
@@ -940,7 +940,7 @@ void GroupWiseAccount::receiveContact( const ContactItem & contact )
 			kdDebug( GROUPWISE_DEBUG_GLOBAL ) << " - ERROR - contact's folder doesn't exist on server" << endl;
 			DeleteItemTask * dit = new DeleteItemTask( client()->rootTask() );
 			dit->item( contact.parentId, contact.id );
-//			TQObject::connect( dit, TQT_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQT_SLOT( receiveContactDeleted( const ContactItem & ) ) );
+//			TQObject::connect( dit, TQ_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQ_SLOT( receiveContactDeleted( const ContactItem & ) ) );
 			dit->go( true );
 			return;
 		}
@@ -1165,7 +1165,7 @@ bool GroupWiseAccount::createContact( const TQString& contactId, Kopete::MetaCon
 	// get the contact's full name to use as the display name of the created contact
 	CreateContactTask * cct = new CreateContactTask( client()->rootTask() );
 	cct->contactFromUserId( contactId, parentContact->displayName(), highestFreeSequence, folders, topLevel );
-	TQObject::connect( cct, TQT_SIGNAL( finished() ), TQT_SLOT( receiveContactCreated() ) );
+	TQObject::connect( cct, TQ_SIGNAL( finished() ), TQ_SLOT( receiveContactCreated() ) );
 	cct->go( true );
 	return true;
 }
@@ -1228,7 +1228,7 @@ void GroupWiseAccount::deleteContact( GroupWiseContact * contact )
 		{
 			DeleteItemTask * dit = new DeleteItemTask( client()->rootTask() );
 			dit->item( ::tqt_cast<GWFolder*>( (*it)->parent() )->id, (*it)->id );
-			TQObject::connect( dit, TQT_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQT_SLOT( receiveContactDeleted( const ContactItem & ) ) );
+			TQObject::connect( dit, TQ_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQ_SLOT( receiveContactDeleted( const ContactItem & ) ) );
 			dit->go( true );
 		}
 	}
@@ -1541,21 +1541,21 @@ void GroupWiseAccount::syncContact( GroupWiseContact * contact )
 			{
 				MoveContactTask * mit = new MoveContactTask( client()->rootTask() );
 				mit->moveContact( instance, destinationFolder->id );
-				TQObject::connect( mit, TQT_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQT_SLOT( receiveContactDeleted( const ContactItem & ) ) );
+				TQObject::connect( mit, TQ_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQ_SLOT( receiveContactDeleted( const ContactItem & ) ) );
 				mit->go();
 			}
 			else if ( *candidateGrp == Kopete::Group::topLevel() )
 			{	
 				MoveContactTask * mit = new MoveContactTask( client()->rootTask() );
 				mit->moveContact( instance, 0 );
-				TQObject::connect( mit, TQT_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQT_SLOT( receiveContactDeleted( const ContactItem & ) ) );
+				TQObject::connect( mit, TQ_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQ_SLOT( receiveContactDeleted( const ContactItem & ) ) );
 				mit->go();
 			}
 			else
 			{
 				MoveContactTask * mit = new MoveContactTask( client()->rootTask() );
-				TQObject::connect( mit, TQT_SIGNAL( gotContactDeleted( const ContactItem & ) ), 
-								  TQT_SLOT( receiveContactDeleted( const ContactItem & ) ) );
+				TQObject::connect( mit, TQ_SIGNAL( gotContactDeleted( const ContactItem & ) ), 
+								  TQ_SLOT( receiveContactDeleted( const ContactItem & ) ) );
 				// discover the next free sequence number and add the group using that
 				mit->moveContactToNewFolder( instance, nextFreeSequence++,
 											 ( *candidateGrp )->displayName() );
@@ -1609,7 +1609,7 @@ void GroupWiseAccount::syncContact( GroupWiseContact * contact )
 
 			DeleteItemTask * dit = new DeleteItemTask( client()->rootTask() );
 			dit->item( folder->id, (*candidateInst)->id );
-			TQObject::connect( dit, TQT_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQT_SLOT( receiveContactDeleted( const ContactItem & ) ) );
+			TQObject::connect( dit, TQ_SIGNAL( gotContactDeleted( const ContactItem & ) ), TQ_SLOT( receiveContactDeleted( const ContactItem & ) ) );
 			dit->go( true );
 
 			instances.remove( candidateInst );
@@ -1636,7 +1636,7 @@ void GroupWiseAccount::syncContact( GroupWiseContact * contact )
 
 				UpdateContactTask * uct = new UpdateContactTask( client()->rootTask() );
 				uct->renameContact( contact->metaContact()->displayName(), instancesToChange );
-				TQObject::connect ( uct, TQT_SIGNAL( finished() ), contact, TQT_SLOT( renamedOnServer() ) );
+				TQObject::connect ( uct, TQ_SIGNAL( finished() ), contact, TQ_SLOT( renamedOnServer() ) );
 				uct->go( true );
 			}
  		}
diff --git a/kopete/protocols/groupwise/gwbytestream.cpp b/kopete/protocols/groupwise/gwbytestream.cpp
index 62bd272a..03cb46be 100644
--- a/kopete/protocols/groupwise/gwbytestream.cpp
+++ b/kopete/protocols/groupwise/gwbytestream.cpp
@@ -39,11 +39,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 ) ) );
 
 }
 
diff --git a/kopete/protocols/groupwise/gwconnector.cpp b/kopete/protocols/groupwise/gwconnector.cpp
index c5a073e3..8839762d 100644
--- a/kopete/protocols/groupwise/gwconnector.cpp
+++ b/kopete/protocols/groupwise/gwconnector.cpp
@@ -34,8 +34,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/groupwise/gwcontact.cpp b/kopete/protocols/groupwise/gwcontact.cpp
index 0c70b04c..fdea9eb2 100644
--- a/kopete/protocols/groupwise/gwcontact.cpp
+++ b/kopete/protocols/groupwise/gwcontact.cpp
@@ -56,8 +56,8 @@ GroupWiseContact::GroupWiseContact( Kopete::Account* account, const TQString &dn
 	{
 		m_dn = dn;
 	}
-	connect( static_cast< GroupWiseAccount *>( account ), TQT_SIGNAL( privacyChanged( const TQString &, bool ) ),
-			TQT_SLOT( receivePrivacyChanged( const TQString &, bool ) ) );
+	connect( static_cast< GroupWiseAccount *>( account ), TQ_SIGNAL( privacyChanged( const TQString &, bool ) ),
+			TQ_SLOT( receivePrivacyChanged( const TQString &, bool ) ) );
 	setOnlineStatus( ( parent && parent->isTemporary() ) ? protocol()->groupwiseUnknown : protocol()->groupwiseOffline );
 }
 
@@ -166,7 +166,7 @@ TQPtrList<TDEAction> *GroupWiseContact::customContextMenuActions()
 	TQString label = account()->isContactBlocked( m_dn ) ? i18n( "Unblock User" ) : i18n( "Block User" );
 	if( !m_actionBlock )
 	{
-		m_actionBlock = new TDEAction( label, "msn_blocked",0, this, TQT_SLOT( slotBlock() ),
+		m_actionBlock = new TDEAction( label, "msn_blocked",0, this, TQ_SLOT( slotBlock() ),
 			this, "actionBlock" );
 	}
 	else
diff --git a/kopete/protocols/groupwise/gwmessagemanager.cpp b/kopete/protocols/groupwise/gwmessagemanager.cpp
index cf0c3225..de9151ed 100644
--- a/kopete/protocols/groupwise/gwmessagemanager.cpp
+++ b/kopete/protocols/groupwise/gwmessagemanager.cpp
@@ -53,22 +53,22 @@ GroupWiseChatSession::GroupWiseChatSession(const Kopete::Contact* user, Kopete::
 	// make sure Kopete knows about this instance
 	Kopete::ChatSessionManager::self()->registerChatSession ( this );
 
-	connect ( this, TQT_SIGNAL( messageSent ( Kopete::Message &, Kopete::ChatSession * ) ),
-			  TQT_SLOT( slotMessageSent ( Kopete::Message &, Kopete::ChatSession * ) ) );
-	connect( this, TQT_SIGNAL( myselfTyping ( bool ) ), TQT_SLOT( slotSendTypingNotification ( bool ) ) );
-	connect( account(), TQT_SIGNAL( contactTyping( const ConferenceEvent & ) ), 
-						TQT_SLOT( slotGotTypingNotification( const ConferenceEvent & ) ) );
-	connect( account(), TQT_SIGNAL( contactNotTyping( const ConferenceEvent & ) ), 
-						TQT_SLOT( slotGotNotTypingNotification( const ConferenceEvent & ) ) );
+	connect ( this, TQ_SIGNAL( messageSent ( Kopete::Message &, Kopete::ChatSession * ) ),
+			  TQ_SLOT( slotMessageSent ( Kopete::Message &, Kopete::ChatSession * ) ) );
+	connect( this, TQ_SIGNAL( myselfTyping ( bool ) ), TQ_SLOT( slotSendTypingNotification ( bool ) ) );
+	connect( account(), TQ_SIGNAL( contactTyping( const ConferenceEvent & ) ), 
+						TQ_SLOT( slotGotTypingNotification( const ConferenceEvent & ) ) );
+	connect( account(), TQ_SIGNAL( contactNotTyping( const ConferenceEvent & ) ), 
+						TQ_SLOT( slotGotNotTypingNotification( const ConferenceEvent & ) ) );
 	
 	// Set up the Invite menu
 	m_actionInvite = new TDEActionMenu( i18n( "&Invite" ), actionCollection() , "gwInvite" );
-	connect( m_actionInvite->popupMenu(), TQT_SIGNAL( aboutToShow() ), this, TQT_SLOT(slotActionInviteAboutToShow() ) ) ;
+	connect( m_actionInvite->popupMenu(), TQ_SIGNAL( aboutToShow() ), this, TQ_SLOT(slotActionInviteAboutToShow() ) ) ;
 	
-	m_secure = new TDEAction( i18n( "Security Status" ), "encrypted", TDEShortcut(), this, TQT_SLOT( slotShowSecurity() ), actionCollection(), "gwSecureChat" );
+	m_secure = new TDEAction( i18n( "Security Status" ), "encrypted", TDEShortcut(), this, TQ_SLOT( slotShowSecurity() ), actionCollection(), "gwSecureChat" );
 	m_secure->setToolTip( i18n( "Conversation is secure" ) );
 	
-	m_logging = new TDEAction( i18n( "Archiving Status" ), "logchat", TDEShortcut(), this, TQT_SLOT( slotShowArchiving() ), actionCollection(), "gwLoggingChat" );
+	m_logging = new TDEAction( i18n( "Archiving Status" ), "logchat", TDEShortcut(), this, TQ_SLOT( slotShowArchiving() ), actionCollection(), "gwLoggingChat" );
 	updateArchiving();
 	
 	setXMLFile("gwchatui.rc");
@@ -154,8 +154,8 @@ void GroupWiseChatSession::createConference()
 			invitees.append( static_cast< GroupWiseContact * >( contact )->dn() );
 		}
 		// this is where we will set the GUID and send any pending messages
-		connect( account(), TQT_SIGNAL( conferenceCreated( const int, const GroupWise::ConferenceGuid & ) ), TQT_SLOT( receiveGuid( const int, const GroupWise::ConferenceGuid & ) ) );
-		connect( account(), TQT_SIGNAL( conferenceCreationFailed( const int, const int ) ), TQT_SLOT( slotCreationFailed( const int, const int ) ) );
+		connect( account(), TQ_SIGNAL( conferenceCreated( const int, const GroupWise::ConferenceGuid & ) ), TQ_SLOT( receiveGuid( const int, const GroupWise::ConferenceGuid & ) ) );
+		connect( account(), TQ_SIGNAL( conferenceCreationFailed( const int, const int ) ), TQ_SLOT( slotCreationFailed( const int, const int ) ) );
 		
 		// create the conference
 		account()->createConference( mmId(), invitees );
@@ -310,13 +310,13 @@ void GroupWiseChatSession::slotActionInviteAboutToShow()
 		if( !members().contains( it.current() ) && it.current()->isOnline() && it.current() != myself() )
 		{
 			TDEAction *a=new KopeteContactAction( it.current(), this,
-				TQT_SLOT( slotInviteContact( Kopete::Contact * ) ), m_actionInvite );
+				TQ_SLOT( slotInviteContact( Kopete::Contact * ) ), m_actionInvite );
 			m_actionInvite->insert( a );
 			m_inviteActions.append( a ) ;
 		}
 	}
 	// Invite someone off-list
-	TDEAction *b=new TDEAction( i18n ("&Other..."), 0, this, TQT_SLOT( slotInviteOtherContact() ), m_actionInvite, "actionOther" );
+	TDEAction *b=new TDEAction( i18n ("&Other..."), 0, this, TQ_SLOT( slotInviteOtherContact() ), m_actionInvite, "actionOther" );
 	m_actionInvite->insert( b );
 	m_inviteActions.append( b ) ;
 }
@@ -363,7 +363,7 @@ void GroupWiseChatSession::slotInviteOtherContact()
 		m_searchDlg = new KDialogBase( w, "invitesearchdialog", false, i18n( "Search for Contact to Invite" ), KDialogBase::Ok|KDialogBase::Cancel );
 		m_search = new GroupWiseContactSearch( account(), TQListView::Single, true, m_searchDlg, "invitesearchwidget" );
 		m_searchDlg->setMainWidget( m_search );
-		connect( m_search, TQT_SIGNAL( selectionValidates( bool ) ), m_searchDlg, TQT_SLOT( enableButtonOK( bool ) ) );
+		connect( m_search, TQ_SIGNAL( selectionValidates( bool ) ), m_searchDlg, TQ_SLOT( enableButtonOK( bool ) ) );
 		m_searchDlg->enableButtonOK( false );
 	}
 	m_searchDlg->show();
diff --git a/kopete/protocols/groupwise/libgroupwise/chatroommanager.cpp b/kopete/protocols/groupwise/libgroupwise/chatroommanager.cpp
index 3ee9b947..bedf8d64 100644
--- a/kopete/protocols/groupwise/libgroupwise/chatroommanager.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/chatroommanager.cpp
@@ -52,7 +52,7 @@ void ChatroomManager::getChatrooms( bool refresh )
 	m_replace = !refresh;
 	SearchChatTask * sct = new SearchChatTask( m_client->rootTask() );
 	sct->search( ( refresh ? SearchChatTask::SinceLastSearch : SearchChatTask::FetchAll ) );
-	connect( sct, TQT_SIGNAL( finished() ), TQT_SLOT( slotGotChatroomList() ) );
+	connect( sct, TQ_SIGNAL( finished() ), TQ_SLOT( slotGotChatroomList() ) );
 	sct->go( true );
 }
 
@@ -80,7 +80,7 @@ void ChatroomManager::slotGotChatroomList()
 void ChatroomManager::updateCounts()
 {
 	ChatCountsTask * cct = new ChatCountsTask( m_client->rootTask() );
-	connect( cct, TQT_SIGNAL( finished() ), TQT_SLOT( slotGotChatCounts() ) );
+	connect( cct, TQ_SIGNAL( finished() ), TQ_SLOT( slotGotChatCounts() ) );
 	cct->go( true );
 }
 
@@ -108,7 +108,7 @@ void ChatroomManager::requestProperties( const TQString & displayName )
 	{
 		ChatPropertiesTask * cpt = new ChatPropertiesTask( m_client->rootTask() );
 		cpt->setChat( displayName );
-		connect ( cpt, TQT_SIGNAL( finished() ), TQT_SLOT( slotGotChatProperties() ) );
+		connect ( cpt, TQ_SIGNAL( finished() ), TQ_SLOT( slotGotChatProperties() ) );
 		cpt->go( true );
 	}
 }
diff --git a/kopete/protocols/groupwise/libgroupwise/client.cpp b/kopete/protocols/groupwise/libgroupwise/client.cpp
index 21c1b1d0..d9b5b385 100644
--- a/kopete/protocols/groupwise/libgroupwise/client.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/client.cpp
@@ -86,7 +86,7 @@ Client::Client(TQObject *par, uint protocolVersion )
 	d->protocolVersion = protocolVersion;
 	// Sends regular keepalives so the server knows we are still running
 	d->keepAliveTimer = new TQTimer( this );
-	connect( d->keepAliveTimer, TQT_SIGNAL( timeout() ), TQT_SLOT( sendKeepAlive() ) );
+	connect( d->keepAliveTimer, TQ_SIGNAL( timeout() ), TQ_SLOT( sendKeepAlive() ) );
 }
 
 Client::~Client()
@@ -100,12 +100,12 @@ Client::~Client()
 void Client::connectToServer( ClientStream *s, const NovellDN &server, bool auth )
 {
 	d->stream = s;
-	//connect(d->stream, TQT_SIGNAL(connected()), TQT_SLOT(streamConnected()));
-	//connect(d->stream, TQT_SIGNAL(handshaken()), TQT_SLOT(streamHandshaken()));
-	connect(d->stream, TQT_SIGNAL(error(int)), TQT_SLOT(streamError(int)));
-	//connect(d->stream, TQT_SIGNAL(sslCertificateReady(const TQSSLCert &)), TQT_SLOT(streamSSLCertificateReady(const TQSSLCert &)));
-	connect(d->stream, TQT_SIGNAL(readyRead()), TQT_SLOT(streamReadyRead()));
-	//connect(d->stream, TQT_SIGNAL(closeFinished()), TQT_SLOT(streamCloseFinished()));
+	//connect(d->stream, TQ_SIGNAL(connected()), TQ_SLOT(streamConnected()));
+	//connect(d->stream, TQ_SIGNAL(handshaken()), TQ_SLOT(streamHandshaken()));
+	connect(d->stream, TQ_SIGNAL(error(int)), TQ_SLOT(streamError(int)));
+	//connect(d->stream, TQ_SIGNAL(sslCertificateReady(const TQSSLCert &)), TQ_SLOT(streamSSLCertificateReady(const TQSSLCert &)));
+	connect(d->stream, TQ_SIGNAL(readyRead()), TQ_SLOT(streamReadyRead()));
+	//connect(d->stream, TQ_SIGNAL(closeFinished()), TQ_SLOT(streamCloseFinished()));
 
 	d->stream->connectToServer(server, auth);
 }
@@ -136,27 +136,27 @@ void Client::start( const TQString &host, const uint port, const TQString &userI
 	
 	LoginTask * login = new LoginTask( d->root );
 	
-	connect( login, TQT_SIGNAL( gotMyself( const GroupWise::ContactDetails &  ) ), 
-			this, TQT_SIGNAL( accountDetailsReceived( const GroupWise::ContactDetails & ) ) );
+	connect( login, TQ_SIGNAL( gotMyself( const GroupWise::ContactDetails &  ) ), 
+			this, TQ_SIGNAL( accountDetailsReceived( const GroupWise::ContactDetails & ) ) );
 			
-	connect( login, TQT_SIGNAL( gotFolder( const FolderItem & ) ), 
-			this, TQT_SIGNAL( folderReceived( const FolderItem & ) ) );
+	connect( login, TQ_SIGNAL( gotFolder( const FolderItem & ) ), 
+			this, TQ_SIGNAL( folderReceived( const FolderItem & ) ) );
 			
-	connect( login, TQT_SIGNAL( gotContact( const ContactItem &  ) ), 
-			this, TQT_SIGNAL( contactReceived( const ContactItem &  ) ) );
+	connect( login, TQ_SIGNAL( gotContact( const ContactItem &  ) ), 
+			this, TQ_SIGNAL( contactReceived( const ContactItem &  ) ) );
 			
-	connect( login, TQT_SIGNAL( gotContactUserDetails( const GroupWise::ContactDetails & ) ), 
-			this, TQT_SIGNAL( contactUserDetailsReceived( const GroupWise::ContactDetails & ) ) ) ;
+	connect( login, TQ_SIGNAL( gotContactUserDetails( const GroupWise::ContactDetails & ) ), 
+			this, TQ_SIGNAL( contactUserDetailsReceived( const GroupWise::ContactDetails & ) ) ) ;
 
-	connect( login, TQT_SIGNAL( gotPrivacySettings( bool, bool, const TQStringList &, const TQStringList & ) ),
-			privacyManager(), TQT_SLOT( slotGotPrivacySettings( bool, bool, const TQStringList &, const TQStringList & ) ) );
+	connect( login, TQ_SIGNAL( gotPrivacySettings( bool, bool, const TQStringList &, const TQStringList & ) ),
+			privacyManager(), TQ_SLOT( slotGotPrivacySettings( bool, bool, const TQStringList &, const TQStringList & ) ) );
 
-	connect( login, TQT_SIGNAL( gotCustomStatus( const GroupWise::CustomStatus & ) ), 
-			TQT_SLOT( lt_gotCustomStatus( const GroupWise::CustomStatus & ) ) );
+	connect( login, TQ_SIGNAL( gotCustomStatus( const GroupWise::CustomStatus & ) ), 
+			TQ_SLOT( lt_gotCustomStatus( const GroupWise::CustomStatus & ) ) );
 
-	connect( login, TQT_SIGNAL( gotKeepalivePeriod( int ) ), TQT_SLOT( lt_gotKeepalivePeriod( int ) ) );
+	connect( login, TQ_SIGNAL( gotKeepalivePeriod( int ) ), TQ_SLOT( lt_gotKeepalivePeriod( int ) ) );
 
-	connect( login, TQT_SIGNAL( finished() ), this, TQT_SLOT( lt_loginFinished() ) );
+	connect( login, TQ_SIGNAL( finished() ), this, TQ_SLOT( lt_loginFinished() ) );
 	
 	login->initialise();
 	login->go( true );
@@ -194,26 +194,26 @@ void Client::initialiseEventTasks()
 {
 	// The StatusTask handles incoming status changes
 	StatusTask * st = new StatusTask( d->root ); // FIXME - add an additional EventRoot?
-	connect( st, TQT_SIGNAL( gotStatus( const TQString &, TQ_UINT16, const TQString & ) ), TQT_SIGNAL( statusReceived( const TQString &, TQ_UINT16, const TQString & ) ) );
+	connect( st, TQ_SIGNAL( gotStatus( const TQString &, TQ_UINT16, const TQString & ) ), TQ_SIGNAL( statusReceived( const TQString &, TQ_UINT16, const TQString & ) ) );
 	// The ConferenceTask handles incoming conference events, messages, joins, leaves, etc
 	ConferenceTask * ct = new ConferenceTask( d->root ); 
-	connect( ct, TQT_SIGNAL( message( const ConferenceEvent & ) ), TQT_SLOT( ct_messageReceived( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( typing( const ConferenceEvent & ) ), TQT_SIGNAL( contactTyping( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( notTyping( const ConferenceEvent & ) ), TQT_SIGNAL( contactNotTyping( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( joined( const ConferenceEvent & ) ), TQT_SIGNAL( conferenceJoinNotifyReceived( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( left( const ConferenceEvent & ) ), TQT_SIGNAL( conferenceLeft( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( invited( const ConferenceEvent & ) ), TQT_SIGNAL( invitationReceived( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( otherInvited( const ConferenceEvent & ) ), TQT_SIGNAL( inviteNotifyReceived( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( invitationDeclined( const ConferenceEvent & ) ), TQT_SIGNAL( invitationDeclined( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( closed( const ConferenceEvent & ) ), TQT_SIGNAL( conferenceClosed( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( autoReply( const ConferenceEvent & ) ), TQT_SIGNAL( autoReplyReceived( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( broadcast( const ConferenceEvent & ) ), TQT_SIGNAL( broadcastReceived( const ConferenceEvent & ) ) );
-	connect( ct, TQT_SIGNAL( systemBroadcast( const ConferenceEvent & ) ), TQT_SIGNAL( systemBroadcastReceived( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( message( const ConferenceEvent & ) ), TQ_SLOT( ct_messageReceived( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( typing( const ConferenceEvent & ) ), TQ_SIGNAL( contactTyping( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( notTyping( const ConferenceEvent & ) ), TQ_SIGNAL( contactNotTyping( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( joined( const ConferenceEvent & ) ), TQ_SIGNAL( conferenceJoinNotifyReceived( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( left( const ConferenceEvent & ) ), TQ_SIGNAL( conferenceLeft( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( invited( const ConferenceEvent & ) ), TQ_SIGNAL( invitationReceived( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( otherInvited( const ConferenceEvent & ) ), TQ_SIGNAL( inviteNotifyReceived( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( invitationDeclined( const ConferenceEvent & ) ), TQ_SIGNAL( invitationDeclined( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( closed( const ConferenceEvent & ) ), TQ_SIGNAL( conferenceClosed( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( autoReply( const ConferenceEvent & ) ), TQ_SIGNAL( autoReplyReceived( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( broadcast( const ConferenceEvent & ) ), TQ_SIGNAL( broadcastReceived( const ConferenceEvent & ) ) );
+	connect( ct, TQ_SIGNAL( systemBroadcast( const ConferenceEvent & ) ), TQ_SIGNAL( systemBroadcastReceived( const ConferenceEvent & ) ) );
 	
 
 	// The ConnectionTask handles incoming connection events
 	ConnectionTask* cont = new ConnectionTask( d->root );
-	connect( cont, TQT_SIGNAL( connectedElsewhere() ), TQT_SIGNAL( connectedElsewhere() ) );
+	connect( cont, TQ_SIGNAL( connectedElsewhere() ), TQ_SIGNAL( connectedElsewhere() ) );
 }
 
 void Client::setStatus( GroupWise::Status status, const TQString & reason, const TQString & autoReply )
@@ -221,7 +221,7 @@ void Client::setStatus( GroupWise::Status status, const TQString & reason, const
 	debug( TQString("Setting status to %1").arg( status ) );;
 	SetStatusTask * sst = new SetStatusTask( d->root );
 	sst->status( status, reason, autoReply );
-	connect( sst, TQT_SIGNAL( finished() ), this, TQT_SLOT( sst_statusChanged() ) );
+	connect( sst, TQ_SIGNAL( finished() ), this, TQ_SLOT( sst_statusChanged() ) );
 	sst->go( true );
 	// TODO: set status change in progress flag
 }
@@ -230,7 +230,7 @@ void Client::requestStatus( const TQString & userDN )
 {
 	GetStatusTask * gst = new GetStatusTask( d->root );
 	gst->userDN( userDN );
-	connect( gst, TQT_SIGNAL( gotStatus( const TQString &, TQ_UINT16, const TQString & ) ), TQT_SIGNAL( statusReceived( const TQString &, TQ_UINT16, const TQString & ) ) );
+	connect( gst, TQ_SIGNAL( gotStatus( const TQString &, TQ_UINT16, const TQString & ) ), TQ_SIGNAL( statusReceived( const TQString &, TQ_UINT16, const TQString & ) ) );
 	gst->go( true );
 }
 
@@ -238,7 +238,7 @@ void Client::sendMessage( const TQStringList & addresseeDNs, const OutgoingMessa
 {
 	SendMessageTask * smt = new SendMessageTask( d->root );
 	smt->message( addresseeDNs, message );
-	connect( smt, TQT_SIGNAL( finished() ), TQT_SLOT( smt_messageSent() ) );
+	connect( smt, TQ_SIGNAL( finished() ), TQ_SLOT( smt_messageSent() ) );
 	smt->go( true );
 }
 
@@ -259,15 +259,15 @@ void Client::createConference( const int clientId, const TQStringList & particip
 {
 	CreateConferenceTask * cct = new CreateConferenceTask( d->root );
 	cct->conference( clientId, participants );
-	connect( cct, TQT_SIGNAL( finished() ), TQT_SLOT( cct_conferenceCreated() ) );
+	connect( cct, TQ_SIGNAL( finished() ), TQ_SLOT( cct_conferenceCreated() ) );
 	cct->go( true );
 }
 void Client::requestDetails( const TQStringList & userDNs )
 {
 	GetDetailsTask * gdt = new GetDetailsTask( d->root );
 	gdt->userDNs( userDNs );
-	connect( gdt, TQT_SIGNAL( gotContactUserDetails( const GroupWise::ContactDetails & ) ),
-			this, TQT_SIGNAL( contactUserDetailsReceived( const GroupWise::ContactDetails & ) ) );
+	connect( gdt, TQ_SIGNAL( gotContactUserDetails( const GroupWise::ContactDetails & ) ),
+			this, TQ_SIGNAL( contactUserDetailsReceived( const GroupWise::ContactDetails & ) ) );
 	gdt->go( true );
 }
 
@@ -275,7 +275,7 @@ void Client::joinConference( const GroupWise::ConferenceGuid & guid )
 {
 	JoinConferenceTask * jct = new JoinConferenceTask( d->root );
 	jct->join( guid );
-	connect( jct, TQT_SIGNAL( finished() ), TQT_SLOT( jct_joinConfCompleted() ) );
+	connect( jct, TQ_SIGNAL( finished() ), TQ_SLOT( jct_joinConfCompleted() ) );
 	jct->go( true );
 }
 
@@ -291,7 +291,7 @@ void Client::leaveConference( const GroupWise::ConferenceGuid & guid )
 {
 	LeaveConferenceTask * lct = new LeaveConferenceTask( d->root );
 	lct->leave( guid );
-	//connect( lct, TQT_SIGNAL( finished() ), TQT_SLOT( lct_leftConference() ) );
+	//connect( lct, TQ_SIGNAL( finished() ), TQ_SLOT( lct_leftConference() ) );
 	lct->go( true );
 }
 
diff --git a/kopete/protocols/groupwise/libgroupwise/gwclientstream.cpp b/kopete/protocols/groupwise/libgroupwise/gwclientstream.cpp
index 0c395159..5dce23a6 100644
--- a/kopete/protocols/groupwise/libgroupwise/gwclientstream.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/gwclientstream.cpp
@@ -149,13 +149,13 @@ ClientStream::ClientStream(Connector *conn, TLSHandler *tlsHandler, TQObject *pa
 	d = new Private;
 	d->mode = Client;
 	d->conn = conn;
-	connect( d->conn, TQT_SIGNAL(connected()), TQT_SLOT(cr_connected()) );
-	connect( d->conn, TQT_SIGNAL(error()), TQT_SLOT(cr_error()) );
-	connect( &d->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()));
 
 	d->tlsHandler = tlsHandler;		// all the extra stuff happening in the larger ctor happens at connect time :)
 }
@@ -446,17 +446,17 @@ 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, TQ_SIGNAL(connectionClosed()), TQ_SLOT(bs_connectionClosed()));
+	connect(d->bs, TQ_SIGNAL(delayedCloseFinished()), TQ_SLOT(bs_delayedCloseFinished()));
 
 	TQByteArray spare = d->bs->read();
 
 	d->ss = new SecureStream(d->bs);
-	connect(d->ss, TQT_SIGNAL(readyRead()), TQT_SLOT(ss_readyRead()));
-	connect(d->ss, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(ss_bytesWritten(int)));
-	connect(d->ss, TQT_SIGNAL(tlsHandshaken()), TQT_SLOT(ss_tlsHandshaken()));
-	connect(d->ss, TQT_SIGNAL(tlsClosed()), TQT_SLOT(ss_tlsClosed()));
-	connect(d->ss, TQT_SIGNAL(error(int)), TQT_SLOT(ss_error(int)));
+	connect(d->ss, TQ_SIGNAL(readyRead()), TQ_SLOT(ss_readyRead()));
+	connect(d->ss, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(ss_bytesWritten(int)));
+	connect(d->ss, TQ_SIGNAL(tlsHandshaken()), TQ_SLOT(ss_tlsHandshaken()));
+	connect(d->ss, TQ_SIGNAL(tlsClosed()), TQ_SLOT(ss_tlsClosed()));
+	connect(d->ss, TQ_SIGNAL(error(int)), TQ_SLOT(ss_error(int)));
 
 	//d->client.startDialbackOut("andbit.net", "im.pyxa.org");
 	//d->client.startServerOut(d->server);
@@ -585,7 +585,7 @@ void ClientStream::processNext()
 {
 	if( !d->in.isEmpty() ) {
 		//d->in_rrsig = true;
-		TQTimer::singleShot(0, this, TQT_SLOT(doReadyRead()));
+		TQTimer::singleShot(0, this, TQ_SLOT(doReadyRead()));
 	}
 }
 
diff --git a/kopete/protocols/groupwise/libgroupwise/privacymanager.cpp b/kopete/protocols/groupwise/libgroupwise/privacymanager.cpp
index 4960310a..7d81b7ea 100644
--- a/kopete/protocols/groupwise/libgroupwise/privacymanager.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/privacymanager.cpp
@@ -97,7 +97,7 @@ void PrivacyManager::setDefaultAllow( bool allow )
 {
 	PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 	pit->defaultPolicy( !allow );
-	connect( pit, TQT_SIGNAL( finished() ), TQT_SLOT( slotDefaultPolicyChanged() ) );
+	connect( pit, TQ_SIGNAL( finished() ), TQ_SLOT( slotDefaultPolicyChanged() ) );
 	pit->go( true );
 }
 
@@ -105,7 +105,7 @@ void PrivacyManager::setDefaultDeny( bool deny )
 {
 	PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 	pit->defaultPolicy( deny);
-	connect( pit, TQT_SIGNAL( finished() ), TQT_SLOT( slotDefaultPolicyChanged() ) );
+	connect( pit, TQ_SIGNAL( finished() ), TQ_SLOT( slotDefaultPolicyChanged() ) );
 	pit->go( true );
 }
 
@@ -114,7 +114,7 @@ void PrivacyManager::addAllow( const TQString & dn )
 	// start off a CreatePrivacyItemTask
 	PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 	pit->allow( dn );
-	connect( pit, TQT_SIGNAL( finished() ), TQT_SLOT( slotAllowAdded() ) );
+	connect( pit, TQ_SIGNAL( finished() ), TQ_SLOT( slotAllowAdded() ) );
 	pit->go( true );
 }
 
@@ -123,7 +123,7 @@ void PrivacyManager::addDeny( const TQString & dn )
 	// start off a CreatePrivacyItemTask
 	PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 	pit->deny( dn );
-	connect( pit, TQT_SIGNAL( finished() ), TQT_SLOT( slotDenyAdded() ) );
+	connect( pit, TQ_SIGNAL( finished() ), TQ_SLOT( slotDenyAdded() ) );
 	pit->go( true );
 }
 
@@ -131,7 +131,7 @@ void PrivacyManager::removeAllow( const TQString & dn )
 {
 	PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 	pit->removeAllow( dn );
-	connect( pit, TQT_SIGNAL( finished() ), TQT_SLOT( slotAllowRemoved() ) );
+	connect( pit, TQ_SIGNAL( finished() ), TQ_SLOT( slotAllowRemoved() ) );
 	pit->go( true );
 }
 
@@ -140,7 +140,7 @@ void PrivacyManager::removeDeny( const TQString & dn )
 	// start off a CreatePrivacyItemTask
 	PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 	pit->removeDeny( dn );
-	connect( pit, TQT_SIGNAL( finished() ), TQT_SLOT( slotDenyRemoved() ) );
+	connect( pit, TQ_SIGNAL( finished() ), TQ_SLOT( slotDenyRemoved() ) );
 	pit->go( true );
 }
 
diff --git a/kopete/protocols/groupwise/libgroupwise/qcatlshandler.cpp b/kopete/protocols/groupwise/libgroupwise/qcatlshandler.cpp
index 372d7d9a..d5d7aaa6 100644
--- a/kopete/protocols/groupwise/libgroupwise/qcatlshandler.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/qcatlshandler.cpp
@@ -35,11 +35,11 @@ TQCATLSHandler::TQCATLSHandler(TQCA::TLS *parent)
 {
 	d = new Private;
 	d->tls = parent;
-	connect(d->tls, TQT_SIGNAL(handshaken()), TQT_SLOT(tls_handshaken()));
-	connect(d->tls, TQT_SIGNAL(readyRead()), TQT_SLOT(tls_readyRead()));
-	connect(d->tls, TQT_SIGNAL(readyReadOutgoing(int)), TQT_SLOT(tls_readyReadOutgoing(int)));
-	connect(d->tls, TQT_SIGNAL(closed()), TQT_SLOT(tls_closed()));
-	connect(d->tls, TQT_SIGNAL(error(int)), TQT_SLOT(tls_error(int)));
+	connect(d->tls, TQ_SIGNAL(handshaken()), TQ_SLOT(tls_handshaken()));
+	connect(d->tls, TQ_SIGNAL(readyRead()), TQ_SLOT(tls_readyRead()));
+	connect(d->tls, TQ_SIGNAL(readyReadOutgoing(int)), TQ_SLOT(tls_readyReadOutgoing(int)));
+	connect(d->tls, TQ_SIGNAL(closed()), TQ_SLOT(tls_closed()));
+	connect(d->tls, TQ_SIGNAL(error(int)), TQ_SLOT(tls_error(int)));
 	d->state = 0;
 	d->err = -1;
 }
@@ -70,7 +70,7 @@ void TQCATLSHandler::startClient(const TQString &host)
 	d->state = 0;
 	d->err = -1;
 	if(!d->tls->startClient(host))
-		TQTimer::singleShot(0, this, TQT_SIGNAL(fail()));
+		TQTimer::singleShot(0, this, TQ_SIGNAL(fail()));
 }
 
 void TQCATLSHandler::write(const TQByteArray &a)
diff --git a/kopete/protocols/groupwise/libgroupwise/safedelete.cpp b/kopete/protocols/groupwise/libgroupwise/safedelete.cpp
index 9de147f0..2b466e68 100644
--- a/kopete/protocols/groupwise/libgroupwise/safedelete.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/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/groupwise/libgroupwise/securestream.cpp b/kopete/protocols/groupwise/libgroupwise/securestream.cpp
index 656f7e43..10784d1c 100644
--- a/kopete/protocols/groupwise/libgroupwise/securestream.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/securestream.cpp
@@ -91,11 +91,11 @@ SecureLayer::SecureLayer(TQCA::TLS *t)
 	type = TLS;
 	p.tls = t;
 	init();
-	connect(p.tls, TQT_SIGNAL(handshaken()), TQT_SLOT(tls_handshaken()));
-	connect(p.tls, TQT_SIGNAL(readyRead()), TQT_SLOT(tls_readyRead()));
-	connect(p.tls, TQT_SIGNAL(readyReadOutgoing(int)), TQT_SLOT(tls_readyReadOutgoing(int)));
-	connect(p.tls, TQT_SIGNAL(closed()), TQT_SLOT(tls_closed()));
-	connect(p.tls, TQT_SIGNAL(error(int)), TQT_SLOT(tls_error(int)));
+	connect(p.tls, TQ_SIGNAL(handshaken()), TQ_SLOT(tls_handshaken()));
+	connect(p.tls, TQ_SIGNAL(readyRead()), TQ_SLOT(tls_readyRead()));
+	connect(p.tls, TQ_SIGNAL(readyReadOutgoing(int)), TQ_SLOT(tls_readyReadOutgoing(int)));
+	connect(p.tls, TQ_SIGNAL(closed()), TQ_SLOT(tls_closed()));
+	connect(p.tls, TQ_SIGNAL(error(int)), TQ_SLOT(tls_error(int)));
 }
 
 SecureLayer::SecureLayer(TQCA::SASL *s)
@@ -103,9 +103,9 @@ SecureLayer::SecureLayer(TQCA::SASL *s)
 	type = SASL;
 	p.sasl = s;
 	init();
-	connect(p.sasl, TQT_SIGNAL(readyRead()), TQT_SLOT(sasl_readyRead()));
-	connect(p.sasl, TQT_SIGNAL(readyReadOutgoing(int)), TQT_SLOT(sasl_readyReadOutgoing(int)));
-	connect(p.sasl, TQT_SIGNAL(error(int)), TQT_SLOT(sasl_error(int)));
+	connect(p.sasl, TQ_SIGNAL(readyRead()), TQ_SLOT(sasl_readyRead()));
+	connect(p.sasl, TQ_SIGNAL(readyReadOutgoing(int)), TQ_SLOT(sasl_readyReadOutgoing(int)));
+	connect(p.sasl, TQ_SIGNAL(error(int)), TQ_SLOT(sasl_error(int)));
 }
 
 #ifdef USE_TLSHANDLER
@@ -114,11 +114,11 @@ SecureLayer::SecureLayer(TLSHandler *t)
 	type = TLSH;
 	p.tlsHandler = t;
 	init();
-	connect(p.tlsHandler, TQT_SIGNAL(success()), TQT_SLOT(tlsHandler_success()));
-	connect(p.tlsHandler, TQT_SIGNAL(fail()), TQT_SLOT(tlsHandler_fail()));
-	connect(p.tlsHandler, TQT_SIGNAL(closed()), TQT_SLOT(tlsHandler_closed()));
-	connect(p.tlsHandler, TQT_SIGNAL(readyRead(const TQByteArray &)), TQT_SLOT(tlsHandler_readyRead(const TQByteArray &)));
-	connect(p.tlsHandler, TQT_SIGNAL(readyReadOutgoing(const TQByteArray &, int)), TQT_SLOT(tlsHandler_readyReadOutgoing(const TQByteArray &, int)));
+	connect(p.tlsHandler, TQ_SIGNAL(success()), TQ_SLOT(tlsHandler_success()));
+	connect(p.tlsHandler, TQ_SIGNAL(fail()), TQ_SLOT(tlsHandler_fail()));
+	connect(p.tlsHandler, TQ_SIGNAL(closed()), TQ_SLOT(tlsHandler_closed()));
+	connect(p.tlsHandler, TQ_SIGNAL(readyRead(const TQByteArray &)), TQ_SLOT(tlsHandler_readyRead(const TQByteArray &)));
+	connect(p.tlsHandler, TQ_SIGNAL(readyReadOutgoing(const TQByteArray &, int)), TQ_SLOT(tlsHandler_readyReadOutgoing(const TQByteArray &, int)));
 }
 #endif
 
@@ -297,8 +297,8 @@ SecureStream::SecureStream(ByteStream *s)
 	d = new Private;
 
 	d->bs = s;
-	connect(d->bs, TQT_SIGNAL(readyRead()), TQT_SLOT(bs_readyRead()));
-	connect(d->bs, TQT_SIGNAL(bytesWritten(int)), TQT_SLOT(bs_bytesWritten(int)));
+	connect(d->bs, TQ_SIGNAL(readyRead()), TQ_SLOT(bs_readyRead()));
+	connect(d->bs, TQ_SIGNAL(bytesWritten(int)), TQ_SLOT(bs_bytesWritten(int)));
 
 	d->layers.setAutoDelete(true);
 	d->pending = 0;
@@ -313,11 +313,11 @@ SecureStream::~SecureStream()
 
 void SecureStream::linkLayer(TQObject *s)
 {
-	connect(s, TQT_SIGNAL(tlsHandshaken()), TQT_SLOT(layer_tlsHandshaken()));
-	connect(s, TQT_SIGNAL(tlsClosed(const TQByteArray &)), TQT_SLOT(layer_tlsClosed(const TQByteArray &)));
-	connect(s, TQT_SIGNAL(readyRead(const TQByteArray &)), TQT_SLOT(layer_readyRead(const TQByteArray &)));
-	connect(s, TQT_SIGNAL(needWrite(const TQByteArray &)), TQT_SLOT(layer_needWrite(const TQByteArray &)));
-	connect(s, TQT_SIGNAL(error(int)), TQT_SLOT(layer_error(int)));
+	connect(s, TQ_SIGNAL(tlsHandshaken()), TQ_SLOT(layer_tlsHandshaken()));
+	connect(s, TQ_SIGNAL(tlsClosed(const TQByteArray &)), TQ_SLOT(layer_tlsClosed(const TQByteArray &)));
+	connect(s, TQ_SIGNAL(readyRead(const TQByteArray &)), TQ_SLOT(layer_readyRead(const TQByteArray &)));
+	connect(s, TQ_SIGNAL(needWrite(const TQByteArray &)), TQ_SLOT(layer_needWrite(const TQByteArray &)));
+	connect(s, TQ_SIGNAL(error(int)), TQ_SLOT(layer_error(int)));
 }
 
 int SecureStream::calcPrebytes() const
diff --git a/kopete/protocols/groupwise/libgroupwise/task.cpp b/kopete/protocols/groupwise/libgroupwise/task.cpp
index 547844d9..f206b6bb 100644
--- a/kopete/protocols/groupwise/libgroupwise/task.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/task.cpp
@@ -48,7 +48,7 @@ Task::Task(Task *parent)
 	d->transfer = 0;
 	d->client = parent->client();
 	d->id = client()->genUniqueId();
-	connect(d->client, TQT_SIGNAL(disconnected()), TQT_SLOT(clientDisconnected()));
+	connect(d->client, TQ_SIGNAL(disconnected()), TQ_SLOT(clientDisconnected()));
 }
 
 Task::Task(Client *parent, bool)
@@ -57,7 +57,7 @@ Task::Task(Client *parent, bool)
 	init();
 
 	d->client = parent;
-	connect(d->client, TQT_SIGNAL(disconnected()), TQT_SLOT(clientDisconnected()));
+	connect(d->client, TQ_SIGNAL(disconnected()), TQ_SLOT(clientDisconnected()));
 }
 
 Task::~Task()
@@ -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/groupwise/libgroupwise/tasks/conferencetask.cpp b/kopete/protocols/groupwise/libgroupwise/tasks/conferencetask.cpp
index c88e22b4..496af2cc 100644
--- a/kopete/protocols/groupwise/libgroupwise/tasks/conferencetask.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tasks/conferencetask.cpp
@@ -42,8 +42,8 @@ ConferenceTask::ConferenceTask( Task* parent )
 	registerEvent( GroupWise::ReceivedSystemBroadcast );
 
 	// listen to the UserDetailsManager telling us that user details are available
-	connect( client()->userDetailsManager(), TQT_SIGNAL( gotContactDetails( const GroupWise::ContactDetails & ) ), 
-		TQT_SLOT( slotReceiveUserDetails( const GroupWise::ContactDetails & ) ) );
+	connect( client()->userDetailsManager(), TQ_SIGNAL( gotContactDetails( const GroupWise::ContactDetails & ) ), 
+		TQ_SLOT( slotReceiveUserDetails( const GroupWise::ContactDetails & ) ) );
 }
 
 
diff --git a/kopete/protocols/groupwise/libgroupwise/tasks/createcontactinstancetask.cpp b/kopete/protocols/groupwise/libgroupwise/tasks/createcontactinstancetask.cpp
index d41db4a9..31c077f7 100644
--- a/kopete/protocols/groupwise/libgroupwise/tasks/createcontactinstancetask.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tasks/createcontactinstancetask.cpp
@@ -24,7 +24,7 @@
 CreateContactInstanceTask::CreateContactInstanceTask(Task* parent) : NeedFolderTask(parent)
 {
 	// make the client tell the client app (Kopete) when we receive a contact
-	connect( this, TQT_SIGNAL( gotContactAdded( const ContactItem & ) ), client(), TQT_SIGNAL( contactReceived( const ContactItem & ) ) );
+	connect( this, TQ_SIGNAL( gotContactAdded( const ContactItem & ) ), client(), TQ_SIGNAL( contactReceived( const ContactItem & ) ) );
 }
 
 CreateContactInstanceTask::~CreateContactInstanceTask()
diff --git a/kopete/protocols/groupwise/libgroupwise/tasks/createcontacttask.cpp b/kopete/protocols/groupwise/libgroupwise/tasks/createcontacttask.cpp
index 0d167236..2c3daf55 100644
--- a/kopete/protocols/groupwise/libgroupwise/tasks/createcontacttask.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tasks/createcontacttask.cpp
@@ -76,8 +76,8 @@ void CreateContactTask::onGo()
 		// the add contact action may cause other contacts' sequence numbers to change
 		// CreateContactInstanceTask signals these changes, so we propagate the signal via the Client, to the GroupWiseAccount
 		// This updates our local versions of those contacts using the same mechanism by which they are updated at login.
-		connect( ccit, TQT_SIGNAL( gotContactAdded( const ContactItem & ) ), TQT_SLOT( slotContactAdded( const ContactItem & ) ) );
-        connect( ccit, TQT_SIGNAL( finished() ), TQT_SLOT( slotCheckContactInstanceCreated() ) );
+		connect( ccit, TQ_SIGNAL( gotContactAdded( const ContactItem & ) ), TQ_SLOT( slotContactAdded( const ContactItem & ) ) );
+        connect( ccit, TQ_SIGNAL( finished() ), TQ_SLOT( slotCheckContactInstanceCreated() ) );
 		if ( (*it).id == 0 ) // caller asserts that this isn't on the server...
 		{
 			ccit->contactFromDNAndFolder( m_userId, m_displayName, m_firstSequenceNumber++, ( *it ).name );
@@ -92,8 +92,8 @@ void CreateContactTask::onGo()
 	{
 		client()->debug( " - contact is in top level folder " );
 		CreateContactInstanceTask * ccit = new CreateContactInstanceTask( client()->rootTask() );
-		connect( ccit, TQT_SIGNAL( gotContactAdded( const ContactItem & ) ), TQT_SLOT( slotContactAdded( const ContactItem & ) ) );
-        connect( ccit, TQT_SIGNAL( finished() ), TQT_SLOT( slotCheckContactInstanceCreated() ) );
+		connect( ccit, TQ_SIGNAL( gotContactAdded( const ContactItem & ) ), TQ_SLOT( slotContactAdded( const ContactItem & ) ) );
+        connect( ccit, TQ_SIGNAL( finished() ), TQ_SLOT( slotCheckContactInstanceCreated() ) );
 		ccit->contactFromDN( m_userId, m_displayName, 0 );
 		ccit->go( true );
 	}
diff --git a/kopete/protocols/groupwise/libgroupwise/tasks/joinconferencetask.cpp b/kopete/protocols/groupwise/libgroupwise/tasks/joinconferencetask.cpp
index b7b1f1cc..a606008e 100644
--- a/kopete/protocols/groupwise/libgroupwise/tasks/joinconferencetask.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tasks/joinconferencetask.cpp
@@ -113,8 +113,8 @@ bool JoinConferenceTask::take( Transfer * transfer )
 			{
 				client()->debug( "JoinConferenceTask::slotReceiveUserDetails(), requesting details" );
 				connect( client()->userDetailsManager(), 
-						TQT_SIGNAL( gotContactDetails( const GroupWise::ContactDetails & ) ),
-						TQT_SLOT( slotReceiveUserDetails( const GroupWise::ContactDetails & ) ) );
+						TQ_SIGNAL( gotContactDetails( const GroupWise::ContactDetails & ) ),
+						TQ_SLOT( slotReceiveUserDetails( const GroupWise::ContactDetails & ) ) );
 				client()->userDetailsManager()->requestDetails( m_unknowns );
 			}
 		}
diff --git a/kopete/protocols/groupwise/libgroupwise/tasks/movecontacttask.cpp b/kopete/protocols/groupwise/libgroupwise/tasks/movecontacttask.cpp
index 4a24f44f..c70eb37e 100644
--- a/kopete/protocols/groupwise/libgroupwise/tasks/movecontacttask.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tasks/movecontacttask.cpp
@@ -25,7 +25,7 @@
 MoveContactTask::MoveContactTask(Task* parent): NeedFolderTask(parent)
 {
 	// make the client tell the client app (Kopete) when we receive a contact
-	connect( this, TQT_SIGNAL( gotContactAdded( const ContactItem & ) ), client(), TQT_SIGNAL( contactReceived( const ContactItem & ) ) );
+	connect( this, TQ_SIGNAL( gotContactAdded( const ContactItem & ) ), client(), TQ_SIGNAL( contactReceived( const ContactItem & ) ) );
 }
 
 
diff --git a/kopete/protocols/groupwise/libgroupwise/tasks/needfoldertask.cpp b/kopete/protocols/groupwise/libgroupwise/tasks/needfoldertask.cpp
index 12c7382a..c1cb696c 100644
--- a/kopete/protocols/groupwise/libgroupwise/tasks/needfoldertask.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tasks/needfoldertask.cpp
@@ -27,9 +27,9 @@ void NeedFolderTask::createFolder()
 {
 	CreateFolderTask * cct = new CreateFolderTask( client()->rootTask() );
 	cct->folder( 0, m_folderSequence, m_folderDisplayName );
-	connect( cct, TQT_SIGNAL( gotFolderAdded( const FolderItem & ) ), client(), TQT_SIGNAL( folderReceived( const FolderItem & ) ) );
-	connect( cct, TQT_SIGNAL( gotFolderAdded( const FolderItem & ) ), TQT_SLOT( slotFolderAdded( const FolderItem & ) ) );
-	connect( cct, TQT_SIGNAL( finished() ), TQT_SLOT( slotFolderTaskFinished() ) );
+	connect( cct, TQ_SIGNAL( gotFolderAdded( const FolderItem & ) ), client(), TQ_SIGNAL( folderReceived( const FolderItem & ) ) );
+	connect( cct, TQ_SIGNAL( gotFolderAdded( const FolderItem & ) ), TQ_SLOT( slotFolderAdded( const FolderItem & ) ) );
+	connect( cct, TQ_SIGNAL( finished() ), TQ_SLOT( slotFolderTaskFinished() ) );
 	cct->go( true );
 }
 
diff --git a/kopete/protocols/groupwise/libgroupwise/tasks/searchchattask.cpp b/kopete/protocols/groupwise/libgroupwise/tasks/searchchattask.cpp
index 87694eb4..10a1ba82 100644
--- a/kopete/protocols/groupwise/libgroupwise/tasks/searchchattask.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tasks/searchchattask.cpp
@@ -75,7 +75,7 @@ bool SearchChatTask::take( Transfer * transfer )
 	m_objectId = sf->value().toInt();
 
 	// now start the results poll timer
-	TQTimer::singleShot( GW_POLL_INITIAL_DELAY, this, TQT_SLOT( slotPollForResults() ) );
+	TQTimer::singleShot( GW_POLL_INITIAL_DELAY, this, TQ_SLOT( slotPollForResults() ) );
 	return true;
 }
 
@@ -84,7 +84,7 @@ void SearchChatTask::slotPollForResults()
 	//create a PollSearchResultsTask
 	GetChatSearchResultsTask * gcsrt = new GetChatSearchResultsTask( client()->rootTask() );
 	gcsrt->poll( m_objectId );
-	connect( gcsrt, TQT_SIGNAL( finished() ), TQT_SLOT( slotGotPollResults() ) );
+	connect( gcsrt, TQ_SIGNAL( finished() ), TQ_SLOT( slotGotPollResults() ) );
 	gcsrt->go( true );
 }
 
@@ -97,14 +97,14 @@ void SearchChatTask::slotGotPollResults()
 	{
 		case GetChatSearchResultsTask::GettingData:
 			if ( m_polls < GW_POLL_MAXIMUM ) // restart timer
-				TQTimer::singleShot( GW_POLL_FREQUENCY_MS, this, TQT_SLOT( slotPollForResults() ) );
+				TQTimer::singleShot( GW_POLL_FREQUENCY_MS, this, TQ_SLOT( slotPollForResults() ) );
 			else
 				setSuccess( gcsrt->statusCode() );
 			break;
 		case GetChatSearchResultsTask::DataRetrieved:
 			// got some results, there may be more.
 			m_results += gcsrt->results();
-            TQTimer::singleShot( 0, this, TQT_SLOT( slotPollForResults() ) );
+            TQTimer::singleShot( 0, this, TQ_SLOT( slotPollForResults() ) );
 			break;
 		case GetChatSearchResultsTask::Completed:
 			m_results += gcsrt->results();
diff --git a/kopete/protocols/groupwise/libgroupwise/tasks/searchusertask.cpp b/kopete/protocols/groupwise/libgroupwise/tasks/searchusertask.cpp
index 1b64c47d..e968c75c 100644
--- a/kopete/protocols/groupwise/libgroupwise/tasks/searchusertask.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tasks/searchusertask.cpp
@@ -86,7 +86,7 @@ bool SearchUserTask::take( Transfer * transfer )
 		return true;
 	}
 	// now start the results poll timer
-	TQTimer::singleShot( GW_POLL_INITIAL_DELAY, this, TQT_SLOT( slotPollForResults() ) );
+	TQTimer::singleShot( GW_POLL_INITIAL_DELAY, this, TQ_SLOT( slotPollForResults() ) );
 	return true;
 }
 
@@ -95,7 +95,7 @@ void SearchUserTask::slotPollForResults()
 	//create a PollSearchResultsTask
 	PollSearchResultsTask * psrt = new PollSearchResultsTask( client()->rootTask() );
 	psrt->poll( m_queryHandle );
-	connect( psrt, TQT_SIGNAL( finished() ), TQT_SLOT( slotGotPollResults() ) );
+	connect( psrt, TQ_SIGNAL( finished() ), TQ_SLOT( slotGotPollResults() ) );
 	psrt->go( true );
 }
 
@@ -109,7 +109,7 @@ void SearchUserTask::slotGotPollResults()
 		case PollSearchResultsTask::Pending:
 		case PollSearchResultsTask::InProgess:
 			if ( m_polls < GW_POLL_MAXIMUM ) // restart timer
-				TQTimer::singleShot( GW_POLL_FREQUENCY_MS, this, TQT_SLOT( slotPollForResults() ) );
+				TQTimer::singleShot( GW_POLL_FREQUENCY_MS, this, TQ_SLOT( slotPollForResults() ) );
 			else
 				setSuccess( psrt->statusCode() );
 			break;
diff --git a/kopete/protocols/groupwise/libgroupwise/tests/clientstream_test.cpp b/kopete/protocols/groupwise/libgroupwise/tests/clientstream_test.cpp
index aae0205c..0bb0ed1a 100644
--- a/kopete/protocols/groupwise/libgroupwise/tests/clientstream_test.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/tests/clientstream_test.cpp
@@ -12,15 +12,15 @@ ClientStreamTest::ClientStreamTest(int argc, char ** argv) : TQApplication( argc
 	myTLSHandler = new TQCATLSHandler( myTLS );
 	myTestObject = new ClientStream( myConnector, myTLSHandler, 0);
 	// notify when the transport layer is connected
-	connect( myTestObject, TQT_SIGNAL( connected() ), TQT_SLOT( slotConnected() ) );
+	connect( myTestObject, TQ_SIGNAL( connected() ), TQ_SLOT( slotConnected() ) );
 	// it's necessary to catch this signal and tell the TLS handler to proceed, even if we don't check cert validity
-	connect( myTLSHandler, TQT_SIGNAL(tlsHandshaken()), TQT_SLOT(slotTLSHandshaken()) );
+	connect( myTLSHandler, TQ_SIGNAL(tlsHandshaken()), TQ_SLOT(slotTLSHandshaken()) );
 	// notify and start sending
-	connect( myTestObject, TQT_SIGNAL( securityLayerActivated(int) ), TQT_SLOT( slotSend(int) ) );
-	connect( myTestObject, TQT_SIGNAL( warning(int) ), TQT_SLOT( slotWarning(int) ) );
+	connect( myTestObject, TQ_SIGNAL( securityLayerActivated(int) ), TQ_SLOT( slotSend(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() ) );
 }
 
 ClientStreamTest::~ClientStreamTest()
diff --git a/kopete/protocols/groupwise/libgroupwise/userdetailsmanager.cpp b/kopete/protocols/groupwise/libgroupwise/userdetailsmanager.cpp
index d0605239..ae52ca84 100644
--- a/kopete/protocols/groupwise/libgroupwise/userdetailsmanager.cpp
+++ b/kopete/protocols/groupwise/libgroupwise/userdetailsmanager.cpp
@@ -97,8 +97,8 @@ void UserDetailsManager::requestDetails( const TQStringList & dnList, bool onlyU
 	{
 		GetDetailsTask * gdt = new GetDetailsTask( m_client->rootTask() );
 		gdt->userDNs( requestList );
-		connect( gdt, TQT_SIGNAL( gotContactUserDetails( const GroupWise::ContactDetails & ) ), 
-			TQT_SLOT( slotReceiveContactDetails( const GroupWise::ContactDetails & ) ) );
+		connect( gdt, TQ_SIGNAL( gotContactUserDetails( const GroupWise::ContactDetails & ) ), 
+			TQ_SLOT( slotReceiveContactDetails( const GroupWise::ContactDetails & ) ) );
 		// TODO: connect to gdt's finished() signal, check for failures, expand gdt to maintain a list of not found DNs?
 		gdt->go( true );
 	}
diff --git a/kopete/protocols/groupwise/ui/gwchatpropsdialog.cpp b/kopete/protocols/groupwise/ui/gwchatpropsdialog.cpp
index 45dd9ec2..c7aa4b3c 100644
--- a/kopete/protocols/groupwise/ui/gwchatpropsdialog.cpp
+++ b/kopete/protocols/groupwise/ui/gwchatpropsdialog.cpp
@@ -82,18 +82,18 @@ void GroupWiseChatPropsDialog::initialise()
 {
 	kdDebug( GROUPWISE_DEBUG_GLOBAL ) << k_funcinfo << endl;
 	m_widget = new GroupWiseChatPropsWidget( this );
-	connect( m_widget->m_topic, TQT_SIGNAL( textChanged( const TQString & )  ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_owner, TQT_SIGNAL( textChanged( const TQString & ) ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_createdOn, TQT_SIGNAL( textChanged( const TQString & ) ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_creator, TQT_SIGNAL( textChanged( const TQString & ) ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_description, TQT_SIGNAL( textChanged( const TQString & ) ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_disclaimer, TQT_SIGNAL( textChanged( const TQString & ) ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_query, TQT_SIGNAL( textChanged( const TQString & ) ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_archive, TQT_SIGNAL( textChanged( const TQString & ) ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_maxUsers, TQT_SIGNAL( textChanged( const TQString & ) ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_btnAddAcl, TQT_SIGNAL( clicked() ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_btnEditAcl, TQT_SIGNAL( clicked() ), TQT_SLOT( slotWidgetChanged() ) );
-	connect( m_widget->m_btnDeleteAcl, TQT_SIGNAL( clicked() ), TQT_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_topic, TQ_SIGNAL( textChanged( const TQString & )  ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_owner, TQ_SIGNAL( textChanged( const TQString & ) ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_createdOn, TQ_SIGNAL( textChanged( const TQString & ) ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_creator, TQ_SIGNAL( textChanged( const TQString & ) ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_description, TQ_SIGNAL( textChanged( const TQString & ) ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_disclaimer, TQ_SIGNAL( textChanged( const TQString & ) ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_query, TQ_SIGNAL( textChanged( const TQString & ) ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_archive, TQ_SIGNAL( textChanged( const TQString & ) ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_maxUsers, TQ_SIGNAL( textChanged( const TQString & ) ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_btnAddAcl, TQ_SIGNAL( clicked() ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_btnEditAcl, TQ_SIGNAL( clicked() ), TQ_SLOT( slotWidgetChanged() ) );
+	connect( m_widget->m_btnDeleteAcl, TQ_SIGNAL( clicked() ), TQ_SLOT( slotWidgetChanged() ) );
 	setMainWidget( m_widget );
 	show();
 }
diff --git a/kopete/protocols/groupwise/ui/gwchatsearchdialog.cpp b/kopete/protocols/groupwise/ui/gwchatsearchdialog.cpp
index 3cf58e7d..885c8340 100644
--- a/kopete/protocols/groupwise/ui/gwchatsearchdialog.cpp
+++ b/kopete/protocols/groupwise/ui/gwchatsearchdialog.cpp
@@ -44,12 +44,12 @@ GroupWiseChatSearchDialog::GroupWiseChatSearchDialog( GroupWiseAccount * account
 
 	m_manager = m_account->client()->chatroomManager();
 	
-	connect ( m_manager, TQT_SIGNAL( updated() ), TQT_SLOT( slotManagerUpdated() ) );
-	connect ( m_manager, TQT_SIGNAL( gotProperties( const GroupWise::Chatroom & ) ),
-			  TQT_SLOT( slotGotProperties( const GroupWise::Chatroom & ) ) );
+	connect ( m_manager, TQ_SIGNAL( updated() ), TQ_SLOT( slotManagerUpdated() ) );
+	connect ( m_manager, TQ_SIGNAL( gotProperties( const GroupWise::Chatroom & ) ),
+			  TQ_SLOT( slotGotProperties( const GroupWise::Chatroom & ) ) );
 
-	connect( m_widget->m_btnRefresh, TQT_SIGNAL( clicked() ), TQT_SLOT( slotUpdateClicked() ) );
-	connect( m_widget->m_btnProperties, TQT_SIGNAL( clicked() ), TQT_SLOT( slotPropertiesClicked() ) );
+	connect( m_widget->m_btnRefresh, TQ_SIGNAL( clicked() ), TQ_SLOT( slotUpdateClicked() ) );
+	connect( m_widget->m_btnProperties, TQ_SIGNAL( clicked() ), TQ_SLOT( slotPropertiesClicked() ) );
 
 	m_manager->updateRooms();
 	show();
diff --git a/kopete/protocols/groupwise/ui/gwcontactproperties.cpp b/kopete/protocols/groupwise/ui/gwcontactproperties.cpp
index 4d13b5b9..a9336845 100644
--- a/kopete/protocols/groupwise/ui/gwcontactproperties.cpp
+++ b/kopete/protocols/groupwise/ui/gwcontactproperties.cpp
@@ -81,10 +81,10 @@ void GroupWiseContactProperties::init()
 	m_dialog = new KDialogBase( ::tqt_cast<TQWidget*>( parent() ), "gwcontactpropsdialog", false, i18n( "Contact Properties" ), KDialogBase::Ok );
 	m_propsWidget = new GroupWiseContactPropsWidget( m_dialog );
 	// set up the context menu and copy action
-	m_copyAction = KStdAction::copy( this, TQT_SLOT( slotCopy() ), 0 );
+	m_copyAction = KStdAction::copy( this, TQ_SLOT( slotCopy() ), 0 );
 	connect( m_propsWidget->m_propsView, 
-			 TQT_SIGNAL( contextMenuRequested( TQListViewItem *, const TQPoint & , int) ),
-			 TQT_SLOT( slotShowContextMenu( TQListViewItem *, const TQPoint & ) ) );
+			 TQ_SIGNAL( contextMenuRequested( TQListViewItem *, const TQPoint & , int) ),
+			 TQ_SLOT( slotShowContextMenu( TQListViewItem *, const TQPoint & ) ) );
 
 	// insert the props widget into the dialog
 	m_dialog->setMainWidget( m_propsWidget );
diff --git a/kopete/protocols/groupwise/ui/gweditaccountwidget.cpp b/kopete/protocols/groupwise/ui/gweditaccountwidget.cpp
index 37a1f26e..64c638d9 100644
--- a/kopete/protocols/groupwise/ui/gweditaccountwidget.cpp
+++ b/kopete/protocols/groupwise/ui/gweditaccountwidget.cpp
@@ -47,9 +47,9 @@ GroupWiseEditAccountWidget::GroupWiseEditAccountWidget( TQWidget* parent, Kopete
 	m_layout = new TQVBoxLayout( this );
 	m_preferencesDialog = new GroupWiseAccountPreferences( this );
 	m_layout->addWidget( m_preferencesDialog );
-	connect( m_preferencesDialog->m_password, TQT_SIGNAL( changed() ), this, TQT_SLOT( configChanged() ) );
-	connect( m_preferencesDialog->m_server, TQT_SIGNAL( textChanged( const TQString & ) ), this, TQT_SLOT( configChanged() ) );
-	connect( m_preferencesDialog->m_port, TQT_SIGNAL( valueChanged( int ) ), this, TQT_SLOT( configChanged() ) );
+	connect( m_preferencesDialog->m_password, TQ_SIGNAL( changed() ), this, TQ_SLOT( configChanged() ) );
+	connect( m_preferencesDialog->m_server, TQ_SIGNAL( textChanged( const TQString & ) ), this, TQ_SLOT( configChanged() ) );
+	connect( m_preferencesDialog->m_port, TQ_SIGNAL( valueChanged( int ) ), this, TQ_SLOT( configChanged() ) );
 	if ( account() )
 		reOpen();
 	else
diff --git a/kopete/protocols/groupwise/ui/gwprivacydialog.cpp b/kopete/protocols/groupwise/ui/gwprivacydialog.cpp
index 208e99fb..aec2b29d 100644
--- a/kopete/protocols/groupwise/ui/gwprivacydialog.cpp
+++ b/kopete/protocols/groupwise/ui/gwprivacydialog.cpp
@@ -68,13 +68,13 @@ GroupWisePrivacyDialog::GroupWisePrivacyDialog( GroupWiseAccount * account, TQWi
 	m_privacy->m_allowList->setSelectionMode( TQListBox::Extended );
 	m_privacy->m_denyList->setSelectionMode( TQListBox::Extended );
 
-	connect( m_privacy->m_btnAllow, TQT_SIGNAL( clicked() ), TQT_SLOT( slotAllowClicked() ) );
-	connect( m_privacy->m_btnBlock, TQT_SIGNAL( clicked() ), TQT_SLOT( slotBlockClicked() ) );
-	connect( m_privacy->m_btnAdd, TQT_SIGNAL( clicked() ), TQT_SLOT( slotAddClicked() ) );
-	connect( m_privacy->m_btnRemove, TQT_SIGNAL( clicked() ), TQT_SLOT( slotRemoveClicked() ) );
-	connect( m_privacy->m_allowList, TQT_SIGNAL( selectionChanged() ), TQT_SLOT( slotAllowListClicked() ) );
-	connect( m_privacy->m_denyList, TQT_SIGNAL( selectionChanged() ), TQT_SLOT( slotDenyListClicked() ) );
-	connect( mgr, TQT_SIGNAL( privacyChanged( const TQString &, bool ) ), TQT_SLOT( slotPrivacyChanged() ) );
+	connect( m_privacy->m_btnAllow, TQ_SIGNAL( clicked() ), TQ_SLOT( slotAllowClicked() ) );
+	connect( m_privacy->m_btnBlock, TQ_SIGNAL( clicked() ), TQ_SLOT( slotBlockClicked() ) );
+	connect( m_privacy->m_btnAdd, TQ_SIGNAL( clicked() ), TQ_SLOT( slotAddClicked() ) );
+	connect( m_privacy->m_btnRemove, TQ_SIGNAL( clicked() ), TQ_SLOT( slotRemoveClicked() ) );
+	connect( m_privacy->m_allowList, TQ_SIGNAL( selectionChanged() ), TQ_SLOT( slotAllowListClicked() ) );
+	connect( m_privacy->m_denyList, TQ_SIGNAL( selectionChanged() ), TQ_SLOT( slotDenyListClicked() ) );
+	connect( mgr, TQ_SIGNAL( privacyChanged( const TQString &, bool ) ), TQ_SLOT( slotPrivacyChanged() ) );
 	m_privacy->m_btnAdd->setEnabled( true );
 	m_privacy->m_btnAllow->setEnabled( false );
 	m_privacy->m_btnBlock->setEnabled( false );
@@ -181,8 +181,8 @@ void GroupWisePrivacyDialog::slotAddClicked()
 				KDialogBase::Ok|KDialogBase::Cancel );
 		m_search = new GroupWiseContactSearch( m_account, TQListView::Multi, false, m_searchDlg, "privacysearchwidget" );
 		m_searchDlg->setMainWidget( m_search );
-		connect( m_searchDlg, TQT_SIGNAL( okClicked() ), TQT_SLOT( slotSearchedForUsers() ) );
-		connect( m_search, TQT_SIGNAL( selectionValidates( bool ) ), m_searchDlg, TQT_SLOT( enableButtonOK( bool ) ) );
+		connect( m_searchDlg, TQ_SIGNAL( okClicked() ), TQ_SLOT( slotSearchedForUsers() ) );
+		connect( m_search, TQ_SIGNAL( selectionValidates( bool ) ), m_searchDlg, TQ_SLOT( enableButtonOK( bool ) ) );
 		m_searchDlg->enableButtonOK( false );
 	}
 	m_searchDlg->show();
@@ -238,9 +238,9 @@ void GroupWisePrivacyDialog::slotRemoveClicked()
 void GroupWisePrivacyDialog::slotAllowListClicked()
 {
 	// don't get into feedback
-	disconnect( m_privacy->m_denyList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotDenyListClicked() ) );
+	disconnect( m_privacy->m_denyList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotDenyListClicked() ) );
 	m_privacy->m_denyList->clearSelection();
-	connect( m_privacy->m_denyList, TQT_SIGNAL( selectionChanged() ), TQT_SLOT( slotDenyListClicked() ) );
+	connect( m_privacy->m_denyList, TQ_SIGNAL( selectionChanged() ), TQ_SLOT( slotDenyListClicked() ) );
 	bool selected = false;
 	for( int i = m_privacy->m_allowList->count() - 1; i >= 0 ; --i )
 	{
@@ -258,9 +258,9 @@ void GroupWisePrivacyDialog::slotAllowListClicked()
 void GroupWisePrivacyDialog::slotDenyListClicked()
 {
 	// don't get into feedback
-	disconnect( m_privacy->m_allowList, TQT_SIGNAL( selectionChanged() ), this, TQT_SLOT( slotAllowListClicked() ) );
+	disconnect( m_privacy->m_allowList, TQ_SIGNAL( selectionChanged() ), this, TQ_SLOT( slotAllowListClicked() ) );
 	m_privacy->m_allowList->clearSelection();
-	connect( m_privacy->m_allowList, TQT_SIGNAL( selectionChanged() ), TQT_SLOT( slotAllowListClicked() ) );
+	connect( m_privacy->m_allowList, TQ_SIGNAL( selectionChanged() ), TQ_SLOT( slotAllowListClicked() ) );
 	bool selected = false;
 	for( int i = m_privacy->m_denyList->count() - 1; i >= 0 ; --i )
 	{
diff --git a/kopete/protocols/groupwise/ui/gwreceiveinvitationdialog.cpp b/kopete/protocols/groupwise/ui/gwreceiveinvitationdialog.cpp
index 4dbbe45b..b5f4d9a5 100644
--- a/kopete/protocols/groupwise/ui/gwreceiveinvitationdialog.cpp
+++ b/kopete/protocols/groupwise/ui/gwreceiveinvitationdialog.cpp
@@ -38,8 +38,8 @@ ReceiveInvitationDialog::ReceiveInvitationDialog( GroupWiseAccount * account, co
 {
 	m_account = account;
 	m_guid = event.guid;	
-	connect( this, TQT_SIGNAL( yesClicked() ), TQT_SLOT( slotYesClicked() ) );
-	connect( this, TQT_SIGNAL( noClicked() ), TQT_SLOT( slotNoClicked() ) );
+	connect( this, TQ_SIGNAL( yesClicked() ), TQ_SLOT( slotYesClicked() ) );
+	connect( this, TQ_SIGNAL( noClicked() ), TQ_SLOT( slotNoClicked() ) );
 	
 	GroupWiseContact * c = account->contactForDN( event.user );
 	
diff --git a/kopete/protocols/groupwise/ui/gwsearch.cpp b/kopete/protocols/groupwise/ui/gwsearch.cpp
index addb54cd..6bc26f0d 100644
--- a/kopete/protocols/groupwise/ui/gwsearch.cpp
+++ b/kopete/protocols/groupwise/ui/gwsearch.cpp
@@ -61,10 +61,10 @@ GroupWiseContactSearch::GroupWiseContactSearch( GroupWiseAccount * account, TQLi
 {
 	m_results->setSelectionMode( mode );
 	m_results->setAllColumnsShowFocus( true );
-	connect( m_details, TQT_SIGNAL( clicked() ), TQT_SLOT( slotShowDetails() ) );
-	connect( m_results, TQT_SIGNAL( selectionChanged() ), TQT_SLOT( slotValidateSelection() ) );
-	connect( m_search, TQT_SIGNAL( clicked() ), TQT_SLOT( slotDoSearch() ) );
-	connect( m_clear, TQT_SIGNAL( clicked() ), TQT_SLOT( slotClear() ) );
+	connect( m_details, TQ_SIGNAL( clicked() ), TQ_SLOT( slotShowDetails() ) );
+	connect( m_results, TQ_SIGNAL( selectionChanged() ), TQ_SLOT( slotValidateSelection() ) );
+	connect( m_search, TQ_SIGNAL( clicked() ), TQ_SLOT( slotDoSearch() ) );
+	connect( m_clear, TQ_SIGNAL( clicked() ), TQ_SLOT( slotClear() ) );
 }
 
 
@@ -130,7 +130,7 @@ void GroupWiseContactSearch::slotDoSearch()
 		// start a search task
 		SearchUserTask * st = new SearchUserTask( m_account->client()->rootTask() );
 		st->search( searchTerms );
-		connect( st, TQT_SIGNAL( finished() ), TQT_SLOT( slotGotSearchResults() ) );
+		connect( st, TQ_SIGNAL( finished() ), TQ_SLOT( slotGotSearchResults() ) );
 		st->go( true );
 		m_matchCount->setText( i18n( "Searching" ) );
 	}