qplatformwindow.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 "qplatformwindow.h"
#include "qplatformwindow_p.h"
#include "qplatformscreen.h"
 
#include <private/qguiapplication_p.h>
#include <qpa/qwindowsysteminterface.h>
#include <QtGui/qwindow.h>
#include <QtGui/qscreen.h>
#include <private/qhighdpiscaling_p.h>
#include <private/qwindow_p.h>
 
 
QT_BEGIN_NAMESPACE
 
QPlatformWindow::QPlatformWindow(QWindow *window)
    : QPlatformSurface(window)
    , d_ptr(new QPlatformWindowPrivate)
{
    Q_D(QPlatformWindow);
    d->rect = QHighDpi::toNativePixels(window->geometry(), window);
}
 
QPlatformWindow::~QPlatformWindow()
{
}
 
void QPlatformWindow::initialize()
{
}
 
QWindow *QPlatformWindow::window() const
{
    return static_cast<QWindow *>(m_surface);
}
 
QPlatformWindow *QPlatformWindow::parent() const
{
    return window()->parent() ? window()->parent()->handle() : nullptr;
}
 
QPlatformScreen *QPlatformWindow::screen() const
{
    QScreen *scr = window()->screen();
    return scr ? scr->handle() : nullptr;
}
 
QSurfaceFormat QPlatformWindow::format() const
{
    return QSurfaceFormat();
}
 
void QPlatformWindow::setGeometry(const QRect &rect)
{
    Q_D(QPlatformWindow);
    d->rect = rect;
}
 
QRect QPlatformWindow::geometry() const
{
    Q_D(const QPlatformWindow);
    return d->rect;
}
 
QRect QPlatformWindow::normalGeometry() const
{
    return QRect();
}
 
QMargins QPlatformWindow::frameMargins() const
{
    return QMargins();
}
 
QMargins QPlatformWindow::safeAreaMargins() const
{
    return QMargins();
}
 
void QPlatformWindow::setVisible(bool visible)
{
    Q_UNUSED(visible);
    QRect rect(QPoint(), geometry().size());
    QWindowSystemInterface::handleExposeEvent(window(), rect);
    QWindowSystemInterface::flushWindowSystemEvents();
}
 
void QPlatformWindow::setWindowFlags(Qt::WindowFlags flags)
{
    Q_UNUSED(flags);
}
 
bool QPlatformWindow::isExposed() const
{
    return window()->isVisible();
}
 
bool QPlatformWindow::isActive() const
{
    return false;
}
 
bool QPlatformWindow::isAncestorOf(const QPlatformWindow *child) const
{
    for (const QPlatformWindow *parent = child->parent(); parent; parent = parent->parent()) {
        if (parent == this)
            return true;
    }
 
    return false;
}
 
bool QPlatformWindow::isEmbedded() const
{
    return false;
}
 
QPoint QPlatformWindow::mapToGlobal(const QPoint &pos) const
{
    const QPlatformWindow *p = this;
    QPoint result = pos;
    while (p) {
        result += p->geometry().topLeft();
        p = p->parent();
    }
    return result;
}
 
QPointF QPlatformWindow::mapToGlobalF(const QPointF &pos) const
{
    const QPoint posPt = pos.toPoint();
    const QPointF delta = pos - posPt;
    return mapToGlobal(posPt) + delta;
}
 
QPointF QPlatformWindow::mapFromGlobalF(const QPointF &pos) const
{
    const QPoint posPt = pos.toPoint();
    const QPointF delta = pos - posPt;
    return mapFromGlobal(posPt) + delta;
}
 
QPoint QPlatformWindow::mapFromGlobal(const QPoint &pos) const
{
    const QPlatformWindow *p = this;
    QPoint result = pos;
    while (p) {
        result -= p->geometry().topLeft();
        p = p->parent();
    }
    return result;
}
 
void QPlatformWindow::setWindowState(Qt::WindowStates)
{
}
 
WId QPlatformWindow::winId() const
{
    // Return anything but 0. Returning 0 would cause havoc with QWidgets on
    // very basic platform plugins that do not reimplement this function,
    // because the top-level widget's internalWinId() would always be 0 which
    // would mean top-levels are never treated as native.
    return WId(1);
}
 
