path: root/kbackgammon/kbgboard.cpp

/* Yo Emacs, this -*- C++ -*-

  Copyright (C) 1999-2001 Jens Hoefkens
  jens@hoefkens.com

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

/*

  This file contains the implementation of the KBgBoard class and
  all related utility classes.

  Effort has been made to keep this class general. Please comment on that
  if you want to use it in your own project.

*/

#include <kapplication.h>

#include "kbgboard.h"
#include "kbgboard.moc"

#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <kcolordialog.h>
#include <klocale.h>
#include <tqlayout.h>
#include <tqgroupbox.h>
#include <tqbuttongroup.h>
#include <kconfig.h>
#include <tqwhatsthis.h>
#include <tqvbox.h>
#include <kiconloader.h>
#include <ktabctl.h>
#include <kpushbutton.h>
#include <kstdguiitem.h>

#include "version.h"


const int CUBE_UPPER = 3;
const int CUBE_LOWER = 4;

static const int MINIMUM_CHECKER_SIZE = 10;

/*
 * Set the default settings in all user configurations
 */
void KBgBoardSetup::setupDefault()
{
	// default background color
	setBackgroundColor(TQColor(200, 200, 166));
	pbc_1->setPalette(TQPalette(backgroundColor()));

	// checker colors
	baseColors[0] = black;
	baseColors[1] = white;
	pbc_2->setPalette(TQPalette(baseColors[0]));
	pbc_3->setPalette(TQPalette(baseColors[1]));

	// default font
	setFont(TQFont("Serif", 18, TQFont::Normal));
	kf->setFont(getFont());

	// short moves
	setShortMoveMode(SHORT_MOVE_DOUBLE);
	for (int i = 0; i < 3; i++)
		rbMove[i]->setChecked(i == SHORT_MOVE_DOUBLE);

	// pip count
	cbp->setChecked(computePipCount = true);
}

/*
 * User committed the changes. Save them.
 */
void KBgBoardSetup::setupOk()
{
	// font selection
	setFont(kf->font());

	// move strategy
	for (int i = 0; i < 3; i++)
		if (rbMove[i]->isChecked()) setShortMoveMode(i);

	// pipcount
	computePipCount = cbp->isChecked();
}

/*
 * User cancelled the changes. Undo the color changes that become
 * visible right away.
 */
void KBgBoardSetup::setupCancel()
{
	// undo background color change
	setBackgroundColor(saveBackgroundColor);

	// undo checker color changes
	baseColors[0] = saveBaseColors[0];
	baseColors[1] = saveBaseColors[1];

	for (int i = 0; i < 30; i++)
		cells[i]->update();
}

/*
 * Fills configuration page in the dialog nb
 */
void KBgBoardSetup::getSetupPages(KDialogBase *nb)
{
	/*
	 * Main Widget
	 * ===========
	 */
	TQVBox *vbp = nb->addVBoxPage(i18n("Board"), i18n("Here you can configure the backgammon board"),
				     kapp->iconLoader()->loadIcon(PROG_NAME, KIcon::Desktop));

	/*
	 * Need more than one page
	 */
	KTabCtl *tc = new KTabCtl(vbp, "board tabs");

	TQWidget *w = new TQWidget(tc);
	TQGridLayout *gl = new TQGridLayout(w, 3, 1, nb->spacingHint());

	/*
	 * Group boxes
	 * ===========
	 */
	TQGroupBox    *ga = new TQGroupBox(w);
	TQButtonGroup *gm = new TQButtonGroup(w);
	TQGroupBox    *go = new TQGroupBox(w);

	ga->setTitle(i18n("Colors"));
	gm->setTitle(i18n("Short Moves"));
	go->setTitle(i18n("Options"));

	gl->addWidget(ga, 0, 0);
	gl->addWidget(gm, 1, 0);
	gl->addWidget(go, 2, 0);

	/*
	 * Appearance group
	 * ----------------
	 */
	TQGridLayout *blc = new TQGridLayout(ga, 2, 2, 20);

	pbc_1 = new TQPushButton(i18n("Background"), ga);
	pbc_1->setPalette(TQPalette(backgroundColor()));

	pbc_2 = new TQPushButton(i18n("Color 1"), ga);
	pbc_2->setPalette(TQPalette(baseColors[0]));

	pbc_3 = new TQPushButton(i18n("Color 2"), ga);
	pbc_3->setPalette(TQPalette(baseColors[1]));

	blc->addWidget(pbc_2, 0, 0);
	blc->addWidget(pbc_3, 0, 1);
	blc->addMultiCellWidget(pbc_1, 1, 1, 0, 1);

	connect(pbc_1, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBackgroundColor()));
	connect(pbc_2, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBaseColorOne()));
	connect(pbc_3, TQT_SIGNAL(clicked()), this, TQT_SLOT(selectBaseColorTwo()));

	/*
	 * Moving style
	 * ------------
	 */
	TQBoxLayout *blm = new TQVBoxLayout(gm, nb->spacingHint());

	blm->addSpacing(gm->fontMetrics().height());

	for (int i = 0; i < 3; i++)
		rbMove[i] = new TQRadioButton(gm);

	rbMove[SHORT_MOVE_NONE]->setText(i18n("&Disable short moves. Only drag and drop will move."));
	rbMove[SHORT_MOVE_SINGLE]->setText(i18n("&Single clicks with the left mouse button will\n"
			  "move a checker the shortest possible distance."));
	rbMove[SHORT_MOVE_DOUBLE]->setText(i18n("D&ouble clicks with the left mouse button will\n"
			  "move a checker the shortest possible distance."));

	for (int i = 0; i < 3; i++) {
		rbMove[i]->setMinimumSize(rbMove[i]->sizeHint());
		blm->addWidget(rbMove[i]);
		rbMove[i]->setChecked(i == getShortMoveMode());
	}

	/*
	 * Other options
	 * -------------
	 */
	TQGridLayout *glo = new TQGridLayout(go, 1, 1, 20);

	cbp = new TQCheckBox(i18n("Show pip count in title bar"), go);
	cbp->setChecked(computePipCount);
	cbp->adjustSize();
	cbp->setMinimumSize(cbp->size());

	glo->addRowSpacing(0, cbp->height());
	glo->addWidget(cbp, 0, 0);

	gl->activate();

	w->adjustSize();
	w->setMinimumSize(w->size());

	tc->addTab(w, i18n("&Board"));

	/*
	 * Save current settings
	 * ---------------------
	 */
	saveBackgroundColor = backgroundColor();
	saveBaseColors[0]   = baseColors[0];
	saveBaseColors[1]   = baseColors[1];

	/*
	 * Font selection page
	 * ===================
	 */
	w = new TQWidget(tc);
	kf = new KFontChooser(w);
	kf->setFont(getFont());
	gl = new TQGridLayout(w, 1, 1, nb->spacingHint());
	gl->addWidget(kf, 0, 0);
	gl->activate();
	w->adjustSize();
	w->setMinimumSize(w->size());
	tc->addTab(w, i18n("&Font"));
}

/*
 * Empty constructor calls the board constructor
 */
KBgBoardSetup::KBgBoardSetup(TQWidget *parent, const char *name, TQPopupMenu *menu)
	: KBgBoard(parent, name, menu)
{
	// empty
}

/*
 * User changed first checker color
 */
void KBgBoardSetup::selectBaseColorOne()
{
	KColorDialog *c = new KColorDialog(this, "base-col-1", true);
	c->setColor(baseColors[0]);
	if (c->exec()) {
		baseColors[0] = c->color();
		pbc_2->setPalette(TQPalette(baseColors[0]));
		for (int i = 0; i < 30; i++)
			cells[i]->update();
	}
	delete c;
}

/*
 * User changed second checker color
 */
void KBgBoardSetup::selectBaseColorTwo()
{
	KColorDialog *c = new KColorDialog(this, "base-col-2", true);
	c->setColor(baseColors[1]);
	if (c->exec()) {
		baseColors[1] = c->color();
		pbc_3->setPalette(TQPalette(baseColors[1]));
		for (int i = 0; i < 30; i++)
			cells[i]->update();
	}
	delete c;
}

/*
 * User changed background color
 */
void KBgBoardSetup::selectBackgroundColor()
{
	KColorDialog *c = new KColorDialog(this, "bg-col", true);
	c->setColor(backgroundColor());
	if (c->exec()) {
		setBackgroundColor(c->color());
		pbc_1->setPalette(TQPalette(backgroundColor()));
		for (int i = 0; i < 30; i++)
			cells[i]->update();
	}
	delete c;
}

/*
 * Saves the persistent settings of the board
 */
void KBgBoard::saveConfig()
{
	KConfig* config = kapp->config();
	config->setGroup(name());

	config->writeEntry("bgcolor", backgroundColor());
	config->writeEntry("color-1", baseColors[0]);
	config->writeEntry("color-2", baseColors[1]);
	config->writeEntry("font", getFont());
	config->writeEntry("move", getShortMoveMode());
	config->writeEntry("pip", computePipCount);
}

/*
 * Restore the settings or use reasonable defaults
 */
void KBgBoard::readConfig()
{
	TQColor col(200, 200, 166);
	TQFont fon("Serif", 18, TQFont::Normal);

	KConfig* config = kapp->config();
	config->setGroup(name());

	setBackgroundColor(config->readColorEntry("bgcolor", &col));
	baseColors[0] = config->readColorEntry("color-1", &black);
	baseColors[1] = config->readColorEntry("color-2", &white);
	setFont(config->readFontEntry("font", &fon));
	setShortMoveMode(config->readNumEntry("move", SHORT_MOVE_DOUBLE));
	computePipCount = config->readBoolEntry("pip", true);
}

/*
 * Get the font the board cells should use for the display of
 * numbers and cube value.
 */
TQFont KBgBoard::getFont() const
{
	return boardFont;
}

/*
 * Allows the users of the board classe to set the font to be used
 * on the board. Note that the fontsize is dynamically set
 */
void KBgBoard::setFont(const TQFont& f)
{
	boardFont = f;
}

/*
 * Ask the user for an updated cube value
 */
void KBgBoard::queryCube()
{
	KBgStatus *st = new KBgStatus();
	getState(st);
	KBgBoardQCube *dlg =
		new KBgBoardQCube(abs(st->cube()), (st->cube(US) > 0), (st->cube(THEM) > 0));
	if (dlg->exec()) {
		bool u = ((dlg->getCubeValue() == 0) || (dlg->getCubeOwner() == US  ));
		bool t = ((dlg->getCubeValue() == 0) || (dlg->getCubeOwner() == THEM));
		st->setCube((int)rint(pow(2.0, dlg->getCubeValue())), u, t);
		setState(*st); // JENS
	}
	delete dlg;
	delete st;
}

/*
 * Constructor, creates the dialog but does not show nor execute it.
 */
