Convert rest of source to 4-space indent

cockatrice/src/cardinfowidget.h

@@ -14,51 +14,51 @@ class QResizeEvent;
 class QMouseEvent;
 
 class CardInfoWidget : public QFrame {
-	Q_OBJECT
+    Q_OBJECT
 
 public:
-	enum ResizeMode { ModeDeckEditor, ModeGameTab, ModePopUp };
+    enum ResizeMode { ModeDeckEditor, ModeGameTab, ModePopUp };
 
 private:
-	int pixmapWidth;
-	qreal cardHeightOffset;
-	qreal aspectRatio;
-	// XXX: Why isn't this an eunm?
-	int minimized; // 0 - card, 1 - oracle only, 2 - full
-	ResizeMode mode;
+    int pixmapWidth;
+    qreal cardHeightOffset;
+    qreal aspectRatio;
+    // XXX: Why isn't this an eunm?
+    int minimized; // 0 - card, 1 - oracle only, 2 - full
+    ResizeMode mode;
 
-	QComboBox *dropList;
-	QLabel *cardPicture;
-	QLabel *nameLabel1, *nameLabel2;
-	QLabel *manacostLabel1, *manacostLabel2;
-	QLabel *cardtypeLabel1, *cardtypeLabel2;
-	QLabel *powtoughLabel1, *powtoughLabel2;
-	QLabel *loyaltyLabel1, *loyaltyLabel2;
-	QTextEdit *textLabel;
+    QComboBox *dropList;
+    QLabel *cardPicture;
+    QLabel *nameLabel1, *nameLabel2;
+    QLabel *manacostLabel1, *manacostLabel2;
+    QLabel *cardtypeLabel1, *cardtypeLabel2;
+    QLabel *powtoughLabel1, *powtoughLabel2;
+    QLabel *loyaltyLabel1, *loyaltyLabel2;
+    QTextEdit *textLabel;
 
-	bool shouldShowPowTough();
-	bool shouldShowLoyalty();
+    bool shouldShowPowTough();
+    bool shouldShowLoyalty();
 
-	CardInfo *info;
-	void setMinimized(int _minimized);
+    CardInfo *info;
+    void setMinimized(int _minimized);
 
 public:
-	CardInfoWidget(ResizeMode _mode, const QString &cardName = QString(), QWidget *parent = 0, Qt::WindowFlags f = 0);
-	void retranslateUi();
-	QString getCardName() const;
+    CardInfoWidget(ResizeMode _mode, const QString &cardName = QString(), QWidget *parent = 0, Qt::WindowFlags f = 0);
+    void retranslateUi();
+    QString getCardName() const;
 
 public slots:
-	void setCard(CardInfo *card);
-	void setCard(const QString &cardName);
-	void setCard(AbstractCardItem *card);
+    void setCard(CardInfo *card);
+    void setCard(const QString &cardName);
+    void setCard(AbstractCardItem *card);
 
 private slots:
-	void clear();
-	void updatePixmap();
-	void minimizeClicked(int newMinimized);
+    void clear();
+    void updatePixmap();
+    void minimizeClicked(int newMinimized);
 
 protected:
-	void resizeEvent(QResizeEvent *event);
+    void resizeEvent(QResizeEvent *event);
 };
 
 #endif

cockatrice/src/carditem.cpp

@@ -18,374 +18,374 @@
 #include "pb/serverinfo_card.pb.h"
 
 CardItem::CardItem(Player *_owner, const QString &_name, int _cardid, bool _revealedCard, QGraphicsItem *parent)
-	: AbstractCardItem(_name, _owner, _cardid, parent), zone(0), revealedCard(_revealedCard), attacking(false), destroyOnZoneChange(false), doesntUntap(false), dragItem(0), attachedTo(0)
+    : AbstractCardItem(_name, _owner, _cardid, parent), zone(0), revealedCard(_revealedCard), attacking(false), destroyOnZoneChange(false), doesntUntap(false), dragItem(0), attachedTo(0)
 {
-	owner->addCard(this);
-	
-	cardMenu = new QMenu;
-	ptMenu = new QMenu;
-	moveMenu = new QMenu;
-	
-	retranslateUi();
-	emit updateCardMenu(this);
+    owner->addCard(this);
+    
+    cardMenu = new QMenu;
+    ptMenu = new QMenu;
+    moveMenu = new QMenu;
+    
+    retranslateUi();
+    emit updateCardMenu(this);
 }
 
 CardItem::~CardItem()
 {
-	prepareDelete();
-	
-	if (scene())
-		static_cast<GameScene *>(scene())->unregisterAnimationItem(this);
-	
-	delete cardMenu;
-	delete ptMenu;
-	delete moveMenu;
-	
-	deleteDragItem();
+    prepareDelete();
+    
+    if (scene())
+        static_cast<GameScene *>(scene())->unregisterAnimationItem(this);
+    
+    delete cardMenu;
+    delete ptMenu;
+    delete moveMenu;
+    
+    deleteDragItem();
 }
 
 void CardItem::prepareDelete()
 {
-	if (owner) {
-		if (owner->getCardMenu() == cardMenu) {
-			owner->setCardMenu(0);
-			owner->getGame()->setActiveCard(0);
-		}
-		owner = 0;
-	}
-	
-	while (!attachedCards.isEmpty()) {
-		attachedCards.first()->setZone(0); // so that it won't try to call reorganizeCards()
-		attachedCards.first()->setAttachedTo(0);
-	}
-	
-	if (attachedTo) {
-		attachedTo->removeAttachedCard(this);
-		attachedTo = 0;
-	}
+    if (owner) {
+        if (owner->getCardMenu() == cardMenu) {
+            owner->setCardMenu(0);
+            owner->getGame()->setActiveCard(0);
+        }
+        owner = 0;
+    }
+    
+    while (!attachedCards.isEmpty()) {
+        attachedCards.first()->setZone(0); // so that it won't try to call reorganizeCards()
+        attachedCards.first()->setAttachedTo(0);
+    }
+    
+    if (attachedTo) {
+        attachedTo->removeAttachedCard(this);
+        attachedTo = 0;
+    }
 }
 
 void CardItem::deleteLater()
 {
-	prepareDelete();
-	AbstractCardItem::deleteLater();
+    prepareDelete();
+    AbstractCardItem::deleteLater();
 }
 
 void CardItem::setZone(CardZone *_zone)
 {
-	zone = _zone;
-	emit updateCardMenu(this);
+    zone = _zone;
+    emit updateCardMenu(this);
 }
 
 void CardItem::retranslateUi()
 {
-	moveMenu->setTitle(tr("&Move to"));
-	ptMenu->setTitle(tr("&Power / toughness"));
+    moveMenu->setTitle(tr("&Move to"));
+    ptMenu->setTitle(tr("&Power / toughness"));
 }
 
 void CardItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
-	painter->save();
-	AbstractCardItem::paint(painter, option, widget);
-	
-	int i = 0;
-	QMapIterator<int, int> counterIterator(counters);
-	while (counterIterator.hasNext()) {
-		counterIterator.next();
-		QColor color;
-		color.setHsv(counterIterator.key() * 60, 150, 255);
-		
-		paintNumberEllipse(counterIterator.value(), 14, color, i, counters.size(), painter);
-		++i;
-	}
-	
-	QSizeF translatedSize = getTranslatedSize(painter);
-	qreal scaleFactor = translatedSize.width() / boundingRect().width();
-	
-	if (!pt.isEmpty()) {
-		painter->save();
-		
-		transformPainter(painter, translatedSize, tapAngle);
-		painter->setBackground(Qt::black);
-		painter->setBackgroundMode(Qt::OpaqueMode);
-		painter->setPen(Qt::white);
-		
-		painter->drawText(QRectF(4 * scaleFactor, 4 * scaleFactor, translatedSize.width() - 8 * scaleFactor, translatedSize.height() - 8 * scaleFactor), Qt::AlignRight | Qt::AlignBottom, pt);
-		painter->restore();
-	}
-	if (!annotation.isEmpty()) {
-		painter->save();
+    painter->save();
+    AbstractCardItem::paint(painter, option, widget);
+    
+    int i = 0;
+    QMapIterator<int, int> counterIterator(counters);
+    while (counterIterator.hasNext()) {
+        counterIterator.next();
+        QColor color;
+        color.setHsv(counterIterator.key() * 60, 150, 255);
+        
+        paintNumberEllipse(counterIterator.value(), 14, color, i, counters.size(), painter);
+        ++i;
+    }
+    
+    QSizeF translatedSize = getTranslatedSize(painter);
+    qreal scaleFactor = translatedSize.width() / boundingRect().width();
+    
+    if (!pt.isEmpty()) {
+        painter->save();
+        
+        transformPainter(painter, translatedSize, tapAngle);
+        painter->setBackground(Qt::black);
+        painter->setBackgroundMode(Qt::OpaqueMode);
+        painter->setPen(Qt::white);
+        
+        painter->drawText(QRectF(4 * scaleFactor, 4 * scaleFactor, translatedSize.width() - 8 * scaleFactor, translatedSize.height() - 8 * scaleFactor), Qt::AlignRight | Qt::AlignBottom, pt);
+        painter->restore();
+    }
+    if (!annotation.isEmpty()) {
+        painter->save();
 
-		transformPainter(painter, translatedSize, tapAngle);
-		painter->setBackground(Qt::black);
-		painter->setBackgroundMode(Qt::OpaqueMode);
-		painter->setPen(Qt::white);
-		
-		painter->drawText(QRectF(4 * scaleFactor, 4 * scaleFactor, translatedSize.width() - 8 * scaleFactor, translatedSize.height() - 8 * scaleFactor), Qt::AlignCenter | Qt::TextWrapAnywhere, annotation);
-		painter->restore();
-	}
-	if (getBeingPointedAt())
-		painter->fillRect(boundingRect(), QBrush(QColor(255, 0, 0, 100)));
-	painter->restore();
+        transformPainter(painter, translatedSize, tapAngle);
+        painter->setBackground(Qt::black);
+        painter->setBackgroundMode(Qt::OpaqueMode);
+        painter->setPen(Qt::white);
+        
+        painter->drawText(QRectF(4 * scaleFactor, 4 * scaleFactor, translatedSize.width() - 8 * scaleFactor, translatedSize.height() - 8 * scaleFactor), Qt::AlignCenter | Qt::TextWrapAnywhere, annotation);
+        painter->restore();
+    }
+    if (getBeingPointedAt())
+        painter->fillRect(boundingRect(), QBrush(QColor(255, 0, 0, 100)));
+    painter->restore();
 }
 
 void CardItem::setAttacking(bool _attacking)
 {
-	attacking = _attacking;
-	update();
+    attacking = _attacking;
+    update();
 }
 
 void CardItem::setCounter(int _id, int _value)
 {
-	if (_value)
-		counters.insert(_id, _value);
-	else
-		counters.remove(_id);
-	update();
+    if (_value)
+        counters.insert(_id, _value);
+    else
+        counters.remove(_id);
+    update();
 }
 
 void CardItem::setAnnotation(const QString &_annotation)
 {
-	annotation = _annotation;
-	update();
+    annotation = _annotation;
+    update();
 }
 
 void CardItem::setDoesntUntap(bool _doesntUntap)
 {
-	doesntUntap = _doesntUntap;
+    doesntUntap = _doesntUntap;
 }
 
 void CardItem::setPT(const QString &_pt)
 {
-	pt = _pt;
-	update();
+    pt = _pt;
+    update();
 }
 
 void CardItem::setAttachedTo(CardItem *_attachedTo)
 {
-	if (attachedTo)
-		attachedTo->removeAttachedCard(this);
-	
-	gridPoint.setX(-1);
-	attachedTo = _attachedTo;
-	if (attachedTo) {
-		setParentItem(attachedTo->getZone());
-		attachedTo->addAttachedCard(this);
-		if (zone != attachedTo->getZone())
-			attachedTo->getZone()->reorganizeCards();
-	} else
-		setParentItem(zone);
+    if (attachedTo)
+        attachedTo->removeAttachedCard(this);
+    
+    gridPoint.setX(-1);
+    attachedTo = _attachedTo;
+    if (attachedTo) {
+        setParentItem(attachedTo->getZone());
+        attachedTo->addAttachedCard(this);
+        if (zone != attachedTo->getZone())
+            attachedTo->getZone()->reorganizeCards();
+    } else
+        setParentItem(zone);
 
-	if (zone)
-		zone->reorganizeCards();
-	
-	emit updateCardMenu(this);
+    if (zone)
+        zone->reorganizeCards();
+    
+    emit updateCardMenu(this);
 }
 
 void CardItem::resetState()
 {
-	attacking = false;
-	facedown = false;
-	counters.clear();
-	pt.clear();
-	annotation.clear();
-	attachedTo = 0;
-	attachedCards.clear();
-	setTapped(false, false);
-	setDoesntUntap(false);
-	if (scene())
-		static_cast<GameScene *>(scene())->unregisterAnimationItem(this);
-	update();
+    attacking = false;
+    facedown = false;
+    counters.clear();
+    pt.clear();
+    annotation.clear();
+    attachedTo = 0;
+    attachedCards.clear();
+    setTapped(false, false);
+    setDoesntUntap(false);
+    if (scene())
+        static_cast<GameScene *>(scene())->unregisterAnimationItem(this);
+    update();
 }
 
 void CardItem::processCardInfo(const ServerInfo_Card &info)
 {
-	counters.clear();
-	const int counterListSize = info.counter_list_size();
-	for (int i = 0; i < counterListSize; ++i) {
-		const ServerInfo_CardCounter &counterInfo = info.counter_list(i);
-		counters.insert(counterInfo.id(), counterInfo.value());
-	}
-	
-	setId(info.id());
-	setName(QString::fromStdString(info.name()));
-	setAttacking(info.attacking());
-	setFaceDown(info.face_down());
-	setPT(QString::fromStdString(info.pt()));
-	setAnnotation(QString::fromStdString(info.annotation()));
-	setColor(QString::fromStdString(info.color()));
-	setTapped(info.tapped());
-	setDestroyOnZoneChange(info.destroy_on_zone_change());
-	setDoesntUntap(info.doesnt_untap());
+    counters.clear();
+    const int counterListSize = info.counter_list_size();
+    for (int i = 0; i < counterListSize; ++i) {
+        const ServerInfo_CardCounter &counterInfo = info.counter_list(i);
+        counters.insert(counterInfo.id(), counterInfo.value());
+    }
+    
+    setId(info.id());
+    setName(QString::fromStdString(info.name()));
+    setAttacking(info.attacking());
+    setFaceDown(info.face_down());
+    setPT(QString::fromStdString(info.pt()));
+    setAnnotation(QString::fromStdString(info.annotation()));
+    setColor(QString::fromStdString(info.color()));
+    setTapped(info.tapped());
+    setDestroyOnZoneChange(info.destroy_on_zone_change());
+    setDoesntUntap(info.doesnt_untap());
 }
 
 CardDragItem *CardItem::createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown)
 {
-	deleteDragItem();
-	dragItem = new CardDragItem(this, _id, _pos, faceDown);
-	dragItem->setVisible(false);
-	scene()->addItem(dragItem);
-	dragItem->updatePosition(_scenePos);
-	dragItem->setVisible(true);
+    deleteDragItem();
+    dragItem = new CardDragItem(this, _id, _pos, faceDown);
+    dragItem->setVisible(false);
+    scene()->addItem(dragItem);
+    dragItem->updatePosition(_scenePos);
+    dragItem->setVisible(true);
 
-	return dragItem;
+    return dragItem;
 }
 
 void CardItem::deleteDragItem()
 {
-	dragItem->deleteLater();
-	dragItem = NULL;
+    dragItem->deleteLater();
+    dragItem = NULL;
 }
 
 void CardItem::drawArrow(const QColor &arrowColor)
 {
-	if (static_cast<TabGame *>(owner->parent())->getSpectator())
-		return;
-	
-	Player *arrowOwner = static_cast<TabGame *>(owner->parent())->getActiveLocalPlayer();
-	ArrowDragItem *arrow = new ArrowDragItem(arrowOwner, this, arrowColor);
-	scene()->addItem(arrow);
-	arrow->grabMouse();
-	
-	QListIterator<QGraphicsItem *> itemIterator(scene()->selectedItems());
-	while (itemIterator.hasNext()) {
-		CardItem *c = qgraphicsitem_cast<CardItem *>(itemIterator.next());
-		if (!c || (c == this))
-			continue;
-		if (c->getZone() != zone)
-			continue;
-		
-		ArrowDragItem *childArrow = new ArrowDragItem(arrowOwner, c, arrowColor);
-		scene()->addItem(childArrow);
-		arrow->addChildArrow(childArrow);
-	}
+    if (static_cast<TabGame *>(owner->parent())->getSpectator())
+        return;
+    
+    Player *arrowOwner = static_cast<TabGame *>(owner->parent())->getActiveLocalPlayer();
+    ArrowDragItem *arrow = new ArrowDragItem(arrowOwner, this, arrowColor);
+    scene()->addItem(arrow);
+    arrow->grabMouse();
+    
+    QListIterator<QGraphicsItem *> itemIterator(scene()->selectedItems());
+    while (itemIterator.hasNext()) {
+        CardItem *c = qgraphicsitem_cast<CardItem *>(itemIterator.next());
+        if (!c || (c == this))
+            continue;
+        if (c->getZone() != zone)
+            continue;
+        
+        ArrowDragItem *childArrow = new ArrowDragItem(arrowOwner, c, arrowColor);
+        scene()->addItem(childArrow);
+        arrow->addChildArrow(childArrow);
+    }
 }
 
 void CardItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-	if (event->buttons().testFlag(Qt::RightButton)) {
-		if ((event->screenPos() - event->buttonDownScreenPos(Qt::RightButton)).manhattanLength() < 2 * QApplication::startDragDistance())
-			return;
-		
-		QColor arrowColor = Qt::red;
-		if (event->modifiers().testFlag(Qt::ControlModifier))
-			arrowColor = Qt::yellow;
-		else if (event->modifiers().testFlag(Qt::AltModifier))
-			arrowColor = Qt::blue;
-		else if (event->modifiers().testFlag(Qt::ShiftModifier))
-			arrowColor = Qt::green;
-		
-		drawArrow(arrowColor);
-	} else if (event->buttons().testFlag(Qt::LeftButton)) {
-		if ((event->screenPos() - event->buttonDownScreenPos(Qt::LeftButton)).manhattanLength() < 2 * QApplication::startDragDistance())
-			return;
-		if (zone->getIsView()) {
-			const ZoneViewZone *const view = static_cast<const ZoneViewZone *const>(zone);
-			if (view->getRevealZone() && !view->getWriteableRevealZone())
-				return;
-		} else if (!owner->getLocal())
-			return;
-		
-		bool forceFaceDown = event->modifiers().testFlag(Qt::ShiftModifier);
-	
-		createDragItem(id, event->pos(), event->scenePos(), facedown || forceFaceDown);
-		dragItem->grabMouse();
-		
-		QList<QGraphicsItem *> sel = scene()->selectedItems();
-		int j = 0;
-		for (int i = 0; i < sel.size(); i++) {
-			CardItem *c = (CardItem *) sel.at(i);
-			if ((c == this) || (c->getZone() != zone))
-				continue;
-			++j;
-			QPointF childPos;
-			if (zone->getHasCardAttr())
-				childPos = c->pos() - pos();
-			else
-				childPos = QPointF(j * CARD_WIDTH / 2, 0);
-			CardDragItem *drag = new CardDragItem(c, c->getId(), childPos, c->getFaceDown() || forceFaceDown, dragItem);
-			drag->setPos(dragItem->pos() + childPos);
-			scene()->addItem(drag);
-		}
-	}
-	setCursor(Qt::OpenHandCursor);
+    if (event->buttons().testFlag(Qt::RightButton)) {
+        if ((event->screenPos() - event->buttonDownScreenPos(Qt::RightButton)).manhattanLength() < 2 * QApplication::startDragDistance())
+            return;
+        
+        QColor arrowColor = Qt::red;
+        if (event->modifiers().testFlag(Qt::ControlModifier))
+            arrowColor = Qt::yellow;
+        else if (event->modifiers().testFlag(Qt::AltModifier))
+            arrowColor = Qt::blue;
+        else if (event->modifiers().testFlag(Qt::ShiftModifier))
+            arrowColor = Qt::green;
+        
+        drawArrow(arrowColor);
+    } else if (event->buttons().testFlag(Qt::LeftButton)) {
+        if ((event->screenPos() - event->buttonDownScreenPos(Qt::LeftButton)).manhattanLength() < 2 * QApplication::startDragDistance())
+            return;
+        if (zone->getIsView()) {
+            const ZoneViewZone *const view = static_cast<const ZoneViewZone *const>(zone);
+            if (view->getRevealZone() && !view->getWriteableRevealZone())
+                return;
+        } else if (!owner->getLocal())
+            return;
+        
+        bool forceFaceDown = event->modifiers().testFlag(Qt::ShiftModifier);
+    
+        createDragItem(id, event->pos(), event->scenePos(), facedown || forceFaceDown);
+        dragItem->grabMouse();
+        
+        QList<QGraphicsItem *> sel = scene()->selectedItems();
+        int j = 0;
+        for (int i = 0; i < sel.size(); i++) {
+            CardItem *c = (CardItem *) sel.at(i);
+            if ((c == this) || (c->getZone() != zone))
+                continue;
+            ++j;
+            QPointF childPos;
+            if (zone->getHasCardAttr())
+                childPos = c->pos() - pos();
+            else
+                childPos = QPointF(j * CARD_WIDTH / 2, 0);
+            CardDragItem *drag = new CardDragItem(c, c->getId(), childPos, c->getFaceDown() || forceFaceDown, dragItem);
+            drag->setPos(dragItem->pos() + childPos);
+            scene()->addItem(drag);
+        }
+    }
+    setCursor(Qt::OpenHandCursor);
 }
 
 void CardItem::playCard(bool faceDown)
 {
-	// Do nothing if the card belongs to another player
-	if (!owner->getLocal())
-		return;
+    // Do nothing if the card belongs to another player
+    if (!owner->getLocal())
+        return;
 
-	TableZone *tz = qobject_cast<TableZone *>(zone);
-	if (tz)
-		tz->toggleTapped();
-	else
-		zone->getPlayer()->playCard(this, faceDown, info->getCipt());
+    TableZone *tz = qobject_cast<TableZone *>(zone);
+    if (tz)
+        tz->toggleTapped();
+    else
+        zone->getPlayer()->playCard(this, faceDown, info->getCipt());
 }
 
 void CardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
