// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include <QMainWindow>
#include <QMenuBar>
#include <QLabel>
#include <QHBoxLayout>
#include <QFormLayout>
#include <QApplication>
#include <QAction>
#include <QStyle>
#include <QToolBar>
#include <QPushButton>
#include <QButtonGroup>
#include <QLineEdit>
#include <QPlainTextEdit>
#include <QTabWidget>
#include <QScrollBar>
#include <QSlider>
#include <QSpinBox>
#include <QTabBar>
#include <QTextBrowser>
#include <QIcon>
#include <QPainter>
#include <QWindow>
#include <QScreen>
#include <QGraphicsView>
#include <QGraphicsTextItem>
#include <QFile>
#include <QFontMetrics>
#include <QMouseEvent>
#include <QTemporaryDir>
#include <QTimer>
#include <QCommandLineParser>
#include <QCommandLineOption>
#include <QDebug>
#include <QElapsedTimer>
#include <private/qhighdpiscaling_p.h>
#include <qpa/qplatformscreen.h>

#include "dragwidget.h"

#include <utility>

static QTextStream &operator<<(QTextStream &str, const QSizeF &s)
{
    str << s.width() << 'x' << s.height();
    return str;
}

static QTextStream &operator<<(QTextStream &str, const QRect &r)
{
    str << r.width() << 'x' << r.height() << Qt::forcesign << r.x() << r.y() << Qt::noforcesign;
    return str;
}

static QString formatWindowTitle(const QString &title)
{
    QString result;
    QTextStream(&result) << title << ' ' << QT_VERSION_STR << " ("
        << QGuiApplication::platformName()
        << '/' << QApplication::style()->objectName() << ')';
    return result;
}

class DemoContainerBase
{
public:
    DemoContainerBase() = default;
    virtual ~DemoContainerBase() = default;
    QString name() { return option().names().constFirst(); }
    virtual QCommandLineOption &option() = 0;
    virtual void makeVisible(bool visible, QWidget *parent) = 0;
    QWidget *widget() const { return m_widget; }

protected:
    QWidget *m_widget = nullptr;
};

using DemoContainerList = QList<DemoContainerBase*>;

template <class T>
class DemoContainer : public DemoContainerBase
{
public:
    DemoContainer(const QString &optionName, const QString &description)
        : m_option(optionName, description)
    {
    }
    ~DemoContainer() { delete m_widget; }

    QCommandLineOption &option() override { return m_option; }

    void makeVisible(bool visible, QWidget *parent) override
    {
        if (visible && !m_widget) {
            m_widget = new T;
            if (m_widget->windowTitle().isEmpty()) {
                QString title = m_option.description();
                if (title.startsWith("Test ", Qt::CaseInsensitive))
                    title.remove(0, 5);
                title[0] = title.at(0).toUpper();
                m_widget->setWindowTitle(formatWindowTitle(title));
            }
            m_widget->installEventFilter(parent);
        }
        if (m_widget)
            m_widget->setVisible(visible);
    }

private:
    QCommandLineOption m_option;
};

class LabelSlider : public QObject
{
Q_OBJECT
public:
    LabelSlider(QObject *parent, const QString &text, QGridLayout *layout, int row)
        : QObject(parent)
    {
        QLabel *textLabel = new QLabel(text);
        m_slider = new QSlider();
        m_slider->setOrientation(Qt::Horizontal);
        m_slider->setMinimum(1);
        m_slider->setMaximum(40);
        m_slider->setValue(10);
        m_slider->setTracking(false);
        m_slider->setTickInterval(5);
        m_slider->setTickPosition(QSlider::TicksBelow);
        m_label = new QLabel("1.0");

        // set up layouts
        layout->addWidget(textLabel, row, 0);
        layout->addWidget(m_slider, row, 1);
        layout->addWidget(m_label, row, 2);

        // handle slider position change
        connect(m_slider, &QSlider::sliderMoved, this, &LabelSlider::updateLabel);
        connect(m_slider, &QSlider::valueChanged, this, &LabelSlider::valueChanged);
    }
    void setValue(int scaleFactor)
    {
        m_slider->setValue(scaleFactor);
        updateLabel(scaleFactor);
    }

private slots:
    void updateLabel(int scaleFactor)
    {
            // slider value is scale factor times ten;
            qreal scalefactorF = qreal(scaleFactor) / 10.0;

            // update label, add ".0" if needed.
            QString number = QString::number(scalefactorF);
            if (!number.contains(QLatin1Char('.')))
                number.append(".0");
            m_label->setText(number);
    }

signals:
    void valueChanged(int scaleFactor);

private:
    QSlider *m_slider;
    QLabel *m_label;
};

static qreal getScreenFactorWithoutPixelDensity(const QScreen *screen)
{
    // this is a hack that relies on knowing the internals of QHighDpiScaling
    static const char *scaleFactorProperty = "_q_scaleFactor";
    QVariant screenFactor = screen->property(scaleFactorProperty);
    return screenFactor.isValid() ? screenFactor.toReal() : 1.0;
}

static inline qreal getGlobalScaleFactor()
{
    QScreen *noScreen = nullptr;
    return QHighDpiScaling::factor(noScreen);
}

class DemoController : public QWidget
{
    Q_OBJECT
public:
    DemoController(DemoContainerList demos, QCommandLineParser *parser);
    ~DemoController();

protected:
    bool eventFilter(QObject *object, QEvent *event) override;
    void closeEvent(QCloseEvent *) override { QCoreApplication::quit(); }

private slots:
    void handleButton(int id, bool toggled);

private:
    DemoContainerList m_demos;
    QButtonGroup *m_group;
};

