/* Implementation of class BoardWidget
 * 
 * This class handles rendering of a Board to a KDE/QT widget,
 * shows moves (with a timer) and manages input of moves
 *
 * Josef Weidendorfer, 9/97
 */

#include <tqbitmap.h>
#include <tqpainter.h>
#include <tqcursor.h>

#include <tdelocale.h>
#include <kdebug.h>

#ifdef HAVE_KIR
#include <kimgrender.h>
#endif

#include "Board.h"
#include "BoardWidget.h"

/* Cursors */
#include "bitmaps/Arrow1"
#include "bitmaps/Arrow1Mask"
#include "bitmaps/Arrow2"
#include "bitmaps/Arrow2Mask"
#include "bitmaps/Arrow3"
#include "bitmaps/Arrow3Mask"
#include "bitmaps/Arrow4"
#include "bitmaps/Arrow4Mask"
#include "bitmaps/Arrow5"
#include "bitmaps/Arrow5Mask"
#include "bitmaps/Arrow6"
#include "bitmaps/Arrow6Mask"

BoardWidget::BoardWidget(Board& b, TQWidget *parent, const char *name)
  : BallWidget(10,9,parent, name), board(b)
{
  pList =0;
  gettingMove = false;
  editMode = false;
  renderMode = false;

#ifdef HAVE_KIR
  m_backRenderer = KIRManager::attach( this, "Background" );
  connect( m_backRenderer, TQ_SIGNAL(rendered()),
	   this, TQ_SLOT(drawBoard()) );
#endif

  /* setup cursors */
	
#define createCursor(bitmap,name) \
  static TQBitmap bitmap(bitmap##_width, bitmap##_height,               \
                        (unsigned char *) bitmap##_bits, TRUE);        \
  static TQBitmap bitmap##Mask(bitmap##Mask_width, bitmap##Mask_height, \
			(unsigned char *) bitmap##Mask_bits, TRUE);    \
  name = new TQCursor(bitmap, bitmap##Mask, bitmap##_x_hot, bitmap##_y_hot);
	
  createCursor(Arrow1, arrow[1]);
  createCursor(Arrow2, arrow[2]);
  createCursor(Arrow3, arrow[3]);
  createCursor(Arrow4, arrow[4]);
  createCursor(Arrow5, arrow[5]);
  createCursor(Arrow6, arrow[6]);

  setCursor(crossCursor);

  //  boardColor   = new TQColor("lightblue");
  boardColor   = new TQColor(backgroundColor());
  redColor     = new TQColor("red2");
  yellowColor  = new TQColor("yellow2");
  redHColor    = new TQColor("orange");
  yellowHColor = new TQColor("green");

  initBalls();   
	
  updatePosition();
}

BoardWidget::~BoardWidget()
{
  for(int i=1; i<7; i++)
    if (arrow[i] != 0)
      delete arrow[i];

#ifdef HAVE_KIR  
  if (m_backRenderer != 0)
    delete m_backRenderer;
#endif
  delete boardColor;
  delete redColor;
  delete yellowColor;
  delete redHColor;
  delete yellowHColor;

}

void BoardWidget::configure()
{
#ifdef HAVE_KIR
  if (m_backRenderer != 0) {
    m_backRenderer->setup();
    m_backRenderer->manager()->saveModules();
  }
#endif
}
   

void BoardWidget::createPos(int pos, int i, int j, Ball* b)
{
  int x=(465*(2*(i)-(j))/9);
  int y=(500*19*(j)/100);
  createBallPosition(pos, x,y, b);
}
                                                 
void BoardWidget::initBalls()
{
  n2 = new Ball( *yellowColor );
  h2 = new Ball( *yellowHColor );
  d2 = new Ball( *yellowHColor, 3.14/2 );

  n1 = new Ball( *redColor );
  h1 = new Ball( *redHColor );
  d1 = new Ball( *redHColor, 3.14/2 );

  // e  = new Ball( white,0,0 );
  // e->setSpecials(.6,.85,.75);

  createBlending(1,10,h1,n1);
  createBlending(2,10,h1,d1);
  createBlending(3,10,h2,n2);
  createBlending(4,10,h2,d2);

  int i,j,pos;
  for(j=-4;j<5;j++)
    for(i= ((j>0)?j-4:-4) ; i< ((j<0)?5+j:5) ;i++) {
      pos=60+j*11+i;
      createPos(pos, i,j, 0);
    }

  pos = 0;
  /* the outer marks of color1 */
  for(i=0;i<3;i++) createPos(pos++, -6, i-4, 0 );
  for(i=0;i<3;i++) createPos(pos++, 2+i, i-4, 0 );

  /* the outer marks of color2 */
  for(i=0;i<3;i++) createPos(pos++, 6, 4-i, 0 );
  for(i=0;i<3;i++) createPos(pos++, -2-i, 4-i, 0 );
}  

void BoardWidget::resizeEvent(TQResizeEvent *e)
{
  drawBoard();
  BallWidget::resizeEvent(e); 
}

void BoardWidget::moveEvent(TQMoveEvent*)
{
  drawBoard();
}

void BoardWidget::paintEvent(TQPaintEvent *)
{
  if (renderMode) {
    pm = boardPM;
    BallWidget::paint(&pm);
  }
  else
    draw();
  bitBlt(this, 0, 0, &pm);
}


void drawShadedHexagon(TQPainter *p, int x, int y, int r, int lineWidth,
		       const TQColorGroup& g, bool sunken)
{
  int dx=r/2, dy=(r*87)/100;
  int y1=y-dy, y2=y+dy;
  int i;

  TQPen oldPen = p->pen();
    
  p->setPen(sunken ? g.midlight() : g.dark());

  for(i=0; i<lineWidth; i++) {
    p->drawLine( x-i+dx, y-dy, x+2*dx-i, y);
    p->drawLine( x+2*dx-i, y, x-i+dx, y+dy);
    p->drawLine( x-i+dx, y1+i, x+i-dx, y1+i);
  }

  p->setPen(sunken ? g.dark() : g.midlight());

  for(i=0; i<lineWidth; i++) {
    p->drawLine( x+i-dx, y-dy, x+i-2*dx, y);
    p->drawLine( x+i-2*dx, y, x+i-dx, y+dy);
    p->drawLine( x-i+dx, y2-i, x+i-dx, y2-i);
  }

  p->setPen(oldPen);
}


void drawColor(TQPainter *p, int x, int y, int r, TQColor* c)
{
  TQColor w("white");
  TQPalette pal(*c);

  TQPen oldPen = p->pen();
  TQBrush oldBrush = p->brush();

  p->setBrush(pal.active().dark());
  p->setPen(pal.active().dark());
  p->drawEllipse( x-r - 10,y-r +5, 2*r,2*r);

  p->setBrush(pal.active().mid());
  p->setPen(pal.active().mid());
  p->drawEllipse( x-r,y-r, 2*r,2*r);

  p->setBrush(pal.active().light());
  p->setPen(pal.active().light());
  p->drawEllipse( x-r/3, y-r/3, 4*r/3,4*r/3);

  p->setBrush(w);
  p->setPen(w);
  p->drawEllipse( x+r/3, y+r/3, r/3,r/3);

  p->setPen(oldPen);
  p->setBrush(oldBrush);
}  


void BoardWidget::drawBoard()
{
  boardPM.resize(width(), height());
  boardPM.fill(this, 0,0);

#ifndef HAVE_KIR
  TQColorGroup g = TQPalette( *boardColor ).active();
  TQColorGroup g2 = TQWidget::colorGroup();

  int boardSize = width() *10/12;
  if (boardSize > height()) boardSize = height();
  
  TQPainter p;
  p.begin(&boardPM);
  p.setBrush(g2.brush(TQColorGroup::Mid));
  
  TQWMatrix m;
  TQPoint cp = rect().center();
  m.translate(cp.x(), cp.y());
  m.scale(boardSize/1100.0, boardSize/1000.0);

  m.rotate(0);

  p.setWorldMatrix(m);

  /* draw field */

  int i,j;

  TQPointArray a;
  int dx=520 /2, dy=(520 *87)/100;
  a.setPoints(6, -dx,-dy, dx,-dy, 2*dx,0, dx,dy, -dx,dy, -2*dx,0 );
  p.drawPolygon(a);

  drawShadedHexagon(&p, 0,0, 505, 1, g, false);
  drawShadedHexagon(&p, 0,0, 512, 3, g, true);
  drawShadedHexagon(&p, 0,0, 525, 5, g2, true);

#define xpos(i,j) (495*(2*(i)-(j))/9)
#define ypos(j)   (500*19*(j)/100)
	
  for(j=-4;j<5;j++)
    for(i= ((j>0)?j-4:-4) ; i< ((j<0)?5+j:5) ;i++) {
      int x=xpos(i,j);
      int y=ypos(j);
		  
      drawShadedHexagon(&p, x,y, 50, 2, g, true);
      drawShadedHexagon(&p, x,y, 30, 1, g, false);
    }
  p.end();
#endif
  draw();
}

void BoardWidget::renderBalls(bool r)
{
  renderMode=r;
  draw();
}

void BoardWidget::updateBalls()
{
  int i,j;
  
  for(j=-4;j<5;j++)
    for(i= ((j>0)?j-4:-4) ; i< ((j<0)?5+j:5) ;i++) {
      int pos = 60+j*11+i;
      int w=field[60+j*11+i];
      
      if (w==Board::color1) {
        if (positions[pos]->def != n1) {
          positions[pos]->def= n1;
          startAnimation(pos,1, ANIMATION_FORWARD);
        }
        else {
          stopAnimation(pos);
	}	
      }                         
      else if (w==Board::color1bright)
        startAnimation(pos,2,ANIMATION_LOOP);
      else if (w==Board::color2) {
        if (positions[pos]->def != n2) {
          positions[pos]->def= n2;
          startAnimation(pos,3,ANIMATION_FORWARD);
        }
        else {
          stopAnimation(pos);
	}
      }
      else if (w==Board::color2bright)
        startAnimation(pos,4,ANIMATION_LOOP);
      else if (w==Board::free) {
	positions[pos]->def= 0;
	positions[pos]->actAnimation = 0;
	//	stopAnimation(pos);
      }                         
    }
  
  for(i=0;i<6;i++)
    positions[i]->def= ((14-color1Count)>i && color1Count>0) ? n1:0;
  
  for(i=6;i<12;i++)
    positions[i]->def= ((14-color2Count)>i-6 && color2Count>0) ? n2:0;
  
}

void BoardWidget::draw()
{
  if (boardPM.isNull())
    return;

  pm = boardPM;

  if (renderMode) {
    updateBalls();
    repaint(false);
    return;
  }

  int boardSize = width() *10/12;
  if (boardSize > height()) boardSize = height();
    
  TQPainter p;
  p.begin(&pm);
  p.setBrush(foregroundColor());
  
  TQWMatrix m;
  TQPoint cp = rect().center();
  m.translate(cp.x(), cp.y());
  m.scale(boardSize/1100.0, boardSize/1000.0);

  m.rotate(0);

  p.setWorldMatrix(m);

  /* draw fields */

  int i,j;

  for(j=-4;j<5;j++)
    for(i= ((j>0)?j-4:-4) ; i< ((j<0)?5+j:5) ;i++) {
      int x=xpos(i,j);
      int y=ypos(j);
      int w=field[60+j*11+i];
		  
      if (w==Board::color1) 
	drawColor(&p, x,y, 35, redColor );
      else if (w==Board::color1bright) 
	drawColor(&p, x,y, 35, redHColor );
      else if (w==Board::color2) 
	drawColor(&p, x,y, 35, yellowColor );
      else if (w==Board::color2bright)
	drawColor(&p, x,y, 35, yellowHColor );
    }

  if (color1Count >0) {
    /* the outer marks of color1 */
    if (color1Count <12) {
      for(i=11; i>8 && i>color1Count ;i--)
	drawColor(&p, xpos(12-i,7-i)+55, ypos(7-i), 35, redColor );
    }
    for(i=14; i>11 && i>color1Count ;i--)
      drawColor(&p, xpos(-6,10-i)+55, ypos(10-i), 35, redColor );
    
    /* the outer marks of color2 */
    if (color2Count <12) {
      for(i=11; i>8 && i>color2Count ;i--)
	drawColor(&p, xpos(i-12,i-7)-55, ypos(i-7), 35, yellowColor);
    }
    for(i=14; i>11 && i>color2Count ;i--)
      drawColor(&p, xpos(6,i-10)-55, ypos(i-10), 35, yellowColor);
  }
  p.end();
  bitBlt(this, 0, 0, &pm);
}

/** updatePosition
 *
 * Update my position with that of the <board> member.
 * If <updateGUI> is true, draw widget
 */
void BoardWidget::updatePosition(bool updateGUI)
{
  for(int i=0; i<Board::AllFields;i++)
    field[i] = board[i];
  color1Count = board.getColor1Count();
  color2Count = board.getColor2Count();
  color       = board.actColor();
  boardOK     = true;

  if (updateGUI) draw();
}


bool BoardWidget::setEditMode(bool mode)
{
  if (editMode == false && mode==true) {
    editMode = true;
  }
  else if (editMode == true && mode == false) {
    editMode = false;

    for(int i=0; i<Board::AllFields;i++)
      board.setField( i, field[i]);
    board.setColor1Count(color1Count);
    board.setColor2Count(color2Count);
    
  }
  return editMode;
}    


void BoardWidget::clearPosition()
{
  for(int i=0; i<Board::AllFields;i++)
    field[i] = 0;
  color1Count = color2Count = 0;
}

void BoardWidget::showMove(const Move& mm, int step, bool updateGUI)
{
  int f, dir, dir2;
  int opponentNew, colorNew;
  bool afterMove;
  static Move lastMove;
  Move m;
  
  if (boardOK) {
    /* board ok means: board has the normal state 
     *  (e.g. no highlighting) 
     */
    if (step == 0)
      return;      /* nothing to be done */
  }
  boardOK = (step == 0) ? true:false;
  
  if (step == 0) 
    m = lastMove;
  else {
    m = lastMove = mm;
  }
  
  if (color == Board::color1) {
    colorNew = (step<2) ? Board::color1 : 
      (step>2) ? Board::color1bright:Board::free;
    opponentNew = (step<2) ? Board::color2 : Board::color2bright;
  }
  else {
    colorNew = (step<2) ? Board::color2 :
      (step>2) ? Board::color2bright:Board::free;
    opponentNew = (step<2) ? Board::color1 : Board::color1bright;
  }
  
  afterMove = (step == 1) || (step == 4);
  
  f = m.field;
  dir = Board::fieldDiffOfDir(m.direction);
  
  /* first field */
  field[f] = afterMove ? Board::free : colorNew;
  
  switch(m.type) {
  case Move::out2:        /* (c c c o o |) */
    field[f + dir] = colorNew;
    field[f + 2*dir] = colorNew;
    field[f + 3*dir] = afterMove ? colorNew : opponentNew;
    field[f + 4*dir] = opponentNew;
    break;		
  case Move::out1with3:   /* (c c c o |)   */
    field[f + dir] = colorNew;
    field[f + 2*dir] = colorNew;
    field[f + 3*dir] = afterMove ? colorNew : opponentNew;
    break;
  case Move::move3:       /* (c c c .)     */
    field[f + dir] = colorNew;
    field[f + 2*dir] = colorNew;
    field[f + 3*dir] = afterMove ? colorNew : Board::free;
    break;
  case Move::out1with2:   /* (c c o |)     */
    field[f + dir] = colorNew;
    field[f + 2*dir] = afterMove ? colorNew : opponentNew;
    break;
  case Move::move2:       /* (c c .)       */
    field[f + dir] = colorNew;
    field[f + 2*dir] = afterMove ? colorNew : Board::free;
    break;
  case Move::push2:       /* (c c c o o .) */
    field[f + dir] = colorNew;
    field[f + 2*dir] = colorNew;
    field[f + 3*dir] = afterMove ? colorNew : opponentNew;
    field[f + 4*dir] = opponentNew;
    field[f + 5*dir] = afterMove ? opponentNew : Board::free;
    break;
  case Move::left3:		
    dir2 = Board::fieldDiffOfDir(m.direction-1);
    field[f+dir2] = afterMove ? colorNew : Board::free;
    field[f+=dir] = afterMove ? Board::free : colorNew;
    field[f+dir2] = afterMove ? colorNew : Board::free;
    field[f+=dir] = afterMove ? Board::free : colorNew;
    field[f+dir2] = afterMove ? colorNew : Board::free;
    break;
  case Move::right3:
    dir2 = Board::fieldDiffOfDir(m.direction+1);
    field[f+dir2] = afterMove ? colorNew : Board::free;
    field[f+=dir] = afterMove ? Board::free : colorNew;
    field[f+dir2] = afterMove ? colorNew : Board::free;
    field[f+=dir] = afterMove ? Board::free : colorNew;
    field[f+dir2] = afterMove ? colorNew : Board::free;
    break;
  case Move::push1with3:   /* (c c c o .) => (. c c c o) */
    field[f + dir] = colorNew;
    field[f + 2*dir] = colorNew;
    field[f + 3*dir] = afterMove ? colorNew : opponentNew;
    field[f + 4*dir] = afterMove ? opponentNew : Board::free;
    break;
  case Move::push1with2:   /* (c c o .) => (. c c o) */
    field[f + dir] = colorNew;
    field[f + 2*dir] = afterMove ? colorNew : opponentNew;
    field[f + 3*dir] = afterMove ? opponentNew : Board::free;
    break;
  case Move::left2:
    dir2 = Board::fieldDiffOfDir(m.direction-1);
    field[f+dir2] = afterMove ? colorNew : Board::free;
    field[f+=dir] = afterMove ? Board::free : colorNew;
    field[f+dir2] = afterMove ? colorNew : Board::free;
    break;
  case Move::right2:
    dir2 = Board::fieldDiffOfDir(m.direction+1);
    field[f+dir2] = afterMove ? colorNew : Board::free;
    field[f+=dir] = afterMove ? Board::free : colorNew;
    field[f+dir2] = afterMove ? colorNew : Board::free;
    break;
  case Move::move1:       /* (c .) => (. c) */
    field[f + dir] = afterMove ? colorNew : Board::free;
    break;
  default:
    break;
  }
  
  if (updateGUI)
    draw();
}

void BoardWidget::showStart(const Move& m, int step, bool updateGUI)
{
  int f, dir;
  int colorNew;
  
  if (boardOK) {
    /* board ok means: board has the normal state before move */
    if (step == 0)
      return;      /* nothing to be done */
  }
  boardOK = (step == 0) ? true:false;
  
  if (color == Board::color1)
    colorNew = (step==0) ? Board::color1 : Board::color1bright;
  else 
    colorNew = (step==0) ? Board::color2 : Board::color2bright;
  
  f = m.field;
  
  /* first field */
  field[f] = colorNew;
  
  switch(m.type) {
  case Move::left3:
  case Move::right3:
    dir = Board::fieldDiffOfDir(m.direction);
    field[f + dir] = colorNew;
    field[f + 2*dir] = colorNew;
    break;
  case Move::left2:
  case Move::right2:
    dir = Board::fieldDiffOfDir(m.direction);
    field[f + dir] = colorNew;
  default:
    break;
  }
  
  if (updateGUI)
    draw();
}


void BoardWidget::choseMove(MoveList *pl)
{ 
  if (!gettingMove && pl != 0) {
    pList = pl;
    gettingMove = true;
    mbDown = false;
    actValue = - board.calcEvaluation();
    kdDebug(12011) << "Chose Move..." << endl;
  }
}


/* returns position of point (xx,yy)
 */
int BoardWidget::positionOf(int xx, int yy)
{
  int boardSize = TQMIN( width()*10/12, height() );
  int x = (1000 * (xx- (width()-boardSize)/2)) / boardSize;
  int y = (1000 * (yy- (height()-boardSize)/2)) / boardSize;
  
  /*
  kdDebug(12011) << "(" << xx << "," << yy << ") -> ("
	    << x << "," << y << ")" << endl;
  */

  y = (y-2)/47;
  if (y < 2 || y > 18) return 0;
  x= ((x+25)/25+ (y-10) )/2;
  if (y <  10 && ((x < 2) || (x > 8+y) )) return 0;
  if (y >= 10 && ((x < y-8) || (x > 18) )) return 0;

  return 22*y + x;
}


bool isBetweenFields(int pos)
{
  bool res = ( ((pos%2) == 1) || ( ((pos/22)%2) == 1) );
  //  kdDebug(12011) << "Pos " << pos << " is between fields: " << res << endl;
  return res;
}

int fieldOf(int pos)
{
  int f = 11*(pos/44) + (pos%22)/2;
  //  kdDebug(12011) << "Field1 of pos " << pos << " is " << f << endl;
  return f;
}

int field2Of(int pos)
{
  int y = pos/22, x = pos%22;
  int f2 = 0, f1 = 11*(y/2) + (x/2);

  if ( (y%2) == 0) {
    /* exact on row */
    if ( (x%2) != 0) {
      /* horizontial between fields */
      f2 = f1+1;
    }
  }
  else {
    /* vertical between fields */
    f2 = f1 + ( ((x%2)==0) ? 11:12 );
  }

  //  kdDebug(12011) << "Field2 of pos " << pos << " is " << f2 << endl;
  return f2;
}


/* get direction depending on difference of positions */
int directionOfPosDiff(int d)
{
  if (d>0) {
    return ((d<21) ? Move::Right : 
	    ((d%22) == 0) ? Move::LeftDown :
	    ((d%23) == 0) ? Move::RightDown : 0);
  }
  else if (d<0) {
    return ((d>-21) ? Move::Left : 
	    ((d%23) == 0) ? Move::LeftUp :
	    ((d%22) == 0) ? Move::RightUp : 0);
  }
  return 0;
}

int directionOfFieldDiff(int d)
{
  if (d>0) {
    return ((d<10) ? Move::Right : 
	    ((d%11) == 0) ? Move::LeftDown :
	    ((d%12) == 0) ? Move::RightDown : 0);
  }
  else if (d<0) {
    return ((d>-10) ? Move::Left : 
	    ((d%12) == 0) ? Move::LeftUp :
	    ((d%11) == 0) ? Move::RightUp : 0);
  }
  return 0;
}

/* Check if <pos> is a valid start position for a allowed move
 * If yes, set 
 *   <startField>, <actMove> and <startType>
 */
bool BoardWidget::isValidStart(int pos, bool midPressed)
{
  bool res = false;
  int f1 = fieldOf(pos);

  startField = f1;

  if (isBetweenFields(pos)) {
    int f2 = field2Of(pos);

    actMove = Move(f1, directionOfFieldDiff( f2-f1 ), Move::none);
    res = pList->isElement(actMove, MoveList::start2);
    if (!res) {
      startField = f2;
      actMove = Move(f2, directionOfFieldDiff( f1-f2 ), Move::none);
      res = pList->isElement(actMove, MoveList::start2);
    }
    startType = MoveList::start2;
    return res;
  }

  if (midPressed) {
    startType = MoveList::start3;

    /* Check all 6 directions */
    for(int dir=1;dir<7;dir++) {
      actMove = Move(f1 - Board::fieldDiffOfDir(dir), dir, Move::none );
      if (pList->isElement(actMove, startType))
	return true;
    }
    /* if we don't find a side move3 fall trough to normal moves... */
  }

  startType = MoveList::start1;
  actMove = Move(f1, 0, Move::none);
  res = pList->isElement(actMove, startType);

  return res;
}


/* Check if <pos> is a valid end position for a move
 * regarding <startPos>
 * If yes, set <actMove> 
 */
bool BoardWidget::isValidEnd(int pos)
{
  int dir = directionOfPosDiff(pos - startPos);
  Move m;

  if (dir == 0) return false;

  switch(startType) {
  case MoveList::start1:
    m = Move(startField, dir, Move::none);
    if (!pList->isElement(m, startType))
      return false;
    break;

  case MoveList::start2:
    {
      int f1 = fieldOf(startPos);
      int f2 = field2Of(startPos);
      int dir2 = directionOfFieldDiff( f2-f1 );
      int dir3 = directionOfFieldDiff( f1-f2 );

      switch((dir2-dir+6)%6) {
      case 1:
	m = Move(f1, dir2, Move::left2);
	break;
      case 2:
	m = Move(f2, dir3, Move::right2);
	break;
      case 4:
	m = Move(f2, dir3, Move::left2);
	break;
      case 5:
	m = Move(f1, dir2, Move::right2);
	break;
      default:
	return false;
      }
      if (!pList->isElement(m, startType))
	return false;

      break;
    }
  case MoveList::start3:
    {
      int rightDir = (dir%6)+1;
      m = Move( startField - Board::fieldDiffOfDir(rightDir), rightDir, Move::left3 );
      if (!pList->isElement(m, startType)) {
	int leftDir = ((dir-2)%6)+1;
	m = Move( startField - Board::fieldDiffOfDir(leftDir), leftDir, Move::right3 );
	if (!pList->isElement(m, startType))
	  return false;
      }
    }
    break;
  }

  actMove = m;
  shownDirection = dir;
  return true;
}



void BoardWidget::mousePressEvent( TQMouseEvent* pEvent )
{
  int pos = positionOf( pEvent->x(), pEvent->y() );
  int f = fieldOf(pos);

  if (pEvent->button() == TQt::RightButton) {
    emit rightButtonPressed(f, pEvent->globalPos());
    return;
  }

  if (!gettingMove && !editMode) {
    return;
  }
  mbDown = true;


  if (editMode) {
    editColor = (pEvent->button() == TQt::MidButton) ? 
      Board::color2 : Board::color1;
    int newColor = (pEvent->button() == TQt::MidButton) ? 
      Board::color2bright : Board::color1bright;

    if (field[f] == Board::free) {
      field[f] = newColor;
    }
    else if (field[f] == Board::color1) {
      if (editColor == Board::color1) {
       editColor = Board::free;
       newColor = Board::color1bright;
      }
      field[f] = newColor;
    }
    else if (field[f] == Board::color2) {
      if (editColor == Board::color2) {
       editColor = Board::free;
       newColor = Board::color2bright;
      }
      field[f] = newColor;
    }
    else {
      editColor = Board::out;
    }

    oldPos = pos;
    draw();
    return;
  }

  startValid = isValidStart(pos, (pEvent->button() == TQt::MidButton));
  kdDebug(12011) << "Start pos " << pos << " is valid: " << startValid << endl;
  //  actMove.print();

  if (!startValid) return;
  startPos = oldPos = pos;

  showStart(actMove,1);
  startShown = true;

  TQString tmp;
  actValue = - board.calcEvaluation();
  tmp = i18n("Board value: %1").arg(actValue);
  emit updateSpy(tmp);
}


void BoardWidget::mouseMoveEvent( TQMouseEvent* pEvent )
{
  if ((!gettingMove && !editMode) || !mbDown) return;

  int pos = positionOf( pEvent->x(), pEvent->y() );
  if (pos == oldPos) return;
  oldPos = pos;

  if (editMode) {
    int f = fieldOf(pos);
    if (field[f] != Board::out && field[f] != editColor) {
      int newColor = (editColor == Board::color1) ? Board::color1bright :
       (editColor == Board::color2) ? Board::color2bright :
       (field[f] == Board::color1) ? Board::color1bright :
       (field[f] == Board::color2) ? Board::color2bright : field[f];
      field[f] = newColor;
      draw();
    }
    return;
  }

  if (!startValid) {
    /* We haven't a valid move yet. Check if we are over a valid start */

    startValid = isValidStart(pos, (pEvent->button() == TQt::MidButton));
    kdDebug(12011) << "Start pos " << pos << " is valid: " << startValid << endl;
    //    actMove.print();

    if (!startValid) return;
    startPos = oldPos = pos;

    showStart(actMove,1);
    startShown = true;

    TQString tmp;
    actValue = - board.calcEvaluation();
    tmp = i18n("Board value: %1").arg(actValue);
    emit updateSpy(tmp);
    return;
  }

  /* restore board */
  updatePosition();
  startShown = false;

  if (isValidEnd(pos)) {
    //    actMove.print();

    board.playMove(actMove);
    int v = board.calcEvaluation();
    board.takeBack();

    TQString tmp;
    tmp.sprintf("%+d", v-actValue);
    TQString str = TQString("%1 : %2").arg(actMove.name()).arg(tmp);
    emit updateSpy(str);
    
    showMove(actMove,3);
    setCursor(*arrow[shownDirection]);
  }
  else {
    TQString tmp;

    setCursor(crossCursor);
    if (pos == startPos) {
	showStart(actMove,1);
	startShown = true;
	tmp = i18n("Board value: %1").arg(actValue);
    }
    else
      draw();
    emit updateSpy(tmp);
  }
}


void BoardWidget::mouseReleaseEvent( TQMouseEvent* pEvent )
{
  if (!gettingMove && !editMode) return;
  mbDown = false;

  if (editMode) {
    int i;

    //    printf("Releasing...");
    for(i=0; i<Board::AllFields;i++)
      if (field[i] == Board::color1bright ||
         field[i] == Board::color2bright) {
       //printf(" Found %d\n",i);
       field[i] = editColor;
      }

    for(i=0; i<Board::AllFields;i++)
      board.setField( i, field[i]);

    int vState = board.validState(); // set color1/2Count
    color1Count = board.getColor1Count();
    color2Count = board.getColor2Count();

    draw();

    emit edited(vState);
    return;
  }

  if (!startValid) return;

  int pos = positionOf( pEvent->x(), pEvent->y() );
  if (isValidEnd(pos)) {
    //    actMove.print();
    startValid = false;
    setCursor(crossCursor);
    gettingMove = false;
    emit moveChoosen(actMove);
    return;
  }

  updatePosition(true);
  startValid = false;
  setCursor(crossCursor);

  TQString tmp;
  emit updateSpy(tmp);
}

TQSize  BoardWidget::sizeHint() const
{
   return TQSize(400, 350);
}

#include "BoardWidget.moc"
