Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

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

10 files changed, 191 insertions, 191 deletions

diff --git a/kbackgammon/engines/fibs/kbgfibs.cpp b/kbackgammon/engines/fibs/kbgfibs.cpp
index 8561b9c2..e1399b85 100644
--- a/kbackgammon/engines/fibs/kbgfibs.cpp
+++ b/kbackgammon/engines/fibs/kbgfibs.cpp
@@ -272,7 +272,7 @@ void KBgEngineFIBS::getSetupPages(KDialogBase *nb)
 		lem[i] = new TQLineEdit(autoMsg[i], gbm);
 		gl->addWidget(cbm[i], i, 0);
 		gl->addWidget(lem[i], i, 1);
-		connect(cbm[i], TQT_SIGNAL(toggled(bool)), lem[i], TQT_SLOT(setEnabled(bool)));
+		connect(cbm[i], TQ_SIGNAL(toggled(bool)), lem[i], TQ_SLOT(setEnabled(bool)));
 		cbm[i]->setChecked(useAutoMsg[i]);
 		lem[i]->setEnabled(useAutoMsg[i]);
 		TQWhatsThis::add(lem[i], TQWhatsThis::textFor(cbm[i]));
@@ -838,8 +838,8 @@ void KBgEngineFIBS::fibsRequestInvitation(const TQString &player)
 	if (!invitationDlg) {
 		TQString p = player;
 		invitationDlg = new KBgInvite("invite");
-		connect(invitationDlg, TQT_SIGNAL(inviteCommand(const TQString &)), this, TQT_SLOT(handleCommand(const TQString &)));
-		connect(invitationDlg, TQT_SIGNAL(dialogDone()), this, TQT_SLOT(invitationDone()));
+		connect(invitationDlg, TQ_SIGNAL(inviteCommand(const TQString &)), this, TQ_SLOT(handleCommand(const TQString &)));
+		connect(invitationDlg, TQ_SIGNAL(dialogDone()), this, TQ_SLOT(invitationDone()));
 	}
 	invitationDlg->setPlayer(player);
 	invitationDlg->show();
@@ -2098,51 +2098,51 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 	playing = false;
 	login = true;
 
-	connect(connection, TQT_SIGNAL(hostFound()),            this, TQT_SLOT(hostFound()));
-	connect(connection, TQT_SIGNAL(connected()),            this, TQT_SLOT(connected()));
-	connect(connection, TQT_SIGNAL(error(int)),             this, TQT_SLOT(connError(int)));
-	connect(connection, TQT_SIGNAL(connectionClosed()),     this, TQT_SLOT(connectionClosed()));
-	connect(connection, TQT_SIGNAL(delayedCloseFinished()), this, TQT_SLOT(connectionClosed()));
-	connect(connection, TQT_SIGNAL(readyRead()),            this, TQT_SLOT(readData()));
+	connect(connection, TQ_SIGNAL(hostFound()),            this, TQ_SLOT(hostFound()));
+	connect(connection, TQ_SIGNAL(connected()),            this, TQ_SLOT(connected()));
+	connect(connection, TQ_SIGNAL(error(int)),             this, TQ_SLOT(connError(int)));
+	connect(connection, TQ_SIGNAL(connectionClosed()),     this, TQ_SLOT(connectionClosed()));
+	connect(connection, TQ_SIGNAL(delayedCloseFinished()), this, TQ_SLOT(connectionClosed()));
+	connect(connection, TQ_SIGNAL(readyRead()),            this, TQ_SLOT(readData()));
 
-	connect(this, TQT_SIGNAL(serverString(const TQString &)), this, TQT_SLOT(sendData(const TQString &)));
+	connect(this, TQ_SIGNAL(serverString(const TQString &)), this, TQ_SLOT(sendData(const TQString &)));
 
 	/*
 	 * No invitation dialog
 	 */
 	invitationDlg = 0;
 
-	connect(this, TQT_SIGNAL(fibsWhoInfo(const TQString &)), this, TQT_SLOT(changeJoin(const TQString &)));
-	connect(this, TQT_SIGNAL(fibsLogout (const TQString &)), this, TQT_SLOT(cancelJoin(const TQString &)));
-	connect(this, TQT_SIGNAL(gameOver()), this, TQT_SLOT(endGame()));
+	connect(this, TQ_SIGNAL(fibsWhoInfo(const TQString &)), this, TQ_SLOT(changeJoin(const TQString &)));
+	connect(this, TQ_SIGNAL(fibsLogout (const TQString &)), this, TQ_SLOT(cancelJoin(const TQString &)));
+	connect(this, TQ_SIGNAL(gameOver()), this, TQ_SLOT(endGame()));
 
 	/*
 	 * Creating, initializing and connecting the player list
 	 */
 	playerlist = new KFibsPlayerList(0, "fibs player list");
 
-	connect(this, TQT_SIGNAL(fibsWhoInfo(const TQString &)), playerlist, TQT_SLOT(changePlayer(const TQString &)));
-	connect(this, TQT_SIGNAL(fibsLogout (const TQString &)), playerlist, TQT_SLOT(deletePlayer(const TQString &)));
-	connect(this, TQT_SIGNAL(fibsWhoEnd()),           playerlist, TQT_SLOT(stopUpdate()));
-	connect(this, TQT_SIGNAL(fibsConnectionClosed()), playerlist, TQT_SLOT(stopUpdate()));
-	connect(this, TQT_SIGNAL(changePlayerStatus(const TQString &, int, bool)),
-		playerlist, TQT_SLOT(changePlayerStatus(const TQString &, int, bool)));
-	connect(playerlist, TQT_SIGNAL(fibsCommand(const TQString &)), this, TQT_SLOT(handleCommand(const TQString &)));
-	connect(playerlist, TQT_SIGNAL(fibsInvite(const TQString &)), this, TQT_SLOT(fibsRequestInvitation(const TQString &)));
+	connect(this, TQ_SIGNAL(fibsWhoInfo(const TQString &)), playerlist, TQ_SLOT(changePlayer(const TQString &)));
+	connect(this, TQ_SIGNAL(fibsLogout (const TQString &)), playerlist, TQ_SLOT(deletePlayer(const TQString &)));
+	connect(this, TQ_SIGNAL(fibsWhoEnd()),           playerlist, TQ_SLOT(stopUpdate()));
+	connect(this, TQ_SIGNAL(fibsConnectionClosed()), playerlist, TQ_SLOT(stopUpdate()));
+	connect(this, TQ_SIGNAL(changePlayerStatus(const TQString &, int, bool)),
+		playerlist, TQ_SLOT(changePlayerStatus(const TQString &, int, bool)));
+	connect(playerlist, TQ_SIGNAL(fibsCommand(const TQString &)), this, TQ_SLOT(handleCommand(const TQString &)));
+	connect(playerlist, TQ_SIGNAL(fibsInvite(const TQString &)), this, TQ_SLOT(fibsRequestInvitation(const TQString &)));
 
 	/*
 	 * Create, initialize and connect the chat window
 	 */
 	chatWindow = new KBgChat(0, "chat window");
 
