/****************************************************************************

**

** Copyright (C) 2016 The Qt Company Ltd.

** Contact: https://www.qt.io/licensing/

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

** packaging of this file. Please review the following information to

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

**

** GNU General Public License Usage

** Alternatively, this file may be used under the terms of the GNU

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qwindow.h"

#include <qpa/qplatformwindow.h>

#include <qpa/qplatformintegration.h>

#include "qsurfaceformat.h"

#ifndef QT_NO_OPENGL

#include <qpa/qplatformopenglcontext.h>

#include "qopenglcontext.h"

#include "qopenglcontext_p.h"

#endif

#include "qscreen.h"

#include "qwindow_p.h"

#include "qguiapplication_p.h"

#ifndef QT_NO_ACCESSIBILITY

#  include "qaccessible.h"

#endif

#include "qhighdpiscaling_p.h"

#if QT_CONFIG(draganddrop)

#include "qshapedpixmapdndwindow_p.h"

#endif // QT_CONFIG(draganddrop)

#include <private/qevent_p.h>

#include <QtCore/QTimer>

#include <QtCore/QDebug>

#include <QStyleHints>

#include <qpa/qplatformcursor.h>

QT_BEGIN_NAMESPACE

/*!

    \class QWindow

    \inmodule QtGui

    \since 5.0

    \brief The QWindow class represents a window in the underlying windowing system.

    A window that is supplied a parent becomes a native child window of

    their parent window.

    An application will typically use QWidget or QQuickView for its UI, and not

    QWindow directly. Still, it is possible to render directly to a QWindow

    with QBackingStore or QOpenGLContext, when wanting to keep dependencies to

    a minimum or when wanting to use OpenGL directly. The

    \l{Raster Window Example} and \l{OpenGL Window Example}

    are useful reference examples for how to render to a QWindow using

    either approach.

    \section1 Resource Management

    Windows can potentially use a lot of memory. A usual measurement is

    width times height times color depth. A window might also include multiple

    buffers to support double and triple buffering, as well as depth and stencil

    buffers. To release a window's memory resources, call the destroy() function.

    \section1 Content Orientation

    QWindow has reportContentOrientationChange() that can be used to specify

    the layout of the window contents in relation to the screen. The content

    orientation is simply a hint to the windowing system about which

    orientation the window contents are in.  It's useful when you wish to keep

    the same window size, but rotate the contents instead, especially when

    doing rotation animations between different orientations. The windowing

    system might use this value to determine the layout of system popups or

    dialogs.

    \section1 Visibility and Windowing System Exposure

    By default, the window is not visible, and you must call setVisible(true),

    or show() or similar to make it visible. To make a window hidden again,

    call setVisible(false) or hide(). The visible property describes the state

    the application wants the window to be in. Depending on the underlying

    system, a visible window might still not be shown on the screen. It could,

    for instance, be covered by other opaque windows or moved outside the

    physical area of the screen. On windowing systems that have exposure

    notifications, the isExposed() accessor describes whether the window should

    be treated as directly visible on screen. The exposeEvent() function is

    called whenever an area of the window is invalidated, for example due to the

    exposure in the windowing system changing. On windowing systems that do not

    make this information visible to the application, isExposed() will simply

    return the same value as isVisible().

    QWindow::Visibility queried through visibility() is a convenience API

    combining the functions of visible() and windowStates().

    \section1 Rendering

    There are two Qt APIs that can be used to render content into a window,

    QBackingStore for rendering with a QPainter and flushing the contents

    to a window with type QSurface::RasterSurface, and QOpenGLContext for

    rendering with OpenGL to a window with type QSurface::OpenGLSurface.

    The application can start rendering as soon as isExposed() returns \c true,

    and can keep rendering until it isExposed() returns \c false. To find out when

    isExposed() changes, reimplement exposeEvent(). The window will always get

    a resize event before the first expose event.

    \section1 Initial Geometry

    If the window's width and height are left uninitialized, the window will

    get a reasonable default geometry from the platform window. If the position

    is left uninitialized, then the platform window will allow the windowing

    system to position the window. For example on X11, the window manager

    usually does some kind of smart positioning to try to avoid having new

    windows completely obscure existing windows. However setGeometry()

    initializes both the position and the size, so if you want a fixed size but

    an automatic position, you should call resize() or setWidth() and

    setHeight() instead.

*/

