[VisualDatabase] Draw the card grid with a model/view (#7701)

* [VisualDatabase] Draw the card grid with a model/view instead of a widget per card

The visual card database built one CardInfoPictureWithTextOverlayWidget per
card, 100 per page, and tore them down on every search, resize and scroll
page. It also looked each card up again by name from the model row, kept a
shadow QList<ExactCard>, and carried paging state plus a 5 s timer that only
existed to defer the first page.

Replace that with a real view on a flattened model:

- CardDatabaseDisplayModel gains CardInfoRole and cardInfoAt(), so a view can
  get the CardInfoPtr behind a proxy row without a name round trip.
- New CardDatabaseVisualDisplayModel (libcockatrice_models) flattens the
  filtered and sorted proxy into one entry per displayed card picture: the
  preferred printing normally, every printing of the selected sets while set
  filters are active. Proxy changes rebuild it on a 30 ms coalescing timer.
- New CardDatabaseVisualView (QListView IconMode) paints only visible rows
  through the new CardPictureDelegate, keeps the old interaction contract
  (left/right/middle press -> cardClicked, hover -> cardHovered, Ctrl+wheel
  resize, no selection, no focus stealing, scroll to top on a new result) and
  repaints when CardPictureLoader reports an async image.
- CardSizeWidget::enableCtrlScrollResize() also watches scroll-area viewports,
  which is what makes Ctrl+wheel work over a QListView.
- VisualDatabaseDisplayWidget drops the paging, the shadow list, the dead
  members and the 5 s timer.

Behaviour-preserving: no gameplay change, no new user-facing strings.

* [VisualDatabase] Fix the card grid wheel step

QListView hands the delegate's item height to the scroll bar as its single step under ScrollPerPixel, so QAbstractSlider moved wheelScrollLines() whole card rows per notch. Handle the wheel in the view instead: one line is an eighth of the grid cell, so a notch moves about a third of a card row at any card size and still follows the OS line count.

---------

Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>

cockatrice/src/interface/widgets/cards/card_info_picture_widget.cpp

@@ -43,11 +43,6 @@
 #include <qlogging.h>
 #include <qnamespace.h>
 
-static constexpr qreal MTG_CARD_ASPECT_RATIO = 1.396;
-// static constexpr qreal YUGIOH_CARD_ASPECT_RATIO = 1.457;
-static constexpr qreal ASPECT_RATIO = MTG_CARD_ASPECT_RATIO;
-
-static constexpr int BASE_WIDTH = 200;
 static constexpr int BASE_HEIGHT = 200;
 
 static constexpr int ENLARGED_PIXMAP_OFFSET = 10;
@@ -162,12 +157,11 @@ void CardInfoPictureWidget::resizeEvent(QResizeEvent *event)
  */
 void CardInfoPictureWidget::setScaleFactor(const int scale)
 {
-    const int newWidth = BASE_WIDTH * scale / 100;
-    const int newHeight = static_cast<int>(newWidth * ASPECT_RATIO);
+    const QSize newSize = sizeForScaleFactor(scale);
 
     scaleFactor = scale;
 
-    setFixedSize(newWidth, newHeight);
+    setFixedSize(newSize);
     updatePixmap();
 
     emit cardScaleFactorChanged(scale);
@@ -266,8 +260,13 @@ void CardInfoPictureWidget::paintEvent(QPaintEvent *event)
  */
 QSize CardInfoPictureWidget::sizeHint() const
 {
-    return {static_cast<int>(BASE_WIDTH * scaleFactor / 100.0),
-            static_cast<int>(BASE_WIDTH * scaleFactor / 100.0 * ASPECT_RATIO)};
+    return sizeForScaleFactor(scaleFactor);
+}
+
+QSize CardInfoPictureWidget::sizeForScaleFactor(int scaleFactor)
+{
+    const int width = BASE_WIDTH * scaleFactor / 100;
+    return {width, static_cast<int>(width * ASPECT_RATIO)};
 }
 
 /**

cockatrice/src/interface/widgets/cards/card_info_picture_widget.h

@@ -28,6 +28,11 @@ class CardInfoPictureWidget : public QWidget
     Q_OBJECT
 
 public:
+    /// Width of a card picture at 100 % scale, in pixels.
+    static constexpr int BASE_WIDTH = 200;
+    /// Height / width of a card picture.
+    static constexpr qreal ASPECT_RATIO = 1.396;
+
     explicit CardInfoPictureWidget(QWidget *parent = nullptr,
                                    bool hoverToZoomEnabled = false,
                                    bool raiseOnEnter = false);
@@ -37,6 +42,12 @@ public:
     }
     [[nodiscard]] QSize sizeHint() const override;
 
+    /**
+     * @brief The size a card picture has at @p scaleFactor percent.
+     * @param scaleFactor Percentage of BASE_WIDTH, as set by the card size slider.
+     */
+    [[nodiscard]] static QSize sizeForScaleFactor(int scaleFactor);
+
 public slots:
     void setCard(const ExactCard &card);
     void setScaleFactor(int scale); // New slot for scaling

cockatrice/src/interface/widgets/cards/card_picture_delegate.cpp

@@ -0,0 +1,83 @@
+#include "card_picture_delegate.h"
+
+#include "../../../client/settings/cache_settings.h"
+#include "../../card_picture_loader/card_picture_loader.h"
+#include "card_art_utils.h"
+#include "card_database_visual_display_model.h"
+#include "libcockatrice/card/printing/exact_card.h"
+#include "libcockatrice/settings/cards_display_settings.h"
+
+#include <QPainter>
+#include <QPainterPath>
+#include <QPixmap>
+#include <QRect>
+#include <QStyleOptionViewItem>
+#include <libcockatrice/card/printing/printing_info.h>
+
+CardPictureDelegate::CardPictureDelegate(CardDatabaseVisualDisplayModel *_model, QObject *parent)
+    : QStyledItemDelegate(parent), model(_model)
+{
+}
+
+void CardPictureDelegate::setCardSize(const QSize &size)
+{
+    if (cardSize == size) {
+        return;
+    }
+
+    cardSize = size;
+}
+
+void CardPictureDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+    if (model == nullptr) {
+        return;
+    }
+
+    const ExactCard card = model->cardAt(index.row());
+    if (!card) {
+        return;
+    }
+
+    // The grid cell is the card plus SPACING; give the picture the rest.
+    const int inset = SPACING / 2;
+    const QRect cardArea = option.rect.adjusted(inset, inset, -inset, -inset);
+
+    QPixmap pixmap;
+    CardPictureLoader::getCardBackLoadingInProgressPixmap(pixmap, cardArea.size());
+    CardPictureLoader::getPixmap(pixmap, card, cardArea.size());
+
+    if (pixmap.isNull()) {
+        return;
+    }
+
+    if (SettingsCache::instance().cardsDisplay().getAutoRotateSidewaysLayoutCards()) {
+        pixmap = CardArtUtils::rotateSidewaysLayoutArt(pixmap, card);
+    }
+
+    // Fit the picture into the cell and center it, like CardInfoPictureWidget does.
+    const QSize pictureSize = pixmap.deviceIndependentSize().toSize().scaled(cardArea.size(), Qt::KeepAspectRatio);
+    const QRect pictureRect(cardArea.center().x() - pictureSize.width() / 2,
+                            cardArea.center().y() - pictureSize.height() / 2, pictureSize.width(),
+                            pictureSize.height());
+
+    const qreal radius = SettingsCache::instance().cardsDisplay().getRoundCardCorners()
+                             ? 0.05 * static_cast<qreal>(pictureRect.width())
+                             : 0.0;
+
+    painter->save();
+    painter->setRenderHint(QPainter::Antialiasing);
+    painter->setRenderHint(QPainter::SmoothPixmapTransform);
+    QPainterPath shape;
+    shape.addRoundedRect(pictureRect, radius, radius);
+    painter->setClipPath(shape);
+    // Source rect is in device pixels, target in logical ones: drawPixmap scales
+    // between them without the device pixel ratio being applied twice.
+    painter->drawPixmap(pictureRect, pixmap, QRectF(pixmap.rect()));
+    painter->restore();
+}
+
+QSize CardPictureDelegate::sizeHint(const QStyleOptionViewItem & /*option*/, const QModelIndex & /*index*/) const
+{
+    return cardSize + QSize(SPACING, SPACING);
+}

cockatrice/src/interface/widgets/cards/card_picture_delegate.h

@@ -0,0 +1,45 @@
+/**
+ * @file card_picture_delegate.h
+ * @ingroup CardWidgets
+ * @brief Paints a card picture for a visual card grid item.
+ */
+
+#ifndef CARD_PICTURE_DELEGATE_H
+#define CARD_PICTURE_DELEGATE_H
+
+#include <QSize>
+#include <QStyledItemDelegate>
+#include <qtmetamacros.h>
+
+class CardDatabaseVisualDisplayModel;
+
+/**
+ * @brief Draws the card of a CardDatabaseVisualDisplayModel row as a picture.
+ *
+ * The delegate only paints rows the view asks for, so a grid of the whole card
+ * database stays cheap: no widget per card and no pixmap loaded for items that
+ * are off screen. Card images come from CardPictureLoader, which caches them and
+ * loads missing ones asynchronously.
+ */
+class CardPictureDelegate : public QStyledItemDelegate
+{
+    Q_OBJECT
+
+public:
+    /// Gap left around a card picture inside its grid cell, in pixels.
+    static constexpr int SPACING = 4;
+
+    explicit CardPictureDelegate(CardDatabaseVisualDisplayModel *_model, QObject *parent = nullptr);
+
+    /// The picture size inside a grid cell. The cell is this size plus SPACING.
+    void setCardSize(const QSize &size);
+
+    void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
+    [[nodiscard]] QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override;
+
+private:
+    CardDatabaseVisualDisplayModel *model;
+    QSize cardSize;
+};
+
+#endif // CARD_PICTURE_DELEGATE_H

cockatrice/src/interface/widgets/cards/card_size_widget.cpp

@@ -2,6 +2,7 @@
 
 #include "../general/layout_containers/flow_widget.h"
 
+#include <QAbstractScrollArea>
 #include <QEvent>
 #include <QFlags>
 #include <QHBoxLayout>
@@ -33,8 +34,8 @@ CardSizeWidget::CardSizeWidget(QWidget *parent, FlowWidget *_flowWidget, int def
     cardSizeLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
 
     cardSizeSlider = new QSlider(Qt::Horizontal, this);
-    cardSizeSlider->setRange(50, 250);      ///< Slider range for card size adjustment.
-    cardSizeSlider->setValue(defaultValue); ///< Initial slider value.
+    cardSizeSlider->setRange(MIN_CARD_SIZE, MAX_CARD_SIZE); ///< Slider range for card size adjustment.
+    cardSizeSlider->setValue(defaultValue);                 ///< Initial slider value.
 
     cardSizeLayout->addWidget(cardSizeLabel);
     cardSizeLayout->addWidget(cardSizeSlider);
@@ -73,13 +74,26 @@ QSlider *CardSizeWidget::getSlider() const
 
 void CardSizeWidget::enableCtrlScrollResize(QWidget *host)
 {
-    host->installEventFilter(this);
-
-    const auto scrollAreas = host->findChildren<QScrollArea *>();
-    for (QScrollArea *scrollArea : scrollAreas) {
-        if (QWidget *content = scrollArea->widget()) {
-            content->installEventFilter(this);
+    const auto watchScrollArea = [this](QAbstractScrollArea *scrollArea) {
+        if (scrollArea == nullptr) {
+            return;
         }
+        if (QWidget *viewport = scrollArea->viewport()) {
+            viewport->installEventFilter(this);
+        }
+        if (auto *contentScrollArea = qobject_cast<QScrollArea *>(scrollArea)) {
+            if (QWidget *content = contentScrollArea->widget()) {
+                content->installEventFilter(this);
+            }
+        }
+    };
+
+    host->installEventFilter(this);
+    watchScrollArea(qobject_cast<QAbstractScrollArea *>(host));
+
+    const auto scrollAreas = host->findChildren<QAbstractScrollArea *>();
+    for (QAbstractScrollArea *scrollArea : scrollAreas) {
+        watchScrollArea(scrollArea);
     }
 }
 

cockatrice/src/interface/widgets/cards/card_size_widget.h

@@ -24,6 +24,10 @@ class CardSizeWidget : public QWidget
     Q_OBJECT
 
 public:
+    /// Range of the card size slider, as a percentage of the base card width.
+    static constexpr int MIN_CARD_SIZE = 50;
+    static constexpr int MAX_CARD_SIZE = 250;
+
     explicit CardSizeWidget(QWidget *parent, FlowWidget *flowWidget = nullptr, int defaultValue = 100);
     [[nodiscard]] QSlider *getSlider() const;
 
@@ -31,8 +35,9 @@ public:
      * @brief Resizes the cards when the user Ctrl + scrolls over @p host or any of its descendants.
      *
      * Installs this widget as an event filter on the given host widget. If the host contains a
-     * scroll area the filter is also installed on the scroll area's content widget, so the resize
-     * intercepts the wheel event before the scroll area would scroll the view.
+     * scroll area the filter is also installed on the scroll area's content widget, and on the
+     * viewport of every scroll area base (QListView, QTableView, ...), so the resize intercepts
+     * the wheel event before the scroll area would scroll the view.
      */
     void enableCtrlScrollResize(QWidget *host);