-	if (event->button() == Qt::RightButton) {
-		if (cardMenu)
-			if (!cardMenu->isEmpty())
-				cardMenu->exec(event->screenPos());
-	} else if ((event->button() == Qt::LeftButton) && !settingsCache->getDoubleClickToPlay()) {
-		
-		bool hideCard = false;
-		if (zone->getIsView()) {
-			ZoneViewZone *view = static_cast<ZoneViewZone *>(zone);
-			if (view->getRevealZone() && !view->getWriteableRevealZone())
-				hideCard = true;
-		}
-		if (hideCard)
-			zone->removeCard(this);
-		else
-			playCard(event->modifiers().testFlag(Qt::ShiftModifier));
-	}
+    if (event->button() == Qt::RightButton) {
+        if (cardMenu)
+            if (!cardMenu->isEmpty())
+                cardMenu->exec(event->screenPos());
+    } else if ((event->button() == Qt::LeftButton) && !settingsCache->getDoubleClickToPlay()) {
+        
+        bool hideCard = false;
+        if (zone->getIsView()) {
+            ZoneViewZone *view = static_cast<ZoneViewZone *>(zone);
+            if (view->getRevealZone() && !view->getWriteableRevealZone())
+                hideCard = true;
+        }
+        if (hideCard)
+            zone->removeCard(this);
+        else
+            playCard(event->modifiers().testFlag(Qt::ShiftModifier));
+    }
 
-	setCursor(Qt::OpenHandCursor);
-	AbstractCardItem::mouseReleaseEvent(event);
+    setCursor(Qt::OpenHandCursor);
+    AbstractCardItem::mouseReleaseEvent(event);
 }
 
 void CardItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
 {
-	if (settingsCache->getDoubleClickToPlay()) {
-		if (revealedCard)
-			zone->removeCard(this);
-		else
-			playCard(event->modifiers().testFlag(Qt::ShiftModifier));
-	}
-	event->accept();
+    if (settingsCache->getDoubleClickToPlay()) {
+        if (revealedCard)
+            zone->removeCard(this);
+        else
+            playCard(event->modifiers().testFlag(Qt::ShiftModifier));
+    }
+    event->accept();
 }
 
 bool CardItem::animationEvent()
 {
-	int delta = 18;
-	if (!tapped)
-		delta *= -1;
-	
-	tapAngle += delta;
-	
-	setTransform(QTransform().translate((float) CARD_WIDTH / 2, (float) CARD_HEIGHT / 2).rotate(tapAngle).translate((float) -CARD_WIDTH / 2, (float) -CARD_HEIGHT / 2));
-	setHovered(false);
-	update();
+    int delta = 18;
+    if (!tapped)
+        delta *= -1;
+    
+    tapAngle += delta;
+    
+    setTransform(QTransform().translate((float) CARD_WIDTH / 2, (float) CARD_HEIGHT / 2).rotate(tapAngle).translate((float) -CARD_WIDTH / 2, (float) -CARD_HEIGHT / 2));
+    setHovered(false);
+    update();
 
-	if ((tapped && (tapAngle >= 90)) || (!tapped && (tapAngle <= 0)))
-		return false;
-	return true;
+    if ((tapped && (tapAngle >= 90)) || (!tapped && (tapAngle <= 0)))
+        return false;
+    return true;
 }
 
 QVariant CardItem::itemChange(GraphicsItemChange change, const QVariant &value)
 {
-	if ((change == ItemSelectedHasChanged) && owner) {
-		if (value == true) {
-			owner->setCardMenu(cardMenu);
-			owner->getGame()->setActiveCard(this);
-		} else if (owner->getCardMenu() == cardMenu) {
-			owner->setCardMenu(0);
-			owner->getGame()->setActiveCard(0);
-		}
-	}
-	return QGraphicsItem::itemChange(change, value);
+    if ((change == ItemSelectedHasChanged) && owner) {
+        if (value == true) {
+            owner->setCardMenu(cardMenu);
+            owner->getGame()->setActiveCard(this);
+        } else if (owner->getCardMenu() == cardMenu) {
+            owner->setCardMenu(0);
+            owner->getGame()->setActiveCard(0);
+        }
+    }
+    return QGraphicsItem::itemChange(change, value);
 }

cockatrice/src/carditem.h

@@ -14,75 +14,75 @@ class QColor;
 const int MAX_COUNTERS_ON_CARD = 999;
 
 class CardItem : public AbstractCardItem {
-	Q_OBJECT
+    Q_OBJECT
 private:
-	CardZone *zone;
-	bool revealedCard;
-	bool attacking;
-	QMap<int, int> counters;
-	QString annotation;
-	QString pt;
-	bool destroyOnZoneChange;
-	bool doesntUntap;
-	QPoint gridPoint;
-	CardDragItem *dragItem;
-	CardItem *attachedTo;
-	QList<CardItem *> attachedCards;
-	
-	QMenu *cardMenu, *ptMenu, *moveMenu;
+    CardZone *zone;
+    bool revealedCard;
+    bool attacking;
+    QMap<int, int> counters;
+    QString annotation;
+    QString pt;
+    bool destroyOnZoneChange;
+    bool doesntUntap;
+    QPoint gridPoint;
+    CardDragItem *dragItem;
+    CardItem *attachedTo;
+    QList<CardItem *> attachedCards;
+    
+    QMenu *cardMenu, *ptMenu, *moveMenu;
 
-	void prepareDelete();
+    void prepareDelete();
 public slots:
-	void deleteLater();
+    void deleteLater();
 public:
-	enum { Type = typeCard };
-	int type() const { return Type; }
-	CardItem(Player *_owner, const QString &_name = QString(), int _cardid = -1, bool revealedCard = false, QGraphicsItem *parent = 0);
-	~CardItem();
-	void retranslateUi();
-	CardZone *getZone() const { return zone; }
-	void setZone(CardZone *_zone);
-	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
-	QPoint getGridPoint() const { return gridPoint; }
-	void setGridPoint(const QPoint &_gridPoint) { gridPoint = _gridPoint; }
-	QPoint getGridPos() const { return gridPoint; }
-	Player *getOwner() const { return owner; }
-	void setOwner(Player *_owner) { owner = _owner; }
-	bool getRevealedCard() const { return revealedCard; }
-	bool getAttacking() const { return attacking; }
-	void setAttacking(bool _attacking);
-	const QMap<int, int> &getCounters() const { return counters; }
-	void setCounter(int _id, int _value);
-	QString getAnnotation() const { return annotation; }
-	void setAnnotation(const QString &_annotation);
-	bool getDoesntUntap() const { return doesntUntap; }
-	void setDoesntUntap(bool _doesntUntap);
-	QString getPT() const { return pt; }
-	void setPT(const QString &_pt);
-	bool getDestroyOnZoneChange() const { return destroyOnZoneChange; }
-	void setDestroyOnZoneChange(bool _destroy) { destroyOnZoneChange = _destroy; }
-	CardItem *getAttachedTo() const { return attachedTo; }
-	void setAttachedTo(CardItem *_attachedTo);
-	void addAttachedCard(CardItem *card) { attachedCards.append(card); }
-	void removeAttachedCard(CardItem *card) { attachedCards.removeAt(attachedCards.indexOf(card)); }
-	const QList<CardItem *> &getAttachedCards() const { return attachedCards; }
-	void resetState();
-	void processCardInfo(const ServerInfo_Card &info);
+    enum { Type = typeCard };
+    int type() const { return Type; }
+    CardItem(Player *_owner, const QString &_name = QString(), int _cardid = -1, bool revealedCard = false, QGraphicsItem *parent = 0);
+    ~CardItem();
+    void retranslateUi();
+    CardZone *getZone() const { return zone; }
+    void setZone(CardZone *_zone);
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+    QPoint getGridPoint() const { return gridPoint; }
+    void setGridPoint(const QPoint &_gridPoint) { gridPoint = _gridPoint; }
+    QPoint getGridPos() const { return gridPoint; }
+    Player *getOwner() const { return owner; }
+    void setOwner(Player *_owner) { owner = _owner; }
+    bool getRevealedCard() const { return revealedCard; }
+    bool getAttacking() const { return attacking; }
+    void setAttacking(bool _attacking);
+    const QMap<int, int> &getCounters() const { return counters; }
+    void setCounter(int _id, int _value);
+    QString getAnnotation() const { return annotation; }
+    void setAnnotation(const QString &_annotation);
+    bool getDoesntUntap() const { return doesntUntap; }
+    void setDoesntUntap(bool _doesntUntap);
+    QString getPT() const { return pt; }
+    void setPT(const QString &_pt);
+    bool getDestroyOnZoneChange() const { return destroyOnZoneChange; }
+    void setDestroyOnZoneChange(bool _destroy) { destroyOnZoneChange = _destroy; }
+    CardItem *getAttachedTo() const { return attachedTo; }
+    void setAttachedTo(CardItem *_attachedTo);
+    void addAttachedCard(CardItem *card) { attachedCards.append(card); }
+    void removeAttachedCard(CardItem *card) { attachedCards.removeAt(attachedCards.indexOf(card)); }
+    const QList<CardItem *> &getAttachedCards() const { return attachedCards; }
+    void resetState();
+    void processCardInfo(const ServerInfo_Card &info);
 
-	QMenu *getCardMenu() const { return cardMenu; }
-	QMenu *getPTMenu() const { return ptMenu; }
-	QMenu *getMoveMenu() const { return moveMenu; }
-	
-	bool animationEvent();
-	CardDragItem *createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown);
-	void deleteDragItem();
-	void drawArrow(const QColor &arrowColor);
-	void playCard(bool faceDown);
+    QMenu *getCardMenu() const { return cardMenu; }
+    QMenu *getPTMenu() const { return ptMenu; }
+    QMenu *getMoveMenu() const { return moveMenu; }
+    
+    bool animationEvent();
+    CardDragItem *createDragItem(int _id, const QPointF &_pos, const QPointF &_scenePos, bool faceDown);
+    void deleteDragItem();
+    void drawArrow(const QColor &arrowColor);
+    void playCard(bool faceDown);
 protected:
-	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
-	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
-	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
-	QVariant itemChange(GraphicsItemChange change, const QVariant &value);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
+    QVariant itemChange(GraphicsItemChange change, const QVariant &value);
 };
 
 #endif

cockatrice/src/cardlist.cpp

@@ -3,57 +3,57 @@
 #include "carddatabase.h"
 
 CardList::CardList(bool _contentsKnown)
-	: QList<CardItem *>(), contentsKnown(_contentsKnown)
+    : QList<CardItem *>(), contentsKnown(_contentsKnown)
 {
 }
 
 CardItem *CardList::findCard(const int id, const bool remove, int *position)
 {
-	if (!contentsKnown) {
-		if (empty())
-			return 0;
-		CardItem *temp = at(0);
-		if (remove)
-			removeAt(0);
-		if (position)
-			*position = id;
-		return temp;
-	} else
-		for (int i = 0; i < size(); i++) {
-			CardItem *temp = at(i);
-			if (temp->getId() == id) {
-				if (remove)
-					removeAt(i);
-				if (position)
-					*position = i;
-				return temp;
-			}
-		}
-	return 0;
+    if (!contentsKnown) {
+        if (empty())
+            return 0;
+        CardItem *temp = at(0);
+        if (remove)
+            removeAt(0);
+        if (position)
+            *position = id;
+        return temp;
+    } else
+        for (int i = 0; i < size(); i++) {
+            CardItem *temp = at(i);
+            if (temp->getId() == id) {
+                if (remove)
+                    removeAt(i);
+                if (position)
+                    *position = i;
+                return temp;
+            }
+        }
+    return 0;
 }
 
 class CardList::compareFunctor {
 private:
-	int flags;
+    int flags;
 public:
-	compareFunctor(int _flags) : flags(_flags)
-	{
-	}
-	inline bool operator()(CardItem *a, CardItem *b) const
-	{
-		if (flags & SortByType) {
-			QString t1 = a->getInfo()->getMainCardType();
-			QString t2 = b->getInfo()->getMainCardType();
-			if ((t1 == t2) && (flags & SortByName))
-				return a->getName() < b->getName();
-			return t1 < t2;
-		} else
-			return a->getName() < b->getName();
-	}
+    compareFunctor(int _flags) : flags(_flags)
+    {
+    }
+    inline bool operator()(CardItem *a, CardItem *b) const
+    {
+        if (flags & SortByType) {
+            QString t1 = a->getInfo()->getMainCardType();
+            QString t2 = b->getInfo()->getMainCardType();
+            if ((t1 == t2) && (flags & SortByName))
+                return a->getName() < b->getName();
+            return t1 < t2;
+        } else
+            return a->getName() < b->getName();
+    }
 };
 
 void CardList::sort(int flags)
 {
-	compareFunctor cf(flags);
-	qSort(begin(), end(), cf);
+    compareFunctor cf(flags);
+    qSort(begin(), end(), cf);
 }

cockatrice/src/cardlist.h

@@ -7,15 +7,15 @@ class CardItem;
 
 class CardList : public QList<CardItem *> {
 private:
-	class compareFunctor;
+    class compareFunctor;
 protected:
-	bool contentsKnown;
+    bool contentsKnown;
 public:
-	enum SortFlags { SortByName = 1, SortByType = 2 };
-	CardList(bool _contentsKnown);
-	CardItem *findCard(const int id, const bool remove, int *position = NULL);
-	bool getContentsKnown() const { return contentsKnown; }
-	void sort(int flags = SortByName);
+    enum SortFlags { SortByName = 1, SortByType = 2 };
+    CardList(bool _contentsKnown);
+    CardItem *findCard(const int id, const bool remove, int *position = NULL);
+    bool getContentsKnown() const { return contentsKnown; }
+    void sort(int flags = SortByName);
 };
 
 #endif

cockatrice/src/cardzone.h

@@ -14,56 +14,56 @@ class QPainter;
 class CardDragItem;
 
 class CardZone : public AbstractGraphicsItem {
-	Q_OBJECT
+    Q_OBJECT
 protected:
-	Player *player;
-	QString name;
-	CardList cards;
-	ZoneViewZone *view;
-	QMenu *menu;
-	QAction *doubleClickAction;
-	bool hasCardAttr;
-	bool isShufflable;
-	bool isView;
-	bool alwaysRevealTopCard;
-	void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
-	void mousePressEvent(QGraphicsSceneMouseEvent *event);
-	virtual void addCardImpl(CardItem *card, int x, int y) = 0;
+    Player *player;
+    QString name;
+    CardList cards;
+    ZoneViewZone *view;
+    QMenu *menu;
+    QAction *doubleClickAction;
+    bool hasCardAttr;
+    bool isShufflable;
+    bool isView;
+    bool alwaysRevealTopCard;
+    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event);
+    void mousePressEvent(QGraphicsSceneMouseEvent *event);
+    virtual void addCardImpl(CardItem *card, int x, int y) = 0;
 signals:
-	void cardCountChanged();
+    void cardCountChanged();
 public slots:
-	void moveAllToZone();
-	bool showContextMenu(const QPoint &screenPos);
+    void moveAllToZone();
+    bool showContextMenu(const QPoint &screenPos);
 public:
-	enum { Type = typeZone };
-	int type() const { return Type; }
-	virtual void handleDropEvent(const QList<CardDragItem *> &dragItem, CardZone *startZone, const QPoint &dropPoint) = 0;
-	CardZone(Player *_player, const QString &_name, bool _hasCardAttr, bool _isShufflable, bool _contentsKnown, QGraphicsItem *parent = 0, bool _isView = false);
-	~CardZone();
-	void retranslateUi();
-	void clearContents();
-	bool getHasCardAttr() const { return hasCardAttr; }
-	bool getIsShufflable() const { return isShufflable; }
-	QMenu *getMenu() const { return menu; }
-	void setMenu(QMenu *_menu, QAction *_doubleClickAction = 0) { menu = _menu; doubleClickAction = _doubleClickAction; }
-	QString getName() const { return name; }
-	QString getTranslatedName(bool hisOwn, GrammaticalCase gc) const;
-	Player *getPlayer() const { return player; }
-	bool contentsKnown() const { return cards.getContentsKnown(); }
-	const CardList &getCards() const { return cards; }
-	void addCard(CardItem *card, bool reorganize, int x, int y = -1);
-	// getCard() finds a card by id.
-	CardItem *getCard(int cardId, const QString &cardName);
-	// takeCard() finds a card by position and removes it from the zone and from all of its views.
-	virtual CardItem *takeCard(int position, int cardId, bool canResize = true);
-	void removeCard(CardItem *card);
-	ZoneViewZone *getView() const { return view; }
-	void setView(ZoneViewZone *_view) { view = _view; }
-	virtual void reorganizeCards() = 0;
-	virtual QPointF closestGridPoint(const QPointF &point);
-	bool getIsView() const { return isView; }
-	bool getAlwaysRevealTopCard() const { return alwaysRevealTopCard; }
-	void setAlwaysRevealTopCard(bool _alwaysRevealTopCard) { alwaysRevealTopCard = _alwaysRevealTopCard; }
+    enum { Type = typeZone };
+    int type() const { return Type; }
+    virtual void handleDropEvent(const QList<CardDragItem *> &dragItem, CardZone *startZone, const QPoint &dropPoint) = 0;
+    CardZone(Player *_player, const QString &_name, bool _hasCardAttr, bool _isShufflable, bool _contentsKnown, QGraphicsItem *parent = 0, bool _isView = false);
+    ~CardZone();
+    void retranslateUi();
+    void clearContents();
+    bool getHasCardAttr() const { return hasCardAttr; }
+    bool getIsShufflable() const { return isShufflable; }
+    QMenu *getMenu() const { return menu; }
+    void setMenu(QMenu *_menu, QAction *_doubleClickAction = 0) { menu = _menu; doubleClickAction = _doubleClickAction; }
+    QString getName() const { return name; }
+    QString getTranslatedName(bool hisOwn, GrammaticalCase gc) const;
+    Player *getPlayer() const { return player; }
+    bool contentsKnown() const { return cards.getContentsKnown(); }
+    const CardList &getCards() const { return cards; }
+    void addCard(CardItem *card, bool reorganize, int x, int y = -1);
+    // getCard() finds a card by id.
+    CardItem *getCard(int cardId, const QString &cardName);
+    // takeCard() finds a card by position and removes it from the zone and from all of its views.
+    virtual CardItem *takeCard(int position, int cardId, bool canResize = true);
+    void removeCard(CardItem *card);
+    ZoneViewZone *getView() const { return view; }
+    void setView(ZoneViewZone *_view) { view = _view; }
+    virtual void reorganizeCards() = 0;
+    virtual QPointF closestGridPoint(const QPointF &point);
+    bool getIsView() const { return isView; }
+    bool getAlwaysRevealTopCard() const { return alwaysRevealTopCard; }
+    void setAlwaysRevealTopCard(bool _alwaysRevealTopCard) { alwaysRevealTopCard = _alwaysRevealTopCard; }
 };
 
 #endif