/*!

    Creates a window as a top level on the \a targetScreen.

    The window is not shown until setVisible(true), show(), or similar is called.

    \sa setScreen()

*/

QWindow::QWindow(QScreen *targetScreen)

    : QObject(*new QWindowPrivate(), nullptr)

    , QSurface(QSurface::Window)

{

    Q_D(QWindow);

    d->init(targetScreen);

}

static QWindow *nonDesktopParent(QWindow *parent)

{

    if (parent && parent->type() == Qt::Desktop) {

        qWarning("QWindows cannot be reparented into desktop windows");

        return nullptr;

    }

    return parent;

}

/*!

    Creates a window as a child of the given \a parent window.

    The window will be embedded inside the parent window, its coordinates

    relative to the parent.

    The screen is inherited from the parent.

    \sa setParent()

*/

QWindow::QWindow(QWindow *parent)

    : QWindow(*new QWindowPrivate(), parent)

{

}

/*!

    Creates a window as a child of the given \a parent window with the \a dd

    private implementation.

    The window will be embedded inside the parent window, its coordinates

    relative to the parent.

    The screen is inherited from the parent.

    \internal

    \sa setParent()

*/

QWindow::QWindow(QWindowPrivate &dd, QWindow *parent)

    : QObject(dd, nonDesktopParent(parent))

    , QSurface(QSurface::Window)

{

    Q_D(QWindow);

    d->init();

}

/*!

    Destroys the window.

*/

QWindow::~QWindow()

{

    Q_D(QWindow);

    d->destroy();

    QGuiApplicationPrivate::window_list.removeAll(this);

    if (!QGuiApplicationPrivate::is_app_closing)

        QGuiApplicationPrivate::instance()->modalWindowList.removeOne(this);

    // focus_window is normally cleared in destroy(), but the window may in

    // some cases end up becoming the focus window again. Clear it again

    // here as a workaround. See QTBUG-75326.

    if (QGuiApplicationPrivate::focus_window == this)

        QGuiApplicationPrivate::focus_window = nullptr;

}

void QWindowPrivate::init(QScreen *targetScreen)

{

    Q_Q(QWindow);

    parentWindow = static_cast<QWindow *>(q->QObject::parent());

    if (!parentWindow)

        connectToScreen(targetScreen ? targetScreen : QGuiApplication::primaryScreen());

    // If your application aborts here, you are probably creating a QWindow

    // before the screen list is populated.

    if (Q_UNLIKELY(!parentWindow && !topLevelScreen)) {

        qFatal("Cannot create window: no screens available");

        exit(1);

    }

    QGuiApplicationPrivate::window_list.prepend(q);

    requestedFormat = QSurfaceFormat::defaultFormat();

}

/*!

    \enum QWindow::Visibility

    \since 5.1

    This enum describes what part of the screen the window occupies or should

    occupy.

    \value Windowed The window occupies part of the screen, but not necessarily

    the entire screen. This state will occur only on windowing systems which

    support showing multiple windows simultaneously. In this state it is

    possible for the user to move and resize the window manually, if

    WindowFlags permit it and if it is supported by the windowing system.

    \value Minimized The window is reduced to an entry or icon on the task bar,

    dock, task list or desktop, depending on how the windowing system handles

    minimized windows.

    \value Maximized The window occupies one entire screen, and the titlebar is

    still visible. On most windowing systems this is the state achieved by

    clicking the maximize button on the toolbar.

    \value FullScreen The window occupies one entire screen, is not resizable,

    and there is no titlebar. On some platforms which do not support showing

    multiple simultaneous windows, this can be the usual visibility when the

    window is not hidden.

    \value AutomaticVisibility This means to give the window a default visible

    state, which might be fullscreen or windowed depending on the platform.

    It can be given as a parameter to setVisibility but will never be

    read back from the visibility accessor.

    \value Hidden The window is not visible in any way, however it may remember

    a latent visibility which can be restored by setting AutomaticVisibility.

*/

