converted phases toolbar to graphics item

cockatrice/cockatrice.qrc

@@ -7,18 +7,18 @@
         <file>resources/icon_config_appearance.svg</file>
         <file>resources/icon_config_interface.svg</file>
         <file>resources/icon_config_messages.svg</file>
-        <file>resources/icon_phase_untap.svg</file>
-        <file>resources/icon_phase_upkeep.svg</file>
-        <file>resources/icon_phase_draw.svg</file>
-        <file>resources/icon_phase_main1.svg</file>
-        <file>resources/icon_phase_combat_start.svg</file>
-        <file>resources/icon_phase_combat_attackers.svg</file>
-        <file>resources/icon_phase_combat_blockers.svg</file>
-        <file>resources/icon_phase_combat_damage.svg</file>
-        <file>resources/icon_phase_combat_end.svg</file>
-        <file>resources/icon_phase_main2.svg</file>
-        <file>resources/icon_phase_cleanup.svg</file>
-        <file>resources/icon_nextturn.svg</file>
+        <file>resources/phases/icon_phase_untap.svg</file>
+        <file>resources/phases/icon_phase_upkeep.svg</file>
+        <file>resources/phases/icon_phase_draw.svg</file>
+        <file>resources/phases/icon_phase_main1.svg</file>
+        <file>resources/phases/icon_phase_combat_start.svg</file>
+        <file>resources/phases/icon_phase_combat_attackers.svg</file>
+        <file>resources/phases/icon_phase_combat_blockers.svg</file>
+        <file>resources/phases/icon_phase_combat_damage.svg</file>
+        <file>resources/phases/icon_phase_combat_end.svg</file>
+        <file>resources/phases/icon_phase_main2.svg</file>
+        <file>resources/phases/icon_phase_cleanup.svg</file>
+        <file>resources/phases/icon_phase_nextturn.svg</file>
 	<file>resources/hand.svg</file>
 	<file>resources/pencil.svg</file>
 	<file>resources/icon_search.svg</file>

cockatrice/src/abstractcarditem.cpp