cockatrice/src/chatview.cpp

@@ -10,256 +10,256 @@
 #include "pixmapgenerator.h"
 
 ChatView::ChatView(const TabSupervisor *_tabSupervisor, TabGame *_game, bool _showTimestamps, QWidget *parent)
-	: QTextBrowser(parent), tabSupervisor(_tabSupervisor), game(_game), evenNumber(true), showTimestamps(_showTimestamps), hoveredItemType(HoveredNothing)
+    : QTextBrowser(parent), tabSupervisor(_tabSupervisor), game(_game), evenNumber(true), showTimestamps(_showTimestamps), hoveredItemType(HoveredNothing)
 {
-	document()->setDefaultStyleSheet("a { text-decoration: none; color: blue; }");
-	userContextMenu = new UserContextMenu(tabSupervisor, this, game);
-	connect(userContextMenu, SIGNAL(openMessageDialog(QString, bool)), this, SIGNAL(openMessageDialog(QString, bool)));
-	
-	viewport()->setCursor(Qt::IBeamCursor);
-	setReadOnly(true);
-	setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::LinksAccessibleByMouse);
-	setOpenLinks(false);
-	connect(this, SIGNAL(anchorClicked(const QUrl &)), this, SLOT(openLink(const QUrl &)));
+    document()->setDefaultStyleSheet("a { text-decoration: none; color: blue; }");
+    userContextMenu = new UserContextMenu(tabSupervisor, this, game);
+    connect(userContextMenu, SIGNAL(openMessageDialog(QString, bool)), this, SIGNAL(openMessageDialog(QString, bool)));
+    
+    viewport()->setCursor(Qt::IBeamCursor);
+    setReadOnly(true);
+    setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::LinksAccessibleByMouse);
+    setOpenLinks(false);
+    connect(this, SIGNAL(anchorClicked(const QUrl &)), this, SLOT(openLink(const QUrl &)));
 }
 
 void ChatView::retranslateUi()
 {
-	userContextMenu->retranslateUi();
+    userContextMenu->retranslateUi();
 }
 
 QTextCursor ChatView::prepareBlock(bool same)
 {
-	lastSender.clear();
-	
-	QTextCursor cursor(document()->lastBlock());
-	cursor.movePosition(QTextCursor::End);
-	if (!same) {
-		QTextBlockFormat blockFormat;
-		if ((evenNumber = !evenNumber))
-			blockFormat.setBackground(palette().alternateBase());
-		blockFormat.setBottomMargin(2);
-		cursor.insertBlock(blockFormat);
-	} else
-		cursor.insertHtml("<br>");
-	
-	return cursor;
+    lastSender.clear();
+    
+    QTextCursor cursor(document()->lastBlock());
+    cursor.movePosition(QTextCursor::End);
+    if (!same) {
+        QTextBlockFormat blockFormat;
+        if ((evenNumber = !evenNumber))
+            blockFormat.setBackground(palette().alternateBase());
+        blockFormat.setBottomMargin(2);
+        cursor.insertBlock(blockFormat);
+    } else
+        cursor.insertHtml("<br>");
+    
+    return cursor;
 }
 
 void ChatView::appendHtml(const QString &html)
 {
-	bool atBottom = verticalScrollBar()->value() >= verticalScrollBar()->maximum();
-	prepareBlock().insertHtml(html);
-	if (atBottom)
-		verticalScrollBar()->setValue(verticalScrollBar()->maximum());
+    bool atBottom = verticalScrollBar()->value() >= verticalScrollBar()->maximum();
+    prepareBlock().insertHtml(html);
+    if (atBottom)
+        verticalScrollBar()->setValue(verticalScrollBar()->maximum());
 }
 
 void ChatView::appendCardTag(QTextCursor &cursor, const QString &cardName)
 {
-	QTextCharFormat oldFormat = cursor.charFormat();
-	QTextCharFormat anchorFormat = oldFormat;
-	anchorFormat.setForeground(Qt::blue);
-	anchorFormat.setAnchor(true);
-	anchorFormat.setAnchorHref("card://" + cardName);
-	
-	cursor.setCharFormat(anchorFormat);
-	cursor.insertText(cardName);
-	cursor.setCharFormat(oldFormat);
+    QTextCharFormat oldFormat = cursor.charFormat();
+    QTextCharFormat anchorFormat = oldFormat;
+    anchorFormat.setForeground(Qt::blue);
+    anchorFormat.setAnchor(true);
+    anchorFormat.setAnchorHref("card://" + cardName);
+    
+    cursor.setCharFormat(anchorFormat);
+    cursor.insertText(cardName);
+    cursor.setCharFormat(oldFormat);
 }
 
 void ChatView::appendUrlTag(QTextCursor &cursor, QString url)
 {
-	if (!url.contains("://"))
-		url.prepend("http://");
-	
-	QTextCharFormat oldFormat = cursor.charFormat();
-	QTextCharFormat anchorFormat = oldFormat;
-	anchorFormat.setForeground(Qt::blue);
-	anchorFormat.setAnchor(true);
-	anchorFormat.setAnchorHref(url);
-	
-	cursor.setCharFormat(anchorFormat);
-	cursor.insertText(url);
-	cursor.setCharFormat(oldFormat);
+    if (!url.contains("://"))
+        url.prepend("http://");
+    
+    QTextCharFormat oldFormat = cursor.charFormat();
+    QTextCharFormat anchorFormat = oldFormat;
+    anchorFormat.setForeground(Qt::blue);
+    anchorFormat.setAnchor(true);
+    anchorFormat.setAnchorHref(url);
+    
+    cursor.setCharFormat(anchorFormat);
+    cursor.insertText(url);
+    cursor.setCharFormat(oldFormat);
 }
 
 void ChatView::appendMessage(QString message, QString sender, UserLevelFlags userLevel, bool playerBold)
 {
-	bool atBottom = verticalScrollBar()->value() >= verticalScrollBar()->maximum();
-	bool sameSender = (sender == lastSender) && !lastSender.isEmpty();
-	QTextCursor cursor = prepareBlock(sameSender);
-	lastSender = sender;
-	
-	if (showTimestamps && !sameSender) {
-		QTextCharFormat timeFormat;
-		timeFormat.setForeground(Qt::black);
-		cursor.setCharFormat(timeFormat);
-		cursor.insertText(QDateTime::currentDateTime().toString("[hh:mm] "));
-	}
-	
-	QTextCharFormat senderFormat;
-	if (tabSupervisor && tabSupervisor->getUserInfo() && (sender == QString::fromStdString(tabSupervisor->getUserInfo()->name()))) {
-		senderFormat.setFontWeight(QFont::Bold);
-		senderFormat.setForeground(Qt::red);
-	} else {
-		senderFormat.setForeground(Qt::blue);
-		if (playerBold)
-			senderFormat.setFontWeight(QFont::Bold);
-	}
-	senderFormat.setAnchor(true);
-	senderFormat.setAnchorHref("user://" + QString::number(userLevel) + "_" + sender);
-	if (!sameSender) {
-		if (!sender.isEmpty()) {
-			const int pixelSize = QFontInfo(cursor.charFormat().font()).pixelSize();
-			cursor.insertImage(UserLevelPixmapGenerator::generatePixmap(pixelSize, userLevel).toImage(), QString::number(pixelSize) + "_" + QString::number((int) userLevel));
-			cursor.insertText(" ");
-		}
-		cursor.setCharFormat(senderFormat);
-		if (!sender.isEmpty())
-			sender.append(": ");
-		cursor.insertText(sender);
-	} else
-		cursor.insertText("    ");
-	
-	QTextCharFormat messageFormat;
-	if (sender.isEmpty())
-		messageFormat.setForeground(Qt::darkGreen);
-	cursor.setCharFormat(messageFormat);
-	
-	int from = 0, index = 0;
-	while ((index = message.indexOf('[', from)) != -1) {
-		cursor.insertText(message.left(index));
-		message = message.mid(index);
-		if (message.isEmpty())
-			break;
+    bool atBottom = verticalScrollBar()->value() >= verticalScrollBar()->maximum();
+    bool sameSender = (sender == lastSender) && !lastSender.isEmpty();
+    QTextCursor cursor = prepareBlock(sameSender);
+    lastSender = sender;
+    
+    if (showTimestamps && !sameSender) {
+        QTextCharFormat timeFormat;
+        timeFormat.setForeground(Qt::black);
+        cursor.setCharFormat(timeFormat);
+        cursor.insertText(QDateTime::currentDateTime().toString("[hh:mm] "));
+    }
+    
+    QTextCharFormat senderFormat;
+    if (tabSupervisor && tabSupervisor->getUserInfo() && (sender == QString::fromStdString(tabSupervisor->getUserInfo()->name()))) {
+        senderFormat.setFontWeight(QFont::Bold);
+        senderFormat.setForeground(Qt::red);
+    } else {
+        senderFormat.setForeground(Qt::blue);
+        if (playerBold)
+            senderFormat.setFontWeight(QFont::Bold);
+    }
+    senderFormat.setAnchor(true);
+    senderFormat.setAnchorHref("user://" + QString::number(userLevel) + "_" + sender);
+    if (!sameSender) {
+        if (!sender.isEmpty()) {
+            const int pixelSize = QFontInfo(cursor.charFormat().font()).pixelSize();
+            cursor.insertImage(UserLevelPixmapGenerator::generatePixmap(pixelSize, userLevel).toImage(), QString::number(pixelSize) + "_" + QString::number((int) userLevel));
+            cursor.insertText(" ");
+        }
+        cursor.setCharFormat(senderFormat);
+        if (!sender.isEmpty())
+            sender.append(": ");
+        cursor.insertText(sender);
+    } else
+        cursor.insertText("    ");
+    
+    QTextCharFormat messageFormat;
+    if (sender.isEmpty())
+        messageFormat.setForeground(Qt::darkGreen);
+    cursor.setCharFormat(messageFormat);
+    
+    int from = 0, index = 0;
+    while ((index = message.indexOf('[', from)) != -1) {
+        cursor.insertText(message.left(index));
+        message = message.mid(index);
+        if (message.isEmpty())
+            break;
 
-		if (message.startsWith("[card]")) {
-			message = message.mid(6);
-			int closeTagIndex = message.indexOf("[/card]");
-			QString cardName = message.left(closeTagIndex);
-			if (closeTagIndex == -1)
-				message.clear();
-			else
-				message = message.mid(closeTagIndex + 7);
-			
-			appendCardTag(cursor, cardName);
-		} else if (message.startsWith("[[")) {
-			message = message.mid(2);
-			int closeTagIndex = message.indexOf("]]");
-			QString cardName = message.left(closeTagIndex);
-			if (closeTagIndex == -1)
-				message.clear();
-			else
-				message = message.mid(closeTagIndex + 2);
-			
-			appendCardTag(cursor, cardName);
-		} else if (message.startsWith("[url]")) {
-			message = message.mid(5);
-			int closeTagIndex = message.indexOf("[/url]");
-			QString url = message.left(closeTagIndex);
-			if (closeTagIndex == -1)
-				message.clear();
-			else
-				message = message.mid(closeTagIndex + 6);
-			
-			appendUrlTag(cursor, url);
-		} else
-			from = 1;
-	}
-	if (!message.isEmpty())
-		cursor.insertText(message);
-	
-	if (atBottom)
-		verticalScrollBar()->setValue(verticalScrollBar()->maximum());
+        if (message.startsWith("[card]")) {
+            message = message.mid(6);
+            int closeTagIndex = message.indexOf("[/card]");
+            QString cardName = message.left(closeTagIndex);
+            if (closeTagIndex == -1)
+                message.clear();
+            else
+                message = message.mid(closeTagIndex + 7);
+            
+            appendCardTag(cursor, cardName);
+        } else if (message.startsWith("[[")) {
+            message = message.mid(2);
+            int closeTagIndex = message.indexOf("]]");
+            QString cardName = message.left(closeTagIndex);
+            if (closeTagIndex == -1)
+                message.clear();
+            else
+                message = message.mid(closeTagIndex + 2);
+            
+            appendCardTag(cursor, cardName);
+        } else if (message.startsWith("[url]")) {
+            message = message.mid(5);
+            int closeTagIndex = message.indexOf("[/url]");
+            QString url = message.left(closeTagIndex);
+            if (closeTagIndex == -1)
+                message.clear();
+            else
+                message = message.mid(closeTagIndex + 6);
+            
+            appendUrlTag(cursor, url);
+        } else
+            from = 1;
+    }
+    if (!message.isEmpty())
+        cursor.insertText(message);
+    
+    if (atBottom)
+        verticalScrollBar()->setValue(verticalScrollBar()->maximum());
 }
 
 void ChatView::enterEvent(QEvent * /*event*/)
 {
-	setMouseTracking(true);
+    setMouseTracking(true);
 }
 
 void ChatView::leaveEvent(QEvent * /*event*/)
 {
-	setMouseTracking(false);
+    setMouseTracking(false);
 }
 
 QTextFragment ChatView::getFragmentUnderMouse(const QPoint &pos) const
 {
-	QTextCursor cursor(cursorForPosition(pos));
-	QTextBlock block(cursor.block());
-	QTextBlock::iterator it;
-	for (it = block.begin(); !(it.atEnd()); ++it) {
-		QTextFragment frag = it.fragment();
-		if (frag.contains(cursor.position()))
-			return frag;
-	}
-	return QTextFragment();
+    QTextCursor cursor(cursorForPosition(pos));
+    QTextBlock block(cursor.block());
+    QTextBlock::iterator it;
+    for (it = block.begin(); !(it.atEnd()); ++it) {
+        QTextFragment frag = it.fragment();
+        if (frag.contains(cursor.position()))
+            return frag;
+    }
+    return QTextFragment();
 }
 
 void ChatView::mouseMoveEvent(QMouseEvent *event)
 {
-	QString anchorHref = getFragmentUnderMouse(event->pos()).charFormat().anchorHref();
-	if (!anchorHref.isEmpty()) {
-		const int delimiterIndex = anchorHref.indexOf("://");
-		if (delimiterIndex != -1) {
-			const QString scheme = anchorHref.left(delimiterIndex);
-			hoveredContent = anchorHref.mid(delimiterIndex + 3);
-			if (scheme == "card") {
-				hoveredItemType = HoveredCard;
-				emit cardNameHovered(hoveredContent);
-			} else if (scheme == "user")
-				hoveredItemType = HoveredUser;
-			else
-				hoveredItemType = HoveredUrl;
-			viewport()->setCursor(Qt::PointingHandCursor);
-		} else {
-			hoveredItemType = HoveredNothing;
-			viewport()->setCursor(Qt::IBeamCursor);
-		}
-	} else {
-		hoveredItemType = HoveredNothing;
-		viewport()->setCursor(Qt::IBeamCursor);
-	}
-	
-	QTextBrowser::mouseMoveEvent(event);
+    QString anchorHref = getFragmentUnderMouse(event->pos()).charFormat().anchorHref();
+    if (!anchorHref.isEmpty()) {
+        const int delimiterIndex = anchorHref.indexOf("://");
+        if (delimiterIndex != -1) {
+            const QString scheme = anchorHref.left(delimiterIndex);
+            hoveredContent = anchorHref.mid(delimiterIndex + 3);
+            if (scheme == "card") {
+                hoveredItemType = HoveredCard;
+                emit cardNameHovered(hoveredContent);
+            } else if (scheme == "user")
+                hoveredItemType = HoveredUser;
+            else
+                hoveredItemType = HoveredUrl;
+            viewport()->setCursor(Qt::PointingHandCursor);
+        } else {
+            hoveredItemType = HoveredNothing;
+            viewport()->setCursor(Qt::IBeamCursor);
+        }
+    } else {
+        hoveredItemType = HoveredNothing;
+        viewport()->setCursor(Qt::IBeamCursor);
+    }
+    
+    QTextBrowser::mouseMoveEvent(event);
 }
 
 void ChatView::mousePressEvent(QMouseEvent *event)
 {
-	switch (hoveredItemType) {
-		case HoveredCard: {
-			if ((event->button() == Qt::MidButton) || (event->button() == Qt::LeftButton))
-				emit showCardInfoPopup(event->globalPos(), hoveredContent);
-			break;
-		}
-		case HoveredUser: {
-			if (event->button() == Qt::RightButton) {
-				const int delimiterIndex = hoveredContent.indexOf("_");
-				UserLevelFlags userLevel(hoveredContent.left(delimiterIndex).toInt());
-				const QString userName = hoveredContent.mid(delimiterIndex + 1);
-				
-				userContextMenu->showContextMenu(event->globalPos(), userName, userLevel);
-			}
-			break;
-		}
-		default: {
-			QTextBrowser::mousePressEvent(event);
-		}
-	}
+    switch (hoveredItemType) {
+        case HoveredCard: {
+            if ((event->button() == Qt::MidButton) || (event->button() == Qt::LeftButton))
+                emit showCardInfoPopup(event->globalPos(), hoveredContent);
+            break;
+        }
+        case HoveredUser: {
+            if (event->button() == Qt::RightButton) {
+                const int delimiterIndex = hoveredContent.indexOf("_");
+                UserLevelFlags userLevel(hoveredContent.left(delimiterIndex).toInt());
+                const QString userName = hoveredContent.mid(delimiterIndex + 1);
+                
+                userContextMenu->showContextMenu(event->globalPos(), userName, userLevel);
+            }
+            break;
+        }
+        default: {
+            QTextBrowser::mousePressEvent(event);
+        }
+    }
 }
 
 void ChatView::mouseReleaseEvent(QMouseEvent *event)
 {
-	if ((event->button() == Qt::MidButton) || (event->button() == Qt::LeftButton))
-		emit deleteCardInfoPopup(QString("_"));
-	
-	QTextBrowser::mouseReleaseEvent(event);
+    if ((event->button() == Qt::MidButton) || (event->button() == Qt::LeftButton))
+        emit deleteCardInfoPopup(QString("_"));
+    
+    QTextBrowser::mouseReleaseEvent(event);
 }
 
 void ChatView::openLink(const QUrl &link)
 {
-	if ((link.scheme() == "card") || (link.scheme() == "user"))
-		return;
-	
-	QDesktopServices::openUrl(link);
+    if ((link.scheme() == "card") || (link.scheme() == "user"))
+        return;
+    
+    QDesktopServices::openUrl(link);
 }

