src/chesstable.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 <iostream>
  12 #include <QLayout>
  13 #include <QSplitter>
  14 #include <QMouseEvent>
  15 #include "chesstable.h"
  16 #include "game.h"
  17 #include "gameinfo.h"
  18 #include "connection.h"
  19 #include "piecepool.h"
  20 #include "clock.h"
  21 #include "global.h"
  22 #include "movelist_table.h"
  23 #include "infodisplay.h"
  24
  25 using namespace boost;
  26
  27 ChessTable::ChessTable(QWidget* parent)
  28 : KGameCanvasWidget(parent)
  29 , m_background(NULL)
  30 , m_current(NULL)
  31 , m_mousegrab(NULL)
  32 , m_need_reload(false) {
  33
  34   setMouseTracking(true);
  35
  36   // create m_board
  37   m_board = new Board(this);
  38   m_board->show();
  39
  40   // create move list
  41   m_movelist = new MoveList::Table;
  42
  43   // create clock
  44   m_clock = new Clock(this);
  45   m_clock->show();
  46   m_clock->activate(0);
  47
  48
  49   // create info display
  50   m_info = new InfoDisplay(this);
  51 //  m_info->show();
  52
  53   // create pools
  54   for(int i=0;i<2;i++) {
  55     m_pools[i] = new PiecePool(i, m_board, this);
  56     m_pools[i]->show();
  57   }
  58
  59   m_board->raise();
  60   settingsChanged();
  61 }
  62
  63 ChessTable::~ChessTable() {
  64   delete m_clock;
  65   delete m_movelist;
  66   delete m_board;
  67   for(int i=0;i<2;i++)
  68     delete m_pools[i];
  69   delete m_info;
  70 }
  71
  72 void ChessTable::settingsChanged() {
  73   if(m_background)
  74     delete m_background;
  75   if (settings["background"]) {
  76     m_background = new KGameCanvasTiledPixmap(QPixmap(settings["background"].value<QString>()),
  77                                        QSize(), QPoint(), false, this);
  78     m_background->show();
  79   }
  80   else
  81     m_background = 0;
  82
  83   m_board->settingsChanged();
  84   m_clock->settingsChanged();
  85   m_info->settingsChanged();
  86   for(int i=0;i<2;i++)
  87     m_pools[i]->settingsChanged();
  88
  89   /* redo the layout, forcing reload */
  90   if(isVisible())
  91     layout(true);
  92   else
  93     m_need_reload = true;
  94 }
  95
  96 ClickableCanvas* ChessTable::eventItemAt(QPoint pos) {
  97   if (m_board->boardRect().contains(pos))
  98     return m_board;
  99
 100   for (int i=0; i<2; i++)
 101   if (m_pools[i]->boardRect().contains(pos))
 102     return m_pools[i];
 103
 104   if (m_clock->rect().contains(pos))
 105     return m_clock;
 106
 107   return NULL;
 108 }
 109
 110 void ChessTable::setEntity(const boost::shared_ptr<UserEntity>& entity) {
 111   m_board->setEntity(entity);
 112 }
 113
 114 void ChessTable::layout(bool force_reload) {
 115   force_reload |= m_need_reload;
 116   m_need_reload = false;
 117
 118   if (m_background)
 119     m_background->setSize(size());
 120
 121   int b = m_board->marginSize();
 122   Point gs = m_board->gridSize();
 123   int sq_size = std::max(0, std::min(int((width()-3*b)/(gs.x+2.2)),
 124                         (gs.y == 0 ? 100000 : (height()-80-3*b)/gs.y)) );
 125   m_board->moveTo(b,80+2*b);
 126   m_board->onResize( sq_size, force_reload);
 127
 128   m_clock->moveTo(0, b);
 129   m_clock->resize(QSize(m_board->rect().width(), 80) /*, force_reload*/);
 130
 131   int x = !!m_board->flipped();
 132   m_pools[x]->m_flipped = false;
 133   m_pools[x]->setGridWidth(3);
 134   m_pools[x]->moveTo(sq_size*gs.x+2*b+b/2, 80+b+b/2);
 135   m_pools[x]->onResize(static_cast<int>(sq_size*2.2/3), force_reload);
 136
 137   x = !x;
 138   m_pools[x]->m_flipped = true;
 139   m_pools[x]->setGridWidth(3);
 140   m_pools[x]->moveTo(sq_size*gs.x+2*b+b/2, 80+sq_size*gs.y+b*2+b/2);
 141   m_pools[x]->onResize(static_cast<int>(sq_size*2.2/3), force_reload);
 142
 143   m_info->moveTo(sq_size*gs.x+4*b, 80+sq_size*gs.y/2+b+b/2);
 144 }
 145
 146 void ChessTable::resizeEvent(QResizeEvent* /*e*/) {
 147   layout();
 148 }
 149
 150 void ChessTable::mouseReleaseEvent(QMouseEvent* e) {
 151
 152   if(m_mousegrab) {
 153     m_mousegrab->onMouseRelease(e->pos() - m_mousegrab->pos(), e->button() );
 154     if(!e->buttons()) {
 155       m_mousegrab = NULL;
 156
 157       ClickableCanvas* cb = eventItemAt(e->pos());
 158       if(cb != m_current) {
 159         if(m_current)
 160           m_current->onMouseLeave();
 161         if(cb) {
 162           cb->onMouseEnter();
 163           cb->onMouseMove(e->pos() - cb->pos(), 0);
 164         }
 165         m_current = cb;
 166       }
 167     }
 168     return;
 169   }
 170 }
 171
 172 void ChessTable::mousePressEvent(QMouseEvent* e) {
 173   if(m_mousegrab) {
 174     m_mousegrab->onMousePress(e->pos() - m_mousegrab->pos(), e->button() );
 175     return;
 176   }
 177
 178   ClickableCanvas* cb = eventItemAt(e->pos());
 179   if(cb != m_current) {
 180     if(m_current)
 181       m_current->onMouseLeave();
 182     if(cb)
 183       cb->onMouseEnter();
 184     m_current = cb;
 185   }
 186   if(cb) {
 187     cb->onMousePress(e->pos() - cb->pos(), e->button() );
 188     m_mousegrab = cb;
 189   }
 190 }
 191
 192 void ChessTable::mouseMoveEvent(QMouseEvent* e) {
 193   if(m_mousegrab) {
 194     m_mousegrab->onMouseMove(e->pos() - m_mousegrab->pos(), e->button() );
 195     return;
 196   }
 197
 198   ClickableCanvas* cb = eventItemAt(e->pos());
 199   if(cb != m_current) {
 200     if(m_current)
 201       m_current->onMouseLeave();
 202     if(cb)
 203       cb->onMouseEnter();
 204     m_current = cb;
 205   }
 206   if(cb)
 207     cb->onMouseMove(e->pos() - cb->pos(), e->button() );
 208 }
 209
 210 void ChessTable::enterEvent(QEvent*) { }
 211
 212 void ChessTable::leaveEvent(QEvent*) {
 213   if(m_current)
 214     m_current->onMouseLeave();
 215   m_current = NULL;
 216 }
 217
 218 void ChessTable::flip() {
 219   m_board->flip();
 220
 221   for(int i=0;i<2;i++)
 222     m_pools[i]->flipAndMoveBy( QPoint(0, m_board->squareSize()*8+m_board->marginSize()) );
 223 }
 224
 225 void ChessTable::flip(bool flipped) {
 226   if(m_board->flipped() != flipped)
 227     flip();
 228 }
 229
 230 void ChessTable::changeClock(int color) {
 231   if (m_clock->running()) {
 232     m_clock->start(color);
 233   }
 234 }
 235
 236 void ChessTable::updateTurn(int color) {
 237   m_clock->activate(color);
 238 }
 239
 240 void ChessTable::stopClocks() {
 241   m_clock->stop();
 242 }
 243
 244 void ChessTable::updateTime(int white, int black) {
 245   m_clock->setTime(0, white);
 246   m_clock->setTime(1, black);
 247 }
 248
 249 void ChessTable::resetClock() {
 250   stopClocks();
 251   updateTime(0, 0);
 252   m_clock->setPlayers(Player(), Player());
 253 }
 254
 255 void ChessTable::setPlayers(const Player& white, const Player& black) {
 256   m_clock->setPlayers(white, black);
 257 }
 258
 259 void ChessTable::run() {
 260   if (!m_clock->running()) m_clock->start(0);
 261 }
 262
 263 void ChessTable::displayMessage(const QString& msg) {
 264   std::cout << msg << std::endl;
 265   emit message(msg);
 266 }
 267
 268