Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

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

19 files changed, 142 insertions, 142 deletions

diff --git a/libtdegames/kgame/DESIGN b/libtdegames/kgame/DESIGN
index 1b834454..0ad9be8b 100644
--- a/libtdegames/kgame/DESIGN
+++ b/libtdegames/kgame/DESIGN
@@ -347,7 +347,7 @@ a slot like
 slotDebug()
 {
  KGameDebugDialog* dialog = new KGameDebugDialog(mGame, this);
- connect(dialog, SIGNAL(finished()), dialog, SLOT(slotDelayedDestruct()));
+ connect(dialog, TQ_SIGNAL(finished()), dialog, TQ_SLOT(slotDelayedDestruct()));
  dialog->show();
 }
 that's it.
diff --git a/libtdegames/kgame/dialogs/kgameconnectdialog.cpp b/libtdegames/kgame/dialogs/kgameconnectdialog.cpp
index 2de27a0e..86d32ac2 100644
--- a/libtdegames/kgame/dialogs/kgameconnectdialog.cpp
+++ b/libtdegames/kgame/dialogs/kgameconnectdialog.cpp
@@ -63,7 +63,7 @@ KGameConnectWidget::KGameConnectWidget(TQWidget* parent) : TQWidget(parent)
  TQVBoxLayout* vb = new TQVBoxLayout(this, KDialog::spacingHint());
  d->mButtonGroup = new TQVButtonGroup(this);
  vb->addWidget(d->mButtonGroup);
- connect(d->mButtonGroup, TQT_SIGNAL(clicked(int)), this, TQT_SLOT(slotTypeChanged(int)));
+ connect(d->mButtonGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(slotTypeChanged(int)));
  (void)new TQRadioButton(i18n("Create a network game"), d->mButtonGroup);
  (void)new TQRadioButton(i18n("Join a network game"), d->mButtonGroup);
 
@@ -74,14 +74,14 @@ KGameConnectWidget::KGameConnectWidget(TQWidget* parent) : TQWidget(parent)
  d->mServerName = new TQLineEdit(g);
  d->mClientNameLabel = new TQLabel(i18n("Network games:"), g);
  d->mClientName = new TQComboBox(g);
- connect(d->mClientName,TQT_SIGNAL(activated(int)),TQT_SLOT(slotGameSelected(int)));
+ connect(d->mClientName,TQ_SIGNAL(activated(int)),TQ_SLOT(slotGameSelected(int)));
  (void)new TQLabel(i18n("Port to connect to:"), g);
  d->mPort = new KIntNumInput(g);
  (void)new TQLabel(i18n("Host to connect to:"), g);
  d->mHost = new TQLineEdit(g); 
 
  TQPushButton *button=new TQPushButton(i18n("&Start Network"), this);
- connect(button, TQT_SIGNAL(clicked()), this, TQT_SIGNAL(signalNetworkSetup()));
+ connect(button, TQ_SIGNAL(clicked()), this, TQ_SIGNAL(signalNetworkSetup()));
  vb->addWidget(button);
  // Hide until type is set
  d->mClientName->hide();
@@ -112,7 +112,7 @@ void KGameConnectWidget::setType(const TQString& type)
  d->mType = type;
  delete d->mBrowser;
  d->mBrowser = new DNSSD::ServiceBrowser(type);
- connect(d->mBrowser,TQT_SIGNAL(finished()),TQT_SLOT(slotGamesFound()));
+ connect(d->mBrowser,TQ_SIGNAL(finished()),TQ_SLOT(slotGamesFound()));
  d->mBrowser->startBrowse();
  showDnssdControls();
 }
diff --git a/libtdegames/kgame/dialogs/kgamedebugdialog.cpp b/libtdegames/kgame/dialogs/kgamedebugdialog.cpp
index 1b172cf2..7b82c909 100644
--- a/libtdegames/kgame/dialogs/kgamedebugdialog.cpp
+++ b/libtdegames/kgame/dialogs/kgamedebugdialog.cpp
@@ -156,7 +156,7 @@ void KGameDebugDialog::initGamePage()
  layout->addWidget(d->mGameProperties);
  
  TQPushButton* b = new TQPushButton(i18n("Update"), d->mGamePage);
- connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotUpdateGameData()));
+ connect(b, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotUpdateGameData()));
  topLayout->addWidget(b);
 
 // game data
@@ -184,7 +184,7 @@ void KGameDebugDialog::initPlayerPage()
  TQLabel* listLabel = new TQLabel(i18n("Available Players"), d->mPlayerPage);
  listLayout->addWidget(listLabel);
  d->mPlayerList = new TDEListBox(d->mPlayerPage);
- connect(d->mPlayerList, TQT_SIGNAL(executed(TQListBoxItem*)), this, TQT_SLOT(slotUpdatePlayerData(TQListBoxItem*)));
+ connect(d->mPlayerList, TQ_SIGNAL(executed(TQListBoxItem*)), this, TQ_SLOT(slotUpdatePlayerData(TQListBoxItem*)));
  listLayout->addWidget(d->mPlayerList);
  d->mPlayerList->setSizePolicy(TQSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Expanding));
 
@@ -200,7 +200,7 @@ void KGameDebugDialog::initPlayerPage()
  layout->addWidget(d->mPlayerProperties);
  
  TQPushButton* b = new TQPushButton(i18n("Update"), d->mPlayerPage);
- connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotUpdatePlayerList()));
+ connect(b, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotUpdatePlayerList()));
  topLayout->addWidget(b);
 
  d->mPlayerAddress = new TQListViewItem(v, i18n("Player Pointer"));
