00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
#include "kgamedialogconfig.h"
00022
00023
#include "kgame.h"
00024
#include "kplayer.h"
00025
#include "kgamechat.h"
00026
#include "kgameconnectdialog.h"
00027
00028
#include <klocale.h>
00029
#include <knuminput.h>
00030
#include <kdialog.h>
00031
#include <klistbox.h>
00032
#include <kmessagebox.h>
00033
00034
#include <qlayout.h>
00035
#include <qhgroupbox.h>
00036
#include <qlabel.h>
00037
#include <qpushbutton.h>
00038
#include <qlineedit.h>
00039
#include <qvbox.h>
00040
#include <qptrdict.h>
00041
00042
#include "kgamedialogconfig.moc"
00043
00044
class KGameDialogConfigPrivate
00045 {
00046
public:
00047 KGameDialogConfigPrivate()
00048 {
00049 mOwner = 0;
00050 mGame = 0;
00051
00052 mAdmin =
false;
00053 }
00054
00055
bool mAdmin;
00056
KGame* mGame;
00057
KPlayer* mOwner;
00058 };
00059
00060 KGameDialogConfig::KGameDialogConfig(
QWidget* parent) :
QWidget(parent)
00061 {
00062 d =
new KGameDialogConfigPrivate;
00063 }
00064
00065 KGameDialogConfig::~KGameDialogConfig()
00066 {
00067 kdDebug(11001) << k_funcinfo << endl;
00068
delete d;
00069 }
00070
00071 void KGameDialogConfig::setKGame(
KGame* g)
00072 {
00073 d->mGame = g;
00074 }
00075
00076 void KGameDialogConfig::setOwner(
KPlayer* p)
00077 {
00078 d->mOwner = p;
00079 }
00080
00081 void KGameDialogConfig::setAdmin(
bool a)
00082 {
00083 d->mAdmin = a;
00084 }
00085
00086 KGame*
KGameDialogConfig::game()
const
00087
{
return d->mGame; }
00088 bool KGameDialogConfig::admin()
const
00089
{
return d->mAdmin; }
00090 KPlayer*
KGameDialogConfig::owner()
const
00091
{
return d->mOwner; }
00092
00094
class KGameDialogNetworkConfigPrivate
00095 {
00096
public:
00097 KGameDialogNetworkConfigPrivate()
00098 {
00099 mInitConnection = 0;
00100 mNetworkLabel = 0;
00101 mDisconnectButton = 0;
00102 mConnect = 0;
00103 mDefaultServer=
true;
00104
00105 }
00106
00107
00108
QHGroupBox* mInitConnection;
00109
QLabel* mNetworkLabel;
00110
QPushButton *mDisconnectButton;
00111
00112
bool mDefaultServer;
00113
QString mDefaultHost;
00114
unsigned short int mDefaultPort;
00115 KGameConnectWidget *mConnect;
00116 };
00117
00118
00119 KGameDialogNetworkConfig::KGameDialogNetworkConfig(
QWidget* parent)
00120 :
KGameDialogConfig(parent)
00121 {
00122
00123 d =
new KGameDialogNetworkConfigPrivate();
00124
00125
QVBoxLayout* topLayout =
new QVBoxLayout(
this, KDialog::marginHint(), KDialog::spacingHint(),
"toplayout");
00126
00127
QHBoxLayout *hb =
new QHBoxLayout(topLayout, KDialog::spacingHint());
00128
00129 d->mNetworkLabel =
new QLabel(
this);
00130 hb->addWidget(d->mNetworkLabel);
00131
00132 d->mDisconnectButton=
new QPushButton(i18n(
"Disconnect"),
this);
00133 connect(d->mDisconnectButton, SIGNAL(clicked()),
this, SLOT(slotExitConnection()));
00134 hb->addWidget(d->mDisconnectButton);
00135
00136 d->mInitConnection =
new QHGroupBox(i18n(
"Network Configuration"),
this);
00137 topLayout->addWidget(d->mInitConnection);
00138
00139 d->mConnect =
new KGameConnectWidget(d->mInitConnection);
00140 connect(d->mConnect, SIGNAL(signalNetworkSetup()),
this, SLOT(slotInitConnection()));
00141 connect(d->mConnect, SIGNAL(signalServerTypeChanged(
int)),
00142
this, SIGNAL(signalServerTypeChanged(
int)));
00143
00144
00145 setConnected(
false);
00146 setDefaultNetworkInfo(
"localhost", 7654,
true);
00147 }
00148
00149 KGameDialogNetworkConfig::~KGameDialogNetworkConfig()
00150 {
00151 kdDebug(11001) << k_funcinfo << endl;
00152
delete d;
00153 }
00154
00155
void KGameDialogNetworkConfig::slotExitConnection()
00156 {
00157 kdDebug(11001) << k_funcinfo <<
" !!!!!!!!!!!!!!!!!!!!!!!" << endl;
00158
if (
game())
game()->
disconnect();
00159 setConnected(
false,
false);
00160 }
00161
00162
void KGameDialogNetworkConfig::slotInitConnection()
00163 {
00164 kdDebug(11001) << k_funcinfo << endl;
00165
bool connected =
false;
00166
bool master =
true;
00167
unsigned short int port = d->mConnect->port();
00168
QString host = d->mConnect->host();
00169
00170
if (host.isNull()) {
00171 master =
true;
00172
if (
game()) {
00173 connected =
game()->
offerConnections(port);
00174 }
00175 }
else {
00176 master =
false;
00177
if (
game()) {
00178 connected =
game()->
connectToServer(host, port);
00179 }
00180
00181
if (
game()) {
00182 connect(
game(), SIGNAL(signalConnectionBroken()),
00183
this, SLOT(slotConnectionBroken()));
00184 }
00185 }
00186 setConnected(connected, master);
00187 }
00188
00189
void KGameDialogNetworkConfig::slotConnectionBroken()
00190 {
00191 kdDebug(11001) << k_funcinfo << endl;
00192 setConnected(
false,
false);
00193 KMessageBox::error(
this, i18n(
"Cannot connect to the network"));
00194 }
00195
00196
void KGameDialogNetworkConfig::setConnected(
bool connected,
bool master)
00197 {
00198
if (!connected) {
00199 d->mNetworkLabel->setText(i18n(
"Network status: No Network"));
00200 d->mInitConnection->setEnabled(
true);
00201 d->mDisconnectButton->setEnabled(
false);
00202
return;
00203 }
00204
if (master) {
00205 d->mNetworkLabel->setText(i18n(
"Network status: You are MASTER"));
00206 }
else {
00207 d->mNetworkLabel->setText(i18n(
"Network status: You are connected"));
00208 }
00209 d->mInitConnection->setEnabled(
false);
00210 d->mDisconnectButton->setEnabled(
true);
00211 }
00212
00213
void KGameDialogNetworkConfig::submitToKGame(
KGame* ,
KPlayer* )
00214 {
00215 }
00216
00217
void KGameDialogNetworkConfig::setKGame(
KGame* g)
00218 {
00219
KGameDialogConfig::setKGame(g);
00220
if (!
game()) {
00221 setConnected(
false);
00222
return;
00223 }
00224 setConnected(
game()->isNetwork(),
game()->isMaster());
00225 }
00226
00227
void KGameDialogNetworkConfig::setDefaultNetworkInfo(
const QString& host,
unsigned short int port,
bool server)
00228 {
00229 d->mDefaultPort = port;
00230 d->mDefaultHost = host;
00231 d->mDefaultServer = server;
00232
00233 d->mConnect->setHost(host);
00234 d->mConnect->setPort(port);
00235
if (server) {
00236 d->mConnect->setDefault(0);
00237 }
else {
00238 d->mConnect->setDefault(1);
00239 }
00240 }
00241
00243
class KGameDialogGeneralConfigPrivate
00244 {
00245
public:
00246 KGameDialogGeneralConfigPrivate()
00247 {
00248 mTopLayout = 0;
00249 mName = 0;
00250 }
00251
00252
QLineEdit* mName;
00253
00254
QVBoxLayout* mTopLayout;
00255 };
00256
00257 KGameDialogGeneralConfig::KGameDialogGeneralConfig(
QWidget* parent,
bool initializeGUI)
00258 :
KGameDialogConfig(parent)
00259 {
00260
00261 d =
new KGameDialogGeneralConfigPrivate;
00262
00263
if (initializeGUI) {
00264 d->mTopLayout =
new QVBoxLayout(
this, KDialog::marginHint(), KDialog::spacingHint());
00265 d->mTopLayout->setAutoAdd(
true);
00266
00267
QWidget* nameWidget =
new QWidget(
this);
00268
QHBoxLayout* l =
new QHBoxLayout(nameWidget);
00269
QLabel* nameLabel =
new QLabel(i18n(
"Your name:"), nameWidget);
00270 l->addWidget(nameLabel);
00271 d->mName =
new QLineEdit(nameWidget);
00272 l->addWidget(d->mName);
00273 }
00274 }
00275
00276 KGameDialogGeneralConfig::~KGameDialogGeneralConfig()
00277 {
00278 kdDebug(11001) << k_funcinfo << endl;
00279
delete d;
00280 }
00281
00282
void KGameDialogGeneralConfig::setPlayerName(
const QString& name)
00283 {
00284
if (d->mName) {
00285 d->mName->setText(name);
00286 }
00287 }
00288
00289
QString KGameDialogGeneralConfig::playerName()
const
00290
{
00291
return d->mName ? d->mName->text() :
QString::null;
00292 }
00293
00294
void KGameDialogGeneralConfig::setOwner(
KPlayer* p)
00295 {
00296
if (
owner()) {
00297
owner()->disconnect(
this);
00298 }
00299
KGameDialogConfig::setOwner(p);
00300
if (!
owner()) {
00301
00302
00303
return;
00304 }
00305 connect(
owner(), SIGNAL(signalPropertyChanged(
KGamePropertyBase*,
KPlayer*)),
00306
this, SLOT(slotPropertyChanged(
KGamePropertyBase*,
KPlayer*)));
00307 setPlayerName(p->
name());
00308
00309 }
00310
00311
void KGameDialogGeneralConfig::setKGame(
KGame* g)
00312 {
00313
KGameDialogConfig::setKGame(g);
00314
if (!g) {
00315
00316
00317
00318
return;
00319 }
00320 }
00321
00322
void KGameDialogGeneralConfig::setAdmin(
bool admin)
00323 {
00324
KGameDialogConfig::setAdmin(admin);
00325
00326
00327 }
00328
00329
void KGameDialogGeneralConfig::submitToKGame(
KGame* g,
KPlayer* p)
00330 {
00331
00332
if (p) {
00333 p->
setName(playerName());
00334 }
00335
if (g) {
00336 }
00337 }
00338
00339
void KGameDialogGeneralConfig::slotPropertyChanged(
KGamePropertyBase* prop,
KPlayer* p)
00340 {
00341
if (!prop || !p || p !=
owner()) {
00342
return;
00343 }
00344
switch (prop->
id()) {
00345
case KGamePropertyBase::IdName:
00346 setPlayerName(p->
name());
00347
break;
00348
default:
00349
break;
00350 }
00351 }
00352
00353
class KGameDialogMsgServerConfigPrivate
00354 {
00355
public:
00356 KGameDialogMsgServerConfigPrivate()
00357 {
00358 senderLayout = 0;
00359 localLayout = 0;
00360
00361 changeMaxClients = 0;
00362 changeAdmin= 0;
00363 removeClient= 0;
00364 noAdmin = 0;
00365
00366 noMaster = 0;
00367 }
00368
00369
QVBoxLayout* senderLayout;
00370
QHBoxLayout* localLayout;
00371
00372
QPushButton* changeMaxClients;
00373
QPushButton* changeAdmin;
00374
QPushButton* removeClient;
00375
QLabel* noAdmin;
00376
00377
QLabel* noMaster;
00378 };
00379
00380
00381
00382
00383
00384 KGameDialogMsgServerConfig::KGameDialogMsgServerConfig(
QWidget* parent)
00385 :
KGameDialogConfig(parent)
00386 {
00387 d =
new KGameDialogMsgServerConfigPrivate;
00388
00389
QVBoxLayout* topLayout =
new QVBoxLayout(
this, KDialog::marginHint(), KDialog::spacingHint());
00390 d->senderLayout =
new QVBoxLayout(topLayout);
00391 d->localLayout =
new QHBoxLayout(topLayout);
00392 }
00393
00394 KGameDialogMsgServerConfig::~KGameDialogMsgServerConfig()
00395 {
00396 kdDebug(11001) << k_funcinfo << endl;
00397
delete d;
00398 }
00399
00400
void KGameDialogMsgServerConfig::setKGame(
KGame* g)
00401 {
00402
KGameDialogConfig::setKGame(g);
00403
00404
00405
if (!
game()) {
00406
00407
setAdmin(
false);
00408
return;
00409 }
00410
setAdmin(
game()->isAdmin());
00411 setHasMsgServer(
game()->messageServer());
00412 }
00413
00414
00415
void KGameDialogMsgServerConfig::slotChangeMaxClients()
00416 {
00417
if (!
game()) {
00418 kdError(11001) << k_funcinfo <<
": no valid game object available!" << endl;
00419
return;
00420 }
00421
if (!
game()->
isAdmin()) {
00422 kdError(11001) << k_funcinfo <<
": only ADMIN is allowed to call this!" << endl;
00423
return;
00424 }
00425
int max;
00426
00427
00428
QDialog* dialog =
new QDialog();
00429 dialog->setCaption(i18n(
"Maximal Number of Clients"));
00430
QHBoxLayout* l =
new QHBoxLayout(dialog, KDialog::marginHint(), KDialog::spacingHint());
00431 l->setAutoAdd(
true);
00432
00433 (
void)
new QLabel(i18n(
"Maximal number of clients (-1 = infinite):"), dialog);
00434
QLineEdit* edit =
new QLineEdit(dialog);
00435
00436
if (dialog->exec() == QDialog::Accepted) {
00437
bool ok;
00438 max = edit->text().toInt(&ok);
00439
if (ok) {
00440
game()->
setMaxClients(max);
00441 }
00442 }
00443
00444 }
00445
00446
void KGameDialogMsgServerConfig::slotRemoveClient()
00447 {
00448 }
00449
00450
void KGameDialogMsgServerConfig::slotChangeAdmin()
00451 {
00452
if (!
game()) {
00453 kdError(11001) << k_funcinfo <<
": no valid game object available!" << endl;
00454
return;
00455 }
00456
if (!
admin()) {
00457 kdError(11001) << k_funcinfo <<
": only ADMIN is allowed to call this!" << endl;
00458
return;
00459 }
00460
00461 Q_UINT32 newAdmin = 0;
00462
00463
game()->
electAdmin(newAdmin);
00464 }
00465
00466
void KGameDialogMsgServerConfig::removeClient(Q_UINT32 )
00467 {
00468
00469 }
00470
00471
void KGameDialogMsgServerConfig::setAdmin(
bool a)
00472 {
00473
if (
admin() == a) {
00474
00475
return;
00476 }
00477
KGameDialogConfig::setAdmin(a);
00478
if (
admin()) {
00479
if (d->noAdmin) {
00480
delete d->noAdmin;
00481 d->noAdmin = 0;
00482 }
00483 d->changeMaxClients =
new QPushButton(i18n(
"Change Maximal Number of Clients"),
this);
00484 connect(d->changeMaxClients, SIGNAL(pressed()),
this, SLOT(slotChangeMaxClients()));
00485 d->changeAdmin =
new QPushButton(i18n(
"Change Admin"),
this);
00486 connect(d->changeAdmin, SIGNAL(pressed()),
this, SLOT(slotChangeAdmin()));
00487 d->removeClient =
new QPushButton(i18n(
"Remove Client with All Players"),
this);
00488 connect(d->removeClient, SIGNAL(pressed()),
this, SLOT(slotRemoveClient()));
00489 d->senderLayout->addWidget(d->changeMaxClients);
00490 d->senderLayout->addWidget(d->changeAdmin);
00491 d->senderLayout->addWidget(d->removeClient);
00492 }
else {
00493
if (d->changeMaxClients) {
00494
delete d->changeMaxClients;
00495 d->changeMaxClients = 0;
00496 }
00497
if (d->changeAdmin) {
00498
delete d->changeAdmin;
00499 d->changeAdmin = 0;
00500 }
00501
if (d->removeClient) {
00502
delete d->removeClient;
00503 d->removeClient = 0;
00504 }
00505 d->noAdmin =
new QLabel(i18n(
"Only the admin can configure the message server!"),
this);
00506 d->senderLayout->addWidget(d->noAdmin);
00507 }
00508 }
00509
00510
00511
void KGameDialogMsgServerConfig::setHasMsgServer(
bool has)
00512 {
00513
if (!has) {
00514
00515
if (!d->noMaster) {
00516 d->noMaster =
new QLabel(i18n(
"You don't own the message server"),
this);
00517 d->localLayout->addWidget(d->noMaster);
00518 }
00519
return;
00520 }
00521
if (d->noMaster) {
00522
delete d->noMaster;
00523 d->noMaster = 0;
00524 }
00525
00526
00527
00528
00529 }
00530
00531
00532
class KGameDialogChatConfigPrivate
00533 {
00534
public:
00535 KGameDialogChatConfigPrivate()
00536 {
00537 mChat = 0;
00538 }
00539
00540
KGameChat* mChat;
00541 };
00542
00543 KGameDialogChatConfig::KGameDialogChatConfig(
int chatMsgId,
QWidget* parent)
00544 :
KGameDialogConfig(parent)
00545 {
00546 d =
new KGameDialogChatConfigPrivate;
00547
QVBoxLayout* topLayout =
new QVBoxLayout(
this, KDialog::marginHint(), KDialog::spacingHint());
00548 topLayout->setAutoAdd(
true);
00549
QHGroupBox* b =
new QHGroupBox(i18n(
"Chat"),
this);
00550 d->mChat =
new KGameChat(0, chatMsgId, b);
00551 }
00552
00553 KGameDialogChatConfig::~KGameDialogChatConfig()
00554 {
00555 kdDebug(11001) << k_funcinfo << endl;
00556
delete d;
00557 }
00558
00559 void KGameDialogChatConfig::setKGame(
KGame* g)
00560 {
00561
KGameDialogConfig::setKGame(g);
00562 d->mChat->setKGame(
game());
00563
if (!
game()) {
00564 hide();
00565 }
else {
00566 show();
00567 }
00568 }
00569
00570 void KGameDialogChatConfig::setOwner(
KPlayer* p)
00571 {
00572
KGameDialogConfig::setOwner(p);
00573
if (!
owner()) {
00574 hide();
00575
return;
00576 }
00577 d->mChat->setFromPlayer(
owner());
00578 show();
00579 }
00580
00581
00582
00583
class KGameDialogConnectionConfigPrivate
00584 {
00585
public:
00586 KGameDialogConnectionConfigPrivate()
00587 {
00588 mPlayerBox = 0;
00589 }
00590
00591
QPtrDict<KPlayer> mItem2Player;
00592 KListBox* mPlayerBox;
00593 };
00594
00595 KGameDialogConnectionConfig::KGameDialogConnectionConfig(
QWidget* parent)
00596 :
KGameDialogConfig(parent)
00597 {
00598
00599 d =
new KGameDialogConnectionConfigPrivate;
00600
QVBoxLayout* topLayout =
new QVBoxLayout(
this, KDialog::marginHint(), KDialog::spacingHint());
00601 topLayout->setAutoAdd(
true);
00602
QHGroupBox* b =
new QHGroupBox(i18n(
"Connected Players"),
this);
00603 d->mPlayerBox =
new KListBox(b);
00604 setMinimumHeight(100);
00605 }
00606
00607 KGameDialogConnectionConfig::~KGameDialogConnectionConfig()
00608 {
00609 kdDebug(11001) << k_funcinfo << endl;
00610
00611
delete d;
00612 }
00613
00614
void KGameDialogConnectionConfig::setKGame(
KGame* g)
00615 {
00616
if (
game()) {
00617 disconnect(
game(), 0,
this, 0);
00618 }
00619
KGameDialogConfig::setKGame(g);
00620 slotClearPlayers();
00621
if (
game()) {
00622
00623 connect(
game(), SIGNAL(signalPlayerJoinedGame(
KPlayer*)),
00624
this, SLOT(slotPlayerJoinedGame(
KPlayer*)));
00625 connect(
game(), SIGNAL(signalPlayerLeftGame(
KPlayer*)),
00626
this, SLOT(slotPlayerLeftGame(
KPlayer*)));
00627
00628
KGame::KGamePlayerList l = *
game()->
playerList();
00629
for (
KPlayer* p = l.first(); p; p = l.next()) {
00630 slotPlayerJoinedGame(p);
00631 }
00632 }
00633 }
00634
00635
void KGameDialogConnectionConfig::setOwner(
KPlayer* p)
00636 {
00637
KGameDialogConfig::setOwner(p);
00638 }
00639
00640
void KGameDialogConnectionConfig::setAdmin(
bool a)
00641 {
00642
if (!
game()) {
00643
return;
00644 }
00645
if (
admin()) {
00646 disconnect(
game(), SIGNAL(executed(
QListBoxItem*)),
this, 0);
00647 }
00648
KGameDialogConfig::setAdmin(a);
00649
if (
admin()) {
00650 connect(d->mPlayerBox, SIGNAL(executed(
QListBoxItem*)),
this,
00651 SLOT(slotKickPlayerOut(
QListBoxItem*)));
00652 }
00653 }
00654
00655
QListBoxItem* KGameDialogConnectionConfig::item(
KPlayer* p)
const
00656
{
00657
QPtrDictIterator<KPlayer> it(d->mItem2Player);
00658
while (it.current()) {
00659
if (it.current() == p) {
00660
return (
QListBoxItem*)it.currentKey();
00661 }
00662 ++it;
00663 }
00664
return 0;
00665 }
00666
00667
void KGameDialogConnectionConfig::slotClearPlayers()
00668 {
00669
QPtrDictIterator<KPlayer> it(d->mItem2Player);
00670
while (it.current()) {
00671 slotPlayerLeftGame(it.current());
00672 ++it;
00673 }
00674
00675
if (d->mItem2Player.count() > 0) {
00676 kdWarning(11001) << k_funcinfo <<
": itemList wasn't cleared properly" << endl;
00677 d->mItem2Player.clear();
00678 }
00679
if (d->mPlayerBox->count() > 0) {
00680 kdWarning(11001) << k_funcinfo <<
": listBox wasn't cleared properly" << endl;
00681 d->mPlayerBox->clear();
00682 }
00683
00684 }
00685
00686
void KGameDialogConnectionConfig::slotPlayerJoinedGame(
KPlayer* p)
00687 {
00688
if (!p) {
00689 kdError(11001) << k_funcinfo <<
": Cannot add NULL player" << endl;
00690 }
00691
if (d->mItem2Player[p]) {
00692 kdError(11001) << k_funcinfo <<
": attempt to double add player" << endl;
00693
return;
00694 }
00695 kdDebug(11001) << k_funcinfo <<
": add player " << p->
id() << endl;
00696
QListBoxText* t =
new QListBoxText(p->
name());
00697 d->mItem2Player.insert(t, p);
00698 d->mPlayerBox->insertItem(t);
00699
00700 connect(p, SIGNAL(signalPropertyChanged(
KGamePropertyBase*,
KPlayer*)),
00701
this, SLOT(slotPropertyChanged(
KGamePropertyBase*,
KPlayer*)));
00702
00703 }
00704
00705
void KGameDialogConnectionConfig::slotPlayerLeftGame(
KPlayer* p)
00706 {
00707
00708 this->disconnect(p);
00709
if (!item(p)) {
00710 kdError(11001) << k_funcinfo <<
": cannot find " << p->
id()
00711 <<
" in list" << endl;
00712
return;
00713 }
00714 d->mPlayerBox->removeItem(d->mPlayerBox->index(item(p)));
00715
00716 }
00717
00718
void KGameDialogConnectionConfig::slotKickPlayerOut(
QListBoxItem* item)
00719 {
00720 kdDebug(11001) <<
"kick player out" << endl;
00721
KPlayer* p = d->mItem2Player[item];
00722
if (!p) {
00723 kdError(11001) <<
"invalid item selected - no player found" << endl;
00724
return;
00725 }
00726
if (!
game()) {
00727 kdWarning(11001) <<
"no game set" << endl;
00728
return;
00729 }
00730
if (!
admin()) {
00731 kdDebug(11001) <<
"Only the ADMIN can kick players" << endl;
00732
return;
00733 }
00734
if (p ==
owner()) {
00735 kdDebug(11001) <<
"you cannot kick the ADMIN" << endl;
00736
return;
00737 }
00738
00739
if (KMessageBox::questionYesNo(
this, i18n(
"Do you want to ban player \"%1\" from the game?").arg(
00740 p->
name())) == KMessageBox::Yes) {
00741 kdDebug(11001) <<
"will remove player " << p << endl;
00742
game()->
removePlayer(p);
00743
00744 }
else {
00745 kdDebug(11001) <<
"will NOT remove player " << p << endl;
00746 }
00747 }
00748
00749
void KGameDialogConnectionConfig::slotPropertyChanged(
KGamePropertyBase* prop,
KPlayer* player)
00750 {
00751
if(prop->
id() == KGamePropertyBase::IdName) {
00752
QListBoxText* old = 0;
00753
QPtrDictIterator<KPlayer> it(d->mItem2Player);
00754
while (it.current() && !old) {
00755
if (it.current() == player) {
00756 old = (
QListBoxText*)it.currentKey();
00757 }
00758 ++it;
00759 }
00760
QListBoxText* t =
new QListBoxText(player->
name());
00761 d->mPlayerBox->changeItem(t, d->mPlayerBox->index(old));
00762 d->mItem2Player.remove(old);
00763 d->mItem2Player.insert(t, player);
00764 }
00765 }
00766