← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/interfacehandler.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/interfacehandler.cpp
 
1
/*
 
2
* interfacehandler.cpp
 
3
*/
 
4
 
 
5
#include "defines.h"
 
6
#include "interfacehandler.h"
 
7
#include "board.h"
 
8
#include "textedit_gui.h"
 
9
#include "normaltools_gui.h"
 
10
#include "scoretools_gui.h"
 
11
#include "mainwidget.h"
 
12
#include "icons.h"
 
13
#include "move.h"
 
14
#include <qaction.h>
 
15
#include <qpushbutton.h>
 
16
#include <qlabel.h>
 
17
#include <qtextedit.h>
 
18
#include <qbuttongroup.h>
 
19
#include <qlineedit.h>
 
20
#include <qslider.h>
 
21
#include <qtabwidget.h>
 
22
 
 
23
#ifdef USE_XPM
 
24
#include ICON_NODE_BLACK
 
25
#include ICON_NODE_WHITE
 
26
#endif
 
27
 
 
28
struct ButtonState
 
29
{
 
30
    bool navPrevVar, navNextVar, navBackward, navForward, navFirst, navStartVar, navMainBranch,
 
31
                navLast, navNextBranch, navPrevComment, navNextComment, navIntersection, editPaste, editPasteBrother; // SL added eb 11
 
32
};
 
33
 
 
34
InterfaceHandler::InterfaceHandler()
 
35
{
 
36
    buttonState = new ButtonState;
 
37
    scored_flag = false;
 
38
}
 
39
 
 
40
InterfaceHandler::~InterfaceHandler()
 
41
{
 
42
    delete buttonState;
 
43
}
 
44
 
 
45
GameMode InterfaceHandler::toggleMode()
 
