Revision control
++ // 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
++ // Qt-Security score:significant reason:default
++
++ #include "qplatformintegration.h"
++
++ #include <qpa/qplatformfontdatabase.h>
++ #include <qpa/qplatformclipboard.h>
++ #include <qpa/qplatformaccessibility.h>
++ #include <qpa/qplatformkeymapper.h>
++ #include <qpa/qplatformtheme.h>
++ #include <QtGui/private/qguiapplication_p.h>
++ #include <QtGui/private/qpixmap_raster_p.h>
++
++ #if QT_CONFIG(draganddrop)
++ #include <private/qdnd_p.h>
++ #include <private/qsimpledrag_p.h>
++ #endif
++
++ #ifndef QT_NO_SESSIONMANAGER
++ # include <qpa/qplatformsessionmanager.h>
++ #endif
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ Accessor for the platform integration's fontdatabase.
++
++ Default implementation returns a default QPlatformFontDatabase.
++
++ \sa QPlatformFontDatabase
++ */
++ QPlatformFontDatabase *QPlatformIntegration::fontDatabase() const
++ {
++ static QPlatformFontDatabase *db = nullptr;
++ if (!db) {
++ db = new QPlatformFontDatabase;
++ }
++ return db;
++ }
++
++ /*!
++ Accessor for the platform integration's clipboard.
++
++ Default implementation returns a default QPlatformClipboard.
++
++ \sa QPlatformClipboard
++
++ */
++
++ #ifndef QT_NO_CLIPBOARD
++
++ QPlatformClipboard *QPlatformIntegration::clipboard() const
++ {
++ static QPlatformClipboard *clipboard = nullptr;
++ if (!clipboard) {
++ clipboard = new QPlatformClipboard;
++ }
++ return clipboard;
++ }
++
++ #endif
++
++ #if QT_CONFIG(draganddrop)
++ /*!
++ Accessor for the platform integration's drag object.
++
++ Default implementation returns QSimpleDrag. This class supports only drag
++ and drop operations within the same Qt application.
++ */
++ QPlatformDrag *QPlatformIntegration::drag() const
++ {
++ static QSimpleDrag *drag = nullptr;
++ if (!drag) {
++ drag = new QSimpleDrag;
++ }
++ return drag;
++ }
++ #endif // QT_CONFIG(draganddrop)
++
++ QPlatformNativeInterface * QPlatformIntegration::nativeInterface() const
++ {
++ return nullptr;
++ }
++
++ QPlatformServices *QPlatformIntegration::services() const
++ {
++ return nullptr;
++ }
++
++ /*!
++ \class QPlatformIntegration
++ \since 4.8
++ \internal
++ \preliminary
++ \ingroup qpa
++ \brief The QPlatformIntegration class is the entry for WindowSystem specific functionality.
++
++ QPlatformIntegration is the single entry point for windowsystem specific functionality when
++ using the QPA platform. It has factory functions for creating platform specific pixmaps and
++ windows. The class also controls the font subsystem.
++
++ QPlatformIntegration is a singleton class which gets instantiated in the QGuiApplication
++ constructor. The QPlatformIntegration instance do not have ownership of objects it creates in
++ functions where the name starts with create. However, functions which don't have a name
++ starting with create acts as accessors to member variables.
++
++ It is not trivial to create or build a platform plugin outside of the Qt source tree. Therefore
++ the recommended approach for making new platform plugin is to copy an existing plugin inside
++ the QTSRCTREE/src/plugins/platform and develop the plugin inside the source tree.
++
++ The minimal platform integration is the smallest platform integration it is possible to make,
++ which makes it an ideal starting point for new plugins. For a slightly more advanced plugin,
++ consider reviewing the directfb plugin, or the testlite plugin.
++ */
++
++ /*!
++ \fn QPlatformPixmap *QPlatformIntegration::createPlatformPixmap(QPlatformPixmap::PixelType type) const
++
++ Factory function for QPlatformPixmap. PixelType can be either PixmapType or BitmapType.
++ \sa QPlatformPixmap
++ */
++
++ /*!
++ \fn QPlatformWindow *QPlatformIntegration::createPlatformWindow(QWindow *window) const
++
++ Factory function for QPlatformWindow. The \a window parameter is a pointer to the window
++ which the QPlatformWindow is supposed to be created for.
++
++ All windows have to have a QPlatformWindow, and it will be created on-demand when the
++ QWindow is made visible for the first time, or explicitly through calling QWindow::create().
++
++ In the constructor, of the QPlatformWindow, the window flags, state, title and geometry
++ of the \a window should be applied to the underlying window. If the resulting flags or state
++ differs, the resulting values should be set on the \a window using QWindow::setWindowFlags()
++ or QWindow::setWindowState(), respectively.
++
++ \sa QPlatformWindow, QPlatformWindowFormat
++ \sa createPlatformBackingStore()
++ */
++
++ /*!
++ \fn QPlatformBackingStore *QPlatformIntegration::createPlatformBackingStore(QWindow *window) const
++
++ Factory function for QPlatformBackingStore. The QWindow parameter is a pointer to the
++ top level widget(tlw) the window surface is created for. A QPlatformWindow is always created
++ before the QPlatformBackingStore for tlw where the widget also requires a backing store.
++
++ \sa QBackingStore
++ \sa createPlatformWindow()
++ */
++
++ /*!
++ \enum QPlatformIntegration::Capability
++
++ Capabilities are used to determine specific features of a platform integration
++
++ \value ThreadedPixmaps The platform uses a pixmap implementation that is reentrant
++ and can be used from multiple threads, like the raster paint engine and QImage based
++ pixmaps.
++
++ \value OpenGL The platform supports OpenGL
++
++ \value ThreadedOpenGL The platform supports using OpenGL outside the GUI thread.
++
++ \value SharedGraphicsCache The platform supports a shared graphics cache
++
++ \value BufferQueueingOpenGL Deprecated. The OpenGL implementation on the platform will
++ queue up buffers when swapBuffers() is called and block only when its buffer pipeline
++ is full, rather than block immediately.
++
++ \value MultipleWindows The platform supports multiple QWindows, i.e. does some kind
++ of compositing either client or server side. Some platforms might only support a
++ single fullscreen window.
++
++ \value ApplicationState The platform handles the application state explicitly.
++ This means that QEvent::ApplicationActivate and QEvent::ApplicationDeativate
++ will not be posted automatically. Instead, the platform must handle application
++ state explicitly by using QWindowSystemInterface::handleApplicationStateChanged().
++ If not set, application state will follow window activation, which is the normal
++ behavior for desktop platforms.
++
++ \value ForeignWindows The platform allows creating QWindows which represent
++ native windows created by other processes or by using native libraries.
++
++ \value NonFullScreenWindows The platform supports top-level windows which do not
++ fill the screen. The default implementation returns \c true. Returning false for
++ this will cause all windows, including dialogs and popups, to be resized to fill the
++ screen.
++
++ \value WindowManagement The platform is based on a system that performs window
++ management. This includes the typical desktop platforms. Can be set to false on
++ platforms where no window management is available, meaning for example that windows
++ are never repositioned by the window manager. The default implementation returns \c true.
++
++ \value AllGLFunctionsQueryable Deprecated. Used to indicate whether the QOpenGLContext
++ backend provided by the platform is
++ able to return function pointers from getProcAddress() even for standard OpenGL
++ functions, for example OpenGL 1 functions like glClear() or glDrawArrays(). This is
++ important because the OpenGL specifications do not require this ability from the
++ getProcAddress implementations of the windowing system interfaces (EGL, WGL, GLX). The
++ platform plugins may however choose to enhance the behavior in the backend
++ implementation for QOpenGLContext::getProcAddress() and support returning a function
++ pointer also for the standard, non-extension functions. This capability is a
++ prerequisite for dynamic OpenGL loading. Starting with Qt 5.7, the platform plugin
++ is required to have this capability.
++
++ \value [since 5.5] ApplicationIcon The platform supports setting the application icon.
++
++ \value TopStackedNativeChildWindows The platform supports native child windows via
++ QWindowContainer without having to punch a transparent hole in the
++ backingstore. (since 5.10)
++
++ \value OpenGLOnRasterSurface The platform supports making a QOpenGLContext current
++ in combination with a QWindow of type RasterSurface.
++
++ \value PaintEvents The platform sends paint events instead of expose events when
++ the window needs repainting. Expose events are only sent when a window is toggled
++ from a non-exposed to exposed state or back.
++
++ \value RhiBasedRendering The platform supports one or more of the 3D rendering APIs
++ that Qt Quick and other components can use via the Qt Rendering Hardware Interface. On
++ platforms where it is clear upfront that the platform cannot, or does not want to,
++ support rendering via 3D graphics APIs such as OpenGL, Vulkan, Direct 3D, or Metal,
++ this capability can be reported as \c false. That in effect means that in modules
++ where there is an alternative, such as Qt Quick with its \c software backend, an
++ automatic fallback to that alternative may occur, if applicable. The default
++ implementation of hasCapability() returns \c true.
++
++ \value ScreenWindowGrabbing The platform supports grabbing window on screen.
++ On Wayland, this capability can be reported as \c false. The default implementation
++ of hasCapability() returns \c true.
++
++ \value BackingStoreStaticContents The platform backingstore supports static contents.
++ On resize of the backingstore the static contents region is provided, and the backing
++ store is expected to propagate the static content to the resized backing store, without
++ clients needing to repaint the static content region.
++
++ \value OffscreenSurface The platform supports creating a platform offscreen surface
++ without falling back to an implementation utilizing an invisible QWindow. A platform
++ without this capability requires QOffscreenSurface::create to be called from the GUI
++ thread.
++
++ \value MouseCursorPositioning The platform supports programmatic cursor positioning via
++ QCursor::setPos(). Platforms such as Wayland that enforce pointer confinement will
++ return \c false. The default implementation returns \c false.
++
++ \value ChildWindows The platform supports child QWindows via QWindow::setParent().
++ Platforms that implement QPlatformWindow::setParent(), either via the native
++ windowing system or by faking it in the QPA plugin, should return \c true.
++ The default implementation returns \c false.
++ */
++
++ /*!
++
++ \fn QAbstractEventDispatcher *QPlatformIntegration::createEventDispatcher() const = 0
++
++ Factory function for the GUI event dispatcher. The platform plugin should create
++ and return a QAbstractEventDispatcher subclass when this function is called.
++
++ If the platform plugin for some reason creates the event dispatcher outside of
++ this function (for example in the constructor), it needs to handle the case
++ where this function is never called, ensuring that the event dispatcher is
++ still deleted at some point (typically in the destructor).
++
++ Note that the platform plugin should never explicitly set the event dispatcher
++ itself, using QCoreApplication::setEventDispatcher(), but let QCoreApplication
++ decide when and which event dispatcher to create.
++
++ \since 5.2
++ */
++
++ bool QPlatformIntegration::hasCapability(Capability cap) const
++ {
++ return cap == NonFullScreenWindows || cap == NativeWidgets || cap == WindowManagement
++ || cap == TopStackedNativeChildWindows || cap == WindowActivation
++ || cap == RhiBasedRendering || cap == ScreenWindowGrabbing;
++ }
++
++ QPlatformPixmap *QPlatformIntegration::createPlatformPixmap(QPlatformPixmap::PixelType type) const
++ {
++ return new QRasterPlatformPixmap(type);
++ }
++
++ #ifndef QT_NO_OPENGL
++ /*!
++ Factory function for QPlatformOpenGLContext. The \a context parameter is a pointer to
++ the context for which a platform-specific context backend needs to be
++ created. Configuration settings like the format, share context and screen have to be
++ taken from this QOpenGLContext and the resulting platform context is expected to be
++ backed by a native context that fulfills these criteria.
++
++ If the context has native handles set, no new native context is expected to be created.
++ Instead, the provided handles have to be used. In this case the ownership of the handle
++ must not be taken and the platform implementation is not allowed to destroy the native
++ context. Configuration parameters like the format are also to be ignored. Instead, the
++ platform implementation is responsible for querying the configuriation from the provided
++ native context.
++
++ Returns a pointer to a QPlatformOpenGLContext instance or \nullptr if the context could
++ not be created.
++
++ \sa QOpenGLContext
++ */
++ QPlatformOpenGLContext *QPlatformIntegration::createPlatformOpenGLContext(QOpenGLContext *context) const
++ {
++ Q_UNUSED(context);
++ qWarning("This plugin does not support createPlatformOpenGLContext!");
++ return nullptr;
++ }
++ #endif // QT_NO_OPENGL
++
++ /*!
++ Factory function for QPlatformSharedGraphicsCache. This function will return 0 if the platform
++ integration does not support any shared graphics cache mechanism for the given \a cacheId.
++ */
++ QPlatformSharedGraphicsCache *QPlatformIntegration::createPlatformSharedGraphicsCache(const char *cacheId) const
++ {
++ qWarning("This plugin does not support createPlatformSharedGraphicsBuffer for cacheId: %s!",
++ cacheId);
++ return nullptr;
++ }
++
++ /*!
++ Factory function for QPaintEngine. This function will return 0 if the platform
++ integration does not support creating any paint engine the given \a paintDevice.
++ */
++ QPaintEngine *QPlatformIntegration::createImagePaintEngine(QPaintDevice *paintDevice) const
++ {
++ Q_UNUSED(paintDevice);
++ return nullptr;
++ }
++
++ /*!
++ Performs initialization steps that depend on having an event dispatcher
++ available. Called after the event dispatcher has been created.
++
++ Tasks that require an event dispatcher, for example creating socket notifiers, cannot be
++ performed in the constructor. Instead, they should be performed here. The default
++ implementation does nothing.
++ */
++ void QPlatformIntegration::initialize()
++ {
++ }
++
++ /*!
++ Called before the platform integration is deleted. Useful when cleanup relies on virtual
++ functions.
++
++ \since 5.5
++ */
++ void QPlatformIntegration::destroy()
++ {
++ }
++
++ /*!
++ Returns the platforms input context.
++
++ The default implementation returns \nullptr, implying no input method support.
++ */
++ QPlatformInputContext *QPlatformIntegration::inputContext() const
++ {
++ return nullptr;
++ }
++
++ /*!
++ Accessor for the platform integration's key mapper.
++
++ Default implementation returns a default QPlatformKeyMapper.
++
++ \sa QPlatformKeyMapper
++ */
++ QPlatformKeyMapper *QPlatformIntegration::keyMapper() const
++ {
++ static QPlatformKeyMapper *keyMapper = nullptr;
++ if (!keyMapper)
++ keyMapper = new QPlatformKeyMapper;
++ return keyMapper;
++ }
++
++ #if QT_CONFIG(accessibility)
++
++ /*!
++ Returns the platforms accessibility.
++
++ The default implementation returns QPlatformAccessibility which
++ delegates handling of accessibility to accessiblebridge plugins.
++ */
++ QPlatformAccessibility *QPlatformIntegration::accessibility() const
++ {
++ static QPlatformAccessibility *accessibility = nullptr;
++ if (Q_UNLIKELY(!accessibility)) {
++ accessibility = new QPlatformAccessibility;
++ }
++ return accessibility;
++ }
++
++ #endif
++
++ QVariant QPlatformIntegration::styleHint(StyleHint hint) const
++ {
++ switch (hint) {
++ case CursorFlashTime:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::CursorFlashTime);
++ case KeyboardInputInterval:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::KeyboardInputInterval);
++ case KeyboardAutoRepeatRate:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::KeyboardAutoRepeatRate);
++ case MouseDoubleClickInterval:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::MouseDoubleClickInterval);
++ case StartDragDistance:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::StartDragDistance);
++ case StartDragTime:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::StartDragTime);
++ case ShowIsFullScreen:
++ return false;
++ case ShowIsMaximized:
++ return false;
++ case ShowShortcutsInContextMenus:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::ShowShortcutsInContextMenus);
++ case PasswordMaskDelay:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::PasswordMaskDelay);
++ case PasswordMaskCharacter:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::PasswordMaskCharacter);
++ case FontSmoothingGamma:
++ return qreal(1.7);
++ case StartDragVelocity:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::StartDragVelocity);
++ case UseRtlExtensions:
++ return QVariant(false);
++ case SetFocusOnTouchRelease:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::SetFocusOnTouchRelease);
++ case MousePressAndHoldInterval:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::MousePressAndHoldInterval);
++ case TabFocusBehavior:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::TabFocusBehavior);
++ case ReplayMousePressOutsidePopup:
++ return true;
++ case ItemViewActivateItemOnSingleClick:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::ItemViewActivateItemOnSingleClick);
++ case UiEffects:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::UiEffects);
++ case WheelScrollLines:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::WheelScrollLines);
++ case MouseQuickSelectionThreshold:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::MouseQuickSelectionThreshold);
++ case MouseDoubleClickDistance:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::MouseDoubleClickDistance);
++ case FlickStartDistance:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::FlickStartDistance);
++ case FlickMaximumVelocity:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::FlickMaximumVelocity);
++ case FlickDeceleration:
++ return QPlatformTheme::defaultThemeHint(QPlatformTheme::FlickDeceleration);
++ case UnderlineShortcut:
++ return true;
++ }
++
++ return 0;
++ }
++
++ Qt::WindowState QPlatformIntegration::defaultWindowState(Qt::WindowFlags flags) const
++ {
++ // Leave popup-windows as is
++ if (flags & Qt::Popup & ~Qt::Window)
++ return Qt::WindowNoState;
++
++ if (flags & Qt::SubWindow)
++ return Qt::WindowNoState;
++
++ if (styleHint(QPlatformIntegration::ShowIsFullScreen).toBool())
++ return Qt::WindowFullScreen;
++ else if (styleHint(QPlatformIntegration::ShowIsMaximized).toBool())
++ return Qt::WindowMaximized;
++
++ return Qt::WindowNoState;
++ }
++
++ Qt::KeyboardModifiers QPlatformIntegration::queryKeyboardModifiers() const
++ {
++ return QGuiApplication::keyboardModifiers();
++ }
++
++ /*!
++ Should be used to obtain a list of possible shortcuts for the given key
++ event. Shortcuts should be encoded as int(Qt::Key + Qt::KeyboardModifiers).
++
++ One example for more than one possibility is the key combination of Shift+5.
++ That one might trigger a shortcut which is set as "Shift+5" as well as one
++ using %. These combinations depend on the currently set keyboard layout.
++
++ \note This function should be called only from key event handlers.
++ */
++ QList<int> QPlatformIntegration::possibleKeys(const QKeyEvent *) const
++ {
++ return QList<int>();
++ }
++
++ QStringList QPlatformIntegration::themeNames() const
++ {
++ return QStringList();
++ }
++
++ class QPlatformTheme *QPlatformIntegration::createPlatformTheme(const QString &name) const
++ {
++ Q_UNUSED(name);
++ return new QPlatformTheme;
++ }
++
++ /*!
++ Factory function for QOffscreenSurface. An offscreen surface will typically be implemented with a
++ pixel buffer (pbuffer). If the platform doesn't support offscreen surfaces, an invisible window
++ will be used by QOffscreenSurface instead.
++
++ If the platform has the OffscreenSurface capability, this should always return a valid pointer.
++ */
++ QPlatformOffscreenSurface *QPlatformIntegration::createPlatformOffscreenSurface(QOffscreenSurface *surface) const
++ {
++ Q_UNUSED(surface);
++ return nullptr;
++ }
++
++ #ifndef QT_NO_SESSIONMANAGER
++ /*!
++ \since 5.2
++
++ Factory function for QPlatformSessionManager. The default QPlatformSessionManager provides the same
++ functionality as the QSessionManager.
++ */
++ QPlatformSessionManager *QPlatformIntegration::createPlatformSessionManager(const QString &id, const QString &key) const
++ {
++ return new QPlatformSessionManager(id, key);
++ }
++ #endif
++
++ /*!
++ \since 5.2
++
++ Function to sync the platform integrations state with the window system.
++
++ This is often implemented as a roundtrip from the platformintegration to the window system.
++
++ This function should not call QWindowSystemInterface::flushWindowSystemEvents() or
++ QCoreApplication::processEvents()
++ */
++ void QPlatformIntegration::sync()
++ {
++ }
++
++ /*!
++ \since 5.7
++
++ Should sound a bell, using the default volume and sound.
++
++ \sa QApplication::beep()
++ */
++ void QPlatformIntegration::beep() const
++ {
++ }
++
++ /*!
++ \since 6.0
++
++ Asks the platform to terminate the application.
++
++ Overrides should ensure there's a callback into the QWSI
++ function handleApplicationTermination so that the quit can
++ be propagated to QtGui and the application.
++ */
++ void QPlatformIntegration::quit() const
++ {
++ QWindowSystemInterface::handleApplicationTermination<QWindowSystemInterface::SynchronousDelivery>();
++ }
++
++ #ifndef QT_NO_OPENGL
++ /*!
++ Platform integration function for querying the OpenGL implementation type.
++
++ Used only when dynamic OpenGL implementation loading is enabled.
++
++ Subclasses should reimplement this function and return a value based on
++ the OpenGL implementation they have chosen to load.
++
++ \note The return value does not indicate or limit the types of
++ contexts that can be created by a given implementation. For example
++ a desktop OpenGL implementation may be capable of creating OpenGL
++ ES-compatible contexts too.
++
++ \sa QOpenGLContext::openGLModuleType(), QOpenGLContext::isOpenGLES()
++
++ \since 5.3
++ */
++ QOpenGLContext::OpenGLModuleType QPlatformIntegration::openGLModuleType()
++ {
++ qWarning("This plugin does not support dynamic OpenGL loading!");
++ return QOpenGLContext::LibGL;
++ }
++ #endif
++
++ /*!
++ \since 5.5
++
++ Platform integration function for setting the application icon.
++
++ \sa QGuiApplication::setWindowIcon()
++ */
++ void QPlatformIntegration::setApplicationIcon(const QIcon &icon) const
++ {
++ Q_UNUSED(icon);
++ }
++
++ /*!
++ \since 6.5
++
++ Should set the application's badge to \a number.
++
++ If the number is 0 the badge should be cleared.
++
++ \sa QGuiApplication::setBadge()
++ */
++ void QPlatformIntegration::setApplicationBadge(qint64 number)
++ {
++ Q_UNUSED(number);
++ }
++
++ #if QT_CONFIG(vulkan) || defined(Q_QDOC)
++
++ /*!
++ Factory function for QPlatformVulkanInstance. The \a instance parameter is a
++ pointer to the instance for which a platform-specific backend needs to be
++ created.
++
++ Returns a pointer to a QPlatformOpenGLContext instance or \nullptr if the context could
++ not be created.
++
++ \sa QVulkanInstance
++ \since 5.10
++ */
++ QPlatformVulkanInstance *QPlatformIntegration::createPlatformVulkanInstance(QVulkanInstance *instance) const
++ {
++ Q_UNUSED(instance);
++ qWarning("This plugin does not support createPlatformVulkanInstance");
++ return nullptr;
++ }
++
++ #endif // QT_CONFIG(vulkan)
++
++ QT_END_NAMESPACE