@@ -20,7 +20,7 @@ AbstractCardItem::AbstractCardItem(const QString &_name, Player *_owner, QGraphi
 	setCacheMode(DeviceCoordinateCache);
 
 	connect(info, SIGNAL(pixmapUpdated()), this, SLOT(pixmapUpdated()));
-	connect(settingsCache, SIGNAL(displayCardNamesChanged()), this, SLOT(update()));
+	connect(settingsCache, SIGNAL(displayCardNamesChanged()), this, SLOT(callUpdate()));
 	
 	animationTimer = new QTimer(this);
 	animationTimer->setSingleShot(false);
@@ -86,9 +86,12 @@ void AbstractCardItem::paintPicture(QPainter *painter, int angle)
 
 	QPixmap *translatedPixmap = info->getPixmap(translatedSize.toSize());
 	painter->save();
+	QColor bgColor = Qt::transparent;
 	if (translatedPixmap) {
+		painter->save();
 		transformPainter(painter, translatedSize, angle);
 		painter->drawPixmap(QPointF(0, 0), *translatedPixmap);
+		painter->restore();
 	} else {
 		QString colorStr;
 		if (!color.isEmpty())
@@ -98,33 +101,26 @@ void AbstractCardItem::paintPicture(QPainter *painter, int angle)
 		else if (!info->getColors().isEmpty())
 			colorStr = info->getColors().first().toLower();
 		
-		QColor bgColor;
-		QColor textColor = Qt::white;
 		if (colorStr == "b")
 			bgColor = QColor(0, 0, 0);
 		else if (colorStr == "u")
 			bgColor = QColor(0, 140, 180);
-		else if (colorStr == "w") {
+		else if (colorStr == "w")
 			bgColor = QColor(255, 250, 140);
-			textColor = Qt::black;
-		} else if (colorStr == "r")
+		else if (colorStr == "r")
 			bgColor = QColor(230, 0, 0);
 		else if (colorStr == "g")
 			bgColor = QColor(0, 160, 0);
-		else if (colorStr == "m") {
+		else if (colorStr == "m")
 			bgColor = QColor(250, 190, 30);
-			textColor = Qt::black;
-		} else {
+		else
 			bgColor = QColor(230, 230, 230);
-			textColor = Qt::black;
 	}
 	painter->setBrush(bgColor);
 	QPen pen(Qt::black);
 	pen.setWidth(2);
 	painter->setPen(pen);
 	painter->drawRect(QRectF(1, 1, CARD_WIDTH - 2, CARD_HEIGHT - 2));
-	}
-	painter->restore();
 	
 	if (!translatedPixmap || settingsCache->getDisplayCardNames()) {
 		painter->save();
@@ -133,6 +129,7 @@ void AbstractCardItem::paintPicture(QPainter *painter, int angle)
 		painter->setBackground(Qt::black);
 		painter->setBackgroundMode(Qt::OpaqueMode);
 		painter->drawText(QRectF(3 * scaleFactor, 3 * scaleFactor, translatedSize.width() - 6 * scaleFactor, translatedSize.height() - 6 * scaleFactor), Qt::AlignTop | Qt::AlignLeft | Qt::TextWrapAnywhere, name);
+		painter->restore();
 	}
 	
 	painter->restore();

cockatrice/src/abstractcarditem.h

@@ -27,6 +27,7 @@ private:
 private slots:
 	void animationEvent();
 	void pixmapUpdated();
+	void callUpdate() { update(); }
 signals:
 	void hovered(AbstractCardItem *card);
 	void showCardInfoPopup(QPoint pos, QString cardName);

cockatrice/src/gamescene.cpp

@@ -2,13 +2,15 @@
 #include "player.h"
 #include "zoneviewwidget.h"
 #include "zoneviewzone.h"
+#include "phasestoolbar.h"
 #include <QAction>
 #include <QGraphicsSceneMouseEvent>
 #include <QSet>
 
-GameScene::GameScene(QObject *parent)
-	: QGraphicsScene(parent)
+GameScene::GameScene(PhasesToolbar *_phasesToolbar, QObject *parent)
+	: QGraphicsScene(parent), phasesToolbar(_phasesToolbar)
 {
+	addItem(phasesToolbar);
 }
 
 void GameScene::retranslateUi()
@@ -37,34 +39,37 @@ void GameScene::removePlayer(Player *player)
 void GameScene::rearrange()
 {
 	struct PlayerProcessor {
-		static void processPlayer(Player *p, qreal &w, qreal &h, QPointF &b, bool singlePlayer)
+		static void processPlayer(Player *p, qreal &w, QPointF &b, bool singlePlayer)
 		{
 			const QRectF br = p->boundingRect();
 			if (br.width() > w)
 				w = br.width();
-			if (h)
-				h += playerAreaSpacing;
-			h += br.height();
 			p->setPos(b);
 			p->setMirrored((b.y() < playerAreaSpacing) && !singlePlayer);
 			b += QPointF(0, br.height() + playerAreaSpacing);
 		}
 	};
 	
-	QPointF base;
-	qreal sceneWidth = 0;
-	qreal sceneHeight = 0;
+	qreal sceneHeight = -playerAreaSpacing;
+	for (int i = 0; i < players.size(); ++i)
+		sceneHeight += players[i]->boundingRect().height() + playerAreaSpacing;
+	phasesToolbar->setHeight(sceneHeight);
+	qreal phasesWidth = phasesToolbar->getWidth();
+	
+	QPointF base(phasesWidth, 0);
+	qreal sceneWidth;
 	QList<Player *> localPlayers;
 
 	for (int i = 0; i < players.size(); ++i)
 		if (!players[i]->getLocal())
-			PlayerProcessor::processPlayer(players[i], sceneWidth, sceneHeight, base, players.size() == 1);
+			PlayerProcessor::processPlayer(players[i], sceneWidth, base, players.size() == 1);
 		else
 			localPlayers.append(players[i]);
 	
 	for (int i = 0; i < localPlayers.size(); ++i)
-		PlayerProcessor::processPlayer(localPlayers[i], sceneWidth, sceneHeight, base, players.size() == 1);
+		PlayerProcessor::processPlayer(localPlayers[i], sceneWidth, base, players.size() == 1);
 
+	sceneWidth += phasesWidth;
 	playersRect = QRectF(0, 0, sceneWidth, sceneHeight);
 	
 	setSceneRect(sceneRect().x(), sceneRect().y(), sceneWidth, sceneHeight);
@@ -127,6 +132,7 @@ void GameScene::processViewSizeChange(const QSize &newSize)
 		if (w > minWidth)
 			minWidth = w;
 	}
+	minWidth += phasesToolbar->getWidth();
 	
 	qreal minRatio = minWidth / sceneRect().height();
 	if (minRatio > newRatio) {
@@ -138,7 +144,7 @@ void GameScene::processViewSizeChange(const QSize &newSize)
 	}
 	
 	for (int i = 0; i < players.size(); ++i)
-		players[i]->processSceneSizeChange(sceneRect().size());
+		players[i]->processSceneSizeChange(sceneRect().size() - QSizeF(phasesToolbar->getWidth(), 0));
 }
 
 bool GameScene::event(QEvent *event)

