← Back to branch summary

~ubuntu-branches/ubuntu/saucy/libkdegames/saucy

« back to all changes in this revision

Viewing changes to libkdegamesprivate/kgame/dialogs/kgamedebugdialog.cpp

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell, Rohan Garg, Philip Muškovac, Jonathan Riddell
  • Date: 2013-06-21 01:42:38 UTC
  • mfrom: (1.2.3)
  • Revision ID: package-import@ubuntu.com-20130621014238-mk0kx5llg3m15ua6
Tags: 4:4.10.80-0ubuntu1
[ Rohan Garg ]
* New upstream release

[ Philip Muškovac ]
* Add Qml imports to libkdegames6.install 
* Add new symbols to libkdegames6.symbols

[ Jonathan Riddell ]
* New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
libkdegamesprivate/kgame/dialogs/kgamedebugdialog.cpp
1
 
/*
2
 
    This file is part of the KDE games library
3
 
    Copyright (C) 2001 Andreas Beckermann (b_mann@gmx.de)
4
 
    Copyright (C) 2001 Martin Heni (kde at heni-online.de)
5
 
 
6
 
    This library is free software; you can redistribute it and/or
7
 
    modify it under the terms of the GNU Library General Public
8
 
    License version 2 as published by the Free Software Foundation.
9
 
 
10
 
    This library is distributed in the hope that it will be useful,
11
 
    but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 
    Library General Public License for more details.
14
 
 
15
 
    You should have received a copy of the GNU Library General Public License
16
 
    along with this library; see the file COPYING.LIB.  If not, write to
17
 
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18
 
    Boston, MA 02110-1301, USA.
19
 
*/
20
 
 
21
 
#include "kgamedebugdialog.h"
22
 
 
23
 
#include "kgamemessage.h"
24
 
#include "kgame.h"
25
 
#include "kplayer.h"
26
 
#include "kgamepropertyhandler.h"
27
 
 
28
 
#include <klistwidget.h>
29
 
#include <klocale.h>
30
 
#include <kdebug.h>
31
 
#include <kpushbutton.h>
32
 
#include <KStandardGuiItem>
33
 
 
34
 
#include <QTreeWidget>
35
 
#include <QLayout>
36
 
 
37
 
#include <QLabel>
38
 
#include <QDateTime>
39
 
#include <QVBoxLayout>
40
 
#include <QFrame>
41
 
#include <QHBoxLayout>
42
 
#include <QGridLayout>
43
 
 
44
 
#include <typeinfo>
45
 
 
46
 
 
47
 
class KGameDebugDialogPrivate
48
 