//jl: It would be useful to have a property on the platform window which indicated if the sub-class
// supported the setParent. If not, then geometry would be in screen coordinates.
void QPlatformWindow::setParent(const QPlatformWindow *parent)
{
    Q_UNUSED(parent);
    qWarning("This plugin does not support setParent!");
}
 
void QPlatformWindow::setWindowTitle(const QString &title) { Q_UNUSED(title); }
 
void QPlatformWindow::setWindowFilePath(const QString &filePath) { Q_UNUSED(filePath); }
 
void QPlatformWindow::setWindowIcon(const QIcon &icon) { Q_UNUSED(icon); }
 
bool QPlatformWindow::close()
{
    return QWindowSystemInterface::handleCloseEvent<QWindowSystemInterface::SynchronousDelivery>(window());
}
 
void QPlatformWindow::raise() { qWarning("This plugin does not support raise()"); }
 
void QPlatformWindow::lower() { qWarning("This plugin does not support lower()"); }
 
void QPlatformWindow::propagateSizeHints() {qWarning("This plugin does not support propagateSizeHints()"); }
 
void QPlatformWindow::setOpacity(qreal level)
{
    Q_UNUSED(level);
    qWarning("This plugin does not support setting window opacity");
}
 
void QPlatformWindow::setMask(const QRegion &region)
{
    Q_UNUSED(region);
    qWarning("This plugin does not support setting window masks");
}
 
void QPlatformWindow::requestActivateWindow()
{
    QWindowSystemInterface::handleFocusWindowChanged(window());
}
 
void QPlatformWindow::handleContentOrientationChange(Qt::ScreenOrientation orientation)
{
    Q_UNUSED(orientation);
}
 
qreal QPlatformWindow::devicePixelRatio() const
{
    return 1.0;
}
 
bool QPlatformWindow::setKeyboardGrabEnabled(bool grab)
{
    Q_UNUSED(grab);
    qWarning("This plugin does not support grabbing the keyboard");
    return false;
}
 
bool QPlatformWindow::setMouseGrabEnabled(bool grab)
{
    Q_UNUSED(grab);
    qWarning("This plugin does not support grabbing the mouse");
    return false;
}
 
bool QPlatformWindow::setWindowModified(bool modified)
{
    Q_UNUSED(modified);
    return false;
}
 
bool QPlatformWindow::windowEvent(QEvent *event)
{
    Q_D(QPlatformWindow);
 
    if (event->type() == QEvent::Timer) {
        if (static_cast<QTimerEvent *>(event)->timerId() == d->updateTimer.timerId()) {
            d->updateTimer.stop();
            deliverUpdateRequest();
            return true;
        }
    }
 
    return false;
}
 
bool QPlatformWindow::startSystemResize(Qt::Edges edges)
{
    Q_UNUSED(edges);
    return false;
}
 
bool QPlatformWindow::startSystemMove()
{
    return false;
}
 
void QPlatformWindow::setFrameStrutEventsEnabled(bool enabled)
{
    Q_UNUSED(enabled); // Do not warn as widgets enable it by default causing warnings with XCB.
}
 
bool QPlatformWindow::frameStrutEventsEnabled() const
{
    return false;
}
 
QString QPlatformWindow::formatWindowTitle(const QString &title, const QString &separator)
{
    QString fullTitle = title;
    if (QGuiApplicationPrivate::displayName && !title.endsWith(*QGuiApplicationPrivate::displayName)) {
        // Append display name, if set.
        if (!fullTitle.isEmpty())
            fullTitle += separator;
        fullTitle += *QGuiApplicationPrivate::displayName;
    } else if (fullTitle.isEmpty()) {
        // Don't let the window title be completely empty, use the app name as fallback.
        fullTitle = QCoreApplication::applicationName();
    }
    return fullTitle;
}
 
QPlatformScreen *QPlatformWindow::screenForGeometry(const QRect &newGeometry) const
{
    QPlatformScreen *currentScreen = screen();
    QPlatformScreen *fallback = currentScreen;
    // QRect::center can return a value outside the rectangle if it's empty.
    // Apply mapToGlobal() in case it is a foreign/embedded window.
    QPoint center = newGeometry.isEmpty() ? newGeometry.topLeft() : newGeometry.center();
    if (isForeignWindow())
        center = mapToGlobal(center - newGeometry.topLeft());
 
    if (!parent() && currentScreen && !currentScreen->geometry().contains(center)) {
        const auto screens = currentScreen->virtualSiblings();
        for (QPlatformScreen *screen : screens) {
            const QRect screenGeometry = screen->geometry();
            if (screenGeometry.contains(center))
                return screen;
            if (screenGeometry.intersects(newGeometry))
                fallback = screen;
        }
    }
    return fallback;
}
 