DemoController::DemoController(DemoContainerList demos, QCommandLineParser *parser)
    : m_demos(std::move(demos))
{
    setWindowTitle(formatWindowTitle("Screen Scale Factors"));
    setObjectName("controller"); // make WindowScaleFactorSetter skip this window

    auto mainLayout = new QVBoxLayout(this);
    auto scaleLayout = new QGridLayout;
    mainLayout->addLayout(scaleLayout);

    int layoutRow = 0;
    LabelSlider *globalScaleSlider = new LabelSlider(this, "Global scale factor", scaleLayout, layoutRow++);
    globalScaleSlider->setValue(int(getGlobalScaleFactor() * 10));
     connect(globalScaleSlider, &LabelSlider::valueChanged, [](int scaleFactor){
            // slider value is scale factor times ten;
            qreal scalefactorF = qreal(scaleFactor) / 10.0;
            QHighDpiScaling::setGlobalFactor(scalefactorF);
         });

    // set up one scale control line per screen
    const auto screens = QGuiApplication::screens();
    for (QScreen *screen : screens) {
        // create scale control line
        QSize screenSize = screen->geometry().size();
        QString screenId = screen->name() + QLatin1Char(' ') + QString::number(screenSize.width())
                                          + QLatin1Char(' ') + QString::number(screenSize.height());
        LabelSlider *slider = new LabelSlider(this, screenId, scaleLayout, layoutRow++);
        slider->setValue(getScreenFactorWithoutPixelDensity(screen) * 10);

        // handle slider value change
        connect(slider, &LabelSlider::valueChanged, [screen](int scaleFactor){
            // slider value is scale factor times ten;
            qreal scalefactorF = qreal(scaleFactor) / 10.0;

            // set scale factor for screen
            qreal oldFactor = QHighDpiScaling::factor(screen);
            QHighDpiScaling::setScreenFactor(screen, scalefactorF);
            qreal newFactor = QHighDpiScaling::factor(screen);

            qDebug() << "factor was / is" << oldFactor << newFactor;
        });
    }

    auto demoLayout = new QFormLayout;
    mainLayout->addLayout(demoLayout);
    m_group = new QButtonGroup(this);
    m_group->setExclusive(false);

    for (int i = 0; i < m_demos.size(); ++i) {
        DemoContainerBase *demo = m_demos.at(i);
        QString name = demo->name();
        name[0] = name.at(0).toUpper();
        auto button = new QPushButton(name);
        button->setCheckable(true);
        demoLayout->addRow(demo->option().description(), button);
        m_group->addButton(button, i);

        if (parser->isSet(demo->option())) {
            demo->makeVisible(true, this);
            button->setChecked(true);
        }
    }
    connect(m_group, &QButtonGroup::idToggled,
            this, &DemoController::handleButton);
}

DemoController::~DemoController()
{
    qDeleteAll(m_demos);
}

bool DemoController::eventFilter(QObject *object, QEvent *event)
{
    if (event->type() == QEvent::Close) {
        for (int i = 0; i < m_demos.size(); ++i) {
            DemoContainerBase *demo = m_demos.at(i);
            if (demo->widget() == object) {
                m_group->button(i)->setChecked(false);
                break;
            }
        }
    }
    return false;
}

void DemoController::handleButton(int id, bool toggled)
{
    m_demos.at(id)->makeVisible(toggled, this);
}

class PixmapPainter : public QWidget
{
public:
    PixmapPainter();

    void paintEvent(QPaintEvent *event) override;

private:
    QPixmap pixmap1X;
    QPixmap pixmap2X;
    QPixmap pixmapLarge;
    QImage image1X;
    QImage image2X;
    QImage imageLarge;
    QIcon qtIcon;
};

PixmapPainter::PixmapPainter()
{
    pixmap1X = QPixmap(":/qticon32.png");
    pixmap2X = QPixmap(":/qticon32@2x.png");
    pixmapLarge = QPixmap(":/qticon64.png");

    image1X = QImage(":/qticon32.png");
    image2X = QImage(":/qticon32@2x.png");
    imageLarge = QImage(":/qticon64.png");

    qtIcon.addFile(":/qticon32.png");
    qtIcon.addFile(":/qticon32@2x.png");
}

void PixmapPainter::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.fillRect(QRect(QPoint(0, 0), size()), QBrush(Qt::gray));

    int pixmapPointSize = 32;
    int y = 30;
    int dy = 90;

    int x = 10;
    int dx = 40;
    // draw at point
//          qDebug() << "paint pixmap" << pixmap1X.devicePixelRatio();
          p.drawPixmap(x, y, pixmap1X);
    x+=dx;p.drawPixmap(x, y, pixmap2X);
    x+=dx;p.drawPixmap(x, y, pixmapLarge);
  x+=dx*2;p.drawPixmap(x, y, qtIcon.pixmap(QSize(pixmapPointSize, pixmapPointSize)));
    x+=dx;p.drawImage(x, y, image1X);
    x+=dx;p.drawImage(x, y, image2X);
    x+=dx;p.drawImage(x, y, imageLarge);

    // draw at 32x32 rect
    y+=dy;
    x = 10;
          p.drawPixmap(QRect(x, y, pixmapPointSize, pixmapPointSize), pixmap1X);
    x+=dx;p.drawPixmap(QRect(x, y, pixmapPointSize, pixmapPointSize), pixmap2X);
    x+=dx;p.drawPixmap(QRect(x, y, pixmapPointSize, pixmapPointSize), pixmapLarge);
    x+=dx;p.drawPixmap(QRect(x, y, pixmapPointSize, pixmapPointSize), qtIcon.pixmap(QSize(pixmapPointSize, pixmapPointSize)));
    x+=dx;p.drawImage(QRect(x, y, pixmapPointSize, pixmapPointSize), image1X);
    x+=dx;p.drawImage(QRect(x, y, pixmapPointSize, pixmapPointSize), image2X);
    x+=dx;p.drawImage(QRect(x, y, pixmapPointSize, pixmapPointSize), imageLarge);


    // draw at 64x64 rect
    y+=dy - 50;
    x = 10;
               p.drawPixmap(QRect(x, y, pixmapPointSize * 2, pixmapPointSize * 2), pixmap1X);
    x+=dx * 2; p.drawPixmap(QRect(x, y, pixmapPointSize * 2, pixmapPointSize * 2), pixmap2X);
    x+=dx * 2; p.drawPixmap(QRect(x, y, pixmapPointSize * 2, pixmapPointSize * 2), pixmapLarge);
    x+=dx * 2; p.drawPixmap(QRect(x, y, pixmapPointSize * 2, pixmapPointSize * 2), qtIcon.pixmap(QSize(pixmapPointSize, pixmapPointSize)));
    x+=dx * 2; p.drawImage(QRect(x, y, pixmapPointSize * 2, pixmapPointSize * 2), image1X);
    x+=dx * 2; p.drawImage(QRect(x, y, pixmapPointSize * 2, pixmapPointSize * 2), image2X);
    x+=dx * 2; p.drawImage(QRect(x, y, pixmapPointSize * 2, pixmapPointSize * 2), imageLarge);
 }