46
{
 
47
        GameMode mode = board->getGameMode();
 
48
        
 
49
        switch (mode)
 
50
        {
 
51
        case modeEdit:
 
52
                board->setMode(modeNormal);
 
53
//              modeButton->setEnabled(true);
 
54
                mainWidget->setToolsTabWidget(tabEdit, tabEnable);
 
55
                scoreButton->setEnabled(true);
 
56
                scoreButton->setText(QObject::tr("Score", "button label"));
 
57
                passButton->setEnabled(true);
 
58
                undoButton->setDisabled(true); // for later: undo button -> one step back
 
59
                resignButton->setDisabled(true);
 
60
                adjournButton->setDisabled(true);
 
61
                refreshButton->setDisabled(true);
 
62
                commentEdit->setReadOnly(false);
 
63
                //commentEdit2->setReadOnly(true);
 
64
                commentEdit2->setDisabled(true);
 
65
                statusMode->setText(" " + QObject::tr("N", "Board status line: normal mode") + " ");
 
66
                statusMark->setText(" - ");
 
67
                return modeNormal;
 
68
                
 
69
        case modeNormal:
 
70
                board->setMode(modeEdit);
 
71
//              modeButton->setEnabled(true);
 
72
                mainWidget->setToolsTabWidget(tabEdit, tabEnable);
 
73
                scoreButton->setDisabled(true);
 
74
                scoreButton->setText(QObject::tr("Score", "button label"));
 
75
                passButton->setDisabled(true);
 
76
                undoButton->setDisabled(true);
 
77
                resignButton->setDisabled(true);
 
78
                adjournButton->setDisabled(true);
 
79
                refreshButton->setDisabled(true);
 
80
                commentEdit->setReadOnly(false);
 
81
                //commentEdit2->setReadOnly(true);
 
82
                commentEdit2->setDisabled(true);
 
83
                statusMode->setText(" " + QObject::tr("E", "Board status line: edit mode") + " ");
 
84
                statusMark->setText(getStatusMarkText(board->getMarkType()));
 
85
                return modeEdit;
 
86
                
 
87
        case modeObserve:
 
88
                board->setMode(modeObserve);
 
89
//              modeButton->setDisabled(true);
 
90
                mainWidget->setToolsTabWidget(tabEdit, tabDisable);
 
91
                scoreButton->setEnabled(true);
 
92
                scoreButton->setText(QObject::tr("Edit", "button label"));
 
93
                passButton->setDisabled(true);
 
94
                undoButton->setDisabled(true);
 
95
                resignButton->setDisabled(true);
 
96
                adjournButton->setDisabled(true);
 
97
                refreshButton->setEnabled(true);
 
98
                commentEdit->setReadOnly(true);
 
99
                commentEdit2->setReadOnly(false);
 
100
                commentEdit2->setDisabled(false);
 
101
    editCut->setEnabled(false);                  //added eb 9
 
102
    editDelete->setEnabled(false);               //end add eb 9
 
103
                statusMode->setText(" " + QObject::tr("O", "Board status line: observe mode") + " ");
 
104
                statusMark->setText(getStatusMarkText(board->getMarkType()));
 
105
                return modeObserve;
 
106
                
 
107
        case modeMatch : 
 
108
                board->setMode(modeMatch);
 
109
//              modeButton->setDisabled(true);
 
110
                mainWidget->setToolsTabWidget(tabEdit, tabDisable);
 
111
                scoreButton->setEnabled(true);
 
112
                scoreButton->setText(QObject::tr("Edit", "button label"));
 
113
                passButton->setEnabled(true);
 
114
                passButton->setText(QObject::tr("Pass", "button label"));
 
115
                undoButton->setEnabled(true);
 
116
                resignButton->setEnabled(true);
 
117
                adjournButton->setEnabled(true);
 
118
                refreshButton->setEnabled(true);
 
119
                commentEdit->setReadOnly(true);
 
120
                commentEdit2->setReadOnly(false);
 
121
                commentEdit2->setDisabled(false);
 
122
                statusMode->setText(" " + QObject::tr("P", "Board status line: play mode") + " ");
 
123
                statusMark->setText(getStatusMarkText(board->getMarkType()));
 
124
                return modeMatch;
 
125
 
 
126
        case   modeComputer :           // added eb 12
 
127
                board->setMode(modeComputer);
 
128
//              modeButton->setDisabled(true);
 
129
                mainWidget->setToolsTabWidget(tabEdit, tabDisable);
 
130
                scoreButton->setEnabled(true);
 
131
                scoreButton->setText(QObject::tr("Edit", "button label"));
 
132
                passButton->setEnabled(true);
 
133
                passButton->setText(QObject::tr("Pass", "button label"));
 
134
                undoButton->setEnabled(true);
 
135
                resignButton->setEnabled(true);
 
136
                adjournButton->setEnabled(false);
 
137
                refreshButton->setEnabled(false);
 
138
                commentEdit->setReadOnly(true);
 
139
                commentEdit2->setReadOnly(false);
 
140
                commentEdit2->setDisabled(false);
 
141
                statusMode->setText(" " + QObject::tr("P", "Board status line: play mode") + " ");
 
142
                statusMark->setText(getStatusMarkText(board->getMarkType()));
 
143
                return modeComputer;               //end add eb 12
 
144
                
 
145
        case modeTeach:
 
146
                board->setMode(modeTeach);
 
147
//              modeButton->setDisabled(true);
 
148
                mainWidget->setToolsTabWidget(tabEdit, tabDisable);
 
149
                scoreButton->setEnabled(true);
 
150
                scoreButton->setText(QObject::tr("Edit", "button label"));
 
151
                passButton->setEnabled(true);
 
152
                passButton->setText(QObject::tr("Pass", "button label"));
 
153
                undoButton->setEnabled(true);
 
154
                resignButton->setEnabled(true);
 
155
                adjournButton->setEnabled(true);
 
156
                refreshButton->setEnabled(true);
 
157
                commentEdit->setReadOnly(true);
 
158
                commentEdit2->setReadOnly(false);
 
159
                commentEdit2->setDisabled(false);
 
160
                statusMode->setText(" " + QObject::tr("T", "Board status line: teach mode") + " ");
 
161
                statusMark->setText(getStatusMarkText(board->getMarkType()));
 
162
                return modeTeach;
 
163
                
 
164
        case modeScore:
 
165
//              modeButton->setDisabled(true);
 
166
                mainWidget->setToolsTabWidget(tabEdit, tabDisable);
 
167
//              mainWidget->setToolsTabWidget(tabNormalScore);
 
168
                scoreButton->setEnabled(true);
 
169
                scoreButton->setText(QObject::tr("Score", "button label"));
 
170
                passButton->setDisabled(true);
 
171
                undoButton->setEnabled(true);
 
172
                resignButton->setDisabled(true);
 
173
                adjournButton->setEnabled(true);
 
174
                refreshButton->setEnabled(true);
 
175
                commentEdit->setReadOnly(true);
 
176
                //commentEdit2->setReadOnly(true);
 
177
                commentEdit2->setDisabled(true);
 
178
                statusMode->setText(" " + QObject::tr("S", "Board status line: score mode") + " ");
 
179
                statusMark->setText(getStatusMarkText(board->getMarkType()));
 
180
                return modeScore;
 
181
                
 
182
        default:
 
183
                return modeNormal;
 
184
        }
 
185
}
 