KBgBoardQCube::KBgBoardQCube(int val, bool us, bool them)
	: TQDialog(0, 0, true)
{
	setCaption(i18n("Set Cube Values"));

	TQBoxLayout *vbox = new TQVBoxLayout(this, 17);

	TQLabel *info = new TQLabel(this);

	cb[0]  = new TQComboBox(this, "first sb");
	cb[1]  = new TQComboBox(this, "second sb");
	ok     = new KPushButton(KStdGuiItem::ok(), this);
	cancel = new KPushButton(KStdGuiItem::cancel(), this);

	info->setText(i18n("Set the face value of the cube and select who should be able to\n"
			   "double. Note that a face value of 1 automatically allows both\n"
			   "players to double."));

	info->setMinimumSize(info->sizeHint());

	vbox->addWidget(info, 0);

	TQBoxLayout *hbox_1 = new TQHBoxLayout();
	TQBoxLayout *hbox_2 = new TQHBoxLayout();

	vbox->addLayout(hbox_1);
	vbox->addLayout(hbox_2);

	hbox_1->addWidget(cb[1]);
	hbox_1->addWidget(cb[0]);

	hbox_2->addWidget(ok);
	hbox_2->addWidget(cancel);

	cb[0]->insertItem(" 1", 0);
	cb[0]->insertItem(" 2", 1);
	cb[0]->insertItem(" 4", 2);
	cb[0]->insertItem(" 8", 3);
	cb[0]->insertItem("16", 4);
	cb[0]->insertItem("32", 5);
	cb[0]->insertItem("64", 6);

	switch(val) {
	case  1:
		cb[0]->setCurrentItem(0);
		break;
	case  2:
		cb[0]->setCurrentItem(1);
		break;
	case  4:
		cb[0]->setCurrentItem(2);
		break;
	case  8:
		cb[0]->setCurrentItem(3);
		break;
	case 16:
		cb[0]->setCurrentItem(4);
		break;
	case 32:
		cb[0]->setCurrentItem(5);
		break;
	case 64:
		cb[0]->setCurrentItem(6);
		break;
	}

	cb[1]->insertItem(i18n("Lower Player"), US);
	cb[1]->insertItem(i18n("Upper Player"), THEM);
	cb[1]->insertItem(i18n("Open Cube"), BOTH);

	if (us && them)
		cb[1]->setCurrentItem(BOTH);
	else if (us)
		cb[1]->setCurrentItem(US);
	else if (them)
		cb[1]->setCurrentItem(THEM);

	cb[0]->setMinimumSize(cb[0]->sizeHint());
	cb[1]->setMinimumSize(cb[1]->sizeHint());

	ok->setMinimumSize(ok->sizeHint());
	cancel->setMinimumSize(cancel->sizeHint());

	setMinimumSize(childrenRect().size());

	vbox->activate();

	resize(minimumSize());

	ok->setAutoDefault (true);
	ok->setDefault(true);

	cb[0]->setFocus();

	connect(ok,     TQT_SIGNAL(clicked()), TQT_SLOT(accept()));
	connect(cancel, TQT_SIGNAL(clicked()), TQT_SLOT(reject()));

	connect(cb[0],  TQT_SIGNAL(activated(int)), TQT_SLOT(changePlayer(int)));
	connect(cb[1],  TQT_SIGNAL(activated(int)), TQT_SLOT(changeValue (int)));
}

/*
 * Deconstructor, empty.
 */
KBgBoardQCube::~KBgBoardQCube()
{
	// nothing
}

/*
 * Get the face value of the cube
 */
int KBgBoardQCube::getCubeValue()
{
	return cb[0]->currentItem();
}

/*
 * Get the owner of the cube
 */
int KBgBoardQCube::getCubeOwner()
{
	return cb[1]->currentItem();
}

/*
 * If the cube is open, the value can only be 1
 */
void KBgBoardQCube::changeValue(int player)
{
	if (player == BOTH)
		cb[0]->setCurrentItem(0);

}

/*
 * If the value is 1, the cube has to be open; and if the value
 * becomes bigger than 1, the player cannot stay open.
 */
void KBgBoardQCube::changePlayer(int val)
{
	if (val == 0)
		cb[1]->setCurrentItem(BOTH);
	else if (cb[1]->currentItem() == BOTH)
		cb[1]->setCurrentItem(US);
}

/*
 * Constructor, creates the dialog but does not show nor execute it.
 */
KBgBoardQDice::KBgBoardQDice(const char *name)
	: TQDialog(0, name, true)
{
	setCaption(i18n("Set Dice Values"));

	TQBoxLayout *vbox = new TQVBoxLayout(this, 17);

	TQLabel *info = new TQLabel(this);

	sb[0]  = new TQSpinBox(this, "first sb");
	sb[1]  = new TQSpinBox(this, "second sb");
	ok     = new KPushButton(KStdGuiItem::ok(), this);
	cancel = new KPushButton(KStdGuiItem::cancel(), this);

	info->setText(i18n("Set the face values of the selected dice. The other player's\n"
			   "dice will be cleared and it will be the dice's owner's turn."));

	info->setMinimumSize(info->sizeHint());

	vbox->addWidget(info, 0);

	TQBoxLayout *hbox_1 = new TQHBoxLayout();
	TQBoxLayout *hbox_2 = new TQHBoxLayout();

	vbox->addLayout(hbox_1);
	vbox->addLayout(hbox_2);

	hbox_1->addWidget(sb[0]);
	hbox_1->addWidget(sb[1]);

	hbox_2->addWidget(ok);
	hbox_2->addWidget(cancel);

	sb[0]->setMinimumSize(sb[0]->sizeHint());
	sb[1]->setMinimumSize(sb[1]->sizeHint());

	ok->setMinimumSize(ok->sizeHint());
	cancel->setMinimumSize(cancel->sizeHint());

	setMinimumSize(childrenRect().size());

	vbox->activate();

	resize(minimumSize());

	ok->setAutoDefault (true);
	ok->setDefault(true);

	sb[0]->setFocus();

	connect(ok,     TQT_SIGNAL(clicked()), TQT_SLOT(accept()));
	connect(cancel, TQT_SIGNAL(clicked()), TQT_SLOT(reject()));

	sb[0]->setValue(1);
	sb[1]->setValue(1);

	sb[0]->setRange(1, 6);
	sb[1]->setRange(1, 6);
}

/*
 * Deconstructor, empty.
 */
KBgBoardQDice::~KBgBoardQDice()
{
	// nothing
}

/*
 * Get the face value of the dice
 */
int KBgBoardQDice::getDice(int n)
{
	return sb[n]->value();
}

/*
 * Allows for overriding the current turn color in edit mode.
 */
void KBgBoard::storeTurn(const int pcs)
{
	storedTurn = ((pcs > 0) ? +1 : -1);
}

/*
 * Switch edit mode on/off
 */
void KBgBoard::setEditMode(const bool m)
{
	editMode = m;
}

/*
 * Retrurns the current edit mode status.
 */
bool KBgBoard::getEditMode() const
{
	return editMode;
}

/*
 * This function takes a KBgStatus object and fills it with the current
 * board status.
 */
KBgStatus* KBgBoard::getState(KBgStatus *st) const
{
	st->setColor(color);
	st->setDirection(direction);

	st->setCube(cube, maydouble[US], maydouble[THEM]);

	st->setBar(US, onbar[US]); st->setBar(THEM, onbar[THEM]);
	st->setHome(US, onhome[US]); st->setHome(THEM, onhome[THEM]);

	st->setDice(US, 0, dice[US][0]);
	st->setDice(US, 1, dice[US][1]);

	st->setDice(THEM, 0, dice[THEM][0]);
	st->setDice(THEM, 1, dice[THEM][1]);

	for (int i = 1; i < 25; ++i)
		st->setBoard(i, ((color*board[i] < 0) ? THEM : US), abs(board[i]));

	return st;
}

/*
 * This function lets external users change the context menu
 */
void KBgBoard::setContextMenu(TQPopupMenu *menu)
{
	contextMenu = menu;
}

/*
 * This function prints all moves up to now in the extended FIBS command
 * notation (that is moves that involved kicking have a "+" instead of "-".
 */
void KBgBoard::sendMove()
{
	if (getEditMode())
		return;

	TQString s, t;

	s.setNum(moveHistory.count());
	s += " ";

	TQPtrListIterator<KBgBoardMove> it(moveHistory);
	for (; it.current(); ++it) {
		KBgBoardMove *move = it.current();
		if (move->source() == BAR_US || move->source() == BAR_THEM ) {
			s += "bar";
		} else {
			t.setNum(move->source());
			s += t;
		}
		if (move->wasKicked())
			s += "+";
		else
		        s += "-";

		if ((move->destination() != HOME_THEM_LEFT) && (move->destination() != HOME_THEM_RIGHT) &&
		    (move->destination() != HOME_US_LEFT  ) && (move->destination() != HOME_US_RIGHT )) {
			t.setNum(move->destination());
			s += t;
		} else {
			s += "off";
		}
		s += " ";
	}
	emit currentMove(&s);
}

/*
 * This is overloaded from TQWidget, since it has to pass the new
 * background color to the child widgets (the cells).
 */
void KBgBoard::setBackgroundColor(const TQColor &col)
{
	if (col != backgroundColor()) {
		TQWidget::setBackgroundColor(col);
		for( int i = 0; i < 30; ++i)
			cells[i]->setBackgroundColor(col);
	}
}

/*
 * Overloaded from TQWidget since we have to resize all cells
 */
void KBgBoard::resizeEvent(TQResizeEvent *)
{
	int xo0 = 0;
	int xo1, w;
	int hu = height()/2;
	int hl = height() - hu;

        checkerDiam = (int)((width()/15-2)<(height()/10.0-2) ?
			    (width()/15-2) : (height()/10.0-2));

	if (checkerDiam < MINIMUM_CHECKER_SIZE) 
		checkerDiam = MINIMUM_CHECKER_SIZE;

	for (int i = 0; i < 14; ++i) {
		xo1  = int((i+1)*width()/15.0);
		w = xo1 - xo0;
		cells[i   ]->setGeometry(xo0,  0, w, hu);
		cells[i+15]->setGeometry(xo0, hu, w, hl);
		xo0 = xo1;
	}
	cells[14]->setGeometry(xo0,  0, width() - xo0, hu);
	cells[29]->setGeometry(xo0, hu, width() - xo0, hl);
}

/*
 * This function draws the whole board in black and white on the
 * painter *p. It is very well suited for printing on paper.
 * It scales the output according to the width of the widget.
 * I.e. if the widget is insanely long (y-direction) this will look
 * shitty. The upper 20% of the painter are not used. So the caller
 * can print whatever she/he wants above the 0.2*p->viewport().height()
 * margin (like game status information).
 */
void KBgBoard::print(TQPainter *p)
{
	double sf = 0.8*p->viewport().width()/width();
	int xo = int((p->viewport().width() - sf*width())/2);
	int yo = int(0.2*p->viewport().height());
	int hu = height()/2;

	int xo0 = 0;
	for (int i = 0; i < 15; ++i) {
		cells[i   ]->paintCell(p, xo+sf*xo0, yo          , sf);
		cells[i+15]->paintCell(p, xo+sf*xo0, yo+sf*(hu-1), sf);
		xo0 = int((i+1)*width()/15.0);
	}
}

/*
 * This function returns the selected drawing color for a checker
 * of the given sign(!). I.e. we distinguish checkers by whether
 * they are negative or positive.
 */
TQColor KBgBoard::getCheckerColor(int p) const
{
	return ((p < 0) ? baseColors[0] : baseColors[1]);
}

