Replace various '#define' strings - part 6

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

56 files changed, 690 insertions, 690 deletions

diff --git a/atlantik/client/atlantik.cpp b/atlantik/client/atlantik.cpp
index fbbe24ec..399bec95 100644
--- a/atlantik/client/atlantik.cpp
+++ b/atlantik/client/atlantik.cpp
@@ -67,12 +67,12 @@
 LogTextEdit::LogTextEdit( TQWidget *parent, const char *name ) : TQTextEdit( parent, name )
 {
 #ifdef KDE_3_2_FEATURES
-	m_clear = KStdAction::clear( TQT_TQOBJECT(this), TQT_SLOT( clear() ), 0 );
+	m_clear = KStdAction::clear( this, TQT_SLOT( clear() ), 0 );
 #else
-	m_clear = new TDEAction( i18n("Clear"), "clear", NULL, TQT_TQOBJECT(this), TQT_SLOT( clear() ), static_cast<TDEActionCollection *>(0), "clear" );
+	m_clear = new TDEAction( i18n("Clear"), "clear", NULL, this, TQT_SLOT( clear() ), static_cast<TDEActionCollection *>(0), "clear" );
 #endif
-	m_selectAll = KStdAction::selectAll( TQT_TQOBJECT(this), TQT_SLOT( selectAll() ), 0 );
-	m_copy = KStdAction::copy( TQT_TQOBJECT(this), TQT_SLOT( copy() ), 0 );
+	m_selectAll = KStdAction::selectAll( this, TQT_SLOT( selectAll() ), 0 );
+	m_copy = KStdAction::copy( this, TQT_SLOT( copy() ), 0 );
 }
 
 LogTextEdit::~LogTextEdit()
@@ -103,12 +103,12 @@ Atlantik::Atlantik ()
 
 	// Toolbar: Game
 //	KStdGameAction::gameNew(this, TQT_SLOT(slotNewGame()), actionCollection(), "game_new");
-        m_showEventLog = new TDEAction(i18n("Show Event &Log")/*, "atlantik_showeventlog"*/, CTRL+Key_L, TQT_TQOBJECT(this), TQT_SLOT(showEventLog()), actionCollection(), "showeventlog");
-	KStdGameAction::quit(TQT_TQOBJECT(kapp), TQT_SLOT(closeAllWindows()), actionCollection(), "game_quit");
+        m_showEventLog = new TDEAction(i18n("Show Event &Log")/*, "atlantik_showeventlog"*/, CTRL+Key_L, this, TQT_SLOT(showEventLog()), actionCollection(), "showeventlog");
+	KStdGameAction::quit(kapp, TQT_SLOT(closeAllWindows()), actionCollection(), "game_quit");
 
 	// Toolbar: Settings
-	KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(slotConfigure()), actionCollection());
-	KStdAction::configureNotifications(TQT_TQOBJECT(this), TQT_SLOT(configureNotifications()), actionCollection());
+	KStdAction::preferences(this, TQT_SLOT(slotConfigure()), actionCollection());
+	KStdAction::configureNotifications(this, TQT_SLOT(configureNotifications()), actionCollection());
 
 	// Initialize pointers to 0L
 	m_configDialog = 0;
@@ -120,29 +120,29 @@ Atlantik::Atlantik ()
 	m_atlantikNetwork = 0;
 
 	// Game and network core
-	m_atlanticCore = new AtlanticCore(TQT_TQOBJECT(this), "atlanticCore");
-	connect(m_atlanticCore, TQT_SIGNAL(createGUI(Player *)), TQT_TQOBJECT(this), TQT_SLOT(newPlayer(Player *)));
-	connect(m_atlanticCore, TQT_SIGNAL(removeGUI(Player *)), TQT_TQOBJECT(this), TQT_SLOT(removeGUI(Player *)));
-	connect(m_atlanticCore, TQT_SIGNAL(createGUI(Trade *)), TQT_TQOBJECT(this), TQT_SLOT(newTrade(Trade *)));
-	connect(m_atlanticCore, TQT_SIGNAL(removeGUI(Trade *)), TQT_TQOBJECT(this), TQT_SLOT(removeGUI(Trade *)));
+	m_atlanticCore = new AtlanticCore(this, "atlanticCore");
+	connect(m_atlanticCore, TQT_SIGNAL(createGUI(Player *)), this, TQT_SLOT(newPlayer(Player *)));
+	connect(m_atlanticCore, TQT_SIGNAL(removeGUI(Player *)), this, TQT_SLOT(removeGUI(Player *)));
+	connect(m_atlanticCore, TQT_SIGNAL(createGUI(Trade *)), this, TQT_SLOT(newTrade(Trade *)));
+	connect(m_atlanticCore, TQT_SIGNAL(removeGUI(Trade *)), this, TQT_SLOT(removeGUI(Trade *)));
 
 	initEventLog();
 	initNetworkObject();
 
 	// Menu,toolbar: Move
-	m_roll = KStdGameAction::roll(TQT_TQOBJECT(this), TQT_SIGNAL(rollDice()), actionCollection());
+	m_roll = KStdGameAction::roll(this, TQT_SIGNAL(rollDice()), actionCollection());
 	m_roll->setEnabled(false);
-	m_buyEstate = new TDEAction(i18n("&Buy"), "atlantik_buy_estate", CTRL+Key_B, TQT_TQOBJECT(this), TQT_SIGNAL(buyEstate()), actionCollection(), "buy_estate");
+	m_buyEstate = new TDEAction(i18n("&Buy"), "atlantik_buy_estate", CTRL+Key_B, this, TQT_SIGNAL(buyEstate()), actionCollection(), "buy_estate");
 	m_buyEstate->setEnabled(false);
-	m_auctionEstate = new TDEAction(i18n("&Auction"), "auction", CTRL+Key_A, TQT_TQOBJECT(this), TQT_SIGNAL(auctionEstate()), actionCollection(), "auction");
+	m_auctionEstate = new TDEAction(i18n("&Auction"), "auction", CTRL+Key_A, this, TQT_SIGNAL(auctionEstate()), actionCollection(), "auction");
 	m_auctionEstate->setEnabled(false);
-	m_endTurn = KStdGameAction::endTurn(TQT_TQOBJECT(this), TQT_SIGNAL(endTurn()), actionCollection());
+	m_endTurn = KStdGameAction::endTurn(this, TQT_SIGNAL(endTurn()), actionCollection());
 	m_endTurn->setEnabled(false);
-        m_jailCard = new TDEAction(i18n("Use Card to Leave Jail")/*, "atlantik_move_jail_card"*/, 0, TQT_TQOBJECT(this), TQT_SIGNAL(jailCard()), actionCollection(), "move_jailcard");
+        m_jailCard = new TDEAction(i18n("Use Card to Leave Jail")/*, "atlantik_move_jail_card"*/, 0, this, TQT_SIGNAL(jailCard()), actionCollection(), "move_jailcard");
 	m_jailCard->setEnabled(false);
-	m_jailPay = new TDEAction(i18n("&Pay to Leave Jail"), "jail_pay", CTRL+Key_P, TQT_TQOBJECT(this), TQT_SIGNAL(jailPay()), actionCollection(), "move_jailpay");
+	m_jailPay = new TDEAction(i18n("&Pay to Leave Jail"), "jail_pay", CTRL+Key_P, this, TQT_SIGNAL(jailPay()), actionCollection(), "move_jailpay");
 	m_jailPay->setEnabled(false);
-        m_jailRoll = new TDEAction(i18n("Roll to Leave &Jail")/*, "atlantik_move_jail_roll"*/, CTRL+Key_J, TQT_TQOBJECT(this), TQT_SIGNAL(jailRoll()), actionCollection(), "move_jailroll");
+        m_jailRoll = new TDEAction(i18n("Roll to Leave &Jail")/*, "atlantik_move_jail_roll"*/, CTRL+Key_J, this, TQT_SIGNAL(jailRoll()), actionCollection(), "move_jailroll");
 	m_jailRoll->setEnabled(false);
 
 	// Mix code and XML into GUI
@@ -150,7 +150,7 @@ Atlantik::Atlantik ()
 	applyMainWindowSettings( TDEGlobal::config(), "AtlantikMainWindow" );
 	TDEMainWindow::statusBar()->insertItem("Atlantik " ATLANTIK_VERSION_STRING, 0);
 	TDEMainWindow::statusBar()->insertItem(TQString(), 1);
-	connect(statusBar(), TQT_SIGNAL(released(int)), TQT_TQOBJECT(this), TQT_SLOT(statusBarClick(int)));
+	connect(statusBar(), TQT_SIGNAL(released(int)), this, TQT_SLOT(statusBarClick(int)));
 
 	// Main widget, containing all others
  	m_mainWidget = new TQWidget(this, "main");
@@ -192,7 +192,7 @@ Atlantik::Atlantik ()
 
 	m_serverMsgs->setFocusProxy(m_input);
 
-	connect(m_input, TQT_SIGNAL(returnPressed()), TQT_TQOBJECT(this), TQT_SLOT(slotSendMsg()));
+	connect(m_input, TQT_SIGNAL(returnPressed()), this, TQT_SLOT(slotSendMsg()));
 
 	// Set stretching where we want it.
 	m_mainLayout->setRowStretch(1, 1); // make m_board+m_serverMsgs stretch vertically, not the rest
@@ -253,8 +253,8 @@ void Atlantik::newPlayer(Player *player)
 	// we'd better force an update.
 	playerChanged(player);
 
-	connect(player, TQT_SIGNAL(changed(Player *)), TQT_TQOBJECT(this), TQT_SLOT(playerChanged(Player *)));
-	connect(player, TQT_SIGNAL(gainedTurn()), TQT_TQOBJECT(this), TQT_SLOT(gainedTurn()));
+	connect(player, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged(Player *)));
+	connect(player, TQT_SIGNAL(gainedTurn()), this, TQT_SLOT(gainedTurn()));
 	connect(player, TQT_SIGNAL(changed(Player *)), m_board, TQT_SLOT(playerChanged(Player *)));
 
 	KNotifyClient::event(winId(), "newplayer");
@@ -315,7 +315,7 @@ void Atlantik::showSelectServer()
 	initNetworkObject();
 
 	connect(m_selectServer, TQT_SIGNAL(serverConnect(const TQString, int)), m_atlantikNetwork, TQT_SLOT(serverConnect(const TQString, int)));
-	connect(m_selectServer, TQT_SIGNAL(msgStatus(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotMsgStatus(const TQString &)));
+	connect(m_selectServer, TQT_SIGNAL(msgStatus(const TQString &)), this, TQT_SLOT(slotMsgStatus(const TQString &)));
 
 	m_selectServer->slotRefresh( m_config.connectOnStart );
 }
@@ -356,8 +356,8 @@ void Atlantik::showSelectGame()
 
 	connect(m_selectGame, TQT_SIGNAL(joinGame(int)), m_atlantikNetwork, TQT_SLOT(joinGame(int)));
 	connect(m_selectGame, TQT_SIGNAL(newGame(const TQString &)), m_atlantikNetwork, TQT_SLOT(newGame(const TQString &)));
-	connect(m_selectGame, TQT_SIGNAL(leaveServer()), TQT_TQOBJECT(this), TQT_SLOT(showSelectServer()));
-	connect(m_selectGame, TQT_SIGNAL(msgStatus(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotMsgStatus(const TQString &)));
+	connect(m_selectGame, TQT_SIGNAL(leaveServer()), this, TQT_SLOT(showSelectServer()));
+	connect(m_selectGame, TQT_SIGNAL(msgStatus(const TQString &)), this, TQT_SLOT(slotMsgStatus(const TQString &)));
 }
 
 void Atlantik::showSelectConfiguration()
@@ -383,7 +383,7 @@ void Atlantik::showSelectConfiguration()
 	connect(m_selectConfiguration, TQT_SIGNAL(changeOption(int, const TQString &)), m_atlantikNetwork, TQT_SLOT(changeOption(int, const TQString &)));
 	connect(m_selectConfiguration, TQT_SIGNAL(buttonCommand(TQString)), m_atlantikNetwork, TQT_SLOT(writeData(TQString)));
 	connect(m_selectConfiguration, TQT_SIGNAL(iconSelected(const TQString &)), m_atlantikNetwork, TQT_SLOT(setImage(const TQString &)));
-	connect(m_selectConfiguration, TQT_SIGNAL(statusMessage(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotMsgStatus(const TQString &)));
+	connect(m_selectConfiguration, TQT_SIGNAL(statusMessage(const TQString &)), this, TQT_SLOT(slotMsgStatus(const TQString &)));
 }
 
 void Atlantik::initBoard()
@@ -491,7 +491,7 @@ void Atlantik::slotConfigure()
 		m_configDialog = new ConfigDialog(this);
 	m_configDialog->show();
 
-	connect(m_configDialog, TQT_SIGNAL(okClicked()), TQT_TQOBJECT(this), TQT_SLOT(slotUpdateConfig()));
+	connect(m_configDialog, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotUpdateConfig()));
 }
 
 void Atlantik::showEventLog()
@@ -728,26 +728,26 @@ void Atlantik::initNetworkObject()
 	}
 
 	m_atlantikNetwork = new AtlantikNetwork(m_atlanticCore);
-	connect(m_atlantikNetwork, TQT_SIGNAL(msgInfo(TQString)), TQT_TQOBJECT(this), TQT_SLOT(slotMsgInfo(TQString)));
-	connect(m_atlantikNetwork, TQT_SIGNAL(msgError(TQString)), TQT_TQOBJECT(this), TQT_SLOT(slotMsgError(TQString)));
-	connect(m_atlantikNetwork, TQT_SIGNAL(msgStatus(const TQString &, const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotMsgStatus(const TQString &, const TQString &)));
-	connect(m_atlantikNetwork, TQT_SIGNAL(msgChat(TQString, TQString)), TQT_TQOBJECT(this), TQT_SLOT(slotMsgChat(TQString, TQString)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(msgInfo(TQString)), this, TQT_SLOT(slotMsgInfo(TQString)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(msgError(TQString)), this, TQT_SLOT(slotMsgError(TQString)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(msgStatus(const TQString &, const TQString &)), this, TQT_SLOT(slotMsgStatus(const TQString &, const TQString &)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(msgChat(TQString, TQString)), this, TQT_SLOT(slotMsgChat(TQString, TQString)));
 
-	connect(m_atlantikNetwork, TQT_SIGNAL(connectionSuccess()), TQT_TQOBJECT(this), TQT_SLOT(slotNetworkConnected()));
-	connect(m_atlantikNetwork, TQT_SIGNAL(connectionFailed(int)), TQT_TQOBJECT(this), TQT_SLOT(slotNetworkError(int)));
-	connect(m_atlantikNetwork, TQT_SIGNAL(closed(int)), TQT_TQOBJECT(this), TQT_SLOT(networkClosed(int)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(connectionSuccess()), this, TQT_SLOT(slotNetworkConnected()));
+	connect(m_atlantikNetwork, TQT_SIGNAL(connectionFailed(int)), this, TQT_SLOT(slotNetworkError(int)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(closed(int)), this, TQT_SLOT(networkClosed(int)));
 
-	connect(m_atlantikNetwork, TQT_SIGNAL(receivedHandshake()), TQT_TQOBJECT(this), TQT_SLOT(sendHandshake()));
+	connect(m_atlantikNetwork, TQT_SIGNAL(receivedHandshake()), this, TQT_SLOT(sendHandshake()));
 
-	connect(m_atlantikNetwork, TQT_SIGNAL(gameConfig()), TQT_TQOBJECT(this), TQT_SLOT(showSelectConfiguration()));
-	connect(m_atlantikNetwork, TQT_SIGNAL(gameInit()), TQT_TQOBJECT(this), TQT_SLOT(initBoard()));
-	connect(m_atlantikNetwork, TQT_SIGNAL(gameRun()), TQT_TQOBJECT(this), TQT_SLOT(showBoard()));
-	connect(m_atlantikNetwork, TQT_SIGNAL(gameEnd()), TQT_TQOBJECT(this), TQT_SLOT(freezeBoard()));
+	connect(m_atlantikNetwork, TQT_SIGNAL(gameConfig()), this, TQT_SLOT(showSelectConfiguration()));
+	connect(m_atlantikNetwork, TQT_SIGNAL(gameInit()), this, TQT_SLOT(initBoard()));
+	connect(m_atlantikNetwork, TQT_SIGNAL(gameRun()), this, TQT_SLOT(showBoard()));
+	connect(m_atlantikNetwork, TQT_SIGNAL(gameEnd()), this, TQT_SLOT(freezeBoard()));
 
-	connect(m_atlantikNetwork, TQT_SIGNAL(newEstate(Estate *)), TQT_TQOBJECT(this), TQT_SLOT(newEstate(Estate *)));
-	connect(m_atlantikNetwork, TQT_SIGNAL(newAuction(Auction *)), TQT_TQOBJECT(this), TQT_SLOT(newAuction(Auction *)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(newEstate(Estate *)), this, TQT_SLOT(newEstate(Estate *)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(newAuction(Auction *)), this, TQT_SLOT(newAuction(Auction *)));
 
-	connect(m_atlantikNetwork, TQT_SIGNAL(clientCookie(TQString)), TQT_TQOBJECT(this), TQT_SLOT(clientCookie(TQString)));
+	connect(m_atlantikNetwork, TQT_SIGNAL(clientCookie(TQString)), this, TQT_SLOT(clientCookie(TQString)));
 	connect(m_atlantikNetwork, TQT_SIGNAL(networkEvent(const TQString &, const TQString &)), m_eventLog, TQT_SLOT(addEvent(const TQString &, const TQString &)));
 
 	connect(this, TQT_SIGNAL(rollDice()), m_atlantikNetwork, TQT_SLOT(rollDice()));
diff --git a/kasteroids/toplevel.cpp b/kasteroids/toplevel.cpp
index 2bb96a92..410ca468 100644
--- a/kasteroids/toplevel.cpp
+++ b/kasteroids/toplevel.cpp
@@ -280,14 +280,14 @@ KAstTopLevel::~KAstTopLevel()
 void KAstTopLevel::initTDEAction()
 {
 // game
-    KStdGameAction::gameNew( TQT_TQOBJECT(this), TQT_SLOT( slotNewGame() ), actionCollection() );
-    KStdGameAction::highscores( TQT_TQOBJECT(this), TQT_SLOT( slotShowHighscores() ), actionCollection() );
-    KStdGameAction::pause( TQT_TQOBJECT(this), TQT_SLOT( slotPause() ), actionCollection() );
-    KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT( close() ), actionCollection());
+    KStdGameAction::gameNew( this, TQT_SLOT( slotNewGame() ), actionCollection() );
+    KStdGameAction::highscores( this, TQT_SLOT( slotShowHighscores() ), actionCollection() );
+    KStdGameAction::pause( this, TQT_SLOT( slotPause() ), actionCollection() );
+    KStdGameAction::quit(this, TQT_SLOT( close() ), actionCollection());
 
 // settings
-    KStdAction::keyBindings(TQT_TQOBJECT(this), TQT_SLOT( slotKeyConfig() ), actionCollection());
-    KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT( slotPref() ), actionCollection());
+    KStdAction::keyBindings(this, TQT_SLOT( slotKeyConfig() ), actionCollection());
+    KStdAction::preferences(this, TQT_SLOT( slotPref() ), actionCollection());
 
 // keyboard-only actions
     keycodes.insert(Thrust, new TDEAction(i18n("Thrust"), TQt::Key_Up, 0, 0, actionCollection(), "Thrust"));
@@ -297,7 +297,7 @@ void KAstTopLevel::initTDEAction()
 //     keycodes.insert(Teleport, new TDEAction(i18n("Teleport"), TQt::Key_Z, 0, 0, actionCollection(), "Teleport"));
     keycodes.insert(Brake, new TDEAction(i18n("Brake"), TQt::Key_X, 0, 0, actionCollection(), "Brake"));
     keycodes.insert(Shield, new TDEAction(i18n("Shield"), TQt::Key_S, 0, 0, actionCollection(), "Shield"));
-    launchAction = new TDEAction(i18n("Launch"), TQt::Key_L, TQT_TQOBJECT(this), TQT_SLOT(slotLaunch()), actionCollection(), "Launch");
+    launchAction = new TDEAction(i18n("Launch"), TQt::Key_L, this, TQT_SLOT(slotLaunch()), actionCollection(), "Launch");
 }
 
 
@@ -529,7 +529,7 @@ void KAstTopLevel::slotShipKilled()
         }
         else
         {
-           TQTimer::singleShot(1000, TQT_TQOBJECT(this), TQT_SLOT(slotGameOver()));
+           TQTimer::singleShot(1000, this, TQT_SLOT(slotGameOver()));
         }
     }
 }
@@ -613,7 +613,7 @@ void KAstTopLevel::slotPref()
   /* Done */
 
   dialog->addPage(w, i18n("General"), "package_settings");
-  connect(dialog, TQT_SIGNAL(settingsChanged()), TQT_TQOBJECT(this), TQT_SLOT(loadSettings()));
+  connect(dialog, TQT_SIGNAL(settingsChanged()), this, TQT_SLOT(loadSettings()));
   dialog->show();
 }
 
diff --git a/katomic/feld.cpp b/katomic/feld.cpp
index 6e422d04..17b8472e 100644
--- a/katomic/feld.cpp
+++ b/katomic/feld.cpp
@@ -70,7 +70,7 @@ void Feld::resetValidDirs()
 void Feld::load (const KSimpleConfig& config)
 {
   if(moving)
-    TQT_TQOBJECT(this)->killTimers();
+    this->killTimers();
 
   mol->load(config);
 
@@ -492,7 +492,7 @@ void Feld::timerEvent (TQTimerEvent *)
   if (frames <= 0)
 	{
 	  moving = false;
-	  TQT_TQOBJECT(this)->killTimers ();
+	  this->killTimers ();
 	  done();
 	  dir = None;
 	}
diff --git a/katomic/toplevel.cpp b/katomic/toplevel.cpp
index 5603f505..02fa6dcd 100644
--- a/katomic/toplevel.cpp
+++ b/katomic/toplevel.cpp
@@ -40,27 +40,27 @@ extern Options settings;
 
 void AtomTopLevel::createMenu()
 {
-    TDEAction *act = KStdGameAction::highscores(TQT_TQOBJECT(main), TQT_SLOT(showHighscores()), actionCollection());
+    TDEAction *act = KStdGameAction::highscores(main, TQT_SLOT(showHighscores()), actionCollection());
     act->setText(i18n("Show &Highscores"));
-    KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
-    KStdGameAction::restart(TQT_TQOBJECT(main), TQT_SLOT(restartLevel()), actionCollection());
+    KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
+    KStdGameAction::restart(main, TQT_SLOT(restartLevel()), actionCollection());
 
-    KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(configopts()), actionCollection());
+    KStdAction::preferences(this, TQT_SLOT(configopts()), actionCollection());
 
-    undoAction = KStdGameAction::undo (TQT_TQOBJECT(main), TQT_SLOT(doUndo()), actionCollection());
-    redoAction = KStdGameAction::redo (TQT_TQOBJECT(main), TQT_SLOT(doRedo()), actionCollection());
+    undoAction = KStdGameAction::undo (main, TQT_SLOT(doUndo()), actionCollection());
+    redoAction = KStdGameAction::redo (main, TQT_SLOT(doRedo()), actionCollection());
     undoAction->setEnabled(false);
     redoAction->setEnabled(false);
     connect (main, TQT_SIGNAL (enableRedo(bool)), TQT_SLOT(enableRedo(bool)));
     connect (main, TQT_SIGNAL (enableUndo(bool)), TQT_SLOT(enableUndo(bool)));
 
-    new TDEAction(i18n("Atom Up"), Key_Up, TQT_TQOBJECT(main), TQT_SLOT(moveUp()), actionCollection(), "atom_up");
-    new TDEAction(i18n("Atom Down"), Key_Down, TQT_TQOBJECT(main), TQT_SLOT(moveDown()), actionCollection(), "atom_down");
-    new TDEAction(i18n("Atom Left"), Key_Left, TQT_TQOBJECT(main), TQT_SLOT(moveLeft()), actionCollection(), "atom_left");
-    new TDEAction(i18n("Atom Right"), Key_Right, TQT_TQOBJECT(main), TQT_SLOT(moveRight()), actionCollection(), "atom_right");
+    new TDEAction(i18n("Atom Up"), Key_Up, main, TQT_SLOT(moveUp()), actionCollection(), "atom_up");
+    new TDEAction(i18n("Atom Down"), Key_Down, main, TQT_SLOT(moveDown()), actionCollection(), "atom_down");
+    new TDEAction(i18n("Atom Left"), Key_Left, main, TQT_SLOT(moveLeft()), actionCollection(), "atom_left");
+    new TDEAction(i18n("Atom Right"), Key_Right, main, TQT_SLOT(moveRight()), actionCollection(), "atom_right");
 
-    new TDEAction(i18n("Next Atom"), Key_Tab, TQT_TQOBJECT(main), TQT_SLOT(nextAtom()), actionCollection(), "next_atom");
-    new TDEAction(i18n("Previous Atom"), SHIFT+Key_Tab, TQT_TQOBJECT(main), TQT_SLOT(previousAtom()), actionCollection(), "prev_atom");
+    new TDEAction(i18n("Next Atom"), Key_Tab, main, TQT_SLOT(nextAtom()), actionCollection(), "next_atom");
+    new TDEAction(i18n("Previous Atom"), SHIFT+Key_Tab, main, TQT_SLOT(previousAtom()), actionCollection(), "prev_atom");
 }
 
 void AtomTopLevel::configopts()
diff --git a/kbackgammon/engines/fibs/kbgfibs.cpp b/kbackgammon/engines/fibs/kbgfibs.cpp
index 4f30a87c..8561b9c2 100644
--- a/kbackgammon/engines/fibs/kbgfibs.cpp
+++ b/kbackgammon/engines/fibs/kbgfibs.cpp
@@ -2094,7 +2094,7 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
 	/*
 	 * No connection, not playing, ready for login
 	 */
-	connection = new TQSocket(TQT_TQOBJECT(parent), "fibs connection");
+	connection = new TQSocket(parent, "fibs connection");
 	playing = false;
 	login = true;
 
diff --git a/kbackgammon/engines/fibs/kbgfibschat.cpp b/kbackgammon/engines/fibs/kbgfibschat.cpp
index 19a4a7a2..95f8577c 100644
--- a/kbackgammon/engines/fibs/kbgfibschat.cpp
+++ b/kbackgammon/engines/fibs/kbgfibschat.cpp
@@ -231,31 +231,31 @@ 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, TQT_TQOBJECT(this), TQT_SLOT(slotInquire()), actions);
+                                                   0, this, TQT_SLOT(slotInquire()), actions);
     d->mAct[KBgChatPrivate::Talk]    = new TDEAction(i18n("Talk To"),
                                                    TQIconSet(kapp->iconLoader()->loadIcon(
                                                                 PROG_NAME "-chat.png", TDEIcon::Small)),
-                                                   0, TQT_TQOBJECT(this), TQT_SLOT(slotTalk()), actions);
+                                                   0, this, TQT_SLOT(slotTalk()), actions);
 
-    d->mAct[KBgChatPrivate::InviteD]  = new TDEAction(i18n("Use Dialog"),    0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::InviteD]  = new TDEAction(i18n("Use Dialog"),    0, this,
                                                     TQT_SLOT(slotInviteD()),  actions);