-	connect(this, TQT_SIGNAL(chatMessage(const TQString &)), chatWindow, TQT_SLOT(handleData(const TQString &)));
-	connect(this, TQT_SIGNAL(fibsStartNewGame(const TQString &)), chatWindow, TQT_SLOT(startGame(const TQString &)));
-	connect(this, TQT_SIGNAL(gameOver()), chatWindow, TQT_SLOT(endGame()));
-	connect(this, TQT_SIGNAL(fibsLogout (const TQString &)), chatWindow, TQT_SLOT(deletePlayer(const TQString &)));
-	connect(chatWindow, TQT_SIGNAL(fibsCommand(const TQString &)), this, TQT_SLOT(handleCommand(const TQString &)));
-	connect(chatWindow, TQT_SIGNAL(fibsRequestInvitation(const TQString &)), this, TQT_SLOT(fibsRequestInvitation(const TQString &)));
-	connect(chatWindow, TQT_SIGNAL(personalMessage(const TQString &)), this, TQT_SLOT(personalMessage(const TQString &)));
-	connect(playerlist, TQT_SIGNAL(fibsTalk(const TQString &)), chatWindow, TQT_SLOT(fibsTalk(const TQString &)));
+	connect(this, TQ_SIGNAL(chatMessage(const TQString &)), chatWindow, TQ_SLOT(handleData(const TQString &)));
+	connect(this, TQ_SIGNAL(fibsStartNewGame(const TQString &)), chatWindow, TQ_SLOT(startGame(const TQString &)));
+	connect(this, TQ_SIGNAL(gameOver()), chatWindow, TQ_SLOT(endGame()));
+	connect(this, TQ_SIGNAL(fibsLogout (const TQString &)), chatWindow, TQ_SLOT(deletePlayer(const TQString &)));
+	connect(chatWindow, TQ_SIGNAL(fibsCommand(const TQString &)), this, TQ_SLOT(handleCommand(const TQString &)));
+	connect(chatWindow, TQ_SIGNAL(fibsRequestInvitation(const TQString &)), this, TQ_SLOT(fibsRequestInvitation(const TQString &)));
+	connect(chatWindow, TQ_SIGNAL(personalMessage(const TQString &)), this, TQ_SLOT(personalMessage(const TQString &)));
+	connect(playerlist, TQ_SIGNAL(fibsTalk(const TQString &)), chatWindow, TQ_SLOT(fibsTalk(const TQString &)));
 
 	/*
 	 * Creating, initializing and connecting the menu
@@ -2156,9 +2156,9 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 	/*
 	 * Initialize the FIBS submenu - this is also put in the play menu
 	 */
-	conAction  = new TDEAction(i18n("&Connect"),    0, this, TQT_SLOT(   connectFIBS()), this);
-	newAction  = new TDEAction(i18n("New Account"), 0, this, TQT_SLOT(    newAccount()), this);
-	disAction  = new TDEAction(i18n("&Disconnect"), 0, this, TQT_SLOT(disconnectFIBS()), this);
+	conAction  = new TDEAction(i18n("&Connect"),    0, this, TQ_SLOT(   connectFIBS()), this);
+	newAction  = new TDEAction(i18n("New Account"), 0, this, TQ_SLOT(    newAccount()), this);
+	disAction  = new TDEAction(i18n("&Disconnect"), 0, this, TQ_SLOT(disconnectFIBS()), this);
 
 	conAction->setEnabled(true ); conAction->plug(menu);
 	disAction->setEnabled(false); disAction->plug(menu);
@@ -2166,7 +2166,7 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 
 	menu->insertSeparator();
 
-	(invAction  = new TDEAction(i18n("&Invite..."), 0, this, TQT_SLOT(inviteDialog()), this))->plug(menu);
+	(invAction  = new TDEAction(i18n("&Invite..."), 0, this, TQ_SLOT(inviteDialog()), this))->plug(menu);
 
 	/*
 	 * Create and fill the response menu. This is for all these: type this or
@@ -2174,8 +2174,8 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 	 */
 	cmdMenuID = menu->insertItem(i18n("&Commands"), cmdMenu); {
 
-		(actAway  = new TDEAction(i18n("Away"), 0, this, TQT_SLOT(away()), this))->plug(cmdMenu);
-		(actBack  = new TDEAction(i18n("Back"), 0, this, TQT_SLOT(back()), this))->plug(cmdMenu);
+		(actAway  = new TDEAction(i18n("Away"), 0, this, TQ_SLOT(away()), this))->plug(cmdMenu);
+		(actBack  = new TDEAction(i18n("Back"), 0, this, TQ_SLOT(back()), this))->plug(cmdMenu);
 
 		actAway->setEnabled(true);
 		actBack->setEnabled(false);
@@ -2192,14 +2192,14 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 			fibsOpt[i] = 0;
 
 		fibsOpt[OptReady]   = new TDEToggleAction(i18n("Ready to Play"),
-							0, this, TQT_SLOT(toggle_ready()),   this);
+							0, this, TQ_SLOT(toggle_ready()),   this);
 		fibsOpt[OptRatings] = new TDEToggleAction(i18n("Show Rating Computations"),
-							0, this, TQT_SLOT(toggle_ratings()), this);
+							0, this, TQ_SLOT(toggle_ratings()), this);
 		fibsOpt[OptRatings]->setCheckedState(i18n("Hide Rating Computations"));
 		fibsOpt[OptGreedy]  = new TDEToggleAction(i18n("Greedy Bearoffs"),
-							0, this, TQT_SLOT(toggle_greedy()),  this);
+							0, this, TQ_SLOT(toggle_greedy()),  this);
 		fibsOpt[OptDouble]  = new TDEToggleAction(i18n("Ask for Doubles"),
-							0, this, TQT_SLOT(toggle_double()),  this);
+							0, this, TQ_SLOT(toggle_double()),  this);
 
 		for (int i = 0; i < NumFIBSOpt; i++)
 			if (fibsOpt[i])
