qplatformscreen.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qplatformscreen.h"
#include <QtCore/qdebug.h>
#include <QtGui/qguiapplication.h>
#include <qpa/qplatformcursor.h>
#include <QtGui/private/qguiapplication_p.h>
#include <qpa/qplatformscreen_p.h>
#include <qpa/qplatformintegration.h>
#include <QtGui/qscreen.h>
#include <QtGui/qwindow.h>
#include <private/qhighdpiscaling_p.h>
#include <private/qwindow_p.h>
 
QT_BEGIN_NAMESPACE
 
QPlatformScreen::QPlatformScreen()
    : d_ptr(new QPlatformScreenPrivate)
{
    Q_D(QPlatformScreen);
    d->screen = nullptr;
}
 
QPlatformScreen::~QPlatformScreen()
{
    Q_D(QPlatformScreen);
    Q_ASSERT_X(!d->screen, "QPlatformScreen",
        "QPlatformScreens should be removed via QWindowSystemInterface::handleScreenRemoved()");
}
 
QPixmap QPlatformScreen::grabWindow(WId window, int x, int y, int width, int height) const
{
    Q_UNUSED(window);
    Q_UNUSED(x);
    Q_UNUSED(y);
    Q_UNUSED(width);
    Q_UNUSED(height);
    return QPixmap();
}
 
QWindow *QPlatformScreen::topLevelAt(const QPoint & pos) const
{
    const QWindowList list = QGuiApplication::topLevelWindows();
    const auto crend = list.crend();
    for (auto it = list.crbegin(); it != crend; ++it) {
        QWindow *w = *it;
        if (w->isVisible() && QHighDpi::toNativePixels(w->geometry(), w).contains(pos))
            return w;
    }
 
    return nullptr;
}
 
QWindowList QPlatformScreen::windows() const
{
    QWindowList windows;
    for (QWindow *window : QGuiApplication::allWindows()) {
        if (platformScreenForWindow(window) != this)
            continue;
        windows.append(window);
    }
    return windows;
}
 
const QPlatformScreen *QPlatformScreen::screenForPosition(const QPoint &point) const
{
    if (!geometry().contains(point)) {
        const auto screens = virtualSiblings();
        for (const QPlatformScreen *screen : screens) {
            if (screen->geometry().contains(point))
                return screen;
        }
    }
    return this;
}
 
 
QList<QPlatformScreen *> QPlatformScreen::virtualSiblings() const
{
    QList<QPlatformScreen *> list;
    list << const_cast<QPlatformScreen *>(this);
    return list;
}
 
QScreen *QPlatformScreen::screen() const
{
    Q_D(const QPlatformScreen);
    return d->screen;
}
 
QSizeF QPlatformScreen::physicalSize() const
{
    static const int dpi = 100;
    return QSizeF(geometry().size()) / dpi * qreal(25.4);
}
 
QDpi QPlatformScreen::logicalDpi() const
{
    return logicalBaseDpi();
}
 
// Helper function for accessing the platform screen logical dpi
// which accounts for QT_FONT_DPI.
QPair<qreal, qreal> QPlatformScreen::overrideDpi(const QPair<qreal, qreal> &in)
{
    static const int overrideDpi = qEnvironmentVariableIntValue("QT_FONT_DPI");
    return overrideDpi > 0 ?  QDpi(overrideDpi, overrideDpi) : in;
}
 
QDpi QPlatformScreen::logicalBaseDpi() const
{
    return QDpi(96, 96);
}
 
qreal QPlatformScreen::devicePixelRatio() const
{
    return 1.0;
}
 
qreal QPlatformScreen::refreshRate() const
{
    return 60;
}
 
Qt::ScreenOrientation QPlatformScreen::nativeOrientation() const
{
    return Qt::PrimaryOrientation;
}
 
Qt::ScreenOrientation QPlatformScreen::orientation() const
{
    return Qt::PrimaryOrientation;
}
 
QPlatformScreen * QPlatformScreen::platformScreenForWindow(const QWindow *window)
{
    // QTBUG 32681: It can happen during the transition between screens
    // when one screen is disconnected that the window doesn't have a screen.
    if (!window->screen())
        return nullptr;
    return window->screen()->handle();
}
 
QString QPlatformScreen::manufacturer() const
{
    return QString();
}
 
QString QPlatformScreen::model() const
{
    return QString();
}
 
QString QPlatformScreen::serialNumber() const
{
    return QString();
}
 
QPlatformCursor *QPlatformScreen::cursor() const
{
    return nullptr;
}
 