@@ -230,11 +230,11 @@ void KGameDebugDialog::initMessagePage()
  d->mMessageList->addColumn(i18n("ID - Text"));
 
  TQPushButton* hide = new TQPushButton(i18n("&>>"), d->mMessagePage);
- connect(hide, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotHideId()));
+ connect(hide, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotHideId()));
  layout->addWidget(hide, 4, 4);
  
  TQPushButton* show = new TQPushButton(i18n("&<<"), d->mMessagePage);
- connect(show, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotShowId()));
+ connect(show, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotShowId()));
  layout->addWidget(show, 6, 4);
 
  TQLabel* l = new TQLabel(i18n("Do not show IDs:"), d->mMessagePage);
@@ -243,7 +243,7 @@ void KGameDebugDialog::initMessagePage()
  layout->addMultiCellWidget(d->mHideIdList, 1, 8, 5, 6);
 
  TQPushButton* clear = new KPushButton(KStdGuiItem::clear(), d->mMessagePage);
- connect(clear, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotClearMessages()));
+ connect(clear, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotClearMessages()));
  layout->addMultiCellWidget(clear, 10, 10, 0, 6);
  //TODO: "show all but..." and "show nothing but..."
 }
@@ -431,7 +431,7 @@ void KGameDebugDialog::setKGame(const KGame* g)
  d->mGame = g;
  if (g) {
  //TODO: connect to the KGame signals for joined/removed players!!!
-	connect(d->mGame, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotUnsetKGame()));
+	connect(d->mGame, TQ_SIGNAL(destroyed()), this, TQ_SLOT(slotUnsetKGame()));
 //	connect();
 
 	TQPtrList<KPlayer> list = *d->mGame->playerList();
@@ -441,7 +441,7 @@ void KGameDebugDialog::setKGame(const KGame* g)
 
 	slotUpdateGameData();
 
-	connect(d->mGame, TQT_SIGNAL(signalMessageUpdate(int, TQ_UINT32, TQ_UINT32)), this, TQT_SLOT(slotMessageUpdate(int, TQ_UINT32, TQ_UINT32)));
+	connect(d->mGame, TQ_SIGNAL(signalMessageUpdate(int, TQ_UINT32, TQ_UINT32)), this, TQ_SLOT(slotMessageUpdate(int, TQ_UINT32, TQ_UINT32)));
  }
 }
 
diff --git a/libtdegames/kgame/dialogs/kgamedialog.cpp b/libtdegames/kgame/dialogs/kgamedialog.cpp
index a2440355..077d7f32 100644
--- a/libtdegames/kgame/dialogs/kgamedialog.cpp
+++ b/libtdegames/kgame/dialogs/kgamedialog.cpp
@@ -239,7 +239,7 @@ void KGameDialog::addConfigWidget(KGameDialogConfig* widget, TQWidget* parent)
 // kdDebug(11001) << "reparenting widget" << endl;
  widget->reparent(parent, TQPoint(0,0));
  d->mConfigWidgets.append(widget);
- connect(widget, TQT_SIGNAL(destroyed(TQObject*)), this, TQT_SLOT(slotRemoveConfigWidget(TQObject*)));
+ connect(widget, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(slotRemoveConfigWidget(TQObject*)));
  if (!d->mGame) {
 	kdWarning(11001) << "No game has been set!" << endl;
  } else {
@@ -306,9 +306,9 @@ void KGameDialog::setKGame(KGame* g)
  }
  if (d->mGame) {
 	setAdmin(d->mGame->isAdmin());
-	connect(d->mGame, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotUnsetKGame()));
-	connect(d->mGame, TQT_SIGNAL(signalAdminStatusChanged(bool)), 
-			this, TQT_SLOT(setAdmin(bool)));
+	connect(d->mGame, TQ_SIGNAL(destroyed()), this, TQ_SLOT(slotUnsetKGame()));
+	connect(d->mGame, TQ_SIGNAL(signalAdminStatusChanged(bool)), 
+			this, TQ_SLOT(setAdmin(bool)));
  }
 }
 
diff --git a/libtdegames/kgame/dialogs/kgamedialogconfig.cpp b/libtdegames/kgame/dialogs/kgamedialogconfig.cpp
index a14abe73..646e8e41 100644
--- a/libtdegames/kgame/dialogs/kgamedialogconfig.cpp
+++ b/libtdegames/kgame/dialogs/kgamedialogconfig.cpp
@@ -130,16 +130,16 @@ KGameDialogNetworkConfig::KGameDialogNetworkConfig(TQWidget* parent)
  hb->addWidget(d->mNetworkLabel);
 
  d->mDisconnectButton=new TQPushButton(i18n("Disconnect"),this);
- connect(d->mDisconnectButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotExitConnection()));
+ connect(d->mDisconnectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotExitConnection()));
  hb->addWidget(d->mDisconnectButton);
 
  d->mInitConnection = new TQHGroupBox(i18n("Network Configuration"), this);
  topLayout->addWidget(d->mInitConnection);
 
  d->mConnect = new KGameConnectWidget(d->mInitConnection);
- connect(d->mConnect, TQT_SIGNAL(signalNetworkSetup()), this, TQT_SLOT(slotInitConnection()));
- connect(d->mConnect, TQT_SIGNAL(signalServerTypeChanged(int)),
-         this, TQT_SIGNAL(signalServerTypeChanged(int)));
+ connect(d->mConnect, TQ_SIGNAL(signalNetworkSetup()), this, TQ_SLOT(slotInitConnection()));
+ connect(d->mConnect, TQ_SIGNAL(signalServerTypeChanged(int)),
+         this, TQ_SIGNAL(signalServerTypeChanged(int)));
 
  // Needs to be AFTER the creation of the dialogs
  setConnected(false);