-    d->mAct[KBgChatPrivate::Invite1]  = new TDEAction(i18n("1 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::Invite1]  = new TDEAction(i18n("1 Point Match"), 0, this,
                                                     TQT_SLOT(slotInvite1()),  actions);
-    d->mAct[KBgChatPrivate::Invite2]  = new TDEAction(i18n("2 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::Invite2]  = new TDEAction(i18n("2 Point Match"), 0, this,
                                                     TQT_SLOT(slotInvite2()),  actions);
-    d->mAct[KBgChatPrivate::Invite3]  = new TDEAction(i18n("3 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::Invite3]  = new TDEAction(i18n("3 Point Match"), 0, this,
                                                     TQT_SLOT(slotInvite3()),  actions);
-    d->mAct[KBgChatPrivate::Invite4]  = new TDEAction(i18n("4 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::Invite4]  = new TDEAction(i18n("4 Point Match"), 0, this,
                                                     TQT_SLOT(slotInvite4()),  actions);
-    d->mAct[KBgChatPrivate::Invite5]  = new TDEAction(i18n("5 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::Invite5]  = new TDEAction(i18n("5 Point Match"), 0, this,
                                                     TQT_SLOT(slotInvite5()),  actions);
-    d->mAct[KBgChatPrivate::Invite6]  = new TDEAction(i18n("6 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::Invite6]  = new TDEAction(i18n("6 Point Match"), 0, this,
                                                     TQT_SLOT(slotInvite6()),  actions);
-    d->mAct[KBgChatPrivate::Invite7]  = new TDEAction(i18n("7 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::Invite7]  = new TDEAction(i18n("7 Point Match"), 0, this,
                                                     TQT_SLOT(slotInvite7()),  actions);
-    d->mAct[KBgChatPrivate::InviteU]  = new TDEAction(i18n("Unlimited"),     0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::InviteU]  = new TDEAction(i18n("Unlimited"),     0, this,
                                                     TQT_SLOT(slotInviteU()),  actions);
-    d->mAct[KBgChatPrivate::InviteR]  = new TDEAction(i18n("Resume"),        0, TQT_TQOBJECT(this),
+    d->mAct[KBgChatPrivate::InviteR]  = new TDEAction(i18n("Resume"),        0, this,
                                                     TQT_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, TQT_TQOBJECT(this), TQT_SLOT(slotGag()),     actions);
-    d->mAct[KBgChatPrivate::Ungag]    = new TDEAction(i18n("Ungag"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotUngag()),   actions);
-    d->mAct[KBgChatPrivate::Cleargag] = new TDEAction(i18n("Clear Gag List"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotCleargag()), actions);
-    d->mAct[KBgChatPrivate::Copy]     = KStdAction::copy(TQT_TQOBJECT(this), TQT_SLOT(slotCopy()), actions);
-    d->mAct[KBgChatPrivate::Clear]    = new TDEAction(i18n("Clear"),        0, TQT_TQOBJECT(this), TQT_SLOT(slotClear()), actions);
-    d->mAct[KBgChatPrivate::Close]    = KStdAction::close(TQT_TQOBJECT(this), TQT_SLOT(hide()), actions);
-    d->mAct[KBgChatPrivate::Silent]   = new TDEToggleAction(i18n("Silent"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotSilent()), actions);
+    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);
 }
 
 
diff --git a/kbackgammon/engines/fibs/kplayerlist.cpp b/kbackgammon/engines/fibs/kplayerlist.cpp
index deffaa91..ab076c61 100644
--- a/kbackgammon/engines/fibs/kplayerlist.cpp
+++ b/kbackgammon/engines/fibs/kplayerlist.cpp
@@ -288,41 +288,41 @@ KFibsPlayerList::KFibsPlayerList(TQWidget *parent, const char *name)
     d->mAct[KFibsPlayerListPrivate::Info] = new TDEAction(i18n("Info"),
                                                         TQIconSet(kapp->iconLoader()->loadIcon
                                                                  ("help.xpm", TDEIcon::Small)),
-                                                        0, TQT_TQOBJECT(this), TQT_SLOT(slotInfo()),   actions);
+                                                        0, this, TQT_SLOT(slotInfo()),   actions);
     d->mAct[KFibsPlayerListPrivate::Talk] = new TDEAction(i18n("Talk"),
                                                         TQIconSet(kapp->iconLoader()->loadIcon
                                                                  (PROG_NAME "-chat.png", TDEIcon::Small)),
-                                                        0, TQT_TQOBJECT(this), TQT_SLOT(slotTalk()),   actions);
+                                                        0, this, TQT_SLOT(slotTalk()),   actions);
 
-    d->mAct[KFibsPlayerListPrivate::Look]     = new TDEAction(i18n("Look"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotLook()),   actions);
-    d->mAct[KFibsPlayerListPrivate::Watch]    = new TDEAction(i18n("Watch"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotWatch()),  actions);
-    d->mAct[KFibsPlayerListPrivate::Unwatch]  = new TDEAction(i18n("Unwatch"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotUnwatch()),actions);
-    d->mAct[KFibsPlayerListPrivate::BlindAct] = new TDEAction(i18n("Blind"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotBlind()),  actions);
-    d->mAct[KFibsPlayerListPrivate::Update]   = new TDEAction(i18n("Update"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotUpdate()), 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::Reload] = KStdAction::redisplay(TQT_TQOBJECT(this), TQT_SLOT(slotReload()), actions);
-    d->mAct[KFibsPlayerListPrivate::Mail]   = KStdAction::mail(TQT_TQOBJECT(this), TQT_SLOT(slotMail()),   actions);
-    d->mAct[KFibsPlayerListPrivate::Close]  = KStdAction::close(TQT_TQOBJECT(this), TQT_SLOT(hide()), 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::InviteD]  = new TDEAction(i18n("Use Dialog"),    0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::InviteD]  = new TDEAction(i18n("Use Dialog"),    0, this,
                                                             TQT_SLOT(slotInviteD()), actions);
-    d->mAct[KFibsPlayerListPrivate::Invite1]  = new TDEAction(i18n("1 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::Invite1]  = new TDEAction(i18n("1 Point Match"), 0, this,
                                                             TQT_SLOT(slotInvite1()), actions);
-    d->mAct[KFibsPlayerListPrivate::Invite2]  = new TDEAction(i18n("2 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::Invite2]  = new TDEAction(i18n("2 Point Match"), 0, this,
                                                             TQT_SLOT(slotInvite2()), actions);
-    d->mAct[KFibsPlayerListPrivate::Invite3]  = new TDEAction(i18n("3 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::Invite3]  = new TDEAction(i18n("3 Point Match"), 0, this,
                                                             TQT_SLOT(slotInvite3()), actions);
-    d->mAct[KFibsPlayerListPrivate::Invite4]  = new TDEAction(i18n("4 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::Invite4]  = new TDEAction(i18n("4 Point Match"), 0, this,
                                                             TQT_SLOT(slotInvite4()), actions);
-    d->mAct[KFibsPlayerListPrivate::Invite5]  = new TDEAction(i18n("5 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::Invite5]  = new TDEAction(i18n("5 Point Match"), 0, this,
                                                             TQT_SLOT(slotInvite5()), actions);
-    d->mAct[KFibsPlayerListPrivate::Invite6]  = new TDEAction(i18n("6 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::Invite6]  = new TDEAction(i18n("6 Point Match"), 0, this,
                                                             TQT_SLOT(slotInvite6()), actions);
-    d->mAct[KFibsPlayerListPrivate::Invite7]  = new TDEAction(i18n("7 Point Match"), 0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::Invite7]  = new TDEAction(i18n("7 Point Match"), 0, this,
                                                             TQT_SLOT(slotInvite7()), actions);
-    d->mAct[KFibsPlayerListPrivate::InviteU]  = new TDEAction(i18n("Unlimited"),     0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::InviteU]  = new TDEAction(i18n("Unlimited"),     0, this,
                                                             TQT_SLOT(slotInviteU()), actions);
-    d->mAct[KFibsPlayerListPrivate::InviteR]  = new TDEAction(i18n("Resume"),        0, TQT_TQOBJECT(this),
+    d->mAct[KFibsPlayerListPrivate::InviteR]  = new TDEAction(i18n("Resume"),        0, this,
                                                             TQT_SLOT(slotInviteR()), actions);
 
     /*
@@ -482,7 +482,7 @@ void KFibsPlayerList::getSetupPages(KTabCtl *nb, int space)
      */
     nb->addTab(w, i18n("&Playerlist"));
 
-    connect(nb, TQT_SIGNAL(applyButtonPressed()), TQT_TQOBJECT(this), TQT_SLOT(setupOk()));
+    connect(nb, TQT_SIGNAL(applyButtonPressed()), this, TQT_SLOT(setupOk()));
 }
 
 /*
diff --git a/kbackgammon/kbg.cpp b/kbackgammon/kbg.cpp
index dcb82e72..0b51b056 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(TQT_TQOBJECT(this), TQT_SLOT(openNew()), actionCollection());
+	newAction = KStdGameAction::gameNew(this, TQT_SLOT(openNew()), actionCollection());
     newAction->setEnabled(false);
-	KStdGameAction::print(TQT_TQOBJECT(this), TQT_SLOT(print()), actionCollection());
-	KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()),  actionCollection());
+	KStdGameAction::print(this, TQT_SLOT(print()), actionCollection());
+	KStdGameAction::quit(this, TQT_SLOT(close()),  actionCollection());
 
 	TQStringList list;
 	for (int i = 0; i < MaxEngine; i++)
 		list.append(engineString[i]);
-	engineSet = new TDESelectAction(i18n("&Engine"), 0, TQT_TQOBJECT(this), TQT_SLOT(setupEngine()), actionCollection(),
+	engineSet = new TDESelectAction(i18n("&Engine"), 0, this, TQT_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(TQT_TQOBJECT(this), TQT_SLOT(load()), actionCollection(), "move_load");
+	loadAction = KStdAction::redisplay(this, TQT_SLOT(load()), actionCollection(), "move_load");
     loadAction->setEnabled(false);
-	undoAction = KStdGameAction::undo(TQT_TQOBJECT(this), TQT_SLOT(undo()), actionCollection());
+	undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
     undoAction->setEnabled(false);
-	redoAction = KStdGameAction::redo(TQT_TQOBJECT(this), TQT_SLOT(redo()), actionCollection());
+	redoAction = KStdGameAction::redo(this, TQT_SLOT(redo()), actionCollection());
     redoAction->setEnabled(false);
 
-	rollAction = KStdGameAction::roll(TQT_TQOBJECT(this), TQT_SLOT(roll()), actionCollection());
+	rollAction = KStdGameAction::roll(this, TQT_SLOT(roll()), actionCollection());
     rollAction->setEnabled(false);
-	endAction = KStdGameAction::endTurn(TQT_TQOBJECT(this), TQT_SLOT(done()), actionCollection());
+	endAction = KStdGameAction::endTurn(this, TQT_SLOT(done()), actionCollection());
     endAction->setEnabled(false);
     cubeAction = new TDEAction(i18n("Double Cube"), TQIconSet(kapp->iconLoader()->loadIcon
                                                           (PROG_NAME "-double.xpm", TDEIcon::Toolbar)),
-                              0, TQT_TQOBJECT(this), TQT_SLOT(cube()), actionCollection(), "move_cube");
+                              0, this, TQT_SLOT(cube()), actionCollection(), "move_cube");
     cubeAction->setEnabled(false);
 
-	KStdAction::showMenubar(TQT_TQOBJECT(this), TQT_SLOT(toggleMenubar()),     actionCollection());
-	KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(setupDlg()), actionCollection());
-	KStdAction::saveOptions(TQT_TQOBJECT(this), TQT_SLOT(saveConfig()), actionCollection());
+	KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()),     actionCollection());
+	KStdAction::preferences(this, TQT_SLOT(setupDlg()), actionCollection());
+	KStdAction::saveOptions(this, TQT_SLOT(saveConfig()), actionCollection());
 
 	TDEPopupMenu *p = (new TDEActionMenu(i18n("&Backgammon on the Web"),
 					 actionCollection(), "help_www"))->popupMenu();
 
-	(new TDEAction(helpTopic[FIBSHome][0], 0, TQT_TQOBJECT(this), TQT_SLOT(wwwFIBS()),
+	(new TDEAction(helpTopic[FIBSHome][0], 0, this, TQT_SLOT(wwwFIBS()),
 		     actionCollection(), "help_www_fibs"))->plug(p);
-	(new TDEAction(helpTopic[RuleHome][0], 0, TQT_TQOBJECT(this), TQT_SLOT(wwwRule()),
+	(new TDEAction(helpTopic[RuleHome][0], 0, this, TQT_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 &)), TQT_TQOBJECT(this), TQT_SLOT(handleCmd(const TQString &)));
+	connect(cmdLine, TQT_SIGNAL(returnPressed(const TQString &)), this, TQT_SLOT(handleCmd(const TQString &)));
 	/*
 	 * Done with the actions, create the XML-defined parts of the
 	 * user interface
@@ -274,7 +274,7 @@ void KBg::setupEngine()
 	newAction->setEnabled(engine[currEngine]->haveNewGame());
 
 	// engine -> this
-	connect(engine[currEngine], TQT_SIGNAL(statText(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(updateCaption(const TQString &)));
+	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)));
 
@@ -616,10 +616,10 @@ void KBg::setupDlg()
 	 */
 	connect(nb, TQT_SIGNAL(okClicked()),     this, TQT_SLOT(setupOk()));
 	connect(nb, TQT_SIGNAL(applyClicked()),  this, TQT_SLOT(setupOk()));
-	connect(nb, TQT_SIGNAL(cancelClicked()), TQT_TQOBJECT(this), TQT_SLOT(setupCancel()));
+	connect(nb, TQT_SIGNAL(cancelClicked()), this, TQT_SLOT(setupCancel()));
 	connect(nb, TQT_SIGNAL(defaultClicked()),this, TQT_SLOT(setupDefault()));
 
-	connect(nb, TQT_SIGNAL(finished()), TQT_TQOBJECT(this), TQT_SLOT(setupDone()));
+	connect(nb, TQT_SIGNAL(finished()), this, TQT_SLOT(setupDone()));
 
 	nb->resize(nb->minimumSize());
 	nb->show();
diff --git a/kbattleship/kbattleship/kbattlefield.cpp b/kbattleship/kbattleship/kbattlefield.cpp
index dc567d2b..c4a9e422 100644
--- a/kbattleship/kbattleship/kbattlefield.cpp
+++ b/kbattleship/kbattleship/kbattlefield.cpp
@@ -91,7 +91,7 @@ void KBattleField::drawOwnField()
 	if(!m_canDraw)
 		return;
 
-	KBattleshipWindow *window = static_cast<KBattleshipWindow *>(TQT_TQWIDGET(m_parent->parent()->parent()));
+	KBattleshipWindow *window = static_cast<KBattleshipWindow *>(m_parent->parent()->parent());
 	KShip *ship = 0;
 	int data;
 
@@ -151,7 +151,7 @@ void KBattleField::drawEnemyField()
 	if(!m_canDraw)
 		return;
 
-	KBattleshipWindow *window = static_cast<KBattleshipWindow *>(TQT_TQWIDGET(m_parent->parent()->parent()));
+	KBattleshipWindow *window = static_cast<KBattleshipWindow *>(m_parent->parent()->parent());
 
 	for(int i = 0; i != m_enemyfieldx; i++)
 	{
diff --git a/kbattleship/kbattleship/kbattleship.cpp b/kbattleship/kbattleship/kbattleship.cpp
index a241696e..e2193cb2 100644
--- a/kbattleship/kbattleship/kbattleship.cpp
+++ b/kbattleship/kbattleship/kbattleship.cpp
@@ -92,16 +92,16 @@ void KBattleshipWindow::initStatusBar()
 
 void KBattleshipWindow::initActions()
 {
-	KStdAction::configureNotifications(TQT_TQOBJECT(this), TQT_SLOT(slotConfigureNotifications()), actionCollection());
-	m_gameServerConnect = new TDEAction(i18n("&Connect to Server..."), "connect_no", Key_F2, TQT_TQOBJECT(this), TQT_SLOT(slotServerConnect()), actionCollection(), "game_serverconnect");
-	m_gameNewServer = new TDEAction(i18n("&Start Server..."), "network", Key_F3, TQT_TQOBJECT(this), TQT_SLOT(slotNewServer()), actionCollection(), "game_newserver");
-	m_gameSingle = new TDEAction(i18n("S&ingle Player..."), "gear", Key_F4, TQT_TQOBJECT(this), TQT_SLOT(slotSinglePlayer()), actionCollection(), "game_singleplayer");
-	m_gameQuit = KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
-	KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(slotHighscore()), actionCollection());
-	m_gameEnemyInfo = new TDEAction(i18n("&Enemy Info"), "view_text", Key_F11, TQT_TQOBJECT(this), TQT_SLOT(slotEnemyClientInfo()), actionCollection(), "game_enemyinfo");
+	KStdAction::configureNotifications(this, TQT_SLOT(slotConfigureNotifications()), actionCollection());
+	m_gameServerConnect = new TDEAction(i18n("&Connect to Server..."), "connect_no", Key_F2, this, TQT_SLOT(slotServerConnect()), actionCollection(), "game_serverconnect");
+	m_gameNewServer = new TDEAction(i18n("&Start Server..."), "network", Key_F3, this, TQT_SLOT(slotNewServer()), actionCollection(), "game_newserver");
+	m_gameSingle = new TDEAction(i18n("S&ingle Player..."), "gear", Key_F4, this, TQT_SLOT(slotSinglePlayer()), actionCollection(), "game_singleplayer");
+	m_gameQuit = KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
+	KStdGameAction::highscores(this, TQT_SLOT(slotHighscore()), actionCollection());
+	m_gameEnemyInfo = new TDEAction(i18n("&Enemy Info"), "view_text", Key_F11, this, TQT_SLOT(slotEnemyClientInfo()), actionCollection(), "game_enemyinfo");
 
 	m_configSound = new TDEToggleAction(i18n("&Play Sounds"), 0, actionCollection(), "options_configure_sound");
-	m_configGrid = new TDEToggleAction(i18n("&Show Grid"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotShowGrid()), actionCollection(), "options_show_grid");
+	m_configGrid = new TDEToggleAction(i18n("&Show Grid"), 0, this, TQT_SLOT(slotShowGrid()), actionCollection(), "options_show_grid");
 	m_configGrid->setCheckedState(i18n("Hide Grid"));
 
 	m_gameEnemyInfo->setEnabled(false);
@@ -111,9 +111,9 @@ void KBattleshipWindow::initActions()
 
 void KBattleshipWindow::initChat()
 {
-	connect(m_chat, TQT_SIGNAL(sigSendMessage(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotSendChatMessage(const TQString &)));
-	connect(m_chat, TQT_SIGNAL(sigChangeEnemyNickname(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
-	connect(m_chat, TQT_SIGNAL(sigChangeOwnNickname(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotChangedNickCommand(const TQString &)));
+	connect(m_chat, TQT_SIGNAL(sigSendMessage(const TQString &)), this, TQT_SLOT(slotSendChatMessage(const TQString &)));
+	connect(m_chat, TQT_SIGNAL(sigChangeEnemyNickname(const TQString &)), this, TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
+	connect(m_chat, TQT_SIGNAL(sigChangeOwnNickname(const TQString &)), this, TQT_SLOT(slotChangedNickCommand(const TQString &)));
 }
 
 void KBattleshipWindow::changeShipPlacementDirection(){
@@ -122,8 +122,8 @@ void KBattleshipWindow::changeShipPlacementDirection(){
 
 void KBattleshipWindow::initShipPlacing()
 {
-	connect(m_ownshiplist, TQT_SIGNAL(sigOwnFieldDataChanged(int, int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotChangeOwnFieldData(int, int, int)));
-	connect(m_ownshiplist, TQT_SIGNAL(sigLastShipAdded()), TQT_TQOBJECT(this), TQT_SLOT(slotShipsReady()));
+	connect(m_ownshiplist, TQT_SIGNAL(sigOwnFieldDataChanged(int, int, int)), this, TQT_SLOT(slotChangeOwnFieldData(int, int, int)));
+	connect(m_ownshiplist, TQT_SIGNAL(sigLastShipAdded()), this, TQT_SLOT(slotShipsReady()));
 }
 
 void KBattleshipWindow::initView()
@@ -148,10 +148,10 @@ void KBattleshipWindow::initView()
 	m_view->startDrawing();
 	setFocusProxy(m_view);
 
-	connect(m_view, TQT_SIGNAL(sigEnemyFieldClicked(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotEnemyFieldClick(int, int)));
-	connect(m_view, TQT_SIGNAL(sigOwnFieldClicked(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotPlaceShip(int, int)));
-	connect(m_view, TQT_SIGNAL(sigMouseOverField(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotPlaceShipPreview(int, int)));
-	connect(m_view, TQT_SIGNAL(changeShipPlacementDirection()), TQT_TQOBJECT(this), TQT_SLOT(changeShipPlacementDirection()));
+	connect(m_view, TQT_SIGNAL(sigEnemyFieldClicked(int, int)), this, TQT_SLOT(slotEnemyFieldClick(int, int)));
+	connect(m_view, TQT_SIGNAL(sigOwnFieldClicked(int, int)), this, TQT_SLOT(slotPlaceShip(int, int)));
+	connect(m_view, TQT_SIGNAL(sigMouseOverField(int, int)), this, TQT_SLOT(slotPlaceShipPreview(int, int)));
+	connect(m_view, TQT_SIGNAL(changeShipPlacementDirection()), this, TQT_SLOT(changeShipPlacementDirection()));
 }
 
 void KBattleshipWindow::slotDeleteAI()
@@ -317,11 +317,11 @@ void KBattleshipWindow::slotEnemyFieldClick(int fieldx, int fieldy)
 				switch(KMessageBox::questionYesNo(this, i18n("Do you want to restart the game?"),TQString(),i18n("Restart"),i18n("Do Not Restart")))
 				{
 					case KMessageBox::Yes:
-						TQTimer::singleShot(0, TQT_TQOBJECT(this), TQT_SLOT(slotRestartAI()));
+						TQTimer::singleShot(0, this, TQT_SLOT(slotRestartAI()));
 						break;
 
 					case KMessageBox::No:
-						TQTimer::singleShot(0, TQT_TQOBJECT(this), TQT_SLOT(slotDeleteAI()));
+						TQTimer::singleShot(0, this, TQT_SLOT(slotDeleteAI()));
 						break;
 				}
 				return;
@@ -697,8 +697,8 @@ void KBattleshipWindow::slotServerConnect()
 		slotStatusMsg(i18n("Loading Connect-Server dialog..."));
 
 		m_client = new KClientDialog(this);
-		connect(m_client, TQT_SIGNAL(sigConnectServer()), TQT_TQOBJECT(this), TQT_SLOT(slotConnectToBattleshipServer()));
-		connect(m_client, TQT_SIGNAL(sigCancelConnect()), TQT_TQOBJECT(this), TQT_SLOT(slotDeleteConnectDialog()));
+		connect(m_client, TQT_SIGNAL(sigConnectServer()), this, TQT_SLOT(slotConnectToBattleshipServer()));
+		connect(m_client, TQT_SIGNAL(sigCancelConnect()), this, TQT_SLOT(slotDeleteConnectDialog()));
 		m_client->show();
 
 		slotStatusMsg(i18n("Ready"));
@@ -806,8 +806,8 @@ void KBattleshipWindow::slotNewServer()
 		slotStatusMsg(i18n("Loading Start-Server dialog..."));
 
 		m_server = new TDEServerDialog(this);
-		connect(m_server, TQT_SIGNAL(okClicked()), TQT_TQOBJECT(this), TQT_SLOT(slotStartBattleshipServer()));
-		connect(m_server, TQT_SIGNAL(cancelClicked()), TQT_TQOBJECT(this), TQT_SLOT(slotDeleteServerDialog()));
+		connect(m_server, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotStartBattleshipServer()));
+		connect(m_server, TQT_SIGNAL(cancelClicked()), this, TQT_SLOT(slotDeleteServerDialog()));
 		m_server->show();
 
 		slotStatusMsg(i18n("Ready"));
@@ -828,7 +828,7 @@ void KBattleshipWindow::slotSendVersion()
 	msg->versionMessage();
 	slotSendMessage(msg);
 
-	TQTimer::singleShot(150, TQT_TQOBJECT(this), TQT_SLOT(slotSendGreet()));
+	TQTimer::singleShot(150, this, TQT_SLOT(slotSendGreet()));
 }
 
 void KBattleshipWindow::slotSendGreet()
@@ -862,49 +862,49 @@ void KBattleshipWindow::slotStartBattleshipServer()
 	if(m_connection == 0)
 	{
 		m_connection = new KonnectionHandling(this, m_kbserver);
-		connect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotStatusMsg(const TQString &)));
-		connect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
-		connect(m_connection, TQT_SIGNAL(sigSendNickname()), TQT_TQOBJECT(this), TQT_SLOT(slotSendGreet()));
-		connect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetPlaceable(bool)));
-		connect(m_connection, TQT_SIGNAL(sigShootable(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetShootable(bool)));
-		connect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotSendEnemyFieldState(int, int)));
-		connect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
-		connect(m_connection, TQT_SIGNAL(sigClientLost()), TQT_TQOBJECT(this), TQT_SLOT(slotClientLost()));
-		connect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), TQT_TQOBJECT(this), TQT_SLOT(slotAbortNetworkGame()));
-		connect(m_connection, TQT_SIGNAL(sigReplay()), TQT_TQOBJECT(this), TQT_SLOT(slotReplayRequest()));
+		connect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), this, TQT_SLOT(slotStatusMsg(const TQString &)));
+		connect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), this, TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
+		connect(m_connection, TQT_SIGNAL(sigSendNickname()), this, TQT_SLOT(slotSendGreet()));
+		connect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), this, TQT_SLOT(slotSetPlaceable(bool)));
+		connect(m_connection, TQT_SIGNAL(sigShootable(bool)), this, TQT_SLOT(slotSetShootable(bool)));
+		connect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), this, TQT_SLOT(slotSendEnemyFieldState(int, int)));
+		connect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
+		connect(m_connection, TQT_SIGNAL(sigClientLost()), this, TQT_SLOT(slotClientLost()));
+		connect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), this, TQT_SLOT(slotAbortNetworkGame()));
+		connect(m_connection, TQT_SIGNAL(sigReplay()), this, TQT_SLOT(slotReplayRequest()));
 		connect(m_connection, TQT_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQT_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
-		connect(m_connection, TQT_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
-		connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), TQT_TQOBJECT(this), TQT_SLOT(slotLost(KMessage *)));
+		connect(m_connection, TQT_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), this, TQT_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
+		connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), this, TQT_SLOT(slotLost(KMessage *)));
 	}
 	else
 	{
 		if(m_connection->type() == KonnectionHandling::CLIENT)
 		{
-			disconnect(m_kbclient, TQT_SIGNAL(sigConnected()), TQT_TQOBJECT(this), TQT_SLOT(slotSendVersion()));
-			disconnect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), TQT_TQOBJECT(this), TQT_SLOT(slotAbortNetworkGame()));
-			disconnect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotStatusMsg(const TQString &)));
-			disconnect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
-			disconnect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotSendEnemyFieldState(int, int)));
-			disconnect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
-			disconnect(m_connection, TQT_SIGNAL(sigShootable(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetShootable(bool)));
-			disconnect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetPlaceable(bool)));
-			disconnect(m_connection, TQT_SIGNAL(sigServerLost()), TQT_TQOBJECT(this), TQT_SLOT(slotServerLost()));
-			disconnect(m_connection, TQT_SIGNAL(sigReplay()), TQT_TQOBJECT(this), TQT_SLOT(slotReplay()));
+			disconnect(m_kbclient, TQT_SIGNAL(sigConnected()), this, TQT_SLOT(slotSendVersion()));
+			disconnect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), this, TQT_SLOT(slotAbortNetworkGame()));
+			disconnect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), this, TQT_SLOT(slotStatusMsg(const TQString &)));
+			disconnect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), this, TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
+			disconnect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), this, TQT_SLOT(slotSendEnemyFieldState(int, int)));
+			disconnect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
+			disconnect(m_connection, TQT_SIGNAL(sigShootable(bool)), this, TQT_SLOT(slotSetShootable(bool)));
+			disconnect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), this, TQT_SLOT(slotSetPlaceable(bool)));
+			disconnect(m_connection, TQT_SIGNAL(sigServerLost()), this, TQT_SLOT(slotServerLost()));
+			disconnect(m_connection, TQT_SIGNAL(sigReplay()), this, TQT_SLOT(slotReplay()));
 			disconnect(m_connection, TQT_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQT_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
-			disconnect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), TQT_TQOBJECT(this), TQT_SLOT(slotLost(KMessage *)));
+			disconnect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), this, TQT_SLOT(slotLost(KMessage *)));
 			m_connection->updateInternal(m_kbserver);
