src/gui/kernel/qplatformwindow_qpa.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
   4 ** Contact: http://www.qt-project.org/
   5 **
   6 ** This file is part of the QtGui module of the Qt Toolkit.
   7 **
   8 ** $QT_BEGIN_LICENSE:LGPL$
   9 ** GNU Lesser General Public License Usage
  10 ** This file may be used under the terms of the GNU Lesser General Public
  11 ** License version 2.1 as published by the Free Software Foundation and
  12 ** appearing in the file LICENSE.LGPL included in the packaging of this
  13 ** file. Please review the following information to ensure the GNU Lesser
  14 ** General Public License version 2.1 requirements will be met:
  15 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  16 **
  17 ** In addition, as a special exception, Nokia gives you certain additional
  18 ** rights. These rights are described in the Nokia Qt LGPL Exception
  19 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  20 **
  21 ** GNU General Public License Usage
  22 ** Alternatively, this file may be used under the terms of the GNU General
  23 ** Public License version 3.0 as published by the Free Software Foundation
  24 ** and appearing in the file LICENSE.GPL included in the packaging of this
  25 ** file. Please review the following information to ensure the GNU General
  26 ** Public License version 3.0 requirements will be met:
  27 ** http://www.gnu.org/copyleft/gpl.html.
  28 **
  29 ** Other Usage
  30 ** Alternatively, this file may be used in accordance with the terms and
  31 ** conditions contained in a signed written agreement between you and Nokia.
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "qplatformwindow.h"
  43
  44 #include <QtGui/qwindowsysteminterface_qpa.h>
  45 #include <QtGui/qwindow.h>
  46 #include <QtGui/qscreen.h>
  47
  48 QT_BEGIN_NAMESPACE
  49
  50 class QPlatformWindowPrivate
  51 {
  52     QRect rect;
  53     friend class QPlatformWindow;
  54 };
  55
  56 /*!
  57     Constructs a platform window with the given top level window.
  58 */
  59
  60 QPlatformWindow::QPlatformWindow(QWindow *window)
  61     : QPlatformSurface(window)
  62     , d_ptr(new QPlatformWindowPrivate)
  63 {
  64     Q_D(QPlatformWindow);
  65     d->rect = window->geometry();
  66 }
  67
  68 /*!
  69     Virtual destructor does not delete its top level window.
  70 */
  71 QPlatformWindow::~QPlatformWindow()
  72 {
  73 }
  74
  75 /*!
  76     Returns the window which belongs to the QPlatformWindow
  77 */
  78 QWindow *QPlatformWindow::window() const
  79 {
  80     return static_cast<QWindow *>(m_surface);
  81 }
  82
  83 /*!
  84     Returns the parent platform window (or 0 if orphan).
  85 */
  86 QPlatformWindow *QPlatformWindow::parent() const
  87 {
  88     return window()->parent() ? window()->parent()->handle() : 0;
  89 }
  90
  91 /*!
  92     Returns the platform screen handle corresponding to this platform window.
  93 */
  94 QPlatformScreen *QPlatformWindow::screen() const
  95 {
  96     return window()->screen()->handle();
  97 }
  98
  99 /*!
 100     Returns the actual surface format of the window.
 101 */
 102 QSurfaceFormat QPlatformWindow::format() const
 103 {
 104     return QSurfaceFormat();
 105 }
 106
 107 /*!
 108     This function is called by Qt whenever a window is moved or the window is resized. The resize
 109     can happen programatically(from ie. user application) or by the window manager. This means that
 110     there is no need to call this function specifically from the window manager callback, instead
 111     call QWindowSystemInterface::handleGeometryChange(QWindow *w, const QRect &newRect);
 112
 113     The position(x, y) part of the rect might be inclusive or exclusive of the window frame
 114     as returned by frameMargins(). You can detect this in the plugin by checking
 115     qt_window_private(window())->positionPolicy.
 116 */
 117 void QPlatformWindow::setGeometry(const QRect &rect)
 118 {
 119     Q_D(QPlatformWindow);
 120     d->rect = rect;
 121 }
 122
 123 /*!
 124     Returnes the current geometry of a window
 125 */
 126 QRect QPlatformWindow::geometry() const
 127 {
 128     Q_D(const QPlatformWindow);
 129     return d->rect;
 130 }
 131
 132 QMargins QPlatformWindow::frameMargins() const
 133 {
 134     return QMargins();
 135 }
 136
 137 /*!
 138     Reimplemented in subclasses to show the surface
 139     if \a visible is \c true, and hide it if \a visible is \c false.
 140
 141     The default implementation sends a synchronous expose event.
 142 */
 143 void QPlatformWindow::setVisible(bool visible)
 144 {
 145     Q_UNUSED(visible);
 146     QRect rect(QPoint(), geometry().size());
 147     QWindowSystemInterface::handleSynchronousExposeEvent(window(), rect);
 148 }
 149 /*!
 150     Requests setting the window flags of this surface
 151     to \a type. Returns the actual flags set.
 152 */
 153 Qt::WindowFlags QPlatformWindow::setWindowFlags(Qt::WindowFlags flags)
 154 {
 155     return flags;
 156 }
 157
 158
 159
 160 /*!
 161     Returns if this window is exposed in the windowing system.
 162
 163     An exposeEvent() is sent every time this value changes.
 164  */
 165
 166 bool QPlatformWindow::isExposed() const
 167 {
 168     return window()->isVisible();
 169 }
 170
 171 /*!
 172     Requests setting the window state of this surface
 173     to \a type. Returns the actual state set.
 174
 175     Qt::WindowActive can be ignored.
 176 */
 177 Qt::WindowState QPlatformWindow::setWindowState(Qt::WindowState)
 178 {
 179     return Qt::WindowNoState;
 180 }
 181
 182 /*!
 183   Reimplement in subclasses to return a handle to the native window
 184 */
 185 WId QPlatformWindow::winId() const
 186 {
 187     // Return anything but 0. Returning 0 would cause havoc with QWidgets on
 188     // very basic platform plugins that do not reimplement this function,
 189     // because the top-level widget's internalWinId() would always be 0 which
 190     // would mean top-levels are never treated as native.
 191     return WId(1);
 192 }
 193
 194 /*!
 195     This function is called to enable native child window in QPA. It is common not to support this
 196     feature in Window systems, but can be faked. When this function is called all geometry of this
 197     platform window will be relative to the parent.
 198 */
 199 //jl: It would be useful to have a property on the platform window which indicated if the sub-class
 200 // supported the setParent. If not, then geometry would be in screen coordinates.
 201 void QPlatformWindow::setParent(const QPlatformWindow *parent)
 202 {
 203     Q_UNUSED(parent);
 204     qWarning("This plugin does not support setParent!");
 205 }
 206
 207 /*!
 208   Reimplement to set the window title to \a title
 209 */
 210 void QPlatformWindow::setWindowTitle(const QString &title) { Q_UNUSED(title); }
 211
 212 /*!
 213   Reimplement to set the window icon to \a icon
 214 */
 215 void QPlatformWindow::setWindowIcon(const QIcon &icon) { Q_UNUSED(icon); }
 216
 217 /*!
 218   Reimplement to be able to let Qt raise windows to the top of the desktop
 219 */
 220 void QPlatformWindow::raise() { qWarning("This plugin does not support raise()"); }
 221
 222 /*!
 223   Reimplement to be able to let Qt lower windows to the bottom of the desktop
 224 */
 225 void QPlatformWindow::lower() { qWarning("This plugin does not support lower()"); }
 226
 227 /*!
 228   Reimplement to propagate the size hints of the QWindow.
 229
 230   The size hints include QWindow::minimumSize(), QWindow::maximumSize(),
 231   QWindow::sizeIncrement(), and QWindow::baseSize().
 232 */
 233 void QPlatformWindow::propagateSizeHints() {qWarning("This plugin does not support propagateSizeHints()"); }
 234
 235 /*!
 236   Reimplement to be able to let Qt set the opacity level of a window
 237 */
 238 void QPlatformWindow::setOpacity(qreal level)
 239 {
 240     Q_UNUSED(level);
 241     qWarning("This plugin does not support setting window opacity");
 242 }
 243
 244 /*!
 245   Reimplement to let Qt be able to request activation/focus for a window
 246
 247   Some window systems will probably not have callbacks for this functionality,
 248   and then calling QWindowSystemInterface::handleWindowActivated(QWindow *w)
 249   would be sufficient.
 250
 251   If the window system has some event handling/callbacks then call
 252   QWindowSystemInterface::handleWindowActivated(QWindow *w) when the window system
 253   gives the notification.
 254
 255   Default implementation calls QWindowSystem::handleWindowActivated(QWindow *w)
 256 */
 257 void QPlatformWindow::requestActivateWindow()
 258 {
 259     QWindowSystemInterface::handleWindowActivated(window());
 260 }
 261
 262 /*!
 263   Handle changes to the orientation of the platform window's contents.
 264
 265   This is a hint to the window manager in case it needs to display
 266   additional content like popups, dialogs, status bars, or similar
 267   in relation to the window.
 268
 269   \sa QWindow::reportContentOrientationChange()
 270 */
 271 void QPlatformWindow::handleContentOrientationChange(Qt::ScreenOrientation orientation)
 272 {
 273     Q_UNUSED(orientation);
 274 }
 275
 276 /*!
 277   Request a different orientation of the platform window.
 278
 279   This tells the window manager how the window wants to be rotated in order
 280   to be displayed, and how input events should be translated.
 281
 282   As an example, a portrait compositor might rotate the window by 90 degrees,
 283   if the window is in landscape. It will also rotate input coordinates from
 284   portrait to landscape such that top right in portrait gets mapped to top
 285   left in landscape.
 286
 287   If the implementation doesn't support the requested orientation it should
 288   signal this by returning an actual supported orientation.
 289
 290   If the implementation doesn't support rotating the window at all it should
 291   return Qt::PrimaryOrientation, this is also the default value.
 292
 293   \sa QWindow::requestWindowOrientation()
 294 */
 295 Qt::ScreenOrientation QPlatformWindow::requestWindowOrientation(Qt::ScreenOrientation orientation)
 296 {
 297     Q_UNUSED(orientation);
 298     return Qt::PrimaryOrientation;
 299 }
 300
 301 bool QPlatformWindow::setKeyboardGrabEnabled(bool grab)
 302 {
 303     Q_UNUSED(grab);
 304     qWarning("This plugin does not support grabbing the keyboard");
 305     return false;
 306 }
 307
 308 bool QPlatformWindow::setMouseGrabEnabled(bool grab)
 309 {
 310     Q_UNUSED(grab);
 311     qWarning("This plugin does not support grabbing the mouse");
 312     return false;
 313 }
 314
 315 /*!
 316     Reimplement to be able to let Qt indicate that the window has been
 317     modified. Return true if the native window supports setting the modified
 318     flag, false otherwise.
 319 */
 320 bool QPlatformWindow::setWindowModified(bool modified)
 321 {
 322     Q_UNUSED(modified);
 323     return false;
 324 }
 325
 326 /*!
 327     Reimplement this method to be able to do any platform specific event
 328     handling. All events for window() are passed to this function before being
 329     sent to QWindow::event().
 330
 331     The default implementation is empty and does nothing with \a event.
 332 */
 333 void QPlatformWindow::windowEvent(QEvent *event)
 334 {
 335     Q_UNUSED(event);
 336 }
 337
 338 /*!
 339     Reimplement this method to start a system size grip drag
 340     operation if the system supports it and return true to indicate
 341     success.
 342     It is called from the mouse press event handler of the size grip.
 343
 344     The default implementation is empty and does nothing with \a pos
 345     and \a corner.
 346 */
 347
 348 bool QPlatformWindow::startSystemResize(const QPoint &pos, Qt::Corner corner)
 349 {
 350     Q_UNUSED(pos)
 351     Q_UNUSED(corner)
 352     return false;
 353 }
 354
 355 /*!
 356     \class QPlatformWindow
 357     \since 4.8
 358     \internal
 359     \preliminary
 360     \ingroup qpa
 361
 362     \brief The QPlatformWindow class provides an abstraction for top-level windows.
 363
 364     The QPlatformWindow abstraction is used by QWindow for all its top level windows. It is being
 365     created by calling the createPlatformWindow function in the loaded QPlatformIntegration
 366     instance.
 367
 368     QPlatformWindow is used to signal to the windowing system, how Qt perceives its frame.
 369     However, it is not concerned with how Qt renders into the window it represents.
 370
 371     Visible QWindows will always have a QPlatformWindow. However, it is not necessary for
 372     all windows to have a QBackingStore. This is the case for QOpenGLWidget. And could be the case for
 373     windows where some  3.party renders into it.
 374
 375     The platform specific window handle can be retrieved by the winId function.
 376
 377     QPlatformWindow is also the way QPA defines how native child windows should be supported
 378     through the setParent function.
 379
 380     The only way to retrieve a QPlatformOpenGLContext in QPA is by calling the glContext() function
 381     on QPlatformWindow.
 382
 383     \sa QBackingStore, QWindow
 384 */
 385
 386 QT_END_NAMESPACE