@@ -180,8 +180,8 @@ void KGameDialogNetworkConfig::slotInitConnection()
 	}
   // We need to learn about failed connections
   if (game()) {
-     connect(game(), TQT_SIGNAL(signalConnectionBroken()),
-      this, TQT_SLOT(slotConnectionBroken()));
+     connect(game(), TQ_SIGNAL(signalConnectionBroken()),
+      this, TQ_SLOT(slotConnectionBroken()));
   }
  }
  setConnected(connected, master);
@@ -309,8 +309,8 @@ void KGameDialogGeneralConfig::setOwner(KPlayer* p)
 	// maybe call hide()
 	return;
  }
- connect(owner(), TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
-		this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
+ connect(owner(), TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
+		this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
  setPlayerName(p->name());
  //TODO: connect signalPropertyChanged and check for playername changes!
 }
@@ -408,7 +408,7 @@ void KGameDialogMsgServerConfig::setKGame(KGame* g)
 {
  KGameDialogConfig::setKGame(g);
  //TODO display the ID of the admin if we aren't
- // connect(g, TQT_SIGNAL(signalAdminChanged(int)), this, TQT_SLOT(slotChangeIsAdmin(int)));//TODO
+ // connect(g, TQ_SIGNAL(signalAdminChanged(int)), this, TQ_SLOT(slotChangeIsAdmin(int)));//TODO
  if (!game()) {
 	// we cannot do anything without a KGame object!
 	setAdmin(false);
@@ -488,11 +488,11 @@ void KGameDialogMsgServerConfig::setAdmin(bool a)
 		d->noAdmin = 0;
 	}
 	d->changeMaxClients = new TQPushButton(i18n("Change Maximal Number of Clients"), this);
-	connect(d->changeMaxClients, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotChangeMaxClients()));
+	connect(d->changeMaxClients, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotChangeMaxClients()));
 	d->changeAdmin = new TQPushButton(i18n("Change Admin"), this);
-	connect(d->changeAdmin, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotChangeAdmin()));
+	connect(d->changeAdmin, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotChangeAdmin()));
 	d->removeClient = new TQPushButton(i18n("Remove Client with All Players"), this);
-	connect(d->removeClient, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotRemoveClient()));
+	connect(d->removeClient, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotRemoveClient()));
 	d->senderLayout->addWidget(d->changeMaxClients);
 	d->senderLayout->addWidget(d->changeAdmin);
 	d->senderLayout->addWidget(d->removeClient);
@@ -627,10 +627,10 @@ void KGameDialogConnectionConfig::setKGame(KGame* g)
  slotClearPlayers();
  if (game()) {
 // react to changes in KGame::playerList()
-	connect(game(), TQT_SIGNAL(signalPlayerJoinedGame(KPlayer*)),
-			this, TQT_SLOT(slotPlayerJoinedGame(KPlayer*)));
-	connect(game(), TQT_SIGNAL(signalPlayerLeftGame(KPlayer*)),
-			this, TQT_SLOT(slotPlayerLeftGame(KPlayer*)));
+	connect(game(), TQ_SIGNAL(signalPlayerJoinedGame(KPlayer*)),
+			this, TQ_SLOT(slotPlayerJoinedGame(KPlayer*)));
+	connect(game(), TQ_SIGNAL(signalPlayerLeftGame(KPlayer*)),
+			this, TQ_SLOT(slotPlayerLeftGame(KPlayer*)));
 
 	KGame::KGamePlayerList l = *game()->playerList();
 	for (KPlayer* p = l.first(); p; p = l.next()) {
@@ -650,12 +650,12 @@ void KGameDialogConnectionConfig::setAdmin(bool a)
 	return;
  }
  if (admin()) {
-	disconnect(game(), TQT_SIGNAL(executed(TQListBoxItem*)), this, 0);
+	disconnect(game(), TQ_SIGNAL(executed(TQListBoxItem*)), this, 0);
  }
  KGameDialogConfig::setAdmin(a);
  if (admin()) {
-	connect(d->mPlayerBox, TQT_SIGNAL(executed(TQListBoxItem*)), this,
-			TQT_SLOT(slotKickPlayerOut(TQListBoxItem*)));
+	connect(d->mPlayerBox, TQ_SIGNAL(executed(TQListBoxItem*)), this,
+			TQ_SLOT(slotKickPlayerOut(TQListBoxItem*)));
  }
 }
 
@@ -704,8 +704,8 @@ void KGameDialogConnectionConfig::slotPlayerJoinedGame(KPlayer* p)
  d->mItem2Player.insert(t, p);
  d->mPlayerBox->insertItem(t);
 
- 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*)));
 
 }
 
diff --git a/libtdegames/kgame/dialogs/kgameerrordialog.cpp b/libtdegames/kgame/dialogs/kgameerrordialog.cpp
index 468ca7c8..574d4545 100644
--- a/libtdegames/kgame/dialogs/kgameerrordialog.cpp
+++ b/libtdegames/kgame/dialogs/kgameerrordialog.cpp
@@ -52,15 +52,15 @@ void KGameErrorDialog::setKGame(const KGame* g)
  slotUnsetKGame();
  d->mGame = g;
 
- connect(d->mGame, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotUnsetKGame()));
+ connect(d->mGame, TQ_SIGNAL(destroyed()), this, TQ_SLOT(slotUnsetKGame()));
 
 // the error signals:
- connect(d->mGame, TQT_SIGNAL(signalNetworkErrorMessage(int, TQString)), 
-		this, TQT_SLOT(slotError(int, TQString)));
- connect(d->mGame, TQT_SIGNAL(signalConnectionBroken()), 
-		this, TQT_SLOT(slotServerConnectionLost()));
- connect(d->mGame, TQT_SIGNAL(signalClientDisconnected(TQ_UINT32,bool)), 
-		this, TQT_SLOT(slotClientConnectionLost(TQ_UINT32,bool)));
+ connect(d->mGame, TQ_SIGNAL(signalNetworkErrorMessage(int, TQString)), 
+		this, TQ_SLOT(slotError(int, TQString)));
+ connect(d->mGame, TQ_SIGNAL(signalConnectionBroken()), 
+		this, TQ_SLOT(slotServerConnectionLost()));
+ connect(d->mGame, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32,bool)), 
+		this, TQ_SLOT(slotClientConnectionLost(TQ_UINT32,bool)));
 }
 
 void KGameErrorDialog::slotUnsetKGame()
diff --git a/libtdegames/kgame/kgame.cpp b/libtdegames/kgame/kgame.cpp
index 70d0644c..a3967cc3 100644
--- a/libtdegames/kgame/kgame.cpp
+++ b/libtdegames/kgame/kgame.cpp
@@ -89,8 +89,8 @@ KGame::KGame(int cookie,TQObject* parent) : KGameNetwork(cookie,parent)
  d->mProperties = new KGamePropertyHandler(this);
 
  d->mProperties->registerHandler(KGameMessage::IdGameProperty,
-                                this,TQT_SLOT(sendProperty(int, TQDataStream&, bool* )),
-                                     TQT_SLOT(emitSignal(KGamePropertyBase *)));
+                                this,TQ_SLOT(sendProperty(int, TQDataStream&, bool* )),
+                                     TQ_SLOT(emitSignal(KGamePropertyBase *)));
  d->mMaxPlayer.registerData(KGamePropertyBase::IdMaxPlayer, this, i18n("MaxPlayers"));
  d->mMaxPlayer.setLocal(-1);  // Infinite
  d->mMinPlayer.registerData(KGamePropertyBase::IdMinPlayer, this, i18n("MinPlayers"));
@@ -101,20 +101,20 @@ KGame::KGame(int cookie,TQObject* parent) : KGameNetwork(cookie,parent)
  d->mRandom = new KRandomSequence;
  d->mRandom->setSeed(0);
 
- connect(this, TQT_SIGNAL(signalClientConnected(TQ_UINT32)),
-                this, TQT_SLOT(slotClientConnected(TQ_UINT32)));
- connect(this, TQT_SIGNAL(signalClientDisconnected(TQ_UINT32,bool)),
-                this, TQT_SLOT(slotClientDisconnected(TQ_UINT32,bool)));
- connect(this, TQT_SIGNAL(signalConnectionBroken()),
-                this, TQT_SLOT(slotServerDisconnected()));
+ connect(this, TQ_SIGNAL(signalClientConnected(TQ_UINT32)),
+                this, TQ_SLOT(slotClientConnected(TQ_UINT32)));
+ connect(this, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32,bool)),
+                this, TQ_SLOT(slotClientDisconnected(TQ_UINT32,bool)));
+ connect(this, TQ_SIGNAL(signalConnectionBroken()),
+                this, TQ_SLOT(slotServerDisconnected()));
 
  setGameSequence(new KGameSequence());
 
  // BL: FIXME This signal does no longer exist. When we are merging
  // MH: super....and how do I find out about the lost conenction now?
  // KGame and KGameNetwork, this could be improved!
-//  connect(this,TQT_SIGNAL(signalConnectionLost(KGameClient *)),
-//          this,TQT_SLOT(slotConnectionLost(KGameClient *)));
+//  connect(this,TQ_SIGNAL(signalConnectionLost(KGameClient *)),
+//          this,TQ_SLOT(slotConnectionLost(KGameClient *)));
 }
 
 KGame::~KGame()
@@ -780,7 +780,7 @@ KPlayer * KGame::playerInputFinished(KPlayer *player)
    player->setTurn(false); // in turn based games we have to switch off input now
    if (gameSequence())
    {
-     TQTimer::singleShot(0,this,TQT_SLOT(prepareNext()));
+     TQTimer::singleShot(0,this,TQ_SLOT(prepareNext()));
    }
  }
  return player;
