Remove _qpa from cpp filenames

36547f4eff44361f7a6acd0cff107c0e47561f93 removed the _qpa from .h
files and promised to remove it from .cpp files at a later date.

Change-Id: I24a5c3796f6b07dd9a1931b699f3212d315edb12
Reviewed-by: Andrew Stanley-Jones <andrew.stanley-jones@nokia.com>

1 files changed, 338 insertions, 0 deletions

diff --git a/src/gui/kernel/qplatformscreen.cpp b/src/gui/kernel/qplatformscreen.cpp
new file mode 100644
index 0000000000..d946e4f240
--- /dev/null
+++ b/src/gui/kernel/qplatformscreen.cpp
@@ -0,0 +1,338 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformscreen.h"
+#include <QtGui/qguiapplication.h>
+#include <qpa/qplatformcursor.h>
+#include <QtGui/private/qguiapplication_p.h>
+#include <qpa/qplatformscreen_p.h>
+#include <qpa/qplatformintegration.h>
+#include <QtGui/qscreen.h>
+#include <QtGui/qwindow.h>
+
+QT_BEGIN_NAMESPACE
+
+QPlatformScreen::QPlatformScreen()
+    : d_ptr(new QPlatformScreenPrivate)
+{
+    Q_D(QPlatformScreen);
+    d->screen = 0;
+}
+
+QPlatformScreen::~QPlatformScreen()
+{
+    Q_D(QPlatformScreen);
+
+    QGuiApplicationPrivate::screen_list.removeOne(d->screen);
+    delete d->screen;
+}
+
+/*!
+    \fn QPixmap QPlatformScreen::grabWindow(WId window, int x, int y, int width, int height) const
+
+    This function is called when Qt needs to be able to grab the content of a window.
+
+    Returnes the content of the window specified with the WId handle within the boundaries of
+    QRect(x,y,width,height).
+*/
+QPixmap QPlatformScreen::grabWindow(WId window, int x, int y, int width, int height) const
+{
+    Q_UNUSED(window);
+    Q_UNUSED(x);
+    Q_UNUSED(y);
+    Q_UNUSED(width);
+    Q_UNUSED(height);
+    return QPixmap();
+}
+
+/*!
+    Return the given top level window for a given position.
+
+    Default implementation retrieves a list of all top level windows and finds the first window
+    which contains point \a pos
+*/
+QWindow *QPlatformScreen::topLevelAt(const QPoint & pos) const
+{
+    QWindowList list = QGuiApplication::topLevelWindows();
+    for (int i = list.size()-1; i >= 0; --i) {
+        QWindow *w = list[i];
+        if (w->isVisible() && w->geometry().contains(pos))
+            return w;
+    }
+
+    return 0;
+}
+
+/*!
+    Returns a list of all the platform screens that are part of the same
+    virtual desktop.
+
+    Screens part of the same virtual desktop share a common coordinate system,
+    and windows can be freely moved between them.
+*/
+QList<QPlatformScreen *> QPlatformScreen::virtualSiblings() const
+{
+    QList<QPlatformScreen *> list;
+    list << const_cast<QPlatformScreen *>(this);
+    return list;
+}
+
+QScreen *QPlatformScreen::screen() const
+{
+    Q_D(const QPlatformScreen);
+    return d->screen;
+}
+
+/*!
+    Reimplement this function in subclass to return the physical size of the
+    screen, in millimeters. The physical size represents the actual physical
+    dimensions of the display.
+
+    The default implementation takes the pixel size of the screen, considers a
+    resolution of 100 dots per inch, and returns the calculated physical size.
+    A device with a screen that has different resolutions will need to be
+    supported by a suitable reimplementation of this function.
+
+    \sa logcalDpi
+*/
+QSizeF QPlatformScreen::physicalSize() const
+{
+    static const int dpi = 100;
+    return QSizeF(geometry().size()) / dpi * qreal(25.4);
+}
+
+/*!
+    Reimplement this function in subclass to return the logical horizontal
+    and vertical dots per inch metrics of the screen.
+
+    The logical dots per inch metrics are used by QFont to convert point sizes
+    to pixel sizes.
+
+    The default implementation uses the screen pixel size and physical size to
+    compute the metrics.
+
+    \sa physicalSize
+*/
+QDpi QPlatformScreen::logicalDpi() const
+{
+    QSizeF ps = physicalSize();
+    QSize s = geometry().size();
+
+    return QDpi(25.4 * s.width() / ps.width(),
+                25.4 * s.height() / ps.height());
+}
+
+/*!
+    Reimplement this function in subclass to return the vertical refresh rate
+    of the screen, in Hz.
+
+    The default returns 60, a sensible default for modern displays.
+*/
+qreal QPlatformScreen::refreshRate() const
+{
+    return 60;
+}
+
+/*!
+    Reimplement this function in subclass to return the native orientation
+    of the screen, e.g. the orientation where the logo sticker of the device
+    appears the right way up.
+
+    The default implementation returns Qt::PrimaryOrientation.
+*/
+Qt::ScreenOrientation QPlatformScreen::nativeOrientation() const
+{
+    return Qt::PrimaryOrientation;
+}
+
+/*!
+    Reimplement this function in subclass to return the current orientation
+    of the screen, for example based on accelerometer data to determine
+    the device orientation.
+
+    The default implementation returns Qt::PrimaryOrientation.
+*/
+Qt::ScreenOrientation QPlatformScreen::orientation() const
+{
+    return Qt::PrimaryOrientation;
+}
+
+/*
+    Reimplement this function in subclass to filter out unneeded screen
+    orientation updates.
+
+    The orientations will anyway be filtered before QScreen::orientationChanged()
+    is emitted, but the mask can be used by the platform plugin for example to
+    prevent having to have an accelerometer sensor running all the time, or to
+    improve the reported values. As an example of the latter, in case of only
+    Landscape | InvertedLandscape being set in the mask, on a platform that gets
+    its orientation readings from an accelerometer sensor embedded in a handheld
+    device, the platform can report transitions between the two even when the
+    device is held in an orientation that's closer to portrait.
+
+    By default, the orientation update mask is empty, so unless this function
+    has been called with a non-empty mask the platform does not need to report
+    any orientation updates through
+    QWindowSystemInterface::handleScreenOrientationChange().
+*/
+void QPlatformScreen::setOrientationUpdateMask(Qt::ScreenOrientations mask)
+{
+    Q_UNUSED(mask);
+}
+
+QPlatformScreen * QPlatformScreen::platformScreenForWindow(const QWindow *window)
+{
+    return window->screen()->handle();
+}
+
+/*!
+    \class QPlatformScreen
+    \since 4.8
+    \internal
+    \preliminary
+    \ingroup qpa
+
+    \brief The QPlatformScreen class provides an abstraction for visual displays.
+
+    Many window systems has support for retrieving information on the attached displays. To be able
+    to query the display QPA uses QPlatformScreen. Qt its self is most dependent on the
+    physicalSize() function, since this is the function it uses to calculate the dpi to use when
+    converting point sizes to pixels sizes. However, this is unfortunate on some systems, as the
+    native system fakes its dpi size.
+
+    QPlatformScreen is also used by the public api QDesktopWidget for information about the desktop.
+ */
+
+/*! \fn QRect QPlatformScreen::geometry() const = 0
+    Reimplement in subclass to return the pixel geometry of the screen
+*/
+
+/*! \fn QRect QPlatformScreen::availableGeometry() const
+    Reimplement in subclass to return the pixel geometry of the available space
+    This normally is the desktop screen minus the task manager, global menubar etc.
+*/
+
+/*! \fn int QPlatformScreen::depth() const = 0
+    Reimplement in subclass to return current depth of the screen
+*/
+
+/*! \fn QImage::Format QPlatformScreen::format() const = 0
+    Reimplement in subclass to return the image format which corresponds to the screen format
+*/
+
+
+/*!
+    \class QPlatformScreenPageFlipper
+    \since 5.0
+    \internal
+    \preliminary
+    \ingroup qpa
+
+    \brief The QPlatformScreenPageFlipper class provides an abstract interface for display buffer swapping
+
+    Implement the displayBuffer() function to initiate a buffer swap. The
+    bufferDisplayed() signal should be emitted once the buffer is actually displayed on
+    the screen. The bufferReleased() signal should be emitted when the buffer data is no
+    longer owned by the display hardware.
+*/
+
+/*!  \fn bool QPlatformScreenPageFlipper::displayBuffer(void *bufferHandle)
+
+Implemented in subclasses to display the buffer referenced by \a bufferHandle directly on
+the screen. Returns \c true if it is possible to display the buffer, and \c false if the
+buffer cannot be displayed.
+
+If this function returns true, the buffer must not be modified or destroyed before the
+bufferReleased() signal is emitted.  The signal bufferDisplayed() is emitted when the buffer
+is displayed on the screen. The two signals may be emitted in either order.
+
+This function is allowed to block.
+*/
+
+
+/*!
+  Implemented in subclasses to return a page flipper object for the screen, or 0 if the
+  hardware does not support page flipping. The default implementation returns 0.
+ */
+QPlatformScreenPageFlipper *QPlatformScreen::pageFlipper() const
+{
+    return 0;
+}
+
+/*!
+    Reimplement this function in subclass to return the cursor of the screen.
+
+    The default implementation returns 0.
+*/
+QPlatformCursor *QPlatformScreen::cursor() const
+{
+    return 0;
+}
+
+/*!
+  Convenience method to resize all the maximized and fullscreen windows
+  of this platform screen.
+*/
+void QPlatformScreen::resizeMaximizedWindows()
+{
+    QList<QWindow*> windows = QGuiApplication::allWindows();
+
+    // 'screen()' still has the old geometry info while 'this' has the new geometry info
+    const QRect oldGeometry = screen()->geometry();
+    const QRect oldAvailableGeometry = screen()->availableGeometry();
+    const QRect newGeometry = geometry();
+    const QRect newAvailableGeometry = availableGeometry();
+
+    // make sure maximized and fullscreen windows are updated
+    for (int i = 0; i < windows.size(); ++i) {
+        QWindow *w = windows.at(i);
+
+        if (platformScreenForWindow(w) != this)
+            continue;
+
+        if (w->windowState() & Qt::WindowFullScreen || w->geometry() == oldGeometry)
+            w->setGeometry(newGeometry);
+        else if (w->windowState() & Qt::WindowMaximized || w->geometry() == oldAvailableGeometry)
+            w->setGeometry(newAvailableGeometry);
+    }
+}
+
+QT_END_NAMESPACE