cockatrice/src/gamescene.h

@@ -8,18 +8,20 @@ class Player;
 class ZoneViewWidget;
 class CardZone;
 class ServerInfo_Card;
+class PhasesToolbar;
 
 class GameScene : public QGraphicsScene {
 	Q_OBJECT
 private:
 	static const int playerAreaSpacing = 5;
 	
+	PhasesToolbar *phasesToolbar;
 	QList<Player *> players;
 	QRectF playersRect;
 	QList<ZoneViewWidget *> views;
 	QSize viewSize;
 public:
-	GameScene(QObject *parent = 0);
+	GameScene(PhasesToolbar *_phasesToolbar, QObject *parent = 0);
 	void retranslateUi();
 	const QRectF &getPlayersRect() const { return playersRect; }
 	void processViewSizeChange(const QSize &newSize);

cockatrice/src/gameview.cpp

@@ -37,7 +37,6 @@ void GameView::resizeEvent(QResizeEvent *event)
 
 void GameView::updateSceneRect(const QRectF &rect)
 {
-	qDebug(QString("updateSceneRect = %1,%2").arg(rect.width()).arg(rect.height()).toLatin1());
 	fitInView(rect, Qt::KeepAspectRatio);
 }
 

cockatrice/src/phasestoolbar.cpp

 #include <QAction>
-#include <QVBoxLayout>
 #include <QPainter>
 #include <QPen>
 #include <QTimer>
+#include <QDebug>
+#include <math.h>
 #include "phasestoolbar.h"
 #include "protocol_items.h"
+#include "pixmapgenerator.h"
 
-PhaseButton::PhaseButton(const QIcon &icon, QAction *_doubleClickAction)
-	: QPushButton(icon, QString()), active(false), activeAnimationCounter(0), doubleClickAction(_doubleClickAction), pixmap(50, 50)
+PhaseButton::PhaseButton(const QString &_name, QGraphicsItem *parent, QAction *_doubleClickAction, bool _highlightable)
+	: QObject(), QGraphicsItem(parent), name(_name), active(false), highlightable(_highlightable), activeAnimationCounter(0), doubleClickAction(_doubleClickAction), width(50)
 {
-	setFocusPolicy(Qt::NoFocus);
-	setFixedSize(50, 50);
-	
+	if (highlightable) {
 		activeAnimationTimer = new QTimer(this);
 		connect(activeAnimationTimer, SIGNAL(timeout()), this, SLOT(updateAnimation()));
 		activeAnimationTimer->setSingleShot(false);
+	} else
+		activeAnimationCounter = 9.0;
 	
-	updatePixmap(pixmap);
+	setCacheMode(DeviceCoordinateCache);
 }
 
-void PhaseButton::updatePixmap(QPixmap &pixmap)
+QRectF PhaseButton::boundingRect() const
 {
-	pixmap.fill(Qt::transparent);
-	
-	QPainter painter(&pixmap);
-	int height = pixmap.height();
-	int width = pixmap.width();
-
-	icon().paint(&painter, 5, 5, width - 10, height - 10);
+	return QRectF(0, 0, width, width);
 }
 
-void PhaseButton::paintEvent(QPaintEvent */*event*/)
+void PhaseButton::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
 {
-	QPainter painter(this);
-
-	painter.setBrush(QColor(220 * (activeAnimationCounter / 10.0), 220 * (activeAnimationCounter / 10.0), 220 * (activeAnimationCounter / 10.0)));
-	painter.setPen(Qt::gray);
-	painter.drawRect(1, 1, pixmap.width() - 2, pixmap.height() - 2);
-
-	painter.drawPixmap(0, 0, size().width(), size().height(), pixmap);
+	QRectF iconRect = boundingRect().adjusted(3, 3, -3, -3);
+	QRectF translatedIconRect = painter->combinedTransform().mapRect(iconRect);
+	qreal scaleFactor = translatedIconRect.width() / iconRect.width();
+	QPixmap iconPixmap = PhasePixmapGenerator::generatePixmap(round(translatedIconRect.height()), name);
+	
+	painter->setBrush(QColor(220 * (activeAnimationCounter / 10.0), 220 * (activeAnimationCounter / 10.0), 220 * (activeAnimationCounter / 10.0)));
+	painter->setPen(Qt::gray);
+	painter->drawRect(0.5, 0.5, width - 1, width - 1);
+	painter->save();
+	painter->resetTransform();
+	painter->drawPixmap(iconPixmap.rect().translated(round(3 * scaleFactor), round(3 * scaleFactor)), iconPixmap, iconPixmap.rect());
+	painter->restore();
+	
+	painter->setBrush(QColor(0, 0, 0, 255 * ((10 - activeAnimationCounter) / 15.0)));
+	painter->setPen(Qt::gray);
+	painter->drawRect(0.5, 0.5, width - 1, width - 1);
+}
 
-//	painter.setBrush(QColor(220 * (activeAnimationCounter / 10.0), 220 * (activeAnimationCounter / 10.0), 220 * (activeAnimationCounter / 10.0), 255 * ((10 - activeAnimationCounter) / 15.0)));
-	painter.setBrush(QColor(0, 0, 0, 255 * ((10 - activeAnimationCounter) / 15.0)));
-	painter.setPen(Qt::gray);
-	painter.drawRect(1, 1, pixmap.width() - 2, pixmap.height() - 2);
+void PhaseButton::setWidth(double _width)
+{
+	prepareGeometryChange();
+	width = _width;
 }
 
 void PhaseButton::setActive(bool _active)
 {
-	if (active == _active)
+	if ((active == _active) || !highlightable)
 		return;
 	
 	active = _active;
@@ -57,6 +63,9 @@ void PhaseButton::setActive(bool _active)
 
 void PhaseButton::updateAnimation()
 {
+	if (!highlightable)
+		return;
+	
 	if (active) {
 		if (++activeAnimationCounter >= 10)
 			activeAnimationTimer->stop();
@@ -67,13 +76,12 @@ void PhaseButton::updateAnimation()
 	update();
 }
 
-void PhaseButton::setPhaseText(const QString &_phaseText)
+void PhaseButton::mousePressEvent(QGraphicsSceneMouseEvent * /*event*/)
 {
-	phaseText = _phaseText;
-	setToolTip(phaseText);
+	emit clicked();
 }
 
-void PhaseButton::mouseDoubleClickEvent(QMouseEvent */*event*/)
+void PhaseButton::mouseDoubleClickEvent(QGraphicsSceneMouseEvent */*event*/)
 {
 	triggerDoubleClickAction();
 }
@@ -84,34 +92,31 @@ void PhaseButton::triggerDoubleClickAction()
 		doubleClickAction->trigger();
 }
 
-PhasesToolbar::PhasesToolbar(QWidget *parent)
-	: QFrame(parent)
+PhasesToolbar::PhasesToolbar(QGraphicsItem *parent)
+	: QGraphicsItem(parent), width(100), height(100)
 {
-	setBackgroundRole(QPalette::Shadow);
-	setAutoFillBackground(true);
-	
 	QAction *aUntapAll = new QAction(this);
 	connect(aUntapAll, SIGNAL(triggered()), this, SLOT(actUntapAll()));
 	QAction *aDrawCard = new QAction(this);
 	connect(aDrawCard, SIGNAL(triggered()), this, SLOT(actDrawCard()));
 	
-	PhaseButton *untapButton = new PhaseButton(QIcon(":/resources/icon_phase_untap.svg"), aUntapAll);
-	untapButton->setShortcut(QKeySequence("F5"));
-	PhaseButton *upkeepButton = new PhaseButton(QIcon(":/resources/icon_phase_upkeep.svg"));
-	PhaseButton *drawButton = new PhaseButton(QIcon(":/resources/icon_phase_draw.svg"), aDrawCard);
-	drawButton->setShortcut(QKeySequence("F6"));
-	PhaseButton *main1Button = new PhaseButton(QIcon(":/resources/icon_phase_main1.svg"));
-	main1Button->setShortcut(QKeySequence("F7"));
-	PhaseButton *combatStartButton = new PhaseButton(QIcon(":/resources/icon_phase_combat_start.svg"));
-	combatStartButton->setShortcut(QKeySequence("F8"));
-	PhaseButton *combatAttackersButton = new PhaseButton(QIcon(":/resources/icon_phase_combat_attackers.svg"));
-	PhaseButton *combatBlockersButton = new PhaseButton(QIcon(":/resources/icon_phase_combat_blockers.svg"));
-	PhaseButton *combatDamageButton = new PhaseButton(QIcon(":/resources/icon_phase_combat_damage.svg"));
-	PhaseButton *combatEndButton = new PhaseButton(QIcon(":/resources/icon_phase_combat_end.svg"));
-	PhaseButton *main2Button = new PhaseButton(QIcon(":/resources/icon_phase_main2.svg"));
-	main2Button->setShortcut(QKeySequence("F9"));
-	PhaseButton *cleanupButton = new PhaseButton(QIcon(":/resources/icon_phase_cleanup.svg"));
-	cleanupButton->setShortcut(QKeySequence("F10"));
+	PhaseButton *untapButton = new PhaseButton("untap", this, aUntapAll);
+//	untapButton->setShortcut(QKeySequence("F5"));
+	PhaseButton *upkeepButton = new PhaseButton("upkeep", this);
+	PhaseButton *drawButton = new PhaseButton("draw", this, aDrawCard);
+//	drawButton->setShortcut(QKeySequence("F6"));
+	PhaseButton *main1Button = new PhaseButton("main1", this);
+//	main1Button->setShortcut(QKeySequence("F7"));
+	PhaseButton *combatStartButton = new PhaseButton("combat_start", this);
+//	combatStartButton->setShortcut(QKeySequence("F8"));
+	PhaseButton *combatAttackersButton = new PhaseButton("combat_attackers", this);
+	PhaseButton *combatBlockersButton = new PhaseButton("combat_blockers", this);
+	PhaseButton *combatDamageButton = new PhaseButton("combat_damage", this);
+	PhaseButton *combatEndButton = new PhaseButton("combat_end", this);
+	PhaseButton *main2Button = new PhaseButton("main2", this);
+//	main2Button->setShortcut(QKeySequence("F9"));
+	PhaseButton *cleanupButton = new PhaseButton("cleanup", this);
+//	cleanupButton->setShortcut(QKeySequence("F10"));
 	
 	buttonList << untapButton << upkeepButton << drawButton << main1Button << combatStartButton
 		<< combatAttackersButton << combatBlockersButton << combatDamageButton << combatEndButton
@@ -120,52 +125,85 @@ PhasesToolbar::PhasesToolbar(QWidget *parent)
 	for (int i = 0; i < buttonList.size(); ++i)
 		connect(buttonList[i], SIGNAL(clicked()), this, SLOT(phaseButtonClicked()));
 	
-	QPushButton *nextTurnButton = new QPushButton(QIcon(":/resources/icon_nextturn.svg"), QString());
-	nextTurnButton->setFocusPolicy(Qt::NoFocus);
-	nextTurnButton->setIconSize(QSize(40, 40));
-	nextTurnButton->setFixedSize(50, 50);
+	nextTurnButton = new PhaseButton("nextturn", this, 0, false);
 	connect(nextTurnButton, SIGNAL(clicked()), this, SLOT(actNextTurn()));
 	
-	QVBoxLayout *layout = new QVBoxLayout;
-	layout->setSpacing(0);
-	
-	layout->addStretch(1);
-	layout->addWidget(untapButton);
-	layout->addWidget(upkeepButton);
-	layout->addWidget(drawButton);
-	layout->addSpacing(10);
-	layout->addWidget(main1Button);
-	layout->addSpacing(10);
-	layout->addWidget(combatStartButton);
-	layout->addWidget(combatAttackersButton);
-	layout->addWidget(combatBlockersButton);
-	layout->addWidget(combatDamageButton);
-	layout->addWidget(combatEndButton);
-	layout->addSpacing(10);
-	layout->addWidget(main2Button);
-	layout->addSpacing(10);
-	layout->addWidget(cleanupButton);
-	layout->addSpacing(20);
-	layout->addWidget(nextTurnButton);
-	layout->addStretch(1);
+	rearrangeButtons();
 	
 	retranslateUi();
-	setLayout(layout);
+}
+
+QRectF PhasesToolbar::boundingRect() const
+{
+	return QRectF(0, 0, width, height);
 }
 
 void PhasesToolbar::retranslateUi()
 {
-	buttonList[0]->setPhaseText(tr("Untap step"));
-	buttonList[1]->setPhaseText(tr("Upkeep step"));
-	buttonList[2]->setPhaseText(tr("Draw step"));
-	buttonList[3]->setPhaseText(tr("First main phase"));
-	buttonList[4]->setPhaseText(tr("Beginning of combat step"));
-	buttonList[5]->setPhaseText(tr("Declare attackers step"));
-	buttonList[6]->setPhaseText(tr("Declare blockers step"));
-	buttonList[7]->setPhaseText(tr("Combat damage step"));
-	buttonList[8]->setPhaseText(tr("End of combat step"));
-	buttonList[9]->setPhaseText(tr("Second main phase"));
-	buttonList[10]->setPhaseText(tr("End of turn step"));
+	for (int i = 0; i < buttonList.size(); ++i)
+		buttonList[i]->setToolTip(getLongPhaseName(i));
+}
+
+QString PhasesToolbar::getLongPhaseName(int phase) const
+{
+	switch (phase) {
+		case 0: return tr("Untap step");
+		case 1: return tr("Upkeep step");
+		case 2: return tr("Draw step");
+		case 3: return tr("First main phase");
+		case 4: return tr("Beginning of combat step");
+		case 5: return tr("Declare attackers step");
+		case 6: return tr("Declare blockers step");
+		case 7: return tr("Combat damage step");
+		case 8: return tr("End of combat step");
+		case 9: return tr("Second main phase");
+		case 10: return tr("End of turn step");
+		default: return QString();
+	}
+}
+
+void PhasesToolbar::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
+{
+	painter->fillRect(boundingRect(), QColor(50, 50, 50));
+}
+
+void PhasesToolbar::rearrangeButtons()
+{
+	for (int i = 0; i < buttonList.size(); ++i)
+		buttonList[i]->setWidth(symbolSize);
+	nextTurnButton->setWidth(symbolSize);
+	
+	double y = margin;
+	buttonList[0]->setPos(margin, y);
+	buttonList[1]->setPos(margin, y += symbolSize);
+	buttonList[2]->setPos(margin, y += symbolSize);
+	y += ySpacing;
+	buttonList[3]->setPos(margin, y += symbolSize);
+	y += ySpacing;
+	buttonList[4]->setPos(margin, y += symbolSize);
+	buttonList[5]->setPos(margin, y += symbolSize);
+	buttonList[6]->setPos(margin, y += symbolSize);
+	buttonList[7]->setPos(margin, y += symbolSize);
+	buttonList[8]->setPos(margin, y += symbolSize);
+	y += ySpacing;
+	buttonList[9]->setPos(margin, y += symbolSize);
+	y += ySpacing;
+	buttonList[10]->setPos(margin, y += symbolSize);
+	y += ySpacing;
+	y += ySpacing;
+	nextTurnButton->setPos(margin, y += symbolSize);
+}
+
+void PhasesToolbar::setHeight(double _height)
+{
+	prepareGeometryChange();
+	
+	height = _height;
+	ySpacing = (height - 2 * margin) / (buttonCount * 5 + spaceCount);
+	symbolSize = ySpacing * 5;
+	width = symbolSize + 2 * margin;
+	
+	rearrangeButtons();
 }
 
 void PhasesToolbar::setActivePhase(int phase)

cockatrice/src/phasestoolbar.h

@@ -3,44 +3,57 @@
 
 #include <QFrame>
 #include <QList>
-#include <QPushButton>
+#include <QGraphicsObject>
 
 class Player;
 class GameCommand;
 
-class PhaseButton : public QPushButton {
+class PhaseButton : public QObject, public QGraphicsItem {
 	Q_OBJECT
 private:
-	QString phaseText;
-	bool active;
+	QString name;
+	bool active, highlightable;
 	int activeAnimationCounter;
 	QTimer *activeAnimationTimer;
 	QAction *doubleClickAction;
-	QPixmap pixmap;
+	double width;
 	
 	void updatePixmap(QPixmap &pixmap);
 private slots:
 	void updateAnimation();
 public:
-	PhaseButton(const QIcon &icon, QAction *_doubleClickAction = 0);
-	void setPhaseText(const QString &_phaseText);
-	QString getPhaseText() const { return phaseText; }
+	PhaseButton(const QString &_name, QGraphicsItem *parent = 0, QAction *_doubleClickAction = 0, bool _highlightable = true);
+	QRectF boundingRect() const;
+	void setWidth(double _width);
 	void setActive(bool _active);
 	bool getActive() const { return active; }
 	void triggerDoubleClickAction();
+signals:
+	void clicked();
 protected:
-	void paintEvent(QPaintEvent *event);
-	void mouseDoubleClickEvent(QMouseEvent *event);
+	void paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/);
+	void mousePressEvent(QGraphicsSceneMouseEvent *event);
+	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
 };
 
-class PhasesToolbar : public QFrame {
+class PhasesToolbar : public QObject, public QGraphicsItem {
 	Q_OBJECT
 private:
 	QList<PhaseButton *> buttonList;
+	PhaseButton *nextTurnButton;
+	double width, height, ySpacing, symbolSize;
+	static const int buttonCount = 12;
+	static const int spaceCount = 6;
+	static const double margin = 3;
+	void rearrangeButtons();
 public:
-	PhasesToolbar(QWidget *parent = 0);
+	PhasesToolbar(QGraphicsItem *parent = 0);
+	QRectF boundingRect() const;
 	void retranslateUi();
+	void setHeight(double _height);
+	double getWidth() const { return width; }
 	int phaseCount() const { return buttonList.size(); }
+	QString getLongPhaseName(int phase) const;
 public slots:
 	void setActivePhase(int phase);
 private slots:
@@ -50,6 +63,8 @@ private slots:
 	void actDrawCard();
 signals:
 	void sendGameCommand(GameCommand *command, int playerId);
+protected:
+	void paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/);
 };
 
 #endif