186
 
 
187
void InterfaceHandler::setEditMode()
 
188
{
 
189
//    modeButton->setOn(true);
 
190
        mainWidget->setToolsTabWidget(tabEdit);
 
191
//    normalTools->hide();
 
192
//    editTools->show();
 
193
    board->setMode(modeEdit);
 
194
    statusMode->setText(" " + QObject::tr("E", "Board status line: edit mode") + " ");
 
195
    statusMark->setText(getStatusMarkText(board->getMarkType()));
 
196
}
 
197
 
 
198
void InterfaceHandler::setMoveData(int n, bool black, int brothers, int sons, bool hasParent,
 
199
                                                                   bool hasPrev, bool hasNext, int lastX, int lastY)
 
200
{
 
201
    QString s(QObject::tr("Move") + " ");
 
202
    s.append(QString::number(n));
 
203
    if (lastX >= 1 && lastX <= board->getBoardSize() && lastY >= 1 && lastY <= board->getBoardSize())
 
204
    {
 
205
                s.append(" (");
 
206
                s.append(black ? QObject::tr("W")+" " : QObject::tr("B")+" ");
 
207
                s.append(QString(QChar(static_cast<const char>('A' + (lastX<9?lastX:lastX+1) - 1))) +
 
208
                        QString::number(board->getBoardSize()-lastY+1) + ")");
 
209
    }
 
210
    else if (lastX == 20 && lastY == 20)  // Pass
 
211
    {
 
212
                s.append(" (");
 
213
                s.append(black ? QObject::tr("W")+" " : QObject::tr("B")+" ");
 
214
                s.append(" " + QObject::tr("Pass") + ")");
 
215
    }
 
216
    
 
217
    moveNumLabel->setText(s);
 
218
    statusTurn->setText(" " + s.right(s.length() - 5) + " ");  // Without 'Move '
 
219
        
 
220
    statusNav->setText(" " + QString::number(brothers) + "/" + QString::number(sons));
 
221
    
 
222
    s = black ? QObject::tr("Black to play") : QObject::tr("White to play");
 
223
    turnLabel->setText(s);
 
224
        
 
225
    s = "";
 
226
    s.append(QString::number(brothers));
 
227
    if (brothers == 1)
 
228
                s.append(" " + QObject::tr("brother") + "\n");
 
229
    else
 
230
                s.append(" " + QObject::tr("brothers") + "\n");
 
231
    s.append(QString::number(sons));
 
232
    if (sons == 1)
 
233
                s.append(" " + QObject::tr("son"));
 
234
    else
 
235
                s.append(" " + QObject::tr("sons"));
 
236
    varLabel->setText(s);
 
237
        
 
238
        if (board->getGameMode() == modeNormal || board->getGameMode() == modeEdit)
 
239
        {
 
240
                // Update the toolbar buttons
 
241
                navPrevVar->setEnabled(hasPrev);
 
242
                navNextVar->setEnabled(hasNext);
 
243
                navBackward->setEnabled(hasParent);
 
244
                navForward->setEnabled(sons);
 
245
                navFirst->setEnabled(hasParent);
 
246
                navStartVar->setEnabled(hasParent);
 
247
                navMainBranch->setEnabled(hasParent);
 
248
                navLast->setEnabled(sons);
 
249
                navNextBranch->setEnabled(sons);
 
250
                navSwapVariations->setEnabled(hasPrev);
 
251
                navPrevComment->setEnabled(hasParent);
 
252
                navNextComment->setEnabled(sons);
 
253
    navIntersection->setEnabled(true); //SL added eb 11
 
254
                
 
255
                slider->setEnabled(true);
 
256
        }
 
257
  else  if (board->getGameMode() == modeObserve)  // add eb 8
 
258
        {
 
259
                // Update the toolbar buttons
 
260
                navBackward->setEnabled(hasParent);
 
261
                navForward->setEnabled(sons);
 
262
                navFirst->setEnabled(hasParent);
 
263
                navLast->setEnabled(sons);
 
264
                navPrevComment->setEnabled(hasParent);
 
265
                navNextComment->setEnabled(sons);
 
266
    navIntersection->setEnabled(true);  //SL added eb 11
 
267
 
 
268
                slider->setEnabled(true);
 
269
 
 
270
    board->getBoardHandler()->display_incoming_move = !bool(sons);            //SL added eb 9 - This is used to know whether we are browsing through a game or at the last move
 
271
                                                    
 
272
  }                                                 
 
273
        else                                               //end add eb 8
 
274
                slider->setDisabled(true);
 
275
        
 
276
    // Update slider
 
277
  mainWidget->toggleSliderSignal(false);
 
278
 
 
279
  int mv = slider->maxValue();                            // add eb 8
 
280
  int v = slider->value();
 
281
    
 
282
  if (slider->maxValue() < n)
 
283
                  setSliderMax(n);
 
284
                                                                  // we need to be carefull with the slider
 
285
  if (board->getGameMode() != modeObserve ||                    // normal case, slider is moved
 
286
    (board->getGameMode() == modeObserve && mv >= n) ||       // observing, but browsing (no incoming move)
 
287
    (board->getGameMode() == modeObserve && mv < n && v==n-1))// observing, but at the last move, and an incoming move occurs 
 
288
          slider->setValue(n);
 
289
          
 
290
                                                             // end add eb 8
 
291
      
 
292
    mainWidget->toggleSliderSignal(true);
 
293
}
 
