← Back to branch summary

~ubuntu-branches/ubuntu/maverick/qgo/maverick

« back to all changes in this revision

Viewing changes to src/mainwidget.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Martin A. Godisch
  • Date: 2005-01-01 23:07:10 UTC
  • Revision ID: james.westby@ubuntu.com-20050101230710-fhng6yidm47xlb2i
Tags: upstream-1.0.0-r2
Import upstream version 1.0.0-r2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mainwidget.cpp
 
1
/*
 
2
* mainwidget.cpp
 
3
*/
 
4
 
 
5
#include "qgo.h"
 
6
#include "mainwidget.h"
 
7
#include "interfacehandler.h"
 
8
#include "normaltools_gui.h"
 
9
#include "scoretools_gui.h"
 
10
#include "defines.h"
 
11
#include "icons.h"
 
12
#include <qbuttongroup.h>
 
13
#include <qpushbutton.h>
 
14
#include <qlayout.h>
 
15
#include <qslider.h>
 
16
#include <qlabel.h>
 
17
#include <qlineedit.h>
 
18
#include <qtabwidget.h>
 
19
 
 
20
#ifdef USE_XPM
 
21
#include ICON_NODE_BLACK
 
22
#include ICON_NODE_WHITE
 
23
#endif
 
24
 
 
25
/* 
 
26
*  Constructs a MainWidget which is a child of 'parent', with the 
 
27
*  name 'name' and widget flags set to 'f' 
 
28
*/
 
29
MainWidget::MainWidget(QWidget* parent,  const char* name, WFlags fl )
 
30
: MainWidgetGui( parent, name, fl )
 
31
{
 
32
        connect(toolsTabWidget,
 
33
                SIGNAL(currentChanged(QWidget*)),
 
34
                SLOT(slot_toolsTabChanged(QWidget*)));
 
35
 
 
36
        normalTools->show();
 
37
 
 
38
        scoreTools = new ScoreTools(tab_ns, "scoreTools");
 
39
//      scoreTools->setSizePolicy(QSizePolicy((QSizePolicy::SizeType)5, (QSizePolicy::SizeType)0,
 
40
//      scoreTools->sizePolicy().hasHeightForWidth()));
 
41
        scoreTools->setMinimumSize(QSize(80, 230));
 
42
        scoreTools->hide();
 
43
        
 
44
        interfaceHandler = new InterfaceHandler();
 
45
        
 
46
        interfaceHandler->moveNumLabel = moveNumLabel;
 
47
        interfaceHandler->turnLabel = turnLabel;
 
48
        interfaceHandler->varLabel = varLabel;
 
49
//      interfaceHandler->editTools = editTools;
 
50
//      interfaceHandler->modeButton = modeButton;
 
51
        interfaceHandler->passButton = passButton;
 
52
        interfaceHandler->scoreButton = scoreButton;
 
53
        interfaceHandler->undoButton = undoButton;
 
54
        interfaceHandler->adjournButton = adjournButton;
 
55
        interfaceHandler->resignButton = resignButton;
 
56
        interfaceHandler->refreshButton = refreshButton;
 
57
        interfaceHandler->capturesBlack = normalTools->capturesBlack;
 
58
        interfaceHandler->capturesWhite = normalTools->capturesWhite;
 
59
        interfaceHandler->normalTools = normalTools;
 
60
//      interfaceHandler->teachTools = teachTools;
 
61
        interfaceHandler->scoreTools = scoreTools;
 
62
        interfaceHandler->toolsFrame = toolsFrame;
 
63
        interfaceHandler->board = board;
 
64
        
 
65
//      connect(editTools->editButtonGroup, SIGNAL(clicked(int)), this, SLOT(setMarkType(int)));
 
66
        
 
67
        showSlider = true;
 
68
        toggleSlider(setting->readBoolEntry("SLIDER"));
 
69
        slider->setMaxValue(SLIDER_INIT);
 
70
        sliderRightLabel->setText(QString::number(SLIDER_INIT));
 
71
        sliderSignalToggle = true;
 
72
        
 
73
        setFont(setting->fontStandard);
 
74
        normalTools->pb_timeWhite->setFont(setting->fontClocks);
 
75
        normalTools->pb_timeBlack->setFont(setting->fontClocks);
 
76
}
 
77
 
 
78
/*  
 
79
*  Destroys the object and frees any allocated resources
 
80
*/
 
81
MainWidget::~MainWidget()
 
82
{
 
83
        // no need to delete child widgets, Qt does it all for us
 
84
        delete interfaceHandler;
 
85
        delete scoreTools;
 
86
        delete normalTools;
 
87
}
 
88
 
 
89
// a tab has been clicked
 