/*!

    \property QWindow::visibility

    \brief the screen-occupation state of the window

    \since 5.1

    Visibility is whether the window should appear in the windowing system as

    normal, minimized, maximized, fullscreen or hidden.

    To set the visibility to AutomaticVisibility means to give the window

    a default visible state, which might be fullscreen or windowed depending on

    the platform.

    When reading the visibility property you will always get the actual state,

    never AutomaticVisibility.

*/

QWindow::Visibility QWindow::visibility() const

{

    Q_D(const QWindow);

    return d->visibility;

}

void QWindow::setVisibility(Visibility v)

{

    switch (v) {

    case Hidden:

        hide();

        break;

    case AutomaticVisibility:

        show();

        break;

    case Windowed:

        showNormal();

        break;

    case Minimized:

        showMinimized();

        break;

    case Maximized:

        showMaximized();

        break;

    case FullScreen:

        showFullScreen();

        break;

    default:

        Q_ASSERT(false);

        break;

    }

}

/*

    Subclasses may override this function to run custom setVisible

    logic. Subclasses that do so must call the base class implementation

    at some point to make the native window visible, and must not

    call QWindow::setVisble() since that will recurse back here.

*/

void QWindowPrivate::setVisible(bool visible)

{

    Q_Q(QWindow);

    if (this->visible != visible) {

        this->visible = visible;

        emit q->visibleChanged(visible);

        updateVisibility();

    } else if (platformWindow) {

        // Visibility hasn't changed, and the platform window is in sync

        return;

    }

    if (!platformWindow) {

        // If we have a parent window, but the parent hasn't been created yet, we

        // can defer creation until the parent is created or we're re-parented.

        if (parentWindow && !parentWindow->handle())

            return;

        // We only need to create the window if it's being shown

        if (visible)

            q->create();

    }

    if (visible) {

        // remove posted quit events when showing a new window

        QCoreApplication::removePostedEvents(qApp, QEvent::Quit);

        if (q->type() == Qt::Window) {

            QGuiApplicationPrivate *app_priv = QGuiApplicationPrivate::instance();

            QString &firstWindowTitle = app_priv->firstWindowTitle;

            if (!firstWindowTitle.isEmpty()) {

                q->setTitle(firstWindowTitle);

                firstWindowTitle = QString();

            }

            if (!app_priv->forcedWindowIcon.isNull())

                q->setIcon(app_priv->forcedWindowIcon);

            // Handling of the -qwindowgeometry, -geometry command line arguments

            static bool geometryApplied = false;

            if (!geometryApplied) {

                geometryApplied = true;

                QGuiApplicationPrivate::applyWindowGeometrySpecificationTo(q);

            }

        }

        QShowEvent showEvent;

        QGuiApplication::sendEvent(q, &showEvent);

    }

    if (q->isModal()) {

        if (visible)

            QGuiApplicationPrivate::showModalWindow(q);

        else

            QGuiApplicationPrivate::hideModalWindow(q);

    // QShapedPixmapWindow is used on some platforms for showing a drag pixmap, so don't block

    // input to this window as it is performing a drag - QTBUG-63846

    } else if (visible && QGuiApplication::modalWindow()

#if QT_CONFIG(draganddrop)

               && !qobject_cast<QShapedPixmapWindow *>(q)

#endif // QT_CONFIG(draganddrop)

              ) {

        QGuiApplicationPrivate::updateBlockedStatus(q);

    }

#ifndef QT_NO_CURSOR

    if (visible && (hasCursor || QGuiApplication::overrideCursor()))

        applyCursor();

#endif

    if (platformWindow)

        platformWindow->setVisible(visible);

    if (!visible) {

        QHideEvent hideEvent;

        QGuiApplication::sendEvent(q, &hideEvent);

    }

}