294
 
 
295
// clear the big field (offline)
 
296
void InterfaceHandler::clearComment()
 
297
{
 
298
        commentEdit->clear();
 
299
}
 
300
 
 
301
// display text
 
302
void InterfaceHandler::displayComment(const QString &c)
 
303
{
 
304
        if (board->get_isLocalGame())
 
305
        {
 
306
                if (c.isEmpty())
 
307
                        commentEdit->clear();
 
308
                else
 
309
                        commentEdit->setText(c);
 
310
        }
 
311
        else if (!c.isEmpty())
 
312
                        commentEdit->append(c);
 
313
}
 
314
 
 
315
// get the comment of commentEdit - the multiline field
 
316
QString InterfaceHandler::getComment()
 
317
{
 
318
        return commentEdit->text();
 
319
}
 
320
 
 
321
// get the comment of commentEdit2 - the single line
 
322
QString InterfaceHandler::getComment2()
 
323
{
 
324
        QString text = commentEdit2->text();
 
325
        
 
326
        // clear entry
 
327
        commentEdit2->setText("");
 
328
        
 
329
        // don't show short text
 
330
        if (text.length() < 1)
 
331
                return 0;
 
332
        
 
333
        return text;
 
334
}
 
335
 
 
336
void InterfaceHandler::setMarkType(int m)
 
