Merge remote-tracking branch 'origin/5.4' into dev

Conflicts:
	src/corelib/tools/qbytearray.cpp
	src/gui/image/qimage.cpp
	src/gui/image/qppmhandler.cpp
	src/gui/kernel/qguiapplication.cpp
	src/gui/painting/qpaintengine_raster.cpp

Change-Id: I7c1a8e7ebdfd7f7ae767fdb932823498a7660765

6 files changed, 91 insertions, 144 deletions

diff --git a/src/corelib/doc/snippets/code/src_corelib_io_qstorageinfo.cpp b/src/corelib/doc/snippets/code/src_corelib_io_qstorageinfo.cpp
index e5e8c1e86a..bba3703325 100644
--- a/src/corelib/doc/snippets/code/src_corelib_io_qstorageinfo.cpp
+++ b/src/corelib/doc/snippets/code/src_corelib_io_qstorageinfo.cpp
@@ -5,36 +5,28 @@
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
 **
-** $QT_BEGIN_LICENSE:LGPL$
+** $QT_BEGIN_LICENSE:LGPL21$
 ** 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 Digia.  For licensing terms and
-** conditions see http://qt.digia.com/licensing.  For further information
+** a written agreement between you and Digia. For licensing terms and
+** conditions see http://qt.digia.com/licensing. For further information
 ** use the contact form at http://qt.digia.com/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 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.
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Digia gives you certain additional
-** rights.  These rights are described in the Digia Qt LGPL Exception
+** rights. These rights are described in the Digia 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.
-**
-**
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
diff --git a/src/corelib/doc/snippets/signalsandslots/signalsandslots.cpp b/src/corelib/doc/snippets/signalsandslots/signalsandslots.cpp
index 91cd3de9d2..357269bac0 100644
--- a/src/corelib/doc/snippets/signalsandslots/signalsandslots.cpp
+++ b/src/corelib/doc/snippets/signalsandslots/signalsandslots.cpp
@@ -38,8 +38,6 @@
 **
 ****************************************************************************/
 
-#include <QAbstractButton>
-
 #include "signalsandslots.h"
 
 //! [0]
@@ -66,19 +64,4 @@ int main()
 //! [3] //! [4]
     b.setValue(48);     // a.value() == 12, b.value() == 48
 //! [4]
-
-
-    QWidget *widget = reinterpret_cast<QWidget *>(new QObject(0));
-//! [5]
-    if (widget->inherits("QAbstractButton")) {
-        QAbstractButton *button = static_cast<QAbstractButton *>(widget);
-        button->toggle();
-//! [5] //! [6]
-    }
-//! [6]
-
-//! [7]
-    if (QAbstractButton *button = qobject_cast<QAbstractButton *>(widget))
-        button->toggle();
-//! [7]
 }
diff --git a/src/corelib/doc/src/custom-types.qdoc b/src/corelib/doc/src/custom-types.qdoc
index ed846aee83..bac4a90829 100644
--- a/src/corelib/doc/src/custom-types.qdoc
+++ b/src/corelib/doc/src/custom-types.qdoc
@@ -147,7 +147,7 @@
     The output sent to the debug stream can, of course, be made as simple or as
     complicated as you like. Note that the value returned by this function is
     the QDebug object itself, though this is often obtained by calling the
-    maybeSpace() member function of QDebug that pads out the stream with space
+    \l{QDebug::}{maybeSpace()} member function of QDebug that pads out the stream with space
     characters to make it more readable.
 
     \section1 Further Reading
diff --git a/src/corelib/doc/src/eventsandfilters.qdoc b/src/corelib/doc/src/eventsandfilters.qdoc
index a880cc8187..d9b2e35e19 100644
--- a/src/corelib/doc/src/eventsandfilters.qdoc
+++ b/src/corelib/doc/src/eventsandfilters.qdoc
@@ -194,7 +194,7 @@
     \l{QCoreApplication::}{sendEvent()} processes the event immediately.
     When it returns, the event filters and/or the object itself have
     already processed the event. For many event classes there is a function
