projects/gui/src/mainwindow.cpp

   1 /*
   2     This file is part of Cute Chess.
   3
   4     Cute Chess is free software: you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation, either version 3 of the License, or
   7     (at your option) any later version.
   8
   9     Cute Chess is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with Cute Chess.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #include <QtGui>
  19
  20 #include <chessgame.h>
  21 #include <chessplayer.h>
  22 #include <timecontrol.h>
  23 #include <engineconfiguration.h>
  24 #include <enginefactory.h>
  25 #include <engineprocess.h>
  26 #include <humanplayer.h>
  27
  28 #include "mainwindow.h"
  29 #include "chessboardview.h"
  30 #include "chessboardmodel.h"
  31 #include "newgamedlg.h"
  32 #include "chessclock.h"
  33 #include "engineconfigurationmodel.h"
  34 #include "enginemanagementdlg.h"
  35
  36 MainWindow::MainWindow()
  37 {
  38         setWindowTitle("Cute Chess");
  39
  40         QHBoxLayout* clockLayout = new QHBoxLayout();
  41         for (int i = 0; i < 2; i++)
  42         {
  43                 m_chessClock[i] = new ChessClock();
  44                 clockLayout->addWidget(m_chessClock[i]);
  45         }
  46
  47         m_boardModel = new ChessboardModel(this);
  48         m_chessboardView = new ChessboardView(this);
  49         m_chessboardView->setModel(m_boardModel);
  50         connect(m_boardModel, SIGNAL(moveMade(const QModelIndex&, const QModelIndex&)),
  51                 m_chessboardView, SLOT(onMoveMade(const QModelIndex&, const QModelIndex&)));
  52
  53         QVBoxLayout* mainLayout = new QVBoxLayout();
  54         mainLayout->addLayout(clockLayout);
  55         mainLayout->addWidget(m_chessboardView);
  56
  57         // The content margins look stupid when used with dock widgets. Drop the
  58         // margins except from the top so that the chess clocks have spacing
  59         mainLayout->setContentsMargins(0,
  60                 style()->pixelMetric(QStyle::PM_LayoutTopMargin), 0, 0);
  61
  62         QWidget* mainWidget = new QWidget(this);
  63         mainWidget->setLayout(mainLayout);
  64         setCentralWidget(mainWidget);
  65
  66         setStatusBar(new QStatusBar());
  67
  68         m_engineConfigurations = new EngineConfigurationModel(this);
  69
  70         createActions();
  71         createMenus();
  72         createToolBars();
  73         createDockWindows();
  74
  75         readSettings();
  76 }
  77
  78 void MainWindow::createActions()
  79 {
  80         m_newGameAct = new QAction(tr("&New game..."), this);
  81         m_newGameAct->setShortcut(QKeySequence("Ctrl+N"));
  82
  83         m_printGameAct = new QAction(tr("&Print..."), this);
  84
  85         m_quitGameAct = new QAction(tr("&Quit"), this);
  86         m_quitGameAct->setShortcut(QKeySequence(tr("Ctrl+Q")));
  87
  88         m_manageEnginesAct = new QAction(tr("Manage..."), this);
  89
  90         m_openConfigurationFileAct = new QAction("Open configuration file", this);
  91
  92         connect(m_newGameAct, SIGNAL(triggered(bool)), this, SLOT(newGame()));
  93         connect(m_printGameAct, SIGNAL(triggered(bool)), this, SLOT(printGame()));
  94         connect(m_quitGameAct, SIGNAL(triggered(bool)), this, SLOT(close()));
  95
  96         connect (m_manageEnginesAct, SIGNAL(triggered(bool)), this,
  97                 SLOT(manageEngines()));
  98
  99         connect(m_openConfigurationFileAct, SIGNAL(triggered(bool)), this,
 100                 SLOT(openConfigurationFile()));
 101 }
 102
 103 void MainWindow::createMenus()
 104 {
 105         m_gameMenu = menuBar()->addMenu(tr("&Game"));
 106         m_gameMenu->addAction(m_newGameAct);
 107         m_gameMenu->addSeparator();
 108         m_gameMenu->addAction(m_printGameAct);
 109         m_gameMenu->addSeparator();
 110         m_gameMenu->addAction(m_quitGameAct);
 111
 112         m_viewMenu = menuBar()->addMenu(tr("&View"));
 113
 114         m_enginesMenu = menuBar()->addMenu(tr("En&gines"));
 115         m_enginesMenu->addAction(m_manageEnginesAct);
 116
 117         m_helpMenu = menuBar()->addMenu(tr("&Help"));
 118
 119         m_debugMenu = menuBar()->addMenu("&Debug");
 120         m_debugMenu->addAction(m_openConfigurationFileAct);
 121 }
 122
 123 void MainWindow::createToolBars()
 124 {
 125         // Create tool bars here, use actions from createActions()
 126         // See: createActions(), QToolBar documentation
 127 }
 128
 129 void MainWindow::createDockWindows()
 130 {
 131         // Log
 132         QDockWidget* logDock = new QDockWidget(tr("Log"), this);
 133         QTextEdit* logTextEdit = new QTextEdit(logDock);
 134         logTextEdit->setReadOnly(true);
 135         logDock->setWidget(logTextEdit);
 136
 137         addDockWidget(Qt::BottomDockWidgetArea, logDock);
 138
 139         // Engine debug
 140         QDockWidget* engineDebugDock = new QDockWidget(tr("Engine Debug"), this);
 141         m_engineDebugTextEdit = new QTextEdit(engineDebugDock);
 142         m_engineDebugTextEdit->setReadOnly(true);
 143         engineDebugDock->setWidget(m_engineDebugTextEdit);
 144
 145         addDockWidget(Qt::BottomDockWidgetArea, engineDebugDock);
 146 }
 147
 148 void MainWindow::readSettings()
 149 {
 150         QSettings settings;
 151
 152         int size = settings.beginReadArray("engines");
 153         for (int i = 0; i < size; i++)
 154         {
 155                 settings.setArrayIndex(i);
 156                 EngineConfiguration config;
 157                 config.setName(settings.value("name").toString());
 158                 config.setCommand(settings.value("command").toString());
 159                 config.setWorkingDirectory(
 160                         settings.value("working_directory").toString());
 161                 config.setProtocol(ChessEngine::Protocol(
 162                         settings.value("protocol").toInt()));
 163
 164                 m_engineConfigurations->addConfiguration(config);
 165         }
 166         settings.endArray();
 167 }
 168
 169 void MainWindow::newGame()
 170 {
 171         NewGameDialog dlg(m_engineConfigurations, this);
 172         if (dlg.exec() != QDialog::Accepted)
 173                 return;
 174
 175         ChessPlayer* player[2] = { 0, 0 };
 176         ChessGame* chessgame = new ChessGame(Chess::Variant::Standard, this);
 177
 178         TimeControl tc;
 179         tc.setTimePerTc(180000);
 180         tc.setMovesPerTc(40);
 181
 182         for (int i = 0; i < 2; i++)
 183         {
 184                 Chess::Side side = (Chess::Side)i;
 185                 if (dlg.playerType(side) == NewGameDialog::CPU)
 186                 {
 187                         EngineConfiguration config = m_engineConfigurations->configuration(dlg.selectedEngine(side));
 188
 189                         QProcess* process = new QProcess(this);
 190
 191                         if (config.workingDirectory().isEmpty())
 192                                 process->setWorkingDirectory(QDir::tempPath());
 193                         else
 194                                 process->setWorkingDirectory(config.workingDirectory());
 195
 196                         process->start(config.command());
 197                         if (!process->waitForStarted())
 198                         {
 199                                 qDebug() << "Cannot start the engine process:" << config.command();
 200                                 return;
 201                         }
 202                         ChessEngine* engine = EngineFactory::createEngine(config.protocol(), process, this);
 203                         engine->start();
 204                         engine->setName(config.name());
 205                         player[i] = engine;
 206                 }
 207                 else
 208                 {
 209                         player[i] = new HumanPlayer(this);
 210                         connect(m_chessboardView, SIGNAL(humanMove(const BookMove&)),
 211                                 player[i], SLOT(onHumanMove(const BookMove&)));
 212                 }
 213
 214                 player[i]->setTimeControl(tc);
 215                 chessgame->setPlayer(side, player[i]);
 216
 217                 connect(player[i], SIGNAL(startedThinking(int)),
 218                         m_chessClock[i], SLOT(start(int)));
 219                 connect(player[i], SIGNAL(moveMade(const Chess::Move&)),
 220                         m_chessClock[i], SLOT(stop()));
 221                 connect(player[i], SIGNAL(humanTurn(bool)),
 222                         m_chessboardView, SLOT(setEnabled(bool)));
 223                 connect(chessgame, SIGNAL(gameEnded()),
 224                         m_chessClock[i], SLOT(stop()));
 225                 connect(player[i], SIGNAL(debugMessage(const QString&)),
 226                         m_engineDebugTextEdit, SLOT(append(const QString&)));
 227         }
 228
 229         m_boardModel->setBoard(chessgame->board());
 230         chessgame->start();
 231 }
 232
 233 void MainWindow::printGame()
 234 {
 235         QPrinter printer(QPrinter::HighResolution);
 236
 237         QPrintDialog* printDialog = new QPrintDialog(&printer, this);
 238         printDialog->setWindowTitle(tr("Print game"));
 239
 240         if (printDialog->exec() != QDialog::Accepted)
 241                 return;
 242
 243         QPainter painter;
 244         painter.begin(&printer);
 245
 246         m_chessboardView->render(&painter);
 247
 248         painter.end();
 249 }
 250
 251 void MainWindow::manageEngines()
 252 {
 253         QList<EngineConfiguration> oldConfigurations =
 254                 m_engineConfigurations->configurations();
 255
 256         EngineManagementDialog dlg(m_engineConfigurations, this);
 257
 258         if (dlg.exec() == QDialog::Accepted)
 259         {
 260                 QSettings settings;
 261
 262                 const QList<EngineConfiguration> engines = m_engineConfigurations->configurations();
 263
 264                 settings.beginWriteArray("engines");
 265                 for (int i = 0; i < engines.size(); i++)
 266                 {
 267                         settings.setArrayIndex(i);
 268                         settings.setValue("name", engines.at(i).name());
 269                         settings.setValue("command", engines.at(i).command());
 270                         settings.setValue("working_directory", engines.at(i).workingDirectory());
 271                         settings.setValue("protocol", engines.at(i).protocol());
 272                 }
 273                 settings.endArray();
 274
 275                 // Make sure that the settings are flushed to disk now
 276                 settings.sync();
 277         }
 278         else
 279         {
 280                 // Release the engine configurations model and use
 281                 // the old configurations as base for the new model
 282                 delete m_engineConfigurations;
 283                 m_engineConfigurations = new EngineConfigurationModel(oldConfigurations);
 284         }
 285 }
 286
 287 void MainWindow::openConfigurationFile()
 288 {
 289         QSettings settings;
 290
 291         if (QFile::exists(settings.fileName()))
 292                 QDesktopServices::openUrl(QUrl("file://" + settings.fileName()));
 293         else
 294                 qDebug() << "Cannot open configuration file:" << settings.fileName();
 295 }
 296