{
49
 
public:
50
 
        KGameDebugDialogPrivate()
51
 
        {
52
 
                mGame = 0;
53
 
 
54
 
                mGamePage = 0;
55
 
                mGameProperties = 0;
56
 
                mGameAddress = 0;
57
 
                mGameId = 0;
58
 
                mGameCookie = 0;
59
 
                mGameMaster = 0;
60
 
                mGameAdmin = 0;
61
 
                mGameOffering = 0;
62
 
                mGameStatus = 0;
63
 
                mGameRunning = 0;
64
 
                mGameMaxPlayers = 0;
65
 
                mGameMinPlayers = 0;
66
 
                mGamePlayerCount = 0;
67
 
 
68
 
                mPlayerPage = 0;
69
 
                mPlayerList = 0;
70
 
                mPlayerProperties = 0;
71
 
                mPlayerAddress = 0;
72
 
                mPlayerId = 0;
73
 
                mPlayerName = 0;
74
 
                mPlayerGroup = 0;
75
 
                mPlayerUserId = 0;
76
 
                mPlayerMyTurn = 0;
77
 
                mPlayerAsyncInput= 0;
78
 
                mPlayerKGameAddress = 0;
79
 
                mPlayerVirtual = 0;
80
 
                mPlayerActive = 0;
81
 
                mPlayerRtti = 0;
82
 
                mPlayerNetworkPriority = 0;
83
 
 
84
 
                mMessagePage = 0;
85
 
                mMessageList = 0;
86
 
                mHideIdList = 0;
87
 
        }
88
 
 
89
 
        const KGame* mGame;
90
 
 
91
 
        QFrame* mGamePage;
92
 
        QTreeWidget* mGameProperties;
93
 
        QTreeWidgetItem* mGameAddress;
94
 
        QTreeWidgetItem* mGameId;
95
 
        QTreeWidgetItem* mGameCookie;
96
 
        QTreeWidgetItem* mGameMaster;
97
 
        QTreeWidgetItem* mGameAdmin;
98
 
        QTreeWidgetItem* mGameOffering;
99
 
        QTreeWidgetItem* mGameStatus;
100
 
        QTreeWidgetItem* mGameRunning;
101
 
        QTreeWidgetItem* mGameMaxPlayers;
102
 
        QTreeWidgetItem* mGameMinPlayers;
103
 
        QTreeWidgetItem* mGamePlayerCount;
104
 
 
105
 
        QFrame* mPlayerPage;
106
 
        KListWidget* mPlayerList;
107
 
        QTreeWidget* mPlayerProperties;
108
 
        QTreeWidgetItem* mPlayerAddress;
109
 
        QTreeWidgetItem* mPlayerId;
110
 
        QTreeWidgetItem* mPlayerName;
111
 
        QTreeWidgetItem* mPlayerGroup;
112
 
        QTreeWidgetItem* mPlayerUserId;
113
 
        QTreeWidgetItem* mPlayerMyTurn;
114
 
        QTreeWidgetItem* mPlayerAsyncInput;
115
 
        QTreeWidgetItem* mPlayerKGameAddress;
116
 
        QTreeWidgetItem* mPlayerVirtual;
117
 
        QTreeWidgetItem* mPlayerActive;
118
 
        QTreeWidgetItem* mPlayerRtti;
119
 
        QTreeWidgetItem* mPlayerNetworkPriority;
120
 
 
121
 
        QFrame* mMessagePage;
122
 
        QTreeWidget* mMessageList;
123
 
        KListWidget* mHideIdList;
124
 
};
125
 
 
126
 
KGameDebugDialog::KGameDebugDialog(KGame* g, QWidget* parent, bool modal)
127
 
    : KPageDialog(parent),
128
 
      d( new KGameDebugDialogPrivate )
129
 
{
130
 
 setCaption(i18n("KGame Debug Dialog"));
131
 
 setButtons(Close);
132
 
 setDefaultButton(Close);
133
 
 setModal(modal);
134
 
 showButtonSeparator(true);
135
 
 setFaceType(KPageDialog::Tabbed);
136
 
 
137
 
 initGamePage();
138
 
 initPlayerPage();
139
 
 initMessagePage();
140
 
 
141
 
 setKGame(g);
142
 
}
143
 
 
144
 
KGameDebugDialog::~KGameDebugDialog()
145
 
{
146
 
 delete d;
147
 
}
148
 
 
149
 
void KGameDebugDialog::initGamePage()
150
 
{
151
 
 d->mGamePage = new QFrame();
152
 
 addPage(d->mGamePage,i18n("Debug &KGame"));
153
 
 QVBoxLayout* topLayout = new QVBoxLayout(d->mGamePage);
154
 
 topLayout->setMargin( marginHint() );
155
 
 topLayout->setSpacing( spacingHint() );
156
 
 QHBoxLayout* layout = new QHBoxLayout;
157
 
 topLayout->addLayout(layout);
158
 
 
159
 
 QTreeWidget* v = new QTreeWidget(d->mGamePage);
160
 
 QTreeWidgetItem* vheader = new QTreeWidgetItem();
161
 
 vheader->setText(0, tr("Data"));
162
 
 vheader->setText(1, tr("Value"));
163
 
 v->setHeaderItem(vheader);
164
 
 layout->addWidget(v);
165
 
 
166
 
 d->mGameProperties = new QTreeWidget(d->mGamePage);
167
 
 QTreeWidgetItem* mGamePropertiesHeader = new QTreeWidgetItem();
168
 
 mGamePropertiesHeader->setText(0, tr("Property"));
169
 
 mGamePropertiesHeader->setText(1, tr("Value"));
170
 
 mGamePropertiesHeader->setText(2, tr("Policy"));
171
 
 d->mGameProperties->setHeaderItem(mGamePropertiesHeader);
172
 
 layout->addWidget(d->mGameProperties);
173
 
 
174
 
 QPushButton* b = new QPushButton(i18n("Update"), d->mGamePage);
175
 
 connect(b, SIGNAL(pressed()), this, SLOT(slotUpdateGameData()));
176
 
 topLayout->addWidget(b);
177
 
 
178
 
// game data
179
 
 d->mGameAddress = new QTreeWidgetItem(v, QStringList(i18n("KGame Pointer")));
180
 
 d->mGameId = new QTreeWidgetItem(v, QStringList(i18n("Game ID")));
181
 
 d->mGameCookie = new QTreeWidgetItem(v, QStringList(i18n("Game Cookie")));
182
 
 d->mGameMaster = new QTreeWidgetItem(v, QStringList(i18n("Is Master")));
183
 
 d->mGameAdmin = new QTreeWidgetItem(v, QStringList(i18n("Is Admin")));
184
 
 d->mGameOffering = new QTreeWidgetItem(v, QStringList(i18n("Is Offering Connections")));
185
 
 d->mGameStatus = new QTreeWidgetItem(v, QStringList(i18n("Game Status")));
186
 
 d->mGameRunning = new QTreeWidgetItem(v, QStringList(i18n("Game is Running")));
187
 
 d->mGameMaxPlayers = new QTreeWidgetItem(v, QStringList(i18n("Maximal Players")));
188
 
 d->mGameMinPlayers = new QTreeWidgetItem(v, QStringList(i18n("Minimal Players")));
189
 
 d->mGamePlayerCount = new QTreeWidgetItem(v, QStringList(i18n("Players")));
190
 
}
191
 
 
192
 