-    called isAccepted() that tells you whether the event was accepted
+    called \l{QEvent::}{isAccepted()} that tells you whether the event was accepted
     or rejected by the last handler that was called.
 
     \l{QCoreApplication::}{postEvent()} posts the event on a queue for
diff --git a/src/corelib/doc/src/filestorage.qdoc b/src/corelib/doc/src/filestorage.qdoc
index fb1279cea5..394d920923 100644
--- a/src/corelib/doc/src/filestorage.qdoc
+++ b/src/corelib/doc/src/filestorage.qdoc
@@ -30,15 +30,15 @@
 \title File and Datastream Functions
 
 The QIODevice class is the base interface class of all I/O devices in
-\l {Qt Core}.  QIODevice provides both a common implementation and an
+\l{Qt Core}.  QIODevice provides both a common implementation and an
 abstract interface for devices that support reading and writing of blocks
 of data. The device can be a memory buffer, a file, or a datastream.
 
 Some subclasses like QFile have been implemented using a memory buffer for
 intermediate storing of data. This speeds up programs by reducing
-read/write operations. Buffering makes functions like getChar() and putChar()
-fast, as they can operate on the memory buffer instead of directly on the
-device itself.
+read/write operations. Buffering makes functions like \l{QFile::}{getChar()} and
+\l{QFile::}{putChar()} fast, as they can operate on the memory buffer instead of
+directly on the device itself.
 
 The QFile class provides functions for reading from and writing to files.
 A QFile may be used by itself or, more conveniently, with a QTextStream or
@@ -48,6 +48,7 @@ QBuffer allows you to access a QByteArray using the QIODevice interface.
 The QByteArray is treated just as a standard random-accessed file.
 An example:
 
+\code
      QBuffer buffer;
      char ch;
 
@@ -58,12 +59,13 @@ An example:
      buffer.getChar(&ch);  // ch == 't'
      buffer.getChar(&ch);  // ch == ' '
      buffer.getChar(&ch);  // ch == 'r'
+\endcode
 
-Call open() to open the buffer. Then call write() or putChar() to write to
-the buffer, and read(), readLine(), readAll(), or getChar() to read from it.
-size() returns the current size of the buffer, and you can seek to arbitrary
-positions in the buffer by calling seek(). When you are done with accessing
-the buffer, call close().
+Call \l{QBuffer::}{open()} to open the buffer. Then call \l{QBuffer::}{write()} or \l{QBuffer::}{putChar()} to write to
+the buffer, and \l{QBuffer::}{read()}, \l{QBuffer::}{readLine()}, \l{QBuffer::}{readAll()}, or \l{QBuffer::}{getChar()} to read from it.
+\l{QBuffer::}{size()} returns the current size of the buffer, and you can seek to arbitrary
+positions in the buffer by calling \l{QBuffer::}{seek()}. When you are done with accessing
+the buffer, call \l{QBuffer::}{close()}.
 
 The QDataStream class provides serialization of binary data to a QIODevice.
 A data stream is a binary stream of encoded information which is 100% inde-
@@ -91,7 +93,7 @@ There are three general ways to use QTextStream when reading text files:
     \li Character by character, by streaming into QChar or char types. This
         method is often used for convenient input handling when parsing files,
         independent of character encoding and end-of-line semantics. To skip
-        white space, call skipWhiteSpace().
+        white space, call \l{QTextStream::}{skipWhiteSpace()}.
 \endlist
 
 QByteArray can be used to store both raw bytes (including \c{\0}) and traditional
diff --git a/src/corelib/doc/src/objectmodel/signalsandslots.qdoc b/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
index d290d7dc37..6dcf567c2e 100644
--- a/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
+++ b/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
@@ -36,7 +36,8 @@
     Signals and slots are used for communication between objects. The
     signals and slots mechanism is a central feature of Qt and
     probably the part that differs most from the features provided by