void QWindowPrivate::updateVisibility()

{

    Q_Q(QWindow);

    QWindow::Visibility old = visibility;

    if (!visible)

        visibility = QWindow::Hidden;

    else if (windowState & Qt::WindowMinimized)

        visibility = QWindow::Minimized;

    else if (windowState & Qt::WindowFullScreen)

        visibility = QWindow::FullScreen;

    else if (windowState & Qt::WindowMaximized)

        visibility = QWindow::Maximized;

    else

        visibility = QWindow::Windowed;

    if (visibility != old)

        emit q->visibilityChanged(visibility);

}

void QWindowPrivate::updateSiblingPosition(SiblingPosition position)

{

    Q_Q(QWindow);

    if (!q->parent())

        return;

    QObjectList &siblings = q->parent()->d_ptr->children;

    const int siblingCount = siblings.size() - 1;

    if (siblingCount == 0)

        return;

    const int currentPosition = siblings.indexOf(q);

    Q_ASSERT(currentPosition >= 0);

    const int targetPosition = position == PositionTop ? siblingCount : 0;

    if (currentPosition == targetPosition)

        return;

    siblings.move(currentPosition, targetPosition);

}

bool QWindowPrivate::windowRecreationRequired(QScreen *newScreen) const

{

    Q_Q(const QWindow);

    const QScreen *oldScreen = q->screen();

    return oldScreen != newScreen && (platformWindow || !oldScreen)

        && !(oldScreen && oldScreen->virtualSiblings().contains(newScreen));

}

void QWindowPrivate::disconnectFromScreen()

{

    if (topLevelScreen)

        topLevelScreen = nullptr;

}

void QWindowPrivate::connectToScreen(QScreen *screen)

{

    disconnectFromScreen();

    topLevelScreen = screen;

}

void QWindowPrivate::emitScreenChangedRecursion(QScreen *newScreen)

{

    Q_Q(QWindow);

    emit q->screenChanged(newScreen);

    for (QObject *child : q->children()) {

        if (child->isWindowType())

            static_cast<QWindow *>(child)->d_func()->emitScreenChangedRecursion(newScreen);

    }

}

void QWindowPrivate::setTopLevelScreen(QScreen *newScreen, bool recreate)

{

    Q_Q(QWindow);

    if (parentWindow) {

        qWarning() << q << '(' << newScreen << "): Attempt to set a screen on a child window.";

        return;

    }

    if (newScreen != topLevelScreen) {

        const bool shouldRecreate = recreate && windowRecreationRequired(newScreen);

        const bool shouldShow = visibilityOnDestroy && !topLevelScreen;

        if (shouldRecreate && platformWindow)

            q->destroy();

        connectToScreen(newScreen);

        if (shouldShow)

            q->setVisible(true);

        else if (newScreen && shouldRecreate)

            create(true);

        emitScreenChangedRecursion(newScreen);

    }

}

void QWindowPrivate::create(bool recursive, WId nativeHandle)

