TDE
/
tdegames
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdegames
0
0
Fork 0
Code Issues Releases Wiki Activity

Use new TQ_METHOD, TQ_SIGNAL, TQ_SLOT defines

Browse Source 
Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/31/head
Michele Calgaro 10 months ago
parent 51f6542777
commit c20f4d8f2c
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF
187 changed files with 1831 additions and 1831 deletions
Show Stats Download Patch File Download Diff File

4
atlantik/atlanticd/atlanticclient.cpp
Unescape View File

@ -22,7 +22,7 @@
AtlanticClient::AtlanticClient(TQObject *parent, const char *name) : TQSocket(parent, name)
{
connect(this, TQT_SIGNAL(readyRead()), this, TQT_SLOT(readData()));
connect(this, TQ_SIGNAL(readyRead()), this, TQ_SLOT(readData()));
}
void AtlanticClient::sendData(const TQString &data)
@ -37,7 +37,7 @@ void AtlanticClient::readData()
emit clientInput(this, readLine());
// There might be more data
TQTimer::singleShot(0, this, TQT_SLOT(readData()));
TQTimer::singleShot(0, this, TQ_SLOT(readData()));
}
else
{

8
atlantik/atlanticd/atlanticdaemon.cpp
Unescape View File

@ -28,13 +28,13 @@
AtlanticDaemon::AtlanticDaemon()
{
m_serverSocket = new ServerSocket(1234, 100);
connect(m_serverSocket, TQT_SIGNAL(newClient(AtlanticClient *)), this, TQT_SLOT(newClient(AtlanticClient *)));
connect(m_serverSocket, TQ_SIGNAL(newClient(AtlanticClient *)), this, TQ_SLOT(newClient(AtlanticClient *)));
m_atlanticCore = new AtlanticCore(this, "atlanticCore");
// Create socket for Monopigator
m_monopigatorSocket = new TQSocket();
connect(m_monopigatorSocket, TQT_SIGNAL(connected()), this, TQT_SLOT(monopigatorConnected()));
connect(m_monopigatorSocket, TQ_SIGNAL(connected()), this, TQ_SLOT(monopigatorConnected()));
// Register server
monopigatorRegister();
@ -57,14 +57,14 @@ void AtlanticDaemon::monopigatorConnected()
m_monopigatorSocket->close();
// Monopigator clears old entries, so keep registering every 180s
TQTimer::singleShot(180000, this, TQT_SLOT(monopigatorRegister()));
TQTimer::singleShot(180000, this, TQ_SLOT(monopigatorRegister()));
}
void AtlanticDaemon::newClient(AtlanticClient *client)
{
m_clients.append(client);
connect(client, TQT_SIGNAL(clientInput(AtlanticClient *, const TQString &)), this, TQT_SLOT(clientInput(AtlanticClient *, const TQString &)));
connect(client, TQ_SIGNAL(clientInput(AtlanticClient *, const TQString &)), this, TQ_SLOT(clientInput(AtlanticClient *, const TQString &)));
}
void AtlanticDaemon::clientInput(AtlanticClient *client, const TQString &data)

146
atlantik/client/atlantik.cpp
Unescape View File

@ -67,12 +67,12 @@
LogTextEdit::LogTextEdit( TQWidget *parent, const char *name ) : TQTextEdit( parent, name )
{
#ifdef KDE_3_2_FEATURES
m_clear = KStdAction::clear( this, TQT_SLOT( clear() ), 0 );
m_clear = KStdAction::clear( this, TQ_SLOT( clear() ), 0 );
#else
m_clear = new TDEAction( i18n("Clear"), "clear", NULL, this, TQT_SLOT( clear() ), static_cast<TDEActionCollection *>(0), "clear" );
m_clear = new TDEAction( i18n("Clear"), "clear", NULL, this, TQ_SLOT( clear() ), static_cast<TDEActionCollection *>(0), "clear" );
#endif
m_selectAll = KStdAction::selectAll( this, TQT_SLOT( selectAll() ), 0 );
m_copy = KStdAction::copy( this, TQT_SLOT( copy() ), 0 );
m_selectAll = KStdAction::selectAll( this, TQ_SLOT( selectAll() ), 0 );
m_copy = KStdAction::copy( this, TQ_SLOT( copy() ), 0 );
}
LogTextEdit::~LogTextEdit()
@ -102,13 +102,13 @@ Atlantik::Atlantik ()
readConfig();
// Toolbar: Game
// KStdGameAction::gameNew(this, TQT_SLOT(slotNewGame()), actionCollection(), "game_new");
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");
// KStdGameAction::gameNew(this, TQ_SLOT(slotNewGame()), actionCollection(), "game_new");
m_showEventLog = new TDEAction(i18n("Show Event &Log")/*, "atlantik_showeventlog"*/, CTRL+Key_L, this, TQ_SLOT(showEventLog()), actionCollection(), "showeventlog");
KStdGameAction::quit(kapp, TQ_SLOT(closeAllWindows()), actionCollection(), "game_quit");
// Toolbar: Settings
KStdAction::preferences(this, TQT_SLOT(slotConfigure()), actionCollection());
KStdAction::configureNotifications(this, TQT_SLOT(configureNotifications()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(slotConfigure()), actionCollection());
KStdAction::configureNotifications(this, TQ_SLOT(configureNotifications()), actionCollection());
// Initialize pointers to 0L
m_configDialog = 0;
@ -121,28 +121,28 @@ Atlantik::Atlantik ()
// Game and network core
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 *)));
connect(m_atlanticCore, TQ_SIGNAL(createGUI(Player *)), this, TQ_SLOT(newPlayer(Player *)));
connect(m_atlanticCore, TQ_SIGNAL(removeGUI(Player *)), this, TQ_SLOT(removeGUI(Player *)));
connect(m_atlanticCore, TQ_SIGNAL(createGUI(Trade *)), this, TQ_SLOT(newTrade(Trade *)));
connect(m_atlanticCore, TQ_SIGNAL(removeGUI(Trade *)), this, TQ_SLOT(removeGUI(Trade *)));
initEventLog();
initNetworkObject();
// Menu,toolbar: Move
m_roll = KStdGameAction::roll(this, TQT_SIGNAL(rollDice()), actionCollection());
m_roll = KStdGameAction::roll(this, TQ_SIGNAL(rollDice()), actionCollection());
m_roll->setEnabled(false);
m_buyEstate = new TDEAction(i18n("&Buy"), "atlantik_buy_estate", CTRL+Key_B, this, TQT_SIGNAL(buyEstate()), actionCollection(), "buy_estate");
m_buyEstate = new TDEAction(i18n("&Buy"), "atlantik_buy_estate", CTRL+Key_B, this, TQ_SIGNAL(buyEstate()), actionCollection(), "buy_estate");
m_buyEstate->setEnabled(false);
m_auctionEstate = new TDEAction(i18n("&Auction"), "auction", CTRL+Key_A, this, TQT_SIGNAL(auctionEstate()), actionCollection(), "auction");
m_auctionEstate = new TDEAction(i18n("&Auction"), "auction", CTRL+Key_A, this, TQ_SIGNAL(auctionEstate()), actionCollection(), "auction");
m_auctionEstate->setEnabled(false);
m_endTurn = KStdGameAction::endTurn(this, TQT_SIGNAL(endTurn()), actionCollection());
m_endTurn = KStdGameAction::endTurn(this, TQ_SIGNAL(endTurn()), actionCollection());
m_endTurn->setEnabled(false);
m_jailCard = new TDEAction(i18n("Use Card to Leave Jail")/*, "atlantik_move_jail_card"*/, 0, this, TQT_SIGNAL(jailCard()), actionCollection(), "move_jailcard");
m_jailCard = new TDEAction(i18n("Use Card to Leave Jail")/*, "atlantik_move_jail_card"*/, 0, this, TQ_SIGNAL(jailCard()), actionCollection(), "move_jailcard");
m_jailCard->setEnabled(false);
m_jailPay = new TDEAction(i18n("&Pay to Leave Jail"), "jail_pay", CTRL+Key_P, this, TQT_SIGNAL(jailPay()), actionCollection(), "move_jailpay");
m_jailPay = new TDEAction(i18n("&Pay to Leave Jail"), "jail_pay", CTRL+Key_P, this, TQ_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, this, TQT_SIGNAL(jailRoll()), actionCollection(), "move_jailroll");
m_jailRoll = new TDEAction(i18n("Roll to Leave &Jail")/*, "atlantik_move_jail_roll"*/, CTRL+Key_J, this, TQ_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)), this, TQT_SLOT(statusBarClick(int)));
connect(statusBar(), TQ_SIGNAL(released(int)), this, TQ_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()), this, TQT_SLOT(slotSendMsg()));
connect(m_input, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(slotSendMsg()));
// Set stretching where we want it.
m_mainLayout->setRowStretch(1, 1); // make m_board+m_serverMsgs stretch vertically, not the rest
@ -253,9 +253,9 @@ void Atlantik::newPlayer(Player *player)
// we'd better force an update.
playerChanged(player);
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 *)));
connect(player, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged(Player *)));
connect(player, TQ_SIGNAL(gainedTurn()), this, TQ_SLOT(gainedTurn()));
connect(player, TQ_SIGNAL(changed(Player *)), m_board, TQ_SLOT(playerChanged(Player *)));
KNotifyClient::event(winId(), "newplayer");
}
@ -314,8 +314,8 @@ void Atlantik::showSelectServer()
m_atlanticCore->reset(true);
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 &)), this, TQT_SLOT(slotMsgStatus(const TQString &)));
connect(m_selectServer, TQ_SIGNAL(serverConnect(const TQString, int)), m_atlantikNetwork, TQ_SLOT(serverConnect(const TQString, int)));
connect(m_selectServer, TQ_SIGNAL(msgStatus(const TQString &)), this, TQ_SLOT(slotMsgStatus(const TQString &)));
m_selectServer->slotRefresh( m_config.connectOnStart );
}
@ -354,10 +354,10 @@ void Atlantik::showSelectGame()
m_selectConfiguration = 0;
}
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()), this, TQT_SLOT(showSelectServer()));
connect(m_selectGame, TQT_SIGNAL(msgStatus(const TQString &)), this, TQT_SLOT(slotMsgStatus(const TQString &)));
connect(m_selectGame, TQ_SIGNAL(joinGame(int)), m_atlantikNetwork, TQ_SLOT(joinGame(int)));
connect(m_selectGame, TQ_SIGNAL(newGame(const TQString &)), m_atlantikNetwork, TQ_SLOT(newGame(const TQString &)));
connect(m_selectGame, TQ_SIGNAL(leaveServer()), this, TQ_SLOT(showSelectServer()));
connect(m_selectGame, TQ_SIGNAL(msgStatus(const TQString &)), this, TQ_SLOT(slotMsgStatus(const TQString &)));
}
void Atlantik::showSelectConfiguration()
@ -375,15 +375,15 @@ void Atlantik::showSelectConfiguration()
m_mainLayout->addMultiCellWidget(m_selectConfiguration, 0, 2, 1, 1);
m_selectConfiguration->show();
connect(m_atlanticCore, TQT_SIGNAL(createGUI(ConfigOption *)), m_selectConfiguration, TQT_SLOT(addConfigOption(ConfigOption *)));
connect(m_atlantikNetwork, TQT_SIGNAL(gameOption(TQString, TQString, TQString, TQString, TQString)), m_selectConfiguration, TQT_SLOT(gameOption(TQString, TQString, TQString, TQString, TQString)));
connect(m_atlantikNetwork, TQT_SIGNAL(gameInit()), m_selectConfiguration, TQT_SLOT(initGame()));
connect(m_selectConfiguration, TQT_SIGNAL(startGame()), m_atlantikNetwork, TQT_SLOT(startGame()));
connect(m_selectConfiguration, TQT_SIGNAL(leaveGame()), m_atlantikNetwork, TQT_SLOT(leaveGame()));
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 &)), this, TQT_SLOT(slotMsgStatus(const TQString &)));
connect(m_atlanticCore, TQ_SIGNAL(createGUI(ConfigOption *)), m_selectConfiguration, TQ_SLOT(addConfigOption(ConfigOption *)));
connect(m_atlantikNetwork, TQ_SIGNAL(gameOption(TQString, TQString, TQString, TQString, TQString)), m_selectConfiguration, TQ_SLOT(gameOption(TQString, TQString, TQString, TQString, TQString)));
connect(m_atlantikNetwork, TQ_SIGNAL(gameInit()), m_selectConfiguration, TQ_SLOT(initGame()));
connect(m_selectConfiguration, TQ_SIGNAL(startGame()), m_atlantikNetwork, TQ_SLOT(startGame()));
connect(m_selectConfiguration, TQ_SIGNAL(leaveGame()), m_atlantikNetwork, TQ_SLOT(leaveGame()));
connect(m_selectConfiguration, TQ_SIGNAL(changeOption(int, const TQString &)), m_atlantikNetwork, TQ_SLOT(changeOption(int, const TQString &)));
connect(m_selectConfiguration, TQ_SIGNAL(buttonCommand(TQString)), m_atlantikNetwork, TQ_SLOT(writeData(TQString)));
connect(m_selectConfiguration, TQ_SIGNAL(iconSelected(const TQString &)), m_atlantikNetwork, TQ_SLOT(setImage(const TQString &)));
connect(m_selectConfiguration, TQ_SIGNAL(statusMessage(const TQString &)), this, TQ_SLOT(slotMsgStatus(const TQString &)));
}
void Atlantik::initBoard()
@ -394,11 +394,11 @@ void Atlantik::initBoard()
m_board = new AtlantikBoard(m_atlanticCore, 40, AtlantikBoard::Play, m_mainWidget, "board");
m_board->setViewProperties(m_config.indicateUnowned, m_config.highliteUnowned, m_config.darkenMortgaged, m_config.quartzEffects, m_config.animateTokens);
connect(m_atlantikNetwork, TQT_SIGNAL(displayDetails(TQString, bool, bool, Estate *)), m_board, TQT_SLOT(insertDetails(TQString, bool, bool, Estate *)));
connect(m_atlantikNetwork, TQT_SIGNAL(addCommandButton(TQString, TQString, bool)), m_board, TQT_SLOT(displayButton(TQString, TQString, bool)));
connect(m_atlantikNetwork, TQT_SIGNAL(addCloseButton()), m_board, TQT_SLOT(addCloseButton()));
connect(m_board, TQT_SIGNAL(tokenConfirmation(Estate *)), m_atlantikNetwork, TQT_SLOT(tokenConfirmation(Estate *)));
connect(m_board, TQT_SIGNAL(buttonCommand(TQString)), m_atlantikNetwork, TQT_SLOT(writeData(TQString)));
connect(m_atlantikNetwork, TQ_SIGNAL(displayDetails(TQString, bool, bool, Estate *)), m_board, TQ_SLOT(insertDetails(TQString, bool, bool, Estate *)));
connect(m_atlantikNetwork, TQ_SIGNAL(addCommandButton(TQString, TQString, bool)), m_board, TQ_SLOT(displayButton(TQString, TQString, bool)));
connect(m_atlantikNetwork, TQ_SIGNAL(addCloseButton()), m_board, TQ_SLOT(addCloseButton()));
connect(m_board, TQ_SIGNAL(tokenConfirmation(Estate *)), m_atlantikNetwork, TQ_SLOT(tokenConfirmation(Estate *)));
connect(m_board, TQ_SIGNAL(buttonCommand(TQString)), m_atlantikNetwork, TQ_SLOT(writeData(TQString)));
}
void Atlantik::showBoard()
@ -491,7 +491,7 @@ void Atlantik::slotConfigure()
m_configDialog = new ConfigDialog(this);
m_configDialog->show();
connect(m_configDialog, TQT_SIGNAL(okClicked()), this, TQT_SLOT(slotUpdateConfig()));
connect(m_configDialog, TQ_SIGNAL(okClicked()), this, TQ_SLOT(slotUpdateConfig()));
}
void Atlantik::showEventLog()
@ -728,35 +728,35 @@ void Atlantik::initNetworkObject()
}
m_atlantikNetwork = new AtlantikNetwork(m_atlanticCore);
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, TQ_SIGNAL(msgInfo(TQString)), this, TQ_SLOT(slotMsgInfo(TQString)));
connect(m_atlantikNetwork, TQ_SIGNAL(msgError(TQString)), this, TQ_SLOT(slotMsgError(TQString)));
connect(m_atlantikNetwork, TQ_SIGNAL(msgStatus(const TQString &, const TQString &)), this, TQ_SLOT(slotMsgStatus(const TQString &, const TQString &)));
connect(m_atlantikNetwork, TQ_SIGNAL(msgChat(TQString, TQString)), this, TQ_SLOT(slotMsgChat(TQString, TQString)));
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, TQ_SIGNAL(connectionSuccess()), this, TQ_SLOT(slotNetworkConnected()));
connect(m_atlantikNetwork, TQ_SIGNAL(connectionFailed(int)), this, TQ_SLOT(slotNetworkError(int)));
connect(m_atlantikNetwork, TQ_SIGNAL(closed(int)), this, TQ_SLOT(networkClosed(int)));
connect(m_atlantikNetwork, TQT_SIGNAL(receivedHandshake()), this, TQT_SLOT(sendHandshake()));
connect(m_atlantikNetwork, TQ_SIGNAL(receivedHandshake()), this, TQ_SLOT(sendHandshake()));
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, TQ_SIGNAL(gameConfig()), this, TQ_SLOT(showSelectConfiguration()));
connect(m_atlantikNetwork, TQ_SIGNAL(gameInit()), this, TQ_SLOT(initBoard()));
connect(m_atlantikNetwork, TQ_SIGNAL(gameRun()), this, TQ_SLOT(showBoard()));
connect(m_atlantikNetwork, TQ_SIGNAL(gameEnd()), this, TQ_SLOT(freezeBoard()));
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, TQ_SIGNAL(newEstate(Estate *)), this, TQ_SLOT(newEstate(Estate *)));
connect(m_atlantikNetwork, TQ_SIGNAL(newAuction(Auction *)), this, TQ_SLOT(newAuction(Auction *)));
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(m_atlantikNetwork, TQ_SIGNAL(clientCookie(TQString)), this, TQ_SLOT(clientCookie(TQString)));
connect(m_atlantikNetwork, TQ_SIGNAL(networkEvent(const TQString &, const TQString &)), m_eventLog, TQ_SLOT(addEvent(const TQString &, const TQString &)));
connect(this, TQT_SIGNAL(rollDice()), m_atlantikNetwork, TQT_SLOT(rollDice()));
connect(this, TQT_SIGNAL(buyEstate()), m_atlantikNetwork, TQT_SLOT(buyEstate()));
connect(this, TQT_SIGNAL(auctionEstate()), m_atlantikNetwork, TQT_SLOT(auctionEstate()));
connect(this, TQT_SIGNAL(endTurn()), m_atlantikNetwork, TQT_SLOT(endTurn()));
connect(this, TQT_SIGNAL(jailCard()), m_atlantikNetwork, TQT_SLOT(jailCard()));
connect(this, TQT_SIGNAL(jailPay()), m_atlantikNetwork, TQT_SLOT(jailPay()));
connect(this, TQT_SIGNAL(jailRoll()), m_atlantikNetwork, TQT_SLOT(jailRoll()));
connect(this, TQ_SIGNAL(rollDice()), m_atlantikNetwork, TQ_SLOT(rollDice()));
connect(this, TQ_SIGNAL(buyEstate()), m_atlantikNetwork, TQ_SLOT(buyEstate()));
connect(this, TQ_SIGNAL(auctionEstate()), m_atlantikNetwork, TQ_SLOT(auctionEstate()));
connect(this, TQ_SIGNAL(endTurn()), m_atlantikNetwork, TQ_SLOT(endTurn()));
connect(this, TQ_SIGNAL(jailCard()), m_atlantikNetwork, TQ_SLOT(jailCard()));
connect(this, TQ_SIGNAL(jailPay()), m_atlantikNetwork, TQ_SLOT(jailPay()));
connect(this, TQ_SIGNAL(jailRoll()), m_atlantikNetwork, TQ_SLOT(jailRoll()));
}
void Atlantik::clientCookie(TQString cookie)
@ -812,10 +812,10 @@ PortfolioView *Atlantik::addPortfolioView(Player *player)
if ( m_portfolioViews.count() > 0 && m_portfolioScroll->isHidden() )
m_portfolioScroll->show();
connect(player, TQT_SIGNAL(changed(Player *)), portfolioView, TQT_SLOT(playerChanged()));
connect(portfolioView, TQT_SIGNAL(newTrade(Player *)), m_atlantikNetwork, TQT_SLOT(newTrade(Player *)));
connect(portfolioView, TQT_SIGNAL(kickPlayer(Player *)), m_atlantikNetwork, TQT_SLOT(kickPlayer(Player *)));
connect(portfolioView, TQT_SIGNAL(estateClicked(Estate *)), m_board, TQT_SLOT(prependEstateDetails(Estate *)));
connect(player, TQ_SIGNAL(changed(Player *)), portfolioView, TQ_SLOT(playerChanged()));
connect(portfolioView, TQ_SIGNAL(newTrade(Player *)), m_atlantikNetwork, TQ_SLOT(newTrade(Player *)));
connect(portfolioView, TQ_SIGNAL(kickPlayer(Player *)), m_atlantikNetwork, TQ_SLOT(kickPlayer(Player *)));
connect(portfolioView, TQ_SIGNAL(estateClicked(Estate *)), m_board, TQ_SLOT(prependEstateDetails(Estate *)));
m_portfolioLayout->addWidget(portfolioView);
portfolioView->show();

2
atlantik/client/configdlg.cpp
Unescape View File

@ -128,7 +128,7 @@ ConfigPlayer::ConfigPlayer(ConfigDialog* configDialog, TQWidget *parent, const c
m_playerIcon = new KPushButton(parent, "playerIcon");
layout->addWidget(m_playerIcon);
connect( m_playerIcon, TQT_SIGNAL(clicked()), this, TQT_SLOT(chooseImage()) );
connect( m_playerIcon, TQ_SIGNAL(clicked()), this, TQ_SLOT(chooseImage()) );
layout->addStretch(1);

4
atlantik/client/eventlogwidget.cpp
Unescape View File

@ -54,7 +54,7 @@ EventLogWidget::EventLogWidget(EventLog *eventLog, TQWidget *parent, const char
{
m_eventLog = eventLog;
connect(m_eventLog, TQT_SIGNAL(newEvent(Event *)), this, TQT_SLOT(addEvent(Event *)));
connect(m_eventLog, TQ_SIGNAL(newEvent(Event *)), this, TQ_SLOT(addEvent(Event *)));
setCaption(i18n("Event Log"));
@ -75,7 +75,7 @@ EventLogWidget::EventLogWidget(EventLog *eventLog, TQWidget *parent, const char
m_saveButton = new KPushButton(BarIcon("document-save", TDEIcon::SizeSmall), i18n("&Save As..."), this);
actionBox->addWidget(m_saveButton);
connect(m_saveButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(save()));
connect(m_saveButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(save()));
// Populate
TQPtrList<Event> events = m_eventLog->events();

10
atlantik/client/monopigator.cpp
Unescape View File

@ -54,9 +54,9 @@ void Monopigator::loadData(const KURL &url)
m_timer->start(10000, true);
}
connect(m_job, TQT_SIGNAL(data(TDEIO::Job *, const TQByteArray &)), TQT_SLOT(slotData(TDEIO::Job *, const TQByteArray &)));
connect(m_job, TQT_SIGNAL(result(TDEIO::Job *)), TQT_SLOT(slotResult(TDEIO::Job *)));
connect(m_timer, TQT_SIGNAL(timeout()), TQT_SLOT(slotTimeout()));
connect(m_job, TQ_SIGNAL(data(TDEIO::Job *, const TQByteArray &)), TQ_SLOT(slotData(TDEIO::Job *, const TQByteArray &)));
connect(m_job, TQ_SIGNAL(result(TDEIO::Job *)), TQ_SLOT(slotResult(TDEIO::Job *)));
connect(m_timer, TQ_SIGNAL(timeout()), TQ_SLOT(slotTimeout()));
}
void Monopigator::slotData(TDEIO::Job *, const TQByteArray &data)
@ -118,8 +118,8 @@ MonopigatorEntry::MonopigatorEntry(TQListView *parent, TQString host, TQString l
if ( !ip.isEmpty() )
host = ip;
m_latencySocket = new KExtendedSocket( host, port.toInt(), KExtendedSocket::inputBufferedSocket | KExtendedSocket::noResolve );
connect(m_latencySocket, TQT_SIGNAL(lookupFinished(int)), this, TQT_SLOT(resolved()));
connect(m_latencySocket, TQT_SIGNAL(connectionSuccess()), this, TQT_SLOT(connected()));
connect(m_latencySocket, TQ_SIGNAL(lookupFinished(int)), this, TQ_SLOT(resolved()));
connect(m_latencySocket, TQ_SIGNAL(connectionSuccess()), this, TQ_SLOT(connected()));
m_latencySocket->startAsyncConnect();
}

16
atlantik/client/selectconfiguration_widget.cpp
Unescape View File

@ -61,7 +61,7 @@ SelectConfiguration::SelectConfiguration(AtlanticCore *atlanticCore, TQWidget *p
m_backButton = new KPushButton(SmallIcon("back"), i18n("Leave Game"), this);
serverButtons->addWidget(m_backButton);
connect(m_backButton, TQT_SIGNAL(clicked()), this, TQT_SIGNAL(leaveGame()));
connect(m_backButton, TQ_SIGNAL(clicked()), this, TQ_SIGNAL(leaveGame()));
serverButtons->addItem(new TQSpacerItem(20, 20, TQSizePolicy::Expanding, TQSizePolicy::Minimum));
@ -69,11 +69,11 @@ SelectConfiguration::SelectConfiguration(AtlanticCore *atlanticCore, TQWidget *p
serverButtons->addWidget(m_startButton);
m_startButton->setEnabled(false);
connect(m_startButton, TQT_SIGNAL(clicked()), this, TQT_SIGNAL(startGame()));
connect(m_startButton, TQ_SIGNAL(clicked()), this, TQ_SIGNAL(startGame()));
Player *playerSelf = m_atlanticCore->playerSelf();
playerChanged(playerSelf);
connect(playerSelf, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged(Player *)));
connect(playerSelf, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged(Player *)));
emit statusMessage(i18n("Retrieving configuration list..."));
}
@ -94,8 +94,8 @@ void SelectConfiguration::addConfigOption(ConfigOption *configOption)
checkBox->setEnabled( configOption->edit() && m_atlanticCore->selfIsMaster() );
checkBox->show();
connect(checkBox, TQT_SIGNAL(clicked()), this, TQT_SLOT(changeOption()));
connect(configOption, TQT_SIGNAL(changed(ConfigOption *)), this, TQT_SLOT(optionChanged(ConfigOption *)));
connect(checkBox, TQ_SIGNAL(clicked()), this, TQ_SLOT(changeOption()));
connect(configOption, TQ_SIGNAL(changed(ConfigOption *)), this, TQ_SLOT(optionChanged(ConfigOption *)));
}
void SelectConfiguration::gameOption(TQString title, TQString type, TQString value, TQString edit, TQString command)
@ -118,7 +118,7 @@ void SelectConfiguration::gameOption(TQString title, TQString type, TQString val
checkBox->setEnabled(edit.toInt());
checkBox->show();
connect(checkBox, TQT_SIGNAL(clicked()), this, TQT_SLOT(optionChanged()));
connect(checkBox, TQ_SIGNAL(clicked()), this, TQ_SLOT(optionChanged()));
}
// TODO: create options other than type=bool
@ -171,12 +171,12 @@ void SelectConfiguration::playerChanged(Player *player)
kdDebug() << "playerChanged::change" << endl;
if (m_game)
disconnect(m_game, TQT_SIGNAL(changed(Game *)), this, TQT_SLOT(gameChanged(Game *)));
disconnect(m_game, TQ_SIGNAL(changed(Game *)), this, TQ_SLOT(gameChanged(Game *)));
m_game = player->game();
if (m_game)
connect(m_game, TQT_SIGNAL(changed(Game *)), this, TQT_SLOT(gameChanged(Game *)));
connect(m_game, TQ_SIGNAL(changed(Game *)), this, TQ_SLOT(gameChanged(Game *)));
}
}

22
atlantik/client/selectgame_widget.cpp
Unescape View File

@ -33,8 +33,8 @@ SelectGame::SelectGame(AtlanticCore *atlanticCore, TQWidget *parent, const char
{
m_atlanticCore = atlanticCore;
connect(m_atlanticCore, TQT_SIGNAL(createGUI(Game *)), this, TQT_SLOT(addGame(Game *)));
connect(m_atlanticCore, TQT_SIGNAL(removeGUI(Game *)), this, TQT_SLOT(delGame(Game *)));
connect(m_atlanticCore, TQ_SIGNAL(createGUI(Game *)), this, TQ_SLOT(addGame(Game *)));
connect(m_atlanticCore, TQ_SIGNAL(removeGUI(Game *)), this, TQ_SLOT(delGame(Game *)));
m_mainLayout = new TQVBoxLayout(this, KDialog::marginHint());
TQ_CHECK_PTR(m_mainLayout);
@ -52,17 +52,17 @@ SelectGame::SelectGame(AtlanticCore *atlanticCore, TQWidget *parent, const char
m_gameList->setAllColumnsShowFocus(true);
// m_mainLayout->addWidget(m_gameList);
connect(m_gameList, TQT_SIGNAL(clicked(TQListViewItem *)), this, TQT_SLOT(validateConnectButton()));
connect(m_gameList, TQT_SIGNAL(doubleClicked(TQListViewItem *)), this, TQT_SLOT(connectClicked()));
connect(m_gameList, TQT_SIGNAL(rightButtonClicked(TQListViewItem *, const TQPoint &, int)), this, TQT_SLOT(validateConnectButton()));
connect(m_gameList, TQT_SIGNAL(selectionChanged(TQListViewItem *)), this, TQT_SLOT(validateConnectButton()));
connect(m_gameList, TQ_SIGNAL(clicked(TQListViewItem *)), this, TQ_SLOT(validateConnectButton()));
connect(m_gameList, TQ_SIGNAL(doubleClicked(TQListViewItem *)), this, TQ_SLOT(connectClicked()));
connect(m_gameList, TQ_SIGNAL(rightButtonClicked(TQListViewItem *, const TQPoint &, int)), this, TQ_SLOT(validateConnectButton()));
connect(m_gameList, TQ_SIGNAL(selectionChanged(TQListViewItem *)), this, TQ_SLOT(validateConnectButton()));
TQHBoxLayout *buttonBox = new TQHBoxLayout(m_mainLayout, KDialog::spacingHint());
KPushButton *backButton = new KPushButton(SmallIcon("back"), i18n("Server List"), this);
buttonBox->addWidget(backButton);
connect(backButton, TQT_SIGNAL(clicked()), this, TQT_SIGNAL(leaveServer()));
connect(backButton, TQ_SIGNAL(clicked()), this, TQ_SIGNAL(leaveServer()));
buttonBox->addItem(new TQSpacerItem(20, 20, TQSizePolicy::Expanding, TQSizePolicy::Minimum));
@ -70,13 +70,13 @@ SelectGame::SelectGame(AtlanticCore *atlanticCore, TQWidget *parent, const char
m_connectButton->setEnabled(false);
buttonBox->addWidget(m_connectButton);
connect(m_connectButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(connectClicked()));
connect(m_connectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(connectClicked()));
}
void SelectGame::addGame(Game *game)
{
connect(game, TQT_SIGNAL(changed(Game *)), this, TQT_SLOT(updateGame(Game *)));
connect(game, TQ_SIGNAL(changed(Game *)), this, TQ_SLOT(updateGame(Game *)));
if (game->id() == -1)
{
@ -92,7 +92,7 @@ void SelectGame::addGame(Game *game)
KNotifyClient::event(winId(), "newgame");
connect(master, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged(Player *)));
connect(master, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged(Player *)));
}
// validateConnectButton();
@ -126,7 +126,7 @@ void SelectGame::updateGame(Game *game)
item->setText( 3, TQString::number( game->players() ) );
item->setEnabled( game->canBeJoined() );
connect(master, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged(Player *)));
connect(master, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged(Player *)));
}
m_gameList->triggerUpdate();

22
atlantik/client/selectserver_widget.cpp
Unescape View File

@ -50,7 +50,7 @@ SelectServer::SelectServer(bool useMonopigatorOnStart, bool hideDevelopmentServe
m_portEdit->setSizePolicy(TQSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Minimum));
KPushButton *connectButton = new KPushButton( KGuiItem(i18n("Connect"), "network"), customGroup);
connect(connectButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(customConnect()));
connect(connectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(customConnect()));
// Server list group
TQVButtonGroup *bgroup = new TQVButtonGroup(i18n("Select monopd Server"), this, "bgroup");
@ -67,10 +67,10 @@ SelectServer::SelectServer(bool useMonopigatorOnStart, bool hideDevelopmentServe
m_serverList->setSorting(1);
// m_mainLayout->addWidget(m_serverList);
connect(m_serverList, TQT_SIGNAL(clicked(TQListViewItem *)), this, TQT_SLOT(validateConnectButton()));
connect(m_serverList, TQT_SIGNAL(doubleClicked(TQListViewItem *)), this, TQT_SLOT(slotConnect()));
connect(m_serverList, TQT_SIGNAL(rightButtonClicked(TQListViewItem *, const TQPoint &, int)), this, TQT_SLOT(validateConnectButton()));
connect(m_serverList, TQT_SIGNAL(selectionChanged(TQListViewItem *)), this, TQT_SLOT(validateConnectButton()));
connect(m_serverList, TQ_SIGNAL(clicked(TQListViewItem *)), this, TQ_SLOT(validateConnectButton()));
connect(m_serverList, TQ_SIGNAL(doubleClicked(TQListViewItem *)), this, TQ_SLOT(slotConnect()));
connect(m_serverList, TQ_SIGNAL(rightButtonClicked(TQListViewItem *, const TQPoint &, int)), this, TQ_SLOT(validateConnectButton()));
connect(m_serverList, TQ_SIGNAL(selectionChanged(TQListViewItem *)), this, TQ_SLOT(validateConnectButton()));
TQHBoxLayout *buttonBox = new TQHBoxLayout(m_mainLayout, KDialog::spacingHint());
buttonBox->addItem(new TQSpacerItem(20, 20, TQSizePolicy::Expanding, TQSizePolicy::Minimum));
@ -79,21 +79,21 @@ SelectServer::SelectServer(bool useMonopigatorOnStart, bool hideDevelopmentServe
m_refreshButton = new KPushButton( KGuiItem(useMonopigatorOnStart ? i18n("Reload Server List") : i18n("Get Server List"), useMonopigatorOnStart ? "reload" : "network"), this);
buttonBox->addWidget(m_refreshButton);
connect(m_refreshButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotRefresh()));
connect(m_refreshButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotRefresh()));
// Connect
m_connectButton = new KPushButton(BarIconSet("forward", TDEIcon::SizeSmall), i18n("Connect"), this);
m_connectButton->setEnabled(false);
buttonBox->addWidget(m_connectButton);
connect(m_connectButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotConnect()));
connect(m_connectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotConnect()));
// Monopigator
m_monopigator = new Monopigator();
connect(m_monopigator, TQT_SIGNAL(monopigatorAdd(TQString, TQString, TQString, TQString, int)), this, TQT_SLOT(slotMonopigatorAdd(TQString, TQString, TQString, TQString, int)));
connect(m_monopigator, TQT_SIGNAL(finished()), TQT_SLOT(monopigatorFinished()));
connect(m_monopigator, TQT_SIGNAL(timeout()), TQT_SLOT(monopigatorTimeout()));
connect(m_monopigator, TQ_SIGNAL(monopigatorAdd(TQString, TQString, TQString, TQString, int)), this, TQ_SLOT(slotMonopigatorAdd(TQString, TQString, TQString, TQString, int)));
connect(m_monopigator, TQ_SIGNAL(finished()), TQ_SLOT(monopigatorFinished()));
connect(m_monopigator, TQ_SIGNAL(timeout()), TQ_SLOT(monopigatorTimeout()));
}
SelectServer::~SelectServer()
@ -127,7 +127,7 @@ void SelectServer::slotMonopigatorAdd(TQString ip, TQString host, TQString port,
if ( item->isDev() )
{
item->setVisible( !m_hideDevelopmentServers );
connect(this, TQT_SIGNAL(showDevelopmentServers(bool)), item, TQT_SLOT(showDevelopmentServers(bool)));
connect(this, TQ_SIGNAL(showDevelopmentServers(bool)), item, TQ_SLOT(showDevelopmentServers(bool)));
}
validateConnectButton();

4
atlantik/libatlantic/trade.cpp
Unescape View File

@ -163,8 +163,8 @@ void Trade::update(bool force)
TradeItem::TradeItem(Trade *trade, Player *from, Player *to) : mFrom(from), mTo(to), mTrade(trade)
{
connect(from, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged()));
connect(to, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged()));
connect(from, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged()));
connect(to, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged()));
}
void TradeItem::playerChanged()

36
atlantik/libatlantikclient/atlantik_network.cpp
Unescape View File

@ -43,13 +43,13 @@ AtlantikNetwork::AtlantikNetwork(AtlanticCore *atlanticCore) : KExtendedSocket(0
m_playerId = -1;
m_serverVersion = "";
TQObject::connect(this, TQT_SIGNAL(readyRead()), this, TQT_SLOT(slotRead()));
TQObject::connect(this, TQT_SIGNAL(lookupFinished(int)),
this, TQT_SLOT(slotLookupFinished(int)));
TQObject::connect(this, TQT_SIGNAL(connectionSuccess()),
this, TQT_SLOT(slotConnectionSuccess()));
TQObject::connect(this, TQT_SIGNAL(connectionFailed(int)),
this, TQT_SLOT(slotConnectionFailed(int)));
TQObject::connect(this, TQ_SIGNAL(readyRead()), this, TQ_SLOT(slotRead()));
TQObject::connect(this, TQ_SIGNAL(lookupFinished(int)),
this, TQ_SLOT(slotLookupFinished(int)));
TQObject::connect(this, TQ_SIGNAL(connectionSuccess()),
this, TQ_SLOT(slotConnectionSuccess()));
TQObject::connect(this, TQ_SIGNAL(connectionFailed(int)),
this, TQ_SLOT(slotConnectionFailed(int)));
}
AtlantikNetwork::~AtlantikNetwork(void)
@ -212,7 +212,7 @@ void AtlantikNetwork::slotRead()
{
processMsg(m_textStream->readLine());
// There might be more data
TQTimer::singleShot(0, this, TQT_SLOT(slotRead()));
TQTimer::singleShot(0, this, TQ_SLOT(slotRead()));
}
else
{
@ -614,10 +614,10 @@ void AtlantikNetwork::processNode(TQDomNode n)
estate = m_atlanticCore->newEstate(estateId);
b_newEstate = true;
TQObject::connect(estate, TQT_SIGNAL(estateToggleMortgage(Estate *)), this, TQT_SLOT(estateToggleMortgage(Estate *)));
TQObject::connect(estate, TQT_SIGNAL(estateHouseBuy(Estate *)), this, TQT_SLOT(estateHouseBuy(Estate *)));
TQObject::connect(estate, TQT_SIGNAL(estateHouseSell(Estate *)), this, TQT_SLOT(estateHouseSell(Estate *)));
TQObject::connect(estate, TQT_SIGNAL(newTrade(Player *)), this, TQT_SLOT(newTrade(Player *)));
TQObject::connect(estate, TQ_SIGNAL(estateToggleMortgage(Estate *)), this, TQ_SLOT(estateToggleMortgage(Estate *)));
TQObject::connect(estate, TQ_SIGNAL(estateHouseBuy(Estate *)), this, TQ_SLOT(estateHouseBuy(Estate *)));
TQObject::connect(estate, TQ_SIGNAL(estateHouseSell(Estate *)), this, TQ_SLOT(estateHouseSell(Estate *)));
TQObject::connect(estate, TQ_SIGNAL(newTrade(Player *)), this, TQ_SLOT(newTrade(Player *)));
// Players without estate should get one
Player *player = 0;
@ -723,10 +723,10 @@ void AtlantikNetwork::processNode(TQDomNode n)
// Create trade object
trade = m_atlanticCore->newTrade(tradeId);
TQObject::connect(trade, TQT_SIGNAL(updateEstate(Trade *, Estate *, Player *)), this, TQT_SLOT(tradeUpdateEstate(Trade *, Estate *, Player *)));
TQObject::connect(trade, TQT_SIGNAL(updateMoney(Trade *, unsigned int, Player *, Player *)), this, TQT_SLOT(tradeUpdateMoney(Trade *, unsigned int, Player *, Player *)));
TQObject::connect(trade, TQT_SIGNAL(reject(Trade *)), this, TQT_SLOT(tradeReject(Trade *)));
TQObject::connect(trade, TQT_SIGNAL(accept(Trade *)), this, TQT_SLOT(tradeAccept(Trade *)));
TQObject::connect(trade, TQ_SIGNAL(updateEstate(Trade *, Estate *, Player *)), this, TQ_SLOT(tradeUpdateEstate(Trade *, Estate *, Player *)));
TQObject::connect(trade, TQ_SIGNAL(updateMoney(Trade *, unsigned int, Player *, Player *)), this, TQ_SLOT(tradeUpdateMoney(Trade *, unsigned int, Player *, Player *)));
TQObject::connect(trade, TQ_SIGNAL(reject(Trade *)), this, TQ_SLOT(tradeReject(Trade *)));
TQObject::connect(trade, TQ_SIGNAL(accept(Trade *)), this, TQ_SLOT(tradeAccept(Trade *)));
}
a = e.attributeNode(TQString("revision"));
@ -751,7 +751,7 @@ void AtlantikNetwork::processNode(TQDomNode n)
if (trade && player)
{
trade->addPlayer(player);
TQObject::connect(m_atlanticCore, TQT_SIGNAL(removePlayer(Player *)), trade, TQT_SLOT(removePlayer(Player *)));
TQObject::connect(m_atlanticCore, TQ_SIGNAL(removePlayer(Player *)), trade, TQ_SLOT(removePlayer(Player *)));
}
}
n_player = n_player.nextSibling();
@ -854,7 +854,7 @@ void AtlantikNetwork::processNode(TQDomNode n)
auction = m_atlanticCore->newAuction(auctionId, m_atlanticCore->findEstate(e.attributeNode(TQString("estateid")).value().toInt()));
m_auctions[auctionId] = auction;
TQObject::connect(auction, TQT_SIGNAL(bid(Auction *, int)), this, TQT_SLOT(auctionBid(Auction *, int)));
TQObject::connect(auction, TQ_SIGNAL(bid(Auction *, int)), this, TQ_SLOT(auctionBid(Auction *, int)));
b_newAuction = true;
}

10
atlantik/libatlantikui/auction_widget.cpp
Unescape View File

@ -38,9 +38,9 @@ AuctionWidget::AuctionWidget(AtlanticCore *atlanticCore, Auction *auction, TQWid
m_atlanticCore = atlanticCore;
m_auction = auction;
connect(m_auction, TQT_SIGNAL(changed()), this, TQT_SLOT(auctionChanged()));
connect(m_auction, TQT_SIGNAL(updateBid(Player *, int)), this, TQT_SLOT(updateBid(Player *, int)));
connect(this, TQT_SIGNAL(bid(Auction *, int)), m_auction, TQT_SIGNAL(bid(Auction *, int)));
connect(m_auction, TQ_SIGNAL(changed()), this, TQ_SLOT(auctionChanged()));
connect(m_auction, TQ_SIGNAL(updateBid(Player *, int)), this, TQ_SLOT(updateBid(Player *, int)));
connect(this, TQ_SIGNAL(bid(Auction *, int)), m_auction, TQ_SIGNAL(bid(Auction *, int)));
m_mainLayout = new TQVBoxLayout(this, KDialog::marginHint());
TQ_CHECK_PTR(m_mainLayout);
@ -67,7 +67,7 @@ AuctionWidget::AuctionWidget(AtlanticCore *atlanticCore, Auction *auction, TQWid
item->setPixmap(0, TQPixmap(SmallIcon("preferences-desktop-personal")));
m_playerItems[player] = item;
connect(player, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged(Player *)));
connect(player, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged(Player *)));
}
}
@ -78,7 +78,7 @@ AuctionWidget::AuctionWidget(AtlanticCore *atlanticCore, Auction *auction, TQWid
m_bidSpinBox = new TQSpinBox(1, 10000, 1, bidBox);
KPushButton *bidButton = new KPushButton(i18n("Make Bid"), bidBox, "bidButton");
connect(bidButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotBidButtonClicked()));
connect(bidButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotBidButtonClicked()));
// Status label
m_statusLabel = new TQLabel(this, "statusLabel");

32
atlantik/libatlantikui/board.cpp
Unescape View File

@ -50,7 +50,7 @@ AtlantikBoard::AtlantikBoard(AtlanticCore *atlanticCore, int maxEstates, Display
// Animated token movement
m_movingToken = 0;
m_timer = new TQTimer(this);
connect(m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotMoveToken()));
connect(m_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotMoveToken()));
m_resumeTimer = false;
m_gridLayout = new TQGridLayout(this, sideLen+1, sideLen+1);
@ -142,16 +142,16 @@ void AtlantikBoard::addEstateView(Estate *estate, bool indicateUnowned, bool hig
EstateView *estateView = new EstateView(estate, orientation, icon, indicateUnowned, highliteUnowned, darkenMortgaged, quartzEffects, this, "estateview");
m_estateViews.append(estateView);
connect(estate, TQT_SIGNAL(changed()), estateView, TQT_SLOT(estateChanged()));
connect(estateView, TQT_SIGNAL(estateToggleMortgage(Estate *)), estate, TQT_SIGNAL(estateToggleMortgage(Estate *)));
connect(estateView, TQT_SIGNAL(LMBClicked(Estate *)), estate, TQT_SIGNAL(LMBClicked(Estate *)));
connect(estateView, TQT_SIGNAL(estateHouseBuy(Estate *)), estate, TQT_SIGNAL(estateHouseBuy(Estate *)));
connect(estateView, TQT_SIGNAL(estateHouseSell(Estate *)), estate, TQT_SIGNAL(estateHouseSell(Estate *)));
connect(estateView, TQT_SIGNAL(newTrade(Player *)), estate, TQT_SIGNAL(newTrade(Player *)));
connect(estate, TQ_SIGNAL(changed()), estateView, TQ_SLOT(estateChanged()));
connect(estateView, TQ_SIGNAL(estateToggleMortgage(Estate *)), estate, TQ_SIGNAL(estateToggleMortgage(Estate *)));
connect(estateView, TQ_SIGNAL(LMBClicked(Estate *)), estate, TQ_SIGNAL(LMBClicked(Estate *)));
connect(estateView, TQ_SIGNAL(estateHouseBuy(Estate *)), estate, TQ_SIGNAL(estateHouseBuy(Estate *)));
connect(estateView, TQ_SIGNAL(estateHouseSell(Estate *)), estate, TQ_SIGNAL(estateHouseSell(Estate *)));
connect(estateView, TQ_SIGNAL(newTrade(Player *)), estate, TQ_SIGNAL(newTrade(Player *)));
// Designer has its own LMBClicked slot
if (m_mode == Play)
connect(estateView, TQT_SIGNAL(LMBClicked(Estate *)), this, TQT_SLOT(prependEstateDetails(Estate *)));
connect(estateView, TQ_SIGNAL(LMBClicked(Estate *)), this, TQ_SLOT(prependEstateDetails(Estate *)));
if (estateId<sideLen)
m_gridLayout->addWidget(estateView, sideLen, sideLen-estateId);
@ -181,7 +181,7 @@ void AtlantikBoard::addAuctionWidget(Auction *auction)
m_displayQueue.prepend(auctionW);
updateCenter();
connect(auction, TQT_SIGNAL(completed()), this, TQT_SLOT(displayDefault()));
connect(auction, TQ_SIGNAL(completed()), this, TQ_SLOT(displayDefault()));
}
Token *AtlantikBoard::findToken(Player *player)
@ -215,12 +215,12 @@ void AtlantikBoard::addToken(Player *player)
Token *token = new Token(player, this, "token");
m_tokens.append(token);
connect(player, TQT_SIGNAL(changed(Player *)), token, TQT_SLOT(playerChanged()));
connect(player, TQ_SIGNAL(changed(Player *)), token, TQ_SLOT(playerChanged()));
jumpToken(token);
// Timer to reinit the gameboard _after_ event loop
TQTimer::singleShot(100, this, TQT_SLOT(slotResizeAftermath()));
TQTimer::singleShot(100, this, TQ_SLOT(slotResizeAftermath()));
}
void AtlantikBoard::playerChanged(Player *player)
@ -466,7 +466,7 @@ void AtlantikBoard::resizeEvent(TQResizeEvent *)
}
*/
// Timer to reinit the gameboard _after_ resizeEvent
TQTimer::singleShot(0, this, TQT_SLOT(slotResizeAftermath()));
TQTimer::singleShot(0, this, TQ_SLOT(slotResizeAftermath()));
}
void AtlantikBoard::slotResizeAftermath()
@ -544,8 +544,8 @@ void AtlantikBoard::insertDetails(TQString text, bool clearText, bool clearButto
eDetails = new EstateDetails(estate, text, this);
m_lastServerDisplay = eDetails;
connect(eDetails, TQT_SIGNAL(buttonCommand(TQString)), this, TQT_SIGNAL(buttonCommand(TQString)));
connect(eDetails, TQT_SIGNAL(buttonClose()), this, TQT_SLOT(displayDefault()));
connect(eDetails, TQ_SIGNAL(buttonCommand(TQString)), this, TQ_SIGNAL(buttonCommand(TQString)));
connect(eDetails, TQ_SIGNAL(buttonClose()), this, TQ_SLOT(displayDefault()));
m_displayQueue.insert(0, eDetails);
updateCenter();
@ -563,8 +563,8 @@ void AtlantikBoard::prependEstateDetails(Estate *estate)
eDetails = new EstateDetails(estate, TQString(), this);
m_displayQueue.prepend(eDetails);
connect(eDetails, TQT_SIGNAL(buttonCommand(TQString)), this, TQT_SIGNAL(buttonCommand(TQString)));
connect(eDetails, TQT_SIGNAL(buttonClose()), this, TQT_SLOT(displayDefault()));
connect(eDetails, TQ_SIGNAL(buttonCommand(TQString)), this, TQ_SIGNAL(buttonCommand(TQString)));
connect(eDetails, TQ_SIGNAL(buttonClose()), this, TQ_SLOT(displayDefault()));
}
else
{

4
atlantik/libatlantikui/estatedetails.cpp
Unescape View File

@ -258,7 +258,7 @@ void EstateDetails::addButton(TQString command, TQString caption, bool enabled)
button->setEnabled(enabled);
button->show();
connect(button, TQT_SIGNAL(pressed()), this, TQT_SLOT(buttonPressed()));
connect(button, TQ_SIGNAL(pressed()), this, TQ_SLOT(buttonPressed()));
}
void EstateDetails::addCloseButton()
@ -268,7 +268,7 @@ void EstateDetails::addCloseButton()
m_closeButton = new KPushButton(KStdGuiItem::close(), this);
m_buttonBox->addWidget(m_closeButton);
m_closeButton->show();
connect(m_closeButton, TQT_SIGNAL(pressed()), this, TQT_SIGNAL(buttonClose()));
connect(m_closeButton, TQ_SIGNAL(pressed()), this, TQ_SIGNAL(buttonClose()));
}
}

4
atlantik/libatlantikui/estateview.cpp
Unescape View File

@ -427,7 +427,7 @@ void EstateView::resizeEvent(TQResizeEvent *)
m_recreateQuartz = true;
b_recreate = true;
TQTimer::singleShot(0, this, TQT_SLOT(slotResizeAftermath()));
TQTimer::singleShot(0, this, TQ_SLOT(slotResizeAftermath()));
}
void EstateView::mousePressEvent(TQMouseEvent *e)
@ -482,7 +482,7 @@ void EstateView::mousePressEvent(TQMouseEvent *e)
TDEPopupMenu *pm = dynamic_cast<TDEPopupMenu *>(rmbMenu);
if (pm) {
connect(pm, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotMenuAction(int)));
connect(pm, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotMenuAction(int)));
}
TQPoint g = TQCursor::pos();
rmbMenu->exec(g);

2
atlantik/libatlantikui/kwrappedlistviewitem.cpp
Unescape View File

@ -110,7 +110,7 @@ void KWrappedListViewItem::init( TQListView *parent, TQString text, TQString t2
wrapColumn( m_wrapColumn );
connect( parent->header(), TQT_SIGNAL(sizeChange(int, int, int)), this, TQT_SLOT(wrapColumn(int)));
connect( parent->header(), TQ_SIGNAL(sizeChange(int, int, int)), this, TQ_SLOT(wrapColumn(int)));
}
#include "kwrappedlistviewitem.moc"

6
atlantik/libatlantikui/portfolioview.cpp
Unescape View File

@ -104,7 +104,7 @@ void PortfolioView::buildPortfolio()
PortfolioEstate *portfolioEstate = new PortfolioEstate(estate, m_player, false, this, "portfolioestate");
m_portfolioEstates.append(portfolioEstate);
connect(portfolioEstate, TQT_SIGNAL(estateClicked(Estate *)), this, TQT_SIGNAL(estateClicked(Estate *)));
connect(portfolioEstate, TQ_SIGNAL(estateClicked(Estate *)), this, TQ_SIGNAL(estateClicked(Estate *)));
if (lastPE)
{
x = lastPE->x() + 2;
@ -130,7 +130,7 @@ void PortfolioView::buildPortfolio()
portfolioEstate->setGeometry(x, y, portfolioEstate->width(), portfolioEstate->height());
portfolioEstate->show();
connect(estate, TQT_SIGNAL(changed()), portfolioEstate, TQT_SLOT(estateChanged()));
connect(estate, TQ_SIGNAL(changed()), portfolioEstate, TQ_SLOT(estateChanged()));
lastPE = portfolioEstate;
}
@ -269,7 +269,7 @@ void PortfolioView::mousePressEvent(TQMouseEvent *e)
rmbMenu->setItemEnabled( 0, m_atlanticCore->selfIsMaster() );
}
connect(rmbMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotMenuAction(int)));
connect(rmbMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotMenuAction(int)));
TQPoint g = TQCursor::pos();
rmbMenu->exec(g);
}

2
atlantik/libatlantikui/token.cpp
Unescape View File

@ -40,7 +40,7 @@ Token::Token(Player *player, AtlantikBoard *parent, const char *name) : TQWidget
m_parentBoard = parent;
m_player = player;
connect(m_player, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged()));
connect(m_player, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged()));
m_inJail = m_player->inJail();
m_location = m_player->location();

36
atlantik/libatlantikui/trade_widget.cpp
Unescape View File

@ -63,7 +63,7 @@ TradeDisplay::TradeDisplay(Trade *trade, AtlanticCore *atlanticCore, TQWidget *p
m_editTypeCombo->insertItem(i18n("Estate"));
m_editTypeCombo->insertItem(i18n("Money"));
connect(m_editTypeCombo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(setTypeCombo(int)));
connect(m_editTypeCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(setTypeCombo(int)));
m_estateCombo = new KComboBox(m_updateComponentBox);
TQPtrList<Estate> estateList = m_atlanticCore->estates();
@ -78,7 +78,7 @@ TradeDisplay::TradeDisplay(Trade *trade, AtlanticCore *atlanticCore, TQWidget *p
}
}
connect(m_estateCombo, TQT_SIGNAL(activated(int)), this, TQT_SLOT(setEstateCombo(int)));
connect(m_estateCombo, TQ_SIGNAL(activated(int)), this, TQ_SLOT(setEstateCombo(int)));
m_moneyBox = new TQSpinBox(0, 10000, 1, m_updateComponentBox);
@ -105,14 +105,14 @@ TradeDisplay::TradeDisplay(Trade *trade, AtlanticCore *atlanticCore, TQWidget *p
m_playerTargetMap[m_playerTargetCombo->count() - 1] = player;
m_playerTargetRevMap[player] = m_playerTargetCombo->count() - 1;
connect(player, TQT_SIGNAL(changed(Player *)), this, TQT_SLOT(playerChanged(Player *)));
connect(player, TQ_SIGNAL(changed(Player *)), this, TQ_SLOT(playerChanged(Player *)));
}
}
m_updateButton = new KPushButton(i18n("Update"), m_updateComponentBox);
m_updateButton->setEnabled(false);
connect(m_updateButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(updateComponent()));
connect(m_updateButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(updateComponent()));
m_componentList = new TDEListView(this, "componentList");
listCompBox->addWidget(m_componentList);
@ -122,8 +122,8 @@ TradeDisplay::TradeDisplay(Trade *trade, AtlanticCore *atlanticCore, TQWidget *p
m_componentList->addColumn(i18n("Player"));
m_componentList->addColumn(i18n("Item"));
connect(m_componentList, TQT_SIGNAL(contextMenu(TDEListView*, TQListViewItem *, const TQPoint&)), TQT_SLOT(contextMenu(TDEListView *, TQListViewItem *, const TQPoint&)));
connect(m_componentList, TQT_SIGNAL(clicked(TQListViewItem *)), this, TQT_SLOT(setCombos(TQListViewItem *)));
connect(m_componentList, TQ_SIGNAL(contextMenu(TDEListView*, TQListViewItem *, const TQPoint&)), TQ_SLOT(contextMenu(TDEListView *, TQListViewItem *, const TQPoint&)));
connect(m_componentList, TQ_SIGNAL(clicked(TQListViewItem *)), this, TQ_SLOT(setCombos(TQListViewItem *)));
TQHBoxLayout *actionBox = new TQHBoxLayout(this, 0, KDialog::spacingHint());
listCompBox->addItem(actionBox);
@ -133,13 +133,13 @@ TradeDisplay::TradeDisplay(Trade *trade, AtlanticCore *atlanticCore, TQWidget *p
m_rejectButton = new KPushButton(BarIcon("cancel", TDEIcon::SizeSmall), i18n("Reject"), this);
actionBox->addWidget(m_rejectButton);
connect(m_rejectButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(reject()));
connect(m_rejectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(reject()));
m_acceptButton = new KPushButton(BarIcon("ok", TDEIcon::SizeSmall), i18n("Accept"), this);
// m_acceptButton->setEnabled(false);
actionBox->addWidget(m_acceptButton);
connect(m_acceptButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(accept()));
connect(m_acceptButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()));
m_status = new TQLabel(this);
listCompBox->addWidget(m_status);
@ -149,14 +149,14 @@ TradeDisplay::TradeDisplay(Trade *trade, AtlanticCore *atlanticCore, TQWidget *p
// mPlayerList->setRootIsDecorated(true);
// mPlayerList->setResizeMode(TDEListView::AllColumns);
connect(m_trade, TQT_SIGNAL(itemAdded(TradeItem *)), this, TQT_SLOT(tradeItemAdded(TradeItem *)));
connect(m_trade, TQT_SIGNAL(itemRemoved(TradeItem *)), this, TQT_SLOT(tradeItemRemoved(TradeItem *)));
connect(m_trade, TQT_SIGNAL(changed(Trade *)), this, TQT_SLOT(tradeChanged()));
connect(m_trade, TQT_SIGNAL(rejected(Player *)), this, TQT_SLOT(tradeRejected(Player *)));
connect(this, TQT_SIGNAL(updateEstate(Trade *, Estate *, Player *)), m_trade, TQT_SIGNAL(updateEstate(Trade *, Estate *, Player *)));
connect(this, TQT_SIGNAL(updateMoney(Trade *, unsigned int, Player *, Player *)), m_trade, TQT_SIGNAL(updateMoney(Trade *, unsigned int, Player *, Player *)));
connect(this, TQT_SIGNAL(reject(Trade *)), m_trade, TQT_SIGNAL(reject(Trade *)));
connect(this, TQT_SIGNAL(accept(Trade *)), m_trade, TQT_SIGNAL(accept(Trade *)));
connect(m_trade, TQ_SIGNAL(itemAdded(TradeItem *)), this, TQ_SLOT(tradeItemAdded(TradeItem *)));
connect(m_trade, TQ_SIGNAL(itemRemoved(TradeItem *)), this, TQ_SLOT(tradeItemRemoved(TradeItem *)));
connect(m_trade, TQ_SIGNAL(changed(Trade *)), this, TQ_SLOT(tradeChanged()));
connect(m_trade, TQ_SIGNAL(rejected(Player *)), this, TQ_SLOT(tradeRejected(Player *)));
connect(this, TQ_SIGNAL(updateEstate(Trade *, Estate *, Player *)), m_trade, TQ_SIGNAL(updateEstate(Trade *, Estate *, Player *)));
connect(this, TQ_SIGNAL(updateMoney(Trade *, unsigned int, Player *, Player *)), m_trade, TQ_SIGNAL(updateMoney(Trade *, unsigned int, Player *, Player *)));
connect(this, TQ_SIGNAL(reject(Trade *)), m_trade, TQ_SIGNAL(reject(Trade *)));
connect(this, TQ_SIGNAL(accept(Trade *)), m_trade, TQ_SIGNAL(accept(Trade *)));
setTypeCombo(m_editTypeCombo->currentItem());
setEstateCombo(m_estateCombo->currentItem());
@ -178,7 +178,7 @@ void TradeDisplay::closeEvent(TQCloseEvent *e)
void TradeDisplay::tradeItemAdded(TradeItem *tradeItem)
{
TDEListViewItem *item = new TDEListViewItem(m_componentList, (tradeItem->from() ? tradeItem->from()->name() : TQString("?")), i18n("gives is transitive ;)", "gives"), (tradeItem->to() ? tradeItem->to()->name() : TQString("?")), tradeItem->text());
connect(tradeItem, TQT_SIGNAL(changed(TradeItem *)), this, TQT_SLOT(tradeItemChanged(TradeItem *)));
connect(tradeItem, TQ_SIGNAL(changed(TradeItem *)), this, TQ_SLOT(tradeItemChanged(TradeItem *)));
item->setPixmap(0, TQPixmap(SmallIcon("preferences-desktop-personal")));
item->setPixmap(2, TQPixmap(SmallIcon("preferences-desktop-personal")));
@ -356,7 +356,7 @@ void TradeDisplay::contextMenu(TDEListView *, TQListViewItem *i, const TQPoint&
// rmbMenu->insertTitle( ... );
rmbMenu->insertItem(i18n("Remove From Trade"), 0);
connect(rmbMenu, TQT_SIGNAL(activated(int)), this, TQT_SLOT(contextMenuClicked(int)));
connect(rmbMenu, TQ_SIGNAL(activated(int)), this, TQ_SLOT(contextMenuClicked(int)));
rmbMenu->exec(p);
}

26
kasteroids/toplevel.cpp
Unescape View File

@ -79,10 +79,10 @@ KAstTopLevel::KAstTopLevel()
mainWin->setFixedSize(640, 480);
view = new KAsteroidsView( mainWin );
connect( view, TQT_SIGNAL( shipKilled() ), TQT_SLOT( slotShipKilled() ) );
connect( view, TQT_SIGNAL( rockHit(int) ), TQT_SLOT( slotRockHit(int) ) );
connect( view, TQT_SIGNAL( rocksRemoved() ), TQT_SLOT( slotRocksRemoved() ) );
connect( view, TQT_SIGNAL( updateVitals() ), TQT_SLOT( slotUpdateVitals() ) );
connect( view, TQ_SIGNAL( shipKilled() ), TQ_SLOT( slotShipKilled() ) );
connect( view, TQ_SIGNAL( rockHit(int) ), TQ_SLOT( slotRockHit(int) ) );
connect( view, TQ_SIGNAL( rocksRemoved() ), TQ_SLOT( slotRocksRemoved() ) );
connect( view, TQ_SIGNAL( updateVitals() ), TQ_SLOT( slotUpdateVitals() ) );
TQVBoxLayout *vb = new TQVBoxLayout( mainWin );
TQHBoxLayout *hb = new TQHBoxLayout;
@ -280,14 +280,14 @@ KAstTopLevel::~KAstTopLevel()
void KAstTopLevel::initTDEAction()
{
// game
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());
KStdGameAction::gameNew( this, TQ_SLOT( slotNewGame() ), actionCollection() );
KStdGameAction::highscores( this, TQ_SLOT( slotShowHighscores() ), actionCollection() );
KStdGameAction::pause( this, TQ_SLOT( slotPause() ), actionCollection() );
KStdGameAction::quit(this, TQ_SLOT( close() ), actionCollection());
// settings
KStdAction::keyBindings(this, TQT_SLOT( slotKeyConfig() ), actionCollection());
KStdAction::preferences(this, TQT_SLOT( slotPref() ), actionCollection());
KStdAction::keyBindings(this, TQ_SLOT( slotKeyConfig() ), actionCollection());
KStdAction::preferences(this, TQ_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, this, TQT_SLOT(slotLaunch()), actionCollection(), "Launch");
launchAction = new TDEAction(i18n("Launch"), TQt::Key_L, this, TQ_SLOT(slotLaunch()), actionCollection(), "Launch");
}
@ -529,7 +529,7 @@ void KAstTopLevel::slotShipKilled()
}
else
{
TQTimer::singleShot(1000, this, TQT_SLOT(slotGameOver()));
TQTimer::singleShot(1000, this, TQ_SLOT(slotGameOver()));
}
}
}
@ -613,7 +613,7 @@ void KAstTopLevel::slotPref()
/* Done */
dialog->addPage(w, i18n("General"), "package_settings");
connect(dialog, TQT_SIGNAL(settingsChanged()), this, TQT_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), this, TQ_SLOT(loadSettings()));
dialog->show();
}

2
kasteroids/view.cpp
Unescape View File

@ -91,7 +91,7 @@ KAsteroidsView::KAsteroidsView( TQWidget *parent, const char *name )
readSprites();
shieldTimer = new TQTimer( this );
connect( shieldTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(hideShield()) );
connect( shieldTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(hideShield()) );
mTimerId = -1;
shipPower = MAX_POWER_LEVEL;

2
katomic/configbox.cpp
Unescape View File

@ -36,7 +36,7 @@ ConfigBox::ConfigBox ( TQWidget *parent, const char *name)
speed = new TQSlider(1, 10, 1, 1, TQt::Horizontal, page);
glay->addMultiCellWidget(speed, 2, 2, 2, 3);
connect(speed, TQT_SIGNAL(valueChanged(int)), disp, TQT_SLOT(display(int)));
connect(speed, TQ_SIGNAL(valueChanged(int)), disp, TQ_SLOT(display(int)));
speed->setValue(settings.anim_speed);
incInitialSize(TQSize(20,20), true);

10
katomic/gamewidget.cpp
Unescape View File

@ -189,16 +189,16 @@ GameWidget::GameWidget ( TQWidget *parent, const char* name )
// scrollbar
scrl = new TQScrollBar(1, nlevels, 1,
5, 1, TQt::Horizontal, vb, "scrl" );
connect (scrl, TQT_SIGNAL (valueChanged (int)), TQT_SLOT (updateLevel (int)));
connect (scrl, TQ_SIGNAL (valueChanged (int)), TQ_SLOT (updateLevel (int)));
// molek<65>l
molek = new Molek (vb, "molek");
feld->setMolek(molek);
connect (feld, TQT_SIGNAL (gameOver(int)), TQT_SLOT(gameOver(int)));
connect (feld, TQT_SIGNAL (sendMoves(int)), TQT_SLOT(getMoves(int)));
connect (feld, TQT_SIGNAL (enableRedo(bool)), TQT_SIGNAL(enableRedo(bool)));
connect (feld, TQT_SIGNAL (enableUndo(bool)), TQT_SIGNAL(enableUndo(bool)));
connect (feld, TQ_SIGNAL (gameOver(int)), TQ_SLOT(gameOver(int)));
connect (feld, TQ_SIGNAL (sendMoves(int)), TQ_SLOT(getMoves(int)));
connect (feld, TQ_SIGNAL (enableRedo(bool)), TQ_SIGNAL(enableRedo(bool)));
connect (feld, TQ_SIGNAL (enableUndo(bool)), TQ_SIGNAL(enableUndo(bool)));
highScore = new KScoreDialog(KScoreDialog::Name | KScoreDialog::Score, this);

28
katomic/toplevel.cpp
Unescape View File

@ -40,27 +40,27 @@ extern Options settings;
void AtomTopLevel::createMenu()
{
TDEAction *act = KStdGameAction::highscores(main, TQT_SLOT(showHighscores()), actionCollection());
TDEAction *act = KStdGameAction::highscores(main, TQ_SLOT(showHighscores()), actionCollection());
act->setText(i18n("Show &Highscores"));
KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
KStdGameAction::restart(main, TQT_SLOT(restartLevel()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
KStdGameAction::restart(main, TQ_SLOT(restartLevel()), actionCollection());
KStdAction::preferences(this, TQT_SLOT(configopts()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(configopts()), actionCollection());
undoAction = KStdGameAction::undo (main, TQT_SLOT(doUndo()), actionCollection());
redoAction = KStdGameAction::redo (main, TQT_SLOT(doRedo()), actionCollection());
undoAction = KStdGameAction::undo (main, TQ_SLOT(doUndo()), actionCollection());
redoAction = KStdGameAction::redo (main, TQ_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)));
connect (main, TQ_SIGNAL (enableRedo(bool)), TQ_SLOT(enableRedo(bool)));
connect (main, TQ_SIGNAL (enableUndo(bool)), TQ_SLOT(enableUndo(bool)));
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("Atom Up"), Key_Up, main, TQ_SLOT(moveUp()), actionCollection(), "atom_up");
new TDEAction(i18n("Atom Down"), Key_Down, main, TQ_SLOT(moveDown()), actionCollection(), "atom_down");
new TDEAction(i18n("Atom Left"), Key_Left, main, TQ_SLOT(moveLeft()), actionCollection(), "atom_left");
new TDEAction(i18n("Atom Right"), Key_Right, main, TQ_SLOT(moveRight()), actionCollection(), "atom_right");
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");
new TDEAction(i18n("Next Atom"), Key_Tab, main, TQ_SLOT(nextAtom()), actionCollection(), "next_atom");
new TDEAction(i18n("Previous Atom"), SHIFT+Key_Tab, main, TQ_SLOT(previousAtom()), actionCollection(), "prev_atom");
}
void AtomTopLevel::configopts()

112
kbackgammon/engines/fibs/kbgfibs.cpp
Unescape View File

@ -272,7 +272,7 @@ void KBgEngineFIBS::getSetupPages(KDialogBase *nb)
lem[i] = new TQLineEdit(autoMsg[i], gbm);
gl->addWidget(cbm[i], i, 0);
gl->addWidget(lem[i], i, 1);
connect(cbm[i], TQT_SIGNAL(toggled(bool)), lem[i], TQT_SLOT(setEnabled(bool)));
connect(cbm[i], TQ_SIGNAL(toggled(bool)), lem[i], TQ_SLOT(setEnabled(bool)));
cbm[i]->setChecked(useAutoMsg[i]);
lem[i]->setEnabled(useAutoMsg[i]);
TQWhatsThis::add(lem[i], TQWhatsThis::textFor(cbm[i]));
@ -838,8 +838,8 @@ void KBgEngineFIBS::fibsRequestInvitation(const TQString &player)
if (!invitationDlg) {
TQString p = player;
invitationDlg = new KBgInvite("invite");
connect(invitationDlg, TQT_SIGNAL(inviteCommand(const TQString &)), this, TQT_SLOT(handleCommand(const TQString &)));
connect(invitationDlg, TQT_SIGNAL(dialogDone()), this, TQT_SLOT(invitationDone()));
connect(invitationDlg, TQ_SIGNAL(inviteCommand(const TQString &)), this, TQ_SLOT(handleCommand(const TQString &)));
connect(invitationDlg, TQ_SIGNAL(dialogDone()), this, TQ_SLOT(invitationDone()));
}
invitationDlg->setPlayer(player);
invitationDlg->show();
@ -2098,51 +2098,51 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
playing = false;
login = true;
connect(connection, TQT_SIGNAL(hostFound()), this, TQT_SLOT(hostFound()));
connect(connection, TQT_SIGNAL(connected()), this, TQT_SLOT(connected()));
connect(connection, TQT_SIGNAL(error(int)), this, TQT_SLOT(connError(int)));
connect(connection, TQT_SIGNAL(connectionClosed()), this, TQT_SLOT(connectionClosed()));
connect(connection, TQT_SIGNAL(delayedCloseFinished()), this, TQT_SLOT(connectionClosed()));
connect(connection, TQT_SIGNAL(readyRead()), this, TQT_SLOT(readData()));
connect(connection, TQ_SIGNAL(hostFound()), this, TQ_SLOT(hostFound()));
connect(connection, TQ_SIGNAL(connected()), this, TQ_SLOT(connected()));
connect(connection, TQ_SIGNAL(error(int)), this, TQ_SLOT(connError(int)));
connect(connection, TQ_SIGNAL(connectionClosed()), this, TQ_SLOT(connectionClosed()));
connect(connection, TQ_SIGNAL(delayedCloseFinished()), this, TQ_SLOT(connectionClosed()));
connect(connection, TQ_SIGNAL(readyRead()), this, TQ_SLOT(readData()));
connect(this, TQT_SIGNAL(serverString(const TQString &)), this, TQT_SLOT(sendData(const TQString &)));
connect(this, TQ_SIGNAL(serverString(const TQString &)), this, TQ_SLOT(sendData(const TQString &)));
/*
* No invitation dialog
*/
invitationDlg = 0;
connect(this, TQT_SIGNAL(fibsWhoInfo(const TQString &)), this, TQT_SLOT(changeJoin(const TQString &)));
connect(this, TQT_SIGNAL(fibsLogout (const TQString &)), this, TQT_SLOT(cancelJoin(const TQString &)));
connect(this, TQT_SIGNAL(gameOver()), this, TQT_SLOT(endGame()));
connect(this, TQ_SIGNAL(fibsWhoInfo(const TQString &)), this, TQ_SLOT(changeJoin(const TQString &)));
connect(this, TQ_SIGNAL(fibsLogout (const TQString &)), this, TQ_SLOT(cancelJoin(const TQString &)));
connect(this, TQ_SIGNAL(gameOver()), this, TQ_SLOT(endGame()));
/*
* Creating, initializing and connecting the player list
*/
playerlist = new KFibsPlayerList(0, "fibs player list");
connect(this, TQT_SIGNAL(fibsWhoInfo(const TQString &)), playerlist, TQT_SLOT(changePlayer(const TQString &)));
connect(this, TQT_SIGNAL(fibsLogout (const TQString &)), playerlist, TQT_SLOT(deletePlayer(const TQString &)));
connect(this, TQT_SIGNAL(fibsWhoEnd()), playerlist, TQT_SLOT(stopUpdate()));
connect(this, TQT_SIGNAL(fibsConnectionClosed()), playerlist, TQT_SLOT(stopUpdate()));
connect(this, TQT_SIGNAL(changePlayerStatus(const TQString &, int, bool)),
playerlist, TQT_SLOT(changePlayerStatus(const TQString &, int, bool)));
connect(playerlist, TQT_SIGNAL(fibsCommand(const TQString &)), this, TQT_SLOT(handleCommand(const TQString &)));
connect(playerlist, TQT_SIGNAL(fibsInvite(const TQString &)), this, TQT_SLOT(fibsRequestInvitation(const TQString &)));
connect(this, TQ_SIGNAL(fibsWhoInfo(const TQString &)), playerlist, TQ_SLOT(changePlayer(const TQString &)));
connect(this, TQ_SIGNAL(fibsLogout (const TQString &)), playerlist, TQ_SLOT(deletePlayer(const TQString &)));
connect(this, TQ_SIGNAL(fibsWhoEnd()), playerlist, TQ_SLOT(stopUpdate()));
connect(this, TQ_SIGNAL(fibsConnectionClosed()), playerlist, TQ_SLOT(stopUpdate()));
connect(this, TQ_SIGNAL(changePlayerStatus(const TQString &, int, bool)),
playerlist, TQ_SLOT(changePlayerStatus(const TQString &, int, bool)));
connect(playerlist, TQ_SIGNAL(fibsCommand(const TQString &)), this, TQ_SLOT(handleCommand(const TQString &)));
connect(playerlist, TQ_SIGNAL(fibsInvite(const TQString &)), this, TQ_SLOT(fibsRequestInvitation(const TQString &)));
/*
* Create, initialize and connect the chat window
*/
chatWindow = new KBgChat(0, "chat window");
connect(this, TQT_SIGNAL(chatMessage(const TQString &)), chatWindow, TQT_SLOT(handleData(const TQString &)));
connect(this, TQT_SIGNAL(fibsStartNewGame(const TQString &)), chatWindow, TQT_SLOT(startGame(const TQString &)));
connect(this, TQT_SIGNAL(gameOver()), chatWindow, TQT_SLOT(endGame()));
connect(this, TQT_SIGNAL(fibsLogout (const TQString &)), chatWindow, TQT_SLOT(deletePlayer(const TQString &)));
connect(chatWindow, TQT_SIGNAL(fibsCommand(const TQString &)), this, TQT_SLOT(handleCommand(const TQString &)));
connect(chatWindow, TQT_SIGNAL(fibsRequestInvitation(const TQString &)), this, TQT_SLOT(fibsRequestInvitation(const TQString &)));
connect(chatWindow, TQT_SIGNAL(personalMessage(const TQString &)), this, TQT_SLOT(personalMessage(const TQString &)));
connect(playerlist, TQT_SIGNAL(fibsTalk(const TQString &)), chatWindow, TQT_SLOT(fibsTalk(const TQString &)));
connect(this, TQ_SIGNAL(chatMessage(const TQString &)), chatWindow, TQ_SLOT(handleData(const TQString &)));
connect(this, TQ_SIGNAL(fibsStartNewGame(const TQString &)), chatWindow, TQ_SLOT(startGame(const TQString &)));
connect(this, TQ_SIGNAL(gameOver()), chatWindow, TQ_SLOT(endGame()));
connect(this, TQ_SIGNAL(fibsLogout (const TQString &)), chatWindow, TQ_SLOT(deletePlayer(const TQString &)));
connect(chatWindow, TQ_SIGNAL(fibsCommand(const TQString &)), this, TQ_SLOT(handleCommand(const TQString &)));
connect(chatWindow, TQ_SIGNAL(fibsRequestInvitation(const TQString &)), this, TQ_SLOT(fibsRequestInvitation(const TQString &)));
connect(chatWindow, TQ_SIGNAL(personalMessage(const TQString &)), this, TQ_SLOT(personalMessage(const TQString &)));
connect(playerlist, TQ_SIGNAL(fibsTalk(const TQString &)), chatWindow, TQ_SLOT(fibsTalk(const TQString &)));
/*
* Creating, initializing and connecting the menu
@ -2156,9 +2156,9 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
/*
* Initialize the FIBS submenu - this is also put in the play menu
*/
conAction = new TDEAction(i18n("&Connect"), 0, this, TQT_SLOT( connectFIBS()), this);
newAction = new TDEAction(i18n("New Account"), 0, this, TQT_SLOT( newAccount()), this);
disAction = new TDEAction(i18n("&Disconnect"), 0, this, TQT_SLOT(disconnectFIBS()), this);
conAction = new TDEAction(i18n("&Connect"), 0, this, TQ_SLOT( connectFIBS()), this);
newAction = new TDEAction(i18n("New Account"), 0, this, TQ_SLOT( newAccount()), this);
disAction = new TDEAction(i18n("&Disconnect"), 0, this, TQ_SLOT(disconnectFIBS()), this);
conAction->setEnabled(true ); conAction->plug(menu);
disAction->setEnabled(false); disAction->plug(menu);
@ -2166,7 +2166,7 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
menu->insertSeparator();
(invAction = new TDEAction(i18n("&Invite..."), 0, this, TQT_SLOT(inviteDialog()), this))->plug(menu);
(invAction = new TDEAction(i18n("&Invite..."), 0, this, TQ_SLOT(inviteDialog()), this))->plug(menu);
/*
* Create and fill the response menu. This is for all these: type this or
@ -2174,8 +2174,8 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
*/
cmdMenuID = menu->insertItem(i18n("&Commands"), cmdMenu); {
(actAway = new TDEAction(i18n("Away"), 0, this, TQT_SLOT(away()), this))->plug(cmdMenu);
(actBack = new TDEAction(i18n("Back"), 0, this, TQT_SLOT(back()), this))->plug(cmdMenu);
(actAway = new TDEAction(i18n("Away"), 0, this, TQ_SLOT(away()), this))->plug(cmdMenu);
(actBack = new TDEAction(i18n("Back"), 0, this, TQ_SLOT(back()), this))->plug(cmdMenu);
actAway->setEnabled(true);
actBack->setEnabled(false);
@ -2192,14 +2192,14 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
fibsOpt[i] = 0;
fibsOpt[OptReady] = new TDEToggleAction(i18n("Ready to Play"),
0, this, TQT_SLOT(toggle_ready()), this);
0, this, TQ_SLOT(toggle_ready()), this);
fibsOpt[OptRatings] = new TDEToggleAction(i18n("Show Rating Computations"),
0, this, TQT_SLOT(toggle_ratings()), this);
0, this, TQ_SLOT(toggle_ratings()), this);
fibsOpt[OptRatings]->setCheckedState(i18n("Hide Rating Computations"));
fibsOpt[OptGreedy] = new TDEToggleAction(i18n("Greedy Bearoffs"),
0, this, TQT_SLOT(toggle_greedy()), this);
0, this, TQ_SLOT(toggle_greedy()), this);
fibsOpt[OptDouble] = new TDEToggleAction(i18n("Ask for Doubles"),
0, this, TQT_SLOT(toggle_double()), this);
0, this, TQ_SLOT(toggle_double()), this);
for (int i = 0; i < NumFIBSOpt; i++)
if (fibsOpt[i])
@ -2213,16 +2213,16 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
*/
respMenuID = menu->insertItem(i18n("&Response"), respMenu); {
(actAccept = new TDEAction(i18n("Accept"), 0, this, TQT_SLOT(accept()), this))->plug(respMenu);
(actReject = new TDEAction(i18n("Reject"), 0, this, TQT_SLOT(reject()), this))->plug(respMenu);
(actAccept = new TDEAction(i18n("Accept"), 0, this, TQ_SLOT(accept()), this))->plug(respMenu);
(actReject = new TDEAction(i18n("Reject"), 0, this, TQ_SLOT(reject()), this))->plug(respMenu);
actAccept->setEnabled(false);
actReject->setEnabled(false);
respMenu->insertSeparator();
(actConti = new TDEAction(i18n("Join"), 0, this, TQT_SLOT(match_conti()), this))->plug(respMenu);
(actLeave = new TDEAction(i18n("Leave"), 0, this, TQT_SLOT(match_leave()), this))->plug(respMenu);
(actConti = new TDEAction(i18n("Join"), 0, this, TQ_SLOT(match_conti()), this))->plug(respMenu);
(actLeave = new TDEAction(i18n("Leave"), 0, this, TQ_SLOT(match_leave()), this))->plug(respMenu);
actConti->setEnabled(false);
actLeave->setEnabled(false);
@ -2235,14 +2235,14 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
joinMenuID = menu->insertItem(i18n("&Join"), joinMenu); {
numJoin = -1;
actJoin[0] = new TDEAction("", 0, this, TQT_SLOT(join_0()), this);
actJoin[1] = new TDEAction("", 0, this, TQT_SLOT(join_1()), this);
actJoin[2] = new TDEAction("", 0, this, TQT_SLOT(join_2()), this);
actJoin[3] = new TDEAction("", 0, this, TQT_SLOT(join_3()), this);
actJoin[4] = new TDEAction("", 0, this, TQT_SLOT(join_4()), this);
actJoin[5] = new TDEAction("", 0, this, TQT_SLOT(join_5()), this);
actJoin[6] = new TDEAction("", 0, this, TQT_SLOT(join_6()), this);
actJoin[7] = new TDEAction("", 0, this, TQT_SLOT(join_7()), this);
actJoin[0] = new TDEAction("", 0, this, TQ_SLOT(join_0()), this);
actJoin[1] = new TDEAction("", 0, this, TQ_SLOT(join_1()), this);
actJoin[2] = new TDEAction("", 0, this, TQ_SLOT(join_2()), this);
actJoin[3] = new TDEAction("", 0, this, TQ_SLOT(join_3()), this);
actJoin[4] = new TDEAction("", 0, this, TQ_SLOT(join_4()), this);
actJoin[5] = new TDEAction("", 0, this, TQ_SLOT(join_5()), this);
actJoin[6] = new TDEAction("", 0, this, TQ_SLOT(join_6()), this);
actJoin[7] = new TDEAction("", 0, this, TQ_SLOT(join_7()), this);
}
menu->setItemEnabled(joinMenuID, false);
@ -2255,11 +2255,11 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
*/
menu->insertSeparator();
(listAct = new TDEToggleAction(i18n("&Player List"), 0, this, TQT_SLOT(showList()), this))->plug(menu);
(chatAct = new TDEToggleAction(i18n("&Chat"), 0, this, TQT_SLOT(showChat()), this))->plug(menu);
(listAct = new TDEToggleAction(i18n("&Player List"), 0, this, TQ_SLOT(showList()), this))->plug(menu);
(chatAct = new TDEToggleAction(i18n("&Chat"), 0, this, TQ_SLOT(showChat()), this))->plug(menu);
connect(playerlist, TQT_SIGNAL(windowVisible(bool)), listAct, TQT_SLOT(setChecked(bool)));
connect(chatWindow, TQT_SIGNAL(windowVisible(bool)), chatAct, TQT_SLOT(setChecked(bool)));
connect(playerlist, TQ_SIGNAL(windowVisible(bool)), listAct, TQ_SLOT(setChecked(bool)));
connect(chatWindow, TQ_SIGNAL(windowVisible(bool)), chatAct, TQ_SLOT(setChecked(bool)));
/*
* Create message IDs. This sets up a lot of regular expressions.
@ -2287,7 +2287,7 @@ KBgEngineFIBS::KBgEngineFIBS(TQWidget *parent, TQString *name, TQPopupMenu *pmen
// FIXME: move the start to connect...
keepaliveTimer = new TQTimer(this);
connect(keepaliveTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(keepAlive()));
connect(keepaliveTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(keepAlive()));
keepaliveTimer->start(1200000);
}

46
kbackgammon/engines/fibs/kbgfibschat.cpp
Unescape View File

@ -205,10 +205,10 @@ KBgChat::KBgChat(TQWidget *parent, const char *name)
if (!addSendingEntry(i18n("Whisper to watchers only"), CLIP_YOU_WHISPER))
kdDebug(10500) << "adding whisper" << endl;
connect(this, TQT_SIGNAL(rightButtonClicked(TQListBoxItem *, const TQPoint &)),
this, TQT_SLOT(contextMenu(TQListBoxItem *, const TQPoint &)));
connect(this, TQT_SIGNAL(signalSendMessage(int, const TQString &)),
this, TQT_SLOT(handleCommand(int, const TQString &)));
connect(this, TQ_SIGNAL(rightButtonClicked(TQListBoxItem *, const TQPoint &)),
this, TQ_SLOT(contextMenu(TQListBoxItem *, const TQPoint &)));
connect(this, TQ_SIGNAL(signalSendMessage(int, const TQString &)),
this, TQ_SLOT(handleCommand(int, const TQString &)));
d->mName2ID = new TQDict<int>(17, true);
d->mName2ID->setAutoDelete(true);
@ -231,32 +231,32 @@ KBgChat::KBgChat(TQWidget *parent, const char *name)
d->mAct[KBgChatPrivate::Inquire] = new TDEAction(i18n("Info On"),
TQIconSet(kapp->iconLoader()->loadIcon(
"help.xpm", TDEIcon::Small)),
0, this, TQT_SLOT(slotInquire()), actions);
0, this, TQ_SLOT(slotInquire()), actions);
d->mAct[KBgChatPrivate::Talk] = new TDEAction(i18n("Talk To"),
TQIconSet(kapp->iconLoader()->loadIcon(
PROG_NAME "-chat.png", TDEIcon::Small)),
0, this, TQT_SLOT(slotTalk()), actions);
0, this, TQ_SLOT(slotTalk()), actions);
d->mAct[KBgChatPrivate::InviteD] = new TDEAction(i18n("Use Dialog"), 0, this,
TQT_SLOT(slotInviteD()), actions);
TQ_SLOT(slotInviteD()), actions);
d->mAct[KBgChatPrivate::Invite1] = new TDEAction(i18n("1 Point Match"), 0, this,
TQT_SLOT(slotInvite1()), actions);
TQ_SLOT(slotInvite1()), actions);
d->mAct[KBgChatPrivate::Invite2] = new TDEAction(i18n("2 Point Match"), 0, this,
TQT_SLOT(slotInvite2()), actions);
TQ_SLOT(slotInvite2()), actions);
d->mAct[KBgChatPrivate::Invite3] = new TDEAction(i18n("3 Point Match"), 0, this,
TQT_SLOT(slotInvite3()), actions);
TQ_SLOT(slotInvite3()), actions);
d->mAct[KBgChatPrivate::Invite4] = new TDEAction(i18n("4 Point Match"), 0, this,
TQT_SLOT(slotInvite4()), actions);
TQ_SLOT(slotInvite4()), actions);
d->mAct[KBgChatPrivate::Invite5] = new TDEAction(i18n("5 Point Match"), 0, this,
TQT_SLOT(slotInvite5()), actions);
TQ_SLOT(slotInvite5()), actions);
d->mAct[KBgChatPrivate::Invite6] = new TDEAction(i18n("6 Point Match"), 0, this,
TQT_SLOT(slotInvite6()), actions);
TQ_SLOT(slotInvite6()), actions);
d->mAct[KBgChatPrivate::Invite7] = new TDEAction(i18n("7 Point Match"), 0, this,
TQT_SLOT(slotInvite7()), actions);
TQ_SLOT(slotInvite7()), actions);
d->mAct[KBgChatPrivate::InviteU] = new TDEAction(i18n("Unlimited"), 0, this,
TQT_SLOT(slotInviteU()), actions);
TQ_SLOT(slotInviteU()), actions);
d->mAct[KBgChatPrivate::InviteR] = new TDEAction(i18n("Resume"), 0, this,
TQT_SLOT(slotInviteR()), actions);
TQ_SLOT(slotInviteR()), actions);
d->mAct[KBgChatPrivate::InviteD]->plug(d->mInvt);
@ -275,13 +275,13 @@ KBgChat::KBgChat(TQWidget *parent, const char *name)
d->mAct[KBgChatPrivate::InviteU]->plug(d->mInvt);
d->mAct[KBgChatPrivate::InviteR]->plug(d->mInvt);
d->mAct[KBgChatPrivate::Gag] = new TDEAction(i18n("Gag"), 0, this, TQT_SLOT(slotGag()), actions);
d->mAct[KBgChatPrivate::Ungag] = new TDEAction(i18n("Ungag"), 0, this, TQT_SLOT(slotUngag()), actions);
d->mAct[KBgChatPrivate::Cleargag] = new TDEAction(i18n("Clear Gag List"), 0, this, TQT_SLOT(slotCleargag()), actions);
d->mAct[KBgChatPrivate::Copy] = KStdAction::copy(this, TQT_SLOT(slotCopy()), actions);
d->mAct[KBgChatPrivate::Clear] = new TDEAction(i18n("Clear"), 0, this, TQT_SLOT(slotClear()), actions);
d->mAct[KBgChatPrivate::Close] = KStdAction::close(this, TQT_SLOT(hide()), actions);
d->mAct[KBgChatPrivate::Silent] = new TDEToggleAction(i18n("Silent"), 0, this, TQT_SLOT(slotSilent()), actions);
d->mAct[KBgChatPrivate::Gag] = new TDEAction(i18n("Gag"), 0, this, TQ_SLOT(slotGag()), actions);
d->mAct[KBgChatPrivate::Ungag] = new TDEAction(i18n("Ungag"), 0, this, TQ_SLOT(slotUngag()), actions);
d->mAct[KBgChatPrivate::Cleargag] = new TDEAction(i18n("Clear Gag List"), 0, this, TQ_SLOT(slotCleargag()), actions);
d->mAct[KBgChatPrivate::Copy] = KStdAction::copy(this, TQ_SLOT(slotCopy()), actions);
d->mAct[KBgChatPrivate::Clear] = new TDEAction(i18n("Clear"), 0, this, TQ_SLOT(slotClear()), actions);
d->mAct[KBgChatPrivate::Close] = KStdAction::close(this, TQ_SLOT(hide()), actions);
d->mAct[KBgChatPrivate::Silent] = new TDEToggleAction(i18n("Silent"), 0, this, TQ_SLOT(slotSilent()), actions);
}

10
kbackgammon/engines/fibs/kbginvite.cpp
Unescape View File

@ -116,11 +116,11 @@ KBgInvite::KBgInvite(const char *name)
/*
* Connect the buttons
*/
connect(d->mUnlimited, TQT_SIGNAL(clicked()), TQT_SLOT(unlimitedClicked()));
connect(d->mResume, TQT_SIGNAL(clicked()), TQT_SLOT(resumeClicked()));
connect(d->mInvite, TQT_SIGNAL(clicked()), TQT_SLOT(inviteClicked()));
connect(d->mClose, TQT_SIGNAL(clicked()), TQT_SLOT(hide()));
connect(d->mCancel, TQT_SIGNAL(clicked()), TQT_SLOT(cancelClicked()));
connect(d->mUnlimited, TQ_SIGNAL(clicked()), TQ_SLOT(unlimitedClicked()));
connect(d->mResume, TQ_SIGNAL(clicked()), TQ_SLOT(resumeClicked()));
connect(d->mInvite, TQ_SIGNAL(clicked()), TQ_SLOT(inviteClicked()));
connect(d->mClose, TQ_SIGNAL(clicked()), TQ_SLOT(hide()));
connect(d->mCancel, TQ_SIGNAL(clicked()), TQ_SLOT(cancelClicked()));
}
/*

50
kbackgammon/engines/fibs/kplayerlist.cpp
Unescape View File

@ -288,42 +288,42 @@ KFibsPlayerList::KFibsPlayerList(TQWidget *parent, const char *name)
d->mAct[KFibsPlayerListPrivate::Info] = new TDEAction(i18n("Info"),
TQIconSet(kapp->iconLoader()->loadIcon
("help.xpm", TDEIcon::Small)),
0, this, TQT_SLOT(slotInfo()), actions);
0, this, TQ_SLOT(slotInfo()), actions);
d->mAct[KFibsPlayerListPrivate::Talk] = new TDEAction(i18n("Talk"),
TQIconSet(kapp->iconLoader()->loadIcon
(PROG_NAME "-chat.png", TDEIcon::Small)),
0, this, TQT_SLOT(slotTalk()), actions);
0, this, TQ_SLOT(slotTalk()), actions);
d->mAct[KFibsPlayerListPrivate::Look] = new TDEAction(i18n("Look"), 0, this, TQT_SLOT(slotLook()), actions);
d->mAct[KFibsPlayerListPrivate::Watch] = new TDEAction(i18n("Watch"), 0, this, TQT_SLOT(slotWatch()), actions);
d->mAct[KFibsPlayerListPrivate::Unwatch] = new TDEAction(i18n("Unwatch"), 0, this, TQT_SLOT(slotUnwatch()),actions);
d->mAct[KFibsPlayerListPrivate::BlindAct] = new TDEAction(i18n("Blind"), 0, this, TQT_SLOT(slotBlind()), actions);
d->mAct[KFibsPlayerListPrivate::Update] = new TDEAction(i18n("Update"), 0, this, TQT_SLOT(slotUpdate()), actions);
d->mAct[KFibsPlayerListPrivate::Look] = new TDEAction(i18n("Look"), 0, this, TQ_SLOT(slotLook()), actions);
d->mAct[KFibsPlayerListPrivate::Watch] = new TDEAction(i18n("Watch"), 0, this, TQ_SLOT(slotWatch()), actions);
d->mAct[KFibsPlayerListPrivate::Unwatch] = new TDEAction(i18n("Unwatch"), 0, this, TQ_SLOT(slotUnwatch()),actions);
d->mAct[KFibsPlayerListPrivate::BlindAct] = new TDEAction(i18n("Blind"), 0, this, TQ_SLOT(slotBlind()), actions);
d->mAct[KFibsPlayerListPrivate::Update] = new TDEAction(i18n("Update"), 0, this, TQ_SLOT(slotUpdate()), actions);
d->mAct[KFibsPlayerListPrivate::Reload] = KStdAction::redisplay(this, TQT_SLOT(slotReload()), actions);
d->mAct[KFibsPlayerListPrivate::Mail] = KStdAction::mail(this, TQT_SLOT(slotMail()), actions);
d->mAct[KFibsPlayerListPrivate::Close] = KStdAction::close(this, TQT_SLOT(hide()), actions);
d->mAct[KFibsPlayerListPrivate::Reload] = KStdAction::redisplay(this, TQ_SLOT(slotReload()), actions);
d->mAct[KFibsPlayerListPrivate::Mail] = KStdAction::mail(this, TQ_SLOT(slotMail()), actions);
d->mAct[KFibsPlayerListPrivate::Close] = KStdAction::close(this, TQ_SLOT(hide()), actions);
d->mAct[KFibsPlayerListPrivate::InviteD] = new TDEAction(i18n("Use Dialog"), 0, this,
TQT_SLOT(slotInviteD()), actions);
TQ_SLOT(slotInviteD()), actions);
d->mAct[KFibsPlayerListPrivate::Invite1] = new TDEAction(i18n("1 Point Match"), 0, this,
TQT_SLOT(slotInvite1()), actions);
TQ_SLOT(slotInvite1()), actions);
d->mAct[KFibsPlayerListPrivate::Invite2] = new TDEAction(i18n("2 Point Match"), 0, this,
TQT_SLOT(slotInvite2()), actions);
TQ_SLOT(slotInvite2()), actions);
d->mAct[KFibsPlayerListPrivate::Invite3] = new TDEAction(i18n("3 Point Match"), 0, this,
TQT_SLOT(slotInvite3()), actions);
TQ_SLOT(slotInvite3()), actions);
d->mAct[KFibsPlayerListPrivate::Invite4] = new TDEAction(i18n("4 Point Match"), 0, this,
TQT_SLOT(slotInvite4()), actions);
TQ_SLOT(slotInvite4()), actions);
d->mAct[KFibsPlayerListPrivate::Invite5] = new TDEAction(i18n("5 Point Match"), 0, this,
TQT_SLOT(slotInvite5()), actions);
TQ_SLOT(slotInvite5()), actions);
d->mAct[KFibsPlayerListPrivate::Invite6] = new TDEAction(i18n("6 Point Match"), 0, this,
TQT_SLOT(slotInvite6()), actions);
TQ_SLOT(slotInvite6()), actions);
d->mAct[KFibsPlayerListPrivate::Invite7] = new TDEAction(i18n("7 Point Match"), 0, this,
TQT_SLOT(slotInvite7()), actions);
TQ_SLOT(slotInvite7()), actions);
d->mAct[KFibsPlayerListPrivate::InviteU] = new TDEAction(i18n("Unlimited"), 0, this,
TQT_SLOT(slotInviteU()), actions);
TQ_SLOT(slotInviteU()), actions);
d->mAct[KFibsPlayerListPrivate::InviteR] = new TDEAction(i18n("Resume"), 0, this,
TQT_SLOT(slotInviteR()), actions);
TQ_SLOT(slotInviteR()), actions);
/*
* Fill normal context menu
@ -362,10 +362,10 @@ KFibsPlayerList::KFibsPlayerList(TQWidget *parent, const char *name)
/*
* Right mouse button gets context menu, double click gets player info
*/
connect(this, TQT_SIGNAL(contextMenu(TDEListView *, TQListViewItem *, const TQPoint &)),
this, TQT_SLOT(showContextMenu(TDEListView *, TQListViewItem *, const TQPoint &)));
connect(this, TQT_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint &, int)),
this, TQT_SLOT(getPlayerInfo(TQListViewItem *, const TQPoint &, int)));
connect(this, TQ_SIGNAL(contextMenu(TDEListView *, TQListViewItem *, const TQPoint &)),
this, TQ_SLOT(showContextMenu(TDEListView *, TQListViewItem *, const TQPoint &)));
connect(this, TQ_SIGNAL(doubleClicked(TQListViewItem *, const TQPoint &, int)),
this, TQ_SLOT(getPlayerInfo(TQListViewItem *, const TQPoint &, int)));
}
/*
@ -482,7 +482,7 @@ void KFibsPlayerList::getSetupPages(KTabCtl *nb, int space)
*/
nb->addTab(w, i18n("&Playerlist"));
connect(nb, TQT_SIGNAL(applyButtonPressed()), this, TQT_SLOT(setupOk()));
connect(nb, TQ_SIGNAL(applyButtonPressed()), this, TQ_SLOT(setupOk()));
}
/*

2
kbackgammon/engines/generic/kbgengine.cpp
Unescape View File

@ -38,7 +38,7 @@ KBgEngine::KBgEngine(TQWidget *parent, TQString *name, TQPopupMenu *pmenu)
menu = pmenu;
cl = -1;
ct = new TQTimer(this);
connect(ct, TQT_SIGNAL(timeout()), this, TQT_SLOT(done()));
connect(ct, TQ_SIGNAL(timeout()), this, TQ_SLOT(done()));
}
/*

18
kbackgammon/engines/gnubg/kbggnubg.cpp
Unescape View File

@ -433,12 +433,12 @@ KBgEngineGNU::KBgEngineGNU(TQWidget *parent, TQString *name, TQPopupMenu *pmenu)
* internal statue variables
*/
rollingAllowed = undoPossible = gameRunning = donePossible = false;
connect(this, TQT_SIGNAL(allowCommand(int, bool)), this, TQT_SLOT(setAllowed(int, bool)));
connect(this, TQ_SIGNAL(allowCommand(int, bool)), this, TQ_SLOT(setAllowed(int, bool)));
/*
* Setup of menu
*/
resAction = new TDEAction(i18n("&Restart GNU Backgammon"), 0, this, TQT_SLOT(startGNU()), this);
resAction = new TDEAction(i18n("&Restart GNU Backgammon"), 0, this, TQ_SLOT(startGNU()), this);
resAction->setEnabled(false); resAction->plug(menu);
/*
@ -468,7 +468,7 @@ void KBgEngineGNU::start()
* Will be started later
*/
cmdTimer = new TQTimer(this);
connect(cmdTimer, TQT_SIGNAL(timeout()), TQT_SLOT(nextCommand()) );
connect(cmdTimer, TQ_SIGNAL(timeout()), TQ_SLOT(nextCommand()) );
emit infoText(i18n("This is experimental code which currently requires a specially "
"patched version of GNU Backgammon.<br/><br/>"));
@ -483,12 +483,12 @@ void KBgEngineGNU::start()
*/
gnubg << "gnubg" << "--tty";
connect(&gnubg, TQT_SIGNAL(processExited(TDEProcess *)), this, TQT_SLOT(gnubgExit(TDEProcess *)));
connect(&gnubg, TQT_SIGNAL(receivedStderr(TDEProcess *, char *, int)),
this, TQT_SLOT(receiveData(TDEProcess *, char *, int)));
connect(&gnubg, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQT_SLOT(receiveData(TDEProcess *, char *, int)));
connect(&gnubg, TQT_SIGNAL(wroteStdin(TDEProcess *)), this, TQT_SLOT(wroteStdin(TDEProcess *)));
connect(&gnubg, TQ_SIGNAL(processExited(TDEProcess *)), this, TQ_SLOT(gnubgExit(TDEProcess *)));
connect(&gnubg, TQ_SIGNAL(receivedStderr(TDEProcess *, char *, int)),
this, TQ_SLOT(receiveData(TDEProcess *, char *, int)));
connect(&gnubg, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int)),
this, TQ_SLOT(receiveData(TDEProcess *, char *, int)));
connect(&gnubg, TQ_SIGNAL(wroteStdin(TDEProcess *)), this, TQ_SLOT(wroteStdin(TDEProcess *)));
startGNU();
}

32
kbackgammon/engines/nextgen/kbgng.cpp
Unescape View File

@ -67,13 +67,13 @@ KBgEngineNg::KBgEngineNg(TQWidget *parent, TQString *name, TQPopupMenu *pmenu)
for (int i = 0; i < MaxTypes; i++)
list.append(label[i]);
_gameSelect = new TDESelectAction(i18n("&Types"), 0, this, TQT_SLOT(setGame()), this);
_gameSelect = new TDESelectAction(i18n("&Types"), 0, this, TQ_SLOT(setGame()), this);
_gameSelect->setItems(list);
_gameSelect->plug(menu);
menu->insertSeparator();
_connectAction = new TDEAction(i18n("&Names..."), 0, this, TQT_SLOT(changeName()), this);
_connectAction = new TDEAction(i18n("&Names..."), 0, this, TQ_SLOT(changeName()), this);
_connectAction->plug(menu);
// Restore last settings
@ -588,8 +588,8 @@ KBgPlayer * KBgEngineNg::createPlayer(int i, TQString name)
p->findProperty(KGamePropertyBase::IdName)->setEmittingSignal(true);
connect(p, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KPlayer *)),
this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase *, KPlayer *)));
connect(p, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KPlayer *)),
this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase *, KPlayer *)));
return (_player[i] = p);
}
@ -602,20 +602,20 @@ void KBgEngineNg::initGame()
_game = new KBgGame(PROG_COOKIE);
_game->random()->setSeed(getpid()*time(NULL));
connect(_game, TQT_SIGNAL(signalPlayerJoinedGame(KPlayer *)),
this, TQT_SLOT(slotPlayerJoinedGame(KPlayer *)));
connect(_game, TQT_SIGNAL(signalCreatePlayer(KPlayer *&, int, int, bool, KGame *)),
this, TQT_SLOT(slotCreatePlayer(KPlayer *&, int, int, bool, KGame *)));
connect(_game, TQ_SIGNAL(signalPlayerJoinedGame(KPlayer *)),
this, TQ_SLOT(slotPlayerJoinedGame(KPlayer *)));
connect(_game, TQ_SIGNAL(signalCreatePlayer(KPlayer *&, int, int, bool, KGame *)),
this, TQ_SLOT(slotCreatePlayer(KPlayer *&, int, int, bool, KGame *)));
connect(_game, TQT_SIGNAL(signalClientConnected(TQ_UINT32)),
this, TQT_SLOT(slotClientConnected(TQ_UINT32)));
connect(_game, TQT_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)),
this, TQT_SLOT(slotClientDisconnected(TQ_UINT32, bool)));
connect(_game, TQ_SIGNAL(signalClientConnected(TQ_UINT32)),
this, TQ_SLOT(slotClientConnected(TQ_UINT32)));
connect(_game, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)),
this, TQ_SLOT(slotClientDisconnected(TQ_UINT32, bool)));
connect(_game, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KGame *)),
this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase *, KGame *)));
connect(_game, TQT_SIGNAL(signalNetworkData(int,const TQByteArray &, TQ_UINT32, TQ_UINT32)),
this, TQT_SLOT(slotNetworkData(int,const TQByteArray &, TQ_UINT32, TQ_UINT32)));
connect(_game, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KGame *)),
this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase *, KGame *)));
connect(_game, TQ_SIGNAL(signalNetworkData(int,const TQByteArray &, TQ_UINT32, TQ_UINT32)),
this, TQ_SLOT(slotNetworkData(int,const TQByteArray &, TQ_UINT32, TQ_UINT32)));
}
// EOF

10
kbackgammon/engines/offline/kbgoffline.cpp
Unescape View File

@ -119,11 +119,11 @@ KBgEngineOffline::KBgEngineOffline(TQWidget *parent, TQString *name, TQPopupMenu
/*
* Create engine specific actions
*/
d->mNew = new TDEAction(i18n("&New Game..."), 0, this, TQT_SLOT(newGame()), this);
d->mSwap = new TDEAction(i18n("&Swap Colors"), 0, this, TQT_SLOT(swapColors()), this);
d->mNew = new TDEAction(i18n("&New Game..."), 0, this, TQ_SLOT(newGame()), this);
d->mSwap = new TDEAction(i18n("&Swap Colors"), 0, this, TQ_SLOT(swapColors()), this);
d->mEdit = new TDEToggleAction(i18n("&Edit Mode"), 0, this,
TQT_SLOT(toggleEditMode()), this);
TQ_SLOT(toggleEditMode()), this);
d->mEdit->setChecked(false);
/*
@ -143,13 +143,13 @@ KBgEngineOffline::KBgEngineOffline(TQWidget *parent, TQString *name, TQPopupMenu
* initialize the commit timeout
*/
ct = new TQTimer(this);
connect(ct, TQT_SIGNAL(timeout()), this, TQT_SLOT(done()));
connect(ct, TQ_SIGNAL(timeout()), this, TQ_SLOT(done()));
/*
* internal statue variables
*/
d->mRollFlag = d->mUndoFlag = d->mGameFlag = d->mDoneFlag = false;
connect(this, TQT_SIGNAL(allowCommand(int, bool)), this, TQT_SLOT(setAllowed(int, bool)));
connect(this, TQ_SIGNAL(allowCommand(int, bool)), this, TQ_SLOT(setAllowed(int, bool)));
/*
* Restore last stored settings

82
kbackgammon/kbg.cpp
Unescape View File

@ -96,45 +96,45 @@ KBg::KBg()
/*
* Create all actions needed by the application
*/
newAction = KStdGameAction::gameNew(this, TQT_SLOT(openNew()), actionCollection());
newAction = KStdGameAction::gameNew(this, TQ_SLOT(openNew()), actionCollection());
newAction->setEnabled(false);
KStdGameAction::print(this, TQT_SLOT(print()), actionCollection());
KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
KStdGameAction::print(this, TQ_SLOT(print()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
TQStringList list;
for (int i = 0; i < MaxEngine; i++)
list.append(engineString[i]);
engineSet = new TDESelectAction(i18n("&Engine"), 0, this, TQT_SLOT(setupEngine()), actionCollection(),
engineSet = new TDESelectAction(i18n("&Engine"), 0, this, TQ_SLOT(setupEngine()), actionCollection(),
"move_engine");
engineSet->setItems(list);
// AB: what the heck has this to do with redisplay? perhaps use reload instead?
loadAction = KStdAction::redisplay(this, TQT_SLOT(load()), actionCollection(), "move_load");
loadAction = KStdAction::redisplay(this, TQ_SLOT(load()), actionCollection(), "move_load");
loadAction->setEnabled(false);
undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
undoAction = KStdGameAction::undo(this, TQ_SLOT(undo()), actionCollection());
undoAction->setEnabled(false);
redoAction = KStdGameAction::redo(this, TQT_SLOT(redo()), actionCollection());
redoAction = KStdGameAction::redo(this, TQ_SLOT(redo()), actionCollection());
redoAction->setEnabled(false);
rollAction = KStdGameAction::roll(this, TQT_SLOT(roll()), actionCollection());
rollAction = KStdGameAction::roll(this, TQ_SLOT(roll()), actionCollection());
rollAction->setEnabled(false);
endAction = KStdGameAction::endTurn(this, TQT_SLOT(done()), actionCollection());
endAction = KStdGameAction::endTurn(this, TQ_SLOT(done()), actionCollection());
endAction->setEnabled(false);
cubeAction = new TDEAction(i18n("Double Cube"), TQIconSet(kapp->iconLoader()->loadIcon
(PROG_NAME "-double.xpm", TDEIcon::Toolbar)),
0, this, TQT_SLOT(cube()), actionCollection(), "move_cube");
0, this, TQ_SLOT(cube()), actionCollection(), "move_cube");
cubeAction->setEnabled(false);
KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
KStdAction::preferences(this, TQT_SLOT(setupDlg()), actionCollection());
KStdAction::saveOptions(this, TQT_SLOT(saveConfig()), actionCollection());
KStdAction::showMenubar(this, TQ_SLOT(toggleMenubar()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(setupDlg()), actionCollection());
KStdAction::saveOptions(this, TQ_SLOT(saveConfig()), actionCollection());
TDEPopupMenu *p = (new TDEActionMenu(i18n("&Backgammon on the Web"),
actionCollection(), "help_www"))->popupMenu();
(new TDEAction(helpTopic[FIBSHome][0], 0, this, TQT_SLOT(wwwFIBS()),
(new TDEAction(helpTopic[FIBSHome][0], 0, this, TQ_SLOT(wwwFIBS()),
actionCollection(), "help_www_fibs"))->plug(p);
(new TDEAction(helpTopic[RuleHome][0], 0, this, TQT_SLOT(wwwRule()),
(new TDEAction(helpTopic[RuleHome][0], 0, this, TQ_SLOT(wwwRule()),
actionCollection(), "help_www_rule"))->plug(p);
/*
@ -148,7 +148,7 @@ KBg::KBg()
actionCmdLine->setAutoSized(true);
cmdLine->completionObject()->setOrder(TDECompletion::Weighted);
connect(cmdLine, TQT_SIGNAL(returnPressed(const TQString &)), this, TQT_SLOT(handleCmd(const TQString &)));
connect(cmdLine, TQ_SIGNAL(returnPressed(const TQString &)), this, TQ_SLOT(handleCmd(const TQString &)));
/*
* Done with the actions, create the XML-defined parts of the
* user interface
@ -172,8 +172,8 @@ KBg::KBg()
* Set up configuration handling.
* FIXME: support session management
*/
connect(this, TQT_SIGNAL(readSettings()), board, TQT_SLOT(readConfig()));
connect(this, TQT_SIGNAL(saveSettings()), board, TQT_SLOT(saveConfig()));
connect(this, TQ_SIGNAL(readSettings()), board, TQ_SLOT(readConfig()));
connect(this, TQ_SIGNAL(saveSettings()), board, TQ_SLOT(saveConfig()));
/*
* Set up some whatis messages for the online help
@ -274,26 +274,26 @@ void KBg::setupEngine()
newAction->setEnabled(engine[currEngine]->haveNewGame());
// engine -> this
connect(engine[currEngine], TQT_SIGNAL(statText(const TQString &)), this, TQT_SLOT(updateCaption(const TQString &)));
connect(engine[currEngine], TQT_SIGNAL(infoText(const TQString &)), status, TQT_SLOT(write(const TQString &)));
connect(engine[currEngine], TQT_SIGNAL(allowCommand(int, bool)), this, TQT_SLOT(allowCommand(int, bool)));
connect(engine[currEngine], TQ_SIGNAL(statText(const TQString &)), this, TQ_SLOT(updateCaption(const TQString &)));
connect(engine[currEngine], TQ_SIGNAL(infoText(const TQString &)), status, TQ_SLOT(write(const TQString &)));
connect(engine[currEngine], TQ_SIGNAL(allowCommand(int, bool)), this, TQ_SLOT(allowCommand(int, bool)));
// this -> engine
connect(this, TQT_SIGNAL(readSettings()), engine[currEngine], TQT_SLOT(readConfig()));
connect(this, TQT_SIGNAL(saveSettings()), engine[currEngine], TQT_SLOT(saveConfig()));
connect(this, TQ_SIGNAL(readSettings()), engine[currEngine], TQ_SLOT(readConfig()));
connect(this, TQ_SIGNAL(saveSettings()), engine[currEngine], TQ_SLOT(saveConfig()));
// board -> engine
connect(board, TQT_SIGNAL(rollDice(const int)), engine[currEngine], TQT_SLOT(rollDice(const int)));
connect(board, TQT_SIGNAL(doubleCube(const int)), engine[currEngine], TQT_SLOT(doubleCube(const int)));
connect(board, TQT_SIGNAL(currentMove(TQString *)), engine[currEngine], TQT_SLOT(handleMove(TQString *)));
connect(board, TQ_SIGNAL(rollDice(const int)), engine[currEngine], TQ_SLOT(rollDice(const int)));
connect(board, TQ_SIGNAL(doubleCube(const int)), engine[currEngine], TQ_SLOT(doubleCube(const int)));
connect(board, TQ_SIGNAL(currentMove(TQString *)), engine[currEngine], TQ_SLOT(handleMove(TQString *)));
// engine -> board
connect(engine[currEngine], TQT_SIGNAL(undoMove()), board, TQT_SLOT(undoMove()));
connect(engine[currEngine], TQT_SIGNAL(redoMove()), board, TQT_SLOT(redoMove()));
connect(engine[currEngine], TQT_SIGNAL(setEditMode(const bool)), board, TQT_SLOT(setEditMode(const bool)));
connect(engine[currEngine], TQT_SIGNAL(allowMoving(const bool)), board, TQT_SLOT(allowMoving(const bool)));
connect(engine[currEngine], TQT_SIGNAL(getState(KBgStatus *)), board, TQT_SLOT(getState(KBgStatus *)));
connect(engine[currEngine], TQT_SIGNAL(newState(const KBgStatus &)), board, TQT_SLOT(setState(const KBgStatus &)));
connect(engine[currEngine], TQ_SIGNAL(undoMove()), board, TQ_SLOT(undoMove()));
connect(engine[currEngine], TQ_SIGNAL(redoMove()), board, TQ_SLOT(redoMove()));
connect(engine[currEngine], TQ_SIGNAL(setEditMode(const bool)), board, TQ_SLOT(setEditMode(const bool)));
connect(engine[currEngine], TQ_SIGNAL(allowMoving(const bool)), board, TQ_SLOT(allowMoving(const bool)));
connect(engine[currEngine], TQ_SIGNAL(getState(KBgStatus *)), board, TQ_SLOT(getState(KBgStatus *)));
connect(engine[currEngine], TQ_SIGNAL(newState(const KBgStatus &)), board, TQ_SLOT(setState(const KBgStatus &)));
// now that all signals are connected, start the engine
engine[currEngine]->start();
@ -535,7 +535,7 @@ void KBg::setupDlg()
sbt->setLabel(i18n("Move timeout in seconds:"));
sbt->setValue(config->readDoubleNumEntry("timeout", 2.5));
connect(cbt, TQT_SIGNAL(toggled(bool)), sbt, TQT_SLOT(setEnabled(bool)));
connect(cbt, TQ_SIGNAL(toggled(bool)), sbt, TQ_SLOT(setEnabled(bool)));
sbt->setEnabled(cbt->isChecked());
TQGridLayout *gl = new TQGridLayout(gbt, 2, 1, 20);
@ -577,7 +577,7 @@ void KBg::setupDlg()
lab->setMaximumSize(lab->sizeHint());
gle->addWidget(lab, 0, 0);
connect(lab, TQT_SIGNAL(leftClickedURL(const TQString &)), TQT_SLOT(startKCM(const TQString &)));
connect(lab, TQ_SIGNAL(leftClickedURL(const TQString &)), TQ_SLOT(startKCM(const TQString &)));
/*
* Board settings
@ -606,7 +606,7 @@ void KBg::setupDlg()
engine[i] = new KBgEngineNg(nb, &s, dummyPopup);
break;
}
connect(this, TQT_SIGNAL(saveSettings()), engine[i], TQT_SLOT(saveConfig()));
connect(this, TQ_SIGNAL(saveSettings()), engine[i], TQ_SLOT(saveConfig()));
}
engine[i]->getSetupPages(nb);
}
@ -614,12 +614,12 @@ void KBg::setupDlg()
/*
* Connect the signals of nb
*/
connect(nb, TQT_SIGNAL(okClicked()), this, TQT_SLOT(setupOk()));
connect(nb, TQT_SIGNAL(applyClicked()), this, TQT_SLOT(setupOk()));
connect(nb, TQT_SIGNAL(cancelClicked()), this, TQT_SLOT(setupCancel()));
connect(nb, TQT_SIGNAL(defaultClicked()),this, TQT_SLOT(setupDefault()));
connect(nb, TQ_SIGNAL(okClicked()), this, TQ_SLOT(setupOk()));
connect(nb, TQ_SIGNAL(applyClicked()), this, TQ_SLOT(setupOk()));
connect(nb, TQ_SIGNAL(cancelClicked()), this, TQ_SLOT(setupCancel()));
connect(nb, TQ_SIGNAL(defaultClicked()),this, TQ_SLOT(setupDefault()));
connect(nb, TQT_SIGNAL(finished()), this, TQT_SLOT(setupDone()));
connect(nb, TQ_SIGNAL(finished()), this, TQ_SLOT(setupDone()));
nb->resize(nb->minimumSize());
nb->show();
@ -685,7 +685,7 @@ void KBg::configureToolbars()
{
saveMainWindowSettings(TDEGlobal::config(), "kedittoolbar settings"); // temp group
KEditToolbar dlg(actionCollection(), xmlFile(), true, this);
connect(&dlg,TQT_SIGNAL(newToolbarConfig()),this,TQT_SLOT(newToolbarConfig()));
connect(&dlg,TQ_SIGNAL(newToolbarConfig()),this,TQ_SLOT(newToolbarConfig()));
dlg.exec();
TDEGlobal::config()->deleteGroup( "kedittoolbar settings" ); // delete temp group
}

20
kbackgammon/kbgboard.cpp
Unescape View File

@ -173,9 +173,9 @@ void KBgBoardSetup::getSetupPages(KDialogBase *nb)
blc->addWidget(pbc_3, 0, 1);
blc->addMultiCellWidget(pbc_1, 1, 1, 0, 1);
connect(pbc_1, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBackgroundColor()));
connect(pbc_2, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBaseColorOne()));
connect(pbc_3, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBaseColorTwo()));
connect(pbc_1, TQ_SIGNAL(clicked()), this, TQ_SLOT(selectBackgroundColor()));
connect(pbc_2, TQ_SIGNAL(clicked()), this, TQ_SLOT(selectBaseColorOne()));
connect(pbc_3, TQ_SIGNAL(clicked()), this, TQ_SLOT(selectBaseColorTwo()));
/*
* Moving style
@ -470,11 +470,11 @@ KBgBoardQCube::KBgBoardQCube(int val, bool us, bool them)
cb[0]->setFocus();
connect(ok, TQT_SIGNAL(clicked()), TQT_SLOT(accept()));
connect(cancel, TQT_SIGNAL(clicked()), TQT_SLOT(reject()));
connect(ok, TQ_SIGNAL(clicked()), TQ_SLOT(accept()));
connect(cancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
connect(cb[0], TQT_SIGNAL(activated(int)), TQT_SLOT(changePlayer(int)));
connect(cb[1], TQT_SIGNAL(activated(int)), TQT_SLOT(changeValue (int)));
connect(cb[0], TQ_SIGNAL(activated(int)), TQ_SLOT(changePlayer(int)));
connect(cb[1], TQ_SIGNAL(activated(int)), TQ_SLOT(changeValue (int)));
}
/*
@ -576,8 +576,8 @@ KBgBoardQDice::KBgBoardQDice(const char *name)
sb[0]->setFocus();
connect(ok, TQT_SIGNAL(clicked()), TQT_SLOT(accept()));
connect(cancel, TQT_SIGNAL(clicked()), TQT_SLOT(reject()));
connect(ok, TQ_SIGNAL(clicked()), TQ_SLOT(accept()));
connect(cancel, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
sb[0]->setValue(1);
sb[1]->setValue(1);
@ -1748,7 +1748,7 @@ KBgBoardCell::KBgBoardCell(TQWidget * parent, int numID)
mouseButton = TQt::NoButton;
dragInProgress = false;
connect(parent, TQT_SIGNAL(finishedUpdate()), this, TQT_SLOT(refresh()));
connect(parent, TQ_SIGNAL(finishedUpdate()), this, TQ_SLOT(refresh()));
}
/*

208
kbattleship/kbattleship/kbattleship.cpp
Unescape View File

@ -92,16 +92,16 @@ void KBattleshipWindow::initStatusBar()
void KBattleshipWindow::initActions()
{
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");
KStdAction::configureNotifications(this, TQ_SLOT(slotConfigureNotifications()), actionCollection());
m_gameServerConnect = new TDEAction(i18n("&Connect to Server..."), "connect_no", Key_F2, this, TQ_SLOT(slotServerConnect()), actionCollection(), "game_serverconnect");
m_gameNewServer = new TDEAction(i18n("&Start Server..."), "network", Key_F3, this, TQ_SLOT(slotNewServer()), actionCollection(), "game_newserver");
m_gameSingle = new TDEAction(i18n("S&ingle Player..."), "gear", Key_F4, this, TQ_SLOT(slotSinglePlayer()), actionCollection(), "game_singleplayer");
m_gameQuit = KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
KStdGameAction::highscores(this, TQ_SLOT(slotHighscore()), actionCollection());
m_gameEnemyInfo = new TDEAction(i18n("&Enemy Info"), "view_text", Key_F11, this, TQ_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, this, TQT_SLOT(slotShowGrid()), actionCollection(), "options_show_grid");
m_configGrid = new TDEToggleAction(i18n("&Show Grid"), 0, this, TQ_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 &)), 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 &)));
connect(m_chat, TQ_SIGNAL(sigSendMessage(const TQString &)), this, TQ_SLOT(slotSendChatMessage(const TQString &)));
connect(m_chat, TQ_SIGNAL(sigChangeEnemyNickname(const TQString &)), this, TQ_SLOT(slotChangeEnemyPlayer(const TQString &)));
connect(m_chat, TQ_SIGNAL(sigChangeOwnNickname(const TQString &)), this, TQ_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)), this, TQT_SLOT(slotChangeOwnFieldData(int, int, int)));
connect(m_ownshiplist, TQT_SIGNAL(sigLastShipAdded()), this, TQT_SLOT(slotShipsReady()));
connect(m_ownshiplist, TQ_SIGNAL(sigOwnFieldDataChanged(int, int, int)), this, TQ_SLOT(slotChangeOwnFieldData(int, int, int)));
connect(m_ownshiplist, TQ_SIGNAL(sigLastShipAdded()), this, TQ_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)), 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()));
connect(m_view, TQ_SIGNAL(sigEnemyFieldClicked(int, int)), this, TQ_SLOT(slotEnemyFieldClick(int, int)));
connect(m_view, TQ_SIGNAL(sigOwnFieldClicked(int, int)), this, TQ_SLOT(slotPlaceShip(int, int)));
connect(m_view, TQ_SIGNAL(sigMouseOverField(int, int)), this, TQ_SLOT(slotPlaceShipPreview(int, int)));
connect(m_view, TQ_SIGNAL(changeShipPlacementDirection()), this, TQ_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, this, TQT_SLOT(slotRestartAI()));
TQTimer::singleShot(0, this, TQ_SLOT(slotRestartAI()));
break;
case KMessageBox::No:
TQTimer::singleShot(0, this, TQT_SLOT(slotDeleteAI()));
TQTimer::singleShot(0, this, TQ_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()), this, TQT_SLOT(slotConnectToBattleshipServer()));
connect(m_client, TQT_SIGNAL(sigCancelConnect()), this, TQT_SLOT(slotDeleteConnectDialog()));
connect(m_client, TQ_SIGNAL(sigConnectServer()), this, TQ_SLOT(slotConnectToBattleshipServer()));
connect(m_client, TQ_SIGNAL(sigCancelConnect()), this, TQ_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()), this, TQT_SLOT(slotStartBattleshipServer()));
connect(m_server, TQT_SIGNAL(cancelClicked()), this, TQT_SLOT(slotDeleteServerDialog()));
connect(m_server, TQ_SIGNAL(okClicked()), this, TQ_SLOT(slotStartBattleshipServer()));
connect(m_server, TQ_SIGNAL(cancelClicked()), this, TQ_SLOT(slotDeleteServerDialog()));
m_server->show();
slotStatusMsg(i18n("Ready"));
@ -828,7 +828,7 @@ void KBattleshipWindow::slotSendVersion()
msg->versionMessage();
slotSendMessage(msg);
TQTimer::singleShot(150, this, TQT_SLOT(slotSendGreet()));
TQTimer::singleShot(150, this, TQ_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 &)), 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 &)), this, TQT_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), this, TQT_SLOT(slotLost(KMessage *)));
connect(m_connection, TQ_SIGNAL(sigStatusBar(const TQString &)), this, TQ_SLOT(slotStatusMsg(const TQString &)));
connect(m_connection, TQ_SIGNAL(sigEnemyNickname(const TQString &)), this, TQ_SLOT(slotChangeEnemyPlayer(const TQString &)));
connect(m_connection, TQ_SIGNAL(sigSendNickname()), this, TQ_SLOT(slotSendGreet()));
connect(m_connection, TQ_SIGNAL(sigPlaceShips(bool)), this, TQ_SLOT(slotSetPlaceable(bool)));
connect(m_connection, TQ_SIGNAL(sigShootable(bool)), this, TQ_SLOT(slotSetShootable(bool)));
connect(m_connection, TQ_SIGNAL(sigSendFieldState(int, int)), this, TQ_SLOT(slotSendEnemyFieldState(int, int)));
connect(m_connection, TQ_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQ_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
connect(m_connection, TQ_SIGNAL(sigClientLost()), this, TQ_SLOT(slotClientLost()));
connect(m_connection, TQ_SIGNAL(sigAbortNetworkGame()), this, TQ_SLOT(slotAbortNetworkGame()));
connect(m_connection, TQ_SIGNAL(sigReplay()), this, TQ_SLOT(slotReplayRequest()));
connect(m_connection, TQ_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQ_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
connect(m_connection, TQ_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), this, TQ_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
connect(m_connection, TQ_SIGNAL(sigLost(KMessage *)), this, TQ_SLOT(slotLost(KMessage *)));
}
else
{
if(m_connection->type() == KonnectionHandling::CLIENT)
{
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 *)), this, TQT_SLOT(slotLost(KMessage *)));
disconnect(m_kbclient, TQ_SIGNAL(sigConnected()), this, TQ_SLOT(slotSendVersion()));
disconnect(m_connection, TQ_SIGNAL(sigAbortNetworkGame()), this, TQ_SLOT(slotAbortNetworkGame()));
disconnect(m_connection, TQ_SIGNAL(sigStatusBar(const TQString &)), this, TQ_SLOT(slotStatusMsg(const TQString &)));
disconnect(m_connection, TQ_SIGNAL(sigEnemyNickname(const TQString &)), this, TQ_SLOT(slotChangeEnemyPlayer(const TQString &)));
disconnect(m_connection, TQ_SIGNAL(sigSendFieldState(int, int)), this, TQ_SLOT(slotSendEnemyFieldState(int, int)));
disconnect(m_connection, TQ_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQ_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
disconnect(m_connection, TQ_SIGNAL(sigShootable(bool)), this, TQ_SLOT(slotSetShootable(bool)));
disconnect(m_connection, TQ_SIGNAL(sigPlaceShips(bool)), this, TQ_SLOT(slotSetPlaceable(bool)));
disconnect(m_connection, TQ_SIGNAL(sigServerLost()), this, TQ_SLOT(slotServerLost()));
disconnect(m_connection, TQ_SIGNAL(sigReplay()), this, TQ_SLOT(slotReplay()));
disconnect(m_connection, TQ_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQ_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
disconnect(m_connection, TQ_SIGNAL(sigLost(KMessage *)), this, TQ_SLOT(slotLost(KMessage *)));
m_connection->updateInternal(m_kbserver);
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 *)), this, TQT_SLOT(slotLost(KMessage *)));
connect(m_connection, TQ_SIGNAL(sigStatusBar(const TQString &)), this, TQ_SLOT(slotStatusMsg(const TQString &)));
connect(m_connection, TQ_SIGNAL(sigEnemyNickname(const TQString &)), this, TQ_SLOT(slotChangeEnemyPlayer(const TQString &)));
connect(m_connection, TQ_SIGNAL(sigSendNickname()), this, TQ_SLOT(slotSendGreet()));
connect(m_connection, TQ_SIGNAL(sigPlaceShips(bool)), this, TQ_SLOT(slotSetPlaceable(bool)));
connect(m_connection, TQ_SIGNAL(sigShootable(bool)), this, TQ_SLOT(slotSetShootable(bool)));
connect(m_connection, TQ_SIGNAL(sigSendFieldState(int, int)), this, TQ_SLOT(slotSendEnemyFieldState(int, int)));
connect(m_connection, TQ_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQ_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
connect(m_connection, TQ_SIGNAL(sigClientLost()), this, TQ_SLOT(slotClientLost()));
connect(m_connection, TQ_SIGNAL(sigAbortNetworkGame()), this, TQ_SLOT(slotAbortNetworkGame()));
connect(m_connection, TQ_SIGNAL(sigReplay()), this, TQ_SLOT(slotReplayRequest()));
connect(m_connection, TQ_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQ_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
connect(m_connection, TQ_SIGNAL(sigLost(KMessage *)), this, TQ_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()), 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 &)), this, TQT_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
connect(m_connection, TQT_SIGNAL(sigLost(KMessage *)), this, TQT_SLOT(slotLost(KMessage *)));
connect(m_kbclient, TQ_SIGNAL(sigConnected()), this, TQ_SLOT(slotSendVersion()));
connect(m_connection, TQ_SIGNAL(sigAbortNetworkGame()), this, TQ_SLOT(slotAbortNetworkGame()));
connect(m_connection, TQ_SIGNAL(sigStatusBar(const TQString &)), this, TQ_SLOT(slotStatusMsg(const TQString &)));
connect(m_connection, TQ_SIGNAL(sigEnemyNickname(const TQString &)), this, TQ_SLOT(slotChangeEnemyPlayer(const TQString &)));
connect(m_connection, TQ_SIGNAL(sigSendFieldState(int, int)), this, TQ_SLOT(slotSendEnemyFieldState(int, int)));
connect(m_connection, TQ_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQ_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
connect(m_connection, TQ_SIGNAL(sigShootable(bool)), this, TQ_SLOT(slotSetShootable(bool)));
connect(m_connection, TQ_SIGNAL(sigPlaceShips(bool)), this, TQ_SLOT(slotSetPlaceable(bool)));
connect(m_connection, TQ_SIGNAL(sigServerLost()), this, TQ_SLOT(slotServerLost()));
connect(m_connection, TQ_SIGNAL(sigReplay()), this, TQ_SLOT(slotReplay()));
connect(m_connection, TQ_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQ_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
connect(m_connection, TQ_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), this, TQ_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
connect(m_connection, TQ_SIGNAL(sigLost(KMessage *)), this, TQ_SLOT(slotLost(KMessage *)));
}
else
{
if(m_connection->type() == KonnectionHandling::SERVER)
{
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 *)), this, TQT_SLOT(slotLost(KMessage *)));
disconnect(m_connection, TQ_SIGNAL(sigStatusBar(const TQString &)), this, TQ_SLOT(slotStatusMsg(const TQString &)));
disconnect(m_connection, TQ_SIGNAL(sigEnemyNickname(const TQString &)), this, TQ_SLOT(slotChangeEnemyPlayer(const TQString &)));
disconnect(m_connection, TQ_SIGNAL(sigSendNickname()), this, TQ_SLOT(slotSendGreet()));
disconnect(m_connection, TQ_SIGNAL(sigPlaceShips(bool)), this, TQ_SLOT(slotSetPlaceable(bool)));
disconnect(m_connection, TQ_SIGNAL(sigShootable(bool)), this, TQ_SLOT(slotSetShootable(bool)));
disconnect(m_connection, TQ_SIGNAL(sigSendFieldState(int, int)), this, TQ_SLOT(slotSendEnemyFieldState(int, int)));
disconnect(m_connection, TQ_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQ_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
disconnect(m_connection, TQ_SIGNAL(sigClientLost()), this, TQ_SLOT(slotClientLost()));
disconnect(m_connection, TQ_SIGNAL(sigAbortNetworkGame()), this, TQ_SLOT(slotAbortNetworkGame()));
disconnect(m_connection, TQ_SIGNAL(sigReplay()), this, TQ_SLOT(slotReplayRequest()));
disconnect(m_connection, TQ_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQ_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
disconnect(m_connection, TQ_SIGNAL(sigLost(KMessage *)), this, TQ_SLOT(slotLost(KMessage *)));
m_connection->updateInternal(m_kbclient);
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_kbclient, TQ_SIGNAL(sigConnected()), this, TQ_SLOT(slotSendVersion()));
connect(m_connection, TQ_SIGNAL(sigAbortNetworkGame()), this, TQ_SLOT(slotAbortNetworkGame()));
connect(m_connection, TQ_SIGNAL(sigStatusBar(const TQString &)), this, TQ_SLOT(slotStatusMsg(const TQString &)));
connect(m_connection, TQ_SIGNAL(sigEnemyNickname(const TQString &)), this, TQ_SLOT(slotChangeEnemyPlayer(const TQString &)));
connect(m_connection, TQ_SIGNAL(sigSendFieldState(int, int)), this, TQ_SLOT(slotSendEnemyFieldState(int, int)));
connect(m_connection, TQ_SIGNAL(sigEnemyFieldData(int, int, int, int, int, int, int, bool)), this, TQ_SLOT(slotReceivedEnemyFieldData(int, int, int, int, int, int, int, bool)));
connect(m_connection, TQ_SIGNAL(sigShootable(bool)), this, TQ_SLOT(slotSetShootable(bool)));
connect(m_connection, TQ_SIGNAL(sigPlaceShips(bool)), this, TQ_SLOT(slotSetPlaceable(bool)));
connect(m_connection, TQ_SIGNAL(sigServerLost()), this, TQ_SLOT(slotServerLost()));
connect(m_connection, TQ_SIGNAL(sigReplay()), this, TQ_SLOT(slotReplay()));
connect(m_connection, TQ_SIGNAL(sigChatMessage(const TQString &, const TQString &, bool)), m_chat, TQ_SLOT(slotReceivedMessage(const TQString &, const TQString &, bool)));
m_kbclient->init();
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 *)));
connect(m_connection, TQ_SIGNAL(sigClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)), this, TQ_SLOT(slotReceivedClientInformation(const TQString &, const TQString &, const TQString &, const TQString &)));
connect(m_connection, TQ_SIGNAL(sigLost(KMessage *)), this, TQ_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, this, TQT_SLOT(slotDeleteAI()));
TQTimer::singleShot(0, this, TQ_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()), this, TQT_SLOT(slotAIReady()));
connect(m_aiPlayer, TQT_SIGNAL(sigShootAt(const TQPoint)), this, TQT_SLOT(slotAIShootsAt(const TQPoint)));
connect(m_aiPlayer, TQ_SIGNAL(sigReady()), this, TQ_SLOT(slotAIReady()));
connect(m_aiPlayer, TQ_SIGNAL(sigShootAt(const TQPoint)), this, TQ_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, this, TQT_SLOT(slotRestartAI()));
TQTimer::singleShot(0, this, TQ_SLOT(slotRestartAI()));
break;
case KMessageBox::No:
TQTimer::singleShot(0, this, TQT_SLOT(slotDeleteAI()));
TQTimer::singleShot(0, this, TQ_SLOT(slotDeleteAI()));
break;
}
}

2
kbattleship/kbattleship/kbattleshipclient.cpp
Unescape View File

@ -44,7 +44,7 @@ void KBattleshipClient::init()
}
m_readNotifier = new TQSocketNotifier(fd(), TQSocketNotifier::Read, this);
TQObject::connect(m_readNotifier, TQT_SIGNAL(activated(int)), TQT_SLOT(slotReadData()));
TQObject::connect(m_readNotifier, TQ_SIGNAL(activated(int)), TQ_SLOT(slotReadData()));
emit sigConnected();
}

4
kbattleship/kbattleship/kbattleshipserver.cpp
Unescape View File

@ -50,7 +50,7 @@ void KBattleshipServer::init()
m_service.setPort(m_port);
m_service.publishAsync();
m_connectNotifier = new TQSocketNotifier(fd(), TQSocketNotifier::Read, this);
TQObject::connect(m_connectNotifier, TQT_SIGNAL(activated(int)), TQT_SLOT(slotNewConnection()));
TQObject::connect(m_connectNotifier, TQ_SIGNAL(activated(int)), TQ_SLOT(slotNewConnection()));
}
void KBattleshipServer::slotNewConnection()
@ -62,7 +62,7 @@ void KBattleshipServer::slotNewConnection()
m_service.stop();
m_serverSocket = sock;
m_readNotifier = new TQSocketNotifier(sock->fd(), TQSocketNotifier::Read, this);
TQObject::connect(m_readNotifier, TQT_SIGNAL(activated(int)), this, TQT_SLOT(slotReadClient()));
TQObject::connect(m_readNotifier, TQ_SIGNAL(activated(int)), this, TQ_SLOT(slotReadClient()));
emit sigNewConnect();
}
else

4
kbattleship/kbattleship/kchatwidget.cpp
Unescape View File

@ -20,8 +20,8 @@
KChatWidget::KChatWidget(TQWidget *parent, const char *name) : chatDlg(parent, name)
{
connect(sendBtn, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotComputeMessage()));
connect(commentEdit, TQT_SIGNAL(returnPressed()), this, TQT_SLOT(slotComputeMessage()));
connect(sendBtn, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotComputeMessage()));
connect(commentEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(slotComputeMessage()));
chatView->setFocusProxy(commentEdit);
chatView->setMinimumSize(0, 50);
commentEdit->installEventFilter(this);

8
kbattleship/kbattleship/kclientdialog.cpp
Unescape View File

@ -38,14 +38,14 @@ KClientDialog::KClientDialog(TQWidget *parent, const char *name)
KUser u;
m_mainWidget->nicknameEdit->setText(u.loginName());
connect(m_mainWidget->serverEdit, TQT_SIGNAL(returnPressed(const TQString &)), this, TQT_SLOT(slotReturnPressed(const TQString &)));
connect(m_mainWidget->serverEdit, TQT_SIGNAL(textChanged(const TQString &)), this, TQT_SLOT(slotCheckEnableOk()));
connect(m_mainWidget->serverEdit, TQ_SIGNAL(returnPressed(const TQString &)), this, TQ_SLOT(slotReturnPressed(const TQString &)));
connect(m_mainWidget->serverEdit, TQ_SIGNAL(textChanged(const TQString &)), this, TQ_SLOT(slotCheckEnableOk()));
m_config->setGroup("History");
m_browser = new DNSSD::ServiceBrowser(TQString::fromLatin1(BATTLESHIP_SERVICE));
connect(m_browser,TQT_SIGNAL(finished()),TQT_SLOT(nextBatch()));
connect(m_browser,TQ_SIGNAL(finished()),TQ_SLOT(nextBatch()));
m_browser->startBrowse();
connect(m_mainWidget->lanBox,TQT_SIGNAL(activated(int)),TQT_SLOT(gameSelected(int)));
connect(m_mainWidget->lanBox,TQ_SIGNAL(activated(int)),TQ_SLOT(gameSelected(int)));
m_mainWidget->serverEdit->completionObject()->setItems(m_config->readListEntry("CompletionList"));
m_mainWidget->serverEdit->setMaxCount(5);

36
kbattleship/kbattleship/konnectionhandling.cpp
Unescape View File

@ -24,11 +24,11 @@ KonnectionHandling::KonnectionHandling(TQWidget *parent, KBattleshipServer *serv
m_kbserver = server;
m_kbclient = 0;
m_type = KonnectionHandling::SERVER;
connect(server, TQT_SIGNAL(sigServerFailure()), this, TQT_SIGNAL(sigAbortNetworkGame()));
connect(server, TQT_SIGNAL(sigNewConnect()), this, TQT_SLOT(slotNewClient()));
connect(server, TQT_SIGNAL(sigEndConnect()), this, TQT_SLOT(slotLostClient()));
connect(server, TQT_SIGNAL(sigNewMessage(KMessage *)), this, TQT_SLOT(slotNewMessage(KMessage *)));
connect(server, TQT_SIGNAL(sigMessageSent(KMessage *)), this, TQT_SLOT(slotMessageSent(KMessage *)));
connect(server, TQ_SIGNAL(sigServerFailure()), this, TQ_SIGNAL(sigAbortNetworkGame()));
connect(server, TQ_SIGNAL(sigNewConnect()), this, TQ_SLOT(slotNewClient()));
connect(server, TQ_SIGNAL(sigEndConnect()), this, TQ_SLOT(slotLostClient()));
connect(server, TQ_SIGNAL(sigNewMessage(KMessage *)), this, TQ_SLOT(slotNewMessage(KMessage *)));
connect(server, TQ_SIGNAL(sigMessageSent(KMessage *)), this, TQ_SLOT(slotMessageSent(KMessage *)));
}
KonnectionHandling::KonnectionHandling(TQWidget *parent, KBattleshipClient *client) : TQObject(parent)
@ -36,10 +36,10 @@ KonnectionHandling::KonnectionHandling(TQWidget *parent, KBattleshipClient *clie
m_kbclient = client;
m_kbserver = 0;
m_type = KonnectionHandling::CLIENT;
connect(client, TQT_SIGNAL(sigEndConnect()), this, TQT_SLOT(slotLostServer()));
connect(client, TQT_SIGNAL(sigSocketFailure(int)), this, TQT_SLOT(slotSocketError(int)));
connect(client, TQT_SIGNAL(sigNewMessage(KMessage *)), this, TQT_SLOT(slotNewMessage(KMessage *)));
connect(client, TQT_SIGNAL(sigMessageSent(KMessage *)), this, TQT_SLOT(slotMessageSent(KMessage *)));
connect(client, TQ_SIGNAL(sigEndConnect()), this, TQ_SLOT(slotLostServer()));
connect(client, TQ_SIGNAL(sigSocketFailure(int)), this, TQ_SLOT(slotSocketError(int)));
connect(client, TQ_SIGNAL(sigNewMessage(KMessage *)), this, TQ_SLOT(slotNewMessage(KMessage *)));
connect(client, TQ_SIGNAL(sigMessageSent(KMessage *)), this, TQ_SLOT(slotMessageSent(KMessage *)));
}
void KonnectionHandling::updateInternal(KBattleshipServer *server)
@ -47,11 +47,11 @@ void KonnectionHandling::updateInternal(KBattleshipServer *server)
m_kbserver = server;
m_kbclient = 0;
m_type = KonnectionHandling::SERVER;
connect(server, TQT_SIGNAL(sigServerFailure()), this, TQT_SIGNAL(sigAbortNetworkGame()));
connect(server, TQT_SIGNAL(sigNewConnect()), this, TQT_SLOT(slotNewClient()));
connect(server, TQT_SIGNAL(sigEndConnect()), this, TQT_SLOT(slotLostClient()));
connect(server, TQT_SIGNAL(sigNewMessage(KMessage *)), this, TQT_SLOT(slotNewMessage(KMessage *)));
connect(server, TQT_SIGNAL(sigMessageSent(KMessage *)), this, TQT_SLOT(slotMessageSent(KMessage *)));
connect(server, TQ_SIGNAL(sigServerFailure()), this, TQ_SIGNAL(sigAbortNetworkGame()));
connect(server, TQ_SIGNAL(sigNewConnect()), this, TQ_SLOT(slotNewClient()));
connect(server, TQ_SIGNAL(sigEndConnect()), this, TQ_SLOT(slotLostClient()));
connect(server, TQ_SIGNAL(sigNewMessage(KMessage *)), this, TQ_SLOT(slotNewMessage(KMessage *)));
connect(server, TQ_SIGNAL(sigMessageSent(KMessage *)), this, TQ_SLOT(slotMessageSent(KMessage *)));
}
void KonnectionHandling::updateInternal(KBattleshipClient *client)
@ -59,10 +59,10 @@ void KonnectionHandling::updateInternal(KBattleshipClient *client)
m_kbclient = client;
m_kbserver = 0;
m_type = KonnectionHandling::CLIENT;
connect(client, TQT_SIGNAL(sigEndConnect()), this, TQT_SLOT(slotLostServer()));
connect(client, TQT_SIGNAL(sigSocketFailure(int)), this, TQT_SLOT(slotSocketError(int)));
connect(client, TQT_SIGNAL(sigNewMessage(KMessage *)), this, TQT_SLOT(slotNewMessage(KMessage *)));
connect(client, TQT_SIGNAL(sigMessageSent(KMessage *)), this, TQT_SLOT(slotMessageSent(KMessage *)));
connect(client, TQ_SIGNAL(sigEndConnect()), this, TQ_SLOT(slotLostServer()));
connect(client, TQ_SIGNAL(sigSocketFailure(int)), this, TQ_SLOT(slotSocketError(int)));
connect(client, TQ_SIGNAL(sigNewMessage(KMessage *)), this, TQ_SLOT(slotNewMessage(KMessage *)));
connect(client, TQ_SIGNAL(sigMessageSent(KMessage *)), this, TQ_SLOT(slotMessageSent(KMessage *)));
}
void KonnectionHandling::slotNewClient()

40
kblackbox/kbbgame.cpp
Unescape View File

@ -89,12 +89,12 @@ KBBGame::KBBGame()
initTDEAction();
connect( gr, TQT_SIGNAL(inputAt(int,int,int)),
this, TQT_SLOT(gotInputAt(int,int,int)) );
connect( this, TQT_SIGNAL(gameRuns(bool)),
gr, TQT_SLOT(setInputAccepted(bool)) );
connect( gr, TQT_SIGNAL(endMouseClicked()),
this, TQT_SLOT(gameFinished()) );
connect( gr, TQ_SIGNAL(inputAt(int,int,int)),
this, TQ_SLOT(gotInputAt(int,int,int)) );
connect( this, TQ_SIGNAL(gameRuns(bool)),
gr, TQ_SLOT(setInputAccepted(bool)) );
connect( gr, TQ_SIGNAL(endMouseClicked()),
this, TQ_SLOT(gameFinished()) );
/*
TQToolTip::add( doneButton, i18n(
@ -698,37 +698,37 @@ void KBBGame::gotInputAt( int col, int row, int state )
void KBBGame::initTDEAction()
{
// game
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());
KStdGameAction::gameNew(this, TQ_SLOT(newGame()), actionCollection());
(void)new TDEAction( i18n("&Give Up"), SmallIcon("giveup"), 0, this, TQ_SLOT(giveUp()), actionCollection(), "game_giveup" );
(void)new TDEAction( i18n("&Done"), SmallIcon("done"), 0, this, TQ_SLOT(gameFinished()), actionCollection(), "game_done" );
(void)new TDEAction( i18n("&Resize"), 0, this, TQ_SLOT(slotResize()), actionCollection(), "game_resize" );
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
// settings
sizeAction = new TDESelectAction( i18n("&Size"), 0, this, TQT_SLOT(slotSize()), actionCollection(), "options_size");
sizeAction = new TDESelectAction( i18n("&Size"), 0, this, TQ_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, this, TQT_SLOT(slotBalls()), actionCollection(), "options_balls");
ballsAction = new TDESelectAction( i18n("&Balls"), 0, this, TQ_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, this, TQT_SLOT(tutorialSwitch()), actionCollection(), "options_tutorial" );
// KStdAction::keyBindings(guiFactory(), TQT_SLOT(configureShortcuts()),
tutorialAction = new TDEToggleAction( i18n("&Tutorial"), 0, this, TQ_SLOT(tutorialSwitch()), actionCollection(), "options_tutorial" );
// KStdAction::keyBindings(guiFactory(), TQ_SLOT(configureShortcuts()),
//actionCollection());
// keyboard only
(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)new TDEAction( i18n("Move Down"), TQt::Key_Down, gr, TQ_SLOT(slotDown()), actionCollection(), "move_down" );
(void)new TDEAction( i18n("Move Up"), TQt::Key_Up, gr, TQ_SLOT(slotUp()), actionCollection(), "move_up" );
(void)new TDEAction( i18n("Move Left"), TQt::Key_Left, gr, TQ_SLOT(slotLeft()), actionCollection(), "move_left" );
(void)new TDEAction( i18n("Move Right"), TQt::Key_Right, gr, TQ_SLOT(slotRight()), actionCollection(), "move_right" );
(void)new TDEAction( i18n("Trigger Action"), TQt::Key_Return, gr, TQ_SLOT(slotInput()), actionCollection(), "move_trigger" );
}
void KBBGame::slotResize()

14
kbounce/game.cpp
Unescape View File

@ -378,13 +378,13 @@ JezzGame::JezzGame( const TQPixmap &background, int ballNum, TQWidget *parent, c
for ( int x=0; x<FIELD_WIDTH; x++ )
m_field->setTile( x, FIELD_HEIGHT-1, TILE_BORDER );
connect( m_field, TQT_SIGNAL(ballCollision(Ball *, int, int, int)), this, TQT_SLOT(ballCollision(Ball *, int, int, int)) );
connect( m_field, TQ_SIGNAL(ballCollision(Ball *, int, int, int)), this, TQ_SLOT(ballCollision(Ball *, int, int, int)) );
// create view
m_view = new JezzView( m_field, this, "m_view" );
m_view->move( 0, 0 );
m_view->adjustSize();
connect( m_view, TQT_SIGNAL(buildWall(int, int, bool)), this, TQT_SLOT(buildWall(int, int, bool)) );
connect( m_view, TQ_SIGNAL(buildWall(int, int, bool)), this, TQ_SLOT(buildWall(int, int, bool)) );
// create balls
for ( int n=0; n<ballNum; n++ )
@ -403,7 +403,7 @@ JezzGame::JezzGame( const TQPixmap &background, int ballNum, TQWidget *parent, c
// create game clock
m_clock = new TQTimer( this );
connect( m_clock, TQT_SIGNAL(timeout()), this, TQT_SLOT(tick()) );
connect( m_clock, TQ_SIGNAL(timeout()), this, TQ_SLOT(tick()) );
m_clock->start( GAME_DELAY );
// setup geometry
@ -618,8 +618,8 @@ void JezzGame::buildWall( int x, int y, bool vertical )
vertical? Wall::Up : Wall::Left,
vertical? TILE_WALLUP : TILE_WALLLEFT,
this, "m_wall1" );
connect( m_wall1, TQT_SIGNAL(finished(Wall *, int)),
this, TQT_SLOT(wallFinished(Wall *, int)) ); }
connect( m_wall1, TQ_SIGNAL(finished(Wall *, int)),
this, TQ_SLOT(wallFinished(Wall *, int)) ); }
if ( !m_wall2 )
{
@ -627,8 +627,8 @@ void JezzGame::buildWall( int x, int y, bool vertical )
vertical? Wall::Down: Wall::Right,
vertical? TILE_WALLDOWN : TILE_WALLRIGHT,
this, "m_wall2" );
connect( m_wall2, TQT_SIGNAL(finished(Wall *, int)),
this, TQT_SLOT(wallFinished(Wall *, int)) );
connect( m_wall2, TQ_SIGNAL(finished(Wall *, int)),
this, TQ_SLOT(wallFinished(Wall *, int)) );
}
}
}

28
kbounce/kbounce.cpp
Unescape View File

@ -89,13 +89,13 @@ KJezzball::KJezzball()
// create timers
m_nextLevelTimer = new TQTimer( this, "m_nextLevelTimer" );
connect( m_nextLevelTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(switchLevel()) );
connect( m_nextLevelTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(switchLevel()) );
m_gameOverTimer = new TQTimer( this, "m_gameOverTimer" );
connect( m_gameOverTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(gameOverNow()) );
connect( m_gameOverTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(gameOverNow()) );
m_timer = new TQTimer( this, "m_timer" );
connect( m_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(second()) );
connect( m_timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(second()) );
// create demo game
createLevel( 1 );
@ -119,23 +119,23 @@ KJezzball::~KJezzball()
*/
void KJezzball::initXMLUI()
{
m_newAction = KStdGameAction::gameNew( this, TQT_SLOT(newGame()), actionCollection() );
m_newAction = KStdGameAction::gameNew( this, TQ_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(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());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection() );
KStdGameAction::highscores(this, TQ_SLOT(showHighscore()), actionCollection() );
m_pauseButton = KStdGameAction::pause(this, TQ_SLOT(pauseGame()), actionCollection());
KStdGameAction::end(this, TQ_SLOT(closeGame()), actionCollection());
KStdGameAction::configureHighscores(this, TQ_SLOT(configureHighscores()),actionCollection());
new TDEAction( i18n("&Select Background Folder..."), 0, this, TQT_SLOT(selectBackground()),
new TDEAction( i18n("&Select Background Folder..."), 0, this, TQ_SLOT(selectBackground()),
actionCollection(), "background_select" );
m_backgroundShowAction =
new TDEToggleAction( i18n("Show &Backgrounds"), 0, this, TQT_SLOT(showBackground()),
new TDEToggleAction( i18n("Show &Backgrounds"), 0, this, TQ_SLOT(showBackground()),
actionCollection(), "background_show" );
m_backgroundShowAction->setCheckedState(i18n("Hide &Backgrounds"));
m_backgroundShowAction->setEnabled( !m_backgroundDir.isEmpty() );
@ -400,9 +400,9 @@ void KJezzball::createLevel( int level )
m_gameWidget->show();
m_layout->addWidget( m_gameWidget, 0, 0 );
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)) );
connect( m_gameWidget, TQ_SIGNAL(died()), this, TQ_SLOT(died()) );
connect( m_gameWidget, TQ_SIGNAL(newPercent(int)), this, TQ_SLOT(newPercent(int)) );
connect( m_soundAction, TQ_SIGNAL(toggled(bool)), m_gameWidget, TQ_SLOT(setSound(bool)) );
// update displays
m_level.lifes = level+1;

72
kenolaba/AbTop.cpp
Unescape View File

@ -63,12 +63,12 @@ AbTop::AbTop()
timer = new TQTimer;
connect( timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timerDone()) );
connect( timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(timerDone()) );
board = new Board();
setMoveNo(0);
connect( board, TQT_SIGNAL(searchBreak()), this, TQT_SLOT(searchBreak()) );
connect( board, TQ_SIGNAL(searchBreak()), this, TQ_SLOT(searchBreak()) );
TQ_CHECK_PTR(board);
boardWidget = new BoardWidget(*board,this);
@ -76,8 +76,8 @@ AbTop::AbTop()
spy = new Spy(*board);
#endif
connect( boardWidget, TQT_SIGNAL(updateSpy(TQString)),
this, TQT_SLOT(updateSpy(TQString)) );
connect( boardWidget, TQ_SIGNAL(updateSpy(TQString)),
this, TQ_SLOT(updateSpy(TQString)) );
setCentralWidget(boardWidget);
boardWidget->show();
@ -88,17 +88,17 @@ AbTop::AbTop()
setMinimumSize(200,300);
// RMB context menu
connect( boardWidget, TQT_SIGNAL(rightButtonPressed(int,const TQPoint&)),
this, TQT_SLOT(rightButtonPressed(int,const TQPoint&)) );
connect( boardWidget, TQ_SIGNAL(rightButtonPressed(int,const TQPoint&)),
this, TQ_SLOT(rightButtonPressed(int,const TQPoint&)) );
connect( boardWidget, TQT_SIGNAL(edited(int)),
this, TQT_SLOT(edited(int)) );
connect( boardWidget, TQ_SIGNAL(edited(int)),
this, TQ_SLOT(edited(int)) );
connect( board, TQT_SIGNAL(updateBestMove(Move&,int)),
this, TQT_SLOT(updateBestMove(Move&,int)) );
connect( board, TQ_SIGNAL(updateBestMove(Move&,int)),
this, TQ_SLOT(updateBestMove(Move&,int)) );
connect( boardWidget, TQT_SIGNAL(moveChoosen(Move&)),
this, TQT_SLOT(moveChoosen(Move&)) );
connect( boardWidget, TQ_SIGNAL(moveChoosen(Move&)),
this, TQ_SLOT(moveChoosen(Move&)) );
/* default */
setLevel(Easy);
@ -132,61 +132,61 @@ AbTop::~AbTop()
void AbTop::setupActions()
{
newAction = KStdGameAction::gameNew( this, TQT_SLOT(newGame()), actionCollection() );
KStdGameAction::quit( this, TQT_SLOT(close()), actionCollection() );
newAction = KStdGameAction::gameNew( this, TQ_SLOT(newGame()), actionCollection() );
KStdGameAction::quit( this, TQ_SLOT(close()), actionCollection() );
stopAction = new TDEAction( i18n("&Stop Search"), "process-stop", Key_S, this,
TQT_SLOT(stopSearch()), actionCollection(), "move_stop");
TQ_SLOT(stopSearch()), actionCollection(), "move_stop");
backAction = new TDEAction( i18n("Take &Back"), "back",
TDEStdAccel::shortcut(TDEStdAccel::Prior), this,
TQT_SLOT(back()), actionCollection(), "move_back");
TQ_SLOT(back()), actionCollection(), "move_back");
forwardAction = new TDEAction( i18n("&Forward"), "forward",
TDEStdAccel::shortcut(TDEStdAccel::Next), this,
TQT_SLOT(forward()), actionCollection(), "move_forward");
TQ_SLOT(forward()), actionCollection(), "move_forward");
hintAction = KStdGameAction::hint(this, TQT_SLOT(suggestion()), actionCollection());
hintAction = KStdGameAction::hint(this, TQ_SLOT(suggestion()), actionCollection());
KStdAction::copy( this, TQT_SLOT(copy()), actionCollection());
pasteAction = KStdAction::paste( this, TQT_SLOT(paste()), actionCollection());
KStdAction::copy( this, TQ_SLOT(copy()), actionCollection());
pasteAction = KStdAction::paste( this, TQ_SLOT(paste()), actionCollection());
(void) new TDEAction( i18n("&Restore Position"),
TDEStdAccel::shortcut(TDEStdAccel::Open),
this, TQT_SLOT(restorePosition()),
this, TQ_SLOT(restorePosition()),
actionCollection(), "edit_restore" );
(void) new TDEAction( i18n("&Save Position"),
TDEStdAccel::shortcut(TDEStdAccel::Save),
this, TQT_SLOT(savePosition()),
this, TQ_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)), this, TQT_SLOT(gameNetwork(bool)));
connect(ta, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(gameNetwork(bool)));
editAction = new TDEToggleAction( i18n("&Modify"), "edit",
CTRL+Key_Insert, actionCollection(), "edit_modify");
connect(editAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT( editModify(bool)));
connect(editAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT( editModify(bool)));
showMenubar = KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
KStdAction::saveOptions( this, TQT_SLOT(writeConfig()), actionCollection());
showMenubar = KStdAction::showMenubar(this, TQ_SLOT(toggleMenubar()), actionCollection());
KStdAction::saveOptions( this, TQ_SLOT(writeConfig()), actionCollection());
KStdAction::preferences( this, TQT_SLOT(configure()), actionCollection());
KStdAction::preferences( this, TQ_SLOT(configure()), actionCollection());
moveSlowAction = new TDEToggleAction( i18n("&Move Slow"), 0,
actionCollection(), "options_moveSlow");
connect(moveSlowAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(optionMoveSlow(bool)));
connect(moveSlowAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(optionMoveSlow(bool)));
renderBallsAction = new TDEToggleAction( i18n("&Render Balls"), 0,
actionCollection(), "options_renderBalls");
connect(renderBallsAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(optionRenderBalls(bool)));
connect(renderBallsAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(optionRenderBalls(bool)));
showSpyAction = new TDEToggleAction( i18n("&Spy"), 0,
actionCollection(), "options_showSpy");
connect(showSpyAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(optionShowSpy(bool)));
connect(showSpyAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(optionShowSpy(bool)));
levelAction = KStdGameAction::chooseGameType(0, 0, actionCollection());
@ -194,14 +194,14 @@ void AbTop::setupActions()
for (uint i=0; i<Nb_Levels; i++)
list.append( i18n(LEVEL[i].label) );
levelAction->setItems(list);
connect(levelAction, TQT_SIGNAL(activated(int)), TQT_SLOT(setLevel(int)));
connect(levelAction, TQ_SIGNAL(activated(int)), TQ_SLOT(setLevel(int)));
iplayAction = new TDESelectAction(i18n("&Computer Play"), 0, actionCollection(), "options_iplay");
list.clear();
for (uint i=0; i<Nb_IPlays; i++)
list.append( i18n(IPLAY[i].label) );
iplayAction->setItems(list);
connect(iplayAction, TQT_SIGNAL(activated(int)), TQT_SLOT(setIPlay(int)));
connect(iplayAction, TQ_SIGNAL(activated(int)), TQ_SLOT(setIPlay(int)));
}
void AbTop::toggleMenubar()
@ -421,8 +421,8 @@ void AbTop::setupStatusBar()
spyPopup->insertItem(spy1, 1);
spyPopup->insertItem(spy2, 2);
spyPopup->insertItem(spy3, 3);
connect( spyPopup, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(setSpy(int)) );
connect( spyPopup, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(setSpy(int)) );
tb->insertButton(spy0, 30, spyPopup,
TRUE, i18n("Spy"));
}
@ -800,8 +800,8 @@ void AbTop::gameNetwork(bool on)
h2[i]=0;
net->addListener(h2, p);
}
TQObject::connect(net, TQT_SIGNAL(gotPosition(const char *)),
this, TQT_SLOT(pastePosition(const char *)) );
TQObject::connect(net, TQ_SIGNAL(gotPosition(const char *)),
this, TQ_SLOT(pastePosition(const char *)) );
}

2
kenolaba/Ball.cpp
Unescape View File

@ -229,7 +229,7 @@ BallWidget::BallWidget( int _freq, int bFr, TQWidget *parent, const char *name )
ballFraction = bFr;
realSize = -1;
timer = new TQTimer(this);
connect( timer, TQT_SIGNAL(timeout()), TQT_SLOT(animate()) );
connect( timer, TQ_SIGNAL(timeout()), TQ_SLOT(animate()) );
}
BallWidget::~BallWidget()

4
kenolaba/BoardWidget.cpp
Unescape View File

@ -44,8 +44,8 @@ BoardWidget::BoardWidget(Board& b, TQWidget *parent, const char *name)
#ifdef HAVE_KIR
m_backRenderer = KIRManager::attach( this, "Background" );
connect( m_backRenderer, TQT_SIGNAL(rendered()),
this, TQT_SLOT(drawBoard()) );
connect( m_backRenderer, TQ_SIGNAL(rendered()),
this, TQ_SLOT(drawBoard()) );
#endif
/* setup cursors */

60
kenolaba/EvalDlgImpl.cpp
Unescape View File

@ -26,9 +26,9 @@ EvalDlgImpl::EvalDlgImpl(TQWidget* parent, Board* board)
_origScheme = board->evalScheme();
_scheme = new EvalScheme(*_origScheme);
connect( evalDelete, TQT_SIGNAL( clicked() ), this, TQT_SLOT( deleteEntry() ) );
connect( evalSaveAs, TQT_SIGNAL( clicked() ), this, TQT_SLOT( saveas() ) );
connect( evalList, TQT_SIGNAL( highlighted(int) ), this, TQT_SLOT( select(int) ) );
connect( evalDelete, TQ_SIGNAL( clicked() ), this, TQ_SLOT( deleteEntry() ) );
connect( evalSaveAs, TQ_SIGNAL( clicked() ), this, TQ_SLOT( saveas() ) );
connect( evalList, TQ_SIGNAL( highlighted(int) ), this, TQ_SLOT( select(int) ) );
TDEConfig* config = kapp->config();
config->setGroup("General");
@ -52,33 +52,33 @@ EvalDlgImpl::~EvalDlgImpl()
void EvalDlgImpl::connectEditLines()
{
connect( moveEval1, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( moveEval2, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( moveEval3, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( moveEval4, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( moveEval5, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( moveEval6, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( moveEval7, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( moveEval8, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( moveEval9, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateMove()) );
connect( posEval1, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( posEval2, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( posEval3, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( posEval4, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( posEval5, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( diffEval2, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( diffEval3, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( diffEval4, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( diffEval5, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateFields()) );
connect( rowEval2, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateInARow()) );
connect( rowEval3, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateInARow()) );
connect( rowEval4, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateInARow()) );
connect( rowEval5, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateInARow()) );
connect( countEval1, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateCount()) );
connect( countEval2, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateCount()) );
connect( countEval3, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateCount()) );
connect( countEval4, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateCount()) );
connect( countEval5, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(updateCount()) );
connect( moveEval1, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( moveEval2, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( moveEval3, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( moveEval4, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( moveEval5, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( moveEval6, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( moveEval7, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( moveEval8, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( moveEval9, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateMove()) );
connect( posEval1, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( posEval2, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( posEval3, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( posEval4, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( posEval5, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( diffEval2, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( diffEval3, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( diffEval4, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( diffEval5, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateFields()) );
connect( rowEval2, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateInARow()) );
connect( rowEval3, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateInARow()) );
connect( rowEval4, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateInARow()) );
connect( rowEval5, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateInARow()) );
connect( countEval1, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateCount()) );
connect( countEval2, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateCount()) );
connect( countEval3, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateCount()) );
connect( countEval4, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateCount()) );
connect( countEval5, TQ_SIGNAL(textChanged(const TQString&)), this, TQ_SLOT(updateCount()) );
}
void EvalDlgImpl::disconnectEditLines()

4
kenolaba/Network.cpp
Unescape View File

@ -62,8 +62,8 @@ Network::Network(int port)
}
sn = new TQSocketNotifier( fd, TQSocketNotifier::Read );
TQObject::connect( sn, TQT_SIGNAL(activated(int)),
this, TQT_SLOT(gotConnection()) );
TQObject::connect( sn, TQ_SIGNAL(activated(int)),
this, TQ_SLOT(gotConnection()) );
}
Network::~Network()

12
kenolaba/Spy.cpp
Unescape View File

@ -43,7 +43,7 @@ Spy::Spy(Board& b)
b2->addWidget( actBoard[i] );
b2->addWidget( actLabel[i] );
connect( actBoard[i], TQT_SIGNAL(mousePressed()), this, TQT_SLOT(nextStep()) );
connect( actBoard[i], TQ_SIGNAL(mousePressed()), this, TQ_SLOT(nextStep()) );
}
l = new TQLabel(this);
@ -68,13 +68,13 @@ Spy::Spy(Board& b)
b2->addWidget( bestBoard[i] );
b2->addWidget( bestLabel[i] );
connect( bestBoard[i], TQT_SIGNAL(mousePressed()), this, TQT_SLOT(nextStep()) );
connect( bestBoard[i], TQ_SIGNAL(mousePressed()), this, TQ_SLOT(nextStep()) );
}
connect( &board, TQT_SIGNAL(update(int,int,Move&,bool)),
this, TQT_SLOT(update(int,int,Move&,bool)) );
connect( &board, TQT_SIGNAL(updateBest(int,int,Move&,bool)),
this, TQT_SLOT(updateBest(int,int,Move&,bool)) );
connect( &board, TQ_SIGNAL(update(int,int,Move&,bool)),
this, TQ_SLOT(update(int,int,Move&,bool)) );
connect( &board, TQ_SIGNAL(updateBest(int,int,Move&,bool)),
this, TQ_SLOT(updateBest(int,int,Move&,bool)) );
top->activate();
setCaption(i18n("Spy"));
// KWM::setDecoration(winId(), 2);

184
kgoldrunner/src/kgoldrunner.cpp
Unescape View File

@ -88,10 +88,10 @@ KGoldrunner::KGoldrunner()
initStatusBar();
// Connect the game actions to the menu and toolbar displays.
connect(game, TQT_SIGNAL (setEditMenu (bool)), TQT_SLOT (setEditMenu (bool)));
connect(game, TQT_SIGNAL (markRuleType (char)), TQT_SLOT (markRuleType (char)));
connect(game, TQT_SIGNAL (hintAvailable(bool)), TQT_SLOT (adjustHintAction(bool)));
connect(game, TQT_SIGNAL (defaultEditObj()), TQT_SLOT (defaultEditObj()));
connect(game, TQ_SIGNAL (setEditMenu (bool)), TQ_SLOT (setEditMenu (bool)));
connect(game, TQ_SIGNAL (markRuleType (char)), TQ_SLOT (markRuleType (char)));
connect(game, TQ_SIGNAL (hintAvailable(bool)), TQ_SLOT (adjustHintAction(bool)));
connect(game, TQ_SIGNAL (defaultEditObj()), TQ_SLOT (defaultEditObj()));
// Apply the saved mainwindow settings, if any, and ask the mainwindow
// to automatically save settings if changed: window size, toolbar
@ -157,22 +157,22 @@ void KGoldrunner::setupActions()
TDEAction * newAction = KStdGameAction::
gameNew (
game,
TQT_SLOT(startLevelOne()), actionCollection());
TQ_SLOT(startLevelOne()), actionCollection());
newAction-> setText (i18n("&New Game..."));
TDEAction * loadGame = KStdGameAction::
load (
game, TQT_SLOT(loadGame()), actionCollection());
game, TQ_SLOT(loadGame()), actionCollection());
loadGame-> setText (i18n("&Load Saved Game..."));
(void) new TDEAction (
i18n("&Play Any Level..."),
0,
game, TQT_SLOT(startAnyLevel()), actionCollection(),
game, TQ_SLOT(startAnyLevel()), actionCollection(),
"play_any");
(void) new TDEAction (
i18n("Play &Next Level..."),
0,
game,
TQT_SLOT(startNextLevel()), actionCollection(),
TQ_SLOT(startNextLevel()), actionCollection(),
"play_next");
// Save Game...
@ -181,7 +181,7 @@ void KGoldrunner::setupActions()
saveGame = KStdGameAction::
save (
game, TQT_SLOT(saveGame()), actionCollection());
game, TQ_SLOT(saveGame()), actionCollection());
saveGame-> setText (i18n("&Save Game..."));
saveGame-> setShortcut (Key_S); // Alternate key.
@ -193,20 +193,20 @@ void KGoldrunner::setupActions()
myPause = KStdGameAction::
pause (
this, TQT_SLOT(stopStart()), actionCollection());
this, TQ_SLOT(stopStart()), actionCollection());
myPause-> setShortcut (Key_Escape); // Alternate key.
highScore = KStdGameAction::
highscores (
game, TQT_SLOT(showHighScores()), actionCollection());
game, TQ_SLOT(showHighScores()), actionCollection());
hintAction = new TDEAction (
i18n("&Get Hint"), "ktip",
0,
game, TQT_SLOT(showHint()), actionCollection(),
game, TQ_SLOT(showHint()), actionCollection(),
"get_hint");
killHero = new TDEAction (
i18n("&Kill Hero"),
Key_Q,
game, TQT_SLOT(herosDead()), actionCollection(),
game, TQ_SLOT(herosDead()), actionCollection(),
"kill_hero");
// Quit
@ -214,7 +214,7 @@ void KGoldrunner::setupActions()
(void) KStdGameAction::
quit (
this, TQT_SLOT(close()), actionCollection());
this, TQ_SLOT(close()), actionCollection());
/**************************************************************************/
/*************************** GAME EDITOR MENU **************************/
@ -228,17 +228,17 @@ void KGoldrunner::setupActions()
(void) new TDEAction (
i18n("&Create Level"),
0,
game, TQT_SLOT(createLevel()), actionCollection(),
game, TQ_SLOT(createLevel()), actionCollection(),
"create");
(void) new TDEAction (
i18n("&Edit Any Level..."),
0,
game, TQT_SLOT(updateLevel()), actionCollection(),
game, TQ_SLOT(updateLevel()), actionCollection(),
"edit_any");
(void) new TDEAction (
i18n("Edit &Next Level..."),
0,
game, TQT_SLOT(updateNext()), actionCollection(),
game, TQ_SLOT(updateNext()), actionCollection(),
"edit_next");
// Save Edits...
@ -249,20 +249,20 @@ void KGoldrunner::setupActions()
saveEdits = new TDEAction (
i18n("&Save Edits..."),
0,
game, TQT_SLOT(saveLevelFile()), actionCollection(),
game, TQ_SLOT(saveLevelFile()), actionCollection(),
"save_edits");
saveEdits->setEnabled (FALSE); // Nothing to save, yet.
(void) new TDEAction (
i18n("&Move Level..."),
0,
game, TQT_SLOT(moveLevelFile()), actionCollection(),
game, TQ_SLOT(moveLevelFile()), actionCollection(),
"move_level");
(void) new TDEAction (
i18n("&Delete Level..."),
0,
game,
TQT_SLOT(deleteLevelFile()), actionCollection(),
TQ_SLOT(deleteLevelFile()), actionCollection(),
"delete_level");
// Create a Game
@ -272,13 +272,13 @@ void KGoldrunner::setupActions()
(void) new TDEAction (
i18n("Create Game..."),
0,
this, TQT_SLOT(createGame()), actionCollection(),
this, TQ_SLOT(createGame()), actionCollection(),
"create_game");
(void) new TDEAction (
i18n("Edit Game Info..."),
0,
this,
TQT_SLOT(editGameInfo()), actionCollection(),
TQ_SLOT(editGameInfo()), actionCollection(),
"edit_game");
/**************************************************************************/
@ -290,27 +290,27 @@ void KGoldrunner::setupActions()
setKGoldrunner = new TDERadioAction (
"K&Goldrunner",
0, // Default Shift+G
this, TQT_SLOT(lsKGoldrunner()), actionCollection(),
this, TQ_SLOT(lsKGoldrunner()), actionCollection(),
"kgoldrunner");
setAppleII = new TDERadioAction (
"&Apple II",
0, // Default Shift+A
this, TQT_SLOT(lsApple2()), actionCollection(),
this, TQ_SLOT(lsApple2()), actionCollection(),
"apple_2");
setIceCave = new TDERadioAction (
i18n("&Ice Cave"),
0, // Default Shift+I
this, TQT_SLOT(lsIceCave()), actionCollection(),
this, TQ_SLOT(lsIceCave()), actionCollection(),
"ice_cave");
setMidnight = new TDERadioAction (
i18n("&Midnight"),
0, // Default Shift+M
this, TQT_SLOT(lsMidnight()), actionCollection(),
this, TQ_SLOT(lsMidnight()), actionCollection(),
"midnight");
setKDEKool = new TDERadioAction (
i18n("&TDE Kool"),
0, // Default Shift+K
this, TQT_SLOT(lsKDEKool()), actionCollection(),
this, TQ_SLOT(lsKDEKool()), actionCollection(),
"kde_kool");
setKGoldrunner-> setExclusiveGroup ("landscapes");
@ -332,13 +332,13 @@ void KGoldrunner::setupActions()
i18n("&Mouse Controls Hero"),
0,
this,
TQT_SLOT(setMouseMode()), actionCollection(),
TQ_SLOT(setMouseMode()), actionCollection(),
"mouse_mode");
setKeyboard = new TDERadioAction (
i18n("&Keyboard Controls Hero"),
0,
this,
TQT_SLOT(setKeyBoardMode()), actionCollection(),
TQ_SLOT(setKeyBoardMode()), actionCollection(),
"keyboard_mode");
setMouse-> setExclusiveGroup ("control");
@ -355,27 +355,27 @@ void KGoldrunner::setupActions()
TDERadioAction * nSpeed = new TDERadioAction (
i18n("Normal Speed"),
0,
this, TQT_SLOT(normalSpeed()), actionCollection(),
this, TQ_SLOT(normalSpeed()), actionCollection(),
"normal_speed");
TDERadioAction * bSpeed = new TDERadioAction (
i18n("Beginner Speed"),
0,
this, TQT_SLOT(beginSpeed()), actionCollection(),
this, TQ_SLOT(beginSpeed()), actionCollection(),
"beginner_speed");
TDERadioAction * cSpeed = new TDERadioAction (
i18n("Champion Speed"),
0,
this, TQT_SLOT(champSpeed()), actionCollection(),
this, TQ_SLOT(champSpeed()), actionCollection(),
"champion_speed");
(void) new TDEAction ( // Repeatable action.
i18n("Increase Speed"),
Key_Plus,
this, TQT_SLOT(incSpeed()), actionCollection(),
this, TQ_SLOT(incSpeed()), actionCollection(),
"increase_speed");
(void) new TDEAction ( // Repeatable action.
i18n("Decrease Speed"),
Key_Minus,
this, TQT_SLOT(decSpeed()), actionCollection(),
this, TQ_SLOT(decSpeed()), actionCollection(),
"decrease_speed");
nSpeed-> setExclusiveGroup ("speed");
@ -390,12 +390,12 @@ void KGoldrunner::setupActions()
tradRules = new TDERadioAction (
i18n("&Traditional Rules"),
0,
this, TQT_SLOT(setTradRules()), actionCollection(),
this, TQ_SLOT(setTradRules()), actionCollection(),
"trad_rules");
kgrRules = new TDERadioAction (
i18n("K&Goldrunner Rules"),
0,
this, TQT_SLOT(setKGrRules()), actionCollection(),
this, TQ_SLOT(setKGrRules()), actionCollection(),
"kgr_rules");
tradRules-> setExclusiveGroup ("rules");
@ -409,12 +409,12 @@ void KGoldrunner::setupActions()
(void) new TDEAction (
i18n("Larger Playing Area"),
0,
this, TQT_SLOT(makeLarger()), actionCollection(),
this, TQ_SLOT(makeLarger()), actionCollection(),
"larger_area");
(void) new TDEAction (
i18n("Smaller Playing Area"),
0,
this, TQT_SLOT(makeSmaller()), actionCollection(),
this, TQ_SLOT(makeSmaller()), actionCollection(),
"smaller_area");
// Configure Shortcuts...
@ -422,10 +422,10 @@ void KGoldrunner::setupActions()
// --------------------------
KStdAction::keyBindings (
this, TQT_SLOT(optionsConfigureKeys()),
this, TQ_SLOT(optionsConfigureKeys()),
actionCollection());
// KStdAction::configureToolbars (
// this, TQT_SLOT(optionsConfigureToolbars()),
// this, TQ_SLOT(optionsConfigureToolbars()),
// actionCollection());
/**************************************************************************/
@ -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,
this, TQT_SLOT(goUp()), actionCollection(), "move_up");
this, TQ_SLOT(goUp()), actionCollection(), "move_up");
(void) new TDEAction (i18n("Move Right"), Key_Right,
this, TQT_SLOT(goR()), actionCollection(), "move_right");
this, TQ_SLOT(goR()), actionCollection(), "move_right");
(void) new TDEAction (i18n("Move Down"), Key_Down,
this, TQT_SLOT(goDown()), actionCollection(), "move_down");
this, TQ_SLOT(goDown()), actionCollection(), "move_down");
(void) new TDEAction (i18n("Move Left"), Key_Left,
this, TQT_SLOT(goL()), actionCollection(), "move_left");
this, TQ_SLOT(goL()), actionCollection(), "move_left");
(void) new TDEAction (i18n("Stop"), Key_Space,
this, TQT_SLOT(stop()), actionCollection(), "stop");
this, TQ_SLOT(stop()), actionCollection(), "stop");
(void) new TDEAction (i18n("Dig Right"), Key_C,
this, TQT_SLOT(digR()), actionCollection(), "dig_right");
this, TQ_SLOT(digR()), actionCollection(), "dig_right");
(void) new TDEAction (i18n("Dig Left"), Key_Z,
this, TQT_SLOT(digL()), actionCollection(), "dig_left");
this, TQ_SLOT(digL()), actionCollection(), "dig_left");
// Alternate one-handed controls. Set up in "kgoldrunnerui.rc".
@ -463,31 +463,31 @@ void KGoldrunner::setupActions()
// Authors' debugging aids.
(void) new TDEAction (i18n("Step"), Key_Period,
game, TQT_SLOT(doStep()), actionCollection(), "do_step");
game, TQ_SLOT(doStep()), actionCollection(), "do_step");
(void) new TDEAction (i18n("Test Bug Fix"), Key_B,
game, TQT_SLOT(bugFix()), actionCollection(), "bug_fix");
game, TQ_SLOT(bugFix()), actionCollection(), "bug_fix");
(void) new TDEAction (i18n("Show Positions"), Key_D,
game, TQT_SLOT(showFigurePositions()), actionCollection(), "step");
game, TQ_SLOT(showFigurePositions()), actionCollection(), "step");
(void) new TDEAction (i18n("Start Logging"), Key_G,
game, TQT_SLOT(startLogging()), actionCollection(), "logging");
game, TQ_SLOT(startLogging()), actionCollection(), "logging");
(void) new TDEAction (i18n("Show Hero"), Key_H,
game, TQT_SLOT(showHeroState()), actionCollection(), "show_hero");
game, TQ_SLOT(showHeroState()), actionCollection(), "show_hero");
(void) new TDEAction (i18n("Show Object"), Key_Question,
game, TQT_SLOT(showObjectState()), actionCollection(), "show_obj");
game, TQ_SLOT(showObjectState()), actionCollection(), "show_obj");
(void) new TDEAction (i18n("Show Enemy") + "0", Key_0,
this, TQT_SLOT(showEnemy0()), actionCollection(), "show_enemy_0");
this, TQ_SLOT(showEnemy0()), actionCollection(), "show_enemy_0");
(void) new TDEAction (i18n("Show Enemy") + "1", Key_1,
this, TQT_SLOT(showEnemy1()), actionCollection(), "show_enemy_1");
this, TQ_SLOT(showEnemy1()), actionCollection(), "show_enemy_1");
(void) new TDEAction (i18n("Show Enemy") + "2", Key_2,
this, TQT_SLOT(showEnemy2()), actionCollection(), "show_enemy_2");
this, TQ_SLOT(showEnemy2()), actionCollection(), "show_enemy_2");
(void) new TDEAction (i18n("Show Enemy") + "3", Key_3,
this, TQT_SLOT(showEnemy3()), actionCollection(), "show_enemy_3");
this, TQ_SLOT(showEnemy3()), actionCollection(), "show_enemy_3");
(void) new TDEAction (i18n("Show Enemy") + "4", Key_4,
this, TQT_SLOT(showEnemy4()), actionCollection(), "show_enemy_4");
this, TQ_SLOT(showEnemy4()), actionCollection(), "show_enemy_4");
(void) new TDEAction (i18n("Show Enemy") + "5", Key_5,
this, TQT_SLOT(showEnemy5()), actionCollection(), "show_enemy_5");
this, TQ_SLOT(showEnemy5()), actionCollection(), "show_enemy_5");
(void) new TDEAction (i18n("Show Enemy") + "6", Key_6,
this, TQT_SLOT(showEnemy6()), actionCollection(), "show_enemy_6");
this, TQ_SLOT(showEnemy6()), actionCollection(), "show_enemy_6");
#endif
/**************************************************************************/
@ -529,10 +529,10 @@ void KGoldrunner::initStatusBar()
statusBar()->setItemFixed (ID_SCORE, -1);
statusBar()->setItemFixed (ID_LEVEL, -1);
connect(game, TQT_SIGNAL (showLives (long)), TQT_SLOT (showLives (long)));
connect(game, TQT_SIGNAL (showScore (long)), TQT_SLOT (showScore (long)));
connect(game, TQT_SIGNAL (showLevel (int)), TQT_SLOT (showLevel (int)));
connect(game, TQT_SIGNAL (gameFreeze (bool)), TQT_SLOT (gameFreeze (bool)));
connect(game, TQ_SIGNAL (showLives (long)), TQ_SLOT (showLives (long)));
connect(game, TQ_SIGNAL (showScore (long)), TQ_SLOT (showScore (long)));
connect(game, TQ_SIGNAL (showLevel (int)), TQ_SLOT (showLevel (int)));
connect(game, TQ_SIGNAL (gameFreeze (bool)), TQ_SLOT (gameFreeze (bool)));
}
void KGoldrunner::showLives (long newLives)
@ -999,51 +999,51 @@ void KGoldrunner::makeEditToolbar()
editToolbar->insertSeparator();
editToolbar->insertButton ("document-new", 0, TQT_SIGNAL(clicked()), game,
TQT_SLOT(createLevel()), TRUE, i18n("&Create a Level"));
editToolbar->insertButton ("document-open", 1, TQT_SIGNAL(clicked()), game,
TQT_SLOT(updateLevel()), TRUE, i18n("&Edit Any Level..."));
editToolbar->insertButton ("document-save", 2, TQT_SIGNAL(clicked()), game,
TQT_SLOT(saveLevelFile()),TRUE, i18n("&Save Edits..."));
editToolbar->insertButton ("document-new", 0, TQ_SIGNAL(clicked()), game,
TQ_SLOT(createLevel()), TRUE, i18n("&Create a Level"));
editToolbar->insertButton ("document-open", 1, TQ_SIGNAL(clicked()), game,
TQ_SLOT(updateLevel()), TRUE, i18n("&Edit Any Level..."));
editToolbar->insertButton ("document-save", 2, TQ_SIGNAL(clicked()), game,
TQ_SLOT(saveLevelFile()),TRUE, i18n("&Save Edits..."));
editToolbar->insertSeparator();
editToolbar->insertSeparator();
editToolbar->insertButton ("ktip", 3, TQT_SIGNAL(clicked()), game,
TQT_SLOT(editNameAndHint()),TRUE,i18n("Edit Name/Hint"));
editToolbar->insertButton ("ktip", 3, TQ_SIGNAL(clicked()), game,
TQ_SLOT(editNameAndHint()),TRUE,i18n("Edit Name/Hint"));
editToolbar->insertSeparator();
editToolbar->insertSeparator();
editToolbar->insertButton (freebg, (int)FREE, TQT_SIGNAL(clicked()), this,
TQT_SLOT(freeSlot()), TRUE, i18n("Empty space"));
editToolbar->insertButton (freebg, (int)FREE, TQ_SIGNAL(clicked()), this,
TQ_SLOT(freeSlot()), TRUE, i18n("Empty space"));
editToolbar->insertSeparator();
editToolbar->insertButton (edherobg, (int)HERO, TQT_SIGNAL(clicked()), this,
TQT_SLOT (edheroSlot()), TRUE, i18n("Hero"));
editToolbar->insertButton (edherobg, (int)HERO, TQ_SIGNAL(clicked()), this,
TQ_SLOT (edheroSlot()), TRUE, i18n("Hero"));
editToolbar->insertSeparator();
editToolbar->insertButton (edenemybg, (int)ENEMY, TQT_SIGNAL(clicked()), this,
TQT_SLOT (edenemySlot()), TRUE, i18n("Enemy"));
editToolbar->insertButton (edenemybg, (int)ENEMY, TQ_SIGNAL(clicked()), this,
TQ_SLOT (edenemySlot()), TRUE, i18n("Enemy"));
editToolbar->insertSeparator();
editToolbar->insertButton (brickbg, (int)BRICK, TQT_SIGNAL(clicked()), this,
TQT_SLOT (brickSlot()), TRUE, i18n("Brick (can dig)"));
editToolbar->insertButton (brickbg, (int)BRICK, TQ_SIGNAL(clicked()), this,
TQ_SLOT (brickSlot()), TRUE, i18n("Brick (can dig)"));
editToolbar->insertSeparator();
editToolbar->insertButton (betonbg, (int)BETON, TQT_SIGNAL(clicked()), this,
TQT_SLOT (betonSlot()), TRUE, i18n("Concrete (cannot dig)"));
editToolbar->insertButton (betonbg, (int)BETON, TQ_SIGNAL(clicked()), this,
TQ_SLOT (betonSlot()), TRUE, i18n("Concrete (cannot dig)"));
editToolbar->insertSeparator();
editToolbar->insertButton (fbrickbg, (int)FBRICK, TQT_SIGNAL(clicked()), this,
TQT_SLOT (fbrickSlot()), TRUE, i18n("Trap (can fall through)"));
editToolbar->insertButton (fbrickbg, (int)FBRICK, TQ_SIGNAL(clicked()), this,
TQ_SLOT (fbrickSlot()), TRUE, i18n("Trap (can fall through)"));
editToolbar->insertSeparator();
editToolbar->insertButton (ladderbg, (int)LADDER, TQT_SIGNAL(clicked()), this,
TQT_SLOT (ladderSlot()), TRUE, i18n("Ladder"));
editToolbar->insertButton (ladderbg, (int)LADDER, TQ_SIGNAL(clicked()), this,
TQ_SLOT (ladderSlot()), TRUE, i18n("Ladder"));
editToolbar->insertSeparator();
editToolbar->insertButton (hladderbg, (int)HLADDER, TQT_SIGNAL(clicked()), this,
TQT_SLOT (hladderSlot()), TRUE, i18n("Hidden ladder"));
editToolbar->insertButton (hladderbg, (int)HLADDER, TQ_SIGNAL(clicked()), this,
TQ_SLOT (hladderSlot()), TRUE, i18n("Hidden ladder"));
editToolbar->insertSeparator();
editToolbar->insertButton (polebg, (int)POLE, TQT_SIGNAL(clicked()), this,
TQT_SLOT (poleSlot()), TRUE, i18n("Pole (or bar)"));
editToolbar->insertButton (polebg, (int)POLE, TQ_SIGNAL(clicked()), this,
TQ_SLOT (poleSlot()), TRUE, i18n("Pole (or bar)"));
editToolbar->insertSeparator();
editToolbar->insertButton (nuggetbg, (int)NUGGET, TQT_SIGNAL(clicked()), this,
TQT_SLOT (nuggetSlot()), TRUE, i18n("Gold nugget"));
editToolbar->insertButton (nuggetbg, (int)NUGGET, TQ_SIGNAL(clicked()), this,
TQ_SLOT (nuggetSlot()), TRUE, i18n("Gold nugget"));
editToolbar->setToggle ((int) FREE, TRUE);
editToolbar->setToggle ((int) HERO, TRUE);

50
kgoldrunner/src/kgrdialog.cpp
Unescape View File

@ -213,36 +213,36 @@ KGrSLDialog::KGrSLDialog (int action, int requestedLevel, int collnIndex,
slPaintLevel();
thumbNail->show();
connect (colln, TQT_SIGNAL (highlighted (int)), this, TQT_SLOT (slColln (int)));
connect (collnA, TQT_SIGNAL (clicked ()), this, TQT_SLOT (slAboutColln ()));
connect (colln, TQ_SIGNAL (highlighted (int)), this, TQ_SLOT (slColln (int)));
connect (collnA, TQ_SIGNAL (clicked ()), this, TQ_SLOT (slAboutColln ()));
connect (display, TQT_SIGNAL (textChanged (const TQString &)),
this, TQT_SLOT (slUpdate (const TQString &)));
connect (display, TQ_SIGNAL (textChanged (const TQString &)),
this, TQ_SLOT (slUpdate (const TQString &)));
connect (number, TQT_SIGNAL (valueChanged(int)), this, TQT_SLOT(slShowLevel(int)));
connect (number, TQ_SIGNAL (valueChanged(int)), this, TQ_SLOT(slShowLevel(int)));
// Only enable name and hint dialog here if saving a new or edited level.
// At other times the name and hint have not been loaded or initialised yet.
if ((slAction == SL_CREATE) || (slAction == SL_SAVE)) {
connect (levelNH, TQT_SIGNAL (clicked()), game, TQT_SLOT (editNameAndHint()));
connect (levelNH, TQ_SIGNAL (clicked()), game, TQ_SLOT (editNameAndHint()));
}
else {
levelNH->setEnabled (FALSE);
levelNH->hide();
}
connect (colln, TQT_SIGNAL (highlighted (int)), this, TQT_SLOT (slPaintLevel ()));
connect (number, TQT_SIGNAL (sliderReleased()), this, TQT_SLOT (slPaintLevel()));
connect (number, TQT_SIGNAL (nextLine()), this, TQT_SLOT (slPaintLevel()));
connect (number, TQT_SIGNAL (prevLine()), this, TQT_SLOT (slPaintLevel()));
connect (number, TQT_SIGNAL (nextPage()), this, TQT_SLOT (slPaintLevel()));
connect (number, TQT_SIGNAL (prevPage()), this, TQT_SLOT (slPaintLevel()));
connect (colln, TQ_SIGNAL (highlighted (int)), this, TQ_SLOT (slPaintLevel ()));
connect (number, TQ_SIGNAL (sliderReleased()), this, TQ_SLOT (slPaintLevel()));
connect (number, TQ_SIGNAL (nextLine()), this, TQ_SLOT (slPaintLevel()));
connect (number, TQ_SIGNAL (prevLine()), this, TQ_SLOT (slPaintLevel()));
connect (number, TQ_SIGNAL (nextPage()), this, TQ_SLOT (slPaintLevel()));
connect (number, TQ_SIGNAL (prevPage()), this, TQ_SLOT (slPaintLevel()));
#ifdef KGR_PORTABLE
// Set the exits from this dialog box.
connect (OK, TQT_SIGNAL (clicked ()), this, TQT_SLOT (accept ()));
connect (CANCEL, TQT_SIGNAL (clicked ()), this, TQT_SLOT (reject ()));
connect (HELP, TQT_SIGNAL (clicked ()), this, TQT_SLOT (slotHelp ()));
connect (OK, TQ_SIGNAL (clicked ()), this, TQ_SLOT (accept ()));
connect (CANCEL, TQ_SIGNAL (clicked ()), this, TQ_SLOT (reject ()));
connect (HELP, TQ_SIGNAL (clicked ()), this, TQ_SLOT (slotHelp ()));
#endif
}
@ -557,8 +557,8 @@ KGrNHDialog::KGrNHDialog(const TQString & levelName, const TQString & levelHint,
// OK-> setAccel (Key_Return); // No! We need it in "mle" box.
CANCEL-> setAccel (Key_Escape);
connect (OK, TQT_SIGNAL (clicked ()), dad, TQT_SLOT (accept ()));
connect (CANCEL, TQT_SIGNAL (clicked ()), dad, TQT_SLOT (reject ()));
connect (OK, TQ_SIGNAL (clicked ()), dad, TQ_SLOT (accept ()));
connect (CANCEL, TQ_SIGNAL (clicked ()), dad, TQ_SLOT (reject ()));
#endif
}
@ -709,8 +709,8 @@ KGrECDialog::KGrECDialog (int action, int collnIndex,
mle-> setText ("");
}
connect (ecKGrB, TQT_SIGNAL (clicked ()), this, TQT_SLOT (ecSetKGr ()));
connect (ecTradB, TQT_SIGNAL (clicked ()), this, TQT_SLOT (ecSetTrad ()));
connect (ecKGrB, TQ_SIGNAL (clicked ()), this, TQ_SLOT (ecSetKGr ()));
connect (ecTradB, TQ_SIGNAL (clicked ()), this, TQ_SLOT (ecSetTrad ()));
#ifdef KGR_PORTABLE
OK-> setGeometry (10, 145 + mle->height(), 100, 25);
@ -721,8 +721,8 @@ KGrECDialog::KGrECDialog (int action, int collnIndex,
dad-> resize (300, 175 + mle->height());
connect (OK, TQT_SIGNAL (clicked ()), this, TQT_SLOT (accept()));
connect (CANCEL, TQT_SIGNAL (clicked ()), this, TQT_SLOT (reject()));
connect (OK, TQ_SIGNAL (clicked ()), this, TQ_SLOT (accept()));
connect (CANCEL, TQ_SIGNAL (clicked ()), this, TQ_SLOT (reject()));
#endif
}
@ -842,10 +842,10 @@ KGrLGDialog::KGrLGDialog (TQFile * savedGames,
lgList-> setSelected (0, TRUE);
lgHighlight = 0;
connect (lgList, TQT_SIGNAL (highlighted (int)), this, TQT_SLOT (lgSelect (int)));
connect (lgList, TQ_SIGNAL (highlighted (int)), this, TQ_SLOT (lgSelect (int)));
#ifdef KGR_PORTABLE
connect (OK, TQT_SIGNAL (clicked ()), this, TQT_SLOT (accept ()));
connect (CANCEL, TQT_SIGNAL (clicked ()), this, TQT_SLOT (reject ()));
connect (OK, TQ_SIGNAL (clicked ()), this, TQ_SLOT (accept ()));
connect (CANCEL, TQ_SIGNAL (clicked ()), this, TQ_SLOT (reject ()));
#endif
}
@ -963,7 +963,7 @@ void KGrMessage::wrapped (TQWidget * parent, TQString title, TQString contents)
#endif
OK-> setAccel (Key_Return);
connect (OK, TQT_SIGNAL (clicked ()), mm, TQT_SLOT (accept ()));
connect (OK, TQ_SIGNAL (clicked ()), mm, TQ_SLOT (accept ()));
mm-> exec ();

10
kgoldrunner/src/kgrfigure.cpp
Unescape View File

@ -310,8 +310,8 @@ KGrHero :: KGrHero (KGrCanvas * view, int x, int y)
walkFrozen = FALSE;
fallFrozen = FALSE;
connect (walkTimer, TQT_SIGNAL (timeout ()), TQT_SLOT (walkTimeDone ()));
connect (fallTimer, TQT_SIGNAL (timeout ()), TQT_SLOT (fallTimeDone ()));
connect (walkTimer, TQ_SIGNAL (timeout ()), TQ_SLOT (walkTimeDone ()));
connect (fallTimer, TQ_SIGNAL (timeout ()), TQ_SLOT (fallTimeDone ()));
}
int KGrHero::WALKDELAY = 0;
@ -817,9 +817,9 @@ KGrEnemy :: KGrEnemy (KGrCanvas * view, int x, int y)
captiveFrozen = FALSE;
captiveTimer = new TQTimer (this);
connect (captiveTimer,TQT_SIGNAL(timeout()),TQT_SLOT(captiveTimeDone()));
connect (walkTimer, TQT_SIGNAL (timeout ()), TQT_SLOT (walkTimeDone ()));
connect (fallTimer, TQT_SIGNAL (timeout ()), TQT_SLOT (fallTimeDone ()));
connect (captiveTimer,TQ_SIGNAL(timeout()),TQ_SLOT(captiveTimeDone()));
connect (walkTimer, TQ_SIGNAL (timeout ()), TQ_SLOT (walkTimeDone ()));
connect (fallTimer, TQ_SIGNAL (timeout ()), TQ_SLOT (fallTimeDone ()));
}
int KGrEnemy::WALKDELAY = 0;

38
kgoldrunner/src/kgrgame.cpp
Unescape View File

@ -63,17 +63,17 @@ KGrGame::KGrGame (KGrCanvas * theView, TQString theSystemDir, TQString theUserDi
modalFreeze = FALSE;
messageFreeze = FALSE;
connect (hero, TQT_SIGNAL (gotNugget(int)), TQT_SLOT (incScore(int)));
connect (hero, TQT_SIGNAL (caughtHero()), TQT_SLOT (herosDead()));
connect (hero, TQT_SIGNAL (haveAllNuggets()), TQT_SLOT (showHiddenLadders()));
connect (hero, TQT_SIGNAL (leaveLevel()), TQT_SLOT (goUpOneLevel()));
connect (hero, TQ_SIGNAL (gotNugget(int)), TQ_SLOT (incScore(int)));
connect (hero, TQ_SIGNAL (caughtHero()), TQ_SLOT (herosDead()));
connect (hero, TQ_SIGNAL (haveAllNuggets()), TQ_SLOT (showHiddenLadders()));
connect (hero, TQ_SIGNAL (leaveLevel()), TQ_SLOT (goUpOneLevel()));
dyingTimer = new TQTimer (this);
connect (dyingTimer, TQT_SIGNAL (timeout()), TQT_SLOT (finalBreath()));
connect (dyingTimer, TQ_SIGNAL (timeout()), TQ_SLOT (finalBreath()));
// Get the mouse position every 40 msec. It is used to steer the hero.
mouseSampler = new TQTimer (this);
connect (mouseSampler, TQT_SIGNAL(timeout()), TQT_SLOT (readMousePos ()));
connect (mouseSampler, TQ_SIGNAL(timeout()), TQ_SLOT (readMousePos ()));
mouseSampler->start (40, FALSE);
srand(1); // initialisiere Random-Generator
@ -456,8 +456,8 @@ int KGrGame::loadLevel (int levelNo)
levelHint = i18n((const char *) levelHintC.left(len-1));
// Disconnect edit-mode slots from signals from "view".
disconnect (view, TQT_SIGNAL (mouseClick(int)), 0, 0);
disconnect (view, TQT_SIGNAL (mouseLetGo(int)), 0, 0);
disconnect (view, TQ_SIGNAL (mouseClick(int)), 0, 0);
disconnect (view, TQ_SIGNAL (mouseLetGo(int)), 0, 0);
if (newLevel) {
hero->setEnemyList (&enemies);
@ -491,7 +491,7 @@ int KGrGame::loadLevel (int levelNo)
view->setMousePos (startI, startJ);
// Connect play-mode slot to signal from "view".
connect (view, TQT_SIGNAL(mouseClick(int)), TQT_SLOT(doDig(int)));
connect (view, TQ_SIGNAL(mouseClick(int)), TQ_SLOT(doDig(int)));
// Re-enable player input.
loading = FALSE;
@ -554,9 +554,9 @@ void KGrGame::changeObject (unsigned char kind, int i, int j)
enemy->setPlayfield(&playfield);
enemy->enemyId = enemyCount++;
enemies.append(enemy);
connect(enemy, TQT_SIGNAL(lostNugget()), TQT_SLOT(loseNugget()));
connect(enemy, TQT_SIGNAL(trapped(int)), TQT_SLOT(incScore(int)));
connect(enemy, TQT_SIGNAL(killed(int)), TQT_SLOT(incScore(int)));
connect(enemy, TQ_SIGNAL(lostNugget()), TQ_SLOT(loseNugget()));
connect(enemy, TQ_SIGNAL(trapped(int)), TQ_SLOT(incScore(int)));
connect(enemy, TQ_SIGNAL(killed(int)), TQ_SLOT(incScore(int)));
} else {
// Starting a level again after losing.
enemy=enemies.at(enemyCount);
@ -1020,8 +1020,8 @@ void KGrGame::checkHighScore()
OK-> setAccel (Key_Return);
hsnUser-> setFocus(); // Set the keyboard input on.
connect (hsnUser, TQT_SIGNAL (returnPressed ()), hsn, TQT_SLOT (accept ()));
connect (OK, TQT_SIGNAL (clicked ()), hsn, TQT_SLOT (accept ()));
connect (hsnUser, TQ_SIGNAL (returnPressed ()), hsn, TQ_SLOT (accept ()));
connect (OK, TQ_SIGNAL (clicked ()), hsn, TQ_SLOT (accept ()));
while (TRUE) {
hsn->exec();
@ -1223,7 +1223,7 @@ void KGrGame::showHighScores()
hs-> move (p.x() + 50, p.y() + 50);
// Start up the dialog box.
connect (OK, TQT_SIGNAL (clicked ()), hs, TQT_SLOT (accept ()));
connect (OK, TQ_SIGNAL (clicked ()), hs, TQ_SLOT (accept ()));
hs-> exec();
delete hs;
@ -2030,12 +2030,12 @@ void KGrGame::setEditableCell (int i, int j, char type)
void KGrGame::showEditLevel()
{
// Disconnect play-mode slots from signals from "view".
disconnect (view, TQT_SIGNAL(mouseClick(int)), 0, 0);
disconnect (view, TQT_SIGNAL(mouseLetGo(int)), 0, 0);
disconnect (view, TQ_SIGNAL(mouseClick(int)), 0, 0);
disconnect (view, TQ_SIGNAL(mouseLetGo(int)), 0, 0);
// Connect edit-mode slots to signals from "view".
connect (view, TQT_SIGNAL(mouseClick(int)), TQT_SLOT(doEdit(int)));
connect (view, TQT_SIGNAL(mouseLetGo(int)), TQT_SLOT(endEdit(int)));
connect (view, TQ_SIGNAL(mouseClick(int)), TQ_SLOT(doEdit(int)));
connect (view, TQ_SIGNAL(mouseLetGo(int)), TQ_SLOT(endEdit(int)));
}
bool KGrGame::reNumberLevels (int cIndex, int first, int last, int inc)

2
kgoldrunner/src/kgrobject.cpp
Unescape View File

@ -106,7 +106,7 @@ KGrBrick::KGrBrick (char objType, int i, int j, KGrCanvas * view)
holeFrozen = FALSE;
iamA = BRICK;
timer = new TQTimer (this);
connect (timer, TQT_SIGNAL (timeout ()), TQT_SLOT (timeDone ()));
connect (timer, TQ_SIGNAL (timeout ()), TQ_SLOT (timeDone ()));
}
void KGrBrick::dig (void)

16
kjumpingcube/kcubeboxwidget.cpp
Unescape View File

@ -435,12 +435,12 @@ void KCubeBoxWidget::init()
KCubeWidget::enableClicks(true);
loadSettings();
connect(moveTimer,TQT_SIGNAL(timeout()),TQT_SLOT(nextLoopStep()));
connect(this,TQT_SIGNAL(startedThinking()),TQT_SLOT(setWaitCursor()));
connect(this,TQT_SIGNAL(stoppedThinking()),TQT_SLOT(setNormalCursor()));
connect(this,TQT_SIGNAL(startedMoving()),TQT_SLOT(setWaitCursor()));
connect(this,TQT_SIGNAL(stoppedMoving()),TQT_SLOT(setNormalCursor()));
connect(this,TQT_SIGNAL(playerWon(int)),TQT_SLOT(stopActivities()));
connect(moveTimer,TQ_SIGNAL(timeout()),TQ_SLOT(nextLoopStep()));
connect(this,TQ_SIGNAL(startedThinking()),TQ_SLOT(setWaitCursor()));
connect(this,TQ_SIGNAL(stoppedThinking()),TQ_SLOT(setNormalCursor()));
connect(this,TQ_SIGNAL(startedMoving()),TQ_SLOT(setWaitCursor()));
connect(this,TQ_SIGNAL(stoppedMoving()),TQ_SLOT(setNormalCursor()));
connect(this,TQ_SIGNAL(playerWon(int)),TQ_SLOT(stopActivities()));
setNormalCursor();
@ -476,8 +476,8 @@ void KCubeBoxWidget::initCubes()
cubes[i][j]->setCoordinates(i,j);
layout->addWidget(cubes[i][j],i,j);
cubes[i][j]->show();
connect(cubes[i][j],TQT_SIGNAL(clicked(int,int,bool)),TQT_SLOT(stopHint()));
connect(cubes[i][j],TQT_SIGNAL(clicked(int,int,bool)),TQT_SLOT(checkClick(int,int,bool)));
connect(cubes[i][j],TQ_SIGNAL(clicked(int,int,bool)),TQ_SLOT(stopHint()));
connect(cubes[i][j],TQ_SIGNAL(clicked(int,int,bool)),TQ_SLOT(checkClick(int,int,bool)));
}
// initialize cubes

2
kjumpingcube/kcubewidget.cpp
Unescape View File

@ -88,7 +88,7 @@ KCubeWidget::KCubeWidget(TQWidget* parent,const char* name
// will be automatically destroyed by the parent
hintTimer = new TQTimer(this);
hintCounter=0;
connect(hintTimer,TQT_SIGNAL(timeout()),TQT_SLOT(hint()));
connect(hintTimer,TQ_SIGNAL(timeout()),TQ_SLOT(hint()));
setPalette(kapp->palette());

32
kjumpingcube/kjumpingcube.cpp
Unescape View File

@ -49,12 +49,12 @@
KJumpingCube::KJumpingCube()
: view(new KCubeBoxWidget(5, this, "KCubeBoxWidget"))
{
connect(view,TQT_SIGNAL(playerChanged(int)),TQT_SLOT(changePlayer(int)));
connect(view,TQT_SIGNAL(stoppedMoving()),TQT_SLOT(disableStop()));
connect(view,TQT_SIGNAL(stoppedThinking()),TQT_SLOT(disableStop()));
connect(view,TQT_SIGNAL(startedMoving()),TQT_SLOT(enableStop_Moving()));
connect(view,TQT_SIGNAL(startedThinking()),TQT_SLOT(enableStop_Thinking()));
connect(view,TQT_SIGNAL(playerWon(int)),TQT_SLOT(showWinner(int)));
connect(view,TQ_SIGNAL(playerChanged(int)),TQ_SLOT(changePlayer(int)));
connect(view,TQ_SIGNAL(stoppedMoving()),TQ_SLOT(disableStop()));
connect(view,TQ_SIGNAL(stoppedThinking()),TQ_SLOT(disableStop()));
connect(view,TQ_SIGNAL(startedMoving()),TQ_SLOT(enableStop_Moving()));
connect(view,TQ_SIGNAL(startedThinking()),TQ_SLOT(enableStop_Thinking()));
connect(view,TQ_SIGNAL(playerWon(int)),TQ_SLOT(showWinner(int)));
// tell the TDEMainWindow that this is indeed the main widget
setCentralWidget(view);
@ -76,19 +76,19 @@ KJumpingCube::KJumpingCube()
}
void KJumpingCube::initTDEAction() {
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());
KStdGameAction::gameNew(this, TQ_SLOT(newGame()), actionCollection());
KStdGameAction::load(this, TQ_SLOT(openGame()), actionCollection());
KStdGameAction::save(this, TQ_SLOT(save()), actionCollection());
KStdGameAction::saveAs(this, TQ_SLOT(saveAs()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
hintAction = KStdGameAction::hint(view, TQT_SLOT(getHint()), actionCollection());
hintAction = KStdGameAction::hint(view, TQ_SLOT(getHint()), actionCollection());
stopAction = new TDEAction(i18n("Stop &Thinking"), "process-stop",
TQt::Key_Escape, this, TQT_SLOT(stop()), actionCollection(), "game_stop");
TQt::Key_Escape, this, TQ_SLOT(stop()), actionCollection(), "game_stop");
stopAction->setEnabled(false);
undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
undoAction = KStdGameAction::undo(this, TQ_SLOT(undo()), actionCollection());
undoAction->setEnabled(false);
KStdAction::preferences(this, TQT_SLOT(showOptions()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(showOptions()), actionCollection());
setupGUI();
}
@ -270,7 +270,7 @@ void KJumpingCube::showOptions(){
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()), view, TQT_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), view, TQ_SLOT(loadSettings()));
dialog->show();
}

10
klickety/field.cpp
Unescape View File

@ -28,17 +28,17 @@ Field::Field(TQWidget *parent)
KGameLCDList *et = new KGameLCDList(i18n("Elapsed time"), this);
elapsedTime = new KGameLCDClock(et);
connect(board, TQT_SIGNAL(firstBlockClicked()), elapsedTime, TQT_SLOT(start()));
connect(board, TQ_SIGNAL(firstBlockClicked()), elapsedTime, TQ_SLOT(start()));
et->append(elapsedTime);
lcds->addWidget(et, 5, 0);
lcds->setRowStretch(6, 1);
connect(board, TQT_SIGNAL(scoreUpdated()), TQT_SLOT(scoreUpdatedSlot()));
connect(board, TQT_SIGNAL(gameOverSignal()), TQT_SLOT(gameOver()));
connect(board, TQ_SIGNAL(scoreUpdated()), TQ_SLOT(scoreUpdatedSlot()));
connect(board, TQ_SIGNAL(gameOverSignal()), TQ_SLOT(gameOver()));
settingsChanged();
connect(parent, TQT_SIGNAL(settingsChanged()), TQT_SLOT(settingsChanged()));
TQTimer::singleShot(0, this, TQT_SLOT(start()));
connect(parent, TQ_SIGNAL(settingsChanged()), TQ_SLOT(settingsChanged()));
TQTimer::singleShot(0, this, TQ_SLOT(start()));
}
void Field::pause()

36
klines/klines.cpp
Unescape View File

@ -64,10 +64,10 @@ KLines::KLines()
setCentralWidget( mwidget );
lsb = mwidget->GetLsb();
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()));
connect(lsb, TQ_SIGNAL(endTurn()), this, TQ_SLOT(makeTurn()));
connect(lsb, TQ_SIGNAL(eraseLine(int)), this, TQ_SLOT(addScore(int)));
connect(lsb, TQ_SIGNAL(endGame()), this, TQ_SLOT(endGame()));
connect(lsb, TQ_SIGNAL(userTurn()), this, TQ_SLOT(userTurn()));
lPrompt = mwidget->GetPrompt();
@ -82,7 +82,7 @@ KLines::KLines()
initTDEAction();
connect(&demoTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(slotDemo()));
connect(&demoTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(slotDemo()));
setFocusPolicy(TQWidget::StrongFocus);
setFocus();
@ -104,18 +104,18 @@ KLines::~KLines()
*/
void KLines::initTDEAction()
{
KStdGameAction::gameNew(this, TQT_SLOT(startGame()), actionCollection());
act_demo = KStdGameAction::demo(this, TQT_SLOT(startDemo()), actionCollection());
KStdGameAction::gameNew(this, TQ_SLOT(startGame()), actionCollection());
act_demo = KStdGameAction::demo(this, TQ_SLOT(startDemo()), actionCollection());
act_demo->setText(i18n("Start &Tutorial"));
KStdGameAction::highscores(this, TQT_SLOT(viewHighScore()), actionCollection());
KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
endTurnAction = KStdGameAction::endTurn(this, TQT_SLOT(makeTurn()), actionCollection());
KStdGameAction::highscores(this, TQ_SLOT(viewHighScore()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
endTurnAction = KStdGameAction::endTurn(this, TQ_SLOT(makeTurn()), actionCollection());
showNextAction = new TDEToggleAction(i18n("&Show Next"), TDEShortcut(CTRL+Key_P),
this, TQT_SLOT(switchPrompt()), actionCollection(), "options_show_next");
this, TQ_SLOT(switchPrompt()), actionCollection(), "options_show_next");
showNextAction->setCheckedState(i18n("Hide Next"));
showNumberedAction = new TDEToggleAction(i18n("&Use Numbered Balls"), TDEShortcut(),
this, TQT_SLOT(switchNumbered()), actionCollection(), "options_show_numbered");
undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
this, TQ_SLOT(switchNumbered()), actionCollection(), "options_show_numbered");
undoAction = KStdGameAction::undo(this, TQ_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, 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");
(void)new TDEAction(i18n("Move Left"), Key_Left, lsb, TQ_SLOT(moveLeft()), actionCollection(), "left");
(void)new TDEAction(i18n("Move Right"), Key_Right, lsb, TQ_SLOT(moveRight()), actionCollection(), "right");
(void)new TDEAction(i18n("Move Up"), Key_Up, lsb, TQ_SLOT(moveUp()), actionCollection(), "up");
(void)new TDEAction(i18n("Move Down"), Key_Down, lsb, TQ_SLOT(moveDown()), actionCollection(), "down");
(void)new TDEAction(i18n("Move Ball"), Key_Space, lsb, TQ_SLOT(placePlayerBall()), actionCollection(), "place_ball");
setupGUI( TDEMainWindow::Save | Keys | StatusBar | Create );
}

4
klines/linesboard.cpp
Unescape View File

@ -58,7 +58,7 @@ LinesBoard::LinesBoard( BallPainter * abPainter, TQWidget* parent, const char* n
setFixedSize(wHint(), hHint());
timer = new TQTimer(this);
connect( timer, TQT_SIGNAL(timeout()), TQT_SLOT(timerSlot()) );
connect( timer, TQ_SIGNAL(timeout()), TQ_SLOT(timerSlot()) );
timer->start( TIMERCLOCK, FALSE );
}
@ -740,7 +740,7 @@ void LinesBoard::demoClick(int x, int y)
TQPoint p = cur + i*(dest-cur) / 25;
TQCursor::setPos(p);
TQApplication::flushX();
TQTimer::singleShot(80, this, TQT_SLOT(demoClickStep()));
TQTimer::singleShot(80, this, TQ_SLOT(demoClickStep()));
kapp->enter_loop();
}
TQCursor::setPos(dest);

2
klines/mwidget.cpp
Unescape View File

@ -36,7 +36,7 @@ MainWidget::MainWidget( TQWidget* parent, const char* name )
TQBoxLayout *right = new TQVBoxLayout(grid, 2);
TQLabel *label = new TQLabel(i18n("Next balls:"), this);
lPrompt = new LinesPrompt(bPainter, this);
connect(lPrompt, TQT_SIGNAL(PromptPressed()), parent, TQT_SLOT(switchPrompt()));
connect(lPrompt, TQ_SIGNAL(PromptPressed()), parent, TQ_SLOT(switchPrompt()));
right->addWidget( label, 0, TQt::AlignBottom | TQt::AlignHCenter );
right->addWidget( lPrompt, 0, TQt::AlignTop | TQt::AlignHCenter );

10
kmahjongg/Editor.cpp
Unescape View File

@ -85,10 +85,10 @@ Editor::Editor
setCaption(kapp->makeStdCaption(i18n("Edit Board Layout")));
connect( drawFrame, TQT_SIGNAL(mousePressed(TQMouseEvent *) ),
TQT_SLOT(drawFrameMousePressEvent(TQMouseEvent *)));
connect( drawFrame, TQT_SIGNAL(mouseMoved(TQMouseEvent *) ),
TQT_SLOT(drawFrameMouseMovedEvent(TQMouseEvent *)));
connect( drawFrame, TQ_SIGNAL(mousePressed(TQMouseEvent *) ),
TQ_SLOT(drawFrameMousePressEvent(TQMouseEvent *)));
connect( drawFrame, TQ_SIGNAL(mouseMoved(TQMouseEvent *) ),
TQ_SLOT(drawFrameMouseMovedEvent(TQMouseEvent *)));
statusChanged();
@ -176,7 +176,7 @@ void Editor::setupToolbar()
topToolbar->alignItemRight( ID_TOOL_STATUS, true );
//addToolBar(topToolbar);
connect( topToolbar, TQT_SIGNAL(clicked(int) ), TQT_SLOT( topToolbarOption(int) ) );
connect( topToolbar, TQ_SIGNAL(clicked(int) ), TQ_SLOT( topToolbarOption(int) ) );
topToolbar->updateRects(0);
topToolbar->setFullSize(true);

10
kmahjongg/HighScore.cpp
Unescape View File

@ -149,7 +149,7 @@ HighScore::HighScore
combo->setMaximumSize( 32767, 32767 );
combo->setFocusPolicy( TQWidget::StrongFocus );
combo->setSizeLimit( 10 );
connect( combo, TQT_SIGNAL(activated(int)), TQT_SLOT(selectionChanged(int)) );
connect( combo, TQ_SIGNAL(activated(int)), TQ_SLOT(selectionChanged(int)) );
resize( 350+70,390+45 );
@ -163,12 +163,12 @@ HighScore::HighScore
selectedLine = -1;
connect(lineEdit, TQT_SIGNAL( textChanged(const TQString &)),
TQT_SLOT( nameChanged(const TQString &)));
connect(lineEdit, TQ_SIGNAL( textChanged(const TQString &)),
TQ_SLOT( nameChanged(const TQString &)));
connect(qtarch_PushButton_1, TQT_SIGNAL(clicked()), TQT_SLOT(reject()));
connect(resetBtn, TQT_SIGNAL(clicked()), TQT_SLOT(reset()));
connect(qtarch_PushButton_1, TQ_SIGNAL(clicked()), TQ_SLOT(reject()));
connect(resetBtn, TQ_SIGNAL(clicked()), TQ_SLOT(reset()));
}
// free up the table structures

4
kmahjongg/Preview.cpp
Unescape View File

@ -30,10 +30,10 @@ Preview::Preview(TQWidget* parent) : KDialogBase(parent), m_tiles(true)
group = new TQHGroupBox(page);
m_combo = new TQComboBox(false, group);
connect(m_combo, TQT_SIGNAL(activated(int)), TQT_SLOT(selectionChanged(int)));
connect(m_combo, TQ_SIGNAL(activated(int)), TQ_SLOT(selectionChanged(int)));
loadButton = new KPushButton(i18n("Load..."), group);
connect( loadButton, TQT_SIGNAL(clicked()), TQT_SLOT(load()) );
connect( loadButton, TQ_SIGNAL(clicked()), TQ_SLOT(load()) );
m_drawFrame = new FrameImage(page);
m_drawFrame->setFixedSize(310, 236);

8
kmahjongg/boardwidget.cpp
Unescape View File

@ -20,8 +20,8 @@ BoardWidget::BoardWidget( TQWidget* parent, const char *name )
setBackgroundColor( TQColor( 0,0,0 ) );
timer = new TQTimer(this);
connect( timer, TQT_SIGNAL(timeout()),
this, TQT_SLOT(helpMoveTimeout()) );
connect( timer, TQ_SIGNAL(timeout()),
this, TQ_SLOT(helpMoveTimeout()) );
TimerState = Stop;
gamePaused = false;
@ -633,7 +633,7 @@ void BoardWidget::demoMoveTimeout()
break;
}
// restart timer
TQTimer::singleShot( ANIMSPEED, this, TQT_SLOT( demoMoveTimeout() ) );
TQTimer::singleShot( ANIMSPEED, this, TQ_SLOT( demoMoveTimeout() ) );
}
}
@ -667,7 +667,7 @@ void BoardWidget::matchAnimationTimeout()
}
}
if( TimerState == Match )
TQTimer::singleShot( ANIMSPEED, this, TQT_SLOT( matchAnimationTimeout() ) );
TQTimer::singleShot( ANIMSPEED, this, TQ_SLOT( matchAnimationTimeout() ) );
}
// ---------------------------------------------------------
void BoardWidget::stopMatchAnimation()

86
kmahjongg/kmahjongg.cpp
Unescape View File

@ -80,37 +80,37 @@ KMahjongg::KMahjongg( TQWidget* parent, const char *name)
bDemoModeActive = false;
connect( bw, TQT_SIGNAL( statusTextChanged(const TQString&, long) ),
TQT_SLOT( showStatusText(const TQString&, long) ) );
connect( bw, TQ_SIGNAL( statusTextChanged(const TQString&, long) ),
TQ_SLOT( showStatusText(const TQString&, long) ) );
connect( bw, TQT_SIGNAL( tileNumberChanged(int,int,int) ),
TQT_SLOT( showTileNumber(int,int,int) ) );
connect( bw, TQ_SIGNAL( tileNumberChanged(int,int,int) ),
TQ_SLOT( showTileNumber(int,int,int) ) );
connect( bw, TQT_SIGNAL( demoModeChanged(bool) ),
TQT_SLOT( demoModeChanged(bool) ) );
connect( bw, TQ_SIGNAL( demoModeChanged(bool) ),
TQ_SLOT( demoModeChanged(bool) ) );
connect( bw, TQT_SIGNAL( gameOver(unsigned short , unsigned short)), this,
TQT_SLOT( gameOver(unsigned short , unsigned short)));
connect( bw, TQ_SIGNAL( gameOver(unsigned short , unsigned short)), this,
TQ_SLOT( gameOver(unsigned short , unsigned short)));
connect(bw, TQT_SIGNAL(gameCalculated()),
this, TQT_SLOT(timerReset()));
connect(bw, TQ_SIGNAL(gameCalculated()),
this, TQ_SLOT(timerReset()));
// Make connections for the preview load dialog
connect( previewLoad, TQT_SIGNAL( boardRedraw(bool) ),
bw, TQT_SLOT( drawBoard(bool) ) );
connect( previewLoad, TQ_SIGNAL( boardRedraw(bool) ),
bw, TQ_SLOT( drawBoard(bool) ) );
connect( previewLoad, TQT_SIGNAL( layoutChange() ),
this, TQT_SLOT( newGame() ) );
connect( previewLoad, TQ_SIGNAL( layoutChange() ),
this, TQ_SLOT( newGame() ) );
connect( previewLoad, TQT_SIGNAL( loadBackground(const TQString&, bool) ),
bw, TQT_SLOT(loadBackground(const TQString&, bool) ) );
connect( previewLoad, TQ_SIGNAL( loadBackground(const TQString&, bool) ),
bw, TQ_SLOT(loadBackground(const TQString&, bool) ) );
connect( previewLoad, TQT_SIGNAL( loadTileset(const TQString &) ),
bw, TQT_SLOT(loadTileset(const TQString&) ) );
connect( previewLoad, TQT_SIGNAL( loadBoard(const TQString&) ),
TQT_SLOT(loadBoardLayout(const TQString&) ) );
connect( previewLoad, TQ_SIGNAL( loadTileset(const TQString &) ),
bw, TQ_SLOT(loadTileset(const TQString&) ) );
connect( previewLoad, TQ_SIGNAL( loadBoard(const TQString&) ),
TQ_SLOT(loadBoardLayout(const TQString&) ) );
startNewGame( );
@ -128,41 +128,41 @@ KMahjongg::~KMahjongg()
void KMahjongg::setupTDEAction()
{
// game
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");
KStdGameAction::gameNew(this, TQ_SLOT(newGame()), actionCollection());
KStdGameAction::load(this, TQ_SLOT(loadGame()), actionCollection());
KStdGameAction::save(this, TQ_SLOT(saveGame()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
KStdGameAction::restart(this, TQ_SLOT(restartGame()), actionCollection());
new TDEAction(i18n("New Numbered Game..."), "newnum", 0, this, TQ_SLOT(startNewNumeric()), actionCollection(), "game_new_numeric");
new TDEAction(i18n("Open Th&eme..."), 0, this, TQ_SLOT(openTheme()), actionCollection(), "game_open_theme");
new TDEAction(i18n("Open &Tileset..."), 0, this, TQ_SLOT(openTileset()), actionCollection(), "game_open_tileset");
new TDEAction(i18n("Open &Background..."), 0, this, TQ_SLOT(openBackground()), actionCollection(), "game_open_background");
new TDEAction(i18n("Open La&yout..."), 0, this, TQ_SLOT(openLayout()), actionCollection(), "game_open_layout");
new TDEAction(i18n("Sa&ve Theme..."), 0, this, TQ_SLOT(saveTheme()), actionCollection(), "game_save_theme");
// originally "file" ends here
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");
KStdGameAction::hint(bw, TQ_SLOT(helpMove()), actionCollection());
new TDEAction(i18n("Shu&ffle"), "reload", 0, bw, TQ_SLOT(shuffle()), actionCollection(), "move_shuffle");
demoAction = KStdGameAction::demo(this, TQ_SLOT(demoMode()), actionCollection());
showMatchingTilesAction = new TDEToggleAction(i18n("Show &Matching Tiles"), 0, this, TQ_SLOT(showMatchingTiles()), actionCollection(), "options_show_matching_tiles");
showMatchingTilesAction->setCheckedState(i18n("Hide &Matching Tiles"));
showMatchingTilesAction->setChecked(Prefs::showMatchingTiles());
bw->setShowMatch( Prefs::showMatchingTiles() );
KStdGameAction::highscores(this, TQT_SLOT(showHighscores()), actionCollection());
pauseAction = KStdGameAction::pause(this, TQT_SLOT(pause()), actionCollection());
KStdGameAction::highscores(this, TQ_SLOT(showHighscores()), actionCollection());
pauseAction = KStdGameAction::pause(this, TQ_SLOT(pause()), actionCollection());
// TODO: store the background ; open on startup
// TODO: same about layout
// TODO: same about theme
// move
undoAction = KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
redoAction = KStdGameAction::redo(this, TQT_SLOT(redo()), actionCollection());
undoAction = KStdGameAction::undo(this, TQ_SLOT(undo()), actionCollection());
redoAction = KStdGameAction::redo(this, TQ_SLOT(redo()), actionCollection());
// edit
new TDEAction(i18n("&Board Editor"), 0, this, TQT_SLOT(slotBoardEditor()), actionCollection(), "edit_board_editor");
new TDEAction(i18n("&Board Editor"), 0, this, TQ_SLOT(slotBoardEditor()), actionCollection(), "edit_board_editor");
// settings
KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(showSettings()), actionCollection());
setupGUI();
}
@ -238,8 +238,8 @@ 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()), this, TQT_SLOT(setDisplayedWidth()));
connect(dialog, TQ_SIGNAL(settingsChanged()), bw, TQ_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), this, TQ_SLOT(setDisplayedWidth()));
dialog->show();
}

10
kmines/dialogs.cpp
Unescape View File

@ -127,19 +127,19 @@ CustomConfig::CustomConfig()
_width = new KIntNumInput(this, "kcfg_CustomWidth");
_width->setLabel(i18n("Width:"));
_width->setRange(minWidth, maxWidth);
connect(_width, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(updateNbMines()));
connect(_width, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(updateNbMines()));
top->addWidget(_width);
_height = new KIntNumInput(this, "kcfg_CustomHeight");
_height->setLabel(i18n("Height:"));
_height->setRange(minWidth, maxWidth);
connect(_height, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(updateNbMines()));
connect(_height, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(updateNbMines()));
top->addWidget(_height);
_mines = new KIntNumInput(this, "kcfg_CustomMines");
_mines->setLabel(i18n("No. of mines:"));
_mines->setRange(1, Level::maxNbMines(maxWidth, maxHeight));
connect(_mines, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(updateNbMines()));
connect(_mines, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(updateNbMines()));
top->addWidget(_mines);
top->addSpacing(2 * KDialog::spacingHint());
@ -149,7 +149,7 @@ CustomConfig::CustomConfig()
TQLabel *label = new TQLabel(i18n("Choose level:"), this);
hbox->addWidget(label);
_gameType = new KComboBox(false, this);
connect(_gameType, TQT_SIGNAL(activated(int)), TQT_SLOT(typeChosen(int)));
connect(_gameType, TQ_SIGNAL(activated(int)), TQ_SLOT(typeChosen(int)));
for (uint i=0; i<=Level::NB_TYPES; i++)
_gameType->insertItem(i18n(Level::LABELS[i]));
hbox->addWidget(_gameType);
@ -224,7 +224,7 @@ GameConfig::GameConfig()
cb = new TQCheckBox(i18n("\"Magic\" reveal"), this, "kcfg_MagicReveal");
TQWhatsThis::add(cb, i18n("Set flags and reveal squares where they are trivial."));
connect(cb, TQT_SIGNAL(toggled(bool)), TQT_SLOT(magicModified(bool)));
connect(cb, TQ_SIGNAL(toggled(bool)), TQ_SLOT(magicModified(bool)));
top->addWidget(cb);
top->addSpacing(2 * KDialog::spacingHint());

2
kmines/field.cpp
Unescape View File

@ -233,7 +233,7 @@ void Field::keyboardAutoReveal()
{
_cursor_back = _cursor;
pressClearFunction(_cursor_back, true);
TQTimer::singleShot(50, this, TQT_SLOT(keyboardAutoRevealSlot()));
TQTimer::singleShot(50, this, TQ_SLOT(keyboardAutoRevealSlot()));
}
void Field::keyboardAutoRevealSlot()

8
kmines/kzoommainwindow.cpp
Unescape View File

@ -30,11 +30,11 @@ KZoomMainWindow::KZoomMainWindow(uint min, uint max, uint step, const char *name
{
installEventFilter(this);
_zoomInAction = KStdAction::zoomIn(this, TQT_SLOT(zoomIn()), actionCollection());
_zoomInAction = KStdAction::zoomIn(this, TQ_SLOT(zoomIn()), actionCollection());
_zoomOutAction =
KStdAction::zoomOut(this, TQT_SLOT(zoomOut()), actionCollection());
KStdAction::zoomOut(this, TQ_SLOT(zoomOut()), actionCollection());
_menu =
KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
KStdAction::showMenubar(this, TQ_SLOT(toggleMenubar()), actionCollection());
}
void KZoomMainWindow::init(const char *popupName)
@ -63,7 +63,7 @@ void KZoomMainWindow::addWidget(TQWidget *widget)
static_cast<KZoomMainWindow *>(tlw->tqt_cast("KZoomMainWindow"));
Q_ASSERT(zm);
zm->_widgets.append(widget);
connect(widget, TQT_SIGNAL(destroyed()), zm, TQT_SLOT(widgetDestroyed()));
connect(widget, TQ_SIGNAL(destroyed()), zm, TQ_SLOT(widgetDestroyed()));
}
void KZoomMainWindow::widgetDestroyed()

62
kmines/main.cpp
Unescape View File

@ -43,17 +43,17 @@
#include "dialogs.h"
const MainWidget::KeyData MainWidget::KEY_DATA[NB_KEYS] = {
{I18N_NOOP("Move Up"), "keyboard_moveup", Key_Up, TQT_SLOT(moveUp())},
{I18N_NOOP("Move Down"), "keyboard_movedown", Key_Down, TQT_SLOT(moveDown())},
{I18N_NOOP("Move Right"), "keyboard_moveright", Key_Right, TQT_SLOT(moveRight())},
{I18N_NOOP("Move Left"), "keyboard_moveleft", Key_Left, TQT_SLOT(moveLeft())},
{I18N_NOOP("Move at Left Edge"), "keyboard_leftedge", Key_Home, TQT_SLOT(moveLeftEdge())},
{I18N_NOOP("Move at Right Edge"), "keyboard_rightedge", Key_End, TQT_SLOT(moveRightEdge())},
{I18N_NOOP("Move at Top Edge"), "keyboard_topedge", Key_PageUp, TQT_SLOT(moveTop())},
{I18N_NOOP("Move at Bottom Edge"), "keyboard_bottomedge", Key_PageDown, TQT_SLOT(moveBottom())},
{I18N_NOOP("Reveal Mine"), "keyboard_revealmine", Key_Space, TQT_SLOT(reveal())},
{I18N_NOOP("Mark Mine"), "keyboard_markmine", Key_W, TQT_SLOT(mark())},
{I18N_NOOP("Automatic Reveal"), "keyboard_autoreveal", Key_Return, TQT_SLOT(autoReveal())}
{I18N_NOOP("Move Up"), "keyboard_moveup", Key_Up, TQ_SLOT(moveUp())},
{I18N_NOOP("Move Down"), "keyboard_movedown", Key_Down, TQ_SLOT(moveDown())},
{I18N_NOOP("Move Right"), "keyboard_moveright", Key_Right, TQ_SLOT(moveRight())},
{I18N_NOOP("Move Left"), "keyboard_moveleft", Key_Left, TQ_SLOT(moveLeft())},
{I18N_NOOP("Move at Left Edge"), "keyboard_leftedge", Key_Home, TQ_SLOT(moveLeftEdge())},
{I18N_NOOP("Move at Right Edge"), "keyboard_rightedge", Key_End, TQ_SLOT(moveRightEdge())},
{I18N_NOOP("Move at Top Edge"), "keyboard_topedge", Key_PageUp, TQ_SLOT(moveTop())},
{I18N_NOOP("Move at Bottom Edge"), "keyboard_bottomedge", Key_PageDown, TQ_SLOT(moveBottom())},
{I18N_NOOP("Reveal Mine"), "keyboard_revealmine", Key_Space, TQ_SLOT(reveal())},
{I18N_NOOP("Mark Mine"), "keyboard_markmine", Key_W, TQ_SLOT(mark())},
{I18N_NOOP("Automatic Reveal"), "keyboard_autoreveal", Key_Return, TQ_SLOT(autoReveal())}
};
@ -63,17 +63,17 @@ MainWidget::MainWidget()
KNotifyClient::startDaemon();
_status = new Status(this);
connect(_status, TQT_SIGNAL(gameStateChangedSignal(KMines::GameState)),
TQT_SLOT(gameStateChanged(KMines::GameState)));
connect(_status, TQT_SIGNAL(pause()), TQT_SLOT(pause()));
connect(_status, TQ_SIGNAL(gameStateChangedSignal(KMines::GameState)),
TQ_SLOT(gameStateChanged(KMines::GameState)));
connect(_status, TQ_SIGNAL(pause()), TQ_SLOT(pause()));
// Game & Popup
KStdGameAction::gameNew(_status, TQT_SLOT(restartGame()), actionCollection());
_pause = KStdGameAction::pause(_status, TQT_SLOT(pauseGame()),
KStdGameAction::gameNew(_status, TQ_SLOT(restartGame()), actionCollection());
_pause = KStdGameAction::pause(_status, TQ_SLOT(pauseGame()),
actionCollection());
KStdGameAction::highscores(this, TQT_SLOT(showHighscores()),
KStdGameAction::highscores(this, TQ_SLOT(showHighscores()),
actionCollection());
KStdGameAction::quit(tqApp, TQT_SLOT(quit()), actionCollection());
KStdGameAction::quit(tqApp, TQ_SLOT(quit()), actionCollection());
// keyboard
_keybCollection = new TDEActionCollection(this);
@ -84,12 +84,12 @@ MainWidget::MainWidget()
}
// Settings
KStdAction::preferences(this, TQT_SLOT(configureSettings()),
KStdAction::preferences(this, TQ_SLOT(configureSettings()),
actionCollection());
KStdAction::keyBindings(this, TQT_SLOT(configureKeys()), actionCollection());
KStdAction::configureNotifications(this, TQT_SLOT(configureNotifications()),
KStdAction::keyBindings(this, TQ_SLOT(configureKeys()), actionCollection());
KStdAction::configureNotifications(this, TQ_SLOT(configureNotifications()),
actionCollection());
KStdGameAction::configureHighscores(this, TQT_SLOT(configureHighscores()),
KStdGameAction::configureHighscores(this, TQ_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)), _status, TQT_SLOT(newGame(int)));
connect(_levels, TQ_SIGNAL(activated(int)), _status, TQ_SLOT(newGame(int)));
// Adviser
_advise =
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()),
KStdGameAction::hint(_status, TQ_SLOT(advise()), actionCollection());
_solve = KStdGameAction::solve(_status, TQ_SLOT(solve()), actionCollection());
(void)new TDEAction(i18n("Solving Rate..."), 0, _status, TQ_SLOT(solveRate()),
actionCollection(), "solve_rate");
// Log
(void)new TDEAction(KGuiItem(i18n("View Log"), "viewmag"), 0,
_status, TQT_SLOT(viewLog()),
_status, TQ_SLOT(viewLog()),
actionCollection(), "log_view");
(void)new TDEAction(KGuiItem(i18n("Replay Log"), "media-playback-start"),
0, _status, TQT_SLOT(replayLog()),
0, _status, TQ_SLOT(replayLog()),
actionCollection(), "log_replay");
(void)new TDEAction(KGuiItem(i18n("Save Log..."), "document-save"), 0,
_status, TQT_SLOT(saveLog()),
_status, TQ_SLOT(saveLog()),
actionCollection(), "log_save");
(void)new TDEAction(KGuiItem(i18n("Load Log..."), "document-open"), 0,
_status, TQT_SLOT(loadLog()),
_status, TQ_SLOT(loadLog()),
actionCollection(), "log_load");
setupGUI( TDEMainWindow::Save | Create );
@ -163,7 +163,7 @@ void MainWidget::configureSettings()
dialog->addPage(new AppearanceConfig, i18n("Appearance"), "style");
CustomConfig *cc = new CustomConfig;
dialog->addPage(cc, i18n("Custom Game"), "package_settings");
connect(dialog, TQT_SIGNAL(settingsChanged()), TQT_SLOT(settingsChanged()));
connect(dialog, TQ_SIGNAL(settingsChanged()), TQ_SLOT(settingsChanged()));
dialog->show();
cc->init();
gc->init();

8
kmines/solver/solver.cpp
Unescape View File

@ -174,7 +174,7 @@ bool Solver::solveStep()
}
if (_inOneStep) return solveStep();
else TQTimer::singleShot(0, this, TQT_SLOT(solveStep()));
else TQTimer::singleShot(0, this, TQ_SLOT(solveStep()));
return false;
}
@ -191,7 +191,7 @@ SolvingRateDialog::SolvingRateDialog(const BaseField &field, TQWidget *parent)
Close, parent, "compute_solving_rate", true, true),
_refField(field)
{
connect(&_solver, TQT_SIGNAL(solvingDone(bool)), TQT_SLOT(solvingDone(bool)));
connect(&_solver, TQ_SIGNAL(solvingDone(bool)), TQ_SLOT(solvingDone(bool)));
KGuiItem item = KStdGuiItem::ok();
item.setText(i18n("Start"));
@ -225,7 +225,7 @@ void SolvingRateDialog::slotOk()
_i = 0;
_success = 0;
_progress->setValue(0);
TQTimer::singleShot(0, this, TQT_SLOT(step()));
TQTimer::singleShot(0, this, TQ_SLOT(step()));
}
void SolvingRateDialog::step()
@ -245,5 +245,5 @@ void SolvingRateDialog::solvingDone(bool success)
_label->setText(i18n("Success rate: %1%")
.arg(_success * 100.0 / _i, 0, 'f', 3));
_progress->advance(1);
TQTimer::singleShot(0, this, TQT_SLOT(step()));
TQTimer::singleShot(0, this, TQ_SLOT(step()));
}

22
kmines/status.cpp
Unescape View File

@ -49,10 +49,10 @@ Status::Status(TQWidget *parent)
: TQWidget(parent, "status"), _oldLevel(Level::Easy)
{
_timer = new TQTimer(this);
connect(_timer, TQT_SIGNAL(timeout()), TQT_SLOT(replayStep()));
connect(_timer, TQ_SIGNAL(timeout()), TQ_SLOT(replayStep()));
_solver = new Solver(this);
connect(_solver, TQT_SIGNAL(solvingDone(bool)), TQT_SLOT(solvingDone(bool)));
connect(_solver, TQ_SIGNAL(solvingDone(bool)), TQ_SLOT(solvingDone(bool)));
// top layout
TQGridLayout *top = new TQGridLayout(this, 2, 5, 10, 10);
@ -73,7 +73,7 @@ Status::Status(TQWidget *parent)
// smiley
smiley = new Smiley(this);
connect(smiley, TQT_SIGNAL(clicked()), TQT_SLOT(smileyClicked()));
connect(smiley, TQ_SIGNAL(clicked()), TQ_SLOT(smileyClicked()));
smiley->setFocusPolicy(TQWidget::NoFocus);
TQWhatsThis::add(smiley, i18n("Press to start a new game"));
top->addWidget(smiley, 0, 2);
@ -93,13 +93,13 @@ Status::Status(TQWidget *parent)
_field = new Field(_fieldContainer);
_field->readSettings();
g->addWidget(_field, 0, 0, AlignCenter);
connect( _field, TQT_SIGNAL(updateStatus(bool)), TQT_SLOT(updateStatus(bool)) );
connect(_field, TQT_SIGNAL(gameStateChanged(GameState)),
TQT_SLOT(gameStateChangedSlot(GameState)) );
connect(_field, TQT_SIGNAL(setMood(Mood)), smiley, TQT_SLOT(setMood(Mood)));
connect(_field, TQT_SIGNAL(setCheating()), dg, TQT_SLOT(setCheating()));
connect(_field,TQT_SIGNAL(addAction(const KGrid2D::Coord &, Field::ActionType)),
TQT_SLOT(addAction(const KGrid2D::Coord &, Field::ActionType)));
connect( _field, TQ_SIGNAL(updateStatus(bool)), TQ_SLOT(updateStatus(bool)) );
connect(_field, TQ_SIGNAL(gameStateChanged(GameState)),
TQ_SLOT(gameStateChangedSlot(GameState)) );
connect(_field, TQ_SIGNAL(setMood(Mood)), smiley, TQ_SLOT(setMood(Mood)));
connect(_field, TQ_SIGNAL(setCheating()), dg, TQ_SLOT(setCheating()));
connect(_field,TQ_SIGNAL(addAction(const KGrid2D::Coord &, Field::ActionType)),
TQ_SLOT(addAction(const KGrid2D::Coord &, Field::ActionType)));
TQWhatsThis::add(_field, i18n("Mines field."));
// resume button
@ -110,7 +110,7 @@ Status::Status(TQWidget *parent)
TQPushButton *pb
= new TQPushButton(i18n("Press to Resume"), _resumeContainer);
pb->setFont(f);
connect(pb, TQT_SIGNAL(clicked()), TQT_SIGNAL(pause()));
connect(pb, TQ_SIGNAL(clicked()), TQ_SIGNAL(pause()));
g->addWidget(pb, 0, 0, AlignCenter);
_stack = new TQWidgetStack(this);

20
knetwalk/src/mainwindow.cpp
Unescape View File

@ -64,11 +64,11 @@ MainWindow::MainWindow(TQWidget *parent, const char* name, WFlags /*fl*/) :
KNotifyClient::startDaemon();
KStdGameAction::gameNew(this, TQT_SLOT(slotNewGame()), actionCollection());
KStdGameAction::gameNew(this, TQ_SLOT(slotNewGame()), actionCollection());
KStdGameAction::highscores(this, TQT_SLOT(showHighscores()), actionCollection());
KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
KStdGameAction::configureHighscores(this, TQT_SLOT(configureHighscores()), actionCollection());
KStdGameAction::highscores(this, TQ_SLOT(showHighscores()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
KStdGameAction::configureHighscores(this, TQ_SLOT(configureHighscores()), actionCollection());
m_levels = KStdGameAction::chooseGameType(0, 0, actionCollection());
TQStringList lst;
@ -83,7 +83,7 @@ MainWindow::MainWindow(TQWidget *parent, const char* name, WFlags /*fl*/) :
statusBar()->insertItem("abcdefghijklmnopqrst: 0 ",1);
setAutoSaveSettings();
createGUI();
connect(m_levels, TQT_SIGNAL(activated(int)), this, TQT_SLOT(newGame(int)));
connect(m_levels, TQ_SIGNAL(activated(int)), this, TQ_SLOT(newGame(int)));
TQWhatsThis::add(this, i18n("<h3>Rules of the Game</h3>"
@ -108,9 +108,9 @@ MainWindow::MainWindow(TQWidget *parent, const char* name, WFlags /*fl*/) :
{
board[i] = new Cell(grid, i);
board[i]->setFixedSize(cellsize, cellsize);
connect(board[i], TQT_SIGNAL(lClicked(int)), TQT_SLOT(lClicked(int)));
connect(board[i], TQT_SIGNAL(rClicked(int)), TQT_SLOT(rClicked(int)));
connect(board[i], TQT_SIGNAL(mClicked(int)), TQT_SLOT(mClicked(int)));
connect(board[i], TQ_SIGNAL(lClicked(int)), TQ_SLOT(lClicked(int)));
connect(board[i], TQ_SIGNAL(rClicked(int)), TQ_SLOT(rClicked(int)));
connect(board[i], TQ_SIGNAL(mClicked(int)), TQ_SLOT(mClicked(int)));
}
srand(time(0));
@ -360,7 +360,7 @@ void MainWindow::rotate(int index, bool toleft)
for(int i = 0; i < 14; i++)
{
kapp->eventLoop()->processEvents(TQEventLoop::ExcludeUserInput);
TQTimer::singleShot(20, board[index], TQT_SLOT(update()));
TQTimer::singleShot(20, board[index], TQ_SLOT(update()));
kapp->eventLoop()->processEvents(TQEventLoop::ExcludeUserInput | TQEventLoop::WaitForMore);
board[index]->rotate(toleft ? -6 : 6);
}
@ -389,7 +389,7 @@ void MainWindow::blink(int index)
for(int i = 0; i < board[index]->width() * 2; i += 2)
{
kapp->eventLoop()->processEvents(TQEventLoop::ExcludeUserInput);
TQTimer::singleShot(20, board[index], TQT_SLOT(update()));
TQTimer::singleShot(20, board[index], TQ_SLOT(update()));
kapp->eventLoop()->processEvents(TQEventLoop::ExcludeUserInput |
TQEventLoop::WaitForMore);
board[index]->setLight(i);

4
kolf/editor.cpp
Unescape View File

@ -30,7 +30,7 @@ Editor::Editor(ObjectList *list, TQWidget *parent, const char *name)
listbox->insertStringList(items);
connect(listbox, TQT_SIGNAL(executed(TQListBoxItem *)), TQT_SLOT(listboxExecuted(TQListBoxItem *)));
connect(listbox, TQ_SIGNAL(executed(TQListBoxItem *)), TQ_SLOT(listboxExecuted(TQListBoxItem *)));
}
void Editor::listboxExecuted(TQListBoxItem * /*item*/)
@ -54,7 +54,7 @@ void Editor::setItem(CanvasItem *item)
config->setFrameStyle(TQFrame::Box | TQFrame::Raised);
config->setLineWidth(1);
config->show();
connect(config, TQT_SIGNAL(modified()), this, TQT_SIGNAL(changed()));
connect(config, TQ_SIGNAL(modified()), this, TQ_SIGNAL(changed()));
}
#include "editor.moc"

2
kolf/floater.cpp
Unescape View File

@ -265,7 +265,7 @@ FloaterConfig::FloaterConfig(Floater *floater, TQWidget *parent)
TQSlider *slider = new TQSlider(0, 20, 2, floater->curSpeed(), TQt::Horizontal, this);
hlayout->addWidget(slider);
hlayout->addWidget(new TQLabel(i18n("Fast"), this));
connect(slider, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(speedChanged(int)));
connect(slider, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(speedChanged(int)));
}
void FloaterConfig::speedChanged(int news)

60
kolf/game.cpp
Unescape View File

@ -202,19 +202,19 @@ BridgeConfig::BridgeConfig(Bridge *bridge, TQWidget *parent)
layout->addWidget(new TQLabel(i18n("Walls on:"), this), 0, 0);
top = new TQCheckBox(i18n("&Top"), this);
layout->addWidget(top, 0, 1);
connect(top, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(topWallChanged(bool)));
connect(top, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(topWallChanged(bool)));
top->setChecked(bridge->topWallVisible());
bot = new TQCheckBox(i18n("&Bottom"), this);
layout->addWidget(bot, 1, 1);
connect(bot, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(botWallChanged(bool)));
connect(bot, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(botWallChanged(bool)));
bot->setChecked(bridge->botWallVisible());
left = new TQCheckBox(i18n("&Left"), this);
layout->addWidget(left, 1, 0);
connect(left, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(leftWallChanged(bool)));
connect(left, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(leftWallChanged(bool)));
left->setChecked(bridge->leftWallVisible());
right = new TQCheckBox(i18n("&Right"), this);
layout->addWidget(right, 1, 2);
connect(right, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(rightWallChanged(bool)));
connect(right, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(rightWallChanged(bool)));
right->setChecked(bridge->rightWallVisible());
}
@ -409,7 +409,7 @@ WindmillConfig::WindmillConfig(Windmill *windmill, TQWidget *parent)
TQCheckBox *check = new TQCheckBox(i18n("Windmill on bottom"), this);
check->setChecked(windmill->bottom());
connect(check, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(endChanged(bool)));
connect(check, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(endChanged(bool)));
m_vlayout->addWidget(check);
TQHBoxLayout *hlayout = new TQHBoxLayout(m_vlayout, spacingHint());
@ -417,7 +417,7 @@ WindmillConfig::WindmillConfig(Windmill *windmill, TQWidget *parent)
TQSlider *slider = new TQSlider(1, 10, 1, windmill->curSpeed(), TQt::Horizontal, this);
hlayout->addWidget(slider);
hlayout->addWidget(new TQLabel(i18n("Fast"), this));
connect(slider, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(speedChanged(int)));
connect(slider, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(speedChanged(int)));
endChanged(check->isChecked());
}
@ -647,7 +647,7 @@ SignConfig::SignConfig(Sign *sign, TQWidget *parent)
m_vlayout->addWidget(new TQLabel(i18n("Sign HTML:"), this));
KLineEdit *name = new KLineEdit(sign->text(), this);
m_vlayout->addWidget(name);
connect(name, TQT_SIGNAL(textChanged(const TQString &)), this, TQT_SLOT(textChanged(const TQString &)));
connect(name, TQ_SIGNAL(textChanged(const TQString &)), this, TQ_SLOT(textChanged(const TQString &)));
}
void SignConfig::textChanged(const TQString &text)
@ -667,7 +667,7 @@ EllipseConfig::EllipseConfig(Ellipse *ellipse, TQWidget *parent)
TQCheckBox *check = new TQCheckBox(i18n("Enable show/hide"), this);
m_vlayout->addWidget(check);
connect(check, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(check1Changed(bool)));
connect(check, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(check1Changed(bool)));
check->setChecked(ellipse->changeEnabled());
TQHBoxLayout *hlayout = new TQHBoxLayout(m_vlayout, spacingHint());
@ -678,7 +678,7 @@ EllipseConfig::EllipseConfig(Ellipse *ellipse, TQWidget *parent)
fast1 = new TQLabel(i18n("Fast"), this);
hlayout->addWidget(fast1);
connect(slider1, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(value1Changed(int)));
connect(slider1, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(value1Changed(int)));
check1Changed(ellipse->changeEnabled());
@ -1310,8 +1310,8 @@ TQPtrList<TQCanvasItem> BlackHole::moveableItems() const
BlackHoleTimer::BlackHoleTimer(Ball *ball, double speed, int msec)
: m_speed(speed), m_ball(ball)
{
TQTimer::singleShot(msec, this, TQT_SLOT(mySlot()));
TQTimer::singleShot(msec / 2, this, TQT_SLOT(myMidSlot()));
TQTimer::singleShot(msec, this, TQ_SLOT(mySlot()));
TQTimer::singleShot(msec / 2, this, TQ_SLOT(myMidSlot()));
}
void BlackHoleTimer::mySlot()
@ -1344,8 +1344,8 @@ bool BlackHole::place(Ball *ball, bool /*wasCenter*/)
double magnitude = Vector(TQPoint(x(), y()), TQPoint(exitItem->x(), exitItem->y())).magnitude();
BlackHoleTimer *timer = new BlackHoleTimer(ball, speed, magnitude * 2.5 - speed * 35 + 500);
connect(timer, TQT_SIGNAL(eject(Ball *, double)), this, TQT_SLOT(eject(Ball *, double)));
connect(timer, TQT_SIGNAL(halfway()), this, TQT_SLOT(halfway()));
connect(timer, TQ_SIGNAL(eject(Ball *, double)), this, TQ_SLOT(eject(Ball *, double)));
connect(timer, TQ_SIGNAL(halfway()), this, TQ_SLOT(halfway()));
playSound("blackhole");
return false;
@ -1510,7 +1510,7 @@ BlackHoleConfig::BlackHoleConfig(BlackHole *blackHole, TQWidget *parent)
deg->setValue(blackHole->curExitDeg());
deg->setWrapping(true);
layout->addWidget(deg);
connect(deg, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(degChanged(int)));
connect(deg, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(degChanged(int)));
layout->addStretch();
@ -1519,7 +1519,7 @@ BlackHoleConfig::BlackHoleConfig(BlackHole *blackHole, TQWidget *parent)
KDoubleNumInput *min = new KDoubleNumInput(this);
min->setRange(0, 8, 1, true);
hlayout->addWidget(min);
connect(min, TQT_SIGNAL(valueChanged(double)), this, TQT_SLOT(minChanged(double)));
connect(min, TQ_SIGNAL(valueChanged(double)), this, TQ_SLOT(minChanged(double)));
min->setValue(blackHole->minSpeed());
hlayout = new TQHBoxLayout(layout, spacingHint());
@ -1527,7 +1527,7 @@ BlackHoleConfig::BlackHoleConfig(BlackHole *blackHole, TQWidget *parent)
KDoubleNumInput *max = new KDoubleNumInput(this);
max->setRange(1, 10, 1, true);
hlayout->addWidget(max);
connect(max, TQT_SIGNAL(valueChanged(double)), this, TQT_SLOT(maxChanged(double)));
connect(max, TQ_SIGNAL(valueChanged(double)), this, TQ_SLOT(maxChanged(double)));
max->setValue(blackHole->maxSpeed());
}
@ -1965,13 +1965,13 @@ HoleConfig::HoleConfig(HoleInfo *holeInfo, TQWidget *parent)
hlayout->addWidget(new TQLabel(i18n("Course name: "), this));
KLineEdit *nameEdit = new KLineEdit(holeInfo->untranslatedName(), this);
hlayout->addWidget(nameEdit);
connect(nameEdit, TQT_SIGNAL(textChanged(const TQString &)), this, TQT_SLOT(nameChanged(const TQString &)));
connect(nameEdit, TQ_SIGNAL(textChanged(const TQString &)), this, TQ_SLOT(nameChanged(const TQString &)));
hlayout = new TQHBoxLayout(layout, spacingHint());
hlayout->addWidget(new TQLabel(i18n("Course author: "), this));
KLineEdit *authorEdit = new KLineEdit(holeInfo->author(), this);
hlayout->addWidget(authorEdit);
connect(authorEdit, TQT_SIGNAL(textChanged(const TQString &)), this, TQT_SLOT(authorChanged(const TQString &)));
connect(authorEdit, TQ_SIGNAL(textChanged(const TQString &)), this, TQ_SLOT(authorChanged(const TQString &)));
layout->addStretch();
@ -1980,7 +1980,7 @@ HoleConfig::HoleConfig(HoleInfo *holeInfo, TQWidget *parent)
TQSpinBox *par = new TQSpinBox(1, 15, 1, this);
par->setValue(holeInfo->par());
hlayout->addWidget(par);
connect(par, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(parChanged(int)));
connect(par, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(parChanged(int)));
hlayout->addStretch();
hlayout->addWidget(new TQLabel(i18n("Maximum:"), this));
@ -1990,12 +1990,12 @@ HoleConfig::HoleConfig(HoleInfo *holeInfo, TQWidget *parent)
maxstrokes->setSpecialValueText(i18n("Unlimited"));
maxstrokes->setValue(holeInfo->maxStrokes());
hlayout->addWidget(maxstrokes);
connect(maxstrokes, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(maxStrokesChanged(int)));
connect(maxstrokes, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(maxStrokesChanged(int)));
TQCheckBox *check = new TQCheckBox(i18n("Show border walls"), this);
check->setChecked(holeInfo->borderWalls());
layout->addWidget(check);
connect(check, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(borderWallsChanged(bool)));
connect(check, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(borderWallsChanged(bool)));
}
void HoleConfig::authorChanged(const TQString &newauthor)
@ -2284,15 +2284,15 @@ KolfGame::KolfGame(ObjectList *obj, PlayerList *players, TQString filename, TQWi
addBorderWall(TQPoint(width - margin - 1, margin), TQPoint(width - margin - 1, height - margin));
timer = new TQTimer(this);
connect(timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timeout()));
connect(timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(timeout()));
timerMsec = 300;
fastTimer = new TQTimer(this);
connect(fastTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(fastTimeout()));
connect(fastTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(fastTimeout()));
fastTimerMsec = 11;
autoSaveTimer = new TQTimer(this);
connect(autoSaveTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(autoSaveTimeout()));
connect(autoSaveTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(autoSaveTimeout()));
autoSaveMsec = 5 * 1000 * 60; // 5 min autosave
// setUseAdvancedPutting() sets maxStrength!
@ -2300,7 +2300,7 @@ KolfGame::KolfGame(ObjectList *obj, PlayerList *players, TQString filename, TQWi
putting = false;
putterTimer = new TQTimer(this);
connect(putterTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(putterTimeout()));
connect(putterTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(putterTimeout()));
putterTimerMsec = 20;
}
@ -2808,7 +2808,7 @@ void KolfGame::timeout()
if (curState == Stopped && inPlay)
{
inPlay = false;
TQTimer::singleShot(0, this, TQT_SLOT(shotDone()));
TQTimer::singleShot(0, this, TQ_SLOT(shotDone()));
}
if (curState == Holed && inPlay)
@ -2842,12 +2842,12 @@ void KolfGame::timeout()
(*curPlayer).addStrokeToHole(curHole);
emit scoreChanged((*curPlayer).id(), curHole, (*curPlayer).score(curHole));
}
TQTimer::singleShot(600, this, TQT_SLOT(holeDone()));
TQTimer::singleShot(600, this, TQ_SLOT(holeDone()));
}
else
{
inPlay = false;
TQTimer::singleShot(0, this, TQT_SLOT(shotDone()));
TQTimer::singleShot(0, this, TQ_SLOT(shotDone()));
}
}
}
@ -3216,11 +3216,11 @@ void KolfGame::shotDone()
if (allPlayersDone())
{
startNextHole();
TQTimer::singleShot(100, this, TQT_SLOT(emitMax()));
TQTimer::singleShot(100, this, TQ_SLOT(emitMax()));
return;
}
TQTimer::singleShot(100, this, TQT_SLOT(emitMax()));
TQTimer::singleShot(100, this, TQ_SLOT(emitMax()));
}
}

156
kolf/kolf.cpp
Unescape View File

@ -79,75 +79,75 @@ Kolf::~Kolf()
void Kolf::initGUI()
{
newAction = KStdGameAction::gameNew(this, TQT_SLOT(newGame()), actionCollection());
newAction = KStdGameAction::gameNew(this, TQ_SLOT(newGame()), actionCollection());
newAction->setText(newAction->text() + TQString("..."));
endAction = KStdGameAction::end(this, TQT_SLOT(closeGame()), actionCollection());
printAction = KStdGameAction::print(this, TQT_SLOT(print()), actionCollection());
endAction = KStdGameAction::end(this, TQ_SLOT(closeGame()), actionCollection());
printAction = KStdGameAction::print(this, TQ_SLOT(print()), actionCollection());
(void) KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
saveAction = KStdAction::save(this, TQT_SLOT(save()), actionCollection(), "game_save");
(void) KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
saveAction = KStdAction::save(this, TQ_SLOT(save()), actionCollection(), "game_save");
saveAction->setText(i18n("Save &Course"));
saveAsAction = KStdAction::saveAs(this, TQT_SLOT(saveAs()), actionCollection(), "game_save_as");
saveAsAction = KStdAction::saveAs(this, TQ_SLOT(saveAs()), actionCollection(), "game_save_as");
saveAsAction->setText(i18n("Save &Course As..."));
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");
saveGameAction = new TDEAction(i18n("&Save Game"), 0, this, TQ_SLOT(saveGame()), actionCollection(), "savegame");
saveGameAsAction = new TDEAction(i18n("&Save Game As..."), 0, this, TQ_SLOT(saveGameAs()), actionCollection(), "savegameas");
loadGameAction = KStdGameAction::load(this, TQT_SLOT(loadGame()), actionCollection());
loadGameAction = KStdGameAction::load(this, TQ_SLOT(loadGame()), actionCollection());
loadGameAction->setText(i18n("Load Saved Game..."));
highScoreAction = KStdGameAction::highscores(this, TQT_SLOT(showHighScores()), actionCollection());
highScoreAction = KStdGameAction::highscores(this, TQ_SLOT(showHighScores()), actionCollection());
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");
editingAction = new TDEToggleAction(i18n("&Edit"), "pencil", CTRL+Key_E, this, TQ_SLOT(emptySlot()), actionCollection(), "editing");
newHoleAction = new TDEAction(i18n("&New"), "document-new", CTRL+SHIFT+Key_N, this, TQ_SLOT(emptySlot()), actionCollection(), "newhole");
clearHoleAction = new TDEAction(KStdGuiItem::clear().text(), "locationbar_erase", CTRL+Key_Delete, this, TQ_SLOT(emptySlot()), actionCollection(), "clearhole");
resetHoleAction = new TDEAction(i18n("&Reset"), CTRL+Key_R, this, TQ_SLOT(emptySlot()), actionCollection(), "resethole");
undoShotAction = KStdAction::undo(this, TQ_SLOT(emptySlot()), actionCollection(), "undoshot");
undoShotAction->setText(i18n("&Undo Shot"));
//replayShotAction = new TDEAction(i18n("&Replay Shot"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "replay");
//replayShotAction = new TDEAction(i18n("&Replay Shot"), 0, this, TQ_SLOT(emptySlot()), actionCollection(), "replay");
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");
holeAction = new TDEListAction(i18n("Switch to Hole"), 0, this, TQ_SLOT(emptySlot()), actionCollection(), "switchhole");
nextAction = new TDEAction(i18n("&Next Hole"), "forward", TDEStdAccel::shortcut(TDEStdAccel::Forward), this, TQ_SLOT(emptySlot()), actionCollection(), "nexthole");
prevAction = new TDEAction(i18n("&Previous Hole"), "back", TDEStdAccel::shortcut(TDEStdAccel::Back), this, TQ_SLOT(emptySlot()), actionCollection(), "prevhole");
firstAction = new TDEAction(i18n("&First Hole"), "go-home", TDEStdAccel::shortcut(TDEStdAccel::Home), this, TQ_SLOT(emptySlot()), actionCollection(), "firsthole");
lastAction = new TDEAction(i18n("&Last Hole"), CTRL+SHIFT+Key_End, this, TQ_SLOT(emptySlot()), actionCollection(), "lasthole");
randAction = new TDEAction(i18n("&Random Hole"), "goto", 0, this, TQ_SLOT(emptySlot()), actionCollection(), "randhole");
useMouseAction = new TDEToggleAction(i18n("Enable &Mouse for Moving Putter"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "usemouse");
useMouseAction = new TDEToggleAction(i18n("Enable &Mouse for Moving Putter"), 0, this, TQ_SLOT(emptySlot()), actionCollection(), "usemouse");
useMouseAction->setCheckedState(i18n("Disable &Mouse for Moving Putter"));
connect(useMouseAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(useMouseChanged(bool)));
connect(useMouseAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(useMouseChanged(bool)));
TDEConfig *config = kapp->config();
config->setGroup("Settings");
useMouseAction->setChecked(config->readBoolEntry("useMouse", true));
useAdvancedPuttingAction = new TDEToggleAction(i18n("Enable &Advanced Putting"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "useadvancedputting");
useAdvancedPuttingAction = new TDEToggleAction(i18n("Enable &Advanced Putting"), 0, this, TQ_SLOT(emptySlot()), actionCollection(), "useadvancedputting");
useAdvancedPuttingAction->setCheckedState(i18n("Disable &Advanced Putting"));
connect(useAdvancedPuttingAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(useAdvancedPuttingChanged(bool)));
connect(useAdvancedPuttingAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(useAdvancedPuttingChanged(bool)));
useAdvancedPuttingAction->setChecked(config->readBoolEntry("useAdvancedPutting", false));
showInfoAction = new TDEToggleAction(i18n("Show &Info"), "application-vnd.tde.info", CTRL+Key_I, this, TQT_SLOT(emptySlot()), actionCollection(), "showinfo");
showInfoAction = new TDEToggleAction(i18n("Show &Info"), "application-vnd.tde.info", CTRL+Key_I, this, TQ_SLOT(emptySlot()), actionCollection(), "showinfo");
showInfoAction->setCheckedState(i18n("Hide &Info"));
connect(showInfoAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(showInfoChanged(bool)));
connect(showInfoAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(showInfoChanged(bool)));
showInfoAction->setChecked(config->readBoolEntry("showInfo", false));
showGuideLineAction = new TDEToggleAction(i18n("Show Putter &Guideline"), 0, this, TQT_SLOT(emptySlot()), actionCollection(), "showguideline");
showGuideLineAction = new TDEToggleAction(i18n("Show Putter &Guideline"), 0, this, TQ_SLOT(emptySlot()), actionCollection(), "showguideline");
showGuideLineAction->setCheckedState(i18n("Hide Putter &Guideline"));
connect(showGuideLineAction, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(showGuideLineChanged(bool)));
connect(showGuideLineAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(showGuideLineChanged(bool)));
showGuideLineAction->setChecked(config->readBoolEntry("showGuideLine", true));
TDEToggleAction *act=new TDEToggleAction(i18n("Enable All Dialog Boxes"), 0, this, TQT_SLOT(enableAllMessages()), actionCollection(), "enableAll");
TDEToggleAction *act=new TDEToggleAction(i18n("Enable All Dialog Boxes"), 0, this, TQ_SLOT(enableAllMessages()), actionCollection(), "enableAll");
act->setCheckedState(i18n("Disable All Dialog Boxes"));
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 = new TDEToggleAction(i18n("Play &Sounds"), 0, this, TQ_SLOT(emptySlot()), actionCollection(), "audio-x-generic");
connect(soundAction, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(soundChanged(bool)));
soundAction->setChecked(config->readBoolEntry("sound", true));
(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");
(void) new TDEAction(i18n("&Reload Plugins"), 0, this, TQ_SLOT(initPlugins()), actionCollection(), "reloadplugins");
(void) new TDEAction(i18n("Show &Plugins"), 0, this, TQ_SLOT(showPlugins()), actionCollection(), "showplugins");
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");
aboutAction = new TDEAction(i18n("&About Course"), 0, this, TQ_SLOT(emptySlot()), actionCollection(), "aboutcourse");
tutorialAction = new TDEAction(i18n("&Tutorial"), 0, this, TQ_SLOT(tutorial()), actionCollection(), "tutorial");
statusBar();
setupGUI();
@ -223,40 +223,40 @@ void Kolf::startNewGame()
game = new KolfGame(obj, &players, filename, dummy);
game->setStrict(competition);
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)), 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()));
connect(firstAction, TQT_SIGNAL(activated()), game, TQT_SLOT(firstHole()));
connect(lastAction, TQT_SIGNAL(activated()), game, TQT_SLOT(lastHole()));
connect(randAction, TQT_SIGNAL(activated()), game, TQT_SLOT(randHole()));
connect(editingAction, TQT_SIGNAL(activated()), game, TQT_SLOT(toggleEditMode()));
connect(newHoleAction, TQT_SIGNAL(activated()), game, TQT_SLOT(addNewHole()));
connect(clearHoleAction, TQT_SIGNAL(activated()), game, TQT_SLOT(clearHole()));
connect(resetHoleAction, TQT_SIGNAL(activated()), game, TQT_SLOT(resetHole()));
connect(undoShotAction, TQT_SIGNAL(activated()), game, TQT_SLOT(undoShot()));
//connect(replayShotAction, TQT_SIGNAL(activated()), game, TQT_SLOT(replay()));
connect(aboutAction, TQT_SIGNAL(activated()), game, TQT_SLOT(showInfoDlg()));
connect(useMouseAction, TQT_SIGNAL(toggled(bool)), game, TQT_SLOT(setUseMouse(bool)));
connect(useAdvancedPuttingAction, TQT_SIGNAL(toggled(bool)), game, TQT_SLOT(setUseAdvancedPutting(bool)));
connect(soundAction, TQT_SIGNAL(toggled(bool)), game, TQT_SLOT(setSound(bool)));
connect(showGuideLineAction, TQT_SIGNAL(toggled(bool)), game, TQT_SLOT(setShowGuideLine(bool)));
connect(showInfoAction, TQT_SIGNAL(toggled(bool)), game, TQT_SLOT(setShowInfo(bool)));
connect(game, TQ_SIGNAL(newHole(int)), scoreboard, TQ_SLOT(newHole(int)));
connect(game, TQ_SIGNAL(scoreChanged(int, int, int)), scoreboard, TQ_SLOT(setScore(int, int, int)));
connect(game, TQ_SIGNAL(parChanged(int, int)), scoreboard, TQ_SLOT(parChanged(int, int)));
connect(game, TQ_SIGNAL(modifiedChanged(bool)), this, TQ_SLOT(updateModified(bool)));
connect(game, TQ_SIGNAL(newPlayersTurn(Player *)), this, TQ_SLOT(newPlayersTurn(Player *)));
connect(game, TQ_SIGNAL(holesDone()), this, TQ_SLOT(gameOver()));
connect(game, TQ_SIGNAL(checkEditing()), this, TQ_SLOT(checkEditing()));
connect(game, TQ_SIGNAL(editingStarted()), this, TQ_SLOT(editingStarted()));
connect(game, TQ_SIGNAL(editingEnded()), this, TQ_SLOT(editingEnded()));
connect(game, TQ_SIGNAL(inPlayStart()), this, TQ_SLOT(inPlayStart()));
connect(game, TQ_SIGNAL(inPlayEnd()), this, TQ_SLOT(inPlayEnd()));
connect(game, TQ_SIGNAL(maxStrokesReached(const TQString &)), this, TQ_SLOT(maxStrokesReached(const TQString &)));
connect(game, TQ_SIGNAL(largestHole(int)), this, TQ_SLOT(updateHoleMenu(int)));
connect(game, TQ_SIGNAL(titleChanged(const TQString &)), this, TQ_SLOT(titleChanged(const TQString &)));
connect(game, TQ_SIGNAL(newStatusText(const TQString &)), this, TQ_SLOT(newStatusText(const TQString &)));
connect(game, TQ_SIGNAL(currentHole(int)), this, TQ_SLOT(setCurrentHole(int)));
connect(holeAction, TQ_SIGNAL(activated(const TQString &)), game, TQ_SLOT(switchHole(const TQString &)));
connect(nextAction, TQ_SIGNAL(activated()), game, TQ_SLOT(nextHole()));
connect(prevAction, TQ_SIGNAL(activated()), game, TQ_SLOT(prevHole()));
connect(firstAction, TQ_SIGNAL(activated()), game, TQ_SLOT(firstHole()));
connect(lastAction, TQ_SIGNAL(activated()), game, TQ_SLOT(lastHole()));
connect(randAction, TQ_SIGNAL(activated()), game, TQ_SLOT(randHole()));
connect(editingAction, TQ_SIGNAL(activated()), game, TQ_SLOT(toggleEditMode()));
connect(newHoleAction, TQ_SIGNAL(activated()), game, TQ_SLOT(addNewHole()));
connect(clearHoleAction, TQ_SIGNAL(activated()), game, TQ_SLOT(clearHole()));
connect(resetHoleAction, TQ_SIGNAL(activated()), game, TQ_SLOT(resetHole()));
connect(undoShotAction, TQ_SIGNAL(activated()), game, TQ_SLOT(undoShot()));
//connect(replayShotAction, TQ_SIGNAL(activated()), game, TQ_SLOT(replay()));
connect(aboutAction, TQ_SIGNAL(activated()), game, TQ_SLOT(showInfoDlg()));
connect(useMouseAction, TQ_SIGNAL(toggled(bool)), game, TQ_SLOT(setUseMouse(bool)));
connect(useAdvancedPuttingAction, TQ_SIGNAL(toggled(bool)), game, TQ_SLOT(setUseAdvancedPutting(bool)));
connect(soundAction, TQ_SIGNAL(toggled(bool)), game, TQ_SLOT(setSound(bool)));
connect(showGuideLineAction, TQ_SIGNAL(toggled(bool)), game, TQ_SLOT(setShowGuideLine(bool)));
connect(showInfoAction, TQ_SIGNAL(toggled(bool)), game, TQ_SLOT(setShowInfo(bool)));
game->setUseMouse(useMouseAction->isChecked());
game->setUseAdvancedPutting(useAdvancedPuttingAction->isChecked());
@ -356,7 +356,7 @@ void Kolf::closeGame()
titleChanged(TQString());
updateModified(false);
TQTimer::singleShot(100, this, TQT_SLOT(createSpacer()));
TQTimer::singleShot(100, this, TQ_SLOT(createSpacer()));
}
void Kolf::createSpacer()
@ -463,7 +463,7 @@ void Kolf::gameOver()
scoreDialog->show();
}
TQTimer::singleShot(700, this, TQT_SLOT(closeGame()));
TQTimer::singleShot(700, this, TQ_SLOT(closeGame()));
}
void Kolf::showHighScores()
@ -564,7 +564,7 @@ void Kolf::openURL(KURL url)
return;
}
TQTimer::singleShot(10, this, TQT_SLOT(startNewGame()));
TQTimer::singleShot(10, this, TQ_SLOT(startNewGame()));
}
else
closeGame();
@ -594,10 +594,10 @@ void Kolf::editingStarted()
{
delete editor;
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 *)), this, TQT_SLOT(setHoleFocus()));
connect(game, TQT_SIGNAL(newSelectedItem(CanvasItem *)), editor, TQT_SLOT(setItem(CanvasItem *)));
connect(editor, TQ_SIGNAL(addNewItem(Object *)), game, TQ_SLOT(addNewObject(Object *)));
connect(editor, TQ_SIGNAL(changed()), game, TQ_SLOT(setModified()));
connect(editor, TQ_SIGNAL(addNewItem(Object *)), this, TQ_SLOT(setHoleFocus()));
connect(game, TQ_SIGNAL(newSelectedItem(CanvasItem *)), editor, TQ_SLOT(setItem(CanvasItem *)));
scoreboard->hide();

18
kolf/newgame.cpp
Unescape View File

@ -52,7 +52,7 @@ NewGameDialog::NewGameDialog(bool enableCourses, TQWidget *parent, const char *_
addButton = new KPushButton(i18n("&New Player"), playerPage);
bigLayout->addWidget(addButton);
connect(addButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(addPlayer()));
connect(addButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(addPlayer()));
scroller = new TQScrollView(playerPage);
bigLayout->addWidget(scroller);
@ -92,7 +92,7 @@ NewGameDialog::NewGameDialog(bool enableCourses, TQWidget *parent, const char *_
TQVBoxLayout *coursePageLayout = new TQVBoxLayout(coursePage, marginHint(), spacingHint());
KURLLabel *coursesLink = new KURLLabel("http://web.mit.edu/~jasonkb/www/kolf/", "http://web.mit.edu/~jasonkb/www/kolf/", coursePage);
connect(coursesLink, TQT_SIGNAL(leftClickedURL(const TQString &)), kapp, TQT_SLOT(invokeBrowser(const TQString &)));
connect(coursesLink, TQ_SIGNAL(leftClickedURL(const TQString &)), kapp, TQ_SLOT(invokeBrowser(const TQString &)));
coursePageLayout->addWidget(coursesLink);
TQHBoxLayout *hlayout = new TQHBoxLayout(coursePageLayout, spacingHint());
@ -131,8 +131,8 @@ NewGameDialog::NewGameDialog(bool enableCourses, TQWidget *parent, const char *_
hlayout->addWidget(courseList);
courseList->insertStringList(nameList);
courseList->setCurrentItem(curItem);
connect(courseList, TQT_SIGNAL(highlighted(int)), this, TQT_SLOT(courseSelected(int)));
connect(courseList, TQT_SIGNAL(selectionChanged()), this, TQT_SLOT(selectionChanged()));
connect(courseList, TQ_SIGNAL(highlighted(int)), this, TQ_SLOT(courseSelected(int)));
connect(courseList, TQ_SIGNAL(selectionChanged()), this, TQ_SLOT(selectionChanged()));
TQVBoxLayout *detailLayout = new TQVBoxLayout(hlayout, spacingHint());
name = new TQLabel(coursePage);
@ -148,7 +148,7 @@ NewGameDialog::NewGameDialog(bool enableCourses, TQWidget *parent, const char *_
detailLayout->addStretch();
KPushButton *scores = new KPushButton(i18n("Highscores"), coursePage);
connect(scores, TQT_SIGNAL(clicked()), this, TQT_SLOT(showHighscores()));
connect(scores, TQ_SIGNAL(clicked()), this, TQ_SLOT(showHighscores()));
detailLayout->addWidget(scores);
detailLayout->addStretch();
@ -158,11 +158,11 @@ NewGameDialog::NewGameDialog(bool enableCourses, TQWidget *parent, const char *_
KPushButton *addCourseButton = new KPushButton(i18n("Add..."), coursePage);
minorLayout->addWidget(addCourseButton);
connect(addCourseButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(addCourse()));
connect(addCourseButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(addCourse()));
remove = new KPushButton(i18n("Remove"), coursePage);
minorLayout->addWidget(remove);
connect(remove, TQT_SIGNAL(clicked()), this, TQT_SLOT(removeCourse()));
connect(remove, TQ_SIGNAL(clicked()), this, TQ_SLOT(removeCourse()));
courseSelected(curItem);
selectionChanged();
@ -289,7 +289,7 @@ void NewGameDialog::addPlayer()
editors.append(new PlayerEditor(i18n("Player %1").arg(editors.count() + 1), *startColors.at(editors.count()), layout));
editors.last()->show();
connect(editors.last(), TQT_SIGNAL(deleteEditor(PlayerEditor *)), this, TQT_SLOT(deleteEditor(PlayerEditor *)));
connect(editors.last(), TQ_SIGNAL(deleteEditor(PlayerEditor *)), this, TQ_SLOT(deleteEditor(PlayerEditor *)));
enableButtons();
}
@ -336,7 +336,7 @@ PlayerEditor::PlayerEditor(TQString startName, TQColor startColor, TQWidget *par
remove->setAutoMask(true);
layout->addWidget(remove);
remove->setBackgroundPixmap(grass);
connect(remove, TQT_SIGNAL(clicked()), this, TQT_SLOT(removeMe()));
connect(remove, TQ_SIGNAL(clicked()), this, TQ_SLOT(removeMe()));
}
void PlayerEditor::removeMe()

2
kolf/objects/poolball/poolball.cpp
Unescape View File

@ -69,7 +69,7 @@ PoolBallConfig::PoolBallConfig(PoolBall *poolBall, TQWidget *parent)
layout->addStretch();
connect(slider, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(numberChanged(int)));
connect(slider, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(numberChanged(int)));
}
void PoolBallConfig::numberChanged(int newNumber)

2
kolf/objects/test/test.cpp
Unescape View File

@ -84,7 +84,7 @@ TestConfig::TestConfig(Test *test, TQWidget *parent)
layout->addStretch();
connect(slider, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(switchEveryChanged(int)));
connect(slider, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(switchEveryChanged(int)));
}
void TestConfig::switchEveryChanged(int news)

8
kolf/slope.cpp
Unescape View File

@ -534,14 +534,14 @@ SlopeConfig::SlopeConfig(Slope *slope, TQWidget *parent)
gradient->insertStringList(items);
gradient->setCurrentText(curText);
layout->addWidget(gradient);
connect(gradient, TQT_SIGNAL(activated(const TQString &)), this, TQT_SLOT(setGradient(const TQString &)));
connect(gradient, TQ_SIGNAL(activated(const TQString &)), this, TQ_SLOT(setGradient(const TQString &)));
layout->addStretch();
TQCheckBox *reversed = new TQCheckBox(i18n("Reverse direction"), this);
reversed->setChecked(slope->isReversed());
layout->addWidget(reversed);
connect(reversed, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(setReversed(bool)));
connect(reversed, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setReversed(bool)));
TQHBoxLayout *hlayout = new TQHBoxLayout(layout, spacingHint());
hlayout->addWidget(new TQLabel(i18n("Grade:"), this));
@ -549,13 +549,13 @@ SlopeConfig::SlopeConfig(Slope *slope, TQWidget *parent)
grade->setRange(0, 8, 1, true);
grade->setValue(slope->curGrade());
hlayout->addWidget(grade);
connect(grade, TQT_SIGNAL(valueChanged(double)), this, TQT_SLOT(gradeChanged(double)));
connect(grade, TQ_SIGNAL(valueChanged(double)), this, TQ_SLOT(gradeChanged(double)));
TQCheckBox *stuck = new TQCheckBox(i18n("Unmovable"), this);
TQWhatsThis::add(stuck, i18n("Whether or not this slope can be moved by other objects, like floaters."));
stuck->setChecked(slope->isStuckOnGround());
layout->addWidget(stuck);
connect(stuck, TQT_SIGNAL(toggled(bool)), this, TQT_SLOT(setStuckOnGround(bool)));
connect(stuck, TQ_SIGNAL(toggled(bool)), this, TQ_SLOT(setStuckOnGround(bool)));
}
void SlopeConfig::setGradient(const TQString &text)

2
konquest/fleetdlg.cpp
Unescape View File

@ -62,7 +62,7 @@ FleetDlg::FleetDlg( TQWidget *parent, AttackFleetList *fleets )
layout2->addWidget( okButton );
layout2->addStretch( 2 );
connect( okButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(accept()) );
connect( okButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()) );
init();

8
konquest/gameboard.cpp
Unescape View File

@ -119,10 +119,10 @@ GameBoard::GameBoard( TQWidget *parent )
//**********************************************************************
// Set up signal/slot connections
//**********************************************************************
connect( mapWidget, TQT_SIGNAL( planetSelected(Planet *) ), this, TQT_SLOT(planetSelected(Planet *)) );
connect( shipCountEdit, TQT_SIGNAL(returnPressed()), this, TQT_SLOT(newShipCount()) );
connect( endTurn, TQT_SIGNAL( clicked() ), this, TQT_SLOT( nextPlayer() ) );
connect( mapWidget, TQT_SIGNAL( planetHighlighted(Planet *)), planetInfo, TQT_SLOT(showPlanet(Planet *)) );
connect( mapWidget, TQ_SIGNAL( planetSelected(Planet *) ), this, TQ_SLOT(planetSelected(Planet *)) );
connect( shipCountEdit, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(newShipCount()) );
connect( endTurn, TQ_SIGNAL( clicked() ), this, TQ_SLOT( nextPlayer() ) );
connect( mapWidget, TQ_SIGNAL( planetHighlighted(Planet *)), planetInfo, TQ_SLOT(showPlanet(Planet *)) );
changeGameBoard( false );
}

4
konquest/gamecore.cpp
Unescape View File

@ -78,7 +78,7 @@ Map::Map()
for( int y = 0; y < columns; y++ )
{
grid[x][y] = Sector( this, x, y );
connect( &grid[x][y], TQT_SIGNAL( update() ), this, TQT_SLOT( childSectorUpdate() ));
connect( &grid[x][y], TQ_SIGNAL( update() ), this, TQ_SLOT( childSectorUpdate() ));
}
}
}
@ -265,7 +265,7 @@ void Sector::setPlanet( Planet *newPlanet )
{
planet = newPlanet;
connect( planet, TQT_SIGNAL( update() ), this, TQT_SLOT( childPlanetUpdate() ) );
connect( planet, TQ_SIGNAL( update() ), this, TQ_SLOT( childPlanetUpdate() ) );
emit update();
}

2
konquest/gameenddlg.cpp
Unescape View File

@ -35,7 +35,7 @@ GameEndDlg::GameEndDlg( TQWidget *parent )
init();
connect( turnCount, TQT_SIGNAL(valueChanged( int )), this, TQT_SLOT(turnCountChange( int )) );
connect( turnCount, TQ_SIGNAL(valueChanged( int )), this, TQ_SLOT(turnCountChange( int )) );
}
GameEndDlg::~GameEndDlg()

14
konquest/mainwin.cpp
Unescape View File

@ -37,18 +37,18 @@ MainWindow::~MainWindow()
void
MainWindow::setupTDEAction()
{
KStdGameAction::gameNew( gameBoard, TQT_SLOT( startNewGame() ), actionCollection() );
KStdGameAction::quit( this, TQT_SLOT( close() ), actionCollection() );
endAction = KStdGameAction::end( gameBoard, TQT_SLOT( shutdownGame() ), actionCollection() );
KStdGameAction::gameNew( gameBoard, TQ_SLOT( startNewGame() ), actionCollection() );
KStdGameAction::quit( this, TQ_SLOT( close() ), actionCollection() );
endAction = KStdGameAction::end( gameBoard, TQ_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, gameBoard, TQT_SLOT( measureDistance() ), actionCollection(), "game_measure" );
measureAction = new TDEAction( i18n("&Measure Distance"), "ruler", 0, gameBoard, TQ_SLOT( measureDistance() ), actionCollection(), "game_measure" );
measureAction->setEnabled(false);
standingAction = new TDEAction( i18n("&Show Standings"), "help", 0, gameBoard, TQT_SLOT( showScores() ), actionCollection(), "game_scores" );
standingAction = new TDEAction( i18n("&Show Standings"), "help", 0, gameBoard, TQ_SLOT( showScores() ), actionCollection(), "game_scores" );
standingAction->setEnabled(false);
fleetAction = new TDEAction( i18n("&Fleet Overview"), "launch", 0, gameBoard, TQT_SLOT( showFleets() ), actionCollection(), "game_fleets" );
fleetAction = new TDEAction( i18n("&Fleet Overview"), "launch", 0, gameBoard, TQ_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 )), this, TQT_SLOT( gameStateChange( GameState ) ) );
connect( gameBoard, TQ_SIGNAL( newGameState( GameState )), this, TQ_SLOT( gameStateChange( GameState ) ) );
}

4
konquest/map_widget.cpp
Unescape View File

@ -32,10 +32,10 @@ ConquestMap::ConquestMap( Map *newMap, TQWidget *parent )
setMinimumSize( BOARD_HEIGHT, BOARD_WIDTH );
setMaximumSize( BOARD_HEIGHT, BOARD_WIDTH );
connect( map, TQT_SIGNAL( update() ), this, TQT_SLOT( mapUpdate() ) );
connect( map, TQ_SIGNAL( update() ), this, TQ_SLOT( mapUpdate() ) );
TQTimer *timer = new TQTimer( this );
connect( timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(squareBlink()) );
connect( timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(squareBlink()) );
timer->start( 500, false );
viewport()->setMouseTracking( true );

2
konquest/minimap.cpp
Unescape View File

@ -39,7 +39,7 @@ MiniMap::setMap(Map *newMap)
setMinimumSize( BOARD_HEIGHT, BOARD_WIDTH );
setMaximumSize( BOARD_HEIGHT, BOARD_WIDTH );
connect( map, TQT_SIGNAL( update() ), this, TQT_SLOT( mapUpdate() ) );
connect( map, TQ_SIGNAL( update() ), this, TQ_SLOT( mapUpdate() ) );
}
MiniMap::~MiniMap()

14
konquest/newgamedlg.cpp
Unescape View File

@ -43,13 +43,13 @@ NewGameDlg::NewGameDlg( TQWidget *parent, Map *pmap, PlayerList *players,
w->newPlayer->setMaxLength( 8 );
connect(w->sliderPlayers, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotPlayerCount(int)));
connect(w->sliderPlanets, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotNewMap()));
connect(w->sliderTurns, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotTurns()));
connect(w->rejectMap, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotNewMap()));
connect(w->newPlayer, TQT_SIGNAL(textChanged(const TQString &)), this, TQT_SLOT(slotNewPlayer()));
connect(w->newPlayer, TQT_SIGNAL(returnPressed()), this, TQT_SLOT(slotAddPlayer()));
connect(w->addPlayer, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotAddPlayer()));
connect(w->sliderPlayers, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotPlayerCount(int)));
connect(w->sliderPlanets, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotNewMap()));
connect(w->sliderTurns, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotTurns()));
connect(w->rejectMap, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotNewMap()));
connect(w->newPlayer, TQ_SIGNAL(textChanged(const TQString &)), this, TQ_SLOT(slotNewPlayer()));
connect(w->newPlayer, TQ_SIGNAL(returnPressed()), this, TQ_SLOT(slotAddPlayer()));
connect(w->addPlayer, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotAddPlayer()));
init();

2
konquest/scoredlg.cpp
Unescape View File

@ -55,7 +55,7 @@ ScoreDlg::ScoreDlg( TQWidget *parent, const TQString& title, PlayerList *players
layout2->addWidget( okButton );
layout2->addStretch( 2 );
connect( okButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(accept()) );
connect( okButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(accept()) );
init();

22
kpat/dealer.cpp
Unescape View File

@ -83,7 +83,7 @@ Dealer::Dealer( TDEMainWindow* _parent , const char* _name )
demotimer = new TQTimer(this);
connect(demotimer, TQT_SIGNAL(timeout()), TQT_SLOT(demo()));
connect(demotimer, TQ_SIGNAL(timeout()), TQ_SLOT(demo()));
assert(!s_instance);
s_instance = this;
@ -115,7 +115,7 @@ void Dealer::setupActions() {
if (actions() & Dealer::Hint) {
ahint = new TDEAction( i18n("&Hint"), TQString::fromLatin1("wizard"), Key_H, this,
TQT_SLOT(hint()),
TQ_SLOT(hint()),
parent()->actionCollection(), "game_hint");
actionlist.append(ahint);
} else
@ -123,7 +123,7 @@ void Dealer::setupActions() {
if (actions() & Dealer::Demo) {
ademo = new TDEToggleAction( i18n("&Demo"), TQString::fromLatin1("1rightarrow"), CTRL+Key_D, this,
TQT_SLOT(toggleDemo()),
TQ_SLOT(toggleDemo()),
parent()->actionCollection(), "game_demo");
actionlist.append(ademo);
} else
@ -131,7 +131,7 @@ void Dealer::setupActions() {
if (actions() & Dealer::Redeal) {
aredeal = new TDEAction (i18n("&Redeal"), TQString::fromLatin1("queue"), 0, this,
TQT_SLOT(redeal()),
TQ_SLOT(redeal()),
parent()->actionCollection(), "game_redeal");
actionlist.append(aredeal);
} else
@ -650,7 +650,7 @@ void Dealer::startNew()
if (!towait)
takeState();
else
connect(towait, TQT_SIGNAL(stoped(Card*)), TQT_SLOT(slotTakeState(Card *)));
connect(towait, TQ_SIGNAL(stoped(Card*)), TQ_SLOT(slotTakeState(Card *)));
resizeEvent(0);
}
@ -791,13 +791,13 @@ void Dealer::takeState()
ademo->setEnabled( false );
if ( aredeal )
aredeal->setEnabled( false );
TQTimer::singleShot(400, this, TQT_SIGNAL(gameLost()));
TQTimer::singleShot(400, this, TQ_SIGNAL(gameLost()));
toldAboutLostGame = true;
return;
}
}
if (!demoActive() && !waiting())
TQTimer::singleShot(TIME_BETWEEN_MOVES, this, TQT_SLOT(startAutoDrop()));
TQTimer::singleShot(TIME_BETWEEN_MOVES, this, TQ_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, this, TQT_SLOT(startAutoDrop()));
TQTimer::singleShot(TIME_BETWEEN_MOVES, this, TQ_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, this, TQT_SLOT(startAutoDrop()));
TQTimer::singleShot(TIME_BETWEEN_MOVES, this, TQ_SLOT(startAutoDrop()));
return true;
}
@ -1034,7 +1034,7 @@ bool Dealer::startAutoDrop()
t->move(x, y);
kdDebug(11111) << "autodrop " << t->name() << endl;
t->moveTo(int(t->source()->x()), int(t->source()->y()), int(t->z()), STEPS_AUTODROP);
connect(t, TQT_SIGNAL(stoped(Card*)), TQT_SLOT(waitForAutoDrop(Card*)));
connect(t, TQ_SIGNAL(stoped(Card*)), TQ_SLOT(waitForAutoDrop(Card*)));
return true;
}
}
@ -1269,7 +1269,7 @@ Card *Dealer::demoNewCards()
void Dealer::newDemoMove(Card *m)
{
towait = m;
connect(m, TQT_SIGNAL(stoped(Card*)), TQT_SLOT(waitForDemo(Card*)));
connect(m, TQ_SIGNAL(stoped(Card*)), TQ_SLOT(waitForDemo(Card*)));
}
void Dealer::waitForDemo(Card *t)

2
kpat/fortyeight.cpp
Unescape View File

@ -35,7 +35,7 @@ Fortyeight::Fortyeight( TDEMainWindow* parent, const char* name)
const int dist_x = cardMap::CARDX() * 11 / 10 + 1;
const int dist_y = cardMap::CARDY() * 11 / 10 + 1;
connect(deck, TQT_SIGNAL(clicked(Card*)), TQT_SLOT(deckClicked(Card*)));
connect(deck, TQ_SIGNAL(clicked(Card*)), TQ_SLOT(deckClicked(Card*)));
deck->move(10 + cardMap::CARDX() * 82 / 10, 10 + cardMap::CARDX() * 56 / 10);
deck->setZ(20);

8
kpat/freecell.cpp
Unescape View File

@ -313,7 +313,7 @@ void FreecellBase::resumeSolution()
}
solver_ret = freecell_solver_user_resume_solution(solver_instance);
TQTimer::singleShot(0, this, TQT_SLOT(resumeSolution()));
TQTimer::singleShot(0, this, TQ_SLOT(resumeSolution()));
}
MoveHint *FreecellBase::translateMove(void *m) {
@ -602,7 +602,7 @@ void FreecellBase::moveCards(CardList &c, FreecellPile *from, Pile *to)
from->moveCardsBack(c);
waitfor = c.first();
connect(waitfor, TQT_SIGNAL(stoped(Card*)), TQT_SLOT(waitForMoving(Card*)));
connect(waitfor, TQ_SIGNAL(stoped(Card*)), TQ_SLOT(waitForMoving(Card*)));
PileList fcs;
@ -625,7 +625,7 @@ void FreecellBase::moveCards(CardList &c, FreecellPile *from, Pile *to)
movePileToPile(c, to, fss, fcs, 0, c.count(), 0);
if (!waitfor->animated())
TQTimer::singleShot(0, this, TQT_SLOT(startMoving()));
TQTimer::singleShot(0, this, TQ_SLOT(startMoving()));
}
struct MoveAway {
@ -707,7 +707,7 @@ void FreecellBase::startMoving()
mh->pile()->moveCardsBack(empty, true);
waitfor = mh->card();
kdDebug(11111) << "wait for moving end " << mh->card()->name() << endl;
connect(mh->card(), TQT_SIGNAL(stoped(Card*)), TQT_SLOT(waitForMoving(Card*)));
connect(mh->card(), TQ_SIGNAL(stoped(Card*)), TQ_SLOT(waitForMoving(Card*)));
delete mh;
}

2
kpat/golf.cpp
Unescape View File

@ -27,7 +27,7 @@ Golf::Golf( TDEMainWindow* parent, const char* _name)
deck = Deck::new_deck( this);
deck->move(10, pile_dist);
connect(deck, TQT_SIGNAL(clicked(Card*)), TQT_SLOT(deckClicked(Card*)));
connect(deck, TQ_SIGNAL(clicked(Card*)), TQ_SLOT(deckClicked(Card*)));
for( int r = 0; r < 7; r++ ) {
stack[r]=new Pile(1+r, this);

2
kpat/gypsy.cpp
Unescape View File

@ -12,7 +12,7 @@ Gypsy::Gypsy( TDEMainWindow* parent, const char *name )
deck = Deck::new_deck(this, 2);
deck->move(10 + dist_x / 2 + 8*dist_x, 10 + 45 * cardMap::CARDY() / 10);
connect(deck, TQT_SIGNAL(clicked(Card*)), TQT_SLOT(slotClicked(Card *)));
connect(deck, TQ_SIGNAL(clicked(Card*)), TQ_SLOT(slotClicked(Card *)));
for (int i=0; i<8; i++) {
target[i] = new Pile(i+1, this);

2
kpat/mod3.cpp
Unescape View File

@ -37,7 +37,7 @@ Mod3::Mod3( TDEMainWindow* parent, const char* _name)
deck = Deck::new_deck( this, 2);
deck->move(8 + dist_x * 8 + 20, 8 + dist_y * 3 + margin);
connect(deck, TQT_SIGNAL(clicked(Card*)), TQT_SLOT(deckClicked(Card*)));
connect(deck, TQ_SIGNAL(clicked(Card*)), TQ_SLOT(deckClicked(Card*)));
aces = new Pile(50, this);
aces->move(16 + dist_x * 8, 8 + dist_y / 2);

2
kpat/napoleon.cpp
Unescape View File

@ -26,7 +26,7 @@ Napoleon::Napoleon( TDEMainWindow* parent, const char* _name )
: Dealer( parent, _name )
{
deck = Deck::new_deck( this );
connect(deck, TQT_SIGNAL(clicked(Card *)), TQT_SLOT(deal1(Card*)));
connect(deck, TQ_SIGNAL(clicked(Card *)), TQ_SLOT(deal1(Card*)));
pile = new Pile( 1, this );
pile->setAddFlags( Pile::disallow );

50
kpat/pwidget.cpp
Unescape View File

@ -59,29 +59,29 @@ pWidget::pWidget()
{
current_pwidget = this;
// TDECrash::setEmergencySaveFunction(::saveGame);
KStdAction::quit(kapp, TQT_SLOT(quit()), actionCollection(), "game_exit");
KStdAction::quit(kapp, TQ_SLOT(quit()), actionCollection(), "game_exit");
undo = KStdAction::undo(this, TQT_SLOT(undoMove()),
undo = KStdAction::undo(this, TQ_SLOT(undoMove()),
actionCollection(), "undo_move");
undo->setEnabled(false);
(void)KStdAction::openNew(this, TQT_SLOT(newGame()),
(void)KStdAction::openNew(this, TQ_SLOT(newGame()),
actionCollection(), "new_game");
(void)KStdAction::open(this, TQT_SLOT(openGame()),
(void)KStdAction::open(this, TQ_SLOT(openGame()),
actionCollection(), "open");
recent = KStdAction::openRecent(this, TQT_SLOT(openGame(const KURL&)),
recent = KStdAction::openRecent(this, TQ_SLOT(openGame(const KURL&)),
actionCollection(), "open_recent");
recent->loadEntries(TDEGlobal::config());
(void)KStdAction::saveAs(this, TQT_SLOT(saveGame()),
(void)KStdAction::saveAs(this, TQ_SLOT(saveGame()),
actionCollection(), "save");
(void)new TDEAction(i18n("&Choose Game..."), 0, this, TQT_SLOT(chooseGame()),
(void)new TDEAction(i18n("&Choose Game..."), 0, this, TQ_SLOT(chooseGame()),
actionCollection(), "choose_game");
(void)new TDEAction(i18n("Restart &Game"), TQString::fromLatin1("reload"), 0,
this, TQT_SLOT(restart()),
this, TQ_SLOT(restart()),
actionCollection(), "restart_game");
(void)KStdAction::help(this, TQT_SLOT(helpGame()), actionCollection(), "help_game");
(void)KStdAction::help(this, TQ_SLOT(helpGame()), actionCollection(), "help_game");
games = new TDESelectAction(i18n("&Game Type"), 0, this,
TQT_SLOT(newGameType()),
TQ_SLOT(newGameType()),
actionCollection(), "game_type");
TQStringList list;
TQValueList<DealerInfo*>::ConstIterator it;
@ -105,7 +105,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, this,
TQT_SLOT(changeWallpaper()),
TQ_SLOT(changeWallpaper()),
actionCollection(), "wallpaper");
list.clear();
wallpaperlist.clear();
@ -132,16 +132,16 @@ pWidget::pWidget()
(void)new cardMap(midcolor);
backs = new TDEAction(i18n("&Switch Cards..."), 0, this,
TQT_SLOT(changeBackside()),
TQ_SLOT(changeBackside()),
actionCollection(), "backside");
stats = new TDEAction(i18n("&Statistics"), 0, this, TQT_SLOT(showStats()),
stats = new TDEAction(i18n("&Statistics"), 0, this, TQ_SLOT(showStats()),
actionCollection(),"game_stats");
animation = new TDEToggleAction(i18n( "&Animation on Startup" ),
0, this, TQT_SLOT(animationChanged()),
0, this, TQ_SLOT(animationChanged()),
actionCollection(), "animation");
dropaction = new TDEToggleAction(i18n("&Enable Autodrop"),
0, this, TQT_SLOT(enableAutoDrop()),
0, this, TQ_SLOT(enableAutoDrop()),
actionCollection(), "enable_autodrop");
dropaction->setCheckedState(i18n("Disable Autodrop"));
@ -347,11 +347,11 @@ void pWidget::newGameType()
name = name.replace(TQRegExp("[&']"), "");
name = name.replace(TQRegExp("[ ]"), "_").lower();
dill->setAnchorName("game_" + name);
connect(dill, TQT_SIGNAL(saveGame()), TQT_SLOT(saveGame()));
connect(dill, TQT_SIGNAL(gameInfo(const TQString&)),
TQT_SLOT(slotGameInfo(const TQString &)));
connect(dill, TQT_SIGNAL(updateMoves()),
TQT_SLOT(slotUpdateMoves()));
connect(dill, TQ_SIGNAL(saveGame()), TQ_SLOT(saveGame()));
connect(dill, TQ_SIGNAL(gameInfo(const TQString&)),
TQ_SLOT(slotGameInfo(const TQString &)));
connect(dill, TQ_SIGNAL(updateMoves()),
TQ_SLOT(slotUpdateMoves()));
dill->setGameId(id);
dill->setupActions();
dill->setBackgroundPixmap(background, midcolor);
@ -365,9 +365,9 @@ void pWidget::newGameType()
dill = DealerInfoList::self()->games().first()->createGame(this);
}
connect(dill, TQT_SIGNAL(undoPossible(bool)), TQT_SLOT(undoPossible(bool)));
connect(dill, TQT_SIGNAL(gameWon(bool)), TQT_SLOT(gameWon(bool)));
connect(dill, TQT_SIGNAL(gameLost()), TQT_SLOT(gameLost()));
connect(dill, TQ_SIGNAL(undoPossible(bool)), TQ_SLOT(undoPossible(bool)));
connect(dill, TQ_SIGNAL(gameWon(bool)), TQ_SLOT(gameWon(bool)));
connect(dill, TQ_SIGNAL(gameLost()), TQ_SLOT(gameLost()));
dill->setAutoDropEnabled(dropaction->isChecked());
@ -455,7 +455,7 @@ void pWidget::gameWon(bool withhelp)
#if TEST_SOLVER == 0
KMessageBox::information(this, congrats, i18n("Congratulations!"));
#endif
TQTimer::singleShot(0, this, TQT_SLOT(newGame()));
TQTimer::singleShot(0, this, TQ_SLOT(newGame()));
#if TEST_SOLVER == 1
dill->demo();
#endif
@ -491,7 +491,7 @@ void pWidget::gameLost()
KStdGuiItem::cont(),
dontAskAgainName) == KMessageBox::Yes) {
TQTimer::singleShot(0, this, TQT_SLOT(newGame()));
TQTimer::singleShot(0, this, TQ_SLOT(newGame()));
}
}

2
kpat/spider.cpp
Unescape View File

@ -68,7 +68,7 @@ Spider::Spider(int suits, TDEMainWindow* parent, const char* _name)
redeals[column]->setCheckIndex(0);
redeals[column]->setAddFlags(Pile::disallow);
redeals[column]->setRemoveFlags(Pile::disallow);
connect(redeals[column], TQT_SIGNAL(clicked(Card*)), TQT_SLOT(deckClicked(Card*)));
connect(redeals[column], TQ_SIGNAL(clicked(Card*)), TQ_SLOT(deckClicked(Card*)));
}
// The 10 playing piles

12
kpoker/betbox.cpp
Unescape View File

@ -54,12 +54,12 @@ BetBox::BetBox(TQWidget* parent, const char* name)
foldButton->setText(i18n("Fold"));
//connects
connect(bet5Up, TQT_SIGNAL(clicked()), TQT_SLOT(bet5UpClicked()));
connect(bet10Up, TQT_SIGNAL(clicked()), TQT_SLOT(bet10UpClicked()));
connect(bet5Down, TQT_SIGNAL(clicked()), TQT_SLOT(bet5DownClicked()));
connect(bet10Down, TQT_SIGNAL(clicked()), TQT_SLOT(bet10DownClicked()));
connect(foldButton, TQT_SIGNAL(clicked()), TQT_SLOT(foldClicked()));
connect(adjustBet, TQT_SIGNAL(clicked()), TQT_SLOT(adjustBetClicked()));
connect(bet5Up, TQ_SIGNAL(clicked()), TQ_SLOT(bet5UpClicked()));
connect(bet10Up, TQ_SIGNAL(clicked()), TQ_SLOT(bet10UpClicked()));
connect(bet5Down, TQ_SIGNAL(clicked()), TQ_SLOT(bet5DownClicked()));
connect(bet10Down, TQ_SIGNAL(clicked()), TQ_SLOT(bet10DownClicked()));
connect(foldButton, TQ_SIGNAL(clicked()), TQ_SLOT(foldClicked()));
connect(adjustBet, TQ_SIGNAL(clicked()), TQ_SLOT(adjustBetClicked()));
stopRaise();
}

2
kpoker/kpaint.cpp
Unescape View File

@ -115,7 +115,7 @@ CardWidget::CardWidget( TQWidget *parent, const char *name )
m_held = false;
setBackgroundMode( NoBackground ); // disables flickering
connect(this, TQT_SIGNAL(clicked()), this, TQT_SLOT(ownClick()));
connect(this, TQ_SIGNAL(clicked()), this, TQ_SLOT(ownClick()));
setFixedSize(cardWidth, cardHeight);
}

16
kpoker/kpoker.cpp
Unescape View File

@ -255,7 +255,7 @@ void kpok::initWindow()
// The draw button
drawButton = new TQPushButton(this);
drawButton->setText(i18n("&Deal"));
connect(drawButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(drawClick()));
connect(drawButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(drawClick()));
inputLayout->addWidget(drawButton);
inputLayout->addStretch(1);
@ -291,20 +291,20 @@ void kpok::initWindow()
// Timers
blinkTimer = new TQTimer(this);
connect( blinkTimer, TQT_SIGNAL(timeout()), TQT_SLOT(bTimerEvent()) );
connect( blinkTimer, TQ_SIGNAL(timeout()), TQ_SLOT(bTimerEvent()) );
waveTimer = new TQTimer(this);
connect( waveTimer, TQT_SIGNAL(timeout()), TQT_SLOT(waveTimerEvent()) );
connect( waveTimer, TQ_SIGNAL(timeout()), TQ_SLOT(waveTimerEvent()) );
drawTimer = new TQTimer(this);
connect (drawTimer, TQT_SIGNAL(timeout()), TQT_SLOT(drawCardsEvent()) );
connect (drawTimer, TQ_SIGNAL(timeout()), TQ_SLOT(drawCardsEvent()) );
// and now the betUp/Down Buttons
betBox = new BetBox(this, 0);
betLayout->addWidget(betBox);
connect(betBox, TQT_SIGNAL(betChanged(int)), this, TQT_SLOT(betChange(int)));
connect(betBox, TQT_SIGNAL(betAdjusted()), this, TQT_SLOT(adjustBet()));
connect(betBox, TQT_SIGNAL(fold()), this, TQT_SLOT(out()));
connect(betBox, TQ_SIGNAL(betChanged(int)), this, TQ_SLOT(betChange(int)));
connect(betBox, TQ_SIGNAL(betAdjusted()), this, TQ_SLOT(adjustBet()));
connect(betBox, TQ_SIGNAL(fold()), this, TQ_SLOT(out()));
// some tips
TQToolTip::add(drawButton, i18n("Continue the round"));
@ -644,7 +644,7 @@ void kpok::initPoker(unsigned int numPlayers)
//
// FIXME: Make CardWidget::toggleHeld() work.
playerBox[0]->activateToggleHeld();
connect(playerBox[0], TQT_SIGNAL(toggleHeld()), this, TQT_SLOT(toggleHeld()));
connect(playerBox[0], TQ_SIGNAL(toggleHeld()), this, TQ_SLOT(toggleHeld()));
// hide some things
playerBox[0]->showHelds(false);

4
kpoker/newgamedlg.cpp
Unescape View File

@ -60,8 +60,8 @@ NewGameDlg::NewGameDlg(TQWidget* parent)
readFromConfigLabel->hide();
readFromConfigLabel->adjustSize();
l->addWidget(readFromConfigLabel);
connect(readFromConfig, TQT_SIGNAL(toggled(bool)),
this, TQT_SLOT(changeReadFromConfig(bool)));
connect(readFromConfig, TQ_SIGNAL(toggled(bool)),
this, TQ_SLOT(changeReadFromConfig(bool)));
players = new KIntNumInput(playerNr, plainPage());
players->setRange(1, MAX_PLAYERS);

4
kpoker/playerbox.cpp
Unescape View File

@ -176,8 +176,8 @@ void PlayerBox::paintCard(int nr)
void PlayerBox::activateToggleHeld()
{
for (int i = 0; i < PokerHandSize; i++) {
connect(m_cardWidgets[i], TQT_SIGNAL(pClicked(CardWidget*)),
this, TQT_SLOT(cardClicked(CardWidget*)));
connect(m_cardWidgets[i], TQ_SIGNAL(pClicked(CardWidget*)),
this, TQ_SLOT(cardClicked(CardWidget*)));
}
}

50
kpoker/top.cpp
Unescape View File

@ -50,14 +50,14 @@ PokerWindow::PokerWindow()
LHLabel = new TQLabel(statusBar());
LHLabel->adjustSize();
connect(m_kpok, TQT_SIGNAL(changeLastHand(const TQString &, bool)),
this, TQT_SLOT(setHand(const TQString &, bool)));
connect(m_kpok, TQT_SIGNAL(showClickToHold(bool)),
this, TQT_SLOT(showClickToHold(bool)));
connect(m_kpok, TQT_SIGNAL(clearStatusBar()),
this, TQT_SLOT(clearStatusBar()));
connect(m_kpok, TQT_SIGNAL(statusBarMessage(TQString)),
this, TQT_SLOT(statusBarMessage(TQString)));
connect(m_kpok, TQ_SIGNAL(changeLastHand(const TQString &, bool)),
this, TQ_SLOT(setHand(const TQString &, bool)));
connect(m_kpok, TQ_SIGNAL(showClickToHold(bool)),
this, TQ_SLOT(showClickToHold(bool)));
connect(m_kpok, TQ_SIGNAL(clearStatusBar()),
this, TQ_SLOT(clearStatusBar()));
connect(m_kpok, TQ_SIGNAL(statusBarMessage(TQString)),
this, TQ_SLOT(statusBarMessage(TQString)));
statusBar()->addWidget(LHLabel, 0, true);
m_kpok->updateLHLabel();
@ -79,47 +79,47 @@ PokerWindow::~PokerWindow()
void PokerWindow::initTDEAction()
{
//Game
KStdGameAction::gameNew(m_kpok, TQT_SLOT(newGame()), actionCollection());
KStdGameAction::save(m_kpok, TQT_SLOT(saveGame()), actionCollection());
KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
KStdGameAction::gameNew(m_kpok, TQ_SLOT(newGame()), actionCollection());
KStdGameAction::save(m_kpok, TQ_SLOT(saveGame()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
//Settings
showMenubarAction =
KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
KStdAction::showMenubar(this, TQ_SLOT(toggleMenubar()), actionCollection());
soundAction = new TDEToggleAction(i18n("Soun&d"), 0, m_kpok,
TQT_SLOT(toggleSound()), actionCollection(), "options_sound");
TQ_SLOT(toggleSound()), actionCollection(), "options_sound");
if (m_kpok->getSound())
m_kpok->toggleSound();
blinkingAction = new TDEToggleAction(i18n("&Blinking Cards"), 0, m_kpok,
TQT_SLOT(toggleBlinking()), actionCollection(), "options_blinking");
TQ_SLOT(toggleBlinking()), actionCollection(), "options_blinking");
if (m_kpok->getBlinking())
m_kpok->toggleBlinking();
adjustAction = new TDEToggleAction(i18n("&Adjust Bet is Default"), 0,
m_kpok, TQT_SLOT(toggleAdjust()), actionCollection(), "options_adjust");
m_kpok, TQ_SLOT(toggleAdjust()), actionCollection(), "options_adjust");
if (m_kpok->getAdjust())
m_kpok->toggleAdjust();
showStatusbarAction =
KStdAction::showStatusbar(this, TQT_SLOT(toggleStatusbar()), actionCollection());
KStdAction::showStatusbar(this, TQ_SLOT(toggleStatusbar()), actionCollection());
KStdAction::saveOptions(this, TQT_SLOT(saveOptions()), actionCollection());
KStdGameAction::carddecks(m_kpok, TQT_SLOT(slotCardDeck()), actionCollection());
KStdAction::preferences(m_kpok, TQT_SLOT(slotPreferences()), actionCollection());
KStdAction::saveOptions(this, TQ_SLOT(saveOptions()), actionCollection());
KStdGameAction::carddecks(m_kpok, TQ_SLOT(slotCardDeck()), actionCollection());
KStdAction::preferences(m_kpok, TQ_SLOT(slotPreferences()), actionCollection());
// Keyboard shortcuts.
(void)new TDEAction(i18n("Draw"), TDEShortcut(TQt::Key_Return), m_kpok,
TQT_SLOT(drawClick()), actionCollection(), "draw");
TQ_SLOT(drawClick()), actionCollection(), "draw");
(void)new TDEAction(i18n("Exchange Card 1"), TDEShortcut(TQt::Key_1), m_kpok,
TQT_SLOT(exchangeCard1()), actionCollection(), "exchange_card_1");
TQ_SLOT(exchangeCard1()), actionCollection(), "exchange_card_1");
(void)new TDEAction(i18n("Exchange Card 2"), TDEShortcut(TQt::Key_2), m_kpok,
TQT_SLOT(exchangeCard2()), actionCollection(), "exchange_card_2");
TQ_SLOT(exchangeCard2()), actionCollection(), "exchange_card_2");
(void)new TDEAction(i18n("Exchange Card 3"), TDEShortcut(TQt::Key_3), m_kpok,
TQT_SLOT(exchangeCard3()), actionCollection(), "exchange_card_3");
TQ_SLOT(exchangeCard3()), actionCollection(), "exchange_card_3");
(void)new TDEAction(i18n("Exchange Card 4"), TDEShortcut(TQt::Key_4), m_kpok,
TQT_SLOT(exchangeCard4()), actionCollection(), "exchange_card_4");
TQ_SLOT(exchangeCard4()), actionCollection(), "exchange_card_4");
(void)new TDEAction(i18n("Exchange Card 5"), TDEShortcut(TQt::Key_5), m_kpok,
TQT_SLOT(exchangeCard5()), actionCollection(), "exchange_card_5");
TQ_SLOT(exchangeCard5()), actionCollection(), "exchange_card_5");
setupGUI( TDEMainWindow::Save | StatusBar | Keys | Create);
}

42
kreversi/kreversi.cpp
Unescape View File

@ -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()), this, TQT_SLOT(showTurn()));
connect(m_game, TQT_SIGNAL(sig_move(uint, Move&)),
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()));
connect(m_game, TQ_SIGNAL(sig_newGame()), this, TQ_SLOT(showTurn()));
connect(m_game, TQ_SIGNAL(sig_move(uint, Move&)),
this, TQ_SLOT(handleMove(uint, Move&))); // Calls showTurn().
connect(m_game, TQ_SIGNAL(sig_update()), this, TQ_SLOT(showTurn()));
connect(m_game, TQ_SIGNAL(sig_gameOver()), this, TQ_SLOT(slotGameOver()));
// Signal that is sent when the user clicks on the board.
connect(m_gameView, TQT_SIGNAL(signalSquareClicked(int, int)),
this, TQT_SLOT(slotSquareClicked(int, int)));
connect(m_gameView, TQ_SIGNAL(signalSquareClicked(int, int)),
this, TQ_SLOT(slotSquareClicked(int, int)));
loadSettings();
@ -150,38 +150,38 @@ KReversi::~KReversi()
void KReversi::createTDEActions()
{
// Standard Game Actions.
KStdGameAction::gameNew(this, TQT_SLOT(slotNewGame()), actionCollection(),
KStdGameAction::gameNew(this, TQ_SLOT(slotNewGame()), actionCollection(),
"game_new");
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(),
KStdGameAction::load(this, TQ_SLOT(slotOpenGame()), actionCollection());
KStdGameAction::save(this, TQ_SLOT(slotSave()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
KStdGameAction::hint(this, TQ_SLOT(slotHint()), actionCollection(),
"game_hint");
KStdGameAction::undo(this, TQT_SLOT(slotUndo()), actionCollection(),
KStdGameAction::undo(this, TQ_SLOT(slotUndo()), actionCollection(),
"game_undo");
// Non-standard Game Actions: Stop, Continue, Switch sides
stopAction = new TDEAction(i18n("&Stop Thinking"), "game_stop", TQt::Key_Escape,
this, TQT_SLOT(slotInterrupt()), actionCollection(),
this, TQ_SLOT(slotInterrupt()), actionCollection(),
"game_stop");
continueAction = new TDEAction(i18n("&Continue Thinking"), "reload", 0,
this, TQT_SLOT(slotContinue()), actionCollection(),
this, TQ_SLOT(slotContinue()), actionCollection(),
"game_continue");
new TDEAction(i18n("S&witch Sides"), 0, 0,
this, TQT_SLOT(slotSwitchSides()), actionCollection(),
this, TQ_SLOT(slotSwitchSides()), actionCollection(),
"game_switch_sides");
// Some more standard game actions: Highscores, Settings.
KStdGameAction::highscores(this, TQT_SLOT(showHighScoreDialog()), actionCollection());
KStdAction::preferences(this, TQT_SLOT(slotEditSettings()), actionCollection());
KStdGameAction::highscores(this, TQ_SLOT(showHighScoreDialog()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(slotEditSettings()), actionCollection());
// Actions for the view(s).
showLastMoveAction = new TDEToggleAction(i18n("Show Last Move"), "lastmoves", 0,
this, TQT_SLOT(slotShowLastMove()),
this, TQ_SLOT(slotShowLastMove()),
actionCollection(),
"show_last_move");
showLegalMovesAction = new TDEToggleAction(i18n("Show Legal Moves"), "legalmoves", 0,
this, TQT_SLOT(slotShowLegalMoves()),
this, TQ_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()), this, TQT_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), this, TQ_SLOT(loadSettings()));
dialog->show();
}

8
kreversi/kzoommainwindow.cpp
Unescape View File

@ -34,11 +34,11 @@ KZoomMainWindow::KZoomMainWindow(uint min, uint max, uint step,
installEventFilter(this);
m_zoomInAction =
KStdAction::zoomIn(this, TQT_SLOT(zoomIn()), actionCollection());
KStdAction::zoomIn(this, TQ_SLOT(zoomIn()), actionCollection());
m_zoomOutAction =
KStdAction::zoomOut(this, TQT_SLOT(zoomOut()), actionCollection());
KStdAction::zoomOut(this, TQ_SLOT(zoomOut()), actionCollection());
m_menu =
KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
KStdAction::showMenubar(this, TQ_SLOT(toggleMenubar()), actionCollection());
}
@ -71,7 +71,7 @@ void KZoomMainWindow::addWidget(TQWidget *widget)
Q_ASSERT(zm);
zm->m_widgets.append(widget);
connect(widget, TQT_SIGNAL(destroyed()), zm, TQT_SLOT(widgetDestroyed()));
connect(widget, TQ_SIGNAL(destroyed()), zm, TQ_SLOT(widgetDestroyed()));
}

12
kreversi/qreversigameview.cpp
Unescape View File

@ -135,15 +135,15 @@ QReversiGameView::QReversiGameView(TQWidget *parent, QReversiGame *game)
m_humanColor = Nobody;
// Connect the game to the view.
connect(m_game, TQT_SIGNAL(sig_newGame()), this, TQT_SLOT(newGame()));
connect(m_game, TQT_SIGNAL(sig_move(uint, Move&)),
this, TQT_SLOT(moveMade(uint, Move&)));
connect(m_game, TQT_SIGNAL(sig_update()), this, TQT_SLOT(updateView()));
connect(m_game, TQ_SIGNAL(sig_newGame()), this, TQ_SLOT(newGame()));
connect(m_game, TQ_SIGNAL(sig_move(uint, Move&)),
this, TQ_SLOT(moveMade(uint, Move&)));
connect(m_game, TQ_SIGNAL(sig_update()), this, TQ_SLOT(updateView()));
// The sig_gameOver signal is not used by the view.
// Reemit the signal from the board.
connect(m_boardView, TQT_SIGNAL(signalSquareClicked(int, int)),
this, TQT_SLOT(squareClicked(int, int)));
connect(m_boardView, TQ_SIGNAL(signalSquareClicked(int, int)),
this, TQ_SLOT(squareClicked(int, int)));
}

28
ksame/KSameWidget.cpp
Unescape View File

@ -48,17 +48,17 @@ static int default_colors=3;
KSameWidget::KSameWidget(TQWidget *parent, const char* name, WFlags fl) :
TDEMainWindow(parent,name,fl)
{
KStdGameAction::gameNew(this, TQT_SLOT(m_new()), actionCollection(), "game_new");
KStdGameAction::gameNew(this, TQ_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(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");
TQ_SLOT(m_restart()), actionCollection(), "game_restart");
KStdGameAction::highscores(this, TQ_SLOT(m_showhs()), actionCollection(), "game_highscores");
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection(), "game_quit");
undo = KStdGameAction::undo(this, TQ_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, this, TQT_SLOT(showNumberRemainingToggled()), actionCollection(), "showNumberRemaining");
showNumberRemaining = new TDEToggleAction(i18n("&Show Number Remaining"), 0, this, TQ_SLOT(showNumberRemainingToggled()), actionCollection(), "showNumberRemaining");
KStdAction::configureNotifications(this, TQT_SLOT(configureNotifications()),
KStdAction::configureNotifications(this, TQ_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()), 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, TQ_SIGNAL(s_gameover()), this, TQ_SLOT(gameover()));
connect( stone, TQ_SIGNAL(s_colors(int)), this, TQ_SLOT(setColors(int)));
connect( stone, TQ_SIGNAL(s_board(int)), this, TQ_SLOT(setBoard(int)));
connect( stone, TQ_SIGNAL(s_marked(int)), this, TQ_SLOT(setMarked(int)));
connect( stone, TQ_SIGNAL(s_score(int)), this, TQ_SLOT(setScore(int)));
connect( stone, TQ_SIGNAL(s_remove(int,int)), this, TQ_SLOT(stonesRemoved(int,int)));
connect(stone, TQT_SIGNAL(s_sizechanged()), this, TQT_SLOT(sizeChanged()));
connect(stone, TQ_SIGNAL(s_sizechanged()), this, TQ_SLOT(sizeChanged()));
sizeChanged();
setCentralWidget(stone);

40
kshisen/app.cpp
Unescape View File

@ -89,13 +89,13 @@ App::App(TQWidget *parent, const char *name) : TDEMainWindow(parent, name),
setupGUI();
connect(board, TQT_SIGNAL(changed()), this, TQT_SLOT(enableItems()));
connect(board, TQ_SIGNAL(changed()), this, TQ_SLOT(enableItems()));
TQTimer *t = new TQTimer(this);
t->start(1000);
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()));
connect(t, TQ_SIGNAL(timeout()), this, TQ_SLOT(updateScore()));
connect(board, TQ_SIGNAL(endOfGame()), this, TQ_SLOT(slotEndOfGame()));
connect(board, TQ_SIGNAL(resized()), this, TQ_SLOT(boardResized()));
kapp->processEvents();
@ -106,25 +106,25 @@ App::App(TQWidget *parent, const char *name) : TDEMainWindow(parent, name),
void App::initTDEAction()
{
// Game
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());
KStdGameAction::gameNew(this, TQ_SLOT(newGame()), actionCollection());
KStdGameAction::restart(this, TQ_SLOT(restartGame()), actionCollection());
KStdGameAction::pause(this, TQ_SLOT(pause()), actionCollection());
KStdGameAction::highscores(this, TQ_SLOT(hallOfFame()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(quitGame()), actionCollection());
// Move
KStdGameAction::undo(this, TQT_SLOT(undo()), actionCollection());
KStdGameAction::redo(this, TQT_SLOT(redo()), actionCollection());
KStdGameAction::hint(this, TQT_SLOT(hint()), actionCollection());
KStdGameAction::undo(this, TQ_SLOT(undo()), actionCollection());
KStdGameAction::redo(this, TQ_SLOT(redo()), actionCollection());
KStdGameAction::hint(this, TQ_SLOT(hint()), actionCollection());
//new TDEAction(i18n("Is Game Solvable?"), 0, this,
// TQT_SLOT(isSolvable()), actionCollection(), "move_solvable");
// TQ_SLOT(isSolvable()), actionCollection(), "move_solvable");
#ifdef DEBUGGING
(void)new TDEAction(i18n("&Finish"), 0, board, TQT_SLOT(finish()), actionCollection(), "move_finish");
(void)new TDEAction(i18n("&Finish"), 0, board, TQ_SLOT(finish()), actionCollection(), "move_finish");
#endif
// Settings
KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(showSettings()), actionCollection());
}
void App::hallOfFame()
@ -372,8 +372,8 @@ TQString App::getPlayerName()
b->setDefault(true);
b->setFixedSize(b->sizeHint());
connect(b, TQT_SIGNAL(released()), dlg, TQT_SLOT(accept()));
connect(e, TQT_SIGNAL(returnPressed()), dlg, TQT_SLOT(accept()));
connect(b, TQ_SIGNAL(released()), dlg, TQ_SLOT(accept()));
connect(e, TQ_SIGNAL(returnPressed()), dlg, TQ_SLOT(accept()));
// create layout
TQVBoxLayout *tl = new TQVBoxLayout(dlg, 10);
@ -723,7 +723,7 @@ void App::showHighscore(int focusitem)
b->setFixedSize(b->sizeHint());
// connect the "Close"-button to done
connect(b, TQT_SIGNAL(clicked()), dlg, TQT_SLOT(accept()));
connect(b, TQ_SIGNAL(clicked()), dlg, TQ_SLOT(accept()));
b->setDefault(true);
b->setFocus();
@ -752,8 +752,8 @@ 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()), this, TQT_SLOT(loadSettings()));
connect(dialog, TQT_SIGNAL(settingsChanged()), board, TQT_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), this, TQ_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), board, TQ_SLOT(loadSettings()));
dialog->show();
}

2
kshisen/board.cpp
Unescape View File

@ -683,7 +683,7 @@ void Board::drawConnection(int timeout)
p.flush();
p.end();
TQTimer::singleShot(timeout, this, TQT_SLOT(undrawConnection()));
TQTimer::singleShot(timeout, this, TQ_SLOT(undrawConnection()));
}
void Board::undrawConnection()

2
ksmiletris/gamewidget.cpp
Unescape View File

@ -70,7 +70,7 @@ GameWidget::GameWidget(TQWidget *parent, const char *name)
next->setNextPieceSprites(next_piece);
timer = new TQTimer(this);
connect(timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(timeout()));
connect(timer, TQ_SIGNAL(timeout()), this, TQ_SLOT(timeout()));
}
GameWidget::~GameWidget()

34
ksmiletris/gamewindow.cpp
Unescape View File

@ -47,32 +47,32 @@ GameWindow::GameWindow(TQWidget *, const char *name)
{
//New Games
(void)KStdGameAction::gameNew(this,
TQT_SLOT(menu_newGame()),
TQ_SLOT(menu_newGame()),
actionCollection());
//Pause Game
(void)KStdGameAction::pause(this,
TQT_SLOT(menu_pause()),
TQ_SLOT(menu_pause()),
actionCollection());
//End Game
(void)KStdGameAction::end(this,
TQT_SLOT(menu_endGame()),
TQ_SLOT(menu_endGame()),
actionCollection());
//Highscores
(void)KStdGameAction::highscores(this,
TQT_SLOT(menu_highScores()),
TQ_SLOT(menu_highScores()),
actionCollection());
//Quit
(void)KStdGameAction::quit(this,
TQT_SLOT(close()),
TQ_SLOT(close()),
actionCollection());
TQStringList list;
TDESelectAction* piecesAct =
new TDESelectAction(i18n("&Pieces"), 0, this, TQT_SLOT(menu_pieces()),
new TDESelectAction(i18n("&Pieces"), 0, this, TQ_SLOT(menu_pieces()),
actionCollection(), "settings_pieces");
list.append(i18n("&Smiles"));
list.append(i18n("S&ymbols"));
@ -80,14 +80,14 @@ GameWindow::GameWindow(TQWidget *, const char *name)
piecesAct->setItems(list);
(void)new TDEToggleAction(i18n("&Sounds"), 0, this,
TQT_SLOT(menu_sounds()), actionCollection(), "settings_sounds");
TQ_SLOT(menu_sounds()), actionCollection(), "settings_sounds");
//connect(menu, TQT_SIGNAL(moved(menuPosition)),
// this, TQT_SLOT(movedMenu(menuPosition))); ?
//connect(menu, TQ_SIGNAL(moved(menuPosition)),
// this, TQ_SLOT(movedMenu(menuPosition))); ?
status = new KStatusBar(this);
status->insertItem(i18n("Level: 99"), 1);
@ -97,16 +97,16 @@ GameWindow::GameWindow(TQWidget *, const char *name)
game = new GameWidget(this);
setCentralWidget(game);
connect(game, TQT_SIGNAL(changedStats(int, int)),
this, TQT_SLOT(updateStats(int, int)));
connect(game, TQT_SIGNAL(gameOver()), this, TQT_SLOT(gameOver()));
connect(game, TQ_SIGNAL(changedStats(int, int)),
this, TQ_SLOT(updateStats(int, int)));
connect(game, TQ_SIGNAL(gameOver()), this, TQ_SLOT(gameOver()));
//keys
(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");
(void)new TDEAction(i18n("Move Left"), Key_Left, game, TQ_SLOT(keyLeft()), actionCollection(), "left");
(void)new TDEAction(i18n("Move Right"), Key_Right, game, TQ_SLOT(keyRight()), actionCollection(), "right");
(void)new TDEAction(i18n("Rotate Left"), Key_Up, game, TQ_SLOT(keyUp()), actionCollection(), "up");
(void)new TDEAction(i18n("Rotate Right"), Key_Down, game, TQ_SLOT(keyDown()), actionCollection(), "down");
(void)new TDEAction(i18n("Drop Down"), Key_Space, game, TQ_SLOT(keySpace()), actionCollection(), "space");
game->setFixedSize(default_width, default_height);
adjustSize();

4
ksnake/basket.cpp
Unescape View File

@ -35,7 +35,7 @@ Kaffee::Kaffee(int pos, int r1, int r2)
p = pos;
t = Red;
r = r2;
TQTimer::singleShot( r1, this, TQT_SLOT(golden()) );
TQTimer::singleShot( r1, this, TQ_SLOT(golden()) );
dirty = true;
}
@ -43,7 +43,7 @@ void Kaffee::golden()
{
dirty = true;
t = (t == Red ? Golden : Red);
TQTimer::singleShot( r, this, TQT_SLOT(golden()) );
TQTimer::singleShot( r, this, TQ_SLOT(golden()) );
}
Basket::Basket(Board *b, PixServer *p)

28
ksnake/game.cpp
Unescape View File

@ -67,14 +67,14 @@ Game::Game(TQWidget *parent, const char *name) : TDEMainWindow(parent,name)
rattler->reloadRoomPixmap();
rattler->setFocus();
connect(rattler, TQT_SIGNAL(setPoints(int)), this, TQT_SLOT(scoreChanged(int)));
connect(rattler, TQT_SIGNAL(setTrys(int)), this, TQT_SLOT(setTrys(int)));
connect(rattler, TQT_SIGNAL(rewind()), view->progress, TQT_SLOT(rewind()));
connect(rattler, TQT_SIGNAL(advance()), view->progress, TQT_SLOT(advance()));
connect(view->progress, TQT_SIGNAL(restart()), rattler, TQT_SLOT(restartTimer()));
connect(rattler, TQ_SIGNAL(setPoints(int)), this, TQ_SLOT(scoreChanged(int)));
connect(rattler, TQ_SIGNAL(setTrys(int)), this, TQ_SLOT(setTrys(int)));
connect(rattler, TQ_SIGNAL(rewind()), view->progress, TQ_SLOT(rewind()));
connect(rattler, TQ_SIGNAL(advance()), view->progress, TQ_SLOT(advance()));
connect(view->progress, TQ_SIGNAL(restart()), rattler, TQ_SLOT(restartTimer()));
connect(rattler, TQT_SIGNAL(togglePaused()), this, TQT_SLOT(togglePaused()));
connect(rattler, TQT_SIGNAL(setScore(int)), this, TQT_SLOT(gameEnd(int)));
connect(rattler, TQ_SIGNAL(togglePaused()), this, TQ_SLOT(togglePaused()));
connect(rattler, TQ_SIGNAL(setScore(int)), this, TQ_SLOT(gameEnd(int)));
setCentralWidget(view);
@ -120,16 +120,16 @@ void Game::createMenu()
actionCollection()->setAutoConnectShortcuts(true);
rattler->setActionCollection(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());
KStdGameAction::gameNew(rattler, TQ_SLOT(restart()), actionCollection());
pause = KStdGameAction::pause(rattler, TQ_SLOT(pause()), actionCollection());
KStdGameAction::highscores(this, TQ_SLOT(showHighScores()), actionCollection());
KStdGameAction::quit( this, TQ_SLOT(close()), actionCollection());
KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(showSettings()), actionCollection());
// TODO change and make custom function that pauses game or
// modify widget to pause when loosing focus and remove this
KStdAction::keyBindings(guiFactory(), TQT_SLOT(configureShortcuts()),
KStdAction::keyBindings(guiFactory(), TQ_SLOT(configureShortcuts()),
actionCollection());
}
@ -173,7 +173,7 @@ void Game::showSettings(){
dialog->addPage(a, i18n("Appearance"), "style");
dialog->addPage(new StartRoom(0, "StartRoom"), i18n("First Level"), "folder_home");
connect(dialog, TQT_SIGNAL(settingsChanged()), rattler, TQT_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), rattler, TQ_SLOT(loadSettings()));
dialog->show();
}

40
ksnake/rattler.cpp
Unescape View File

@ -67,16 +67,16 @@ Rattler::Rattler( TQWidget *parent, const char *name )
balls = new TQPtrList<Ball>;
balls->setAutoDelete( true );
connect( samy, TQT_SIGNAL(closeGate(int)), this, TQT_SLOT(closeGate(int)));
connect( samy, TQT_SIGNAL(score(bool, int)), this, TQT_SLOT(scoring(bool,int)));
connect( samy, TQT_SIGNAL(goingOut()), this, TQT_SLOT(speedUp()));
connect( basket, TQT_SIGNAL(openGate()), this, TQT_SLOT(openGate()));
connect( samy, TQ_SIGNAL(closeGate(int)), this, TQ_SLOT(closeGate(int)));
connect( samy, TQ_SIGNAL(score(bool, int)), this, TQ_SLOT(scoring(bool,int)));
connect( samy, TQ_SIGNAL(goingOut()), this, TQ_SLOT(speedUp()));
connect( basket, TQ_SIGNAL(openGate()), this, TQ_SLOT(openGate()));
gameState.fill(false);
gameState.setBit(Demo);
timerCount = 0;
TQTimer::singleShot( 2000, this, TQT_SLOT(demo()) ); // Why wait?
TQTimer::singleShot( 2000, this, TQ_SLOT(demo()) ); // Why wait?
backgroundPixmaps =
TDEGlobal::dirs()->findAllResources("appdata", "backgrounds/*.png");
@ -345,7 +345,7 @@ void Rattler::restartDemo()
return;
int r = 50000+ (kapp->random() % 30000);
TQTimer::singleShot( r, this, TQT_SLOT(restartDemo()) );
TQTimer::singleShot( r, this, TQ_SLOT(restartDemo()) );
stop();
level->create(Intro);
@ -364,7 +364,7 @@ void Rattler::demo()
stop();
TQTimer::singleShot( 60000, this, TQT_SLOT(restartDemo()) );
TQTimer::singleShot( 60000, this, TQ_SLOT(restartDemo()) );
gameState.fill(false);
gameState.setBit(Init);
gameState.setBit(Demo);
@ -414,7 +414,7 @@ void Rattler::restart()
cleanLabel();
repaint();
TQTimer::singleShot( 2000, this, TQT_SLOT(showRoom()) );
TQTimer::singleShot( 2000, this, TQ_SLOT(showRoom()) );
}
void Rattler::newTry()
@ -427,7 +427,7 @@ void Rattler::newTry()
level->create(GameOver);
pix->initRoomPixmap();
repaint();
TQTimer::singleShot( 5000, this, TQT_SLOT(demo()) );
TQTimer::singleShot( 5000, this, TQ_SLOT(demo()) );
emit setScore(points);
return;
}
@ -440,7 +440,7 @@ void Rattler::newTry()
pix->initRoomPixmap();
init(true);
repaint();
TQTimer::singleShot( 1000, this, TQT_SLOT(run()) );
TQTimer::singleShot( 1000, this, TQ_SLOT(run()) );
}
void Rattler::levelUp()
@ -458,7 +458,7 @@ void Rattler::levelUp()
pix->initRoomPixmap();
repaint();
TQTimer::singleShot( 2000, this, TQT_SLOT(showRoom()) );
TQTimer::singleShot( 2000, this, TQ_SLOT(showRoom()) );
}
/* this slot is called by the progressBar when value() == 0
@ -494,7 +494,7 @@ void Rattler::showRoom()
pix->initRoomPixmap();
init(true);
repaint();
TQTimer::singleShot( 1000, this, TQT_SLOT(run()) );
TQTimer::singleShot( 1000, this, TQ_SLOT(run()) );
}
void Rattler::init(bool play)
@ -557,10 +557,10 @@ void Rattler::restartComputerSnakes(bool play)
as = new KillerCompuSnake(board, pix);
break;
}
connect( as, TQT_SIGNAL(closeGate(int)), this, TQT_SLOT(closeGate(int)));
connect( as, TQT_SIGNAL(restartTimer()), this, TQT_SLOT(restartTimer()));
connect( as, TQT_SIGNAL(score(bool, int)), this, TQT_SLOT(scoring(bool,int)));
connect( as, TQT_SIGNAL(killed()), this, TQT_SLOT(killedComputerSnake()));
connect( as, TQ_SIGNAL(closeGate(int)), this, TQ_SLOT(closeGate(int)));
connect( as, TQ_SIGNAL(restartTimer()), this, TQ_SLOT(restartTimer()));
connect( as, TQ_SIGNAL(score(bool, int)), this, TQ_SLOT(scoring(bool,int)));
connect( as, TQ_SIGNAL(killed()), this, TQ_SLOT(killedComputerSnake()));
computerSnakes->append(as);
}
}
@ -643,10 +643,10 @@ void Rattler::setCompuSnakes(int i)
as = new KillerCompuSnake(board, pix);
break;
}
connect( as, TQT_SIGNAL(closeGate(int)), this, TQT_SLOT(closeGate(int)));
connect( as, TQT_SIGNAL(restartTimer()), this, TQT_SLOT(restartTimer()));
connect( as, TQT_SIGNAL(score(bool, int)), this, TQT_SLOT(scoring(bool,int)));
connect( as, TQT_SIGNAL(killed()), this, TQT_SLOT(killedComputerSnake()));
connect( as, TQ_SIGNAL(closeGate(int)), this, TQ_SLOT(closeGate(int)));
connect( as, TQ_SIGNAL(restartTimer()), this, TQ_SLOT(restartTimer()));
connect( as, TQ_SIGNAL(score(bool, int)), this, TQ_SLOT(scoring(bool,int)));
connect( as, TQ_SIGNAL(killed()), this, TQ_SLOT(killedComputerSnake()));
computerSnakes->append(as);
i--;
}

2
ksnake/startroom.cpp
Unescape View File

@ -61,7 +61,7 @@ StartRoom::StartRoom( TQWidget *parent, const char *name)
textLabel->setText(i18n("First level:"));
Form1Layout->addWidget( textLabel, 1, 0 );
connect( roomRange, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(loadLevel(int)));
connect( roomRange, TQ_SIGNAL(valueChanged(int)), TQ_SLOT(loadLevel(int)));
loadLevel(1);
}

26
ksokoban/MainWindow.cpp
Unescape View File

@ -49,8 +49,8 @@ void
MainWindow::createCollectionMenu() {
collection_ = new TQPopupMenu(0,"collection menu");
collection_->setCheckable(true);
//connect(collection_, TQT_SIGNAL(activated(int)), playField_, TQT_SLOT(changeCollection(int)));
connect(collection_, TQT_SIGNAL(activated(int)), this, TQT_SLOT(changeCollection(int)));
//connect(collection_, TQ_SIGNAL(activated(int)), playField_, TQ_SLOT(changeCollection(int)));
connect(collection_, TQ_SIGNAL(activated(int)), this, TQ_SLOT(changeCollection(int)));
for (int i=0; i<internalCollections_.collections(); i++) {
collection_->insertItem(internalCollections_[i]->name(), i);
@ -90,30 +90,30 @@ MainWindow::MainWindow() : TDEMainWindow(0), externalCollection_(0) {
game_ = new TQPopupMenu(0,"game menu");
pixmap = SmallIcon("document-open");
game_->insertItem(TQIconSet(pixmap), i18n("&Load Levels..."), this, TQT_SLOT(loadLevels()));
game_->insertItem(TQIconSet(pixmap), i18n("&Load Levels..."), this, TQ_SLOT(loadLevels()));
pixmap = SmallIcon("forward");
game_->insertItem(TQIconSet(pixmap), i18n("&Next Level"), playField_, TQT_SLOT(nextLevel()), Key_N);
game_->insertItem(TQIconSet(pixmap), i18n("&Next Level"), playField_, TQ_SLOT(nextLevel()), Key_N);
pixmap = SmallIcon("back");
game_->insertItem(TQIconSet(pixmap), i18n("&Previous Level"), playField_, TQT_SLOT(previousLevel()), Key_P);
game_->insertItem(TQIconSet(pixmap), i18n("&Previous Level"), playField_, TQ_SLOT(previousLevel()), Key_P);
pixmap = SmallIcon("reload");
game_->insertItem(TQIconSet(pixmap), i18n("Re&start Level"), playField_, TQT_SLOT(restartLevel()), Key_Escape);
game_->insertItem(TQIconSet(pixmap), i18n("Re&start Level"), playField_, TQ_SLOT(restartLevel()), Key_Escape);
createCollectionMenu();
game_->insertItem(i18n("&Level Collection"), collection_);
pixmap = SmallIcon("edit-undo");
game_->insertItem(TQIconSet(pixmap), i18n("&Undo"), playField_, TQT_SLOT(undo()),TQKeySequence( (TDEStdAccel::undo()).toString()));
game_->insertItem(TQIconSet(pixmap), i18n("&Undo"), playField_, TQ_SLOT(undo()),TQKeySequence( (TDEStdAccel::undo()).toString()));
pixmap = SmallIcon("edit-redo");
game_->insertItem(TQIconSet(pixmap), i18n("&Redo"), playField_, TQT_SLOT(redo()), TQKeySequence( (TDEStdAccel::redo()).toString()));
game_->insertItem(TQIconSet(pixmap), i18n("&Redo"), playField_, TQ_SLOT(redo()), TQKeySequence( (TDEStdAccel::redo()).toString()));
game_->insertSeparator();
pixmap = SmallIcon("system-log-out");
game_->insertItem(TQIconSet(pixmap), i18n("&Quit"), TDEApplication::kApplication(), TQT_SLOT(closeAllWindows()), TQKeySequence( (TDEStdAccel::quit()).toString()));
game_->insertItem(TQIconSet(pixmap), i18n("&Quit"), TDEApplication::kApplication(), TQ_SLOT(closeAllWindows()), TQKeySequence( (TDEStdAccel::quit()).toString()));
menu_->insertItem(i18n("&Game"), game_);
animation_ = new TQPopupMenu(0,"animation menu");
animation_->setCheckable(true);
connect(animation_, TQT_SIGNAL(activated(int)), this, TQT_SLOT(updateAnimMenu(int)));
connect(animation_, TQT_SIGNAL(activated(int)), playField_, TQT_SLOT(changeAnim(int)));
connect(animation_, TQ_SIGNAL(activated(int)), this, TQ_SLOT(updateAnimMenu(int)));
connect(animation_, TQ_SIGNAL(activated(int)), playField_, TQ_SLOT(changeAnim(int)));
animation_->insertItem(i18n("&Slow"), 3);
animation_->insertItem(i18n("&Medium"), 2);
animation_->insertItem(i18n("&Fast"), 1);
@ -145,7 +145,7 @@ MainWindow::MainWindow() : TDEMainWindow(0), externalCollection_(0) {
setBM_->setAccel(CTRL+Key_9, 9);
setBM_->insertItem(TQIconSet(pixmap), i18n("(unused)"), 10);
setBM_->setAccel(CTRL+Key_0, 10);
connect(setBM_, TQT_SIGNAL(activated(int)), this, TQT_SLOT(setBookmark(int)));
connect(setBM_, TQ_SIGNAL(activated(int)), this, TQ_SLOT(setBookmark(int)));
bookmarkMenu_->insertItem(i18n("&Set Bookmark"), setBM_);
pixmap = SmallIcon("bookmark");
@ -170,7 +170,7 @@ MainWindow::MainWindow() : TDEMainWindow(0), externalCollection_(0) {
goToBM_->setAccel(Key_9, 9);
goToBM_->insertItem(TQIconSet(pixmap), i18n("(unused)"), 10);
goToBM_->setAccel(Key_0, 10);
connect(goToBM_, TQT_SIGNAL(activated(int)), this, TQT_SLOT(goToBookmark(int)));
connect(goToBM_, TQ_SIGNAL(activated(int)), this, TQ_SLOT(goToBookmark(int)));
bookmarkMenu_->insertItem(i18n("&Go to Bookmark"), goToBM_);
menu_->insertItem(i18n("&Bookmarks"), bookmarkMenu_);

2
ksokoban/main.cpp
Unescape View File

@ -76,7 +76,7 @@ main (int argc, char **argv)
}
args->clear();
TQObject::connect(&app, TQT_SIGNAL(lastWindowClosed()), &app, TQT_SLOT(quit()));
TQObject::connect(&app, TQ_SIGNAL(lastWindowClosed()), &app, TQ_SLOT(quit()));
int rc = app.exec();

6
kspaceduel/dialogs.cpp
Unescape View File

@ -146,13 +146,13 @@ ConfigSetup::ConfigSetup(SConfig *custom,TQWidget *parent,const char *name)
(EditVal[i][1]-EditVal[i][0])/10,
EditVal[i][2]*EditDiv[i],
TQt::Horizontal,configWidgets[Parent[i]]);
connect(slider[i],TQT_SIGNAL(valueChanged(int)),TQT_SLOT(sliderChanged(int)));
connect(slider[i],TQ_SIGNAL(valueChanged(int)),TQ_SLOT(sliderChanged(int)));
value[i]=new TQLCDNumber(LCDLen,configWidgets[Parent[i]]);
value[i]->setFrameStyle(TQFrame::NoFrame);
}
configCombo=new TQComboBox(false,this);
connect(configCombo,TQT_SIGNAL(activated(int)),TQT_SLOT(configSelected(int)));
connect(configCombo,TQ_SIGNAL(activated(int)),TQ_SLOT(configSelected(int)));
for(i=0;i<predefinedConfigNum;i++)
configCombo->insertItem(i18n(predefinedConfigName[i]));
configCombo->insertItem(i18n("Custom"));
@ -396,7 +396,7 @@ SettingsDialog::SettingsDialog(SConfig *customConfig, TQWidget *parent, const ch
cs = new ConfigSetup(customConfig);
addPage(cs, i18n("Game"), "kspaceduel", i18n("Game Settings"));
connect(cs, TQT_SIGNAL(changed()), this, TQT_SLOT(updateButtons()));
connect(cs, TQ_SIGNAL(changed()), this, TQ_SLOT(updateButtons()));
// resize(600,400);
}

2
kspaceduel/mainview.cpp
Unescape View File

@ -990,7 +990,7 @@ void MyMainView::gameSetup()
return;
SettingsDialog *settings=new SettingsDialog(&customConfig,this,"settings");
connect(settings, TQT_SIGNAL(settingsUpdated()),this,TQT_SLOT(closeSettings()));
connect(settings, TQ_SIGNAL(settingsUpdated()),this,TQ_SLOT(closeSettings()));
settings->show();
}

26
kspaceduel/topwidget.cpp
Unescape View File

@ -34,13 +34,13 @@ void MyTopLevelWidget::initGameWidgets( ){
playfield->setFocusPolicy(TQWidget::StrongFocus);
playfield->setFocus();
TQObject::connect(playfield,TQT_SIGNAL(energy(int,int)),
TQT_SLOT(energy(int,int)));
TQObject::connect(playfield,TQT_SIGNAL(hitPoints(int,int)),
TQT_SLOT(hitPoints(int,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)));
TQObject::connect(playfield,TQ_SIGNAL(energy(int,int)),
TQ_SLOT(energy(int,int)));
TQObject::connect(playfield,TQ_SIGNAL(hitPoints(int,int)),
TQ_SLOT(hitPoints(int,int)));
TQObject::connect(playfield,TQ_SIGNAL(wins(int,int)),TQ_SLOT(wins(int,int)));
TQObject::connect(playfield,TQ_SIGNAL(setStatusText(const TQString &,int)),
TQ_SLOT(setStatusText(const TQString &,int)));
setCentralWidget(w);
}
@ -62,18 +62,18 @@ void MyTopLevelWidget::wins(int pn,int w)
void MyTopLevelWidget::initActions( )
{
KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection());
KStdGameAction::gameNew(playfield, TQT_SLOT(newGame()), actionCollection());
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection());
KStdGameAction::gameNew(playfield, TQ_SLOT(newGame()), actionCollection());
( void )new TDEAction( i18n( "&New Round" ), "spnewround",
CTRL + Key_R, playfield, TQT_SLOT( newRound( ) ),
CTRL + Key_R, playfield, TQ_SLOT( newRound( ) ),
actionCollection( ), "new_round" );
MyMainView::pauseAction =
KStdGameAction::pause(playfield, TQT_SLOT(togglePause()), actionCollection());
KStdGameAction::pause(playfield, TQ_SLOT(togglePause()), actionCollection());
MyMainView::pauseAction->setChecked( false );
TDEAction* gameStart = new TDEAction( i18n( "Start" ), GAME_START_SHORTCUT,
playfield, TQT_SLOT( start( ) ), actionCollection( ), "game_start" );
playfield, TQ_SLOT( start( ) ), actionCollection( ), "game_start" );
KStdAction::preferences(playfield, TQT_SLOT(gameSetup()), actionCollection());
KStdAction::preferences(playfield, TQ_SLOT(gameSetup()), actionCollection());
TDEAccel* acc = new TDEAccel(this);
gameStart->plugAccel(acc);

14
ktron/ktron.cpp
Unescape View File

@ -46,7 +46,7 @@ KTron::KTron(TQWidget *parent, const char *name) : TDEMainWindow(parent, name) {
playerPoints[0]=playerPoints[1]=0;
tron=new Tron(this, "Tron");
connect(tron,TQT_SIGNAL(gameEnds(Player)),TQT_SLOT(changeStatus(Player)));
connect(tron,TQ_SIGNAL(gameEnds(Player)),TQ_SLOT(changeStatus(Player)));
setCentralWidget(tron);
tron->setMinimumSize(200,180);
@ -81,10 +81,10 @@ KTron::KTron(TQWidget *parent, const char *name) : TDEMainWindow(parent, name) {
tron->setActionCollection(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());
KStdGameAction::pause(tron, TQ_SLOT(togglePause()), actionCollection());
KStdGameAction::gameNew( tron, TQ_SLOT( newGame() ), actionCollection() );
KStdGameAction::quit(this, TQ_SLOT( close() ), actionCollection());
KStdAction::preferences(this, TQ_SLOT(showSettings()), actionCollection());
setupGUI( TDEMainWindow::Keys | StatusBar | Save | Create);
loadSettings();
@ -186,8 +186,8 @@ void KTron::showSettings(){
dialog->addPage(new General(0, "General"), i18n("General"), "package_settings");
dialog->addPage(new Ai(0, "Ai"), i18n("A.I."), "preferences-desktop-personal");
dialog->addPage(new Appearance(0, "Appearance"), i18n("Appearance"), "style");
connect(dialog, TQT_SIGNAL(settingsChanged()), tron, TQT_SLOT(loadSettings()));
connect(dialog, TQT_SIGNAL(settingsChanged()), this, TQT_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), tron, TQ_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), this, TQ_SLOT(loadSettings()));
dialog->show();
}

14
ktron/tron.cpp
Unescape View File

@ -59,8 +59,8 @@ Tron::Tron(TQWidget *parent,const char *name)
timer = new TQTimer(this,"timer");
loadSettings();
connect(timer, TQT_SIGNAL(timeout()), TQT_SLOT(doMove()));
TQTimer::singleShot(15000, this,TQT_SLOT(showBeginHint()));
connect(timer, TQ_SIGNAL(timeout()), TQ_SLOT(doMove()));
TQTimer::singleShot(15000, this,TQ_SLOT(showBeginHint()));
}
void Tron::loadSettings(){
@ -150,7 +150,7 @@ void Tron::newGame()
emit gameEnds(Nobody);
reset();
TQTimer::singleShot(15000,this,TQT_SLOT(showBeginHint()));
TQTimer::singleShot(15000,this,TQ_SLOT(showBeginHint()));
}
void Tron::reset()
@ -274,7 +274,7 @@ void Tron::showWinner(Player player)
if(isComputer(Both))
{
TQTimer::singleShot(1000,this,TQT_SLOT(computerStart()));
TQTimer::singleShot(1000,this,TQ_SLOT(computerStart()));
}
}
@ -453,7 +453,7 @@ void Tron::setComputerplayer(Player player, bool flag) {
players[1].setComputer(flag);
if(isComputer(Both))
TQTimer::singleShot(1000,this,TQT_SLOT(computerStart()));
TQTimer::singleShot(1000,this,TQ_SLOT(computerStart()));
}
bool Tron::isComputer(Player player)
@ -939,7 +939,7 @@ void Tron::doMove()
{
//this is for waiting 0,5s before starting next game
gameBlocked=true;
TQTimer::singleShot(1000,this,TQT_SLOT(unblockGame()));
TQTimer::singleShot(1000,this,TQ_SLOT(unblockGame()));
return;
}
}
@ -1056,7 +1056,7 @@ void Tron::doMove()
{
//this is for waiting 1s before starting next game
gameBlocked=true;
TQTimer::singleShot(1000,this,TQT_SLOT(unblockGame()));
TQTimer::singleShot(1000,this,TQ_SLOT(unblockGame()));
}
}

68
ktuberling/toplevel.cpp
Unescape View File

@ -61,21 +61,21 @@ void TopLevel::registerGameboard(const TQString &menuItem, const char *actionId)
switch (gameboards)
{
case 0: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard0()), actionCollection(), actionId);
case 0: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(gameboard0()), actionCollection(), actionId);
break;
case 1: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard1()), actionCollection(), actionId);
case 1: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(gameboard1()), actionCollection(), actionId);
break;
case 2: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard2()), actionCollection(), actionId);
case 2: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(gameboard2()), actionCollection(), actionId);
break;
case 3: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard3()), actionCollection(), actionId);
case 3: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(gameboard3()), actionCollection(), actionId);
break;
case 4: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard4()), actionCollection(), actionId);
case 4: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(gameboard4()), actionCollection(), actionId);
break;
case 5: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard5()), actionCollection(), actionId);
case 5: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(gameboard5()), actionCollection(), actionId);
break;
case 6: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard6()), actionCollection(), actionId);
case 6: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(gameboard6()), actionCollection(), actionId);
break;
case 7: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(gameboard7()), actionCollection(), actionId);
case 7: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_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, this, TQT_SLOT(language0()), actionCollection(), actionId);
case 0: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language0()), actionCollection(), actionId);
break;
case 1: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language1()), actionCollection(), actionId);
case 1: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language1()), actionCollection(), actionId);
break;
case 2: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language2()), actionCollection(), actionId);
case 2: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language2()), actionCollection(), actionId);
break;
case 3: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language3()), actionCollection(), actionId);
case 3: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language3()), actionCollection(), actionId);
break;
case 4: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language4()), actionCollection(), actionId);
case 4: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language4()), actionCollection(), actionId);
break;
case 5: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language5()), actionCollection(), actionId);
case 5: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language5()), actionCollection(), actionId);
break;
case 6: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language6()), actionCollection(), actionId);
case 6: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language6()), actionCollection(), actionId);
break;
case 7: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language7()), actionCollection(), actionId);
case 7: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language7()), actionCollection(), actionId);
break;
case 8: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language8()), actionCollection(), actionId);
case 8: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language8()), actionCollection(), actionId);
break;
case 9: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language9()), actionCollection(), actionId);
case 9: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language9()), actionCollection(), actionId);
break;
case 10: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language10()), actionCollection(), actionId);
case 10: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language10()), actionCollection(), actionId);
break;
case 11: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language11()), actionCollection(), actionId);
case 11: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language11()), actionCollection(), actionId);
break;
case 12: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language12()), actionCollection(), actionId);
case 12: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language12()), actionCollection(), actionId);
break;
case 13: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language13()), actionCollection(), actionId);
case 13: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language13()), actionCollection(), actionId);
break;
case 14: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language14()), actionCollection(), actionId);
case 14: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language14()), actionCollection(), actionId);
break;
case 15: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQT_SLOT(language15()), actionCollection(), actionId);
case 15: t = new TDEToggleAction(i18n(menuItem.latin1()), 0, this, TQ_SLOT(language15()), actionCollection(), actionId);
break;
}
@ -254,22 +254,22 @@ void TopLevel::writeOptions()
void TopLevel::setupTDEAction()
{
//Game
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");
KStdGameAction::gameNew(this, TQ_SLOT(fileNew()), actionCollection());
KStdGameAction::load(this, TQ_SLOT(fileOpen()), actionCollection());
KStdGameAction::save(this, TQ_SLOT(fileSave()), actionCollection());
KStdGameAction::print(this, TQ_SLOT(filePrint()), actionCollection());
KStdGameAction::quit(kapp, TQ_SLOT(quit()), actionCollection());
(void) new TDEAction(i18n("Save &as Picture..."), 0, this, TQ_SLOT(filePicture()), actionCollection(), "game_save_picture");
//Edit
KStdAction::copy(this, TQT_SLOT(editCopy()), actionCollection());
KStdAction::undo(this, TQT_SLOT(editUndo()), actionCollection());
KStdAction::redo(this, TQT_SLOT(editRedo()), actionCollection());
KStdAction::copy(this, TQ_SLOT(editCopy()), actionCollection());
KStdAction::undo(this, TQ_SLOT(editUndo()), actionCollection());
KStdAction::redo(this, TQ_SLOT(editRedo()), actionCollection());
enableUndo(false);
enableRedo(false);
//Speech
TDEToggleAction* t = new TDEToggleAction(i18n("&No Sound"), 0, this, TQT_SLOT(soundOff()), actionCollection(), "speech_no_sound");
TDEToggleAction* t = new TDEToggleAction(i18n("&No Sound"), 0, this, TQ_SLOT(soundOff()), actionCollection(), "speech_no_sound");
if (!soundEnabled) t->setChecked(true);
setupGUI();

2
libksirtet/base/board.cpp
Unescape View File

@ -54,7 +54,7 @@ BaseBoard::BaseBoard(bool graphic, TQWidget *parent)
_next = new BlockInfo(*sequences);
setBlockInfo(main, _next);
connect(&timer, TQT_SIGNAL(timeout()), TQT_SLOT(timeout()));
connect(&timer, TQ_SIGNAL(timeout()), TQ_SLOT(timeout()));
Piece::info().loadColors();
KZoomMainWindow::addWidget(this);

6
libksirtet/base/field.cpp
Unescape View File

@ -90,9 +90,9 @@ void BaseField::setMessage(const TQString &label, ButtonType type)
if ( type!=NoButton ) {
_button = new TQPushButton(i18n(BUTTON_TEXTS[type]), board);
_button->setFocus();
const char *slot = (type==ResumeButton ? TQT_SLOT(pause())
: TQT_SLOT(start()));
_button->connect(_button, TQT_SIGNAL(clicked()),
const char *slot = (type==ResumeButton ? TQ_SLOT(pause())
: TQ_SLOT(start()));
_button->connect(_button, TQ_SIGNAL(clicked()),
_widget->parent(), slot);
_boardLayout->addWidget(_button, 0, TQt::AlignCenter);
_button->show();

8
libksirtet/base/kzoommainwindow.cpp
Unescape View File

@ -30,11 +30,11 @@ KZoomMainWindow::KZoomMainWindow(uint min, uint max, uint step, const char *name
{
installEventFilter(this);
_zoomInAction = KStdAction::zoomIn(this, TQT_SLOT(zoomIn()), actionCollection());
_zoomInAction = KStdAction::zoomIn(this, TQ_SLOT(zoomIn()), actionCollection());
_zoomOutAction =
KStdAction::zoomOut(this, TQT_SLOT(zoomOut()), actionCollection());
KStdAction::zoomOut(this, TQ_SLOT(zoomOut()), actionCollection());
_menu =
KStdAction::showMenubar(this, TQT_SLOT(toggleMenubar()), actionCollection());
KStdAction::showMenubar(this, TQ_SLOT(toggleMenubar()), actionCollection());
}
void KZoomMainWindow::init(const char *popupName)
@ -63,7 +63,7 @@ void KZoomMainWindow::addWidget(TQWidget *widget)
static_cast<KZoomMainWindow *>(tlw->tqt_cast("KZoomMainWindow"));
Q_ASSERT(zm);
zm->_widgets.append(widget);
connect(widget, TQT_SIGNAL(destroyed()), zm, TQT_SLOT(widgetDestroyed()));
connect(widget, TQ_SIGNAL(destroyed()), zm, TQ_SLOT(widgetDestroyed()));
}
void KZoomMainWindow::widgetDestroyed()

18
libksirtet/base/main.cpp
Unescape View File

@ -24,20 +24,20 @@ BaseMainWindow::BaseMainWindow()
KNotifyClient::startDaemon();
// File & Popup
KStdGameAction::gameNew(this, TQT_SLOT(start()), actionCollection());
_pause = KStdGameAction::pause(this, TQT_SLOT(pause()), actionCollection());
KStdGameAction::gameNew(this, TQ_SLOT(start()), actionCollection());
_pause = KStdGameAction::pause(this, TQ_SLOT(pause()), actionCollection());
_pause->setEnabled(false);
KStdGameAction::highscores(this, TQT_SLOT(showHighscores()),
KStdGameAction::highscores(this, TQ_SLOT(showHighscores()),
actionCollection());
KStdGameAction::quit(tqApp, TQT_SLOT(quit()), actionCollection());
KStdGameAction::quit(tqApp, TQ_SLOT(quit()), actionCollection());
// Settings
KStdAction::preferences(this, TQT_SLOT(configureSettings()),
KStdAction::preferences(this, TQ_SLOT(configureSettings()),
actionCollection());
KStdAction::keyBindings(this, TQT_SLOT(configureKeys()), actionCollection());
KStdAction::configureNotifications(this, TQT_SLOT(configureNotifications()),
KStdAction::keyBindings(this, TQ_SLOT(configureKeys()), actionCollection());
KStdAction::configureNotifications(this, TQ_SLOT(configureNotifications()),
actionCollection());
KStdGameAction::configureHighscores(this, TQT_SLOT(configureHighscores()),
KStdGameAction::configureHighscores(this, TQ_SLOT(configureHighscores()),
actionCollection());
_inter = bfactory->createInterface(this);
@ -89,7 +89,7 @@ void BaseMainWindow::configureSettings()
if (w) dialog->addPage(w, i18n("Colors"), "colorize");
// dialog->addPage(new BackgroundConfigWidget, i18n("Background"), "background");
addConfig(dialog);
connect(dialog, TQT_SIGNAL(settingsChanged()), TQT_SIGNAL(settingsChanged()));
connect(dialog, TQ_SIGNAL(settingsChanged()), TQ_SIGNAL(settingsChanged()));
dialog->show();
}

2
libksirtet/common/ai.cpp
Unescape View File

@ -89,7 +89,7 @@ AI::AI(uint tTime, uint oTime, const Data *DATA)
: timer(this), thinkTime(tTime), orderTime(oTime), stopped(false),
board(0)
{
connect(&timer, TQT_SIGNAL(timeout()), TQT_SLOT(timeout()));
connect(&timer, TQ_SIGNAL(timeout()), TQ_SLOT(timeout()));
for (uint i=0; DATA[i].name; i++) {
Element element;

6
libksirtet/common/field.cpp
Unescape View File

@ -85,9 +85,9 @@ Field::Field(TQWidget *parent)
vbl->addWidget(showNext, 0);
vbl->addStretch(4);
connect(board, TQT_SIGNAL(scoreUpdated()), TQT_SLOT(scoreUpdatedSlot()));
connect(board, TQT_SIGNAL(levelUpdated()), TQT_SLOT(levelUpdated()));
connect(board, TQT_SIGNAL(removedUpdated()), TQT_SLOT(removedUpdated()));
connect(board, TQ_SIGNAL(scoreUpdated()), TQ_SLOT(scoreUpdatedSlot()));
connect(board, TQ_SIGNAL(levelUpdated()), TQ_SLOT(levelUpdated()));
connect(board, TQ_SIGNAL(removedUpdated()), TQ_SLOT(removedUpdated()));
initVariableGUI();
}

20
libksirtet/common/inter.cpp
Unescape View File

@ -12,17 +12,17 @@
const ActionData Interface::ACTION_DATA[Nb_Actions] = {
{ I18N_NOOP("Move Left"), "move left", TQT_SLOT(moveLeft()), 0 },
{ I18N_NOOP("Move Right"), "move right", TQT_SLOT(moveRight()), 0 },
{ I18N_NOOP("Drop Down"), "drop down", TQT_SLOT(dropDownStart()),
TQT_SLOT(dropDownStop()) },
{ I18N_NOOP("One Line Down"), "one line down", TQT_SLOT(oneLineDown()), 0 },
{ I18N_NOOP("Rotate Left"), "rotate left", TQT_SLOT(rotateLeft()), 0 },
{ I18N_NOOP("Rotate Right"), "rotate right", TQT_SLOT(rotateRight()), 0 },
{ I18N_NOOP("Move Left"), "move left", TQ_SLOT(moveLeft()), 0 },
{ I18N_NOOP("Move Right"), "move right", TQ_SLOT(moveRight()), 0 },
{ I18N_NOOP("Drop Down"), "drop down", TQ_SLOT(dropDownStart()),
TQ_SLOT(dropDownStop()) },
{ I18N_NOOP("One Line Down"), "one line down", TQ_SLOT(oneLineDown()), 0 },
{ I18N_NOOP("Rotate Left"), "rotate left", TQ_SLOT(rotateLeft()), 0 },
{ I18N_NOOP("Rotate Right"), "rotate right", TQ_SLOT(rotateRight()), 0 },
{ I18N_NOOP("Move to Left Column"), "move left total",
TQT_SLOT(moveLeftTotal()), 0 },
TQ_SLOT(moveLeftTotal()), 0 },
{ I18N_NOOP("Move to Right Column"), "move right total",
TQT_SLOT(moveRightTotal()), 0 }
TQ_SLOT(moveRightTotal()), 0 }
};
const int Interface::KEYCODE_ONE[Nb_Actions] = {
@ -45,7 +45,7 @@ MPBoard *Interface::newBoard(uint i)
{
Field *f = static_cast<Field *>(cfactory->createField(this));
f->settingsChanged();
connect(this, TQT_SIGNAL(settingsChanged()), f, TQT_SLOT(settingsChanged()));
connect(this, TQ_SIGNAL(settingsChanged()), f, TQ_SLOT(settingsChanged()));
if ( i==0 ) _firstField = f;
return f;
}

14
libksirtet/common/main.cpp
Unescape View File

@ -25,22 +25,22 @@ 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, inter, TQT_SLOT(normalGame()),
(void)new TDEAction(s, 0, inter, TQ_SLOT(normalGame()),
actionCollection(), "mp_single_human");
if (ama) (void)new TDEAction(i18n("&Single Human (Arcade)"), 0,
inter, TQT_SLOT(arcadeGame()),
inter, TQ_SLOT(arcadeGame()),
actionCollection(), "mp_arcade");
(void)new TDEAction(i18n("Human vs &Human"), 0, inter, TQT_SLOT(humanVsHuman()),
(void)new TDEAction(i18n("Human vs &Human"), 0, inter, TQ_SLOT(humanVsHuman()),
actionCollection(), "mp_human_vs_human");
(void)new TDEAction(i18n("Human vs &Computer"), 0,
inter, TQT_SLOT(humanVsComputer()),
inter, TQ_SLOT(humanVsComputer()),
actionCollection(), "mp_human_vs_computer");
(void)new TDEAction(i18n("&More..."), 0, inter, TQT_SLOT(dialog()),
(void)new TDEAction(i18n("&More..."), 0, inter, TQ_SLOT(dialog()),
actionCollection(), "mp_more");
buildGUI(inter);
connect(this, TQT_SIGNAL(settingsChanged()),
inter, TQT_SLOT(settingsChangedSlot()));
connect(this, TQ_SIGNAL(settingsChanged()),
inter, TQ_SLOT(settingsChangedSlot()));
}
void MainWindow::addKeys(KKeyDialog &d)

4
libksirtet/common/misc_ui.cpp
Unescape View File

@ -38,7 +38,7 @@ Shadow::Shadow(BaseBoard *board, TQWidget *parent)
_board(board), _show(false)
{
KZoomMainWindow::addWidget(this);
connect(board, TQT_SIGNAL(updatePieceConfigSignal()), TQT_SLOT(update()));
connect(board, TQ_SIGNAL(updatePieceConfigSignal()), TQ_SLOT(update()));
}
TQSize Shadow::sizeHint() const
@ -130,7 +130,7 @@ void GiftPool::put(uint n)
if ( n==0 ) return;
if ( nb==0 && !ready )
TQTimer::singleShot(cfactory->cbi.giftPoolTimeout,
this, TQT_SLOT(timeout()));
this, TQ_SLOT(timeout()));
uint e = TQMIN(nb+n, leds.size());
for (uint i=nb; i<e; i++) leds[i]->on();
uint f = TQMIN(nb+n-e, leds.size());

12
libksirtet/lib/internal.cpp
Unescape View File

@ -76,8 +76,8 @@ Network::Network(MPInterface *_interface,
for (; it.current(); ++it) {
rd.socket = it.current()->socket;
rd.socket->notifier()->setEnabled(TRUE);
connect(rd.socket->notifier(), TQT_SIGNAL(activated(int)),
TQT_SLOT(notifier(int)));
connect(rd.socket->notifier(), TQ_SIGNAL(activated(int)),
TQ_SLOT(notifier(int)));
uint nb = it.current()->bds.count();
Q_ASSERT( nb>=1 );
rd.array = new BufferArray(nb);
@ -155,8 +155,8 @@ LocalServer::LocalServer(MPInterface *_interface,
uint _interval)
: Local(_interface, _boards), Server(_interval)
{
connect(&timer, TQT_SIGNAL(timeout()), TQT_SLOT(timeoutSlot()));
connect(&ctimer, TQT_SIGNAL(timeout()), TQT_SLOT(congestionTimeoutSlot()));
connect(&timer, TQ_SIGNAL(timeout()), TQ_SLOT(timeoutSlot()));
connect(&ctimer, TQ_SIGNAL(timeout()), TQ_SLOT(congestionTimeoutSlot()));
serverTimeout();
}
@ -167,8 +167,8 @@ NetworkServer::NetworkServer(MPInterface *_interface,
: Network(_interface, _boards, rhd), Server(_interval),
nbReceived(remotes.count())
{
connect(&timer, TQT_SIGNAL(timeout()), TQT_SLOT(timeoutSlot()));
connect(&ctimer, TQT_SIGNAL(timeout()), TQT_SLOT(congestionTimeoutSlot()));
connect(&timer, TQ_SIGNAL(timeout()), TQ_SLOT(timeoutSlot()));
connect(&ctimer, TQ_SIGNAL(timeout()), TQ_SLOT(congestionTimeoutSlot()));
// to catch unexpected data
for (uint i=0; i<remotes.count(); i++) remotes[i].received = TRUE;
nbReceived = remotes.count();

24
libksirtet/lib/meeting.cpp
Unescape View File

@ -65,13 +65,13 @@ void NetMeeting::appendLine(const MeetingLineData &pld, bool server)
{
MeetingLine *pl;
pl = new MeetingLine(pld.own, server, false, wl);
if (pld.own) connect(pl, TQT_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(textChanged(const TQString &)));
if (pld.own) connect(pl, TQ_SIGNAL(textChanged(const TQString &)),
TQ_SLOT(textChanged(const TQString &)));
else message(i18n("A new client has just arrived (#%1)")
.arg(wl->size()+1));
pl->setData(pld.ed);
connect(pl, TQT_SIGNAL(typeChanged(MeetingCheckBox::Type)),
TQT_SLOT(typeChanged(MeetingCheckBox::Type)));
connect(pl, TQ_SIGNAL(typeChanged(MeetingCheckBox::Type)),
TQ_SLOT(typeChanged(MeetingCheckBox::Type)));
wl->append(pl);
waiting();
}
@ -216,17 +216,17 @@ ServerNetMeeting::ServerNetMeeting(const cId &id,
TQPtrList<RemoteHostData> &arhd, TQWidget *parent, const char * name)
: NetMeeting(id, r.socket, option, TRUE, parent, name), rhd(arhd)
{
connect(sm[0]->notifier(), TQT_SIGNAL(activated(int)), TQT_SLOT(newHost(int)));
connect(sm[0]->notifier(), TQ_SIGNAL(activated(int)), TQ_SLOT(newHost(int)));
players.append(Accepted); // server
// set server line
ExtData ed(r.bds, "", MeetingCheckBox::Ready);
spl->setData(ed);
connect(spl, TQT_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(textChanged(const TQString &)));
connect(spl, TQ_SIGNAL(textChanged(const TQString &)),
TQ_SLOT(textChanged(const TQString &)));
// options signal
if (ow) connect(ow, TQT_SIGNAL(changed()), TQT_SLOT(optionsChanged()));
if (ow) connect(ow, TQ_SIGNAL(changed()), TQ_SLOT(optionsChanged()));
}
void ServerNetMeeting::writeToAll(uint i)
@ -271,8 +271,8 @@ void ServerNetMeeting::newHost(int)
players.append(NewPlayer);
Socket *socket = new Socket(s, true);
uint i = sm.append(socket, SocketManager::ReadWrite);
connect(sm[i]->notifier(), TQT_SIGNAL(activated(int)),
TQT_SLOT(readNotifier(int)));
connect(sm[i]->notifier(), TQ_SIGNAL(activated(int)),
TQ_SLOT(readNotifier(int)));
sm[i]->notifier()->setEnabled(TRUE);
}
@ -451,8 +451,8 @@ ClientNetMeeting::ClientNetMeeting(const cId &id,
TQWidget *parent, const char * name)
: NetMeeting(id, rhd.socket, option, FALSE, parent, name), bds(rhd.bds)
{
connect(sm[0]->notifier(), TQT_SIGNAL(activated(int)),
TQT_SLOT(readNotifier(int)));
connect(sm[0]->notifier(), TQ_SIGNAL(activated(int)),
TQ_SLOT(readNotifier(int)));
players.append(NewPlayer); // server player
// Send id to server (Id flag + Id struct)

6
libksirtet/lib/miscui.cpp
Unescape View File

@ -16,12 +16,12 @@ MeetingCheckBox::MeetingCheckBox(Type type, bool owner, bool server,
_ready = new TQCheckBox(i18n("Ready"), this);
vbox->addWidget(_ready);
_ready->setEnabled(owner);
connect(_ready, TQT_SIGNAL(clicked()), TQT_SLOT(changedSlot()));
connect(_ready, TQ_SIGNAL(clicked()), TQ_SLOT(changedSlot()));
_excluded = new TQCheckBox(i18n("Excluded"), this);
vbox->addWidget(_excluded);
_excluded->setEnabled(server);
connect(_excluded, TQT_SIGNAL(clicked()), TQT_SLOT(changedSlot()));
connect(_excluded, TQ_SIGNAL(clicked()), TQ_SLOT(changedSlot()));
setType(type);
}
@ -54,5 +54,5 @@ PlayerComboBox::PlayerComboBox(Type type, bool canBeEmpty, bool acceptAI,
if (canBeEmpty) insertItem(i18n("None"));
setCurrentItem(type);
connect(this, TQT_SIGNAL(activated(int)), TQT_SIGNAL(changed(int)));
connect(this, TQ_SIGNAL(activated(int)), TQ_SIGNAL(changed(int)));
}

4
libksirtet/lib/mp_interface.cpp
Unescape View File

@ -155,7 +155,7 @@ void MPInterface::createLocalGame(const ConnectionData &cd)
d.ptr = newBoard(i);
hbl->addWidget(d.ptr);
d.ptr->show();
connect(d.ptr, TQT_SIGNAL(enableKeys(bool)), TQT_SLOT(enableKeys(bool)));
connect(d.ptr, TQ_SIGNAL(enableKeys(bool)), TQ_SLOT(enableKeys(bool)));
boards += d;
}
@ -257,7 +257,7 @@ void MPInterface::hostDisconnected(uint, const TQString &msg)
if ( !disconnected ) { // to avoid multiple calls
disconnected = TRUE;
// the zero timer is used to be outside the "internal" class
TQTimer::singleShot(0, this, TQT_SLOT(singleHumanSlot()));
TQTimer::singleShot(0, this, TQ_SLOT(singleHumanSlot()));
}
}

2
libksirtet/lib/mp_simple_interface.cpp
Unescape View File

@ -73,7 +73,7 @@ void MPSimpleInterface::dataFromServer(TQDataStream &s)
switch (scf.value()) {
case SC_Flag::Stop:
KMessageBox::information(this, i18n("Server has left game!"));
TQTimer::singleShot(0, this, TQT_SLOT(singleHuman()));
TQTimer::singleShot(0, this, TQ_SLOT(singleHuman()));
return;
case SC_Flag::GameOver:
_readGameOverData(s);

10
libksirtet/lib/pline.cpp
Unescape View File

@ -21,7 +21,7 @@ MeetingLine::MeetingLine(bool isOwner, bool serverIsReader, bool serverLine,
tcb = new MeetingCheckBox(MeetingCheckBox::Ready, isOwner, serverIsReader,
this);
if ( !XOR(isOwner, serverIsReader) ) tcb->setEnabled(FALSE);
else connect(tcb, TQT_SIGNAL(changed(int)), TQT_SLOT(_typeChanged(int)));
else connect(tcb, TQ_SIGNAL(changed(int)), TQ_SLOT(_typeChanged(int)));
hbl->addWidget(tcb);
/* Name */
@ -52,8 +52,8 @@ MeetingLine::MeetingLine(bool isOwner, bool serverIsReader, bool serverLine,
qle->setFont( TQFont("fixed", 12, TQFont::Bold) );
qle->setFixedSize(qle->fontMetrics().maxWidth()*TALKER_MAX_LENGTH,
qle->sizeHint().height());
connect(qle, TQT_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(_textChanged(const TQString &)));
connect(qle, TQ_SIGNAL(textChanged(const TQString &)),
TQ_SLOT(_textChanged(const TQString &)));
qle->setEnabled(isOwner);
hbl->addWidget(qle);
}
@ -95,7 +95,7 @@ PlayerLine::PlayerLine(PlayerComboBox::Type type, const TQString &txt,
/* CheckBox */
pcb = new PlayerComboBox(type, canBeEmpty, acceptAI, this);
connect(pcb, TQT_SIGNAL(changed(int)), TQT_SLOT(typeChangedSlot(int)));
connect(pcb, TQ_SIGNAL(changed(int)), TQ_SLOT(typeChangedSlot(int)));
hbl->addWidget(pcb);
/* Name */
@ -107,7 +107,7 @@ PlayerLine::PlayerLine(PlayerComboBox::Type type, const TQString &txt,
/* settings button */
setting = new TQPushButton(i18n("Settings"), this);
connect(setting, TQT_SIGNAL(clicked()), TQT_SLOT(setSlot()));
connect(setting, TQ_SIGNAL(clicked()), TQ_SLOT(setSlot()));
hbl->addWidget(setting);
typeChangedSlot(type);

14
libksirtet/lib/wizard.cpp
Unescape View File

@ -49,7 +49,7 @@ void MPWizard::setupTypePage()
typePage->setMargin(KDialogBase::marginHint());
TQVButtonGroup *vbg = new TQVButtonGroup(typePage);
connect(vbg, TQT_SIGNAL(clicked(int)), TQT_SLOT(typeChanged(int)));
connect(vbg, TQ_SIGNAL(clicked(int)), TQ_SLOT(typeChanged(int)));
TQRadioButton *b;
b = new TQRadioButton(i18n("Create a local game"), vbg);
b = new TQRadioButton(i18n("Create a network game"), vbg);
@ -82,10 +82,10 @@ void MPWizard::setupLocalPage(const MPGameInfo &gi)
wl = new WidgetList<PlayerLine>(5, localPage);
TQSignalMapper *husm = new TQSignalMapper(this);
if (gi.humanSettingSlot) connect(husm, TQT_SIGNAL(mapped(int)),
if (gi.humanSettingSlot) connect(husm, TQ_SIGNAL(mapped(int)),
gi.humanSettingSlot);
TQSignalMapper *aism = new TQSignalMapper(this);
if (gi.AISettingSlot) connect(aism, TQT_SIGNAL(mapped(int)), gi.AISettingSlot);
if (gi.AISettingSlot) connect(aism, TQ_SIGNAL(mapped(int)), gi.AISettingSlot);
TDEConfigGroupSaver cg(kapp->config(), MP_GROUP);
TQString n;
@ -101,18 +101,18 @@ 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)));
connect(pl, TQ_SIGNAL(typeChanged(int)), TQ_SLOT(lineTypeChanged(int)));
husm->setMapping(pl, i);
connect(pl, TQT_SIGNAL(setHuman()), husm, TQT_SLOT(map()));
connect(pl, TQ_SIGNAL(setHuman()), husm, TQ_SLOT(map()));
aism->setMapping(pl, i);
connect(pl, TQT_SIGNAL(setAI()), aism, TQT_SLOT(map()));
connect(pl, TQ_SIGNAL(setAI()), aism, TQ_SLOT(map()));
wl->append(pl);
}
((TQVBox *)localPage)->setSpacing(KDialogBase::spacingHint());
// keys = new TQPushButton(i18n("Configure Keys..."), localPage);
// connect(keys, TQT_SIGNAL(clicked()), TQT_SLOT(configureKeysSlot()));
// connect(keys, TQ_SIGNAL(clicked()), TQ_SLOT(configureKeysSlot()));
addPage(localPage, i18n("Local Player's Settings"));
setHelpEnabled(localPage, FALSE);

36
libtdegames/highscore/kexthighscore_gui.cpp
Unescape View File

@ -130,7 +130,7 @@ HighscoresWidget::HighscoresWidget(TQWidget *parent)
TQVBoxLayout *vbox = new TQVBoxLayout(this, KDialogBase::spacingHint());
_tw = new TQTabWidget(this);
connect(_tw, TQT_SIGNAL(currentChanged(TQWidget *)), TQT_SLOT(tabChanged()));
connect(_tw, TQ_SIGNAL(currentChanged(TQWidget *)), TQ_SLOT(tabChanged()));
vbox->addWidget(_tw);
// scores tab
@ -160,15 +160,15 @@ HighscoresWidget::HighscoresWidget(TQWidget *parent)
KURL url = internal->queryURL(ManagerPrivate::Scores);
_scoresUrl = new KURLLabel(url.url(),
i18n("View world-wide highscores"), this);
connect(_scoresUrl, TQT_SIGNAL(leftClickedURL(const TQString &)),
TQT_SLOT(showURL(const TQString &)));
connect(_scoresUrl, TQ_SIGNAL(leftClickedURL(const TQString &)),
TQ_SLOT(showURL(const TQString &)));
vbox->addWidget(_scoresUrl);
url = internal->queryURL(ManagerPrivate::Players);
_playersUrl = new KURLLabel(url.url(),
i18n("View world-wide players"), this);
connect(_playersUrl, TQT_SIGNAL(leftClickedURL(const TQString &)),
TQT_SLOT(showURL(const TQString &)));
connect(_playersUrl, TQ_SIGNAL(leftClickedURL(const TQString &)),
TQ_SLOT(showURL(const TQString &)));
vbox->addWidget(_playersUrl);
}
}
@ -215,8 +215,8 @@ HighscoresDialog::HighscoresDialog(int rank, TQWidget *parent)
if ( i==internal->gameType() ) createPage(w);
}
connect(this, TQT_SIGNAL(aboutToShowPage(TQWidget *)),
TQT_SLOT(createPage(TQWidget *)));
connect(this, TQ_SIGNAL(aboutToShowPage(TQWidget *)),
TQ_SLOT(createPage(TQWidget *)));
showPage(internal->gameType());
} else {
TQVBoxLayout *vbox = new TQVBoxLayout(plainPage());
@ -234,7 +234,7 @@ void HighscoresDialog::createPage(TQWidget *page)
int i = (several ? pageIndex(page) : 0);
if ( _widgets[i]==0 ) {
_widgets[i] = new HighscoresWidget(page);
connect(_widgets[i], TQT_SIGNAL(tabChanged(int)), TQT_SLOT(tabChanged(int)));
connect(_widgets[i], TQ_SIGNAL(tabChanged(int)), TQ_SLOT(tabChanged(int)));
}
uint type = internal->gameType();
if (several) internal->setGameType(i);
@ -376,10 +376,10 @@ ConfigDialog::ConfigDialog(TQWidget *parent)
TQLabel *label = new TQLabel(i18n("Nickname:"), page);
pageTop->addWidget(label, 0, 0);
_nickname = new TQLineEdit(page);
connect(_nickname, TQT_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(modifiedSlot()));
connect(_nickname, TQT_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(nickNameChanged(const TQString &)));
connect(_nickname, TQ_SIGNAL(textChanged(const TQString &)),
TQ_SLOT(modifiedSlot()));
connect(_nickname, TQ_SIGNAL(textChanged(const TQString &)),
TQ_SLOT(nickNameChanged(const TQString &)));
_nickname->setMaxLength(16);
pageTop->addWidget(_nickname, 0, 1);
@ -387,16 +387,16 @@ ConfigDialog::ConfigDialog(TQWidget *parent)
label = new TQLabel(i18n("Comment:"), page);
pageTop->addWidget(label, 1, 0);
_comment = new TQLineEdit(page);
connect(_comment, TQT_SIGNAL(textChanged(const TQString &)),
TQT_SLOT(modifiedSlot()));
connect(_comment, TQ_SIGNAL(textChanged(const TQString &)),
TQ_SLOT(modifiedSlot()));
_comment->setMaxLength(50);
pageTop->addWidget(_comment, 1, 1);
if (tab) {
_WWHEnabled
= new TQCheckBox(i18n("World-wide highscores enabled"), page);
connect(_WWHEnabled, TQT_SIGNAL(toggled(bool)),
TQT_SLOT(modifiedSlot()));
connect(_WWHEnabled, TQ_SIGNAL(toggled(bool)),
TQ_SLOT(modifiedSlot()));
pageTop->addMultiCellWidget(_WWHEnabled, 2, 2, 0, 1);
// advanced tab
@ -421,7 +421,7 @@ ConfigDialog::ConfigDialog(TQWidget *parent)
KGuiItem gi = KStdGuiItem::clear();
gi.setText(i18n("Remove"));
_removeButton = new KPushButton(gi, grid);
connect(_removeButton, TQT_SIGNAL(clicked()), TQT_SLOT(removeSlot()));
connect(_removeButton, TQ_SIGNAL(clicked()), TQ_SLOT(removeSlot()));
}
load();
@ -533,7 +533,7 @@ AskNameDialog::AskNameDialog(TQWidget *parent)
hbox->addWidget(label);
_edit = new TQLineEdit(plainPage());
_edit->setFocus();
connect(_edit, TQT_SIGNAL(textChanged(const TQString &)), TQT_SLOT(nameChanged()));
connect(_edit, TQ_SIGNAL(textChanged(const TQString &)), TQ_SLOT(nameChanged()));
hbox->addWidget(_edit);
top->addSpacing(spacingHint());

8
libtdegames/highscore/kexthighscore_tab.cpp
Unescape View File

@ -46,7 +46,7 @@ PlayersCombo::PlayersCombo(TQWidget *parent, const char *name)
for (uint i = 0; i<p.nbEntries(); i++)
insertItem(p.prettyName(i));
insertItem(TQString("<") + i18n("all") + '>');
connect(this, TQT_SIGNAL(activated(int)), TQT_SLOT(activatedSlot(int)));
connect(this, TQ_SIGNAL(activated(int)), TQ_SLOT(activatedSlot(int)));
}
void PlayersCombo::activatedSlot(int i)
@ -75,9 +75,9 @@ AdditionalTab::AdditionalTab(TQWidget *parent, const char *name)
TQLabel *label = new TQLabel(i18n("Select player:"), this);
hbox->addWidget(label);
_combo = new PlayersCombo(this);
connect(_combo, TQT_SIGNAL(playerSelected(uint)),
TQT_SLOT(playerSelected(uint)));
connect(_combo, TQT_SIGNAL(allSelected()), TQT_SLOT(allSelected()));
connect(_combo, TQ_SIGNAL(playerSelected(uint)),
TQ_SLOT(playerSelected(uint)));
connect(_combo, TQ_SIGNAL(allSelected()), TQ_SLOT(allSelected()));
hbox->addWidget(_combo);
hbox->addStretch(1);
}

8
libtdegames/highscore/kscoredialog.cpp
Unescape View File

@ -90,7 +90,7 @@ KScoreDialog::KScoreDialog(int fields, TQWidget *parent, const char *oname)
d->key[Score] = "Score";
d->page = makeMainWidget();
connect(this, TQT_SIGNAL(okClicked()), TQT_SLOT(slotGotName()));
connect(this, TQ_SIGNAL(okClicked()), TQ_SLOT(slotGotName()));
}
KScoreDialog::~KScoreDialog()
@ -239,8 +239,8 @@ void KScoreDialog::aboutToShow()
stack->addWidget(d->edit);
stack->raiseWidget(d->edit);
d->edit->setFocus();
connect(d->edit, TQT_SIGNAL(returnPressed()),
this, TQT_SLOT(slotGotReturn()));
connect(d->edit, TQ_SIGNAL(returnPressed()),
this, TQ_SLOT(slotGotReturn()));
}
else
{
@ -365,7 +365,7 @@ void KScoreDialog::show()
void KScoreDialog::slotGotReturn()
{
TQTimer::singleShot(0, this, TQT_SLOT(slotGotName()));
TQTimer::singleShot(0, this, TQ_SLOT(slotGotName()));
}
void KScoreDialog::slotGotName()

4
libtdegames/kcanvasrootpixmap.cpp
Unescape View File

@ -26,8 +26,8 @@ KCanvasRootPixmap::KCanvasRootPixmap(TQCanvasView *view, const char *name)
: KRootPixmap(view, name), _view(view)
{
setCustomPainting(true);
connect(this, TQT_SIGNAL(backgroundUpdated(const TQPixmap &)),
TQT_SLOT(backgroundUpdatedSlot(const TQPixmap &)));
connect(this, TQ_SIGNAL(backgroundUpdated(const TQPixmap &)),
TQ_SLOT(backgroundUpdatedSlot(const TQPixmap &)));
}
void KCanvasRootPixmap::backgroundUpdatedSlot(const TQPixmap &pixmap)

24
libtdegames/kcarddialog.cpp
Unescape View File

@ -304,8 +304,8 @@ void KCardDialog::setupDialog(bool showResizeBox)
d->randomDeck = new TQCheckBox(plainPage());
d->randomDeck->setChecked(false);
connect(d->randomDeck, TQT_SIGNAL(toggled(bool)), this,
TQT_SLOT(slotRandomDeckToggled(bool)));
connect(d->randomDeck, TQ_SIGNAL(toggled(bool)), this,
TQ_SLOT(slotRandomDeckToggled(bool)));
d->randomDeck->setText(i18n("Random backside"));
l->addWidget(d->randomDeck, 0, AlignTop|AlignHCenter);
@ -315,11 +315,11 @@ void KCardDialog::setupDialog(bool showResizeBox)
l->addWidget(d->globalDeck, 0, AlignTop|AlignHCenter);
TQPushButton* b = new TQPushButton(i18n("Make Backside Global"), plainPage());
connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotSetGlobalDeck()));
connect(b, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotSetGlobalDeck()));
l->addWidget(b, 0, AlignTop|AlignHCenter);
connect(d->deckIconView,TQT_SIGNAL(clicked(TQIconViewItem *)),
this,TQT_SLOT(slotDeckClicked(TQIconViewItem *)));
connect(d->deckIconView,TQ_SIGNAL(clicked(TQIconViewItem *)),
this,TQ_SLOT(slotDeckClicked(TQIconViewItem *)));
}
if (! (flags() & NoCards))
@ -354,8 +354,8 @@ void KCardDialog::setupDialog(bool showResizeBox)
d->randomCardDir = new TQCheckBox(plainPage());
d->randomCardDir->setChecked(false);
connect(d->randomCardDir, TQT_SIGNAL(toggled(bool)), this,
TQT_SLOT(slotRandomCardDirToggled(bool)));
connect(d->randomCardDir, TQ_SIGNAL(toggled(bool)), this,
TQ_SLOT(slotRandomCardDirToggled(bool)));
d->randomCardDir->setText(i18n("Random frontside"));
l->addWidget(d->randomCardDir, 0, AlignTop|AlignHCenter);
@ -365,11 +365,11 @@ void KCardDialog::setupDialog(bool showResizeBox)
l->addWidget(d->globalCardDir, 0, AlignTop|AlignHCenter);
TQPushButton* b = new TQPushButton(i18n("Make Frontside Global"), plainPage());
connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotSetGlobalCardDir()));
connect(b, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotSetGlobalCardDir()));
l->addWidget(b, 0, AlignTop|AlignHCenter);
connect(d->cardIconView,TQT_SIGNAL(clicked(TQIconViewItem *)),
this,TQT_SLOT(slotCardClicked(TQIconViewItem *)));
connect(d->cardIconView,TQ_SIGNAL(clicked(TQIconViewItem *)),
this,TQ_SLOT(slotCardClicked(TQIconViewItem *)));
}
// Insert deck icons
@ -433,11 +433,11 @@ void KCardDialog::setupDialog(bool showResizeBox)
d->scaleSlider = new TQSlider(1, SLIDER_MAX, 1, (-1000+SLIDER_MIN+SLIDER_MAX),TQt::Horizontal, box);
d->scaleSlider->setMinValue(SLIDER_MIN);
connect(d->scaleSlider, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotCardResized(int)));
connect(d->scaleSlider, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotCardResized(int)));
boxLayout->addWidget(d->scaleSlider, 0, AlignLeft);
TQPushButton* b = new TQPushButton(i18n("Default Size"), box);
connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotDefaultSize()));
connect(b, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotDefaultSize()));
boxLayout->addWidget(b, 0, AlignLeft);
TQLabel* l = new TQLabel(i18n("Preview:"), box);

8
libtdegames/kchatbase.cpp
Unescape View File

@ -206,8 +206,8 @@ void KChatBase::init(bool noComboBox)
TQVBoxLayout* l = new TQVBoxLayout(this);
d->mBox = new TQListBox(this);
connect(d->mBox, TQT_SIGNAL(rightButtonClicked(TQListBoxItem*, const TQPoint&)),
this, TQT_SIGNAL(rightButtonClicked(TQListBoxItem*, const TQPoint&)));
connect(d->mBox, TQ_SIGNAL(rightButtonClicked(TQListBoxItem*, const TQPoint&)),
this, TQ_SIGNAL(rightButtonClicked(TQListBoxItem*, const TQPoint&)));
l->addWidget(d->mBox);
d->mBox->setVScrollBarMode(TQScrollView::AlwaysOn);
d->mBox->setHScrollBarMode(TQScrollView::AlwaysOff);
@ -223,7 +223,7 @@ void KChatBase::init(bool noComboBox)
d->mEdit->setTrapReturnKey(true);
d->mEdit->completionObject(); // add the completion object
d->mEdit->setCompletionMode(TDEGlobalSettings::CompletionNone);
connect(d->mEdit, TQT_SIGNAL(returnPressed(const TQString&)), this, TQT_SLOT(slotReturnPressed(const TQString&)));
connect(d->mEdit, TQ_SIGNAL(returnPressed(const TQString&)), this, TQ_SLOT(slotReturnPressed(const TQString&)));
h->addWidget(d->mEdit);
if (!noComboBox) {
@ -399,7 +399,7 @@ void KChatBase::slotReturnPressed(const TQString& text)
return;
}
d->mEdit->completionObject()->addItem(text);
// connect(d->mEdit, TQT_SIGNAL(returnPressed(const TQString&)), comp, TQT_SLOT(addItem(const TQString&)));
// connect(d->mEdit, TQ_SIGNAL(returnPressed(const TQString&)), comp, TQ_SLOT(addItem(const TQString&)));
d->mEdit->clear();
returnPressed(text);
}

8
libtdegames/kchatdialog.cpp
Unescape View File

@ -84,10 +84,10 @@ void KChatDialog::init()
// General fonts
TQPushButton* nameFont = new TQPushButton(i18n("Name Font..."), d->mTextPage);
connect(nameFont, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotGetNameFont()));
connect(nameFont, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotGetNameFont()));
layout->addWidget(nameFont, 0, 0);
TQPushButton* textFont = new TQPushButton(i18n("Text Font..."), d->mTextPage);
connect(textFont, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotGetTextFont()));
connect(textFont, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotGetTextFont()));
layout->addWidget(textFont, 0, 1);
TQFrame* messagePreview = new TQFrame(d->mTextPage);
@ -106,10 +106,10 @@ void KChatDialog::init()
TQLabel* systemMessages = new TQLabel(i18n("System Messages - Messages directly sent from the game"), d->mTextPage);
layout->addMultiCellWidget(systemMessages, 3, 3, 0, 1);
TQPushButton* systemNameFont = new TQPushButton(i18n("Name Font..."), d->mTextPage);
connect(systemNameFont, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotGetSystemNameFont()));
connect(systemNameFont, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotGetSystemNameFont()));
layout->addWidget(systemNameFont, 4, 0);
TQPushButton* systemTextFont = new TQPushButton(i18n("Text Font..."), d->mTextPage);
connect(systemTextFont, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotGetSystemTextFont()));
connect(systemTextFont, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotGetSystemTextFont()));
layout->addWidget(systemTextFont, 4, 1);
TQFrame* systemMessagePreview = new TQFrame(d->mTextPage);

2
libtdegames/kgame/DESIGN
Unescape View File

@ -347,7 +347,7 @@ a slot like
slotDebug()
{
KGameDebugDialog* dialog = new KGameDebugDialog(mGame, this);
connect(dialog, SIGNAL(finished()), dialog, SLOT(slotDelayedDestruct()));
connect(dialog, TQ_SIGNAL(finished()), dialog, TQ_SLOT(slotDelayedDestruct()));
dialog->show();
}
that's it.

8
libtdegames/kgame/dialogs/kgameconnectdialog.cpp
Unescape View File

@ -63,7 +63,7 @@ KGameConnectWidget::KGameConnectWidget(TQWidget* parent) : TQWidget(parent)
TQVBoxLayout* vb = new TQVBoxLayout(this, KDialog::spacingHint());
d->mButtonGroup = new TQVButtonGroup(this);
vb->addWidget(d->mButtonGroup);
connect(d->mButtonGroup, TQT_SIGNAL(clicked(int)), this, TQT_SLOT(slotTypeChanged(int)));
connect(d->mButtonGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(slotTypeChanged(int)));
(void)new TQRadioButton(i18n("Create a network game"), d->mButtonGroup);
(void)new TQRadioButton(i18n("Join a network game"), d->mButtonGroup);
@ -74,14 +74,14 @@ KGameConnectWidget::KGameConnectWidget(TQWidget* parent) : TQWidget(parent)
d->mServerName = new TQLineEdit(g);
d->mClientNameLabel = new TQLabel(i18n("Network games:"), g);
d->mClientName = new TQComboBox(g);
connect(d->mClientName,TQT_SIGNAL(activated(int)),TQT_SLOT(slotGameSelected(int)));
connect(d->mClientName,TQ_SIGNAL(activated(int)),TQ_SLOT(slotGameSelected(int)));
(void)new TQLabel(i18n("Port to connect to:"), g);
d->mPort = new KIntNumInput(g);
(void)new TQLabel(i18n("Host to connect to:"), g);
d->mHost = new TQLineEdit(g);
TQPushButton *button=new TQPushButton(i18n("&Start Network"), this);
connect(button, TQT_SIGNAL(clicked()), this, TQT_SIGNAL(signalNetworkSetup()));
connect(button, TQ_SIGNAL(clicked()), this, TQ_SIGNAL(signalNetworkSetup()));
vb->addWidget(button);
// Hide until type is set
d->mClientName->hide();
@ -112,7 +112,7 @@ void KGameConnectWidget::setType(const TQString& type)
d->mType = type;
delete d->mBrowser;
d->mBrowser = new DNSSD::ServiceBrowser(type);
connect(d->mBrowser,TQT_SIGNAL(finished()),TQT_SLOT(slotGamesFound()));
connect(d->mBrowser,TQ_SIGNAL(finished()),TQ_SLOT(slotGamesFound()));
d->mBrowser->startBrowse();
showDnssdControls();
}

16
libtdegames/kgame/dialogs/kgamedebugdialog.cpp
Unescape View File

@ -156,7 +156,7 @@ void KGameDebugDialog::initGamePage()
layout->addWidget(d->mGameProperties);
TQPushButton* b = new TQPushButton(i18n("Update"), d->mGamePage);
connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotUpdateGameData()));
connect(b, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotUpdateGameData()));
topLayout->addWidget(b);
// game data
@ -184,7 +184,7 @@ void KGameDebugDialog::initPlayerPage()
TQLabel* listLabel = new TQLabel(i18n("Available Players"), d->mPlayerPage);
listLayout->addWidget(listLabel);
d->mPlayerList = new TDEListBox(d->mPlayerPage);
connect(d->mPlayerList, TQT_SIGNAL(executed(TQListBoxItem*)), this, TQT_SLOT(slotUpdatePlayerData(TQListBoxItem*)));
connect(d->mPlayerList, TQ_SIGNAL(executed(TQListBoxItem*)), this, TQ_SLOT(slotUpdatePlayerData(TQListBoxItem*)));
listLayout->addWidget(d->mPlayerList);
d->mPlayerList->setSizePolicy(TQSizePolicy(TQSizePolicy::Preferred, TQSizePolicy::Expanding));
@ -200,7 +200,7 @@ void KGameDebugDialog::initPlayerPage()
layout->addWidget(d->mPlayerProperties);
TQPushButton* b = new TQPushButton(i18n("Update"), d->mPlayerPage);
connect(b, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotUpdatePlayerList()));
connect(b, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotUpdatePlayerList()));
topLayout->addWidget(b);
d->mPlayerAddress = new TQListViewItem(v, i18n("Player Pointer"));
@ -230,11 +230,11 @@ void KGameDebugDialog::initMessagePage()
d->mMessageList->addColumn(i18n("ID - Text"));
TQPushButton* hide = new TQPushButton(i18n("&>>"), d->mMessagePage);
connect(hide, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotHideId()));
connect(hide, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotHideId()));
layout->addWidget(hide, 4, 4);
TQPushButton* show = new TQPushButton(i18n("&<<"), d->mMessagePage);
connect(show, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotShowId()));
connect(show, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotShowId()));
layout->addWidget(show, 6, 4);
TQLabel* l = new TQLabel(i18n("Do not show IDs:"), d->mMessagePage);
@ -243,7 +243,7 @@ void KGameDebugDialog::initMessagePage()
layout->addMultiCellWidget(d->mHideIdList, 1, 8, 5, 6);
TQPushButton* clear = new KPushButton(KStdGuiItem::clear(), d->mMessagePage);
connect(clear, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotClearMessages()));
connect(clear, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotClearMessages()));
layout->addMultiCellWidget(clear, 10, 10, 0, 6);
//TODO: "show all but..." and "show nothing but..."
}
@ -431,7 +431,7 @@ void KGameDebugDialog::setKGame(const KGame* g)
d->mGame = g;
if (g) {
//TODO: connect to the KGame signals for joined/removed players!!!
connect(d->mGame, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotUnsetKGame()));
connect(d->mGame, TQ_SIGNAL(destroyed()), this, TQ_SLOT(slotUnsetKGame()));
// connect();
TQPtrList<KPlayer> list = *d->mGame->playerList();
@ -441,7 +441,7 @@ void KGameDebugDialog::setKGame(const KGame* g)
slotUpdateGameData();
connect(d->mGame, TQT_SIGNAL(signalMessageUpdate(int, TQ_UINT32, TQ_UINT32)), this, TQT_SLOT(slotMessageUpdate(int, TQ_UINT32, TQ_UINT32)));
connect(d->mGame, TQ_SIGNAL(signalMessageUpdate(int, TQ_UINT32, TQ_UINT32)), this, TQ_SLOT(slotMessageUpdate(int, TQ_UINT32, TQ_UINT32)));
}
}

8
libtdegames/kgame/dialogs/kgamedialog.cpp
Unescape View File

@ -239,7 +239,7 @@ void KGameDialog::addConfigWidget(KGameDialogConfig* widget, TQWidget* parent)
// kdDebug(11001) << "reparenting widget" << endl;
widget->reparent(parent, TQPoint(0,0));
d->mConfigWidgets.append(widget);
connect(widget, TQT_SIGNAL(destroyed(TQObject*)), this, TQT_SLOT(slotRemoveConfigWidget(TQObject*)));
connect(widget, TQ_SIGNAL(destroyed(TQObject*)), this, TQ_SLOT(slotRemoveConfigWidget(TQObject*)));
if (!d->mGame) {
kdWarning(11001) << "No game has been set!" << endl;
} else {
@ -306,9 +306,9 @@ void KGameDialog::setKGame(KGame* g)
}
if (d->mGame) {
setAdmin(d->mGame->isAdmin());
connect(d->mGame, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotUnsetKGame()));
connect(d->mGame, TQT_SIGNAL(signalAdminStatusChanged(bool)),
this, TQT_SLOT(setAdmin(bool)));
connect(d->mGame, TQ_SIGNAL(destroyed()), this, TQ_SLOT(slotUnsetKGame()));
connect(d->mGame, TQ_SIGNAL(signalAdminStatusChanged(bool)),
this, TQ_SLOT(setAdmin(bool)));
}
}

42
libtdegames/kgame/dialogs/kgamedialogconfig.cpp
Unescape View File

@ -130,16 +130,16 @@ KGameDialogNetworkConfig::KGameDialogNetworkConfig(TQWidget* parent)
hb->addWidget(d->mNetworkLabel);
d->mDisconnectButton=new TQPushButton(i18n("Disconnect"),this);
connect(d->mDisconnectButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotExitConnection()));
connect(d->mDisconnectButton, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotExitConnection()));
hb->addWidget(d->mDisconnectButton);
d->mInitConnection = new TQHGroupBox(i18n("Network Configuration"), this);
topLayout->addWidget(d->mInitConnection);
d->mConnect = new KGameConnectWidget(d->mInitConnection);
connect(d->mConnect, TQT_SIGNAL(signalNetworkSetup()), this, TQT_SLOT(slotInitConnection()));
connect(d->mConnect, TQT_SIGNAL(signalServerTypeChanged(int)),
this, TQT_SIGNAL(signalServerTypeChanged(int)));
connect(d->mConnect, TQ_SIGNAL(signalNetworkSetup()), this, TQ_SLOT(slotInitConnection()));
connect(d->mConnect, TQ_SIGNAL(signalServerTypeChanged(int)),
this, TQ_SIGNAL(signalServerTypeChanged(int)));
// Needs to be AFTER the creation of the dialogs
setConnected(false);
@ -180,8 +180,8 @@ void KGameDialogNetworkConfig::slotInitConnection()
}
// We need to learn about failed connections
if (game()) {
connect(game(), TQT_SIGNAL(signalConnectionBroken()),
this, TQT_SLOT(slotConnectionBroken()));
connect(game(), TQ_SIGNAL(signalConnectionBroken()),
this, TQ_SLOT(slotConnectionBroken()));
}
}
setConnected(connected, master);
@ -309,8 +309,8 @@ void KGameDialogGeneralConfig::setOwner(KPlayer* p)
// maybe call hide()
return;
}
connect(owner(), TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
connect(owner(), TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
setPlayerName(p->name());
//TODO: connect signalPropertyChanged and check for playername changes!
}
@ -408,7 +408,7 @@ void KGameDialogMsgServerConfig::setKGame(KGame* g)
{
KGameDialogConfig::setKGame(g);
//TODO display the ID of the admin if we aren't
// connect(g, TQT_SIGNAL(signalAdminChanged(int)), this, TQT_SLOT(slotChangeIsAdmin(int)));//TODO
// connect(g, TQ_SIGNAL(signalAdminChanged(int)), this, TQ_SLOT(slotChangeIsAdmin(int)));//TODO
if (!game()) {
// we cannot do anything without a KGame object!
setAdmin(false);
@ -488,11 +488,11 @@ void KGameDialogMsgServerConfig::setAdmin(bool a)
d->noAdmin = 0;
}
d->changeMaxClients = new TQPushButton(i18n("Change Maximal Number of Clients"), this);
connect(d->changeMaxClients, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotChangeMaxClients()));
connect(d->changeMaxClients, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotChangeMaxClients()));
d->changeAdmin = new TQPushButton(i18n("Change Admin"), this);
connect(d->changeAdmin, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotChangeAdmin()));
connect(d->changeAdmin, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotChangeAdmin()));
d->removeClient = new TQPushButton(i18n("Remove Client with All Players"), this);
connect(d->removeClient, TQT_SIGNAL(pressed()), this, TQT_SLOT(slotRemoveClient()));
connect(d->removeClient, TQ_SIGNAL(pressed()), this, TQ_SLOT(slotRemoveClient()));
d->senderLayout->addWidget(d->changeMaxClients);
d->senderLayout->addWidget(d->changeAdmin);
d->senderLayout->addWidget(d->removeClient);
@ -627,10 +627,10 @@ void KGameDialogConnectionConfig::setKGame(KGame* g)
slotClearPlayers();
if (game()) {
// react to changes in KGame::playerList()
connect(game(), TQT_SIGNAL(signalPlayerJoinedGame(KPlayer*)),
this, TQT_SLOT(slotPlayerJoinedGame(KPlayer*)));
connect(game(), TQT_SIGNAL(signalPlayerLeftGame(KPlayer*)),
this, TQT_SLOT(slotPlayerLeftGame(KPlayer*)));
connect(game(), TQ_SIGNAL(signalPlayerJoinedGame(KPlayer*)),
this, TQ_SLOT(slotPlayerJoinedGame(KPlayer*)));
connect(game(), TQ_SIGNAL(signalPlayerLeftGame(KPlayer*)),
this, TQ_SLOT(slotPlayerLeftGame(KPlayer*)));
KGame::KGamePlayerList l = *game()->playerList();
for (KPlayer* p = l.first(); p; p = l.next()) {
@ -650,12 +650,12 @@ void KGameDialogConnectionConfig::setAdmin(bool a)
return;
}
if (admin()) {
disconnect(game(), TQT_SIGNAL(executed(TQListBoxItem*)), this, 0);
disconnect(game(), TQ_SIGNAL(executed(TQListBoxItem*)), this, 0);
}
KGameDialogConfig::setAdmin(a);
if (admin()) {
connect(d->mPlayerBox, TQT_SIGNAL(executed(TQListBoxItem*)), this,
TQT_SLOT(slotKickPlayerOut(TQListBoxItem*)));
connect(d->mPlayerBox, TQ_SIGNAL(executed(TQListBoxItem*)), this,
TQ_SLOT(slotKickPlayerOut(TQListBoxItem*)));
}
}
@ -704,8 +704,8 @@ void KGameDialogConnectionConfig::slotPlayerJoinedGame(KPlayer* p)
d->mItem2Player.insert(t, p);
d->mPlayerBox->insertItem(t);
connect(p, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
connect(p, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
}

14
libtdegames/kgame/dialogs/kgameerrordialog.cpp
Unescape View File

@ -52,15 +52,15 @@ void KGameErrorDialog::setKGame(const KGame* g)
slotUnsetKGame();
d->mGame = g;
connect(d->mGame, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotUnsetKGame()));
connect(d->mGame, TQ_SIGNAL(destroyed()), this, TQ_SLOT(slotUnsetKGame()));
// the error signals:
connect(d->mGame, TQT_SIGNAL(signalNetworkErrorMessage(int, TQString)),
this, TQT_SLOT(slotError(int, TQString)));
connect(d->mGame, TQT_SIGNAL(signalConnectionBroken()),
this, TQT_SLOT(slotServerConnectionLost()));
connect(d->mGame, TQT_SIGNAL(signalClientDisconnected(TQ_UINT32,bool)),
this, TQT_SLOT(slotClientConnectionLost(TQ_UINT32,bool)));
connect(d->mGame, TQ_SIGNAL(signalNetworkErrorMessage(int, TQString)),
this, TQ_SLOT(slotError(int, TQString)));
connect(d->mGame, TQ_SIGNAL(signalConnectionBroken()),
this, TQ_SLOT(slotServerConnectionLost()));
connect(d->mGame, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32,bool)),
this, TQ_SLOT(slotClientConnectionLost(TQ_UINT32,bool)));
}
void KGameErrorDialog::slotUnsetKGame()

22
libtdegames/kgame/kgame.cpp
Unescape View File

@ -89,8 +89,8 @@ KGame::KGame(int cookie,TQObject* parent) : KGameNetwork(cookie,parent)
d->mProperties = new KGamePropertyHandler(this);
d->mProperties->registerHandler(KGameMessage::IdGameProperty,
this,TQT_SLOT(sendProperty(int, TQDataStream&, bool* )),
TQT_SLOT(emitSignal(KGamePropertyBase *)));
this,TQ_SLOT(sendProperty(int, TQDataStream&, bool* )),
TQ_SLOT(emitSignal(KGamePropertyBase *)));
d->mMaxPlayer.registerData(KGamePropertyBase::IdMaxPlayer, this, i18n("MaxPlayers"));
d->mMaxPlayer.setLocal(-1); // Infinite
d->mMinPlayer.registerData(KGamePropertyBase::IdMinPlayer, this, i18n("MinPlayers"));
@ -101,20 +101,20 @@ KGame::KGame(int cookie,TQObject* parent) : KGameNetwork(cookie,parent)
d->mRandom = new KRandomSequence;
d->mRandom->setSeed(0);
connect(this, TQT_SIGNAL(signalClientConnected(TQ_UINT32)),
this, TQT_SLOT(slotClientConnected(TQ_UINT32)));
connect(this, TQT_SIGNAL(signalClientDisconnected(TQ_UINT32,bool)),
this, TQT_SLOT(slotClientDisconnected(TQ_UINT32,bool)));
connect(this, TQT_SIGNAL(signalConnectionBroken()),
this, TQT_SLOT(slotServerDisconnected()));
connect(this, TQ_SIGNAL(signalClientConnected(TQ_UINT32)),
this, TQ_SLOT(slotClientConnected(TQ_UINT32)));
connect(this, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32,bool)),
this, TQ_SLOT(slotClientDisconnected(TQ_UINT32,bool)));
connect(this, TQ_SIGNAL(signalConnectionBroken()),
this, TQ_SLOT(slotServerDisconnected()));
setGameSequence(new KGameSequence());
// BL: FIXME This signal does no longer exist. When we are merging
// MH: super....and how do I find out about the lost conenction now?
// KGame and KGameNetwork, this could be improved!
// connect(this,TQT_SIGNAL(signalConnectionLost(KGameClient *)),
// this,TQT_SLOT(slotConnectionLost(KGameClient *)));
// connect(this,TQ_SIGNAL(signalConnectionLost(KGameClient *)),
// this,TQ_SLOT(slotConnectionLost(KGameClient *)));
}
KGame::~KGame()
@ -780,7 +780,7 @@ KPlayer * KGame::playerInputFinished(KPlayer *player)
player->setTurn(false); // in turn based games we have to switch off input now
if (gameSequence())
{
TQTimer::singleShot(0,this,TQT_SLOT(prepareNext()));
TQTimer::singleShot(0,this,TQ_SLOT(prepareNext()));
}
}
return player;

22
libtdegames/kgame/kgamechat.cpp
Unescape View File

@ -227,13 +227,13 @@ void KGameChat::setKGame(KGame* g)
d->mGame = g;
if (d->mGame) {
connect(d->mGame, TQT_SIGNAL(signalPlayerJoinedGame(KPlayer*)),
this, TQT_SLOT(slotAddPlayer(KPlayer*)));
connect(d->mGame, TQT_SIGNAL(signalPlayerLeftGame(KPlayer*)),
this, TQT_SLOT(slotRemovePlayer(KPlayer*)));
connect(d->mGame, TQT_SIGNAL(signalNetworkData(int, const TQByteArray&, TQ_UINT32, TQ_UINT32)),
this, TQT_SLOT(slotReceiveMessage(int, const TQByteArray&, TQ_UINT32, TQ_UINT32)));
connect(d->mGame, TQT_SIGNAL(destroyed()), this, TQT_SLOT(slotUnsetKGame()));
connect(d->mGame, TQ_SIGNAL(signalPlayerJoinedGame(KPlayer*)),
this, TQ_SLOT(slotAddPlayer(KPlayer*)));
connect(d->mGame, TQ_SIGNAL(signalPlayerLeftGame(KPlayer*)),
this, TQ_SLOT(slotRemovePlayer(KPlayer*)));
connect(d->mGame, TQ_SIGNAL(signalNetworkData(int, const TQByteArray&, TQ_UINT32, TQ_UINT32)),
this, TQ_SLOT(slotReceiveMessage(int, const TQByteArray&, TQ_UINT32, TQ_UINT32)));
connect(d->mGame, TQ_SIGNAL(destroyed()), this, TQ_SLOT(slotUnsetKGame()));
TQPtrList<KPlayer> playerList = *d->mGame->playerList();
for (int unsigned i = 0; i < playerList.count(); i++) {
@ -281,10 +281,10 @@ void KGameChat::slotAddPlayer(KPlayer* p)
int sendingId = nextId();
addSendingEntry(comboBoxItem(p->name()), sendingId);
d->mSendId2PlayerId.insert(sendingId, p->id());
connect(p, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
this, TQT_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
connect(p, TQT_SIGNAL(signalNetworkData(int, const TQByteArray&, TQ_UINT32, KPlayer*)),
this, TQT_SLOT(slotReceivePrivateMessage(int, const TQByteArray&, TQ_UINT32, KPlayer*)));
connect(p, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase*, KPlayer*)),
this, TQ_SLOT(slotPropertyChanged(KGamePropertyBase*, KPlayer*)));
connect(p, TQ_SIGNAL(signalNetworkData(int, const TQByteArray&, TQ_UINT32, KPlayer*)),
this, TQ_SLOT(slotReceivePrivateMessage(int, const TQByteArray&, TQ_UINT32, KPlayer*)));
}
void KGameChat::slotRemovePlayer(KPlayer* p)

14
libtdegames/kgame/kgameio.cpp
Unescape View File

@ -266,12 +266,12 @@ KGameProcessIO::KGameProcessIO(const TQString& name)
//kdDebug(11001) << "================= KMEssage SetSErver ==================== " << endl;
//d->mMessageClient->setServer(d->mMessageServer);
kdDebug(11001) << "================= KMEssage: Connect ==================== " << endl;
//connect(d->mMessageClient, TQT_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
// this, TQT_SLOT(clientMessage(const TQByteArray&, TQ_UINT32)));
//connect(d->mMessageClient, TQT_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList <TQ_UINT32> &)),
// this, TQT_SLOT(clientMessage(const TQByteArray&, TQ_UINT32, const TQValueList <TQ_UINT32> &)));
connect(d->mProcessIO, TQT_SIGNAL(received(const TQByteArray&)),
this, TQT_SLOT(receivedMessage(const TQByteArray&)));
//connect(d->mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
// this, TQ_SLOT(clientMessage(const TQByteArray&, TQ_UINT32)));
//connect(d->mMessageClient, TQ_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList <TQ_UINT32> &)),
// this, TQ_SLOT(clientMessage(const TQByteArray&, TQ_UINT32, const TQValueList <TQ_UINT32> &)));
connect(d->mProcessIO, TQ_SIGNAL(received(const TQByteArray&)),
this, TQ_SLOT(receivedMessage(const TQByteArray&)));
//kdDebug(11001) << "Our client is id="<<d->mMessageClient->id() << endl;
}
@ -489,7 +489,7 @@ void KGameComputerIO::setAdvancePeriod(int ms)
{
stopAdvancePeriod();
d->mAdvanceTimer = new TQTimer(this);
connect(d->mAdvanceTimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(advance()));
connect(d->mAdvanceTimer, TQ_SIGNAL(timeout()), this, TQ_SLOT(advance()));
d->mAdvanceTimer->start(ms);
}

16
libtdegames/kgame/kgameio.h
Unescape View File

@ -195,8 +195,8 @@ public:
* \code
* KGameKeyIO *input;
* input=new KGameKeyIO(myWidget);
* connect(input,TQT_SIGNAL(signalKeyEvent(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)),
* this,TQT_SLOT(slotKeyInput(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)));
* connect(input,TQ_SIGNAL(signalKeyEvent(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)),
* this,TQ_SLOT(slotKeyInput(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)));
* \endcode
*
* @param parent The parents widget whose keyboard events * should be grabbed
@ -261,8 +261,8 @@ public:
* \code
* KGameMouseIO *input;
* input=new KGameMouseIO(mView);
* connect(input,TQT_SIGNAL(signalMouseEvent(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)),
* this,TQT_SLOT(slotMouseInput(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)));
* connect(input,TQ_SIGNAL(signalMouseEvent(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)),
* this,TQ_SLOT(slotMouseInput(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)));
* \endcode
*
* @param parent The widget whose events should be captured
@ -336,10 +336,10 @@ public:
* \code
* KGameProcessIO *input;
* input=new KGameProcessIO(executable_file);
* connect(input,TQT_SIGNAL(signalPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)),
* this,TQT_SLOT(slotPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)));
* connect(input,TQT_SIGNAL(signalProcessQuery(TQDataStream &,KGameProcessIO *)),
* this,TQT_SLOT(slotProcessQuery(TQDataStream &,KGameProcessIO *)));
* connect(input,TQ_SIGNAL(signalPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)),
* this,TQ_SLOT(slotPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)));
* connect(input,TQ_SIGNAL(signalProcessQuery(TQDataStream &,KGameProcessIO *)),
* this,TQ_SLOT(slotProcessQuery(TQDataStream &,KGameProcessIO *)));
* \endcode
*
* @param name the filename of the process to start

34
libtdegames/kgame/kgamenetwork.cpp
Unescape View File

@ -120,25 +120,25 @@ void KGameNetwork::setMaster()
}
if (!d->mMessageClient) {
d->mMessageClient = new KMessageClient (this);
connect (d->mMessageClient, TQT_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
this, TQT_SLOT(receiveNetworkTransmission(const TQByteArray&, TQ_UINT32)));
connect (d->mMessageClient, TQT_SIGNAL(connectionBroken()),
this, TQT_SIGNAL(signalConnectionBroken()));
connect (d->mMessageClient, TQT_SIGNAL(aboutToDisconnect(TQ_UINT32)),
this, TQT_SLOT(aboutToLoseConnection(TQ_UINT32)));
connect (d->mMessageClient, TQT_SIGNAL(connectionBroken()),
this, TQT_SLOT(slotResetConnection()));
connect (d->mMessageClient, TQT_SIGNAL(adminStatusChanged(bool)),
this, TQT_SLOT(slotAdminStatusChanged(bool)));
connect (d->mMessageClient, TQT_SIGNAL(eventClientConnected(TQ_UINT32)),
this, TQT_SIGNAL(signalClientConnected(TQ_UINT32)));
connect (d->mMessageClient, TQT_SIGNAL(eventClientDisconnected(TQ_UINT32, bool)),
this, TQT_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)));
connect (d->mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
this, TQ_SLOT(receiveNetworkTransmission(const TQByteArray&, TQ_UINT32)));
connect (d->mMessageClient, TQ_SIGNAL(connectionBroken()),
this, TQ_SIGNAL(signalConnectionBroken()));
connect (d->mMessageClient, TQ_SIGNAL(aboutToDisconnect(TQ_UINT32)),
this, TQ_SLOT(aboutToLoseConnection(TQ_UINT32)));
connect (d->mMessageClient, TQ_SIGNAL(connectionBroken()),
this, TQ_SLOT(slotResetConnection()));
connect (d->mMessageClient, TQ_SIGNAL(adminStatusChanged(bool)),
this, TQ_SLOT(slotAdminStatusChanged(bool)));
connect (d->mMessageClient, TQ_SIGNAL(eventClientConnected(TQ_UINT32)),
this, TQ_SIGNAL(signalClientConnected(TQ_UINT32)));
connect (d->mMessageClient, TQ_SIGNAL(eventClientDisconnected(TQ_UINT32, bool)),
this, TQ_SIGNAL(signalClientDisconnected(TQ_UINT32, bool)));
// broacast and direct messages are treated equally on receive.
connect (d->mMessageClient, TQT_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList<TQ_UINT32>&)),
d->mMessageClient, TQT_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)));
connect (d->mMessageClient, TQ_SIGNAL(forwardReceived(const TQByteArray&, TQ_UINT32, const TQValueList<TQ_UINT32>&)),
d->mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)));
} else {
// should be no problem but still has to be tested

8
libtdegames/kgame/kgameprocess.cpp
Unescape View File

@ -52,10 +52,10 @@ KGameProcess::KGameProcess() : TQObject(0,0)
mMessageIO=new KMessageFilePipe(this,&rFile,&wFile);
// mMessageClient=new KMessageClient(this);
// mMessageClient->setServer(mMessageIO);
// connect (mMessageClient, TQT_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
// this, TQT_SLOT(receivedMessage(const TQByteArray&, TQ_UINT32)));
connect (mMessageIO, TQT_SIGNAL(received(const TQByteArray&)),
this, TQT_SLOT(receivedMessage(const TQByteArray&)));
// connect (mMessageClient, TQ_SIGNAL(broadcastReceived(const TQByteArray&, TQ_UINT32)),
// this, TQ_SLOT(receivedMessage(const TQByteArray&, TQ_UINT32)));
connect (mMessageIO, TQ_SIGNAL(received(const TQByteArray&)),
this, TQ_SLOT(receivedMessage(const TQByteArray&)));
fprintf(stderr,"KGameProcess::constructor %p %p\n",&rFile,&wFile);
mRandom = new KRandomSequence;

12
libtdegames/kgame/kgameprocess.h
Unescape View File

@ -61,12 +61,12 @@ class KDE_EXPORT KGameProcess: public TQObject
* int main(int argc ,char * argv[])
* {
* KGameProcess proc;
* connect(&proc,TQT_SIGNAL(signalCommand(TQDataStream &,int ,int ,int )),
* this,TQT_SLOT(slotCommand(TQDataStream & ,int ,int ,int )));
* connect(&proc,TQT_SIGNAL(signalInit(TQDataStream &,int)),
* this,TQT_SLOT(slotInit(TQDataStream & ,int )));
* connect(&proc,TQT_SIGNAL(signalTurn(TQDataStream &,bool )),
* this,TQT_SLOT(slotTurn(TQDataStream & ,bool )));
* connect(&proc,TQ_SIGNAL(signalCommand(TQDataStream &,int ,int ,int )),
* this,TQ_SLOT(slotCommand(TQDataStream & ,int ,int ,int )));
* connect(&proc,TQ_SIGNAL(signalInit(TQDataStream &,int)),
* this,TQ_SLOT(slotInit(TQDataStream & ,int )));
* connect(&proc,TQ_SIGNAL(signalTurn(TQDataStream &,bool )),
* this,TQ_SLOT(slotTurn(TQDataStream & ,bool )));
* return proc.exec(argc,argv);
* }
* \endcode

8
libtdegames/kgame/kgamepropertyhandler.cpp
Unescape View File

@ -94,12 +94,12 @@ void KGamePropertyHandler::registerHandler(int id,const TQObject * receiver, con
{
setId(id);
if (receiver && sendf) {
kdDebug(11001) << "Connecting TQT_SLOT " << sendf << endl;
connect(this, TQT_SIGNAL(signalSendMessage(int, TQDataStream &, bool*)), receiver, sendf);
kdDebug(11001) << "Connecting TQ_SLOT " << sendf << endl;
connect(this, TQ_SIGNAL(signalSendMessage(int, TQDataStream &, bool*)), receiver, sendf);
}
if (receiver && emitf) {
kdDebug(11001) << "Connecting TQT_SLOT " << emitf << endl;
connect(this, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *)), receiver, emitf);
kdDebug(11001) << "Connecting TQ_SLOT " << emitf << endl;
connect(this, TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *)), receiver, emitf);
}
}

12
libtdegames/kgame/kmessageclient.cpp
Unescape View File

@ -86,10 +86,10 @@ void KMessageClient::setServer (KMessageIO *connection)
d->connection = connection;
if (connection )
{
connect (connection, TQT_SIGNAL (received(const TQByteArray &)),
this, TQT_SLOT (processIncomingMessage(const TQByteArray &)));
connect (connection, TQT_SIGNAL (connectionBroken()),
this, TQT_SLOT (removeBrokenConnection ()));
connect (connection, TQ_SIGNAL (received(const TQByteArray &)),
this, TQ_SLOT (processIncomingMessage(const TQByteArray &)));
connect (connection, TQ_SIGNAL (connectionBroken()),
this, TQ_SLOT (removeBrokenConnection ()));
}
}
@ -322,7 +322,7 @@ void KMessageClient::removeBrokenConnection ()
{
kdDebug (11001) << k_funcinfo << ": timer single shot for removeBrokenConnection"<<this << endl;
// MH We cannot directly delete the socket. otherwise TQSocket crashes
TQTimer::singleShot( 0, this, TQT_SLOT(removeBrokenConnection2()) );
TQTimer::singleShot( 0, this, TQ_SLOT(removeBrokenConnection2()) );
return;
}
@ -361,7 +361,7 @@ void KMessageClient::unlock ()
d->isLocked = false;
for (unsigned int i = 0; i < d->delayedMessages.count(); i++)
{
TQTimer::singleShot(0, this, TQT_SLOT(processFirstMessage()));
TQTimer::singleShot(0, this, TQ_SLOT(processFirstMessage()));
}
}

4
libtdegames/kgame/kmessageclient.h
Unescape View File

@ -295,8 +295,8 @@ signals:
\code
KMessageClient *client = new KMessageClient ();
connect (client, TQT_SIGNAL (forwardReceived (const TQByteArray &, TQ_UINT32, const TQValueList <TQ_UINT32>&)),
client, TQT_SIGNAL (broadcastReceived (const TQByteArray &, TQ_UINT32)));
connect (client, TQ_SIGNAL (forwardReceived (const TQByteArray &, TQ_UINT32, const TQValueList <TQ_UINT32>&)),
client, TQ_SIGNAL (broadcastReceived (const TQByteArray &, TQ_UINT32)));
\endcode
Then connect the broadcast signal to your slot that analyzes the message.

22
libtdegames/kgame/kmessageio.cpp
Unescape View File

@ -157,9 +157,9 @@ void KMessageSocket::processNewData ()
void KMessageSocket::initSocket ()
{
connect (mSocket, TQT_SIGNAL (error(int)), TQT_SIGNAL (connectionBroken()));
connect (mSocket, TQT_SIGNAL (connectionClosed()), TQT_SIGNAL (connectionBroken()));
connect (mSocket, TQT_SIGNAL (readyRead()), TQT_SLOT (processNewData()));
connect (mSocket, TQ_SIGNAL (error(int)), TQ_SIGNAL (connectionBroken()));
connect (mSocket, TQ_SIGNAL (connectionClosed()), TQ_SIGNAL (connectionBroken()));
connect (mSocket, TQ_SIGNAL (readyRead()), TQ_SLOT (processNewData()));
mAwaitingHeader = true;
mNextBlockLength = 0;
isRecursive = false;
@ -248,14 +248,14 @@ KMessageProcess::KMessageProcess(TQObject *parent, TQString file) : KMessageIO(p
*mProcess << mProcessName << TQString("%1").arg(id);
kdDebug(11001) << "@@@KMessageProcess::Init:Id= " << id << endl;
kdDebug(11001) << "@@@KMessgeProcess::Init:Processname: " << mProcessName << endl;
connect(mProcess, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int )),
this, TQT_SLOT(slotReceivedStdout(TDEProcess *, char * , int )));
connect(mProcess, TQT_SIGNAL(receivedStderr(TDEProcess *, char *, int )),
this, TQT_SLOT(slotReceivedStderr(TDEProcess *, char * , int )));
connect(mProcess, TQT_SIGNAL(processExited(TDEProcess *)),
this, TQT_SLOT(slotProcessExited(TDEProcess *)));
connect(mProcess, TQT_SIGNAL(wroteStdin(TDEProcess *)),
this, TQT_SLOT(slotWroteStdin(TDEProcess *)));
connect(mProcess, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int )),
this, TQ_SLOT(slotReceivedStdout(TDEProcess *, char * , int )));
connect(mProcess, TQ_SIGNAL(receivedStderr(TDEProcess *, char *, int )),
this, TQ_SLOT(slotReceivedStderr(TDEProcess *, char * , int )));
connect(mProcess, TQ_SIGNAL(processExited(TDEProcess *)),
this, TQ_SLOT(slotProcessExited(TDEProcess *)));
connect(mProcess, TQ_SIGNAL(wroteStdin(TDEProcess *)),
this, TQ_SLOT(slotWroteStdin(TDEProcess *)));
mProcess->start(TDEProcess::NotifyOnExit,TDEProcess::All);
mSendBuffer=0;
mReceiveCount=0;

16
libtdegames/kgame/kmessageserver.cpp
Unescape View File

@ -92,8 +92,8 @@ KMessageServer::KMessageServer (TQ_UINT16 cookie,TQObject* parent)
d = new KMessageServerPrivate;
d->mIsRecursive=false;
d->mCookie=cookie;
connect (&(d->mTimer), TQT_SIGNAL (timeout()),
this, TQT_SLOT (processOneMessage()));
connect (&(d->mTimer), TQ_SIGNAL (timeout()),
this, TQ_SLOT (processOneMessage()));
kdDebug(11001) << "CREATE(KMessageServer="
<< this
<< ") cookie="
@ -138,8 +138,8 @@ bool KMessageServer::initNetwork (TQ_UINT16 port)
kdDebug (11001) << k_funcinfo << ": Now listening to port "
<< d->mServerSocket->port() << endl;
connect (d->mServerSocket, TQT_SIGNAL (newClientConnected (KMessageIO*)),
this, TQT_SLOT (addClient (KMessageIO*)));
connect (d->mServerSocket, TQ_SIGNAL (newClientConnected (KMessageIO*)),
this, TQ_SLOT (addClient (KMessageIO*)));
return true;
}
@ -183,10 +183,10 @@ void KMessageServer::addClient (KMessageIO* client)
kdDebug (11001) << k_funcinfo << ": " << client->id() << endl;
// connect its signals
connect (client, TQT_SIGNAL (connectionBroken()),
this, TQT_SLOT (removeBrokenClient()));
connect (client, TQT_SIGNAL (received (const TQByteArray &)),
this, TQT_SLOT (getReceivedMessage (const TQByteArray &)));
connect (client, TQ_SIGNAL (connectionBroken()),
this, TQ_SLOT (removeBrokenClient()));
connect (client, TQ_SIGNAL (received (const TQByteArray &)),
this, TQ_SLOT (getReceivedMessage (const TQByteArray &)));
// Tell everyone about the new guest
// Note: The new client doesn't get this message!

4
libtdegames/kgame/kplayer.cpp
Unescape View File

@ -78,8 +78,8 @@ void KPlayer::init()
d = new KPlayerPrivate;
d->mProperties.registerHandler(KGameMessage::IdPlayerProperty,
this,TQT_SLOT(sendProperty(int, TQDataStream&, bool*)),
TQT_SLOT(emitSignal(KGamePropertyBase *)));
this,TQ_SLOT(sendProperty(int, TQDataStream&, bool*)),
TQ_SLOT(emitSignal(KGamePropertyBase *)));
d->mVirtual=false;
mActive=true;
mGame=0;

4
libtdegames/kgamelcd.cpp
Unescape View File

@ -36,7 +36,7 @@ KGameLCD::KGameLCD(uint nbDigits, TQWidget *parent, const char *name)
_hlColor = p.color(TQPalette::Active, TQColorGroup::HighlightedText);
_timer = new TQTimer(this);
connect(_timer, TQT_SIGNAL(timeout()), TQT_SLOT(timeout()));
connect(_timer, TQ_SIGNAL(timeout()), TQ_SLOT(timeout()));
setFrameStyle(Panel | Plain);
setSegmentStyle(Flat);
@ -114,7 +114,7 @@ KGameLCDClock::KGameLCDClock(TQWidget *parent, const char *name)
: KGameLCD(5, parent, name)
{
_timerClock = new TQTimer(this);
connect(_timerClock, TQT_SIGNAL(timeout()), TQT_SLOT(timeoutClock()));
connect(_timerClock, TQ_SIGNAL(timeout()), TQ_SLOT(timeoutClock()));
}
KGameLCDClock::~KGameLCDClock()

2
libtdegames/kgameprogress.cpp
Unescape View File

@ -72,7 +72,7 @@ void KGameProgress::initialize()
bar_style = Solid;
text_enabled = TRUE;
setBackgroundMode( PaletteBackground );
connect(kapp, TQT_SIGNAL(appearanceChanged()), this, TQT_SLOT(paletteChange()));
connect(kapp, TQ_SIGNAL(appearanceChanged()), this, TQ_SLOT(paletteChange()));
paletteChange();
}

28
lskat/lskat/KEInput.cpp
Unescape View File

@ -127,22 +127,22 @@ bool KEInput::SetInputDevice(int no, KG_INPUTTYPE type,KEMessage *msg)
switch(QueryType(no))
{
case KG_INPUTTYPE_INTERACTIVE:
connect(playerArray[no].QueryInteractiveConnect(),TQT_SIGNAL(signalReceiveMsg(KEMessage *,int )),
this,TQT_SLOT(slotSetInput(KEMessage *,int )));
connect(playerArray[no].QueryInteractiveConnect(),TQT_SIGNAL(signalPrepareMove(KEMessage *,KG_INPUTTYPE)),
this,TQT_SLOT(slotPrepareMove(KEMessage *,KG_INPUTTYPE)));
connect(playerArray[no].QueryInteractiveConnect(),TQ_SIGNAL(signalReceiveMsg(KEMessage *,int )),
this,TQ_SLOT(slotSetInput(KEMessage *,int )));
connect(playerArray[no].QueryInteractiveConnect(),TQ_SIGNAL(signalPrepareMove(KEMessage *,KG_INPUTTYPE)),
this,TQ_SLOT(slotPrepareMove(KEMessage *,KG_INPUTTYPE)));
break;
case KG_INPUTTYPE_REMOTE:
connect(playerArray[no].QueryRemoteConnect(),TQT_SIGNAL(signalReceiveMsg(KEMessage *,int )),
this,TQT_SLOT(slotSetInput(KEMessage *,int )));
connect(playerArray[no].QueryRemoteConnect(),TQT_SIGNAL(signalPrepareMove(KEMessage *,KG_INPUTTYPE)),
this,TQT_SLOT(slotPrepareMove(KEMessage *,KG_INPUTTYPE)));
connect(playerArray[no].QueryRemoteConnect(),TQ_SIGNAL(signalReceiveMsg(KEMessage *,int )),
this,TQ_SLOT(slotSetInput(KEMessage *,int )));
connect(playerArray[no].QueryRemoteConnect(),TQ_SIGNAL(signalPrepareMove(KEMessage *,KG_INPUTTYPE)),
this,TQ_SLOT(slotPrepareMove(KEMessage *,KG_INPUTTYPE)));
break;
case KG_INPUTTYPE_PROCESS:
connect(playerArray[no].QueryProcessConnect(),TQT_SIGNAL(signalReceiveMsg(KEMessage *,int )),
this,TQT_SLOT(slotSetInput(KEMessage *,int )));
connect(playerArray[no].QueryProcessConnect(),TQT_SIGNAL(signalPrepareMove(KEMessage *,KG_INPUTTYPE)),
this,TQT_SLOT(slotPrepareMove(KEMessage *,KG_INPUTTYPE)));
connect(playerArray[no].QueryProcessConnect(),TQ_SIGNAL(signalReceiveMsg(KEMessage *,int )),
this,TQ_SLOT(slotSetInput(KEMessage *,int )));
connect(playerArray[no].QueryProcessConnect(),TQ_SIGNAL(signalPrepareMove(KEMessage *,KG_INPUTTYPE)),
this,TQ_SLOT(slotPrepareMove(KEMessage *,KG_INPUTTYPE)));
break;
default:
break;
@ -190,7 +190,7 @@ bool KEInput::Next(int number, bool force)
// delay non interactive move to allow interactive inout
if (cTimer) delete cTimer; // Ouch...
cTimer=new TQTimer(this);
connect(cTimer,TQT_SIGNAL(timeout()),this,TQT_SLOT(slotTimerNextRemote()));
connect(cTimer,TQ_SIGNAL(timeout()),this,TQ_SLOT(slotTimerNextRemote()));
cTimer->start(K_INPUT_DELAY,TRUE);
}
else
@ -204,7 +204,7 @@ bool KEInput::Next(int number, bool force)
{
// delay non interactive move to allow interactive inout
cTimer=new TQTimer(this);
connect(cTimer,TQT_SIGNAL(timeout()),this,TQT_SLOT(slotTimerNextProcess()));
connect(cTimer,TQ_SIGNAL(timeout()),this,TQ_SLOT(slotTimerNextProcess()));
cTimer->start(K_INPUT_DELAY,TRUE);
}
else

4
lskat/lskat/KInputChildProcess.cpp
Unescape View File

@ -36,8 +36,8 @@ bool KInputChildProcess::exec()
childConnect=new KChildConnect;
if (!childConnect) return false;
connect(childConnect,TQT_SIGNAL(signalReceiveMsg(KEMessage *,int)),
this,TQT_SLOT(slotReceiveMsg(KEMessage *,int)));
connect(childConnect,TQ_SIGNAL(signalReceiveMsg(KEMessage *,int)),
this,TQ_SLOT(slotReceiveMsg(KEMessage *,int)));
do
{
// Wait for input

8
lskat/lskat/KRSocket.cpp
Unescape View File

@ -114,7 +114,7 @@ KRServerSocket::KRServerSocket( const char *_path, int optname, int value, int l
}
notifier = new TQSocketNotifier( sock, TQSocketNotifier::Read );
connect( notifier, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( slotAccept(int) ) );
connect( notifier, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( slotAccept(int) ) );
}
KRServerSocket::KRServerSocket( const char *_path ) :
@ -129,7 +129,7 @@ KRServerSocket::KRServerSocket( const char *_path ) :
}
notifier = new TQSocketNotifier( sock, TQSocketNotifier::Read );
connect( notifier, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( slotAccept(int) ) );
connect( notifier, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( slotAccept(int) ) );
}
KRServerSocket::KRServerSocket( unsigned short int _port ) :
@ -144,7 +144,7 @@ KRServerSocket::KRServerSocket( unsigned short int _port ) :
}
notifier = new TQSocketNotifier( sock, TQSocketNotifier::Read );
connect( notifier, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( slotAccept(int) ) );
connect( notifier, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( slotAccept(int) ) );
}
KRServerSocket::KRServerSocket( unsigned short int _port,int optname,int value,int level ) :
@ -159,7 +159,7 @@ KRServerSocket::KRServerSocket( unsigned short int _port,int optname,int value,i
}
notifier = new TQSocketNotifier( sock, TQSocketNotifier::Read );
connect( notifier, TQT_SIGNAL( activated(int) ), this, TQT_SLOT( slotAccept(int) ) );
connect( notifier, TQ_SIGNAL( activated(int) ), this, TQ_SLOT( slotAccept(int) ) );
}
bool KRServerSocket::init( const char *_path )

28
lskat/lskat/KRemoteConnect.cpp
Unescape View File

@ -110,13 +110,13 @@ bool tryserver;
{
kSocket->enableRead(TRUE);
//kSocket->enableWrite(TRUE);
connect(kSocket,TQT_SIGNAL(closeEvent(TDESocket *)),
this,TQT_SLOT(socketClosed(TDESocket *)));
connect(kSocket,TQT_SIGNAL(readEvent(TDESocket *)),
this,TQT_SLOT(socketRead(TDESocket *)));
connect(kSocket,TQ_SIGNAL(closeEvent(TDESocket *)),
this,TQ_SLOT(socketClosed(TDESocket *)));
connect(kSocket,TQ_SIGNAL(readEvent(TDESocket *)),
this,TQ_SLOT(socketRead(TDESocket *)));
/*
connect(kSocket,TQT_SIGNAL(writeEvent(TDESocket *)),
this,TQT_SLOT(socketWrite(TDESocket *)));
connect(kSocket,TQ_SIGNAL(writeEvent(TDESocket *)),
this,TQ_SLOT(socketWrite(TDESocket *)));
*/
/*
printf("Socket(%d) %p connection built to a server\n",
@ -187,8 +187,8 @@ bool KRemoteConnect::OfferServerSocket()
printf("Offering socket and publishing stuff\n");
service = new DNSSD::PublicService(Name,LSKAT_SERVICE,port);
service->publishAsync();
connect(kServerSocket,TQT_SIGNAL(accepted(TDESocket *)),
this,TQT_SLOT(socketRequest(TDESocket *)));
connect(kServerSocket,TQ_SIGNAL(accepted(TDESocket *)),
this,TQ_SLOT(socketRequest(TDESocket *)));
return true;
}
@ -206,13 +206,13 @@ void KRemoteConnect::socketRequest(TDESocket *sock)
{
kSocket->enableRead(TRUE);
//kSocket->enableWrite(TRUE);
connect(kSocket,TQT_SIGNAL(closeEvent(TDESocket *)),
this,TQT_SLOT(socketClosed(TDESocket *)));
connect(kSocket,TQT_SIGNAL(readEvent(TDESocket *)),
this,TQT_SLOT(socketRead(TDESocket *)));
connect(kSocket,TQ_SIGNAL(closeEvent(TDESocket *)),
this,TQ_SLOT(socketClosed(TDESocket *)));
connect(kSocket,TQ_SIGNAL(readEvent(TDESocket *)),
this,TQ_SLOT(socketRead(TDESocket *)));
/*
connect(kSocket,TQT_SIGNAL(writeEvent(TDESocket *)),
this,TQT_SLOT(socketWrite(TDESocket *)));
connect(kSocket,TQ_SIGNAL(writeEvent(TDESocket *)),
this,TQ_SLOT(socketWrite(TDESocket *)));
*/
socketStatus=KR_SERVER;
delete kServerSocket; // no more connections

12
lskat/lskat/TDEProcessConnect.cpp
Unescape View File

@ -75,13 +75,13 @@ bool TDEProcessConnect::Init(int id,KEMessage *msg)
// create process
process=new TDEProcess;
*process << processname;
connect(process, TQT_SIGNAL(receivedStdout(TDEProcess *, char *, int )),
this, TQT_SLOT(slotReceivedStdout(TDEProcess *, char * , int )));
connect(process, TQT_SIGNAL(processExited(TDEProcess *)),
this, TQT_SLOT(slotProcessExited(TDEProcess *)));
connect(process, TQ_SIGNAL(receivedStdout(TDEProcess *, char *, int )),
this, TQ_SLOT(slotReceivedStdout(TDEProcess *, char * , int )));
connect(process, TQ_SIGNAL(processExited(TDEProcess *)),
this, TQ_SLOT(slotProcessExited(TDEProcess *)));
/*
connect(process, TQT_SIGNAL(wroteStdin(TDEProcess *)),
this, TQT_SLOT(slotWroteStdin(TDEProcess *)));
connect(process, TQ_SIGNAL(wroteStdin(TDEProcess *)),
this, TQ_SLOT(slotWroteStdin(TDEProcess *)));
*/
// TRUE if ok

48
lskat/lskat/lskat.cpp
Unescape View File

@ -75,14 +75,14 @@ LSkatApp::LSkatApp() : TDEMainWindow(0)
mInput=new KEInput(this);
doc->SetInputHandler(mInput);
connect(mInput,TQT_SIGNAL(signalPrepareProcessMove(KEMessage *)),
this,TQT_SLOT(slotPrepareProcessMove(KEMessage *)));
connect(mInput,TQT_SIGNAL(signalPrepareRemoteMove(KEMessage *)),
this,TQT_SLOT(slotPrepareRemoteMove(KEMessage *)));
connect(mInput,TQT_SIGNAL(signalPrepareInteractiveMove(KEMessage *)),
this,TQT_SLOT(slotPrepareInteractiveMove(KEMessage *)));
connect(mInput,TQT_SIGNAL(signalReceiveInput(KEMessage *, int)),
this,TQT_SLOT(slotReceiveInput(KEMessage *,int )));
connect(mInput,TQ_SIGNAL(signalPrepareProcessMove(KEMessage *)),
this,TQ_SLOT(slotPrepareProcessMove(KEMessage *)));
connect(mInput,TQ_SIGNAL(signalPrepareRemoteMove(KEMessage *)),
this,TQ_SLOT(slotPrepareRemoteMove(KEMessage *)));
connect(mInput,TQ_SIGNAL(signalPrepareInteractiveMove(KEMessage *)),
this,TQ_SLOT(slotPrepareInteractiveMove(KEMessage *)));
connect(mInput,TQ_SIGNAL(signalReceiveInput(KEMessage *, int)),
this,TQ_SLOT(slotReceiveInput(KEMessage *,int )));
setMinimumSize(640,480);
setMaximumSize(800,600);
@ -158,26 +158,26 @@ void LSkatApp::initGUI()
{
TQStringList list;
(void)KStdAction::openNew(this, TQT_SLOT(slotFileNew()), actionCollection(), "new_game");
(void)KStdAction::openNew(this, TQ_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, this, TQT_SLOT(slotFileEnd()),
(void)new TDEAction(i18n("&End Game"),"process-stop", 0, this, TQ_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, this, TQT_SLOT(slotFileStatistics()),
(void)new TDEAction(i18n("&Clear Statistics"),"flag", 0, this, TQ_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, this, TQT_SLOT(slotFileMessage()),
(void)new TDEAction(i18n("Send &Message..."), CTRL+Key_M, this, TQ_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(this, TQT_SLOT(slotFileQuit()), actionCollection(), "game_exit");
(void)KStdAction::quit(this, TQ_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,this,TQT_SLOT(slotStartplayer()),
(void)new TDESelectAction(i18n("Starting Player"),0,this,TQ_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,this,TQT_SLOT(slotPlayer1By()),
(void)new TDESelectAction(i18n("Player &1 Played By"),0,this,TQ_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,this,TQT_SLOT(slotPlayer2By()),
(void)new TDESelectAction(i18n("Player &2 Played By"),0,this,TQ_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,this,TQT_SLOT(slotLevel()),
(void)new TDESelectAction(i18n("&Level"),0,this,TQ_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,21 +211,21 @@ void LSkatApp::initGUI()
list.append(i18n("&Hard"));
((TDESelectAction *)ACTION("choose_level"))->setItems(list);
(void)new TDEAction(i18n("Select &Card Deck..."), 0, this, TQT_SLOT(slotOptionsCardDeck()),
(void)new TDEAction(i18n("Select &Card Deck..."), 0, this, TQ_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, this, TQT_SLOT(slotOptionsNames()),
(void)new TDEAction(i18n("Change &Names..."), 0, this, TQ_SLOT(slotOptionsNames()),
actionCollection(), "change_names");
ACTION("change_names")->setStatusText(i18n("Configure player names..."));
ACTION("change_names")->setWhatsThis(i18n("Configure player names..."));
actionCollection()->setHighlightingEnabled(true);
connect(actionCollection(), TQT_SIGNAL(actionStatusText(const TQString &)), TQT_SLOT(slotStatusMsg(const TQString &)));
connect(actionCollection(), TQT_SIGNAL(clearStatusText()), TQT_SLOT(slotClearStatusMsg()));
connect(actionCollection(), TQ_SIGNAL(actionStatusText(const TQString &)), TQ_SLOT(slotStatusMsg(const TQString &)));
connect(actionCollection(), TQ_SIGNAL(clearStatusText()), TQ_SLOT(slotClearStatusMsg()));
KStdAction::keyBindings(guiFactory(), TQT_SLOT(configureShortcuts()),
KStdAction::keyBindings(guiFactory(), TQ_SLOT(configureShortcuts()),
actionCollection());
}
@ -243,7 +243,7 @@ void LSkatApp::initStatusBar()
// computer move timer
procTimer=new TQTimer(this);
connect(procTimer,TQT_SIGNAL(timeout()),this,TQT_SLOT(slotProcTimer()));
connect(procTimer,TQ_SIGNAL(timeout()),this,TQ_SLOT(slotProcTimer()));
}
void LSkatApp::initDocument()
@ -349,7 +349,7 @@ bool LSkatApp::queryExit()
}
/////////////////////////////////////////////////////////////////////
// TQT_SLOT IMPLEMENTATION
// SLOT IMPLEMENTATION
/////////////////////////////////////////////////////////////////////
void LSkatApp::slotFileStatistics()

4
lskat/lskat/lskatview.cpp
Unescape View File

@ -119,12 +119,12 @@ LSkatView::LSkatView(TQWidget *parent, const char *name) : TQWidget(parent, name
moveTimer=new TQTimer(this);
moveTimer->stop();
connect(moveTimer,TQT_SIGNAL(timeout()),this,TQT_SLOT(moveTimerReady()));
connect(moveTimer,TQ_SIGNAL(timeout()),this,TQ_SLOT(moveTimerReady()));
introcnt=0;
introTimer=new TQTimer(this);
introTimer->stop();
connect(introTimer,TQT_SIGNAL(timeout()),this,TQT_SLOT(introTimerReady()));
connect(introTimer,TQ_SIGNAL(timeout()),this,TQ_SLOT(introTimerReady()));
introTimer->start(75,FALSE);
for (int i=0;i<NO_OF_CARDS;i++)

4
lskat/lskat/msgdlg.cpp
Unescape View File

@ -57,12 +57,12 @@ MsgDlg::MsgDlg( TQWidget *parent, const char *name,const char * /*sufi */ )
TQPushButton *PushButton;
PushButton = new TQPushButton( i18n("Send" ), this, "PushButton_1" );
PushButton->setGeometry( 20, 120, 65, 30 );
connect( PushButton, TQT_SIGNAL(clicked()), TQT_SLOT(accept()) );
connect( PushButton, TQ_SIGNAL(clicked()), TQ_SLOT(accept()) );
PushButton->setAutoRepeat( FALSE );
PushButton = new KPushButton( KStdGuiItem::cancel(), this, "PushButton_2" );
PushButton->setGeometry( 305, 120, 65, 30 );
connect( PushButton, TQT_SIGNAL(clicked()), TQT_SLOT(reject()) );
connect( PushButton, TQ_SIGNAL(clicked()), TQ_SLOT(reject()) );
PushButton->setAutoRepeat( FALSE );
}

2
lskat/lskat/networkdlg.cpp
Unescape View File

@ -29,7 +29,7 @@ NetworkDlg::NetworkDlg( TQWidget *parent, const char *name )
: NetworkDlgBase( parent, name, TRUE )
{
browser = new DNSSD::ServiceBrowser(TQString::fromLatin1(LSKAT_SERVICE));
connect(browser,TQT_SIGNAL(finished()),TQT_SLOT(gamesFound()));
connect(browser,TQ_SIGNAL(finished()),TQ_SLOT(gamesFound()));
browser->startBrowse();
}

4
lskat/lskatproc/KInputChildProcess.cpp
Unescape View File

@ -36,8 +36,8 @@ bool KInputChildProcess::exec()
childConnect=new KChildConnect;
if (!childConnect) return false;
connect(childConnect,TQT_SIGNAL(signalReceiveMsg(KEMessage *,int)),
this,TQT_SLOT(slotReceiveMsg(KEMessage *,int)));
connect(childConnect,TQ_SIGNAL(signalReceiveMsg(KEMessage *,int)),
this,TQ_SLOT(slotReceiveMsg(KEMessage *,int)));
do
{
// Wait for input

2
tdefifteen/src/gameboard.cpp
Unescape View File

@ -58,7 +58,7 @@ GameBoard::GameBoard(TQWidget *parent, const char *name)
dx = dy = 0;
tmr = new TQTimer(this);
TQObject::connect(tmr, SIGNAL(timeout()), this, SLOT(moveItem()));
TQObject::connect(tmr, TQ_SIGNAL(timeout()), this, TQ_SLOT(moveItem()));
setEnabled(TRUE);
origin = xpm;
}

6
tdefifteen/src/mainwindow.cpp
Unescape View File

@ -11,11 +11,11 @@
MainWindow::MainWindow(TQWidget* parent, const char* name) : TDEMainWindow(parent, name)
{
TDEAction* actionQuit = KStdAction::quit(this, SLOT(close()), 0);
TDEAction* actionNew = new TDEAction( "&New Game", "reload", TQt::CTRL + TQt::Key_N, this, SLOT(newGame()), this, "New Game");
TDEAction* actionQuit = KStdAction::quit(this, TQ_SLOT(close()), 0);
TDEAction* actionNew = new TDEAction( "&New Game", "reload", TQt::CTRL + TQt::Key_N, this, TQ_SLOT(newGame()), this, "New Game");
mMenu = new TDEPopupMenu(this);
mMenu->insertItem(SmallIcon("images_display"), "Load an image", this, SLOT(loadImage()), TQt::CTRL + TQt::Key_L);
mMenu->insertItem(SmallIcon("images_display"), "Load an image", this, TQ_SLOT(loadImage()), TQt::CTRL + TQt::Key_L);
mMenu->insertSeparator();
actionNew->plug(mMenu);

4
twin4/twin4/kspritecache.h
Unescape View File

@ -151,8 +151,8 @@ class KSprite : public TQCanvasSprite
* animation is finished.
* Example:
* <pre>
* connect(sprite->createNotify(),TQT_SIGNAL(signalNotify(TQCanvasItem *,int)),
* this,TQT_SLOT(moveDone(TQCanvasItem *,int)));
* connect(sprite->createNotify(),TQ_SIGNAL(signalNotify(TQCanvasItem *,int)),
* this,TQ_SLOT(moveDone(TQCanvasItem *,int)));
* </pre>
* In the move done function you best delete the notify again with
* @ref deleteNotify

62
twin4/twin4/twin4.cpp
Unescape View File

@ -82,7 +82,7 @@ ChatDlg::ChatDlg(KGame *game,TQWidget *parent)
adjustSize();
mChatDlg=new KChatDialog(mChat,plainPage(),true);
connect(mButton,TQT_SIGNAL(clicked()),mChatDlg,TQT_SLOT(show()));
connect(mButton,TQ_SIGNAL(clicked()),mChatDlg,TQ_SLOT(show()));
}
/**
@ -188,50 +188,50 @@ void Kwin4App::checkMenus(CheckFlags menu)
*/
void Kwin4App::initGUI()
{
KStdGameAction::gameNew(this, TQT_SLOT(newGame()), actionCollection(), "new_game");
KStdGameAction::gameNew(this, TQ_SLOT(newGame()), actionCollection(), "new_game");
ACTION("new_game")->setStatusText(i18n("Start a new game"));
KStdGameAction::load(this, TQT_SLOT(slotOpenGame()), actionCollection(), "open");
KStdGameAction::load(this, TQ_SLOT(slotOpenGame()), actionCollection(), "open");
ACTION("open")->setStatusText(i18n("Open a saved game..."));
KStdGameAction::save(this, TQT_SLOT(slotSaveGame()), actionCollection(), "save");
KStdGameAction::save(this, TQ_SLOT(slotSaveGame()), actionCollection(), "save");
ACTION("save")->setStatusText(i18n("Save a game..."));
KStdGameAction::end(this, TQT_SLOT(endGame()), actionCollection(), "end_game");
KStdGameAction::end(this, TQ_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, this, TQT_SLOT(slotInitNetwork()),
new TDEAction(i18n("&Network Configuration..."),0, this, TQ_SLOT(slotInitNetwork()),
actionCollection(), "network_conf");
new TDEAction(i18n("Network Chat..."),0, this, TQT_SLOT(slotChat()),
new TDEAction(i18n("Network Chat..."),0, this, TQ_SLOT(slotChat()),
actionCollection(), "network_chat");
if (global_debug>0)
new TDEAction(i18n("Debug KGame"), 0, this, TQT_SLOT(slotDebugKGame()),
new TDEAction(i18n("Debug KGame"), 0, this, TQ_SLOT(slotDebugKGame()),
actionCollection(), "file_debug");
new TDEAction(i18n("&Show Statistics"),"flag", 0, this,
TQT_SLOT(showStatistics()), actionCollection(), "statistics");
TQ_SLOT(showStatistics()), actionCollection(), "statistics");
ACTION("statistics")->setStatusText(i18n("Show statistics."));
KStdGameAction::hint(doc, TQT_SLOT(calcHint()), actionCollection(), "hint");
KStdGameAction::hint(doc, TQ_SLOT(calcHint()), actionCollection(), "hint");
ACTION("hint")->setStatusText(i18n("Shows a hint on how to move."));
KStdGameAction::quit(this, TQT_SLOT(close()), actionCollection(), "game_exit");
KStdGameAction::quit(this, TQ_SLOT(close()), actionCollection(), "game_exit");
ACTION("game_exit")->setStatusText(i18n("Quits the program."));
KStdGameAction::undo(this, TQT_SLOT(slotUndo()), actionCollection(), "edit_undo");
KStdGameAction::undo(this, TQ_SLOT(slotUndo()), actionCollection(), "edit_undo");
ACTION("edit_undo")->setStatusText(i18n("Undo last move."));
KStdGameAction::redo(this, TQT_SLOT(slotRedo()), actionCollection(), "edit_redo");
KStdGameAction::redo(this, TQ_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()));
connect(actionCollection(), TQ_SIGNAL(actionStatusText(const TQString &)), TQ_SLOT(slotStatusMsg(const TQString &)));
connect(actionCollection(), TQ_SIGNAL(clearStatusText()), TQ_SLOT(slotClearStatusText()));
KStdAction::preferences(this, TQT_SLOT(showSettings()), actionCollection());
KStdAction::preferences(this, TQ_SLOT(showSettings()), actionCollection());
}
/**
@ -263,17 +263,17 @@ void Kwin4App::initDocument()
{
doc = new Kwin4Doc(this);
// Game Over signal
connect(doc,TQT_SIGNAL(signalGameOver(int, KPlayer *,KGame *)),
this,TQT_SLOT(slotGameOver(int, KPlayer *,KGame *)));
connect(doc,TQT_SIGNAL(signalMoveDone(int, int)),
this,TQT_SLOT(slotMoveDone(int, int)));
connect(doc,TQT_SIGNAL(signalClientLeftGame(int, int,KGame *)),
this,TQT_SLOT(slotNetworkBroken(int, int, KGame *)));
connect(doc,TQT_SIGNAL(signalNextPlayer()),
this,TQT_SLOT(slotStatusNames()));
connect(doc,TQ_SIGNAL(signalGameOver(int, KPlayer *,KGame *)),
this,TQ_SLOT(slotGameOver(int, KPlayer *,KGame *)));
connect(doc,TQ_SIGNAL(signalMoveDone(int, int)),
this,TQ_SLOT(slotMoveDone(int, int)));
connect(doc,TQ_SIGNAL(signalClientLeftGame(int, int,KGame *)),
this,TQ_SLOT(slotNetworkBroken(int, int, KGame *)));
connect(doc,TQ_SIGNAL(signalNextPlayer()),
this,TQ_SLOT(slotStatusNames()));
connect(doc,TQT_SIGNAL(signalGameRun()),
this,TQT_SLOT(slotNewGame()));
connect(doc,TQ_SIGNAL(signalGameRun()),
this,TQ_SLOT(slotNewGame()));
}
void Kwin4App::changeAction(const char *action, bool enable){
@ -542,8 +542,8 @@ void Kwin4App::slotInitNetwork()
TQVBoxLayout *l=(TQVBoxLayout *)(box->layout());
mColorGroup=new TQVButtonGroup(box);
connect(mColorGroup, TQT_SIGNAL(clicked(int)), this, TQT_SLOT(slotRemoteChanged(int)));
connect(dlg.networkConfig(), TQT_SIGNAL(signalServerTypeChanged(int)), this, TQT_SLOT(slotServerTypeChanged(int)));
connect(mColorGroup, TQ_SIGNAL(clicked(int)), this, TQ_SLOT(slotRemoteChanged(int)));
connect(dlg.networkConfig(), TQ_SIGNAL(signalServerTypeChanged(int)), this, TQ_SLOT(slotServerTypeChanged(int)));
new TQRadioButton(i18n("Yellow should be played by remote"), mColorGroup);
new TQRadioButton(i18n("Red should be played by remote"), mColorGroup);
@ -590,8 +590,8 @@ void Kwin4App::slotChat()
mMyChatDlg->setPlayer(doc->getPlayer(Gelb));
else
mMyChatDlg->setPlayer(doc->getPlayer(Rot));
connect(doc,TQT_SIGNAL(signalChatChanged(Kwin4Player *)),
mMyChatDlg,TQT_SLOT(setPlayer(Kwin4Player *)));
connect(doc,TQ_SIGNAL(signalChatChanged(Kwin4Player *)),
mMyChatDlg,TQ_SLOT(setPlayer(Kwin4Player *)));
}
if (mMyChatDlg->isHidden())
@ -619,7 +619,7 @@ void Kwin4App::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()), doc, TQT_SLOT(loadSettings()));
connect(dialog, TQ_SIGNAL(settingsChanged()), doc, TQ_SLOT(loadSettings()));
dialog->show();
}

42
twin4/twin4/twin4doc.cpp
Unescape View File

@ -38,8 +38,8 @@
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 *)));
connect(this,TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *,KGame *)),
this,TQ_SLOT(slotPropertyChanged(KGamePropertyBase *,KGame *)));
dataHandler()->Debug();
//kdDebug(12010) << "Property 7 policy=" << dataHandler()->find(7)->policy() << endl;
@ -93,14 +93,14 @@ Kwin4Doc::Kwin4Doc(TQWidget *parent, const char *) : KGame(1234,parent), pView(0
setGameStatus(Intro);
// Listen to network
connect(this,TQT_SIGNAL(signalMessageUpdate(int,TQ_UINT32,TQ_UINT32)),
this,TQT_SLOT(slotMessageUpdate(int, TQ_UINT32,TQ_UINT32)));
connect(this,TQT_SIGNAL(signalClientJoinedGame(TQ_UINT32,KGame *)),
this,TQT_SLOT(slotClientConnected(TQ_UINT32, KGame *)));
connect(this,TQ_SIGNAL(signalMessageUpdate(int,TQ_UINT32,TQ_UINT32)),
this,TQ_SLOT(slotMessageUpdate(int, TQ_UINT32,TQ_UINT32)));
connect(this,TQ_SIGNAL(signalClientJoinedGame(TQ_UINT32,KGame *)),
this,TQ_SLOT(slotClientConnected(TQ_UINT32, KGame *)));
// Debug only
connect(this,TQT_SIGNAL(signalGameOver(int, KPlayer *,KGame *)),
this,TQT_SLOT(slotGameOver(int, KPlayer *,KGame *)));
connect(this,TQ_SIGNAL(signalGameOver(int, KPlayer *,KGame *)),
this,TQ_SLOT(slotGameOver(int, KPlayer *,KGame *)));
// Change global KGame policy
//dataHandler()->setPolicy(KGamePropertyBase::PolicyDirty,false);
@ -813,8 +813,8 @@ KPlayer *Kwin4Doc::createPlayer(int /*rtti*/,int io,bool isvirtual)
if (!isvirtual)
createIO(player,(KGameIO::IOMode)io);
connect(player,TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KPlayer *)),
this,TQT_SLOT(slotPlayerPropertyChanged(KGamePropertyBase *, KPlayer *)));
connect(player,TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *, KPlayer *)),
this,TQ_SLOT(slotPlayerPropertyChanged(KGamePropertyBase *, KPlayer *)));
((Kwin4Player *)player)->setWidget(pView->statusWidget());
return player;
}
@ -828,7 +828,7 @@ bool Kwin4Doc::playerInput(TQDataStream &msg, KPlayer * /*player*/)
int move, pl;
msg >> pl >> move;
if (!Move(move,pl))
TQTimer::singleShot(0, this,TQT_SLOT(slotRepeatMove()));
TQTimer::singleShot(0, this,TQ_SLOT(slotRepeatMove()));
return false;
}
@ -907,8 +907,8 @@ void Kwin4Doc::createIO(KPlayer *player,KGameIO::IOMode io)
input=new KGameMouseIO(pView);
if (global_debug>1) kdDebug(12010) << "MOUSE IO added " << endl;
// Connect mouse input to a function to process the actual input
connect(input,TQT_SIGNAL(signalMouseEvent(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)),
pView,TQT_SLOT(slotMouseInput(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)));
connect(input,TQ_SIGNAL(signalMouseEvent(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)),
pView,TQ_SLOT(slotMouseInput(KGameIO *,TQDataStream &,TQMouseEvent *,bool *)));
player->addGameIO(input);
}
else if (io&KGameIO::ProcessIO)
@ -920,11 +920,11 @@ void Kwin4Doc::createIO(KPlayer *player,KGameIO::IOMode io)
// We want a computer player
input=new KGameProcessIO(file);
// Connect computer player to the setTurn
connect(input,TQT_SIGNAL(signalPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)),
this,TQT_SLOT(slotPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)));
connect(input,TQ_SIGNAL(signalPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)),
this,TQ_SLOT(slotPrepareTurn(TQDataStream &,bool,KGameIO *,bool *)));
connect(input,TQT_SIGNAL(signalProcessQuery(TQDataStream &,KGameProcessIO *)),
this,TQT_SLOT(slotProcessQuery(TQDataStream &,KGameProcessIO *)));
connect(input,TQ_SIGNAL(signalProcessQuery(TQDataStream &,KGameProcessIO *)),
this,TQ_SLOT(slotProcessQuery(TQDataStream &,KGameProcessIO *)));
player->addGameIO(input);
}
else if (io&KGameIO::KeyIO)
@ -934,8 +934,8 @@ void Kwin4Doc::createIO(KPlayer *player,KGameIO::IOMode io)
KGameKeyIO *input;
input=new KGameKeyIO(pView->parentWidget());
// Connect keys input to a function to process the actual input
connect((KGameKeyIO *)input,TQT_SIGNAL(signalKeyEvent(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)),
pView,TQT_SLOT(slotKeyInput(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)));
connect((KGameKeyIO *)input,TQ_SIGNAL(signalKeyEvent(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)),
pView,TQ_SLOT(slotKeyInput(KGameIO *,TQDataStream &,TQKeyEvent *,bool *)));
player->addGameIO(input);
}
}
@ -1104,8 +1104,8 @@ void Kwin4Doc::calcHint()
// We want a computer player
mHintProcess=new KGameProcessIO(file);
connect(mHintProcess,TQT_SIGNAL(signalProcessQuery(TQDataStream &,KGameProcessIO *)),
this,TQT_SLOT(slotProcessHint(TQDataStream &,KGameProcessIO *)));
connect(mHintProcess,TQ_SIGNAL(signalProcessQuery(TQDataStream &,KGameProcessIO *)),
this,TQ_SLOT(slotProcessHint(TQDataStream &,KGameProcessIO *)));
}
TQ_INT32 pl;
TQByteArray buffer;

4
twin4/twin4/twin4player.cpp
Unescape View File

@ -39,8 +39,8 @@ Kwin4Player::Kwin4Player() : KPlayer(), sWidget(0)
dataHandler()->setPolicy(KGamePropertyBase::PolicyDirty,false);
resetStats();
connect(this,TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *,KPlayer *)),
this,TQT_SLOT(slotPlayerPropertyChanged(KGamePropertyBase *,KPlayer *)));
connect(this,TQ_SIGNAL(signalPropertyChanged(KGamePropertyBase *,KPlayer *)),
this,TQ_SLOT(slotPlayerPropertyChanged(KGamePropertyBase *,KPlayer *)));
}
#include <tqlabel.h>

12
twin4/twin4/twin4proc.cpp
Unescape View File

@ -51,12 +51,12 @@ TDEComputer::TDEComputer() : TQObject(0,0)
for (i=0;i<strlen(s2);i++)
startofrow[i]=s2[i]-'0';
connect(&proc,TQT_SIGNAL(signalCommand(TQDataStream &,int ,int ,int )),
this,TQT_SLOT(slotCommand(TQDataStream & ,int ,int ,int )));
connect(&proc,TQT_SIGNAL(signalInit(TQDataStream &,int)),
this,TQT_SLOT(slotInit(TQDataStream & ,int )));
connect(&proc,TQT_SIGNAL(signalTurn(TQDataStream &,bool )),
this,TQT_SLOT(slotTurn(TQDataStream & ,bool )));
connect(&proc,TQ_SIGNAL(signalCommand(TQDataStream &,int ,int ,int )),
this,TQ_SLOT(slotCommand(TQDataStream & ,int ,int ,int )));
connect(&proc,TQ_SIGNAL(signalInit(TQDataStream &,int)),
this,TQ_SLOT(slotInit(TQDataStream & ,int )));
connect(&proc,TQ_SIGNAL(signalTurn(TQDataStream &,bool )),
this,TQ_SLOT(slotTurn(TQDataStream & ,bool )));
fprintf(stderr, "----------------->\nTDEComputer::Computer\n");
}

12
twin4/twin4/twin4view.cpp
Unescape View File

@ -371,8 +371,8 @@ void Kwin4View::drawIntro(bool /*remove*/)
if (sprite)
{
KIntroMove *move=new KIntroMove;
connect(sprite->createNotify(),TQT_SIGNAL(signalNotify(TQCanvasItem *,int)),
this,TQT_SLOT(introMoveDone(TQCanvasItem *,int)));
connect(sprite->createNotify(),TQ_SIGNAL(signalNotify(TQCanvasItem *,int)),
this,TQ_SLOT(introMoveDone(TQCanvasItem *,int)));
sprite->setMoveObject(move);
if (no%2==0)
{
@ -531,8 +531,8 @@ void Kwin4View::setPiece(int x,int y,int color,int no,bool animation)
mBoardY-sprite->height()-mSpreadY);
sprite->moveTo(sprite->x(),
sprite->y()+y*(sprite->height()+mSpreadY)+mBoardY);
connect(sprite->createNotify(),TQT_SIGNAL(signalNotify(TQCanvasItem *,int)),
doc,TQT_SLOT(moveDone(TQCanvasItem *,int)));
connect(sprite->createNotify(),TQ_SIGNAL(signalNotify(TQCanvasItem *,int)),
doc,TQ_SLOT(moveDone(TQCanvasItem *,int)));
}
else
{
@ -541,8 +541,8 @@ void Kwin4View::setPiece(int x,int y,int color,int no,bool animation)
y*(sprite->height()+mSpreadY)+mBoardY);
// Prevent moving (== speed =0)
sprite->moveTo(sprite->x(),sprite->y());
connect(sprite->createNotify(),TQT_SIGNAL(signalNotify(TQCanvasItem *,int)),
doc,TQT_SLOT(moveDone(TQCanvasItem *,int)));
connect(sprite->createNotify(),TQ_SIGNAL(signalNotify(TQCanvasItem *,int)),
doc,TQ_SLOT(moveDone(TQCanvasItem *,int)));
sprite->emitNotify(3);
}

Write Preview
Loading…
Cancel
Save