-    other frameworks.
+    other frameworks. Signals and slots are made possible by Qt's
+    \l{The Meta-Object System}{meta-object system}.
 
     \tableofcontents
 
@@ -112,87 +113,6 @@
     Together, signals and slots make up a powerful component programming
     mechanism.
 
-    \section1 A Small Example
-
-    A minimal C++ class declaration might read:
-
-    \snippet signalsandslots/signalsandslots.h 0
-
-    A small QObject-based class might read:
-
-    \snippet signalsandslots/signalsandslots.h 1
-    \codeline
-    \snippet signalsandslots/signalsandslots.h 2
-    \snippet signalsandslots/signalsandslots.h 3
-
-    The QObject-based version has the same internal state, and provides
-    public methods to access the state, but in addition it has support
-    for component programming using signals and slots. This class can
-    tell the outside world that its state has changed by emitting a
-    signal, \c{valueChanged()}, and it has a slot which other objects
-    can send signals to.
-
-    All classes that contain signals or slots must mention
-    Q_OBJECT at the top of their declaration. They must also derive
-    (directly or indirectly) from QObject.
-
-    Slots are implemented by the application programmer.
-    Here is a possible implementation of the \c{Counter::setValue()}
-    slot:
-
-    \snippet signalsandslots/signalsandslots.cpp 0
-
-    The \c{emit} line emits the signal \c valueChanged() from the
-    object, with the new value as argument.
-
-    In the following code snippet, we create two \c Counter objects
-    and connect the first object's \c valueChanged() signal to the
-    second object's \c setValue() slot using QObject::connect():
-
-    \snippet signalsandslots/signalsandslots.cpp 1
-    \snippet signalsandslots/signalsandslots.cpp 2
-    \codeline
-    \snippet signalsandslots/signalsandslots.cpp 3
-    \snippet signalsandslots/signalsandslots.cpp 4
-
-    Calling \c{a.setValue(12)} makes \c{a} emit a
-    \c{valueChanged(12)} signal, which \c{b} will receive in its
-    \c{setValue()} slot, i.e. \c{b.setValue(12)} is called. Then
-    \c{b} emits the same \c{valueChanged()} signal, but since no slot
-    has been connected to \c{b}'s \c{valueChanged()} signal, the
-    signal is ignored.
-
-    Note that the \c{setValue()} function sets the value and emits
-    the signal only if \c{value != m_value}. This prevents infinite
-    looping in the case of cyclic connections (e.g., if
-    \c{b.valueChanged()} were connected to \c{a.setValue()}).
-
-    By default, for every connection you make, a signal is emitted;
-    two signals are emitted for duplicate connections. You can break
-    all of these connections with a single disconnect() call.
-    If you pass the Qt::UniqueConnection \a type, the connection will only
-    be made if it is not a duplicate. If there is already a duplicate
-    (exact same signal to the exact same slot on the same objects),
-    the connection will fail and connect will return false
-
-    This example illustrates that objects can work together without needing to
-    know any information about each other. To enable this, the objects only
-    need to be connected together, and this can be achieved with some simple
-    QObject::connect() function calls, or with \c{uic}'s
-    \l{Using a Designer UI File in Your Application#Automatic Connections}
-    {automatic connections} feature.
-
-    \section1 Building the Example
-
-    The C++ preprocessor changes or removes the \c{signals},
-    \c{slots}, and \c{emit} keywords so that the compiler is
-    presented with standard C++.
-
-    By running the \l moc on class definitions that contain signals
-    or slots, a C++ source file is produced which should be compiled
-    and linked with the other object files for the application. If
-    you use \l qmake, the makefile rules to automatically invoke \c
-    moc will be added to your project's makefile.
 
     \section1 Signals
 
@@ -267,27 +187,77 @@
     alongside a Qt-based application. To solve this problem, \c
     #undef the offending preprocessor symbol.
 
-    \section1 Meta-Object Information
 
-    The meta-object compiler (\l moc) parses the class declaration in
-    a C++ file and generates C++ code that initializes the
-    meta-object. The meta-object contains the names of all the signal
-    and slot members, as well as pointers to these functions.
+    \section1 A Small Example
+
+    A minimal C++ class declaration might read:
+
+    \snippet signalsandslots/signalsandslots.h 0
+
+    A small QObject-based class might read:
+
+    \snippet signalsandslots/signalsandslots.h 1
+    \codeline
+    \snippet signalsandslots/signalsandslots.h 2
+    \snippet signalsandslots/signalsandslots.h 3
+
+    The QObject-based version has the same internal state, and provides
+    public methods to access the state, but in addition it has support
+    for component programming using signals and slots. This class can
+    tell the outside world that its state has changed by emitting a
+    signal, \c{valueChanged()}, and it has a slot which other objects
+    can send signals to.
+
+    All classes that contain signals or slots must mention
+    Q_OBJECT at the top of their declaration. They must also derive
+    (directly or indirectly) from QObject.
+
+    Slots are implemented by the application programmer.
+    Here is a possible implementation of the \c{Counter::setValue()}
+    slot:
+
+    \snippet signalsandslots/signalsandslots.cpp 0
+
+    The \c{emit} line emits the signal \c valueChanged() from the
+    object, with the new value as argument.
+
+    In the following code snippet, we create two \c Counter objects
+    and connect the first object's \c valueChanged() signal to the
+    second object's \c setValue() slot using QObject::connect():
 
-    The meta-object contains additional information such as the
-    object's \l{QMetaObject::className()}{class name}. You can
-    also check if an object \l{QObject::inherits()}{inherits}
-    a specific class, for example:
+    \snippet signalsandslots/signalsandslots.cpp 1
+    \snippet signalsandslots/signalsandslots.cpp 2
+    \codeline
+    \snippet signalsandslots/signalsandslots.cpp 3
+    \snippet signalsandslots/signalsandslots.cpp 4
+
+    Calling \c{a.setValue(12)} makes \c{a} emit a
+    \c{valueChanged(12)} signal, which \c{b} will receive in its
+    \c{setValue()} slot, i.e. \c{b.setValue(12)} is called. Then
+    \c{b} emits the same \c{valueChanged()} signal, but since no slot
+    has been connected to \c{b}'s \c{valueChanged()} signal, the
+    signal is ignored.
 
-    \snippet signalsandslots/signalsandslots.cpp 5
-    \snippet signalsandslots/signalsandslots.cpp 6
+    Note that the \c{setValue()} function sets the value and emits
+    the signal only if \c{value != m_value}. This prevents infinite
+    looping in the case of cyclic connections (e.g., if
+    \c{b.valueChanged()} were connected to \c{a.setValue()}).
 
-    The meta-object information is also used by qobject_cast<T>(), which
-    is similar to QObject::inherits() but is less error-prone:
+    By default, for every connection you make, a signal is emitted;
+    two signals are emitted for duplicate connections. You can break
+    all of these connections with a single disconnect() call.
+    If you pass the Qt::UniqueConnection \a type, the connection will only
+    be made if it is not a duplicate. If there is already a duplicate
+    (exact same signal to the exact same slot on the same objects),
+    the connection will fail and connect will return false
 
-    \snippet signalsandslots/signalsandslots.cpp 7
+    This example illustrates that objects can work together without needing to
+    know any information about each other. To enable this, the objects only
+    need to be connected together, and this can be achieved with some simple
+    QObject::connect() function calls, or with \c{uic}'s
+    \l{Using a Designer UI File in Your Application#Automatic Connections}
+    {automatic connections} feature.
 
-    See \l{Meta-Object System} for more information.
 
     \section1 A Real Example