diff --git a/libtdegames/kgame/kgamechat.cpp b/libtdegames/kgame/kgamechat.cpp
index 80059e7b..650cf060 100644
--- a/libtdegames/kgame/kgamechat.cpp
+++ b/libtdegames/kgame/kgamechat.cpp
@@ -227,13 +227,13 @@ void KGameChat::setKGame(KGame* g)
  d->mGame = g;
 
  if (d->mGame) {
-	connect(d->mGame, TQT_SIGNAL(signalPlayerJoinedGame(KPlayer*)), 
-			this, TQT_SLOT(slotAddPlayer(KPlayer*)));
-	connect(d->mGame, TQT_SIGNAL(signalPlayerLeftGame(KPlayer*)), 
-			this, TQT_SLOT(slotRemovePlayer(KPlayer*)));
-	connect(d->mGame, TQT_SIGNAL(signalNetworkData(int, const TQByteArray&, TQ_UINT32, TQ_UINT32)),
-			this, TQT_SLOT(slotReceiveMessage(int, const TQByteArray&, TQ_UINT32, TQ_UINT32)));
-	connect(d->mGame, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotUnsetKGame()));
+	connect(d->mGame, TQ_SIGNAL(signalPlayerJoinedGame(KPlayer*)), 
+			this, TQ_SLOT(slotAddPlayer(KPlayer*)));
+	connect(d->mGame, TQ_SIGNAL(signalPlayerLeftGame(KPlayer*)), 
+			this, TQ_SLOT(slotRemovePlayer(KPlayer*)));
+	connect(d->mGame, TQ_SIGNAL(signalNetworkData(int, const TQByteArray&, TQ_UINT32, TQ_UINT32)),
+			this, TQ_SLOT(slotReceiveMessage(int, const TQByteArray&, TQ_UINT32, TQ_UINT32)));
+	connect(d->mGame, TQ_SIGNAL(destroyed()), this, TQ_SLOT(slotUnsetKGame()));
 
 	TQPtrList<KPlayer> playerList = *d->mGame->playerList();
 	for (int unsigned i = 0; i < playerList.count(); i++) {
@@ -281,10 +281,10 @@ void KGameChat::slotAddPlayer(KPlayer* p)
  int sendingId = nextId();
  addSendingEntry(comboBoxItem(p->name()), sendingId);
  d->mSendId2PlayerId.insert(sendingId, p->id());
- connect(p, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
-		this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
- connect(p, TQT_SIGNAL(signalNetworkData(int, const TQByteArray&, TQ_UINT32, KPlayer*)),
-		this, TQT_SLOT(slotReceivePrivateMessage(int, const TQByteArray&, TQ_UINT32, KPlayer*)));
+ connect(p, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
+		this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
+ connect(p, TQ_SIGNAL(signalNetworkData(int, const TQByteArray&, TQ_UINT32, KPlayer*)),
+		this, TQ_SLOT(slotReceivePrivateMessage(int, const TQByteArray&, TQ_UINT32, KPlayer*)));
 }
 
 void KGameChat::slotRemovePlayer(KPlayer* p)
diff --git a/libtdegames/kgame/kgameio.cpp b/libtdegames/kgame/kgameio.cpp
index 852e04f2..13a19a81 100644
--- a/libtdegames/kgame/kgameio.cpp
+++ b/libtdegames/kgame/kgameio.cpp
@@ -266,12 +266,12 @@ KGameProcessIO::KGameProcessIO(const TQString& name)
   //kdDebug(11001) << "================= KMEssage SetSErver ==================== " << endl;
   //d->mMessageClient->setServer(d->mMessageServer);
   kdDebug(11001) << "================= KMEssage: Connect ==================== " << endl;
-  //connect(d->mMessageClient, TQT_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
-  //        this, TQT_SLOT(clientMessage(const TQByteArray&, TQ_UINT32)));
-  //connect(d->mMessageClient, TQT_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList <TQ_UINT32> &)),
-  //        this, TQT_SLOT(clientMessage(const TQByteArray&, TQ_UINT32, const TQValueList <TQ_UINT32> &)));
-  connect(d->mProcessIO, TQT_SIGNAL(received(const TQByteArray&)),
-          this, TQT_SLOT(receivedMessage(const TQByteArray&)));
+  //connect(d->mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
+  //        this, TQ_SLOT(clientMessage(const TQByteArray&, TQ_UINT32)));
+  //connect(d->mMessageClient, TQ_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList <TQ_UINT32> &)),
+  //        this, TQ_SLOT(clientMessage(const TQByteArray&, TQ_UINT32, const TQValueList <TQ_UINT32> &)));
+  connect(d->mProcessIO, TQ_SIGNAL(received(const TQByteArray&)),
+          this, TQ_SLOT(receivedMessage(const TQByteArray&)));
   //kdDebug(11001) << "Our client is id="<<d->mMessageClient->id() << endl;
 }
 
@@ -489,7 +489,7 @@ void KGameComputerIO::setAdvancePeriod(int ms)
 {
   stopAdvancePeriod();
   d->mAdvanceTimer = new TQTimer(this);
-  connect(d->mAdvanceTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(advance()));
+  connect(d->mAdvanceTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(advance()));
   d->mAdvanceTimer->start(ms);
 }
 
diff --git a/libtdegames/kgame/kgameio.h b/libtdegames/kgame/kgameio.h
index 898b0491..9b7c34b5 100644
--- a/libtdegames/kgame/kgameio.h
+++ b/libtdegames/kgame/kgameio.h
@@ -195,8 +195,8 @@ public:
      * \code
      * KGameKeyIO *input;
      *  input=new KGameKeyIO(myWidget);
-     *  connect(input,TQT_SIGNAL(signalKeyEvent(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)),
-     *          this,TQT_SLOT(slotKeyInput(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)));
+     *  connect(input,TQ_SIGNAL(signalKeyEvent(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)),
+     *          this,TQ_SLOT(slotKeyInput(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)));
      * \endcode
      *
      * @param parent The parents widget whose keyboard events * should be grabbed
@@ -261,8 +261,8 @@ public:
      * \code
      * KGameMouseIO *input;
      * input=new KGameMouseIO(mView);
-     * connect(input,TQT_SIGNAL(signalMouseEvent(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)),
-     *        this,TQT_SLOT(slotMouseInput(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)));
+     * connect(input,TQ_SIGNAL(signalMouseEvent(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)),
+     *        this,TQ_SLOT(slotMouseInput(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)));
      * \endcode
      *
      * @param parent The widget whose events should be captured
@@ -336,10 +336,10 @@ public:
      * \code
      * KGameProcessIO *input;
      *   input=new KGameProcessIO(executable_file);
-     *  connect(input,TQT_SIGNAL(signalPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)),
-     *          this,TQT_SLOT(slotPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)));
-     *  connect(input,TQT_SIGNAL(signalProcessQuery(TQDataStream &,KGameProcessIO *)),
-     *          this,TQT_SLOT(slotProcessQuery(TQDataStream &,KGameProcessIO *)));
+     *  connect(input,TQ_SIGNAL(signalPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)),
+     *          this,TQ_SLOT(slotPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)));
+     *  connect(input,TQ_SIGNAL(signalProcessQuery(TQDataStream &,KGameProcessIO *)),
+     *          this,TQ_SLOT(slotProcessQuery(TQDataStream &,KGameProcessIO *)));
      * \endcode
      *
      * @param name the filename of the process to start
