src/mainwindow.cpp

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