QSize QPlatformWindow::constrainWindowSize(const QSize &size)
{
    return size.expandedTo(QSize(0, 0)).boundedTo(QSize(QWINDOWSIZE_MAX, QWINDOWSIZE_MAX));
}
 
void QPlatformWindow::setAlertState(bool enable)
{
    Q_UNUSED(enable);
}
 
bool QPlatformWindow::isAlertState() const
{
    return false;
}
 
// Return the effective screen for the initial geometry of a window. In a
// multimonitor-setup, try to find the right screen by checking the transient
// parent or the mouse cursor for parentless windows (cf QTBUG-34204,
// QDialog::adjustPosition()), unless a non-primary screen has been set,
// in which case we try to respect that.
static inline const QScreen *effectiveScreen(const QWindow *window)
{
    if (!window)
        return QGuiApplication::primaryScreen();
    const QScreen *screen = window->screen();
    if (!screen)
        return QGuiApplication::primaryScreen();
    if (screen != QGuiApplication::primaryScreen())
        return screen;
#ifndef QT_NO_CURSOR
    const QList<QScreen *> siblings = screen->virtualSiblings();
    if (siblings.size() > 1) {
        const QPoint referencePoint = window->transientParent() ? window->transientParent()->geometry().center() : QCursor::pos();
        for (const QScreen *sibling : siblings) {
            if (sibling->geometry().contains(referencePoint))
                return sibling;
        }
    }
#endif
    return screen;
}
 
void QPlatformWindow::invalidateSurface()
{
}
 
static QSize fixInitialSize(QSize size, const QWindow *w, int deviceIndependentDefaultWidth,
                            int deviceIndependentDefaultHeight)
{
    if (size.width() == 0) {
        const int minWidth = w->minimumWidth();
        size.setWidth(minWidth > 0 ? minWidth : deviceIndependentDefaultWidth);
    }
    if (size.height() == 0) {
        const int minHeight = w->minimumHeight();
        size.setHeight(minHeight > 0 ? minHeight : deviceIndependentDefaultHeight);
    }
    return size;
}
 
QRect QPlatformWindow::initialGeometry(const QWindow *w, const QRect &initialGeometry,
                                       int defaultWidth, int defaultHeight,
                                       const QScreen **resultingScreenReturn)
{
    if (resultingScreenReturn)
        *resultingScreenReturn = w->screen();
    if (!w->isTopLevel()) {
        const qreal factor = QHighDpiScaling::factor(w);
        const QSize deviceIndependentSize =
                fixInitialSize(QHighDpi::fromNative(initialGeometry.size(), factor), w,
                               defaultWidth, defaultHeight);
        return QRect(initialGeometry.topLeft(), QHighDpi::toNative(deviceIndependentSize, factor));
    }
    const auto *wp = qt_window_private(const_cast<QWindow*>(w));
    const bool position = wp->positionAutomatic && w->type() != Qt::Popup;
    if (!position && !wp->resizeAutomatic)
        return initialGeometry;
    const QScreen *screen = wp->positionAutomatic
        ? effectiveScreen(w)
        : QGuiApplication::screenAt(initialGeometry.center());
    if (!screen)
        return initialGeometry;
    if (resultingScreenReturn)
        *resultingScreenReturn = screen;
    // initialGeometry refers to window's screen
    QRect deviceIndependentRect(QHighDpi::fromNativePixels(initialGeometry, w));
    if (wp->resizeAutomatic)
        deviceIndependentRect.setSize(
                fixInitialSize(deviceIndependentRect.size(), w, defaultWidth, defaultHeight));
    if (position) {
        const QRect availableDeviceIndependentGeometry = screen->availableGeometry();
        // Center unless the geometry ( + unknown window frame) is too large for the screen).
        if (deviceIndependentRect.height() < (availableDeviceIndependentGeometry.height() * 8) / 9
            && deviceIndependentRect.width()
                    < (availableDeviceIndependentGeometry.width() * 8) / 9) {
            const QWindow *tp = w->transientParent();
            if (tp) {
                // A transient window should be centered w.r.t. its transient parent.
                deviceIndependentRect.moveCenter(tp->geometry().center());
            } else {
                // Center the window on the screen.  (Only applicable on platforms
                // which do not provide a better way.)
                deviceIndependentRect.moveCenter(availableDeviceIndependentGeometry.center());
            }
        }
    }
    return QHighDpi::toNativePixels(deviceIndependentRect, screen);
}
 