diff --git a/libtdegames/kgame/kgamenetwork.cpp b/libtdegames/kgame/kgamenetwork.cpp
index b51b5ae0..94badd88 100644
--- a/libtdegames/kgame/kgamenetwork.cpp
+++ b/libtdegames/kgame/kgamenetwork.cpp
@@ -120,25 +120,25 @@ void KGameNetwork::setMaster()
  }
  if (!d->mMessageClient) {
    d->mMessageClient = new KMessageClient (this);
-   connect (d->mMessageClient, TQT_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
-            this, TQT_SLOT(receiveNetworkTransmission(const TQByteArray&, TQ_UINT32)));
-   connect (d->mMessageClient, TQT_SIGNAL(connectionBroken()),
-            this, TQT_SIGNAL(signalConnectionBroken()));
-   connect (d->mMessageClient, TQT_SIGNAL(aboutToDisconnect(TQ_UINT32)),
-            this, TQT_SLOT(aboutToLoseConnection(TQ_UINT32)));
-   connect (d->mMessageClient, TQT_SIGNAL(connectionBroken()),
-            this, TQT_SLOT(slotResetConnection()));
-
-   connect (d->mMessageClient, TQT_SIGNAL(adminStatusChanged(bool)),
-            this, TQT_SLOT(slotAdminStatusChanged(bool)));
-   connect (d->mMessageClient, TQT_SIGNAL(eventClientConnected(TQ_UINT32)),
-            this, TQT_SIGNAL(signalClientConnected(TQ_UINT32)));
-   connect (d->mMessageClient, TQT_SIGNAL(eventClientDisconnected(TQ_UINT32, bool)),
-            this, TQT_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)));
+   connect (d->mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
+            this, TQ_SLOT(receiveNetworkTransmission(const TQByteArray&, TQ_UINT32)));
+   connect (d->mMessageClient, TQ_SIGNAL(connectionBroken()),
+            this, TQ_SIGNAL(signalConnectionBroken()));
+   connect (d->mMessageClient, TQ_SIGNAL(aboutToDisconnect(TQ_UINT32)),
+            this, TQ_SLOT(aboutToLoseConnection(TQ_UINT32)));
+   connect (d->mMessageClient, TQ_SIGNAL(connectionBroken()),
+            this, TQ_SLOT(slotResetConnection()));
+
+   connect (d->mMessageClient, TQ_SIGNAL(adminStatusChanged(bool)),
+            this, TQ_SLOT(slotAdminStatusChanged(bool)));
+   connect (d->mMessageClient, TQ_SIGNAL(eventClientConnected(TQ_UINT32)),
+            this, TQ_SIGNAL(signalClientConnected(TQ_UINT32)));
+   connect (d->mMessageClient, TQ_SIGNAL(eventClientDisconnected(TQ_UINT32, bool)),
+            this, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)));
 
    // broacast and direct messages are treated equally on receive.
-   connect (d->mMessageClient, TQT_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList<TQ_UINT32>&)),
-            d->mMessageClient, TQT_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)));
+   connect (d->mMessageClient, TQ_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList<TQ_UINT32>&)),
+            d->mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)));
 
  } else {
    // should be no problem but still has to be tested
diff --git a/libtdegames/kgame/kgameprocess.cpp b/libtdegames/kgame/kgameprocess.cpp
index 8a8a2571..b0858e81 100644
--- a/libtdegames/kgame/kgameprocess.cpp
+++ b/libtdegames/kgame/kgameprocess.cpp
@@ -52,10 +52,10 @@ KGameProcess::KGameProcess() : TQObject(0,0)
   mMessageIO=new KMessageFilePipe(this,&rFile,&wFile);
 //  mMessageClient=new KMessageClient(this);
 //  mMessageClient->setServer(mMessageIO);
-//  connect (mMessageClient, TQT_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
-//          this, TQT_SLOT(receivedMessage(const TQByteArray&, TQ_UINT32)));
-  connect (mMessageIO, TQT_SIGNAL(received(const TQByteArray&)),
-          this, TQT_SLOT(receivedMessage(const TQByteArray&)));
+//  connect (mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
+//          this, TQ_SLOT(receivedMessage(const TQByteArray&, TQ_UINT32)));
+  connect (mMessageIO, TQ_SIGNAL(received(const TQByteArray&)),
+          this, TQ_SLOT(receivedMessage(const TQByteArray&)));
   fprintf(stderr,"KGameProcess::constructor %p %p\n",&rFile,&wFile);
  
   mRandom = new KRandomSequence;
diff --git a/libtdegames/kgame/kgameprocess.h b/libtdegames/kgame/kgameprocess.h
index 7b297019..65b0ab74 100644
--- a/libtdegames/kgame/kgameprocess.h
+++ b/libtdegames/kgame/kgameprocess.h
@@ -61,12 +61,12 @@ class KDE_EXPORT KGameProcess:  public TQObject
      *  int main(int argc ,char * argv[])
      *  {
      *    KGameProcess proc;
-     *    connect(&proc,TQT_SIGNAL(signalCommand(TQDataStream &,int ,int ,int )),
-     *                    this,TQT_SLOT(slotCommand(TQDataStream & ,int ,int ,int )));
-     *    connect(&proc,TQT_SIGNAL(signalInit(TQDataStream &,int)),
-     *                    this,TQT_SLOT(slotInit(TQDataStream & ,int )));
-     *    connect(&proc,TQT_SIGNAL(signalTurn(TQDataStream &,bool )),
-     *                    this,TQT_SLOT(slotTurn(TQDataStream & ,bool )));
+     *    connect(&proc,TQ_SIGNAL(signalCommand(TQDataStream &,int ,int ,int )),
+     *                    this,TQ_SLOT(slotCommand(TQDataStream & ,int ,int ,int )));
+     *    connect(&proc,TQ_SIGNAL(signalInit(TQDataStream &,int)),
+     *                    this,TQ_SLOT(slotInit(TQDataStream & ,int )));
+     *    connect(&proc,TQ_SIGNAL(signalTurn(TQDataStream &,bool )),
+     *                    this,TQ_SLOT(slotTurn(TQDataStream & ,bool )));
      *    return proc.exec(argc,argv);
      *  }
      *  \endcode
diff --git a/libtdegames/kgame/kgamepropertyhandler.cpp b/libtdegames/kgame/kgamepropertyhandler.cpp
index 732c8bde..0cd02fbf 100644
--- a/libtdegames/kgame/kgamepropertyhandler.cpp
+++ b/libtdegames/kgame/kgamepropertyhandler.cpp
@@ -94,12 +94,12 @@ void KGamePropertyHandler::registerHandler(int id,const TQObject * receiver, con
 {
  setId(id); 
  if (receiver && sendf) {
-	kdDebug(11001) << "Connecting TQT_SLOT " << sendf << endl;
-	connect(this, TQT_SIGNAL(signalSendMessage(int, TQDataStream &, bool*)), receiver, sendf);
+	kdDebug(11001) << "Connecting TQ_SLOT " << sendf << endl;
+	connect(this, TQ_SIGNAL(signalSendMessage(int, TQDataStream &, bool*)), receiver, sendf);
  }
  if (receiver && emitf) {
-	kdDebug(11001) << "Connecting TQT_SLOT " << emitf << endl;
-	connect(this, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *)), receiver, emitf);
+	kdDebug(11001) << "Connecting TQ_SLOT " << emitf << endl;
+	connect(this, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *)), receiver, emitf);
  }
 }
 