-			connect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotStatusMsg(const TQString &)));
-			connect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
-			connect(m_connection, TQT_SIGNAL(sigSendNickname()), TQT_TQOBJECT(this), TQT_SLOT(slotSendGreet()));
-			connect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetPlaceable(bool)));
-			connect(m_connection, TQT_SIGNAL(sigShootable(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetShootable(bool)));
-			connect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotSendEnemyFieldState(int, int)));
-			connect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
-			connect(m_connection, TQT_SIGNAL(sigClientLost()), TQT_TQOBJECT(this), TQT_SLOT(slotClientLost()));
-			connect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), TQT_TQOBJECT(this), TQT_SLOT(slotAbortNetworkGame()));
-			connect(m_connection, TQT_SIGNAL(sigReplay()), TQT_TQOBJECT(this), TQT_SLOT(slotReplayRequest()));
+			connect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), this, TQT_SLOT(slotStatusMsg(const TQString &)));
+			connect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), this, TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
+			connect(m_connection, TQT_SIGNAL(sigSendNickname()), this, TQT_SLOT(slotSendGreet()));
+			connect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), this, TQT_SLOT(slotSetPlaceable(bool)));
+			connect(m_connection, TQT_SIGNAL(sigShootable(bool)), this, TQT_SLOT(slotSetShootable(bool)));
+			connect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), this, TQT_SLOT(slotSendEnemyFieldState(int, int)));
+			connect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
+			connect(m_connection, TQT_SIGNAL(sigClientLost()), this, TQT_SLOT(slotClientLost()));
+			connect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), this, TQT_SLOT(slotAbortNetworkGame()));
+			connect(m_connection, TQT_SIGNAL(sigReplay()), this, TQT_SLOT(slotReplayRequest()));
 			connect(m_connection, TQT_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQT_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
-			connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), TQT_TQOBJECT(this), TQT_SLOT(slotLost(KMessage *)));
+			connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), this, TQT_SLOT(slotLost(KMessage *)));
 		}
 		else
 			m_connection->updateInternal(m_kbserver);
@@ -1119,51 +1119,51 @@ void KBattleshipWindow::slotConnectToBattleshipServer(const TQString &host, int
 	if(m_connection == 0)
 	{
 		m_connection = new KonnectionHandling(this, m_kbclient);
-		connect(m_kbclient, TQT_SIGNAL(sigConnected()), TQT_TQOBJECT(this), TQT_SLOT(slotSendVersion()));
-		connect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), TQT_TQOBJECT(this), TQT_SLOT(slotAbortNetworkGame()));
-		connect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotStatusMsg(const TQString &)));
-		connect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
-		connect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotSendEnemyFieldState(int, int)));
-		connect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
-		connect(m_connection, TQT_SIGNAL(sigShootable(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetShootable(bool)));
-		connect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetPlaceable(bool)));
-		connect(m_connection, TQT_SIGNAL(sigServerLost()), TQT_TQOBJECT(this), TQT_SLOT(slotServerLost()));
-		connect(m_connection, TQT_SIGNAL(sigReplay()), TQT_TQOBJECT(this), TQT_SLOT(slotReplay()));
+		connect(m_kbclient, TQT_SIGNAL(sigConnected()), this, TQT_SLOT(slotSendVersion()));
+		connect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), this, TQT_SLOT(slotAbortNetworkGame()));
+		connect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), this, TQT_SLOT(slotStatusMsg(const TQString &)));
+		connect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), this, TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
+		connect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), this, TQT_SLOT(slotSendEnemyFieldState(int, int)));
+		connect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
+		connect(m_connection, TQT_SIGNAL(sigShootable(bool)), this, TQT_SLOT(slotSetShootable(bool)));
+		connect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), this, TQT_SLOT(slotSetPlaceable(bool)));
+		connect(m_connection, TQT_SIGNAL(sigServerLost()), this, TQT_SLOT(slotServerLost()));
+		connect(m_connection, TQT_SIGNAL(sigReplay()), this, TQT_SLOT(slotReplay()));
 		connect(m_connection, TQT_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQT_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
-		connect(m_connection, TQT_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
-		connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), TQT_TQOBJECT(this), TQT_SLOT(slotLost(KMessage *)));
+		connect(m_connection, TQT_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), this, TQT_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
+		connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), this, TQT_SLOT(slotLost(KMessage *)));
 	}
 	else
 	{
 		if(m_connection->type() == KonnectionHandling::SERVER)
 		{
-			disconnect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotStatusMsg(const TQString &)));
-			disconnect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
-			disconnect(m_connection, TQT_SIGNAL(sigSendNickname()), TQT_TQOBJECT(this), TQT_SLOT(slotSendGreet()));
-			disconnect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetPlaceable(bool)));
-			disconnect(m_connection, TQT_SIGNAL(sigShootable(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetShootable(bool)));
-			disconnect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotSendEnemyFieldState(int, int)));
-			disconnect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
-			disconnect(m_connection, TQT_SIGNAL(sigClientLost()), TQT_TQOBJECT(this), TQT_SLOT(slotClientLost()));
-			disconnect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), TQT_TQOBJECT(this), TQT_SLOT(slotAbortNetworkGame()));
-			disconnect(m_connection, TQT_SIGNAL(sigReplay()), TQT_TQOBJECT(this), TQT_SLOT(slotReplayRequest()));
+			disconnect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), this, TQT_SLOT(slotStatusMsg(const TQString &)));
+			disconnect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), this, TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
+			disconnect(m_connection, TQT_SIGNAL(sigSendNickname()), this, TQT_SLOT(slotSendGreet()));
+			disconnect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), this, TQT_SLOT(slotSetPlaceable(bool)));
+			disconnect(m_connection, TQT_SIGNAL(sigShootable(bool)), this, TQT_SLOT(slotSetShootable(bool)));
+			disconnect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), this, TQT_SLOT(slotSendEnemyFieldState(int, int)));
+			disconnect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
+			disconnect(m_connection, TQT_SIGNAL(sigClientLost()), this, TQT_SLOT(slotClientLost()));
+			disconnect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), this, TQT_SLOT(slotAbortNetworkGame()));
+			disconnect(m_connection, TQT_SIGNAL(sigReplay()), this, TQT_SLOT(slotReplayRequest()));
 			disconnect(m_connection, TQT_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQT_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
-			disconnect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), TQT_TQOBJECT(this), TQT_SLOT(slotLost(KMessage *)));
+			disconnect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), this, TQT_SLOT(slotLost(KMessage *)));
 			m_connection->updateInternal(m_kbclient);
-			connect(m_kbclient, TQT_SIGNAL(sigConnected()), TQT_TQOBJECT(this), TQT_SLOT(slotSendVersion()));
-			connect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), TQT_TQOBJECT(this), TQT_SLOT(slotAbortNetworkGame()));
-			connect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotStatusMsg(const TQString &)));
-			connect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
-			connect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), TQT_TQOBJECT(this), TQT_SLOT(slotSendEnemyFieldState(int, int)));
-			connect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
-			connect(m_connection, TQT_SIGNAL(sigShootable(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetShootable(bool)));
-			connect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), TQT_TQOBJECT(this), TQT_SLOT(slotSetPlaceable(bool)));
-			connect(m_connection, TQT_SIGNAL(sigServerLost()), TQT_TQOBJECT(this), TQT_SLOT(slotServerLost()));
-			connect(m_connection, TQT_SIGNAL(sigReplay()), TQT_TQOBJECT(this), TQT_SLOT(slotReplay()));
+			connect(m_kbclient, TQT_SIGNAL(sigConnected()), this, TQT_SLOT(slotSendVersion()));
+			connect(m_connection, TQT_SIGNAL(sigAbortNetworkGame()), this, TQT_SLOT(slotAbortNetworkGame()));
+			connect(m_connection, TQT_SIGNAL(sigStatusBar(const TQString &)), this, TQT_SLOT(slotStatusMsg(const TQString &)));
+			connect(m_connection, TQT_SIGNAL(sigEnemyNickname(const TQString &)), this, TQT_SLOT(slotChangeEnemyPlayer(const TQString &)));
+			connect(m_connection, TQT_SIGNAL(sigSendFieldState(int, int)), this, TQT_SLOT(slotSendEnemyFieldState(int, int)));
+			connect(m_connection, TQT_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQT_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
+			connect(m_connection, TQT_SIGNAL(sigShootable(bool)), this, TQT_SLOT(slotSetShootable(bool)));
+			connect(m_connection, TQT_SIGNAL(sigPlaceShips(bool)), this, TQT_SLOT(slotSetPlaceable(bool)));
+			connect(m_connection, TQT_SIGNAL(sigServerLost()), this, TQT_SLOT(slotServerLost()));
+			connect(m_connection, TQT_SIGNAL(sigReplay()), this, TQT_SLOT(slotReplay()));
 			connect(m_connection, TQT_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQT_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
 			m_kbclient->init();
-			connect(m_connection, TQT_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
-			connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), TQT_TQOBJECT(this), TQT_SLOT(slotLost(KMessage *)));
+			connect(m_connection, TQT_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), this, TQT_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
+			connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), this, TQT_SLOT(slotLost(KMessage *)));
 		}
 		else
 			m_connection->updateInternal(m_kbclient);
@@ -1234,7 +1234,7 @@ void KBattleshipWindow::slotSinglePlayer()
 			slotStatusMsg(i18n("Ready"));
 			m_stat->clear();
 			m_chat->clear();
-			TQTimer::singleShot(0, TQT_TQOBJECT(this), TQT_SLOT(slotDeleteAI()));
+			TQTimer::singleShot(0, this, TQT_SLOT(slotDeleteAI()));
 			cleanup(false);
 		}
 	}
@@ -1269,8 +1269,8 @@ void KBattleshipWindow::slotStartBattleshipGame(bool clearstat)
 	{
 		m_aiPlayer = new KBAIPlayer();
 		m_aiPlayer->init(m_view->field(), m_enemyshiplist);
-		connect(m_aiPlayer, TQT_SIGNAL(sigReady()), TQT_TQOBJECT(this), TQT_SLOT(slotAIReady()));
-		connect(m_aiPlayer, TQT_SIGNAL(sigShootAt(const TQPoint)), TQT_TQOBJECT(this), TQT_SLOT(slotAIShootsAt(const TQPoint)));
+		connect(m_aiPlayer, TQT_SIGNAL(sigReady()), this, TQT_SLOT(slotAIReady()));
+		connect(m_aiPlayer, TQT_SIGNAL(sigShootAt(const TQPoint)), this, TQT_SLOT(slotAIShootsAt(const TQPoint)));
 	}
 	m_aiPlayer->slotRestart();
 }
@@ -1320,11 +1320,11 @@ void KBattleshipWindow::slotAIShootsAt(const TQPoint pos)
 		switch(KMessageBox::questionYesNo(this, i18n("Do you want to restart the game?"), TQString(), i18n("Restart"), i18n("Do Not Restart")))
 		{
 			case KMessageBox::Yes:
-				TQTimer::singleShot(0, TQT_TQOBJECT(this), TQT_SLOT(slotRestartAI()));
+				TQTimer::singleShot(0, this, TQT_SLOT(slotRestartAI()));
 				break;
 
 			case KMessageBox::No:
-				TQTimer::singleShot(0, TQT_TQOBJECT(this), TQT_SLOT(slotDeleteAI()));
+				TQTimer::singleShot(0, this, TQT_SLOT(slotDeleteAI()));
 				break;
 		}
 	}
diff --git a/kbattleship/kbattleship/kbattleshipclient.cpp b/kbattleship/kbattleship/kbattleshipclient.cpp
index 039dcc0c..e7d61638 100644
--- a/kbattleship/kbattleship/kbattleshipclient.cpp
+++ b/kbattleship/kbattleship/kbattleshipclient.cpp
@@ -43,7 +43,7 @@ void KBattleshipClient::init()
 		return;
 	}
 
-	m_readNotifier = new TQSocketNotifier(fd(), TQSocketNotifier::Read, TQT_TQOBJECT(this));
+	m_readNotifier = new TQSocketNotifier(fd(), TQSocketNotifier::Read, this);
 	TQObject::connect(m_readNotifier, TQT_SIGNAL(activated(int)), TQT_SLOT(slotReadData()));
 	emit sigConnected();
 }
diff --git a/kbattleship/kbattleship/kbattleshipserver.cpp b/kbattleship/kbattleship/kbattleshipserver.cpp
index df171f7a..b05b0f7e 100644
--- a/kbattleship/kbattleship/kbattleshipserver.cpp
+++ b/kbattleship/kbattleship/kbattleshipserver.cpp
@@ -49,7 +49,7 @@ void KBattleshipServer::init()
 	m_service.setType(BATTLESHIP_SERVICE);
 	m_service.setPort(m_port);
 	m_service.publishAsync();
-	m_connectNotifier = new TQSocketNotifier(fd(), TQSocketNotifier::Read, TQT_TQOBJECT(this));
+	m_connectNotifier = new TQSocketNotifier(fd(), TQSocketNotifier::Read, this);
 	TQObject::connect(m_connectNotifier, TQT_SIGNAL(activated(int)), TQT_SLOT(slotNewConnection()));
 }
 
@@ -61,7 +61,7 @@ void KBattleshipServer::slotNewConnection()
 	{
 		m_service.stop();
 		m_serverSocket = sock;
-		m_readNotifier = new TQSocketNotifier(sock->fd(), TQSocketNotifier::Read, TQT_TQOBJECT(this));
+		m_readNotifier = new TQSocketNotifier(sock->fd(), TQSocketNotifier::Read, this);
 		TQObject::connect(m_readNotifier, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotReadClient()));
 		emit sigNewConnect();
 	}
diff --git a/kbattleship/kbattleship/kchatwidget.cpp b/kbattleship/kbattleship/kchatwidget.cpp
index 649fd777..c1925e5d 100644
--- a/kbattleship/kbattleship/kchatwidget.cpp
+++ b/kbattleship/kbattleship/kchatwidget.cpp
@@ -63,7 +63,7 @@ bool KChatWidget::eventFilter(TQObject *obj, TQEvent *e)
 {
 	if(obj == commentEdit && e->type() == TQEvent::Wheel)
 	{
-		kapp->notify(TQT_TQOBJECT(chatView), e);
+		kapp->notify(chatView, e);
 		return true;
 	}
 	return chatDlg::eventFilter(obj, e);
diff --git a/kblackbox/kbbgame.cpp b/kblackbox/kbbgame.cpp
index 2920f02e..f0c97a60 100644
--- a/kblackbox/kbbgame.cpp
+++ b/kblackbox/kbbgame.cpp
@@ -698,37 +698,37 @@ void KBBGame::gotInputAt( int col, int row, int state )
 void KBBGame::initTDEAction()
 {
 // game
-  KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(newGame()), actionCollection());
-  (void)new TDEAction( i18n("&Give Up"), SmallIcon("giveup"), 0, TQT_TQOBJECT(this), TQT_SLOT(giveUp()), actionCollection(), "game_giveup" );
-  (void)new TDEAction( i18n("&Done"), SmallIcon("done"), 0, TQT_TQOBJECT(this), TQT_SLOT(gameFinished()), actionCollection(), "game_done" );
-  (void)new TDEAction( i18n("&Resize"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotResize()), actionCollection(), "game_resize" );
-  KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
+  KStdGameAction::gameNew(this, TQT_SLOT(newGame()), actionCollection());
+  (void)new TDEAction( i18n("&Give Up"), SmallIcon("giveup"), 0, this, TQT_SLOT(giveUp()), actionCollection(), "game_giveup" );
+  (void)new TDEAction( i18n("&Done"), SmallIcon("done"), 0, this, TQT_SLOT(gameFinished()), actionCollection(), "game_done" );
+  (void)new TDEAction( i18n("&Resize"), 0, this, TQT_SLOT(slotResize()), actionCollection(), "game_resize" );
+  KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
 
 
 // settings
-  sizeAction = new TDESelectAction( i18n("&Size"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotSize()), actionCollection(), "options_size");
+  sizeAction = new TDESelectAction( i18n("&Size"), 0, this, TQT_SLOT(slotSize()), actionCollection(), "options_size");
   TQStringList list;
   list.append(i18n("  8 x  8 "));
   list.append(i18n(" 10 x 10 "));
   list.append(i18n(" 12 x 12 "));
   sizeAction->setItems(list);
 
-  ballsAction = new TDESelectAction( i18n("&Balls"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotBalls()), actionCollection(), "options_balls");
+  ballsAction = new TDESelectAction( i18n("&Balls"), 0, this, TQT_SLOT(slotBalls()), actionCollection(), "options_balls");
   list.clear();
   list.append(i18n(" 4 "));
   list.append(i18n(" 6 "));
   list.append(i18n(" 8 "));
   ballsAction->setItems(list);
-  tutorialAction = new TDEToggleAction( i18n("&Tutorial"), 0, TQT_TQOBJECT(this), TQT_SLOT(tutorialSwitch()), actionCollection(), "options_tutorial" );
+  tutorialAction = new TDEToggleAction( i18n("&Tutorial"), 0, this, TQT_SLOT(tutorialSwitch()), actionCollection(), "options_tutorial" );
 //  KStdAction::keyBindings(guiFactory(), TQT_SLOT(configureShortcuts()), 
 //actionCollection());
 
 // keyboard only
-  (void)new TDEAction( i18n("Move Down"), TQt::Key_Down, TQT_TQOBJECT(gr), TQT_SLOT(slotDown()), actionCollection(), "move_down" );
-  (void)new TDEAction( i18n("Move Up"), TQt::Key_Up, TQT_TQOBJECT(gr), TQT_SLOT(slotUp()), actionCollection(), "move_up" );
-  (void)new TDEAction( i18n("Move Left"), TQt::Key_Left, TQT_TQOBJECT(gr), TQT_SLOT(slotLeft()), actionCollection(), "move_left" );
-  (void)new TDEAction( i18n("Move Right"), TQt::Key_Right, TQT_TQOBJECT(gr), TQT_SLOT(slotRight()), actionCollection(), "move_right" );
-  (void)new TDEAction( i18n("Trigger Action"), TQt::Key_Return, TQT_TQOBJECT(gr), TQT_SLOT(slotInput()), actionCollection(), "move_trigger" );
+  (void)new TDEAction( i18n("Move Down"), TQt::Key_Down, gr, TQT_SLOT(slotDown()), actionCollection(), "move_down" );
+  (void)new TDEAction( i18n("Move Up"), TQt::Key_Up, gr, TQT_SLOT(slotUp()), actionCollection(), "move_up" );
+  (void)new TDEAction( i18n("Move Left"), TQt::Key_Left, gr, TQT_SLOT(slotLeft()), actionCollection(), "move_left" );
+  (void)new TDEAction( i18n("Move Right"), TQt::Key_Right, gr, TQT_SLOT(slotRight()), actionCollection(), "move_right" );
+  (void)new TDEAction( i18n("Trigger Action"), TQt::Key_Return, gr, TQT_SLOT(slotInput()), actionCollection(), "move_trigger" );
 }
 
 void KBBGame::slotResize()
diff --git a/kbounce/game.cpp b/kbounce/game.cpp
index 4b2f14b3..2d4c9721 100644
--- a/kbounce/game.cpp
+++ b/kbounce/game.cpp
@@ -363,7 +363,7 @@ JezzGame::JezzGame( const TQPixmap &background, int ballNum, TQWidget *parent, c
                  "kbounce/sounds/";
 
    // create field
-   m_field = new JezzField( tiles, background, TQT_TQOBJECT(this), "m_field" );
+   m_field = new JezzField( tiles, background, this, "m_field" );
    m_field->resize( TILE_SIZE*FIELD_WIDTH, TILE_SIZE*FIELD_HEIGHT );
 
    for ( int x=0; x<FIELD_WIDTH; x++ )
@@ -617,7 +617,7 @@ void JezzGame::buildWall( int x, int y, bool vertical )
          m_wall1 = new Wall( m_field, x, y,
                              vertical? Wall::Up : Wall::Left,
                              vertical? TILE_WALLUP : TILE_WALLLEFT,
-                             TQT_TQOBJECT(this), "m_wall1" );
+                             this, "m_wall1" );
          connect( m_wall1, TQT_SIGNAL(finished(Wall *, int)),
                   this, TQT_SLOT(wallFinished(Wall *, int)) );            }
 
@@ -626,7 +626,7 @@ void JezzGame::buildWall( int x, int y, bool vertical )
          m_wall2 = new Wall( m_field, x, y,
                              vertical? Wall::Down: Wall::Right,
                              vertical? TILE_WALLDOWN : TILE_WALLRIGHT,
-                             TQT_TQOBJECT(this), "m_wall2" );
+                             this, "m_wall2" );
          connect( m_wall2, TQT_SIGNAL(finished(Wall *, int)),
                   this, TQT_SLOT(wallFinished(Wall *, int)) );
       }
diff --git a/kbounce/kbounce.cpp b/kbounce/kbounce.cpp
index d3450bf9..64b51f0a 100644
--- a/kbounce/kbounce.cpp
+++ b/kbounce/kbounce.cpp
@@ -89,13 +89,13 @@ KJezzball::KJezzball()
 
     // create timers
     m_nextLevelTimer = new TQTimer( this, "m_nextLevelTimer" );
-    connect( m_nextLevelTimer, TQT_SIGNAL(timeout()), TQT_TQOBJECT(this), TQT_SLOT(switchLevel()) );
+    connect( m_nextLevelTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(switchLevel()) );
 
     m_gameOverTimer = new TQTimer( this, "m_gameOverTimer" );
-    connect( m_gameOverTimer, TQT_SIGNAL(timeout()), TQT_TQOBJECT(this), TQT_SLOT(gameOverNow()) );
+    connect( m_gameOverTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(gameOverNow()) );
 
     m_timer = new TQTimer( this, "m_timer" );
-    connect( m_timer, TQT_SIGNAL(timeout()), TQT_TQOBJECT(this), TQT_SLOT(second()) );
+    connect( m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(second()) );
 
     // create demo game
     createLevel( 1 );
@@ -119,23 +119,23 @@ KJezzball::~KJezzball()
  */
 void KJezzball::initXMLUI()
 {
-    m_newAction = KStdGameAction::gameNew( TQT_TQOBJECT(this), TQT_SLOT(newGame()), actionCollection() );
+    m_newAction = KStdGameAction::gameNew( this, TQT_SLOT(newGame()), actionCollection() );
     // AB: originally KBounce/KJezzball used Space for new game - but Ctrl+N is
     // default. We solve this by providing space as an alternative key
     TDEShortcut s = m_newAction->shortcut();
     s.append(KKeySequence(TQKeySequence(Key_Space)));
     m_newAction->setShortcut(s);
 
-    KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection() );
-    KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighscore()), actionCollection() );
-    m_pauseButton = KStdGameAction::pause(TQT_TQOBJECT(this), TQT_SLOT(pauseGame()), actionCollection());
-    KStdGameAction::end(TQT_TQOBJECT(this), TQT_SLOT(closeGame()), actionCollection());
-    KStdGameAction::configureHighscores(TQT_TQOBJECT(this), TQT_SLOT(configureHighscores()),actionCollection());
+    KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection() );
+    KStdGameAction::highscores(this, TQT_SLOT(showHighscore()), actionCollection() );
+    m_pauseButton = KStdGameAction::pause(this, TQT_SLOT(pauseGame()), actionCollection());
+    KStdGameAction::end(this, TQT_SLOT(closeGame()), actionCollection());
+    KStdGameAction::configureHighscores(this, TQT_SLOT(configureHighscores()),actionCollection());
 
-    new TDEAction( i18n("&Select Background Folder..."), 0, TQT_TQOBJECT(this), TQT_SLOT(selectBackground()),
+    new TDEAction( i18n("&Select Background Folder..."), 0, this, TQT_SLOT(selectBackground()),
                        actionCollection(), "background_select" );
     m_backgroundShowAction =
-        new TDEToggleAction( i18n("Show &Backgrounds"), 0, TQT_TQOBJECT(this), TQT_SLOT(showBackground()),
+        new TDEToggleAction( i18n("Show &Backgrounds"), 0, this, TQT_SLOT(showBackground()),
                            actionCollection(), "background_show" );
     m_backgroundShowAction->setCheckedState(i18n("Hide &Backgrounds"));
     m_backgroundShowAction->setEnabled( !m_backgroundDir.isEmpty() );
@@ -400,8 +400,8 @@ void KJezzball::createLevel( int level )
 
     m_gameWidget->show();
     m_layout->addWidget( m_gameWidget, 0, 0 );
-    connect( m_gameWidget, TQT_SIGNAL(died()), TQT_TQOBJECT(this), TQT_SLOT(died()) );
-    connect( m_gameWidget, TQT_SIGNAL(newPercent(int)), TQT_TQOBJECT(this), TQT_SLOT(newPercent(int)) );
+    connect( m_gameWidget, TQT_SIGNAL(died()), this, TQT_SLOT(died()) );
+    connect( m_gameWidget, TQT_SIGNAL(newPercent(int)), this, TQT_SLOT(newPercent(int)) );
     connect( m_soundAction, TQT_SIGNAL(toggled(bool)), m_gameWidget, TQT_SLOT(setSound(bool)) );
 
     // update displays
diff --git a/kenolaba/AbTop.cpp b/kenolaba/AbTop.cpp
index 51a54532..891128b2 100644
--- a/kenolaba/AbTop.cpp
+++ b/kenolaba/AbTop.cpp
@@ -63,12 +63,12 @@ AbTop::AbTop()
 
 
   timer = new TQTimer;
-  connect( timer, TQT_SIGNAL(timeout()), TQT_TQOBJECT(this), TQT_SLOT(timerDone()) );
+  connect( timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timerDone()) );
 
   board = new Board();
   setMoveNo(0);
 
-  connect( board, TQT_SIGNAL(searchBreak()), TQT_TQOBJECT(this), TQT_SLOT(searchBreak()) );
+  connect( board, TQT_SIGNAL(searchBreak()), this, TQT_SLOT(searchBreak()) );
   TQ_CHECK_PTR(board);
   boardWidget = new BoardWidget(*board,this);
 
@@ -77,7 +77,7 @@ AbTop::AbTop()
 #endif
 
   connect( boardWidget, TQT_SIGNAL(updateSpy(TQString)),
-	   TQT_TQOBJECT(this), TQT_SLOT(updateSpy(TQString)) );
+	   this, TQT_SLOT(updateSpy(TQString)) );
 
   setCentralWidget(boardWidget);
   boardWidget->show();