{

    Q_Q(QWindow);

    if (platformWindow)

        return;

    // avoid losing update requests when re-creating

    const bool needsUpdate = updateRequestPending;

    // the platformWindow, if there was one, is now gone, so make this flag reflect reality now

    updateRequestPending = false;

    if (q->parent())

        q->parent()->create();

    QPlatformIntegration *platformIntegration = QGuiApplicationPrivate::platformIntegration();

    platformWindow = nativeHandle ? platformIntegration->createForeignWindow(q, nativeHandle)

        : platformIntegration->createPlatformWindow(q);

    Q_ASSERT(platformWindow);

    if (!platformWindow) {

        qWarning() << "Failed to create platform window for" << q << "with flags" << q->flags();

        return;

    }

    platformWindow->initialize();

    QObjectList childObjects = q->children();

    for (int i = 0; i < childObjects.size(); i ++) {

        QObject *object = childObjects.at(i);

        if (!object->isWindowType())

            continue;

        QWindow *childWindow = static_cast<QWindow *>(object);

        if (recursive)

            childWindow->d_func()->create(recursive);

        // The child may have had deferred creation due to this window not being created

        // at the time setVisible was called, so we re-apply the visible state, which

        // may result in creating the child, and emitting the appropriate signals.

        if (childWindow->isVisible())

            childWindow->setVisible(true);

        if (QPlatformWindow *childPlatformWindow = childWindow->d_func()->platformWindow)

            childPlatformWindow->setParent(this->platformWindow);

    }

    QPlatformSurfaceEvent e(QPlatformSurfaceEvent::SurfaceCreated);

    QGuiApplication::sendEvent(q, &e);

    if (needsUpdate)

        q->requestUpdate();

}

void QWindowPrivate::clearFocusObject()

{

}

// Allows for manipulating the suggested geometry before a resize/move

// event in derived classes for platforms that support it, for example to

// implement heightForWidth().

QRectF QWindowPrivate::closestAcceptableGeometry(const QRectF &rect) const

{

    Q_UNUSED(rect)

    return QRectF();

}

/*!

    Sets the \a surfaceType of the window.

    Specifies whether the window is meant for raster rendering with

    QBackingStore, or OpenGL rendering with QOpenGLContext.

    The surfaceType will be used when the native surface is created

    in the create() function. Calling this function after the native

    surface has been created requires calling destroy() and create()

    to release the old native surface and create a new one.

    \sa QBackingStore, QOpenGLContext, create(), destroy()

*/

void QWindow::setSurfaceType(SurfaceType surfaceType)

{

    Q_D(QWindow);

    d->surfaceType = surfaceType;

}

/*!

    Returns the surface type of the window.

    \sa setSurfaceType()

*/

QWindow::SurfaceType QWindow::surfaceType() const

{

    Q_D(const QWindow);

    return d->surfaceType;

}

/*!

    \property QWindow::visible

    \brief whether the window is visible or not

    This property controls the visibility of the window in the windowing system.

    By default, the window is not visible, you must call setVisible(true), or

    show() or similar to make it visible.

    \note Hiding a window does not remove the window from the windowing system,

    it only hides it. On windowing systems that give full screen applications a

    dedicated desktop (such as macOS), hiding a full screen window will not remove

    that desktop, but leave it blank. Another window from the same application

    might be shown full screen, and will fill that desktop. Use QWindow::close to

    completely remove a window from the windowing system.

    \sa show()

*/

void QWindow::setVisible(bool visible)

{

    Q_D(QWindow);

    d->setVisible(visible);

}

bool QWindow::isVisible() const

{

    Q_D(const QWindow);

    return d->visible;

}

/*!

    Allocates the platform resources associated with the window.

    It is at this point that the surface format set using setFormat() gets resolved

    into an actual native surface. However, the window remains hidden until setVisible() is called.

    Note that it is not usually necessary to call this function directly, as it will be implicitly

    called by show(), setVisible(), and other functions that require access to the platform

    resources.

    Call destroy() to free the platform resources if necessary.

    \sa destroy()

*/

void QWindow::create()

{

    Q_D(QWindow);

    d->create(false);

}

/*!

    Returns the window's platform id.

    \note This function will cause the platform window to be created if it is not already.

    Returns 0, if the platform window creation failed.

    For platforms where this id might be useful, the value returned

    will uniquely represent the window inside the corresponding screen.

    \sa screen()

*/