diff --git a/libtdegames/kgame/kmessageclient.cpp b/libtdegames/kgame/kmessageclient.cpp
index eddd6f9f..01cc7175 100644
--- a/libtdegames/kgame/kmessageclient.cpp
+++ b/libtdegames/kgame/kmessageclient.cpp
@@ -86,10 +86,10 @@ void KMessageClient::setServer (KMessageIO *connection)
   d->connection = connection;
   if (connection )
   {
-    connect (connection, TQT_SIGNAL (received(const TQByteArray &)),
-             this, TQT_SLOT (processIncomingMessage(const TQByteArray &)));
-    connect (connection, TQT_SIGNAL (connectionBroken()),
-             this, TQT_SLOT (removeBrokenConnection ()));
+    connect (connection, TQ_SIGNAL (received(const TQByteArray &)),
+             this, TQ_SLOT (processIncomingMessage(const TQByteArray &)));
+    connect (connection, TQ_SIGNAL (connectionBroken()),
+             this, TQ_SLOT (removeBrokenConnection ()));
   }
 }
 
@@ -322,7 +322,7 @@ void KMessageClient::removeBrokenConnection ()
 {
   kdDebug (11001) << k_funcinfo << ": timer single shot for removeBrokenConnection"<<this << endl;
   // MH We cannot directly delete the socket. otherwise TQSocket crashes
-  TQTimer::singleShot( 0, this, TQT_SLOT(removeBrokenConnection2()) );
+  TQTimer::singleShot( 0, this, TQ_SLOT(removeBrokenConnection2()) );
   return;
 }
 
@@ -361,7 +361,7 @@ void KMessageClient::unlock ()
   d->isLocked = false;
   for (unsigned int i = 0; i < d->delayedMessages.count(); i++)
   {
-    TQTimer::singleShot(0, this, TQT_SLOT(processFirstMessage()));
+    TQTimer::singleShot(0, this, TQ_SLOT(processFirstMessage()));
   }
 }
 
diff --git a/libtdegames/kgame/kmessageclient.h b/libtdegames/kgame/kmessageclient.h
index 42dcc275..456f79cc 100644
--- a/libtdegames/kgame/kmessageclient.h
+++ b/libtdegames/kgame/kmessageclient.h
@@ -295,8 +295,8 @@ signals:
 
     \code
       KMessageClient *client = new KMessageClient ();
-      connect (client, TQT_SIGNAL (forwardReceived (const TQByteArray &, TQ_UINT32, const TQValueList <TQ_UINT32>&)),
-               client, TQT_SIGNAL (broadcastReceived (const TQByteArray &, TQ_UINT32)));
+      connect (client, TQ_SIGNAL (forwardReceived (const TQByteArray &, TQ_UINT32, const TQValueList <TQ_UINT32>&)),
+               client, TQ_SIGNAL (broadcastReceived (const TQByteArray &, TQ_UINT32)));
     \endcode
 
     Then connect the broadcast signal to your slot that analyzes the message.