cockatrice/src/chatview.h

@@ -14,40 +14,40 @@ class TabSupervisor;
 class TabGame;
 
 class ChatView : public QTextBrowser {
-	Q_OBJECT
+    Q_OBJECT
 protected:
-	const TabSupervisor * const tabSupervisor;
-	TabGame * const game;
+    const TabSupervisor * const tabSupervisor;
+    TabGame * const game;
 private:
-	enum HoveredItemType { HoveredNothing, HoveredUrl, HoveredCard, HoveredUser };
-	UserContextMenu *userContextMenu;
-	QString lastSender;
-	bool evenNumber;
-	bool showTimestamps;
-	HoveredItemType hoveredItemType;
-	QString hoveredContent;
-	QTextFragment getFragmentUnderMouse(const QPoint &pos) const;
-	QTextCursor prepareBlock(bool same = false);
-	void appendCardTag(QTextCursor &cursor, const QString &cardName);
-	void appendUrlTag(QTextCursor &cursor, QString url);
+    enum HoveredItemType { HoveredNothing, HoveredUrl, HoveredCard, HoveredUser };
+    UserContextMenu *userContextMenu;
+    QString lastSender;
+    bool evenNumber;
+    bool showTimestamps;
+    HoveredItemType hoveredItemType;
+    QString hoveredContent;
+    QTextFragment getFragmentUnderMouse(const QPoint &pos) const;
+    QTextCursor prepareBlock(bool same = false);
+    void appendCardTag(QTextCursor &cursor, const QString &cardName);
+    void appendUrlTag(QTextCursor &cursor, QString url);
 private slots:
-	void openLink(const QUrl &link);
+    void openLink(const QUrl &link);
 public:
-	ChatView(const TabSupervisor *_tabSupervisor, TabGame *_game, bool _showTimestamps, QWidget *parent = 0);
-	void retranslateUi();
-	void appendHtml(const QString &html);
-	void appendMessage(QString message, QString sender = QString(), UserLevelFlags userLevel = UserLevelFlags(), bool playerBold = false);
+    ChatView(const TabSupervisor *_tabSupervisor, TabGame *_game, bool _showTimestamps, QWidget *parent = 0);
+    void retranslateUi();
+    void appendHtml(const QString &html);
+    void appendMessage(QString message, QString sender = QString(), UserLevelFlags userLevel = UserLevelFlags(), bool playerBold = false);
 protected:
-	void enterEvent(QEvent *event);
-	void leaveEvent(QEvent *event);
-	void mouseMoveEvent(QMouseEvent *event);
-	void mousePressEvent(QMouseEvent *event);
-	void mouseReleaseEvent(QMouseEvent *event);
+    void enterEvent(QEvent *event);
+    void leaveEvent(QEvent *event);
+    void mouseMoveEvent(QMouseEvent *event);
+    void mousePressEvent(QMouseEvent *event);
+    void mouseReleaseEvent(QMouseEvent *event);
 signals:
-	void openMessageDialog(const QString &userName, bool focus);
-	void cardNameHovered(QString cardName);
-	void showCardInfoPopup(QPoint pos, QString cardName);
-	void deleteCardInfoPopup(QString cardName);
+    void openMessageDialog(const QString &userName, bool focus);
+    void cardNameHovered(QString cardName);
+    void showCardInfoPopup(QPoint pos, QString cardName);
+    void deleteCardInfoPopup(QString cardName);
 };
 
 #endif

cockatrice/src/counter_general.cpp

@@ -3,34 +3,34 @@
 #include <QPainter>
 
 GeneralCounter::GeneralCounter(Player *_player, int _id, const QString &_name, const QColor &_color, int _radius, int _value, QGraphicsItem *parent)
-	: AbstractCounter(_player, _id, _name, true, _value, parent), color(_color), radius(_radius)
+    : AbstractCounter(_player, _id, _name, true, _value, parent), color(_color), radius(_radius)
 {
-	setCacheMode(DeviceCoordinateCache);
+    setCacheMode(DeviceCoordinateCache);
 }
 
 QRectF GeneralCounter::boundingRect() const
 {
-	return QRectF(0, 0, radius * 2, radius * 2);
+    return QRectF(0, 0, radius * 2, radius * 2);
 }
 
 void GeneralCounter::paint(QPainter *painter, const QStyleOptionGraphicsItem */*option*/, QWidget */*widget*/)
 {
-	QRectF mapRect = painter->combinedTransform().mapRect(boundingRect());
-	int translatedHeight = mapRect.size().height();
-	qreal scaleFactor = translatedHeight / boundingRect().height();
-	QPixmap pixmap = CounterPixmapGenerator::generatePixmap(translatedHeight, name, hovered);
-	
-	painter->save();
-	painter->resetTransform();
-	painter->drawPixmap(QPoint(0, 0), pixmap);
+    QRectF mapRect = painter->combinedTransform().mapRect(boundingRect());
+    int translatedHeight = mapRect.size().height();
+    qreal scaleFactor = translatedHeight / boundingRect().height();
+    QPixmap pixmap = CounterPixmapGenerator::generatePixmap(translatedHeight, name, hovered);
+    
+    painter->save();
+    painter->resetTransform();
+    painter->drawPixmap(QPoint(0, 0), pixmap);
 
-	if (value) {
-		QFont f("Serif");
-		f.setPixelSize(qMax((int) (radius * scaleFactor), 10));
-		f.setWeight(QFont::Bold);
-		painter->setPen(Qt::black);
-		painter->setFont(f);
-		painter->drawText(mapRect, Qt::AlignCenter, QString::number(value));
-	}
-	painter->restore();
+    if (value) {
+        QFont f("Serif");
+        f.setPixelSize(qMax((int) (radius * scaleFactor), 10));
+        f.setWeight(QFont::Bold);
+        painter->setPen(Qt::black);
+        painter->setFont(f);
+        painter->drawText(mapRect, Qt::AlignCenter, QString::number(value));
+    }
+    painter->restore();
 }

cockatrice/src/counter_general.h

@@ -4,14 +4,14 @@
 #include "abstractcounter.h"
 
 class GeneralCounter : public AbstractCounter {
-	Q_OBJECT
+    Q_OBJECT
 private:
-	QColor color;
-	int radius;
+    QColor color;
+    int radius;
 public:
-	GeneralCounter(Player *_player, int _id, const QString &_name, const QColor &_color, int _radius, int _value, QGraphicsItem *parent = 0);
-	QRectF boundingRect() const;
-	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+    GeneralCounter(Player *_player, int _id, const QString &_name, const QColor &_color, int _radius, int _value, QGraphicsItem *parent = 0);
+    QRectF boundingRect() const;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
 };
 
 #endif

cockatrice/src/deck_loader.cpp

@@ -4,96 +4,96 @@
 #include "decklist.h"
 
 const QStringList DeckLoader::fileNameFilters = QStringList()
-	<< QObject::tr("Common deck formats (*.cod *.dec *.mwDeck)")
-	<< QObject::tr("All files (*.*)");
+    << QObject::tr("Common deck formats (*.cod *.dec *.mwDeck)")
+    << QObject::tr("All files (*.*)");
 
 DeckLoader::DeckLoader()
-	: DeckList(),
-	  lastFileName(QString()),
-	  lastFileFormat(CockatriceFormat),
-	  lastRemoteDeckId(-1)
+    : DeckList(),
+      lastFileName(QString()),
+      lastFileFormat(CockatriceFormat),
+      lastRemoteDeckId(-1)
 {
 }
 
 DeckLoader::DeckLoader(const QString &nativeString)
-	: DeckList(nativeString),
-	  lastFileName(QString()),
-	  lastFileFormat(CockatriceFormat),
-	  lastRemoteDeckId(-1)
+    : DeckList(nativeString),
+      lastFileName(QString()),
+      lastFileFormat(CockatriceFormat),
+      lastRemoteDeckId(-1)
 {
 }
 
 DeckLoader::DeckLoader(const DeckList &other)
-	: DeckList(other),
-	  lastFileName(QString()),
-	  lastFileFormat(CockatriceFormat),
-	  lastRemoteDeckId(-1)
+    : DeckList(other),
+      lastFileName(QString()),
+      lastFileFormat(CockatriceFormat),
+      lastRemoteDeckId(-1)
 {
 }
 
 DeckLoader::DeckLoader(const DeckLoader &other)
-	: DeckList(other),
-	  lastFileName(other.lastFileName),
-	  lastFileFormat(other.lastFileFormat),
-	  lastRemoteDeckId(other.lastRemoteDeckId)
+    : DeckList(other),
+      lastFileName(other.lastFileName),
+      lastFileFormat(other.lastFileFormat),
+      lastRemoteDeckId(other.lastRemoteDeckId)
 {
 }
 
 bool DeckLoader::loadFromFile(const QString &fileName, FileFormat fmt)
 {
-	QFile file(fileName);
-	if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
-		return false;
-	
-	bool result = false;
-	switch (fmt) {
-		case PlainTextFormat: result = loadFromFile_Plain(&file); break;
-		case CockatriceFormat: result = loadFromFile_Native(&file); break;
-	}
-	if (result) {
-		lastFileName = fileName;
-		lastFileFormat = fmt;
-		
-		emit deckLoaded();
-	}
-	return result;
+    QFile file(fileName);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
+        return false;
+    
+    bool result = false;
+    switch (fmt) {
+        case PlainTextFormat: result = loadFromFile_Plain(&file); break;
+        case CockatriceFormat: result = loadFromFile_Native(&file); break;
+    }
+    if (result) {
+        lastFileName = fileName;
+        lastFileFormat = fmt;
+        
+        emit deckLoaded();
+    }
+    return result;
 }
 
 bool DeckLoader::loadFromRemote(const QString &nativeString, int remoteDeckId)
 {
-	bool result = loadFromString_Native(nativeString);
-	if (result) {
-		lastFileName = QString();
-		lastFileFormat = CockatriceFormat;
-		lastRemoteDeckId = remoteDeckId;
-		
-		emit deckLoaded();
-	}
-	return result;
+    bool result = loadFromString_Native(nativeString);
+    if (result) {
+        lastFileName = QString();
+        lastFileFormat = CockatriceFormat;
+        lastRemoteDeckId = remoteDeckId;
+        
+        emit deckLoaded();
+    }
+    return result;
 }
 
 bool DeckLoader::saveToFile(const QString &fileName, FileFormat fmt)
 {
-	QFile file(fileName);
-	if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
-		return false;
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
+        return false;
 
-	bool result = false;
-	switch (fmt) {
-		case PlainTextFormat: result = saveToFile_Plain(&file); break;
-		case CockatriceFormat: result = saveToFile_Native(&file); break;
-	}
-	if (result) {
-		lastFileName = fileName;
-		lastFileFormat = fmt;
-	}
-	return result;
+    bool result = false;
+    switch (fmt) {
+        case PlainTextFormat: result = saveToFile_Plain(&file); break;
+        case CockatriceFormat: result = saveToFile_Native(&file); break;
+    }
+    if (result) {
+        lastFileName = fileName;
+        lastFileFormat = fmt;
+    }
+    return result;
 }
 
 DeckLoader::FileFormat DeckLoader::getFormatFromName(const QString &fileName)
 {
-	if (fileName.endsWith(".cod", Qt::CaseInsensitive)) {
-		return CockatriceFormat;
-	}
-	return PlainTextFormat;
+    if (fileName.endsWith(".cod", Qt::CaseInsensitive)) {
+        return CockatriceFormat;
+    }
+    return PlainTextFormat;
 }

cockatrice/src/deck_loader.h

@@ -4,30 +4,30 @@
 #include "decklist.h"
 
 class DeckLoader : public DeckList {
-	Q_OBJECT
+    Q_OBJECT
 signals:
-	void deckLoaded();
+    void deckLoaded();
 public:
-	enum FileFormat { PlainTextFormat, CockatriceFormat };
-	static const QStringList fileNameFilters;
+    enum FileFormat { PlainTextFormat, CockatriceFormat };
+    static const QStringList fileNameFilters;
 private:
-	QString lastFileName;
-	FileFormat lastFileFormat;
-	int lastRemoteDeckId;
+    QString lastFileName;
+    FileFormat lastFileFormat;
+    int lastRemoteDeckId;
 public:
-	DeckLoader();
-	DeckLoader(const QString &nativeString);
-	DeckLoader(const DeckList &other);
-	DeckLoader(const DeckLoader &other);
-	const QString &getLastFileName() const { return lastFileName; }
-	FileFormat getLastFileFormat() const { return lastFileFormat; }
-	int getLastRemoteDeckId() const { return lastRemoteDeckId; }
-	
-	static FileFormat getFormatFromName(const QString &fileName);
-	
-	bool loadFromFile(const QString &fileName, FileFormat fmt);
-	bool loadFromRemote(const QString &nativeString, int remoteDeckId);
-	bool saveToFile(const QString &fileName, FileFormat fmt);
+    DeckLoader();
+    DeckLoader(const QString &nativeString);
+    DeckLoader(const DeckList &other);
+    DeckLoader(const DeckLoader &other);
+    const QString &getLastFileName() const { return lastFileName; }
+    FileFormat getLastFileFormat() const { return lastFileFormat; }
+    int getLastRemoteDeckId() const { return lastRemoteDeckId; }
+    
+    static FileFormat getFormatFromName(const QString &fileName);
+    
+    bool loadFromFile(const QString &fileName, FileFormat fmt);
+    bool loadFromRemote(const QString &nativeString, int remoteDeckId);
+    bool saveToFile(const QString &fileName, FileFormat fmt);
 };
 
 #endif

cockatrice/src/decklistmodel.cpp

@@ -14,423 +14,423 @@
 #include "deck_loader.h"
 
 DeckListModel::DeckListModel(QObject *parent)
-	: QAbstractItemModel(parent)
+    : QAbstractItemModel(parent)
 {
-	deckList = new DeckLoader;
-	connect(deckList, SIGNAL(deckLoaded()), this, SLOT(rebuildTree()));
-	connect(deckList, SIGNAL(deckHashChanged()), this, SIGNAL(deckHashChanged()));
-	root = new InnerDecklistNode;
+    deckList = new DeckLoader;
+    connect(deckList, SIGNAL(deckLoaded()), this, SLOT(rebuildTree()));
+    connect(deckList, SIGNAL(deckHashChanged()), this, SIGNAL(deckHashChanged()));
+    root = new InnerDecklistNode;
 }
 
 DeckListModel::~DeckListModel()
 {
-	delete root;
-	delete deckList;
+    delete root;
+    delete deckList;
 }
 
 void DeckListModel::rebuildTree()
 {
-	root->clearTree();
-	InnerDecklistNode *listRoot = deckList->getRoot();
-	for (int i = 0; i < listRoot->size(); i++) {
-		InnerDecklistNode *currentZone = dynamic_cast<InnerDecklistNode *>(listRoot->at(i));
-		InnerDecklistNode *node = new InnerDecklistNode(currentZone->getName(), root);
-		for (int j = 0; j < currentZone->size(); j++) {
-			DecklistCardNode *currentCard = dynamic_cast<DecklistCardNode *>(currentZone->at(j));
-			// XXX better sanity checking
-			if (!currentCard)
-				continue;
-
-			CardInfo *info = db->getCard(currentCard->getName());
-			QString cardType;
-			if (!info)
-				cardType = "unknown";
-			else
-				cardType = info->getMainCardType();
-			InnerDecklistNode *cardTypeNode = dynamic_cast<InnerDecklistNode *>(node->findChild(cardType));
-			if (!cardTypeNode)
-				cardTypeNode = new InnerDecklistNode(cardType, node);
-
-			new DecklistModelCardNode(currentCard, cardTypeNode);
-		}
-	}
-
-	reset();
+    root->clearTree();
+    InnerDecklistNode *listRoot = deckList->getRoot();
+    for (int i = 0; i < listRoot->size(); i++) {
+        InnerDecklistNode *currentZone = dynamic_cast<InnerDecklistNode *>(listRoot->at(i));
+        InnerDecklistNode *node = new InnerDecklistNode(currentZone->getName(), root);
+        for (int j = 0; j < currentZone->size(); j++) {
+            DecklistCardNode *currentCard = dynamic_cast<DecklistCardNode *>(currentZone->at(j));
+            // XXX better sanity checking
+            if (!currentCard)
+                continue;
+
+            CardInfo *info = db->getCard(currentCard->getName());
+            QString cardType;
+            if (!info)
+                cardType = "unknown";
+            else
+                cardType = info->getMainCardType();
+            InnerDecklistNode *cardTypeNode = dynamic_cast<InnerDecklistNode *>(node->findChild(cardType));
+            if (!cardTypeNode)
+                cardTypeNode = new InnerDecklistNode(cardType, node);
+
+            new DecklistModelCardNode(currentCard, cardTypeNode);
+        }
+    }
+
+    reset();
 }
 
 int DeckListModel::rowCount(const QModelIndex &parent) const
 {
-//	debugIndexInfo("rowCount", parent);
-	InnerDecklistNode *node = getNode<InnerDecklistNode *>(parent);
-	if (node)
-		return node->size();
-	else
-		return 0;
+//    debugIndexInfo("rowCount", parent);
+    InnerDecklistNode *node = getNode<InnerDecklistNode *>(parent);
+    if (node)
+        return node->size();
+    else
+        return 0;
 }
 
 int DeckListModel::columnCount(const QModelIndex &/*parent*/) const
 {
-	if (settingsCache->getPriceTagFeature())
-		return 3;
-	else
-		return 2;
+    if (settingsCache->getPriceTagFeature())
+        return 3;
+    else
+        return 2;
 }
 
 QVariant DeckListModel::data(const QModelIndex &index, int role) const
 {
-//	debugIndexInfo("data", index);
-	if (!index.isValid())
-		return QVariant();
+//    debugIndexInfo("data", index);
+    if (!index.isValid())
+        return QVariant();
         if (index.column() >= columnCount())
-		return QVariant();
-
-	AbstractDecklistNode *temp = static_cast<AbstractDecklistNode *>(index.internalPointer());
-	DecklistModelCardNode *card = dynamic_cast<DecklistModelCardNode *>(temp);
-	if (!card) {
-		InnerDecklistNode *node = dynamic_cast<InnerDecklistNode *>(temp);
-		switch (role) {
-			case Qt::FontRole: {
-				QFont f;
-				f.setBold(true);
-				return f;
-			}
-			case Qt::DisplayRole:
-			case Qt::EditRole:
-				switch (index.column()) {
+        return QVariant();
+
+    AbstractDecklistNode *temp = static_cast<AbstractDecklistNode *>(index.internalPointer());
+    DecklistModelCardNode *card = dynamic_cast<DecklistModelCardNode *>(temp);
+    if (!card) {
+        InnerDecklistNode *node = dynamic_cast<InnerDecklistNode *>(temp);
+        switch (role) {
+            case Qt::FontRole: {
+                QFont f;
+                f.setBold(true);
+                return f;
+            }
+            case Qt::DisplayRole:
+            case Qt::EditRole:
+                switch (index.column()) {
                                         case 0: return node->recursiveCount(true);
                                         case 1: return node->getVisibleName();
                                         case 2: return QString().sprintf("$%.2f", node->recursivePrice(true));
-					default: return QVariant();
-				}
-			case Qt::BackgroundRole: {
-				int color = 90 + 60 * node->depth();
-				return QBrush(QColor(color, 255, color));
-			}
-			default: return QVariant();
-		}
-	} else {
-		switch (role) {
-			case Qt::DisplayRole:
-			case Qt::EditRole: {
-				switch (index.column()) {
+                    default: return QVariant();
+                }
+            case Qt::BackgroundRole: {
+                int color = 90 + 60 * node->depth();
+                return QBrush(QColor(color, 255, color));
+            }
+            default: return QVariant();
+        }
+    } else {
+        switch (role) {
+            case Qt::DisplayRole:
+            case Qt::EditRole: {
+                switch (index.column()) {
                                         case 0: return card->getNumber();
                                         case 1: return card->getName();
                                         case 2: return QString().sprintf("$%.2f", card->getTotalPrice());
-					default: return QVariant();
-				}
-			}
-			case Qt::BackgroundRole: {
-				int color = 255 - (index.row() % 2) * 30;
-				return QBrush(QColor(color, color, color));
-			}
-			default: return QVariant();
-		}
-	}
+                    default: return QVariant();
+                }
+            }
+            case Qt::BackgroundRole: {
+                int color = 255 - (index.row() % 2) * 30;
+                return QBrush(QColor(color, color, color));
+            }
+            default: return QVariant();
+        }
+    }
 }
 
 QVariant DeckListModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