void KGameDebugDialog::initPlayerPage()
193
 
{
194
 
 d->mPlayerPage = new QFrame();
195
 
 addPage(d->mPlayerPage,i18n("Debug &Players"));
196
 
 QVBoxLayout* topLayout = new QVBoxLayout(d->mPlayerPage);
197
 
 topLayout->setMargin( marginHint() );
198
 
 topLayout->setSpacing( spacingHint() );
199
 
 QHBoxLayout* layout = new QHBoxLayout;
200
 
 topLayout->addLayout(layout);
201
 
 
202
 
 //TODO: connect to the KGame signals for joined/removed players!!!
203
 
 QVBoxLayout* listLayout = new QVBoxLayout;
204
 
 layout->addLayout(listLayout);
205
 
 QLabel* listLabel = new QLabel(i18n("Available Players"), d->mPlayerPage);
206
 
 listLayout->addWidget(listLabel);
207
 
 d->mPlayerList = new KListWidget(d->mPlayerPage);
208
 
 connect(d->mPlayerList, SIGNAL(executed(QListWidgetItem*)), this, SLOT(slotUpdatePlayerData(QListWidgetItem*)));
209
 
 listLayout->addWidget(d->mPlayerList);
210
 
 d->mPlayerList->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
211
 
 
212
 
 QTreeWidget* v = new QTreeWidget(d->mPlayerPage);
213
 
 layout->addWidget(v);
214
 
 QTreeWidgetItem* vheader = new QTreeWidgetItem();
215
 
 vheader->setText(0, tr("Data"));
216
 
 vheader->setText(1, tr("Value"));
217
 
 v->setHeaderItem(vheader);
218
 
 
219
 
 d->mPlayerProperties = new QTreeWidget(d->mPlayerPage);
220
 
 QTreeWidgetItem* mPlayerPropertiesHeader = new QTreeWidgetItem();
221
 
 mPlayerPropertiesHeader->setText(0, tr("Property"));
222
 
 mPlayerPropertiesHeader->setText(1, tr("Value"));
223
 
 mPlayerPropertiesHeader->setText(2, tr("Policy")); d->mPlayerProperties->setHeaderItem(mPlayerPropertiesHeader);
224
 
 layout->addWidget(d->mPlayerProperties);
225
 
 
226
 
 QPushButton* b = new QPushButton(i18n("Update"), d->mPlayerPage);
227
 
 connect(b, SIGNAL(pressed()), this, SLOT(slotUpdatePlayerList()));
228
 
 topLayout->addWidget(b);
229
 
 
230
 
 d->mPlayerAddress = new QTreeWidgetItem(v, QStringList(i18n("Player Pointer")));
231
 
 d->mPlayerId = new QTreeWidgetItem(v, QStringList(i18n("Player ID")));
232
 
 d->mPlayerName = new QTreeWidgetItem(v, QStringList(i18n("Player Name")));
233
 
 d->mPlayerGroup = new QTreeWidgetItem(v, QStringList(i18n("Player Group")));
234
 
 d->mPlayerUserId = new QTreeWidgetItem(v, QStringList(i18n("Player User ID")));
235
 
 d->mPlayerMyTurn = new QTreeWidgetItem(v, QStringList(i18n("My Turn")));
236
 
 d->mPlayerAsyncInput = new QTreeWidgetItem(v, QStringList(i18n("Async Input")));
237
 
 d->mPlayerKGameAddress = new QTreeWidgetItem(v, QStringList(i18n("KGame Address")));
238
 
 d->mPlayerVirtual = new QTreeWidgetItem(v, QStringList(i18n("Player is Virtual")));
239
 
 d->mPlayerActive = new QTreeWidgetItem(v, QStringList(i18n("Player is Active")));
240
 
 d->mPlayerRtti = new QTreeWidgetItem(v, QStringList(i18n("RTTI")));
241
 
 d->mPlayerNetworkPriority = new QTreeWidgetItem(v, QStringList(i18n("Network Priority")));
242
 
}
243
 
 
244
 