@@ -89,16 +89,16 @@ AbTop::AbTop()
 
   // RMB context menu
   connect( boardWidget, TQT_SIGNAL(rightButtonPressed(int,const TQPoint&)),
-	   TQT_TQOBJECT(this), TQT_SLOT(rightButtonPressed(int,const TQPoint&)) );
+	   this, TQT_SLOT(rightButtonPressed(int,const TQPoint&)) );
 
   connect( boardWidget, TQT_SIGNAL(edited(int)),
-	   TQT_TQOBJECT(this), TQT_SLOT(edited(int)) );
+	   this, TQT_SLOT(edited(int)) );
 
   connect( board, TQT_SIGNAL(updateBestMove(Move&,int)),
-	   TQT_TQOBJECT(this), TQT_SLOT(updateBestMove(Move&,int)) );
+	   this, TQT_SLOT(updateBestMove(Move&,int)) );
 
   connect( boardWidget, TQT_SIGNAL(moveChoosen(Move&)),
-	   TQT_TQOBJECT(this), TQT_SLOT(moveChoosen(Move&)) );
+	   this, TQT_SLOT(moveChoosen(Move&)) );
 
   /* default */
   setLevel(Easy);
@@ -132,61 +132,61 @@ AbTop::~AbTop()
 
 void AbTop::setupActions()
 {
-  newAction = KStdGameAction::gameNew( TQT_TQOBJECT(this), TQT_SLOT(newGame()), actionCollection() );
-  KStdGameAction::quit( TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection() );
+  newAction = KStdGameAction::gameNew( this, TQT_SLOT(newGame()), actionCollection() );
+  KStdGameAction::quit( this, TQT_SLOT(close()), actionCollection() );
 
-  stopAction = new TDEAction( i18n("&Stop Search"), "process-stop", Key_S, TQT_TQOBJECT(this),
+  stopAction = new TDEAction( i18n("&Stop Search"), "process-stop", Key_S, this,
                             TQT_SLOT(stopSearch()), actionCollection(), "move_stop");
 
   backAction = new TDEAction( i18n("Take &Back"), "back",
-                            TDEStdAccel::shortcut(TDEStdAccel::Prior), TQT_TQOBJECT(this),
+                            TDEStdAccel::shortcut(TDEStdAccel::Prior), this,
                             TQT_SLOT(back()), actionCollection(), "move_back");
 
   forwardAction = new TDEAction( i18n("&Forward"), "forward",
-                            TDEStdAccel::shortcut(TDEStdAccel::Next), TQT_TQOBJECT(this),
+                            TDEStdAccel::shortcut(TDEStdAccel::Next), this,
                             TQT_SLOT(forward()), actionCollection(), "move_forward");
 
-  hintAction = KStdGameAction::hint(TQT_TQOBJECT(this), TQT_SLOT(suggestion()), actionCollection());
+  hintAction = KStdGameAction::hint(this, TQT_SLOT(suggestion()), actionCollection());
 
-  KStdAction::copy( TQT_TQOBJECT(this), TQT_SLOT(copy()), actionCollection());
-  pasteAction = KStdAction::paste( TQT_TQOBJECT(this), TQT_SLOT(paste()), actionCollection());
+  KStdAction::copy( this, TQT_SLOT(copy()), actionCollection());
+  pasteAction = KStdAction::paste( this, TQT_SLOT(paste()), actionCollection());
 
   (void) new TDEAction( i18n("&Restore Position"),
 		      TDEStdAccel::shortcut(TDEStdAccel::Open),
-		      TQT_TQOBJECT(this), TQT_SLOT(restorePosition()),
+		      this, TQT_SLOT(restorePosition()),
 		      actionCollection(), "edit_restore" );
 
   (void) new TDEAction( i18n("&Save Position"),
 		      TDEStdAccel::shortcut(TDEStdAccel::Save),
-		      TQT_TQOBJECT(this), TQT_SLOT(savePosition()),
+		      this, TQT_SLOT(savePosition()),
 		      actionCollection(), "edit_save" );
 
   TDEToggleAction *ta;
 
   ta = new TDEToggleAction( i18n("&Network Play"), "network", Key_N,
 			  actionCollection(), "game_net");
-  connect(ta, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(gameNetwork(bool)));
+  connect(ta, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(gameNetwork(bool)));
 
   editAction = new TDEToggleAction( i18n("&Modify"), "edit",
                                   CTRL+Key_Insert, actionCollection(), "edit_modify");
-  connect(editAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT( editModify(bool)));
+  connect(editAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT( editModify(bool)));
 
-  showMenubar = KStdAction::showMenubar(TQT_TQOBJECT(this), TQT_SLOT(toggleMenubar()), actionCollection());
-  KStdAction::saveOptions( TQT_TQOBJECT(this), TQT_SLOT(writeConfig()), actionCollection());
+  showMenubar = KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
+  KStdAction::saveOptions( this, TQT_SLOT(writeConfig()), actionCollection());
 
-  KStdAction::preferences( TQT_TQOBJECT(this), TQT_SLOT(configure()), actionCollection());
+  KStdAction::preferences( this, TQT_SLOT(configure()), actionCollection());
 
   moveSlowAction =  new TDEToggleAction( i18n("&Move Slow"), 0,
                                        actionCollection(), "options_moveSlow");
-  connect(moveSlowAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(optionMoveSlow(bool)));
+  connect(moveSlowAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(optionMoveSlow(bool)));
 
   renderBallsAction =  new TDEToggleAction( i18n("&Render Balls"), 0,
                                           actionCollection(), "options_renderBalls");
-  connect(renderBallsAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(optionRenderBalls(bool)));
+  connect(renderBallsAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(optionRenderBalls(bool)));
 
   showSpyAction =  new TDEToggleAction( i18n("&Spy"), 0,
                                       actionCollection(), "options_showSpy");
-  connect(showSpyAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(optionShowSpy(bool)));
+  connect(showSpyAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(optionShowSpy(bool)));
 
 
   levelAction = KStdGameAction::chooseGameType(0, 0, actionCollection());
@@ -422,7 +422,7 @@ void AbTop::setupStatusBar()
     spyPopup->insertItem(spy2, 2);
     spyPopup->insertItem(spy3, 3);
     connect( spyPopup, TQT_SIGNAL(activated(int)),
-	     TQT_TQOBJECT(this), TQT_SLOT(setSpy(int)) );
+	     this, TQT_SLOT(setSpy(int)) );
     tb->insertButton(spy0, 30, spyPopup,
 			    TRUE, i18n("Spy"));
   }
@@ -801,7 +801,7 @@ void AbTop::gameNetwork(bool on)
     net->addListener(h2, p);
   }
   TQObject::connect(net, TQT_SIGNAL(gotPosition(const char *)),
-		   TQT_TQOBJECT(this), TQT_SLOT(pastePosition(const char *)) );
+		   this, TQT_SLOT(pastePosition(const char *)) );
 }
 
 
diff --git a/kgoldrunner/src/kgoldrunner.cpp b/kgoldrunner/src/kgoldrunner.cpp
index 4362bb5d..ca98b30f 100644
--- a/kgoldrunner/src/kgoldrunner.cpp
+++ b/kgoldrunner/src/kgoldrunner.cpp
@@ -193,7 +193,7 @@ void KGoldrunner::setupActions()
 
     myPause =			KStdGameAction::
 				pause (
-				TQT_TQOBJECT(this), TQT_SLOT(stopStart()), actionCollection());
+				this, TQT_SLOT(stopStart()), actionCollection());
     myPause->			setShortcut (Key_Escape); // Alternate key.
     highScore =			KStdGameAction::
 				highscores (
@@ -214,7 +214,7 @@ void KGoldrunner::setupActions()
 
     (void)			KStdGameAction::
 				quit (
-				TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
+				this, TQT_SLOT(close()), actionCollection());
 
     /**************************************************************************/
     /***************************   GAME EDITOR MENU  **************************/
@@ -228,17 +228,17 @@ void KGoldrunner::setupActions()
     (void)			new TDEAction (
 				i18n("&Create Level"),
 				0,
-				TQT_TQOBJECT(game), TQT_SLOT(createLevel()), actionCollection(),
+				game, TQT_SLOT(createLevel()), actionCollection(),
 				"create");
     (void)			new TDEAction (
 				i18n("&Edit Any Level..."),
 				0,
-				TQT_TQOBJECT(game), TQT_SLOT(updateLevel()), actionCollection(),
+				game, TQT_SLOT(updateLevel()), actionCollection(),
 				"edit_any");
     (void)			new TDEAction (
 				i18n("Edit &Next Level..."),
 				0,
-				TQT_TQOBJECT(game), TQT_SLOT(updateNext()), actionCollection(),
+				game, TQT_SLOT(updateNext()), actionCollection(),
 				"edit_next");
 
     // Save Edits...
@@ -249,19 +249,19 @@ void KGoldrunner::setupActions()
     saveEdits =			new TDEAction (
 				i18n("&Save Edits..."),
 				0,
-				TQT_TQOBJECT(game), TQT_SLOT(saveLevelFile()), actionCollection(),
+				game, TQT_SLOT(saveLevelFile()), actionCollection(),
 				"save_edits");
     saveEdits->setEnabled (FALSE);			// Nothing to save, yet.
 
     (void)			new TDEAction (
 				i18n("&Move Level..."),
 				0,
-				TQT_TQOBJECT(game), TQT_SLOT(moveLevelFile()), actionCollection(),
+				game, TQT_SLOT(moveLevelFile()), actionCollection(),
 				"move_level");
     (void)			new TDEAction (
 				i18n("&Delete Level..."),
 				0,
-				TQT_TQOBJECT(game),
+				game,
 				TQT_SLOT(deleteLevelFile()), actionCollection(),
 				"delete_level");
 
@@ -272,12 +272,12 @@ void KGoldrunner::setupActions()
     (void)			new TDEAction (
 				i18n("Create Game..."),
 				0,
-				TQT_TQOBJECT(this), TQT_SLOT(createGame()), actionCollection(),
+				this, TQT_SLOT(createGame()), actionCollection(),
 				"create_game");
     (void)			new TDEAction (
 				i18n("Edit Game Info..."),
 				0,
-				TQT_TQOBJECT(this),
+				this,
 				TQT_SLOT(editGameInfo()), actionCollection(),
 				"edit_game");
 
@@ -290,27 +290,27 @@ void KGoldrunner::setupActions()
     setKGoldrunner =		new TDERadioAction (
 				"K&Goldrunner",
 				0,			// Default Shift+G
-				TQT_TQOBJECT(this), TQT_SLOT(lsKGoldrunner()), actionCollection(),
+				this, TQT_SLOT(lsKGoldrunner()), actionCollection(),
 				"kgoldrunner");
     setAppleII =		new TDERadioAction (
 				"&Apple II",
 				0,			// Default Shift+A
-				TQT_TQOBJECT(this), TQT_SLOT(lsApple2()), actionCollection(),
+				this, TQT_SLOT(lsApple2()), actionCollection(),
 				"apple_2");
     setIceCave =		new TDERadioAction (
 				i18n("&Ice Cave"),
 				0,			// Default Shift+I
-				TQT_TQOBJECT(this), TQT_SLOT(lsIceCave()), actionCollection(),
+				this, TQT_SLOT(lsIceCave()), actionCollection(),
 				"ice_cave");
     setMidnight =		new TDERadioAction (
 				i18n("&Midnight"),
 				0,			// Default Shift+M
-				TQT_TQOBJECT(this), TQT_SLOT(lsMidnight()), actionCollection(),
+				this, TQT_SLOT(lsMidnight()), actionCollection(),
 				"midnight");
     setKDEKool =		new TDERadioAction (
 				i18n("&TDE Kool"),
 				0,			// Default Shift+K
-				TQT_TQOBJECT(this), TQT_SLOT(lsKDEKool()), actionCollection(),
+				this, TQT_SLOT(lsKDEKool()), actionCollection(),
 				"kde_kool");
 
     setKGoldrunner->		setExclusiveGroup ("landscapes");
@@ -331,13 +331,13 @@ void KGoldrunner::setupActions()
     setMouse =			new TDERadioAction (
 				i18n("&Mouse Controls Hero"),
 				0,
-				TQT_TQOBJECT(this),
+				this,
 				TQT_SLOT(setMouseMode()), actionCollection(),
 				"mouse_mode");
     setKeyboard =		new TDERadioAction (
 				i18n("&Keyboard Controls Hero"),
 				0,
-				TQT_TQOBJECT(this),
+				this,
 				TQT_SLOT(setKeyBoardMode()), actionCollection(),
 				"keyboard_mode");
 
@@ -355,27 +355,27 @@ void KGoldrunner::setupActions()
     TDERadioAction * nSpeed =	new TDERadioAction (
 				i18n("Normal Speed"),
 				0,
-				TQT_TQOBJECT(this), TQT_SLOT(normalSpeed()), actionCollection(),
+				this, TQT_SLOT(normalSpeed()), actionCollection(),
 				"normal_speed");
     TDERadioAction * bSpeed =	new TDERadioAction (
 				i18n("Beginner Speed"),
 				0,
-				TQT_TQOBJECT(this), TQT_SLOT(beginSpeed()), actionCollection(),
+				this, TQT_SLOT(beginSpeed()), actionCollection(),
 				"beginner_speed");
     TDERadioAction * cSpeed =	new TDERadioAction (
 				i18n("Champion Speed"),
 				0,
-				TQT_TQOBJECT(this), TQT_SLOT(champSpeed()), actionCollection(),
+				this, TQT_SLOT(champSpeed()), actionCollection(),
 				"champion_speed");
     (void)			new TDEAction (		// Repeatable action.
 				i18n("Increase Speed"),
 				Key_Plus,
-				TQT_TQOBJECT(this), TQT_SLOT(incSpeed()), actionCollection(),
+				this, TQT_SLOT(incSpeed()), actionCollection(),
 				"increase_speed");
     (void)			new TDEAction (		// Repeatable action.
 				i18n("Decrease Speed"),
 				Key_Minus,
-				TQT_TQOBJECT(this), TQT_SLOT(decSpeed()), actionCollection(),
+				this, TQT_SLOT(decSpeed()), actionCollection(),
 				"decrease_speed");
 
     nSpeed->			setExclusiveGroup ("speed");
@@ -390,12 +390,12 @@ void KGoldrunner::setupActions()
     tradRules =			new TDERadioAction (
 				i18n("&Traditional Rules"),
 				0,
-				TQT_TQOBJECT(this), TQT_SLOT(setTradRules()), actionCollection(),
+				this, TQT_SLOT(setTradRules()), actionCollection(),
 				"trad_rules");
     kgrRules =			new TDERadioAction (
 				i18n("K&Goldrunner Rules"),
 				0,
-				TQT_TQOBJECT(this), TQT_SLOT(setKGrRules()), actionCollection(),
+				this, TQT_SLOT(setKGrRules()), actionCollection(),
 				"kgr_rules");
 
     tradRules->			setExclusiveGroup ("rules");
@@ -409,12 +409,12 @@ void KGoldrunner::setupActions()
     (void)			new TDEAction (
 				i18n("Larger Playing Area"),
 				0,
-				TQT_TQOBJECT(this), TQT_SLOT(makeLarger()), actionCollection(),
+				this, TQT_SLOT(makeLarger()), actionCollection(),
 				"larger_area");
     (void)			new TDEAction (
 				i18n("Smaller Playing Area"),
 				0,
-				TQT_TQOBJECT(this), TQT_SLOT(makeSmaller()), actionCollection(),
+				this, TQT_SLOT(makeSmaller()), actionCollection(),
 				"smaller_area");
 
     // Configure Shortcuts...
@@ -422,7 +422,7 @@ void KGoldrunner::setupActions()
     // --------------------------
 
     KStdAction::keyBindings (
-				TQT_TQOBJECT(this), TQT_SLOT(optionsConfigureKeys()),
+				this, TQT_SLOT(optionsConfigureKeys()),
 				actionCollection());
     // KStdAction::configureToolbars (
 				// this, TQT_SLOT(optionsConfigureToolbars()),
@@ -435,19 +435,19 @@ void KGoldrunner::setupActions()
     // Two-handed KB controls and alternate one-handed controls for the hero.
 
     (void)	new TDEAction (i18n("Move Up"), Key_Up,
-		TQT_TQOBJECT(this), TQT_SLOT(goUp()), actionCollection(), "move_up");
+		this, TQT_SLOT(goUp()), actionCollection(), "move_up");
     (void)	new TDEAction (i18n("Move Right"), Key_Right,
-		TQT_TQOBJECT(this), TQT_SLOT(goR()), actionCollection(), "move_right");
+		this, TQT_SLOT(goR()), actionCollection(), "move_right");
     (void)	new TDEAction (i18n("Move Down"), Key_Down,
-		TQT_TQOBJECT(this), TQT_SLOT(goDown()), actionCollection(), "move_down");
+		this, TQT_SLOT(goDown()), actionCollection(), "move_down");
     (void)	new TDEAction (i18n("Move Left"), Key_Left,
-		TQT_TQOBJECT(this), TQT_SLOT(goL()), actionCollection(), "move_left");
+		this, TQT_SLOT(goL()), actionCollection(), "move_left");
     (void)	new TDEAction (i18n("Stop"), Key_Space,
-		TQT_TQOBJECT(this), TQT_SLOT(stop()), actionCollection(), "stop");
+		this, TQT_SLOT(stop()), actionCollection(), "stop");
     (void)	new TDEAction (i18n("Dig Right"), Key_C,
-		TQT_TQOBJECT(this), TQT_SLOT(digR()), actionCollection(), "dig_right");
+		this, TQT_SLOT(digR()), actionCollection(), "dig_right");
     (void)	new TDEAction (i18n("Dig Left"), Key_Z,
-		TQT_TQOBJECT(this), TQT_SLOT(digL()), actionCollection(), "dig_left");
+		this, TQT_SLOT(digL()), actionCollection(), "dig_left");
 
     // Alternate one-handed controls.  Set up in "kgoldrunnerui.rc".
 
@@ -1015,34 +1015,34 @@ void KGoldrunner::makeEditToolbar()
     editToolbar->insertSeparator();
     editToolbar->insertSeparator();
 