337
{
 
338
    MarkType t;
 
339
    QString txt;
 
340
        
 
341
    switch(m)
 
342
    {
 
343
    case 0:
 
344
                t = markNone;
 
345
                break;
 
346
                
 
347
    case 1:
 
348
                t = markSquare;
 
349
                break;
 
350
                
 
351
    case 2:
 
352
                t = markCircle;
 
353
                break;
 
354
                
 
355
    case 3:
 
356
                t = markTriangle;
 
357
                break;
 
358
                
 
359
    case 4:
 
360
                t = markCross;
 
361
                break;
 
362
                
 
363
    case 5:
 
364
                t = markText;
 
365
                break;
 
366
                
 
367
    case 6:
 
368
                t = markNumber;
 
369
                break;
 
370
 
 
371
        case 7:
 
372
        {
 
373
                Move *current = board->getBoardHandler()->getTree()->getCurrent();
 
374
                // set next move's color
 
375
                if (board->getBoardHandler()->getBlackTurn())
 
376
                {
 
377
                        current->setPLinfo(stoneWhite);
 
378
#ifndef USE_XPM
 
379
                        mainWidget->colorButton->setPixmap(QPixmap(ICON_NODE_WHITE));
 
380
#else
 
381
                        mainWidget->colorButton->setPixmap(QPixmap(const_cast<const char**>(node_white_xpm)));
 
382
#endif
 
383
                }
 
384
                else
 
385
                {
 
386
                        current->setPLinfo(stoneBlack);
 
387
#ifndef USE_XPM
 
388
                        mainWidget->colorButton->setPixmap(QPixmap(ICON_NODE_BLACK));
 
389
#else
 
390
                        mainWidget->colorButton->setPixmap(QPixmap(const_cast<const char**>(node_black_xpm)));
 
391
#endif
 
392
                }
 
393
 
 
394
                // check if set color is natural color:
 
395
                if (current->getMoveNumber() == 0 && current->getPLnextMove() == stoneBlack ||
 
396
                        current->getMoveNumber() > 0 && current->getColor() != current->getPLnextMove())
 
397
                        current->clearPLinfo();
 
398
 
 
399
                board->setCurStoneColor();
 
400
                return;
 
401
        }
 
402
                
 
403
    default:
 
404
                return;
 
405
    }
 
406
        
 
407
    statusMark->setText(getStatusMarkText(t));
 
408
    board->setMarkType(t);
 
409
}
 
410
 
 
411
void InterfaceHandler::clearData()
 
412
{
 
413
    // qDebug("void InterfaceHandler::clearData()");
 
414
        
 
415
    clearComment();
 
416
    setMoveData(0, true, 0, 0, false, false, false);
 
417
//    modeButton->setOn(false);
 
418
          mainWidget->setToolsTabWidget(tabNormalScore);
 
419
    mainWidget->editButtonGroup->setButton(0);
 
420
//    editTools->hide();
 
421
    normalTools->capturesBlack->setText("0");
 
422
    normalTools->capturesWhite->setText("0");
 
423
        
 
424
    if (board->getGameMode() != modeObserve && 
 
425
                board->getGameMode() != modeMatch &&
 
426
                board->getGameMode() != modeTeach)
 
427
    {
 
428
                normalTools->pb_timeBlack->setText("00:00");
 
429
                normalTools->pb_timeWhite->setText("00:00");
 
430
    }
 
431
    normalTools->show();
 
432
    scoreButton->setOn(false);
 
433
    editPaste->setEnabled(false);
 
434
    editPasteBrother->setEnabled(false);
 
435
    slider->setValue(0);
 
436
    setSliderMax(SLIDER_INIT);
 
437
    scored_flag = false;
 
438
}
 
