src/mainwindow.cpp

   1 /*
   2   Copyright (c) 2006 Paolo Capriotti <p.capriotti@sns.it>
   3             (c) 2006 Maurizio Monge <maurizio.monge@kdemail.net>
   4
   5   This program is free software; you can redistribute it and/or modify
   6   it under the terms of the GNU General Public License as published by
   7   the Free Software Foundation; either version 2 of the License, or
   8   (at your option) any later version.
   9 */
  10
  11 #include "mainwindow.h"
  12 #include <boost/scoped_ptr.hpp>
  13 #include <kaction.h>
  14 #include <kstandardaction.h>
  15 #include <kactioncollection.h>
  16 #include <kicon.h>
  17 #include <klocale.h>
  18 #include <kurl.h>
  19 #include <kfiledialog.h>
  20 #include <kio/netaccess.h>
  21 #include <kmessagebox.h>
  22 #include <kmenubar.h>
  23 #include <QKeySequence>
  24 #include <QStackedWidget>
  25 #include <QDockWidget>
  26 #include <QCloseEvent>
  27 #include <QTextStream>
  28 #include <QTextCodec>
  29 #include <ktabwidget.h>
  30 #include "chesstable.h"
  31 #include "console.h"
  32 #include "clock.h"
  33 #include "newgame.h"
  34 #include "variants.h"
  35 #include "gameinfo.h"
  36 #include "controllers/editgame.h"
  37 #include "controllers/editposition.h"
  38 #include "engineinfo.h"
  39 #include "movelist_table.h"
  40 #include "icsconnection.h"
  41 #include "qconnect.h"
  42 #include "mastersettings.h"
  43 #include "flash.h"
  44 #include "foreach.h"
  45 #include "pgnparser.h"
  46 #include "pref_highlight.h"
  47 #include "pref_preferences.h"
  48
  49 using namespace Qt;
  50 using namespace boost;
  51
  52 MainWindow::~MainWindow() {
  53   delete console;
  54   qApp->quit();
  55 }
  56
  57 MainWindow::MainWindow(const QString& variant)
  58 : KXmlGuiWindow(0) {
  59   setObjectName("tagua_main");
  60   m_main = new KTabWidget(this);
  61   setCentralWidget(m_main);
  62
  63   m_movelist_stack = new QStackedWidget;
  64
  65   connect(m_main, SIGNAL(currentChanged(int)),
  66     this, SLOT(changeTab(int)));
  67   connect(m_main, SIGNAL(closeTab()),
  68     this, SLOT(closeTab()));
  69
  70   movelist_dock = new QDockWidget(this);
  71   movelist_dock->setWidget(m_movelist_stack);
  72   movelist_dock->setWindowTitle(i18n("Move list"));
  73   movelist_dock->setObjectName("move_list");
  74   addDockWidget(Qt::LeftDockWidgetArea, movelist_dock, Qt::Vertical);
  75   movelist_dock->show();
  76
  77   ChessTable* board = new ChessTable;
  78
  79   board->setFocus();
  80
  81   console_dock = new QDockWidget(this);
  82   console = new Console(0, i18n("FICS Connection"));
  83   console_dock->setWidget(console);
  84   console_dock->setFocusProxy(console);
  85   console_dock->setWindowTitle(i18n("Console"));
  86   console_dock->setObjectName("console");
  87   addDockWidget(Qt::BottomDockWidgetArea, console_dock, Qt::Horizontal);
  88   console_dock->setWindowFlags(console_dock->windowFlags() & ~Qt::WindowStaysOnTopHint);
  89   console_dock->show();
  90
  91   connect(board, SIGNAL(error(ErrorCode)), this, SLOT(displayErrorMessage(ErrorCode)));
  92   //BROKEN connect(board->clock(), SIGNAL(labelClicked(int)), &ui(), SLOT(setTurn(int)));
  93
  94 //  start in edit game mode
  95   newGame(variant, AbstractPosition::Ptr());
  96
  97   setupActions();
  98   setupGUI();
  99   setupEngineMenu();
 100   updatePromotionType();
 101 }
 102
 103 ChessTable* MainWindow::table() {
 104   return qobject_cast<ChessTable*>(m_main->currentWidget());
 105 }
 106
 107 KAction* MainWindow::installRegularAction(const QString& name, const KIcon& icon, const QString& text, QObject* obj, const char* slot) {
 108   KAction* temp = new KAction(icon, text, this);
 109   actionCollection()->addAction(name, temp);
 110   connect(temp, SIGNAL(triggered(bool)), obj, slot);
 111   return temp;
 112 }
 113
 114 void MainWindow::setupEngineMenu() {
 115   QMenu* engine_menu = 0;
 116   SettingArray engine_settings = settings().group("engines").array("engine");
 117   foreach (Settings s, engine_settings) {
 118     if (!engine_menu) {
 119       // this way the menu is created only if there is at least one engine
 120       engine_menu = menuBar()->addMenu(i18n("E&ngines"));
 121     }
 122
 123     QString name;
 124     EngineDetails engine_details;
 125     s["name"] >> engine_details.name;
 126     s["path"] >> engine_details.path;
 127     engine_details.type = EngineDetails::typeFromName(s["type"].value<QString>());
 128     if (s["work-path"])
 129       s["work-path"] >> engine_details.workPath;
 130
 131     kDebug() << "creating engine " << engine_details.name << endl;
 132     EngineInfo* engine = new EngineInfo(engine_details, ui());
 133
 134     m_engines.push_back(engine);
 135
 136     QMenu* menu = engine_menu->addMenu(engine_details.name);
 137
 138     {
 139       KAction* play_white = new KAction(i18n("Play as &white"), this);
 140       play_white->setCheckable(true);
 141       connect(play_white, SIGNAL(triggered()), engine, SLOT(playAsWhite()));
 142       menu->addAction(play_white);
 143     }
 144     {
 145       KAction* play_black = new KAction(i18n("Play as &black"), this);
 146       play_black->setCheckable(true);
 147       connect(play_black, SIGNAL(triggered()), engine, SLOT(playAsBlack()));
 148       menu->addAction(play_black);
 149     }
 150 #if 0 // disable analysis for the moment
 151     {
 152       KAction* analyze = new KAction(i18n("&Analyze"), this);
 153       analyze->setCheckable(true);
 154       connect(analyze, SIGNAL(triggered()), engine, SLOT(analyze()));
 155       menu->addAction(analyze);
 156     }
 157 #endif
 158   }
 159 }
 160
 161 void MainWindow::setupActions() {
 162   KStandardAction::openNew(this, SLOT(newGame()), actionCollection());
 163   KStandardAction::open(this, SLOT(loadGame()), actionCollection());
 164   KStandardAction::quit(this, SLOT(quit()), actionCollection());
 165
 166   installRegularAction("back", KIcon("go-previous"), i18n("&Back"), &ui(), SLOT(back()));
 167   installRegularAction("forward", KIcon("go-next"), i18n("&Forward"), &ui(), SLOT(forward()));
 168   installRegularAction("begin", KIcon("go-first"), i18n("Be&gin"), &ui(), SLOT(gotoFirst()));
 169   installRegularAction("end", KIcon("go-last"), i18n("&End"), &ui(), SLOT(gotoLast()));
 170   installRegularAction("connect", KIcon("connection-established"), i18n("&Connect"), this, SLOT(icsConnect()));
 171   installRegularAction("disconnect", KIcon("connect-no"), i18n("&Disconnect"), this, SLOT(icsDisconnect()));
 172
 173   KStandardAction::undo(&ui(), SLOT(undo()), actionCollection());
 174   KStandardAction::redo(&ui(), SLOT(redo()), actionCollection());
 175
 176   installRegularAction("pgnCopy", KIcon("edit-copy"), i18n("Copy PGN"), this, SLOT(pgnCopy()));
 177   installRegularAction("pgnPaste", KIcon("edit-paste"), i18n("Paste PGN"), this, SLOT(pgnPaste()));
 178   installRegularAction("editPosition", KIcon("edit"), i18n("&Edit position"), this, SLOT(editPosition()));
 179   installRegularAction("clearBoard", KIcon("edit-delete"), i18n("&Clear board"), &ui(), SLOT(clearBoard()));
 180   installRegularAction("setStartingPosition", KIcon("contents"), i18n("&Set starting position"),
 181       &ui(), SLOT(setStartingPosition()));
 182   installRegularAction("copyPosition", KIcon(), i18n("&Copy position"), &ui(), SLOT(copyPosition()));
 183   installRegularAction("pastePosition", KIcon(), i18n("&Paste position"), &ui(), SLOT(pastePosition()));
 184   installRegularAction("flip", KIcon("rotate"), i18n("&Flip view"), this, SLOT(flipView()));
 185   installRegularAction("toggleConsole", KIcon("openterm"), i18n("Toggle &console"), this, SLOT(toggleConsole()));
 186   installRegularAction("toggleMoveList", KIcon("view_text"), i18n("Toggle &move list"), this, SLOT(toggleMoveList()));
 187   installRegularAction("configure", KIcon("configure"), i18n("&Configure Tagua..."), this, SLOT(preferences()));
 188 }
 189
 190 void MainWindow::updatePromotionType() {
 191   // TODO: I'm removing this code because it causes a crash
 192   // and I don't want to investigate further, since the promotion
 193   // stuff needs to be changed completely.
 194 #if 0
 195   int ptype = m_ui.promotionType();
 196   if (ptype == 0)
 197     m_promote_group->setEnabled(false);
 198   else {
 199     m_promote_group->setEnabled(true);
 200     switch(ptype) {
 201     case QUEEN:
 202       m_promote_queen->setChecked(true);
 203       break;
 204     case ROOK:
 205       m_promote_rook->setChecked(true);
 206       break;
 207     case BISHOP:
 208       m_promote_bishop->setChecked(true);
 209       break;
 210     case KNIGHT:
 211       m_promote_knight->setChecked(true);
 212       break;
 213     default:
 214       m_promote_group->setEnabled(false);
 215     }
 216   }
 217
 218   std::cout << "do promotion: " << m_ui.doPromotion() << std::endl;
 219   m_do_promotion->setChecked(m_ui.doPromotion());
 220 #endif
 221 }
 222
 223 void MainWindow::readSettings() { }
 224 void MainWindow::writeSettings() { }
 225
 226 void MainWindow::closeEvent(QCloseEvent* e) {
 227   e->accept();
 228   writeSettings();
 229   delete this;
 230 }
 231
 232
 233 void MainWindow::keyPressEvent(QKeyEvent* event) {
 234   if (event->key() == Qt::Key_F5) {
 235     ui().createCtrlAction();
 236   }
 237 }
 238
 239 void MainWindow::keyReleaseEvent(QKeyEvent* event) {
 240   if (event->key() == Qt::Key_F5) {
 241     ui().destroyCtrlAction();
 242   }
 243 }
 244
 245 void MainWindow::changeTab(int index) {
 246   m_ui.setCurrentTab(m_main->currentWidget());
 247   m_movelist_stack->setCurrentIndex(index);
 248   updatePromotionType();
 249 }
 250
 251 void MainWindow::closeTab() {
 252   if (m_main->count() > 1) {
 253     ChessTable* old_board = table();
 254     m_ui.removeController(old_board);
 255     m_movelist_stack->removeWidget(
 256       m_movelist_stack->widget(m_main->currentIndex()));
 257     m_main->removeTab(m_main->currentIndex());
 258
 259     delete old_board;
 260
 261     if (m_main->count() <= 1) {
 262       m_main->setTabBarHidden(true);
 263     }
 264
 265     // update ui controller (just in case...)
 266     m_ui.setCurrentTab(m_main->currentWidget());
 267   }
 268 }
 269
 270 void MainWindow::createTab(ChessTable* board, const shared_ptr<Controller>& controller,
 271                            const QString& caption, int index) {
 272   if (index == -1)
 273     index = m_main->addTab(board, caption);
 274   else
 275     m_main->insertTab(index, board, caption);
 276
 277   m_main->setCurrentIndex(index);
 278   m_ui.addController(board, controller);
 279   m_ui.setCurrentTab(board);
 280   m_movelist_stack->addWidget(board->moveListTable());
 281   m_movelist_stack->setCurrentIndex(index);
 282   if (m_main->count() > 1) m_main->setTabBarHidden(false);
 283 }
 284
 285
 286 void MainWindow::cleanupGame(const QString& what, const QString& result) {
 287   Q_UNUSED(what);
 288   Q_UNUSED(result);
 289
 290   cleanupGame();
 291 }
 292
 293 void MainWindow::cleanupGame() {
 294   ui().detach();
 295   ui().end();
 296 }
 297
 298
 299 bool MainWindow::newGame(const QString& variantName, AbstractPosition::Ptr startingPos) {
 300   VariantInfo* variant = Variant::variant(variantName);
 301   if (!variant) {
 302     variant = Variant::variant("chess");
 303   }
 304
 305   if (variant) {
 306     ChessTable* board = new ChessTable;
 307     shared_ptr<Controller> controller(new EditGameController(
 308       board, variant, startingPos));
 309     createTab(board, controller,
 310       QString("Editing %1 game").arg(variant->name().toLower()));
 311     return true;
 312   }
 313   else return false;
 314 }
 315
 316
 317 void MainWindow::editPosition() {
 318 //BROKEN
 319 #if 0
 320   shared_ptr<Controller> controller(new EditPositionController(table(), ChessVariant::info()));
 321   m_main->setTabText(m_main->currentIndex(), "Editing chess position");
 322   ui().setController(controller);
 323 #endif
 324 }
 325
 326 void MainWindow::setupGame(const GameInfo* gameInfo, const PositionInfo& style12) {
 327   QString variantCode = gameInfo->variant();
 328   VariantInfo* variant = Variant::variant(variantCode);
 329   shared_ptr<EditGameController> controller(new EditGameController(
 330     table(), variant));
 331   Q_ASSERT(style12.relation == PositionInfo::NotMyMove ||
 332            style12.relation == PositionInfo::MyMove);
 333
 334   // set opponent side
 335   int side = (style12.relation == PositionInfo::MyMove ^ style12.turn == 0) ? 0 : 1;
 336
 337   if (controller->addICSPlayer(side, style12.gameNumber, m_connection)) {
 338     ui().setController(controller);
 339     table()->setPlayers(gameInfo->white(), gameInfo->black());
 340     m_main->setTabText(m_main->currentIndex(),
 341       QString("FICS Game - %1 vs %2").arg(style12.whitePlayer)
 342                                      .arg(style12.blackPlayer));
 343   }
 344 }
 345
 346 void MainWindow::setupExaminedGame(const GameInfo* /*gameInfo*/, const PositionInfo& style12) {
 347   shared_ptr<EditGameController> controller(new EditGameController(
 348                                       table(), Variant::variant("chess")));
 349   if (controller->setExaminationMode(style12.gameNumber, m_connection)) {
 350     table()->setPlayers(Player(style12.whitePlayer, -1),
 351                       Player(style12.blackPlayer, -1));
 352     ui().setController(controller);
 353     m_main->setTabText(m_main->currentIndex(),
 354       QString("Examining - %1 vs %2").arg(style12.whitePlayer)
 355                                      .arg(style12.blackPlayer));
 356   }
 357
 358 }
 359
 360 void MainWindow::setupObservedGame(const GameInfo* g, const PositionInfo& style12) {
 361   std::auto_ptr<ChessTable> board(new ChessTable);
 362
 363   shared_ptr<EditGameController> controller(new EditGameController(
 364                                       board.get(), Variant::variant(g->variant())));
 365   if (controller->setObserveMode(style12.gameNumber, m_connection)) {
 366     board->setPlayers(Player(style12.whitePlayer, -1),
 367                       Player(style12.blackPlayer, -1));
 368 //    ui().setController(controller);
 369     //std::cout << "adding tab" << std::endl;
 370     createTab(board.get(), controller,
 371       QString("Observing - %1 vs %2").arg(style12.whitePlayer)
 372                                      .arg(style12.blackPlayer));
 373     board.release();
 374   }
 375 }
 376
 377 void MainWindow::setupPGN(const QString& s) {
 378   PGN pgn(s);
 379
 380   std::map<QString, QString>::const_iterator var = pgn.m_tags.find("Variant");
 381   VariantInfo *variant;
 382
 383   if(var == pgn.m_tags.end())
 384     variant = Variant::variant("Chess");
 385   else if(!(variant = Variant::variant(var->second))) {
 386     std::cout << " --> MainWindow::setupPGN: Error, no such variant " << var->second << std::endl;
 387     return;
 388   }
 389
 390   shared_ptr<EditGameController> controller(new EditGameController(
 391                                               table(), variant));
 392   ui().setController(controller);
 393   controller->loadPGN(pgn);
 394
 395 //   table()->setPlayers(gameInfo->white(), gameInfo->black());
 396 //   m_main->setTabText(m_main->currentIndex(),
 397 //     QString("FICS Game - %1 vs %2").arg(style12.whitePlayer)
 398 //                                     .arg(style12.blackPlayer));
 399 }
 400
 401 bool MainWindow::openFile(const QString& filename) {
 402   QFileInfo info(filename);
 403
 404   if(info.isDir()) {
 405      KMessageBox::sorry(this, i18n("You have specified a folder"), i18n("Error"));
 406      return false;
 407   }
 408
 409   if(!info.exists() || !info.isFile()) {
 410      KMessageBox::sorry(this, i18n("The specified file does not exist"), i18n("Error"));
 411      return false;
 412   }
 413
 414   QFile file(filename);
 415
 416   if(!file.open(QIODevice::ReadOnly)) {
 417      KMessageBox::sorry(this, i18n("You do not have read permission to this file."), i18n("Error"));
 418      return false;
 419   }
 420
 421   QTextStream stream(&file);
 422   QTextCodec *codec;
 423   codec = QTextCodec::codecForLocale();
 424   stream.setCodec(codec);
 425
 426   setupPGN(stream.readAll());
 427   //ui().pgnPaste(stream.readAll());
 428   return true;
 429 }
 430
 431 void MainWindow::loadGame() {
 432   KUrl url = KFileDialog::getOpenUrl(KUrl(), "*.pgn", this, i18n("Open PGN file"));
 433
 434   if(url.isEmpty())
 435     return;
 436
 437   QString tmp_file;
 438   if (KIO::NetAccess::download(url, tmp_file, this)) {
 439     openFile(tmp_file);
 440     KIO::NetAccess::removeTempFile(tmp_file);
 441   }
 442   else
 443     KMessageBox::error(this, KIO::NetAccess::lastErrorString());
 444 }
 445
 446 void MainWindow::createConnection(const QString& username, const QString& password,
 447                                   const QString& host, quint16 port,
 448                                   const QString& timeseal, const QString& timeseal_cmd) {
 449   m_connection = shared_ptr<ICSConnection>(new ICSConnection);
 450
 451   connect(m_connection.get(), SIGNAL(established()), this, SLOT(onEstablishConnection()));
 452   connect(m_connection.get(), SIGNAL(hostLookup()), this, SLOT(onHostLookup()));
 453   connect(m_connection.get(), SIGNAL(hostFound()), this, SLOT(onHostFound()));
 454
 455   connect(m_connection.get(), SIGNAL(receivedLine(QString, int)), console, SLOT(displayText(QString, int)));
 456   connect(m_connection.get(), SIGNAL(receivedText(QString, int)), console, SLOT(displayText(QString, int)));
 457
 458   connect(console, SIGNAL(receivedInput(const QString&)), m_connection.get(), SLOT(sendText(const QString&)));
 459   connect(console, SIGNAL(notify()), this, SLOT(flash()));
 460
 461   connect(m_connection.get(), SIGNAL(loginPrompt()), this, SLOT(sendLogin()));
 462   connect(m_connection.get(), SIGNAL(registeredNickname()), this, SLOT(sendBlankPassword()));
 463   connect(m_connection.get(), SIGNAL(prompt()), this, SLOT(prompt()));
 464
 465
 466   connect(m_connection.get(), SIGNAL(creatingExaminedGame(const GameInfo*, const PositionInfo&)),
 467           this, SLOT(setupExaminedGame(const GameInfo*, const PositionInfo&)));
 468   connect(m_connection.get(), SIGNAL(endingExaminedGame(int)), this, SLOT(cleanupGame()));
 469
 470   connect(m_connection.get(), SIGNAL(creatingObservedGame(const GameInfo*, const PositionInfo&)),
 471           this, SLOT(setupObservedGame(const GameInfo*, const PositionInfo&)));
 472   connect(m_connection.get(), SIGNAL(endingObservedGame(int)), this, SLOT(cleanupGame()));
 473
 474
 475   connect(m_connection.get(), SIGNAL(creatingGame(const GameInfo*, const PositionInfo&)),
 476           this, SLOT(setupGame(const GameInfo*, const PositionInfo&)));
 477   connect(m_connection.get(), SIGNAL(endingGame(const QString&, const QString&)),
 478           this, SLOT(cleanupGame(const QString&, const QString&)));
 479   connect(m_connection.get(), SIGNAL(notification()), this, SLOT(flash()));
 480
 481   m_connection->establish(host.toAscii().constData(), port, timeseal, timeseal_cmd);
 482   console->show();
 483
 484   // send username / password combination
 485   if (!username.isEmpty()) {
 486     m_connection->sendText(username);
 487     m_connection->sendText(password);
 488   }
 489
 490   quickConnectDialog.reset();
 491 }
 492
 493 void MainWindow::icsConnect() {
 494   quickConnectDialog = shared_ptr<QConnect>(new QConnect(this));
 495   connect(quickConnectDialog.get(),
 496           SIGNAL(acceptConnection(const QString&,
 497                                   const QString&,
 498                                   const QString&,
 499                                   quint16,
 500                                   const QString&,
 501                                   const QString&)),
 502           this,
 503           SLOT(createConnection(const QString&,
 504                                 const QString&,
 505                                 const QString&,
 506                                 quint16,
 507                                 const QString&,
 508                                 const QString&)));
 509   quickConnectDialog->show();
 510 }
 511
 512 void MainWindow::destroyConnection() {
 513   m_connection.reset();
 514 }
 515
 516 void MainWindow::icsDisconnect() {
 517   destroyConnection();
 518   console->hide();
 519   console->clear();
 520 }
 521
 522 void MainWindow::testConnect() {
 523   Settings s_ics = settings().group("ics");
 524   if (s_ics["username"]) {
 525     QString username = s_ics["username"].value<QString>();
 526     QString password = (s_ics["password"] | "");
 527     QString host = (s_ics["icsHost"] | "freechess.org");
 528     quint16 port = (s_ics["icsPort"] | 5000);
 529     createConnection(username, password, host, port, QString(), QString() );
 530   }
 531   else icsConnect();
 532 }
 533
 534
 535 void MainWindow::onEstablishConnection() {
 536 //  std::cout << "connection established" << std::endl;
 537 }
 538
 539 void MainWindow::onConnectionError(int ) {
 540 //  std::cout << "connection error (" << code << ")" << std::endl;
 541 }
 542
 543 void MainWindow::onHostLookup() {
 544 //  std::cout << "hostLookup..." << std::flush;
 545 }
 546
 547 void MainWindow::onHostFound() {
 548 //  std::cout << "found" << std::endl;
 549 }
 550
 551
 552 void MainWindow::sendLogin() {
 553 //  std::cout << "sending username" << std::endl;
 554 //  connection->sendText(connection->username());
 555 }
 556
 557 void MainWindow::sendBlankPassword() {
 558   std::cout << "sending blank password" << std::endl;
 559   m_connection->sendText("");
 560 }
 561
 562 void MainWindow::prompt() {
 563   if (!m_connection->initialized()) {
 564     m_connection->startup();
 565     m_connection->setInitialized();
 566   }
 567 }
 568
 569 void MainWindow::newGame() {
 570   AbstractPosition::Ptr pos = ui().position();
 571   scoped_ptr<NewGame> dialog(new NewGame(this, pos));
 572   if (dialog->exec() == QDialog::Accepted) {
 573     if(dialog->isCustom()) {
 574       VariantInfo *vi = Variant::variant(dialog->variant());
 575       std::cout << "vi[" << dialog->variant() << "] = " << vi << std::endl;
 576       pos = vi->createCustomPosition(dialog->customOptions());
 577       pos->setup();
 578     }
 579     else if (!dialog->playFromCurrent())
 580       pos = AbstractPosition::Ptr();
 581     if (!newGame(dialog->variant(), pos))
 582       QMessageBox::information(this, tr("Error"), tr("Variant not implemented, yet"));
 583   }
 584 }
 585
 586 void MainWindow::quit() {
 587   delete this;
 588 }
 589
 590 void MainWindow::flipView() {
 591   table()->flip();
 592 }
 593
 594 void MainWindow::toggleConsole() {
 595   if (console_dock->isVisible())
 596     console_dock->hide();
 597   else {
 598     console_dock->show();
 599     console_dock->setFocus(Qt::MouseFocusReason
 600           /*Qt::ActiveWindowFocusReason*/ /*Qt::OtherFocusReason*/);
 601   }
 602 }
 603
 604 void MainWindow::toggleMoveList() {
 605   if (movelist_dock->isVisible())
 606     movelist_dock->hide();
 607   else {
 608     movelist_dock->show();
 609     movelist_dock->setFocus(Qt::OtherFocusReason);
 610   }
 611 }
 612
 613
 614 void MainWindow::displayMessage(const QString& msg) {
 615   Q_UNUSED(msg); // TODO
 616 //   statusBar()->message(msg, 2000);
 617 }
 618
 619 void MainWindow::displayErrorMessage(ErrorCode code) {
 620   switch(code) {
 621   case InvalidMove:
 622     displayMessage(tr("Illegal move"));
 623     break;
 624   }
 625 }
 626
 627 void MainWindow::flash() {
 628   if( !isAncestorOf(QApplication::focusWidget()) )
 629     Flash::flash(this);
 630 }
 631
 632 #if 0
 633 void MainWindow::prefHighlight() {
 634   PrefHighlight dialog;
 635   int result = dialog.exec();
 636   if (result == QDialog::Accepted) {
 637     dialog.apply();
 638   }
 639 }
 640 #endif
 641
 642 void MainWindow::preferences() {
 643   Preferences dialog(ui().currentVariant());
 644   int result = dialog.exec();
 645   if (result == QDialog::Accepted)
 646     dialog.apply();
 647 }
 648
 649
 650