-    editToolbar->insertButton (freebg,    (int)FREE,    TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (freebg,    (int)FREE,    TQT_SIGNAL(clicked()), this,
 		TQT_SLOT(freeSlot()),     TRUE,  i18n("Empty space"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (edherobg,  (int)HERO,    TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (edherobg,  (int)HERO,    TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (edheroSlot()),  TRUE,  i18n("Hero"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (edenemybg, (int)ENEMY,   TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (edenemybg, (int)ENEMY,   TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (edenemySlot()), TRUE,  i18n("Enemy"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (brickbg,   (int)BRICK,   TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (brickbg,   (int)BRICK,   TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (brickSlot()),   TRUE,  i18n("Brick (can dig)"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (betonbg,   (int)BETON,   TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (betonbg,   (int)BETON,   TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (betonSlot()),   TRUE,  i18n("Concrete (cannot dig)"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (fbrickbg,  (int)FBRICK,  TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (fbrickbg,  (int)FBRICK,  TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (fbrickSlot()),  TRUE,  i18n("Trap (can fall through)"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (ladderbg,  (int)LADDER,  TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (ladderbg,  (int)LADDER,  TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (ladderSlot()),  TRUE,  i18n("Ladder"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (hladderbg, (int)HLADDER, TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (hladderbg, (int)HLADDER, TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (hladderSlot()), TRUE,  i18n("Hidden ladder"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (polebg,    (int)POLE,    TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (polebg,    (int)POLE,    TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (poleSlot()),    TRUE,  i18n("Pole (or bar)"));
     editToolbar->insertSeparator();
-    editToolbar->insertButton (nuggetbg,  (int)NUGGET,  TQT_SIGNAL(clicked()), TQT_TQOBJECT(this),
+    editToolbar->insertButton (nuggetbg,  (int)NUGGET,  TQT_SIGNAL(clicked()), this,
 		TQT_SLOT (nuggetSlot()),  TRUE,  i18n("Gold nugget"));
 
     editToolbar->setToggle ((int) FREE,    TRUE);
diff --git a/kjumpingcube/kjumpingcube.cpp b/kjumpingcube/kjumpingcube.cpp
index 6981b449..42eea056 100644
--- a/kjumpingcube/kjumpingcube.cpp
+++ b/kjumpingcube/kjumpingcube.cpp
@@ -76,19 +76,19 @@ KJumpingCube::KJumpingCube()
 }
 
 void KJumpingCube::initTDEAction() {
-  KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(newGame()), actionCollection());
-  KStdGameAction::load(TQT_TQOBJECT(this), TQT_SLOT(openGame()), actionCollection());
-  KStdGameAction::save(TQT_TQOBJECT(this), TQT_SLOT(save()), actionCollection());
-  KStdGameAction::saveAs(TQT_TQOBJECT(this), TQT_SLOT(saveAs()), actionCollection());
-  KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
+  KStdGameAction::gameNew(this, TQT_SLOT(newGame()), actionCollection());
+  KStdGameAction::load(this, TQT_SLOT(openGame()), actionCollection());
+  KStdGameAction::save(this, TQT_SLOT(save()), actionCollection());
+  KStdGameAction::saveAs(this, TQT_SLOT(saveAs()), actionCollection());
+  KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
 
-  hintAction = KStdGameAction::hint(TQT_TQOBJECT(view), TQT_SLOT(getHint()), actionCollection());
+  hintAction = KStdGameAction::hint(view, TQT_SLOT(getHint()), actionCollection());
   stopAction = new TDEAction(i18n("Stop &Thinking"), "process-stop",
-  TQt::Key_Escape, TQT_TQOBJECT(this), TQT_SLOT(stop()), actionCollection(), "game_stop");
+  TQt::Key_Escape, this, TQT_SLOT(stop()), actionCollection(), "game_stop");
   stopAction->setEnabled(false);
-  undoAction = KStdGameAction::undo(TQT_TQOBJECT(this), TQT_SLOT(undo()), actionCollection());
+  undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
   undoAction->setEnabled(false);
-  KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(showOptions()), actionCollection());
+  KStdAction::preferences(this, TQT_SLOT(showOptions()), actionCollection());
 
   setupGUI();
 }
diff --git a/klines/klines.cpp b/klines/klines.cpp
index b874679f..43d60835 100644
--- a/klines/klines.cpp
+++ b/klines/klines.cpp
@@ -64,10 +64,10 @@ KLines::KLines()
   setCentralWidget( mwidget );
 
   lsb = mwidget->GetLsb();
-  connect(lsb, TQT_SIGNAL(endTurn()), TQT_TQOBJECT(this), TQT_SLOT(makeTurn()));
-  connect(lsb, TQT_SIGNAL(eraseLine(int)), TQT_TQOBJECT(this), TQT_SLOT(addScore(int)));
-  connect(lsb, TQT_SIGNAL(endGame()), TQT_TQOBJECT(this), TQT_SLOT(endGame()));
-  connect(lsb, TQT_SIGNAL(userTurn()), TQT_TQOBJECT(this), TQT_SLOT(userTurn()));
+  connect(lsb, TQT_SIGNAL(endTurn()), this, TQT_SLOT(makeTurn()));
+  connect(lsb, TQT_SIGNAL(eraseLine(int)), this, TQT_SLOT(addScore(int)));
+  connect(lsb, TQT_SIGNAL(endGame()), this, TQT_SLOT(endGame()));
+  connect(lsb, TQT_SIGNAL(userTurn()), this, TQT_SLOT(userTurn()));
 
   lPrompt = mwidget->GetPrompt();
 
@@ -82,7 +82,7 @@ KLines::KLines()
  
   initTDEAction();
 
-  connect(&demoTimer, TQT_SIGNAL(timeout()), TQT_TQOBJECT(this), TQT_SLOT(slotDemo()));
+  connect(&demoTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotDemo()));
 
   setFocusPolicy(TQWidget::StrongFocus);
   setFocus();
@@ -104,18 +104,18 @@ KLines::~KLines()
 */
 void KLines::initTDEAction()
 {
-  KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(startGame()), actionCollection());
-  act_demo = KStdGameAction::demo(TQT_TQOBJECT(this), TQT_SLOT(startDemo()), actionCollection());
+  KStdGameAction::gameNew(this, TQT_SLOT(startGame()), actionCollection());
+  act_demo = KStdGameAction::demo(this, TQT_SLOT(startDemo()), actionCollection());
   act_demo->setText(i18n("Start &Tutorial"));
-  KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(viewHighScore()), actionCollection());
-  KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
-  endTurnAction = KStdGameAction::endTurn(TQT_TQOBJECT(this), TQT_SLOT(makeTurn()), actionCollection());
+  KStdGameAction::highscores(this, TQT_SLOT(viewHighScore()), actionCollection());
+  KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
+  endTurnAction = KStdGameAction::endTurn(this, TQT_SLOT(makeTurn()), actionCollection());
   showNextAction = new TDEToggleAction(i18n("&Show Next"), TDEShortcut(CTRL+Key_P),
-                                TQT_TQOBJECT(this), TQT_SLOT(switchPrompt()), actionCollection(), "options_show_next");
+                                this, TQT_SLOT(switchPrompt()), actionCollection(), "options_show_next");
   showNextAction->setCheckedState(i18n("Hide Next"));
   showNumberedAction = new TDEToggleAction(i18n("&Use Numbered Balls"), TDEShortcut(),
-                                TQT_TQOBJECT(this), TQT_SLOT(switchNumbered()), actionCollection(), "options_show_numbered");
-  undoAction = KStdGameAction::undo(TQT_TQOBJECT(this), TQT_SLOT(undo()), actionCollection());
+                                this, TQT_SLOT(switchNumbered()), actionCollection(), "options_show_numbered");
+  undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
 
   levelAction = KStdGameAction::chooseGameType(0, 0, actionCollection());
   TQStringList items;
@@ -128,11 +128,11 @@ void KLines::initTDEAction()
   showNumberedAction->setChecked(Prefs::numberedBalls());
   lPrompt->setPrompt(Prefs::showNext());
 
-  (void)new TDEAction(i18n("Move Left"), Key_Left, TQT_TQOBJECT(lsb), TQT_SLOT(moveLeft()), actionCollection(), "left");
-  (void)new TDEAction(i18n("Move Right"), Key_Right, TQT_TQOBJECT(lsb), TQT_SLOT(moveRight()), actionCollection(), "right");
-  (void)new TDEAction(i18n("Move Up"), Key_Up, TQT_TQOBJECT(lsb), TQT_SLOT(moveUp()), actionCollection(), "up");
-  (void)new TDEAction(i18n("Move Down"), Key_Down, TQT_TQOBJECT(lsb), TQT_SLOT(moveDown()), actionCollection(), "down");
-  (void)new TDEAction(i18n("Move Ball"), Key_Space, TQT_TQOBJECT(lsb), TQT_SLOT(placePlayerBall()), actionCollection(), "place_ball");
+  (void)new TDEAction(i18n("Move Left"), Key_Left, lsb, TQT_SLOT(moveLeft()), actionCollection(), "left");
+  (void)new TDEAction(i18n("Move Right"), Key_Right, lsb, TQT_SLOT(moveRight()), actionCollection(), "right");
+  (void)new TDEAction(i18n("Move Up"), Key_Up, lsb, TQT_SLOT(moveUp()), actionCollection(), "up");
+  (void)new TDEAction(i18n("Move Down"), Key_Down, lsb, TQT_SLOT(moveDown()), actionCollection(), "down");
+  (void)new TDEAction(i18n("Move Ball"), Key_Space, lsb, TQT_SLOT(placePlayerBall()), actionCollection(), "place_ball");
 
   setupGUI( TDEMainWindow::Save | Keys | StatusBar | Create );
 }
diff --git a/kmahjongg/kmahjongg.cpp b/kmahjongg/kmahjongg.cpp
index 8edf7b6c..57f43512 100644
--- a/kmahjongg/kmahjongg.cpp
+++ b/kmahjongg/kmahjongg.cpp
@@ -128,41 +128,41 @@ KMahjongg::~KMahjongg()
 void KMahjongg::setupTDEAction()
 {
     // game
-    KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(newGame()), actionCollection());
-    KStdGameAction::load(TQT_TQOBJECT(this), TQT_SLOT(loadGame()), actionCollection());
-    KStdGameAction::save(TQT_TQOBJECT(this), TQT_SLOT(saveGame()), actionCollection());
-    KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
-    KStdGameAction::restart(TQT_TQOBJECT(this), TQT_SLOT(restartGame()), actionCollection());
-    new TDEAction(i18n("New Numbered Game..."), "newnum", 0, TQT_TQOBJECT(this), TQT_SLOT(startNewNumeric()), actionCollection(), "game_new_numeric");
-    new TDEAction(i18n("Open Th&eme..."), 0, TQT_TQOBJECT(this), TQT_SLOT(openTheme()), actionCollection(), "game_open_theme");
-    new TDEAction(i18n("Open &Tileset..."), 0, TQT_TQOBJECT(this), TQT_SLOT(openTileset()), actionCollection(), "game_open_tileset");
-    new TDEAction(i18n("Open &Background..."), 0, TQT_TQOBJECT(this), TQT_SLOT(openBackground()), actionCollection(), "game_open_background");
-    new TDEAction(i18n("Open La&yout..."), 0, TQT_TQOBJECT(this), TQT_SLOT(openLayout()), actionCollection(), "game_open_layout");
-    new TDEAction(i18n("Sa&ve Theme..."), 0, TQT_TQOBJECT(this), TQT_SLOT(saveTheme()), actionCollection(), "game_save_theme");
+    KStdGameAction::gameNew(this, TQT_SLOT(newGame()), actionCollection());
+    KStdGameAction::load(this, TQT_SLOT(loadGame()), actionCollection());
+    KStdGameAction::save(this, TQT_SLOT(saveGame()), actionCollection());
+    KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
+    KStdGameAction::restart(this, TQT_SLOT(restartGame()), actionCollection());
+    new TDEAction(i18n("New Numbered Game..."), "newnum", 0, this, TQT_SLOT(startNewNumeric()), actionCollection(), "game_new_numeric");
+    new TDEAction(i18n("Open Th&eme..."), 0, this, TQT_SLOT(openTheme()), actionCollection(), "game_open_theme");
+    new TDEAction(i18n("Open &Tileset..."), 0, this, TQT_SLOT(openTileset()), actionCollection(), "game_open_tileset");
+    new TDEAction(i18n("Open &Background..."), 0, this, TQT_SLOT(openBackground()), actionCollection(), "game_open_background");
+    new TDEAction(i18n("Open La&yout..."), 0, this, TQT_SLOT(openLayout()), actionCollection(), "game_open_layout");
+    new TDEAction(i18n("Sa&ve Theme..."), 0, this, TQT_SLOT(saveTheme()), actionCollection(), "game_save_theme");
     // originally "file" ends here
-    KStdGameAction::hint(TQT_TQOBJECT(bw), TQT_SLOT(helpMove()), actionCollection());
-    new TDEAction(i18n("Shu&ffle"), "reload", 0, TQT_TQOBJECT(bw), TQT_SLOT(shuffle()), actionCollection(), "move_shuffle");
-    demoAction = KStdGameAction::demo(TQT_TQOBJECT(this), TQT_SLOT(demoMode()), actionCollection());
-    showMatchingTilesAction = new TDEToggleAction(i18n("Show &Matching Tiles"), 0, TQT_TQOBJECT(this), TQT_SLOT(showMatchingTiles()), actionCollection(), "options_show_matching_tiles");
+    KStdGameAction::hint(bw, TQT_SLOT(helpMove()), actionCollection());
+    new TDEAction(i18n("Shu&ffle"), "reload", 0, bw, TQT_SLOT(shuffle()), actionCollection(), "move_shuffle");
+    demoAction = KStdGameAction::demo(this, TQT_SLOT(demoMode()), actionCollection());
+    showMatchingTilesAction = new TDEToggleAction(i18n("Show &Matching Tiles"), 0, this, TQT_SLOT(showMatchingTiles()), actionCollection(), "options_show_matching_tiles");
     showMatchingTilesAction->setCheckedState(i18n("Hide &Matching Tiles"));
     showMatchingTilesAction->setChecked(Prefs::showMatchingTiles());
     bw->setShowMatch( Prefs::showMatchingTiles() );
-    KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighscores()), actionCollection());
-    pauseAction = KStdGameAction::pause(TQT_TQOBJECT(this), TQT_SLOT(pause()), actionCollection());
+    KStdGameAction::highscores(this, TQT_SLOT(showHighscores()), actionCollection());
+    pauseAction = KStdGameAction::pause(this, TQT_SLOT(pause()), actionCollection());
 
     // TODO: store the background ; open on startup
     // TODO: same about layout
     // TODO: same about theme
 
     // move
-    undoAction = KStdGameAction::undo(TQT_TQOBJECT(this), TQT_SLOT(undo()), actionCollection());
-    redoAction = KStdGameAction::redo(TQT_TQOBJECT(this), TQT_SLOT(redo()), actionCollection());
+    undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
+    redoAction = KStdGameAction::redo(this, TQT_SLOT(redo()), actionCollection());
 
     // edit
-    new TDEAction(i18n("&Board Editor"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotBoardEditor()), actionCollection(), "edit_board_editor");
+    new TDEAction(i18n("&Board Editor"), 0, this, TQT_SLOT(slotBoardEditor()), actionCollection(), "edit_board_editor");
 
     // settings
-    KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(showSettings()), actionCollection());
+    KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
     
     setupGUI();
 }
@@ -239,7 +239,7 @@ void KMahjongg::showSettings(){
   TDEConfigDialog *dialog = new TDEConfigDialog(this, "settings", Prefs::self(), KDialogBase::Swallow);
   dialog->addPage(new Settings(0, "General"), i18n("General"), "package_settings");
   connect(dialog, TQT_SIGNAL(settingsChanged()), bw, TQT_SLOT(loadSettings()));
-  connect(dialog, TQT_SIGNAL(settingsChanged()), TQT_TQOBJECT(this), TQT_SLOT(setDisplayedWidth()));
+  connect(dialog, TQT_SIGNAL(settingsChanged()), this, TQT_SLOT(setDisplayedWidth()));
   dialog->show();
 }
 
diff --git a/kmines/kzoommainwindow.cpp b/kmines/kzoommainwindow.cpp
index 758d73d6..c0c7fc92 100644
--- a/kmines/kzoommainwindow.cpp
+++ b/kmines/kzoommainwindow.cpp
@@ -30,11 +30,11 @@ KZoomMainWindow::KZoomMainWindow(uint min, uint max, uint step, const char *name
 {
   installEventFilter(this);
   
-  _zoomInAction = KStdAction::zoomIn(TQT_TQOBJECT(this), TQT_SLOT(zoomIn()), actionCollection());
+  _zoomInAction = KStdAction::zoomIn(this, TQT_SLOT(zoomIn()), actionCollection());
   _zoomOutAction =
-    KStdAction::zoomOut(TQT_TQOBJECT(this), TQT_SLOT(zoomOut()), actionCollection());
+    KStdAction::zoomOut(this, TQT_SLOT(zoomOut()), actionCollection());
   _menu =
-    KStdAction::showMenubar(TQT_TQOBJECT(this), TQT_SLOT(toggleMenubar()), actionCollection());
+    KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
 }
 
 void KZoomMainWindow::init(const char *popupName)
diff --git a/kmines/main.cpp b/kmines/main.cpp
index fe39f052..f4dd0210 100644
--- a/kmines/main.cpp
+++ b/kmines/main.cpp
@@ -68,28 +68,28 @@ MainWidget::MainWidget()
     connect(_status, TQT_SIGNAL(pause()), TQT_SLOT(pause()));
 
 	// Game & Popup
-	KStdGameAction::gameNew(TQT_TQOBJECT(_status), TQT_SLOT(restartGame()), actionCollection());
-	_pause = KStdGameAction::pause(TQT_TQOBJECT(_status), TQT_SLOT(pauseGame()),
+	KStdGameAction::gameNew(_status, TQT_SLOT(restartGame()), actionCollection());
+	_pause = KStdGameAction::pause(_status, TQT_SLOT(pauseGame()),
                                   actionCollection());
-	KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighscores()),
+	KStdGameAction::highscores(this, TQT_SLOT(showHighscores()),
                                actionCollection());
-	KStdGameAction::quit(TQT_TQOBJECT(tqApp), TQT_SLOT(quit()), actionCollection());
+	KStdGameAction::quit(tqApp, TQT_SLOT(quit()), actionCollection());
 
 	// keyboard
     _keybCollection = new TDEActionCollection(this);
     for (uint i=0; i<NB_KEYS; i++) {
         const KeyData &d = KEY_DATA[i];
-        (void)new TDEAction(i18n(d.label), d.keycode, TQT_TQOBJECT(_status),
+        (void)new TDEAction(i18n(d.label), d.keycode, _status,
                           d.slot, _keybCollection, d.name);
     }
 
 	// Settings
-	KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(configureSettings()),
+	KStdAction::preferences(this, TQT_SLOT(configureSettings()),
                             actionCollection());
-	KStdAction::keyBindings(TQT_TQOBJECT(this), TQT_SLOT(configureKeys()), actionCollection());
-    KStdAction::configureNotifications(TQT_TQOBJECT(this), TQT_SLOT(configureNotifications()),
+	KStdAction::keyBindings(this, TQT_SLOT(configureKeys()), actionCollection());
+    KStdAction::configureNotifications(this, TQT_SLOT(configureNotifications()),
                                        actionCollection());
-    KStdGameAction::configureHighscores(TQT_TQOBJECT(this), TQT_SLOT(configureHighscores()),
+    KStdGameAction::configureHighscores(this, TQT_SLOT(configureHighscores()),
                                         actionCollection());
 	// Levels
     _levels = KStdGameAction::chooseGameType(0, 0, actionCollection());
@@ -97,27 +97,27 @@ MainWidget::MainWidget()
     for (uint i=0; i<=Level::NB_TYPES; i++)
         list += i18n(Level::LABELS[i]);
     _levels->setItems(list);
-    connect(_levels, TQT_SIGNAL(activated(int)), TQT_TQOBJECT(_status), TQT_SLOT(newGame(int)));
+    connect(_levels, TQT_SIGNAL(activated(int)), _status, TQT_SLOT(newGame(int)));
 
     // Adviser
     _advise =
-        KStdGameAction::hint(TQT_TQOBJECT(_status), TQT_SLOT(advise()), actionCollection());
-    _solve = KStdGameAction::solve(TQT_TQOBJECT(_status), TQT_SLOT(solve()), actionCollection());
-    (void)new TDEAction(i18n("Solving Rate..."), 0, TQT_TQOBJECT(_status), TQT_SLOT(solveRate()),
+        KStdGameAction::hint(_status, TQT_SLOT(advise()), actionCollection());
+    _solve = KStdGameAction::solve(_status, TQT_SLOT(solve()), actionCollection());
+    (void)new TDEAction(i18n("Solving Rate..."), 0, _status, TQT_SLOT(solveRate()),
                       actionCollection(), "solve_rate");
 
     // Log
     (void)new TDEAction(KGuiItem(i18n("View Log"), "viewmag"), 0,
-                      TQT_TQOBJECT(_status), TQT_SLOT(viewLog()),
+                      _status, TQT_SLOT(viewLog()),
                       actionCollection(), "log_view");
     (void)new TDEAction(KGuiItem(i18n("Replay Log"), "media-playback-start"),
-                      0, TQT_TQOBJECT(_status), TQT_SLOT(replayLog()),
+                      0, _status, TQT_SLOT(replayLog()),
                       actionCollection(), "log_replay");
     (void)new TDEAction(KGuiItem(i18n("Save Log..."), "document-save"), 0,
-                      TQT_TQOBJECT(_status), TQT_SLOT(saveLog()),
+                      _status, TQT_SLOT(saveLog()),
                       actionCollection(), "log_save");
     (void)new TDEAction(KGuiItem(i18n("Load Log..."), "document-open"), 0,
-                      TQT_TQOBJECT(_status), TQT_SLOT(loadLog()),
+                      _status, TQT_SLOT(loadLog()),
                       actionCollection(), "log_load");
 
 	setupGUI( TDEMainWindow::Save | Create );
diff --git a/kmines/status.cpp b/kmines/status.cpp
index 0cc7da39..5272e68b 100644
--- a/kmines/status.cpp
+++ b/kmines/status.cpp
@@ -51,7 +51,7 @@ Status::Status(TQWidget *parent)
     _timer  = new TQTimer(this);
     connect(_timer, TQT_SIGNAL(timeout()), TQT_SLOT(replayStep()));
 
-    _solver = new Solver(TQT_TQOBJECT(this));
+    _solver = new Solver(this);
     connect(_solver, TQT_SIGNAL(solvingDone(bool)), TQT_SLOT(solvingDone(bool)));
 
 // top layout
diff --git a/knetwalk/src/mainwindow.cpp b/knetwalk/src/mainwindow.cpp
index 13007ea6..7abf5c77 100644
--- a/knetwalk/src/mainwindow.cpp
+++ b/knetwalk/src/mainwindow.cpp
@@ -64,11 +64,11 @@ MainWindow::MainWindow(TQWidget *parent, const char* name, WFlags /*fl*/) :
 
 	KNotifyClient::startDaemon();
 	
-	KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(slotNewGame()), actionCollection());
+	KStdGameAction::gameNew(this, TQT_SLOT(slotNewGame()), actionCollection());
 	
-	KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighscores()), actionCollection());
-	KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
-	KStdGameAction::configureHighscores(TQT_TQOBJECT(this), TQT_SLOT(configureHighscores()), actionCollection());
+	KStdGameAction::highscores(this, TQT_SLOT(showHighscores()), actionCollection());
+	KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
+	KStdGameAction::configureHighscores(this, TQT_SLOT(configureHighscores()), actionCollection());
 
 	m_levels = KStdGameAction::chooseGameType(0, 0, actionCollection());
 	TQStringList lst;
diff --git a/kolf/game.cpp b/kolf/game.cpp
index e29e9932..d2b61221 100644
--- a/kolf/game.cpp
+++ b/kolf/game.cpp
@@ -2202,7 +2202,7 @@ KolfGame::KolfGame(ObjectList *obj, PlayerList *players, TQString filename, TQWi
 
 	setMargins(margin, margin, margin, margin);
 
-	course = new TQCanvas(TQT_TQOBJECT(this));
+	course = new TQCanvas(this);
 	course->setBackgroundColor(white);
 	course->resize(width, height);
 
diff --git a/kolf/kolf.cpp b/kolf/kolf.cpp
index a68a1c9e..7151a197 100644
--- a/kolf/kolf.cpp
+++ b/kolf/kolf.cpp
@@ -79,75 +79,75 @@ Kolf::~Kolf()
 
 void Kolf::initGUI()
 {
-	newAction = KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(newGame()), actionCollection());
+	newAction = KStdGameAction::gameNew(this, TQT_SLOT(newGame()), actionCollection());
 	newAction->setText(newAction->text() + TQString("..."));
 
-	endAction = KStdGameAction::end(TQT_TQOBJECT(this), TQT_SLOT(closeGame()), actionCollection());
-	printAction = KStdGameAction::print(TQT_TQOBJECT(this), TQT_SLOT(print()), actionCollection());
+	endAction = KStdGameAction::end(this, TQT_SLOT(closeGame()), actionCollection());
+	printAction = KStdGameAction::print(this, TQT_SLOT(print()), actionCollection());
 
-	(void) KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
-	saveAction = KStdAction::save(TQT_TQOBJECT(this), TQT_SLOT(save()), actionCollection(), "game_save");
+	(void) KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
+	saveAction = KStdAction::save(this, TQT_SLOT(save()), actionCollection(), "game_save");
 	saveAction->setText(i18n("Save &Course"));
-	saveAsAction = KStdAction::saveAs(TQT_TQOBJECT(this), TQT_SLOT(saveAs()), actionCollection(), "game_save_as");
+	saveAsAction = KStdAction::saveAs(this, TQT_SLOT(saveAs()), actionCollection(), "game_save_as");
 	saveAsAction->setText(i18n("Save &Course As..."));
 
-	saveGameAction = new TDEAction(i18n("&Save Game"), 0, TQT_TQOBJECT(this), TQT_SLOT(saveGame()), actionCollection(), "savegame");
-	saveGameAsAction = new TDEAction(i18n("&Save Game As..."), 0, TQT_TQOBJECT(this), TQT_SLOT(saveGameAs()), actionCollection(), "savegameas");
+	saveGameAction = new TDEAction(i18n("&Save Game"), 0, this, TQT_SLOT(saveGame()), actionCollection(), "savegame");
+	saveGameAsAction = new TDEAction(i18n("&Save Game As..."), 0, this, TQT_SLOT(saveGameAs()), actionCollection(), "savegameas");
 
-	loadGameAction = KStdGameAction::load(TQT_TQOBJECT(this), TQT_SLOT(loadGame()), actionCollection());
+	loadGameAction = KStdGameAction::load(this, TQT_SLOT(loadGame()), actionCollection());
 	loadGameAction->setText(i18n("Load Saved Game..."));
 
-	highScoreAction = KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighScores()), actionCollection());
+	highScoreAction = KStdGameAction::highscores(this, TQT_SLOT(showHighScores()), actionCollection());
 
-	editingAction = new TDEToggleAction(i18n("&Edit"), "pencil", CTRL+Key_E, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "editing");
-	newHoleAction = new TDEAction(i18n("&New"), "document-new", CTRL+SHIFT+Key_N, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "newhole");
-	clearHoleAction = new TDEAction(KStdGuiItem::clear().text(), "locationbar_erase", CTRL+Key_Delete, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "clearhole");
-	resetHoleAction = new TDEAction(i18n("&Reset"), CTRL+Key_R, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "resethole");
-	undoShotAction = KStdAction::undo(TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "undoshot");
+	editingAction = new TDEToggleAction(i18n("&Edit"), "pencil", CTRL+Key_E, this, TQT_SLOT(emptySlot()), actionCollection(), "editing");
+	newHoleAction = new TDEAction(i18n("&New"), "document-new", CTRL+SHIFT+Key_N, this, TQT_SLOT(emptySlot()), actionCollection(), "newhole");
+	clearHoleAction = new TDEAction(KStdGuiItem::clear().text(), "locationbar_erase", CTRL+Key_Delete, this, TQT_SLOT(emptySlot()), actionCollection(), "clearhole");
+	resetHoleAction = new TDEAction(i18n("&Reset"), CTRL+Key_R, this, TQT_SLOT(emptySlot()), actionCollection(), "resethole");
+	undoShotAction = KStdAction::undo(this, TQT_SLOT(emptySlot()), actionCollection(), "undoshot");
 	undoShotAction->setText(i18n("&Undo Shot"));
-	//replayShotAction = new TDEAction(i18n("&Replay Shot"), 0, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "replay");
+	//replayShotAction = new TDEAction(i18n("&Replay Shot"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "replay");
 
-	holeAction = new TDEListAction(i18n("Switch to Hole"), 0, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "switchhole");
-	nextAction = new TDEAction(i18n("&Next Hole"), "forward", TDEStdAccel::shortcut(TDEStdAccel::Forward), TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "nexthole");
-	prevAction = new TDEAction(i18n("&Previous Hole"), "back", TDEStdAccel::shortcut(TDEStdAccel::Back), TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "prevhole");
-	firstAction = new TDEAction(i18n("&First Hole"), "go-home", TDEStdAccel::shortcut(TDEStdAccel::Home), TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "firsthole");
-	lastAction = new TDEAction(i18n("&Last Hole"), CTRL+SHIFT+Key_End, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "lasthole");
-	randAction = new TDEAction(i18n("&Random Hole"), "goto", 0, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "randhole");
+	holeAction = new TDEListAction(i18n("Switch to Hole"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "switchhole");
+	nextAction = new TDEAction(i18n("&Next Hole"), "forward", TDEStdAccel::shortcut(TDEStdAccel::Forward), this, TQT_SLOT(emptySlot()), actionCollection(), "nexthole");
+	prevAction = new TDEAction(i18n("&Previous Hole"), "back", TDEStdAccel::shortcut(TDEStdAccel::Back), this, TQT_SLOT(emptySlot()), actionCollection(), "prevhole");
+	firstAction = new TDEAction(i18n("&First Hole"), "go-home", TDEStdAccel::shortcut(TDEStdAccel::Home), this, TQT_SLOT(emptySlot()), actionCollection(), "firsthole");
+	lastAction = new TDEAction(i18n("&Last Hole"), CTRL+SHIFT+Key_End, this, TQT_SLOT(emptySlot()), actionCollection(), "lasthole");
+	randAction = new TDEAction(i18n("&Random Hole"), "goto", 0, this, TQT_SLOT(emptySlot()), actionCollection(), "randhole");
 
-	useMouseAction = new TDEToggleAction(i18n("Enable &Mouse for Moving Putter"), 0, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "usemouse");
+	useMouseAction = new TDEToggleAction(i18n("Enable &Mouse for Moving Putter"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "usemouse");
 	useMouseAction->setCheckedState(i18n("Disable &Mouse for Moving Putter"));
-	connect(useMouseAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(useMouseChanged(bool)));
+	connect(useMouseAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(useMouseChanged(bool)));
 	TDEConfig *config = kapp->config();
 	config->setGroup("Settings");
 	useMouseAction->setChecked(config->readBoolEntry("useMouse", true));
 
-	useAdvancedPuttingAction = new TDEToggleAction(i18n("Enable &Advanced Putting"), 0, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "useadvancedputting");
+	useAdvancedPuttingAction = new TDEToggleAction(i18n("Enable &Advanced Putting"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "useadvancedputting");
 	useAdvancedPuttingAction->setCheckedState(i18n("Disable &Advanced Putting"));
-	connect(useAdvancedPuttingAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(useAdvancedPuttingChanged(bool)));
+	connect(useAdvancedPuttingAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(useAdvancedPuttingChanged(bool)));
 	useAdvancedPuttingAction->setChecked(config->readBoolEntry("useAdvancedPutting", false));
 
-	showInfoAction = new TDEToggleAction(i18n("Show &Info"), "application-vnd.tde.info", CTRL+Key_I, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "showinfo");
+	showInfoAction = new TDEToggleAction(i18n("Show &Info"), "application-vnd.tde.info", CTRL+Key_I, this, TQT_SLOT(emptySlot()), actionCollection(), "showinfo");
 	showInfoAction->setCheckedState(i18n("Hide &Info"));
-	connect(showInfoAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(showInfoChanged(bool)));
+	connect(showInfoAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(showInfoChanged(bool)));
 	showInfoAction->setChecked(config->readBoolEntry("showInfo", false));
 
-	showGuideLineAction = new TDEToggleAction(i18n("Show Putter &Guideline"), 0, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "showguideline");
+	showGuideLineAction = new TDEToggleAction(i18n("Show Putter &Guideline"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "showguideline");
 	showGuideLineAction->setCheckedState(i18n("Hide Putter &Guideline"));
-	connect(showGuideLineAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(showGuideLineChanged(bool)));
+	connect(showGuideLineAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(showGuideLineChanged(bool)));
 	showGuideLineAction->setChecked(config->readBoolEntry("showGuideLine", true));
 
-	TDEToggleAction *act=new TDEToggleAction(i18n("Enable All Dialog Boxes"), 0, TQT_TQOBJECT(this), TQT_SLOT(enableAllMessages()), actionCollection(), "enableAll");
+	TDEToggleAction *act=new TDEToggleAction(i18n("Enable All Dialog Boxes"), 0, this, TQT_SLOT(enableAllMessages()), actionCollection(), "enableAll");
 	act->setCheckedState(i18n("Disable All Dialog Boxes"));
 
-	soundAction = new TDEToggleAction(i18n("Play &Sounds"), 0, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "audio-x-generic");
-	connect(soundAction, TQT_SIGNAL(toggled(bool)), TQT_TQOBJECT(this), TQT_SLOT(soundChanged(bool)));
+	soundAction = new TDEToggleAction(i18n("Play &Sounds"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "audio-x-generic");
+	connect(soundAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(soundChanged(bool)));
 	soundAction->setChecked(config->readBoolEntry("sound", true));
 
-	(void) new TDEAction(i18n("&Reload Plugins"), 0, TQT_TQOBJECT(this), TQT_SLOT(initPlugins()), actionCollection(), "reloadplugins");
-	(void) new TDEAction(i18n("Show &Plugins"), 0, TQT_TQOBJECT(this), TQT_SLOT(showPlugins()), actionCollection(), "showplugins");
+	(void) new TDEAction(i18n("&Reload Plugins"), 0, this, TQT_SLOT(initPlugins()), actionCollection(), "reloadplugins");
+	(void) new TDEAction(i18n("Show &Plugins"), 0, this, TQT_SLOT(showPlugins()), actionCollection(), "showplugins");
 
-	aboutAction = new TDEAction(i18n("&About Course"), 0, TQT_TQOBJECT(this), TQT_SLOT(emptySlot()), actionCollection(), "aboutcourse");
-	tutorialAction = new TDEAction(i18n("&Tutorial"), 0, TQT_TQOBJECT(this), TQT_SLOT(tutorial()), actionCollection(), "tutorial");
+	aboutAction = new TDEAction(i18n("&About Course"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "aboutcourse");
+	tutorialAction = new TDEAction(i18n("&Tutorial"), 0, this, TQT_SLOT(tutorial()), actionCollection(), "tutorial");
 
 	statusBar();
 	setupGUI();
@@ -226,19 +226,19 @@ void Kolf::startNewGame()
 	connect(game, TQT_SIGNAL(newHole(int)), scoreboard, TQT_SLOT(newHole(int)));
 	connect(game, TQT_SIGNAL(scoreChanged(int, int, int)), scoreboard, TQT_SLOT(setScore(int, int, int)));
 	connect(game, TQT_SIGNAL(parChanged(int, int)), scoreboard, TQT_SLOT(parChanged(int, int)));
-	connect(game, TQT_SIGNAL(modifiedChanged(bool)), TQT_TQOBJECT(this), TQT_SLOT(updateModified(bool)));
-	connect(game, TQT_SIGNAL(newPlayersTurn(Player *)), TQT_TQOBJECT(this), TQT_SLOT(newPlayersTurn(Player *)));
-	connect(game, TQT_SIGNAL(holesDone()), TQT_TQOBJECT(this), TQT_SLOT(gameOver()));
-	connect(game, TQT_SIGNAL(checkEditing()), TQT_TQOBJECT(this), TQT_SLOT(checkEditing()));
-	connect(game, TQT_SIGNAL(editingStarted()), TQT_TQOBJECT(this), TQT_SLOT(editingStarted()));
-	connect(game, TQT_SIGNAL(editingEnded()), TQT_TQOBJECT(this), TQT_SLOT(editingEnded()));
-	connect(game, TQT_SIGNAL(inPlayStart()), TQT_TQOBJECT(this), TQT_SLOT(inPlayStart()));
-	connect(game, TQT_SIGNAL(inPlayEnd()), TQT_TQOBJECT(this), TQT_SLOT(inPlayEnd()));
-	connect(game, TQT_SIGNAL(maxStrokesReached(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(maxStrokesReached(const TQString &)));
-	connect(game, TQT_SIGNAL(largestHole(int)), TQT_TQOBJECT(this), TQT_SLOT(updateHoleMenu(int)));
-	connect(game, TQT_SIGNAL(titleChanged(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(titleChanged(const TQString &)));
-	connect(game, TQT_SIGNAL(newStatusText(const TQString &)), TQT_TQOBJECT(this), TQT_SLOT(newStatusText(const TQString &)));
-	connect(game, TQT_SIGNAL(currentHole(int)), TQT_TQOBJECT(this), TQT_SLOT(setCurrentHole(int)));
+	connect(game, TQT_SIGNAL(modifiedChanged(bool)), this, TQT_SLOT(updateModified(bool)));
+	connect(game, TQT_SIGNAL(newPlayersTurn(Player *)), this, TQT_SLOT(newPlayersTurn(Player *)));
+	connect(game, TQT_SIGNAL(holesDone()), this, TQT_SLOT(gameOver()));
+	connect(game, TQT_SIGNAL(checkEditing()), this, TQT_SLOT(checkEditing()));
+	connect(game, TQT_SIGNAL(editingStarted()), this, TQT_SLOT(editingStarted()));
+	connect(game, TQT_SIGNAL(editingEnded()), this, TQT_SLOT(editingEnded()));
+	connect(game, TQT_SIGNAL(inPlayStart()), this, TQT_SLOT(inPlayStart()));
+	connect(game, TQT_SIGNAL(inPlayEnd()), this, TQT_SLOT(inPlayEnd()));
+	connect(game, TQT_SIGNAL(maxStrokesReached(const TQString &)), this, TQT_SLOT(maxStrokesReached(const TQString &)));
+	connect(game, TQT_SIGNAL(largestHole(int)), this, TQT_SLOT(updateHoleMenu(int)));
+	connect(game, TQT_SIGNAL(titleChanged(const TQString &)), this, TQT_SLOT(titleChanged(const TQString &)));
+	connect(game, TQT_SIGNAL(newStatusText(const TQString &)), this, TQT_SLOT(newStatusText(const TQString &)));
+	connect(game, TQT_SIGNAL(currentHole(int)), this, TQT_SLOT(setCurrentHole(int)));
 	connect(holeAction, TQT_SIGNAL(activated(const TQString &)), game, TQT_SLOT(switchHole(const TQString &)));
 	connect(nextAction, TQT_SIGNAL(activated()), game, TQT_SLOT(nextHole()));
 	connect(prevAction, TQT_SIGNAL(activated()), game, TQT_SLOT(prevHole()));
@@ -356,7 +356,7 @@ void Kolf::closeGame()
 	titleChanged(TQString());
 	updateModified(false);
 
-	TQTimer::singleShot(100, TQT_TQOBJECT(this), TQT_SLOT(createSpacer()));
+	TQTimer::singleShot(100, this, TQT_SLOT(createSpacer()));
 }
 
 void Kolf::createSpacer()
@@ -463,7 +463,7 @@ void Kolf::gameOver()
 		scoreDialog->show();
 	}
 
-	TQTimer::singleShot(700, TQT_TQOBJECT(this), TQT_SLOT(closeGame()));
+	TQTimer::singleShot(700, this, TQT_SLOT(closeGame()));
 }
 
 void Kolf::showHighScores()
@@ -564,7 +564,7 @@ void Kolf::openURL(KURL url)
 			return;
 		}
 
-		TQTimer::singleShot(10, TQT_TQOBJECT(this), TQT_SLOT(startNewGame()));
+		TQTimer::singleShot(10, this, TQT_SLOT(startNewGame()));
 	}
 	else
 		closeGame();
@@ -596,7 +596,7 @@ void Kolf::editingStarted()
 	editor = new Editor(obj, dummy, "Editor");
 	connect(editor, TQT_SIGNAL(addNewItem(Object *)), game, TQT_SLOT(addNewObject(Object *)));
 	connect(editor, TQT_SIGNAL(changed()), game, TQT_SLOT(setModified()));
-	connect(editor, TQT_SIGNAL(addNewItem(Object *)), TQT_TQOBJECT(this), TQT_SLOT(setHoleFocus()));
+	connect(editor, TQT_SIGNAL(addNewItem(Object *)), this, TQT_SLOT(setHoleFocus()));
 	connect(game, TQT_SIGNAL(newSelectedItem(CanvasItem *)), editor, TQT_SLOT(setItem(CanvasItem *)));
 
 	scoreboard->hide();
diff --git a/konquest/int_validator.cpp b/konquest/int_validator.cpp
index dd96ca82..12f707c6 100644
--- a/konquest/int_validator.cpp
+++ b/konquest/int_validator.cpp
@@ -4,7 +4,7 @@
 #include "int_validator.moc"
 
 IntValidator::IntValidator( TQWidget *parent, const char *name ) :
-    TQValidator( TQT_TQOBJECT(parent), name )
+    TQValidator( parent, name )
 {
 #ifdef INT_MIN
     v_bottom = INT_MIN;
@@ -15,7 +15,7 @@ IntValidator::IntValidator( TQWidget *parent, const char *name ) :
 }
 
 IntValidator::IntValidator( int bottom, int top, TQWidget *parent, const char *name ) :
-TQValidator( TQT_TQOBJECT(parent), name )
+TQValidator( parent, name )
 {
     v_bottom = bottom;
     v_top = top;
diff --git a/konquest/mainwin.cpp b/konquest/mainwin.cpp
index 8982974a..2131b589 100644
--- a/konquest/mainwin.cpp
+++ b/konquest/mainwin.cpp
@@ -37,18 +37,18 @@ MainWindow::~MainWindow()
 void
 MainWindow::setupTDEAction()
 {
-    KStdGameAction::gameNew( TQT_TQOBJECT(gameBoard), TQT_SLOT( startNewGame() ), actionCollection() );
-    KStdGameAction::quit( TQT_TQOBJECT(this), TQT_SLOT( close() ), actionCollection() );
-    endAction = KStdGameAction::end( TQT_TQOBJECT(gameBoard), TQT_SLOT( shutdownGame() ), actionCollection() );
+    KStdGameAction::gameNew( gameBoard, TQT_SLOT( startNewGame() ), actionCollection() );
+    KStdGameAction::quit( this, TQT_SLOT( close() ), actionCollection() );
+    endAction = KStdGameAction::end( gameBoard, TQT_SLOT( shutdownGame() ), actionCollection() );
     endAction->setEnabled(false);
 
     //AB: there is no icon for disabled - TDEToolBar::insertButton shows the
     //different state - TDEAction not :-(
-    measureAction = new TDEAction( i18n("&Measure Distance"), "ruler", 0, TQT_TQOBJECT(gameBoard), TQT_SLOT( measureDistance() ), actionCollection(), "game_measure" );
+    measureAction = new TDEAction( i18n("&Measure Distance"), "ruler", 0, gameBoard, TQT_SLOT( measureDistance() ), actionCollection(), "game_measure" );
     measureAction->setEnabled(false);
-    standingAction = new TDEAction( i18n("&Show Standings"), "help", 0, TQT_TQOBJECT(gameBoard), TQT_SLOT( showScores() ), actionCollection(), "game_scores" );
+    standingAction = new TDEAction( i18n("&Show Standings"), "help", 0, gameBoard, TQT_SLOT( showScores() ), actionCollection(), "game_scores" );
     standingAction->setEnabled(false);
-    fleetAction = new TDEAction( i18n("&Fleet Overview"), "launch", 0, TQT_TQOBJECT(gameBoard), TQT_SLOT( showFleets() ), actionCollection(), "game_fleets" );
+    fleetAction = new TDEAction( i18n("&Fleet Overview"), "launch", 0, gameBoard, TQT_SLOT( showFleets() ), actionCollection(), "game_fleets" );
     fleetAction->setEnabled(false);
     toolBar()->setBarPos( TDEToolBar::Left );
     toolBar()->setMovingEnabled( false );
@@ -60,7 +60,7 @@ MainWindow::setupGameBoard()
     gameBoard = new GameBoard( this );
     setCentralWidget(gameBoard);
 
-    connect( gameBoard, TQT_SIGNAL( newGameState( GameState )), TQT_TQOBJECT(this), TQT_SLOT( gameStateChange( GameState ) ) );
+    connect( gameBoard, TQT_SIGNAL( newGameState( GameState )), this, TQT_SLOT( gameStateChange( GameState ) ) );
 }
 
 
diff --git a/kpat/dealer.cpp b/kpat/dealer.cpp
index 2eb3c705..14b7978d 100644
--- a/kpat/dealer.cpp
+++ b/kpat/dealer.cpp
@@ -114,7 +114,7 @@ void Dealer::setupActions() {
 
     if (actions() & Dealer::Hint) {
 
-        ahint = new TDEAction( i18n("&Hint"), TQString::fromLatin1("wizard"), Key_H, TQT_TQOBJECT(this),
+        ahint = new TDEAction( i18n("&Hint"), TQString::fromLatin1("wizard"), Key_H, this,
                              TQT_SLOT(hint()),
                              parent()->actionCollection(), "game_hint");
         actionlist.append(ahint);
@@ -122,7 +122,7 @@ void Dealer::setupActions() {
         ahint = 0;
 
     if (actions() & Dealer::Demo) {
-        ademo = new TDEToggleAction( i18n("&Demo"), TQString::fromLatin1("1rightarrow"), CTRL+Key_D, TQT_TQOBJECT(this),
+        ademo = new TDEToggleAction( i18n("&Demo"), TQString::fromLatin1("1rightarrow"), CTRL+Key_D, this,
                                    TQT_SLOT(toggleDemo()),
                                    parent()->actionCollection(), "game_demo");
         actionlist.append(ademo);
@@ -130,7 +130,7 @@ void Dealer::setupActions() {
         ademo = 0;
 
     if (actions() & Dealer::Redeal) {
-        aredeal = new TDEAction (i18n("&Redeal"), TQString::fromLatin1("queue"), 0, TQT_TQOBJECT(this),
+        aredeal = new TDEAction (i18n("&Redeal"), TQString::fromLatin1("queue"), 0, this,
                                TQT_SLOT(redeal()),
                                parent()->actionCollection(), "game_redeal");
         actionlist.append(aredeal);
@@ -791,13 +791,13 @@ void Dealer::takeState()
                 ademo->setEnabled( false );
             if ( aredeal )
                 aredeal->setEnabled( false );
-            TQTimer::singleShot(400, TQT_TQOBJECT(this), TQT_SIGNAL(gameLost()));
+            TQTimer::singleShot(400, this, TQT_SIGNAL(gameLost()));
             toldAboutLostGame = true;
             return;
         }
     }
     if (!demoActive() && !waiting())
-            TQTimer::singleShot(TIME_BETWEEN_MOVES, TQT_TQOBJECT(this), TQT_SLOT(startAutoDrop()));
+            TQTimer::singleShot(TIME_BETWEEN_MOVES, this, TQT_SLOT(startAutoDrop()));
 
     emit undoPossible(undoList.count() > 1 && !waiting());
 }
@@ -998,7 +998,7 @@ void Dealer::setWaiting(bool w)
 void Dealer::setAutoDropEnabled(bool a)
 {
     _autodrop = a;
-    TQTimer::singleShot(TIME_BETWEEN_MOVES, TQT_TQOBJECT(this), TQT_SLOT(startAutoDrop()));
+    TQTimer::singleShot(TIME_BETWEEN_MOVES, this, TQT_SLOT(startAutoDrop()));
 }
 
 bool Dealer::startAutoDrop()
@@ -1010,7 +1010,7 @@ bool Dealer::startAutoDrop()
 
     for (TQCanvasItemList::ConstIterator it = list.begin(); it != list.end(); ++it)
         if ((*it)->animated()) {
-            TQTimer::singleShot(TIME_BETWEEN_MOVES, TQT_TQOBJECT(this), TQT_SLOT(startAutoDrop()));
+            TQTimer::singleShot(TIME_BETWEEN_MOVES, this, TQT_SLOT(startAutoDrop()));
             return true;
         }
 
diff --git a/kpat/pwidget.cpp b/kpat/pwidget.cpp
index 2eb38fc1..a2405e54 100644
--- a/kpat/pwidget.cpp
+++ b/kpat/pwidget.cpp
@@ -59,28 +59,28 @@ pWidget::pWidget()
 {
     current_pwidget = this;
     // TDECrash::setEmergencySaveFunction(::saveGame);
-    KStdAction::quit(TQT_TQOBJECT(kapp), TQT_SLOT(quit()), actionCollection(), "game_exit");
+    KStdAction::quit(kapp, TQT_SLOT(quit()), actionCollection(), "game_exit");
 
-    undo = KStdAction::undo(TQT_TQOBJECT(this), TQT_SLOT(undoMove()),
+    undo = KStdAction::undo(this, TQT_SLOT(undoMove()),
                      actionCollection(), "undo_move");
     undo->setEnabled(false);
-    (void)KStdAction::openNew(TQT_TQOBJECT(this), TQT_SLOT(newGame()),
+    (void)KStdAction::openNew(this, TQT_SLOT(newGame()),
                               actionCollection(), "new_game");
-    (void)KStdAction::open(TQT_TQOBJECT(this), TQT_SLOT(openGame()),
+    (void)KStdAction::open(this, TQT_SLOT(openGame()),
                            actionCollection(), "open");
-    recent = KStdAction::openRecent(TQT_TQOBJECT(this), TQT_SLOT(openGame(const KURL&)),
+    recent = KStdAction::openRecent(this, TQT_SLOT(openGame(const KURL&)),
                                     actionCollection(), "open_recent");
     recent->loadEntries(TDEGlobal::config());
-    (void)KStdAction::saveAs(TQT_TQOBJECT(this), TQT_SLOT(saveGame()),
+    (void)KStdAction::saveAs(this, TQT_SLOT(saveGame()),
                            actionCollection(), "save");
-    (void)new TDEAction(i18n("&Choose Game..."), 0, TQT_TQOBJECT(this), TQT_SLOT(chooseGame()),
+    (void)new TDEAction(i18n("&Choose Game..."), 0, this, TQT_SLOT(chooseGame()),
                       actionCollection(), "choose_game");
     (void)new TDEAction(i18n("Restart &Game"), TQString::fromLatin1("reload"), 0,
-                      TQT_TQOBJECT(this), TQT_SLOT(restart()),
+                      this, TQT_SLOT(restart()),
                       actionCollection(), "restart_game");
-    (void)KStdAction::help(TQT_TQOBJECT(this), TQT_SLOT(helpGame()), actionCollection(), "help_game");
+    (void)KStdAction::help(this, TQT_SLOT(helpGame()), actionCollection(), "help_game");
 
-    games = new TDESelectAction(i18n("&Game Type"), 0, TQT_TQOBJECT(this),
+    games = new TDESelectAction(i18n("&Game Type"), 0, this,
                               TQT_SLOT(newGameType()),
                               actionCollection(), "game_type");
     TQStringList list;
@@ -104,7 +104,7 @@ pWidget::pWidget()
 
     TDEGlobal::dirs()->addResourceType("wallpaper", TDEStandardDirs::kde_default("data") + "kpat/backgrounds/");
     TDEGlobal::dirs()->addResourceType("wallpaper", TDEStandardDirs::kde_default("data") + "ksnake/backgrounds/");
-    wallpapers = new TDESelectAction(i18n("&Change Background"), 0, TQT_TQOBJECT(this),
+    wallpapers = new TDESelectAction(i18n("&Change Background"), 0, this,
                               TQT_SLOT(changeWallpaper()),
                               actionCollection(), "wallpaper");
     list.clear();
@@ -131,17 +131,17 @@ pWidget::pWidget()
 
     (void)new cardMap(midcolor);
 
-    backs = new TDEAction(i18n("&Switch Cards..."), 0, TQT_TQOBJECT(this),
+    backs = new TDEAction(i18n("&Switch Cards..."), 0, this,
                         TQT_SLOT(changeBackside()),
                         actionCollection(), "backside");
-	 stats = new TDEAction(i18n("&Statistics"), 0, TQT_TQOBJECT(this), TQT_SLOT(showStats()),
+	 stats = new TDEAction(i18n("&Statistics"), 0, this, TQT_SLOT(showStats()),
 			 actionCollection(),"game_stats");
 
     animation = new TDEToggleAction(i18n( "&Animation on Startup" ),
-                                  0, TQT_TQOBJECT(this), TQT_SLOT(animationChanged()),
+                                  0, this, TQT_SLOT(animationChanged()),
                                   actionCollection(), "animation");
     dropaction = new TDEToggleAction(i18n("&Enable Autodrop"),
-                                   0, TQT_TQOBJECT(this), TQT_SLOT(enableAutoDrop()),
+                                   0, this, TQT_SLOT(enableAutoDrop()),
                                    actionCollection(), "enable_autodrop");
     dropaction->setCheckedState(i18n("Disable Autodrop"));
 
@@ -455,7 +455,7 @@ void pWidget::gameWon(bool withhelp)
 #if TEST_SOLVER == 0
     KMessageBox::information(this, congrats, i18n("Congratulations!"));
 #endif
-    TQTimer::singleShot(0, TQT_TQOBJECT(this), TQT_SLOT(newGame()));
+    TQTimer::singleShot(0, this, TQT_SLOT(newGame()));
 #if TEST_SOLVER == 1
     dill->demo();
 #endif
@@ -491,7 +491,7 @@ void pWidget::gameLost()
 				   KStdGuiItem::cont(),
 				   dontAskAgainName) == KMessageBox::Yes) {
 
-        TQTimer::singleShot(0, TQT_TQOBJECT(this), TQT_SLOT(newGame()));
+        TQTimer::singleShot(0, this, TQT_SLOT(newGame()));
     }
 }
 
diff --git a/kpoker/top.cpp b/kpoker/top.cpp
index a8d9002f..57c34add 100644
--- a/kpoker/top.cpp
+++ b/kpoker/top.cpp
@@ -79,46 +79,46 @@ PokerWindow::~PokerWindow()
 void PokerWindow::initTDEAction()
 {
   //Game
-  KStdGameAction::gameNew(TQT_TQOBJECT(m_kpok), TQT_SLOT(newGame()), actionCollection());
-  KStdGameAction::save(TQT_TQOBJECT(m_kpok), TQT_SLOT(saveGame()), actionCollection());
-  KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
+  KStdGameAction::gameNew(m_kpok, TQT_SLOT(newGame()), actionCollection());
+  KStdGameAction::save(m_kpok, TQT_SLOT(saveGame()), actionCollection());
+  KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
 
   //Settings
   showMenubarAction =
-    KStdAction::showMenubar(TQT_TQOBJECT(this), TQT_SLOT(toggleMenubar()), actionCollection());
+    KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
    
-  soundAction = new TDEToggleAction(i18n("Soun&d"), 0, TQT_TQOBJECT(m_kpok),
+  soundAction = new TDEToggleAction(i18n("Soun&d"), 0, m_kpok,
 				  TQT_SLOT(toggleSound()), actionCollection(), "options_sound");
   if (m_kpok->getSound())
     m_kpok->toggleSound();
-  blinkingAction = new TDEToggleAction(i18n("&Blinking Cards"), 0, TQT_TQOBJECT(m_kpok),
+  blinkingAction = new TDEToggleAction(i18n("&Blinking Cards"), 0, m_kpok,
 				     TQT_SLOT(toggleBlinking()), actionCollection(), "options_blinking");
   if (m_kpok->getBlinking())
     m_kpok->toggleBlinking();
   adjustAction = new TDEToggleAction(i18n("&Adjust Bet is Default"), 0,
-				   TQT_TQOBJECT(m_kpok), TQT_SLOT(toggleAdjust()), actionCollection(), "options_adjust");
+				   m_kpok, TQT_SLOT(toggleAdjust()), actionCollection(), "options_adjust");
   if (m_kpok->getAdjust())
     m_kpok->toggleAdjust();
 
   showStatusbarAction =
-    KStdAction::showStatusbar(TQT_TQOBJECT(this), TQT_SLOT(toggleStatusbar()), actionCollection());
+    KStdAction::showStatusbar(this, TQT_SLOT(toggleStatusbar()), actionCollection());
 
-  KStdAction::saveOptions(TQT_TQOBJECT(this),     TQT_SLOT(saveOptions()), actionCollection());
-  KStdGameAction::carddecks(TQT_TQOBJECT(m_kpok), TQT_SLOT(slotCardDeck()), actionCollection());
-  KStdAction::preferences(TQT_TQOBJECT(m_kpok),   TQT_SLOT(slotPreferences()), actionCollection());
+  KStdAction::saveOptions(this,     TQT_SLOT(saveOptions()), actionCollection());
+  KStdGameAction::carddecks(m_kpok, TQT_SLOT(slotCardDeck()), actionCollection());
+  KStdAction::preferences(m_kpok,   TQT_SLOT(slotPreferences()), actionCollection());
 
   // Keyboard shortcuts.
-  (void)new TDEAction(i18n("Draw"), TDEShortcut(TQt::Key_Return), TQT_TQOBJECT(m_kpok),
+  (void)new TDEAction(i18n("Draw"), TDEShortcut(TQt::Key_Return), m_kpok,
 		    TQT_SLOT(drawClick()), actionCollection(), "draw");
-  (void)new TDEAction(i18n("Exchange Card 1"), TDEShortcut(TQt::Key_1), TQT_TQOBJECT(m_kpok),
+  (void)new TDEAction(i18n("Exchange Card 1"), TDEShortcut(TQt::Key_1), m_kpok,
 		    TQT_SLOT(exchangeCard1()), actionCollection(), "exchange_card_1");
-  (void)new TDEAction(i18n("Exchange Card 2"), TDEShortcut(TQt::Key_2), TQT_TQOBJECT(m_kpok),
+  (void)new TDEAction(i18n("Exchange Card 2"), TDEShortcut(TQt::Key_2), m_kpok,
 		    TQT_SLOT(exchangeCard2()), actionCollection(), "exchange_card_2");
-  (void)new TDEAction(i18n("Exchange Card 3"), TDEShortcut(TQt::Key_3), TQT_TQOBJECT(m_kpok),
+  (void)new TDEAction(i18n("Exchange Card 3"), TDEShortcut(TQt::Key_3), m_kpok,
 		    TQT_SLOT(exchangeCard3()), actionCollection(), "exchange_card_3");
-  (void)new TDEAction(i18n("Exchange Card 4"), TDEShortcut(TQt::Key_4), TQT_TQOBJECT(m_kpok),
+  (void)new TDEAction(i18n("Exchange Card 4"), TDEShortcut(TQt::Key_4), m_kpok,
 		    TQT_SLOT(exchangeCard4()), actionCollection(), "exchange_card_4");
-  (void)new TDEAction(i18n("Exchange Card 5"), TDEShortcut(TQt::Key_5), TQT_TQOBJECT(m_kpok),
+  (void)new TDEAction(i18n("Exchange Card 5"), TDEShortcut(TQt::Key_5), m_kpok,
 		    TQT_SLOT(exchangeCard5()), actionCollection(), "exchange_card_5");
 
   setupGUI( TDEMainWindow::Save | StatusBar | Keys | Create);
diff --git a/kreversi/kreversi.cpp b/kreversi/kreversi.cpp
index 7e2e83ff..be02d428 100644
--- a/kreversi/kreversi.cpp
+++ b/kreversi/kreversi.cpp
@@ -116,15 +116,15 @@ KReversi::KReversi()
   // The only part of the view that is left in this class is the
   // indicator of whose turn it is in the status bar.  The rest is
   // in the game view.
-  connect(m_game, TQT_SIGNAL(sig_newGame()),  TQT_TQOBJECT(this), TQT_SLOT(showTurn()));
+  connect(m_game, TQT_SIGNAL(sig_newGame()),  this, TQT_SLOT(showTurn()));
   connect(m_game, TQT_SIGNAL(sig_move(uint, Move&)), 
-	  TQT_TQOBJECT(this),   TQT_SLOT(handleMove(uint, Move&))); // Calls showTurn().
-  connect(m_game, TQT_SIGNAL(sig_update()),   TQT_TQOBJECT(this), TQT_SLOT(showTurn()));
-  connect(m_game, TQT_SIGNAL(sig_gameOver()), TQT_TQOBJECT(this), TQT_SLOT(slotGameOver()));
+	  this,   TQT_SLOT(handleMove(uint, Move&))); // Calls showTurn().
+  connect(m_game, TQT_SIGNAL(sig_update()),   this, TQT_SLOT(showTurn()));
+  connect(m_game, TQT_SIGNAL(sig_gameOver()), this, TQT_SLOT(slotGameOver()));
 
   // Signal that is sent when the user clicks on the board.
   connect(m_gameView, TQT_SIGNAL(signalSquareClicked(int, int)),
-	  TQT_TQOBJECT(this),       TQT_SLOT(slotSquareClicked(int, int)));
+	  this,       TQT_SLOT(slotSquareClicked(int, int)));
 
   loadSettings();
 
@@ -150,38 +150,38 @@ KReversi::~KReversi()
 void KReversi::createTDEActions()
 {
   // Standard Game Actions.
-  KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(slotNewGame()),  actionCollection(), 
+  KStdGameAction::gameNew(this, TQT_SLOT(slotNewGame()),  actionCollection(), 
 			  "game_new");
-  KStdGameAction::load(TQT_TQOBJECT(this),    TQT_SLOT(slotOpenGame()), actionCollection());
-  KStdGameAction::save(TQT_TQOBJECT(this),    TQT_SLOT(slotSave()),     actionCollection());
-  KStdGameAction::quit(TQT_TQOBJECT(this),    TQT_SLOT(close()),        actionCollection());
-  KStdGameAction::hint(TQT_TQOBJECT(this),    TQT_SLOT(slotHint()),     actionCollection(),
+  KStdGameAction::load(this,    TQT_SLOT(slotOpenGame()), actionCollection());
+  KStdGameAction::save(this,    TQT_SLOT(slotSave()),     actionCollection());
+  KStdGameAction::quit(this,    TQT_SLOT(close()),        actionCollection());
+  KStdGameAction::hint(this,    TQT_SLOT(slotHint()),     actionCollection(),
 		       "game_hint");
-  KStdGameAction::undo(TQT_TQOBJECT(this),    TQT_SLOT(slotUndo()),     actionCollection(),
+  KStdGameAction::undo(this,    TQT_SLOT(slotUndo()),     actionCollection(),
 		       "game_undo");
 
   // Non-standard Game Actions: Stop, Continue, Switch sides
   stopAction = new TDEAction(i18n("&Stop Thinking"), "game_stop", TQt::Key_Escape,
-			   TQT_TQOBJECT(this), TQT_SLOT(slotInterrupt()), actionCollection(),
+			   this, TQT_SLOT(slotInterrupt()), actionCollection(),
 			   "game_stop");
   continueAction = new TDEAction(i18n("&Continue Thinking"), "reload", 0,
-			       TQT_TQOBJECT(this), TQT_SLOT(slotContinue()), actionCollection(),
+			       this, TQT_SLOT(slotContinue()), actionCollection(),
 			       "game_continue");
   new TDEAction(i18n("S&witch Sides"), 0, 0,
-	      TQT_TQOBJECT(this), TQT_SLOT(slotSwitchSides()), actionCollection(),
+	      this, TQT_SLOT(slotSwitchSides()), actionCollection(),
 	      "game_switch_sides");
 
   // Some more standard game actions: Highscores, Settings.
-  KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighScoreDialog()), actionCollection());
-  KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(slotEditSettings()), actionCollection());
+  KStdGameAction::highscores(this, TQT_SLOT(showHighScoreDialog()), actionCollection());
+  KStdAction::preferences(this, TQT_SLOT(slotEditSettings()), actionCollection());
 
   // Actions for the view(s).
   showLastMoveAction = new TDEToggleAction(i18n("Show Last Move"), "lastmoves", 0, 
-					 TQT_TQOBJECT(this), TQT_SLOT(slotShowLastMove()),
+					 this, TQT_SLOT(slotShowLastMove()),
 					 actionCollection(),
 					 "show_last_move");
   showLegalMovesAction = new TDEToggleAction(i18n("Show Legal Moves"), "legalmoves", 0, 
-					   TQT_TQOBJECT(this), TQT_SLOT(slotShowLegalMoves()),
+					   this, TQT_SLOT(slotShowLegalMoves()),
 					   actionCollection(),
 					   "show_legal_moves");
 }
@@ -755,7 +755,7 @@ void KReversi::slotEditSettings()
   Settings      *general = new Settings(0, "General");
 
   dialog->addPage(general, i18n("General"), "package_settings");
-  connect(dialog, TQT_SIGNAL(settingsChanged()), TQT_TQOBJECT(this), TQT_SLOT(loadSettings()));
+  connect(dialog, TQT_SIGNAL(settingsChanged()), this, TQT_SLOT(loadSettings()));
   dialog->show();
 }
 
diff --git a/kreversi/kzoommainwindow.cpp b/kreversi/kzoommainwindow.cpp
index f8c3c490..10953a2d 100644
--- a/kreversi/kzoommainwindow.cpp
+++ b/kreversi/kzoommainwindow.cpp
@@ -34,11 +34,11 @@ KZoomMainWindow::KZoomMainWindow(uint min, uint max, uint step,
   installEventFilter(this);
   
   m_zoomInAction = 
-    KStdAction::zoomIn(TQT_TQOBJECT(this), TQT_SLOT(zoomIn()), actionCollection());
+    KStdAction::zoomIn(this, TQT_SLOT(zoomIn()), actionCollection());
   m_zoomOutAction =
-    KStdAction::zoomOut(TQT_TQOBJECT(this), TQT_SLOT(zoomOut()), actionCollection());
+    KStdAction::zoomOut(this, TQT_SLOT(zoomOut()), actionCollection());
   m_menu =
-    KStdAction::showMenubar(TQT_TQOBJECT(this), TQT_SLOT(toggleMenubar()), actionCollection());
+    KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
 }
 
 
diff --git a/ksame/KSameWidget.cpp b/ksame/KSameWidget.cpp
index 60fabc01..4ac4eab2 100644
--- a/ksame/KSameWidget.cpp
+++ b/ksame/KSameWidget.cpp
@@ -48,17 +48,17 @@ static int default_colors=3;
 KSameWidget::KSameWidget(TQWidget *parent, const char* name, WFlags fl) :
              TDEMainWindow(parent,name,fl)
 {
-	KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(m_new()), actionCollection(), "game_new");
-	restart = new TDEAction(i18n("&Restart This Board"), CTRL+Key_R, TQT_TQOBJECT(this),
+	KStdGameAction::gameNew(this, TQT_SLOT(m_new()), actionCollection(), "game_new");
+	restart = new TDEAction(i18n("&Restart This Board"), CTRL+Key_R, this,
 						  TQT_SLOT(m_restart()), actionCollection(), "game_restart");
-	KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(m_showhs()), actionCollection(), "game_highscores");
-	KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection(), "game_quit");
-	undo = KStdGameAction::undo(TQT_TQOBJECT(this), TQT_SLOT(m_undo()), actionCollection(), "edit_undo");
+	KStdGameAction::highscores(this, TQT_SLOT(m_showhs()), actionCollection(), "game_highscores");
+	KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection(), "game_quit");
+	undo = KStdGameAction::undo(this, TQT_SLOT(m_undo()), actionCollection(), "edit_undo");
 
 	random = new TDEToggleAction(i18n("&Random Board"), 0, 0, 0, actionCollection(), "random_board");
-	showNumberRemaining = new TDEToggleAction(i18n("&Show Number Remaining"), 0, TQT_TQOBJECT(this), TQT_SLOT(showNumberRemainingToggled()), actionCollection(), "showNumberRemaining");
+	showNumberRemaining = new TDEToggleAction(i18n("&Show Number Remaining"), 0, this, TQT_SLOT(showNumberRemainingToggled()), actionCollection(), "showNumberRemaining");
 
-	KStdAction::configureNotifications(TQT_TQOBJECT(this), TQT_SLOT(configureNotifications()),
+	KStdAction::configureNotifications(this, TQT_SLOT(configureNotifications()),
                actionCollection());
 
 	status=statusBar();
@@ -69,14 +69,14 @@ KSameWidget::KSameWidget(TQWidget *parent, const char* name, WFlags fl) :
 
 	stone = new StoneWidget(this,15,10);
 
-	connect( stone, TQT_SIGNAL(s_gameover()), TQT_TQOBJECT(this), TQT_SLOT(gameover()));
-	connect( stone, TQT_SIGNAL(s_colors(int)), TQT_TQOBJECT(this), TQT_SLOT(setColors(int)));
-	connect( stone, TQT_SIGNAL(s_board(int)), TQT_TQOBJECT(this), TQT_SLOT(setBoard(int)));
-	connect( stone, TQT_SIGNAL(s_marked(int)), TQT_TQOBJECT(this), TQT_SLOT(setMarked(int)));
-	connect( stone, TQT_SIGNAL(s_score(int)), TQT_TQOBJECT(this), TQT_SLOT(setScore(int)));
-	connect( stone, TQT_SIGNAL(s_remove(int,int)), TQT_TQOBJECT(this), TQT_SLOT(stonesRemoved(int,int)));
+	connect( stone, TQT_SIGNAL(s_gameover()), this, TQT_SLOT(gameover()));
+	connect( stone, TQT_SIGNAL(s_colors(int)), this, TQT_SLOT(setColors(int)));
+	connect( stone, TQT_SIGNAL(s_board(int)), this, TQT_SLOT(setBoard(int)));
+	connect( stone, TQT_SIGNAL(s_marked(int)), this, TQT_SLOT(setMarked(int)));
+	connect( stone, TQT_SIGNAL(s_score(int)), this, TQT_SLOT(setScore(int)));
+	connect( stone, TQT_SIGNAL(s_remove(int,int)), this, TQT_SLOT(stonesRemoved(int,int)));
 
-	connect(stone, TQT_SIGNAL(s_sizechanged()), TQT_TQOBJECT(this), TQT_SLOT(sizeChanged()));
+	connect(stone, TQT_SIGNAL(s_sizechanged()), this, TQT_SLOT(sizeChanged()));
 
 	sizeChanged();
 	setCentralWidget(stone);
diff --git a/ksame/StoneWidget.cpp b/ksame/StoneWidget.cpp
index 5097ac78..8ada4f44 100644
--- a/ksame/StoneWidget.cpp
+++ b/ksame/StoneWidget.cpp
@@ -102,7 +102,7 @@ StoneWidget::~StoneWidget() {
     delete [] map;
 
     setMouseTracking(false);
-    TQT_TQOBJECT(this)->killTimers();
+    this->killTimers();
 }
 
 unsigned int
diff --git a/kshisen/app.cpp b/kshisen/app.cpp
index ae3e7f94..8717e70d 100644
--- a/kshisen/app.cpp
+++ b/kshisen/app.cpp
@@ -65,7 +65,7 @@
 App::App(TQWidget *parent, const char *name) : TDEMainWindow(parent, name),
    hintmode(false)
 {
-	highscoreTable = new KHighscore(TQT_TQOBJECT(this));
+	highscoreTable = new KHighscore(this);
 
 	// TODO?
 	// Would it make sense long term to have a tdeconfig update rather then
@@ -89,13 +89,13 @@ App::App(TQWidget *parent, const char *name) : TDEMainWindow(parent, name),
 
 	setupGUI();
 
-	connect(board, TQT_SIGNAL(changed()), TQT_TQOBJECT(this), TQT_SLOT(enableItems()));
+	connect(board, TQT_SIGNAL(changed()), this, TQT_SLOT(enableItems()));
 
 	TQTimer *t = new TQTimer(this);
 	t->start(1000);
-	connect(t, TQT_SIGNAL(timeout()), TQT_TQOBJECT(this), TQT_SLOT(updateScore()));
-	connect(board, TQT_SIGNAL(endOfGame()), TQT_TQOBJECT(this), TQT_SLOT(slotEndOfGame()));
-	connect(board, TQT_SIGNAL(resized()), TQT_TQOBJECT(this), TQT_SLOT(boardResized()));
+	connect(t, TQT_SIGNAL(timeout()), this, TQT_SLOT(updateScore()));
+	connect(board, TQT_SIGNAL(endOfGame()), this, TQT_SLOT(slotEndOfGame()));
+	connect(board, TQT_SIGNAL(resized()), this, TQT_SLOT(boardResized()));
 
 	kapp->processEvents();
 
@@ -106,16 +106,16 @@ App::App(TQWidget *parent, const char *name) : TDEMainWindow(parent, name),
 void App::initTDEAction()
 {
 	// Game
-	KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(newGame()), actionCollection());
-	KStdGameAction::restart(TQT_TQOBJECT(this), TQT_SLOT(restartGame()), actionCollection());
-	KStdGameAction::pause(TQT_TQOBJECT(this), TQT_SLOT(pause()), actionCollection());
-	KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(hallOfFame()), actionCollection());
-	KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(quitGame()), actionCollection());
+	KStdGameAction::gameNew(this, TQT_SLOT(newGame()), actionCollection());
+	KStdGameAction::restart(this, TQT_SLOT(restartGame()), actionCollection());
+	KStdGameAction::pause(this, TQT_SLOT(pause()), actionCollection());
+	KStdGameAction::highscores(this, TQT_SLOT(hallOfFame()), actionCollection());
+	KStdGameAction::quit(this, TQT_SLOT(quitGame()), actionCollection());
 
 	// Move
-	KStdGameAction::undo(TQT_TQOBJECT(this), TQT_SLOT(undo()), actionCollection());
-	KStdGameAction::redo(TQT_TQOBJECT(this), TQT_SLOT(redo()), actionCollection());
-	KStdGameAction::hint(TQT_TQOBJECT(this), TQT_SLOT(hint()), actionCollection());
+	KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
+	KStdGameAction::redo(this, TQT_SLOT(redo()), actionCollection());
+	KStdGameAction::hint(this, TQT_SLOT(hint()), actionCollection());
 	//new TDEAction(i18n("Is Game Solvable?"), 0, this,
 	//	TQT_SLOT(isSolvable()), actionCollection(), "move_solvable");
 
@@ -124,7 +124,7 @@ void App::initTDEAction()
 #endif
 
 	// Settings
-	KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(showSettings()), actionCollection());
+	KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
 }
 
 void App::hallOfFame()
@@ -752,7 +752,7 @@ void App::showSettings(){
 	TDEConfigDialog *dialog = new TDEConfigDialog(this, "settings", Prefs::self(), KDialogBase::Swallow);
 	Settings *general = new Settings(0, "General");
 	dialog->addPage(general, i18n("General"), "package_settings");
-	connect(dialog, TQT_SIGNAL(settingsChanged()), TQT_TQOBJECT(this), TQT_SLOT(loadSettings()));
+	connect(dialog, TQT_SIGNAL(settingsChanged()), this, TQT_SLOT(loadSettings()));
 	connect(dialog, TQT_SIGNAL(settingsChanged()), board, TQT_SLOT(loadSettings()));
 	dialog->show();
 }
diff --git a/ksmiletris/gamewindow.cpp b/ksmiletris/gamewindow.cpp
index 5337868f..04ddda8a 100644
--- a/ksmiletris/gamewindow.cpp
+++ b/ksmiletris/gamewindow.cpp
@@ -46,40 +46,40 @@ GameWindow::GameWindow(TQWidget *, const char *name)
         : TDEMainWindow(0, name)
 {
         //New Games
-        (void)KStdGameAction::gameNew(TQT_TQOBJECT(this),
+        (void)KStdGameAction::gameNew(this,
                                   TQT_SLOT(menu_newGame()),
                                   actionCollection());
 
         //Pause Game
-        (void)KStdGameAction::pause(TQT_TQOBJECT(this),
+        (void)KStdGameAction::pause(this,
                                       TQT_SLOT(menu_pause()),
                                       actionCollection());
 
         //End Game
-        (void)KStdGameAction::end(TQT_TQOBJECT(this),
+        (void)KStdGameAction::end(this,
                                   TQT_SLOT(menu_endGame()),
                                   actionCollection());
 
         //Highscores
-        (void)KStdGameAction::highscores(TQT_TQOBJECT(this),
+        (void)KStdGameAction::highscores(this,
                                     TQT_SLOT(menu_highScores()),
                                     actionCollection());
 
         //Quit
-        (void)KStdGameAction::quit(TQT_TQOBJECT(this),
+        (void)KStdGameAction::quit(this,
                                TQT_SLOT(close()),
                                actionCollection());
 
         TQStringList list;
         TDESelectAction* piecesAct =
-          new TDESelectAction(i18n("&Pieces"), 0, TQT_TQOBJECT(this), TQT_SLOT(menu_pieces()),
+          new TDESelectAction(i18n("&Pieces"), 0, this, TQT_SLOT(menu_pieces()),
                              actionCollection(), "settings_pieces");
         list.append(i18n("&Smiles"));
         list.append(i18n("S&ymbols"));
         list.append(i18n("&Icons"));
         piecesAct->setItems(list);
 
-        (void)new TDEToggleAction(i18n("&Sounds"), 0, TQT_TQOBJECT(this),
+        (void)new TDEToggleAction(i18n("&Sounds"), 0, this,
 		TQT_SLOT(menu_sounds()), actionCollection(), "settings_sounds");
 
 
@@ -99,14 +99,14 @@ GameWindow::GameWindow(TQWidget *, const char *name)
 	setCentralWidget(game);
 	connect(game, TQT_SIGNAL(changedStats(int, int)),
 		this, TQT_SLOT(updateStats(int, int)));
-	connect(game, TQT_SIGNAL(gameOver()), TQT_TQOBJECT(this), TQT_SLOT(gameOver()));
+	connect(game, TQT_SIGNAL(gameOver()), this, TQT_SLOT(gameOver()));
 
         //keys
-        (void)new TDEAction(i18n("Move Left"), Key_Left, TQT_TQOBJECT(game), TQT_SLOT(keyLeft()), actionCollection(), "left");
-        (void)new TDEAction(i18n("Move Right"), Key_Right, TQT_TQOBJECT(game), TQT_SLOT(keyRight()), actionCollection(), "right");
-        (void)new TDEAction(i18n("Rotate Left"), Key_Up, TQT_TQOBJECT(game), TQT_SLOT(keyUp()), actionCollection(), "up");
-        (void)new TDEAction(i18n("Rotate Right"), Key_Down, TQT_TQOBJECT(game), TQT_SLOT(keyDown()), actionCollection(), "down");
-        (void)new TDEAction(i18n("Drop Down"), Key_Space, TQT_TQOBJECT(game), TQT_SLOT(keySpace()), actionCollection(), "space");
+        (void)new TDEAction(i18n("Move Left"), Key_Left, game, TQT_SLOT(keyLeft()), actionCollection(), "left");
+        (void)new TDEAction(i18n("Move Right"), Key_Right, game, TQT_SLOT(keyRight()), actionCollection(), "right");
+        (void)new TDEAction(i18n("Rotate Left"), Key_Up, game, TQT_SLOT(keyUp()), actionCollection(), "up");
+        (void)new TDEAction(i18n("Rotate Right"), Key_Down, game, TQT_SLOT(keyDown()), actionCollection(), "down");
+        (void)new TDEAction(i18n("Drop Down"), Key_Space, game, TQT_SLOT(keySpace()), actionCollection(), "space");
 
 	game->setFixedSize(default_width, default_height);
 	adjustSize();
diff --git a/ksnake/game.cpp b/ksnake/game.cpp
index 0641b7d3..a4d61c18 100644
--- a/ksnake/game.cpp
+++ b/ksnake/game.cpp
@@ -120,12 +120,12 @@ void Game::createMenu()
 	actionCollection()->setAutoConnectShortcuts(true);
 	rattler->setActionCollection(actionCollection());
 
-	KStdGameAction::gameNew(TQT_TQOBJECT(rattler), TQT_SLOT(restart()), actionCollection());
-	pause = KStdGameAction::pause(TQT_TQOBJECT(rattler), TQT_SLOT(pause()), actionCollection());
-	KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighScores()), actionCollection());
-	KStdGameAction::quit( TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
+	KStdGameAction::gameNew(rattler, TQT_SLOT(restart()), actionCollection());
+	pause = KStdGameAction::pause(rattler, TQT_SLOT(pause()), actionCollection());
+	KStdGameAction::highscores(this, TQT_SLOT(showHighScores()), actionCollection());
+	KStdGameAction::quit( this, TQT_SLOT(close()), actionCollection());
 
-	KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(showSettings()), actionCollection());
+	KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
 
 	// TODO change and make custom function that pauses game or
 	// modify widget to pause when loosing focus and remove this
diff --git a/ksnake/rattler.cpp b/ksnake/rattler.cpp
index d7bc630c..8c1db1ed 100644
--- a/ksnake/rattler.cpp
+++ b/ksnake/rattler.cpp
@@ -534,7 +534,7 @@ void Rattler::start(int t)
 
 void Rattler::stop()
 {
-	TQT_TQOBJECT(this)->killTimers();
+	this->killTimers();
 }
 
 void Rattler::restartComputerSnakes(bool play)
diff --git a/ksokoban/PlayField.cpp b/ksokoban/PlayField.cpp
index 2b16ed44..f9ec4f79 100644
--- a/ksokoban/PlayField.cpp
+++ b/ksokoban/PlayField.cpp
@@ -421,7 +421,7 @@ PlayField::highlight() {
 
 void
 PlayField::stopMoving() {
-  TQT_TQOBJECT(this)->killTimers();
+  this->killTimers();
   delete moveSequence_;
   moveSequence_ = 0;
   moveInProgress_ = false;
@@ -456,7 +456,7 @@ void
 PlayField::timerEvent(TQTimerEvent *) {
   assert(moveInProgress_);
   if (moveSequence_ == 0) {
-    TQT_TQOBJECT(this)->killTimers();
+    this->killTimers();
     moveInProgress_ = false;
     return;
   }
diff --git a/kspaceduel/mainview.cpp b/kspaceduel/mainview.cpp
index a2645087..9fabcf3c 100644
--- a/kspaceduel/mainview.cpp
+++ b/kspaceduel/mainview.cpp
@@ -99,7 +99,7 @@ MyMainView::MyMainView(TQWidget *parent)
 
 MyMainView::~MyMainView()
 {
-   TQT_TQOBJECT(this)->killTimers();
+   this->killTimers();
    writeConfig();
 }
 
@@ -340,7 +340,7 @@ void MyMainView::pause()
       pauseAction->setChecked( true );
 
       waitForStart=true;
-      TQT_TQOBJECT(this)->killTimers();
+      this->killTimers();
       emit setStatusText(i18n(" paused "), IDS_PAUSE);
    }
 }
@@ -375,7 +375,7 @@ void MyMainView::stop()
    pauseAction->setEnabled( false );
    pauseAction->setChecked( false );
 
-   TQT_TQOBJECT(this)->killTimers();
+   this->killTimers();
    waitForStart = true;
 }
 
@@ -444,7 +444,7 @@ void MyMainView::newRound()
    timeToNextPowerup=random.getDouble() * config.powerupRefreshTime;
    powerups.clear();
 
-   TQT_TQOBJECT(this)->killTimers();
+   this->killTimers();
    mx=width()/2.0;
    my=height()/2.0;
    ship[0]->move(mx+config.startPosX,my+config.startPosY);
@@ -517,7 +517,7 @@ void MyMainView::timerEvent(TQTimerEvent *event)
 
    if(event->timerId()==timerID)
    {
-      TQT_TQOBJECT(this)->killTimers();
+      this->killTimers();
       if(gameEnd>0.0)
       {
          gameEnd-=1.0;
diff --git a/kspaceduel/topwidget.cpp b/kspaceduel/topwidget.cpp
index fb385b0c..ce727607 100644
--- a/kspaceduel/topwidget.cpp
+++ b/kspaceduel/topwidget.cpp
@@ -34,12 +34,12 @@ void MyTopLevelWidget::initGameWidgets( ){
    playfield->setFocusPolicy(TQWidget::StrongFocus);
    playfield->setFocus();
 
-   TQObject::connect(TQT_TQOBJECT(playfield),TQT_SIGNAL(energy(int,int)),
+   TQObject::connect(playfield,TQT_SIGNAL(energy(int,int)),
                     TQT_SLOT(energy(int,int)));
-   TQObject::connect(TQT_TQOBJECT(playfield),TQT_SIGNAL(hitPoints(int,int)),
+   TQObject::connect(playfield,TQT_SIGNAL(hitPoints(int,int)),
                     TQT_SLOT(hitPoints(int,int)));
-   TQObject::connect(TQT_TQOBJECT(playfield),TQT_SIGNAL(wins(int,int)),TQT_SLOT(wins(int,int)));
-   TQObject::connect(TQT_TQOBJECT(playfield),TQT_SIGNAL(setStatusText(const TQString &,int)),
+   TQObject::connect(playfield,TQT_SIGNAL(wins(int,int)),TQT_SLOT(wins(int,int)));
+   TQObject::connect(playfield,TQT_SIGNAL(setStatusText(const TQString &,int)),
                     TQT_SLOT(setStatusText(const TQString &,int)));
 
    setCentralWidget(w);
@@ -62,18 +62,18 @@ void MyTopLevelWidget::wins(int pn,int w)
 
 void MyTopLevelWidget::initActions( )
 {
-   KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection());
-   KStdGameAction::gameNew(TQT_TQOBJECT(playfield), TQT_SLOT(newGame()), actionCollection());
+   KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
+   KStdGameAction::gameNew(playfield, TQT_SLOT(newGame()), actionCollection());
    ( void )new TDEAction( i18n( "&New Round" ), "spnewround",
-                        CTRL + Key_R, TQT_TQOBJECT(playfield), TQT_SLOT( newRound( ) ),
+                        CTRL + Key_R, playfield, TQT_SLOT( newRound( ) ),
                         actionCollection( ), "new_round" );
    MyMainView::pauseAction =
-       KStdGameAction::pause(TQT_TQOBJECT(playfield), TQT_SLOT(togglePause()), actionCollection());
+       KStdGameAction::pause(playfield, TQT_SLOT(togglePause()), actionCollection());
    MyMainView::pauseAction->setChecked( false );
    TDEAction* gameStart = new TDEAction( i18n( "Start" ), GAME_START_SHORTCUT,
-	   TQT_TQOBJECT(playfield), TQT_SLOT( start( ) ), actionCollection( ), "game_start" );
+	   playfield, TQT_SLOT( start( ) ), actionCollection( ), "game_start" );
 
-   KStdAction::preferences(TQT_TQOBJECT(playfield), TQT_SLOT(gameSetup()), actionCollection());
+   KStdAction::preferences(playfield, TQT_SLOT(gameSetup()), actionCollection());
 
    TDEAccel* acc = new TDEAccel(this);
    gameStart->plugAccel(acc);
diff --git a/ktron/ktron.cpp b/ktron/ktron.cpp
index 33b6f561..25511fae 100644
--- a/ktron/ktron.cpp
+++ b/ktron/ktron.cpp
@@ -81,10 +81,10 @@ KTron::KTron(TQWidget *parent, const char *name) : TDEMainWindow(parent, name) {
 
   tron->setActionCollection(actionCollection());
 
-  KStdGameAction::pause(TQT_TQOBJECT(tron), TQT_SLOT(togglePause()), actionCollection());
-  KStdGameAction::gameNew( TQT_TQOBJECT(tron), TQT_SLOT( newGame() ), actionCollection() );
-  KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT( close() ), actionCollection());
-  KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(showSettings()), actionCollection());
+  KStdGameAction::pause(tron, TQT_SLOT(togglePause()), actionCollection());
+  KStdGameAction::gameNew( tron, TQT_SLOT( newGame() ), actionCollection() );
+  KStdGameAction::quit(this, TQT_SLOT( close() ), actionCollection());
+  KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
 
   setupGUI( TDEMainWindow::Keys | StatusBar | Save | Create);
   loadSettings();
diff --git a/ktuberling/toplevel.cpp b/ktuberling/toplevel.cpp
index eadedb09..b5013950 100644
--- a/ktuberling/toplevel.cpp
+++ b/ktuberling/toplevel.cpp
@@ -61,21 +61,21 @@ void TopLevel::registerGameboard(const TQString &menuItem, const char *actionId)
 
   switch (gameboards)
   {
-  	case 0: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(gameboard0()), actionCollection(), actionId);
+  	case 0: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard0()), actionCollection(), actionId);
 		break;
-  	case 1: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(gameboard1()), actionCollection(), actionId);
+  	case 1: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard1()), actionCollection(), actionId);
 		break;
-  	case 2: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(gameboard2()), actionCollection(), actionId);
+  	case 2: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard2()), actionCollection(), actionId);
 		break;
-  	case 3: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(gameboard3()), actionCollection(), actionId);
+  	case 3: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard3()), actionCollection(), actionId);
 		break;
-  	case 4: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(gameboard4()), actionCollection(), actionId);
+  	case 4: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard4()), actionCollection(), actionId);
 		break;
-  	case 5: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(gameboard5()), actionCollection(), actionId);
+  	case 5: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard5()), actionCollection(), actionId);
 		break;
-  	case 6: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(gameboard6()), actionCollection(), actionId);
+  	case 6: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard6()), actionCollection(), actionId);
 		break;
-  	case 7: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(gameboard7()), actionCollection(), actionId);
+  	case 7: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard7()), actionCollection(), actionId);
 		break;
   }
 
@@ -93,37 +93,37 @@ void TopLevel::registerLanguage(const TQString &menuItem, const char *actionId,
 
   switch (languages)
   {
-  	case 0: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language0()), actionCollection(), actionId);
+  	case 0: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language0()), actionCollection(), actionId);
 		break;
-  	case 1: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language1()), actionCollection(), actionId);
+  	case 1: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language1()), actionCollection(), actionId);
 		break;
-  	case 2: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language2()), actionCollection(), actionId);
+  	case 2: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language2()), actionCollection(), actionId);
 		break;
-  	case 3: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language3()), actionCollection(), actionId);
+  	case 3: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language3()), actionCollection(), actionId);
 		break;
-  	case 4: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language4()), actionCollection(), actionId);
+  	case 4: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language4()), actionCollection(), actionId);
 		break;
-  	case 5: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language5()), actionCollection(), actionId);
+  	case 5: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language5()), actionCollection(), actionId);
 		break;