WId QWindow::winId() const

{

    Q_D(const QWindow);

    if(!d->platformWindow)

        const_cast<QWindow *>(this)->create();

    if (!d->platformWindow)

        return 0;

    return d->platformWindow->winId();

}

 /*!

    Returns the parent window, if any.

    If \a mode is IncludeTransients, then the transient parent is returned

    if there is no parent.

    A window without a parent is known as a top level window.

    \since 5.9

*/

QWindow *QWindow::parent(AncestorMode mode) const

{

    Q_D(const QWindow);

    return d->parentWindow ? d->parentWindow : (mode == IncludeTransients ? transientParent() : nullptr);

}

/*!

    Returns the parent window, if any.

    A window without a parent is known as a top level window.

*/

QWindow *QWindow::parent() const

{

    Q_D(const QWindow);

    return d->parentWindow;

}

/*!

    Sets the \a parent Window. This will lead to the windowing system managing

    the clip of the window, so it will be clipped to the \a parent window.

    Setting \a parent to be \nullptr will make the window become a top level

    window.

    If \a parent is a window created by fromWinId(), then the current window

    will be embedded inside \a parent, if the platform supports it.

*/

void QWindow::setParent(QWindow *parent)

{

    parent = nonDesktopParent(parent);

    Q_D(QWindow);

    if (d->parentWindow == parent)

        return;

    QScreen *newScreen = parent ? parent->screen() : screen();

    if (d->windowRecreationRequired(newScreen)) {

        qWarning() << this << '(' << parent << "): Cannot change screens (" << screen() << newScreen << ')';

        return;

    }

    QObject::setParent(parent);

    d->parentWindow = parent;

    if (parent)

        d->disconnectFromScreen();

    else

        d->connectToScreen(newScreen);

    // If we were set visible, but not created because we were a child, and we're now

    // re-parented into a created parent, or to being a top level, we need re-apply the

    // visibility state, which will also create.

    if (isVisible() && (!parent || parent->handle()))

        setVisible(true);

    if (d->platformWindow) {

        if (parent)

            parent->create();

        d->platformWindow->setParent(parent ? parent->d_func()->platformWindow : nullptr);

    }

    QGuiApplicationPrivate::updateBlockedStatus(this);

}

/*!

    Returns whether the window is top level, i.e. has no parent window.

*/

bool QWindow::isTopLevel() const

{

    Q_D(const QWindow);

    return d->parentWindow == nullptr;

}

/*!

    Returns whether the window is modal.

    A modal window prevents other windows from getting any input.

    \sa QWindow::modality

*/

bool QWindow::isModal() const

{

    Q_D(const QWindow);

    return d->modality != Qt::NonModal;

}

/*! \property QWindow::modality

    \brief the modality of the window

    A modal window prevents other windows from receiving input events. Qt

    supports two types of modality: Qt::WindowModal and Qt::ApplicationModal.

    By default, this property is Qt::NonModal

    \sa Qt::WindowModality

*/

Qt::WindowModality QWindow::modality() const

{

    Q_D(const QWindow);

    return d->modality;

}

void QWindow::setModality(Qt::WindowModality modality)

{

    Q_D(QWindow);

    if (d->modality == modality)

        return;

    d->modality = modality;

    emit modalityChanged(modality);

}

/*! \fn void QWindow::modalityChanged(Qt::WindowModality modality)

    This signal is emitted when the Qwindow::modality property changes to \a modality.

*/

