Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegames@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1026 insertions, 0 deletions

diff --git a/kolf/game.h b/kolf/game.h
new file mode 100644
index 00000000..afb13b3c
--- /dev/null
+++ b/kolf/game.h
@@ -0,0 +1,1026 @@
+#ifndef GAME_H
+#define GAME_H
+
+#include <kdebug.h>
+#include <klocale.h>
+#include <kpixmap.h>
+#include <arts/kplayobject.h>
+#include <arts/kartsserver.h>
+#include <arts/kartsdispatcher.h>
+
+#include <math.h>
+
+#include <qcanvas.h>
+#include <qpainter.h>
+#include <qcolor.h>
+#include <qframe.h>
+#include <qlayout.h>
+#include <qmap.h>
+#include <qpen.h>
+#include <qpoint.h>
+#include <qpointarray.h>
+#include <qrect.h>
+#include <qstringlist.h>
+#include <qvaluelist.h>
+
+#include "object.h"
+#include "config.h"
+#include "canvasitem.h"
+#include "ball.h"
+#include "statedb.h"
+#include "rtti.h"
+#include <kdemacros.h>
+
+class QLabel;
+class QSlider;
+class QCheckBox;
+class QTimer;
+class QKeyEvent;
+class QMouseEvent;
+class QPainter;
+class KConfig;
+class KPrinter;
+class KolfGame;
+
+enum Direction { D_Left, D_Right, Forwards, Backwards };
+enum Amount { Amount_Less, Amount_Normal, Amount_More };
+enum HoleResult { Result_Holed, Result_Miss, Result_LipOut };
+
+class Player;
+
+class BallStateInfo
+{
+public:
+	void saveState(KConfig *cfg);
+	void loadState(KConfig *cfg);
+
+	int id;
+	QPoint spot;
+	BallState state;
+	bool beginningOfHole;
+	int score;
+};
+class BallStateList : public QValueList<BallStateInfo>
+{
+public:
+	int hole;
+	int player;
+	bool canUndo;
+	Vector vector;
+};
+
+class Player
+{
+public:
+	Player() : m_ball(new Ball(0)) {};
+	Ball *ball() const { return m_ball; }
+	void setBall(Ball *ball) { m_ball = ball; }
+	BallStateInfo stateInfo(int hole) const { BallStateInfo ret; ret.spot = QPoint(m_ball->x(), m_ball->y()); ret.state = m_ball->curState(); ret.score = score(hole); ret.beginningOfHole = m_ball->beginningOfHole(); ret.id = m_id; return ret; }
+
+	QValueList<int> scores() const { return m_scores; }
+	void setScores(const QValueList<int> &newScores) { m_scores = newScores; }
+	int score(int hole) const { return (*m_scores.at(hole - 1)); }
+	int lastScore() const { return m_scores.last(); }
+	int firstScore() const { return m_scores.first(); }
+
+	void addStrokeToHole(int hole) { (*m_scores.at(hole - 1))++; }
+	void setScoreForHole(int score, int hole) { (*m_scores.at(hole - 1)) = score; }
+	void subtractStrokeFromHole(int hole) { (*m_scores.at(hole - 1))--; }
+	void resetScore(int hole) { (*m_scores.at(hole - 1)) = 0; }
+	void addHole() { m_scores.append(0); }
+	unsigned int numHoles() const { return m_scores.count(); }
+
+	QString name() const { return m_name; }
+	void setName(const QString &name) { m_name = name; m_ball->setName(name); }
+
+	void setId(int id) { m_id = id; }
+	int id() const { return m_id; }
+
+private:
+	Ball *m_ball;
+	QValueList<int> m_scores;
+	QString m_name;
+	int m_id;
+};
+typedef QValueList<Player> PlayerList;
+
+class Arrow : public QCanvasLine
+{
+public:
+	Arrow(QCanvas *canvas);
+	void setAngle(double newAngle) { m_angle = newAngle; }
+	double angle() const { return m_angle; }
+	void setLength(double newLength) { m_length = newLength; }
+	double length() const { return m_length; }
+	void setReversed(bool yes) { m_reversed = yes; }
+	bool reversed() const { return m_reversed; }
+	virtual void setVisible(bool);
+	virtual void setPen(QPen p);
+	void aboutToDie();
+	virtual void moveBy(double, double);
+	void updateSelf();
+	virtual void setZ(double newz);
+
+private:
+	double m_angle;
+	double m_length;
+	bool m_reversed;
+	QCanvasLine *line1;
+	QCanvasLine *line2;
+};
+
+class RectPoint;
+class RectItem
+{
+public:
+	virtual void newSize(int /*width*/, int /*height*/) {};
+};
+
+class RectPoint : public QCanvasEllipse, public CanvasItem
+{
+public:
+	RectPoint(QColor color, RectItem *, QCanvas *canvas);
+	void dontMove() { dontmove = true; }
+	virtual void moveBy(double dx, double dy);
+	virtual Config *config(QWidget *parent);
+	virtual bool deleteable() const { return false; }
+	virtual bool cornerResize() const { return true; }
+	virtual CanvasItem *itemToDelete() { return dynamic_cast<CanvasItem *>(rect); }
+	void setSizeFactor(double newFactor) { m_sizeFactor = newFactor; }
+
+protected:
+	RectItem *rect;
+	double m_sizeFactor;
+
+private:
+	bool dontmove;
+};
+
+class Ellipse : public QCanvasEllipse, public CanvasItem, public RectItem
+{
+public:
+	Ellipse(QCanvas *canvas);
+	virtual void advance(int phase);
+
+	int changeEvery() const { return m_changeEvery; }
+	void setChangeEvery(int news) { m_changeEvery = news; }
+	bool changeEnabled() const { return m_changeEnabled; }
+	void setChangeEnabled(bool news);
+
+	virtual void aboutToDie();
+	virtual void aboutToSave();
+	virtual void savingDone();
+
+	virtual QPtrList<QCanvasItem> moveableItems() const;
+
+	virtual void newSize(int width, int height);
+	virtual void moveBy(double dx, double dy);
+
+	virtual void editModeChanged(bool changed);
+
+	virtual void save(KConfig *cfg);
+	virtual void load(KConfig *cfg);
+
+	virtual Config *config(QWidget *parent);
+
+protected:
+	RectPoint *point;
+	int m_changeEvery;
+	bool m_changeEnabled;
+
+private:
+	int count;
+	bool dontHide;
+};
+class EllipseConfig : public Config
+{
+	Q_OBJECT
+
+public:
+	EllipseConfig(Ellipse *ellipse, QWidget *);
+
+private slots:
+	void value1Changed(int news);
+	void value2Changed(int news);
+	void check1Changed(bool on);
+	void check2Changed(bool on);
+
+protected:
+	QVBoxLayout *m_vlayout;
+
+private:
+	QLabel *slow1;
+	QLabel *fast1;
+	QLabel *slow2;
+	QLabel *fast2;
+	QSlider *slider1;
+	QSlider *slider2;
+	Ellipse *ellipse;
+};
+
+class Puddle : public Ellipse
+{
+public:
+	Puddle(QCanvas *canvas);
+	virtual bool collision(Ball *ball, long int id);
+	virtual int rtti() const { return Rtti_DontPlaceOn; }
+};
+class PuddleObj : public Object
+{
+public:
+	PuddleObj() { m_name = i18n("Puddle"); m__name = "puddle"; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new Puddle(canvas); }
+};
+
+class Sand : public Ellipse
+{
+public:
+	Sand(QCanvas *canvas);
+	virtual bool collision(Ball *ball, long int id);
+};
+class SandObj : public Object
+{
+public:
+	SandObj() { m_name = i18n("Sand"); m__name = "sand"; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new Sand(canvas); }
+};
+
+class Inside : public QCanvasEllipse, public CanvasItem
+{
+public:
+	Inside(CanvasItem *item, QCanvas *canvas) : QCanvasEllipse(canvas) { this->item = item; }
+	virtual bool collision(Ball *ball, long int id) { return item->collision(ball, id); }
+
+protected:
+	CanvasItem *item;
+};
+
+class Bumper : public QCanvasEllipse, public CanvasItem
+{
+public:
+	Bumper(QCanvas *canvas);
+
+	virtual void advance(int phase);
+	virtual void aboutToDie();
+	virtual void moveBy(double dx, double dy);
+	virtual void editModeChanged(bool changed);
+
+	virtual bool collision(Ball *ball, long int id);
+
+protected:
+	QColor firstColor;
+	QColor secondColor;
+	Inside *inside;
+
+private:
+	int count;
+};
+class BumperObj : public Object
+{
+public:
+	BumperObj() { m_name = i18n("Bumper"); m__name = "bumper"; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new Bumper(canvas); }
+};
+
+class Hole : public QCanvasEllipse, public CanvasItem
+{
+public:
+	Hole(QColor color, QCanvas *canvas);
+	virtual bool place(Ball * /*ball*/, bool /*wasCenter*/) { return true; };
+
+	virtual bool collision(Ball *ball, long int id);
+
+protected:
+	virtual HoleResult result(const QPoint, double, bool *wasCenter);
+};
+
+class Cup : public Hole
+{
+public:
+	Cup(QCanvas *canvas);
+	virtual bool place(Ball *ball, bool wasCenter);
+	virtual void save(KConfig *cfg);
+	virtual bool canBeMovedByOthers() const { return true; }
+	virtual void draw(QPainter &painter);
+
+protected:
+	QPixmap pixmap;
+};
+class CupObj : public Object
+{
+public:
+	CupObj() { m_name = i18n("Cup"); m__name = "cup"; m_addOnNewHole = true; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new Cup(canvas); }
+};
+
+class BlackHole;
+class BlackHoleConfig : public Config
+{
+	Q_OBJECT
+
+public:
+	BlackHoleConfig(BlackHole *blackHole, QWidget *parent);
+
+private slots:
+	void degChanged(int);
+	void minChanged(double);
+	void maxChanged(double);
+
+private:
+	BlackHole *blackHole;
+};
+class BlackHoleExit : public QCanvasLine, public CanvasItem
+{
+public:
+	BlackHoleExit(BlackHole *blackHole, QCanvas *canvas);
+	virtual int rtti() const { return Rtti_NoCollision; }
+	virtual void aboutToDie();
+	virtual void moveBy(double dx, double dy);
+	virtual bool deleteable() const { return false; }
+	virtual bool canBeMovedByOthers() const { return true; }
+	virtual void editModeChanged(bool editing);
+	virtual void setPen(QPen p);
+	virtual void showInfo();
+	virtual void hideInfo();
+	void updateArrowAngle();
+	void updateArrowLength();
+	virtual Config *config(QWidget *parent);
+	BlackHole *blackHole;
+
+protected:
+	Arrow *arrow;
+};
+class BlackHoleTimer : public QObject
+{
+Q_OBJECT
+
+public:
+	BlackHoleTimer(Ball *ball, double speed, int msec);
+
+signals:
+	void eject(Ball *ball, double speed);
+	void halfway();
+
+protected slots:
+	void mySlot();
+	void myMidSlot();
+
+protected:
+	double m_speed;
+	Ball *m_ball;
+};
+class BlackHole : public QObject, public Hole
+{
+Q_OBJECT
+
+public:
+	BlackHole(QCanvas *canvas);
+	virtual bool canBeMovedByOthers() const { return true; }
+	virtual void aboutToDie();
+	virtual void showInfo();
+	virtual void hideInfo();
+	virtual bool place(Ball *ball, bool wasCenter);
+	virtual void save(KConfig *cfg);
+	virtual void load(KConfig *cfg);
+	virtual Config *config(QWidget *parent) { return new BlackHoleConfig(this, parent); }
+	virtual QPtrList<QCanvasItem> moveableItems() const;
+	double minSpeed() const { return m_minSpeed; }
+	double maxSpeed() const { return m_maxSpeed; }
+	void setMinSpeed(double news) { m_minSpeed = news; exitItem->updateArrowLength(); }
+	void setMaxSpeed(double news) { m_maxSpeed = news; exitItem->updateArrowLength(); }
+
+	int curExitDeg() const { return exitDeg; }
+	void setExitDeg(int newdeg);
+
+	virtual void editModeChanged(bool editing) { exitItem->editModeChanged(editing); }
+	void updateInfo();
+
+	virtual void shotStarted() { runs = 0; };
+
+	virtual void moveBy(double dx, double dy);
+
+public slots:
+	void eject(Ball *ball, double speed);
+	void halfway();
+
+protected:
+	int exitDeg;
+	BlackHoleExit *exitItem;
+	double m_minSpeed;
+	double m_maxSpeed;
+
+private:
+	int runs;
+	QCanvasLine *infoLine;
+	QCanvasEllipse *outside;
+	void finishMe();
+};
+class BlackHoleObj : public Object
+{
+public:
+	BlackHoleObj() { m_name = i18n("Black Hole"); m__name = "blackhole"; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new BlackHole(canvas); }
+};
+
+class WallPoint;
+class Wall : public QCanvasLine, public CanvasItem
+{
+public:
+	Wall(QCanvas *canvas);
+	virtual void aboutToDie();
+	double dampening;
+
+	void setAlwaysShow(bool yes);
+	virtual void setZ(double newz);
+	virtual void setPen(QPen p);
+	virtual bool collision(Ball *ball, long int id);
+	virtual void save(KConfig *cfg);
+	virtual void load(KConfig *cfg);
+	virtual void selectedItem(QCanvasItem *item);
+	virtual void editModeChanged(bool changed);
+	virtual void moveBy(double dx, double dy);
+	virtual void setVelocity(double vx, double vy);
+	virtual void clean();
+
+	// must reimp because we gotta move the end items,
+	// and we do that in moveBy()
+	virtual void setPoints(int xa, int ya, int xb, int yb) { QCanvasLine::setPoints(xa, ya, xb, yb); moveBy(0, 0); }
+
+	virtual int rtti() const { return Rtti_Wall; }
+	virtual QPtrList<QCanvasItem> moveableItems() const;
+	virtual void setGame(KolfGame *game);
+	virtual void setVisible(bool);
+
+	virtual QPointArray areaPoints() const;
+
+protected:
+	WallPoint *startItem;
+	WallPoint *endItem;
+	bool editing;
+
+private:
+	long int lastId;
+
+	friend class WallPoint;
+};
+class WallPoint : public QCanvasEllipse, public CanvasItem
+{
+public:
+	WallPoint(bool start, Wall *wall, QCanvas *canvas);
+	void setAlwaysShow(bool yes) { alwaysShow = yes; updateVisible(); }
+	virtual void editModeChanged(bool changed);
+	virtual void moveBy(double dx, double dy);
+	virtual int rtti() const { return Rtti_WallPoint; }
+	virtual bool deleteable() const { return false; }
+	virtual bool collision(Ball *ball, long int id);
+	virtual CanvasItem *itemToDelete() { return wall; }
+	virtual void clean();
+	virtual Config *config(QWidget *parent) { return wall->config(parent); }
+	void dontMove() { dontmove = true; };
+	void updateVisible();
+
+	Wall *parentWall() { return wall; }
+
+protected:
+	Wall *wall;
+	bool editing;
+	bool visible;
+
+private:
+	bool alwaysShow;
+	bool start;
+	bool dontmove;
+	long int lastId;
+
+	friend class Wall;
+};
+class WallObj : public Object
+{
+public:
+	WallObj() { m_name = i18n("Wall"); m__name = "wall"; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new Wall(canvas); }
+};
+
+class Putter : public QCanvasLine, public CanvasItem
+{
+public:
+	Putter(QCanvas *canvas);
+	void go(Direction, Amount amount = Amount_Normal);
+	void setOrigin(int x, int y);
+	int curLen() const { return len; }
+	double curAngle() const { return angle; }
+	int curDeg() const { return rad2deg(angle); }
+	virtual void showInfo();
+	virtual void hideInfo();
+	void setAngle(double news) { angle = news; finishMe(); }
+	void setDeg(int news) { angle = deg2rad(news); finishMe(); }
+	double curMaxAngle() const { return maxAngle; }
+	virtual int rtti() const { return Rtti_Putter; }
+	virtual void setVisible(bool yes);
+	void saveAngle(Ball *ball) { angleMap[ball] = angle; }
+	void setAngle(Ball *ball);
+	void resetAngles() { angleMap.clear(); setZ(999999); }
+	virtual bool canBeMovedByOthers() const { return true; }
+	virtual void moveBy(double dx, double dy);
+	void setShowGuideLine(bool yes);
+
+private:
+	QPoint midPoint;
+	double maxAngle;
+	double angle;
+	double oneDegree;
+	QMap<Ball *, double> angleMap;
+	int len;
+	void finishMe();
+	int putterWidth;
+	QCanvasLine *guideLine;
+	bool m_showGuideLine;
+};
+
+class Bridge;
+class BridgeConfig : public Config
+{
+	Q_OBJECT
+
+public:
+	BridgeConfig(Bridge *bridge, QWidget *);
+
+protected slots:
+	void topWallChanged(bool);
+	void botWallChanged(bool);
+	void leftWallChanged(bool);
+	void rightWallChanged(bool);
+
+protected:
+	QVBoxLayout *m_vlayout;
+	QCheckBox *top;
+	QCheckBox *bot;
+	QCheckBox *left;
+	QCheckBox *right;
+
+private:
+	Bridge *bridge;
+};
+class Bridge : public QCanvasRectangle, public CanvasItem, public RectItem
+{
+public:
+	Bridge(QRect rect, QCanvas *canvas);
+	virtual bool collision(Ball *ball, long int id);
+	virtual void aboutToDie();
+	virtual void editModeChanged(bool changed);
+	virtual void moveBy(double dx, double dy);
+	virtual void load(KConfig *cfg);
+	virtual void save(KConfig *cfg);
+	virtual bool vStrut() const { return true; }
+	void doLoad(KConfig *cfg);
+	void doSave(KConfig *cfg);
+	virtual void newSize(int width, int height);
+	virtual void setGame(KolfGame *game);
+	virtual Config *config(QWidget *parent) { return new BridgeConfig(this, parent); }
+	void setSize(int width, int height);
+	virtual QPtrList<QCanvasItem> moveableItems() const;
+
+	void setWallColor(QColor color);
+	QPen wallPen() const { return topWall->pen(); }
+
+	double wallZ() const { return topWall->z(); }
+	void setWallZ(double);
+
+	void setTopWallVisible(bool yes) { topWall->setVisible(yes); }
+	void setBotWallVisible(bool yes) { botWall->setVisible(yes); }
+	void setLeftWallVisible(bool yes) { leftWall->setVisible(yes); }
+	void setRightWallVisible(bool yes) { rightWall->setVisible(yes); }
+	bool topWallVisible() const { return topWall->isVisible(); }
+	bool botWallVisible() const { return botWall->isVisible(); }
+	bool leftWallVisible() const { return leftWall->isVisible(); }
+	bool rightWallVisible() const { return rightWall->isVisible(); }
+
+protected:
+	Wall *topWall;
+	Wall *botWall;
+	Wall *leftWall;
+	Wall *rightWall;
+	RectPoint *point;
+};
+class BridgeObj : public Object
+{
+public:
+	BridgeObj() { m_name = i18n("Bridge"); m__name = "bridge"; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new Bridge(QRect(0, 0, 80, 40), canvas); }
+};
+
+class Sign;
+class SignConfig : public BridgeConfig
+{
+	Q_OBJECT
+
+public:
+	SignConfig(Sign *sign, QWidget *parent);
+
+private slots:
+	void textChanged(const QString &);
+
+private:
+	Sign *sign;
+};
+class Sign : public Bridge
+{
+public:
+	Sign(QCanvas *canvas);
+	void setText(const QString &text);
+	QString text() const { return m_text; }
+	virtual void draw(QPainter &painter);
+	virtual bool vStrut() const { return false; }
+	virtual Config *config(QWidget *parent) { return new SignConfig(this, parent); }
+	virtual void save(KConfig *cfg);
+	virtual void load(KConfig *cfg);
+
+protected:
+	QString m_text;
+	QString m_untranslatedText;
+};
+class SignObj : public Object
+{
+public:
+	SignObj() { m_name = i18n("Sign"); m__name = "sign"; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new Sign(canvas); }
+};
+
+class Windmill;
+class WindmillGuard : public Wall
+{
+public:
+	WindmillGuard(QCanvas *canvas) : Wall(canvas) {};
+	void setBetween(int newmin, int newmax) { max = newmax; min = newmin; }
+	virtual void advance(int phase);
+
+protected:
+	int max;
+	int min;
+};
+class WindmillConfig : public BridgeConfig
+{
+	Q_OBJECT
+
+public:
+	WindmillConfig(Windmill *windmill, QWidget *parent);
+
+private slots:
+	void speedChanged(int news);
+	void endChanged(bool yes);
+
+private:
+	Windmill *windmill;
+};
+class Windmill : public Bridge
+{
+public:
+	Windmill(QRect rect, QCanvas *canvas);
+	virtual void aboutToDie();
+	virtual void newSize(int width, int height);
+	virtual void save(KConfig *cfg);
+	virtual void load(KConfig *cfg);
+	virtual void setGame(KolfGame *game);
+	virtual Config *config(QWidget *parent) { return new WindmillConfig(this, parent); }
+	void setSize(int width, int height);
+	virtual void moveBy(double dx, double dy);
+	void setSpeed(int news);
+	int curSpeed() const { return speed; }
+	void setBottom(bool yes);
+	bool bottom() const { return m_bottom; }
+
+protected:
+	WindmillGuard *guard;
+	Wall *left;
+	Wall *right;
+	int speedfactor;
+	int speed;
+	bool m_bottom;
+};
+class WindmillObj : public Object
+{
+public:
+	WindmillObj() { m_name = i18n("Windmill"); m__name = "windmill"; }
+	virtual QCanvasItem *newObject(QCanvas *canvas) { return new Windmill(QRect(0, 0, 80, 40), canvas); }
+};
+
+class HoleInfo;
+class HoleConfig : public Config
+{
+	Q_OBJECT
+
+public:
+	HoleConfig(HoleInfo *holeInfo, QWidget *);
+
+private slots:
+	void authorChanged(const QString &);
+	void parChanged(int);
+	void maxStrokesChanged(int);
+	void nameChanged(const QString &);
+	void borderWallsChanged(bool);
+
+private:
+	HoleInfo *holeInfo;
+};
+class HoleInfo : public CanvasItem
+{
+public:
+	HoleInfo() { m_lowestMaxStrokes = 4; }
+	virtual ~HoleInfo() {}
+	void setPar(int newpar) { m_par = newpar; }
+	int par() const { return m_par; }
+	void setMaxStrokes(int newMaxStrokes) { m_maxStrokes = newMaxStrokes; }
+	int lowestMaxStrokes() const { return m_lowestMaxStrokes; }
+	int maxStrokes() const { return m_maxStrokes; }
+	bool hasMaxStrokes() const { return m_maxStrokes != m_lowestMaxStrokes; }
+	void setAuthor(QString newauthor) { m_author = newauthor; }
+	QString author() const { return m_author; }
+
+	void setName(QString newname) { m_name = newname; }
+	void setUntranslatedName(QString newname) { m_untranslatedName = newname; }
+	QString name() const { return m_name; }
+	QString untranslatedName() const { return m_untranslatedName; }
+
+	virtual Config *config(QWidget *parent) { return new HoleConfig(this, parent); }
+	void borderWallsChanged(bool yes);
+	bool borderWalls() const { return m_borderWalls; }
+
+private:
+	QString m_author;
+	QString m_name;
+	QString m_untranslatedName;
+	bool m_borderWalls;
+	int m_par;
+	int m_maxStrokes;
+	int m_lowestMaxStrokes;
+};
+
+class StrokeCircle : public QCanvasItem
+{
+public:
+	StrokeCircle(QCanvas *canvas);
+
+	void setValue(double v);
+	double value();
+	void setMaxValue(double m);
+	void setSize(int w, int h);
+	void setThickness(int t);
+	int thickness() const;
+	int width() const;
+	int height() const;
+	virtual void draw(QPainter &p);
+	virtual QRect boundingRect() const;
+	virtual bool collidesWith(const QCanvasItem*) const;
+	virtual bool collidesWith(const QCanvasSprite*, const QCanvasPolygonalItem*, const QCanvasRectangle*, const QCanvasEllipse*, const QCanvasText*) const;
+
+private:
+	double dvalue, dmax;
+	int ithickness, iwidth, iheight;
+};
+
+struct KDE_EXPORT CourseInfo
+{
+	CourseInfo(const QString &_name, const QString &_untranslatedName, const QString &_author, unsigned int _holes, unsigned int _par) { name = _name; untranslatedName = _untranslatedName, author = _author; holes = _holes; par = _par; }
+	CourseInfo();
+
+	QString name;
+	QString untranslatedName;
+	QString author;
+	unsigned int holes;
+	unsigned int par;
+};
+
+class KDE_EXPORT KolfGame : public QCanvasView
+{
+	Q_OBJECT
+
+public:
+	KolfGame(ObjectList *obj, PlayerList *players, QString filename, QWidget *parent=0, const char *name=0 );
+	~KolfGame();
+	void setObjects(ObjectList *obj) { this->obj = obj; }
+	void setFilename(const QString &filename);
+	QString curFilename() const { return filename; }
+	void emitLargestHole() { emit largestHole(highestHole); }
+	QCanvas *canvas() const { return course; }
+	void removeItem(QCanvasItem *item) { items.setAutoDelete(false); items.removeRef(item); }
+	// returns whether it was a cancel
+	bool askSave(bool);
+	bool isEditing() const { return editing; }
+	int currentHole() { return curHole; }
+	void setStrict(bool yes) { strict = yes; }
+	// returns true when you shouldn't do anything
+	bool isPaused() const { return paused; }
+	Ball *curBall() const { return (*curPlayer).ball(); }
+	void updateMouse();
+	void ballMoved();
+	void updateHighlighter();
+	void updateCourse() { course->update(); }
+	QCanvasItem *curSelectedItem() const { return selectedItem; }
+	void setBorderWalls(bool);
+	void setInPlay(bool yes) { inPlay = yes; }
+	bool isInPlay() { return inPlay; }
+	bool isInfoShowing() { return m_showInfo; }
+	void stoppedBall();
+	QString courseName() const { return holeInfo.name(); }
+	void hidePutter() { putter->setVisible(false); }
+	void ignoreEvents(bool ignore) { m_ignoreEvents = ignore; }
+
+	static void scoresFromSaved(KConfig *, PlayerList &players);
+	static void courseInfo(CourseInfo &info, const QString &filename);
+
+public slots:
+	void pause();
+	void unPause();
+	void save();
+	void toggleEditMode();
+	void setModified(bool mod = true);
+	void addNewObject(Object *newObj);
+	void addNewHole();
+	void switchHole(int);
+	void switchHole(const QString &);
+	void nextHole();
+	void prevHole();
+	void firstHole();
+	void lastHole();
+	void randHole();
+	void playSound(QString file, double vol = 1);
+	void showInfoDlg(bool = false);
+	void resetHole();
+	void clearHole();
+	void print(KPrinter &);
+	void setShowInfo(bool yes);
+	void toggleShowInfo();
+	void updateShowInfo();
+	void setUseMouse(bool yes) { m_useMouse = yes; }
+	void setUseAdvancedPutting(bool yes);
+	void setShowGuideLine(bool yes);
+	void setSound(bool yes);
+	void undoShot();
+	void timeout();
+	void saveScores(KConfig *);
+	void startFirstHole(int hole);
+	void sayWhosGoing();
+
+signals:
+	void holesDone();
+	void newHole(int);
+	void parChanged(int, int);
+	void titleChanged(const QString &);
+	void largestHole(int);
+	void scoreChanged(int, int, int);
+	void newPlayersTurn(Player *);
+	void playerHoled(Player *);
+	void newSelectedItem(CanvasItem *);
+	void checkEditing();
+	void editingStarted();
+	void editingEnded();
+	void inPlayStart();
+	void inPlayEnd();
+	void maxStrokesReached(const QString &);
+	void currentHole(int);
+	void modifiedChanged(bool);
+	void newStatusText(const QString &);
+
+private slots:
+	void shotDone();
+	void holeDone();
+	void startNextHole();
+	void fastTimeout();
+	void putterTimeout();
+	void autoSaveTimeout();
+	void addItemsToMoveableList(QPtrList<QCanvasItem>);
+	void addItemToFastAdvancersList(CanvasItem *);
+	void hideInfo();
+
+	void emitMax();
+
+protected:
+	void mouseMoveEvent(QMouseEvent *e);
+	void mousePressEvent(QMouseEvent *e);
+	void mouseReleaseEvent(QMouseEvent *e);
+	void mouseDoubleClickEvent(QMouseEvent *e);
+
+	void handleMousePressEvent(QMouseEvent *e);
+	void handleMouseDoubleClickEvent(QMouseEvent *e);
+	void handleMouseMoveEvent(QMouseEvent *e);
+	void handleMouseReleaseEvent(QMouseEvent *e);
+	void keyPressEvent(QKeyEvent *e);
+	void keyReleaseEvent(QKeyEvent *e);
+
+	QPoint viewportToViewport(const QPoint &p);
+
+private:
+	QCanvas *course;
+	Putter *putter;
+	PlayerList *players;
+	PlayerList::Iterator curPlayer;
+	Ball *whiteBall;
+	StrokeCircle *strokeCircle;
+
+	QTimer *timer;
+	QTimer *autoSaveTimer;
+	QTimer *fastTimer;
+	QTimer *putterTimer;
+	bool regAdv;
+
+	ObjectList *obj;
+	QPtrList<QCanvasItem> items;
+	QPtrList<QCanvasItem> extraMoveable;
+	QPtrList<Wall> borderWalls;
+
+	int timerMsec;
+	int autoSaveMsec;
+	int fastTimerMsec;
+	int putterTimerMsec;
+
+	void puttPress();
+	void puttRelease();
+	bool inPlay;
+	bool putting;
+	bool stroking;
+	bool finishStroking;
+	double strength;
+	double maxStrength;
+	int puttCount;
+	bool puttReverse;
+
+	int curHole;
+	int highestHole;
+	int curPar;
+
+	int wallWidth;
+	int height;
+	int width;
+	int margin;
+	QColor grass;
+
+	int advancePeriod;
+
+	int lastDelId;
+
+	bool paused;
+
+	QString filename;
+	bool recalcHighestHole;
+	void openFile();
+
+	bool strict;
+
+	bool editing;
+	QPoint storedMousePos;
+	bool moving;
+	bool dragging;
+	QCanvasItem *movingItem;
+	QCanvasItem *selectedItem;
+	QCanvasRectangle *highlighter;
+
+	// sound
+	KArtsDispatcher artsDispatcher;
+	KArtsServer artsServer;
+	QPtrList<KPlayObject> oldPlayObjects;
+	bool m_sound;
+	bool soundedOnce;
+	QString soundDir;
+
+	bool m_ignoreEvents;
+
+	HoleInfo holeInfo;
+	QCanvasText *infoText;
+	void showInfo();
+	StateDB stateDB;
+
+	BallStateList ballStateList;
+	void loadStateList();
+	void recreateStateList();
+	void addHoleInfo(BallStateList &list);
+
+	bool dontAddStroke;
+
+	bool addingNewHole;
+	int scoreboardHoles;
+	inline void resetHoleScores();
+
+	bool m_showInfo;
+
+	bool infoShown;
+
+	KConfig *cfg;
+
+	inline void addBorderWall(QPoint start, QPoint end);
+	void shotStart();
+	void startBall(const Vector &vector);
+
+	bool modified;
+
+	inline bool allPlayersDone();
+
+	bool m_useMouse;
+	bool m_useAdvancedPutting;
+
+	QPtrList<CanvasItem> fastAdvancers;
+	bool fastAdvancedExist;
+
+	QString playerWhoMaxed;
+};
+
+#endif