-  	case 6: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language6()), actionCollection(), actionId);
+  	case 6: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language6()), actionCollection(), actionId);
 		break;
-  	case 7: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language7()), actionCollection(), actionId);
+  	case 7: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language7()), actionCollection(), actionId);
 		break;
-  	case 8: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language8()), actionCollection(), actionId);
+  	case 8: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language8()), actionCollection(), actionId);
 		break;
-  	case 9: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language9()), actionCollection(), actionId);
+  	case 9: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language9()), actionCollection(), actionId);
 		break;
-  	case 10: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language10()), actionCollection(), actionId);
+  	case 10: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language10()), actionCollection(), actionId);
 		break;
-  	case 11: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language11()), actionCollection(), actionId);
+  	case 11: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language11()), actionCollection(), actionId);
 		break;
-  	case 12: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language12()), actionCollection(), actionId);
+  	case 12: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language12()), actionCollection(), actionId);
 		break;
-  	case 13: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language13()), actionCollection(), actionId);
+  	case 13: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language13()), actionCollection(), actionId);
 		break;
-  	case 14: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language14()), actionCollection(), actionId);
+  	case 14: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language14()), actionCollection(), actionId);
 		break;
-  	case 15: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, TQT_TQOBJECT(this), TQT_SLOT(language15()), actionCollection(), actionId);
+  	case 15: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language15()), actionCollection(), actionId);
 		break;
   }
 
