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