/*
 * This small utility function returns the y-coordinate base
 * of a checker. This is the offset in the y-coordinate at
 * which we have toposition the upper corner of the first
 * checker so that it is fully in the cell.
 */
int KBgBoardField::numberBase() const
{
	return (cellID < 13) ? 0 : height()-20;
}

/*
 * This function computes the proper diameter for checkers on this cell.
 * It tries to stay within the horizontal boundaries and adjusts the
 * diameter in such a way that 5 checkers fit on top of each other and
 * there is still some room for stacked checkers.
 */
int KBgBoardCell::getCheckerDiameter() const
{
	return board->checkerDiam;
}

/*
 * Draws the cells content using the painter p.
 * Reimplemented from TQLabel.
 */
void KBgBoardCell::drawContents(TQPainter *)
{
	TQRect cr(0, 0, width(), height());
	cr.moveBottomLeft(rect().bottomLeft());
	TQPixmap  pix(cr.size());
	TQPainter tmp;
	pix.fill(this, cr.topLeft());
	tmp.begin(&pix);
	paintCell(&tmp);
	tmp.end();
	bitBlt(this, 0, 0, &pix);
	/*
	 * New state is now current.
	 * This avoids unnecessary redrawings.
	 */
	stateChanged = false;
}

/*
 * This does the absolute bare minimum of painting a cell. It draws a small
 * horizontal black line that marks the outer boundary of the cell and all
 * overloaded paintCell() member are supposed to call this one after(!) they
 * have painted themselves.
 */
void KBgBoardCell::paintCell(TQPainter *p, int xo, int yo, double sf) const
{
	int x1 = xo; int x2 = xo;
	int y1 = yo; int y2 = yo;

	if ((cellID==HOME_THEM_LEFT || cellID==BAR_THEM) ||
	    (cellID<13 && cellID>0)) {
		x2 += int(sf*width());
	} else if ((cellID==HOME_US_LEFT || cellID==BAR_US) ||
		   (cellID<25 && cellID>12)) {
		x2 += int(sf*width());
		y1 = y2 += int(sf*(height()-1));
	} else if (cellID == HOME_THEM_RIGHT) {
		x2 += int(sf*(width()-1));
	} else if (cellID == HOME_US_RIGHT) {
		x2 += int(sf*(width()-1));
		y1 = y2 += int(sf*(height()-1));
	} else {
		return; // do nothing if the cellID is wrong
	}

	// draw line in black
	p->setBrush( black );
	p->setPen( black );
	p->drawLine(x1, y1, x2, y2);
}

/*
 * This function draws vertical boundaries around a cell. This is used
 * for bars and homes to get them separated from the rest of the board.
 */
void
KBgBoardCell::drawVertBorder(TQPainter *p, int xo, int yo, double sf) const
{
	p->setBrush(black);
	p->setPen(black);
	p->drawLine(xo,                yo, xo,                yo+sf*(height()-1));
	p->drawLine(xo+sf*(width()-1), yo, xo+sf*(width()-1), yo+sf*(height()-1));
}

/*
 * This function draws the content of the homes on the painter *p. It
 * starts at the upper left corner (xo, yo) and uses the scaling factor
 * sf.
 */
void KBgBoardHome::paintCell(TQPainter *p, int xo, int yo, double sf) const
{
	/*
	 * Only these homes contain checkers. The other ones contains dice and cube.
	 */
	if (((cellID == HOME_THEM_LEFT ) && (direction > 0)) ||
	    ((cellID == HOME_THEM_RIGHT) && (direction < 0)) ||
	    ((cellID == HOME_US_LEFT   ) && (direction > 0)) ||
	    ((cellID == HOME_US_RIGHT  ) && (direction < 0))) {

		drawOverlappingCheckers(p, xo, yo, sf);

	} else {

		drawDiceAndCube(p, ((cellID == HOME_THEM_LEFT ||
				     cellID == HOME_THEM_RIGHT) ?
				    THEM : US), xo, yo, sf);

	}

	/*
	 * Finally draw the boundaries
	 */
	drawVertBorder(p, xo, yo, sf);
	KBgBoardCell::paintCell(p, xo, yo, sf);
}

/*
 * This function draws the content of the bar cells. Bars may contain
 * checkers and the cube. Please read the comments in the code on how
 * and why the checkers and (especially) the cube is printed.
 */
void KBgBoardBar::paintCell(TQPainter *p, int xo, int yo, double sf) const
{
	/*
	 * Put in the checkers.
	 */
	drawOverlappingCheckers(p, xo, yo, sf);

	/*
	 * Now comes a slightly tricky part: the cube belongs in the center
	 * of the board if nobody has doubled yet. In the way we do the board
	 * the center belongs to two(!) fields - both bars.
	 *
	 * If we are not printing on paper we use the fact that
	 * TQt will clip the drawing for us. So we print the upper
	 * half of the cube and the lower half on different cells.
	 *
	 * Since there is no such thing as clipping when we print
	 * on paper we can only print one cube. It turns out that
	 * the lower one is sufficiently centered.
	 */
	if (board->canDouble(US) &&
	    board->canDouble(THEM) &&
	    !(abs(xo)+abs(yo) > 0 && cellID == BAR_THEM)) {

		drawCube(p, cellID == BAR_THEM ? CUBE_UPPER :
			 CUBE_LOWER, xo, yo, sf);

	}

	/*
	 * Finally draw the boundaries
	 */
	drawVertBorder(p, xo, yo, sf);
       	KBgBoardCell::paintCell(p, xo, yo, sf);
}


/*
 * This function draws a cube on the painetr p. The cube will be drawn in
 * the coundaries given by cubeRect(...). The other parameters are like
 * in the other functions.
 */
void KBgBoardCell::drawCube(TQPainter *p, int who, int xo, int yo,
				    double sf) const
{
	TQRect r = cubeRect(who, true, sf);
	r.moveTopLeft(TQPoint(xo+r.left(), yo+r.top()));

	p->setBrush(black);
	p->setPen(black);
	p->drawRoundRect(r, 20, 20);

	r = cubeRect(who, false, sf);
	r.moveTopLeft(TQPoint(xo+r.left(), yo+r.top()));

	p->setBrush(white);
	p->setPen(white);
	p->drawRoundRect(r, 20, 20);

	p->setBrush(black);
	p->setPen(black);

	TQString cubeNum;
	int v = board->getCube();
	/*
	 * Ensure that the cube shows 64 initially
	 */
	if (v == 1) v = 64;
	cubeNum.setNum(v);

	/*
	 * Adjust the font size
	 */
	TQFont f = board->getFont();
	f.setPointSizeFloat(0.75*f.pointSizeFloat());
	p->setFont(f);
	p->drawText(r, AlignCenter, cubeNum);
}

/*
 * This function returns a boundary rectangle for the dice. It does so for both
 * dice (i is either 0 or 1). It can return big and small rectangles and everything
 * is scaled with a default value of 1.0. The scale parameter determines the the
 * size of the dice relative to the checker diameter.
 */
TQRect KBgBoardCell::diceRect(int i, bool big, double sf, double scale) const
{
	int d = int(scale*getCheckerDiameter());
	int l = (1+width())%2;
	int k = (big ? 0 : 1);
	return(TQRect(sf*(width()/2-d+k),
		     sf*(height()/2-2*d-3+2*i*(d+3)-1+k),
		     sf*(2*(d-k)+1-l),
		     sf*(2*(d-k)+1-l)));
}

/*
 * This function returns a bounding rectangle for the cube. This rectangle
 * is moved to the correct place and scaled correctly. The cube is slightly
 * smaller than the dice.
 */
TQRect KBgBoardCell::cubeRect(int who, bool big, double sf) const
{
	TQRect r = diceRect(0, big, sf, 0.40);

	int d = int(0.40*getCheckerDiameter());
	int h = r.height();
	int k = (big ? 1 : 0);

	switch (who) {
	case US:
		r.setTop(sf*(height() - 3*d) - k);
		break;
	case THEM:
		r.setTop(sf*d - k);
		break;
	case CUBE_UPPER:
		r.setTop(height()-d*sf - k);
		break;
	case CUBE_LOWER:
		r.setTop( -d*sf - k);
		break;
	default:
		return(TQRect(0,0,0,0));
	}
	r.setHeight(h);
	return r;
}

/*
 * This function draws the face value on a given dice painter.
 * If the painting of dice should be saved this is the place
 * to modify.
 */
void KBgBoardHome::drawDiceFace(TQPainter *p, int col, int num, int who,
					int xo, int yo, double sf) const
{
	p->setBrush(board->getCheckerColor(col));
	p->setPen(board->getCheckerColor(col));

	TQRect r = diceRect(num, false, sf);
	r.moveTopLeft(TQPoint(xo+r.left(), yo+r.top()));

	int cx  = r.width() /2;
	int cy  = r.height()/2;
	int cx2 = cx/2;
	int cy2 = cy/2;
	int cx7 = int(0.7*cx);
	int cy7 = int(0.7*cy);

	switch (board->getDice(who, num)) {
	case 5:
		p->drawEllipse(r.x()+cx-cx7  , r.y()+cy+cy7-1, 2, 2);
		p->drawEllipse(r.x()+cx+cx7-1, r.y()+cy-cy7  , 2, 2);
	case 3: // fall through
		p->drawEllipse(r.x()+cx-cx7  , r.y()+cy-cy7  , 2, 2);
		p->drawEllipse(r.x()+cx+cx7-1, r.y()+cy+cy7-1, 2, 2);
	case 1: // fall through
		p->drawEllipse(r.x()+cx      , r.y()+cy      , 2, 2);
		break;
	case 4:
		p->drawEllipse(r.x()+cx-cx2,   r.y()+cy+cy2-1, 2, 2);
		p->drawEllipse(r.x()+cx+cx2-1, r.y()+cy-cy2,   2, 2);
	case 2:  // fall through
		p->drawEllipse(r.x()+cx-cx2,   r.y()+cy-cy2,   2, 2);
		p->drawEllipse(r.x()+cx+cx2-1, r.y()+cy+cy2-1, 2, 2);
		break;
	case 6:
		p->drawEllipse(r.x()+cx-cx2,   r.y()+cy-cy7, 2, 2);
		p->drawEllipse(r.x()+cx-cx2,   r.y()+cy,     2, 2);
		p->drawEllipse(r.x()+cx-cx2,   r.y()+cy+cy7, 2, 2);
		p->drawEllipse(r.x()+cx+cx2-1, r.y()+cy-cy7, 2, 2);
		p->drawEllipse(r.x()+cx+cx2-1, r.y()+cy,     2, 2);
		p->drawEllipse(r.x()+cx+cx2-1, r.y()+cy+cy7, 2, 2);
		break;
	default: // nothing
		break;
	}
}

/*
 * This function draws a nice little square on the painter p.
 * The square is suited to contain a a face value as printed
 * by drawDiceFace(...).
 */
void KBgBoardHome::drawDiceFrame(TQPainter *p, int col, int num,
					 int xo, int yo, bool big, double sf) const
{
	p->setBrush(board->getCheckerColor(col));
	p->setPen(board->getCheckerColor(col));
	TQRect r = diceRect(num, big, sf);
	r.moveTopLeft(TQPoint(xo+r.left(), yo+r.top()));
	p->drawRoundRect(r, 20, 20);
}