void KGameDebugDialog::initMessagePage()
245
 
{
246
 
 d->mMessagePage = new QFrame();
247
 
 addPage(d->mMessagePage,i18n("Debug &Messages"));
248
 
 QGridLayout* layout = new QGridLayout(d->mMessagePage);
249
 
 layout->setMargin(marginHint());
250
 
 layout->setSpacing(spacingHint());
251
 
 d->mMessageList = new QTreeWidget(d->mMessagePage);
252
 
 layout->addWidget(d->mMessageList, 0, 0, 10, 4);
253
 
 
254
 
 QTreeWidgetItem* mMessageListHeader = new QTreeWidgetItem();
255
 
 mMessageListHeader->setText(0, tr("Time"));
256
 
 mMessageListHeader->setText(1, tr("ID"));
257
 
 mMessageListHeader->setText(2, tr("Receiver")); mMessageListHeader->setText(2, tr("Sender"));
258
 
 mMessageListHeader->setText(2, tr("ID - Text"));
259
 
 d->mMessageList->setHeaderItem(mMessageListHeader);
260
 
 
261
 
 QPushButton* hide = new QPushButton(i18n("&>>"), d->mMessagePage);
262
 
 connect(hide, SIGNAL(pressed()), this, SLOT(slotHideId()));
263
 
 layout->addWidget(hide, 4, 4);
264
 
 
265
 
 QPushButton* show = new QPushButton(i18n("&<<"), d->mMessagePage);
266
 
 connect(show, SIGNAL(pressed()), this, SLOT(slotShowId()));
267
 
 layout->addWidget(show, 6, 4);
268
 
 
269
 
 QLabel* l = new QLabel(i18n("Do not show IDs:"), d->mMessagePage);
270
 
 layout->addWidget(l, 0, 5, 1, 2);
271
 
 d->mHideIdList = new KListWidget(d->mMessagePage);
272
 
 layout->addWidget(d->mHideIdList, 1, 5, 8, 2);
273
 
 
274
 
 QPushButton* clear = new KPushButton(KStandardGuiItem::clear(), d->mMessagePage);
275
 
 connect(clear, SIGNAL(pressed()), this, SLOT(slotClearMessages()));
276
 
 layout->addWidget(clear, 10, 0, 1, 7);
277
 
 //TODO: "show all but..." and "show nothing but..."
278
 
}
279
 
 
280
 
void KGameDebugDialog::clearPlayerData()
281
 
{
282
 
 d->mPlayerAddress->setText(1, QLatin1String( "" ));
283
 
 d->mPlayerId->setText(1, QLatin1String( "" ));
284
 
 d->mPlayerName->setText(1, QLatin1String( "" ));
285
 
 d->mPlayerGroup->setText(1, QLatin1String( "" ));
286
 
 d->mPlayerUserId->setText(1, QLatin1String( "" ));
287
 
 d->mPlayerMyTurn->setText(1, QLatin1String( "" ));
288
 
 d->mPlayerAsyncInput->setText(1, QLatin1String( "" ));
289
 
 d->mPlayerKGameAddress->setText(1, QLatin1String( "" ));
290
 
 d->mPlayerVirtual->setText(1, QLatin1String( "" ));
291
 
 d->mPlayerActive->setText(1, QLatin1String( "" ));
292
 
 d->mPlayerRtti->setText(1, QLatin1String( "" ));
293
 
 d->mPlayerNetworkPriority->setText(1, QLatin1String( "" ));
294
 
 
295
 
 d->mPlayerProperties->clear();
296
 
}
297
 
 
298
 