@@ -2213,16 +2213,16 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 	 */
 	respMenuID = menu->insertItem(i18n("&Response"), respMenu); {
 
-		(actAccept  = new TDEAction(i18n("Accept"), 0, this, TQT_SLOT(accept()), this))->plug(respMenu);
-		(actReject  = new TDEAction(i18n("Reject"), 0, this, TQT_SLOT(reject()), this))->plug(respMenu);
+		(actAccept  = new TDEAction(i18n("Accept"), 0, this, TQ_SLOT(accept()), this))->plug(respMenu);
+		(actReject  = new TDEAction(i18n("Reject"), 0, this, TQ_SLOT(reject()), this))->plug(respMenu);
 
 		actAccept->setEnabled(false);
 		actReject->setEnabled(false);
 
 		respMenu->insertSeparator();
 
-		(actConti  = new TDEAction(i18n("Join"),  0, this, TQT_SLOT(match_conti()), this))->plug(respMenu);
-		(actLeave  = new TDEAction(i18n("Leave"), 0, this, TQT_SLOT(match_leave()), this))->plug(respMenu);
+		(actConti  = new TDEAction(i18n("Join"),  0, this, TQ_SLOT(match_conti()), this))->plug(respMenu);
+		(actLeave  = new TDEAction(i18n("Leave"), 0, this, TQ_SLOT(match_leave()), this))->plug(respMenu);
 
 		actConti->setEnabled(false);
 		actLeave->setEnabled(false);
@@ -2235,14 +2235,14 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 	joinMenuID = menu->insertItem(i18n("&Join"), joinMenu); {
 		numJoin = -1;
 
-		actJoin[0] = new TDEAction("", 0, this, TQT_SLOT(join_0()), this);
-		actJoin[1] = new TDEAction("", 0, this, TQT_SLOT(join_1()), this);
-		actJoin[2] = new TDEAction("", 0, this, TQT_SLOT(join_2()), this);
-		actJoin[3] = new TDEAction("", 0, this, TQT_SLOT(join_3()), this);
-		actJoin[4] = new TDEAction("", 0, this, TQT_SLOT(join_4()), this);
-		actJoin[5] = new TDEAction("", 0, this, TQT_SLOT(join_5()), this);
-		actJoin[6] = new TDEAction("", 0, this, TQT_SLOT(join_6()), this);
-		actJoin[7] = new TDEAction("", 0, this, TQT_SLOT(join_7()), this);
+		actJoin[0] = new TDEAction("", 0, this, TQ_SLOT(join_0()), this);
+		actJoin[1] = new TDEAction("", 0, this, TQ_SLOT(join_1()), this);
+		actJoin[2] = new TDEAction("", 0, this, TQ_SLOT(join_2()), this);
+		actJoin[3] = new TDEAction("", 0, this, TQ_SLOT(join_3()), this);
+		actJoin[4] = new TDEAction("", 0, this, TQ_SLOT(join_4()), this);
+		actJoin[5] = new TDEAction("", 0, this, TQ_SLOT(join_5()), this);
+		actJoin[6] = new TDEAction("", 0, this, TQ_SLOT(join_6()), this);
+		actJoin[7] = new TDEAction("", 0, this, TQ_SLOT(join_7()), this);
 	}
 
 	menu->setItemEnabled(joinMenuID, false);
@@ -2255,11 +2255,11 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 	 */
 	menu->insertSeparator();
 
-	(listAct = new TDEToggleAction(i18n("&Player List"), 0, this, TQT_SLOT(showList()), this))->plug(menu);
-	(chatAct = new TDEToggleAction(i18n("&Chat"),        0, this, TQT_SLOT(showChat()), this))->plug(menu);
+	(listAct = new TDEToggleAction(i18n("&Player List"), 0, this, TQ_SLOT(showList()), this))->plug(menu);
+	(chatAct = new TDEToggleAction(i18n("&Chat"),        0, this, TQ_SLOT(showChat()), this))->plug(menu);
 
-	connect(playerlist, TQT_SIGNAL(windowVisible(bool)), listAct, TQT_SLOT(setChecked(bool)));
-	connect(chatWindow, TQT_SIGNAL(windowVisible(bool)), chatAct, TQT_SLOT(setChecked(bool)));
+	connect(playerlist, TQ_SIGNAL(windowVisible(bool)), listAct, TQ_SLOT(setChecked(bool)));
+	connect(chatWindow, TQ_SIGNAL(windowVisible(bool)), chatAct, TQ_SLOT(setChecked(bool)));
 
 	/*
 	 * Create message IDs. This sets up a lot of regular expressions.
@@ -2287,7 +2287,7 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 	// FIXME: move the start to connect...
 
 	keepaliveTimer = new TQTimer(this);
-	connect(keepaliveTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(keepAlive()));
+	connect(keepaliveTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(keepAlive()));
 	keepaliveTimer->start(1200000);
 }
 
diff --git a/kbackgammon/engines/fibs/kbgfibschat.cpp b/kbackgammon/engines/fibs/kbgfibschat.cpp
index 95f8577c..cb77962d 100644
--- a/kbackgammon/engines/fibs/kbgfibschat.cpp
+++ b/kbackgammon/engines/fibs/kbgfibschat.cpp
@@ -205,10 +205,10 @@ KBgChat::KBgChat(TQWidget *parent, const char *name)
     if (!addSendingEntry(i18n("Whisper to watchers only"), CLIP_YOU_WHISPER))
         kdDebug(10500) << "adding whisper" << endl;
 
-    connect(this, TQT_SIGNAL(rightButtonClicked(TQListBoxItem *, const TQPoint &)),
-            this, TQT_SLOT(contextMenu(TQListBoxItem *, const TQPoint &)));
-    connect(this, TQT_SIGNAL(signalSendMessage(int, const TQString &)),
-            this, TQT_SLOT(handleCommand(int, const TQString &)));
+    connect(this, TQ_SIGNAL(rightButtonClicked(TQListBoxItem *, const TQPoint &)),
+            this, TQ_SLOT(contextMenu(TQListBoxItem *, const TQPoint &)));
+    connect(this, TQ_SIGNAL(signalSendMessage(int, const TQString &)),
+            this, TQ_SLOT(handleCommand(int, const TQString &)));
 
     d->mName2ID = new TQDict<int>(17, true);
     d->mName2ID->setAutoDelete(true);
@@ -231,32 +231,32 @@ KBgChat::KBgChat(TQWidget *parent, const char *name)
     d->mAct[KBgChatPrivate::Inquire] = new TDEAction(i18n("Info On"),
                                                    TQIconSet(kapp->iconLoader()->loadIcon(
                                                                 "help.xpm", TDEIcon::Small)),
-                                                   0, this, TQT_SLOT(slotInquire()), actions);
+                                                   0, this, TQ_SLOT(slotInquire()), actions);
     d->mAct[KBgChatPrivate::Talk]    = new TDEAction(i18n("Talk To"),
                                                    TQIconSet(kapp->iconLoader()->loadIcon(
                                                                 PROG_NAME "-chat.png", TDEIcon::Small)),
-                                                   0, this, TQT_SLOT(slotTalk()), actions);
+                                                   0, this, TQ_SLOT(slotTalk()), actions);
 
     d->mAct[KBgChatPrivate::InviteD]  = new TDEAction(i18n("Use Dialog"),    0, this,
-                                                    TQT_SLOT(slotInviteD()),  actions);
+                                                    TQ_SLOT(slotInviteD()),  actions);
     d->mAct[KBgChatPrivate::Invite1]  = new TDEAction(i18n("1 Point Match"), 0, this,
-                                                    TQT_SLOT(slotInvite1()),  actions);
+                                                    TQ_SLOT(slotInvite1()),  actions);
     d->mAct[KBgChatPrivate::Invite2]  = new TDEAction(i18n("2 Point Match"), 0, this,
-                                                    TQT_SLOT(slotInvite2()),  actions);
+                                                    TQ_SLOT(slotInvite2()),  actions);
     d->mAct[KBgChatPrivate::Invite3]  = new TDEAction(i18n("3 Point Match"), 0, this,
-                                                    TQT_SLOT(slotInvite3()),  actions);
+                                                    TQ_SLOT(slotInvite3()),  actions);
     d->mAct[KBgChatPrivate::Invite4]  = new TDEAction(i18n("4 Point Match"), 0, this,
-                                                    TQT_SLOT(slotInvite4()),  actions);
+                                                    TQ_SLOT(slotInvite4()),  actions);
     d->mAct[KBgChatPrivate::Invite5]  = new TDEAction(i18n("5 Point Match"), 0, this,
-                                                    TQT_SLOT(slotInvite5()),  actions);
+                                                    TQ_SLOT(slotInvite5()),  actions);
     d->mAct[KBgChatPrivate::Invite6]  = new TDEAction(i18n("6 Point Match"), 0, this,
-                                                    TQT_SLOT(slotInvite6()),  actions);
+                                                    TQ_SLOT(slotInvite6()),  actions);
     d->mAct[KBgChatPrivate::Invite7]  = new TDEAction(i18n("7 Point Match"), 0, this,
-                                                    TQT_SLOT(slotInvite7()),  actions);
+                                                    TQ_SLOT(slotInvite7()),  actions);
     d->mAct[KBgChatPrivate::InviteU]  = new TDEAction(i18n("Unlimited"),     0, this,
-                                                    TQT_SLOT(slotInviteU()),  actions);
+                                                    TQ_SLOT(slotInviteU()),  actions);
     d->mAct[KBgChatPrivate::InviteR]  = new TDEAction(i18n("Resume"),        0, this,
-                                                    TQT_SLOT(slotInviteR()),  actions);
+                                                    TQ_SLOT(slotInviteR()),  actions);
 
     d->mAct[KBgChatPrivate::InviteD]->plug(d->mInvt);
 
@@ -275,13 +275,13 @@ KBgChat::KBgChat(TQWidget *parent, const char *name)
     d->mAct[KBgChatPrivate::InviteU]->plug(d->mInvt);
     d->mAct[KBgChatPrivate::InviteR]->plug(d->mInvt);
 
-    d->mAct[KBgChatPrivate::Gag]      = new TDEAction(i18n("Gag"),   0, this, TQT_SLOT(slotGag()),     actions);
-    d->mAct[KBgChatPrivate::Ungag]    = new TDEAction(i18n("Ungag"), 0, this, TQT_SLOT(slotUngag()),   actions);
-    d->mAct[KBgChatPrivate::Cleargag] = new TDEAction(i18n("Clear Gag List"), 0, this, TQT_SLOT(slotCleargag()), actions);
-    d->mAct[KBgChatPrivate::Copy]     = KStdAction::copy(this, TQT_SLOT(slotCopy()), actions);
-    d->mAct[KBgChatPrivate::Clear]    = new TDEAction(i18n("Clear"),        0, this, TQT_SLOT(slotClear()), actions);
-    d->mAct[KBgChatPrivate::Close]    = KStdAction::close(this, TQT_SLOT(hide()), actions);
-    d->mAct[KBgChatPrivate::Silent]   = new TDEToggleAction(i18n("Silent"), 0, this, TQT_SLOT(slotSilent()), actions);
+    d->mAct[KBgChatPrivate::Gag]      = new TDEAction(i18n("Gag"),   0, this, TQ_SLOT(slotGag()),     actions);
+    d->mAct[KBgChatPrivate::Ungag]    = new TDEAction(i18n("Ungag"), 0, this, TQ_SLOT(slotUngag()),   actions);
+    d->mAct[KBgChatPrivate::Cleargag] = new TDEAction(i18n("Clear Gag List"), 0, this, TQ_SLOT(slotCleargag()), actions);
+    d->mAct[KBgChatPrivate::Copy]     = KStdAction::copy(this, TQ_SLOT(slotCopy()), actions);
+    d->mAct[KBgChatPrivate::Clear]    = new TDEAction(i18n("Clear"),        0, this, TQ_SLOT(slotClear()), actions);
+    d->mAct[KBgChatPrivate::Close]    = KStdAction::close(this, TQ_SLOT(hide()), actions);
+    d->mAct[KBgChatPrivate::Silent]   = new TDEToggleAction(i18n("Silent"), 0, this, TQ_SLOT(slotSilent()), actions);
 }
 
 
diff --git a/kbackgammon/engines/fibs/kbginvite.cpp b/kbackgammon/engines/fibs/kbginvite.cpp
index ef186f03..fd4b35a7 100644
--- a/kbackgammon/engines/fibs/kbginvite.cpp
+++ b/kbackgammon/engines/fibs/kbginvite.cpp
@@ -116,11 +116,11 @@ KBgInvite::KBgInvite(const char *name)
     /*
      * Connect the buttons
      */
-    connect(d->mUnlimited, TQT_SIGNAL(clicked()), TQT_SLOT(unlimitedClicked()));
-    connect(d->mResume,    TQT_SIGNAL(clicked()), TQT_SLOT(resumeClicked()));
-    connect(d->mInvite,    TQT_SIGNAL(clicked()), TQT_SLOT(inviteClicked()));
-    connect(d->mClose,     TQT_SIGNAL(clicked()), TQT_SLOT(hide()));
-    connect(d->mCancel,    TQT_SIGNAL(clicked()), TQT_SLOT(cancelClicked()));
+    connect(d->mUnlimited, TQ_SIGNAL(clicked()), TQ_SLOT(unlimitedClicked()));
+    connect(d->mResume,    TQ_SIGNAL(clicked()), TQ_SLOT(resumeClicked()));
+    connect(d->mInvite,    TQ_SIGNAL(clicked()), TQ_SLOT(inviteClicked()));
+    connect(d->mClose,     TQ_SIGNAL(clicked()), TQ_SLOT(hide()));
+    connect(d->mCancel,    TQ_SIGNAL(clicked()), TQ_SLOT(cancelClicked()));
 }
 
 /*
diff --git a/kbackgammon/engines/fibs/kplayerlist.cpp b/kbackgammon/engines/fibs/kplayerlist.cpp
index ab076c61..c7ce8ab6 100644
--- a/kbackgammon/engines/fibs/kplayerlist.cpp
+++ b/kbackgammon/engines/fibs/kplayerlist.cpp
@@ -288,42 +288,42 @@ KFibsPlayerList::KFibsPlayerList(TQWidget *parent, const char *name)
     d->mAct[KFibsPlayerListPrivate::Info] = new TDEAction(i18n("Info"),
                                                         TQIconSet(kapp->iconLoader()->loadIcon
                                                                  ("help.xpm", TDEIcon::Small)),
-                                                        0, this, TQT_SLOT(slotInfo()),   actions);
+                                                        0, this, TQ_SLOT(slotInfo()),   actions);
     d->mAct[KFibsPlayerListPrivate::Talk] = new TDEAction(i18n("Talk"),
                                                         TQIconSet(kapp->iconLoader()->loadIcon
                                                                  (PROG_NAME "-chat.png", TDEIcon::Small)),
-                                                        0, this, TQT_SLOT(slotTalk()),   actions);
+                                                        0, this, TQ_SLOT(slotTalk()),   actions);
 
-    d->mAct[KFibsPlayerListPrivate::Look]     = new TDEAction(i18n("Look"), 0, this, TQT_SLOT(slotLook()),   actions);
-    d->mAct[KFibsPlayerListPrivate::Watch]    = new TDEAction(i18n("Watch"), 0, this, TQT_SLOT(slotWatch()),  actions);
-    d->mAct[KFibsPlayerListPrivate::Unwatch]  = new TDEAction(i18n("Unwatch"), 0, this, TQT_SLOT(slotUnwatch()),actions);
-    d->mAct[KFibsPlayerListPrivate::BlindAct] = new TDEAction(i18n("Blind"), 0, this, TQT_SLOT(slotBlind()),  actions);
-    d->mAct[KFibsPlayerListPrivate::Update]   = new TDEAction(i18n("Update"), 0, this, TQT_SLOT(slotUpdate()), actions);
+    d->mAct[KFibsPlayerListPrivate::Look]     = new TDEAction(i18n("Look"), 0, this, TQ_SLOT(slotLook()),   actions);
+    d->mAct[KFibsPlayerListPrivate::Watch]    = new TDEAction(i18n("Watch"), 0, this, TQ_SLOT(slotWatch()),  actions);
+    d->mAct[KFibsPlayerListPrivate::Unwatch]  = new TDEAction(i18n("Unwatch"), 0, this, TQ_SLOT(slotUnwatch()),actions);
+    d->mAct[KFibsPlayerListPrivate::BlindAct] = new TDEAction(i18n("Blind"), 0, this, TQ_SLOT(slotBlind()),  actions);
+    d->mAct[KFibsPlayerListPrivate::Update]   = new TDEAction(i18n("Update"), 0, this, TQ_SLOT(slotUpdate()), actions);
 
-    d->mAct[KFibsPlayerListPrivate::Reload] = KStdAction::redisplay(this, TQT_SLOT(slotReload()), actions);
-    d->mAct[KFibsPlayerListPrivate::Mail]   = KStdAction::mail(this, TQT_SLOT(slotMail()),   actions);
-    d->mAct[KFibsPlayerListPrivate::Close]  = KStdAction::close(this, TQT_SLOT(hide()), actions);
+    d->mAct[KFibsPlayerListPrivate::Reload] = KStdAction::redisplay(this, TQ_SLOT(slotReload()), actions);
+    d->mAct[KFibsPlayerListPrivate::Mail]   = KStdAction::mail(this, TQ_SLOT(slotMail()),   actions);
+    d->mAct[KFibsPlayerListPrivate::Close]  = KStdAction::close(this, TQ_SLOT(hide()), actions);
 
     d->mAct[KFibsPlayerListPrivate::InviteD]  = new TDEAction(i18n("Use Dialog"),    0, this,
-                                                            TQT_SLOT(slotInviteD()), actions);
+                                                            TQ_SLOT(slotInviteD()), actions);
     d->mAct[KFibsPlayerListPrivate::Invite1]  = new TDEAction(i18n("1 Point Match"), 0, this,
-                                                            TQT_SLOT(slotInvite1()), actions);
+                                                            TQ_SLOT(slotInvite1()), actions);
     d->mAct[KFibsPlayerListPrivate::Invite2]  = new TDEAction(i18n("2 Point Match"), 0, this,
-                                                            TQT_SLOT(slotInvite2()), actions);
+                                                            TQ_SLOT(slotInvite2()), actions);
     d->mAct[KFibsPlayerListPrivate::Invite3]  = new TDEAction(i18n("3 Point Match"), 0, this,
-                                                            TQT_SLOT(slotInvite3()), actions);
+                                                            TQ_SLOT(slotInvite3()), actions);
     d->mAct[KFibsPlayerListPrivate::Invite4]  = new TDEAction(i18n("4 Point Match"), 0, this,
-                                                            TQT_SLOT(slotInvite4()), actions);
+                                                            TQ_SLOT(slotInvite4()), actions);
     d->mAct[KFibsPlayerListPrivate::Invite5]  = new TDEAction(i18n("5 Point Match"), 0, this,
-                                                            TQT_SLOT(slotInvite5()), actions);
+                                                            TQ_SLOT(slotInvite5()), actions);
     d->mAct[KFibsPlayerListPrivate::Invite6]  = new TDEAction(i18n("6 Point Match"), 0, this,
-                                                            TQT_SLOT(slotInvite6()), actions);
+                                                            TQ_SLOT(slotInvite6()), actions);
     d->mAct[KFibsPlayerListPrivate::Invite7]  = new TDEAction(i18n("7 Point Match"), 0, this,
-                                                            TQT_SLOT(slotInvite7()), actions);
+                                                            TQ_SLOT(slotInvite7()), actions);
     d->mAct[KFibsPlayerListPrivate::InviteU]  = new TDEAction(i18n("Unlimited"),     0, this,
-                                                            TQT_SLOT(slotInviteU()), actions);
+                                                            TQ_SLOT(slotInviteU()), actions);
     d->mAct[KFibsPlayerListPrivate::InviteR]  = new TDEAction(i18n("Resume"),        0, this,
-                                                            TQT_SLOT(slotInviteR()), actions);
+                                                            TQ_SLOT(slotInviteR()), actions);
 
     /*
      * Fill normal context menu
@@ -362,10 +362,10 @@ KFibsPlayerList::KFibsPlayerList(TQWidget *parent, const char *name)
     /*
      * Right mouse button gets context menu, double click gets player info
      */