/*
 * If the event is left button we just store that. If the event is right
 * button we ask the board to possibly display the popup menu.
 */
void KBgBoardCell::mousePressEvent(TQMouseEvent *e)
{
	if (e->button() == Qt::RightButton)
		board->showContextMenu();
	else
		mouseButton = e->button();
}

/*
 * This function sets the short move mode of the board.
 */
void KBgBoard::setShortMoveMode(int m)
{
	switch (m) {
	case SHORT_MOVE_NONE:
	case SHORT_MOVE_SINGLE:
		shortMoveMode = m;
		break;
	case SHORT_MOVE_DOUBLE:
	default:
		shortMoveMode = SHORT_MOVE_DOUBLE;
	}
}

/*
 * This function returns the currently selected short move mode.
 */
int KBgBoard::getShortMoveMode()
{
	return shortMoveMode;
}

/*
 * This function checks if (a) the mouse event was a left button,
 * (b) the parameter m equals the currently selected short move
 * mode and (c) t a short move from this field is possible. If all
 * tests are ok, the shortest possible move away from here is
 * made.
 */
void KBgBoardCell::checkAndMakeShortMove(TQMouseEvent *e, int m)
{
	if ((e->button() == Qt::LeftButton) &&
	    (board->getShortMoveMode() == m) &&
	    (dragPossible()) &&
	    (!board->getEditMode()))
		makeShortMove();
}

/*
 * This functions reacts on a double click.
 */
void KBgBoardCell::mouseDoubleClickEvent(TQMouseEvent *e)
{
	checkAndMakeShortMove(e, SHORT_MOVE_DOUBLE);
}

/*
 * This function reacts on a double click. Note that the bar knows
 * about two different double clicks: double the cube and make a
 * short move.
 */
void KBgBoardBar::mouseDoubleClickEvent(TQMouseEvent *e)
{
	TQRect r = cubeRect(cellID == BAR_THEM ? CUBE_UPPER : CUBE_LOWER, true);
	if (board->canDouble(US) &&
	    board->canDouble(THEM) && r.contains(e->pos())) {
		if (board->getEditMode())
			board->queryCube();
		else
			board->getDoubleCube(US);
		return;
	}
	checkAndMakeShortMove(e, SHORT_MOVE_DOUBLE);
}

/*
 * This is the destructor of the backgammon board. It frees
 * all resources previously allocated.
 */
KBgBoard::~KBgBoard()
{
	restoreCursor();
}

/*
 * This function draws dice and cube on the painter for a home cell.
 * who may be either US or THEM.
 */
void KBgBoardHome::drawDiceAndCube(TQPainter *p, int who, int xo, int yo,
					   double sf) const
{
 	int col = ((who == THEM) ? -color : color);

	/*
	 * draw the empty squares and then put the face value in there
	 */
	for (int i = 0; i < 2; i++) {
		drawDiceFrame(p,-col, i, xo, yo,  true, sf);
		drawDiceFrame(p, col, i, xo, yo, false, sf);
		drawDiceFace(p,-col, i, who, xo, yo, sf);
	}
	/*
	 * if necessary draw the cube
	 */
	if (board->canDouble(who) &&
	    !(board->canDouble(US) && board->canDouble(THEM)))
		drawCube(p, who, xo, yo, sf);
}

/*
 * This function determines whether a drag off this home is possible.
 * This is only possible if there are checkers and edit mode is on.
 */
bool KBgBoardHome::dragPossible() const
{
	if (board->getEditMode())
		return (pcs != 0);
	return false;
}

/*
 * This function determines whether a drag off this bar is possible.
 * It checks in the follwoing order: (1) owner of this bar is the one
 * whose turn it is now, (2) does the board allow moving right now is
 * it in read-only mode?
 */
bool KBgBoardBar::dragPossible() const
{
	if (board->getEditMode())
		return (pcs != 0);

	switch(board->getTurn()) {
	case US:
		if (pcs*color <= 0) return false;
		break;
	case THEM:
		if (pcs*color >= 0) return false;
		break;
	default:
		return false;
	}
	return board->movingAllowed();
}

/*
 * This function checks whether a checker can be moved away from
 * this field. It first checks whether the owner of this field is
 * the one whose turn to move it it, then it is checked whether
 * the players bar is empty and finally it is checked if the board
 * is in read-only mode.
 */
bool KBgBoardField::dragPossible() const
{
	if (board->getEditMode())
		return (pcs != 0);

	switch(board->getTurn()) {
	case US:
		if (pcs*color <= 0) return false;
		break;
	case THEM:
		if (pcs*color >= 0) return false;
		break;
	default:
		return false;
	}
	if (board->getOnBar(board->getTurn()))
		return false;
	return board->movingAllowed();
}

/*
 * This function returns the current read-write flag of the board.
 * If this returns true the board doesn't accept user input. If
 * allowmoving is true we will accept user events.
 */
bool KBgBoard::movingAllowed() const
{
	return allowmoving;
}

/*
 * This function sets the read-write or read-only flag of the
 * board. See also movingAllowed().
 */
void KBgBoard::allowMoving(const bool fl)
{
	allowmoving = fl;
}

/*
 * This function returns the current pip count of the player w.
 */
int KBgBoard::getPipCount(const int& w) const
{
	if (!computePipCount || (w != US && w != THEM))
		return -1;
	int pip = 25*abs(onbar[w]);
	int d = ((w == US) ? 1 : -1);
	for (int i = 1; i < 25; i++) {
		if (d*board[i]*color > 0)
			pip += ((d*direction < 0) ?
				i*abs(board[i]) :
				(25 - i)*abs(board[i]));
	}
	return pip;
}

/*
 * This function handles double clicks on homes. It will ignore
 * double clicks on the real home and only handle the ones on the
 * "other" home - the one with the dice. It will propagate the event
 * only if the the click happened within the boundaries of a
 * dice or the cube.
 */
void KBgBoardHome::mouseDoubleClickEvent(TQMouseEvent * e)
{
	if (e->button() != Qt::LeftButton)
		return;
	/*
	 * Check whether this is the bookkeeping home...
	 */
	if ((cellID == HOME_US_LEFT    && direction < 0) ||
	    (cellID == HOME_US_RIGHT   && direction > 0) ||
	    (cellID == HOME_THEM_LEFT  && direction < 0) ||
	    (cellID == HOME_THEM_RIGHT && direction > 0)) {

		int w = ((cellID == HOME_US_LEFT || cellID == HOME_US_RIGHT) ?
			 US : THEM);
		for (int i = 0; i < 2; ++i) {
			TQRect r = diceRect(i, true);
			if (r.contains(e->pos())) {
				if (board->getEditMode()) {

					KBgBoardQDice *dlg = new KBgBoardQDice();
					if (dlg->exec()) {
						KBgStatus *st = new KBgStatus();
						board->getState(st);
						st->setDice(w, 0, dlg->getDice(0));
						st->setDice(w, 1, dlg->getDice(1));
						st->setDice(((w == US) ? THEM : US), 0, 0);
						st->setDice(((w == US) ? THEM : US), 1, 0);
						board->setState(*st); // JENS
						delete st;
					}
					delete dlg;

				} else
					board->getRollDice(w);
				return;
			}
		}
		if (board->canDouble(w) &&
		    !(board->canDouble(US) && board->canDouble(THEM))) {
			TQRect r = cubeRect(w, true);
			if (r.contains(e->pos()))
				if (board->getEditMode())
					board->queryCube();
				else
					board->getDoubleCube(w);
		}
	}
}

/*
 * This function determines if a checker can be dropped on this field.
 * It checks whether the field is already owned, empty or contains
 * only one opponents piece. Then the dice are checked.
 */
bool KBgBoardField::dropPossible(int fromCellID, int newColor)
{
	if ((newColor*pcs > 0) || (pcs == 0) || (abs(pcs) == 1))
		// editMode is checked in diceAllowMove(...)
		return board->diceAllowMove(fromCellID, cellID);
	return false;
}

/*
 * This function determines if a checker can be dropped on this field.
 * Drops on the bar are never possible.
 */
bool KBgBoardBar::dropPossible(int fromCellID, int newColor)
{
	if (!board->getEditMode())
		return false;

	if (newColor*pcs > 0)
		return true;
	if ((cellID == BAR_US) && (board->getTurn() == US))
		return true;
	if ((cellID == BAR_THEM) && (board->getTurn() == THEM))
		return true;

	return (fromCellID == -12345); // always false
}

/*
 * This function checks if the current player can move a checker off.
 * Check if we can move a piece off. This obviously only works if there
 * are no pieces on the bar and all remaining pieces are in the home
 * board. This does not check the dice and it doesn't work for multiple
 * moves that start outside the home.
 */
bool KBgBoard::moveOffPossible() const
{
	if (getEditMode())
		return true;

	int w = getTurn();
	int d = ((w == THEM) ? -1 : 1);
	if (onbar[w] == 0 && d*direction > 0) {
		for (int i = 1; i < 19; ++i) {
			if (d*color*board[i] > 0) return false;
		}
		return true;

	} else if (onbar[w] == 0 && d*direction < 0) {
		for (int i = 24; i > 6; --i) {
			if (d*color*board[i] > 0) return false;
		}
		return true;
	}
	return false;
}

/*
 * This function tries to determine the field cell under the point p.
 * The point needs to be in board coordinates and the function returns
 * a pointer to the cell or NULL if there is no cell under the point.
 */

KBgBoardCell* KBgBoard::getCellByPos(const TQPoint& p) const
{
       	for (int i = 0; i < 30; ++i) {
		if (TQT_TQRECT_OBJECT(cells[i]->rect()).contains(cells[i]->mapFromParent(p)))
			return cells[i];
	}
	return NULL;
}

/*
 * This function takes a board number (1 to 24 and 0 or 25 depending on the
 * direction) or a cell ID and returns a pointer to the corresponding cell.
 * If the cell cannot be found it returns NULL.
 */
KBgBoardCell* KBgBoard::getCell(int num)
{
	switch (num) {
	case BAR_US:
		return (KBgBoardCell *)cells[22];
	case BAR_THEM:
		return (KBgBoardCell *)cells[ 7];
	case HOME_THEM_LEFT:
		return (KBgBoardCell *)cells[ 0];
	case HOME_THEM_RIGHT:
		return (KBgBoardCell *)cells[14];
	case HOME_US_LEFT:
		return (KBgBoardCell *)cells[15];
	case HOME_US_RIGHT:
		return (KBgBoardCell *)cells[29];
	default:
		int cell;
		if (num < 0 || num > 25)
			return NULL;
		else if (num < 7)
			cell = ((direction > 0) ? num      : 29 - num);
		else if (num < 13)
			cell = ((direction > 0) ? num + 1  : 28 - num);
		else if (num < 19)
			cell = ((direction > 0) ? 41 - num : num - 12);
		else
			cell = ((direction > 0) ? 40 - num : num - 11);
		return (KBgBoardCell *)cells[cell];
	}
}

/*
 * This function translates a field ID to the field number or just
 * returns the ID for bars and homes.
 */