void KGameDebugDialog::clearGameData()
299
 
{
300
 
 d->mGameAddress->setText(1, QLatin1String( "" ));
301
 
 d->mGameId->setText(1, QLatin1String( "" ));
302
 
 d->mGameCookie->setText(1, QLatin1String( "" ));
303
 
 d->mGameMaster->setText(1, QLatin1String( "" ));
304
 
 d->mGameAdmin->setText(1, QLatin1String( "" ));
305
 
 d->mGameOffering->setText(1, QLatin1String( "" ));
306
 
 d->mGameStatus->setText(1, QLatin1String( "" ));
307
 
 d->mGameRunning->setText(1, QLatin1String( "" ));
308
 
 d->mGameMaxPlayers->setText(1, QLatin1String( "" ));
309
 
 d->mGameMinPlayers->setText(1, QLatin1String( "" ));
310
 
 
311
 
 d->mGameProperties->clear();
312
 
}
313
 
 
314
 
void KGameDebugDialog::slotUpdatePlayerData()
315
 
{
316
 
 if (!d->mGame || d->mPlayerList->currentRow() == -1) {
317
 
        return;
318
 
 }
319
 
 slotUpdatePlayerData(d->mPlayerList->item(d->mPlayerList->currentRow()));
320
 
}
321
 
 
322
 
void KGameDebugDialog::slotUpdatePlayerList()
323
 
{
324
 
 QListWidgetItem* i = d->mPlayerList->item(0);
325
 
 for (; d->mPlayerList->count() > 0; i = d->mPlayerList->item(0)) {
326
 
        removePlayer(i);
327
 
 }
328
 
 
329
 
 for ( QList<KPlayer*>::const_iterator it = d->mGame->playerList()->begin(); it!=d->mGame->playerList()->end(); ++it )
330
 
 {
331
 
  addPlayer(*it);
332
 
 }
333
 
}
334
 
 
335
 
void KGameDebugDialog::slotUpdateGameData()
336
 
{
337
 
 if (!d->mGame) {
338
 
        d->mGameAddress->setText(1, i18n("NULL pointer"));
339
 
        return;
340
 
}
341
 
 
342
 
 clearGameData();
343
 
 
344
 
 QString buf;
345
 
 buf.sprintf("%p", (void*)d->mGame);
346
 
 d->mGameAddress->setText(1, buf);
347
 
 d->mGameId->setText(1, QString::number(d->mGame->gameId()));
348
 
 d->mGameCookie->setText(1, QString::number(d->mGame->cookie()));
349
 
 d->mGameMaster->setText(1, d->mGame->isMaster() ? i18n("True") : i18n("False"));
350
 
 d->mGameAdmin->setText(1, d->mGame->isAdmin() ? i18n("True") : i18n("False"));
351
 
 d->mGameOffering->setText(1, d->mGame->isOfferingConnections() ? i18n("True") : i18n("False"));
352
 
 d->mGameStatus->setText(1, QString::number(d->mGame->gameStatus()));
353
 
 d->mGameRunning->setText(1, d->mGame->isRunning() ? i18n("True") : i18n("False"));
354
 
 d->mGameMaxPlayers->setText(1, QString::number(d->mGame->maxPlayers()));
355
 
 d->mGameMinPlayers->setText(1, QString::number(d->mGame->minPlayers()));
356
 
 d->mGamePlayerCount->setText(1, QString::number(d->mGame->playerCount()));
357
 
 
358
 
//TODO ios
359
 
 
360
 
 KGamePropertyHandler* handler = d->mGame->dataHandler();
361
 
 QHashIterator<int, KGamePropertyBase*> it(handler->dict());
362
 
 while (it.hasNext()) {
363
 
        it.next();
364
 
        QString policy;
365
 
        switch (it.value()->policy()) {
366
 
                case KGamePropertyBase::PolicyClean:
367
 
                        policy = i18n("Clean");
368
 
                        break;
369
 
                case KGamePropertyBase::PolicyDirty:
370
 
                        policy = i18n("Dirty");
371
 
                        break;
372
 
                case KGamePropertyBase::PolicyLocal:
373
 
                        policy = i18n("Local");
374
 
                        break;
375
 
                case KGamePropertyBase::PolicyUndefined:
376
 
                default:
377
 
                        policy = i18n("Undefined");
378
 
                        break;
379
 
        }
380
 
  QStringList items;
381
 
  items << handler->propertyName(it.value()->id()) << handler->propertyValue(it.value()) << policy;
382
 
        new QTreeWidgetItem(d->mGameProperties,items);
383
 
//      kDebug(11001) << ": checking for all game properties: found property name" << name;
384
 
 }
385
 
}
386
 
 
387
 