class TiledPixmapPainter : public QWidget
{
public:
    TiledPixmapPainter();

    void paintEvent(QPaintEvent *event) override;

private:
    QPixmap pixmap1X;
    QPixmap pixmap2X;
    QPixmap pixmapLarge;
};

TiledPixmapPainter::TiledPixmapPainter()
{
    pixmap1X = QPixmap(":/qticon32.png");
    pixmap2X = QPixmap(":/qticon32@2x.png");
    pixmapLarge = QPixmap(":/qticon64.png");
}

void TiledPixmapPainter::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter p(this);

    int xoff = 10;
    int yoff = 10;
    int tiles = 4;
    int pixmapEdge = 32;
    int tileAreaEdge = pixmapEdge * tiles;

    // Expected behavior for both 1x and 2x dislays:
    // 1x pixmap   : 4 x 4 tiles
    // large pixmap: 2 x 2 tiles
    // 2x pixmap   : 4 x 4 tiles
    //
    // On a 2x display the 2x pixmap tiles
    // will be drawn in high resolution.
    p.drawTiledPixmap(QRect(xoff, yoff, tileAreaEdge, tileAreaEdge), pixmap1X);
    yoff += tiles * pixmapEdge + 10;
    p.drawTiledPixmap(QRect(xoff, yoff, tileAreaEdge, tileAreaEdge), pixmapLarge);
    yoff += tiles * pixmapEdge + 10;
    p.drawTiledPixmap(QRect(xoff, yoff, tileAreaEdge, tileAreaEdge), pixmap2X);

    // Again, with an offset. The offset is in
    // device-independent pixels.
    QPoint offset(40, 40); // larger than the pixmap edge size to exercise that code path
    yoff = 10;
    xoff = 20 + tiles * pixmapEdge ;
    p.drawTiledPixmap(QRect(xoff, yoff, tileAreaEdge, tileAreaEdge), pixmap1X, offset);
    yoff += tiles * pixmapEdge + 10;
    p.drawTiledPixmap(QRect(xoff, yoff, tileAreaEdge, tileAreaEdge), pixmapLarge, offset);
    yoff += tiles * pixmapEdge + 10;
    p.drawTiledPixmap(QRect(xoff, yoff, tileAreaEdge, tileAreaEdge), pixmap2X, offset);
}

class Labels : public QWidget
{
public:
    Labels();

private:
    QPixmap pixmap1X;
    QPixmap pixmap2X;
    QPixmap pixmapLarge;
    QIcon qtIcon;
};

Labels::Labels()
{
    pixmap1X = QPixmap(":/qticon32.png");
    pixmap2X = QPixmap(":/qticon32@2x.png");
    pixmapLarge = QPixmap(":/qticon64.png");

    qtIcon.addFile(":/qticon32.png");
    qtIcon.addFile(":/qticon32@2x.png");
    setWindowIcon(qtIcon);
    setWindowTitle(formatWindowTitle("Labels"));

    QLabel *label1x = new QLabel();
    label1x->setPixmap(pixmap1X);
    QLabel *label2x = new QLabel();
    label2x->setPixmap(pixmap2X);
    QLabel *labelIcon = new QLabel();
    labelIcon->setPixmap(qtIcon.pixmap(QSize(32,32)));
    QLabel *labelLarge = new QLabel();
    labelLarge->setPixmap(pixmapLarge);

    QHBoxLayout *layout = new QHBoxLayout(this);
    layout->addWidget(label1x);    //expected low-res on high-dpi displays
    layout->addWidget(label2x);    //expected high-res on high-dpi displays
    layout->addWidget(labelIcon);  //expected high-res on high-dpi displays
    layout->addWidget(labelLarge); // expected large size and low-res
    setLayout(layout);
}

class MainWindow : public QMainWindow
{
    Q_OBJECT
public:
    MainWindow();
    QMenu *addNewMenu(const QString &title, int itemCount = 5);

private slots:
    void maskActionToggled(bool t);

private:
    QIcon qtIcon;
    QIcon qtIcon1x;
    QIcon qtIcon2x;

    QToolBar *fileToolBar;
    QAction *m_maskAction;
    int menuCount = 0;
};

MainWindow::MainWindow()
{
    // beware that QIcon auto-loads the @2x versions.
    qtIcon1x.addFile(":/qticon16.png");
    qtIcon2x.addFile(":/qticon32.png");
    setWindowIcon(qtIcon);
    setWindowTitle(formatWindowTitle("MainWindow"));

    fileToolBar = addToolBar(tr("File"));
//    fileToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
    fileToolBar->addAction(new QAction(qtIcon1x, QString("1x"), this));
    fileToolBar->addAction(new QAction(qtIcon2x, QString("2x"), this));
    addNewMenu("&Edit");
    addNewMenu("&Build");
    addNewMenu("&Debug", 4);
    QMenu *menu = addNewMenu("&Transmogrify", 7);
    menu->addSeparator();
    m_maskAction = menu->addAction("Mask");
    m_maskAction->setCheckable(true);
    connect(m_maskAction, &QAction::toggled, this, &MainWindow::maskActionToggled);
    fileToolBar->addAction(m_maskAction);
    addNewMenu("T&ools");
    addNewMenu("&Help", 2);
}

QMenu *MainWindow::addNewMenu(const QString &title, int itemCount)
{
    QMenu *menu = menuBar()->addMenu(title);
    for (int i = 0; i < itemCount; i++) {
        menuCount++;
        QString s = "Menu item " + QString::number(menuCount);
        if (i == 3) {
            QMenu *subMenu = menu->addMenu(s);
            for (int j = 1; j < 4; j++)
                subMenu->addAction(QString::fromLatin1("SubMenu item %1.%2").arg(menuCount).arg(j));
        } else {
            menu->addAction(s);
        }
    }
    return menu;
}

void MainWindow::maskActionToggled(bool t)
{
    if (t) {
        QList<QPoint> upperLeftTriangle;
        upperLeftTriangle << QPoint(0, 0) << QPoint(width(), 0) << QPoint(0, height());
        setMask(QRegion(QPolygon(upperLeftTriangle)));
    } else {
        clearMask();
    }
}