int KBgBoard::IDtoNum(const int ID) const
{
	if (ID > 0 && ID < 25) {
		if (ID < 13)
			return ((direction > 0) ?      ID : 12 + ID);
		else
			return ((direction > 0) ? 37 - ID : 25 - ID);
	}
	return  ID;
}

/*
 * This function takes a checker from the cell if possible. It also
 * updates the bookkeeping of the board and redraws itself.
 */
bool KBgBoardCell::getPiece()
{
	if (pcs != 0) {
		((pcs > 0) ? --pcs : ++pcs);
		stateChanged = true;
		refresh();
		board->updateField(getNumber(), pcs);
		return true;
	}
	return false;
}

/*
 * This function stores the current cursor and replaces it with the
 * supplied one c.
 */
void KBgBoard::replaceCursor(const TQCursor& c)
{
	if (savedCursor)
		delete savedCursor;
	savedCursor = new TQCursor(cursor());
	setCursor(c);
}

/*
 * This function restores the previously set cursor to the stored one.
 */
void KBgBoard::restoreCursor()
{
	if (savedCursor) {
		setCursor(*savedCursor);
		delete savedCursor;
		savedCursor = NULL;
	}
}

/*
 * This function puts a checker of color newColor on the cell. It handles
 * all necessary updates including the kicking. It will however not properly
 * handle illegal moves!
 */
void KBgBoardCell::putPiece(int newColor)
{
	if (newColor*pcs > 0) {
		pcs > 0 ? ++pcs : --pcs;
	} else if (pcs == 0) {
		newColor > 0 ? pcs = 1 : pcs = -1;
	} else if (newColor*pcs < 0) {
		board->kickedPiece();
		newColor > 0 ? pcs = 1 : pcs = -1;
	}
	stateChanged = true;
	refresh();
	board->updateField(getNumber(), pcs);
	board->sendMove();
}

/*
 * This function handles mouse release events. It is important to know that
 * the cell where the first mousePressEvent occurred receives the release event.
 * The release event marks the end of a drag or a single click short move.
 */
void KBgBoardCell::mouseReleaseEvent(TQMouseEvent *e)
{
 	if (dragInProgress) {

		KBgBoardCell *dest = board->getCellByPos
			(mapToParent(e->pos()));
		board->restoreCursor();
		if ((dest != NULL) && (dest->dropPossible(cellID, ((board->getTurn() == US) ?
								   color : -color)))) {
			if (!board->getEditMode())
				board->makeMove(getNumber(), dest->getNumber());
			dest->putPiece(((board->getTurn() == US) ? color : -color));
		} else {
			putPiece(((board->getTurn() == US) ? color : -color));
		}
		dragInProgress = false;

 	} else {

		checkAndMakeShortMove(e, SHORT_MOVE_SINGLE);

 	}
}

/*
 * This is the destructor of the home cells. It doesn't do anything.
 */
KBgBoardHome::~KBgBoardHome()
{
	//  nothing
}

/*
 * This is the destructor of the bar cells. It doesn't do anything.
 */
KBgBoardBar::~KBgBoardBar()
{
	// nothing
}

/*
 * This is the destructor of regular fields. It doesn't do anything.
 */
KBgBoardField::~KBgBoardField()
{
	// nothing
}

/*
 * This is the constructor of the bars. It calls the base class' constructor
 * and defines the TQWhatsThis string.
 */
KBgBoardBar::KBgBoardBar(TQWidget * parent, int numID)
	: KBgBoardCell(parent, numID)
{
	TQWhatsThis::add(this, i18n("This is the bar of the backgammon board.\n\n"
				   "Checkers that have been kicked from the board are put "
				   "on the bar and remain there until they can be put back "
				   "on the board. Checkers can be moved by dragging them to "
				   "their destination or by using the 'short move' feature.\n\n"
				   "If the cube hasn't been doubled yet and if it can be used, "
				   "its face shows 64 and if the cube can be doubled, double "
				   "clicking it will do so."));
}

/*
 * This is the constructor of regular fields. It calls the base class' constructor
 * and defines the TQWhatsThis string.
 */
KBgBoardField::KBgBoardField(TQWidget * parent, int numID)
	: KBgBoardCell(parent, numID)
{
	TQWhatsThis::add(this, i18n("This is a regular field of the backgammon board.\n\n"
				   "Checkers can be placed on this field and if the current state "
				   "of the game and the dice permit this, they can be moved by "
				   "dragging them to their destination or by using the 'short "
				   "move' feature."));
}

/*
 * This is the constructor of the homes. It calls the base class' constructor
 * and defines the TQWhatsThis string.
 */
KBgBoardHome::KBgBoardHome(TQWidget * parent, int numID)
	: KBgBoardCell(parent, numID)
{
	TQWhatsThis::add(this, i18n("This part of the backgammon board is the home.\n\n"
				   "Depending on the direction of the game, one of the homes "
				   "contains the dice and the other one contains checkers that "
				   "have been moved off the board. Checkers can never be moved "
				   "away from the home. If this home contains the dice and the "
				   "current state of the game permits this, double clicking on "
				   "the dice will roll them. Moreover, the cube might be placed "
				   "on the home bar and if it can be doubled, double clicking it "
				   "will do so."));
	savedDice[0] = -1;
	savedDice[1] = -1;
}

/*
 * This function updates the number of checkers on the bar and also updates
 * the cell if the cube has changed (this is more often than necessary...)
 */
void KBgBoardBar::cellUpdate(const int p, const bool cubechanged)
{
	stateChanged = (cubechanged || colorChanged);
	if (pcs != p) {
		stateChanged = true;
		pcs = p;
	}
}

/*
 * This function updates the number of checkers on the field.
 */
void KBgBoardField::cellUpdate(const int p, const bool cubechanged)
{
	if (p != pcs) {
		pcs = p;
		stateChanged = true;
	}
	bool f = stateChanged; // useless, avoids compiler warning
	stateChanged = cubechanged;
	stateChanged = (f || colorChanged);
}

/*
 * This function updates the number of checkers on the home if it
 * actually contains checkers. It will also redraw if the cube or dice
 * have changed.
 */
void KBgBoardHome::cellUpdate(const int p, const bool cubechanged)
{
	if ((cellID == HOME_THEM_LEFT  && direction > 0) ||
	    (cellID == HOME_THEM_RIGHT && direction < 0) ||
	    (cellID == HOME_US_LEFT    && direction > 0) ||
	    (cellID == HOME_US_RIGHT   && direction < 0)) {

		if (pcs != p) {
			pcs = p;
			stateChanged = true;
		}

	} else {

		int who = ((cellID == HOME_THEM_LEFT || cellID == HOME_THEM_RIGHT) ? THEM : US);

		stateChanged = ((savedDice[0] != board->getDice(who, 0)) ||
				(savedDice[1] != board->getDice(who, 1)));

		savedDice[0] = board->getDice(who, 0);
		savedDice[1] = board->getDice(who, 1);

		stateChanged = (stateChanged || cubechanged || colorChanged || directionChanged);
	}
}

/*
 * This function returns whose players turn it is.
 */
int KBgBoard::getTurn() const
{
	if (getEditMode())
		return ((storedTurn*color > 0) ? US : THEM);

	if (getDice(US  , 0) != 0 && getDice(US  , 1) != 0)
		return   US;
	if (getDice(THEM, 0) != 0 && getDice(THEM, 1) != 0)
		return THEM;
	return -1;
}

/*
 * This is the constructor of the basic cells. It initializes the cell
 * to a sane state and connects a signal to the board.
 */
KBgBoardCell::KBgBoardCell(TQWidget * parent, int numID)
	: TQLabel(parent)
{
	board = (KBgBoard *)parent;

	direction        = +1;
	color            = -1;
	pcs              =  0;
	cellID           = numID;
	stateChanged     = false;
	colorChanged     = false;
	directionChanged = false;
	mouseButton      = Qt::NoButton;
	dragInProgress   = false;

	connect(parent, TQT_SIGNAL(finishedUpdate()), this, TQT_SLOT(refresh()));
}

/*
 * This is the destructor of the cells. It doesn't do anything.
 */
KBgBoardCell::~KBgBoardCell()
{
	// nothing
}

/*
 * This function returns the color of the checkers on this cell.
 */
int KBgBoardCell::getCellColor()
{
	return ((pcs < 0) ? -1 : +1);
}

/*
 * This function updates the basic board settings color and direction
 * and signals a redraw if necessary.
 */
void KBgBoardCell::statusUpdate(int dir, int col)
{
	if (direction != dir || color != col) {
		colorChanged     = (color != col);
		directionChanged = (direction != dir);
		color        = col;
		direction    = dir;
		stateChanged = true;
	}
}

/*
 * This function refreshes the content of the cell if necessary.
 */
void KBgBoardCell::refresh()
{
	if (stateChanged) {
		update();
		stateChanged     = false;
		colorChanged     = false;
		directionChanged = false;
	}
}

/*
 * This function returns the board number of this cell as given by the board.
 */
int KBgBoardCell::getNumber() const
{
	return board->IDtoNum(cellID);
}

/*
 * This function returns the number of checkers of player who on the bar.
 */
int KBgBoard::getOnBar(int who) const
{
	return ((who == US || who == THEM) ? onbar[who] : 0);
}

/*
 * This function returns the face value of the n-th dice of player w
 */
int KBgBoard::getDice( int w, int n ) const
{
	return (((w == US || w == THEM) && (n == 0 || n == 1)) ? dice[w][n] : 0);
}

/*
 * This function returns the current cube value.
 */
int KBgBoard::getCube() const
{
	return cube;
}

/*
 * This function updates the stored number of pieces on field f to v.
 */
void KBgBoard::updateField(int f, int v)
{
	switch (f) {
	case BAR_US:
	case BAR_THEM:
		onbar[((f == BAR_US) ? US : THEM)] = v;
		break;
	case HOME_US_RIGHT:
	case HOME_US_LEFT:
		onhome[US] = v;
		break;
	case HOME_THEM_RIGHT:
	case HOME_THEM_LEFT:
		onhome[THEM] = v;
		break;
	default:
		if (0 < f && f < 25)
			board[f] = v;
		break;
	}
}

/*
 * This function displays the context menu our parent may have given us
 */
void KBgBoard::showContextMenu()
{
	if (contextMenu) contextMenu->popup(TQCursor::pos());
}

/*
 * This function determines if the player who can double.
 */
bool KBgBoard::canDouble(int who) const
{
	return ((who == US || who == THEM) ? maydouble[who] : false);
}

/*
 * This function is a simple utility for makeMove. It takes care
 * of all the bookeeeping needed for a move.
 */
int KBgBoard::makeMoveHelper(int si, int sf, int delta)
{
	moveHistory.append(new KBgBoardMove(si, sf, abs(delta)));
	--possMoves[abs(delta)];
	return delta;
}

/*
 * This function makes a move from src to dest for the current player.
 * It can handle illegal moves but the move should have been checked.
 */