-    connect(this, TQT_SIGNAL(contextMenu(TDEListView *, TQListViewItem *, const TQPoint &)),
-            this, TQT_SLOT(showContextMenu(TDEListView *, TQListViewItem *, const TQPoint &)));
-    connect(this, TQT_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint &, int)),
-            this, TQT_SLOT(getPlayerInfo(TQListViewItem *, const TQPoint &, int)));
+    connect(this, TQ_SIGNAL(contextMenu(TDEListView *, TQListViewItem *, const TQPoint &)),
+            this, TQ_SLOT(showContextMenu(TDEListView *, TQListViewItem *, const TQPoint &)));
+    connect(this, TQ_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint &, int)),
+            this, TQ_SLOT(getPlayerInfo(TQListViewItem *, const TQPoint &, int)));
 }
 
 /*
@@ -482,7 +482,7 @@ void KFibsPlayerList::getSetupPages(KTabCtl *nb, int space)
      */
     nb->addTab(w, i18n("&Playerlist"));
 
-    connect(nb, TQT_SIGNAL(applyButtonPressed()), this, TQT_SLOT(setupOk()));
+    connect(nb, TQ_SIGNAL(applyButtonPressed()), this, TQ_SLOT(setupOk()));
 }
 
 /*
diff --git a/kbackgammon/engines/generic/kbgengine.cpp b/kbackgammon/engines/generic/kbgengine.cpp
index 3e193984..677c8b49 100644
--- a/kbackgammon/engines/generic/kbgengine.cpp
+++ b/kbackgammon/engines/generic/kbgengine.cpp
@@ -38,7 +38,7 @@ KBgEngine::KBgEngine(TQWidget *parent, TQString *name, TQPopupMenu *pmenu)
     menu = pmenu;
     cl = -1;
     ct = new TQTimer(this);
-    connect(ct, TQT_SIGNAL(timeout()), this, TQT_SLOT(done()));
+    connect(ct, TQ_SIGNAL(timeout()), this, TQ_SLOT(done()));
 }
 
 /*
diff --git a/kbackgammon/engines/gnubg/kbggnubg.cpp b/kbackgammon/engines/gnubg/kbggnubg.cpp
index 6b49a78d..72f683c8 100644
--- a/kbackgammon/engines/gnubg/kbggnubg.cpp
+++ b/kbackgammon/engines/gnubg/kbggnubg.cpp
@@ -433,12 +433,12 @@ KBgEngineGNU::KBgEngineGNU(TQWidget *parent, TQString *name, TQPopupMenu *pmenu)
 	 * internal statue variables
 	 */
 	rollingAllowed = undoPossible = gameRunning = donePossible = false;