-	if ((role != Qt::DisplayRole) || (orientation != Qt::Horizontal))
-		return QVariant();
+    if ((role != Qt::DisplayRole) || (orientation != Qt::Horizontal))
+        return QVariant();
         if (section >= columnCount())
-		return QVariant();
-	switch (section) {
+        return QVariant();
+    switch (section) {
                 case 0: return tr("Number");
                 case 1: return tr("Card");
                 case 2: return tr("Price");
-		default: return QVariant();
-	}
+        default: return QVariant();
+    }
 }
 
 QModelIndex DeckListModel::index(int row, int column, const QModelIndex &parent) const
 {
-//	debugIndexInfo("index", parent);
-	if (!hasIndex(row, column, parent))
-		return QModelIndex();
+//    debugIndexInfo("index", parent);
+    if (!hasIndex(row, column, parent))
+        return QModelIndex();
 
-	InnerDecklistNode *parentNode = getNode<InnerDecklistNode *>(parent);
-	if (row >= parentNode->size())
-		return QModelIndex();
+    InnerDecklistNode *parentNode = getNode<InnerDecklistNode *>(parent);
+    if (row >= parentNode->size())
+        return QModelIndex();
 
-	return createIndex(row, column, parentNode->at(row));
+    return createIndex(row, column, parentNode->at(row));
 }
 
 QModelIndex DeckListModel::parent(const QModelIndex &ind) const
 {
-	if (!ind.isValid())
-		return QModelIndex();
+    if (!ind.isValid())
+        return QModelIndex();
 
-	return nodeToIndex(static_cast<AbstractDecklistNode *>(ind.internalPointer())->getParent());
+    return nodeToIndex(static_cast<AbstractDecklistNode *>(ind.internalPointer())->getParent());
 }
 
 Qt::ItemFlags DeckListModel::flags(const QModelIndex &index) const
 {
-	if (!index.isValid())
-		return 0;
+    if (!index.isValid())
+        return 0;
 
-	Qt::ItemFlags result = Qt::ItemIsEnabled;
-	if (getNode<DecklistModelCardNode *>(index))
-		result |= Qt::ItemIsSelectable;
+    Qt::ItemFlags result = Qt::ItemIsEnabled;
+    if (getNode<DecklistModelCardNode *>(index))
+        result |= Qt::ItemIsSelectable;
 
-	return result;
+    return result;
 }
 
 void DeckListModel::emitRecursiveUpdates(const QModelIndex &index)
 {
-	if (!index.isValid())
-		return;
-	emit dataChanged(index, index);
-	emitRecursiveUpdates(index.parent());
+    if (!index.isValid())
+        return;
+    emit dataChanged(index, index);
+    emitRecursiveUpdates(index.parent());
 }
 
 bool DeckListModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
-	DecklistModelCardNode *node = getNode<DecklistModelCardNode *>(index);
-	if (!node || (role != Qt::EditRole))
-		return false;
+    DecklistModelCardNode *node = getNode<DecklistModelCardNode *>(index);
+    if (!node || (role != Qt::EditRole))
+        return false;
 
-	switch (index.column()) {
+    switch (index.column()) {
                 case 0: node->setNumber(value.toInt()); break;
                 case 1: node->setName(value.toString()); break;
                 case 2: node->setPrice(value.toFloat()); break;
-		default: return false;
-	}
-	emitRecursiveUpdates(index);
-	deckList->updateDeckHash();
-	return true;
+        default: return false;
+    }
+    emitRecursiveUpdates(index);
+    deckList->updateDeckHash();
+    return true;
 }
 
 bool DeckListModel::removeRows(int row, int count, const QModelIndex &parent)
 {
-	InnerDecklistNode *node = getNode<InnerDecklistNode *>(parent);
-	if (!node)
-		return false;
-	if (row + count > node->size())
-		return false;
-
-	beginRemoveRows(parent, row, row + count - 1);
-	for (int i = 0; i < count; i++) {
-		AbstractDecklistNode *toDelete = node->takeAt(row);
-		if (DecklistModelCardNode *temp = dynamic_cast<DecklistModelCardNode *>(toDelete))
-			deckList->deleteNode(temp->getDataNode());
-		delete toDelete;
-	}
-	endRemoveRows();
-
-	if (!node->size() && (node != root))
-		removeRows(parent.row(), 1, parent.parent());
-	else
-		emitRecursiveUpdates(parent);
-
-	return true;
+    InnerDecklistNode *node = getNode<InnerDecklistNode *>(parent);
+    if (!node)
+        return false;
+    if (row + count > node->size())
+        return false;
+
+    beginRemoveRows(parent, row, row + count - 1);
+    for (int i = 0; i < count; i++) {
+        AbstractDecklistNode *toDelete = node->takeAt(row);
+        if (DecklistModelCardNode *temp = dynamic_cast<DecklistModelCardNode *>(toDelete))
+            deckList->deleteNode(temp->getDataNode());
+        delete toDelete;
+    }
+    endRemoveRows();
+
+    if (!node->size() && (node != root))
+        removeRows(parent.row(), 1, parent.parent());
+    else
+        emitRecursiveUpdates(parent);
+
+    return true;
 }
 
 InnerDecklistNode *DeckListModel::createNodeIfNeeded(const QString &name, InnerDecklistNode *parent)
 {
-	InnerDecklistNode *newNode = dynamic_cast<InnerDecklistNode *>(parent->findChild(name));
-	if (!newNode) {
-		beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
-		newNode = new InnerDecklistNode(name, parent);
-		endInsertRows();
-	}
-	return newNode;
+    InnerDecklistNode *newNode = dynamic_cast<InnerDecklistNode *>(parent->findChild(name));
+    if (!newNode) {
+        beginInsertRows(nodeToIndex(parent), parent->size(), parent->size());
+        newNode = new InnerDecklistNode(name, parent);
+        endInsertRows();
+    }
+    return newNode;
 }
 
 QModelIndex DeckListModel::addCard(const QString &cardName, const QString &zoneName)
 {
-	InnerDecklistNode *zoneNode = createNodeIfNeeded(zoneName, root);
-
-	CardInfo *info = db->getCard(cardName);
-	QString cardType = info->getMainCardType();
-	InnerDecklistNode *cardTypeNode = createNodeIfNeeded(cardType, zoneNode);
-
-	DecklistModelCardNode *cardNode = dynamic_cast<DecklistModelCardNode *>(cardTypeNode->findChild(cardName));
-	if (!cardNode) {
-		DecklistCardNode *decklistCard = deckList->addCard(cardName, zoneName);
-		QModelIndex parentIndex = nodeToIndex(cardTypeNode);
-		beginInsertRows(parentIndex, cardTypeNode->size(), cardTypeNode->size());
-		cardNode = new DecklistModelCardNode(decklistCard, cardTypeNode);
-		endInsertRows();
-		sort(1);
-		emitRecursiveUpdates(parentIndex);
-		return nodeToIndex(cardNode);
-	} else {
-		cardNode->setNumber(cardNode->getNumber() + 1);
-		QModelIndex ind = nodeToIndex(cardNode);
-		emitRecursiveUpdates(ind);
-		deckList->updateDeckHash();
-		return ind;
-	}
+    InnerDecklistNode *zoneNode = createNodeIfNeeded(zoneName, root);
+
+    CardInfo *info = db->getCard(cardName);
+    QString cardType = info->getMainCardType();
+    InnerDecklistNode *cardTypeNode = createNodeIfNeeded(cardType, zoneNode);
+
+    DecklistModelCardNode *cardNode = dynamic_cast<DecklistModelCardNode *>(cardTypeNode->findChild(cardName));
+    if (!cardNode) {
+        DecklistCardNode *decklistCard = deckList->addCard(cardName, zoneName);
+        QModelIndex parentIndex = nodeToIndex(cardTypeNode);
+        beginInsertRows(parentIndex, cardTypeNode->size(), cardTypeNode->size());
+        cardNode = new DecklistModelCardNode(decklistCard, cardTypeNode);
+        endInsertRows();
+        sort(1);
+        emitRecursiveUpdates(parentIndex);
+        return nodeToIndex(cardNode);
+    } else {
+        cardNode->setNumber(cardNode->getNumber() + 1);
+        QModelIndex ind = nodeToIndex(cardNode);
+        emitRecursiveUpdates(ind);
+        deckList->updateDeckHash();
+        return ind;
+    }
 }
 
 QModelIndex DeckListModel::nodeToIndex(AbstractDecklistNode *node) const
 {
-	if (node == root)
-		return QModelIndex();
-	return createIndex(node->getParent()->indexOf(node), 0, node);
+    if (node == root)
+        return QModelIndex();
+    return createIndex(node->getParent()->indexOf(node), 0, node);
 }
 
 void DeckListModel::sortHelper(InnerDecklistNode *node, Qt::SortOrder order)
 {
-	// Sort children of node and save the information needed to
-	// update the list of persistent indexes.
-	QVector<QPair<int, int> > sortResult = node->sort(order);
-	
-	QModelIndexList from, to;
-	for (int i = sortResult.size() - 1; i >= 0; --i) {
-		const int fromRow = sortResult[i].first;
-		const int toRow = sortResult[i].second;
-		AbstractDecklistNode *temp = node->at(toRow);
-		for (int j = columnCount(); j; --j) {
-			from << createIndex(fromRow, 0, temp);
-			to << createIndex(toRow, 0, temp);
-		}
-	}
-	changePersistentIndexList(from, to);
-	
-	// Recursion
-	for (int i = node->size() - 1; i >= 0; --i) {
-		InnerDecklistNode *subNode = dynamic_cast<InnerDecklistNode *>(node->at(i));
-		if (subNode)
-			sortHelper(subNode, order);
-	}
+    // Sort children of node and save the information needed to
+    // update the list of persistent indexes.
+    QVector<QPair<int, int> > sortResult = node->sort(order);
+    
+    QModelIndexList from, to;
+    for (int i = sortResult.size() - 1; i >= 0; --i) {
+        const int fromRow = sortResult[i].first;
+        const int toRow = sortResult[i].second;
+        AbstractDecklistNode *temp = node->at(toRow);
+        for (int j = columnCount(); j; --j) {
+            from << createIndex(fromRow, 0, temp);
+            to << createIndex(toRow, 0, temp);
+        }
+    }
+    changePersistentIndexList(from, to);
+    
+    // Recursion
+    for (int i = node->size() - 1; i >= 0; --i) {
+        InnerDecklistNode *subNode = dynamic_cast<InnerDecklistNode *>(node->at(i));
+        if (subNode)
+            sortHelper(subNode, order);
+    }
 }
 
 void DeckListModel::sort(int /*column*/, Qt::SortOrder order)
 {
-	emit layoutAboutToBeChanged();
-	sortHelper(root, order);
-	emit layoutChanged();
+    emit layoutAboutToBeChanged();
+    sortHelper(root, order);
+    emit layoutChanged();
 }
 
 void DeckListModel::cleanList()
 {
-	setDeckList(new DeckLoader);
+    setDeckList(new DeckLoader);
 }
 
 void DeckListModel::setDeckList(DeckLoader *_deck)
 {
-	delete deckList;
-	deckList = _deck;
-	connect(deckList, SIGNAL(deckLoaded()), this, SLOT(rebuildTree()));
-	connect(deckList, SIGNAL(deckHashChanged()), this, SIGNAL(deckHashChanged()));
-	rebuildTree();
+    delete deckList;
+    deckList = _deck;
+    connect(deckList, SIGNAL(deckLoaded()), this, SLOT(rebuildTree()));
+    connect(deckList, SIGNAL(deckHashChanged()), this, SIGNAL(deckHashChanged()));
+    rebuildTree();
 }
 
 void DeckListModel::printDeckListNode(QTextCursor *cursor, InnerDecklistNode *node)
 {
-	const int totalColumns = settingsCache->getPriceTagFeature() ? 3 : 2;
-
-	if (node->height() == 1) {
-		QTextBlockFormat blockFormat;
-		QTextCharFormat charFormat;
-		charFormat.setFontPointSize(11);
-		charFormat.setFontWeight(QFont::Bold);
-		cursor->insertBlock(blockFormat, charFormat);
-		QString priceStr;
-		if (settingsCache->getPriceTagFeature())
-			priceStr = QString().sprintf(": $%.2f", node->recursivePrice(true));
+    const int totalColumns = settingsCache->getPriceTagFeature() ? 3 : 2;
+
+    if (node->height() == 1) {
+        QTextBlockFormat blockFormat;
+        QTextCharFormat charFormat;
+        charFormat.setFontPointSize(11);
+        charFormat.setFontWeight(QFont::Bold);
+        cursor->insertBlock(blockFormat, charFormat);
+        QString priceStr;
+        if (settingsCache->getPriceTagFeature())
+            priceStr = QString().sprintf(": $%.2f", node->recursivePrice(true));
                 cursor->insertText(QString("%1: %2").arg(node->getVisibleName()).arg(node->recursiveCount(true)).append(priceStr));
 
-		QTextTableFormat tableFormat;
-		tableFormat.setCellPadding(0);
-		tableFormat.setCellSpacing(0);
-		tableFormat.setBorder(0);
+        QTextTableFormat tableFormat;
+        tableFormat.setCellPadding(0);
+        tableFormat.setCellSpacing(0);
+        tableFormat.setBorder(0);
                 QTextTable *table = cursor->insertTable(node->size() + 1, totalColumns, tableFormat);
-		for (int i = 0; i < node->size(); i++) {
-			AbstractDecklistCardNode *card = dynamic_cast<AbstractDecklistCardNode *>(node->at(i));
-
-			QTextCharFormat cellCharFormat;
-			cellCharFormat.setFontPointSize(9);
-
-			QTextTableCell cell = table->cellAt(i, 0);
-			cell.setFormat(cellCharFormat);
-			QTextCursor cellCursor = cell.firstCursorPosition();
-			cellCursor.insertText(QString("%1 ").arg(card->getNumber()));
-
-			cell = table->cellAt(i, 1);
-			cell.setFormat(cellCharFormat);
-			cellCursor = cell.firstCursorPosition();
-			cellCursor.insertText(card->getName());
-
-			if (settingsCache->getPriceTagFeature()) {
-	                        cell = table->cellAt(i, 2);
-	                        cell.setFormat(cellCharFormat);
-	                        cellCursor = cell.firstCursorPosition();
-	                        cellCursor.insertText(QString().sprintf("$%.2f ", card->getTotalPrice()));
-			}
-		}
-	} else if (node->height() == 2) {
-		QTextBlockFormat blockFormat;
-		QTextCharFormat charFormat;
-		charFormat.setFontPointSize(14);
-		charFormat.setFontWeight(QFont::Bold);
-
-		cursor->insertBlock(blockFormat, charFormat);
-		QString priceStr;
-		if (settingsCache->getPriceTagFeature())
-			priceStr = QString().sprintf(": $%.2f", node->recursivePrice(true));
+        for (int i = 0; i < node->size(); i++) {
+            AbstractDecklistCardNode *card = dynamic_cast<AbstractDecklistCardNode *>(node->at(i));
+
+            QTextCharFormat cellCharFormat;
+            cellCharFormat.setFontPointSize(9);
+
+            QTextTableCell cell = table->cellAt(i, 0);
+            cell.setFormat(cellCharFormat);
+            QTextCursor cellCursor = cell.firstCursorPosition();
+            cellCursor.insertText(QString("%1 ").arg(card->getNumber()));
+
+            cell = table->cellAt(i, 1);
+            cell.setFormat(cellCharFormat);
+            cellCursor = cell.firstCursorPosition();
+            cellCursor.insertText(card->getName());
+
+            if (settingsCache->getPriceTagFeature()) {
+                            cell = table->cellAt(i, 2);
+                            cell.setFormat(cellCharFormat);
+                            cellCursor = cell.firstCursorPosition();
+                            cellCursor.insertText(QString().sprintf("$%.2f ", card->getTotalPrice()));
+            }
+        }
+    } else if (node->height() == 2) {
+        QTextBlockFormat blockFormat;
+        QTextCharFormat charFormat;
+        charFormat.setFontPointSize(14);
+        charFormat.setFontWeight(QFont::Bold);
+
+        cursor->insertBlock(blockFormat, charFormat);
+        QString priceStr;
+        if (settingsCache->getPriceTagFeature())
+            priceStr = QString().sprintf(": $%.2f", node->recursivePrice(true));
                 cursor->insertText(QString("%1: %2").arg(node->getVisibleName()).arg(node->recursiveCount(true)).append(priceStr));
 
-		QTextTableFormat tableFormat;
-		tableFormat.setCellPadding(10);
-		tableFormat.setCellSpacing(0);
-		tableFormat.setBorder(0);
-		QVector<QTextLength> constraints;
-		for (int i = 0; i < totalColumns; i++)
-			constraints << QTextLength(QTextLength::PercentageLength, 100.0 / totalColumns);
-		tableFormat.setColumnWidthConstraints(constraints);
-
-		QTextTable *table = cursor->insertTable(1, totalColumns, tableFormat);
-		for (int i = 0; i < node->size(); i++) {
-			QTextCursor cellCursor = table->cellAt(0, (i * totalColumns) / node->size()).lastCursorPosition();
-			printDeckListNode(&cellCursor, dynamic_cast<InnerDecklistNode *>(node->at(i)));
-		}
-	}
-	cursor->movePosition(QTextCursor::End);
+        QTextTableFormat tableFormat;
+        tableFormat.setCellPadding(10);
+        tableFormat.setCellSpacing(0);
+        tableFormat.setBorder(0);
+        QVector<QTextLength> constraints;
+        for (int i = 0; i < totalColumns; i++)
+            constraints << QTextLength(QTextLength::PercentageLength, 100.0 / totalColumns);
+        tableFormat.setColumnWidthConstraints(constraints);
+
+        QTextTable *table = cursor->insertTable(1, totalColumns, tableFormat);
+        for (int i = 0; i < node->size(); i++) {
+            QTextCursor cellCursor = table->cellAt(0, (i * totalColumns) / node->size()).lastCursorPosition();
+            printDeckListNode(&cellCursor, dynamic_cast<InnerDecklistNode *>(node->at(i)));
+        }
+    }
+    cursor->movePosition(QTextCursor::End);
 }
 
 void DeckListModel::printDeckList(QPrinter *printer)
 {
-	QTextDocument doc;
+    QTextDocument doc;
 
-	QFont font("Serif");
-	font.setStyleHint(QFont::Serif);
-	doc.setDefaultFont(font);
+    QFont font("Serif");
+    font.setStyleHint(QFont::Serif);
+    doc.setDefaultFont(font);
 
-	QTextCursor cursor(&doc);
+    QTextCursor cursor(&doc);
 
-	QTextBlockFormat headerBlockFormat;
-	QTextCharFormat headerCharFormat;
-	headerCharFormat.setFontPointSize(16);
-	headerCharFormat.setFontWeight(QFont::Bold);
+    QTextBlockFormat headerBlockFormat;
+    QTextCharFormat headerCharFormat;
+    headerCharFormat.setFontPointSize(16);
+    headerCharFormat.setFontWeight(QFont::Bold);
 
-	cursor.insertBlock(headerBlockFormat, headerCharFormat);
-	cursor.insertText(deckList->getName());
+    cursor.insertBlock(headerBlockFormat, headerCharFormat);
+    cursor.insertText(deckList->getName());
 
-	headerCharFormat.setFontPointSize(12);
-	cursor.insertBlock(headerBlockFormat, headerCharFormat);
-	cursor.insertText(deckList->getComments());
-	cursor.insertBlock(headerBlockFormat, headerCharFormat);
+    headerCharFormat.setFontPointSize(12);
+    cursor.insertBlock(headerBlockFormat, headerCharFormat);
+    cursor.insertText(deckList->getComments());
+    cursor.insertBlock(headerBlockFormat, headerCharFormat);
 
-	for (int i = 0; i < root->size(); i++) {
-		cursor.insertHtml("<br><img src=:/resources/hr.jpg>");
-		//cursor.insertHtml("<hr>");
-		cursor.insertBlock(headerBlockFormat, headerCharFormat);
+    for (int i = 0; i < root->size(); i++) {
+        cursor.insertHtml("<br><img src=:/resources/hr.jpg>");
+        //cursor.insertHtml("<hr>");
+        cursor.insertBlock(headerBlockFormat, headerCharFormat);
 
-		printDeckListNode(&cursor, dynamic_cast<InnerDecklistNode *>(root->at(i)));
-	}
+        printDeckListNode(&cursor, dynamic_cast<InnerDecklistNode *>(root->at(i)));
+    }
 
-	doc.print(printer);
+    doc.print(printer);
 }
 
 void DeckListModel::pricesUpdated(InnerDecklistNode *node)
 {
-	if (!node)
-		node = root;
-	
-	if (node->isEmpty())
-		return;
-	
-	emit dataChanged(createIndex(0, 2, node->at(0)), createIndex(node->size() - 1, 2, node->last()));
+    if (!node)
+        node = root;
+    
+    if (node->isEmpty())
+        return;
+    
+    emit dataChanged(createIndex(0, 2, node->at(0)), createIndex(node->size() - 1, 2, node->last()));
 }