void KBgBoard::makeMove(int src, int dest)
{
	int m[4];
	int l;

	int d = direction*((getTurn() == US) ? +1 : -1);

	if (src == BAR_US || src == BAR_THEM ) {

		int start = ((d > 0) ? 0 : 25);
		l = checkMultiMove(start, dest, m);
		moveHistory.append(new KBgBoardMove(src, start+d*m[0], m[0]));
		src = start+d*m[0];
		--possMoves[m[0]];
		for (int i = 1; i < l; i++)
			src += makeMoveHelper(src, src+d*m[i], d*m[i]);

	} else if (0 < src && src < 25 && 0 < dest && dest < 25) {

		l = checkMultiMove(src, dest, m);
		for (int i = 0; i < l; i++)
			src += makeMoveHelper(src, src+d*m[i], d*m[i]);

	} else {

		int s = src;
		int final = ((d > 0) ? 25 : 0);
		while (((l = checkMultiMove(s, final, m)) == 0) && (0 < s && s < 25))
			s -= d;

		for (int i = 0; i < l-1; i++)
			src += makeMoveHelper(src, src+d*m[i], d*m[i]);

		moveHistory.append(new KBgBoardMove(src, dest, ((d > 0) ? 25 - src : src)));
		--possMoves[m[l-1]];

	}
}

/*
 * This function checks if there is any possibility (based on the dice)
 * to move from src to dest. It takes the ownership of the intermediate
 * fields into account. The function returns the number of steps necessary
 * to perform the move (or 0 if the move is not possible) and the actual
 * dice values used for the steps are returned in the array m.
 *
 * The values src and dest are expected to be in board coordinates and the
 * homes and/or bars should already be mapped to the corresponding values
 * 0 and 25 (based onb direction and whose turn it is).
 */
int KBgBoard::checkMultiMove(int src, int dest, int m[4])
{
	m[0] = 0; m[1] = 0; m[2] = 0; m[3] = 0;

	int mcolor = ((getTurn() == US) ? color : -color);
	int d      = ((src > dest) ? -1 : 1);

	/*
	 * These are very easy special cases: move length is 0 or
	 * player cannot move to the destination field.
	 */
	if ((src == dest) || (mcolor*board[dest] < -1)) return 0;

	int diceToUse[4];
	int dice = 0;
	/*
	 * Get the available step sizes for this move
	 */
	for (int i = 1; i < 7; i++) {
		for (int j = 0; j < possMoves[i]; j++) {
			diceToUse[dice++] = i;
			/*
			 * If this happens there is something wrong
			 */
			if (dice > 4) return 0;
		}
	}
	/*
	 * And start all possible combination of dices.
	 */
	switch (dice) {
	case 4:	if (src+4*d*diceToUse[0] == dest) {
		if ((mcolor*board[src+1*d*diceToUse[0]] >=  0) &&
		    (mcolor*board[src+2*d*diceToUse[0]] >=  0) &&
		    (mcolor*board[src+3*d*diceToUse[0]] >=  0)) {
			m[0] = m[1] = m[2] = m[3] = diceToUse[0];
			return 4;
		}
	}
	case 3:	if (src+3*d*diceToUse[0] == dest) {
		if ((mcolor*board[src+1*d*diceToUse[0]] >=  0) &&
		    (mcolor*board[src+2*d*diceToUse[0]] >=  0)) {
			m[0] = m[1] = m[2] = diceToUse[0];
			return 3;
		}
	}
	case 2: if ((src+d*(diceToUse[0]+diceToUse[1])) == dest) {
		if (mcolor*board[src+d*diceToUse[0]] >= 0) {
			m[0] = diceToUse[0];
			m[1] = diceToUse[1];
			return 2;
		}
		if (mcolor*board[src+d*diceToUse[1]] >= 0) {
			m[0] = diceToUse[1];
			m[1] = diceToUse[0];
			return 2;
		}
	}
	case 1:	if (abs(src-dest) < 7 && possMoves[abs(src-dest)] > 0) {
		m[0] = abs(src-dest);
		return 1;
	}
	default: return 0;
	}
}

/*
 * This function determines if a checker can be dropped on this home field.
 * It first checks whether this is the proper of the four home fields (belongs
 * to the player and not the one with dice and cube). Then we check if the move
 * itself is possible.
 */
bool KBgBoardHome::dropPossible(int fromCellID, int newColor)
{
	if ((cellID==HOME_US_LEFT && board->getTurn() == US   && direction > 0) ||
	    (cellID==HOME_THEM_LEFT && board->getTurn() == THEM && direction > 0) ||
	    (cellID==HOME_US_RIGHT && board->getTurn() == US   && direction < 0) ||
	    (cellID==HOME_THEM_RIGHT && board->getTurn() == THEM && direction < 0))
		return (board->moveOffPossible() &&
			board->diceAllowMove(fromCellID, cellID));
	return (newColor == -12345); // always false
}

/*
 * This function is a simple boolean interface to checkMultiMove.
 * It takes car of directions and bar/home mappings. If necessary
 * it also handles the case of bearing off.
 */
bool KBgBoard::diceAllowMove(int src, int dest)
{
	int m[4];
	int w = getTurn();
	int k = ((w == US) ? +1 : -1);
	int t = ((k*direction > 0) ? 25 : 0);
	int d = ((k*direction > 0) ? +1 : -1);

	if (getEditMode())
		return true;

	if ((w == US && src == BAR_US) || (w == THEM && src == BAR_THEM)) {
		/*
		 * Move comes from a bar. Hence it has to end on a field
		 * and not on bars or homes. If there are checkers left
		 * on the bar we don't accept multi moves.
		 */
		if (0 < dest && dest < 25) {
			int r = checkMultiMove((k*direction > 0) ? 0 : 25,
					       IDtoNum(dest), m);
			return((abs(onbar[w]) == 0) ? (r != 0) : (r == 1));
		} else {
			return false;
		}
	} else if (0 < dest && dest < 25 && 0 < src && src < 25) {
		/*
		 * Move from a field to a field
		 */
		if (direction*k*(IDtoNum(dest)-IDtoNum(src)) > 0) {
			return(checkMultiMove(IDtoNum(src), IDtoNum(dest), m));
		} else {
			return false;
		}
	} else {
		/*
		 * Move from a field on the home. First we try exact dice.
		 */
		if (checkMultiMove(IDtoNum(src), t, m) > 0) return true;

 		/*
  		 * Then maybe we could bear the checker off ?
  		 */
		int i = IDtoNum(src);
 		while (0 < i && i < 25) {
			i -= d;
 			if (k*color*board[i] > 0) return false;
 		}

		/*
		 * Indeed we are bearing off. So find the highest dice and use it.
		 * Start from all the way back to catch double 6 from the start.
		 */
		int j = 24;
		while (checkMultiMove(t-d*j, t, m) == 0 && j > 0) {--j;}
		return (j >= t-d*IDtoNum(src));
	}
	return false;
}

/*
 * This is the most important of all members of the board class. It takes
 * a single board status object and initializes the internal status.
 */
void KBgBoard::setState(const KBgStatus &st)
{
	color     = st.color();
	direction = st.direction();

	cubechanged = (cube != abs(st.cube()));
	cube        = abs(st.cube());
	maydouble[US  ] = (st.cube(US  ) > 0);
	maydouble[THEM] = (st.cube(THEM) > 0);

	for (int i = 0; i < 30; i++)
		cells[i]->statusUpdate(direction, color);

	for (int i = 1; i < 25; ++i)
		board[i] = st.board(i);

	onbar[US  ] = st.bar(US  );
	onbar[THEM] = st.bar(THEM);

	onhome[US]   = st.home(US  );
	onhome[THEM] = st.home(THEM);

	dice[US  ][0]    = st.dice(US  , 0);
	dice[US  ][1]    = st.dice(US  , 1);
	dice[THEM][0]    = st.dice(THEM, 0);
	dice[THEM][1]    = st.dice(THEM, 1);

	for (int i = 0; i < 7; ++i)
		possMoves[i] = 0;

	int w = getTurn();
	if (getEditMode())
		w = ((dice[US][0] && dice[US][1]) ? US : THEM);

	if (w == US || w == THEM) {
		++possMoves[dice[w][0]];
		++possMoves[dice[w][1]];
		if (dice[w][0] == dice[w][1])
			possMoves[dice[w][0]] *= 2;
	}

	board[ 0] = 0;
	board[25] = 0;
	for (int i=1; i<25; ++i)
		(getCell(i))->cellUpdate(board[i]);

	(getCell(BAR_US  ))->cellUpdate(st.bar(US  ), cubechanged);
	(getCell(BAR_THEM))->cellUpdate(st.bar(THEM), cubechanged);

	(getCell(HOME_US_LEFT   ))->cellUpdate(st.home(US  ), cubechanged);
	(getCell(HOME_US_RIGHT  ))->cellUpdate(st.home(US  ), cubechanged);
	(getCell(HOME_THEM_LEFT ))->cellUpdate(st.home(THEM), cubechanged);
	(getCell(HOME_THEM_RIGHT))->cellUpdate(st.home(THEM), cubechanged);

	moveHistory.clear();
	redoHistory.clear();

	emit finishedUpdate();
}

/*
 * This function starts a drag from this cell if possible. It asks the board to
 * change the mouse pointer and takes a checker away from this cell.
 */
void KBgBoardCell::mouseMoveEvent(TQMouseEvent *)
{
	if ((mouseButton == Qt::LeftButton) && dragPossible()) {
		dragInProgress = true;
		TQRect cr(0, 0, 1+getCheckerDiameter(), 1+getCheckerDiameter());
		cr.moveBottomLeft(rect().bottomLeft());
		TQPixmap pix(cr.size());
		TQPainter tmp;
		pix.fill(this, cr.topLeft());
		tmp.begin(&pix);
		board->drawSimpleChecker(&tmp, 0, 0, pcs, getCheckerDiameter());
		tmp.end();
		pix.setMask(pix.createHeuristicMask());
		TQBitmap mask = *(pix.mask());
		TQBitmap newCursor;
		newCursor = pix;
		board->replaceCursor(TQCursor(newCursor, mask));
		if (board->getEditMode())
			board->storeTurn(pcs);
		getPiece();
	}
	mouseButton = Qt::NoButton;
}

/*
 * This function draws a checker on the painter p. It is painted
 * in the ractangle with the upper left corner (x,y) and has a
 * maximum diameter of diam. This checker has only two colors and
 * as such it is suited for the mouse cursor and printing.
 */
void KBgBoard::drawSimpleChecker(TQPainter *p, int x, int y, int pcs,
					 int diam) const
{
	p->setBrush(getCheckerColor(pcs));
	p->setPen(getCheckerColor(pcs));
	p->drawEllipse(x+1, y+0, diam-0, diam-0);
	p->setBrush(getCheckerColor(-pcs));
	p->setPen(getCheckerColor(-pcs));
	p->drawEllipse(x+2, y+1, diam-2, diam-2);
	p->setBrush(getCheckerColor(pcs));
	p->setPen(getCheckerColor(pcs));
	p->drawEllipse(x+3, y+2, diam-4, diam-4);
}

/*
 * This function draws an anti-aliased checker on the painter p. It
 * is painted in the ractangle with the upper left corner (x,y) and
 * has a diameter of diam. col indicates the color of the cell this
 * checker is painted on. Special values for col are 0 and 100 that
 * indicate that the checker is stacked (bars and homes) or stacked
 * on a field respectively. upper indicates whether the checker is
 * in the upper half of the board or not.
 */