90
void MainWidget::slot_toolsTabChanged(QWidget * /*w*/)
 
91
{
 
92
        static bool rememberEditTab = false;
 
93
 
 
94
        if (rememberEditTab)
 
95
        {
 
96
                // edit tab has been released
 
97
                rememberEditTab = false;
 
98
                interfaceHandler->toggleMode();
 
99
        }
 
100
 
 
101
        switch (toolsTabWidget->currentPageIndex())
 
102
        {
 
103
                // normal/score tools
 
104
                case tabNormalScore:
 
105
                        if (interfaceHandler->board->getGameMode() == modeEdit)
 
106
                        {
 
107
                                // sholdn't be, but however...
 
108
                                rememberEditTab = false;
 
109
                                interfaceHandler->toggleMode();
 
110
                        }
 
111
                        break;
 
112
 
 
113
                // edit tools
 
114
                case tabEdit:
 
115
                        // set color of next move
 
116
                        if (interfaceHandler->board->getBoardHandler()->getBlackTurn())
 
117
                        {
 
118
#ifndef USE_XPM
 
119
                                colorButton->setPixmap(QPixmap(ICON_NODE_BLACK));
 
120
#else
 
121
                                colorButton->setPixmap(QPixmap(const_cast<const char**>(node_black_xpm)));
 
122
#endif
 
123
                        }
 
124
                        else
 
125
                        {
 
126
#ifndef USE_XPM
 
127
                                colorButton->setPixmap(QPixmap(ICON_NODE_WHITE));
 
128
#else
 
129
                                colorButton->setPixmap(QPixmap(const_cast<const char**>(node_white_xpm)));
 
130
#endif
 
131
                        }
 
132
 
 
133
                        interfaceHandler->toggleMode();
 
134
                        rememberEditTab = true;
 
135
                        break;
 
136
 
 
137
                // teach tools + game tree
 
138
                case tabTeachGameTree:
 
139
                        break;
 
140
 
 
141
                default:
 
142
                        break;
 
143
        }
 
144
}
 
145
 
 
146
// set a tab on toolsTabWidget
 
147
void MainWidget::setToolsTabWidget(enum tabType p, enum tabState s)
 
148
{
 
149
        QWidget *w = NULL;
 
150
 
 
151
        switch (p)
 
152
        {
 
153
                case tabNormalScore:
 
154
                        w = tab_ns;
 
155
                        break;
 
156
 
 
157
                case tabEdit:
 
158
                        w = tab_e;
 
159
                        break;
 
160
 
 
161
                case tabTeachGameTree:
 
162
                        w = tab_tg;
 
163
                        break;
 
164
 
 
165
                default:
 
166
                        return;
 
167
                        break;
 
168
        }
 
169
 
 
170
        if (s == tabSet)
 
171
        {
 
172
                // check whether the page to switch to is enabled
 
173
                if (!toolsTabWidget->isEnabled())
 
174
                        toolsTabWidget->setTabEnabled(w, true);
 
175
 
 
176
                toolsTabWidget->setCurrentPage(p);
 
177
        }
 
178
        else
 
179
        {
 
180
                // check whether the current page is to disable; then set to 'normal'
 
181
                if (s == tabDisable && toolsTabWidget->currentPageIndex() == p)
 
182
                        toolsTabWidget->setCurrentPage(tabNormalScore);
 
183
 
 
184
                toolsTabWidget->setTabEnabled(w, s == tabEnable);
 
185
        }
 
186
}
 
187
 
 
188
/*
 
189
void MainWidget::toggleGameMode()
 
190
{
 
191
        if (interfaceHandler->toggleMode() != modeEdit)
 
192
        {
 
193
//              editTools->hide();
 
194
                normalTools->show();
 
195
//              if (modeButton->isOn())
 
196
//                      modeButton->setOn(false);
 
197
        }
 
198
        else
 
199
        {
 
200
                normalTools->hide();
 
201
//              editTools->show();
 
202
        }
 
203
}
 
204
*/
 
205
void MainWidget::setMarkType(int m)
 
206
{
 
207
        interfaceHandler->setMarkType(m);
 
208
}
 
209
 
 
210
void MainWidget::doPass()
 
211
{
 
212
        if (interfaceHandler->board->getGameMode() == modeScore)
 
213
        {
 
214
                interfaceHandler->board->doCountDone();
 
215
/*              if (scoreButton->text() != QString(tr("Edit")))
 
216
                {
 
217
                        scoreButton->toggle();
 
218
                }*/
 
219
        }
 
220
        else
 
221
                interfaceHandler->board->doPass();
 
222
}
 