cockatrice/src/decklistmodel.h

@@ -13,60 +13,60 @@ class QTextCursor;
 
 class DecklistModelCardNode : public AbstractDecklistCardNode {
 private:
-	DecklistCardNode *dataNode;
+    DecklistCardNode *dataNode;
 public:
-	DecklistModelCardNode(DecklistCardNode *_dataNode, InnerDecklistNode *_parent) : AbstractDecklistCardNode(_parent), dataNode(_dataNode) { }
-	int getNumber() const { return dataNode->getNumber(); }
-	void setNumber(int _number) { dataNode->setNumber(_number); }
+    DecklistModelCardNode(DecklistCardNode *_dataNode, InnerDecklistNode *_parent) : AbstractDecklistCardNode(_parent), dataNode(_dataNode) { }
+    int getNumber() const { return dataNode->getNumber(); }
+    void setNumber(int _number) { dataNode->setNumber(_number); }
         float getPrice() const { return dataNode->getPrice(); }
         void setPrice(float _price) { dataNode->setPrice(_price); }
-	QString getName() const { return dataNode->getName(); }
-	void setName(const QString &_name) { dataNode->setName(_name); }
-	DecklistCardNode *getDataNode() const { return dataNode; }
+    QString getName() const { return dataNode->getName(); }
+    void setName(const QString &_name) { dataNode->setName(_name); }
+    DecklistCardNode *getDataNode() const { return dataNode; }
 };
 
 class DeckListModel : public QAbstractItemModel {
-	Q_OBJECT
+    Q_OBJECT
 private slots:
-	void rebuildTree();
+    void rebuildTree();
 public slots:
-	void printDeckList(QPrinter *printer);
+    void printDeckList(QPrinter *printer);
 signals:
-	void deckHashChanged();
+    void deckHashChanged();
 public:
-	DeckListModel(QObject *parent = 0);
-	~DeckListModel();
-	int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    DeckListModel(QObject *parent = 0);
+    ~DeckListModel();
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
         int columnCount(const QModelIndex &/*parent*/ = QModelIndex()) const;
-	QVariant data(const QModelIndex &index, int role) const;
-	QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
-	QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
-	QModelIndex parent(const QModelIndex &index) const;
-	Qt::ItemFlags flags(const QModelIndex &index) const;
-	bool setData(const QModelIndex &index, const QVariant &value, int role);
-	bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
-	QModelIndex addCard(const QString &cardName, const QString &zoneName);
-	void sort(int column, Qt::SortOrder order = Qt::AscendingOrder);
-	void cleanList();
-	DeckLoader *getDeckList() const { return deckList; }
-	void setDeckList(DeckLoader *_deck);
-	void pricesUpdated(InnerDecklistNode *node = 0);
+    QVariant data(const QModelIndex &index, int role) const;
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex &index) const;
+    Qt::ItemFlags flags(const QModelIndex &index) const;
+    bool setData(const QModelIndex &index, const QVariant &value, int role);
+    bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex());
+    QModelIndex addCard(const QString &cardName, const QString &zoneName);
+    void sort(int column, Qt::SortOrder order = Qt::AscendingOrder);
+    void cleanList();
+    DeckLoader *getDeckList() const { return deckList; }
+    void setDeckList(DeckLoader *_deck);
+    void pricesUpdated(InnerDecklistNode *node = 0);
 private:
-	DeckLoader *deckList;
-	InnerDecklistNode *root;
-	InnerDecklistNode *createNodeIfNeeded(const QString &name, InnerDecklistNode *parent);
-	QModelIndex nodeToIndex(AbstractDecklistNode *node) const;
-	void emitRecursiveUpdates(const QModelIndex &index);
-	void sortHelper(InnerDecklistNode *node, Qt::SortOrder order);
+    DeckLoader *deckList;
+    InnerDecklistNode *root;
+    InnerDecklistNode *createNodeIfNeeded(const QString &name, InnerDecklistNode *parent);
+    QModelIndex nodeToIndex(AbstractDecklistNode *node) const;
+    void emitRecursiveUpdates(const QModelIndex &index);
+    void sortHelper(InnerDecklistNode *node, Qt::SortOrder order);
 
-	void printDeckListNode(QTextCursor *cursor, InnerDecklistNode *node);
+    void printDeckListNode(QTextCursor *cursor, InnerDecklistNode *node);
 
-	template<typename T> T getNode(const QModelIndex &index) const
-	{
-		if (!index.isValid())
-			return dynamic_cast<T>(root);
-		return dynamic_cast<T>(static_cast<AbstractDecklistNode *>(index.internalPointer()));
-	}
+    template<typename T> T getNode(const QModelIndex &index) const
+    {
+        if (!index.isValid())
+            return dynamic_cast<T>(root);
+        return dynamic_cast<T>(static_cast<AbstractDecklistNode *>(index.internalPointer()));
+    }
 };
 
 #endif

cockatrice/src/deckstats_interface.cpp

@@ -8,46 +8,46 @@
 #include <QDesktopServices>
 
 DeckStatsInterface::DeckStatsInterface(QObject *parent)
-	: QObject(parent)
+    : QObject(parent)
 {
-	manager = new QNetworkAccessManager(this);
-	connect(manager, SIGNAL(finished(QNetworkReply *)), this, SLOT(queryFinished(QNetworkReply *)));
+    manager = new QNetworkAccessManager(this);
+    connect(manager, SIGNAL(finished(QNetworkReply *)), this, SLOT(queryFinished(QNetworkReply *)));
 }
 
 void DeckStatsInterface::queryFinished(QNetworkReply *reply)
 {
-	if (reply->error() != QNetworkReply::NoError) {
-		QMessageBox::critical(0, tr("Error"), reply->errorString());
-		reply->deleteLater();
-		deleteLater();
-		return;
-	}
-		
-	QString data(reply->readAll());
-	reply->deleteLater();
-	
-	QRegExp rx("id=\"deckstats_deck_url\" value=\"([^\"]+)\"");
-	if (!rx.indexIn(data)) {
-		QMessageBox::critical(0, tr("Error"), tr("The reply from the server could not be parsed."));
-		deleteLater();
-		return;
-	}
-	
-	QString deckUrl = rx.cap(1);
-	QDesktopServices::openUrl(deckUrl);
-	
-	deleteLater();
+    if (reply->error() != QNetworkReply::NoError) {
+        QMessageBox::critical(0, tr("Error"), reply->errorString());
+        reply->deleteLater();
+        deleteLater();
+        return;
+    }
+        
+    QString data(reply->readAll());
+    reply->deleteLater();
+    
+    QRegExp rx("id=\"deckstats_deck_url\" value=\"([^\"]+)\"");
+    if (!rx.indexIn(data)) {
+        QMessageBox::critical(0, tr("Error"), tr("The reply from the server could not be parsed."));
+        deleteLater();
+        return;
+    }
+    
+    QString deckUrl = rx.cap(1);
+    QDesktopServices::openUrl(deckUrl);
+    
+    deleteLater();
 }
 
 void DeckStatsInterface::analyzeDeck(DeckList *deck)
 {
-	QUrl params;
-	params.addQueryItem("deck", deck->writeToString_Plain());
-	QByteArray data;
-	data.append(params.encodedQuery());
-	
-	QNetworkRequest request(QUrl("http://deckstats.net/index.php"));
-	request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
-	
-	manager->post(request, data);
+    QUrl params;
+    params.addQueryItem("deck", deck->writeToString_Plain());
+    QByteArray data;
+    data.append(params.encodedQuery());
+    
+    QNetworkRequest request(QUrl("http://deckstats.net/index.php"));
+    request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+    
+    manager->post(request, data);
 }

cockatrice/src/deckstats_interface.h

@@ -8,14 +8,14 @@ class QNetworkReply;
 class DeckList;
 
 class DeckStatsInterface : public QObject {
-	Q_OBJECT
+    Q_OBJECT
 private:
-	QNetworkAccessManager *manager;
+    QNetworkAccessManager *manager;
 private slots:
-	void queryFinished(QNetworkReply *reply);
+    void queryFinished(QNetworkReply *reply);
 public:
-	DeckStatsInterface(QObject *parent = 0);
-	void analyzeDeck(DeckList *deck);
+    DeckStatsInterface(QObject *parent = 0);
+    void analyzeDeck(DeckList *deck);
 };
 
 #endif

cockatrice/src/deckview.cpp

@@ -8,479 +8,479 @@
 #include "main.h"
 
 DeckViewCardDragItem::DeckViewCardDragItem(DeckViewCard *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag)
-	: AbstractCardDragItem(_item, _hotSpot, parentDrag), currentZone(0)
+    : AbstractCardDragItem(_item, _hotSpot, parentDrag), currentZone(0)
 {
 }
 
 void DeckViewCardDragItem::updatePosition(const QPointF &cursorScenePos)
 {
-	QList<QGraphicsItem *> colliding = scene()->items(cursorScenePos);
+    QList<QGraphicsItem *> colliding = scene()->items(cursorScenePos);
 
-	DeckViewCardContainer *cursorZone = 0;
-	for (int i = colliding.size() - 1; i >= 0; i--)
-		if ((cursorZone = qgraphicsitem_cast<DeckViewCardContainer *>(colliding.at(i))))
-			break;
-	if (!cursorZone)
-		return;
-	currentZone = cursorZone;
-	
-	QPointF newPos = cursorScenePos;
-	if (newPos != pos()) {
-		for (int i = 0; i < childDrags.size(); i++)
-			childDrags[i]->setPos(newPos + childDrags[i]->getHotSpot());
-		setPos(newPos);
-	}
+    DeckViewCardContainer *cursorZone = 0;
+    for (int i = colliding.size() - 1; i >= 0; i--)
+        if ((cursorZone = qgraphicsitem_cast<DeckViewCardContainer *>(colliding.at(i))))
+            break;
+    if (!cursorZone)
+        return;
+    currentZone = cursorZone;
+    
+    QPointF newPos = cursorScenePos;
+    if (newPos != pos()) {
+        for (int i = 0; i < childDrags.size(); i++)
+            childDrags[i]->setPos(newPos + childDrags[i]->getHotSpot());
+        setPos(newPos);
+    }
 }
 
 void DeckViewCardDragItem::handleDrop(DeckViewCardContainer *target)
 {
-	DeckViewCard *card = static_cast<DeckViewCard *>(item);
-	DeckViewCardContainer *start = static_cast<DeckViewCardContainer *>(item->parentItem());
-	start->removeCard(card);
-	target->addCard(card);
-	card->setParentItem(target);
+    DeckViewCard *card = static_cast<DeckViewCard *>(item);
+    DeckViewCardContainer *start = static_cast<DeckViewCardContainer *>(item->parentItem());
+    start->removeCard(card);
+    target->addCard(card);
+    card->setParentItem(target);
 }
 
 void DeckViewCardDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
-	setCursor(Qt::OpenHandCursor);
-	DeckViewScene *sc = static_cast<DeckViewScene *>(scene());
-	sc->removeItem(this);
+    setCursor(Qt::OpenHandCursor);
+    DeckViewScene *sc = static_cast<DeckViewScene *>(scene());
+    sc->removeItem(this);
 
-	if (currentZone) {
-		handleDrop(currentZone);
-		for (int i = 0; i < childDrags.size(); i++) {
-			DeckViewCardDragItem *c = static_cast<DeckViewCardDragItem *>(childDrags[i]);
-			c->handleDrop(currentZone);
-			sc->removeItem(c);
-		}
-		
-		sc->updateContents();
-	}
-	
-	event->accept();
+    if (currentZone) {
+        handleDrop(currentZone);
+        for (int i = 0; i < childDrags.size(); i++) {
+            DeckViewCardDragItem *c = static_cast<DeckViewCardDragItem *>(childDrags[i]);
+            c->handleDrop(currentZone);
+            sc->removeItem(c);
+        }
+        
+        sc->updateContents();
+    }
+    
+    event->accept();
 }
 
 DeckViewCard::DeckViewCard(const QString &_name, const QString &_originZone, QGraphicsItem *parent)
-	: AbstractCardItem(_name, 0, -1, parent), originZone(_originZone), dragItem(0)
+    : AbstractCardItem(_name, 0, -1, parent), originZone(_originZone), dragItem(0)
 {
-	setAcceptsHoverEvents(true);
+    setAcceptsHoverEvents(true);
 }
 
 DeckViewCard::~DeckViewCard()
 {
-	delete dragItem;
+    delete dragItem;
 }
 
 void DeckViewCard::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
 {
-	AbstractCardItem::paint(painter, option, widget);
-	
-	painter->save();
-	QPen pen;//(Qt::DotLine);
-	pen.setWidth(3);
-	if (originZone == "main")
-		pen.setColor(QColor(0, 255, 0));
-	else
-		pen.setColor(QColor(255, 0, 0));
-	painter->setPen(pen);
-	painter->drawRect(QRectF(1.5, 1.5, CARD_WIDTH - 3, CARD_HEIGHT - 3));
-	painter->restore();
+    AbstractCardItem::paint(painter, option, widget);
+    
+    painter->save();
+    QPen pen;//(Qt::DotLine);
+    pen.setWidth(3);
+    if (originZone == "main")
+        pen.setColor(QColor(0, 255, 0));
+    else
+        pen.setColor(QColor(255, 0, 0));
+    painter->setPen(pen);
+    painter->drawRect(QRectF(1.5, 1.5, CARD_WIDTH - 3, CARD_HEIGHT - 3));
+    painter->restore();
 }
 
 void DeckViewCard::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 {
-	if ((event->screenPos() - event->buttonDownScreenPos(Qt::LeftButton)).manhattanLength() < 2 * QApplication::startDragDistance())
-		return;
-	
-	if (static_cast<DeckViewScene *>(scene())->getLocked())
-		return;
-	
-	delete dragItem;
-	dragItem = new DeckViewCardDragItem(this, event->pos());
-	scene()->addItem(dragItem);
-	dragItem->updatePosition(event->scenePos());
-	dragItem->grabMouse();
-	
-	QList<QGraphicsItem *> sel = scene()->selectedItems();
-	int j = 0;
-	for (int i = 0; i < sel.size(); i++) {
-		DeckViewCard *c = static_cast<DeckViewCard *>(sel.at(i));
-		if (c == this)
-			continue;
-		++j;
-		QPointF childPos = QPointF(j * CARD_WIDTH / 2, 0);
-		DeckViewCardDragItem *drag = new DeckViewCardDragItem(c, childPos, dragItem);
-		drag->setPos(dragItem->pos() + childPos);
-		scene()->addItem(drag);
-	}
-	setCursor(Qt::OpenHandCursor);
+    if ((event->screenPos() - event->buttonDownScreenPos(Qt::LeftButton)).manhattanLength() < 2 * QApplication::startDragDistance())
+        return;
+    
+    if (static_cast<DeckViewScene *>(scene())->getLocked())
+        return;
+    
+    delete dragItem;
+    dragItem = new DeckViewCardDragItem(this, event->pos());
+    scene()->addItem(dragItem);
+    dragItem->updatePosition(event->scenePos());
+    dragItem->grabMouse();
+    
+    QList<QGraphicsItem *> sel = scene()->selectedItems();
+    int j = 0;
+    for (int i = 0; i < sel.size(); i++) {
+        DeckViewCard *c = static_cast<DeckViewCard *>(sel.at(i));
+        if (c == this)
+            continue;
+        ++j;
+        QPointF childPos = QPointF(j * CARD_WIDTH / 2, 0);
+        DeckViewCardDragItem *drag = new DeckViewCardDragItem(c, childPos, dragItem);
+        drag->setPos(dragItem->pos() + childPos);
+        scene()->addItem(drag);
+    }
+    setCursor(Qt::OpenHandCursor);
 }
 
 void DeckViewCard::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
 {
-	event->accept();
-	processHoverEvent();
+    event->accept();
+    processHoverEvent();
 }
 
 DeckViewCardContainer::DeckViewCardContainer(const QString &_name)