void KBgBoard::drawChecker(TQPainter *p, int x, int y, int pcs, int diam,
				   int col, bool upper) const
{
	drawCircle(p, x,   y,   pcs, diam  , col, upper, true );
	drawCircle(p, x+1, y+1,-pcs, diam-2, col, upper, false);
	drawCircle(p, x+2, y+2, pcs, diam-4, col, upper, false);
}

/*
 * This function draws checkers on the painter *p. They overlap so that
 * up to fifteen checkers fit on the cell. This is used by homes and
 * bars.
 */
void KBgBoardCell::drawOverlappingCheckers(TQPainter *p, int xo, int yo,
						   double sf) const
{
	int d = getCheckerDiameter();
	bool upper =
	  cellID == HOME_THEM_LEFT  ||
	  cellID == HOME_THEM_RIGHT ||
	  cellID == BAR_THEM;
	double xp = xo + sf*((width()-d-1)/2);
	double ra = sf*d;
	for (int i = 0; i < abs(pcs); ++i) {
		double yp = yo + (upper ? 1+i*sf*height()/25.0 :
				  sf*(height()-d-i*height()/25.0));
		board->drawChecker(p, xp, yp, pcs, ra, 0, upper);
	}
}

/*
 * This function paints the content of a regular cell on the painter p.
 * It does so by first drawing a triangle (depending on whether we draw
 * on the screen or not this will be antialiased). Then on top of that
 * we draw the field number in inverse color. Finally we draw all the
 * checkers in such a way that always five are in one level and the next
 * level is slightly shifted.
 */
void KBgBoardField::paintCell(TQPainter *p, int xo, int yo, double sf) const
{
	TQColor color, alphaColor, background = backgroundColor();
	bool printing = abs(xo)+abs(yo) > 0;

	if (printing) {
		/*
		 * This is the code for black and white printing on
		 * paper. This justs draws a triangle and surrounds
		 * it by a black triangle. Easy but works.
		 */
		TQPointArray pa(3);

		color = (getNumber()%2 ? white : black);

		if (cellID < 13) {
			pa.setPoint( 0, xo               , yo                  );
			pa.setPoint( 1, xo + sf*width()/2, yo + 0.9*sf*height());
			pa.setPoint( 2, xo + sf*width()  , yo                  );
		} else {
			pa.setPoint( 0, xo               , yo + sf*(height()-1));
			pa.setPoint( 1, xo + sf*width()/2, yo + 0.1*sf*height());
			pa.setPoint( 2, xo + sf*width()  , yo + sf*(height()-1));
		}

		p->setBrush(color);
		p->setPen(color);
		p->drawPolygon(pa);

		p->setBrush(black);
		p->setPen(black);
		p->drawPolyline(pa);

	} else {
		/*
		 * This is the code for antialiased triangles. This code has
		 * been written by Bo Thorsen.
		 */
		color = board->getCheckerColor(getNumber()%2-1);

		int topX, topY, bottomX1, bottomX2, bottomY, incrY;
		topX = xo + (int)(sf*width()/2.0);
		bottomX1 = xo;
		bottomX2 = xo + (int)(sf*width());
		if (cellID < 13) {
			topY = yo + (int)(0.9*sf*height());
			bottomY = yo;
			incrY = 1;
		} else {
			topY = yo + (int)(0.1*sf*height());
			bottomY = yo + (int)(sf*height());
			incrY = -1;
		}

		float x1 = bottomX1, x2 = bottomX2;
		float dx1 = (float)(topX-bottomX1) / (topY-bottomY);
		float dx2 = (float)(topX-bottomX2) / (topY-bottomY);
		if (dx1 < 0) dx1 = -dx1;
		if (dx2 < 0) dx2 = -dx2;

		p->setPen( color );
		p->drawLine(bottomX1, bottomY, bottomX2, bottomY);
		x1 += dx1;
		x2 -= dx2;

		/*
		 * The scaling factor (0.99) cuts off the top op the points
		 */
		for (int y=bottomY; x1 < x2*0.99; y+=incrY) {
			int ix1 = (int)x1, ix2 = (int)x2;
			float a1 = x1 - ix1, a2 = x2 - ix2;

			/*
			 * This is a simple linear interpolation between
			 * the two colors
			 */
			int red1 = (int)
				((1-a1)*color.red() + a1*background.red());
			int green1 = (int)
				((1-a1)*color.green() + a1*background.green());
			int blue1 = (int)
				((1-a1)*color.blue() + a1*background.blue());
			int red2 = (int)
				(a2*color.red() + (1-a2)*background.red());
			int green2 = (int)
				(a2*color.green() + (1-a2)*background.green());
			int blue2 = (int)
				(a2*color.blue() + (1-a2)*background.blue());

			/*
			 * Draw the antialiasing pixels
			 */
			alphaColor.setRgb(red1, green1, blue1);
			p->setPen(alphaColor);
			p->drawPoint(ix1, y);
			alphaColor.setRgb(red2, green2, blue2);
			p->setPen(alphaColor);
			p->drawPoint(ix2, y);

			ix1++;
			ix2--;
			x1 += dx1;
			x2 -= dx2;

			if (ix1 <= ix2 && x1 < x2*0.99) {
				/*
				 * Draw the line
				 */
				p->setPen(color);
				p->drawLine(ix1, y, ix2, y);
			}
		}
	}

	/*
	 * Print the field number in inverted color
	 */
	color = board->getCheckerColor((1+getNumber())%2-1);

	p->setBrush(color);
	p->setPen(color);

	TQString t;
	t.setNum(getNumber());

	p->setFont(board->getFont());
	int textHeight = TQFontMetrics(p->font()).height();
	p->drawText(xo, yo+((cellID < 13) ? 5 : height()-5-textHeight),
		    width()*sf, textHeight, AlignCenter, t);

	/*
	 * Put the checkers on the field.
	 */
	int d = getCheckerDiameter();
	double yp, xp = xo + sf*((width()-d-1)/2);
	double ra = sf*d;
	bool upper = cellID < 13;
	int col = (getNumber()%2) ? 1 : -1;

	for (int i = 0; i < abs(pcs); ++i) {
		/*
		 * There is hard work in these formulas. Unless you have
		 * tried _ALL_ possible windowsizes: don't touch!
		 */
		yp = yo + (upper ? sf*((i%5)+(i/5)/4.0)*(d-1) :
			   sf*(height()-((1+i%5)*d)-int(i/5)*0.25*d)-1);
		if (printing) {
			board->drawSimpleChecker(p, xp, yp, pcs, ra);
		} else {
			board->drawChecker(p, xp, yp, pcs, ra,
					   ((i < 5) ? col : 100), upper);
		}
	}

	/*
	 * Finally draw the horizontal boundaries
	 */
	KBgBoardCell::paintCell(p, xo, yo, sf);
}

/*
 * This function draws an anti-aliased circle on the painter p. It is painted
 * in the ractangle with the upper left corner (x,y) and has a maximum diameter
 * of diam. col and upper are as in drawChecker(). outer indicates if this
 * circle blends with the background. Note that this function needs knowledge
 * about the triangles on the cells. This is long but it is just a big if
 * construct.
 */
void KBgBoard::drawCircle(TQPainter *p, int x, int y, int pcs, int diam,
				  int col, bool upper, bool outer) const
{
	TQColor fColor = getCheckerColor(pcs);
	TQColor alphaColor;
	TQColor bColor;

	int red, green, blue;
	int rad = diam/2;
	int xoff = 0;

	float sn = 4;
	float rs = 0.25*diam*diam;
	float cf, a;

	for (int ys = rad; ys >= 0; ys--) {
		for (int xs = xoff; cf = 0, xs < rad; xs++) {

			/*
			 * perform super-sample this pixel
			 */
			for (int s1 = 0; s1 < sn; s1++)
				for (int s2 = 0; s2 < sn; s2++)
					if ((rad-xs+s1/sn)*(rad-xs+s1/sn)+
					    (rad-ys+s2/sn)*(rad-ys+s2/sn) < rs)
						cf += 1;
			a = cf/sn/sn;

			if (outer && (col == 0 || col == 100)) {

				if (col == 0)
					bColor = backgroundColor();
				else
					bColor = fColor;

				red   = (int)
					((1-a)*bColor.red()+a*fColor.red());
				green = (int)
					((1-a)*bColor.green()+a*fColor.green());
				blue  = (int)
					((1-a)*bColor.blue()+a*fColor.blue());

				alphaColor.setRgb(red, green, blue);

				p->setBrush(alphaColor);
				p->setPen(alphaColor);

				if (upper) {

					p->drawPoint(x+xs, y+diam-ys);
					p->drawPoint(x+diam-xs, y+diam-ys);

					p->setBrush(fColor);
					p->setPen(fColor);

					p->drawPoint(x+xs, y+ys);
					p->drawPoint(x+diam-xs, y+ys);

				} else {

					p->drawPoint(x+xs, y+ys);
					p->drawPoint(x+diam-xs, y+ys);

					p->setBrush(fColor);
					p->setPen(fColor);

					p->drawPoint(x+xs, y+diam-ys);
					p->drawPoint(x+diam-xs, y+diam-ys);

				}

			} else if (outer) {

				if (upper) {

					bColor = getCheckerColor(col);

					red   = (int)((1-a)*bColor.red()+
						      a*fColor.red());
					green = (int)((1-a)*bColor.green()+
						      a*fColor.green());
					blue  = (int)((1-a)*bColor.blue()+
						      a*fColor.blue());

					alphaColor.setRgb(red, green, blue);

					p->setBrush(alphaColor);
					p->setPen(alphaColor);

					p->drawPoint(x+xs, y+ys);
					p->drawPoint(x+diam-xs, y+ys);
					p->drawPoint(x+xs, y+diam-ys);
					p->drawPoint(x+diam-xs, y+diam-ys);

					bColor = backgroundColor();

					red   = (int)((1-a)*bColor.red()+
						      a*fColor.red());
					green = (int)((1-a)*bColor.green()+
						      a*fColor.green());
					blue  = (int)((1-a)*bColor.blue()+
						      a*fColor.blue());

					alphaColor.setRgb(red, green, blue);
					p->setBrush(alphaColor);
					p->setPen(alphaColor);

					if (x+xs < rad*(y+ys)/(0.45*height())) {
						p->drawPoint(x+xs, y+ys);
						p->drawPoint(x+diam-xs, y+ys);
					}
					if (x+xs<rad*(y+diam-ys)/(0.45*height())) {
						p->drawPoint(x+xs, y+diam-ys);
						p->drawPoint(x+diam-xs, y+diam-ys);
					}

				} else {

					bColor = getCheckerColor(col);

					red   = (int)((1-a)*bColor.red()+
						      a*fColor.red());
					green = (int)((1-a)*bColor.green()+
						      a*fColor.green());
					blue  = (int)((1-a)*bColor.blue()+
						      a*fColor.blue());

					alphaColor.setRgb(red, green, blue);
					p->setBrush(alphaColor);
					p->setPen(alphaColor);

					p->drawPoint(x+xs, y+ys);
					p->drawPoint(x+diam-xs, y+ys);
					p->drawPoint(x+xs, y+diam-ys);
					p->drawPoint(x+diam-xs, y+diam-ys);

					bColor = backgroundColor();

					red   = (int)((1-a)*bColor.red()+
						      a*fColor.red());
					green = (int)((1-a)*bColor.green()+
						      a*fColor.green());
					blue  = (int)((1-a)*bColor.blue()+
						      a*fColor.blue());

					alphaColor.setRgb(red, green, blue);
					p->setBrush(alphaColor);
					p->setPen(alphaColor);

					if (x+xs<rad*(0.5-(y+ys)/
						      (1.0*height()))/0.45) {
						p->drawPoint(x+xs, y+ys);
						p->drawPoint(x+diam-xs, y+ys);
					}
					if (x+xs < rad*(0.5-(y+diam-ys)/
							(1.0*height()))/0.45) {
						p->drawPoint(x+xs, y+diam-ys);
						p->drawPoint(x+diam-xs, y+diam-ys);
					}
				}

			} else {

				bColor = getCheckerColor(-pcs);

				red   = (int)((1-a)*bColor.red()+
					      a*fColor.red());
				green = (int)((1-a)*bColor.green()+
					      a*fColor.green());
				blue  = (int)((1-a)*bColor.blue()+
					      a*fColor.blue());

				alphaColor.setRgb(red, green, blue);
				p->setBrush(alphaColor);
				p->setPen(alphaColor);

				p->drawPoint(x+xs, y+ys);
				p->drawPoint(x+diam-xs, y+ys);
				p->drawPoint(x+xs, y+diam-ys);
				p->drawPoint(x+diam-xs, y+diam-ys);

			}

			if (fabs(cf-sn*sn) < 0.0001) {

				p->moveTo(x+xs, y+ys);
				p->lineTo(x+diam-xs, y+ys);
				p->moveTo(x+xs, y+diam-ys);
				p->lineTo(x+diam-xs, y+diam-ys);

				xoff = xs;
				break;

			}
		}
	}
}