439
 
 
440
void InterfaceHandler::toggleSidebar(bool toggle)
 
441
{
 
442
    if (!toggle)
 
443
                toolsFrame->hide();
 
444
    else
 
445
                toolsFrame->show();
 
446
}
 
447
 
 
448
QString InterfaceHandler::getTextLabelInput(QWidget *parent, const QString &oldText)
 
449
{
 
450
    TextEditDialog dlg(parent, QObject::tr("textedit"), true);
 
451
    dlg.textLineEdit->setFocus();
 
452
    if (!oldText.isNull() && !oldText.isEmpty())
 
453
                dlg.textLineEdit->setText(oldText);
 
454
    
 
455
    if (dlg.exec() == QDialog::Accepted)
 
456
                return dlg.textLineEdit->text();
 
457
    return NULL;
 
458
}
 
459
 
 
460
void InterfaceHandler::showEditGroup()
 
461
{
 
462
//    editTools->editButtonGroup->show();
 
463
//      mainWidget->setToolsTabWidget(tabEdit);
 
464
}
 
465
 
 
466
void InterfaceHandler::toggleMarks()
 
467
{
 
468
        if (board->getGameMode() == modeEdit)
 
469
                return;
 
470
//    if (!modeButton->isOn())
 
471
//              return;
 
472
        
 
473
    int cur = board->getMarkType();
 
474
    cur ++;
 
475
    if (cur > 6)
 
476
                cur = 0;
 
477
    mainWidget->editButtonGroup->setButton(cur);
 
478
    setMarkType(cur);
 
479
}
 
480
 
 
481
const QString InterfaceHandler::getStatusMarkText(MarkType t)
 
482
{
 
483
    QString txt;
 
484
    
 
485
    switch(t)
 
486
    {
 
487
    case markNone:
 
488
                txt = " S ";
 
489
                break;
 
490
                
 
491
    case markSquare:
 
492
                txt = " Q ";
 
493
                break;
 
494
                
 
495
    case markCircle:
 
496
                txt = " C ";
 
497
                break;
 
498
                
 
499
    case markTriangle:
 
500
                txt = " T ";
 
501
                break;
 
502
                
 
503
    case markCross:
 
504
                txt = " X ";
 
505
                break;
 
506
                
 
507
    case markText:
 
508
                txt = " A ";
 
509
                break;
 
510
                
 
511
    case markNumber:
 
512
                txt = " 1 ";
 
513
                break;
 
514
                
 
515
    default:
 
516
                txt = " ? ";
 
517
    }
 
518
    
 
519
    return txt;
 
520
}
 
521
 
 
522
void InterfaceHandler::setCaptures(float black, float white, bool /*scored*/)
 
523
{
 
524
/*
 
525
if (scored && !scored_flag)
 
526
{
 
527
normalTools->capturesFrame->setTitle(QObject::tr("Points"));
 
528
scored_flag = true;
 
529
}
 
530
else if (!scored && scored_flag)
 
531
{
 
532
normalTools->capturesFrame->setTitle(QObject::tr("Captures"));
 
533
scored_flag = false;
 
534
}
 
535
        */
 
536
    capturesBlack->setText(QString::number(black));
 
537
    capturesWhite->setText(QString::number(white));
 
538
}
 
539
 
 
540
void InterfaceHandler::setTimes(const QString &btime, const QString &bstones, const QString &wtime, const QString &wstones)
 
541
{
 
542
        if (btime)
 
543
        {
 
544
                if (bstones != QString("-1"))
 
545
                        normalTools->pb_timeBlack->setText(btime + " / " + bstones);
 
546
                else
 
547
                        normalTools->pb_timeBlack->setText(btime);
 
548
        }
 
549
 
 
550
        if (wtime)
 
551
        {
 
552
                if (wstones != QString("-1"))
 
553
                        normalTools->pb_timeWhite->setText(wtime + " / " + wstones);
 
554
                else
 
555
                        normalTools->pb_timeWhite->setText(wtime);
 
556
        }
 
557
}
 