void QPlatformScreen::resizeMaximizedWindows()
{
    // 'screen()' still has the old geometry (in device independent pixels),
    // while 'this' has the new geometry (in native pixels)
    const QRect oldGeometry = screen()->geometry();
    const QRect oldAvailableGeometry = screen()->availableGeometry();
    const QRect newNativeGeometry = this->geometry();
    const QRect newNativeAvailableGeometry = this->availableGeometry();
 
    const bool supportsMaximizeUsingFullscreen = QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::MaximizeUsingFullscreenGeometry);
 
    for (QWindow *w : windows()) {
        // Skip non-platform windows, e.g., offscreen windows.
        if (!w->handle())
            continue;
 
        // Set QPlatformWindow size in native pixels, and let the platform's geometry
        // change signals update the QWindow geomeyry. This way we make sure that the
        // platform window geometry covers the entire (available) platform screen geometry,
        // also when fractional DPRs introduce rounding errors in the device independent
        // QWindow and QScreen sizes.
        if (supportsMaximizeUsingFullscreen
                && w->windowState() & Qt::WindowMaximized
                && w->flags() & Qt::MaximizeUsingFullscreenGeometryHint) {
            w->handle()->setGeometry(newNativeGeometry);
        } else if (w->windowState() & Qt::WindowMaximized || w->geometry() == oldAvailableGeometry) {
            w->handle()->setGeometry(newNativeAvailableGeometry);
        } else if (w->windowState() & Qt::WindowFullScreen || w->geometry() == oldGeometry) {
            w->handle()->setGeometry(newNativeGeometry);
        }
    }
}
 
// i must be power of two
static int log2(uint i)
{
    if (i == 0)
        return -1;
 
    int result = 0;
    while (!(i & 1)) {
        ++result;
        i >>= 1;
    }
    return result;
}
 
int QPlatformScreen::angleBetween(Qt::ScreenOrientation a, Qt::ScreenOrientation b)
{
    if (a == Qt::PrimaryOrientation || b == Qt::PrimaryOrientation) {
        qWarning("Use QScreen version of %sBetween() when passing Qt::PrimaryOrientation", "angle");
        return 0;
    }
 
    if (a == b)
        return 0;
 
    int ia = log2(uint(a));
    int ib = log2(uint(b));
 
    int delta = ia - ib;
 
    if (delta < 0)
        delta = delta + 4;
 
    int angles[] = { 0, 90, 180, 270 };
    return angles[delta];
}
 
QTransform QPlatformScreen::transformBetween(Qt::ScreenOrientation a, Qt::ScreenOrientation b, const QRect &target)
{
    if (a == Qt::PrimaryOrientation || b == Qt::PrimaryOrientation) {
        qWarning("Use QScreen version of %sBetween() when passing Qt::PrimaryOrientation", "transform");
        return QTransform();
    }
 
    if (a == b)
        return QTransform();
 
    int angle = angleBetween(a, b);
 
    QTransform result;
    switch (angle) {
    case 90:
        result.translate(target.width(), 0);
        break;
    case 180:
        result.translate(target.width(), target.height());
        break;
    case 270:
        result.translate(0, target.height());
        break;
    default:
        Q_ASSERT(false);
    }
    result.rotate(angle);
 
    return result;
}
 
QRect QPlatformScreen::mapBetween(Qt::ScreenOrientation a, Qt::ScreenOrientation b, const QRect &rect)
{
    if (a == Qt::PrimaryOrientation || b == Qt::PrimaryOrientation) {
        qWarning("Use QScreen version of %sBetween() when passing Qt::PrimaryOrientation", "map");
        return rect;
    }
 
    if (a == b)
        return rect;
 
    if ((a == Qt::PortraitOrientation || a == Qt::InvertedPortraitOrientation)
        != (b == Qt::PortraitOrientation || b == Qt::InvertedPortraitOrientation))
    {
        return QRect(rect.y(), rect.x(), rect.height(), rect.width());
    }
 
    return rect;
}
 
QPlatformScreen::SubpixelAntialiasingType QPlatformScreen::subpixelAntialiasingTypeHint() const
{
    static int type = -1;
    if (type == -1) {
        QByteArray env = qgetenv("QT_SUBPIXEL_AA_TYPE");
        if (env == "RGB")
            type = QPlatformScreen::Subpixel_RGB;
        else if (env == "BGR")
            type = QPlatformScreen::Subpixel_BGR;
        else if (env == "VRGB")
            type = QPlatformScreen::Subpixel_VRGB;
        else if (env == "VBGR")
            type = QPlatformScreen::Subpixel_VBGR;
        else
            type = QPlatformScreen::Subpixel_None;
    }
 
    return static_cast<QPlatformScreen::SubpixelAntialiasingType>(type);
}
 
QPlatformScreen::PowerState QPlatformScreen::powerState() const
{
    return PowerStateOn;
}
 
void QPlatformScreen::setPowerState(PowerState state)
{
    Q_UNUSED(state);
}
 
QList<QPlatformScreen::Mode> QPlatformScreen::modes() const
{
    QList<QPlatformScreen::Mode> list;
    list.append({geometry().size(), refreshRate()});
    return list;
}
 
int QPlatformScreen::currentMode() const
{
    return 0;
}
 
int QPlatformScreen::preferredMode() const
{
    return 0;
}
 
QList<QPlatformScreen *> QPlatformPlaceholderScreen::virtualSiblings() const
{
    QList<QPlatformScreen *> siblings;
 
    if (!m_virtualSibling)
        return siblings;
 
    for (QScreen *screen : QGuiApplication::screens()) {
        if (screen->handle() && screen->handle() != this)
            siblings << screen->handle();
    }
    return siblings;
}
 
QT_END_NAMESPACE