/*!

    Sets the window's surface \a format.

    The format determines properties such as color depth, alpha, depth and

    stencil buffer size, etc. For example, to give a window a transparent

    background (provided that the window system supports compositing, and

    provided that other content in the window does not make it opaque again):

    \code

    QSurfaceFormat format;

    format.setAlphaBufferSize(8);

    window.setFormat(format);

    \endcode

    The surface format will be resolved in the create() function. Calling

    this function after create() has been called will not re-resolve the

    surface format of the native surface.

    When the format is not explicitly set via this function, the format returned

    by QSurfaceFormat::defaultFormat() will be used. This means that when having

    multiple windows, individual calls to this function can be replaced by one

    single call to QSurfaceFormat::setDefaultFormat() before creating the first

    window.

    \sa create(), destroy(), QSurfaceFormat::setDefaultFormat()

*/

void QWindow::setFormat(const QSurfaceFormat &format)

{

    Q_D(QWindow);

    d->requestedFormat = format;

}

/*!

    Returns the requested surface format of this window.

    If the requested format was not supported by the platform implementation,

    the requestedFormat will differ from the actual window format.

    This is the value set with setFormat().

    \sa setFormat(), format()

 */

QSurfaceFormat QWindow::requestedFormat() const

{

    Q_D(const QWindow);

    return d->requestedFormat;

}

/*!

    Returns the actual format of this window.

    After the window has been created, this function will return the actual surface format

    of the window. It might differ from the requested format if the requested format could

    not be fulfilled by the platform. It might also be a superset, for example certain

    buffer sizes may be larger than requested.

    \note Depending on the platform, certain values in this surface format may still

    contain the requested values, that is, the values that have been passed to

    setFormat(). Typical examples are the OpenGL version, profile and options. These may

    not get updated during create() since these are context specific and a single window

    may be used together with multiple contexts over its lifetime. Use the

    QOpenGLContext's format() instead to query such values.

    \sa create(), requestedFormat(), QOpenGLContext::format()

*/

QSurfaceFormat QWindow::format() const

{

    Q_D(const QWindow);

    if (d->platformWindow)

        return d->platformWindow->format();

    return d->requestedFormat;

}

/*!

    \property QWindow::flags

    \brief the window flags of the window

    The window flags control the window's appearance in the windowing system,

    whether it's a dialog, popup, or a regular window, and whether it should

    have a title bar, etc.

    The actual window flags might differ from the flags set with setFlags()

    if the requested flags could not be fulfilled.

    \sa setFlag()

*/

void QWindow::setFlags(Qt::WindowFlags flags)

{

    Q_D(QWindow);

    if (d->windowFlags == flags)

        return;

    if (d->platformWindow)

        d->platformWindow->setWindowFlags(flags);

    d->windowFlags = flags;

}

Qt::WindowFlags QWindow::flags() const

{

    Q_D(const QWindow);

    Qt::WindowFlags flags = d->windowFlags;

    if (d->platformWindow && d->platformWindow->isForeignWindow())

        flags |= Qt::ForeignWindow;

    return flags;

}

/*!

    \since 5.9

    Sets the window flag \a flag on this window if \a on is true;

    otherwise clears the flag.

    \sa setFlags(), flags(), type()

*/

void QWindow::setFlag(Qt::WindowType flag, bool on)

{

    Q_D(QWindow);

    if (on)

        setFlags(d->windowFlags | flag);

    else

        setFlags(d->windowFlags & ~flag);

}

/*!

    Returns the type of the window.

    This returns the part of the window flags that represents

    whether the window is a dialog, tooltip, popup, regular window, etc.

    \sa flags(), setFlags()

*/

Qt::WindowType QWindow::type() const

{

    return static_cast<Qt::WindowType>(int(flags() & Qt::WindowType_Mask));

}

/*!

    \property QWindow::title

    \brief the window's title in the windowing system

    The window title might appear in the title area of the window decorations,

    depending on the windowing system and the window flags. It might also

    be used by the windowing system to identify the window in other contexts,

    such as in the task switcher.

    \sa flags()

*/

void QWindow::setTitle(const QString &title)

{

    Q_D(QWindow);

    bool changed = false;

    if (d->windowTitle != title) {

        d->windowTitle = title;

        changed = true;

    }