558
 
 
559
void InterfaceHandler::setTimes(bool isBlacksTurn, float time, int stones)
 
560
{
 
561
        QString strTime;
 
562
        int seconds = (int)time;
 
563
        bool neg = seconds < 0;
 
564
        if (neg)
 
565
                seconds = -seconds;
 
566
 
 
567
        int h = seconds / 3600;
 
568
        seconds -= h*3600;
 
569
        int m = seconds / 60;
 
570
        int s = seconds - m*60;
 
571
 
 
572
        QString sec;
 
573
 
 
574
        // prevailling 0 for seconds
 
575
        if ((h || m) && s < 10)
 
576
                sec = "0" + QString::number(s);
 
577
        else
 
578
                sec = QString::number(s);
 
579
 
 
580
        if (h)
 
581
        {
 
582
                QString min;
 
583
 
 
584
                // prevailling 0 for minutes
 
585
                if (h && m < 10)
 
586
                        min = "0" + QString::number(m);
 
587
                else
 
588
                        min = QString::number(m);
 
589
 
 
590
                strTime = (neg ? "-" : "") + QString::number(h) + ":" + min + ":" + sec;
 
591
        }
 
592
        else
 
593
                strTime = (neg ? "-" : "") + QString::number(m) + ":" + sec;
 
594
 
 
595
        if (isBlacksTurn)
 
596
                setTimes(strTime, QString::number(stones), 0, 0);
 
597
        else
 
598
                setTimes(0, 0, strTime, QString::number(stones));
 
599
}
 
600
 
 
601
void InterfaceHandler::disableToolbarButtons()
 
602
{
 
603
    CHECK_PTR(buttonState);
 
604
        
 
605
    buttonState->navPrevVar = navPrevVar->isEnabled();
 
606
    navPrevVar->setEnabled(false);
 
607
        
 
608
    buttonState->navNextVar = navNextVar->isEnabled();
 
609
    navNextVar->setEnabled(false);
 
610
        
 
611
    buttonState->navBackward = navBackward->isEnabled();
 
612
    navBackward->setEnabled(false);
 
613
    
 
614
    buttonState->navForward = navForward->isEnabled();
 
615
    navForward->setEnabled(false);
 
616
        
 
617
    buttonState->navFirst = navFirst->isEnabled();
 
618
    navFirst->setEnabled(false);
 
619
        
 
620
    buttonState->navStartVar = navStartVar->isEnabled();
 
621
    navStartVar->setEnabled(false);
 
622
        
 
623
    buttonState->navMainBranch = navMainBranch->isEnabled();
 
624
    navMainBranch->setEnabled(false);
 
625
        
 
626
    buttonState->navLast = navLast->isEnabled();
 
627
    navLast->setEnabled(false);
 
628
        
 
629
    buttonState->navNextBranch = navNextBranch->isEnabled();
 
630
    navNextBranch->setEnabled(false);
 
631
        
 
632
    buttonState->navPrevComment = navPrevComment->isEnabled();
 
633
          navPrevComment->setEnabled(false);
 
634
 
 
635
    buttonState->navNextComment = navNextComment->isEnabled();
 
636
          navNextComment->setEnabled(false);
 
637
 
 
638
    buttonState->navIntersection = navIntersection->isEnabled(); // added eb 111
 
639
          navIntersection->setEnabled(false);                          // end add eb 11
 
640
 
 
641
    buttonState->editPaste = editPaste->isEnabled();
 
642
    editPaste->setEnabled(false);
 
643
        
 
644
    buttonState->editPasteBrother = editPasteBrother->isEnabled();
 
645
    editPasteBrother->setEnabled(false);
 
646
    
 
647
    navNthMove->setEnabled(false);
 
648
    navAutoplay->setEnabled(false);
 
649
    editCut->setEnabled(false);
 
650
    editDelete->setEnabled(false);
 
651
    navEmptyBranch->setEnabled(false);
 
652
    navCloneNode->setEnabled(false);
 
653
    navSwapVariations->setEnabled(false);
 
654
    fileImportASCII->setEnabled(false);
 
655
    fileImportASCIIClipB->setEnabled(false);
 
656
    fileImportSgfClipB->setEnabled(false);
 
657
}
 