223
 
 
224
void MainWidget::doRealScore(bool toggle)
 
225
{
 
226
        static GameMode rememberMode;
 
227
        static int      rememberTab;
 
228
 
 
229
qDebug("MainWidget::doRealScore()");
 
230
        if (toggle)
 
231
        {
 
232
                rememberMode = interfaceHandler->board->getGameMode();
 
233
                rememberTab = toolsTabWidget->currentPageIndex();
 
234
//              modeButton->setEnabled(false);
 
235
                setToolsTabWidget(tabEdit, tabDisable);
 
236
                setToolsTabWidget(tabTeachGameTree, tabDisable);
 
237
                if (scoreButton->text() == QString(tr("Edit")))
 
238
                {
 
239
                        passButton->setText(tr("Done"));
 
240
                        scoreButton->setEnabled(false);
 
241
 
 
242
      if (rememberMode==modeComputer)
 
243
      {
 
244
        adjournButton->setEnabled(false);
 
245
        resignButton->setEnabled(false);
 
246
        undoButton->setEnabled(false);
 
247
      }      
 
248
                }
 
249
    
 
250
                else
 
251
                        passButton->setEnabled(false);
 
252
 
 
253
 
 
254
                interfaceHandler->disableToolbarButtons();
 
255
//              editTools->hide();
 
256
                normalTools->hide();
 
257
                scoreTools->show();
 
258
//              interfaceHandler->board->setMode(modeScore);
 
259
                interfaceHandler->board->countScore();
 
260
        }
 
261
        else
 
262
        {
 
263
//              modeButton->setEnabled(true);
 
264
                setToolsTabWidget(tabEdit, tabEnable);
 
265
                setToolsTabWidget(tabTeachGameTree, tabEnable);
 
266
                if (scoreButton->text() == QString(tr("Edit")))
 
267
                {
 
268
                        passButton->setText(tr("Pass"));
 
269
                        scoreButton->setEnabled(true);
 
270
                }
 
271
                else
 
272
                        passButton->setEnabled(true);
 
273
                interfaceHandler->restoreToolbarButtons();
 
274
                scoreTools->hide();
 
275
                normalTools->show();
 
276
//              if (modeButton->isOn())
 
277
//                      editTools->show();
 
278
//              else
 
279
//                      normalTools->show();
 
280
                interfaceHandler->board->setMode(rememberMode);
 
281
                setToolsTabWidget(static_cast<tabType>(rememberTab));
 
282
        }
 
283
}
 
284
        
 
285
void MainWidget::doScore(bool toggle)
 
286
{
 
287
        static bool     skipNextSignal;
 
288
 
 
289
qDebug("MainWidget::doScore()");
 
290
        if (scoreButton->text() == QString(tr("Edit")))
 
291
        {
 
292
                if (scoreButton->isOn())
 
293
                {
 
294
                        // online mode -> don't score, open new Window instead
 
295
                        interfaceHandler->board->doEditBoardInNewWindow();
 
296
                        // setOn() causes a signal which has to be skipped over
 
297
                        skipNextSignal = true;
 
298
                        
 
299
                        scoreButton->setOn(false);
 
300
                        return;
 
301
                }
 
302
                
 
303
                if (skipNextSignal)
 
304
                {
 
305
                        // skip over this one incoming signal
 
306
                        skipNextSignal = false;
 
307
                        return;
 
308
                }
 
309
        }
 
310
 
 
311
        // offline mode -> scoring
 
312
        doRealScore(toggle);
 
313
}
 
314
 
 
315
void MainWidget::sliderChanged(int n)
 
316
{
 
317
        if (sliderSignalToggle)
 
318
                interfaceHandler->board->gotoNthMoveInVar(n);
 
319
}
 
320
 
 
321
void MainWidget::toggleSlider(bool b)
 
322
{
 
323
        if (showSlider == b)
 
324
                return;
 
325
        
 
326
        showSlider = b;
 
327
        
 
328
        if (b)
 
329
        {
 
330
                slider->show();
 
331
                sliderLeftLabel->show();
 
332
                sliderRightLabel->show();
 
333
        }
 
334
        else
 
335
        {
 
336
                slider->hide();
 
337
                sliderLeftLabel->hide();
 
338
                sliderRightLabel->hide();
 
339
        }
 
340
}
 
341
 
 
342
// Overwritten from QWidget
 
343
void MainWidget::setFont(const QFont &font)
 
344
{
 
345
        QFont f(font);
 
346
        f.setBold(true);
 
347
        scoreTools->totalBlack->setFont(f);
 
348
        scoreTools->totalWhite->setFont(f);
 
349
        
 
350
        QWidget::setFont(font);
 
351
}
 
352