@@ -254,22 +254,22 @@ void TopLevel::writeOptions()
 void TopLevel::setupTDEAction()
 {
 //Game
-  KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(fileNew()), actionCollection());
-  KStdGameAction::load(TQT_TQOBJECT(this), TQT_SLOT(fileOpen()), actionCollection());
-  KStdGameAction::save(TQT_TQOBJECT(this), TQT_SLOT(fileSave()), actionCollection());
-  KStdGameAction::print(TQT_TQOBJECT(this), TQT_SLOT(filePrint()), actionCollection());
-  KStdGameAction::quit(TQT_TQOBJECT(kapp), TQT_SLOT(quit()), actionCollection());
-  (void) new TDEAction(i18n("Save &as Picture..."), 0, TQT_TQOBJECT(this), TQT_SLOT(filePicture()), actionCollection(), "game_save_picture");
+  KStdGameAction::gameNew(this, TQT_SLOT(fileNew()), actionCollection());
+  KStdGameAction::load(this, TQT_SLOT(fileOpen()), actionCollection());
+  KStdGameAction::save(this, TQT_SLOT(fileSave()), actionCollection());
+  KStdGameAction::print(this, TQT_SLOT(filePrint()), actionCollection());
+  KStdGameAction::quit(kapp, TQT_SLOT(quit()), actionCollection());
+  (void) new TDEAction(i18n("Save &as Picture..."), 0, this, TQT_SLOT(filePicture()), actionCollection(), "game_save_picture");
 
 //Edit