void QPlatformWindow::requestUpdate()
{
    Q_D(QPlatformWindow);
 
    static bool customUpdateIntervalValid = false;
    static int customUpdateInterval = qEnvironmentVariableIntValue("QT_QPA_UPDATE_IDLE_TIME",
                                                                   &customUpdateIntervalValid);
    int updateInterval = customUpdateInterval;
    if (!customUpdateIntervalValid) {
        updateInterval = 5;
        if (QPlatformScreen *currentScreen = screen()) {
            const qreal refreshRate = currentScreen->refreshRate();
            if (refreshRate > 60.0)
                updateInterval /= refreshRate / 60.0;
        }
    }
 
    Q_ASSERT(!d->updateTimer.isActive());
    d->updateTimer.start(updateInterval, Qt::PreciseTimer, window());
}
 
bool QPlatformWindow::hasPendingUpdateRequest() const
{
    return qt_window_private(window())->updateRequestPending;
}
 
void QPlatformWindow::deliverUpdateRequest()
{
    Q_ASSERT(hasPendingUpdateRequest());
 
    QWindow *w = window();
    QWindowPrivate *wp = qt_window_private(w);
 
    // We expect that the platform plugins send DevicePixelRatioChange events.
    // As a fail-safe make a final check here to make sure the cached DPR value is
    // always up to date before delivering the update request.
    if (wp->updateDevicePixelRatio()) {
        qWarning() << "The cached device pixel ratio value was stale on window update. "
                   << "Please file a QTBUG which explains how to reproduce.";
    }
 
    wp->updateRequestPending = false;
    QEvent request(QEvent::UpdateRequest);
    QCoreApplication::sendEvent(w, &request);
}
 
QSize QPlatformWindow::windowMinimumSize() const
{
    return constrainWindowSize(QHighDpi::toNativePixels(window()->minimumSize(), window()));
}
 
QSize QPlatformWindow::windowMaximumSize() const
{
    return constrainWindowSize(QHighDpi::toNativePixels(window()->maximumSize(), window()));
}
 
QSize QPlatformWindow::windowBaseSize() const
{
    return QHighDpi::toNativePixels(window()->baseSize(), window());
}
 
QSize QPlatformWindow::windowSizeIncrement() const
{
    QSize increment = window()->sizeIncrement();
    if (!QHighDpiScaling::isActive())
        return increment;
 
    // Normalize the increment. If not set the increment can be
    // (-1, -1) or (0, 0). Make that (1, 1) which is scalable.
    if (increment.isEmpty())
        increment = QSize(1, 1);
 
    return QHighDpi::toNativePixels(increment, window());
}
 
QRect QPlatformWindow::windowGeometry() const
{
    return QHighDpi::toNativeWindowGeometry(window()->geometry(), window());
}
 
QRect QPlatformWindow::windowFrameGeometry() const
{
    return QHighDpi::toNativeWindowGeometry(window()->frameGeometry(), window());
}
 
QRectF QPlatformWindow::closestAcceptableGeometry(const QWindow *qWindow, const QRectF &nativeRect)
{
    const QRectF rectF = QHighDpi::fromNativeWindowGeometry(nativeRect, qWindow);
    const QRectF correctedGeometryF = qt_window_private(const_cast<QWindow *>(qWindow))->closestAcceptableGeometry(rectF);
    return !correctedGeometryF.isEmpty() && rectF != correctedGeometryF
        ? QHighDpi::toNativeWindowGeometry(correctedGeometryF, qWindow) : nativeRect;
}
 
QRectF QPlatformWindow::windowClosestAcceptableGeometry(const QRectF &nativeRect) const
{
    return QPlatformWindow::closestAcceptableGeometry(window(), nativeRect);
}
 
QT_END_NAMESPACE