class StandardIcons : public QWidget
{
public:
    void paintEvent(QPaintEvent *) override
    {
        int x = 10;
        int y = 10;
        int dx = 50;
        int dy = 50;
        int maxX = 500;

        for (uint iconIndex = QStyle::SP_TitleBarMenuButton; iconIndex < QStyle::SP_MediaVolumeMuted; ++iconIndex) {
            QIcon icon = qApp->style()->standardIcon(QStyle::StandardPixmap(iconIndex));
            QPainter p(this);
            p.drawPixmap(x, y, icon.pixmap(dx - 5, dy - 5));
            if (x + dx > maxX)
                y+=dy;
            x = ((x + dx) % maxX);
        }
    }
};

class Caching : public QWidget
{
public:
    void paintEvent(QPaintEvent *) override
    {
        QSize layoutSize(75, 75);

        QPainter widgetPainter(this);
        widgetPainter.fillRect(QRect(QPoint(0, 0), this->size()), Qt::gray);

        {
            const qreal devicePixelRatio = this->windowHandle()->devicePixelRatio();
            QPixmap cache(layoutSize * devicePixelRatio);
            cache.setDevicePixelRatio(devicePixelRatio);

            QPainter cachedPainter(&cache);
            cachedPainter.fillRect(QRect(0,0, 75, 75), Qt::blue);
            cachedPainter.fillRect(QRect(10,10, 55, 55), Qt::red);
            cachedPainter.drawEllipse(QRect(10,10, 55, 55));

            QPainter widgetPainter(this);
            widgetPainter.drawPixmap(QPoint(10, 10), cache);
        }

        {
            const qreal devicePixelRatio = this->windowHandle()->devicePixelRatio();
            QImage cache = QImage(layoutSize * devicePixelRatio, QImage::Format_ARGB32_Premultiplied);
            cache.setDevicePixelRatio(devicePixelRatio);

            QPainter cachedPainter(&cache);
            cachedPainter.fillRect(QRect(0,0, 75, 75), Qt::blue);
            cachedPainter.fillRect(QRect(10,10, 55, 55), Qt::red);
            cachedPainter.drawEllipse(QRect(10,10, 55, 55));

            QPainter widgetPainter(this);
            widgetPainter.drawImage(QPoint(95, 10), cache);
        }

    }
};

class Style : public QWidget
{
public:
    Style()
    {
        row1 = new QHBoxLayout(this);

        button = new QPushButton();
        button->setText("Test Button");
        row1->addWidget(button);

        lineEdit = new QLineEdit();
        lineEdit->setText("Test Lineedit");
        row1->addWidget(lineEdit);

        slider = new QSlider();
        row1->addWidget(slider);

        row1->addWidget(new QSpinBox);
        row1->addWidget(new QScrollBar);

        auto tab  = new QTabBar();
        tab->addTab("Foo");
        tab->addTab("Bar");
        row1->addWidget(tab);
    }

private:
    QPushButton *button;
    QLineEdit *lineEdit;
    QSlider *slider;
    QHBoxLayout *row1;
};

class Fonts : public QWidget
{
public:
    void paintEvent(QPaintEvent *) override
    {
        QPainter painter(this);

        // Points
        int y = 10;
        for (int fontSize = 6; fontSize < 18; fontSize += 2) {
            QFont font;
            font.setPointSize(fontSize);
            QString string = QString(QStringLiteral("This text is in point size %1")).arg(fontSize);
            painter.setFont(font);
            y += (painter.fontMetrics().lineSpacing());
            painter.drawText(10, y, string);
        }

        // Pixels
        y += painter.fontMetrics().lineSpacing();
        for (int fontSize = 6; fontSize < 18; fontSize += 2) {
            QFont font;
            font.setPixelSize(fontSize);
            QString string = QString(QStringLiteral("This text is in pixel size %1")).arg(fontSize);
            painter.setFont(font);
            y += (painter.fontMetrics().lineSpacing());
            painter.drawText(10, y, string);
        }
    }
};


template <typename T>
void apiTestdevicePixelRatioGetter()
{
    if (0) {
        T *t = nullptr;
        t->devicePixelRatio();
    }
}

template <typename T>
void apiTestdevicePixelRatioSetter()
{
    if (0) {
        T *t = nullptr;
        t->setDevicePixelRatio(2.0);
    }
}

void apiTest()
{
    // compile call to devicePixelRatio getter and setter (verify spelling)
    apiTestdevicePixelRatioGetter<QWindow>();
    apiTestdevicePixelRatioGetter<QScreen>();
    apiTestdevicePixelRatioGetter<QGuiApplication>();

    apiTestdevicePixelRatioGetter<QImage>();
    apiTestdevicePixelRatioSetter<QImage>();
    apiTestdevicePixelRatioGetter<QPixmap>();
    apiTestdevicePixelRatioSetter<QPixmap>();
}

// Request and draw an icon at different sizes
class IconDrawing : public QWidget
{
public:
    IconDrawing()
    {
        const QString tempPath = m_temporaryDir.path();
        const QString path32 = tempPath + "/qticon32.png";
        const QString path32_2 = tempPath + "/qticon32-2.png";
        const QString path32_2x = tempPath + "/qticon32@2x.png";

        QFile::copy(":/qticon32.png", path32_2);
        QFile::copy(":/qticon32.png", path32);
        QFile::copy(":/qticon32@2x.png", path32_2x);

        iconHighDPI.reset(new QIcon(path32)); // will auto-load @2x version.
        iconNormalDpi.reset(new QIcon(path32_2)); // does not have a 2x version.
    }

    void paintEvent(QPaintEvent *) override
    {
        int x = 10;
        int y = 10;
        int dx = 50;
        int dy = 50;
        int maxX = 600;
        int minSize = 5;
        int maxSize = 64;
        int sizeIncrement = 5;

        // normal icon
        for (int size = minSize; size < maxSize; size += sizeIncrement) {
            QPainter p(this);
            p.drawPixmap(x, y, iconNormalDpi->pixmap(size, size));
            if (x + dx > maxX)
                y+=dy;
            x = ((x + dx) % maxX);
        }
        x = 10;
        y+=dy;

        // high-dpi icon
        for (int size = minSize; size < maxSize; size += sizeIncrement) {
            QPainter p(this);
            p.drawPixmap(x, y, iconHighDPI->pixmap(size, size));
            if (x + dx > maxX)
                y+=dy;
            x = ((x + dx) % maxX);
        }
    }

private:
    QTemporaryDir m_temporaryDir;
    QScopedPointer<QIcon> iconHighDPI;
    QScopedPointer<QIcon> iconNormalDpi;
};

// Icons on buttons
class Buttons : public QWidget
{
public:
    Buttons()
    {
        QIcon icon;
        icon.addFile(":/qticon16@2x.png");

        QPushButton *button =  new QPushButton(this);
        button->setIcon(icon);
        button->setText("16@2x");

        QTabBar *tab = new QTabBar(this);
        tab->addTab(QIcon(":/qticon16.png"), "16@1x");
        tab->addTab(QIcon(":/qticon16@2x.png"), "16@2x");
        tab->addTab(QIcon(":/qticon16.png"), "");
        tab->addTab(QIcon(":/qticon16@2x.png"), "");
        tab->move(10, 100);
        tab->show();

        auto toolBar = new QToolBar(this);
        toolBar->addAction(QIcon(":/qticon16.png"), "16");
        toolBar->addAction(QIcon(":/qticon16@2x.png"), "16@2x");
        toolBar->addAction(QIcon(":/qticon32.png"), "32");
        toolBar->addAction(QIcon(":/qticon32@2x.png"), "32@2x");

        toolBar->move(10, 200);
        toolBar->show();
    }
};

class LinePainter : public QWidget
{
public:
    void paintEvent(QPaintEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;

private:
    QPoint lastMousePoint;
    QList<QPoint> linePoints;
};

void LinePainter::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.fillRect(QRect(QPoint(0, 0), size()), QBrush(Qt::gray));

    // Default antialiased line
    p.setRenderHint(QPainter::Antialiasing);
    p.drawLines(linePoints);

    // Cosmetic 1 antialiased line
    QPen pen;
    pen.setCosmetic(true);
    pen.setWidth(1);
    p.setPen(pen);
    p.translate(3, 3);
    p.drawLines(linePoints);

    // Aliased cosmetic 1 line
    p.setRenderHint(QPainter::Antialiasing, false);
    p.translate(3, 3);
    p.drawLines(linePoints);
}

void LinePainter::mousePressEvent(QMouseEvent *event)
{
    lastMousePoint = event->pos();
}

void LinePainter::mouseReleaseEvent(QMouseEvent *)
{
    lastMousePoint = QPoint();
}

void LinePainter::mouseMoveEvent(QMouseEvent *event)
{
    if (lastMousePoint.isNull())
        return;

    QPoint newMousePoint = event->pos();
    if (lastMousePoint == newMousePoint)
        return;
    linePoints.append(lastMousePoint);
    linePoints.append(newMousePoint);
    lastMousePoint = newMousePoint;
    update();
}

class CursorTester : public QWidget
{
public:
    CursorTester() = default;

    inline QRect getRect(int idx) const
    {
        int h = height() / 2;
        return QRect(10, 10 + h * (idx - 1), width() - 20, h - 20);
    }

    void paintEvent(QPaintEvent *) override
    {
        QPainter p(this);
        QRect r1 = getRect(1);
        QRect r2 = getRect(2);
        p.fillRect(r1, QColor(200, 200, 250));
        p.drawText(r1, "Drag from here to move a window based on QCursor::pos()");
        p.fillRect(r2, QColor(250, 200, 200));
        p.drawText(r2, "Drag from here to move a window based on mouse event position");

        if (moving) {
            p.setPen(Qt::darkGray);
            QFont f = font();
            f.setPointSize(8);
            p.setFont(f);
            p.drawEllipse(mousePos, 30,60);
            QPoint pt = mousePos - QPoint(0, 60);
            QPoint pt2 = pt - QPoint(30,10);
            QPoint offs(30, 0);
            p.drawLine(pt, pt2);
            p.drawLine(pt2 - offs, pt2 + offs);
            p.drawText(pt2 - offs, "mouse pos");

            p.setPen(QColor(50,130,70));
            QPoint cursorPos = mapFromGlobal(QCursor::pos());
            pt = cursorPos - QPoint(0, 30);
            pt2 = pt + QPoint(60, -20);
            p.drawEllipse(cursorPos, 60, 30);
            p.drawLine(pt, pt2);
            p.drawLine(pt2 - offs, pt2 + offs);
            p.drawText(pt2 - offs, "cursor pos");
        }
    }

    void mousePressEvent(QMouseEvent *e) override
    {
        if (moving)
            return;
        QRect r1 = getRect(1);
        QRect r2 = getRect(2);

        moving = r1.contains(e->pos()) || r2.contains(e->pos());
        if (!moving)
            return;
        useCursorPos = r1.contains(e->pos());

        if (!moveLabel)
            moveLabel = new QLabel(this,Qt::BypassWindowManagerHint|Qt::FramelessWindowHint|Qt::Window );

        if (useCursorPos)
            moveLabel->setText("I'm following QCursor::pos()");
        else
            moveLabel->setText("I'm following QMouseEvent::globalPos()");
        moveLabel->adjustSize();
        mouseMoveEvent(e);
        moveLabel->show();
    }

    void mouseReleaseEvent(QMouseEvent *) override
    {
        if (moveLabel)
            moveLabel->hide();
        update();
        moving = false;
    }

    void mouseMoveEvent(QMouseEvent *e) override
    {
        if (!moving)
            return;
        QPoint pos = useCursorPos ? QCursor::pos() : e->globalPosition().toPoint();
        pos -= moveLabel->rect().center();
        moveLabel->move(pos);
        mousePos = e->pos();
        update();
    }

private:
    QLabel *moveLabel = nullptr;
    QPoint mousePos;
    bool useCursorPos = false;
    bool moving = false;
};

class ScreenDisplayer : public QWidget
{
public:
    ScreenDisplayer() = default;

    void timerEvent(QTimerEvent *) override
    {
        update();
    }

    void mousePressEvent(QMouseEvent *) override
    {
        if (!moveLabel)
            moveLabel = new QLabel(this,Qt::BypassWindowManagerHint|Qt::FramelessWindowHint|Qt::Window );
        moveLabel->setText("Hello, Qt this is a label\nwith some text");
        moveLabel->show();
    }

    void mouseMoveEvent(QMouseEvent *e) override
    {
        if (!moveLabel)
            return;
        moveLabel->move(e->pos() / scaleFactor);
        QString str;
        QDebug dbg(&str);
        dbg.setAutoInsertSpaces(false);
        dbg << moveLabel->geometry();
        moveLabel->setText(str);
    }

    void mouseReleaseEvent(QMouseEvent *) override
    {
        if (moveLabel)
            moveLabel->hide();
    }

    void showEvent(QShowEvent *) override
    {
        refreshTimer.start(300, this);
    }

    void hideEvent(QHideEvent *) override
    {
        refreshTimer.stop();
    }

    void paintEvent(QPaintEvent *) override
    {
        QPainter p(this);
        QRectF total;
        const auto screens = QGuiApplication::screens();
        for (const QScreen *screen : screens)
            total |= screen->geometry();
        if (total.isEmpty())
            return;

        scaleFactor = qMin(width()/total.width(), height()/total.height());

        p.fillRect(rect(), Qt::black);
        p.scale(scaleFactor, scaleFactor);
        p.translate(-total.topLeft());
        p.setPen(QPen(Qt::white, 10));
        p.setBrush(Qt::gray);

        for (const QScreen *screen : screens) {
            p.drawRect(screen->geometry());
            QFont f = font();
            f.setPixelSize(screen->geometry().height() / 8);
            p.setFont(f);
            p.drawText(screen->geometry(), Qt::AlignCenter, screen->name());
        }
        p.setBrush(QColor(200,220,255,127));

        const auto topLevels = QApplication::topLevelWidgets();
        for (QWidget *widget : topLevels) {
            if (!widget->isHidden())
                p.drawRect(widget->geometry());
        }

        QPolygon cursorShape;
        cursorShape << QPoint(0,0) << QPoint(20, 60)
                    << QPoint(30, 50) << QPoint(60, 80)
                    << QPoint(80, 60) << QPoint(50, 30)
                    << QPoint(60, 20);
        cursorShape.translate(QCursor::pos());
        p.drawPolygon(cursorShape);
    }

private:
    QLabel *moveLabel = nullptr;
    qreal scaleFactor = 1;
    QBasicTimer refreshTimer;
};

class PhysicalSizeTest : public QWidget
{
    Q_OBJECT
public:
    PhysicalSizeTest() = default;

    void paintEvent(QPaintEvent *event) override;

    void resizeEvent(QResizeEvent *) override
    {
        qreal ppi = window()->windowHandle()->screen()->physicalDotsPerInchX();
        QSizeF s = size();
        if (!m_ignoreResize)
            m_physicalSize = s / ppi;
    }

    bool event(QEvent *event) override
    {
        if (event->type() == QEvent::ScreenChangeInternal) {
            // we will get resize events when the scale factor changes
            m_ignoreResize = true;
            QTimer::singleShot(100, this, &PhysicalSizeTest::handleScreenChange);
        }
        return QWidget::event(event);
    }

public slots:
    void handleScreenChange()
    {
        qreal ppi = window()->windowHandle()->screen()->physicalDotsPerInchX();
        QSizeF newSize = m_physicalSize * ppi;
        resize(newSize.toSize());
        m_ignoreResize = false;
    }

private:
    QSizeF m_physicalSize;
    bool m_ignoreResize = false;
};

void PhysicalSizeTest::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing);

    qreal ppi = window()->windowHandle()->screen()->physicalDotsPerInchX();
    qreal ppmm = ppi / 25.4;
    qreal h = 15 * ppmm;
    QRectF rulerRect(0,0, width(), h);
    rulerRect.moveCenter(rect().center());

    QFont f = font();
    f.setPixelSize(18);
    p.setFont(f);

    // draw a rectangle in (Qt) pixel coordinates, for comparison
    QRect pixelRect(0, 0, 300, 50);
    pixelRect.moveTopLeft(QPoint(5 * ppmm, rulerRect.bottom() + 5 * ppmm));
    p.fillRect(pixelRect, QColor(199,222,255));
    p.drawText(pixelRect, "This rectangle is 300x50 pixels");

    f.setPixelSize(4 * ppmm);
    p.setFont(f);

    QRectF topRect(0, 0, width(), rulerRect.top());
    p.drawText(topRect, Qt::AlignCenter, "The ruler is drawn in physical units.\nThis window tries to keep its physical size\nwhen moved between screens.");

    // draw a ruler in real physical coordinates

    p.fillRect(rulerRect, QColor(255, 222, 111));

    QPen linePen(Qt::black, 0.3 * ppmm);
    p.setPen(linePen);
    f.setBold(true);
    p.setFont(f);

    qreal vCenter = rulerRect.center().y();
    p.drawLine(0, vCenter, width(), vCenter);

    // cm
    for (int i = 0;;) {
        i++;
        qreal x = i * ppmm;
        if (x > width())
            break;
        qreal y = rulerRect.bottom();
        qreal len;
        if (i % 5)
            len = 2 * ppmm;
        else if (i % 10)
            len = 3 * ppmm;
        else
            len = h / 2;

        p.drawLine(QPointF(x, y), QPointF(x, y - len));
        if (i % 10 == 5) {
            QRectF textR(0, 0, 5 * ppmm, h / 2 - 2 * ppmm);
            textR.moveTopLeft(QPointF(x, vCenter));
            int n = i / 10 + 1;
            if (n % 10 == 0)
                p.setPen(Qt::red);
            p.drawText(textR, Qt::AlignCenter, QString::number(n));
            p.setPen(linePen);
        }
    }

    //inches
    for (int i = 0;;) {
        i++;
        qreal x = i * ppi / 16;
        if (x > width())
            break;
        qreal y = rulerRect.top();

        qreal d = h / 10;
        qreal len;
        if (i % 2)
            len = 1 * d;
        else if (i % 4)
            len = 2 * d;
        else if (i % 8)
            len = 3 * d;
        else if (i % 16)
            len = 4 * d;
        else
            len = h / 2;

        p.drawLine(QPointF(x, y), QPointF(x, y + len));
        if (i % 16 == 12) {
            QRectF textR(0, 0, 0.25 * ppi, h / 2 - 2 * d);
            textR.moveBottomLeft(QPointF(x, vCenter));
            p.drawText(textR, Qt::AlignCenter, QString::number(1 + i/16));
        }
    }

}

class GraphicsViewCaching : public QGraphicsView
{
public:
    GraphicsViewCaching()
    {
        auto scene = new QGraphicsScene(0, 0, 400, 400);

        QGraphicsTextItem *item = scene->addText("NoCache");
        item->setCacheMode(QGraphicsItem::NoCache);
        item->setPos(10, 10);

        item = scene->addText("ItemCoordinateCache");
        item->setCacheMode(QGraphicsItem::ItemCoordinateCache);
        item->setPos(10, 30);

        item = scene->addText("DeviceCoordinateCache");
        item->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
        item->setPos(10, 50);

        setScene(scene);
    }
};

class MetricsTest : public QTabWidget
{
    Q_OBJECT
public:
    MetricsTest()
    {
        qDebug().noquote().nospace() << "MetricsTest " << QT_VERSION_STR
            << ' ' << QGuiApplication::platformName() << '\n'
<< R"(Relevant environment variables are:
QT_FONT_DPI=N
QT_SCALE_FACTOR=n
QT_ENABLE_HIGHDPI_SCALING=0|1
QT_USE_PHYSICAL_DPI=0|1
QT_SCREEN_SCALE_FACTORS=N;N;N or QT_SCREEN_SCALE_FACTORS=name:N
QT_SCALE_FACTOR_ROUNDING_POLICY=Round|Ceil|Floor|RoundPreferFloor|PassThrough
QT_DPI_ADJUSTMENT_POLICY=AdjustDpi|DontAdjustDpi|AdjustUpOnly)";

        m_textEdit = addTextPage("Parameters");
        m_logEdit = addTextPage("Screen Change Log");

        const auto screens = QGuiApplication::screens();
        for (auto screen : screens)
            connectScreenChangeSignals(screen);
        connect(qApp, &QGuiApplication::screenAdded, this, &MetricsTest::slotScreenAdded);
        connect(qApp, &QGuiApplication::primaryScreenChanged, this, &MetricsTest::slotPrimaryScreenChanged);
        connect(qApp, &QGuiApplication::screenRemoved, this, &MetricsTest::slotScreenRemoved);

        setWindowTitle(formatWindowTitle("Screens"));
        m_logTimer.start();
        logMessage(briefFormatScreens());

        // Resize to roughly match the metrics text.
        const auto metrics = QFontMetrics(m_textEdit->font(), m_textEdit);
        const int width = 10 + metrics.horizontalAdvance(QStringLiteral("X")) * 50;
        const int height = 40 + metrics.height() * (10 + 8 * screens.size());
        resize(width, height);
    }

    void setVisible(bool visible) override
    {
        QWidget::setVisible(visible);
        if (visible && !m_screenChangedConnected) {
            m_screenChangedConnected = true;
            QObject::connect(windowHandle(), &QWindow::screenChanged,
                             this, &MetricsTest::screenChanged);
            updateMetrics();
        }
    }

    void updateMetrics()
    {
        QString text;
        QTextStream str(&text);

        auto currentScreen = windowHandle()->screen();
        const auto screens = QGuiApplication::screens();
        for (int i = 0, size = screens.size(); i < size; ++i) {
            auto screen = screens.at(i);
            auto platformScreen = screen->handle();
            str << "Screen #" << i << " \"" << screen->name() << '"';
            if (screen == currentScreen)
                str << " [current]";
            if (screen == QGuiApplication::primaryScreen())
                str << " [primary]";
            str << "\n  screen geometry: " << screen->geometry()
                << "\n  platform screen geometry: " << platformScreen->geometry()
                << "\n  platform screen logicalDpi: " << platformScreen->logicalDpi().first;

#ifdef HAVE_SCREEN_BASE_DPI
            str << "\n  platform screen logicalBaseDpi: " << platformScreen->logicalBaseDpi().first;
#endif
            str << "\n  platform screen devicePixelRatio: " <<platformScreen->devicePixelRatio()
                << "\n  platform screen physicalDpi: " << screen->physicalDotsPerInch()
                << "\n\n";
        }

        str << "widget devicePixelRatio: " << this->devicePixelRatio()
            << "\nwidget logicalDpi: " << this->logicalDpiX()
            << "\n\nQT_FONT_DPI: " << qgetenv("QT_FONT_DPI")
            << "\nQT_SCALE_FACTOR: " << qgetenv("QT_SCALE_FACTOR")
            << "\nQT_ENABLE_HIGHDPI_SCALING: " << qgetenv("QT_ENABLE_HIGHDPI_SCALING")
            << "\nQT_SCREEN_SCALE_FACTORS: " << qgetenv("QT_SCREEN_SCALE_FACTORS")
            << "\nQT_USE_PHYSICAL_DPI: " << qgetenv("QT_USE_PHYSICAL_DPI")
            << "\nQT_SCALE_FACTOR_ROUNDING_POLICY: " << qgetenv("QT_SCALE_FACTOR_ROUNDING_POLICY")
            << "\nQT_DPI_ADJUSTMENT_POLICY: " << qgetenv("QT_DPI_ADJUSTMENT_POLICY")
            << '\n';

        m_textEdit->setPlainText(text);
    }

private slots:
    void screenChanged()
    {
        const QString message = QLatin1String("screenChanged ") + windowHandle()->screen()->name();
        qInfo("%s", qPrintable(message));
        logMessage(message);
        updateMetrics();
    }

    void slotScreenAdded(QScreen *);
    void slotScreenRemoved(QScreen *);
    void slotPrimaryScreenChanged(QScreen *);
    void slotScreenGeometryChanged(const QRect &geometry)
    { logScreenChangeSignal(sender(), "geometry", geometry); }
    void slotScreenAvailableGeometryChanged(const QRect &geometry)
    { logScreenChangeSignal(sender(), "availableGeometry", geometry); }
    void slotScreenPhysicalSizeChanged(const QSizeF &size)
    { logScreenChangeSignal(sender(), "physicalSize", size); }
    void slotScreenPhysicalDotsPerInchChanged(qreal dpi)
    { logScreenChangeSignal(sender(), "physicalDotsPerInch", dpi); }
    void slotScreenLogicalDotsPerInchChanged(qreal dpi)
    { logScreenChangeSignal(sender(), "logicalDotsPerInch", dpi); }
    void slotScreenVirtualGeometryChanged(const QRect &rect)
    { logScreenChangeSignal(sender(), "virtualGeometry", rect); }
    void slotScreenPrimaryOrientationChanged(Qt::ScreenOrientation orientation)
    { logScreenChangeSignal(sender(), "primaryOrientation", orientation); }
    void slotScreenOrientationChanged(Qt::ScreenOrientation orientation)
    { logScreenChangeSignal(sender(), "orientation", orientation); }
    void slotScreenRefreshRateChanged(qreal refreshRate)
    { logScreenChangeSignal(sender(), "refreshRate", refreshRate); }