-	: QGraphicsItem(), name(_name), width(0), height(0)
+    : QGraphicsItem(), name(_name), width(0), height(0)
 {
-	QString bgPath = settingsCache->getTableBgPath();
-	if (!bgPath.isEmpty())
-		bgPixmap.load(bgPath);
+    QString bgPath = settingsCache->getTableBgPath();
+    if (!bgPath.isEmpty())
+        bgPixmap.load(bgPath);
 
-	setCacheMode(DeviceCoordinateCache);
+    setCacheMode(DeviceCoordinateCache);
 }
 
 QRectF DeckViewCardContainer::boundingRect() const
 {
-	return QRectF(0, 0, width, height);
+    return QRectF(0, 0, width, height);
 }
 
 void DeckViewCardContainer::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
 {
-	qreal totalTextWidth = getCardTypeTextWidth();
-	
-	if (bgPixmap.isNull())
-		painter->fillRect(boundingRect(), QColor(0, 0, 100));
-	else
-		painter->fillRect(boundingRect(), QBrush(bgPixmap));
-	painter->setPen(QColor(255, 255, 255, 100));
-	painter->drawLine(QPointF(0, separatorY), QPointF(width, separatorY));
-	
-	painter->setPen(QColor(Qt::white));
-	QFont f("Serif");
-	f.setStyleHint(QFont::Serif);
-	f.setPixelSize(24);
-	f.setWeight(QFont::Bold);
-	painter->setFont(f);
-	painter->drawText(10, 0, width - 20, separatorY, Qt::AlignLeft | Qt::AlignVCenter | Qt::TextSingleLine, InnerDecklistNode::visibleNameFromName(name) + QString(": %1").arg(cards.size()));
-	
-	f.setPixelSize(16);
-	painter->setFont(f);
-	QList<QString> cardTypeList = cardsByType.uniqueKeys();
-	qreal yUntilNow = separatorY + paddingY;
-	for (int i = 0; i < cardTypeList.size(); ++i) {
-		if (i != 0) {
-			painter->setPen(QColor(255, 255, 255, 100));
-			painter->drawLine(QPointF(0, yUntilNow - paddingY / 2), QPointF(width, yUntilNow - paddingY / 2));
-		}
-		qreal thisRowHeight = CARD_HEIGHT * currentRowsAndCols[i].first;
-		QRectF textRect(0, yUntilNow, totalTextWidth, thisRowHeight);
-		yUntilNow += thisRowHeight + paddingY;
-		
-		painter->setPen(Qt::white);
-		painter->drawText(textRect, Qt::AlignHCenter | Qt::AlignVCenter | Qt::TextSingleLine, cardTypeList[i]);
-	}
+    qreal totalTextWidth = getCardTypeTextWidth();
+    
+    if (bgPixmap.isNull())
+        painter->fillRect(boundingRect(), QColor(0, 0, 100));
+    else
+        painter->fillRect(boundingRect(), QBrush(bgPixmap));
+    painter->setPen(QColor(255, 255, 255, 100));
+    painter->drawLine(QPointF(0, separatorY), QPointF(width, separatorY));
+    
+    painter->setPen(QColor(Qt::white));
+    QFont f("Serif");
+    f.setStyleHint(QFont::Serif);
+    f.setPixelSize(24);
+    f.setWeight(QFont::Bold);
+    painter->setFont(f);
+    painter->drawText(10, 0, width - 20, separatorY, Qt::AlignLeft | Qt::AlignVCenter | Qt::TextSingleLine, InnerDecklistNode::visibleNameFromName(name) + QString(": %1").arg(cards.size()));
+    
+    f.setPixelSize(16);
+    painter->setFont(f);
+    QList<QString> cardTypeList = cardsByType.uniqueKeys();
+    qreal yUntilNow = separatorY + paddingY;
+    for (int i = 0; i < cardTypeList.size(); ++i) {
+        if (i != 0) {
+            painter->setPen(QColor(255, 255, 255, 100));
+            painter->drawLine(QPointF(0, yUntilNow - paddingY / 2), QPointF(width, yUntilNow - paddingY / 2));
+        }
+        qreal thisRowHeight = CARD_HEIGHT * currentRowsAndCols[i].first;
+        QRectF textRect(0, yUntilNow, totalTextWidth, thisRowHeight);
+        yUntilNow += thisRowHeight + paddingY;
+        
+        painter->setPen(Qt::white);
+        painter->drawText(textRect, Qt::AlignHCenter | Qt::AlignVCenter | Qt::TextSingleLine, cardTypeList[i]);
+    }
 }
 
 void DeckViewCardContainer::addCard(DeckViewCard *card)
 {
-	cards.append(card);
-	cardsByType.insert(card->getInfo()->getMainCardType(), card);
+    cards.append(card);
+    cardsByType.insert(card->getInfo()->getMainCardType(), card);
 }
 
 void DeckViewCardContainer::removeCard(DeckViewCard *card)
 {
-	cards.removeAt(cards.indexOf(card));
-	cardsByType.remove(card->getInfo()->getMainCardType(), card);
+    cards.removeAt(cards.indexOf(card));
+    cardsByType.remove(card->getInfo()->getMainCardType(), card);
 }
 
 QList<QPair<int, int> > DeckViewCardContainer::getRowsAndCols() const
 {
-	QList<QPair<int, int> > result;
-	QList<QString> cardTypeList = cardsByType.uniqueKeys();
-	for (int i = 0; i < cardTypeList.size(); ++i)
-		result.append(QPair<int, int>(1, cardsByType.count(cardTypeList[i])));
-	return result;
+    QList<QPair<int, int> > result;
+    QList<QString> cardTypeList = cardsByType.uniqueKeys();
+    for (int i = 0; i < cardTypeList.size(); ++i)
+        result.append(QPair<int, int>(1, cardsByType.count(cardTypeList[i])));
+    return result;
 }
 
 int DeckViewCardContainer::getCardTypeTextWidth() const
 {
-	QFont f("Serif");
-	f.setStyleHint(QFont::Serif);
-	f.setPixelSize(16);
-	f.setWeight(QFont::Bold);
-	QFontMetrics fm(f);
-	
-	int maxCardTypeWidth = 0;
-	QMapIterator<QString, DeckViewCard *> i(cardsByType);
-	while (i.hasNext()) {
-		int cardTypeWidth = fm.size(Qt::TextSingleLine, i.next().key()).width();
-		if (cardTypeWidth > maxCardTypeWidth)
-			maxCardTypeWidth = cardTypeWidth;
-	}
-	
-	return maxCardTypeWidth + 15;
+    QFont f("Serif");
+    f.setStyleHint(QFont::Serif);
+    f.setPixelSize(16);
+    f.setWeight(QFont::Bold);
+    QFontMetrics fm(f);
+    
+    int maxCardTypeWidth = 0;
+    QMapIterator<QString, DeckViewCard *> i(cardsByType);
+    while (i.hasNext()) {
+        int cardTypeWidth = fm.size(Qt::TextSingleLine, i.next().key()).width();
+        if (cardTypeWidth > maxCardTypeWidth)
+            maxCardTypeWidth = cardTypeWidth;
+    }
+    
+    return maxCardTypeWidth + 15;
 }
 
 QSizeF DeckViewCardContainer::calculateBoundingRect(const QList<QPair<int, int> > &rowsAndCols) const
 {
-	qreal totalHeight = 0;
-	qreal totalWidth = 0;
-	
-	// Calculate space needed for cards
-	for (int i = 0; i < rowsAndCols.size(); ++i) {
-		totalHeight += CARD_HEIGHT * rowsAndCols[i].first + paddingY;
-		if (CARD_WIDTH * rowsAndCols[i].second > totalWidth)
-			totalWidth = CARD_WIDTH * rowsAndCols[i].second;
-	}
-	
-	return QSizeF(getCardTypeTextWidth() + totalWidth, totalHeight + separatorY + paddingY);
+    qreal totalHeight = 0;
+    qreal totalWidth = 0;
+    
+    // Calculate space needed for cards
+    for (int i = 0; i < rowsAndCols.size(); ++i) {
+        totalHeight += CARD_HEIGHT * rowsAndCols[i].first + paddingY;
+        if (CARD_WIDTH * rowsAndCols[i].second > totalWidth)
+            totalWidth = CARD_WIDTH * rowsAndCols[i].second;
+    }
+    
+    return QSizeF(getCardTypeTextWidth() + totalWidth, totalHeight + separatorY + paddingY);
 }
 
 void DeckViewCardContainer::rearrangeItems(const QList<QPair<int, int> > &rowsAndCols)
 {
-	currentRowsAndCols = rowsAndCols;
-	
-	int totalCols = 0, totalRows = 0;
-	qreal yUntilNow = separatorY + paddingY;
-	qreal x = (qreal) getCardTypeTextWidth();
-	for (int i = 0; i < rowsAndCols.size(); ++i) {
-		const int tempRows = rowsAndCols[i].first;
-		const int tempCols = rowsAndCols[i].second;
-		totalRows += tempRows;
-		if (tempCols > totalCols)
-			totalCols = tempCols;
-		
-		QList<QString> cardTypeList = cardsByType.uniqueKeys();
-		QList<DeckViewCard *> row = cardsByType.values(cardTypeList[i]);
-		for (int j = 0; j < row.size(); ++j) {
-			DeckViewCard *card = row[j];
-			card->setPos(x + (j % tempCols) * CARD_WIDTH, yUntilNow + (j / tempCols) * CARD_HEIGHT);
-		}
-		yUntilNow += tempRows * CARD_HEIGHT + paddingY;
-	}
-	
-	prepareGeometryChange();
-	QSizeF bRect = calculateBoundingRect(rowsAndCols);
-	width = bRect.width();
-	height = bRect.height();
+    currentRowsAndCols = rowsAndCols;
+    
+    int totalCols = 0, totalRows = 0;
+    qreal yUntilNow = separatorY + paddingY;
+    qreal x = (qreal) getCardTypeTextWidth();
+    for (int i = 0; i < rowsAndCols.size(); ++i) {
+        const int tempRows = rowsAndCols[i].first;
+        const int tempCols = rowsAndCols[i].second;
+        totalRows += tempRows;
+        if (tempCols > totalCols)
+            totalCols = tempCols;
+        
+        QList<QString> cardTypeList = cardsByType.uniqueKeys();
+        QList<DeckViewCard *> row = cardsByType.values(cardTypeList[i]);
+        for (int j = 0; j < row.size(); ++j) {
+            DeckViewCard *card = row[j];
+            card->setPos(x + (j % tempCols) * CARD_WIDTH, yUntilNow + (j / tempCols) * CARD_HEIGHT);
+        }
+        yUntilNow += tempRows * CARD_HEIGHT + paddingY;
+    }
+    
+    prepareGeometryChange();
+    QSizeF bRect = calculateBoundingRect(rowsAndCols);
+    width = bRect.width();
+    height = bRect.height();
 }
 
 void DeckViewCardContainer::setWidth(qreal _width)
 {
-	prepareGeometryChange();
-	width = _width;
-	update();
+    prepareGeometryChange();
+    width = _width;
+    update();
 }
 
 DeckViewScene::DeckViewScene(QObject *parent)
-	: QGraphicsScene(parent), locked(true), deck(0), optimalAspectRatio(1.0)
+    : QGraphicsScene(parent), locked(true), deck(0), optimalAspectRatio(1.0)
 {
 }
 
 DeckViewScene::~DeckViewScene()
 {
-	clearContents();
-	delete deck;
+    clearContents();
+    delete deck;
 }
 
 void DeckViewScene::clearContents()
 {
-	QMapIterator<QString, DeckViewCardContainer *> i(cardContainers);
-	while (i.hasNext())
-		delete i.next().value();
-	cardContainers.clear();
+    QMapIterator<QString, DeckViewCardContainer *> i(cardContainers);
+    while (i.hasNext())
+        delete i.next().value();
+    cardContainers.clear();
 }
 
 void DeckViewScene::setDeck(const DeckList &_deck)
 {
-	if (deck)
-		delete deck;
-	
-	deck = new DeckList(_deck);
-	rebuildTree();
-	applySideboardPlan(deck->getCurrentSideboardPlan());
-	rearrangeItems();
+    if (deck)
+        delete deck;
+    
+    deck = new DeckList(_deck);
+    rebuildTree();
+    applySideboardPlan(deck->getCurrentSideboardPlan());
+    rearrangeItems();
 }
 
 void DeckViewScene::rebuildTree()
 {
-	clearContents();
-	
-	if (!deck)
-		return;
-	
-	InnerDecklistNode *listRoot = deck->getRoot();
-	for (int i = 0; i < listRoot->size(); i++) {
-		InnerDecklistNode *currentZone = dynamic_cast<InnerDecklistNode *>(listRoot->at(i));
-		
-		DeckViewCardContainer *container = cardContainers.value(currentZone->getName(), 0);
-		if (!container) {
-			container = new DeckViewCardContainer(currentZone->getName());
-			cardContainers.insert(currentZone->getName(), container);
-			addItem(container);
-		}
-		
-		for (int j = 0; j < currentZone->size(); j++) {
-			DecklistCardNode *currentCard = dynamic_cast<DecklistCardNode *>(currentZone->at(j));
-			if (!currentCard)
-				continue;
-
-			for (int k = 0; k < currentCard->getNumber(); ++k) {
-				DeckViewCard *newCard = new DeckViewCard(currentCard->getName(), currentZone->getName(), container);
-				container->addCard(newCard);
-				emit newCardAdded(newCard);
-			}
-		}
-	}
+    clearContents();
+    
+    if (!deck)
+        return;
+    
+    InnerDecklistNode *listRoot = deck->getRoot();
+    for (int i = 0; i < listRoot->size(); i++) {
+        InnerDecklistNode *currentZone = dynamic_cast<InnerDecklistNode *>(listRoot->at(i));
+        
+        DeckViewCardContainer *container = cardContainers.value(currentZone->getName(), 0);
+        if (!container) {
+            container = new DeckViewCardContainer(currentZone->getName());
+            cardContainers.insert(currentZone->getName(), container);
+            addItem(container);
+        }
+        
+        for (int j = 0; j < currentZone->size(); j++) {
+            DecklistCardNode *currentCard = dynamic_cast<DecklistCardNode *>(currentZone->at(j));
+            if (!currentCard)
+                continue;
+
+            for (int k = 0; k < currentCard->getNumber(); ++k) {
+                DeckViewCard *newCard = new DeckViewCard(currentCard->getName(), currentZone->getName(), container);
+                container->addCard(newCard);
+                emit newCardAdded(newCard);
+            }
+        }
+    }
 }
 
 void DeckViewScene::applySideboardPlan(const QList<MoveCard_ToZone> &plan)
 {
-	for (int i = 0; i < plan.size(); ++i) {
-		const MoveCard_ToZone &m = plan[i];
-		DeckViewCardContainer *start = cardContainers.value(QString::fromStdString(m.start_zone()));
-		DeckViewCardContainer *target = cardContainers.value(QString::fromStdString(m.target_zone()));
-		if (!start || !target)
-			continue;
-		
-		DeckViewCard *card = 0;
-		const QList<DeckViewCard *> &cardList = start->getCards();
-		for (int j = 0; j < cardList.size(); ++j)
-			if (cardList[j]->getName() == QString::fromStdString(m.card_name())) {
-				card = cardList[j];
-				break;
-			}
-		if (!card)
-			continue;
-		
-		start->removeCard(card);
-		target->addCard(card);
-		card->setParentItem(target);
-	}
+    for (int i = 0; i < plan.size(); ++i) {
+        const MoveCard_ToZone &m = plan[i];
+        DeckViewCardContainer *start = cardContainers.value(QString::fromStdString(m.start_zone()));
+        DeckViewCardContainer *target = cardContainers.value(QString::fromStdString(m.target_zone()));
+        if (!start || !target)
+            continue;
+        
+        DeckViewCard *card = 0;
+        const QList<DeckViewCard *> &cardList = start->getCards();
+        for (int j = 0; j < cardList.size(); ++j)
+            if (cardList[j]->getName() == QString::fromStdString(m.card_name())) {
+                card = cardList[j];
+                break;
+            }
+        if (!card)
+            continue;
+        
+        start->removeCard(card);
+        target->addCard(card);
+        card->setParentItem(target);
+    }
 }
 
 void DeckViewScene::rearrangeItems()
 {
-	const int spacing = CARD_HEIGHT / 3;
-	QList<DeckViewCardContainer *> contList = cardContainers.values();
-	
-	// Initialize space requirements
-	QList<QList<QPair<int, int> > > rowsAndColsList;
-	QList<QList<int> > cardCountList;
-	for (int i = 0; i < contList.size(); ++i) {
-		QList<QPair<int, int> > rowsAndCols = contList[i]->getRowsAndCols();
-		rowsAndColsList.append(rowsAndCols);
-		
-		cardCountList.append(QList<int>());
-		for (int j = 0; j < rowsAndCols.size(); ++j)
-			cardCountList[i].append(rowsAndCols[j].second);
-	}
-	
-	qreal totalHeight, totalWidth;
-	for (;;) {
-		// Calculate total size before this iteration
-		totalHeight = -spacing;
-		totalWidth = 0;
-		for (int i = 0; i < contList.size(); ++i) {
-			QSizeF contSize = contList[i]->calculateBoundingRect(rowsAndColsList[i]);
-			totalHeight += contSize.height() + spacing;
-			if (contSize.width() > totalWidth)
-				totalWidth = contSize.width();
-		}
-		
-		// We're done when the aspect ratio shifts from too high to too low.
-		if (totalWidth / totalHeight <= optimalAspectRatio)
-			break;
-		
-		// Find category with highest column count
-		int maxIndex1 = -1, maxIndex2 = -1, maxCols = 0;
-		for (int i = 0; i < rowsAndColsList.size(); ++i)
-			for (int j = 0; j < rowsAndColsList[i].size(); ++j)
-				if (rowsAndColsList[i][j].second > maxCols) {
-					maxIndex1 = i;
-					maxIndex2 = j;
-					maxCols = rowsAndColsList[i][j].second;
-				}
-		
-		// Add row to category
-		const int maxRows = rowsAndColsList[maxIndex1][maxIndex2].first;
-		const int maxCardCount = cardCountList[maxIndex1][maxIndex2];
-		rowsAndColsList[maxIndex1][maxIndex2] = QPair<int, int>(maxRows + 1, (int) ceil((qreal) maxCardCount / (qreal) (maxRows + 1)));
-	}
-	
-	totalHeight = -spacing;
-	for (int i = 0; i < contList.size(); ++i) {
-		DeckViewCardContainer *c = contList[i];
-		c->rearrangeItems(rowsAndColsList[i]);
-		c->setPos(0, totalHeight + spacing);
-		totalHeight += c->boundingRect().height() + spacing;
-	}
-	
-	totalWidth = totalHeight * optimalAspectRatio;
-	for (int i = 0; i < contList.size(); ++i)
-		contList[i]->setWidth(totalWidth);
-	
-	setSceneRect(QRectF(0, 0, totalWidth, totalHeight));
+    const int spacing = CARD_HEIGHT / 3;
+    QList<DeckViewCardContainer *> contList = cardContainers.values();
+    
+    // Initialize space requirements
+    QList<QList<QPair<int, int> > > rowsAndColsList;
+    QList<QList<int> > cardCountList;
+    for (int i = 0; i < contList.size(); ++i) {
+        QList<QPair<int, int> > rowsAndCols = contList[i]->getRowsAndCols();
+        rowsAndColsList.append(rowsAndCols);
+        
+        cardCountList.append(QList<int>());
+        for (int j = 0; j < rowsAndCols.size(); ++j)
+            cardCountList[i].append(rowsAndCols[j].second);
+    }
+    
+    qreal totalHeight, totalWidth;
+    for (;;) {
+        // Calculate total size before this iteration
+        totalHeight = -spacing;
+        totalWidth = 0;
+        for (int i = 0; i < contList.size(); ++i) {
+            QSizeF contSize = contList[i]->calculateBoundingRect(rowsAndColsList[i]);
+            totalHeight += contSize.height() + spacing;
+            if (contSize.width() > totalWidth)
+                totalWidth = contSize.width();
+        }
+        
+        // We're done when the aspect ratio shifts from too high to too low.
+        if (totalWidth / totalHeight <= optimalAspectRatio)
+            break;
+        
+        // Find category with highest column count
+        int maxIndex1 = -1, maxIndex2 = -1, maxCols = 0;
+        for (int i = 0; i < rowsAndColsList.size(); ++i)
+            for (int j = 0; j < rowsAndColsList[i].size(); ++j)
+                if (rowsAndColsList[i][j].second > maxCols) {
+                    maxIndex1 = i;
+                    maxIndex2 = j;
+                    maxCols = rowsAndColsList[i][j].second;
+                }
+        
+        // Add row to category
+        const int maxRows = rowsAndColsList[maxIndex1][maxIndex2].first;
+        const int maxCardCount = cardCountList[maxIndex1][maxIndex2];
+        rowsAndColsList[maxIndex1][maxIndex2] = QPair<int, int>(maxRows + 1, (int) ceil((qreal) maxCardCount / (qreal) (maxRows + 1)));
+    }
+    
+    totalHeight = -spacing;
+    for (int i = 0; i < contList.size(); ++i) {
+        DeckViewCardContainer *c = contList[i];
+        c->rearrangeItems(rowsAndColsList[i]);
+        c->setPos(0, totalHeight + spacing);
+        totalHeight += c->boundingRect().height() + spacing;
+    }
+    
+    totalWidth = totalHeight * optimalAspectRatio;
+    for (int i = 0; i < contList.size(); ++i)
+        contList[i]->setWidth(totalWidth);
+    
+    setSceneRect(QRectF(0, 0, totalWidth, totalHeight));
 }
 
 void DeckViewScene::updateContents()
 {
-	rearrangeItems();
-	emit sideboardPlanChanged();
+    rearrangeItems();
+    emit sideboardPlanChanged();
 }
 
 QList<MoveCard_ToZone> DeckViewScene::getSideboardPlan() const
 {
-	QList<MoveCard_ToZone> result;
-	QMapIterator<QString, DeckViewCardContainer *> containerIterator(cardContainers);
-	while (containerIterator.hasNext()) {
-		DeckViewCardContainer *cont = containerIterator.next().value();
-		const QList<DeckViewCard *> cardList = cont->getCards();
-		for (int i = 0; i < cardList.size(); ++i)
-			if (cardList[i]->getOriginZone() != cont->getName()) {
-				MoveCard_ToZone m;
-				m.set_card_name(cardList[i]->getName().toStdString());
-				m.set_start_zone(cardList[i]->getOriginZone().toStdString());
-				m.set_target_zone(cont->getName().toStdString());
-				result.append(m);
-			}
-	}
-	return result;
+    QList<MoveCard_ToZone> result;
+    QMapIterator<QString, DeckViewCardContainer *> containerIterator(cardContainers);
+    while (containerIterator.hasNext()) {
+        DeckViewCardContainer *cont = containerIterator.next().value();
+        const QList<DeckViewCard *> cardList = cont->getCards();
+        for (int i = 0; i < cardList.size(); ++i)
+            if (cardList[i]->getOriginZone() != cont->getName()) {
+                MoveCard_ToZone m;
+                m.set_card_name(cardList[i]->getName().toStdString());
+                m.set_start_zone(cardList[i]->getOriginZone().toStdString());
+                m.set_target_zone(cont->getName().toStdString());
+                result.append(m);
+            }
+    }
+    return result;
 }
 
 void DeckViewScene::resetSideboardPlan()
 {
-	rebuildTree();
-	rearrangeItems();
+    rebuildTree();
+    rearrangeItems();
 }
 
 DeckView::DeckView(QWidget *parent)