void KGameDebugDialog::slotUpdatePlayerData(QListWidgetItem* item)
388
 
{
389
 
 if (!item || !d->mGame) {
390
 
        return;
391
 
 }
392
 
 
393
 
 KPlayer* p = d->mGame->findPlayer(item->text().toInt());
394
 
 
395
 
 if (!p) {
396
 
        kError(11001) << ": cannot find player";
397
 
        return;
398
 
 }
399
 
 
400
 
 clearPlayerData();
401
 
 
402
 
 QString buf;
403
 
 buf.sprintf("%p", (void*)p);
404
 
 d->mPlayerAddress->setText(1, buf);
405
 
 d->mPlayerId->setText(1, QString::number(p->id()));
406
 
 d->mPlayerName->setText(1, p->name());
407
 
 d->mPlayerGroup->setText(1, p->group());
408
 
 d->mPlayerUserId->setText(1, QString::number(p->userId()));
409
 
 d->mPlayerMyTurn->setText(1, p->myTurn() ? i18n("True") : i18n("False"));
410
 
 d->mPlayerAsyncInput->setText(1, p->asyncInput() ? i18n("True") : i18n("False"));
411
 
 buf.sprintf("%p", (void*)p->game());
412
 
 d->mPlayerKGameAddress->setText(1, buf);
413
 
 d->mPlayerVirtual->setText(1, p->isVirtual() ? i18n("True") : i18n("False"));
414
 
 d->mPlayerActive->setText(1, p->isActive() ? i18n("True") : i18n("False"));
415
 
 d->mPlayerRtti->setText(1, QString::number(p->rtti()));
416
 
 d->mPlayerNetworkPriority->setText(1, QString::number(p->networkPriority()));
417
 
 
418
 
//TODO ios
419
 
 
420
 
// Properties
421
 
 KGamePropertyHandler * handler = p->dataHandler();
422
 
 QHashIterator<int, KGamePropertyBase*> it((handler->dict()));
423
 
 while (it.hasNext()) {
424
 
        it.next();
425
 
        QString policy;
426
 
        switch (it.value()->policy()) {
427
 
                case KGamePropertyBase::PolicyClean:
428
 
                        policy = i18n("Clean");
429
 
                        break;
430
 
                case KGamePropertyBase::PolicyDirty:
431
 
                        policy = i18n("Dirty");
432
 
                        break;
433
 
                case KGamePropertyBase::PolicyLocal:
434
 
                        policy = i18n("Local");
435
 
                        break;
436
 
                case KGamePropertyBase::PolicyUndefined:
437
 
                default:
438
 
                        policy = i18n("Undefined");
439
 
                        break;
440
 
        }
441
 
  QStringList items;
442
 
  items << handler->propertyName(it.value()->id()) << handler->propertyValue(it.value()) << policy;
443
 
        new QTreeWidgetItem(d->mPlayerProperties,items);
444
 
 }
445
 
}
446
 
 
447
 
void KGameDebugDialog::clearPages()
448
 
{
449
 
 clearPlayerData();
450
 
 clearGameData();
451
 
 d->mPlayerList->clear();
452
 
 slotClearMessages();
453
 
}
454
 
 
455
 
void KGameDebugDialog::setKGame(const KGame* g)
456
 
{
457
 
 slotUnsetKGame();
458
 
 d->mGame = g;
459
 
 if (g) {
460
 
 //TODO: connect to the KGame signals for joined/removed players!!!
461
 
        connect(d->mGame, SIGNAL(destroyed()), this, SLOT(slotUnsetKGame()));
462
 
//      connect();
463
 
 
464
 
  for ( QList<KPlayer*>::const_iterator it = d->mGame->playerList()->begin(); it!=d->mGame->playerList()->end(); ++it )
465
 
  {
466
 
          addPlayer(*it);
467
 
  }
468
 
 
469
 
        slotUpdateGameData();
470
 
 
471
 
        connect(d->mGame, SIGNAL(signalMessageUpdate(int,quint32,quint32)), this, SLOT(slotMessageUpdate(int,quint32,quint32)));
472
 
 }
473
 
}
474
 
 
475
 
