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_wallpaper(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 clocks
  44   for(int i=0;i<2;i++) {
  45     m_clocks[i] = new Clock(i, m_board, this);
  46     m_clocks[i]->show();
  47   }
  48   m_clocks[0]->activate(0);
  49
  50   // create info display
  51   m_info = new InfoDisplay(this);
  52 //  m_info->show();
  53
  54   // create pools
  55   for(int i=0;i<2;i++) {
  56     m_pools[i] = new PiecePool(i, m_board, this);
  57     m_pools[i]->show();
  58   }
  59
  60   m_board->raise();
  61   settingsChanged();
  62 }
  63
  64 ChessTable::~ChessTable() {
  65   for(int i=0;i<2;i++)
  66   delete m_clocks[i];
  67   delete m_movelist;
  68   delete m_board;
  69   for(int i=0;i<2;i++)
  70     delete m_pools[i];
  71   delete m_info;
  72 }
  73
  74 void ChessTable::settingsChanged() {
  75   m_board->settingsChanged();
  76   for(int i=0;i<2;i++)
  77     m_clocks[i]->settingsChanged();
  78   m_info->settingsChanged();
  79   for(int i=0;i<2;i++)
  80     m_pools[i]->settingsChanged();
  81
  82   if(m_wallpaper)
  83     delete m_wallpaper;
  84   bool was0 = m_board->squareSize() == 0;
  85   if(was0) m_board->tagsLoader()->setSize(1);
  86   QPixmap bg = m_board->tagsLoader()->operator()("wallpaper");
  87   if(was0) m_board->tagsLoader()->setSize(0);
  88   if(!bg.isNull()) {
  89     std::cout << "Size is " << bg.size().width() << " "<< bg.size().height()  << std::endl;
  90     m_wallpaper = new KGameCanvasTiledPixmap(bg, QSize(), QPoint(), false, this);
  91     m_wallpaper->lower();
  92     m_wallpaper->show();
  93   }
  94   else
  95     m_wallpaper = 0;
  96
  97   /* redo the layout, forcing reload */
  98   if(isVisible())
  99     layout(true);
 100   else
 101     m_need_reload = true;
 102 }
 103
 104 ClickableCanvas* ChessTable::eventItemAt(QPoint pos) {
 105   if (m_board->boardRect().contains(pos))
 106     return m_board;
 107
 108   for (int i=0; i<2; i++)
 109   if (m_pools[i]->boardRect().contains(pos))
 110     return m_pools[i];
 111
 112   for (int i=0; i<2; i++)
 113   if (m_clocks[i]->rect().contains(pos))
 114     return m_clocks[i];
 115
 116   return NULL;
 117 }
 118
 119 void ChessTable::setEntity(const boost::shared_ptr<UserEntity>& entity) {
 120   m_board->setEntity(entity);
 121 }
 122
 123 void ChessTable::layout(bool force_reload) {
 124   force_reload |= m_need_reload;
 125   m_need_reload = false;
 126
 127   if (m_wallpaper) {
 128     m_wallpaper->setSize(size());
 129     QSize delta = (m_wallpaper->pixmap().size()-size())/2;
 130     m_wallpaper->setOrigin(QPoint(delta.width(), delta.height()));
 131   }
 132
 133   Point gs = m_board->gridSize();
 134   int sq_size = std::max(0, std::min(int(width()/(gs.x+2.6+(2.0/3.0)*3)),
 135                         int(gs.y == 0 ? 100000 : height()/(gs.y+4.0/3.0))) );
 136   int b = sq_size*2/3;
 137   m_board->moveTo(b,b);
 138   m_board->onResize( sq_size, force_reload);
 139
 140   m_clocks[0]->resize();
 141   m_clocks[1]->resize();
 142   m_clocks[0]->moveTo(sq_size*gs.x+2*b+b/2, b/2);
 143   m_clocks[1]->moveTo(sq_size*gs.x+2*b+b/2, sq_size*gs.y+b+b/2-m_clocks[1]->height());
 144
 145   int x = !!m_board->flipped();
 146   m_pools[x]->m_flipped = false;
 147   m_pools[x]->setGridWidth(3);
 148   m_pools[x]->moveTo(sq_size*gs.x+2*b+b/2, b+m_clocks[0]->height());
 149   m_pools[x]->onResize(static_cast<int>(sq_size*2.2/3), force_reload);
 150
 151   x = !x;
 152   m_pools[x]->m_flipped = true;
 153   m_pools[x]->setGridWidth(3);
 154   m_pools[x]->moveTo(sq_size*gs.x+2*b+b/2, sq_size*gs.y+b-m_clocks[1]->height());
 155   m_pools[x]->onResize(static_cast<int>(sq_size*2.2/3), force_reload);
 156
 157   m_info->moveTo(sq_size*gs.x+4*b, 80+sq_size*gs.y/2+b+b/2);
 158 }
 159
 160 void ChessTable::resizeEvent(QResizeEvent* /*e*/) {
 161   layout();
 162 }
 163
 164 void ChessTable::mouseReleaseEvent(QMouseEvent* e) {
 165
 166   if(m_mousegrab) {
 167     m_mousegrab->onMouseRelease(e->pos() - m_mousegrab->pos(), e->button() );
 168     if(!e->buttons()) {
 169       m_mousegrab = NULL;
 170
 171       ClickableCanvas* cb = eventItemAt(e->pos());
 172       if(cb != m_current) {
 173         if(m_current)
 174           m_current->onMouseLeave();
 175         if(cb) {
 176           cb->onMouseEnter();
 177           cb->onMouseMove(e->pos() - cb->pos(), 0);
 178         }
 179         m_current = cb;
 180       }
 181     }
 182     return;
 183   }
 184 }
 185
 186 void ChessTable::mousePressEvent(QMouseEvent* e) {
 187   if(m_mousegrab) {
 188     m_mousegrab->onMousePress(e->pos() - m_mousegrab->pos(), e->button() );
 189     return;
 190   }
 191
 192   ClickableCanvas* cb = eventItemAt(e->pos());
 193   if(cb != m_current) {
 194     if(m_current)
 195       m_current->onMouseLeave();
 196     if(cb)
 197       cb->onMouseEnter();
 198     m_current = cb;
 199   }
 200   if(cb) {
 201     cb->onMousePress(e->pos() - cb->pos(), e->button() );
 202     m_mousegrab = cb;
 203   }
 204 }
 205
 206 void ChessTable::mouseMoveEvent(QMouseEvent* e) {
 207   if(m_mousegrab) {
 208     m_mousegrab->onMouseMove(e->pos() - m_mousegrab->pos(), e->button() );
 209     return;
 210   }
 211
 212   ClickableCanvas* cb = eventItemAt(e->pos());
 213   if(cb != m_current) {
 214     if(m_current)
 215       m_current->onMouseLeave();
 216     if(cb)
 217       cb->onMouseEnter();
 218     m_current = cb;
 219   }
 220   if(cb)
 221     cb->onMouseMove(e->pos() - cb->pos(), e->button() );
 222 }
 223
 224 void ChessTable::enterEvent(QEvent*) { }
 225
 226 void ChessTable::leaveEvent(QEvent*) {
 227   if(m_current)
 228     m_current->onMouseLeave();
 229   m_current = NULL;
 230 }
 231
 232 void ChessTable::flip() {
 233   m_board->flip();
 234
 235   for(int i=0;i<2;i++)
 236     m_pools[i]->flipAndMoveBy( QPoint(0, m_board->squareSize()*8+m_board->squareSize()*2/3) );
 237 }
 238
 239 void ChessTable::flip(bool flipped) {
 240   if(m_board->flipped() != flipped)
 241     flip();
 242 }
 243
 244 void ChessTable::changeClock(int color) {
 245   std::cout << "change " << color << std::endl;
 246   if(m_clocks[0]->running() || m_clocks[1]->running())
 247   for(int i=0;i<2;i++) {
 248     if ( (i == color) != m_clocks[i]->running() )
 249     if( i==color )
 250       m_clocks[i]->start();
 251     else
 252       m_clocks[i]->stop();
 253   }
 254 }
 255
 256 void ChessTable::updateTurn(int color) {
 257   std::cout << "updatet" << std::endl;
 258   for(int i=0;i<2;i++)
 259     m_clocks[i]->activate(color == i);
 260 }
 261
 262 void ChessTable::stopClocks() {
 263   for(int i=0;i<2;i++)
 264     m_clocks[i]->stop();
 265 }
 266
 267 void ChessTable::updateTime(int white, int black) {
 268   std::cout << "update" << std::endl;
 269   m_clocks[0]->setTime(white);
 270   m_clocks[1]->setTime(black);
 271 }
 272
 273 void ChessTable::resetClock() {
 274   std::cout << "reset" << std::endl;
 275   stopClocks();
 276   updateTime(0, 0);
 277   for(int i=0;i<2;i++)
 278     m_clocks[i]->setPlayer(Player());
 279 }
 280
 281 void ChessTable::setPlayers(const Player& white, const Player& black) {
 282   std::cout << "set players " << std::endl;
 283   m_clocks[0]->setPlayer(white);
 284   m_clocks[1]->setPlayer(black);
 285 }
 286
 287 void ChessTable::run() {
 288   std::cout << "run" << std::endl;
 289   for(int i=0;i<2;i++)
 290   if(m_clocks[i]->active() && !m_clocks[i]->running())
 291     m_clocks[i]->start();
 292 }
 293
 294 void ChessTable::displayMessage(const QString& msg) {
 295   std::cout << msg << std::endl;
 296   emit message(msg);
 297 }
 298
 299