-  KStdAction::copy(TQT_TQOBJECT(this), TQT_SLOT(editCopy()), actionCollection());
-  KStdAction::undo(TQT_TQOBJECT(this), TQT_SLOT(editUndo()), actionCollection());
-  KStdAction::redo(TQT_TQOBJECT(this), TQT_SLOT(editRedo()), actionCollection());
+  KStdAction::copy(this, TQT_SLOT(editCopy()), actionCollection());
+  KStdAction::undo(this, TQT_SLOT(editUndo()), actionCollection());
+  KStdAction::redo(this, TQT_SLOT(editRedo()), actionCollection());
   enableUndo(false);
   enableRedo(false);
 
 //Speech
-  TDEToggleAction* t = new TDEToggleAction(i18n("&No Sound"), 0, TQT_TQOBJECT(this), TQT_SLOT(soundOff()), actionCollection(), "speech_no_sound");
+  TDEToggleAction* t = new TDEToggleAction(i18n("&No Sound"), 0, this, TQT_SLOT(soundOff()), actionCollection(), "speech_no_sound");
   if (!soundEnabled) t->setChecked(true);
 
   setupGUI();
diff --git a/libksirtet/base/kzoommainwindow.cpp b/libksirtet/base/kzoommainwindow.cpp
index 758d73d6..c0c7fc92 100644
--- a/libksirtet/base/kzoommainwindow.cpp
+++ b/libksirtet/base/kzoommainwindow.cpp
@@ -30,11 +30,11 @@ KZoomMainWindow::KZoomMainWindow(uint min, uint max, uint step, const char *name
 {
   installEventFilter(this);
   
-  _zoomInAction = KStdAction::zoomIn(TQT_TQOBJECT(this), TQT_SLOT(zoomIn()), actionCollection());
+  _zoomInAction = KStdAction::zoomIn(this, TQT_SLOT(zoomIn()), actionCollection());
   _zoomOutAction =
-    KStdAction::zoomOut(TQT_TQOBJECT(this), TQT_SLOT(zoomOut()), actionCollection());
+    KStdAction::zoomOut(this, TQT_SLOT(zoomOut()), actionCollection());
   _menu =
-    KStdAction::showMenubar(TQT_TQOBJECT(this), TQT_SLOT(toggleMenubar()), actionCollection());
+    KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
 }
 
 void KZoomMainWindow::init(const char *popupName)
diff --git a/libksirtet/base/main.cpp b/libksirtet/base/main.cpp
index e9f576f1..a1a938b9 100644
--- a/libksirtet/base/main.cpp
+++ b/libksirtet/base/main.cpp
@@ -24,20 +24,20 @@ BaseMainWindow::BaseMainWindow()
     KNotifyClient::startDaemon();
 
     // File & Popup
-    KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(start()), actionCollection());
-    _pause = KStdGameAction::pause(TQT_TQOBJECT(this), TQT_SLOT(pause()), actionCollection());
+    KStdGameAction::gameNew(this, TQT_SLOT(start()), actionCollection());
+    _pause = KStdGameAction::pause(this, TQT_SLOT(pause()), actionCollection());
     _pause->setEnabled(false);
-    KStdGameAction::highscores(TQT_TQOBJECT(this), TQT_SLOT(showHighscores()),
+    KStdGameAction::highscores(this, TQT_SLOT(showHighscores()),
                                actionCollection());
-    KStdGameAction::quit(TQT_TQOBJECT(tqApp), TQT_SLOT(quit()), actionCollection());
+    KStdGameAction::quit(tqApp, TQT_SLOT(quit()), actionCollection());
 
     // Settings
-    KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(configureSettings()),
+    KStdAction::preferences(this, TQT_SLOT(configureSettings()),
                             actionCollection());
-    KStdAction::keyBindings(TQT_TQOBJECT(this), TQT_SLOT(configureKeys()), actionCollection());
-    KStdAction::configureNotifications(TQT_TQOBJECT(this), TQT_SLOT(configureNotifications()),
+    KStdAction::keyBindings(this, TQT_SLOT(configureKeys()), actionCollection());
+    KStdAction::configureNotifications(this, TQT_SLOT(configureNotifications()),
                                        actionCollection());
-    KStdGameAction::configureHighscores(TQT_TQOBJECT(this), TQT_SLOT(configureHighscores()),
+    KStdGameAction::configureHighscores(this, TQT_SLOT(configureHighscores()),
                                         actionCollection());
 
     _inter = bfactory->createInterface(this);
diff --git a/libksirtet/common/main.cpp b/libksirtet/common/main.cpp
index f869cb1c..3553e9c1 100644
--- a/libksirtet/common/main.cpp
+++ b/libksirtet/common/main.cpp
@@ -25,17 +25,17 @@ void MainWindow::init()
     // Modes
     bool ama = ( bfactory->bbi.nbArcadeStages!=0 );
     TQString s = (ama ? i18n("&Single Human (Normal)") : i18n("&Single Human"));
-    (void)new TDEAction(s, 0, TQT_TQOBJECT(inter), TQT_SLOT(normalGame()),
+    (void)new TDEAction(s, 0, inter, TQT_SLOT(normalGame()),
                       actionCollection(), "mp_single_human");
     if (ama) (void)new TDEAction(i18n("&Single Human (Arcade)"), 0,
-                               TQT_TQOBJECT(inter), TQT_SLOT(arcadeGame()),
+                               inter, TQT_SLOT(arcadeGame()),
                                actionCollection(), "mp_arcade");
-    (void)new TDEAction(i18n("Human vs &Human"), 0, TQT_TQOBJECT(inter), TQT_SLOT(humanVsHuman()),
+    (void)new TDEAction(i18n("Human vs &Human"), 0, inter, TQT_SLOT(humanVsHuman()),
                       actionCollection(), "mp_human_vs_human");
     (void)new TDEAction(i18n("Human vs &Computer"), 0,
-                      TQT_TQOBJECT(inter), TQT_SLOT(humanVsComputer()),
+                      inter, TQT_SLOT(humanVsComputer()),
                       actionCollection(), "mp_human_vs_computer");
-    (void)new TDEAction(i18n("&More..."), 0, TQT_TQOBJECT(inter), TQT_SLOT(dialog()),
+    (void)new TDEAction(i18n("&More..."), 0, inter, TQT_SLOT(dialog()),
                       actionCollection(), "mp_more");
 
     buildGUI(inter);
diff --git a/libksirtet/common/misc_ui.cpp b/libksirtet/common/misc_ui.cpp
index c95b1b6b..e9adf4cb 100644
--- a/libksirtet/common/misc_ui.cpp
+++ b/libksirtet/common/misc_ui.cpp
@@ -161,7 +161,7 @@ uint GiftPool::take()
 
 void GiftPool::reset()
 {
-    TQT_TQOBJECT(this)->killTimers();
+    this->killTimers();
     ready = false;
     nb = 0;
     for (uint i=0; i<leds.size(); i++) {
diff --git a/libksirtet/lib/keys.cpp b/libksirtet/lib/keys.cpp
index 5d250680..b6cc99cd 100644
--- a/libksirtet/lib/keys.cpp
+++ b/libksirtet/lib/keys.cpp
@@ -49,7 +49,7 @@ void KeyData::createActionCollection(uint index, TQWidget *receiver)
         TQString name = TQString("%2 %3").arg(index+1).arg(_data[k].name);
         const char *slot = (_data[k].slotRelease ? 0 : _data[k].slot);
         TDEAction *a = new TDEAction(label, _keycodes[_cols.size()-1][index][k],
-                                 TQT_TQOBJECT(receiver), slot, _cols[index], name.utf8());
+                                 receiver, slot, _cols[index], name.utf8());
         a->setEnabled(false);
         if ( slot==0 ) {
             SpecialData data;
diff --git a/libksirtet/lib/mp_interface.cpp b/libksirtet/lib/mp_interface.cpp
index 1ad8a572..559f0d7e 100644
--- a/libksirtet/lib/mp_interface.cpp
+++ b/libksirtet/lib/mp_interface.cpp
@@ -29,7 +29,7 @@ MPInterface::MPInterface(const MPGameInfo &_gameInfo,
     hbl = new TQHBoxLayout(this, 0, 5);
 	hbl->setResizeMode( TQLayout::Fixed );
 
-    _keyData = new KeyData(gameInfo.maxNbLocalPlayers, nbActions, data, TQT_TQOBJECT(this));
+    _keyData = new KeyData(gameInfo.maxNbLocalPlayers, nbActions, data, this);
 }
 
 MPInterface::~MPInterface()
diff --git a/libksirtet/lib/wizard.cpp b/libksirtet/lib/wizard.cpp
index 68537602..891a0c6d 100644
--- a/libksirtet/lib/wizard.cpp
+++ b/libksirtet/lib/wizard.cpp
@@ -81,10 +81,10 @@ void MPWizard::setupLocalPage(const MPGameInfo &gi)
 	localPage->setMargin(KDialogBase::marginHint());
 
 	wl = new WidgetList<PlayerLine>(5, localPage);
-	TQSignalMapper *husm = new TQSignalMapper(TQT_TQOBJECT(this));
+	TQSignalMapper *husm = new TQSignalMapper(this);
 	if (gi.humanSettingSlot) connect(husm, TQT_SIGNAL(mapped(int)),
 									 gi.humanSettingSlot);
-	TQSignalMapper *aism = new TQSignalMapper(TQT_TQOBJECT(this));
+	TQSignalMapper *aism = new TQSignalMapper(this);
 	if (gi.AISettingSlot) connect(aism, TQT_SIGNAL(mapped(int)), gi.AISettingSlot);
 
     TDEConfigGroupSaver cg(kapp->config(), MP_GROUP);
@@ -102,9 +102,9 @@ void MPWizard::setupLocalPage(const MPGameInfo &gi)
 		pl = new PlayerLine(type, n, gi.humanSettingSlot, gi.AISettingSlot,
 							i!=0, gi.AIAllowed, wl);
 		connect(pl, TQT_SIGNAL(typeChanged(int)), TQT_SLOT(lineTypeChanged(int)));
-		husm->setMapping(TQT_TQOBJECT(pl), i);
+		husm->setMapping(pl, i);
 		connect(pl, TQT_SIGNAL(setHuman()), husm, TQT_SLOT(map()));
-		aism->setMapping(TQT_TQOBJECT(pl), i);
+		aism->setMapping(pl, i);
 		connect(pl, TQT_SIGNAL(setAI()), aism, TQT_SLOT(map()));
 		wl->append(pl);
 	}
diff --git a/lskat/lskat/lskat.cpp b/lskat/lskat/lskat.cpp
index 4774855b..6659879f 100644
--- a/lskat/lskat/lskat.cpp
+++ b/lskat/lskat/lskat.cpp
@@ -73,7 +73,7 @@ LSkatApp::LSkatApp() : TDEMainWindow(0)
   // Needs to be after readOptions as we read in default paths
   doc->LoadGrafix(mGrafix);
 
-  mInput=new KEInput(TQT_TQOBJECT(this));
+  mInput=new KEInput(this);
   doc->SetInputHandler(mInput);
   connect(mInput,TQT_SIGNAL(signalPrepareProcessMove(KEMessage *)),
           this,TQT_SLOT(slotPrepareProcessMove(KEMessage *)));
@@ -158,26 +158,26 @@ void LSkatApp::initGUI()
 {
   TQStringList list;
 
-  (void)KStdAction::openNew(TQT_TQOBJECT(this), TQT_SLOT(slotFileNew()), actionCollection(), "new_game");
+  (void)KStdAction::openNew(this, TQT_SLOT(slotFileNew()), actionCollection(), "new_game");
   ACTION("new_game")->setStatusText(i18n("Starting a new game..."));
   ACTION("new_game")->setWhatsThis(i18n("Starting a new game..."));
-  (void)new TDEAction(i18n("&End Game"),"process-stop", 0, TQT_TQOBJECT(this), TQT_SLOT(slotFileEnd()),
+  (void)new TDEAction(i18n("&End Game"),"process-stop", 0, this, TQT_SLOT(slotFileEnd()),
                       actionCollection(), "end_game");
   ACTION("end_game")->setStatusText(i18n("Ending the current game..."));
   ACTION("end_game")->setWhatsThis(i18n("Aborts a currently played game. No winner will be declared."));
-  (void)new TDEAction(i18n("&Clear Statistics"),"flag", 0, TQT_TQOBJECT(this), TQT_SLOT(slotFileStatistics()),
+  (void)new TDEAction(i18n("&Clear Statistics"),"flag", 0, this, TQT_SLOT(slotFileStatistics()),
                       actionCollection(), "clear_statistics");
   ACTION("clear_statistics")->setStatusText(i18n("Delete all time statistics..."));
   ACTION("clear_statistics")->setWhatsThis(i18n("Clears the all time statistics which is kept in all sessions."));
-  (void)new TDEAction(i18n("Send &Message..."), CTRL+Key_M, TQT_TQOBJECT(this), TQT_SLOT(slotFileMessage()),
+  (void)new TDEAction(i18n("Send &Message..."), CTRL+Key_M, this, TQT_SLOT(slotFileMessage()),
                       actionCollection(), "send_message");
   ACTION("send_message")->setStatusText(i18n("Sending message to remote player..."));
   ACTION("send_message")->setWhatsThis(i18n("Allows you to talk with a remote player."));
-  (void)KStdAction::quit(TQT_TQOBJECT(this), TQT_SLOT(slotFileQuit()), actionCollection(), "game_exit");
+  (void)KStdAction::quit(this, TQT_SLOT(slotFileQuit()), actionCollection(), "game_exit");
   ACTION("game_exit")->setStatusText(i18n("Exiting..."));
   ACTION("game_exit")->setWhatsThis(i18n("Quits the program."));
 
-  (void)new TDESelectAction(i18n("Starting Player"),0,TQT_TQOBJECT(this),TQT_SLOT(slotStartplayer()),
+  (void)new TDESelectAction(i18n("Starting Player"),0,this,TQT_SLOT(slotStartplayer()),
                       actionCollection(), "startplayer");
   ACTION("startplayer")->setStatusText(i18n("Changing starting player..."));
   ACTION("startplayer")->setWhatsThis(i18n("Chooses which player begins the next game."));
@@ -186,7 +186,7 @@ void LSkatApp::initGUI()
   list.append(i18n("Player &2"));
   ((TDESelectAction *)ACTION("startplayer"))->setItems(list);
 
-  (void)new TDESelectAction(i18n("Player &1 Played By"),0,TQT_TQOBJECT(this),TQT_SLOT(slotPlayer1By()),
+  (void)new TDESelectAction(i18n("Player &1 Played By"),0,this,TQT_SLOT(slotPlayer1By()),
                       actionCollection(), "player1");
   ACTION("player1")->setStatusText(i18n("Changing who plays player 1..."));
   ACTION("player1")->setWhatsThis(i18n("Changing who plays player 1..."));
@@ -195,13 +195,13 @@ void LSkatApp::initGUI()
   list.append(i18n("&Computer"));
   list.append(i18n("&Remote"));
   ((TDESelectAction *)ACTION("player1"))->setItems(list);
-  (void)new TDESelectAction(i18n("Player &2 Played By"),0,TQT_TQOBJECT(this),TQT_SLOT(slotPlayer2By()),
+  (void)new TDESelectAction(i18n("Player &2 Played By"),0,this,TQT_SLOT(slotPlayer2By()),
                       actionCollection(), "player2");
   ACTION("player1")->setStatusText(i18n("Changing who plays player 2..."));
   ACTION("player1")->setWhatsThis(i18n("Changing who plays player 2..."));
   ((TDESelectAction *)ACTION("player2"))->setItems(list);
 
-  (void)new TDESelectAction(i18n("&Level"),0,TQT_TQOBJECT(this),TQT_SLOT(slotLevel()),
+  (void)new TDESelectAction(i18n("&Level"),0,this,TQT_SLOT(slotLevel()),
                       actionCollection(), "choose_level");
   ACTION("choose_level")->setStatusText(i18n("Change level..."));
   ACTION("choose_level")->setWhatsThis(i18n("Change the strength of the computer player."));
@@ -211,12 +211,12 @@ void LSkatApp::initGUI()
   list.append(i18n("&Hard"));
   ((TDESelectAction *)ACTION("choose_level"))->setItems(list);
 
-  (void)new TDEAction(i18n("Select &Card Deck..."), 0, TQT_TQOBJECT(this), TQT_SLOT(slotOptionsCardDeck()),
+  (void)new TDEAction(i18n("Select &Card Deck..."), 0, this, TQT_SLOT(slotOptionsCardDeck()),
                       actionCollection(), "select_carddeck");
   ACTION("select_carddeck")->setStatusText(i18n("Configure card decks..."));
   ACTION("select_carddeck")->setWhatsThis(i18n("Choose how the cards should look."));
 
-  (void)new TDEAction(i18n("Change &Names..."), 0, TQT_TQOBJECT(this), TQT_SLOT(slotOptionsNames()),
+  (void)new TDEAction(i18n("Change &Names..."), 0, this, TQT_SLOT(slotOptionsNames()),
                       actionCollection(), "change_names");
   ACTION("change_names")->setStatusText(i18n("Configure player names..."));
   ACTION("change_names")->setWhatsThis(i18n("Configure player names..."));
@@ -243,7 +243,7 @@ void LSkatApp::initStatusBar()
 
   // computer move timer
   procTimer=new TQTimer(this);
-  connect(procTimer,TQT_SIGNAL(timeout()),TQT_TQOBJECT(this),TQT_SLOT(slotProcTimer()));
+  connect(procTimer,TQT_SIGNAL(timeout()),this,TQT_SLOT(slotProcTimer()));
 }
 
 void LSkatApp::initDocument()
diff --git a/twin4/twin4/twin4.cpp b/twin4/twin4/twin4.cpp
index d97d31f2..391f1a9e 100644
--- a/twin4/twin4/twin4.cpp
+++ b/twin4/twin4/twin4.cpp
@@ -188,50 +188,50 @@ void Kwin4App::checkMenus(CheckFlags menu)
  */
 void Kwin4App::initGUI()
 {
-  KStdGameAction::gameNew(TQT_TQOBJECT(this), TQT_SLOT(newGame()), actionCollection(), "new_game");
+  KStdGameAction::gameNew(this, TQT_SLOT(newGame()), actionCollection(), "new_game");
   ACTION("new_game")->setStatusText(i18n("Start a new game"));
 
-  KStdGameAction::load(TQT_TQOBJECT(this), TQT_SLOT(slotOpenGame()), actionCollection(), "open");
+  KStdGameAction::load(this, TQT_SLOT(slotOpenGame()), actionCollection(), "open");
   ACTION("open")->setStatusText(i18n("Open a saved game..."));
 
-  KStdGameAction::save(TQT_TQOBJECT(this), TQT_SLOT(slotSaveGame()), actionCollection(), "save");
+  KStdGameAction::save(this, TQT_SLOT(slotSaveGame()), actionCollection(), "save");
   ACTION("save")->setStatusText(i18n("Save a game..."));
 
-  KStdGameAction::end(TQT_TQOBJECT(this), TQT_SLOT(endGame()), actionCollection(), "end_game");
+  KStdGameAction::end(this, TQT_SLOT(endGame()), actionCollection(), "end_game");
   ACTION("end_game")->setStatusText(i18n("Ending the current game..."));
   ACTION("end_game")->setWhatsThis(i18n("Aborts a currently played game. No winner will be declared."));
 
-  new TDEAction(i18n("&Network Configuration..."),0, TQT_TQOBJECT(this), TQT_SLOT(slotInitNetwork()),
+  new TDEAction(i18n("&Network Configuration..."),0, this, TQT_SLOT(slotInitNetwork()),
                        actionCollection(), "network_conf");
 
-  new TDEAction(i18n("Network Chat..."),0, TQT_TQOBJECT(this), TQT_SLOT(slotChat()),
+  new TDEAction(i18n("Network Chat..."),0, this, TQT_SLOT(slotChat()),
                        actionCollection(), "network_chat");
 
   if (global_debug>0)                     
-    new TDEAction(i18n("Debug KGame"), 0, TQT_TQOBJECT(this), TQT_SLOT(slotDebugKGame()),
+    new TDEAction(i18n("Debug KGame"), 0, this, TQT_SLOT(slotDebugKGame()),
                         actionCollection(), "file_debug");
 
-  new TDEAction(i18n("&Show Statistics"),"flag", 0, TQT_TQOBJECT(this),
+  new TDEAction(i18n("&Show Statistics"),"flag", 0, this,
            TQT_SLOT(showStatistics()), actionCollection(), "statistics");
   ACTION("statistics")->setStatusText(i18n("Show statistics."));
 
-  KStdGameAction::hint(TQT_TQOBJECT(doc), TQT_SLOT(calcHint()), actionCollection(), "hint");
+  KStdGameAction::hint(doc, TQT_SLOT(calcHint()), actionCollection(), "hint");
   ACTION("hint")->setStatusText(i18n("Shows a hint on how to move."));
 
-  KStdGameAction::quit(TQT_TQOBJECT(this), TQT_SLOT(close()), actionCollection(), "game_exit");
+  KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection(), "game_exit");
   ACTION("game_exit")->setStatusText(i18n("Quits the program."));
 
-  KStdGameAction::undo(TQT_TQOBJECT(this), TQT_SLOT(slotUndo()), actionCollection(), "edit_undo");
+  KStdGameAction::undo(this, TQT_SLOT(slotUndo()), actionCollection(), "edit_undo");
   ACTION("edit_undo")->setStatusText(i18n("Undo last move."));
 
-  KStdGameAction::redo(TQT_TQOBJECT(this), TQT_SLOT(slotRedo()), actionCollection(), "edit_redo");
+  KStdGameAction::redo(this, TQT_SLOT(slotRedo()), actionCollection(), "edit_redo");
   ACTION("edit_redo")->setStatusText(i18n("Redo last move."));
   
   actionCollection()->setHighlightingEnabled(true);
   connect(actionCollection(), TQT_SIGNAL(actionStatusText(const TQString &)), TQT_SLOT(slotStatusMsg(const TQString &)));
   connect(actionCollection(), TQT_SIGNAL(clearStatusText()), TQT_SLOT(slotClearStatusText()));
 
-  KStdAction::preferences(TQT_TQOBJECT(this), TQT_SLOT(showSettings()), actionCollection());
+  KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
 }
 
 /**
@@ -542,8 +542,8 @@ void Kwin4App::slotInitNetwork()
   TQVBoxLayout *l=(TQVBoxLayout *)(box->layout());
 
   mColorGroup=new TQVButtonGroup(box);
-  connect(mColorGroup, TQT_SIGNAL(clicked(int)), TQT_TQOBJECT(this), TQT_SLOT(slotRemoteChanged(int)));
-  connect(dlg.networkConfig(), TQT_SIGNAL(signalServerTypeChanged(int)), TQT_TQOBJECT(this), TQT_SLOT(slotServerTypeChanged(int)));
+  connect(mColorGroup, TQT_SIGNAL(clicked(int)), this, TQT_SLOT(slotRemoteChanged(int)));
+  connect(dlg.networkConfig(), TQT_SIGNAL(signalServerTypeChanged(int)), this, TQT_SLOT(slotServerTypeChanged(int)));
 
   new TQRadioButton(i18n("Yellow should be played by remote"), mColorGroup);
   new TQRadioButton(i18n("Red should be played by remote"), mColorGroup);
diff --git a/twin4/twin4/twin4doc.cpp b/twin4/twin4/twin4doc.cpp
index 4014043a..1ee5e25b 100644
--- a/twin4/twin4/twin4doc.cpp
+++ b/twin4/twin4/twin4doc.cpp
@@ -36,7 +36,7 @@
 #include "prefs.h"
 #include "statuswidget.h"
 
-Kwin4Doc::Kwin4Doc(TQWidget *parent, const char *) : KGame(1234,TQT_TQOBJECT(parent)), pView(0), mHintProcess(0)
+Kwin4Doc::Kwin4Doc(TQWidget *parent, const char *) : KGame(1234,parent), pView(0), mHintProcess(0)
 {
   connect(this,TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *,KGame *)),
           this,TQT_SLOT(slotPropertyChanged(KGamePropertyBase *,KGame *)));
diff --git a/twin4/twin4/twin4view.cpp b/twin4/twin4/twin4view.cpp
index 81bb159b..d1996db9 100644
--- a/twin4/twin4/twin4view.cpp
+++ b/twin4/twin4/twin4view.cpp
@@ -129,13 +129,13 @@ Kwin4View::Kwin4View(Kwin4Doc *theDoc, TQWidget *parent, const char *name)
   //setBackgroundMode(PaletteBase);
   setBackgroundColor(TQColor(0,0,128));
 
-  mCanvas=new TQCanvas(TQT_TQOBJECT(parent));
+  mCanvas=new TQCanvas(parent);
   mCanvas->resize(parent->width(),parent->height()); 
   mCanvas->setDoubleBuffering(true);
   mCanvas->setBackgroundColor(TQColor(0,0,128));
   setCanvas(mCanvas);
 
-  mCache=new KSpriteCache(mGrafix,TQT_TQOBJECT(this));
+  mCache=new KSpriteCache(mGrafix,this);
   mCache->setCanvas(mCanvas);
   TDEConfig *config=mCache->config();