void KGameDebugDialog::slotUnsetKGame()
476
 
{
477
 
 if (d->mGame) {
478
 
        disconnect(d->mGame, 0, this, 0);
479
 
 }
480
 
 d->mGame = 0;
481
 
 clearPages();
482
 
}
483
 
 
484
 
void KGameDebugDialog::addPlayer(KPlayer* p)
485
 
{
486
 
 if (!p) {
487
 
        kError(11001) << "trying to add NULL player";
488
 
        return;
489
 
 }
490
 
 
491
 
 (void) new QListWidgetItem(QString::number(p->id()), d->mPlayerList);
492
 
 //TODO connect to signals, like deleted/removed, ...
493
 
}
494
 
 
495
 
void KGameDebugDialog::removePlayer(QListWidgetItem* i)
496
 
{
497
 
 if (!i || !d->mGame) {
498
 
        return;
499
 
 }
500
 
 KPlayer* p = d->mGame->findPlayer(i->text().toInt());
501
 
 if (!p) {
502
 
        return;
503
 
 }
504
 
 disconnect(p, 0, this, 0);
505
 
 if (i->isSelected()) {
506
 
        clearPlayerData();
507
 
 }
508
 
 delete i;
509
 
}
510
 
 
511
 
void KGameDebugDialog::slotMessageUpdate(int msgid, quint32 receiver, quint32 sender)
512
 
{
513
 
 if (!showId(msgid)) {
514
 
        return;
515
 
 }
516
 
 QString msgidText = KGameMessage::messageId2Text(msgid);
517
 
 if (msgidText.isNull()) {
518
 
        if (msgid > KGameMessage::IdUser) {
519
 
                emit signalRequestIdName(msgid-KGameMessage::IdUser, true, msgidText);
520
 
        } else {
521
 
                emit signalRequestIdName(msgid, false, msgidText);
522
 
        }
523
 
        if (msgidText.isNull()) {
524
 
                msgidText = i18n("Unknown");
525
 
        }
526
 
 }
527
 
 QStringList items;
528
 
 items << QTime::currentTime().toString() <<
529
 
    QString::number(msgid) << QString::number(receiver) <<
530
 
    QString::number(sender) << msgidText;
531
 
 new QTreeWidgetItem( d->mMessageList, items);
532
 
}
533
 
 
534
 
void KGameDebugDialog::slotClearMessages()
535
 
{
536
 
 d->mMessageList->clear();
537
 
}
538
 
 
539
 
void KGameDebugDialog::slotShowId()
540
 
{
541
 
/* QListBoxItem* i = d->mHideIdList->firstItem();
542
 
 for (; i; i = i->next()) {
543
 
        if (i->selected()) {
544
 
                d->mHideIdList->removeItem(i->);
545
 
        }
546
 
 }*/
547
 
 if (!d->mHideIdList->currentItem()) {
548
 
        return;
549
 
 }
550
 
 d->mHideIdList->takeItem(d->mHideIdList->currentRow());
551
 
}
552
 
 
553
 
void KGameDebugDialog::slotHideId()
554
 
{
555
 
 if (!d->mMessageList->currentItem()) {
556
 
        return;
557
 
 }
558
 
 int msgid = d->mMessageList->currentItem()->text(1).toInt();
559
 
 if (!showId(msgid)) {
560
 
        return;
561
 
 }
562
 
 (void)new QListWidgetItem(QString::number(msgid), d->mHideIdList);
563
 
}
564
 
 
565
 
bool KGameDebugDialog::showId(int msgid)
566
 
{
567
 
 for (int j = 0; j < d->mHideIdList->count(); ++j) {
568
 
        QListWidgetItem* i = d->mHideIdList->item(j);
569
 
        if (i->text().toInt() == msgid) {
570
 
                return false;
571
 
        }
572
 
 }
573
 
 return true;
574
 
}
575
 
 
576
 
 
577
 
#include "kgamedebugdialog.moc"