Skip to content
GitLab
Commit 1bc48a78 authored by Matt Kelly's avatar Matt Kelly
Browse files

Convert rest of source to 4-space indent

parent a171df74
Hide whitespace changes
Inline Side-by-side
cockatrice/src/abstractcarddragitem.cpp
View file @ 1bc48a78
...@@ -5,47 +5,47 @@ ...@@ -5,47 +5,47 @@
#include <QDebug> #include <QDebug>
AbstractCardDragItem::AbstractCardDragItem(AbstractCardItem *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag) AbstractCardDragItem::AbstractCardDragItem(AbstractCardItem *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag)
: QGraphicsItem(), item(_item), hotSpot(_hotSpot) : QGraphicsItem(), item(_item), hotSpot(_hotSpot)
{ {
if (parentDrag) { if (parentDrag) {
parentDrag->addChildDrag(this); parentDrag->addChildDrag(this);
setZValue(2000000007 + hotSpot.x() * 1000000 + hotSpot.y() * 1000 + 1000); setZValue(2000000007 + hotSpot.x() * 1000000 + hotSpot.y() * 1000 + 1000);
} else { } else {
if ((hotSpot.x() < 0) || (hotSpot.y() < 0)) { if ((hotSpot.x() < 0) || (hotSpot.y() < 0)) {
qDebug() << "CardDragItem: coordinate overflow: x =" << hotSpot.x() << ", y =" << hotSpot.y(); qDebug() << "CardDragItem: coordinate overflow: x =" << hotSpot.x() << ", y =" << hotSpot.y();
hotSpot = QPointF(); hotSpot = QPointF();
} else if ((hotSpot.x() > CARD_WIDTH) || (hotSpot.y() > CARD_HEIGHT)) { } else if ((hotSpot.x() > CARD_WIDTH) || (hotSpot.y() > CARD_HEIGHT)) {
qDebug() << "CardDragItem: coordinate overflow: x =" << hotSpot.x() << ", y =" << hotSpot.y(); qDebug() << "CardDragItem: coordinate overflow: x =" << hotSpot.x() << ", y =" << hotSpot.y();
hotSpot = QPointF(CARD_WIDTH, CARD_HEIGHT); hotSpot = QPointF(CARD_WIDTH, CARD_HEIGHT);
} }
setCursor(Qt::ClosedHandCursor); setCursor(Qt::ClosedHandCursor);
setZValue(2000000007); setZValue(2000000007);
} }
if (item->getTapped()) if (item->getTapped())
setTransform(QTransform().translate((float) CARD_WIDTH / 2, (float) CARD_HEIGHT / 2).rotate(90).translate((float) -CARD_WIDTH / 2, (float) -CARD_HEIGHT / 2)); setTransform(QTransform().translate((float) CARD_WIDTH / 2, (float) CARD_HEIGHT / 2).rotate(90).translate((float) -CARD_WIDTH / 2, (float) -CARD_HEIGHT / 2));
setCacheMode(DeviceCoordinateCache); setCacheMode(DeviceCoordinateCache);
} }
AbstractCardDragItem::~AbstractCardDragItem() AbstractCardDragItem::~AbstractCardDragItem()
{ {
qDebug("CardDragItem destructor"); qDebug("CardDragItem destructor");
for (int i = 0; i < childDrags.size(); i++) for (int i = 0; i < childDrags.size(); i++)
delete childDrags[i]; delete childDrags[i];
} }
void AbstractCardDragItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) void AbstractCardDragItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{ {
item->paint(painter, option, widget); item->paint(painter, option, widget);
} }
void AbstractCardDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) void AbstractCardDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{ {
event->accept(); event->accept();
updatePosition(event->scenePos()); updatePosition(event->scenePos());
} }
void AbstractCardDragItem::addChildDrag(AbstractCardDragItem *child) void AbstractCardDragItem::addChildDrag(AbstractCardDragItem *child)
{ {
childDrags << child; childDrags << child;
} }
cockatrice/src/abstractcarddragitem.h
View file @ 1bc48a78
...@@ -8,24 +8,24 @@ class CardZone; ...@@ -8,24 +8,24 @@ class CardZone;
class CardInfo; class CardInfo;
class AbstractCardDragItem : public QObject, public QGraphicsItem { class AbstractCardDragItem : public QObject, public QGraphicsItem {
Q_OBJECT Q_OBJECT
protected: protected:
AbstractCardItem *item; AbstractCardItem *item;
QPointF hotSpot; QPointF hotSpot;
QList<AbstractCardDragItem *> childDrags; QList<AbstractCardDragItem *> childDrags;
public: public:
enum { Type = typeCardDrag }; enum { Type = typeCardDrag };
int type() const { return Type; } int type() const { return Type; }
AbstractCardDragItem(AbstractCardItem *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag = 0); AbstractCardDragItem(AbstractCardItem *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag = 0);
~AbstractCardDragItem(); ~AbstractCardDragItem();
QRectF boundingRect() const { return QRectF(0, 0, CARD_WIDTH, CARD_HEIGHT); } QRectF boundingRect() const { return QRectF(0, 0, CARD_WIDTH, CARD_HEIGHT); }
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
AbstractCardItem *getItem() const { return item; } AbstractCardItem *getItem() const { return item; }
QPointF getHotSpot() const { return hotSpot; } QPointF getHotSpot() const { return hotSpot; }
void addChildDrag(AbstractCardDragItem *child); void addChildDrag(AbstractCardDragItem *child);
virtual void updatePosition(const QPointF &cursorScenePos) = 0; virtual void updatePosition(const QPointF &cursorScenePos) = 0;
protected: protected:
void mouseMoveEvent(QGraphicsSceneMouseEvent *event); void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
}; };
#endif #endif
cockatrice/src/abstractcarditem.cpp
View file @ 1bc48a78
...@@ -12,245 +12,245 @@ ...@@ -12,245 +12,245 @@
#include <QDebug> #include <QDebug>
AbstractCardItem::AbstractCardItem(const QString &_name, Player *_owner, int _id, QGraphicsItem *parent) AbstractCardItem::AbstractCardItem(const QString &_name, Player *_owner, int _id, QGraphicsItem *parent)
: ArrowTarget(_owner, parent), infoWidget(0), id(_id), name(_name), tapped(false), facedown(false), tapAngle(0), isHovered(false), realZValue(0) : ArrowTarget(_owner, parent), infoWidget(0), id(_id), name(_name), tapped(false), facedown(false), tapAngle(0), isHovered(false), realZValue(0)
{ {
setCursor(Qt::OpenHandCursor); setCursor(Qt::OpenHandCursor);
setFlag(ItemIsSelectable); setFlag(ItemIsSelectable);
setCacheMode(DeviceCoordinateCache); setCacheMode(DeviceCoordinateCache);
connect(db, SIGNAL(cardListChanged()), this, SLOT(cardInfoUpdated())); connect(db, SIGNAL(cardListChanged()), this, SLOT(cardInfoUpdated()));
connect(settingsCache, SIGNAL(displayCardNamesChanged()), this, SLOT(callUpdate())); connect(settingsCache, SIGNAL(displayCardNamesChanged()), this, SLOT(callUpdate()));
cardInfoUpdated(); cardInfoUpdated();
} }
AbstractCardItem::~AbstractCardItem() AbstractCardItem::~AbstractCardItem()
{ {
emit deleteCardInfoPopup(name); emit deleteCardInfoPopup(name);
} }
QRectF AbstractCardItem::boundingRect() const QRectF AbstractCardItem::boundingRect() const
{ {
return QRectF(0, 0, CARD_WIDTH, CARD_HEIGHT); return QRectF(0, 0, CARD_WIDTH, CARD_HEIGHT);
} }
void AbstractCardItem::pixmapUpdated() void AbstractCardItem::pixmapUpdated()
{ {
update(); update();
emit sigPixmapUpdated(); emit sigPixmapUpdated();
} }
void AbstractCardItem::cardInfoUpdated() void AbstractCardItem::cardInfoUpdated()
{ {
info = db->getCard(name); info = db->getCard(name);
connect(info, SIGNAL(pixmapUpdated()), this, SLOT(pixmapUpdated())); connect(info, SIGNAL(pixmapUpdated()), this, SLOT(pixmapUpdated()));
} }
void AbstractCardItem::setRealZValue(qreal _zValue) void AbstractCardItem::setRealZValue(qreal _zValue)
{ {
realZValue = _zValue; realZValue = _zValue;
setZValue(_zValue); setZValue(_zValue);
} }
QSizeF AbstractCardItem::getTranslatedSize(QPainter *painter) const QSizeF AbstractCardItem::getTranslatedSize(QPainter *painter) const
{ {
return QSizeF( return QSizeF(
painter->combinedTransform().map(QLineF(0, 0, boundingRect().width(), 0)).length(), painter->combinedTransform().map(QLineF(0, 0, boundingRect().width(), 0)).length(),
painter->combinedTransform().map(QLineF(0, 0, 0, boundingRect().height())).length() painter->combinedTransform().map(QLineF(0, 0, 0, boundingRect().height())).length()
); );
} }
void AbstractCardItem::transformPainter(QPainter *painter, const QSizeF &translatedSize, int angle) void AbstractCardItem::transformPainter(QPainter *painter, const QSizeF &translatedSize, int angle)
{ {
QRectF totalBoundingRect = painter->combinedTransform().mapRect(boundingRect()); QRectF totalBoundingRect = painter->combinedTransform().mapRect(boundingRect());
painter->resetTransform(); painter->resetTransform();
QTransform pixmapTransform; QTransform pixmapTransform;
pixmapTransform.translate(totalBoundingRect.width() / 2, totalBoundingRect.height() / 2); pixmapTransform.translate(totalBoundingRect.width() / 2, totalBoundingRect.height() / 2);
pixmapTransform.rotate(angle); pixmapTransform.rotate(angle);
pixmapTransform.translate(-translatedSize.width() / 2, -translatedSize.height() / 2); pixmapTransform.translate(-translatedSize.width() / 2, -translatedSize.height() / 2);
painter->setTransform(pixmapTransform); painter->setTransform(pixmapTransform);
QFont f; QFont f;
int fontSize = round(translatedSize.height() / 8); int fontSize = round(translatedSize.height() / 8);
if (fontSize < 9) if (fontSize < 9)
fontSize = 9; fontSize = 9;
if (fontSize > 10) if (fontSize > 10)
fontSize = 10; fontSize = 10;
f.setPixelSize(fontSize); f.setPixelSize(fontSize);
painter->setFont(f); painter->setFont(f);
} }
void AbstractCardItem::paintPicture(QPainter *painter, const QSizeF &translatedSize, int angle) void AbstractCardItem::paintPicture(QPainter *painter, const QSizeF &translatedSize, int angle)
{ {
qreal scaleFactor = translatedSize.width() / boundingRect().width(); qreal scaleFactor = translatedSize.width() / boundingRect().width();
CardInfo *imageSource = facedown ? db->getCard() : info; CardInfo *imageSource = facedown ? db->getCard() : info;
QPixmap *translatedPixmap = imageSource->getPixmap(translatedSize.toSize()); QPixmap *translatedPixmap = imageSource->getPixmap(translatedSize.toSize());
painter->save(); painter->save();
QColor bgColor = Qt::transparent; QColor bgColor = Qt::transparent;
if (translatedPixmap) { if (translatedPixmap) {
painter->save(); painter->save();
transformPainter(painter, translatedSize, angle); transformPainter(painter, translatedSize, angle);
painter->drawPixmap(QPointF(0, 0), *translatedPixmap); painter->drawPixmap(QPointF(0, 0), *translatedPixmap);
painter->restore(); painter->restore();
} else { } else {
QString colorStr; QString colorStr;
if (!color.isEmpty()) if (!color.isEmpty())
colorStr = color; colorStr = color;
else if (info->getColors().size() > 1) else if (info->getColors().size() > 1)
colorStr = "m"; colorStr = "m";
else if (!info->getColors().isEmpty()) else if (!info->getColors().isEmpty())
colorStr = info->getColors().first().toLower(); colorStr = info->getColors().first().toLower();
if (colorStr == "b") if (colorStr == "b")
bgColor = QColor(0, 0, 0); bgColor = QColor(0, 0, 0);
else if (colorStr == "u") else if (colorStr == "u")
bgColor = QColor(0, 140, 180); bgColor = QColor(0, 140, 180);
else if (colorStr == "w") else if (colorStr == "w")
bgColor = QColor(255, 250, 140); bgColor = QColor(255, 250, 140);
else if (colorStr == "r") else if (colorStr == "r")
bgColor = QColor(230, 0, 0); bgColor = QColor(230, 0, 0);
else if (colorStr == "g") else if (colorStr == "g")
bgColor = QColor(0, 160, 0); bgColor = QColor(0, 160, 0);
else if (colorStr == "m") else if (colorStr == "m")
bgColor = QColor(250, 190, 30); bgColor = QColor(250, 190, 30);
else else
bgColor = QColor(230, 230, 230); bgColor = QColor(230, 230, 230);
} }
painter->setBrush(bgColor); painter->setBrush(bgColor);
QPen pen(Qt::black); QPen pen(Qt::black);
pen.setWidth(2); pen.setWidth(2);
painter->setPen(pen); painter->setPen(pen);
painter->drawRect(QRectF(1, 1, CARD_WIDTH - 2, CARD_HEIGHT - 2)); painter->drawRect(QRectF(1, 1, CARD_WIDTH - 2, CARD_HEIGHT - 2));
if (!translatedPixmap || settingsCache->getDisplayCardNames() || facedown) { if (!translatedPixmap || settingsCache->getDisplayCardNames() || facedown) {
painter->save(); painter->save();
transformPainter(painter, translatedSize, angle); transformPainter(painter, translatedSize, angle);
painter->setPen(Qt::white); painter->setPen(Qt::white);
painter->setBackground(Qt::black); painter->setBackground(Qt::black);
painter->setBackgroundMode(Qt::OpaqueMode); painter->setBackgroundMode(Qt::OpaqueMode);
QString nameStr; QString nameStr;
if (facedown) if (facedown)
nameStr = "# " + QString::number(id); nameStr = "# " + QString::number(id);
else else
nameStr = name; nameStr = name;
painter->drawText(QRectF(3 * scaleFactor, 3 * scaleFactor, translatedSize.width() - 6 * scaleFactor, translatedSize.height() - 6 * scaleFactor), Qt::AlignTop | Qt::AlignLeft | Qt::TextWrapAnywhere, nameStr); painter->drawText(QRectF(3 * scaleFactor, 3 * scaleFactor, translatedSize.width() - 6 * scaleFactor, translatedSize.height() - 6 * scaleFactor), Qt::AlignTop | Qt::AlignLeft | Qt::TextWrapAnywhere, nameStr);
painter->restore(); painter->restore();
} }
painter->restore(); painter->restore();
} }
void AbstractCardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/) void AbstractCardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
{ {
painter->save(); painter->save();
QSizeF translatedSize = getTranslatedSize(painter); QSizeF translatedSize = getTranslatedSize(painter);
paintPicture(painter, translatedSize, tapAngle); paintPicture(painter, translatedSize, tapAngle);
painter->save(); painter->save();
painter->setRenderHint(QPainter::Antialiasing, false); painter->setRenderHint(QPainter::Antialiasing, false);
transformPainter(painter, translatedSize, tapAngle); transformPainter(painter, translatedSize, tapAngle);
if (isSelected()) { if (isSelected()) {
painter->setPen(Qt::red); painter->setPen(Qt::red);
painter->drawRect(QRectF(0.5, 0.5, translatedSize.width() - 1, translatedSize.height() - 1)); painter->drawRect(QRectF(0.5, 0.5, translatedSize.width() - 1, translatedSize.height() - 1));
} else if (isHovered) { } else if (isHovered) {
painter->setPen(Qt::yellow); painter->setPen(Qt::yellow);
painter->drawRect(QRectF(0.5, 0.5, translatedSize.width() - 1, translatedSize.height() - 1)); painter->drawRect(QRectF(0.5, 0.5, translatedSize.width() - 1, translatedSize.height() - 1));
} }
painter->restore(); painter->restore();
painter->restore(); painter->restore();
} }
void AbstractCardItem::setName(const QString &_name) void AbstractCardItem::setName(const QString &_name)
{ {
if (name == _name) if (name == _name)
return; return;
emit deleteCardInfoPopup(name); emit deleteCardInfoPopup(name);
disconnect(info, 0, this, 0); disconnect(info, 0, this, 0);
name = _name; name = _name;
info = db->getCard(name); info = db->getCard(name);
connect(info, SIGNAL(pixmapUpdated()), this, SLOT(pixmapUpdated())); connect(info, SIGNAL(pixmapUpdated()), this, SLOT(pixmapUpdated()));
update(); update();
} }
void AbstractCardItem::setHovered(bool _hovered) void AbstractCardItem::setHovered(bool _hovered)
{ {
if (isHovered == _hovered) if (isHovered == _hovered)
return; return;
if (_hovered) if (_hovered)
processHoverEvent(); processHoverEvent();
isHovered = _hovered; isHovered = _hovered;
setZValue(_hovered ? 2000000004 : realZValue); setZValue(_hovered ? 2000000004 : realZValue);
update(); update();
} }
void AbstractCardItem::setColor(const QString &_color) void AbstractCardItem::setColor(const QString &_color)
{ {
color = _color; color = _color;
update(); update();
} }
void AbstractCardItem::setTapped(bool _tapped, bool canAnimate) void AbstractCardItem::setTapped(bool _tapped, bool canAnimate)
{ {
if (tapped == _tapped) if (tapped == _tapped)
return; return;
tapped = _tapped; tapped = _tapped;
if (settingsCache->getTapAnimation() && canAnimate) if (settingsCache->getTapAnimation() && canAnimate)
static_cast<GameScene *>(scene())->registerAnimationItem(this); static_cast<GameScene *>(scene())->registerAnimationItem(this);
else { else {
tapAngle = tapped ? 90 : 0; tapAngle = tapped ? 90 : 0;
setTransform(QTransform().translate((float) CARD_WIDTH / 2, (float) CARD_HEIGHT / 2).rotate(tapAngle).translate((float) -CARD_WIDTH / 2, (float) -CARD_HEIGHT / 2)); setTransform(QTransform().translate((float) CARD_WIDTH / 2, (float) CARD_HEIGHT / 2).rotate(tapAngle).translate((float) -CARD_WIDTH / 2, (float) -CARD_HEIGHT / 2));
update(); update();
} }
} }
void AbstractCardItem::setFaceDown(bool _facedown) void AbstractCardItem::setFaceDown(bool _facedown)
{ {
facedown = _facedown; facedown = _facedown;
update(); update();
emit updateCardMenu(this); emit updateCardMenu(this);
} }
void AbstractCardItem::mousePressEvent(QGraphicsSceneMouseEvent *event) void AbstractCardItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{ {
if (!isSelected()) { if (!isSelected()) {
scene()->clearSelection(); scene()->clearSelection();
setSelected(true); setSelected(true);
} }
if (event->button() == Qt::LeftButton) if (event->button() == Qt::LeftButton)
setCursor(Qt::ClosedHandCursor); setCursor(Qt::ClosedHandCursor);
else if (event->button() == Qt::MidButton) else if (event->button() == Qt::MidButton)
emit showCardInfoPopup(event->screenPos(), name); emit showCardInfoPopup(event->screenPos(), name);
event->accept(); event->accept();
} }
void AbstractCardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) void AbstractCardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{ {
if (event->button() == Qt::MidButton) if (event->button() == Qt::MidButton)
emit deleteCardInfoPopup(name); emit deleteCardInfoPopup(name);
// This function ensures the parent function doesn't mess around with our selection. // This function ensures the parent function doesn't mess around with our selection.
event->accept(); event->accept();
} }
void AbstractCardItem::processHoverEvent() void AbstractCardItem::processHoverEvent()
{ {
emit hovered(this); emit hovered(this);
} }
QVariant AbstractCardItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value) QVariant AbstractCardItem::itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value)
{ {
if (change == ItemSelectedHasChanged) { if (change == ItemSelectedHasChanged) {
update(); update();
return value; return value;
} else } else
return QGraphicsItem::itemChange(change, value); return QGraphicsItem::itemChange(change, value);
} }
cockatrice/src/abstractcarditem.h
View file @ 1bc48a78
...@@ -12,59 +12,59 @@ const int CARD_WIDTH = 72; ...@@ -12,59 +12,59 @@ const int CARD_WIDTH = 72;
const int CARD_HEIGHT = 102; const int CARD_HEIGHT = 102;
class AbstractCardItem : public ArrowTarget { class AbstractCardItem : public ArrowTarget {
Q_OBJECT Q_OBJECT
protected: protected:
CardInfo *info; CardInfo *info;
CardInfoWidget *infoWidget; CardInfoWidget *infoWidget;
int id; int id;
QString name; QString name;
bool tapped; bool tapped;
bool facedown; bool facedown;
int tapAngle; int tapAngle;
QString color; QString color;
private: private:
bool isHovered; bool isHovered;
qreal realZValue; qreal realZValue;
private slots: private slots:
void pixmapUpdated(); void pixmapUpdated();
void cardInfoUpdated(); void cardInfoUpdated();
void callUpdate() { update(); } void callUpdate() { update(); }
signals: signals:
void hovered(AbstractCardItem *card); void hovered(AbstractCardItem *card);
void showCardInfoPopup(QPoint pos, QString cardName); void showCardInfoPopup(QPoint pos, QString cardName);
void deleteCardInfoPopup(QString cardName); void deleteCardInfoPopup(QString cardName);
void updateCardMenu(AbstractCardItem *card); void updateCardMenu(AbstractCardItem *card);
void sigPixmapUpdated(); void sigPixmapUpdated();
public: public:
enum { Type = typeCard }; enum { Type = typeCard };
int type() const { return Type; } int type() const { return Type; }
AbstractCardItem(const QString &_name = QString(), Player *_owner = 0, int _id = -1, QGraphicsItem *parent = 0); AbstractCardItem(const QString &_name = QString(), Player *_owner = 0, int _id = -1, QGraphicsItem *parent = 0);
~AbstractCardItem(); ~AbstractCardItem();
QRectF boundingRect() const; QRectF boundingRect() const;
QSizeF getTranslatedSize(QPainter *painter) const; QSizeF getTranslatedSize(QPainter *painter) const;
void paintPicture(QPainter *painter, const QSizeF &translatedSize, int angle); void paintPicture(QPainter *painter, const QSizeF &translatedSize, int angle);
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
CardInfo *getInfo() const { return info; } CardInfo *getInfo() const { return info; }
int getId() const { return id; } int getId() const { return id; }
void setId(int _id) { id = _id; } void setId(int _id) { id = _id; }
QString getName() const { return name; } QString getName() const { return name; }
void setName(const QString &_name = QString()); void setName(const QString &_name = QString());
qreal getRealZValue() const { return realZValue; } qreal getRealZValue() const { return realZValue; }
void setRealZValue(qreal _zValue); void setRealZValue(qreal _zValue);
void setHovered(bool _hovered); void setHovered(bool _hovered);
QString getColor() const { return color; } QString getColor() const { return color; }
void setColor(const QString &_color); void setColor(const QString &_color);
bool getTapped() const { return tapped; } bool getTapped() const { return tapped; }
void setTapped(bool _tapped, bool canAnimate = false); void setTapped(bool _tapped, bool canAnimate = false);
bool getFaceDown() const { return facedown; } bool getFaceDown() const { return facedown; }
void setFaceDown(bool _facedown); void setFaceDown(bool _facedown);
void processHoverEvent(); void processHoverEvent();
void deleteCardInfoPopup() { emit deleteCardInfoPopup(name); } void deleteCardInfoPopup() { emit deleteCardInfoPopup(name); }
protected: protected:
void transformPainter(QPainter *painter, const QSizeF &translatedSize, int angle); void transformPainter(QPainter *painter, const QSizeF &translatedSize, int angle);
void mousePressEvent(QGraphicsSceneMouseEvent *event); void mousePressEvent(QGraphicsSceneMouseEvent *event);
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value); QVariant itemChange(QGraphicsItem::GraphicsItemChange change, const QVariant &value);
}; };
#endif #endif
cockatrice/src/abstractclient.h
View file @ 1bc48a78
...@@ -26,67 +26,67 @@ class Event_ServerShutdown; ...@@ -26,67 +26,67 @@ class Event_ServerShutdown;
class Event_ReplayAdded; class Event_ReplayAdded;
enum ClientStatus { enum ClientStatus {
StatusDisconnected, StatusDisconnected,
StatusDisconnecting, StatusDisconnecting,
StatusConnecting, StatusConnecting,
StatusAwaitingWelcome, StatusAwaitingWelcome,
StatusLoggingIn, StatusLoggingIn,
StatusLoggedIn, StatusLoggedIn,
}; };
class AbstractClient : public QObject { class AbstractClient : public QObject {
Q_OBJECT Q_OBJECT
signals: signals:
void statusChanged(ClientStatus _status); void statusChanged(ClientStatus _status);
// Room events // Room events
void roomEventReceived(const RoomEvent &event); void roomEventReceived(const RoomEvent &event);
// Game events // Game events
void gameEventContainerReceived(const GameEventContainer &event); void gameEventContainerReceived(const GameEventContainer &event);
// Session events // Session events
void serverIdentificationEventReceived(const Event_ServerIdentification &event); void serverIdentificationEventReceived(const Event_ServerIdentification &event);
void connectionClosedEventReceived(const Event_ConnectionClosed &event); void connectionClosedEventReceived(const Event_ConnectionClosed &event);
void serverShutdownEventReceived(const Event_ServerShutdown &event); void serverShutdownEventReceived(const Event_ServerShutdown &event);
void addToListEventReceived(const Event_AddToList &event); void addToListEventReceived(const Event_AddToList &event);
void removeFromListEventReceived(const Event_RemoveFromList &event); void removeFromListEventReceived(const Event_RemoveFromList &event);
void userJoinedEventReceived(const Event_UserJoined &event); void userJoinedEventReceived(const Event_UserJoined &event);
void userLeftEventReceived(const Event_UserLeft &event); void userLeftEventReceived(const Event_UserLeft &event);
void serverMessageEventReceived(const Event_ServerMessage &event); void serverMessageEventReceived(const Event_ServerMessage &event);
void listRoomsEventReceived(const Event_ListRooms &event); void listRoomsEventReceived(const Event_ListRooms &event);
void gameJoinedEventReceived(const Event_GameJoined &event); void gameJoinedEventReceived(const Event_GameJoined &event);
void userMessageEventReceived(const Event_UserMessage &event); void userMessageEventReceived(const Event_UserMessage &event);
void userInfoChanged(const ServerInfo_User &userInfo); void userInfoChanged(const ServerInfo_User &userInfo);
void buddyListReceived(const QList<ServerInfo_User> &buddyList); void buddyListReceived(const QList<ServerInfo_User> &buddyList);
void ignoreListReceived(const QList<ServerInfo_User> &ignoreList); void ignoreListReceived(const QList<ServerInfo_User> &ignoreList);
void replayAddedEventReceived(const Event_ReplayAdded &event); void replayAddedEventReceived(const Event_ReplayAdded &event);
void sigQueuePendingCommand(PendingCommand *pend); void sigQueuePendingCommand(PendingCommand *pend);
private: private:
int nextCmdId; int nextCmdId;
mutable QMutex clientMutex; mutable QMutex clientMutex;
ClientStatus status; ClientStatus status;
private slots: private slots:
void queuePendingCommand(PendingCommand *pend); void queuePendingCommand(PendingCommand *pend);
protected slots: protected slots:
void processProtocolItem(const ServerMessage &item); void processProtocolItem(const ServerMessage &item);
protected: protected:
QMap<int, PendingCommand *> pendingCommands; QMap<int, PendingCommand *> pendingCommands;
QString userName, password; QString userName, password;
void setStatus(ClientStatus _status); void setStatus(ClientStatus _status);
int getNewCmdId() { return nextCmdId++; } int getNewCmdId() { return nextCmdId++; }
virtual void sendCommandContainer(const CommandContainer &cont) = 0; virtual void sendCommandContainer(const CommandContainer &cont) = 0;
public: public:
AbstractClient(QObject *parent = 0); AbstractClient(QObject *parent = 0);
~AbstractClient(); ~AbstractClient();
ClientStatus getStatus() const { QMutexLocker locker(&clientMutex); return status; } ClientStatus getStatus() const { QMutexLocker locker(&clientMutex); return status; }
void sendCommand(const CommandContainer &cont); void sendCommand(const CommandContainer &cont);
void sendCommand(PendingCommand *pend); void sendCommand(PendingCommand *pend);
static PendingCommand *prepareSessionCommand(const ::google::protobuf::Message &cmd); static PendingCommand *prepareSessionCommand(const ::google::protobuf::Message &cmd);
static PendingCommand *prepareRoomCommand(const ::google::protobuf::Message &cmd, int roomId); static PendingCommand *prepareRoomCommand(const ::google::protobuf::Message &cmd, int roomId);
static PendingCommand *prepareModeratorCommand(const ::google::protobuf::Message &cmd); static PendingCommand *prepareModeratorCommand(const ::google::protobuf::Message &cmd);
static PendingCommand *prepareAdminCommand(const ::google::protobuf::Message &cmd); static PendingCommand *prepareAdminCommand(const ::google::protobuf::Message &cmd);
}; };
#endif #endif
cockatrice/src/abstractcounter.cpp
View file @ 1bc48a78
...@@ -9,137 +9,137 @@ ...@@ -9,137 +9,137 @@
#include "pb/command_set_counter.pb.h" #include "pb/command_set_counter.pb.h"
AbstractCounter::AbstractCounter(Player *_player, int _id, const QString &_name, bool _shownInCounterArea, int _value, QGraphicsItem *parent) AbstractCounter::AbstractCounter(Player *_player, int _id, const QString &_name, bool _shownInCounterArea, int _value, QGraphicsItem *parent)
: QGraphicsItem(parent), player(_player), id(_id), name(_name), value(_value), hovered(false), aDec(0), aInc(0), dialogSemaphore(false), deleteAfterDialog(false), shownInCounterArea(_shownInCounterArea) : QGraphicsItem(parent), player(_player), id(_id), name(_name), value(_value), hovered(false), aDec(0), aInc(0), dialogSemaphore(false), deleteAfterDialog(false), shownInCounterArea(_shownInCounterArea)
{ {
setAcceptsHoverEvents(true); setAcceptsHoverEvents(true);
if (player->getLocal()) { if (player->getLocal()) {
menu = new QMenu(name); menu = new QMenu(name);
aSet = new QAction(this); aSet = new QAction(this);
connect(aSet, SIGNAL(triggered()), this, SLOT(setCounter())); connect(aSet, SIGNAL(triggered()), this, SLOT(setCounter()));
menu->addAction(aSet); menu->addAction(aSet);
menu->addSeparator(); menu->addSeparator();
for (int i = -10; i <= 10; ++i) for (int i = -10; i <= 10; ++i)
if (i == 0) if (i == 0)
menu->addSeparator(); menu->addSeparator();
else { else {
QAction *aIncrement = new QAction(QString(i < 0 ? "%1" : "+%1").arg(i), this); QAction *aIncrement = new QAction(QString(i < 0 ? "%1" : "+%1").arg(i), this);
if (i == -1) if (i == -1)
aDec = aIncrement; aDec = aIncrement;
else if (i == 1) else if (i == 1)
aInc = aIncrement; aInc = aIncrement;
aIncrement->setData(i); aIncrement->setData(i);
connect(aIncrement, SIGNAL(triggered()), this, SLOT(incrementCounter())); connect(aIncrement, SIGNAL(triggered()), this, SLOT(incrementCounter()));
menu->addAction(aIncrement); menu->addAction(aIncrement);
} }
} else } else
menu = 0; menu = 0;
retranslateUi(); retranslateUi();
} }
AbstractCounter::~AbstractCounter() AbstractCounter::~AbstractCounter()
{ {
delete menu; delete menu;
} }
void AbstractCounter::delCounter() void AbstractCounter::delCounter()
{ {
if (dialogSemaphore) if (dialogSemaphore)
deleteAfterDialog = true; deleteAfterDialog = true;
else else
deleteLater(); deleteLater();
} }
void AbstractCounter::retranslateUi() void AbstractCounter::retranslateUi()
{ {
if (menu) { if (menu) {
aSet->setText(tr("&Set counter...")); aSet->setText(tr("&Set counter..."));
} }
} }
void AbstractCounter::setShortcutsActive() void AbstractCounter::setShortcutsActive()
{ {
if (name == "life") { if (name == "life") {
aSet->setShortcut(tr("Ctrl+L")); aSet->setShortcut(tr("Ctrl+L"));
aDec->setShortcut(tr("F11")); aDec->setShortcut(tr("F11"));
aInc->setShortcut(tr("F12")); aInc->setShortcut(tr("F12"));
} }
} }
void AbstractCounter::setShortcutsInactive() void AbstractCounter::setShortcutsInactive()
{ {
if (name == "life") { if (name == "life") {
aSet->setShortcut(QKeySequence()); aSet->setShortcut(QKeySequence());
aDec->setShortcut(QKeySequence()); aDec->setShortcut(QKeySequence());
aInc->setShortcut(QKeySequence()); aInc->setShortcut(QKeySequence());
} }
} }
void AbstractCounter::setValue(int _value) void AbstractCounter::setValue(int _value)
{ {
value = _value; value = _value;
update(); update();
} }
void AbstractCounter::mousePressEvent(QGraphicsSceneMouseEvent *event) void AbstractCounter::mousePressEvent(QGraphicsSceneMouseEvent *event)
{ {
if (event->button() == Qt::LeftButton) { if (event->button() == Qt::LeftButton) {
Command_IncCounter cmd; Command_IncCounter cmd;
cmd.set_counter_id(id); cmd.set_counter_id(id);
cmd.set_delta(1); cmd.set_delta(1);
player->sendGameCommand(cmd); player->sendGameCommand(cmd);
event->accept(); event->accept();
} else if (event->button() == Qt::RightButton) { } else if (event->button() == Qt::RightButton) {
Command_IncCounter cmd; Command_IncCounter cmd;
cmd.set_counter_id(id); cmd.set_counter_id(id);
cmd.set_delta(-1); cmd.set_delta(-1);
player->sendGameCommand(cmd); player->sendGameCommand(cmd);
event->accept(); event->accept();
} else if (event->button() == Qt::MidButton) { } else if (event->button() == Qt::MidButton) {
if (menu) if (menu)
menu->exec(event->screenPos()); menu->exec(event->screenPos());
event->accept(); event->accept();
} else } else
event->ignore(); event->ignore();
} }
void AbstractCounter::hoverEnterEvent(QGraphicsSceneHoverEvent * /*event*/) void AbstractCounter::hoverEnterEvent(QGraphicsSceneHoverEvent * /*event*/)
{ {
hovered = true; hovered = true;
update(); update();
} }
void AbstractCounter::hoverLeaveEvent(QGraphicsSceneHoverEvent * /*event*/) void AbstractCounter::hoverLeaveEvent(QGraphicsSceneHoverEvent * /*event*/)
{ {
hovered = false; hovered = false;
update(); update();
} }
void AbstractCounter::incrementCounter() void AbstractCounter::incrementCounter()
{ {
const int delta = static_cast<QAction *>(sender())->data().toInt(); const int delta = static_cast<QAction *>(sender())->data().toInt();
Command_IncCounter cmd; Command_IncCounter cmd;
cmd.set_counter_id(id); cmd.set_counter_id(id);
cmd.set_delta(delta); cmd.set_delta(delta);
player->sendGameCommand(cmd); player->sendGameCommand(cmd);
} }
void AbstractCounter::setCounter() void AbstractCounter::setCounter()
{ {
bool ok; bool ok;
dialogSemaphore = true; dialogSemaphore = true;
int newValue = QInputDialog::getInteger(0, tr("Set counter"), tr("New value for counter '%1':").arg(name), value, -2000000000, 2000000000, 1, &ok); int newValue = QInputDialog::getInteger(0, tr("Set counter"), tr("New value for counter '%1':").arg(name), value, -2000000000, 2000000000, 1, &ok);
if (deleteAfterDialog) { if (deleteAfterDialog) {
deleteLater(); deleteLater();
return; return;
} }
dialogSemaphore = false; dialogSemaphore = false;
if (!ok) if (!ok)
return; return;
Command_SetCounter cmd; Command_SetCounter cmd;
cmd.set_counter_id(id); cmd.set_counter_id(id);
cmd.set_value(newValue); cmd.set_value(newValue);
player->sendGameCommand(cmd); player->sendGameCommand(cmd);
} }
cockatrice/src/abstractcounter.h
View file @ 1bc48a78
...@@ -8,41 +8,41 @@ class QMenu; ...@@ -8,41 +8,41 @@ class QMenu;
class QAction; class QAction;
class AbstractCounter : public QObject, public QGraphicsItem { class AbstractCounter : public QObject, public QGraphicsItem {
Q_OBJECT Q_OBJECT
protected: protected:
Player *player; Player *player;
int id; int id;
QString name; QString name;
int value; int value;
bool hovered; bool hovered;
void mousePressEvent(QGraphicsSceneMouseEvent *event); void mousePressEvent(QGraphicsSceneMouseEvent *event);
void hoverEnterEvent(QGraphicsSceneHoverEvent *event); void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
void hoverLeaveEvent(QGraphicsSceneHoverEvent *event); void hoverLeaveEvent(QGraphicsSceneHoverEvent *event);
private: private:
QAction *aSet, *aDec, *aInc; QAction *aSet, *aDec, *aInc;
QMenu *menu; QMenu *menu;
bool dialogSemaphore, deleteAfterDialog; bool dialogSemaphore, deleteAfterDialog;
bool shownInCounterArea; bool shownInCounterArea;
private slots: private slots:
void incrementCounter(); void incrementCounter();
void setCounter(); void setCounter();
public: public:
AbstractCounter(Player *_player, int _id, const QString &_name, bool _shownInCounterArea, int _value, QGraphicsItem *parent = 0); AbstractCounter(Player *_player, int _id, const QString &_name, bool _shownInCounterArea, int _value, QGraphicsItem *parent = 0);
~AbstractCounter(); ~AbstractCounter();
QMenu *getMenu() const { return menu; } QMenu *getMenu() const { return menu; }
void retranslateUi(); void retranslateUi();
int getId() const { return id; } int getId() const { return id; }
QString getName() const { return name; } QString getName() const { return name; }
bool getShownInCounterArea() const { return shownInCounterArea; } bool getShownInCounterArea() const { return shownInCounterArea; }
int getValue() const { return value; } int getValue() const { return value; }
void setValue(int _value); void setValue(int _value);
void delCounter(); void delCounter();
void setShortcutsActive(); void setShortcutsActive();
void setShortcutsInactive(); void setShortcutsInactive();
}; };
#endif #endif
cockatrice/src/abstractgraphicsitem.cpp
View file @ 1bc48a78
...@@ -3,48 +3,48 @@ ...@@ -3,48 +3,48 @@
void AbstractGraphicsItem::paintNumberEllipse(int number, int fontSize, const QColor &color, int position, int count, QPainter *painter) void AbstractGraphicsItem::paintNumberEllipse(int number, int fontSize, const QColor &color, int position, int count, QPainter *painter)
{ {
painter->save(); painter->save();
QString numStr = QString::number(number); QString numStr = QString::number(number);
QFont font("Serif"); QFont font("Serif");
font.setPixelSize(fontSize); font.setPixelSize(fontSize);
font.setWeight(QFont::Bold); font.setWeight(QFont::Bold);
QFontMetrics fm(font); QFontMetrics fm(font);
double w = fm.width(numStr) * 1.3; double w = fm.width(numStr) * 1.3;
double h = fm.height() * 1.3; double h = fm.height() * 1.3;
if (w < h) if (w < h)
w = h; w = h;
painter->setPen(QColor(255, 255, 255, 0)); painter->setPen(QColor(255, 255, 255, 0));
QRadialGradient grad(QPointF(0.5, 0.5), 0.5); QRadialGradient grad(QPointF(0.5, 0.5), 0.5);
grad.setCoordinateMode(QGradient::ObjectBoundingMode); grad.setCoordinateMode(QGradient::ObjectBoundingMode);
QColor color1(color), color2(color); QColor color1(color), color2(color);
color1.setAlpha(255); color1.setAlpha(255);
color2.setAlpha(0); color2.setAlpha(0);
grad.setColorAt(0, color1); grad.setColorAt(0, color1);
grad.setColorAt(0.8, color1); grad.setColorAt(0.8, color1);
grad.setColorAt(1, color2); grad.setColorAt(1, color2);
painter->setBrush(QBrush(grad)); painter->setBrush(QBrush(grad));
QRectF textRect; QRectF textRect;
if (position == -1) if (position == -1)
textRect = QRectF((boundingRect().width() - w) / 2.0, (boundingRect().height() - h) / 2.0, w, h); textRect = QRectF((boundingRect().width() - w) / 2.0, (boundingRect().height() - h) / 2.0, w, h);
else { else {
qreal xOffset = 10; qreal xOffset = 10;
qreal yOffset = 20; qreal yOffset = 20;
qreal spacing = 2; qreal spacing = 2;
if (position < 2) if (position < 2)
textRect = QRectF(count == 1 ? ((boundingRect().width() - w) / 2.0) : (position % 2 == 0 ? xOffset : (boundingRect().width() - xOffset - w)), yOffset, w, h); textRect = QRectF(count == 1 ? ((boundingRect().width() - w) / 2.0) : (position % 2 == 0 ? xOffset : (boundingRect().width() - xOffset - w)), yOffset, w, h);
else else
textRect = QRectF(count == 3 ? ((boundingRect().width() - w) / 2.0) : (position % 2 == 0 ? xOffset : (boundingRect().width() - xOffset - w)), yOffset + (spacing + h) * (position / 2), w, h); textRect = QRectF(count == 3 ? ((boundingRect().width() - w) / 2.0) : (position % 2 == 0 ? xOffset : (boundingRect().width() - xOffset - w)), yOffset + (spacing + h) * (position / 2), w, h);
} }
painter->drawEllipse(textRect); painter->drawEllipse(textRect);
painter->setPen(Qt::black); painter->setPen(Qt::black);
painter->setFont(font); painter->setFont(font);
painter->drawText(textRect, Qt::AlignCenter, numStr); painter->drawText(textRect, Qt::AlignCenter, numStr);
painter->restore(); painter->restore();
} }
cockatrice/src/abstractgraphicsitem.h
View file @ 1bc48a78
...@@ -4,20 +4,20 @@ ...@@ -4,20 +4,20 @@
#include <QGraphicsItem> #include <QGraphicsItem>
enum GraphicsItemType { enum GraphicsItemType {
typeCard = QGraphicsItem::UserType + 1, typeCard = QGraphicsItem::UserType + 1,
typeCardDrag = QGraphicsItem::UserType + 2, typeCardDrag = QGraphicsItem::UserType + 2,
typeZone = QGraphicsItem::UserType + 3, typeZone = QGraphicsItem::UserType + 3,
typePlayerTarget = QGraphicsItem::UserType + 4, typePlayerTarget = QGraphicsItem::UserType + 4,
typeDeckViewCardContainer = QGraphicsItem::UserType + 5, typeDeckViewCardContainer = QGraphicsItem::UserType + 5,
typeOther = QGraphicsItem::UserType + 6 typeOther = QGraphicsItem::UserType + 6
}; };
class AbstractGraphicsItem : public QObject, public QGraphicsItem { class AbstractGraphicsItem : public QObject, public QGraphicsItem {
Q_OBJECT Q_OBJECT
protected: protected:
void paintNumberEllipse(int number, int radius, const QColor &color, int position, int count, QPainter *painter); void paintNumberEllipse(int number, int radius, const QColor &color, int position, int count, QPainter *painter);
public: public:
AbstractGraphicsItem(QGraphicsItem *parent = 0) : QObject(), QGraphicsItem(parent) { } AbstractGraphicsItem(QGraphicsItem *parent = 0) : QObject(), QGraphicsItem(parent) { }
}; };
#endif #endif
cockatrice/src/arrowitem.cpp
View file @ 1bc48a78
...@@ -17,127 +17,127 @@ ...@@ -17,127 +17,127 @@
ArrowItem::ArrowItem(Player *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &_color) ArrowItem::ArrowItem(Player *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &_color)
: QGraphicsItem(), player(_player), id(_id), startItem(_startItem), targetItem(_targetItem), color(_color), fullColor(true) : QGraphicsItem(), player(_player), id(_id), startItem(_startItem), targetItem(_targetItem), color(_color), fullColor(true)
{ {
qDebug() << "ArrowItem constructor: startItem=" << static_cast<QGraphicsItem *>(startItem); qDebug() << "ArrowItem constructor: startItem=" << static_cast<QGraphicsItem *>(startItem);
setZValue(2000000005); setZValue(2000000005);
if (startItem) if (startItem)
startItem->addArrowFrom(this); startItem->addArrowFrom(this);
if (targetItem) if (targetItem)
targetItem->addArrowTo(this); targetItem->addArrowTo(this);
if (startItem && targetItem) if (startItem && targetItem)
updatePath(); updatePath();
} }
ArrowItem::~ArrowItem() ArrowItem::~ArrowItem()
{ {
qDebug() << "ArrowItem destructor"; qDebug() << "ArrowItem destructor";
} }
void ArrowItem::delArrow() void ArrowItem::delArrow()
{ {
if (startItem) { if (startItem) {
startItem->removeArrowFrom(this); startItem->removeArrowFrom(this);
startItem = 0; startItem = 0;
} }
if (targetItem) { if (targetItem) {
targetItem->setBeingPointedAt(false); targetItem->setBeingPointedAt(false);
targetItem->removeArrowTo(this); targetItem->removeArrowTo(this);
targetItem = 0; targetItem = 0;
} }
player->removeArrow(this); player->removeArrow(this);
deleteLater(); deleteLater();
} }
void ArrowItem::updatePath() void ArrowItem::updatePath()
{ {
if (!targetItem) if (!targetItem)
return; return;
QPointF endPoint = targetItem->mapToScene(QPointF(targetItem->boundingRect().width() / 2, targetItem->boundingRect().height() / 2)); QPointF endPoint = targetItem->mapToScene(QPointF(targetItem->boundingRect().width() / 2, targetItem->boundingRect().height() / 2));
updatePath(endPoint); updatePath(endPoint);
} }
void ArrowItem::updatePath(const QPointF &endPoint) void ArrowItem::updatePath(const QPointF &endPoint)
{ {
const double arrowWidth = 15.0; const double arrowWidth = 15.0;
const double headWidth = 40.0; const double headWidth = 40.0;
const double headLength = headWidth / sqrt(2); const double headLength = headWidth / sqrt(2);
const double phi = 15; const double phi = 15;
if (!startItem) if (!startItem)
return; return;
QPointF startPoint = startItem->mapToScene(QPointF(startItem->boundingRect().width() / 2, startItem->boundingRect().height() / 2)); QPointF startPoint = startItem->mapToScene(QPointF(startItem->boundingRect().width() / 2, startItem->boundingRect().height() / 2));
QLineF line(startPoint, endPoint); QLineF line(startPoint, endPoint);
qreal lineLength = line.length(); qreal lineLength = line.length();
prepareGeometryChange(); prepareGeometryChange();
if (lineLength < 30) if (lineLength < 30)
path = QPainterPath(); path = QPainterPath();
else { else {
QPointF c(lineLength / 2, tan(phi * M_PI / 180) * lineLength); QPointF c(lineLength / 2, tan(phi * M_PI / 180) * lineLength);
QPainterPath centerLine; QPainterPath centerLine;
centerLine.moveTo(0, 0); centerLine.moveTo(0, 0);
centerLine.quadTo(c, QPointF(lineLength, 0)); centerLine.quadTo(c, QPointF(lineLength, 0));
double percentage = 1 - headLength / lineLength; double percentage = 1 - headLength / lineLength;
QPointF arrowBodyEndPoint = centerLine.pointAtPercent(percentage); QPointF arrowBodyEndPoint = centerLine.pointAtPercent(percentage);
QLineF testLine(arrowBodyEndPoint, centerLine.pointAtPercent(percentage + 0.001)); QLineF testLine(arrowBodyEndPoint, centerLine.pointAtPercent(percentage + 0.001));
qreal alpha = testLine.angle() - 90; qreal alpha = testLine.angle() - 90;
QPointF endPoint1 = arrowBodyEndPoint + arrowWidth / 2 * QPointF(cos(alpha * M_PI / 180), -sin(alpha * M_PI / 180)); QPointF endPoint1 = arrowBodyEndPoint + arrowWidth / 2 * QPointF(cos(alpha * M_PI / 180), -sin(alpha * M_PI / 180));
QPointF endPoint2 = arrowBodyEndPoint + arrowWidth / 2 * QPointF(-cos(alpha * M_PI / 180), sin(alpha * M_PI / 180)); QPointF endPoint2 = arrowBodyEndPoint + arrowWidth / 2 * QPointF(-cos(alpha * M_PI / 180), sin(alpha * M_PI / 180));
QPointF point1 = endPoint1 + (headWidth - arrowWidth) / 2 * QPointF(cos(alpha * M_PI / 180), -sin(alpha * M_PI / 180)); QPointF point1 = endPoint1 + (headWidth - arrowWidth) / 2 * QPointF(cos(alpha * M_PI / 180), -sin(alpha * M_PI / 180));
QPointF point2 = endPoint2 + (headWidth - arrowWidth) / 2 * QPointF(-cos(alpha * M_PI / 180), sin(alpha * M_PI / 180)); QPointF point2 = endPoint2 + (headWidth - arrowWidth) / 2 * QPointF(-cos(alpha * M_PI / 180), sin(alpha * M_PI / 180));
path = QPainterPath(-arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180))); path = QPainterPath(-arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180)));
path.quadTo(c, endPoint1); path.quadTo(c, endPoint1);
path.lineTo(point1); path.lineTo(point1);
path.lineTo(QPointF(lineLength, 0)); path.lineTo(QPointF(lineLength, 0));
path.lineTo(point2); path.lineTo(point2);
path.lineTo(endPoint2); path.lineTo(endPoint2);
path.quadTo(c, arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180))); path.quadTo(c, arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180)));
path.lineTo(-arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180))); path.lineTo(-arrowWidth / 2 * QPointF(cos((phi - 90) * M_PI / 180), sin((phi - 90) * M_PI / 180)));
} }
setPos(startPoint); setPos(startPoint);
setTransform(QTransform().rotate(-line.angle())); setTransform(QTransform().rotate(-line.angle()));
} }
void ArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/) void ArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
{ {
QColor paintColor(color); QColor paintColor(color);
if (fullColor) if (fullColor)
paintColor.setAlpha(200); paintColor.setAlpha(200);
else else
paintColor.setAlpha(150); paintColor.setAlpha(150);
painter->setBrush(paintColor); painter->setBrush(paintColor);
painter->drawPath(path); painter->drawPath(path);
} }
void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event) void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{ {
if (!player->getLocal()) { if (!player->getLocal()) {
event->ignore(); event->ignore();
return; return;
} }
QList<QGraphicsItem *> colliding = scene()->items(event->scenePos()); QList<QGraphicsItem *> colliding = scene()->items(event->scenePos());
for (int i = 0; i < colliding.size(); ++i) for (int i = 0; i < colliding.size(); ++i)
if (qgraphicsitem_cast<CardItem *>(colliding[i])) { if (qgraphicsitem_cast<CardItem *>(colliding[i])) {
event->ignore(); event->ignore();
return; return;
} }
event->accept(); event->accept();
if (event->button() == Qt::RightButton) { if (event->button() == Qt::RightButton) {
Command_DeleteArrow cmd; Command_DeleteArrow cmd;
cmd.set_arrow_id(id); cmd.set_arrow_id(id);
player->sendGameCommand(cmd); player->sendGameCommand(cmd);
} }
} }
ArrowDragItem::ArrowDragItem(Player *_owner, ArrowTarget *_startItem, const QColor &_color) ArrowDragItem::ArrowDragItem(Player *_owner, ArrowTarget *_startItem, const QColor &_color)
...@@ -147,85 +147,85 @@ ArrowDragItem::ArrowDragItem(Player *_owner, ArrowTarget *_startItem, const QCol ...@@ -147,85 +147,85 @@ ArrowDragItem::ArrowDragItem(Player *_owner, ArrowTarget *_startItem, const QCol
void ArrowDragItem::addChildArrow(ArrowDragItem *childArrow) void ArrowDragItem::addChildArrow(ArrowDragItem *childArrow)
{ {
childArrows.append(childArrow); childArrows.append(childArrow);
} }
void ArrowDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) void ArrowDragItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{ {
// This ensures that if a mouse move event happens after a call to delArrow(), // This ensures that if a mouse move event happens after a call to delArrow(),
// the event will be discarded as it would create some stray pointers. // the event will be discarded as it would create some stray pointers.
if (!startItem) if (!startItem)
return; return;
QPointF endPos = event->scenePos(); QPointF endPos = event->scenePos();
QList<QGraphicsItem *> colliding = scene()->items(endPos); QList<QGraphicsItem *> colliding = scene()->items(endPos);
ArrowTarget *cursorItem = 0; ArrowTarget *cursorItem = 0;
qreal cursorItemZ = -1; qreal cursorItemZ = -1;
for (int i = colliding.size() - 1; i >= 0; i--) for (int i = colliding.size() - 1; i >= 0; i--)
if (qgraphicsitem_cast<PlayerTarget *>(colliding.at(i)) || qgraphicsitem_cast<CardItem *>(colliding.at(i))) if (qgraphicsitem_cast<PlayerTarget *>(colliding.at(i)) || qgraphicsitem_cast<CardItem *>(colliding.at(i)))
if (colliding.at(i)->zValue() > cursorItemZ) { if (colliding.at(i)->zValue() > cursorItemZ) {
cursorItem = static_cast<ArrowTarget *>(colliding.at(i)); cursorItem = static_cast<ArrowTarget *>(colliding.at(i));
cursorItemZ = cursorItem->zValue(); cursorItemZ = cursorItem->zValue();
} }
if ((cursorItem != targetItem) && targetItem) { if ((cursorItem != targetItem) && targetItem) {
targetItem->setBeingPointedAt(false); targetItem->setBeingPointedAt(false);
targetItem->removeArrowTo(this); targetItem->removeArrowTo(this);
} }
if (!cursorItem) { if (!cursorItem) {
fullColor = false; fullColor = false;
targetItem = 0; targetItem = 0;
updatePath(endPos); updatePath(endPos);
} else { } else {
if (cursorItem != targetItem) { if (cursorItem != targetItem) {
fullColor = true; fullColor = true;
if (cursorItem != startItem) { if (cursorItem != startItem) {
cursorItem->setBeingPointedAt(true); cursorItem->setBeingPointedAt(true);
cursorItem->addArrowTo(this); cursorItem->addArrowTo(this);
} }
targetItem = cursorItem; targetItem = cursorItem;
} }
updatePath(); updatePath();
} }
update(); update();
for (int i = 0; i < childArrows.size(); ++i) for (int i = 0; i < childArrows.size(); ++i)
childArrows[i]->mouseMoveEvent(event); childArrows[i]->mouseMoveEvent(event);
} }
void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{ {
if (!startItem) if (!startItem)
return; return;
if (targetItem && (targetItem != startItem)) { if (targetItem && (targetItem != startItem)) {
CardZone *startZone = static_cast<CardItem *>(startItem)->getZone(); CardZone *startZone = static_cast<CardItem *>(startItem)->getZone();
// For now, we can safely assume that the start item is always a card. // For now, we can safely assume that the start item is always a card.
// The target item can be a player as well. // The target item can be a player as well.
CardItem *startCard = qgraphicsitem_cast<CardItem *>(startItem); CardItem *startCard = qgraphicsitem_cast<CardItem *>(startItem);
CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem); CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem);
Command_CreateArrow cmd; Command_CreateArrow cmd;
cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(color)); cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(color));
cmd.set_start_player_id(startZone->getPlayer()->getId()); cmd.set_start_player_id(startZone->getPlayer()->getId());
cmd.set_start_zone(startZone->getName().toStdString()); cmd.set_start_zone(startZone->getName().toStdString());
cmd.set_start_card_id(startCard->getId()); cmd.set_start_card_id(startCard->getId());
if (targetCard) { if (targetCard) {
CardZone *targetZone = targetCard->getZone(); CardZone *targetZone = targetCard->getZone();
cmd.set_target_player_id(targetZone->getPlayer()->getId()); cmd.set_target_player_id(targetZone->getPlayer()->getId());
cmd.set_target_zone(targetZone->getName().toStdString()); cmd.set_target_zone(targetZone->getName().toStdString());
cmd.set_target_card_id(targetCard->getId()); cmd.set_target_card_id(targetCard->getId());
} else { } else {
PlayerTarget *targetPlayer = qgraphicsitem_cast<PlayerTarget *>(targetItem); PlayerTarget *targetPlayer = qgraphicsitem_cast<PlayerTarget *>(targetItem);
cmd.set_target_player_id(targetPlayer->getOwner()->getId()); cmd.set_target_player_id(targetPlayer->getOwner()->getId());
} }
player->sendGameCommand(cmd); player->sendGameCommand(cmd);
} }
delArrow(); delArrow();
for (int i = 0; i < childArrows.size(); ++i) for (int i = 0; i < childArrows.size(); ++i)
childArrows[i]->mouseReleaseEvent(event); childArrows[i]->mouseReleaseEvent(event);
} }
ArrowAttachItem::ArrowAttachItem(ArrowTarget *_startItem) ArrowAttachItem::ArrowAttachItem(ArrowTarget *_startItem)
...@@ -235,57 +235,57 @@ ArrowAttachItem::ArrowAttachItem(ArrowTarget *_startItem) ...@@ -235,57 +235,57 @@ ArrowAttachItem::ArrowAttachItem(ArrowTarget *_startItem)
void ArrowAttachItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event) void ArrowAttachItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{ {
if (!startItem) if (!startItem)
return; return;
QPointF endPos = event->scenePos(); QPointF endPos = event->scenePos();
QList<QGraphicsItem *> colliding = scene()->items(endPos); QList<QGraphicsItem *> colliding = scene()->items(endPos);
ArrowTarget *cursorItem = 0; ArrowTarget *cursorItem = 0;
qreal cursorItemZ = -1; qreal cursorItemZ = -1;
for (int i = colliding.size() - 1; i >= 0; i--) for (int i = colliding.size() - 1; i >= 0; i--)
if (qgraphicsitem_cast<CardItem *>(colliding.at(i))) if (qgraphicsitem_cast<CardItem *>(colliding.at(i)))
if (colliding.at(i)->zValue() > cursorItemZ) { if (colliding.at(i)->zValue() > cursorItemZ) {
cursorItem = static_cast<ArrowTarget *>(colliding.at(i)); cursorItem = static_cast<ArrowTarget *>(colliding.at(i));
cursorItemZ = cursorItem->zValue(); cursorItemZ = cursorItem->zValue();
} }
if ((cursorItem != targetItem) && targetItem) if ((cursorItem != targetItem) && targetItem)
targetItem->setBeingPointedAt(false); targetItem->setBeingPointedAt(false);
if (!cursorItem) { if (!cursorItem) {
fullColor = false; fullColor = false;
targetItem = 0; targetItem = 0;
updatePath(endPos); updatePath(endPos);
} else { } else {
fullColor = true; fullColor = true;
if (cursorItem != startItem) if (cursorItem != startItem)
cursorItem->setBeingPointedAt(true); cursorItem->setBeingPointedAt(true);
targetItem = cursorItem; targetItem = cursorItem;
updatePath(); updatePath();
} }
update(); update();
} }
void ArrowAttachItem::mouseReleaseEvent(QGraphicsSceneMouseEvent * /*event*/) void ArrowAttachItem::mouseReleaseEvent(QGraphicsSceneMouseEvent * /*event*/)
{ {
if (!startItem) if (!startItem)
return; return;
if (targetItem && (targetItem != startItem)) { if (targetItem && (targetItem != startItem)) {
CardItem *startCard = qgraphicsitem_cast<CardItem *>(startItem); CardItem *startCard = qgraphicsitem_cast<CardItem *>(startItem);
CardZone *startZone = startCard->getZone(); CardZone *startZone = startCard->getZone();
CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem); CardItem *targetCard = qgraphicsitem_cast<CardItem *>(targetItem);
CardZone *targetZone = targetCard->getZone(); CardZone *targetZone = targetCard->getZone();
Command_AttachCard cmd; Command_AttachCard cmd;
cmd.set_start_zone(startZone->getName().toStdString()); cmd.set_start_zone(startZone->getName().toStdString());
cmd.set_card_id(startCard->getId()); cmd.set_card_id(startCard->getId());
cmd.set_target_player_id(targetZone->getPlayer()->getId()); cmd.set_target_player_id(targetZone->getPlayer()->getId());
cmd.set_target_zone(targetZone->getName().toStdString()); cmd.set_target_zone(targetZone->getName().toStdString());
cmd.set_target_card_id(targetCard->getId()); cmd.set_target_card_id(targetCard->getId());
player->sendGameCommand(cmd); player->sendGameCommand(cmd);
} }
delArrow(); delArrow();
} }
cockatrice/src/arrowitem.h
View file @ 1bc48a78
...@@ -10,54 +10,54 @@ class Player; ...@@ -10,54 +10,54 @@ class Player;
class ArrowTarget; class ArrowTarget;
class ArrowItem : public QObject, public QGraphicsItem { class ArrowItem : public QObject, public QGraphicsItem {
Q_OBJECT Q_OBJECT
private: private:
QPainterPath path; QPainterPath path;
QMenu *menu; QMenu *menu;
protected: protected:
Player *player; Player *player;
int id; int id;
ArrowTarget *startItem, *targetItem; ArrowTarget *startItem, *targetItem;
QColor color; QColor color;
bool fullColor; bool fullColor;
void mousePressEvent(QGraphicsSceneMouseEvent *event); void mousePressEvent(QGraphicsSceneMouseEvent *event);
public: public:
ArrowItem(Player *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &color); ArrowItem(Player *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &color);
~ArrowItem(); ~ArrowItem();
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
QRectF boundingRect() const { return path.boundingRect(); } QRectF boundingRect() const { return path.boundingRect(); }
QPainterPath shape() const { return path; } QPainterPath shape() const { return path; }
void updatePath(); void updatePath();
void updatePath(const QPointF &endPoint); void updatePath(const QPointF &endPoint);
int getId() const { return id; } int getId() const { return id; }
Player *getPlayer() const { return player; } Player *getPlayer() const { return player; }
void setStartItem(ArrowTarget *_item) { startItem = _item; } void setStartItem(ArrowTarget *_item) { startItem = _item; }
void setTargetItem(ArrowTarget *_item) { targetItem = _item; } void setTargetItem(ArrowTarget *_item) { targetItem = _item; }
ArrowTarget *getStartItem() const { return startItem; } ArrowTarget *getStartItem() const { return startItem; }
ArrowTarget *getTargetItem() const { return targetItem; } ArrowTarget *getTargetItem() const { return targetItem; }
void delArrow(); void delArrow();
}; };
class ArrowDragItem : public ArrowItem { class ArrowDragItem : public ArrowItem {
Q_OBJECT Q_OBJECT
private: private:
QList<ArrowDragItem *> childArrows; QList<ArrowDragItem *> childArrows;
public: public:
ArrowDragItem(Player *_owner, ArrowTarget *_startItem, const QColor &_color); ArrowDragItem(Player *_owner, ArrowTarget *_startItem, const QColor &_color);
void addChildArrow(ArrowDragItem *childArrow); void addChildArrow(ArrowDragItem *childArrow);
protected: protected:
void mouseMoveEvent(QGraphicsSceneMouseEvent *event); void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
}; };
class ArrowAttachItem : public ArrowItem { class ArrowAttachItem : public ArrowItem {
Q_OBJECT Q_OBJECT
public: public:
ArrowAttachItem(ArrowTarget *_startItem); ArrowAttachItem(ArrowTarget *_startItem);
protected: protected:
void mouseMoveEvent(QGraphicsSceneMouseEvent *event); void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
}; };
#endif // ARROWITEM_H #endif // ARROWITEM_H
cockatrice/src/arrowtarget.cpp
View file @ 1bc48a78
...@@ -3,24 +3,24 @@ ...@@ -3,24 +3,24 @@
#include "player.h" #include "player.h"
ArrowTarget::ArrowTarget(Player *_owner, QGraphicsItem *parent) ArrowTarget::ArrowTarget(Player *_owner, QGraphicsItem *parent)
: AbstractGraphicsItem(parent), owner(_owner), beingPointedAt(false) : AbstractGraphicsItem(parent), owner(_owner), beingPointedAt(false)
{ {
} }
ArrowTarget::~ArrowTarget() ArrowTarget::~ArrowTarget()
{ {
for (int i = 0; i < arrowsFrom.size(); ++i) { for (int i = 0; i < arrowsFrom.size(); ++i) {
arrowsFrom[i]->setStartItem(0); arrowsFrom[i]->setStartItem(0);
arrowsFrom[i]->delArrow(); arrowsFrom[i]->delArrow();
} }
for (int i = 0; i < arrowsTo.size(); ++i) { for (int i = 0; i < arrowsTo.size(); ++i) {
arrowsTo[i]->setTargetItem(0); arrowsTo[i]->setTargetItem(0);
arrowsTo[i]->delArrow(); arrowsTo[i]->delArrow();
} }
} }
void ArrowTarget::setBeingPointedAt(bool _beingPointedAt) void ArrowTarget::setBeingPointedAt(bool _beingPointedAt)
{ {
beingPointedAt = _beingPointedAt; beingPointedAt = _beingPointedAt;
update(); update();
} }
cockatrice/src/arrowtarget.h
View file @ 1bc48a78
...@@ -8,28 +8,28 @@ class Player; ...@@ -8,28 +8,28 @@ class Player;
class ArrowItem; class ArrowItem;
class ArrowTarget : public AbstractGraphicsItem { class ArrowTarget : public AbstractGraphicsItem {
Q_OBJECT Q_OBJECT
protected: protected:
Player *owner; Player *owner;
private: private:
bool beingPointedAt; bool beingPointedAt;
QList<ArrowItem *> arrowsFrom, arrowsTo; QList<ArrowItem *> arrowsFrom, arrowsTo;
public: public:
ArrowTarget(Player *_owner, QGraphicsItem *parent = 0); ArrowTarget(Player *_owner, QGraphicsItem *parent = 0);
~ArrowTarget(); ~ArrowTarget();
Player *getOwner() const { return owner; } Player *getOwner() const { return owner; }
void setBeingPointedAt(bool _beingPointedAt); void setBeingPointedAt(bool _beingPointedAt);
bool getBeingPointedAt() const { return beingPointedAt; } bool getBeingPointedAt() const { return beingPointedAt; }
const QList<ArrowItem *> &getArrowsFrom() const { return arrowsFrom; } const QList<ArrowItem *> &getArrowsFrom() const { return arrowsFrom; }
void addArrowFrom(ArrowItem *arrow) { arrowsFrom.append(arrow); } void addArrowFrom(ArrowItem *arrow) { arrowsFrom.append(arrow); }
void removeArrowFrom(ArrowItem *arrow) { arrowsFrom.removeAt(arrowsFrom.indexOf(arrow)); } void removeArrowFrom(ArrowItem *arrow) { arrowsFrom.removeAt(arrowsFrom.indexOf(arrow)); }
const QList<ArrowItem *> &getArrowsTo() const { return arrowsTo; } const QList<ArrowItem *> &getArrowsTo() const { return arrowsTo; }
void addArrowTo(ArrowItem *arrow) { arrowsTo.append(arrow); } void addArrowTo(ArrowItem *arrow) { arrowsTo.append(arrow); }
void removeArrowTo(ArrowItem *arrow) { arrowsTo.removeAt(arrowsTo.indexOf(arrow)); } void removeArrowTo(ArrowItem *arrow) { arrowsTo.removeAt(arrowsTo.indexOf(arrow)); }
}; };
#endif #endif
cockatrice/src/carddatabase.cpp
View file @ 1bc48a78
...@@ -17,782 +17,782 @@ ...@@ -17,782 +17,782 @@
const int CardDatabase::versionNeeded = 2; const int CardDatabase::versionNeeded = 2;
CardSet::CardSet(const QString &_shortName, const QString &_longName) CardSet::CardSet(const QString &_shortName, const QString &_longName)
: shortName(_shortName), longName(_longName) : shortName(_shortName), longName(_longName)
{ {
updateSortKey(); updateSortKey();
} }
QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardSet *set) QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardSet *set)
{ {
xml.writeStartElement("set"); xml.writeStartElement("set");
xml.writeTextElement("name", set->getShortName()); xml.writeTextElement("name", set->getShortName());
xml.writeTextElement("longname", set->getLongName()); xml.writeTextElement("longname", set->getLongName());
xml.writeEndElement(); xml.writeEndElement();
return xml; return xml;
} }
void CardSet::setSortKey(unsigned int _sortKey) void CardSet::setSortKey(unsigned int _sortKey)
{ {
sortKey = _sortKey; sortKey = _sortKey;
QSettings settings; QSettings settings;
settings.beginGroup("sets"); settings.beginGroup("sets");
settings.beginGroup(shortName); settings.beginGroup(shortName);
settings.setValue("sortkey", sortKey); settings.setValue("sortkey", sortKey);
} }
void CardSet::updateSortKey() void CardSet::updateSortKey()
{ {
QSettings settings; QSettings settings;
settings.beginGroup("sets"); settings.beginGroup("sets");
settings.beginGroup(shortName); settings.beginGroup(shortName);
sortKey = settings.value("sortkey", 0).toInt(); sortKey = settings.value("sortkey", 0).toInt();
} }
class SetList::CompareFunctor { class SetList::CompareFunctor {
public: public:
inline bool operator()(CardSet *a, CardSet *b) const inline bool operator()(CardSet *a, CardSet *b) const
{ {
return a->getSortKey() < b->getSortKey(); return a->getSortKey() < b->getSortKey();
} }
}; };
void SetList::sortByKey() void SetList::sortByKey()
{ {
qSort(begin(), end(), CompareFunctor()); qSort(begin(), end(), CompareFunctor());
} }
PictureToLoad::PictureToLoad(CardInfo *_card, bool _stripped, bool _hq) PictureToLoad::PictureToLoad(CardInfo *_card, bool _stripped, bool _hq)
: card(_card), stripped(_stripped), setIndex(0), hq(_hq) : card(_card), stripped(_stripped), setIndex(0), hq(_hq)
{ {
if (card) { if (card) {
sortedSets = card->getSets(); sortedSets = card->getSets();
sortedSets.sortByKey(); sortedSets.sortByKey();
} }
} }
bool PictureToLoad::nextSet() bool PictureToLoad::nextSet()
{ {
if (setIndex == sortedSets.size() - 1) if (setIndex == sortedSets.size() - 1)
return false; return false;
++setIndex; ++setIndex;
return true; return true;
} }
PictureLoader::PictureLoader(const QString &__picsPath, bool _picDownload, QObject *parent) PictureLoader::PictureLoader(const QString &__picsPath, bool _picDownload, QObject *parent)
: QObject(parent), _picsPath(__picsPath), picDownload(_picDownload), downloadRunning(false), loadQueueRunning(false) : QObject(parent), _picsPath(__picsPath), picDownload(_picDownload), downloadRunning(false), loadQueueRunning(false)
{ {
connect(this, SIGNAL(startLoadQueue()), this, SLOT(processLoadQueue()), Qt::QueuedConnection); connect(this, SIGNAL(startLoadQueue()), this, SLOT(processLoadQueue()), Qt::QueuedConnection);
networkManager = new QNetworkAccessManager(this); networkManager = new QNetworkAccessManager(this);
connect(networkManager, SIGNAL(finished(QNetworkReply *)), this, SLOT(picDownloadFinished(QNetworkReply *))); connect(networkManager, SIGNAL(finished(QNetworkReply *)), this, SLOT(picDownloadFinished(QNetworkReply *)));
} }
PictureLoader::~PictureLoader() PictureLoader::~PictureLoader()
{ {
// This does not work with the destroyed() signal as this destructor is called after the main event loop is done. // This does not work with the destroyed() signal as this destructor is called after the main event loop is done.
thread()->quit(); thread()->quit();
} }
void PictureLoader::processLoadQueue() void PictureLoader::processLoadQueue()
{ {
if (loadQueueRunning) if (loadQueueRunning)
return; return;
loadQueueRunning = true; loadQueueRunning = true;
forever { forever {
mutex.lock(); mutex.lock();
if (loadQueue.isEmpty()) { if (loadQueue.isEmpty()) {
mutex.unlock(); mutex.unlock();
loadQueueRunning = false; loadQueueRunning = false;
return; return;
} }
PictureToLoad ptl = loadQueue.takeFirst(); PictureToLoad ptl = loadQueue.takeFirst();
mutex.unlock(); mutex.unlock();
QString correctedName = ptl.getCard()->getCorrectedName(); QString correctedName = ptl.getCard()->getCorrectedName();
QString picsPath = _picsPath; QString picsPath = _picsPath;
QString setName = ptl.getSetName(); QString setName = ptl.getSetName();
QImage image; QImage image;
if (!image.load(QString("%1/%2/%3.full.jpg").arg(picsPath).arg(setName).arg(correctedName))) if (!image.load(QString("%1/%2/%3.full.jpg").arg(picsPath).arg(setName).arg(correctedName)))
if (!image.load(QString("%1/%2/%3%4.full.jpg").arg(picsPath).arg(setName).arg(correctedName).arg(1))) if (!image.load(QString("%1/%2/%3%4.full.jpg").arg(picsPath).arg(setName).arg(correctedName).arg(1)))
if (!image.load(QString("%1/%2/%3/%4.full.jpg").arg(picsPath).arg("downloadedPics").arg(setName).arg(correctedName))) { if (!image.load(QString("%1/%2/%3/%4.full.jpg").arg(picsPath).arg("downloadedPics").arg(setName).arg(correctedName))) {
if (picDownload) { if (picDownload) {
cardsToDownload.append(ptl); cardsToDownload.append(ptl);
if (!downloadRunning) if (!downloadRunning)
startNextPicDownload(); startNextPicDownload();
} else { } else {
if (ptl.nextSet()) if (ptl.nextSet())
loadQueue.prepend(ptl); loadQueue.prepend(ptl);
else else
emit imageLoaded(ptl.getCard(), QImage()); emit imageLoaded(ptl.getCard(), QImage());
} }
continue; continue;
} }
emit imageLoaded(ptl.getCard(), image); emit imageLoaded(ptl.getCard(), image);
} }
} }
void PictureLoader::startNextPicDownload() void PictureLoader::startNextPicDownload()
{ {
if (cardsToDownload.isEmpty()) { if (cardsToDownload.isEmpty()) {
cardBeingDownloaded = 0; cardBeingDownloaded = 0;
downloadRunning = false; downloadRunning = false;
return; return;
} }
downloadRunning = true; downloadRunning = true;
cardBeingDownloaded = cardsToDownload.takeFirst(); cardBeingDownloaded = cardsToDownload.takeFirst();
QString picUrl; QString picUrl;
if (cardBeingDownloaded.getStripped()) if (cardBeingDownloaded.getStripped())
picUrl = cardBeingDownloaded.getCard()->getPicURLSt(cardBeingDownloaded.getSetName()); picUrl = cardBeingDownloaded.getCard()->getPicURLSt(cardBeingDownloaded.getSetName());
else if (cardBeingDownloaded.getHq()) { else if (cardBeingDownloaded.getHq()) {
picUrl = cardBeingDownloaded.getCard()->getPicURLHq(cardBeingDownloaded.getSetName()); picUrl = cardBeingDownloaded.getCard()->getPicURLHq(cardBeingDownloaded.getSetName());
if (picUrl.isEmpty()) { if (picUrl.isEmpty()) {
picUrl = cardBeingDownloaded.getCard()->getPicURL(cardBeingDownloaded.getSetName()); picUrl = cardBeingDownloaded.getCard()->getPicURL(cardBeingDownloaded.getSetName());
cardBeingDownloaded.setHq(false); cardBeingDownloaded.setHq(false);
} }
} else } else
picUrl = cardBeingDownloaded.getCard()->getPicURL(cardBeingDownloaded.getSetName()); picUrl = cardBeingDownloaded.getCard()->getPicURL(cardBeingDownloaded.getSetName());
QUrl url(picUrl); QUrl url(picUrl);
QNetworkRequest req(url); QNetworkRequest req(url);
qDebug() << "starting picture download:" << req.url(); qDebug() << "starting picture download:" << req.url();
networkManager->get(req); networkManager->get(req);
} }
void PictureLoader::picDownloadFinished(QNetworkReply *reply) void PictureLoader::picDownloadFinished(QNetworkReply *reply)
{ {
QString picsPath = _picsPath; QString picsPath = _picsPath;
const QByteArray &picData = reply->readAll(); const QByteArray &picData = reply->readAll();
QImage testImage; QImage testImage;
if (testImage.loadFromData(picData)) { if (testImage.loadFromData(picData)) {
if (!QDir(QString(picsPath + "/downloadedPics/")).exists()) { if (!QDir(QString(picsPath + "/downloadedPics/")).exists()) {
QDir dir(picsPath); QDir dir(picsPath);
if (!dir.exists()) if (!dir.exists())
return; return;
dir.mkdir("downloadedPics"); dir.mkdir("downloadedPics");
} }
if (!QDir(QString(picsPath + "/downloadedPics/" + cardBeingDownloaded.getSetName())).exists()) { if (!QDir(QString(picsPath + "/downloadedPics/" + cardBeingDownloaded.getSetName())).exists()) {
QDir dir(QString(picsPath + "/downloadedPics")); QDir dir(QString(picsPath + "/downloadedPics"));
dir.mkdir(cardBeingDownloaded.getSetName()); dir.mkdir(cardBeingDownloaded.getSetName());
} }
QString suffix; QString suffix;
if (!cardBeingDownloaded.getStripped()) if (!cardBeingDownloaded.getStripped())
suffix = ".full"; suffix = ".full";
QFile newPic(picsPath + "/downloadedPics/" + cardBeingDownloaded.getSetName() + "/" + cardBeingDownloaded.getCard()->getCorrectedName() + suffix + ".jpg"); QFile newPic(picsPath + "/downloadedPics/" + cardBeingDownloaded.getSetName() + "/" + cardBeingDownloaded.getCard()->getCorrectedName() + suffix + ".jpg");
if (!newPic.open(QIODevice::WriteOnly)) if (!newPic.open(QIODevice::WriteOnly))
return; return;
newPic.write(picData); newPic.write(picData);
newPic.close(); newPic.close();
emit imageLoaded(cardBeingDownloaded.getCard(), testImage); emit imageLoaded(cardBeingDownloaded.getCard(), testImage);
} else if (cardBeingDownloaded.getHq()) { } else if (cardBeingDownloaded.getHq()) {
qDebug() << "HQ: received invalid picture. URL:" << reply->request().url(); qDebug() << "HQ: received invalid picture. URL:" << reply->request().url();
cardBeingDownloaded.setHq(false); cardBeingDownloaded.setHq(false);
cardsToDownload.prepend(cardBeingDownloaded); cardsToDownload.prepend(cardBeingDownloaded);
} else { } else {
qDebug() << "LQ: received invalid picture. URL:" << reply->request().url(); qDebug() << "LQ: received invalid picture. URL:" << reply->request().url();
if (cardBeingDownloaded.nextSet()) { if (cardBeingDownloaded.nextSet()) {
cardBeingDownloaded.setHq(true); cardBeingDownloaded.setHq(true);
mutex.lock(); mutex.lock();
loadQueue.prepend(cardBeingDownloaded); loadQueue.prepend(cardBeingDownloaded);
mutex.unlock(); mutex.unlock();
emit startLoadQueue(); emit startLoadQueue();
} else } else
emit imageLoaded(cardBeingDownloaded.getCard(), QImage()); emit imageLoaded(cardBeingDownloaded.getCard(), QImage());
} }
reply->deleteLater(); reply->deleteLater();
startNextPicDownload(); startNextPicDownload();
} }
void PictureLoader::loadImage(CardInfo *card, bool stripped) void PictureLoader::loadImage(CardInfo *card, bool stripped)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
loadQueue.append(PictureToLoad(card, stripped)); loadQueue.append(PictureToLoad(card, stripped));
emit startLoadQueue(); emit startLoadQueue();
} }
void PictureLoader::setPicsPath(const QString &path) void PictureLoader::setPicsPath(const QString &path)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
_picsPath = path; _picsPath = path;
} }
void PictureLoader::setPicDownload(bool _picDownload) void PictureLoader::setPicDownload(bool _picDownload)
{ {
QMutexLocker locker(&mutex); QMutexLocker locker(&mutex);
picDownload = _picDownload; picDownload = _picDownload;
} }
CardInfo::CardInfo(CardDatabase *_db, CardInfo::CardInfo(CardDatabase *_db,
const QString &_name, const QString &_name,
bool _isToken, bool _isToken,
const QString &_manacost, const QString &_manacost,
const QString &_cardtype, const QString &_cardtype,
const QString &_powtough, const QString &_powtough,
const QString &_text, const QString &_text,
const QStringList &_colors, const QStringList &_colors,
int _loyalty, int _loyalty,
bool _cipt, bool _cipt,
int _tableRow, int _tableRow,
const SetList &_sets, const SetList &_sets,
const QMap<QString, QString> &_picURLs, const QMap<QString, QString> &_picURLs,
const QMap<QString, QString> &_picURLsHq, const QMap<QString, QString> &_picURLsHq,
const QMap<QString, QString> &_picURLsSt) const QMap<QString, QString> &_picURLsSt)
: db(_db), : db(_db),
name(_name), name(_name),
isToken(_isToken), isToken(_isToken),
sets(_sets), sets(_sets),
manacost(_manacost), manacost(_manacost),
cardtype(_cardtype), cardtype(_cardtype),
powtough(_powtough), powtough(_powtough),
text(_text), text(_text),
colors(_colors), colors(_colors),
loyalty(_loyalty), loyalty(_loyalty),
picURLs(_picURLs), picURLs(_picURLs),
picURLsHq(_picURLsHq), picURLsHq(_picURLsHq),
picURLsSt(_picURLsSt), picURLsSt(_picURLsSt),
cipt(_cipt), cipt(_cipt),
tableRow(_tableRow), tableRow(_tableRow),
pixmap(NULL) pixmap(NULL)
{ {
for (int i = 0; i < sets.size(); i++) for (int i = 0; i < sets.size(); i++)
sets[i]->append(this); sets[i]->append(this);
} }
CardInfo::~CardInfo() CardInfo::~CardInfo()
{ {
clearPixmapCache(); clearPixmapCache();
} }
QString CardInfo::getMainCardType() const QString CardInfo::getMainCardType() const
{ {
QString result = getCardType(); QString result = getCardType();
/* /*
Legendary Artifact Creature - Golem Legendary Artifact Creature - Golem
Instant // Instant Instant // Instant
*/ */
int pos; int pos;
if ((pos = result.indexOf('-')) != -1) if ((pos = result.indexOf('-')) != -1)
result.remove(pos, result.length()); result.remove(pos, result.length());
if ((pos = result.indexOf("//")) != -1) if ((pos = result.indexOf("//")) != -1)
result.remove(pos, result.length()); result.remove(pos, result.length());
result = result.simplified(); result = result.simplified();
/* /*
Legendary Artifact Creature Legendary Artifact Creature
Instant Instant
*/ */
if ((pos = result.lastIndexOf(' ')) != -1) if ((pos = result.lastIndexOf(' ')) != -1)
result = result.mid(pos + 1); result = result.mid(pos + 1);
/* /*
Creature Creature
Instant Instant
*/ */
return result; return result;
} }
QString CardInfo::getCorrectedName() const QString CardInfo::getCorrectedName() const
{ {
QString result = name; QString result = name;
// Fire // Ice, Circle of Protection: Red, "Ach! Hans, Run!", Who/What/When/Where/Why, Question Elemental? // Fire // Ice, Circle of Protection: Red, "Ach! Hans, Run!", Who/What/When/Where/Why, Question Elemental?
return result.remove(" // ").remove(':').remove('"').remove('?').replace('/', ' '); return result.remove(" // ").remove(':').remove('"').remove('?').replace('/', ' ');
} }
void CardInfo::addToSet(CardSet *set) void CardInfo::addToSet(CardSet *set)
{ {
set->append(this); set->append(this);
sets << set; sets << set;
} }
QString CardInfo::getPicURL() const QString CardInfo::getPicURL() const
{ {
SetList sortedSets = sets; SetList sortedSets = sets;
sortedSets.sortByKey(); sortedSets.sortByKey();
return picURLs.value(sortedSets.first()->getShortName()); return picURLs.value(sortedSets.first()->getShortName());
} }
QPixmap *CardInfo::loadPixmap() QPixmap *CardInfo::loadPixmap()
{ {
if (pixmap) if (pixmap)
return pixmap; return pixmap;
pixmap = new QPixmap(); pixmap = new QPixmap();
if (getName().isEmpty()) { if (getName().isEmpty()) {
pixmap->load(settingsCache->getCardBackPicturePath()); pixmap->load(settingsCache->getCardBackPicturePath());
return pixmap; return pixmap;
} }
db->loadImage(this); db->loadImage(this);
return pixmap; return pixmap;
} }
void CardInfo::imageLoaded(const QImage &image) void CardInfo::imageLoaded(const QImage &image)
{ {
if (!image.isNull()) { if (!image.isNull()) {
*pixmap = QPixmap::fromImage(image); *pixmap = QPixmap::fromImage(image);
emit pixmapUpdated(); emit pixmapUpdated();
} }
} }
QPixmap *CardInfo::getPixmap(QSize size) QPixmap *CardInfo::getPixmap(QSize size)
{ {
QPixmap *cachedPixmap = scaledPixmapCache.value(size.width()); QPixmap *cachedPixmap = scaledPixmapCache.value(size.width());
if (cachedPixmap) if (cachedPixmap)
return cachedPixmap; return cachedPixmap;
QPixmap *bigPixmap = loadPixmap(); QPixmap *bigPixmap = loadPixmap();
QPixmap *result; QPixmap *result;
if (bigPixmap->isNull()) { if (bigPixmap->isNull()) {
if (!getName().isEmpty()) if (!getName().isEmpty())
return 0; return 0;
else { else {
result = new QPixmap(size); result = new QPixmap(size);
result->fill(Qt::transparent); result->fill(Qt::transparent);
QSvgRenderer svg(QString(":/back.svg")); QSvgRenderer svg(QString(":/back.svg"));
QPainter painter(result); QPainter painter(result);
svg.render(&painter, QRectF(0, 0, size.width(), size.height())); svg.render(&painter, QRectF(0, 0, size.width(), size.height()));
} }
} else } else
result = new QPixmap(bigPixmap->scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation)); result = new QPixmap(bigPixmap->scaled(size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
scaledPixmapCache.insert(size.width(), result); scaledPixmapCache.insert(size.width(), result);
return result; return result;
} }
void CardInfo::clearPixmapCache() void CardInfo::clearPixmapCache()
{ {
if (pixmap) { if (pixmap) {
qDebug() << "Deleting pixmap for" << name; qDebug() << "Deleting pixmap for" << name;
delete pixmap; delete pixmap;
pixmap = 0; pixmap = 0;
QMapIterator<int, QPixmap *> i(scaledPixmapCache); QMapIterator<int, QPixmap *> i(scaledPixmapCache);
while (i.hasNext()) { while (i.hasNext()) {
i.next(); i.next();
qDebug() << " Deleting cached pixmap for width" << i.key(); qDebug() << " Deleting cached pixmap for width" << i.key();
delete i.value(); delete i.value();
} }
scaledPixmapCache.clear(); scaledPixmapCache.clear();
} }
} }
void CardInfo::clearPixmapCacheMiss() void CardInfo::clearPixmapCacheMiss()
{ {
if (!pixmap) if (!pixmap)
return; return;
if (pixmap->isNull()) if (pixmap->isNull())
clearPixmapCache(); clearPixmapCache();
} }
void CardInfo::updatePixmapCache() void CardInfo::updatePixmapCache()
{ {
qDebug() << "Updating pixmap cache for" << name; qDebug() << "Updating pixmap cache for" << name;
clearPixmapCache(); clearPixmapCache();
loadPixmap(); loadPixmap();
emit pixmapUpdated(); emit pixmapUpdated();
} }
QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardInfo *info) QXmlStreamWriter &operator<<(QXmlStreamWriter &xml, const CardInfo *info)
{ {
xml.writeStartElement("card"); xml.writeStartElement("card");
xml.writeTextElement("name", info->getName()); xml.writeTextElement("name", info->getName());
const SetList &sets = info->getSets(); const SetList &sets = info->getSets();
for (int i = 0; i < sets.size(); i++) { for (int i = 0; i < sets.size(); i++) {
xml.writeStartElement("set"); xml.writeStartElement("set");
xml.writeAttribute("picURL", info->getPicURL(sets[i]->getShortName())); xml.writeAttribute("picURL", info->getPicURL(sets[i]->getShortName()));
xml.writeAttribute("picURLHq", info->getPicURLHq(sets[i]->getShortName())); xml.writeAttribute("picURLHq", info->getPicURLHq(sets[i]->getShortName()));
xml.writeAttribute("picURLSt", info->getPicURLSt(sets[i]->getShortName())); xml.writeAttribute("picURLSt", info->getPicURLSt(sets[i]->getShortName()));
xml.writeCharacters(sets[i]->getShortName()); xml.writeCharacters(sets[i]->getShortName());
xml.writeEndElement(); xml.writeEndElement();
} }
const QStringList &colors = info->getColors(); const QStringList &colors = info->getColors();
for (int i = 0; i < colors.size(); i++) for (int i = 0; i < colors.size(); i++)
xml.writeTextElement("color", colors[i]); xml.writeTextElement("color", colors[i]);
xml.writeTextElement("manacost", info->getManaCost()); xml.writeTextElement("manacost", info->getManaCost());
xml.writeTextElement("type", info->getCardType()); xml.writeTextElement("type", info->getCardType());
if (!info->getPowTough().isEmpty()) if (!info->getPowTough().isEmpty())
xml.writeTextElement("pt", info->getPowTough()); xml.writeTextElement("pt", info->getPowTough());
xml.writeTextElement("tablerow", QString::number(info->getTableRow())); xml.writeTextElement("tablerow", QString::number(info->getTableRow()));
xml.writeTextElement("text", info->getText()); xml.writeTextElement("text", info->getText());
if (info->getMainCardType() == "Planeswalker") if (info->getMainCardType() == "Planeswalker")
xml.writeTextElement("loyalty", QString::number(info->getLoyalty())); xml.writeTextElement("loyalty", QString::number(info->getLoyalty()));
if (info->getCipt()) if (info->getCipt())
xml.writeTextElement("cipt", "1"); xml.writeTextElement("cipt", "1");
if (info->getIsToken()) if (info->getIsToken())
xml.writeTextElement("token", "1"); xml.writeTextElement("token", "1");
xml.writeEndElement(); // card xml.writeEndElement(); // card
return xml; return xml;
} }
CardDatabase::CardDatabase(QObject *parent) CardDatabase::CardDatabase(QObject *parent)
: QObject(parent), loadSuccess(false), noCard(0) : QObject(parent), loadSuccess(false), noCard(0)
{ {
connect(settingsCache, SIGNAL(picsPathChanged()), this, SLOT(picsPathChanged())); connect(settingsCache, SIGNAL(picsPathChanged()), this, SLOT(picsPathChanged()));
connect(settingsCache, SIGNAL(cardDatabasePathChanged()), this, SLOT(loadCardDatabase())); connect(settingsCache, SIGNAL(cardDatabasePathChanged()), this, SLOT(loadCardDatabase()));
connect(settingsCache, SIGNAL(tokenDatabasePathChanged()), this, SLOT(loadTokenDatabase())); connect(settingsCache, SIGNAL(tokenDatabasePathChanged()), this, SLOT(loadTokenDatabase()));
connect(settingsCache, SIGNAL(picDownloadChanged()), this, SLOT(picDownloadChanged())); connect(settingsCache, SIGNAL(picDownloadChanged()), this, SLOT(picDownloadChanged()));
loadCardDatabase(); loadCardDatabase();
loadTokenDatabase(); loadTokenDatabase();
pictureLoaderThread = new QThread; pictureLoaderThread = new QThread;
pictureLoader = new PictureLoader(settingsCache->getPicsPath(), settingsCache->getPicDownload()); pictureLoader = new PictureLoader(settingsCache->getPicsPath(), settingsCache->getPicDownload());
pictureLoader->moveToThread(pictureLoaderThread); pictureLoader->moveToThread(pictureLoaderThread);
connect(pictureLoader, SIGNAL(imageLoaded(CardInfo *, const QImage &)), this, SLOT(imageLoaded(CardInfo *, const QImage &))); connect(pictureLoader, SIGNAL(imageLoaded(CardInfo *, const QImage &)), this, SLOT(imageLoaded(CardInfo *, const QImage &)));
pictureLoaderThread->start(QThread::LowPriority); pictureLoaderThread->start(QThread::LowPriority);
noCard = new CardInfo(this); noCard = new CardInfo(this);
noCard->loadPixmap(); // cache pixmap for card back noCard->loadPixmap(); // cache pixmap for card back
connect(settingsCache, SIGNAL(cardBackPicturePathChanged()), noCard, SLOT(updatePixmapCache())); connect(settingsCache, SIGNAL(cardBackPicturePathChanged()), noCard, SLOT(updatePixmapCache()));
} }
CardDatabase::~CardDatabase() CardDatabase::~CardDatabase()
{ {
clear(); clear();
delete noCard; delete noCard;
pictureLoader->deleteLater(); pictureLoader->deleteLater();
pictureLoaderThread->wait(); pictureLoaderThread->wait();
delete pictureLoaderThread; delete pictureLoaderThread;
} }
void CardDatabase::clear() void CardDatabase::clear()
{ {
QHashIterator<QString, CardSet *> setIt(setHash); QHashIterator<QString, CardSet *> setIt(setHash);
while (setIt.hasNext()) { while (setIt.hasNext()) {
setIt.next(); setIt.next();
delete setIt.value(); delete setIt.value();
} }
setHash.clear(); setHash.clear();
QHashIterator<QString, CardInfo *> i(cardHash); QHashIterator<QString, CardInfo *> i(cardHash);
while (i.hasNext()) { while (i.hasNext()) {
i.next(); i.next();
delete i.value(); delete i.value();
} }
cardHash.clear(); cardHash.clear();
} }
void CardDatabase::addCard(CardInfo *card) void CardDatabase::addCard(CardInfo *card)
{ {
cardHash.insert(card->getName(), card); cardHash.insert(card->getName(), card);
emit cardAdded(card); emit cardAdded(card);
} }
void CardDatabase::removeCard(CardInfo *card) void CardDatabase::removeCard(CardInfo *card)
{ {
cardHash.remove(card->getName()); cardHash.remove(card->getName());
emit cardRemoved(card); emit cardRemoved(card);
} }
CardInfo *CardDatabase::getCard(const QString &cardName, bool createIfNotFound) CardInfo *CardDatabase::getCard(const QString &cardName, bool createIfNotFound)
{ {
if (cardName.isEmpty()) if (cardName.isEmpty())
return noCard; return noCard;
else if (cardHash.contains(cardName)) else if (cardHash.contains(cardName))
return cardHash.value(cardName); return cardHash.value(cardName);
else if (createIfNotFound) { else if (createIfNotFound) {
CardInfo *newCard = new CardInfo(this, cardName, true); CardInfo *newCard = new CardInfo(this, cardName, true);
newCard->addToSet(getSet("TK")); newCard->addToSet(getSet("TK"));
cardHash.insert(cardName, newCard); cardHash.insert(cardName, newCard);
return newCard; return newCard;
} else } else
return 0; return 0;
} }
CardSet *CardDatabase::getSet(const QString &setName) CardSet *CardDatabase::getSet(const QString &setName)
{ {
if (setHash.contains(setName)) if (setHash.contains(setName))
return setHash.value(setName); return setHash.value(setName);
else { else {
CardSet *newSet = new CardSet(setName); CardSet *newSet = new CardSet(setName);
setHash.insert(setName, newSet); setHash.insert(setName, newSet);
return newSet; return newSet;
} }
} }
SetList CardDatabase::getSetList() const SetList CardDatabase::getSetList() const
{ {
SetList result; SetList result;
QHashIterator<QString, CardSet *> i(setHash); QHashIterator<QString, CardSet *> i(setHash);
while (i.hasNext()) { while (i.hasNext()) {
i.next(); i.next();
result << i.value(); result << i.value();
} }
return result; return result;
} }
void CardDatabase::clearPixmapCache() void CardDatabase::clearPixmapCache()
{ {
QHashIterator<QString, CardInfo *> i(cardHash); QHashIterator<QString, CardInfo *> i(cardHash);
while (i.hasNext()) { while (i.hasNext()) {
i.next(); i.next();
i.value()->clearPixmapCache(); i.value()->clearPixmapCache();
} }
if (noCard) if (noCard)
noCard->clearPixmapCache(); noCard->clearPixmapCache();
} }
void CardDatabase::loadSetsFromXml(QXmlStreamReader &xml) void CardDatabase::loadSetsFromXml(QXmlStreamReader &xml)
{ {
while (!xml.atEnd()) { while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement) if (xml.readNext() == QXmlStreamReader::EndElement)
break; break;
if (xml.name() == "set") { if (xml.name() == "set") {
QString shortName, longName; QString shortName, longName;
while (!xml.atEnd()) { while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement) if (xml.readNext() == QXmlStreamReader::EndElement)
break; break;
if (xml.name() == "name") if (xml.name() == "name")
shortName = xml.readElementText(); shortName = xml.readElementText();
else if (xml.name() == "longname") else if (xml.name() == "longname")
longName = xml.readElementText(); longName = xml.readElementText();
} }
setHash.insert(shortName, new CardSet(shortName, longName)); setHash.insert(shortName, new CardSet(shortName, longName));
} }
} }
} }
void CardDatabase::loadCardsFromXml(QXmlStreamReader &xml) void CardDatabase::loadCardsFromXml(QXmlStreamReader &xml)
{ {
while (!xml.atEnd()) { while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement) if (xml.readNext() == QXmlStreamReader::EndElement)
break; break;
if (xml.name() == "card") { if (xml.name() == "card") {
QString name, manacost, type, pt, text; QString name, manacost, type, pt, text;
QStringList colors; QStringList colors;
QMap<QString, QString> picURLs, picURLsHq, picURLsSt; QMap<QString, QString> picURLs, picURLsHq, picURLsSt;
SetList sets; SetList sets;
int tableRow = 0; int tableRow = 0;
int loyalty = 0; int loyalty = 0;
bool cipt = false; bool cipt = false;
bool isToken = false; bool isToken = false;
while (!xml.atEnd()) { while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement) if (xml.readNext() == QXmlStreamReader::EndElement)
break; break;
if (xml.name() == "name") if (xml.name() == "name")
name = xml.readElementText(); name = xml.readElementText();
else if (xml.name() == "manacost") else if (xml.name() == "manacost")
manacost = xml.readElementText(); manacost = xml.readElementText();
else if (xml.name() == "type") else if (xml.name() == "type")
type = xml.readElementText(); type = xml.readElementText();
else if (xml.name() == "pt") else if (xml.name() == "pt")
pt = xml.readElementText(); pt = xml.readElementText();
else if (xml.name() == "text") else if (xml.name() == "text")
text = xml.readElementText(); text = xml.readElementText();
else if (xml.name() == "set") { else if (xml.name() == "set") {
QString picURL = xml.attributes().value("picURL").toString(); QString picURL = xml.attributes().value("picURL").toString();
QString picURLHq = xml.attributes().value("picURLHq").toString(); QString picURLHq = xml.attributes().value("picURLHq").toString();
QString picURLSt = xml.attributes().value("picURLSt").toString(); QString picURLSt = xml.attributes().value("picURLSt").toString();
QString setName = xml.readElementText(); QString setName = xml.readElementText();
sets.append(getSet(setName)); sets.append(getSet(setName));
picURLs.insert(setName, picURL); picURLs.insert(setName, picURL);
picURLsHq.insert(setName, picURLHq); picURLsHq.insert(setName, picURLHq);
picURLsSt.insert(setName, picURLSt); picURLsSt.insert(setName, picURLSt);
} else if (xml.name() == "color") } else if (xml.name() == "color")
colors << xml.readElementText(); colors << xml.readElementText();
else if (xml.name() == "tablerow") else if (xml.name() == "tablerow")
tableRow = xml.readElementText().toInt(); tableRow = xml.readElementText().toInt();
else if (xml.name() == "cipt") else if (xml.name() == "cipt")
cipt = (xml.readElementText() == "1"); cipt = (xml.readElementText() == "1");
else if (xml.name() == "loyalty") else if (xml.name() == "loyalty")
loyalty = xml.readElementText().toInt(); loyalty = xml.readElementText().toInt();
else if (xml.name() == "token") else if (xml.name() == "token")
isToken = xml.readElementText().toInt(); isToken = xml.readElementText().toInt();
} }
cardHash.insert(name, new CardInfo(this, name, isToken, manacost, type, pt, text, colors, loyalty, cipt, tableRow, sets, picURLs, picURLsHq, picURLsSt)); cardHash.insert(name, new CardInfo(this, name, isToken, manacost, type, pt, text, colors, loyalty, cipt, tableRow, sets, picURLs, picURLsHq, picURLsSt));
} }
} }
} }
bool CardDatabase::loadFromFile(const QString &fileName, bool tokens) bool CardDatabase::loadFromFile(const QString &fileName, bool tokens)
{ {
QFile file(fileName); QFile file(fileName);
file.open(QIODevice::ReadOnly); file.open(QIODevice::ReadOnly);
if (!file.isOpen()) if (!file.isOpen())
return false; return false;
if (tokens) { if (tokens) {
QMutableHashIterator<QString, CardInfo *> i(cardHash); QMutableHashIterator<QString, CardInfo *> i(cardHash);
while (i.hasNext()) { while (i.hasNext()) {
i.next(); i.next();
if (i.value()->getIsToken()) { if (i.value()->getIsToken()) {
delete i.value(); delete i.value();
i.remove(); i.remove();
} }
} }
} else { } else {
QHashIterator<QString, CardSet *> setIt(setHash); QHashIterator<QString, CardSet *> setIt(setHash);
while (setIt.hasNext()) { while (setIt.hasNext()) {
setIt.next(); setIt.next();
delete setIt.value(); delete setIt.value();
} }
setHash.clear(); setHash.clear();
QMutableHashIterator<QString, CardInfo *> i(cardHash); QMutableHashIterator<QString, CardInfo *> i(cardHash);
while (i.hasNext()) { while (i.hasNext()) {
i.next(); i.next();
if (!i.value()->getIsToken()) { if (!i.value()->getIsToken()) {
delete i.value(); delete i.value();
i.remove(); i.remove();
} }
} }
cardHash.clear(); cardHash.clear();
} }
QXmlStreamReader xml(&file); QXmlStreamReader xml(&file);
while (!xml.atEnd()) { while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::StartElement) { if (xml.readNext() == QXmlStreamReader::StartElement) {
if (xml.name() != "cockatrice_carddatabase") if (xml.name() != "cockatrice_carddatabase")
return false; return false;
if (xml.attributes().value("version").toString().toInt() < versionNeeded) if (xml.attributes().value("version").toString().toInt() < versionNeeded)
return false; return false;
while (!xml.atEnd()) { while (!xml.atEnd()) {
if (xml.readNext() == QXmlStreamReader::EndElement) if (xml.readNext() == QXmlStreamReader::EndElement)
break; break;
if (xml.name() == "sets") if (xml.name() == "sets")
loadSetsFromXml(xml); loadSetsFromXml(xml);
else if (xml.name() == "cards") else if (xml.name() == "cards")
loadCardsFromXml(xml); loadCardsFromXml(xml);
} }
} }
} }
qDebug() << cardHash.size() << "cards in" << setHash.size() << "sets loaded"; qDebug() << cardHash.size() << "cards in" << setHash.size() << "sets loaded";
return !cardHash.isEmpty(); return !cardHash.isEmpty();
} }
bool CardDatabase::saveToFile(const QString &fileName, bool tokens) bool CardDatabase::saveToFile(const QString &fileName, bool tokens)
{ {
QFile file(fileName); QFile file(fileName);
if (!file.open(QIODevice::WriteOnly)) if (!file.open(QIODevice::WriteOnly))
return false; return false;
QXmlStreamWriter xml(&file); QXmlStreamWriter xml(&file);
xml.setAutoFormatting(true); xml.setAutoFormatting(true);
xml.writeStartDocument(); xml.writeStartDocument();
xml.writeStartElement("cockatrice_carddatabase"); xml.writeStartElement("cockatrice_carddatabase");
xml.writeAttribute("version", QString::number(versionNeeded)); xml.writeAttribute("version", QString::number(versionNeeded));
if (!tokens) { if (!tokens) {
xml.writeStartElement("sets"); xml.writeStartElement("sets");
QHashIterator<QString, CardSet *> setIterator(setHash); QHashIterator<QString, CardSet *> setIterator(setHash);
while (setIterator.hasNext()) while (setIterator.hasNext())
xml << setIterator.next().value(); xml << setIterator.next().value();
xml.writeEndElement(); // sets xml.writeEndElement(); // sets
} }
xml.writeStartElement("cards"); xml.writeStartElement("cards");
QHashIterator<QString, CardInfo *> cardIterator(cardHash); QHashIterator<QString, CardInfo *> cardIterator(cardHash);
while (cardIterator.hasNext()) { while (cardIterator.hasNext()) {
CardInfo *card = cardIterator.next().value(); CardInfo *card = cardIterator.next().value();
if (card->getIsToken() == tokens) if (card->getIsToken() == tokens)
xml << card; xml << card;
} }
xml.writeEndElement(); // cards xml.writeEndElement(); // cards
xml.writeEndElement(); // cockatrice_carddatabase xml.writeEndElement(); // cockatrice_carddatabase
xml.writeEndDocument(); xml.writeEndDocument();
return true; return true;
} }
void CardDatabase::picDownloadChanged() void CardDatabase::picDownloadChanged()
{ {
pictureLoader->setPicDownload(settingsCache->getPicDownload()); pictureLoader->setPicDownload(settingsCache->getPicDownload());
if (settingsCache->getPicDownload()) { if (settingsCache->getPicDownload()) {
QHashIterator<QString, CardInfo *> cardIterator(cardHash); QHashIterator<QString, CardInfo *> cardIterator(cardHash);
while (cardIterator.hasNext()) while (cardIterator.hasNext())
cardIterator.next().value()->clearPixmapCacheMiss(); cardIterator.next().value()->clearPixmapCacheMiss();
} }
} }
bool CardDatabase::loadCardDatabase(const QString &path, bool tokens) bool CardDatabase::loadCardDatabase(const QString &path, bool tokens)
{ {
bool tempLoadSuccess = false; bool tempLoadSuccess = false;
if (!path.isEmpty()) if (!path.isEmpty())
tempLoadSuccess = loadFromFile(path, tokens); tempLoadSuccess = loadFromFile(path, tokens);
if (tempLoadSuccess) { if (tempLoadSuccess) {
SetList allSets; SetList allSets;
QHashIterator<QString, CardSet *> setsIterator(setHash); QHashIterator<QString, CardSet *> setsIterator(setHash);
while (setsIterator.hasNext()) while (setsIterator.hasNext())
allSets.append(setsIterator.next().value()); allSets.append(setsIterator.next().value());
allSets.sortByKey(); allSets.sortByKey();
for (int i = 0; i < allSets.size(); ++i) for (int i = 0; i < allSets.size(); ++i)
allSets[i]->setSortKey(i); allSets[i]->setSortKey(i);
emit cardListChanged(); emit cardListChanged();
} }
if (!tokens) if (!tokens)
loadSuccess = tempLoadSuccess; loadSuccess = tempLoadSuccess;
return tempLoadSuccess; return tempLoadSuccess;
} }
void CardDatabase::loadCardDatabase() void CardDatabase::loadCardDatabase()
{ {
loadCardDatabase(settingsCache->getCardDatabasePath(), false); loadCardDatabase(settingsCache->getCardDatabasePath(), false);
} }
void CardDatabase::loadTokenDatabase() void CardDatabase::loadTokenDatabase()
{ {
loadCardDatabase(settingsCache->getTokenDatabasePath(), true); loadCardDatabase(settingsCache->getTokenDatabasePath(), true);
} }
QStringList CardDatabase::getAllColors() const QStringList CardDatabase::getAllColors() const
{ {
QSet<QString> colors; QSet<QString> colors;
QHashIterator<QString, CardInfo *> cardIterator(cardHash); QHashIterator<QString, CardInfo *> cardIterator(cardHash);
while (cardIterator.hasNext()) { while (cardIterator.hasNext()) {
const QStringList &cardColors = cardIterator.next().value()->getColors(); const QStringList &cardColors = cardIterator.next().value()->getColors();
if (cardColors.isEmpty()) if (cardColors.isEmpty())
colors.insert("X"); colors.insert("X");
else else
for (int i = 0; i < cardColors.size(); ++i) for (int i = 0; i < cardColors.size(); ++i)
colors.insert(cardColors[i]); colors.insert(cardColors[i]);
} }
return colors.toList(); return colors.toList();
} }
QStringList CardDatabase::getAllMainCardTypes() const QStringList CardDatabase::getAllMainCardTypes() const
{ {
QSet<QString> types; QSet<QString> types;
QHashIterator<QString, CardInfo *> cardIterator(cardHash); QHashIterator<QString, CardInfo *> cardIterator(cardHash);
while (cardIterator.hasNext()) while (cardIterator.hasNext())
types.insert(cardIterator.next().value()->getMainCardType()); types.insert(cardIterator.next().value()->getMainCardType());
return types.toList(); return types.toList();
} }
void CardDatabase::cacheCardPixmaps(const QStringList &cardNames) void CardDatabase::cacheCardPixmaps(const QStringList &cardNames)
{ {
for (int i = 0; i < cardNames.size(); ++i) for (int i = 0; i < cardNames.size(); ++i)
getCard(cardNames[i])->loadPixmap(); getCard(cardNames[i])->loadPixmap();
} }
void CardDatabase::loadImage(CardInfo *card) void CardDatabase::loadImage(CardInfo *card)
{ {
pictureLoader->loadImage(card, false); pictureLoader->loadImage(card, false);
} }
void CardDatabase::imageLoaded(CardInfo *card, QImage image) void CardDatabase::imageLoaded(CardInfo *card, QImage image)
{ {
card->imageLoaded(image); card->imageLoaded(image);
} }
void CardDatabase::picsPathChanged() void CardDatabase::picsPathChanged()
{ {
pictureLoader->setPicsPath(settingsCache->getPicsPath()); pictureLoader->setPicsPath(settingsCache->getPicsPath());
clearPixmapCache(); clearPixmapCache();
} }
cockatrice/src/carddatabase.h
View file @ 1bc48a78
...@@ -22,191 +22,191 @@ typedef QMap<QString, QString> QStringMap; ...@@ -22,191 +22,191 @@ typedef QMap<QString, QString> QStringMap;
class CardSet : public QList<CardInfo *> { class CardSet : public QList<CardInfo *> {
private: private:
QString shortName, longName; QString shortName, longName;
unsigned int sortKey; unsigned int sortKey;
public: public:
CardSet(const QString &_shortName = QString(), const QString &_longName = QString()); CardSet(const QString &_shortName = QString(), const QString &_longName = QString());
QString getShortName() const { return shortName; } QString getShortName() const { return shortName; }
QString getLongName() const { return longName; } QString getLongName() const { return longName; }
int getSortKey() const { return sortKey; } int getSortKey() const { return sortKey; }
void setSortKey(unsigned int _sortKey); void setSortKey(unsigned int _sortKey);
void updateSortKey(); void updateSortKey();
}; };
class SetList : public QList<CardSet *> { class SetList : public QList<CardSet *> {
private: private:
class CompareFunctor; class CompareFunctor;
public: public:
void sortByKey(); void sortByKey();
}; };
class PictureToLoad { class PictureToLoad {
private: private:
CardInfo *card; CardInfo *card;
bool stripped; bool stripped;
SetList sortedSets; SetList sortedSets;
int setIndex; int setIndex;
bool hq; bool hq;
public: public:
PictureToLoad(CardInfo *_card = 0, bool _stripped = false, bool _hq = true); PictureToLoad(CardInfo *_card = 0, bool _stripped = false, bool _hq = true);
CardInfo *getCard() const { return card; } CardInfo *getCard() const { return card; }
bool getStripped() const { return stripped; } bool getStripped() const { return stripped; }
QString getSetName() const { return sortedSets[setIndex]->getShortName(); } QString getSetName() const { return sortedSets[setIndex]->getShortName(); }
bool nextSet(); bool nextSet();
bool getHq() const { return hq; } bool getHq() const { return hq; }
void setHq(bool _hq) { hq = _hq; } void setHq(bool _hq) { hq = _hq; }
}; };
class PictureLoader : public QObject { class PictureLoader : public QObject {
Q_OBJECT Q_OBJECT
private: private:
QString _picsPath; QString _picsPath;
QList<PictureToLoad> loadQueue; QList<PictureToLoad> loadQueue;
QMutex mutex; QMutex mutex;
QNetworkAccessManager *networkManager; QNetworkAccessManager *networkManager;
QList<PictureToLoad> cardsToDownload; QList<PictureToLoad> cardsToDownload;
PictureToLoad cardBeingDownloaded; PictureToLoad cardBeingDownloaded;
bool picDownload, downloadRunning, loadQueueRunning; bool picDownload, downloadRunning, loadQueueRunning;
void startNextPicDownload(); void startNextPicDownload();
public: public:
PictureLoader(const QString &__picsPath, bool _picDownload, QObject *parent = 0); PictureLoader(const QString &__picsPath, bool _picDownload, QObject *parent = 0);
~PictureLoader(); ~PictureLoader();
void setPicsPath(const QString &path); void setPicsPath(const QString &path);
void setPicDownload(bool _picDownload); void setPicDownload(bool _picDownload);
void loadImage(CardInfo *card, bool stripped); void loadImage(CardInfo *card, bool stripped);
private slots: private slots:
void picDownloadFinished(QNetworkReply *reply); void picDownloadFinished(QNetworkReply *reply);
public slots: public slots:
void processLoadQueue(); void processLoadQueue();
signals: signals:
void startLoadQueue(); void startLoadQueue();
void imageLoaded(CardInfo *card, const QImage &image); void imageLoaded(CardInfo *card, const QImage &image);
}; };
class CardInfo : public QObject { class CardInfo : public QObject {
Q_OBJECT Q_OBJECT
private: private:
CardDatabase *db; CardDatabase *db;
QString name; QString name;
bool isToken; bool isToken;
SetList sets; SetList sets;
QString manacost; QString manacost;
QString cardtype; QString cardtype;
QString powtough; QString powtough;
QString text; QString text;
QStringList colors; QStringList colors;
int loyalty; int loyalty;
QMap<QString, QString> picURLs, picURLsHq, picURLsSt; QMap<QString, QString> picURLs, picURLsHq, picURLsSt;
bool cipt; bool cipt;
int tableRow; int tableRow;
QPixmap *pixmap; QPixmap *pixmap;
QMap<int, QPixmap *> scaledPixmapCache; QMap<int, QPixmap *> scaledPixmapCache;
public: public:
CardInfo(CardDatabase *_db, CardInfo(CardDatabase *_db,
const QString &_name = QString(), const QString &_name = QString(),
bool _isToken = false, bool _isToken = false,
const QString &_manacost = QString(), const QString &_manacost = QString(),
const QString &_cardtype = QString(), const QString &_cardtype = QString(),
const QString &_powtough = QString(), const QString &_powtough = QString(),
const QString &_text = QString(), const QString &_text = QString(),
const QStringList &_colors = QStringList(), const QStringList &_colors = QStringList(),
int _loyalty = 0, int _loyalty = 0,
bool _cipt = false, bool _cipt = false,
int _tableRow = 0, int _tableRow = 0,
const SetList &_sets = SetList(), const SetList &_sets = SetList(),
const QStringMap &_picURLs = QStringMap(), const QStringMap &_picURLs = QStringMap(),
const QStringMap &_picURLsHq = QStringMap(), const QStringMap &_picURLsHq = QStringMap(),
const QStringMap &_picURLsSt = QStringMap()); const QStringMap &_picURLsSt = QStringMap());
~CardInfo(); ~CardInfo();
const QString &getName() const { return name; } const QString &getName() const { return name; }
bool getIsToken() const { return isToken; } bool getIsToken() const { return isToken; }
const SetList &getSets() const { return sets; } const SetList &getSets() const { return sets; }
const QString &getManaCost() const { return manacost; } const QString &getManaCost() const { return manacost; }
const QString &getCardType() const { return cardtype; } const QString &getCardType() const { return cardtype; }
const QString &getPowTough() const { return powtough; } const QString &getPowTough() const { return powtough; }
const QString &getText() const { return text; } const QString &getText() const { return text; }
const int &getLoyalty() const { return loyalty; } const int &getLoyalty() const { return loyalty; }
bool getCipt() const { return cipt; } bool getCipt() const { return cipt; }
void setManaCost(const QString &_manaCost) { manacost = _manaCost; emit cardInfoChanged(this); } void setManaCost(const QString &_manaCost) { manacost = _manaCost; emit cardInfoChanged(this); }
void setCardType(const QString &_cardType) { cardtype = _cardType; emit cardInfoChanged(this); } void setCardType(const QString &_cardType) { cardtype = _cardType; emit cardInfoChanged(this); }
void setPowTough(const QString &_powTough) { powtough = _powTough; emit cardInfoChanged(this); } void setPowTough(const QString &_powTough) { powtough = _powTough; emit cardInfoChanged(this); }
void setText(const QString &_text) { text = _text; emit cardInfoChanged(this); } void setText(const QString &_text) { text = _text; emit cardInfoChanged(this); }
void setColors(const QStringList &_colors) { colors = _colors; emit cardInfoChanged(this); } void setColors(const QStringList &_colors) { colors = _colors; emit cardInfoChanged(this); }
const QStringList &getColors() const { return colors; } const QStringList &getColors() const { return colors; }
QString getPicURL(const QString &set) const { return picURLs.value(set); } QString getPicURL(const QString &set) const { return picURLs.value(set); }
QString getPicURLHq(const QString &set) const { return picURLsHq.value(set); } QString getPicURLHq(const QString &set) const { return picURLsHq.value(set); }
QString getPicURLSt(const QString &set) const { return picURLsSt.value(set); } QString getPicURLSt(const QString &set) const { return picURLsSt.value(set); }
QString getPicURL() const; QString getPicURL() const;
const QMap<QString, QString> &getPicURLs() const { return picURLs; } const QMap<QString, QString> &getPicURLs() const { return picURLs; }
QString getMainCardType() const; QString getMainCardType() const;
QString getCorrectedName() const; QString getCorrectedName() const;
int getTableRow() const { return tableRow; } int getTableRow() const { return tableRow; }
void setTableRow(int _tableRow) { tableRow = _tableRow; } void setTableRow(int _tableRow) { tableRow = _tableRow; }
void setLoyalty(int _loyalty) { loyalty = _loyalty; emit cardInfoChanged(this); } void setLoyalty(int _loyalty) { loyalty = _loyalty; emit cardInfoChanged(this); }
void setPicURL(const QString &_set, const QString &_picURL) { picURLs.insert(_set, _picURL); } void setPicURL(const QString &_set, const QString &_picURL) { picURLs.insert(_set, _picURL); }
void setPicURLHq(const QString &_set, const QString &_picURL) { picURLsHq.insert(_set, _picURL); } void setPicURLHq(const QString &_set, const QString &_picURL) { picURLsHq.insert(_set, _picURL); }
void setPicURLSt(const QString &_set, const QString &_picURL) { picURLsSt.insert(_set, _picURL); } void setPicURLSt(const QString &_set, const QString &_picURL) { picURLsSt.insert(_set, _picURL); }
void addToSet(CardSet *set); void addToSet(CardSet *set);
QPixmap *loadPixmap(); QPixmap *loadPixmap();
QPixmap *getPixmap(QSize size); QPixmap *getPixmap(QSize size);
void clearPixmapCache(); void clearPixmapCache();
void clearPixmapCacheMiss(); void clearPixmapCacheMiss();
void imageLoaded(const QImage &image); void imageLoaded(const QImage &image);
public slots: public slots:
void updatePixmapCache(); void updatePixmapCache();
signals: signals:
void pixmapUpdated(); void pixmapUpdated();
void cardInfoChanged(CardInfo *card); void cardInfoChanged(CardInfo *card);
}; };
class CardDatabase : public QObject { class CardDatabase : public QObject {
Q_OBJECT Q_OBJECT
protected: protected:
QHash<QString, CardInfo *> cardHash; QHash<QString, CardInfo *> cardHash;
QHash<QString, CardSet *> setHash; QHash<QString, CardSet *> setHash;
bool loadSuccess; bool loadSuccess;
CardInfo *noCard; CardInfo *noCard;
QThread *pictureLoaderThread; QThread *pictureLoaderThread;
PictureLoader *pictureLoader; PictureLoader *pictureLoader;
private: private:
static const int versionNeeded; static const int versionNeeded;
void loadCardsFromXml(QXmlStreamReader &xml); void loadCardsFromXml(QXmlStreamReader &xml);
void loadSetsFromXml(QXmlStreamReader &xml); void loadSetsFromXml(QXmlStreamReader &xml);
public: public:
CardDatabase(QObject *parent = 0); CardDatabase(QObject *parent = 0);
~CardDatabase(); ~CardDatabase();
void clear(); void clear();
void addCard(CardInfo *card); void addCard(CardInfo *card);
void removeCard(CardInfo *card); void removeCard(CardInfo *card);
CardInfo *getCard(const QString &cardName = QString(), bool createIfNotFound = true); CardInfo *getCard(const QString &cardName = QString(), bool createIfNotFound = true);
CardSet *getSet(const QString &setName); CardSet *getSet(const QString &setName);
QList<CardInfo *> getCardList() const { return cardHash.values(); } QList<CardInfo *> getCardList() const { return cardHash.values(); }
SetList getSetList() const; SetList getSetList() const;
bool loadFromFile(const QString &fileName, bool tokens = false); bool loadFromFile(const QString &fileName, bool tokens = false);
bool saveToFile(const QString &fileName, bool tokens = false); bool saveToFile(const QString &fileName, bool tokens = false);
QStringList getAllColors() const; QStringList getAllColors() const;
QStringList getAllMainCardTypes() const; QStringList getAllMainCardTypes() const;
bool getLoadSuccess() const { return loadSuccess; } bool getLoadSuccess() const { return loadSuccess; }
void cacheCardPixmaps(const QStringList &cardNames); void cacheCardPixmaps(const QStringList &cardNames);
void loadImage(CardInfo *card); void loadImage(CardInfo *card);
public slots: public slots:
void clearPixmapCache(); void clearPixmapCache();
bool loadCardDatabase(const QString &path, bool tokens = false); bool loadCardDatabase(const QString &path, bool tokens = false);
private slots: private slots:
void imageLoaded(CardInfo *card, QImage image); void imageLoaded(CardInfo *card, QImage image);
void picDownloadChanged(); void picDownloadChanged();
void picsPathChanged(); void picsPathChanged();
void loadCardDatabase(); void loadCardDatabase();
void loadTokenDatabase(); void loadTokenDatabase();
signals: signals:
void cardListChanged(); void cardListChanged();
void cardAdded(CardInfo *card); void cardAdded(CardInfo *card);
void cardRemoved(CardInfo *card); void cardRemoved(CardInfo *card);
}; };
#endif #endif
cockatrice/src/carddatabasemodel.cpp
View file @ 1bc48a78
#include "carddatabasemodel.h" #include "carddatabasemodel.h"
CardDatabaseModel::CardDatabaseModel(CardDatabase *_db, QObject *parent) CardDatabaseModel::CardDatabaseModel(CardDatabase *_db, QObject *parent)
: QAbstractListModel(parent), db(_db) : QAbstractListModel(parent), db(_db)
{ {
connect(db, SIGNAL(cardListChanged()), this, SLOT(updateCardList())); connect(db, SIGNAL(cardListChanged()), this, SLOT(updateCardList()));
connect(db, SIGNAL(cardAdded(CardInfo *)), this, SLOT(cardAdded(CardInfo *))); connect(db, SIGNAL(cardAdded(CardInfo *)), this, SLOT(cardAdded(CardInfo *)));
connect(db, SIGNAL(cardRemoved(CardInfo *)), this, SLOT(cardRemoved(CardInfo *))); connect(db, SIGNAL(cardRemoved(CardInfo *)), this, SLOT(cardRemoved(CardInfo *)));
updateCardList(); updateCardList();
} }
CardDatabaseModel::~CardDatabaseModel() CardDatabaseModel::~CardDatabaseModel()
...@@ -15,143 +15,143 @@ CardDatabaseModel::~CardDatabaseModel() ...@@ -15,143 +15,143 @@ CardDatabaseModel::~CardDatabaseModel()
int CardDatabaseModel::rowCount(const QModelIndex &/*parent*/) const int CardDatabaseModel::rowCount(const QModelIndex &/*parent*/) const
{ {
return cardList.size(); return cardList.size();
} }
int CardDatabaseModel::columnCount(const QModelIndex &/*parent*/) const int CardDatabaseModel::columnCount(const QModelIndex &/*parent*/) const
{ {
return 5; return 5;
} }
QVariant CardDatabaseModel::data(const QModelIndex &index, int role) const QVariant CardDatabaseModel::data(const QModelIndex &index, int role) const
{ {
if (!index.isValid()) if (!index.isValid())
return QVariant(); return QVariant();
if ((index.row() >= cardList.size()) || (index.column() >= 5)) if ((index.row() >= cardList.size()) || (index.column() >= 5))
return QVariant(); return QVariant();
if (role != Qt::DisplayRole) if (role != Qt::DisplayRole)
return QVariant(); return QVariant();
CardInfo *card = cardList.at(index.row()); CardInfo *card = cardList.at(index.row());
switch (index.column()){ switch (index.column()){
case 0: return card->getName(); case 0: return card->getName();
case 1: { case 1: {
QStringList setList; QStringList setList;
const QList<CardSet *> &sets = card->getSets(); const QList<CardSet *> &sets = card->getSets();
for (int i = 0; i < sets.size(); i++) for (int i = 0; i < sets.size(); i++)
setList << sets[i]->getShortName(); setList << sets[i]->getShortName();
return setList.join(", "); return setList.join(", ");
} }
case 2: return card->getManaCost(); case 2: return card->getManaCost();
case 3: return card->getCardType(); case 3: return card->getCardType();
case 4: return card->getPowTough(); case 4: return card->getPowTough();
default: return QVariant(); default: return QVariant();
} }
} }
QVariant CardDatabaseModel::headerData(int section, Qt::Orientation orientation, int role) const QVariant CardDatabaseModel::headerData(int section, Qt::Orientation orientation, int role) const
{ {
if (role != Qt::DisplayRole) if (role != Qt::DisplayRole)
return QVariant(); return QVariant();
if (orientation != Qt::Horizontal) if (orientation != Qt::Horizontal)
return QVariant(); return QVariant();
switch (section) { switch (section) {
case 0: return QString(tr("Name")); case 0: return QString(tr("Name"));
case 1: return QString(tr("Sets")); case 1: return QString(tr("Sets"));
case 2: return QString(tr("Mana cost")); case 2: return QString(tr("Mana cost"));
case 3: return QString(tr("Card type")); case 3: return QString(tr("Card type"));
case 4: return QString(tr("P/T")); case 4: return QString(tr("P/T"));
default: return QVariant(); default: return QVariant();
} }
} }
void CardDatabaseModel::updateCardList() void CardDatabaseModel::updateCardList()
{ {
for (int i = 0; i < cardList.size(); ++i) for (int i = 0; i < cardList.size(); ++i)
disconnect(cardList[i], 0, this, 0); disconnect(cardList[i], 0, this, 0);
cardList = db->getCardList(); cardList = db->getCardList();
for (int i = 0; i < cardList.size(); ++i) for (int i = 0; i < cardList.size(); ++i)
connect(cardList[i], SIGNAL(cardInfoChanged(CardInfo *)), this, SLOT(cardInfoChanged(CardInfo *))); connect(cardList[i], SIGNAL(cardInfoChanged(CardInfo *)), this, SLOT(cardInfoChanged(CardInfo *)));
reset(); reset();
} }
void CardDatabaseModel::cardInfoChanged(CardInfo *card) void CardDatabaseModel::cardInfoChanged(CardInfo *card)
{ {
const int row = cardList.indexOf(card); const int row = cardList.indexOf(card);
if (row == -1) if (row == -1)
return; return;
emit dataChanged(index(row, 0), index(row, 4)); emit dataChanged(index(row, 0), index(row, 4));
} }
void CardDatabaseModel::cardAdded(CardInfo *card) void CardDatabaseModel::cardAdded(CardInfo *card)
{ {
beginInsertRows(QModelIndex(), cardList.size(), cardList.size()); beginInsertRows(QModelIndex(), cardList.size(), cardList.size());
cardList.append(card); cardList.append(card);
connect(card, SIGNAL(cardInfoChanged(CardInfo *)), this, SLOT(cardInfoChanged(CardInfo *))); connect(card, SIGNAL(cardInfoChanged(CardInfo *)), this, SLOT(cardInfoChanged(CardInfo *)));
endInsertRows(); endInsertRows();
} }
void CardDatabaseModel::cardRemoved(CardInfo *card) void CardDatabaseModel::cardRemoved(CardInfo *card)
{ {
const int row = cardList.indexOf(card); const int row = cardList.indexOf(card);
if (row == -1) if (row == -1)
return; return;
beginRemoveRows(QModelIndex(), row, row); beginRemoveRows(QModelIndex(), row, row);
cardList.removeAt(row); cardList.removeAt(row);
endRemoveRows(); endRemoveRows();
} }
CardDatabaseDisplayModel::CardDatabaseDisplayModel(QObject *parent) CardDatabaseDisplayModel::CardDatabaseDisplayModel(QObject *parent)
: QSortFilterProxyModel(parent), : QSortFilterProxyModel(parent),
isToken(ShowAll) isToken(ShowAll)
{ {
setFilterCaseSensitivity(Qt::CaseInsensitive); setFilterCaseSensitivity(Qt::CaseInsensitive);
setSortCaseSensitivity(Qt::CaseInsensitive); setSortCaseSensitivity(Qt::CaseInsensitive);
} }
bool CardDatabaseDisplayModel::filterAcceptsRow(int sourceRow, const QModelIndex & /*sourceParent*/) const bool CardDatabaseDisplayModel::filterAcceptsRow(int sourceRow, const QModelIndex & /*sourceParent*/) const
{ {
CardInfo const *info = static_cast<CardDatabaseModel *>(sourceModel())->getCard(sourceRow); CardInfo const *info = static_cast<CardDatabaseModel *>(sourceModel())->getCard(sourceRow);
if (((isToken == ShowTrue) && !info->getIsToken()) || ((isToken == ShowFalse) && info->getIsToken())) if (((isToken == ShowTrue) && !info->getIsToken()) || ((isToken == ShowFalse) && info->getIsToken()))
return false; return false;
if (!cardNameBeginning.isEmpty()) if (!cardNameBeginning.isEmpty())
if (!info->getName().startsWith(cardNameBeginning, Qt::CaseInsensitive)) if (!info->getName().startsWith(cardNameBeginning, Qt::CaseInsensitive))
return false; return false;
if (!cardName.isEmpty()) if (!cardName.isEmpty())
if (!info->getName().contains(cardName, Qt::CaseInsensitive)) if (!info->getName().contains(cardName, Qt::CaseInsensitive))
return false; return false;
if (!cardNameSet.isEmpty()) if (!cardNameSet.isEmpty())
if (!cardNameSet.contains(info->getName())) if (!cardNameSet.contains(info->getName()))
return false; return false;
if (!cardText.isEmpty()) if (!cardText.isEmpty())
if (!info->getText().contains(cardText, Qt::CaseInsensitive)) if (!info->getText().contains(cardText, Qt::CaseInsensitive))
return false; return false;
if (!cardColors.isEmpty()) if (!cardColors.isEmpty())
if (QSet<QString>::fromList(info->getColors()).intersect(cardColors).isEmpty() && !(info->getColors().isEmpty() && cardColors.contains("X"))) if (QSet<QString>::fromList(info->getColors()).intersect(cardColors).isEmpty() && !(info->getColors().isEmpty() && cardColors.contains("X")))
return false; return false;
if (!cardTypes.isEmpty()) if (!cardTypes.isEmpty())
if (!cardTypes.contains(info->getMainCardType())) if (!cardTypes.contains(info->getMainCardType()))
return false; return false;
return true; return true;
} }
void CardDatabaseDisplayModel::clearSearch() void CardDatabaseDisplayModel::clearSearch()
{ {
cardName.clear(); cardName.clear();
cardText.clear(); cardText.clear();
cardTypes.clear(); cardTypes.clear();
cardColors.clear(); cardColors.clear();
invalidateFilter(); invalidateFilter();
} }
cockatrice/src/carddatabasemodel.h
View file @ 1bc48a78
...@@ -8,46 +8,46 @@ ...@@ -8,46 +8,46 @@
#include "carddatabase.h" #include "carddatabase.h"
class CardDatabaseModel : public QAbstractListModel { class CardDatabaseModel : public QAbstractListModel {
Q_OBJECT Q_OBJECT
public: public:
CardDatabaseModel(CardDatabase *_db, QObject *parent = 0); CardDatabaseModel(CardDatabase *_db, QObject *parent = 0);
~CardDatabaseModel(); ~CardDatabaseModel();
int rowCount(const QModelIndex &parent = QModelIndex()) const; int rowCount(const QModelIndex &parent = QModelIndex()) const;
int columnCount(const QModelIndex &parent = QModelIndex()) const; int columnCount(const QModelIndex &parent = QModelIndex()) const;
QVariant data(const QModelIndex &index, int role) const; QVariant data(const QModelIndex &index, int role) const;
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const; QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
CardDatabase *getDatabase() const { return db; } CardDatabase *getDatabase() const { return db; }
CardInfo *getCard(int index) const { return cardList[index]; } CardInfo *getCard(int index) const { return cardList[index]; }
private: private:
QList<CardInfo *> cardList; QList<CardInfo *> cardList;
CardDatabase *db; CardDatabase *db;
private slots: private slots:
void updateCardList(); void updateCardList();
void cardAdded(CardInfo *card); void cardAdded(CardInfo *card);
void cardRemoved(CardInfo *card); void cardRemoved(CardInfo *card);
void cardInfoChanged(CardInfo *card); void cardInfoChanged(CardInfo *card);
}; };
class CardDatabaseDisplayModel : public QSortFilterProxyModel { class CardDatabaseDisplayModel : public QSortFilterProxyModel {
Q_OBJECT Q_OBJECT
public: public:
enum FilterBool { ShowTrue, ShowFalse, ShowAll }; enum FilterBool { ShowTrue, ShowFalse, ShowAll };
private: private:
FilterBool isToken; FilterBool isToken;
QString cardNameBeginning, cardName, cardText; QString cardNameBeginning, cardName, cardText;
QSet<QString> cardNameSet, cardTypes, cardColors; QSet<QString> cardNameSet, cardTypes, cardColors;
public: public:
CardDatabaseDisplayModel(QObject *parent = 0); CardDatabaseDisplayModel(QObject *parent = 0);
void setIsToken(FilterBool _isToken) { isToken = _isToken; invalidate(); } void setIsToken(FilterBool _isToken) { isToken = _isToken; invalidate(); }
void setCardNameBeginning(const QString &_beginning) { cardNameBeginning = _beginning; invalidate(); } void setCardNameBeginning(const QString &_beginning) { cardNameBeginning = _beginning; invalidate(); }
void setCardName(const QString &_cardName) { cardName = _cardName; invalidate(); } void setCardName(const QString &_cardName) { cardName = _cardName; invalidate(); }
void setCardNameSet(const QSet<QString> &_cardNameSet) { cardNameSet = _cardNameSet; invalidate(); } void setCardNameSet(const QSet<QString> &_cardNameSet) { cardNameSet = _cardNameSet; invalidate(); }
void setCardText(const QString &_cardText) { cardText = _cardText; invalidate(); } void setCardText(const QString &_cardText) { cardText = _cardText; invalidate(); }
void setCardTypes(const QSet<QString> &_cardTypes) { cardTypes = _cardTypes; invalidate(); } void setCardTypes(const QSet<QString> &_cardTypes) { cardTypes = _cardTypes; invalidate(); }
void setCardColors(const QSet<QString> &_cardColors) { cardColors = _cardColors; invalidate(); } void setCardColors(const QSet<QString> &_cardColors) { cardColors = _cardColors; invalidate(); }
void clearSearch(); void clearSearch();
protected: protected:
bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const; bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const;
}; };
#endif #endif
cockatrice/src/carddragitem.cpp
View file @ 1bc48a78
...@@ -9,82 +9,82 @@ ...@@ -9,82 +9,82 @@
#include <QPainter> #include <QPainter>
CardDragItem::CardDragItem(CardItem *_item, int _id, const QPointF &_hotSpot, bool _faceDown, AbstractCardDragItem *parentDrag) CardDragItem::CardDragItem(CardItem *_item, int _id, const QPointF &_hotSpot, bool _faceDown, AbstractCardDragItem *parentDrag)
: AbstractCardDragItem(_item, _hotSpot, parentDrag), id(_id), faceDown(_faceDown), occupied(false), currentZone(0) : AbstractCardDragItem(_item, _hotSpot, parentDrag), id(_id), faceDown(_faceDown), occupied(false), currentZone(0)
{ {
} }
void CardDragItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) void CardDragItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{ {
AbstractCardDragItem::paint(painter, option, widget); AbstractCardDragItem::paint(painter, option, widget);
if (occupied) if (occupied)
painter->fillRect(boundingRect(), QColor(200, 0, 0, 100)); painter->fillRect(boundingRect(), QColor(200, 0, 0, 100));
} }
void CardDragItem::updatePosition(const QPointF &cursorScenePos) void CardDragItem::updatePosition(const QPointF &cursorScenePos)
{ {
QList<QGraphicsItem *> colliding = scene()->items(cursorScenePos, Qt::IntersectsItemBoundingRect, Qt::DescendingOrder, static_cast<GameScene *>(scene())->getViewTransform()); QList<QGraphicsItem *> colliding = scene()->items(cursorScenePos, Qt::IntersectsItemBoundingRect, Qt::DescendingOrder, static_cast<GameScene *>(scene())->getViewTransform());
CardZone *cardZone = 0; CardZone *cardZone = 0;
ZoneViewZone *zoneViewZone = 0; ZoneViewZone *zoneViewZone = 0;
for (int i = colliding.size() - 1; i >= 0; i--) { for (int i = colliding.size() - 1; i >= 0; i--) {
CardZone *temp = qgraphicsitem_cast<CardZone *>(colliding.at(i)); CardZone *temp = qgraphicsitem_cast<CardZone *>(colliding.at(i));
if (!cardZone) if (!cardZone)
cardZone = temp; cardZone = temp;
if (!zoneViewZone) if (!zoneViewZone)
zoneViewZone = qobject_cast<ZoneViewZone *>(temp); zoneViewZone = qobject_cast<ZoneViewZone *>(temp);
} }
CardZone *cursorZone = 0; CardZone *cursorZone = 0;
if (zoneViewZone) if (zoneViewZone)
cursorZone = zoneViewZone; cursorZone = zoneViewZone;
else if (cardZone) else if (cardZone)
cursorZone = cardZone; cursorZone = cardZone;
if (!cursorZone) if (!cursorZone)
return; return;
currentZone = cursorZone; currentZone = cursorZone;
QPointF zonePos = currentZone->scenePos(); QPointF zonePos = currentZone->scenePos();
QPointF cursorPosInZone = cursorScenePos - zonePos; QPointF cursorPosInZone = cursorScenePos - zonePos;
QPointF cardTopLeft = cursorPosInZone - hotSpot; QPointF cardTopLeft = cursorPosInZone - hotSpot;
QPointF closestGridPoint = cursorZone->closestGridPoint(cardTopLeft); QPointF closestGridPoint = cursorZone->closestGridPoint(cardTopLeft);
QPointF newPos = zonePos + closestGridPoint; QPointF newPos = zonePos + closestGridPoint;
if (newPos != pos()) { if (newPos != pos()) {
for (int i = 0; i < childDrags.size(); i++) for (int i = 0; i < childDrags.size(); i++)
childDrags[i]->setPos(newPos + childDrags[i]->getHotSpot()); childDrags[i]->setPos(newPos + childDrags[i]->getHotSpot());
setPos(newPos); setPos(newPos);
bool newOccupied = false; bool newOccupied = false;
TableZone *table = qobject_cast<TableZone *>(cursorZone); TableZone *table = qobject_cast<TableZone *>(cursorZone);
if (table) if (table)
if (table->getCardFromCoords(closestGridPoint)) if (table->getCardFromCoords(closestGridPoint))
newOccupied = true; newOccupied = true;
if (newOccupied != occupied) { if (newOccupied != occupied) {
occupied = newOccupied; occupied = newOccupied;
update(); update();
} }
} }
} }
void CardDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event) void CardDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{ {
setCursor(Qt::OpenHandCursor); setCursor(Qt::OpenHandCursor);
QGraphicsScene *sc = scene(); QGraphicsScene *sc = scene();
QPointF sp = pos(); QPointF sp = pos();
sc->removeItem(this); sc->removeItem(this);
QList<CardDragItem *> dragItemList; QList<CardDragItem *> dragItemList;
CardZone *startZone = static_cast<CardItem *>(item)->getZone(); CardZone *startZone = static_cast<CardItem *>(item)->getZone();
if (currentZone && !(static_cast<CardItem *>(item)->getAttachedTo() && (startZone == currentZone))) { if (currentZone && !(static_cast<CardItem *>(item)->getAttachedTo() && (startZone == currentZone))) {
dragItemList.append(this); dragItemList.append(this);
for (int i = 0; i < childDrags.size(); i++) { for (int i = 0; i < childDrags.size(); i++) {
CardDragItem *c = static_cast<CardDragItem *>(childDrags[i]); CardDragItem *c = static_cast<CardDragItem *>(childDrags[i]);
if (!(static_cast<CardItem *>(c->item)->getAttachedTo() && (startZone == currentZone)) && !c->occupied) if (!(static_cast<CardItem *>(c->item)->getAttachedTo() && (startZone == currentZone)) && !c->occupied)
dragItemList.append(c); dragItemList.append(c);
sc->removeItem(c); sc->removeItem(c);
} }
} }
currentZone->handleDropEvent(dragItemList, startZone, (sp - currentZone->scenePos()).toPoint()); currentZone->handleDropEvent(dragItemList, startZone, (sp - currentZone->scenePos()).toPoint());
event->accept(); event->accept();
} }
cockatrice/src/carddragitem.h
View file @ 1bc48a78
...@@ -6,20 +6,20 @@ ...@@ -6,20 +6,20 @@
class CardItem; class CardItem;
class CardDragItem : public AbstractCardDragItem { class CardDragItem : public AbstractCardDragItem {
Q_OBJECT Q_OBJECT
private: private:
int id; int id;
bool faceDown; bool faceDown;
bool occupied; bool occupied;
CardZone *currentZone; CardZone *currentZone;
public: public:
CardDragItem(CardItem *_item, int _id, const QPointF &_hotSpot, bool _faceDown, AbstractCardDragItem *parentDrag = 0); CardDragItem(CardItem *_item, int _id, const QPointF &_hotSpot, bool _faceDown, AbstractCardDragItem *parentDrag = 0);
int getId() const { return id; } int getId() const { return id; }
bool getFaceDown() const { return faceDown; } bool getFaceDown() const { return faceDown; }
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget); void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
void updatePosition(const QPointF &cursorScenePos); void updatePosition(const QPointF &cursorScenePos);
protected: protected:
void mouseReleaseEvent(QGraphicsSceneMouseEvent *event); void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
}; };
#endif #endif
cockatrice/src/cardinfowidget.cpp
View file @ 1bc48a78
...@@ -12,209 +12,209 @@ ...@@ -12,209 +12,209 @@
#include "settingscache.h" #include "settingscache.h"
CardInfoWidget::CardInfoWidget(ResizeMode _mode, const QString &cardName, QWidget *parent, Qt::WindowFlags flags) CardInfoWidget::CardInfoWidget(ResizeMode _mode, const QString &cardName, QWidget *parent, Qt::WindowFlags flags)
: QFrame(parent, flags) : QFrame(parent, flags)
, pixmapWidth(0) , pixmapWidth(0)
, aspectRatio((qreal) CARD_HEIGHT / (qreal) CARD_WIDTH) , aspectRatio((qreal) CARD_HEIGHT / (qreal) CARD_WIDTH)
, minimized(settingsCache->getCardInfoMinimized()) // Initialize the cardinfo view status from cache. , minimized(settingsCache->getCardInfoMinimized()) // Initialize the cardinfo view status from cache.
, mode(_mode) , mode(_mode)
, info(0) , info(0)
{ {
if (mode == ModeGameTab) { if (mode == ModeGameTab) {
// Create indexed list of status views for card. // Create indexed list of status views for card.
const QStringList cardInfoStatus = QStringList() << tr("Show card only") << tr("Show text only") << tr("Show full info"); const QStringList cardInfoStatus = QStringList() << tr("Show card only") << tr("Show text only") << tr("Show full info");
// Create droplist for cardinfo view selection, and set right current index. // Create droplist for cardinfo view selection, and set right current index.
dropList = new QComboBox(); dropList = new QComboBox();
dropList->addItems(cardInfoStatus); dropList->addItems(cardInfoStatus);
dropList->setCurrentIndex(minimized); dropList->setCurrentIndex(minimized);
connect(dropList, SIGNAL(currentIndexChanged(int)), this, SLOT(minimizeClicked(int))); connect(dropList, SIGNAL(currentIndexChanged(int)), this, SLOT(minimizeClicked(int)));
} }
cardPicture = new QLabel; cardPicture = new QLabel;
cardPicture->setAlignment(Qt::AlignCenter); cardPicture->setAlignment(Qt::AlignCenter);
nameLabel1 = new QLabel; nameLabel1 = new QLabel;
nameLabel2 = new QLabel; nameLabel2 = new QLabel;
nameLabel2->setWordWrap(true); nameLabel2->setWordWrap(true);
manacostLabel1 = new QLabel; manacostLabel1 = new QLabel;
manacostLabel2 = new QLabel; manacostLabel2 = new QLabel;
manacostLabel2->setWordWrap(true); manacostLabel2->setWordWrap(true);
cardtypeLabel1 = new QLabel; cardtypeLabel1 = new QLabel;
cardtypeLabel2 = new QLabel; cardtypeLabel2 = new QLabel;
cardtypeLabel2->setWordWrap(true); cardtypeLabel2->setWordWrap(true);
powtoughLabel1 = new QLabel; powtoughLabel1 = new QLabel;
powtoughLabel2 = new QLabel; powtoughLabel2 = new QLabel;
loyaltyLabel1 = new QLabel; loyaltyLabel1 = new QLabel;
loyaltyLabel2 = new QLabel; loyaltyLabel2 = new QLabel;
textLabel = new QTextEdit(); textLabel = new QTextEdit();
textLabel->setReadOnly(true); textLabel->setReadOnly(true);
QGridLayout *grid = new QGridLayout(this); QGridLayout *grid = new QGridLayout(this);
int row = 0; int row = 0;
if (mode == ModeGameTab) if (mode == ModeGameTab)
grid->addWidget(dropList, row++, 1, 1, 1, Qt::AlignRight); grid->addWidget(dropList, row++, 1, 1, 1, Qt::AlignRight);
grid->addWidget(cardPicture, row++, 0, 1, 2); grid->addWidget(cardPicture, row++, 0, 1, 2);
grid->addWidget(nameLabel1, row, 0); grid->addWidget(nameLabel1, row, 0);
grid->addWidget(nameLabel2, row++, 1); grid->addWidget(nameLabel2, row++, 1);
grid->addWidget(manacostLabel1, row, 0); grid->addWidget(manacostLabel1, row, 0);
grid->addWidget(manacostLabel2, row++, 1); grid->addWidget(manacostLabel2, row++, 1);
grid->addWidget(cardtypeLabel1, row, 0); grid->addWidget(cardtypeLabel1, row, 0);
grid->addWidget(cardtypeLabel2, row++, 1); grid->addWidget(cardtypeLabel2, row++, 1);
grid->addWidget(powtoughLabel1, row, 0); grid->addWidget(powtoughLabel1, row, 0);
grid->addWidget(powtoughLabel2, row++, 1); grid->addWidget(powtoughLabel2, row++, 1);
grid->addWidget(loyaltyLabel1, row, 0); grid->addWidget(loyaltyLabel1, row, 0);
grid->addWidget(loyaltyLabel2, row++, 1); grid->addWidget(loyaltyLabel2, row++, 1);
grid->addWidget(textLabel, row, 0, -1, 2); grid->addWidget(textLabel, row, 0, -1, 2);
grid->setRowStretch(row, 1); grid->setRowStretch(row, 1);
grid->setColumnStretch(1, 1); grid->setColumnStretch(1, 1);
retranslateUi(); retranslateUi();
setFrameStyle(QFrame::Panel | QFrame::Raised); setFrameStyle(QFrame::Panel | QFrame::Raised);
if (mode == ModeGameTab) { if (mode == ModeGameTab) {
textLabel->setMinimumHeight(100); textLabel->setMinimumHeight(100);
setFixedWidth(sizeHint().width()); setFixedWidth(sizeHint().width());
} else if (mode == ModePopUp) { } else if (mode == ModePopUp) {
QDesktopWidget desktopWidget; QDesktopWidget desktopWidget;
pixmapWidth = desktopWidget.screenGeometry().height() / 3 / aspectRatio; pixmapWidth = desktopWidget.screenGeometry().height() / 3 / aspectRatio;
setFixedWidth(pixmapWidth + 150); setFixedWidth(pixmapWidth + 150);
} else } else
setFixedWidth(250); setFixedWidth(250);
setCard(db->getCard(cardName)); setCard(db->getCard(cardName));
setMinimized(settingsCache->getCardInfoMinimized()); setMinimized(settingsCache->getCardInfoMinimized());
} }
void CardInfoWidget::minimizeClicked(int newMinimized) void CardInfoWidget::minimizeClicked(int newMinimized)
{ {
// Set new status, and store it in the settings cache. // Set new status, and store it in the settings cache.
setMinimized(newMinimized); setMinimized(newMinimized);
settingsCache->setCardInfoMinimized(newMinimized); settingsCache->setCardInfoMinimized(newMinimized);
} }
bool CardInfoWidget::shouldShowPowTough() bool CardInfoWidget::shouldShowPowTough()
{ {
// return (!info->getPowTough().isEmpty() && (minimized != 0)); // return (!info->getPowTough().isEmpty() && (minimized != 0));
return (minimized != 0); return (minimized != 0);
} }
bool CardInfoWidget::shouldShowLoyalty() bool CardInfoWidget::shouldShowLoyalty()
{ {
// return ((info->getLoyalty() > 0) && (minimized != 0)); // return ((info->getLoyalty() > 0) && (minimized != 0));
return (minimized != 0); return (minimized != 0);
} }
void CardInfoWidget::setMinimized(int _minimized) void CardInfoWidget::setMinimized(int _minimized)
{ {
minimized = _minimized; minimized = _minimized;
// Toggle oracle fields according to selected view. // Toggle oracle fields according to selected view.
bool showAll = ((minimized == 1) || (minimized == 2)); bool showAll = ((minimized == 1) || (minimized == 2));
bool showPowTough = info ? (showAll && shouldShowPowTough()) : true; bool showPowTough = info ? (showAll && shouldShowPowTough()) : true;
bool showLoyalty = info ? (showAll && shouldShowLoyalty()) : true; bool showLoyalty = info ? (showAll && shouldShowLoyalty()) : true;
if (mode == ModeGameTab) { if (mode == ModeGameTab) {
nameLabel1->setVisible(showAll); nameLabel1->setVisible(showAll);
nameLabel2->setVisible(showAll); nameLabel2->setVisible(showAll);
manacostLabel1->setVisible(showAll); manacostLabel1->setVisible(showAll);
manacostLabel2->setVisible(showAll); manacostLabel2->setVisible(showAll);
cardtypeLabel1->setVisible(showAll); cardtypeLabel1->setVisible(showAll);
cardtypeLabel2->setVisible(showAll); cardtypeLabel2->setVisible(showAll);
powtoughLabel1->setVisible(showPowTough); powtoughLabel1->setVisible(showPowTough);
powtoughLabel2->setVisible(showPowTough); powtoughLabel2->setVisible(showPowTough);
loyaltyLabel1->setVisible(showLoyalty); loyaltyLabel1->setVisible(showLoyalty);
loyaltyLabel2->setVisible(showLoyalty); loyaltyLabel2->setVisible(showLoyalty);
textLabel->setVisible(showAll); textLabel->setVisible(showAll);
} }
cardPicture->hide(); cardPicture->hide();
cardHeightOffset = minimumSizeHint().height() + 10; cardHeightOffset = minimumSizeHint().height() + 10;
// Set the picture to be shown only at "card only" (0) and "full info" (2) // Set the picture to be shown only at "card only" (0) and "full info" (2)
if (mode == ModeGameTab) { if (mode == ModeGameTab) {
cardPicture->setVisible((minimized == 0) || (minimized == 2)); cardPicture->setVisible((minimized == 0) || (minimized == 2));
if (minimized == 0) if (minimized == 0)
setMaximumHeight(cardHeightOffset + width() * aspectRatio); setMaximumHeight(cardHeightOffset + width() * aspectRatio);
else else
setMaximumHeight(1000000); setMaximumHeight(1000000);
} else } else
cardPicture->show(); cardPicture->show();
resize(width(), sizeHint().height()); resize(width(), sizeHint().height());
} }
void CardInfoWidget::setCard(CardInfo *card) void CardInfoWidget::setCard(CardInfo *card)
{ {
if (info) if (info)
disconnect(info, 0, this, 0); disconnect(info, 0, this, 0);
info = card; info = card;
connect(info, SIGNAL(pixmapUpdated()), this, SLOT(updatePixmap())); connect(info, SIGNAL(pixmapUpdated()), this, SLOT(updatePixmap()));
connect(info, SIGNAL(destroyed()), this, SLOT(clear())); connect(info, SIGNAL(destroyed()), this, SLOT(clear()));
updatePixmap(); updatePixmap();
nameLabel2->setText(card->getName()); nameLabel2->setText(card->getName());
manacostLabel2->setText(card->getManaCost()); manacostLabel2->setText(card->getManaCost());
cardtypeLabel2->setText(card->getCardType()); cardtypeLabel2->setText(card->getCardType());
powtoughLabel2->setText(card->getPowTough()); powtoughLabel2->setText(card->getPowTough());
loyaltyLabel2->setText(card->getLoyalty() > 0 ? QString::number(card->getLoyalty()) : QString()); loyaltyLabel2->setText(card->getLoyalty() > 0 ? QString::number(card->getLoyalty()) : QString());
textLabel->setText(card->getText()); textLabel->setText(card->getText());
powtoughLabel1->setVisible(shouldShowPowTough()); powtoughLabel1->setVisible(shouldShowPowTough());
powtoughLabel2->setVisible(shouldShowPowTough()); powtoughLabel2->setVisible(shouldShowPowTough());
loyaltyLabel1->setVisible(shouldShowLoyalty()); loyaltyLabel1->setVisible(shouldShowLoyalty());
loyaltyLabel2->setVisible(shouldShowLoyalty()); loyaltyLabel2->setVisible(shouldShowLoyalty());
} }
void CardInfoWidget::setCard(const QString &cardName) void CardInfoWidget::setCard(const QString &cardName)
{ {
setCard(db->getCard(cardName)); setCard(db->getCard(cardName));
} }
void CardInfoWidget::setCard(AbstractCardItem *card) void CardInfoWidget::setCard(AbstractCardItem *card)
{ {
setCard(card->getInfo()); setCard(card->getInfo());
} }
void CardInfoWidget::clear() void CardInfoWidget::clear()
{ {
setCard(db->getCard()); setCard(db->getCard());
} }
void CardInfoWidget::updatePixmap() void CardInfoWidget::updatePixmap()
{ {
if (pixmapWidth == 0) if (pixmapWidth == 0)
return; return;
QPixmap *resizedPixmap = info->getPixmap(QSize(pixmapWidth, pixmapWidth * aspectRatio)); QPixmap *resizedPixmap = info->getPixmap(QSize(pixmapWidth, pixmapWidth * aspectRatio));
if (resizedPixmap) if (resizedPixmap)
cardPicture->setPixmap(*resizedPixmap); cardPicture->setPixmap(*resizedPixmap);
else else
cardPicture->setPixmap(*(db->getCard()->getPixmap(QSize(pixmapWidth, pixmapWidth * aspectRatio)))); cardPicture->setPixmap(*(db->getCard()->getPixmap(QSize(pixmapWidth, pixmapWidth * aspectRatio))));
} }
void CardInfoWidget::retranslateUi() void CardInfoWidget::retranslateUi()
{ {
nameLabel1->setText(tr("Name:")); nameLabel1->setText(tr("Name:"));
manacostLabel1->setText(tr("Mana cost:")); manacostLabel1->setText(tr("Mana cost:"));
cardtypeLabel1->setText(tr("Card type:")); cardtypeLabel1->setText(tr("Card type:"));
powtoughLabel1->setText(tr("P / T:")); powtoughLabel1->setText(tr("P / T:"));
loyaltyLabel1->setText(tr("Loyalty:")); loyaltyLabel1->setText(tr("Loyalty:"));
} }
void CardInfoWidget::resizeEvent(QResizeEvent * /*event*/) void CardInfoWidget::resizeEvent(QResizeEvent * /*event*/)
{ {
if (mode == ModePopUp) if (mode == ModePopUp)
return; return;
if ((minimized == 1) && (mode == ModeGameTab)) { if ((minimized == 1) && (mode == ModeGameTab)) {
pixmapWidth = 0; pixmapWidth = 0;
return; return;
} }
qreal newPixmapWidth = qMax((qreal) 100.0, qMin((qreal) cardPicture->width(), (qreal) ((height() - cardHeightOffset) / aspectRatio))); qreal newPixmapWidth = qMax((qreal) 100.0, qMin((qreal) cardPicture->width(), (qreal) ((height() - cardHeightOffset) / aspectRatio)));
if (newPixmapWidth != pixmapWidth) { if (newPixmapWidth != pixmapWidth) {
pixmapWidth = newPixmapWidth; pixmapWidth = newPixmapWidth;
updatePixmap(); updatePixmap();
} }
} }
QString CardInfoWidget::getCardName() const QString CardInfoWidget::getCardName() const
{ {
return nameLabel2->text(); return nameLabel2->text();
} }
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment