qpixeltool.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
#include "qpixeltool.h"
 
#include <qapplication.h>
#include <qdir.h>
#include <qscreen.h>
#if QT_CONFIG(clipboard)
#include <qclipboard.h>
#endif
#include <qpainter.h>
#include <qevent.h>
#include <qfiledialog.h>
#include <qmessagebox.h>
#include <qsettings.h>
#include <qmenu.h>
#include <qactiongroup.h>
#include <qimagewriter.h>
#include <qstandardpaths.h>
#include <qtextstream.h>
#include <qwindow.h>
#include <qmetaobject.h>
#include <private/qhighdpiscaling_p.h>
 
#include <qdebug.h>
 
#include <cmath>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
static constexpr auto settingsGroup = "QPixelTool"_L1;
static constexpr auto organization = "QtProject"_L1;
static constexpr auto autoUpdateKey = "autoUpdate"_L1;
static constexpr auto gridSizeKey = "gridSize"_L1;
static constexpr auto gridActiveKey = "gridActive"_L1;
static constexpr auto zoomKey = "zoom"_L1;
static constexpr auto initialSizeKey = "initialSize"_L1;
static constexpr auto positionKey = "position"_L1;
static constexpr auto lcdModeKey = "lcdMode"_L1;
 
static QPoint initialPos(const QSettings &settings, QSize initialSize)
{
    const QPoint defaultPos = QGuiApplication::primaryScreen()->availableGeometry().topLeft();
    const QPoint savedPos =
        settings.value(positionKey, QVariant(defaultPos)).toPoint();
    auto *savedScreen = QGuiApplication::screenAt(savedPos);
    return savedScreen != nullptr
        && savedScreen->availableGeometry().intersects(QRect(savedPos, initialSize))
        ? savedPos : defaultPos;
}
 
QPixelTool::QPixelTool(QWidget *parent)
    : QWidget(parent)
{
    setWindowTitle(QCoreApplication::applicationName());
    QSettings settings(organization, settingsGroup);
    m_autoUpdate = settings.value(autoUpdateKey, 0).toBool();
    m_gridSize = settings.value(gridSizeKey, 1).toInt();
    m_gridActive = settings.value(gridActiveKey, 1).toInt();
    m_zoom = settings.value(zoomKey, 4).toInt();
    m_initialSize = settings.value(initialSizeKey, QSize(250, 200)).toSize();
    m_lcdMode = settings.value(lcdModeKey, 0).toInt();
 
    move(initialPos(settings, m_initialSize));
 
    setMouseTracking(true);
    setAttribute(Qt::WA_OpaquePaintEvent);
    m_updateId = startTimer(30);
}
 
QPixelTool::~QPixelTool()
{
    QSettings settings(organization, settingsGroup);
    settings.setValue(autoUpdateKey, int(m_autoUpdate));
    settings.setValue(gridSizeKey, m_gridSize);
    settings.setValue(gridActiveKey, m_gridActive);
    settings.setValue(zoomKey, m_zoom);
    settings.setValue(initialSizeKey, size());
    settings.setValue(positionKey, pos());
    settings.setValue(lcdModeKey, m_lcdMode);
}
 
void QPixelTool::setPreviewImage(const QImage &image)
{
    m_preview_mode = true;
    m_preview_image = image;
    m_freeze = true;
}
 
void QPixelTool::timerEvent(QTimerEvent *event)
{
    if (event->timerId() == m_updateId && !m_freeze) {
        grabScreen();
    } else if (event->timerId() == m_displayZoomId) {
        killTimer(m_displayZoomId);
        m_displayZoomId = 0;
        setZoomVisible(false);
    } else if (event->timerId() == m_displayGridSizeId) {
        killTimer(m_displayGridSizeId);
        m_displayGridSizeId = 0;
        m_displayGridSize = false;
    }
}
 
void render_string(QPainter *p, int w, int h, const QString &text, int flags)
{
    p->setBrush(QColor(255, 255, 255, 191));
    p->setPen(Qt::black);
    QRect bounds;
    p->drawText(0, 0, w, h, Qt::TextDontPrint | flags, text, &bounds);
 
    if (bounds.x() == 0) bounds.adjust(0, 0, 10, 0);
    else bounds.adjust(-10, 0, 0, 0);
 
    if (bounds.y() == 0) bounds.adjust(0, 0, 0, 10);
    else bounds.adjust(0, -10, 0, 0);
 
    p->drawRect(bounds);
    p->drawText(bounds, flags, text);
}
 
static QImage imageLCDFilter(const QImage &image, int lcdMode)
{
    Q_ASSERT(lcdMode > 0 && lcdMode < 5);
    const bool vertical = (lcdMode > 2);
    QImage scaled(image.width()  * (vertical ? 1 : 3),
                  image.height() * (vertical ? 3 : 1),
                  image.format());
 
    const int w = image.width();
    const int h = image.height();
    if (!vertical) {
        for (int y = 0; y < h; ++y) {
            const QRgb *in = reinterpret_cast<const QRgb *>(image.scanLine(y));
            QRgb *out = reinterpret_cast<QRgb *>(scaled.scanLine(y));
            if (lcdMode == 1) {
                for (int x = 0; x < w; ++x) {
                    *out++ = in[x] & 0xffff0000;
                    *out++ = in[x] & 0xff00ff00;
                    *out++ = in[x] & 0xff0000ff;
                }
            } else {
                for (int x = 0; x < w; ++x) {
                    *out++ = in[x] & 0xff0000ff;
                    *out++ = in[x] & 0xff00ff00;
                    *out++ = in[x] & 0xffff0000;
                }
            }
        }
    } else {
        for (int y = 0; y < h; ++y) {
            const QRgb *in = reinterpret_cast<const QRgb *>(image.scanLine(y));
            QRgb *out1 = reinterpret_cast<QRgb *>(scaled.scanLine(y * 3 + 0));
            QRgb *out2 = reinterpret_cast<QRgb *>(scaled.scanLine(y * 3 + 1));
            QRgb *out3 = reinterpret_cast<QRgb *>(scaled.scanLine(y * 3 + 2));
            if (lcdMode == 2) {
                for (int x = 0; x < w; ++x) {
                    out1[x] = in[x] & 0xffff0000;
                    out2[x] = in[x] & 0xff00ff00;
                    out3[x] = in[x] & 0xff0000ff;
                }
            } else {
                for (int x = 0; x < w; ++x) {
                    out1[x] = in[x] & 0xff0000ff;
                    out2[x] = in[x] & 0xff00ff00;
                    out3[x] = in[x] & 0xffff0000;
                }
            }
        }
    }
    return scaled;
}
 
void QPixelTool::paintEvent(QPaintEvent *)
{
    QPainter p(this);
 
    if (m_preview_mode) {
        QPixmap pixmap(40, 40);
        QPainter pt(&pixmap);
        pt.fillRect(0, 0, 20, 20, Qt::white);
        pt.fillRect(20, 20, 20, 20, Qt::white);
        pt.fillRect(20, 0, 20, 20, Qt::lightGray);
        pt.fillRect(0, 20, 20, 20, Qt::lightGray);
        pt.end();
        p.fillRect(0, 0, width(), height(), pixmap);
    }
 
    int w = width();
    int h = height();
 
    p.save();
    if (m_lcdMode == 0)  {
        p.scale(m_zoom, m_zoom);
        p.drawPixmap(0, 0, m_buffer);
    } else {
        if (m_lcdMode <= 2)
            p.scale(m_zoom / 3.0, m_zoom);
        else
            p.scale(m_zoom, m_zoom / 3.0);
        p.drawImage(0, 0, imageLCDFilter(m_buffer.toImage(), m_lcdMode));
    }
    p.restore();
 
    // Draw the grid on top.
    if (m_gridActive) {
        p.setPen(m_gridActive == 1 ? Qt::black : Qt::white);
        int incr = m_gridSize * m_zoom;
        if (m_lcdMode == 0 || m_lcdMode > 2) {
            for (int x=0; x<w; x+=incr)
                p.drawLine(x, 0, x, h);
        }
        if (m_lcdMode <= 2) {
            for (int y=0; y<h; y+=incr)
                p.drawLine(0, y, w, y);
        }
    }
 
    QFont f(QStringList{u"courier"_s}, -1, QFont::Bold);
    p.setFont(f);
 
    if (m_displayZoom) {
        render_string(&p, w, h,
                      "Zoom: x"_L1 + QString::number(m_zoom),
                      Qt::AlignTop | Qt::AlignRight);
    }
 
    if (m_displayGridSize) {
        render_string(&p, w, h,
                      "Grid size: "_L1 + QString::number(m_gridSize),
                      Qt::AlignBottom | Qt::AlignLeft);
    }
 
    if (m_freeze) {
        QString str = QString::asprintf("%8X (%3d,%3d,%3d,%3d)",
                                        m_currentColor,
                                        (0xff000000 & m_currentColor) >> 24,
                                        (0x00ff0000 & m_currentColor) >> 16,
                                        (0x0000ff00 & m_currentColor) >> 8,
                                        (0x000000ff & m_currentColor));
        render_string(&p, w, h,
                      str,
                      Qt::AlignBottom | Qt::AlignRight);
    }
 
    if (m_mouseDown && m_dragStart != m_dragCurrent) {
        int x1 = (m_dragStart.x() / m_zoom) * m_zoom;
        int y1 = (m_dragStart.y() / m_zoom) * m_zoom;
        int x2 = (m_dragCurrent.x() / m_zoom) * m_zoom;
        int y2 = (m_dragCurrent.y() / m_zoom) * m_zoom;
        QRect r = QRect(x1, y1, x2 - x1, y2 - y1).normalized();
        p.setBrush(Qt::NoBrush);
        p.setPen(QPen(Qt::red, 3, Qt::SolidLine));
        p.drawRect(r);
        p.setPen(QPen(Qt::black, 1, Qt::SolidLine));
        p.drawRect(r);
 
        QString str = QString::asprintf("Rect: x=%d, y=%d, w=%d, h=%d",
                                        r.x() / m_zoom,
                                        r.y() / m_zoom,
                                        r.width() / m_zoom,
                                        r.height() / m_zoom);
        render_string(&p, w, h, str, Qt::AlignBottom | Qt::AlignLeft);
    }
 
 
}
 
void QPixelTool::keyPressEvent(QKeyEvent *e)
{
    switch (e->key()) {
    case Qt::Key_Space:
        toggleFreeze();
        break;
    case Qt::Key_Plus:
        increaseZoom();
        break;
    case Qt::Key_Minus:
        decreaseZoom();
        break;
    case Qt::Key_PageUp:
        setGridSize(m_gridSize + 1);
        break;
    case Qt::Key_PageDown:
        setGridSize(m_gridSize - 1);
        break;
    case Qt::Key_G:
        toggleGrid();
        break;
    case Qt::Key_A:
        m_autoUpdate = !m_autoUpdate;
        break;
#if QT_CONFIG(clipboard)
    case Qt::Key_C:
        if (e->modifiers().testFlag(Qt::ControlModifier))
            copyToClipboard();
        else
            copyColorToClipboard();
        break;
#endif // QT_CONFIG(clipboard)
    case Qt::Key_S:
        if (e->modifiers().testFlag(Qt::ControlModifier)) {
            releaseKeyboard();
            saveToFile();
        }
        break;
    case Qt::Key_Control:
        grabKeyboard();
        break;
    case Qt::Key_F1:
        aboutPixelTool();
        break;
    }
}
 
void QPixelTool::keyReleaseEvent(QKeyEvent *e)
{
    switch(e->key()) {
    case Qt::Key_Control:
        releaseKeyboard();
        break;
    default:
        break;
    }
}
 
void QPixelTool::resizeEvent(QResizeEvent *)
{
    grabScreen();
}
 
void QPixelTool::mouseMoveEvent(QMouseEvent *e)
{
    if (m_mouseDown)
        m_dragCurrent = e->pos();
 
    const auto pos = e->position().toPoint();
    const int x = pos.x() / m_zoom;
    const int y = pos.y() / m_zoom;
 
    QImage im = m_buffer.toImage().convertToFormat(QImage::Format_ARGB32);
    if (x < im.width() && y < im.height() && x >= 0 && y >= 0) {
        m_currentColor = im.pixel(x, y);
        update();
    }
}
 
void QPixelTool::mousePressEvent(QMouseEvent *e)
{
    if (!m_freeze)
        return;
    m_mouseDown = true;
    m_dragStart = e->pos();
}
 
void QPixelTool::mouseReleaseEvent(QMouseEvent *)
{
    m_mouseDown = false;
}
 
static QAction *addCheckableAction(QMenu &menu, const QString &title,
                                   bool value, const QKeySequence &key)
{
    QAction *result = menu.addAction(title);
    result->setCheckable(true);
    result->setChecked(value);
    result->setShortcut(key);
    return result;
}
 
static QAction *addCheckableAction(QMenu &menu, const QString &title,
                                   bool value, const QKeySequence &key,
                                   QActionGroup *group)
{
    QAction *result = addCheckableAction(menu, title, value, key);
    result->setActionGroup(group);
    return result;
}
 
void QPixelTool::contextMenuEvent(QContextMenuEvent *e)
{
    const bool tmpFreeze = m_freeze;
    m_freeze = true;
 
    QMenu menu;
    menu.addAction("Qt Pixel Zooming Tool"_L1)->setEnabled(false);
    menu.addSeparator();
 
    // Grid color options...
    auto *gridGroup = new QActionGroup(&menu);
    addCheckableAction(menu, "White grid"_L1, m_gridActive == 2,
                       Qt::Key_W, gridGroup);
    QAction *blackGrid = addCheckableAction(menu, "Black grid"_L1,
                                            m_gridActive == 1, Qt::Key_B, gridGroup);
    QAction *noGrid = addCheckableAction(menu, "No grid"_L1, m_gridActive == 0,
                                         Qt::Key_N, gridGroup);
    menu.addSeparator();
 
    // Grid size options
    menu.addAction("Increase grid size"_L1, Qt::Key_PageUp,
                   this, &QPixelTool::increaseGridSize);
    menu.addAction("Decrease grid size"_L1, Qt::Key_PageDown,
                   this, &QPixelTool::decreaseGridSize);
    menu.addSeparator();
 
    auto *lcdGroup = new QActionGroup(&menu);
    addCheckableAction(menu, "No subpixels"_L1, m_lcdMode == 0,
                       QKeySequence(), lcdGroup);
    QAction *rgbPixels = addCheckableAction(menu, "RGB subpixels"_L1,
                                            m_lcdMode == 1, QKeySequence(), lcdGroup);
    QAction *bgrPixels = addCheckableAction(menu, "BGR subpixels"_L1,
                                            m_lcdMode == 2, QKeySequence(), lcdGroup);
    QAction *vrgbPixels = addCheckableAction(menu, "VRGB subpixels"_L1,
                                             m_lcdMode == 3, QKeySequence(), lcdGroup);
    QAction *vbgrPixels = addCheckableAction(menu, "VBGR subpixels"_L1,
                                             m_lcdMode == 4, QKeySequence(), lcdGroup);
    menu.addSeparator();
 
    // Zoom options
    menu.addAction("Zoom in"_L1, Qt::Key_Plus,
                   this, &QPixelTool::increaseZoom);
    menu.addAction("Zoom out"_L1, Qt::Key_Minus,
                   this, &QPixelTool::decreaseZoom);
    menu.addSeparator();
 
    // Freeze / Autoupdate
    QAction *freeze = addCheckableAction(menu, "Frozen"_L1,
                                         tmpFreeze, Qt::Key_Space);
    QAction *autoUpdate = addCheckableAction(menu, "Continuous update"_L1,
                                             m_autoUpdate, Qt::Key_A);
    menu.addSeparator();
 
    // Copy to clipboard / save
    menu.addAction("Save as image..."_L1, QKeySequence::SaveAs,
                   this, &QPixelTool::saveToFile);
#if QT_CONFIG(clipboard)
    menu.addAction("Copy to clipboard"_L1, QKeySequence::Copy,
                   this, &QPixelTool::copyToClipboard);
    menu.addAction("Copy color value to clipboard"_L1, Qt::Key_C,
                   this, &QPixelTool::copyColorToClipboard);
    // Screen
    menu.addSeparator();
    menu.addAction("Copy screen shot to clipboard"_L1, QKeySequence(),
                   this, &QPixelTool::copyScreenShotToClipboard);
    menu.addAction("Copy screen info to clipboard"_L1, QKeySequence(),
                   this, &QPixelTool::copyScreenInfoToClipboard);
#endif // QT_CONFIG(clipboard)
 
    menu.addSeparator();
    menu.addAction("About Qt"_L1, qApp, &QApplication::aboutQt);
    menu.addAction("About Qt Pixeltool"_L1, this, &QPixelTool::aboutPixelTool);
 
    menu.exec(mapToGlobal(e->pos()));
 
    // Read out grid settings
    if (noGrid->isChecked())
        m_gridActive = 0;
    else if (blackGrid->isChecked())
        m_gridActive = 1;
    else
        m_gridActive = 2;
 
    // Read out lcd settings
    if (rgbPixels->isChecked())
        m_lcdMode = 1;
    else if (bgrPixels->isChecked())
        m_lcdMode = 2;
    else if (vrgbPixels->isChecked())
        m_lcdMode = 3;
    else if (vbgrPixels->isChecked())
        m_lcdMode = 4;
    else
        m_lcdMode = 0;
 
    m_autoUpdate = autoUpdate->isChecked();
    m_freeze = freeze->isChecked();
 
    // LCD mode looks off unless zoom is dividable by 3
    if (m_lcdMode && (m_zoom % 3) != 0)
        setZoom(qMax(3, (m_zoom + 1) / 3));
}
 
QSize QPixelTool::sizeHint() const
{
    return m_initialSize;
}
 
static inline QString pixelToolTitle(QPoint pos, const QScreen *screen, const QColor &currentColor)
{
    if (screen != nullptr)
        pos = QHighDpi::toNativePixels(pos, screen);
    return QCoreApplication::applicationName() + " ["_L1
        + QString::number(pos.x())
        + ", "_L1 + QString::number(pos.y()) + "] "_L1
        + currentColor.name();
}
 
void QPixelTool::grabScreen()
{
    if (m_preview_mode) {
        int w = qMin(width() / m_zoom + 1, m_preview_image.width());
        int h = qMin(height() / m_zoom + 1, m_preview_image.height());
        m_buffer = QPixmap::fromImage(m_preview_image).copy(0, 0, w, h);
        update();
        return;
    }
 
    QPoint mousePos = QCursor::pos();
    if (mousePos == m_lastMousePos && !m_autoUpdate)
        return;
 
    QScreen *screen = QGuiApplication::screenAt(mousePos);
 
    if (m_lastMousePos != mousePos)
        setWindowTitle(pixelToolTitle(mousePos, screen, m_currentColor));
 
    const auto widgetDpr = devicePixelRatioF();
    const auto screenDpr = screen != nullptr ? screen->devicePixelRatio() : widgetDpr;
    // When grabbing from another screen, we grab an area fitting our size using our DPR.
    const auto factor = widgetDpr / screenDpr / qreal(m_zoom);
    const QSize size{int(std::ceil(width() * factor)), int(std::ceil(height() * factor))};
    const QPoint pos = mousePos - QPoint{size.width(), size.height()} / 2;
 
    const QBrush darkBrush = palette().color(QPalette::Dark);
    if (screen != nullptr) {
        const QPoint screenPos = pos - screen->geometry().topLeft();
        m_buffer = screen->grabWindow(0, screenPos.x(), screenPos.y(), size.width(), size.height());
    } else {
        m_buffer = QPixmap(size);
        m_buffer.fill(darkBrush.color());
    }
    m_buffer.setDevicePixelRatio(widgetDpr);
 
    QRegion geom(QRect{pos, size});
    QRect screenRect;
    const auto screens = QGuiApplication::screens();
    for (auto *screen : screens)
        screenRect |= screen->geometry();
    geom -= screenRect;
    const auto rectsInRegion = geom.rectCount();
    if (!geom.isEmpty()) {
        QPainter p(&m_buffer);
        p.translate(-pos);
        p.setPen(Qt::NoPen);
        p.setBrush(darkBrush);
        p.drawRects(geom.begin(), rectsInRegion);
    }
 
    update();
 
    m_currentColor = m_buffer.toImage().pixel(m_buffer.rect().center());
    m_lastMousePos = mousePos;
}
 
void QPixelTool::startZoomVisibleTimer()
{
    if (m_displayZoomId > 0)
        killTimer(m_displayZoomId);
    m_displayZoomId = startTimer(5000);
    setZoomVisible(true);
}
 
void QPixelTool::startGridSizeVisibleTimer()
{
    if (m_gridActive) {
        if (m_displayGridSizeId > 0)
            killTimer(m_displayGridSizeId);
        m_displayGridSizeId = startTimer(5000);
        m_displayGridSize = true;
        update();
    }
}
 
void QPixelTool::setZoomVisible(bool visible)
{
    m_displayZoom = visible;
    update();
}
 
void QPixelTool::toggleFreeze()
{
    m_freeze = !m_freeze;
    if (!m_freeze)
        m_dragStart = m_dragCurrent = QPoint();
}
 
void QPixelTool::increaseZoom()
{
    if (!m_lcdMode)
        setZoom(m_zoom + 1);
    else
        setZoom(m_zoom + 3);
}
 
void QPixelTool::decreaseZoom()
{
    if (!m_lcdMode)
        setZoom(m_zoom - 1);
    else
        setZoom(m_zoom - 3);
}
 
void QPixelTool::setZoom(int zoom)
{
    if (zoom > 0) {
        QPoint pos = m_lastMousePos;
        m_lastMousePos = QPoint();
        m_zoom = zoom;
        grabScreen();
        m_lastMousePos = pos;
        m_dragStart = m_dragCurrent = QPoint();
        startZoomVisibleTimer();
    }
}
 
void QPixelTool::toggleGrid()
{
    if (++m_gridActive > 2)
        m_gridActive = 0;
    update();
}
 
void QPixelTool::setGridSize(int gridSize)
{
    if (m_gridActive && gridSize > 0) {
        m_gridSize = gridSize;
        startGridSizeVisibleTimer();
        update();
    }
}
 
#if QT_CONFIG(clipboard)
void QPixelTool::copyToClipboard()
{
    QGuiApplication::clipboard()->setPixmap(m_buffer);
}
 
void QPixelTool::copyColorToClipboard()
{
    QGuiApplication::clipboard()->setText(QColor(m_currentColor).name());
}
 
void QPixelTool::copyScreenShotToClipboard()
{
    QPixmap screenShot = screen()->grabWindow();
    QGuiApplication::clipboard()->setImage(screenShot.toImage());
}
 
void QPixelTool::copyScreenInfoToClipboard()
{
    const auto *screen = this->screen();
    QString text;
    QTextStream str(&text);
    const auto geom = screen->geometry();
    const auto availGeom = screen->availableGeometry();
    auto orientationMt = QMetaEnum::fromType<Qt::ScreenOrientation>();
 
    str << "Model/name: \"" << screen->model() << "\"/\"" << screen->name() << '"'
        << "\nGeometry: " << geom.width() << 'x' << geom.height() << Qt::forcesign
        << geom.x() << geom.y() << Qt::noforcesign
        << "\nAvailable geometry: " << availGeom.width() << 'x' << availGeom.height() << Qt::forcesign
        << availGeom.x() << availGeom.y() << Qt::noforcesign
        << "\nDevice pixel ratio: " << screen->devicePixelRatio()
        << "\nLogical DPI: " << screen->logicalDotsPerInchX() << ','
        << screen->logicalDotsPerInchY() << "DPI"
        << "\nPhysical DPI: " << screen->physicalDotsPerInchX() << ','
        << screen->physicalDotsPerInchY() << "DPI"
        << "\nPhysical size: " << screen->physicalSize().width()  << 'x'
        << screen->physicalSize().height() << "mm";
    if (const char *orientation = orientationMt.valueToKey(screen->orientation()))
        str << "\nOrientation: " << orientation;
    str << "\nRefresh rate: " << screen->refreshRate() << "Hz";
    QGuiApplication::clipboard()->setText(text);
}
 
#endif // QT_CONFIG(clipboard)
 
void QPixelTool::saveToFile()
{
    bool oldFreeze = m_freeze;
    m_freeze = true;
 
    QFileDialog fileDialog(this);
    fileDialog.setWindowTitle("Save as image"_L1);
    fileDialog.setAcceptMode(QFileDialog::AcceptSave);
    fileDialog.setDirectory(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
    QStringList mimeTypes;
    const QByteArrayList supportedMimeTypes = QImageWriter::supportedMimeTypes();
    for (const QByteArray &mimeTypeB : supportedMimeTypes)
        mimeTypes.append(QString::fromLatin1(mimeTypeB));
    fileDialog.setMimeTypeFilters(mimeTypes);
    const QString pngType = "image/png"_L1;
    if (mimeTypes.contains(pngType)) {
        fileDialog.selectMimeTypeFilter(pngType);
        fileDialog.setDefaultSuffix("png"_L1);
    }
 
    while (fileDialog.exec() == QDialog::Accepted
        && !m_buffer.save(fileDialog.selectedFiles().constFirst())) {
        QMessageBox::warning(this, "Unable to write image"_L1,
                             "Unable to write "_L1
                             + QDir::toNativeSeparators(fileDialog.selectedFiles().constFirst()));
    }
    m_freeze = oldFreeze;
}
 
QTextStream &operator<<(QTextStream &str, const QScreen *screen)
{
    const QRect geometry = screen->geometry();
    str << '"' << screen->name() << "\" " << geometry.width()
        << 'x' << geometry.height() << Qt::forcesign << geometry.x() << geometry.y()
        << Qt::noforcesign << ", " << qRound(screen->logicalDotsPerInch()) << "DPI"
        << ", Depth: " << screen->depth() << ", " << screen->refreshRate() << "Hz";
    const qreal dpr = screen->devicePixelRatio();
    if (!qFuzzyCompare(dpr, qreal(1)))
        str << ", DPR: " << dpr;
    return str;
}
 
QString QPixelTool::aboutText() const
{
    const QList<QScreen *> screens = QGuiApplication::screens();
    const QScreen *windowScreen = windowHandle()->screen();
 
    QString result;
    QTextStream str(&result);
    str << "<html><head></head><body><h2>Qt Pixeltool</h2><p>Qt " << QT_VERSION_STR
        << "</p><p>Copyright (C) 2017 The Qt Company Ltd.</p><h3>Screens</h3><ul>";
    for (const QScreen *screen : screens)
        str << "<li>" << (screen == windowScreen ? "* " : "  ") << screen << "</li>";
    str << "</ul></body></html>";
    return result;
}
 
void QPixelTool::aboutPixelTool()
{
    QMessageBox aboutBox(QMessageBox::Information, tr("About Qt Pixeltool"), aboutText(),
                         QMessageBox::Close, this);
    aboutBox.setWindowFlags(aboutBox.windowFlags() & ~Qt::WindowContextHelpButtonHint);
    aboutBox.setTextInteractionFlags(Qt::TextBrowserInteraction);
    aboutBox.exec();
}
 
QT_END_NAMESPACE