diff --git a/libtdegames/kgame/kmessageio.cpp b/libtdegames/kgame/kmessageio.cpp
index 6067d9e5..413d1a66 100644
--- a/libtdegames/kgame/kmessageio.cpp
+++ b/libtdegames/kgame/kmessageio.cpp
@@ -157,9 +157,9 @@ void KMessageSocket::processNewData ()
 
 void KMessageSocket::initSocket ()
 {
-  connect (mSocket, TQT_SIGNAL (error(int)), TQT_SIGNAL (connectionBroken()));
-  connect (mSocket, TQT_SIGNAL (connectionClosed()), TQT_SIGNAL (connectionBroken()));
-  connect (mSocket, TQT_SIGNAL (readyRead()), TQT_SLOT (processNewData()));
+  connect (mSocket, TQ_SIGNAL (error(int)), TQ_SIGNAL (connectionBroken()));
+  connect (mSocket, TQ_SIGNAL (connectionClosed()), TQ_SIGNAL (connectionBroken()));
+  connect (mSocket, TQ_SIGNAL (readyRead()), TQ_SLOT (processNewData()));
   mAwaitingHeader = true;
   mNextBlockLength = 0;
   isRecursive = false;
@@ -248,14 +248,14 @@ KMessageProcess::KMessageProcess(TQObject *parent, TQString file) : KMessageIO(p
   *mProcess << mProcessName << TQString("%1").arg(id);
   kdDebug(11001) << "@@@KMessageProcess::Init:Id= " << id << endl;
   kdDebug(11001) << "@@@KMessgeProcess::Init:Processname: " << mProcessName << endl;
-  connect(mProcess, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int )),
-                        this, TQT_SLOT(slotReceivedStdout(TDEProcess *, char * , int )));
-  connect(mProcess, TQT_SIGNAL(receivedStderr(TDEProcess *, char *, int )),
-                        this, TQT_SLOT(slotReceivedStderr(TDEProcess *, char * , int )));
-  connect(mProcess, TQT_SIGNAL(processExited(TDEProcess *)),
-                        this, TQT_SLOT(slotProcessExited(TDEProcess *)));
-  connect(mProcess, TQT_SIGNAL(wroteStdin(TDEProcess *)),
-                        this, TQT_SLOT(slotWroteStdin(TDEProcess *)));
+  connect(mProcess, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int )),
+                        this, TQ_SLOT(slotReceivedStdout(TDEProcess *, char * , int )));
+  connect(mProcess, TQ_SIGNAL(receivedStderr(TDEProcess *, char *, int )),
+                        this, TQ_SLOT(slotReceivedStderr(TDEProcess *, char * , int )));
+  connect(mProcess, TQ_SIGNAL(processExited(TDEProcess *)),
+                        this, TQ_SLOT(slotProcessExited(TDEProcess *)));
+  connect(mProcess, TQ_SIGNAL(wroteStdin(TDEProcess *)),
+                        this, TQ_SLOT(slotWroteStdin(TDEProcess *)));
   mProcess->start(TDEProcess::NotifyOnExit,TDEProcess::All);
   mSendBuffer=0;
   mReceiveCount=0;
diff --git a/libtdegames/kgame/kmessageserver.cpp b/libtdegames/kgame/kmessageserver.cpp
index cd5da802..e8617f57 100644
--- a/libtdegames/kgame/kmessageserver.cpp
+++ b/libtdegames/kgame/kmessageserver.cpp
@@ -92,8 +92,8 @@ KMessageServer::KMessageServer (TQ_UINT16 cookie,TQObject* parent)
   d = new KMessageServerPrivate;
   d->mIsRecursive=false;
   d->mCookie=cookie;
-  connect (&(d->mTimer), TQT_SIGNAL (timeout()),
-           this, TQT_SLOT (processOneMessage()));
+  connect (&(d->mTimer), TQ_SIGNAL (timeout()),
+           this, TQ_SLOT (processOneMessage()));
   kdDebug(11001) << "CREATE(KMessageServer="
 		<< this
 		<< ") cookie="
@@ -138,8 +138,8 @@ bool KMessageServer::initNetwork (TQ_UINT16 port)
 
   kdDebug (11001) << k_funcinfo << ": Now listening to port "
                   << d->mServerSocket->port() << endl;
-  connect (d->mServerSocket, TQT_SIGNAL (newClientConnected (KMessageIO*)),
-           this, TQT_SLOT (addClient (KMessageIO*)));
+  connect (d->mServerSocket, TQ_SIGNAL (newClientConnected (KMessageIO*)),
+           this, TQ_SLOT (addClient (KMessageIO*)));
   return true;
 }
 
@@ -183,10 +183,10 @@ void KMessageServer::addClient (KMessageIO* client)
   kdDebug (11001) << k_funcinfo << ": " << client->id() << endl;
 
   // connect its signals
-  connect (client, TQT_SIGNAL (connectionBroken()),
-           this, TQT_SLOT (removeBrokenClient()));
-  connect (client, TQT_SIGNAL (received (const TQByteArray &)),
-           this, TQT_SLOT (getReceivedMessage (const TQByteArray &)));
+  connect (client, TQ_SIGNAL (connectionBroken()),
+           this, TQ_SLOT (removeBrokenClient()));
+  connect (client, TQ_SIGNAL (received (const TQByteArray &)),
+           this, TQ_SLOT (getReceivedMessage (const TQByteArray &)));
 
   // Tell everyone about the new guest
   // Note: The new client doesn't get this message!
diff --git a/libtdegames/kgame/kplayer.cpp b/libtdegames/kgame/kplayer.cpp
index 5945f9cf..4e815b81 100644
--- a/libtdegames/kgame/kplayer.cpp
+++ b/libtdegames/kgame/kplayer.cpp
@@ -78,8 +78,8 @@ void KPlayer::init()
    d = new KPlayerPrivate;
 
    d->mProperties.registerHandler(KGameMessage::IdPlayerProperty,
-                                  this,TQT_SLOT(sendProperty(int, TQDataStream&, bool*)),
-                                       TQT_SLOT(emitSignal(KGamePropertyBase *)));
+                                  this,TQ_SLOT(sendProperty(int, TQDataStream&, bool*)),
+                                       TQ_SLOT(emitSignal(KGamePropertyBase *)));
    d->mVirtual=false;
    mActive=true;
    mGame=0;