-	: QGraphicsView(parent)
+    : QGraphicsView(parent)
 {
-	deckViewScene = new DeckViewScene(this);
-	
-	setBackgroundBrush(QBrush(QColor(0, 0, 0)));
-	setDragMode(RubberBandDrag);
-	setRenderHints(QPainter::TextAntialiasing | QPainter::Antialiasing/* | QPainter::SmoothPixmapTransform*/);
-	setScene(deckViewScene);
+    deckViewScene = new DeckViewScene(this);
+    
+    setBackgroundBrush(QBrush(QColor(0, 0, 0)));
+    setDragMode(RubberBandDrag);
+    setRenderHints(QPainter::TextAntialiasing | QPainter::Antialiasing/* | QPainter::SmoothPixmapTransform*/);
+    setScene(deckViewScene);
 
-	connect(deckViewScene, SIGNAL(sceneRectChanged(const QRectF &)), this, SLOT(updateSceneRect(const QRectF &)));
-	connect(deckViewScene, SIGNAL(newCardAdded(AbstractCardItem *)), this, SIGNAL(newCardAdded(AbstractCardItem *)));
-	connect(deckViewScene, SIGNAL(sideboardPlanChanged()), this, SIGNAL(sideboardPlanChanged()));
+    connect(deckViewScene, SIGNAL(sceneRectChanged(const QRectF &)), this, SLOT(updateSceneRect(const QRectF &)));
+    connect(deckViewScene, SIGNAL(newCardAdded(AbstractCardItem *)), this, SIGNAL(newCardAdded(AbstractCardItem *)));
+    connect(deckViewScene, SIGNAL(sideboardPlanChanged()), this, SIGNAL(sideboardPlanChanged()));
 }
 
 void DeckView::resizeEvent(QResizeEvent *event)
 {
-	QGraphicsView::resizeEvent(event);
-	deckViewScene->setOptimalAspectRatio((qreal) width() / (qreal) height());
-	deckViewScene->rearrangeItems();
+    QGraphicsView::resizeEvent(event);
+    deckViewScene->setOptimalAspectRatio((qreal) width() / (qreal) height());
+    deckViewScene->rearrangeItems();
 }
 
 void DeckView::updateSceneRect(const QRectF &rect)
 {
-	fitInView(rect, Qt::KeepAspectRatio);
+    fitInView(rect, Qt::KeepAspectRatio);
 }
 
 void DeckView::setDeck(const DeckList &_deck)
 {
-	deckViewScene->setDeck(_deck);
+    deckViewScene->setDeck(_deck);
 }
 
 void DeckView::resetSideboardPlan()
 {
-	deckViewScene->resetSideboardPlan();
+    deckViewScene->resetSideboardPlan();
 }

cockatrice/src/deckview.h

@@ -19,101 +19,101 @@ class MoveCardToZone;
 
 class DeckViewCard : public AbstractCardItem {
 private:
-	QString originZone;
-	DeckViewCardDragItem *dragItem;
+    QString originZone;
+    DeckViewCardDragItem *dragItem;
 public:
-	DeckViewCard(const QString &_name = QString(), const QString &_originZone = QString(), QGraphicsItem *parent = 0);
-	~DeckViewCard();
-	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
-	const QString &getOriginZone() const { return originZone; }
+    DeckViewCard(const QString &_name = QString(), const QString &_originZone = QString(), QGraphicsItem *parent = 0);
+    ~DeckViewCard();
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+    const QString &getOriginZone() const { return originZone; }
 protected:
-	void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
-	void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
+    void mouseMoveEvent(QGraphicsSceneMouseEvent *event);
+    void hoverEnterEvent(QGraphicsSceneHoverEvent *event);
 };
 
 class DeckViewCardDragItem : public AbstractCardDragItem {
 private:
-	DeckViewCardContainer *currentZone;
-	void handleDrop(DeckViewCardContainer *target);
+    DeckViewCardContainer *currentZone;
+    void handleDrop(DeckViewCardContainer *target);
 public:
-	DeckViewCardDragItem(DeckViewCard *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag = 0);
-	void updatePosition(const QPointF &cursorScenePos);
+    DeckViewCardDragItem(DeckViewCard *_item, const QPointF &_hotSpot, AbstractCardDragItem *parentDrag = 0);
+    void updatePosition(const QPointF &cursorScenePos);
 protected:
-	void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
+    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
 };
 
 class DeckViewCardContainer : public QGraphicsItem {
 private:
-	static const int separatorY = 20;
-	static const int paddingY = 10;
-	
-	QString name;
-	QList<DeckViewCard *> cards;
-	QMultiMap<QString, DeckViewCard *> cardsByType;
-	QList<QPair<int, int> > currentRowsAndCols;
-	qreal width, height;
-	QPixmap bgPixmap;
-	int getCardTypeTextWidth() const;
+    static const int separatorY = 20;
+    static const int paddingY = 10;
+    
+    QString name;
+    QList<DeckViewCard *> cards;
+    QMultiMap<QString, DeckViewCard *> cardsByType;
+    QList<QPair<int, int> > currentRowsAndCols;
+    qreal width, height;
+    QPixmap bgPixmap;
+    int getCardTypeTextWidth() const;
 public:
-	enum { Type = typeDeckViewCardContainer };
-	int type() const { return Type; }
-	DeckViewCardContainer(const QString &_name);
-	QRectF boundingRect() const;
-	void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
-	void addCard(DeckViewCard *card);
-	void removeCard(DeckViewCard *card);
-	const QList<DeckViewCard *> &getCards() const { return cards; }
-	const QString &getName() const { return name; }
-	void setWidth(qreal _width);
+    enum { Type = typeDeckViewCardContainer };
+    int type() const { return Type; }
+    DeckViewCardContainer(const QString &_name);
+    QRectF boundingRect() const;
+    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
+    void addCard(DeckViewCard *card);
+    void removeCard(DeckViewCard *card);
+    const QList<DeckViewCard *> &getCards() const { return cards; }
+    const QString &getName() const { return name; }
+    void setWidth(qreal _width);
 
-	QList<QPair<int, int> > getRowsAndCols() const;
-	QSizeF calculateBoundingRect(const QList<QPair<int, int> > &rowsAndCols) const;
-	void rearrangeItems(const QList<QPair<int, int> > &rowsAndCols);
+    QList<QPair<int, int> > getRowsAndCols() const;
+    QSizeF calculateBoundingRect(const QList<QPair<int, int> > &rowsAndCols) const;
+    void rearrangeItems(const QList<QPair<int, int> > &rowsAndCols);
 };
 
 class DeckViewScene : public QGraphicsScene {
-	Q_OBJECT
+    Q_OBJECT
 signals:
-	void newCardAdded(AbstractCardItem *card);
-	void sideboardPlanChanged();
+    void newCardAdded(AbstractCardItem *card);
+    void sideboardPlanChanged();
 private:
-	bool locked;
-	DeckList *deck;
-	QMap<QString, DeckViewCardContainer *> cardContainers;
-	qreal optimalAspectRatio;
-	void clearContents();
-	void rebuildTree();
-	void applySideboardPlan(const QList<MoveCard_ToZone> &plan);
+    bool locked;
+    DeckList *deck;
+    QMap<QString, DeckViewCardContainer *> cardContainers;
+    qreal optimalAspectRatio;
+    void clearContents();
+    void rebuildTree();
+    void applySideboardPlan(const QList<MoveCard_ToZone> &plan);
 public:
-	DeckViewScene(QObject *parent = 0);
-	~DeckViewScene();
-	void setLocked(bool _locked) { locked = _locked; }
-	bool getLocked() const { return locked; }
-	void setDeck(const DeckList &_deck);
-	void setOptimalAspectRatio(qreal _optimalAspectRatio) { optimalAspectRatio = _optimalAspectRatio; }
-	void rearrangeItems();
-	void updateContents();
-	QList<MoveCard_ToZone> getSideboardPlan() const;
-	void resetSideboardPlan();
+    DeckViewScene(QObject *parent = 0);
+    ~DeckViewScene();
+    void setLocked(bool _locked) { locked = _locked; }
+    bool getLocked() const { return locked; }
+    void setDeck(const DeckList &_deck);
+    void setOptimalAspectRatio(qreal _optimalAspectRatio) { optimalAspectRatio = _optimalAspectRatio; }
+    void rearrangeItems();
+    void updateContents();
+    QList<MoveCard_ToZone> getSideboardPlan() const;
+    void resetSideboardPlan();
 };
 
 class DeckView : public QGraphicsView {
-	Q_OBJECT
+    Q_OBJECT
 private:
-	DeckViewScene *deckViewScene;
+    DeckViewScene *deckViewScene;
 protected:
-	void resizeEvent(QResizeEvent *event);
+    void resizeEvent(QResizeEvent *event);
 public slots:
-	void updateSceneRect(const QRectF &rect);
+    void updateSceneRect(const QRectF &rect);
 signals:
-	void newCardAdded(AbstractCardItem *card);
-	void sideboardPlanChanged();
+    void newCardAdded(AbstractCardItem *card);
+    void sideboardPlanChanged();
 public:
-	DeckView(QWidget *parent = 0);
-	void setDeck(const DeckList &_deck);
-	void setLocked(bool _locked) { deckViewScene->setLocked(_locked); }
-	QList<MoveCard_ToZone> getSideboardPlan() const { return deckViewScene->getSideboardPlan(); }
-	void resetSideboardPlan();
+    DeckView(QWidget *parent = 0);
+    void setDeck(const DeckList &_deck);
+    void setLocked(bool _locked) { deckViewScene->setLocked(_locked); }
+    QList<MoveCard_ToZone> getSideboardPlan() const { return deckViewScene->getSideboardPlan(); }
+    void resetSideboardPlan();
 };
 
 #endif

cockatrice/src/dlg_cardsearch.cpp

@@ -10,86 +10,86 @@
 #include "main.h"
 
 DlgCardSearch::DlgCardSearch(QWidget *parent)
-	: QDialog(parent)
+    : QDialog(parent)
 {
-	QLabel *cardNameLabel = new QLabel(tr("Card name:"));
-	cardNameEdit = new QLineEdit;
-	
-	QLabel *cardTextLabel = new QLabel(tr("Card text:"));
-	cardTextEdit = new QLineEdit;
-	
-	QLabel *cardTypesLabel = new QLabel(tr("Card type (OR):"));
-	const QStringList &cardTypes = db->getAllMainCardTypes();
-	QVBoxLayout *cardTypesLayout = new QVBoxLayout;
-	for (int i = 0; i < cardTypes.size(); ++i) {
-		QCheckBox *cardTypeCheckBox = new QCheckBox(cardTypes[i]);
-		cardTypeCheckBox->setChecked(true);
-		cardTypeCheckBoxes.append(cardTypeCheckBox);
-		cardTypesLayout->addWidget(cardTypeCheckBox);
-	}
-	
-	QLabel *cardColorsLabel = new QLabel(tr("Color (OR):"));
-	const QStringList &cardColors = db->getAllColors();
-	QHBoxLayout *cardColorsLayout = new QHBoxLayout;
-	for (int i = 0; i < cardColors.size(); ++i) {
-		QCheckBox *cardColorCheckBox = new QCheckBox(cardColors[i]);
-		cardColorCheckBox->setChecked(true);
-		cardColorCheckBoxes.append(cardColorCheckBox);
-		cardColorsLayout->addWidget(cardColorCheckBox);
-	}
-	
-	QPushButton *okButton = new QPushButton(tr("O&K"));
-	okButton->setDefault(true);
-	okButton->setAutoDefault(true);
-	QPushButton *cancelButton = new QPushButton(tr("&Cancel"));
-	connect(okButton, SIGNAL(clicked()), this, SLOT(accept()));
-	connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
-	QHBoxLayout *buttonHBox = new QHBoxLayout;
-	buttonHBox->addStretch();
-	buttonHBox->addWidget(okButton);
-	buttonHBox->addWidget(cancelButton);
-	
-	QGridLayout *optionsLayout = new QGridLayout;
-	optionsLayout->addWidget(cardNameLabel, 0, 0);
-	optionsLayout->addWidget(cardNameEdit, 0, 1);
-	optionsLayout->addWidget(cardTextLabel, 1, 0);
-	optionsLayout->addWidget(cardTextEdit, 1, 1);
-	optionsLayout->addWidget(cardTypesLabel, 2, 0);
-	optionsLayout->addLayout(cardTypesLayout, 2, 1);
-	optionsLayout->addWidget(cardColorsLabel, 3, 0);
-	optionsLayout->addLayout(cardColorsLayout, 3, 1);
-	
-	QVBoxLayout *mainLayout = new QVBoxLayout;
-	mainLayout->addLayout(optionsLayout);
-	mainLayout->addLayout(buttonHBox);
-	setLayout(mainLayout);
-	setWindowTitle(tr("Card search"));
+    QLabel *cardNameLabel = new QLabel(tr("Card name:"));
+    cardNameEdit = new QLineEdit;
+    
+    QLabel *cardTextLabel = new QLabel(tr("Card text:"));
+    cardTextEdit = new QLineEdit;
+    
+    QLabel *cardTypesLabel = new QLabel(tr("Card type (OR):"));
+    const QStringList &cardTypes = db->getAllMainCardTypes();
+    QVBoxLayout *cardTypesLayout = new QVBoxLayout;
+    for (int i = 0; i < cardTypes.size(); ++i) {
+        QCheckBox *cardTypeCheckBox = new QCheckBox(cardTypes[i]);
+        cardTypeCheckBox->setChecked(true);
+        cardTypeCheckBoxes.append(cardTypeCheckBox);
+        cardTypesLayout->addWidget(cardTypeCheckBox);
+    }
+    
+    QLabel *cardColorsLabel = new QLabel(tr("Color (OR):"));
+    const QStringList &cardColors = db->getAllColors();
+    QHBoxLayout *cardColorsLayout = new QHBoxLayout;
+    for (int i = 0; i < cardColors.size(); ++i) {
+        QCheckBox *cardColorCheckBox = new QCheckBox(cardColors[i]);
+        cardColorCheckBox->setChecked(true);
+        cardColorCheckBoxes.append(cardColorCheckBox);
+        cardColorsLayout->addWidget(cardColorCheckBox);
+    }
+    
+    QPushButton *okButton = new QPushButton(tr("O&K"));
+    okButton->setDefault(true);
+    okButton->setAutoDefault(true);
+    QPushButton *cancelButton = new QPushButton(tr("&Cancel"));
+    connect(okButton, SIGNAL(clicked()), this, SLOT(accept()));
+    connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
+    QHBoxLayout *buttonHBox = new QHBoxLayout;
+    buttonHBox->addStretch();
+    buttonHBox->addWidget(okButton);
+    buttonHBox->addWidget(cancelButton);
+    
+    QGridLayout *optionsLayout = new QGridLayout;
+    optionsLayout->addWidget(cardNameLabel, 0, 0);
+    optionsLayout->addWidget(cardNameEdit, 0, 1);
+    optionsLayout->addWidget(cardTextLabel, 1, 0);
+    optionsLayout->addWidget(cardTextEdit, 1, 1);
+    optionsLayout->addWidget(cardTypesLabel, 2, 0);
+    optionsLayout->addLayout(cardTypesLayout, 2, 1);
+    optionsLayout->addWidget(cardColorsLabel, 3, 0);
+    optionsLayout->addLayout(cardColorsLayout, 3, 1);
+    
+    QVBoxLayout *mainLayout = new QVBoxLayout;
+    mainLayout->addLayout(optionsLayout);
+    mainLayout->addLayout(buttonHBox);
+    setLayout(mainLayout);
+    setWindowTitle(tr("Card search"));
 }
 
 QString DlgCardSearch::getCardName() const
 {
-	return cardNameEdit->text();
+    return cardNameEdit->text();
 }
 
 QString DlgCardSearch::getCardText() const
 {
-	return cardTextEdit->text();
+    return cardTextEdit->text();
 }
 
 QSet<QString> DlgCardSearch::getCardTypes() const
 {
-	QStringList result;
-	for (int i = 0; i < cardTypeCheckBoxes.size(); ++i)
-		if (cardTypeCheckBoxes[i]->isChecked())
-			result.append(cardTypeCheckBoxes[i]->text());
-	return QSet<QString>::fromList(result);
+    QStringList result;
+    for (int i = 0; i < cardTypeCheckBoxes.size(); ++i)
+        if (cardTypeCheckBoxes[i]->isChecked())
+            result.append(cardTypeCheckBoxes[i]->text());
+    return QSet<QString>::fromList(result);
 }
 
 QSet<QString> DlgCardSearch::getCardColors() const
 {
-	QStringList result;
-	for (int i = 0; i < cardColorCheckBoxes.size(); ++i)
-		if (cardColorCheckBoxes[i]->isChecked())
-			result.append(cardColorCheckBoxes[i]->text());
-	return QSet<QString>::fromList(result);
+    QStringList result;
+    for (int i = 0; i < cardColorCheckBoxes.size(); ++i)
+        if (cardColorCheckBoxes[i]->isChecked())
+            result.append(cardColorCheckBoxes[i]->text());
+    return QSet<QString>::fromList(result);
 }

cockatrice/src/dlg_cardsearch.h

@@ -9,16 +9,16 @@ class QLineEdit;
 class QCheckBox;
 
 class DlgCardSearch : public QDialog {
-	Q_OBJECT
+    Q_OBJECT
 private:
-	QLineEdit *cardNameEdit, *cardTextEdit;
-	QList<QCheckBox *> cardTypeCheckBoxes, cardColorCheckBoxes;
+    QLineEdit *cardNameEdit, *cardTextEdit;
+    QList<QCheckBox *> cardTypeCheckBoxes, cardColorCheckBoxes;
 public:
-	DlgCardSearch(QWidget *parent = 0);
-	QString getCardName() const;
-	QString getCardText() const;
-	QSet<QString> getCardTypes() const;
-	QSet<QString> getCardColors() const;
+    DlgCardSearch(QWidget *parent = 0);
+    QString getCardName() const;
+    QString getCardText() const;
+    QSet<QString> getCardTypes() const;
+    QSet<QString> getCardColors() const;
 };
 
 #endif