private:
    QPlainTextEdit *addTextPage(const QString &title);
    void logMessage(const QString &);
    void connectScreenChangeSignals(QScreen *s);
    static QString briefFormatScreens();
    template <class T>
    void logScreenChangeSignal(const QObject *o, const char *name, const T &value);

    QPlainTextEdit *m_textEdit;
    QPlainTextEdit *m_logEdit;
    QElapsedTimer m_logTimer;
    bool m_screenChangedConnected = false;
};

void MetricsTest::slotScreenAdded(QScreen *screen)
{
    logMessage(QLatin1String("Added ") + screen->name() + QLatin1Char(' ')
               + briefFormatScreens());
    connectScreenChangeSignals(screen);
}

void MetricsTest::slotScreenRemoved(QScreen *screen)
{
    logMessage(QLatin1String("Removed ") + screen->name() + QLatin1Char(' ')
               + briefFormatScreens());
}

void MetricsTest::slotPrimaryScreenChanged(QScreen *screen)
{
    logMessage(QLatin1String("PrimaryScreenChanged ") + screen->name() + QLatin1Char(' ')
               + briefFormatScreens());
}

QPlainTextEdit *MetricsTest::addTextPage(const QString &title)
{
    auto result = new QPlainTextEdit(this);
    result->setReadOnly(true);
    result->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
    addTab(result, title);
    return result;
}

void MetricsTest::logMessage(const QString &m)
{
    const QString timeStamp =
        QStringLiteral("%1ms: %2").arg(m_logTimer.elapsed(), 6, 10, QLatin1Char('0')).arg(m);
    m_logEdit->appendPlainText(timeStamp);
}

void MetricsTest::connectScreenChangeSignals(QScreen *s)
{
    connect(s, &QScreen::geometryChanged, this, &MetricsTest::slotScreenGeometryChanged);
    connect(s, &QScreen::availableGeometryChanged, this, &MetricsTest::slotScreenAvailableGeometryChanged);
    connect(s, &QScreen::physicalSizeChanged, this, &MetricsTest::slotScreenPhysicalSizeChanged);
    connect(s, &QScreen::physicalDotsPerInchChanged, this, &MetricsTest::slotScreenPhysicalDotsPerInchChanged);
    connect(s, &QScreen::logicalDotsPerInchChanged, this, &MetricsTest::slotScreenLogicalDotsPerInchChanged);
    connect(s, &QScreen::virtualGeometryChanged, this, &MetricsTest::slotScreenVirtualGeometryChanged);
    connect(s, &QScreen::primaryOrientationChanged, this, &MetricsTest::slotScreenPrimaryOrientationChanged);
    connect(s, &QScreen::orientationChanged, this, &MetricsTest::slotScreenOrientationChanged);
    connect(s, &QScreen::refreshRateChanged, this, &MetricsTest::slotScreenRefreshRateChanged);
}

QString MetricsTest::briefFormatScreens()
{
    QString message;
    QTextStream str(&message);
    const auto screens = QGuiApplication::screens();
    for (int i = 0, size = screens.size(); i < size; ++i) {
        str << (i ? ", " : "(");
        str << screens.at(i)->name() << " " << screens.at(i)->geometry();
    }
    str << ')';
    return message;
}

template <class T>
void MetricsTest::logScreenChangeSignal(const QObject *o, const char *name, const T &value)
{
    auto screen = qobject_cast<const QScreen *>(o);
    QString message;
    QTextStream(&message) << (screen ? screen->name() : QString()) << ' ' << name << " changed: " << value;
    logMessage(message);
}

int main(int argc, char **argv)
{
    qInfo("High DPI tester %s", QT_VERSION_STR);

    QApplication app(argc, argv);
    QCoreApplication::setApplicationVersion(QT_VERSION_STR);

    QCommandLineParser parser;
    parser.setApplicationDescription("High DPI tester. Pass one or more of the options to\n"
                                     "test various high-dpi aspects. \n"
                                     "--interactive is a special option and opens a configuration"
                                     " window.");
    parser.addHelpOption();
    parser.addVersionOption();
    QCommandLineOption controllerOption("interactive", "Show configuration window.");
    parser.addOption(controllerOption);

    DemoContainerList demoList;
    demoList << new DemoContainer<PixmapPainter>("pixmap", "Test pixmap painter");
    demoList << new DemoContainer<TiledPixmapPainter>("tiledpixmap", "Test tiled pixmap painter");
    demoList << new DemoContainer<Labels>("label", "Test Labels");
    demoList << new DemoContainer<MainWindow>("mainwindow", "Test QMainWindow");
    demoList << new DemoContainer<StandardIcons>("standard-icons", "Test standard icons");
    demoList << new DemoContainer<Caching>("caching", "Test caching");
    demoList << new DemoContainer<Style>("styles", "Test style");
    demoList << new DemoContainer<Fonts>("fonts", "Test fonts");
    demoList << new DemoContainer<IconDrawing>("icondrawing", "Test icon drawing");
    demoList << new DemoContainer<Buttons>("buttons", "Test buttons");
    demoList << new DemoContainer<LinePainter>("linepainter", "Test line painting");
    demoList << new DemoContainer<DragWidget>("draganddrop", "Test drag and drop");
    demoList << new DemoContainer<CursorTester>("cursorpos", "Test cursor and window positioning");
    demoList << new DemoContainer<ScreenDisplayer>("screens", "Test screen and window positioning");
    demoList << new DemoContainer<PhysicalSizeTest>("physicalsize", "Test manual highdpi support using physicalDotsPerInch");
    demoList << new DemoContainer<GraphicsViewCaching>("graphicsview", "Test QGraphicsView caching");
    demoList << new DemoContainer<MetricsTest>("metrics", "Show screen metrics");

    for (DemoContainerBase *demo : std::as_const(demoList))
        parser.addOption(demo->option());

    parser.process(app);

    //controller takes ownership of all demos
    DemoController controller(demoList, &parser);

    if (parser.isSet(controllerOption) || (QCoreApplication::arguments().count()) <= 1)
        controller.show();

    if (QApplication::topLevelWidgets().isEmpty())
        parser.showHelp(0);

    return app.exec();
}

#include "main.moc"