/*
 * This function redoes a previously undone move
 */
void KBgBoard::redoMove()
{
	if (getEditMode())
		return;

	int w      = getTurn();
	int mcolor = ((w == US) ? color : -color);
	KBgBoardMove *move = redoHistory.last();
	if (move && (w == US || w == THEM)) {
		/*
		 * Make changes at source
		 */
		if (move->source() == BAR_US || move->source() == BAR_THEM) {
			onbar[w] -= mcolor;
			(getCell(move->source()))->cellUpdate(onbar[w], false);
		} else {
			board[move->source()] -= mcolor;
			(getCell(move->source()))->cellUpdate(board[move->source()]);
		}
		/*
		 * Make changes at the destination
		 */
		if ((move->destination() == HOME_THEM_LEFT ) || (move->destination() == HOME_THEM_RIGHT) ||
		    (move->destination() == HOME_US_LEFT   ) || (move->destination() == HOME_US_RIGHT  )) {
			onhome[w] += mcolor;
			(getCell(move->destination()))->cellUpdate(onhome[w], false);
		} else {
			board[move->destination()] += mcolor;
			if (move->wasKicked()) {
				board[move->destination()] = mcolor;
				onbar[((w == US) ? THEM : US)] -= mcolor;
				(getCell(((w == US) ? BAR_THEM : BAR_US)))->cellUpdate
					(onbar[((w == US) ? THEM : US)], false);
			}
			(getCell(move->destination()))->cellUpdate(board[move->destination()]);
		}
		makeMove(move->source(), move->destination());
		redoHistory.remove();
		emit finishedUpdate();
	}
	sendMove();
}

/*
 * This function performs and undo for the last move and updates the parent
 * of the board by calling sendMove() after the undo.
 */
void KBgBoard::undoMove()
{
	if (getEditMode())
		return;

	int w      = getTurn();
	int mcolor = ((w == US) ? color : -color);
	KBgBoardMove *move = moveHistory.last();
	if (move && (w == US || w == THEM)) {
		/*
		 * Undo changes at source
		 */
		if (move->source() == BAR_US || move->source() == BAR_THEM) {
			onbar[w] += mcolor;
			(getCell(move->source()))->cellUpdate(onbar[w], false);
		} else {
			board[move->source()] += mcolor;
			(getCell(move->source()))->cellUpdate
				(board[move->source()]);
		}
		/*
		 * Undo changes at the destination
		 */
		if ( (move->destination() == HOME_THEM_LEFT ) ||
		     (move->destination() == HOME_THEM_RIGHT) ||
		     (move->destination() == HOME_US_LEFT   ) ||
		     (move->destination() == HOME_US_RIGHT  )) {
			onhome[w] -= mcolor;
			(getCell(move->destination()))->cellUpdate
				(onhome[w], false);
		} else {
			board[move->destination()] -= mcolor;
			if (move->wasKicked()) {
				board[move->destination()] = -mcolor;
				onbar[((w == US) ? THEM : US)] += mcolor;
				(getCell(((w == US) ?
					  BAR_THEM : BAR_US)))->cellUpdate
					(onbar[((w == US) ? THEM : US)], false);
			}
			(getCell(move->destination()))->cellUpdate
				(board[move->destination()]);
		}
		++possMoves[move->length()];
		redoHistory.append(new KBgBoardMove(*move));
		moveHistory.remove();
		emit finishedUpdate();
	}
	sendMove();
}

/*
 * While putting a piece on a cell the cell has noticed that it changed
 * ownership and hence needs a piece to be kicked. Since cells don't
 * know where the opponents bar is we handle this here.
 */
void KBgBoard::kickedPiece()
{
	int w = ((getTurn()) == US ? THEM : US);

	if (w == US) {
		onbar[w] += color;
		(getCell(BAR_US  ))->cellUpdate(onbar[w], false);
	} else {
		onbar[w] -= color;
		(getCell(BAR_THEM))->cellUpdate(onbar[w], false);
	}
	if (!getEditMode()) {
		KBgBoardMove *move = moveHistory.last();
		move->setKicked(true);
	}
	emit finishedUpdate();
}

/*
 * This is a very short utility function for makeShortMove().
 */
void KBgBoardCell::makeShortMoveHelper(int s, int d)
{
	if (getPiece()) {
		board->makeMove(s, d);
		KBgBoardCell *dest = board->getCell(d);
		dest->putPiece(((board->getTurn() == US) ? color : -color));
	}
}

/*
 * This function makes the shortes possible move from this cell. It
 * uses only one dice and and it will kick opponent checkers.
 */
void KBgBoardCell::makeShortMove()
{
	int m[4];

	int dir = ((board->getTurn() == US) ? direction : -direction);
	int src = board->IDtoNum(cellID);

	if (src == BAR_US || src == BAR_THEM) {

		int s = (dir > 0) ? 0 : 25;
		for (int i = 1; i < 7; i++) {
			int d = (dir > 0) ? i : 25 - i;
			if (board->checkMultiMove(s, d, m) == 1) {
				makeShortMoveHelper(src, d);
				break;
			}
		}

	} else {

		for (int i = 1; i < 7; i++) {
			int d = src + dir*i;
			if (d > 25) d = 25;
			if (d <  0) d =  0;
			if (0 < d && d < 25) {

				if (board->checkMultiMove(src, d, m) == 1) {
					makeShortMoveHelper(src, d);
					break;
				}

			} else {

				if (board->moveOffPossible()) {
					int whichHome;
					if (board->getTurn() == US)
						whichHome = ((direction > 0) ?
							     HOME_US_LEFT :
							     HOME_US_RIGHT);
					else
						whichHome = ((direction > 0) ?
							     HOME_THEM_LEFT :
							     HOME_THEM_RIGHT);

					if (board->diceAllowMove
					    (cellID, whichHome)) {
						makeShortMoveHelper(src, whichHome);
						break;
					}
				}
			}
		}
	}
}

/*
 * Ask the current backgammon engine for a doubled cube.
 */
void KBgBoard::getDoubleCube(const int w)
{
	emit doubleCube(w);
}

/*
 * Ask the current backgammon engine rolling the dice.
 */
void KBgBoard::getRollDice(const int w)
{
	emit rollDice(w);
}

/*
 * This is the constructor of the KBgBoard class. It creates
 * a backgammon board with an initial distribution of checkers, empty
 * dice and a cube with face value 1. The initial board is not usable!
 * You have to change the status by passing a KBgStatus
 * object to setState(...) before you can play!
 */
KBgBoard::KBgBoard(TQWidget *parent, const char *name, TQPopupMenu *menu)
	: TQWidget(parent, name)
{
	/*
	 * The following lines set up internal bookkeeping data.
	 */
	moveHistory.setAutoDelete(true);
	redoHistory.setAutoDelete(true);
	cube = 1;
	allowMoving(true);
	setEditMode(false);
	savedCursor = NULL;
	checkerDiam = MINIMUM_CHECKER_SIZE;

	/*
	 * We may be initialized with a popup menu by our parent.
	 */
	contextMenu = menu;

	baseColors[0] = black;
	baseColors[1] = white;

	/*
	 * Get the 30 cells that constitute the board and initialize
	 * them properly.
	 */
	cells[ 0] = new KBgBoardHome(this, HOME_THEM_LEFT);
	cells[14] = new KBgBoardHome(this, HOME_THEM_RIGHT);
	cells[15] = new KBgBoardHome(this, HOME_US_LEFT);
	cells[29] = new KBgBoardHome(this, HOME_US_RIGHT);

	cells[ 7] = new KBgBoardBar(this, BAR_THEM);
	cells[22] = new KBgBoardBar(this, BAR_US);

	for (int i=1; i<7; ++i) {
		cells[   i] = new KBgBoardField(this,    i);
		cells[ 7+i] = new KBgBoardField(this,  6+i);
		cells[15+i] = new KBgBoardField(this, 12+i);
		cells[22+i] = new KBgBoardField(this, 18+i);
	}

	/*
	 * Get the default seeting of the board and initialize the
	 * state of it.
	 */
	KBgStatus *st = new KBgStatus();

	st->setCube(1, true, true);
	st->setDirection(+1);
	st->setColor(+1);

	st->setBoard( 1, US,   2); st->setBoard( 6, THEM, 5);
	st->setBoard( 8, THEM, 3); st->setBoard(12, US,   5);
	st->setBoard(13, THEM, 5); st->setBoard(17, US,   3);
	st->setBoard(19, US,   5); st->setBoard(24, THEM, 2);

	st->setHome(US, 0);

	st->setDice(US  , 0, 0); st->setDice(US  , 1, 0);
	st->setDice(THEM, 0, 0); st->setDice(THEM, 1, 0);

	setState(*st);

	delete st;

	/*
	 * This line simplifies the checkMultiMove(...) function a lot.
	 */
	board[0] = board[25] = 0;

	/*
	 * User interface design settings come here. These may be
	 * overwritten by the user.
	 */
	shortMoveMode = SHORT_MOVE_DOUBLE;
	setBackgroundColor(TQColor(200, 200, 166));
	computePipCount = true;

	/*
	 * Set initial font
	 */
	setFont(TQApplication::font());
}

TQSize KBgBoard::minimumSizeHint() const
{
	return TQSize(MINIMUM_CHECKER_SIZE * 15, MINIMUM_CHECKER_SIZE * 11);
}

TQSize KBgBoard::sizeHint() const {
	return TQSize(MINIMUM_CHECKER_SIZE *15*4,MINIMUM_CHECKER_SIZE*11*2);
}