-	connect(this, TQT_SIGNAL(allowCommand(int, bool)), this, TQT_SLOT(setAllowed(int, bool)));
+	connect(this, TQ_SIGNAL(allowCommand(int, bool)), this, TQ_SLOT(setAllowed(int, bool)));
 
 	/*
 	 * Setup of menu
 	 */
-	resAction  = new TDEAction(i18n("&Restart GNU Backgammon"), 0, this, TQT_SLOT(startGNU()), this);
+	resAction  = new TDEAction(i18n("&Restart GNU Backgammon"), 0, this, TQ_SLOT(startGNU()), this);
 	resAction->setEnabled(false); resAction->plug(menu);
 
 	/*
@@ -468,7 +468,7 @@ void KBgEngineGNU::start()
 	 * Will be started later
 	 */
 	cmdTimer = new TQTimer(this);
-	connect(cmdTimer, TQT_SIGNAL(timeout()), TQT_SLOT(nextCommand()) );
+	connect(cmdTimer, TQ_SIGNAL(timeout()), TQ_SLOT(nextCommand()) );
 
 	emit infoText(i18n("This is experimental code which currently requires a specially "
 			   "patched version of GNU Backgammon.<br/><br/>"));
@@ -483,12 +483,12 @@ void KBgEngineGNU::start()
 	 */
 	gnubg << "gnubg" << "--tty";
 
-        connect(&gnubg, TQT_SIGNAL(processExited(TDEProcess *)), this, TQT_SLOT(gnubgExit(TDEProcess *)));
-        connect(&gnubg, TQT_SIGNAL(receivedStderr(TDEProcess *, char *, int)),
-		this, TQT_SLOT(receiveData(TDEProcess *, char *, int)));
-	connect(&gnubg, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
-		this, TQT_SLOT(receiveData(TDEProcess *, char *, int)));
-	connect(&gnubg, TQT_SIGNAL(wroteStdin(TDEProcess *)), this, TQT_SLOT(wroteStdin(TDEProcess *)));
+        connect(&gnubg, TQ_SIGNAL(processExited(TDEProcess *)), this, TQ_SLOT(gnubgExit(TDEProcess *)));
+        connect(&gnubg, TQ_SIGNAL(receivedStderr(TDEProcess *, char *, int)),
+		this, TQ_SLOT(receiveData(TDEProcess *, char *, int)));
+	connect(&gnubg, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
+		this, TQ_SLOT(receiveData(TDEProcess *, char *, int)));
+	connect(&gnubg, TQ_SIGNAL(wroteStdin(TDEProcess *)), this, TQ_SLOT(wroteStdin(TDEProcess *)));
 
 	startGNU();
 }