658
 
 
659
void InterfaceHandler::restoreToolbarButtons()
 
660
{
 
661
    CHECK_PTR(buttonState);
 
662
        
 
663
        navPrevVar->setEnabled(buttonState->navPrevVar);
 
664
        navNextVar->setEnabled(buttonState->navNextVar);
 
665
        navBackward->setEnabled(buttonState->navBackward);
 
666
        navForward->setEnabled(buttonState->navForward);
 
667
        navFirst->setEnabled(buttonState->navFirst);
 
668
        navStartVar->setEnabled(buttonState->navStartVar);
 
669
        navMainBranch->setEnabled(buttonState->navMainBranch);
 
670
        navLast->setEnabled(buttonState->navLast);
 
671
        navNextBranch->setEnabled(buttonState->navNextBranch);
 
672
        navPrevComment->setEnabled(buttonState->navPrevComment);
 
673
        navNextComment->setEnabled(buttonState->navNextComment);
 
674
  navIntersection->setEnabled(buttonState->navNextComment);  // SL added eb 11
 
675
        editPaste->setEnabled(buttonState->editPaste);
 
676
        editPasteBrother->setEnabled(buttonState->editPasteBrother);
 
677
        
 
678
        navNthMove->setEnabled(true);
 
679
        navAutoplay->setEnabled(true);
 
680
        editCut->setEnabled(true);
 
681
        editDelete->setEnabled(true);
 
682
        navEmptyBranch->setEnabled(true);
 
683
        navCloneNode->setEnabled(true);
 
684
        navSwapVariations->setEnabled(true);
 
685
        fileImportASCII->setEnabled(true);
 
686
        fileImportASCIIClipB->setEnabled(true);
 
687
        fileImportSgfClipB->setEnabled(true);
 
688
}
 
689
 
 
690
void InterfaceHandler::setScore(int terrB, int capB, int terrW, int capW, float komi)
 
691
{
 
692
        scoreTools->komi->setText(QString::number(komi));
 
693
        scoreTools->terrWhite->setText(QString::number(terrW));
 
694
        scoreTools->capturesWhite->setText(QString::number(capW));
 
695
        scoreTools->totalWhite->setText(QString::number((float)terrW + (float)capW + komi));
 
696
        scoreTools->terrBlack->setText(QString::number(terrB));
 
697
        scoreTools->capturesBlack->setText(QString::number(capB));
 
698
        scoreTools->totalBlack->setText(QString::number(terrB + capB));
 
699
}
 
700
 
 
701
void InterfaceHandler::setClipboard(bool b)
 
702
{
 
703
    if (b)  // Clipboard filled
 
704
    {
 
705
                editPaste->setEnabled(true);
 
706
                editPasteBrother->setEnabled(true);
 
707
    }
 
708
    else    // Clipboard filled
 
709
    {
 
710
                editPaste->setEnabled(false);
 
711
                editPasteBrother->setEnabled(false);
 
712
    }
 
713
}
 
714
 
 
715
void InterfaceHandler::setSliderMax(int n)
 
716
{
 
717
    if (n < 0)
 
718
                n = 0;
 
719
    
 
720
    slider->setMaxValue(n);
 
721
    mainWidget->sliderRightLabel->setText(QString::number(n));
 
722
}
 
723