TDE
/
tdegames
6
0
Fork 0
Code Issues Pull Requests 1 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 11 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