diff --git a/kbackgammon/engines/nextgen/kbgng.cpp b/kbackgammon/engines/nextgen/kbgng.cpp
index aadb536f..a9e1ac56 100644
--- a/kbackgammon/engines/nextgen/kbgng.cpp
+++ b/kbackgammon/engines/nextgen/kbgng.cpp
@@ -67,13 +67,13 @@ KBgEngineNg::KBgEngineNg(TQWidget *parent, TQString *name, TQPopupMenu *pmenu)
     for (int i = 0; i < MaxTypes; i++)
 	list.append(label[i]);
 
-    _gameSelect = new TDESelectAction(i18n("&Types"), 0, this, TQT_SLOT(setGame()), this);
+    _gameSelect = new TDESelectAction(i18n("&Types"), 0, this, TQ_SLOT(setGame()), this);
     _gameSelect->setItems(list);
     _gameSelect->plug(menu);
 
     menu->insertSeparator();
 
-    _connectAction = new TDEAction(i18n("&Names..."), 0, this, TQT_SLOT(changeName()), this);
+    _connectAction = new TDEAction(i18n("&Names..."), 0, this, TQ_SLOT(changeName()), this);
     _connectAction->plug(menu);
 
     // Restore last settings
@@ -588,8 +588,8 @@ KBgPlayer * KBgEngineNg::createPlayer(int i, TQString name)
 
     p->findProperty(KGamePropertyBase::IdName)->setEmittingSignal(true);
 
-    connect(p, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KPlayer *)),
-	    this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase *, KPlayer *)));
+    connect(p, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KPlayer *)),
+	    this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase *, KPlayer *)));
 
     return (_player[i] = p);
 }
@@ -602,20 +602,20 @@ void KBgEngineNg::initGame()
     _game = new KBgGame(PROG_COOKIE);
     _game->random()->setSeed(getpid()*time(NULL));
 
-    connect(_game, TQT_SIGNAL(signalPlayerJoinedGame(KPlayer *)),
-	    this, TQT_SLOT(slotPlayerJoinedGame(KPlayer *)));
-    connect(_game, TQT_SIGNAL(signalCreatePlayer(KPlayer *&, int, int, bool, KGame *)),
-	    this, TQT_SLOT(slotCreatePlayer(KPlayer *&, int, int, bool, KGame *)));
+    connect(_game, TQ_SIGNAL(signalPlayerJoinedGame(KPlayer *)),
+	    this, TQ_SLOT(slotPlayerJoinedGame(KPlayer *)));
+    connect(_game, TQ_SIGNAL(signalCreatePlayer(KPlayer *&, int, int, bool, KGame *)),
+	    this, TQ_SLOT(slotCreatePlayer(KPlayer *&, int, int, bool, KGame *)));
 
-    connect(_game, TQT_SIGNAL(signalClientConnected(TQ_UINT32)),
-	    this, TQT_SLOT(slotClientConnected(TQ_UINT32)));
-    connect(_game, TQT_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)),
-	    this, TQT_SLOT(slotClientDisconnected(TQ_UINT32, bool)));
+    connect(_game, TQ_SIGNAL(signalClientConnected(TQ_UINT32)),
+	    this, TQ_SLOT(slotClientConnected(TQ_UINT32)));
+    connect(_game, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)),
+	    this, TQ_SLOT(slotClientDisconnected(TQ_UINT32, bool)));
 
-    connect(_game, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KGame *)),
-	    this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase *, KGame *)));
-    connect(_game, TQT_SIGNAL(signalNetworkData(int,const TQByteArray &, TQ_UINT32, TQ_UINT32)),
-	    this, TQT_SLOT(slotNetworkData(int,const TQByteArray &, TQ_UINT32, TQ_UINT32)));
+    connect(_game, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KGame *)),
+	    this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase *, KGame *)));
+    connect(_game, TQ_SIGNAL(signalNetworkData(int,const TQByteArray &, TQ_UINT32, TQ_UINT32)),
+	    this, TQ_SLOT(slotNetworkData(int,const TQByteArray &, TQ_UINT32, TQ_UINT32)));
 }
 
 // EOF
diff --git a/kbackgammon/engines/offline/kbgoffline.cpp b/kbackgammon/engines/offline/kbgoffline.cpp
index ce8dd54d..f1a16189 100644
--- a/kbackgammon/engines/offline/kbgoffline.cpp
+++ b/kbackgammon/engines/offline/kbgoffline.cpp
@@ -119,11 +119,11 @@ KBgEngineOffline::KBgEngineOffline(TQWidget *parent, TQString *name, TQPopupMenu
     /*
      * Create engine specific actions
      */
-    d->mNew  = new TDEAction(i18n("&New Game..."),    0, this, TQT_SLOT(newGame()),  this);
-    d->mSwap = new TDEAction(i18n("&Swap Colors"), 0, this, TQT_SLOT(swapColors()), this);
+    d->mNew  = new TDEAction(i18n("&New Game..."),    0, this, TQ_SLOT(newGame()),  this);
+    d->mSwap = new TDEAction(i18n("&Swap Colors"), 0, this, TQ_SLOT(swapColors()), this);
 
     d->mEdit = new TDEToggleAction(i18n("&Edit Mode"), 0, this,
-                                 TQT_SLOT(toggleEditMode()), this);
+                                 TQ_SLOT(toggleEditMode()), this);
     d->mEdit->setChecked(false);
 
     /*
@@ -143,13 +143,13 @@ KBgEngineOffline::KBgEngineOffline(TQWidget *parent, TQString *name, TQPopupMenu
      * initialize the commit timeout
      */
     ct = new TQTimer(this);
-    connect(ct, TQT_SIGNAL(timeout()), this, TQT_SLOT(done()));
+    connect(ct, TQ_SIGNAL(timeout()), this, TQ_SLOT(done()));
 
     /*
      * internal statue variables
      */
     d->mRollFlag = d->mUndoFlag = d->mGameFlag = d->mDoneFlag = false;
-    connect(this, TQT_SIGNAL(allowCommand(int, bool)), this, TQT_SLOT(setAllowed(int, bool)));
+    connect(this, TQ_SIGNAL(allowCommand(int, bool)), this, TQ_SLOT(setAllowed(int, bool)));
 
     /*
      * Restore last stored settings
diff --git a/kbackgammon/kbg.cpp b/kbackgammon/kbg.cpp
index 0b51b056..6034d670 100644
--- a/kbackgammon/kbg.cpp
+++ b/kbackgammon/kbg.cpp
@@ -96,45 +96,45 @@ KBg::KBg()
 	/*
 	 * Create all actions needed by the application
 	 */
-	newAction = KStdGameAction::gameNew(this, TQT_SLOT(openNew()), actionCollection());
+	newAction = KStdGameAction::gameNew(this, TQ_SLOT(openNew()), actionCollection());
     newAction->setEnabled(false);
-	KStdGameAction::print(this, TQT_SLOT(print()), actionCollection());
-	KStdGameAction::quit(this, TQT_SLOT(close()),  actionCollection());
+	KStdGameAction::print(this, TQ_SLOT(print()), actionCollection());
+	KStdGameAction::quit(this, TQ_SLOT(close()),  actionCollection());
 
 	TQStringList list;
 	for (int i = 0; i < MaxEngine; i++)
 		list.append(engineString[i]);
-	engineSet = new TDESelectAction(i18n("&Engine"), 0, this, TQT_SLOT(setupEngine()), actionCollection(),
+	engineSet = new TDESelectAction(i18n("&Engine"), 0, this, TQ_SLOT(setupEngine()), actionCollection(),
                                   "move_engine");
     engineSet->setItems(list);
 
     // AB: what the heck has this to do with redisplay? perhaps use reload instead?
-	loadAction = KStdAction::redisplay(this, TQT_SLOT(load()), actionCollection(), "move_load");
+	loadAction = KStdAction::redisplay(this, TQ_SLOT(load()), actionCollection(), "move_load");
     loadAction->setEnabled(false);
-	undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
+	undoAction = KStdGameAction::undo(this, TQ_SLOT(undo()), actionCollection());
     undoAction->setEnabled(false);
-	redoAction = KStdGameAction::redo(this, TQT_SLOT(redo()), actionCollection());
+	redoAction = KStdGameAction::redo(this, TQ_SLOT(redo()), actionCollection());
     redoAction->setEnabled(false);
 
-	rollAction = KStdGameAction::roll(this, TQT_SLOT(roll()), actionCollection());
+	rollAction = KStdGameAction::roll(this, TQ_SLOT(roll()), actionCollection());
     rollAction->setEnabled(false);
-	endAction = KStdGameAction::endTurn(this, TQT_SLOT(done()), actionCollection());
+	endAction = KStdGameAction::endTurn(this, TQ_SLOT(done()), actionCollection());
     endAction->setEnabled(false);
     cubeAction = new TDEAction(i18n("Double Cube"), TQIconSet(kapp->iconLoader()->loadIcon
                                                           (PROG_NAME "-double.xpm", TDEIcon::Toolbar)),
-                              0, this, TQT_SLOT(cube()), actionCollection(), "move_cube");
+                              0, this, TQ_SLOT(cube()), actionCollection(), "move_cube");
     cubeAction->setEnabled(false);
 
-	KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()),     actionCollection());
-	KStdAction::preferences(this, TQT_SLOT(setupDlg()), actionCollection());
-	KStdAction::saveOptions(this, TQT_SLOT(saveConfig()), actionCollection());
+	KStdAction::showMenubar(this, TQ_SLOT(toggleMenubar()),     actionCollection());
+	KStdAction::preferences(this, TQ_SLOT(setupDlg()), actionCollection());
+	KStdAction::saveOptions(this, TQ_SLOT(saveConfig()), actionCollection());
 
 	TDEPopupMenu *p = (new TDEActionMenu(i18n("&Backgammon on the Web"),
 					 actionCollection(), "help_www"))->popupMenu();
 
-	(new TDEAction(helpTopic[FIBSHome][0], 0, this, TQT_SLOT(wwwFIBS()),
+	(new TDEAction(helpTopic[FIBSHome][0], 0, this, TQ_SLOT(wwwFIBS()),
 		     actionCollection(), "help_www_fibs"))->plug(p);
-	(new TDEAction(helpTopic[RuleHome][0], 0, this, TQT_SLOT(wwwRule()),
+	(new TDEAction(helpTopic[RuleHome][0], 0, this, TQ_SLOT(wwwRule()),
 		     actionCollection(), "help_www_rule"))->plug(p);
 
 	/*
@@ -148,7 +148,7 @@ KBg::KBg()
 	actionCmdLine->setAutoSized(true);
 
 	cmdLine->completionObject()->setOrder(TDECompletion::Weighted);
-	connect(cmdLine, TQT_SIGNAL(returnPressed(const TQString &)), this, TQT_SLOT(handleCmd(const TQString &)));
+	connect(cmdLine, TQ_SIGNAL(returnPressed(const TQString &)), this, TQ_SLOT(handleCmd(const TQString &)));
 	/*
 	 * Done with the actions, create the XML-defined parts of the
 	 * user interface
@@ -172,8 +172,8 @@ KBg::KBg()
 	 * Set up configuration handling.
 	 * FIXME: support session management
 	 */
-	connect(this, TQT_SIGNAL(readSettings()), board, TQT_SLOT(readConfig()));
-	connect(this, TQT_SIGNAL(saveSettings()), board, TQT_SLOT(saveConfig()));
+	connect(this, TQ_SIGNAL(readSettings()), board, TQ_SLOT(readConfig()));
+	connect(this, TQ_SIGNAL(saveSettings()), board, TQ_SLOT(saveConfig()));
 
 	/*
 	 * Set up some whatis messages for the online help
@@ -274,26 +274,26 @@ void KBg::setupEngine()
 	newAction->setEnabled(engine[currEngine]->haveNewGame());
 
 	// engine -> this
-	connect(engine[currEngine], TQT_SIGNAL(statText(const TQString &)), this, TQT_SLOT(updateCaption(const TQString &)));
-	connect(engine[currEngine], TQT_SIGNAL(infoText(const TQString &)), status, TQT_SLOT(write(const TQString &)));
-	connect(engine[currEngine], TQT_SIGNAL(allowCommand(int, bool)),   this, TQT_SLOT(allowCommand(int, bool)));
+	connect(engine[currEngine], TQ_SIGNAL(statText(const TQString &)), this, TQ_SLOT(updateCaption(const TQString &)));
+	connect(engine[currEngine], TQ_SIGNAL(infoText(const TQString &)), status, TQ_SLOT(write(const TQString &)));
+	connect(engine[currEngine], TQ_SIGNAL(allowCommand(int, bool)),   this, TQ_SLOT(allowCommand(int, bool)));
 
 	// this -> engine
-	connect(this, TQT_SIGNAL(readSettings()), engine[currEngine], TQT_SLOT(readConfig()));
-	connect(this, TQT_SIGNAL(saveSettings()), engine[currEngine], TQT_SLOT(saveConfig()));
+	connect(this, TQ_SIGNAL(readSettings()), engine[currEngine], TQ_SLOT(readConfig()));
+	connect(this, TQ_SIGNAL(saveSettings()), engine[currEngine], TQ_SLOT(saveConfig()));
 
 	// board -> engine
-	connect(board, TQT_SIGNAL(rollDice(const int)),    engine[currEngine], TQT_SLOT(rollDice(const int)));
-	connect(board, TQT_SIGNAL(doubleCube(const int)),  engine[currEngine], TQT_SLOT(doubleCube(const int)));
-	connect(board, TQT_SIGNAL(currentMove(TQString *)), engine[currEngine], TQT_SLOT(handleMove(TQString *)));
+	connect(board, TQ_SIGNAL(rollDice(const int)),    engine[currEngine], TQ_SLOT(rollDice(const int)));
+	connect(board, TQ_SIGNAL(doubleCube(const int)),  engine[currEngine], TQ_SLOT(doubleCube(const int)));
+	connect(board, TQ_SIGNAL(currentMove(TQString *)), engine[currEngine], TQ_SLOT(handleMove(TQString *)));
 
 	// engine -> board
-	connect(engine[currEngine], TQT_SIGNAL(undoMove()), board, TQT_SLOT(undoMove()));
-	connect(engine[currEngine], TQT_SIGNAL(redoMove()), board, TQT_SLOT(redoMove()));
-	connect(engine[currEngine], TQT_SIGNAL(setEditMode(const bool)), board, TQT_SLOT(setEditMode(const bool)));
-	connect(engine[currEngine], TQT_SIGNAL(allowMoving(const bool)), board, TQT_SLOT(allowMoving(const bool)));
-	connect(engine[currEngine], TQT_SIGNAL(getState(KBgStatus *)), board, TQT_SLOT(getState(KBgStatus *)));
-	connect(engine[currEngine], TQT_SIGNAL(newState(const KBgStatus &)), board, TQT_SLOT(setState(const KBgStatus &)));
+	connect(engine[currEngine], TQ_SIGNAL(undoMove()), board, TQ_SLOT(undoMove()));
+	connect(engine[currEngine], TQ_SIGNAL(redoMove()), board, TQ_SLOT(redoMove()));
+	connect(engine[currEngine], TQ_SIGNAL(setEditMode(const bool)), board, TQ_SLOT(setEditMode(const bool)));
+	connect(engine[currEngine], TQ_SIGNAL(allowMoving(const bool)), board, TQ_SLOT(allowMoving(const bool)));
+	connect(engine[currEngine], TQ_SIGNAL(getState(KBgStatus *)), board, TQ_SLOT(getState(KBgStatus *)));
+	connect(engine[currEngine], TQ_SIGNAL(newState(const KBgStatus &)), board, TQ_SLOT(setState(const KBgStatus &)));
 
 	// now that all signals are connected, start the engine
 	engine[currEngine]->start();
@@ -535,7 +535,7 @@ void KBg::setupDlg()
 	sbt->setLabel(i18n("Move timeout in seconds:"));
 	sbt->setValue(config->readDoubleNumEntry("timeout", 2.5));
 
-	connect(cbt, TQT_SIGNAL(toggled(bool)), sbt, TQT_SLOT(setEnabled(bool)));
+	connect(cbt, TQ_SIGNAL(toggled(bool)), sbt, TQ_SLOT(setEnabled(bool)));
 	sbt->setEnabled(cbt->isChecked());
 
 	TQGridLayout *gl = new TQGridLayout(gbt, 2, 1, 20);
@@ -577,7 +577,7 @@ void KBg::setupDlg()
 	lab->setMaximumSize(lab->sizeHint());
 
 	gle->addWidget(lab, 0, 0);
-	connect(lab, TQT_SIGNAL(leftClickedURL(const TQString &)), TQT_SLOT(startKCM(const TQString &)));
+	connect(lab, TQ_SIGNAL(leftClickedURL(const TQString &)), TQ_SLOT(startKCM(const TQString &)));
 
 	/*
 	 * Board settings
@@ -606,7 +606,7 @@ void KBg::setupDlg()
 				engine[i] = new KBgEngineNg(nb, &s, dummyPopup);
 				break;
 			}
-			connect(this, TQT_SIGNAL(saveSettings()), engine[i], TQT_SLOT(saveConfig()));
+			connect(this, TQ_SIGNAL(saveSettings()), engine[i], TQ_SLOT(saveConfig()));
 		}
 		engine[i]->getSetupPages(nb);
 	}
@@ -614,12 +614,12 @@ void KBg::setupDlg()
 	/*
 	 * Connect the signals of nb
 	 */
-	connect(nb, TQT_SIGNAL(okClicked()),     this, TQT_SLOT(setupOk()));
-	connect(nb, TQT_SIGNAL(applyClicked()),  this, TQT_SLOT(setupOk()));
-	connect(nb, TQT_SIGNAL(cancelClicked()), this, TQT_SLOT(setupCancel()));
-	connect(nb, TQT_SIGNAL(defaultClicked()),this, TQT_SLOT(setupDefault()));
+	connect(nb, TQ_SIGNAL(okClicked()),     this, TQ_SLOT(setupOk()));
+	connect(nb, TQ_SIGNAL(applyClicked()),  this, TQ_SLOT(setupOk()));
+	connect(nb, TQ_SIGNAL(cancelClicked()), this, TQ_SLOT(setupCancel()));
+	connect(nb, TQ_SIGNAL(defaultClicked()),this, TQ_SLOT(setupDefault()));
 
-	connect(nb, TQT_SIGNAL(finished()), this, TQT_SLOT(setupDone()));
+	connect(nb, TQ_SIGNAL(finished()), this, TQ_SLOT(setupDone()));
 
 	nb->resize(nb->minimumSize());
 	nb->show();
@@ -685,7 +685,7 @@ void KBg::configureToolbars()
 {
 	saveMainWindowSettings(TDEGlobal::config(), "kedittoolbar settings"); // temp group
 	KEditToolbar dlg(actionCollection(), xmlFile(), true, this);
-	connect(&dlg,TQT_SIGNAL(newToolbarConfig()),this,TQT_SLOT(newToolbarConfig()));
+	connect(&dlg,TQ_SIGNAL(newToolbarConfig()),this,TQ_SLOT(newToolbarConfig()));
 	dlg.exec();
 	TDEGlobal::config()->deleteGroup( "kedittoolbar settings" ); // delete temp group
 }
diff --git a/kbackgammon/kbgboard.cpp b/kbackgammon/kbgboard.cpp
index 63d58281..cfc2d631 100644
--- a/kbackgammon/kbgboard.cpp
+++ b/kbackgammon/kbgboard.cpp
@@ -173,9 +173,9 @@ void KBgBoardSetup::getSetupPages(KDialogBase *nb)
 	blc->addWidget(pbc_3, 0, 1);
 	blc->addMultiCellWidget(pbc_1, 1, 1, 0, 1);
 
-	connect(pbc_1, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBackgroundColor()));
-	connect(pbc_2, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBaseColorOne()));
-	connect(pbc_3, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBaseColorTwo()));
+	connect(pbc_1, TQ_SIGNAL(clicked()), this, TQ_SLOT(selectBackgroundColor()));
+	connect(pbc_2, TQ_SIGNAL(clicked()), this, TQ_SLOT(selectBaseColorOne()));
+	connect(pbc_3, TQ_SIGNAL(clicked()), this, TQ_SLOT(selectBaseColorTwo()));
 
 	/*
 	 * Moving style
@@ -470,11 +470,11 @@ KBgBoardQCube::KBgBoardQCube(int val, bool us, bool them)
 
 	cb[0]->setFocus();
 
-	connect(ok,     TQT_SIGNAL(clicked()), TQT_SLOT(accept()));
-	connect(cancel, TQT_SIGNAL(clicked()), TQT_SLOT(reject()));
+	connect(ok,     TQ_SIGNAL(clicked()), TQ_SLOT(accept()));
+	connect(cancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
 
-	connect(cb[0],  TQT_SIGNAL(activated(int)), TQT_SLOT(changePlayer(int)));
-	connect(cb[1],  TQT_SIGNAL(activated(int)), TQT_SLOT(changeValue (int)));
+	connect(cb[0],  TQ_SIGNAL(activated(int)), TQ_SLOT(changePlayer(int)));
+	connect(cb[1],  TQ_SIGNAL(activated(int)), TQ_SLOT(changeValue (int)));
 }
 
 /*
@@ -576,8 +576,8 @@ KBgBoardQDice::KBgBoardQDice(const char *name)
 
 	sb[0]->setFocus();
 
-	connect(ok,     TQT_SIGNAL(clicked()), TQT_SLOT(accept()));
-	connect(cancel, TQT_SIGNAL(clicked()), TQT_SLOT(reject()));
+	connect(ok,     TQ_SIGNAL(clicked()), TQ_SLOT(accept()));
+	connect(cancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
 
 	sb[0]->setValue(1);
 	sb[1]->setValue(1);
@@ -1748,7 +1748,7 @@ KBgBoardCell::KBgBoardCell(TQWidget * parent, int numID)
 	mouseButton      = TQt::NoButton;
 	dragInProgress   = false;
 
-	connect(parent, TQT_SIGNAL(finishedUpdate()), this, TQT_SLOT(refresh()));
+	connect(parent, TQ_SIGNAL(finishedUpdate()), this, TQ_SLOT(refresh()));
 }
 
 /*