Merge "Merge remote-tracking branch 'origin/stable' into dev" into refs/staging/dev

configure

@@ -797,6 +797,7 @@ CFG_SQL_AVAILABLE=
 QT_DEFAULT_BUILD_PARTS="libs tools examples"
 CFG_BUILD_PARTS=""
 CFG_NOBUILD_PARTS=""
+CFG_SKIP_MODULES=""
 CFG_RELEASE_QMAKE=no
 CFG_AUDIO_BACKEND=auto
 CFG_V8SNAPSHOT=auto
@@ -1026,7 +1027,7 @@ while [ "$#" -gt 0 ]; do
         VAL=no
         ;;
     #Qt style options that pass an argument
-    -prefix|-docdir|-headerdir|-plugindir|-importdir|-qmldir|-archdatadir|-datadir|-libdir|-bindir|-libexecdir|-translationdir|-sysconfdir|-examplesdir|-testsdir|-depths|-make|-nomake|-platform|-xplatform|-device|-device-option|-sdk|-arch|-host-arch|-mysql_config|-sysroot|-hostdatadir|-hostbindir|-qpa|-qconfig|-android-sdk|-android-ndk|-android-ndk-platform|-android-ndk-host|-android-arch|-android-toolchain-version)
+    -prefix|-docdir|-headerdir|-plugindir|-importdir|-qmldir|-archdatadir|-datadir|-libdir|-bindir|-libexecdir|-translationdir|-sysconfdir|-examplesdir|-testsdir|-depths|-make|-nomake|-skip|-platform|-xplatform|-device|-device-option|-sdk|-arch|-host-arch|-mysql_config|-sysroot|-hostdatadir|-hostbindir|-qpa|-qconfig|-android-sdk|-android-ndk|-android-ndk-platform|-android-ndk-host|-android-arch|-android-toolchain-version)
         VAR=`echo $1 | sed "s,^-\(.*\),\1,"`
         shift
         VAL="$1"
@@ -1319,6 +1320,14 @@ while [ "$#" -gt 0 ]; do
     make)
 	CFG_BUILD_PARTS="$CFG_BUILD_PARTS $VAL"
         ;;
+    skip)
+        VAL=qt${VAL#qt}
+        if ! [ -d $relpath/../$VAL ]; then
+            echo "Attempting to skip non-existent module $VAL." >&2
+            exit 1
+        fi
+        CFG_SKIP_MODULES="$CFG_SKIP_MODULES $VAL"
+        ;;
     sdk)
         if [ "$BUILD_ON_MAC" = "yes" ]; then
             DeviceVar set QMAKE_MAC_SDK "$VAL"
@@ -2736,7 +2745,7 @@ if [ "$CFG_DEBUG_RELEASE" = "yes" ]; then
 fi
 
 if [ "$CFG_FORCEDEBUGINFO" = "yes" ]; then
-    QT_CONFIG="$QT_CONFIG force_debug_info"
+    QMAKE_CONFIG="$QMAKE_CONFIG force_debug_info"
 fi
 
 # iOS builds should be static to be able to submit to the App Store
@@ -2969,7 +2978,7 @@ else
 fi
 
 if [ -z "$QT_INSTALL_LIBEXECS" ]; then #default
-    QT_INSTALL_LIBEXECS="$QT_INSTALL_ARCHDATA/$$QT_INSTALL_LIBEXECS_DIRNAME" #fallback
+    QT_INSTALL_LIBEXECS="$QT_INSTALL_ARCHDATA/$QT_INSTALL_LIBEXECS_DIRNAME" #fallback
 fi
 QT_INSTALL_LIBEXECS=`"$relpath/config.tests/unix/makeabs" "$QT_INSTALL_LIBEXECS"`
 
@@ -3232,6 +3241,9 @@ Configure options:
     -opensource ........ Compile and link the Open-Source Edition of Qt.
     -commercial ........ Compile and link the Commercial Edition of Qt.
 
+    -confirm-license.... Automatically acknowledge the license (use with
+                         either -opensource or -commercial)
+
     -no-c++11 .......... Do not compile Qt with C++11 support enabled.
  +  -c++11 ............. Compile Qt with C++11 support enabled.
 
@@ -3336,9 +3348,11 @@ Third Party Libraries:
 Additional options:
 
     -make <part> ....... Add part to the list of parts to be built at make time.
-                         ($QT_DEFAULT_BUILD_PARTS)
+                         (defaults to: $QT_DEFAULT_BUILD_PARTS)
     -nomake <part> ..... Exclude part from the list of parts to be built.
 
+    -skip <module> ..... Exclude an entire module from the build.
+
     -no-gui ............ Don't build the Qt GUI module and dependencies.
  +  -gui ............... Build the Qt GUI module and dependencies.
 
@@ -6365,6 +6379,9 @@ QTMODULE="$outpath/mkspecs/qmodule.pri"
 
 echo "CONFIG += $QMAKE_CONFIG" >> "$QTMODULE.tmp"
 echo "QT_BUILD_PARTS += $CFG_BUILD_PARTS" >> "$QTMODULE.tmp"
+if [ -n "$CFG_SKIP_MODULES" ]; then
+    echo "QT_SKIP_MODULES += $CFG_SKIP_MODULES" >> "$QTMODULE.tmp"
+fi
 
 if [ -n "$QT_CFLAGS_PSQL" ]; then
     echo "QT_CFLAGS_PSQL   = $QT_CFLAGS_PSQL" >> "$QTMODULE.tmp"

dist/changes-5.0.2

@@ -22,6 +22,9 @@ information about a particular change.
 General Improvements
 --------------------
 
+ - [QTBUG-26697] The -skip option was added to configure, which enables not
+   building particular modules. Typical use case: -skip webkit.
+
 Third party components
 ----------------------
 

examples/gui/gui.pro

@@ -3,4 +3,6 @@ CONFIG += no_docs_target
 
 SUBDIRS += analogclock
 SUBDIRS += rasterwindow
-SUBDIRS += openglwindow
+contains(QT_CONFIG, opengl(es1|es2)?) {
+    SUBDIRS += openglwindow
+}

examples/widgets/graphicsview/chip/view.cpp

@@ -47,6 +47,8 @@
 #endif
 #ifndef QT_NO_OPENGL
 #include <QtOpenGL>
+#else
+#include <QtWidgets>
 #endif
 #include <qmath.h>
 

examples/widgets/graphicsview/padnavigator/padnavigator.cpp

@@ -44,6 +44,8 @@
 
 #ifndef QT_NO_OPENGL
 #include <QtOpenGL>
+#else
+#include <QtWidgets>
 #endif
 
 //! [0]

mkspecs/blackberry-armv7le-qcc/qmake.conf

@@ -15,7 +15,7 @@ contains(QT_CONFIG, stack-protector-strong) {
     QMAKE_CFLAGS += -fstack-protector -fstack-protector-all
 }
 
-QMAKE_CFLAGS += -mcpu=cortex-a9
+QMAKE_CFLAGS += -mcpu=cortex-a9 -mtune=cortex-a9 -mthumb -D_FORTIFY_SOURCE=2
 
 QMAKE_LFLAGS_SHLIB += -Wl,-z,relro -Wl,-z,now
 

mkspecs/devices/linux-imx53qsb-g++/qmake.conf

@@ -0,0 +1,37 @@
+#
+# qmake configuration for the Freescale iMX53 board
+#
+# This mkspec is based and tested on the Yocto Project's Poky Distribution
+# with libEGL.so from Freescale without the X11 dependency.
+#
+# This mkspec is tested with a framebuffer (eglfs) configuration
+#
+# A typical configure line looks like:
+#
+# export PATH=/opt/imx53qsb/x86_64-linux/usr/bin/armv7a-vfp-neon-poky-linux-gnueabi:$PATH
+#
+# ./configure -prefix /usr/local/qt5-imx53 -hostprefix /opt/imx53qsb/x86_64-linux/usr/local/qt5-imx53 -release -device linux-imx53qsb-g++
+# -opensource -confirm-license -no-gtkstyle -device-option CROSS_COMPILE=arm-poky-linux-gnueabi- -sysroot /opt/imx53qsb/sysroot
+# -eglfs -no-pch -opengl es2 -no-xcb -silent
+
+include(../common/linux_device_pre.conf)
+
+QMAKE_INCDIR           += $$[QT_SYSROOT]/usr/include
+QMAKE_LIBDIR           += $$[QT_SYSROOT]/usr/lib
+
+QMAKE_LIBS_EGL         += -lEGL
+QMAKE_LIBS_OPENGL_ES2  += -lGLESv2 -lEGL
+QMAKE_LIBS_OPENVG      += -lOpenVG -lEGL
+
+QMAKE_LFLAGS           += -Wl,-rpath-link,$$[QT_SYSROOT]/usr/lib
+
+IMX5_CFLAGS             = -march=armv7-a -mfpu=neon -DLINUX=1 -DEGL_API_FB=1 -Wno-psabi
+IMX5_CFLAGS_RELEASE     = -O2 $$IMX5_CFLAGS
+QMAKE_CFLAGS_RELEASE   += $$IMX5_CFLAGS_RELEASE
+QMAKE_CXXFLAGS_RELEASE += $$IMX5_CFLAGS_RELEASE
+QMAKE_CFLAGS_DEBUG     += $$IMX5_CFLAGS
+QMAKE_CXXFLAGS_DEBUG   += $$IMX5_CFLAGS
+
+include(../common/linux_device_post.conf)
+
+load(qt_config)

mkspecs/devices/linux-imx53qsb-g++/qplatformdefs.h

@@ -0,0 +1,42 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the qmake spec of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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
+** 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.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** 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$
+**
+****************************************************************************/
+
+#include "../../linux-g++/qplatformdefs.h"

mkspecs/features/cmake_functions.prf

@@ -0,0 +1,26 @@
+#
+#  W A R N I N G
+#  -------------
+#
+# This file is not part of the Qt API.  It exists purely as an
+# implementation detail.  It may change from version to version
+# without notice, or even be removed.
+#
+# We mean it.
+#
+
+defineReplace(cmakeModuleName) {
+    _module = $$1
+    _name = $$eval(QT.$${_module}.name)
+    cmake_module_name = $$replace(_name, ^Qt, )
+    return ($$cmake_module_name)
+}
+
+defineReplace(cmakeModuleList) {
+    variable = $$1
+    out =
+    for(v, variable) {
+        out += $$cmakeModuleName($$v)
+    }
+    return ($$join(out, ";"))
+}

mkspecs/features/create_cmake.prf

@@ -9,21 +9,7 @@
 # We mean it.
 #
 
-defineReplace(cmakeModuleName) {
+load(cmake_functions)
-    _module = $$1
-    _name = $$eval(QT.$${_module}.name)
-    cmake_module_name = $$replace(_name, ^Qt, )
-    return ($$cmake_module_name)
-}
-
-defineReplace(cmakeModuleList) {
-    variable = $$1
-    out =
-    for(v, variable) {
-        out += $$cmakeModuleName($$v)
-    }
-    return ($$join(out, ";"))
-}
 
 defineReplace(cmakeRelativePath) {
     path = $$relative_path($$1, $$2)

mkspecs/features/ctest_testcase.prf

@@ -31,6 +31,8 @@ isEmpty(CMAKE_VERSION) {
         isEmpty(VERSION_OK) {
             message("cmake $$CMAKE_VERSION is too old for this test.")
         } else {
+            load(cmake_functions)
+
             CMAKE_BUILD_TYPE = Debug
             CONFIG(release, debug|release):CMAKE_BUILD_TYPE = Release
             win32-g++*:CMAKE_GENERATOR = -G \"MinGW Makefiles\"
@@ -41,9 +43,13 @@ isEmpty(CMAKE_VERSION) {
                 CMAKE_PREFIX_PATH *= $$dirname(d)
             }
 
+            dependentmodules = $$resolve_depends(CMAKE_QT_MODULES_UNDER_TEST, "QT.")
+            dependentmodules -= $$CMAKE_QT_MODULES_UNDER_TEST
+            dependentmodules = $$cmakeModuleList($$dependentmodules)
+
             check.commands = \
                 $(MKDIR) $$BUILD_DIR && cd $$BUILD_DIR && \
-                cmake $$_PRO_FILE_PWD_ $$CMAKE_GENERATOR -DCMAKE_BUILD_TYPE=$${CMAKE_BUILD_TYPE} -DCMAKE_PREFIX_PATH=\"$$join(CMAKE_PREFIX_PATH, ;)\" && \
+                cmake $$_PRO_FILE_PWD_ $$CMAKE_GENERATOR -DCMAKE_BUILD_TYPE=$${CMAKE_BUILD_TYPE} -DCMAKE_PREFIX_PATH=\"$$join(CMAKE_PREFIX_PATH, ;)\" -DQt5_MODULE_TEST_DEPENDS=\"$${dependentmodules}\" && \
                 $(TESTRUNNER) ctest --output-on-failure
 
         }

mkspecs/features/data/cmake/Qt5BasicConfig.cmake.in

@@ -16,70 +16,7 @@ set(Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING "$$eval(QT.$${MODULE}.MAJOR_VERSION)
 
 set(Qt5$${CMAKE_MODULE_NAME}_LIBRARIES Qt5::$${CMAKE_MODULE_NAME})
 
-!!IF !no_module_headers
+macro(_populate_$${CMAKE_MODULE_NAME}_target_properties Configuration LIB_LOCATION IMPLIB_LOCATION)
-!!IF isEmpty(CMAKE_INCLUDE_DIR_IS_ABSOLUTE)
-set(Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}\")
-set(Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS
-    \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}/${Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING}\"
-    \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}/${Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING}/$${MODULE_INCNAME}\"
-)
-!!ELSE
-set(Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS \"$${CMAKE_INCLUDE_DIR}Qt$${CMAKE_MODULE_NAME}\")
-set(Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS
-    \"$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}/${Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING}\"
-    \"$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}/${Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING}/$${MODULE_INCNAME}\"
-)
-!!ENDIF
-!!ELSE
-set(Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS)
-set(Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS)
-!!ENDIF
-
-set(Qt5$${CMAKE_MODULE_NAME}_DEFINITIONS -D$${MODULE_DEFINE})
-set(Qt5$${CMAKE_MODULE_NAME}_COMPILE_DEFINITIONS $${MODULE_DEFINE})
-
-set(_Qt5$${CMAKE_MODULE_NAME}_MODULE_DEPENDENCIES \"$${CMAKE_MODULE_DEPS}\")
-
-set(_Qt5$${CMAKE_MODULE_NAME}_FIND_DEPENDENCIES_REQUIRED)
-if (Qt5$${CMAKE_MODULE_NAME}_FIND_REQUIRED)
-    set(_Qt5$${CMAKE_MODULE_NAME}_FIND_DEPENDENCIES_REQUIRED REQUIRED)
-endif()
-set(_Qt5$${CMAKE_MODULE_NAME}_FIND_DEPENDENCIES_QUIET)
-if (Qt5$${CMAKE_MODULE_NAME}_FIND_QUIETLY)
-    set(_Qt5$${CMAKE_MODULE_NAME}_DEPENDENCIES_FIND_QUIET QUIET)
-endif()
-
-foreach(_module_dep ${_Qt5$${CMAKE_MODULE_NAME}_MODULE_DEPENDENCIES})
-    if (NOT Qt5${_module_dep}_FOUND)
-        find_package(Qt5${_module_dep}
-            ${_Qt5$${CMAKE_MODULE_NAME}_DEPENDENCIES_FIND_QUIET}
-            ${_Qt5$${CMAKE_MODULE_NAME}_FIND_DEPENDENCIES_REQUIRED}
-            PATHS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}\" NO_DEFAULT_PATH
-        )
-    endif()
-
-    if (NOT Qt5${_module_dep}_FOUND)
-        set(Qt5$${CMAKE_MODULE_NAME}_FOUND False)
-        return()
-    endif()
-
-    list(APPEND Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS \"${Qt5${_module_dep}_INCLUDE_DIRS}\")
-    list(APPEND Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS \"${Qt5${_module_dep}_PRIVATE_INCLUDE_DIRS}\")
-    list(APPEND Qt5$${CMAKE_MODULE_NAME}_DEFINITIONS ${Qt5${_module_dep}_DEFINITIONS})
-    list(APPEND Qt5$${CMAKE_MODULE_NAME}_COMPILE_DEFINITIONS ${Qt5${_module_dep}_COMPILE_DEFINITIONS})
-    list(APPEND Qt5$${CMAKE_MODULE_NAME}_EXECUTABLE_COMPILE_FLAGS ${Qt5${_module_dep}_EXECUTABLE_COMPILE_FLAGS})
-endforeach()
-list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS)
-list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS)
-list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_DEFINITIONS)
-list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_COMPILE_DEFINITIONS)
-if (Qt5$${CMAKE_MODULE_NAME}_EXECUTABLE_COMPILE_FLAGS)
-  list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_EXECUTABLE_COMPILE_FLAGS)
-endif()
-
-set(_Qt5$${CMAKE_MODULE_NAME}_LIB_DEPENDENCIES \"$${CMAKE_QT5_MODULE_DEPS}\")
-
-macro(_populate_imported_target_properties Configuration LIB_LOCATION IMPLIB_LOCATION)
     set_property(TARGET Qt5::$${CMAKE_MODULE_NAME} APPEND PROPERTY IMPORTED_CONFIGURATIONS ${Configuration})
 
     set_target_properties(Qt5::$${CMAKE_MODULE_NAME} PROPERTIES
@@ -107,6 +44,70 @@ macro(_populate_imported_target_properties Configuration LIB_LOCATION IMPLIB_LOC
 endmacro()
 
 if (NOT TARGET Qt5::$${CMAKE_MODULE_NAME})
+
+!!IF !no_module_headers
+!!IF isEmpty(CMAKE_INCLUDE_DIR_IS_ABSOLUTE)
+    set(Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}\")
+    set(Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS
+        \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}/${Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING}\"
+        \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}/${Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING}/$${MODULE_INCNAME}\"
+    )
+!!ELSE
+    set(Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS \"$${CMAKE_INCLUDE_DIR}Qt$${CMAKE_MODULE_NAME}\")
+    set(Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS
+        \"$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}/${Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING}\"
+        \"$${CMAKE_INCLUDE_DIR}$${MODULE_INCNAME}/${Qt5$${CMAKE_MODULE_NAME}_VERSION_STRING}/$${MODULE_INCNAME}\"
+    )
+!!ENDIF
+!!ELSE
+    set(Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS)
+    set(Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS)
+!!ENDIF
+
+    set(Qt5$${CMAKE_MODULE_NAME}_DEFINITIONS -D$${MODULE_DEFINE})
+    set(Qt5$${CMAKE_MODULE_NAME}_COMPILE_DEFINITIONS $${MODULE_DEFINE})
+
+    set(_Qt5$${CMAKE_MODULE_NAME}_MODULE_DEPENDENCIES \"$${CMAKE_MODULE_DEPS}\")
+
+    set(_Qt5$${CMAKE_MODULE_NAME}_FIND_DEPENDENCIES_REQUIRED)
+    if (Qt5$${CMAKE_MODULE_NAME}_FIND_REQUIRED)
+        set(_Qt5$${CMAKE_MODULE_NAME}_FIND_DEPENDENCIES_REQUIRED REQUIRED)
+    endif()
+    set(_Qt5$${CMAKE_MODULE_NAME}_FIND_DEPENDENCIES_QUIET)
+    if (Qt5$${CMAKE_MODULE_NAME}_FIND_QUIETLY)
+        set(_Qt5$${CMAKE_MODULE_NAME}_DEPENDENCIES_FIND_QUIET QUIET)
+    endif()
+
+    foreach(_module_dep ${_Qt5$${CMAKE_MODULE_NAME}_MODULE_DEPENDENCIES})
+        if (NOT Qt5${_module_dep}_FOUND)
+            find_package(Qt5${_module_dep}
+                ${_Qt5$${CMAKE_MODULE_NAME}_DEPENDENCIES_FIND_QUIET}
+                ${_Qt5$${CMAKE_MODULE_NAME}_FIND_DEPENDENCIES_REQUIRED}
+                PATHS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}\" NO_DEFAULT_PATH
+            )
+        endif()
+
+        if (NOT Qt5${_module_dep}_FOUND)
+            set(Qt5$${CMAKE_MODULE_NAME}_FOUND False)
+            return()
+        endif()
+
+        list(APPEND Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS \"${Qt5${_module_dep}_INCLUDE_DIRS}\")
+        list(APPEND Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS \"${Qt5${_module_dep}_PRIVATE_INCLUDE_DIRS}\")
+        list(APPEND Qt5$${CMAKE_MODULE_NAME}_DEFINITIONS ${Qt5${_module_dep}_DEFINITIONS})
+        list(APPEND Qt5$${CMAKE_MODULE_NAME}_COMPILE_DEFINITIONS ${Qt5${_module_dep}_COMPILE_DEFINITIONS})
+        list(APPEND Qt5$${CMAKE_MODULE_NAME}_EXECUTABLE_COMPILE_FLAGS ${Qt5${_module_dep}_EXECUTABLE_COMPILE_FLAGS})
+    endforeach()
+    list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_INCLUDE_DIRS)
+    list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_PRIVATE_INCLUDE_DIRS)
+    list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_DEFINITIONS)
+    list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_COMPILE_DEFINITIONS)
+    if (Qt5$${CMAKE_MODULE_NAME}_EXECUTABLE_COMPILE_FLAGS)
+        list(REMOVE_DUPLICATES Qt5$${CMAKE_MODULE_NAME}_EXECUTABLE_COMPILE_FLAGS)
+    endif()
+
+    set(_Qt5$${CMAKE_MODULE_NAME}_LIB_DEPENDENCIES \"$${CMAKE_QT5_MODULE_DEPS}\")
+
 !!IF !isEmpty(CMAKE_STATIC_TYPE)
     add_library(Qt5::$${CMAKE_MODULE_NAME} STATIC IMPORTED)
     set_property(TARGET Qt5::$${CMAKE_MODULE_NAME} PROPERTY IMPORTED_LINK_INTERFACE_LANGUAGES "CXX")
@@ -117,44 +118,11 @@ if (NOT TARGET Qt5::$${CMAKE_MODULE_NAME})
     set_property(TARGET Qt5::$${CMAKE_MODULE_NAME} PROPERTY FRAMEWORK 1)
 !!ENDIF
 
-!!IF !isEmpty(CMAKE_DEBUG_TYPE)
-!!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
-    _populate_imported_target_properties(DEBUG \"$${CMAKE_IMPLIB_FILE_LOCATION_DEBUG}\" \"\" )
-!!ELSE
-    _populate_imported_target_properties(DEBUG \"$${CMAKE_LIB_FILE_LOCATION_DEBUG}\" \"$${CMAKE_IMPLIB_FILE_LOCATION_DEBUG}\" )
-!!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
-
-!!IF !isEmpty(CMAKE_FIND_OTHER_LIBRARY_BUILD)
-!!IF isEmpty(CMAKE_RELEASE_TYPE)
-!!IF isEmpty(CMAKE_LIB_DIR_IS_ABSOLUTE)
-!!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
-    if (EXISTS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_LIB_DIR}$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
-!!ELSE
-    if (EXISTS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_LIB_DIR}$${CMAKE_LIB_FILE_LOCATION_RELEASE}\" AND EXISTS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_LIB_DIR}$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
-!!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
-!!ELSE
-!!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
-    if (EXISTS \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
-!!ELSE
-    if (EXISTS \"$${CMAKE_LIB_FILE_LOCATION_RELEASE}\" AND EXISTS \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
-!!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
-!!ENDIF
-!!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
-        _populate_imported_target_properties(RELEASE \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" \"\" )
-!!ELSE
-        _populate_imported_target_properties(RELEASE \"$${CMAKE_LIB_FILE_LOCATION_RELEASE}\" \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
-!!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
-    endif()
-!!ENDIF // CMAKE_RELEASE_TYPE
-!!ENDIF // CMAKE_FIND_OTHER_LIBRARY_BUILD
-
-!!ENDIF // CMAKE_DEBUG_TYPE
-
 !!IF !isEmpty(CMAKE_RELEASE_TYPE)
 !!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
-    _populate_imported_target_properties(RELEASE \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" \"\" )
+    _populate_$${CMAKE_MODULE_NAME}_target_properties(RELEASE \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" \"\" )
 !!ELSE
-    _populate_imported_target_properties(RELEASE \"$${CMAKE_LIB_FILE_LOCATION_RELEASE}\" \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
+    _populate_$${CMAKE_MODULE_NAME}_target_properties(RELEASE \"$${CMAKE_LIB_FILE_LOCATION_RELEASE}\" \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
 !!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
 
 !!IF !isEmpty(CMAKE_FIND_OTHER_LIBRARY_BUILD)
@@ -173,9 +141,9 @@ if (NOT TARGET Qt5::$${CMAKE_MODULE_NAME})
 !!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
 !!ENDIF
 !!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
-        _populate_imported_target_properties(DEBUG \"$${CMAKE_IMPLIB_FILE_LOCATION_DEBUG}\" \"\" )
+        _populate_$${CMAKE_MODULE_NAME}_target_properties(DEBUG \"$${CMAKE_IMPLIB_FILE_LOCATION_DEBUG}\" \"\" )
 !!ELSE
-        _populate_imported_target_properties(DEBUG \"$${CMAKE_LIB_FILE_LOCATION_DEBUG}\" \"$${CMAKE_IMPLIB_FILE_LOCATION_DEBUG}\" )
+        _populate_$${CMAKE_MODULE_NAME}_target_properties(DEBUG \"$${CMAKE_LIB_FILE_LOCATION_DEBUG}\" \"$${CMAKE_IMPLIB_FILE_LOCATION_DEBUG}\" )
 !!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
     endif()
 !!ENDIF // CMAKE_DEBUG_TYPE
@@ -183,6 +151,39 @@ if (NOT TARGET Qt5::$${CMAKE_MODULE_NAME})
 
 !!ENDIF // CMAKE_RELEASE_TYPE
 
+!!IF !isEmpty(CMAKE_DEBUG_TYPE)
+!!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
+    _populate_$${CMAKE_MODULE_NAME}_target_properties(DEBUG \"$${CMAKE_IMPLIB_FILE_LOCATION_DEBUG}\" \"\" )
+!!ELSE
+    _populate_$${CMAKE_MODULE_NAME}_target_properties(DEBUG \"$${CMAKE_LIB_FILE_LOCATION_DEBUG}\" \"$${CMAKE_IMPLIB_FILE_LOCATION_DEBUG}\" )
+!!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
+
+!!IF !isEmpty(CMAKE_FIND_OTHER_LIBRARY_BUILD)
+!!IF isEmpty(CMAKE_RELEASE_TYPE)
+!!IF isEmpty(CMAKE_LIB_DIR_IS_ABSOLUTE)
+!!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
+    if (EXISTS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_LIB_DIR}$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
+!!ELSE
+    if (EXISTS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_LIB_DIR}$${CMAKE_LIB_FILE_LOCATION_RELEASE}\" AND EXISTS \"${_qt5$${CMAKE_MODULE_NAME}_install_prefix}/$${CMAKE_LIB_DIR}$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
+!!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
+!!ELSE
+!!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
+    if (EXISTS \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
+!!ELSE
+    if (EXISTS \"$${CMAKE_LIB_FILE_LOCATION_RELEASE}\" AND EXISTS \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
+!!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
+!!ENDIF
+!!IF !isEmpty(CMAKE_STATIC_WINDOWS_BUILD)
+        _populate_$${CMAKE_MODULE_NAME}_target_properties(RELEASE \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" \"\" )
+!!ELSE
+        _populate_$${CMAKE_MODULE_NAME}_target_properties(RELEASE \"$${CMAKE_LIB_FILE_LOCATION_RELEASE}\" \"$${CMAKE_IMPLIB_FILE_LOCATION_RELEASE}\" )
+!!ENDIF // CMAKE_STATIC_WINDOWS_BUILD
+    endif()
+!!ENDIF // CMAKE_RELEASE_TYPE
+!!ENDIF // CMAKE_FIND_OTHER_LIBRARY_BUILD
+
+!!ENDIF // CMAKE_DEBUG_TYPE
+
 !!IF !isEmpty(CMAKE_MODULE_EXTRAS)
     include(\"${CMAKE_CURRENT_LIST_DIR}/Qt5$${CMAKE_MODULE_NAME}ConfigExtras.cmake\")
 !!ENDIF

mkspecs/features/qt_example_installs.prf

@@ -93,8 +93,8 @@ probase = $$relative_path($$_PRO_FILE_PWD_, $$dirname(_QMAKE_CONF_)/examples)
         !isEmpty(allfiles): warning("remaining files in $$_PRO_FILE_PWD_: $$allfiles")
     }
 
-    # Do not actually build the examples in production builds
+    # Do not actually build the examples in production builds with -prefix
-    !equals(TEMPLATE, subdirs):!contains(QT_CONFIG, private_tests) {
+    !equals(TEMPLATE, subdirs):prefix_build:!contains(QT_CONFIG, private_tests) {
         TEMPLATE = aux
         CONFIG -= have_target qt staticlib dll
         SOURCES =

mkspecs/features/qt_functions.prf

@@ -19,10 +19,7 @@ defineReplace(qtLibraryTarget) {
        MAJOR_VERSION = $$section(VERSION, ., 0, 0)
        LIBRARY_NAME ~= s,^Qt,Qt$$MAJOR_VERSION,
    }
-   unset(LIBRARY_SUFFIX)
+   return($$LIBRARY_NAME$$qtPlatformTargetSuffix())
-   contains(TEMPLATE, .*lib):LIBRARY_SUFFIX = $$qtPlatformTargetSuffix()
-   isEmpty(LIBRARY_SUFFIX):return($$LIBRARY_NAME)
-   else:return($$member(LIBRARY_NAME, 0)$$LIBRARY_SUFFIX)
 }
 
 defineTest(qtAddLibrary) {
@@ -108,12 +105,7 @@ defineTest(qtAddModule) {
 
     isEmpty(LINKAGE) {
        !isEmpty(MODULE_LIBS_ADD): LINKAGE = -L$$MODULE_LIBS_ADD
-       lib =
+       lib = $${MODULE_NAME}$${QT_LIBINFIX}$$qtPlatformTargetSuffix()
-       if(!debug_and_release|build_pass):CONFIG(debug, debug|release) {
-           win32: lib = $${MODULE_NAME}$${QT_LIBINFIX}d
-           mac: lib = $${MODULE_NAME}$${QT_LIBINFIX}_debug
-       }
-       isEmpty(lib): lib = $${MODULE_NAME}$${QT_LIBINFIX}
        LINKAGE += -l$$lib
 
        contains(QT_CONFIG, rpath): QMAKE_RPATHDIR *= $$eval(QT.$${1}.rpath)

qmake/generators/mac/pbuilder_pbx.cpp

@@ -930,19 +930,23 @@ ProjectBuilderMakefileGenerator::writeMakeParts(QTextStream &t)
                     QString filetype = xcodeFiletypeForFilename(library);
                     QString key = keyFor(library);
                     if (!project->values("QMAKE_PBX_LIBRARIES").contains(key)) {
+                        bool is_frmwrk = (library.endsWith(".framework"));
                         t << "\t\t" << key << " = {" << "\n"
                           << "\t\t\t" << writeSettings("isa", "PBXFileReference", SettingsNoQuote) << ";" << "\n"
                           << "\t\t\t" << writeSettings("name", escapeFilePath(name)) << ";" << "\n"
                           << "\t\t\t" << writeSettings("path", escapeFilePath(library)) << ";" << "\n"
+                          << "\t\t\t" << writeSettings("refType", QString::number(reftypeForFile(library)), SettingsNoQuote) << ";" << "\n"
                           << "\t\t\t" << writeSettings("sourceTree", sourceTreeForFile(library)) << ";" << "\n";
-                        if (!filetype.isNull())
+                        if (is_frmwrk)
-                            t << "\t\t\t" << writeSettings("lastKnownFileType", filetype) << ";" << "\n";
+                            t << "\t\t\t" << writeSettings("lastKnownFileType", "wrapper.framework") << ";" << "\n";
                         t << "\t\t" << "};" << "\n";
                         project->values("QMAKE_PBX_LIBRARIES").append(key);
                         QString build_key = keyFor(library + ".BUILDABLE");
                         t << "\t\t" << build_key << " = {" << "\n"
                           << "\t\t\t" << writeSettings("fileRef", key) << ";" << "\n"
                           << "\t\t\t" << writeSettings("isa", "PBXBuildFile", SettingsNoQuote) << ";" << "\n"
+                          << "\t\t\t" << "settings = {" << "\n"
+                          << "\t\t\t" << "};" << "\n"
                           << "\t\t" << "};" << "\n";
                         project->values("QMAKE_PBX_BUILD_LIBRARIES").append(build_key);
                     }

qmake/generators/makefile.cpp

@@ -3161,11 +3161,8 @@ MakefileGenerator::pkgConfigFixPath(QString path) const
 void
 MakefileGenerator::writePkgConfigFile()
 {
-    QString fname = pkgConfigFileName(), lname = fname;
+    QString fname = pkgConfigFileName();
     mkdir(fileInfo(fname).path());
-    int slsh = lname.lastIndexOf(Option::dir_sep);
-    if(slsh != -1)
-        lname = lname.right(lname.length() - slsh - 1);
     QFile ft(fname);
     if(!ft.open(QIODevice::WriteOnly))
         return;
@@ -3252,7 +3249,7 @@ MakefileGenerator::writePkgConfigFile()
         pkgConfiglibName = "-framework " + bundle + " ";
     } else {
         pkgConfiglibDir = "-L${libdir}";
-        pkgConfiglibName = "-l" + lname.left(lname.length()-Option::libtool_ext.length());
+        pkgConfiglibName = "-l" + fileInfo(fname).completeBaseName();
         if (project->isActiveConfig("shared"))
             pkgConfiglibName += project->first("TARGET_VERSION_EXT").toQString();
     }

src/corelib/doc/snippets/code/src_corelib_global_qglobal.cpp

@@ -598,3 +598,13 @@ bool readConfiguration(const QFile &file)
            break;
    }
 //! [qunreachable-switch]
+
+//! [qt-version-check]
+#include <QtGlobal>
+
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
+#include <QtWidgets>
+#else
+#include <QtGui>
+#endif
+//! [qt-version-check]

src/corelib/doc/snippets/plugins/extrafiltersplugin.h

@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef EXTRAFILTERSPLUGIN_H
+#define EXTRAFILTERSPLUGIN_H
+
+//! [0]
+#include <QObject>
+#include <QtPlugin>
+#include <QStringList>
+#include <QImage>
+
+#include <plugandpaint/interfaces.h>
+
+class ExtraFiltersPlugin : public QObject, public FilterInterface
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.PlugAndPaint.FilterInterface" FILE "extrafilters.json")
+    Q_INTERFACES(FilterInterface)
+
+public:
+    QStringList filters() const;
+    QImage filterImage(const QString &filter, const QImage &image,
+                       QWidget *parent);
+};
+//! [0]
+
+#endif

src/corelib/doc/snippets/plugins/interfaces.h

@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef INTERFACES_H
+#define INTERFACES_H
+
+#include <QtPlugin>
+
+QT_BEGIN_NAMESPACE
+class QImage;
+class QPainter;
+class QWidget;
+class QPainterPath;
+class QPoint;
+class QRect;
+class QString;
+class QStringList;
+QT_END_NAMESPACE
+
+//! [0]
+class BrushInterface
+{
+public:
+    virtual ~BrushInterface() {}
+
+    virtual QStringList brushes() const = 0;
+    virtual QRect mousePress(const QString &brush, QPainter &painter,
+                             const QPoint &pos) = 0;
+    virtual QRect mouseMove(const QString &brush, QPainter &painter,
+                            const QPoint &oldPos, const QPoint &newPos) = 0;
+    virtual QRect mouseRelease(const QString &brush, QPainter &painter,
+                               const QPoint &pos) = 0;
+};
+//! [0]
+
+//! [1]
+class ShapeInterface
+{
+public:
+    virtual ~ShapeInterface() {}
+
+    virtual QStringList shapes() const = 0;
+    virtual QPainterPath generateShape(const QString &shape,
+                                       QWidget *parent) = 0;
+};
+//! [1]
+
+//! [2]
+class FilterInterface
+{
+public:
+    virtual ~FilterInterface() {}
+
+    virtual QStringList filters() const = 0;
+    virtual QImage filterImage(const QString &filter, const QImage &image,
+                               QWidget *parent) = 0;
+};
+//! [2]
+
+QT_BEGIN_NAMESPACE
+//! [3] //! [4]
+#define BrushInterface_iid "org.qt-project.Qt.Examples.PlugAndPaint.BrushInterface"
+
+Q_DECLARE_INTERFACE(BrushInterface, BrushInterface_iid)
+//! [3]
+
+#define ShapeInterface_iid  "org.qt-project.Qt.Examples.PlugAndPaint.ShapeInterface"
+
+Q_DECLARE_INTERFACE(ShapeInterface, ShapeInterface_iid)
+//! [5]
+#define FilterInterface_iid "org.qt-project.Qt.Examples.PlugAndPaint.FilterInterface"
+
+Q_DECLARE_INTERFACE(FilterInterface, FilterInterface_iid)
+//! [4] //! [5]
+QT_END_NAMESPACE
+
+#endif

src/corelib/doc/snippets/timers/analogclock.cpp

@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the examples of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:BSD$
+** You may use this file under the terms of the BSD license as follows:
+**
+** "Redistribution and use in source and binary forms, with or without
+** modification, are permitted provided that the following conditions are
+** met:
+**   * Redistributions of source code must retain the above copyright
+**     notice, this list of conditions and the following disclaimer.
+**   * Redistributions in binary form must reproduce the above copyright
+**     notice, this list of conditions and the following disclaimer in
+**     the documentation and/or other materials provided with the
+**     distribution.
+**   * Neither the name of Digia Plc and its Subsidiary(-ies) nor the names
+**     of its contributors may be used to endorse or promote products derived
+**     from this software without specific prior written permission.
+**
+**
+** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtWidgets>
+
+#include "analogclock.h"
+
+//! [0] //! [1]
+AnalogClock::AnalogClock(QWidget *parent)
+//! [0] //! [2]
+    : QWidget(parent)
+//! [2] //! [3]
+{
+//! [3] //! [4]
+    QTimer *timer = new QTimer(this);
+//! [4] //! [5]
+    connect(timer, SIGNAL(timeout()), this, SLOT(update()));
+//! [5] //! [6]
+    timer->start(1000);
+//! [6]
+
+    setWindowTitle(tr("Analog Clock"));
+    resize(200, 200);
+//! [7]
+}
+//! [1] //! [7]
+
+//! [8] //! [9]
+void AnalogClock::paintEvent(QPaintEvent *)
+//! [8] //! [10]
+{
+    static const QPoint hourHand[3] = {
+        QPoint(7, 8),
+        QPoint(-7, 8),
+        QPoint(0, -40)
+    };
+    static const QPoint minuteHand[3] = {
+        QPoint(7, 8),
+        QPoint(-7, 8),
+        QPoint(0, -70)
+    };
+
+    QColor hourColor(127, 0, 127);
+    QColor minuteColor(0, 127, 127, 191);
+
+    int side = qMin(width(), height());
+    QTime time = QTime::currentTime();
+//! [10]
+
+//! [11]
+    QPainter painter(this);
+//! [11] //! [12]
+    painter.setRenderHint(QPainter::Antialiasing);
+//! [12] //! [13]
+    painter.translate(width() / 2, height() / 2);
+//! [13] //! [14]
+    painter.scale(side / 200.0, side / 200.0);
+//! [9] //! [14]
+
+//! [15]
+    painter.setPen(Qt::NoPen);
+//! [15] //! [16]
+    painter.setBrush(hourColor);
+//! [16]
+
+//! [17] //! [18]
+    painter.save();
+//! [17] //! [19]
+    painter.rotate(30.0 * ((time.hour() + time.minute() / 60.0)));
+    painter.drawConvexPolygon(hourHand, 3);
+    painter.restore();
+//! [18] //! [19]
+
+//! [20]
+    painter.setPen(hourColor);
+//! [20] //! [21]
+
+    for (int i = 0; i < 12; ++i) {
+        painter.drawLine(88, 0, 96, 0);
+        painter.rotate(30.0);
+    }
+//! [21]
+
+//! [22]
+    painter.setPen(Qt::NoPen);
+//! [22] //! [23]
+    painter.setBrush(minuteColor);
+
+//! [24]
+    painter.save();
+    painter.rotate(6.0 * (time.minute() + time.second() / 60.0));
+    painter.drawConvexPolygon(minuteHand, 3);
+    painter.restore();
+//! [23] //! [24]
+
+//! [25]
+    painter.setPen(minuteColor);
+//! [25] //! [26]
+
+//! [27]
+    for (int j = 0; j < 60; ++j) {
+        if ((j % 5) != 0)
+            painter.drawLine(92, 0, 96, 0);
+        painter.rotate(6.0);
+    }
+//! [27]
+}
+//! [26]

src/corelib/doc/src/plugins-howto.qdoc

@@ -184,12 +184,12 @@
 
     For example, here's the definition of an interface class:
 
-    \snippet tools/plugandpaint/interfaces.h 2
+    \snippet plugins/interfaces.h 2
 
     Here's the definition of a plugin class that implements that
     interface:
 
-    \snippet tools/plugandpaintplugins/extrafilters/extrafiltersplugin.h 0
+    \snippet plugins/extrafiltersplugin.h 0
 
     The \l{tools/plugandpaint}{Plug & Paint} example documentation
     explains this process in detail. See also \l{Creating Custom

src/corelib/doc/src/timers.qdoc

@@ -102,14 +102,14 @@
     QTimer to redraw a widget at regular intervals. From \c{AnalogClock}'s
     implementation:
 
-    \snippet analogclock.cpp 0
+    \snippet timers/analogclock.cpp 0
-    \snippet analogclock.cpp 2
+    \snippet timers/analogclock.cpp 2
-    \snippet analogclock.cpp 3
+    \snippet timers/analogclock.cpp 3
-    \snippet analogclock.cpp 4
+    \snippet timers/analogclock.cpp 4
-    \snippet analogclock.cpp 5
+    \snippet timers/analogclock.cpp 5
-    \snippet analogclock.cpp 6
+    \snippet timers/analogclock.cpp 6
     \dots
-    \snippet analogclock.cpp 7
+    \snippet timers/analogclock.cpp 7
 
     Every second, QTimer will call the QWidget::update() slot to
     refresh the clock's display.

src/corelib/global/qglobal.cpp

@@ -846,6 +846,10 @@ Q_CORE_EXPORT void *qMemSet(void *dest, int c, size_t n);
     integer, 0xMMNNPP (MM = major, NN = minor, PP = patch). This can
     be compared with another similarly processed version id.
 
+    Example:
+
+    \snippet code/src_corelib_global_qglobal.cpp qt-version-check
+
     \sa QT_VERSION
 */
 

src/corelib/io/qfsfileengine.cpp

@@ -128,7 +128,7 @@ void QFSFileEnginePrivate::init()
 #ifdef Q_OS_WIN
     fileAttrib = INVALID_FILE_ATTRIBUTES;
     fileHandle = INVALID_HANDLE_VALUE;
-    mapHandle = INVALID_HANDLE_VALUE;
+    mapHandle = NULL;
 #ifndef Q_OS_WINCE
     cachedFd = -1;
 #endif

src/corelib/io/qfsfileengine_win.cpp

@@ -921,7 +921,7 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
         return 0;
     }
 
-    if (mapHandle == INVALID_HANDLE_VALUE) {
+    if (mapHandle == NULL) {
         // get handle to the file
         HANDLE handle = fileHandle;
 
@@ -954,7 +954,7 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
         // first create the file mapping handle
         DWORD protection = (openMode & QIODevice::WriteOnly) ? PAGE_READWRITE : PAGE_READONLY;
         mapHandle = ::CreateFileMapping(handle, 0, protection, 0, 0, 0);
-        if (mapHandle == INVALID_HANDLE_VALUE) {
+        if (mapHandle == NULL) {
             q->setError(QFile::PermissionsError, qt_error_string());
 #ifdef Q_USE_DEPRECATED_MAP_API
             ::CloseHandle(handle);
@@ -997,6 +997,7 @@ uchar *QFSFileEnginePrivate::map(qint64 offset, qint64 size,
     }
 
     ::CloseHandle(mapHandle);
+    mapHandle = NULL;
     return 0;
 }
 
@@ -1016,7 +1017,7 @@ bool QFSFileEnginePrivate::unmap(uchar *ptr)
     maps.remove(ptr);
     if (maps.isEmpty()) {
         ::CloseHandle(mapHandle);
-        mapHandle = INVALID_HANDLE_VALUE;
+        mapHandle = NULL;
     }
 
     return true;

src/corelib/io/qstandardpaths_win.cpp

@@ -160,10 +160,10 @@ QString QStandardPaths::writableLocation(StandardLocation type)
         // Although Microsoft has a Cache key it is a pointer to IE's cache, not a cache
         // location for everyone.  Most applications seem to be using a
         // cache directory located in their AppData directory
-        return writableLocation(DataLocation) + QLatin1String("\\cache");
+        return writableLocation(DataLocation) + QLatin1String("/cache");
 
     case GenericCacheLocation:
-        return writableLocation(GenericDataLocation) + QLatin1String("\\cache");
+        return writableLocation(GenericDataLocation) + QLatin1String("/cache");
 
     case RuntimeLocation:
     case HomeLocation:

src/corelib/io/qurlquery.cpp

@@ -49,6 +49,7 @@ QT_BEGIN_NAMESPACE
 /*!
   \class QUrlQuery
   \inmodule QtCore
+  \since 5.0
 
   \brief The QUrlQuery class provides a way to manipulate a key-value pairs in
   a URL's query.

src/corelib/itemmodels/qabstractitemmodel.cpp

@@ -2295,7 +2295,6 @@ void QAbstractItemModel::doSetRoleNames(const QHash<int,QByteArray> &roleNames)
 
     Returns the model's role names.
 
-    \sa setRoleNames()
 */
 QHash<int,QByteArray> QAbstractItemModel::roleNames() const
 {

src/corelib/itemmodels/qidentityproxymodel.cpp

@@ -74,7 +74,7 @@ class QIdentityProxyModelPrivate : public QAbstractProxyModelPrivate
     void _q_sourceColumnsAboutToBeMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest);
     void _q_sourceColumnsMoved(const QModelIndex &sourceParent, int sourceStart, int sourceEnd, const QModelIndex &destParent, int dest);
 
-    void _q_sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight);
+    void _q_sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles);
     void _q_sourceHeaderDataChanged(Qt::Orientation orientation, int first, int last);
 
     void _q_sourceLayoutAboutToBeChanged(const QList<QPersistentModelIndex> &sourceParents, QAbstractItemModel::LayoutChangeHint hint);
@@ -371,8 +371,8 @@ void QIdentityProxyModel::setSourceModel(QAbstractItemModel* newSourceModel)
                    this, SLOT(_q_sourceModelAboutToBeReset()));
         disconnect(sourceModel(), SIGNAL(modelReset()),
                    this, SLOT(_q_sourceModelReset()));
-        disconnect(sourceModel(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+        disconnect(sourceModel(), SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
-                   this, SLOT(_q_sourceDataChanged(QModelIndex,QModelIndex)));
+                   this, SLOT(_q_sourceDataChanged(QModelIndex,QModelIndex,QVector<int>)));
         disconnect(sourceModel(), SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
                    this, SLOT(_q_sourceHeaderDataChanged(Qt::Orientation,int,int)));
         disconnect(sourceModel(), SIGNAL(layoutAboutToBeChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)),
@@ -412,8 +412,8 @@ void QIdentityProxyModel::setSourceModel(QAbstractItemModel* newSourceModel)
                 SLOT(_q_sourceModelAboutToBeReset()));
         connect(sourceModel(), SIGNAL(modelReset()),
                 SLOT(_q_sourceModelReset()));
-        connect(sourceModel(), SIGNAL(dataChanged(QModelIndex,QModelIndex)),
+        connect(sourceModel(), SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)),
-                SLOT(_q_sourceDataChanged(QModelIndex,QModelIndex)));
+                SLOT(_q_sourceDataChanged(QModelIndex,QModelIndex,QVector<int>)));
         connect(sourceModel(), SIGNAL(headerDataChanged(Qt::Orientation,int,int)),
                 SLOT(_q_sourceHeaderDataChanged(Qt::Orientation,int,int)));
         connect(sourceModel(), SIGNAL(layoutAboutToBeChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)),
@@ -480,12 +480,12 @@ void QIdentityProxyModelPrivate::_q_sourceColumnsRemoved(const QModelIndex &pare
     q->endRemoveColumns();
 }
 
-void QIdentityProxyModelPrivate::_q_sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)
+void QIdentityProxyModelPrivate::_q_sourceDataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QVector<int> &roles)
 {
     Q_ASSERT(topLeft.isValid() ? topLeft.model() == model : true);
     Q_ASSERT(bottomRight.isValid() ? bottomRight.model() == model : true);
     Q_Q(QIdentityProxyModel);
-    q->dataChanged(q->mapFromSource(topLeft), q->mapFromSource(bottomRight));
+    q->dataChanged(q->mapFromSource(topLeft), q->mapFromSource(bottomRight), roles);
 }
 
 void QIdentityProxyModelPrivate::_q_sourceHeaderDataChanged(Qt::Orientation orientation, int first, int last)

src/corelib/itemmodels/qidentityproxymodel.h

@@ -100,7 +100,7 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsAboutToBeMoved(QModelIndex,int,int,QModelIndex,int))
     Q_PRIVATE_SLOT(d_func(), void _q_sourceColumnsMoved(QModelIndex,int,int,QModelIndex,int))
 
-    Q_PRIVATE_SLOT(d_func(), void _q_sourceDataChanged(QModelIndex,QModelIndex))
+    Q_PRIVATE_SLOT(d_func(), void _q_sourceDataChanged(QModelIndex,QModelIndex,QVector<int>))
     Q_PRIVATE_SLOT(d_func(), void _q_sourceHeaderDataChanged(Qt::Orientation orientation, int first, int last))
 
     Q_PRIVATE_SLOT(d_func(), void _q_sourceLayoutAboutToBeChanged(const QList<QPersistentModelIndex> &sourceParents, QAbstractItemModel::LayoutChangeHint hint))

src/corelib/itemmodels/qstringlistmodel.cpp

@@ -189,7 +189,7 @@ bool QStringListModel::setData(const QModelIndex &index, const QVariant &value,
     if (index.row() >= 0 && index.row() < lst.size()
         && (role == Qt::EditRole || role == Qt::DisplayRole)) {
         lst.replace(index.row(), value.toString());
-        emit dataChanged(index, index);
+        emit dataChanged(index, index, QVector<int>() << role);
         return true;
     }
     return false;

src/corelib/kernel/kernel.pri

@@ -92,6 +92,8 @@ mac {
 }
 
 mac:!nacl {
+       HEADERS += \
+                kernel/qcore_mac_p.h
        SOURCES += \
                 kernel/qcore_mac.cpp
        OBJECTIVE_SOURCES += \

src/corelib/kernel/qcore_mac_p.h

@@ -108,6 +108,7 @@ public:
 	return *this;
     }
     inline T *operator&() { return &type; }
+    template <typename X> X as() const { return reinterpret_cast<X>(type); }
     static QCFType constructFromGet(const T &t)
     {
         CFRetain(t);

src/corelib/kernel/qpointer.cpp

@@ -158,6 +158,7 @@
 
 /*!
     \fn void QPointer::clear()
+    \since 5.0
 
     Clears this QPointer object.
 

src/corelib/kernel/qtimerinfo_unix.cpp

@@ -94,8 +94,7 @@ timespec QTimerInfoList::updateCurrentTime()
 
 #if ((_POSIX_MONOTONIC_CLOCK-0 <= 0) && !defined(Q_OS_MAC) && !defined(Q_OS_INTEGRITY)) || defined(QT_BOOTSTRAPPED)
 
-template <>
+timespec qAbsTimespec(const timespec &t)
-timespec qAbs(const timespec &t)
 {
     timespec tmp = t;
     if (tmp.tv_sec < 0) {
@@ -144,7 +143,7 @@ bool QTimerInfoList::timeChanged(timespec *delta)
     timespec tickGranularity;
     tickGranularity.tv_sec = 0;
     tickGranularity.tv_nsec = msPerTick * 1000 * 1000;
-    return elapsedTimeTicks < ((qAbs(*delta) - tickGranularity) * 10);
+    return elapsedTimeTicks < ((qAbsTimespec(*delta) - tickGranularity) * 10);
 }
 
 /*

src/corelib/tools/qlocale_mac.mm

@@ -432,18 +432,26 @@ QVariant QSystemLocale::query(QueryType type, QVariant in = QVariant()) const
     case CurrencyToString:
         return macFormatCurrency(in.value<QSystemLocale::CurrencyToStringArgument>());
     case UILanguages: {
-        QCFType<CFArrayRef> languages = (CFArrayRef)CFPreferencesCopyValue(
+        QCFType<CFPropertyListRef> languages = (CFArrayRef)CFPreferencesCopyValue(
                  CFSTR("AppleLanguages"),
                  kCFPreferencesAnyApplication,
                  kCFPreferencesCurrentUser,
                  kCFPreferencesAnyHost);
-        const int cnt = languages == NULL ? 0 : CFArrayGetCount(languages);
         QStringList result;
-        result.reserve(cnt);
+        CFTypeID typeId = CFGetTypeID(languages);
-        for (int i = 0; i < cnt; ++i) {
+        if (typeId == CFArrayGetTypeID()) {
-            const QString lang = QCFString::toQString(
+            const int cnt = CFArrayGetCount(languages.as<CFArrayRef>());
-                        static_cast<CFStringRef>(CFArrayGetValueAtIndex(languages, i)));
+            result.reserve(cnt);
-            result.append(lang);
+            for (int i = 0; i < cnt; ++i) {
+                const QString lang = QCFString::toQString(
+                            static_cast<CFStringRef>(CFArrayGetValueAtIndex(languages.as<CFArrayRef>(), i)));
+                result.append(lang);
+            }
+        } else if (typeId == CFStringGetTypeID()) {
+            result = QStringList(QCFString::toQString(languages.as<CFStringRef>()));
+        } else {
+            qWarning("QLocale::uiLanguages(): CFPreferencesCopyValue returned unhandled type \"%s\"; please report to http://bugreports.qt-project.org",
+                     qPrintable(QCFString::toQString(CFCopyTypeIDDescription(typeId))));
         }
         return QVariant(result);
     }

src/corelib/tools/qstring.cpp

@@ -9553,6 +9553,8 @@ float QStringRef::toFloat(bool *ok) const
 */
 
 /*!
+    \since 5.0
+
     Converts a plain text string to an HTML string with
     HTML metacharacters \c{<}, \c{>}, \c{&}, and \c{"} replaced by HTML
     entities.
@@ -9621,6 +9623,19 @@ QString QString::toHtmlEscaped() const
   \code
   if (attribute.name() == QLatin1String("http-contents-length")) //...
   \endcode
+
+  \note There some restrictions when using the MSVC 2010 or 2012 compilers. The example snippets provided here
+  fail to compile with them.
+  \list
+  \li Concatenated string literals cannot be used with QStringLiteral.
+  \code
+  QString s = QStringLiteral("a" "b");
+  \endcode
+  \li QStringLiteral cannot be used to initialize lists or arrays of QString.
+  \code
+  QString a[] = { QStringLiteral("a"), QStringLiteral("b") };
+  \endcode
+  \endlist
 */
 
 QT_END_NAMESPACE

src/corelib/tools/qvector.h

@@ -504,8 +504,7 @@ void QVector<T>::reallocData(const int asize, const int aalloc, QArrayData::Allo
     }
     if (d != x) {
         if (!d->ref.deref()) {
-            Q_ASSERT(!isShared);
+            if (QTypeInfo<T>::isStatic || !aalloc || (isShared && QTypeInfo<T>::isComplex)) {
-            if (QTypeInfo<T>::isStatic || !aalloc) {
                 // data was copy constructed, we need to call destructors
                 // or if !alloc we did nothing to the old 'd'.
                 freeData(d);

src/gui/doc/src/dnd.qdoc

@@ -33,8 +33,7 @@
     \ingroup qt-gui-concepts
 
     Drag and drop provides a simple visual mechanism which users can use
-    to transfer information between and within applications. (In the
+    to transfer information between and within applications. Drag
-    literature this is referred to as a "direct manipulation model".) Drag
     and drop is similar in function to the clipboard's cut and paste
     mechanism.
 

src/gui/image/qimagereader.cpp

@@ -133,6 +133,7 @@
 // factory loader
 #include <qcoreapplication.h>
 #include <private/qfactoryloader_p.h>
+#include <QMutexLocker>
 
 // image handlers
 #include <private/qbmphandler_p.h>
@@ -233,6 +234,9 @@ static QImageIOHandler *createReadHandlerHelper(QIODevice *device,
     QByteArray suffix;
 
 #ifndef QT_NO_IMAGEFORMATPLUGIN
+    static QMutex mutex;
+    QMutexLocker locker(&mutex);
+
     typedef QMultiMap<int, QString> PluginKeyMap;
 
     // check if we have plugins that support the image format

src/gui/itemmodels/qstandarditemmodel.cpp

@@ -2714,7 +2714,7 @@ bool QStandardItemModel::hasChildren(const QModelIndex &parent) const
 */
 QModelIndex QStandardItemModel::sibling(int row, int column, const QModelIndex &idx) const
 {
-    return createIndex(row, column, idx.internalPointer());
+    return QAbstractItemModel::sibling(row, column, idx);
 }
 
 /*!

src/gui/itemmodels/qstandarditemmodel.h

@@ -330,6 +330,7 @@ public:
     int rowCount(const QModelIndex &parent = QModelIndex()) const;
     int columnCount(const QModelIndex &parent = QModelIndex()) const;
     bool hasChildren(const QModelIndex &parent = QModelIndex()) const;
+    // Qt 6: Remove
     QModelIndex sibling(int row, int column, const QModelIndex &idx) const;
 
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;

src/gui/kernel/qguiapplication.cpp

@@ -1591,6 +1591,8 @@ void QGuiApplicationPrivate::processActivatedEvent(QWindowSystemInterfacePrivate
     }
 
     QGuiApplicationPrivate::focus_window = newFocus;
+    if (!qApp)
+        return;
 
     if (previous) {
         QFocusEvent focusOut(QEvent::FocusOut);

src/gui/kernel/qplatformwindow.cpp

@@ -41,11 +41,13 @@
 
 #include "qplatformwindow.h"
 #include "qplatformwindow_p.h"
+#include "qplatformscreen.h"
 
 #include <private/qguiapplication_p.h>
 #include <qpa/qwindowsysteminterface.h>
 #include <QtGui/qwindow.h>
 #include <QtGui/qscreen.h>
+#include <private/qwindow_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -460,6 +462,43 @@ QString QPlatformWindow::formatWindowTitle(const QString &title, const QString &
     return fullTitle;
 }
 
+/*!
+    Helper function to get initial geometry on windowing systems which do not
+    do smart positioning and also do not provide a means of centering a
+    transient window w.r.t. its parent. For example this is useful on Windows
+    and MacOS but not X11, because an X11 window manager typically tries to
+    layout new windows to optimize usage of the available desktop space.
+    However if the given window already has geometry which the application has
+    initialized, it takes priority.
+*/
+QRect QPlatformWindow::initialGeometry(const QWindow *w,
+    const QRect &initialGeometry, int defaultWidth, int defaultHeight)
+{
+    QRect rect(initialGeometry);
+    if (rect.isNull()) {
+        QSize minimumSize = w->minimumSize();
+        if (minimumSize.width() > 0 || minimumSize.height() > 0) {
+            rect.setSize(minimumSize);
+        } else {
+            rect.setWidth(defaultWidth);
+            rect.setHeight(defaultHeight);
+        }
+    }
+    if (w->isTopLevel() && qt_window_private(const_cast<QWindow*>(w))->positionAutomatic) {
+        const QWindow *tp = w->transientParent();
+        if (tp) {
+            // A transient window should be centered w.r.t. its transient parent.
+            rect.moveCenter(tp->geometry().center());
+        } else {
+            // Center the window on the screen.  (Only applicable on platforms
+            // which do not provide a better way.)
+            QPlatformScreen *scr = QPlatformScreen::platformScreenForWindow(w);
+            rect.moveCenter(scr->availableGeometry().center());
+        }
+    }
+    return rect;
+}
+
 /*!
     \class QPlatformWindow
     \since 4.8

src/gui/kernel/qplatformwindow.h

@@ -128,6 +128,9 @@ public:
     virtual void setFrameStrutEventsEnabled(bool enabled);
     virtual bool frameStrutEventsEnabled() const;
 
+    static QRect initialGeometry(const QWindow *w,
+        const QRect &initialGeometry, int defaultWidth, int defaultHeight);
+
 protected:
     static QString formatWindowTitle(const QString &title, const QString &separator);
 

src/gui/kernel/qwindow.cpp

@@ -129,6 +129,18 @@ QT_BEGIN_NAMESPACE
     and can keep rendering until it isExposed() returns false. To find out when
     isExposed() changes, reimplement exposeEvent(). The window will always get
     a resize event before the first expose event.
+
+    \section1 Initial geometry
+
+    If the window's width and height are left uninitialized, the window will
+    get a reasonable default geometry from the platform window. If the position
+    is left uninitialized, then the platform window will allow the windowing
+    system to position the window. For example on X11, the window manager
+    usually does some kind of smart positioning to try to avoid having new
+    windows completely obscure existing windows. However setGeometry()
+    initializes both the position and the size, so if you want a fixed size but
+    an automatic position, you should call resize() or setWidth() and
+    setHeight() instead.
 */
 
 /*!
@@ -1125,7 +1137,7 @@ void QWindow::setY(int arg)
 void QWindow::setWidth(int arg)
 {
     if (width() != arg)
-        setGeometry(QRect(x(), y(), arg, height()));
+        resize(arg, height());
 }
 
 /*!
@@ -1135,7 +1147,7 @@ void QWindow::setWidth(int arg)
 void QWindow::setHeight(int arg)
 {
     if (height() != arg)
-        setGeometry(QRect(x(), y(), width(), arg));
+        resize(width(), arg);
 }
 
 /*!
@@ -1258,6 +1270,7 @@ void QWindow::setGeometry(int posx, int posy, int w, int h)
 void QWindow::setGeometry(const QRect &rect)
 {
     Q_D(QWindow);
+    d->positionAutomatic = false;
     if (rect == geometry())
         return;
     QRect oldRect = geometry();

src/gui/kernel/qwindow_p.h

@@ -87,6 +87,7 @@ public:
         , resizeEventPending(true)
         , receivedExpose(false)
         , positionPolicy(WindowFrameExclusive)
+        , positionAutomatic(true)
         , contentOrientation(Qt::PrimaryOrientation)
         , opacity(qreal(1.0))
         , minimumSize(0, 0)
@@ -141,6 +142,7 @@ public:
     bool resizeEventPending;
     bool receivedExpose;
     PositionPolicy positionPolicy;
+    bool positionAutomatic;
     Qt::ScreenOrientation contentOrientation;
     qreal opacity;
     QRegion mask;

src/platformsupport/linuxaccessibility/atspiadaptor.cpp

@@ -1104,23 +1104,64 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event)
         }
         break;
     }
+        // For now we ignore these events
     case QAccessible::TableModelChanged:
-        // For now we ignore this event and hope that
+        // For tables, setting manages_descendants should
-        // setting manages_descendants works.
+        // indicate to the client that it cannot cache these
-        break;
+        // interfaces.
     case QAccessible::ParentChanged:
-        break;
     case QAccessible::DialogStart:
-        break;
     case QAccessible::DialogEnd:
-        break;
     case QAccessible::SelectionRemove:
-        break;
+    case QAccessible::PopupMenuStart:
-    default:
+    case QAccessible::PopupMenuEnd:
-        QAIPointer iface = QAIPointer(event->accessibleInterface());
+    case QAccessible::SoundPlayed:
-        qAtspiDebug() << "QSpiAccessible::accessibleEvent not handled: " << QString::number(event->type(), 16)
+    case QAccessible::Alert:
-                   << " obj: " << iface->object()
+    case QAccessible::ForegroundChanged:
-                   << ((iface->isValid() && iface->object()) ? iface->object()->objectName() : QLatin1String(" invalid interface!"));
+    case QAccessible::MenuStart:
+    case QAccessible::MenuEnd:
+    case QAccessible::ContextHelpStart:
+    case QAccessible::ContextHelpEnd:
+    case QAccessible::DragDropStart:
+    case QAccessible::DragDropEnd:
+    case QAccessible::ScrollingStart:
+    case QAccessible::ScrollingEnd:
+    case QAccessible::MenuCommand:
+    case QAccessible::ActionChanged:
+    case QAccessible::ActiveDescendantChanged:
+    case QAccessible::AttributeChanged:
+    case QAccessible::DocumentContentChanged:
+    case QAccessible::DocumentLoadComplete:
+    case QAccessible::DocumentLoadStopped:
+    case QAccessible::DocumentReload:
+    case QAccessible::HyperlinkEndIndexChanged:
+    case QAccessible::HyperlinkNumberOfAnchorsChanged:
+    case QAccessible::HyperlinkSelectedLinkChanged:
+    case QAccessible::HypertextLinkActivated:
+    case QAccessible::HypertextLinkSelected:
+    case QAccessible::HyperlinkStartIndexChanged:
+    case QAccessible::HypertextChanged:
+    case QAccessible::HypertextNLinksChanged:
+    case QAccessible::ObjectAttributeChanged:
+    case QAccessible::PageChanged:
+    case QAccessible::SectionChanged:
+    case QAccessible::TableCaptionChanged:
+    case QAccessible::TableColumnDescriptionChanged:
+    case QAccessible::TableColumnHeaderChanged:
+    case QAccessible::TableRowDescriptionChanged:
+    case QAccessible::TableRowHeaderChanged:
+    case QAccessible::TableSummaryChanged:
+    case QAccessible::TextAttributeChanged:
+    case QAccessible::TextColumnChanged:
+    case QAccessible::VisibleDataChanged:
+    case QAccessible::ObjectReorder:
+    case QAccessible::SelectionAdd:
+    case QAccessible::SelectionWithin:
+    case QAccessible::LocationChanged:
+    case QAccessible::HelpChanged:
+    case QAccessible::DefaultActionChanged:
+    case QAccessible::AcceleratorChanged:
+    case QAccessible::InvalidEvent:
         break;
     }
 }

src/plugins/bearer/connman/qconnmanengine.cpp

@@ -159,7 +159,7 @@ void QConnmanEngine::connectToId(const QString &id)
             QOfonoDataConnectionManagerInterface dc(modemPath,0);
             foreach (const QDBusObjectPath &dcPath,dc.getPrimaryContexts()) {
                 if(dcPath.path().contains(servicePath.section("_",-1))) {
-                    QOfonoPrimaryDataContextInterface primaryContext(dcPath.path(),0);
+                    QOfonoConnectionContextInterface primaryContext(dcPath.path(),0);
                     primaryContext.setActive(true);
                 }
             }
@@ -183,7 +183,7 @@ void QConnmanEngine::disconnectFromId(const QString &id)
             QOfonoDataConnectionManagerInterface dc(modemPath,0);
             foreach (const QDBusObjectPath &dcPath,dc.getPrimaryContexts()) {
                 if(dcPath.path().contains(servicePath.section("_",-1))) {
-                    QOfonoPrimaryDataContextInterface primaryContext(dcPath.path(),0);
+                    QOfonoConnectionContextInterface primaryContext(dcPath.path(),0);
                     primaryContext.setActive(false);
                 }
             }

src/plugins/bearer/connman/qofonoservice_linux.cpp

@@ -108,7 +108,7 @@ QDBusObjectPath QOfonoManagerInterface::currentModem()
     foreach (const QDBusObjectPath &modem, modems) {
         QOfonoModemInterface device(modem.path());
         if (device.isPowered() && device.isOnline())
-        return modem;;
+        return modem;
     }
     return QDBusObjectPath();
 }
@@ -770,7 +770,7 @@ QVariantMap QOfonoDataConnectionManagerInterface::getProperties()
     return reply.value();
 }
 
-QOfonoPrimaryDataContextInterface::QOfonoPrimaryDataContextInterface(const QString &dbusPathName, QObject *parent)
+QOfonoConnectionContextInterface::QOfonoConnectionContextInterface(const QString &dbusPathName, QObject *parent)
     : QDBusAbstractInterface(QLatin1String(OFONO_SERVICE),
                              dbusPathName,
                              OFONO_DATA_CONTEXT_INTERFACE,
@@ -778,68 +778,68 @@ QOfonoPrimaryDataContextInterface::QOfonoPrimaryDataContextInterface(const QStri
 {
 }
 
-QOfonoPrimaryDataContextInterface::~QOfonoPrimaryDataContextInterface()
+QOfonoConnectionContextInterface::~QOfonoConnectionContextInterface()
 {
 }
 
-bool QOfonoPrimaryDataContextInterface::isActive()
+bool QOfonoConnectionContextInterface::isActive()
 {
     QVariant var = getProperty("Active");
     return qdbus_cast<bool>(var);
 }
 
-QString QOfonoPrimaryDataContextInterface::getApName()
+QString QOfonoConnectionContextInterface::getApName()
 {
     QVariant var = getProperty("AccessPointName");
     return qdbus_cast<QString>(var);
 }
 
-QString QOfonoPrimaryDataContextInterface::getType()
+QString QOfonoConnectionContextInterface::getType()
 {
     QVariant var = getProperty("Type");
     return qdbus_cast<QString>(var);
 }
 
-QString QOfonoPrimaryDataContextInterface::getName()
+QString QOfonoConnectionContextInterface::getName()
 {
     QVariant var = getProperty("Name");
     return qdbus_cast<QString>(var);
 }
 
-QVariantMap QOfonoPrimaryDataContextInterface::getSettings()
+QVariantMap QOfonoConnectionContextInterface::getSettings()
 {
     QVariant var = getProperty("Settings");
     return qdbus_cast<QVariantMap>(var);
 }
 
-QString QOfonoPrimaryDataContextInterface::getInterface()
+QString QOfonoConnectionContextInterface::getInterface()
 {
     QVariant var = getProperty("Interface");
     return qdbus_cast<QString>(var);
 }
 
-QString QOfonoPrimaryDataContextInterface::getAddress()
+QString QOfonoConnectionContextInterface::getAddress()
 {
     QVariant var = getProperty("Address");
     return qdbus_cast<QString>(var);
 }
 
-bool QOfonoPrimaryDataContextInterface::setActive(bool on)
+bool QOfonoConnectionContextInterface::setActive(bool on)
 {
 //    this->setProperty("Active", QVariant(on));
 
     return setProp("Active", QVariant::fromValue(on));
 }
 
-bool QOfonoPrimaryDataContextInterface::setApn(const QString &name)
+bool QOfonoConnectionContextInterface::setApn(const QString &name)
 {
     return setProp("AccessPointName", QVariant::fromValue(name));
 }
 
-void QOfonoPrimaryDataContextInterface::connectNotify(const QMetaMethod &signal)
+void QOfonoConnectionContextInterface::connectNotify(const QMetaMethod &signal)
 {
     Q_UNUSED(signal);
-//    static const QMetaMethod propertyChangedSignal = QMetaMethod::fromSignal(&QOfonoPrimaryDataContextInterface::propertyChanged);
+//    static const QMetaMethod propertyChangedSignal = QMetaMethod::fromSignal(&QOfonoConnectionContextInterface::propertyChanged);
 //    if (signal == propertyChangedSignal) {
 //        if (!connection().connect(QLatin1String(OFONO_SERVICE),
 //                               this->path(),
@@ -850,7 +850,7 @@ void QOfonoPrimaryDataContextInterface::connectNotify(const QMetaMethod &signal)
 //        }
 //    }
 
-//    static const QMetaMethod propertyChangedContextSignal = QMetaMethod::fromSignal(&QOfonoPrimaryDataContextInterface::propertyChangedContext);
+//    static const QMetaMethod propertyChangedContextSignal = QMetaMethod::fromSignal(&QOfonoConnectionContextInterface::propertyChangedContext);
 //    if (signal == propertyChangedContextSignal) {
 //        QOfonoDBusHelper *helper;
 //        helper = new QOfonoDBusHelper(this);
@@ -867,16 +867,16 @@ void QOfonoPrimaryDataContextInterface::connectNotify(const QMetaMethod &signal)
 //    }
 }
 
-void QOfonoPrimaryDataContextInterface::disconnectNotify(const QMetaMethod &signal)
+void QOfonoConnectionContextInterface::disconnectNotify(const QMetaMethod &signal)
 {
     Q_UNUSED(signal);
-//    static const QMetaMethod propertyChangedSignal = QMetaMethod::fromSignal(&QOfonoPrimaryDataContextInterface::propertyChanged);
+//    static const QMetaMethod propertyChangedSignal = QMetaMethod::fromSignal(&QOfonoConnectionContextInterface::propertyChanged);
 //    if (signal == propertyChangedSignal) {
 
 //    }
 }
 
-QVariant QOfonoPrimaryDataContextInterface::getProperty(const QString &property)
+QVariant QOfonoConnectionContextInterface::getProperty(const QString &property)
 {
     QVariant var;
     QVariantMap map = getProperties();
@@ -888,13 +888,13 @@ QVariant QOfonoPrimaryDataContextInterface::getProperty(const QString &property)
     return var;
 }
 
-QVariantMap QOfonoPrimaryDataContextInterface::getProperties()
+QVariantMap QOfonoConnectionContextInterface::getProperties()
 {
     QDBusReply<QVariantMap > reply =  this->call(QLatin1String("GetProperties"));
     return reply.value();
 }
 
-bool QOfonoPrimaryDataContextInterface::setProp(const QString &property, const QVariant &var)
+bool QOfonoConnectionContextInterface::setProp(const QString &property, const QVariant &var)
 {
     QList<QVariant> args;
     args << QVariant::fromValue(property) << QVariant::fromValue(QDBusVariant(var));

src/plugins/bearer/connman/qofonoservice_linux_p.h

@@ -76,7 +76,7 @@
 #define OFONO_NETWORK_OPERATOR_INTERFACE         "org.ofono.NetworkOperator"
 #define OFONO_DATA_CONNECTION_MANAGER_INTERFACE  "org.ofono.DataConnectionManager"
 #define OFONO_SIM_MANAGER_INTERFACE              "org.ofono.SimManager"
-#define OFONO_DATA_CONTEXT_INTERFACE             "org.ofono.PrimaryDataContext"
+#define OFONO_DATA_CONTEXT_INTERFACE             "org.ofono.ConnectionContext"
 
 #define OFONO_SMS_MANAGER_INTERFACE              "org.ofono.SmsManager"
 #define OFONO_PHONEBOOK_INTERFACE                "org.ofono.Phonebook"
@@ -281,14 +281,14 @@ protected:
 };
 
 
-class QOfonoPrimaryDataContextInterface : public QDBusAbstractInterface
+class QOfonoConnectionContextInterface : public QDBusAbstractInterface
 {
     Q_OBJECT
 
 public:
 
-    explicit QOfonoPrimaryDataContextInterface(const QString &dbusPathName, QObject *parent = 0);
+    explicit QOfonoConnectionContextInterface(const QString &dbusPathName, QObject *parent = 0);
-    ~QOfonoPrimaryDataContextInterface();
+    ~QOfonoConnectionContextInterface();
 
     QVariantMap getProperties();
 

src/plugins/platforms/cocoa/qcocoabackingstore.mm

@@ -73,7 +73,9 @@ QPaintDevice *QCocoaBackingStore::paintDevice()
         }
 #endif
 
-        m_qImage = QImage(m_requestedSize * scaleFactor, QImage::Format_ARGB32_Premultiplied);
+        QImage::Format format = window()->format().hasAlpha()
+                ? QImage::Format_ARGB32_Premultiplied : QImage::Format_RGB32;
+        m_qImage = QImage(m_requestedSize * scaleFactor, format);
         m_qImage.setDevicePixelRatio(scaleFactor);
     }
     return &m_qImage;
@@ -92,7 +94,7 @@ void QCocoaBackingStore::flush(QWindow *win, const QRegion &region, const QPoint
     m_cgImage = 0;
     if (!m_qImage.isNull()) {
         if (QCocoaWindow *cocoaWindow = static_cast<QCocoaWindow *>(win->handle()))
-            [cocoaWindow->m_contentView flushBackingStore:this region:region offset:offset];
+            [cocoaWindow->m_qtView flushBackingStore:this region:region offset:offset];
     }
 }
 

src/plugins/platforms/cocoa/qcocoaintegration.mm

@@ -172,13 +172,13 @@ QPixmap QCocoaScreen::grabWindow(WId window, int x, int y, int width, int height
             windowSize.setHeight(windowRect.height());
     }
 
-    QPixmap windowPixmap(windowSize);
+    QPixmap windowPixmap(windowSize * devicePixelRatio());
     windowPixmap.fill(Qt::transparent);
 
     for (uint i = 0; i < displayCount; ++i) {
         const CGRect bounds = CGDisplayBounds(displays[i]);
-        int w = (width < 0 ? bounds.size.width : width);
+        int w = (width < 0 ? bounds.size.width : width) * devicePixelRatio();
-        int h = (height < 0 ? bounds.size.height : height);
+        int h = (height < 0 ? bounds.size.height : height) * devicePixelRatio();
         QRect displayRect = QRect(x, y, w, h);
         QCFType<CGImageRef> image = CGDisplayCreateImageForRect(displays[i],
             CGRectMake(displayRect.x(), displayRect.y(), displayRect.width(), displayRect.height()));

src/plugins/platforms/cocoa/qcocoamenubar.mm

@@ -77,8 +77,10 @@ QCocoaMenuBar::~QCocoaMenuBar()
     [m_nativeMenu release];
     static_menubars.removeOne(this);
 
-    if (m_window)
+    if (m_window && m_window->menubar() == this) {
         m_window->setMenubar(0);
+        updateMenuBarImmediately();
+    }
 }
 
 void QCocoaMenuBar::insertMenu(QPlatformMenu *platformMenu, QPlatformMenu *before)

src/plugins/platforms/cocoa/qcocoamenuitem.mm

@@ -315,9 +315,12 @@ NSMenuItem *QCocoaMenuItem::sync()
     return m_native;
 }
 
+QT_BEGIN_NAMESPACE
+extern QString qt_mac_applicationmenu_string(int type);
+QT_END_NAMESPACE
+
 QString QCocoaMenuItem::mergeText()
 {
-    extern QString qt_mac_applicationmenu_string(int type);
     QT_MANGLE_NAMESPACE(QCocoaMenuLoader) *loader = getMenuLoader();
     if (m_native == [loader aboutMenuItem]) {
         return qt_mac_applicationmenu_string(6).arg(qt_mac_applicationName());

src/plugins/platforms/cocoa/qcocoanativeinterface.h

@@ -102,6 +102,9 @@ private:
     // QImage <-> CGImage conversion functions
     static CGImageRef qImageToCGImage(const QImage &image);
     static QImage cgImageToQImage(CGImageRef image);
+
+    // Embedding NSViews as child QWindows
+    static void setWindowContentView(QPlatformWindow *window, void *nsViewContentView);
 };
 
 #endif // QCOCOANATIVEINTERFACE_H

src/plugins/platforms/cocoa/qcocoanativeinterface.mm

@@ -113,6 +113,8 @@ QPlatformNativeInterface::NativeResourceForIntegrationFunction QCocoaNativeInter
         return NativeResourceForIntegrationFunction(QCocoaNativeInterface::qImageToCGImage);
     if (resource.toLower() == "cgimagetoqimage")
         return NativeResourceForIntegrationFunction(QCocoaNativeInterface::cgImageToQImage);
+    if (resource.toLower() == "setwindowcontentview")
+        return NativeResourceForIntegrationFunction(QCocoaNativeInterface::setWindowContentView);
 
     return 0;
 }
@@ -198,5 +200,10 @@ QImage QCocoaNativeInterface::cgImageToQImage(CGImageRef image)
     return qt_mac_toQImage(image);
 }
 
+void QCocoaNativeInterface::setWindowContentView(QPlatformWindow *window, void *contentView)
+{
+    QCocoaWindow *cocoaPlatformWindow = static_cast<QCocoaWindow *>(window);
+    cocoaPlatformWindow->setContentView(reinterpret_cast<NSView *>(contentView));
+}
 
 QT_END_NAMESPACE

src/plugins/platforms/cocoa/qcocoaservices.mm

@@ -55,7 +55,7 @@ bool QCocoaServices::openUrl(const QUrl &url)
     const QString scheme = url.scheme();
     if (scheme.isEmpty())
         return openDocument(url);
-    return [[NSWorkspace sharedWorkspace] openURL:[NSURL URLWithString:QT_PREPEND_NAMESPACE(QCFString::toNSString)(url.toString())]];
+    return [[NSWorkspace sharedWorkspace] openURL:[NSURL URLWithString:QT_PREPEND_NAMESPACE(QCFString::toNSString)(url.toString(QUrl::FullyEncoded))]];
 }
 
 bool QCocoaServices::openDocument(const QUrl &url)

src/plugins/platforms/cocoa/qcocoawindow.h

@@ -121,6 +121,7 @@ public:
     void setParent(const QPlatformWindow *window);
 
     NSView *contentView() const;
+    void setContentView(NSView *contentView);
 
     void windowWillMove();
     void windowDidMove();
@@ -164,8 +165,11 @@ public: // for QNSView
     friend class QCocoaBackingStore;
     friend class QCocoaNativeInterface;
 
-    QNSView *m_contentView;
+    NSView *m_contentView;
+    QNSView *m_qtView;
     NSWindow *m_nsWindow;
+    bool m_contentViewIsEmbedded; // true if the m_contentView is embedded in a "foregin" NSView hiearchy
+
     QNSWindowDelegate *m_nsWindowDelegate;
     Qt::WindowFlags m_windowFlags;
     Qt::WindowState m_synchedWindowState;

src/plugins/platforms/cocoa/qcocoawindow.mm

@@ -58,6 +58,11 @@
 
 #include <QDebug>
 
+enum {
+    defaultWindowWidth = 160,
+    defaultWindowHeight = 160
+};
+
 static bool isMouseEvent(NSEvent *ev)
 {
     switch ([ev type]) {
@@ -186,6 +191,7 @@ static bool isMouseEvent(NSEvent *ev)
 QCocoaWindow::QCocoaWindow(QWindow *tlw)
     : QPlatformWindow(tlw)
     , m_nsWindow(0)
+    , m_contentViewIsEmbedded(false)
     , m_nsWindowDelegate(0)
     , m_synchedWindowState(Qt::WindowActive)
     , m_windowModality(Qt::NonModal)
@@ -200,7 +206,8 @@ QCocoaWindow::QCocoaWindow(QWindow *tlw)
 #endif
     QCocoaAutoReleasePool pool;
 
-    m_contentView = [[QNSView alloc] initWithQWindow:tlw platformWindow:this];
+    m_qtView = [[QNSView alloc] initWithQWindow:tlw platformWindow:this];
+    m_contentView = m_qtView;
     setGeometry(tlw->geometry());
 
     recreateWindow(parent());
@@ -237,6 +244,10 @@ void QCocoaWindow::setGeometry(const QRect &rect)
 void QCocoaWindow::setCocoaGeometry(const QRect &rect)
 {
     QCocoaAutoReleasePool pool;
+
+    if (m_contentViewIsEmbedded)
+        return;
+
     if (m_nsWindow) {
         NSRect bounds = qt_mac_flipRect(rect, window());
         [m_nsWindow setContentSize : bounds.size];
@@ -538,7 +549,7 @@ void QCocoaWindow::setMask(const QRegion &region)
     if (m_nsWindow)
         [m_nsWindow setBackgroundColor:[NSColor clearColor]];
 
-    [m_contentView setMaskRegion:&region];
+    [m_qtView setMaskRegion:&region];
     updateOpaque();
 }
 
@@ -583,6 +594,19 @@ NSView *QCocoaWindow::contentView() const
     return m_contentView;
 }
 
+void QCocoaWindow::setContentView(NSView *contentView)
+{
+    // Remove and release the previous content view
+    [m_contentView removeFromSuperview];
+    [m_contentView release];
+
+    // Insert and retain the new content view
+    [contentView retain];
+    m_contentView = contentView;
+    m_qtView = 0; // The new content view is not a QNSView.
+    recreateWindow(parent()); // Adds the content view to parent NSView
+}
+
 void QCocoaWindow::windowWillMove()
 {
     // Close any open popups on window move
@@ -595,7 +619,7 @@ void QCocoaWindow::windowWillMove()
 
 void QCocoaWindow::windowDidMove()
 {
-    [m_contentView updateGeometry];
+    [m_qtView updateGeometry];
 }
 
 void QCocoaWindow::windowDidResize()
@@ -603,7 +627,7 @@ void QCocoaWindow::windowDidResize()
     if (!m_nsWindow)
         return;
 
-    [m_contentView updateGeometry];
+    [m_qtView updateGeometry];
 }
 
 void QCocoaWindow::windowWillClose()
@@ -644,7 +668,9 @@ void QCocoaWindow::recreateWindow(const QPlatformWindow *parentWindow)
         m_nsWindowDelegate = 0;
     }
 
-    if (!parentWindow) {
+    if (window()->type() == Qt::SubWindow) {
+        // Subwindows don't have a NSWindow.
+    } else if (!parentWindow) {
         // Create a new NSWindow if this is a top-level window.
         m_nsWindow = createNSWindow();
         setNSWindow(m_nsWindow);
@@ -679,7 +705,8 @@ NSWindow * QCocoaWindow::createNSWindow()
 {
     QCocoaAutoReleasePool pool;
 
-    NSRect frame = qt_mac_flipRect(window()->geometry(), window());
+    QRect rect = initialGeometry(window(), window()->geometry(), defaultWindowWidth, defaultWindowHeight);
+    NSRect frame = qt_mac_flipRect(rect, window());
 
     Qt::WindowType type = window()->type();
     Qt::WindowFlags flags = window()->flags();

src/plugins/platforms/cocoa/qnsview.mm

@@ -173,6 +173,36 @@ static QTouchDevice *touchDevice = 0;
     QWindowSystemInterface::handleExposeEvent(m_window, m_window->geometry());
 }
 
+- (void)viewDidMoveToSuperview
+{
+    if (!(m_window->type() & Qt::SubWindow))
+        return;
+
+    if ([self superview]) {
+        m_platformWindow->m_contentViewIsEmbedded = true;
+        QWindowSystemInterface::handleGeometryChange(m_window, m_platformWindow->geometry());
+        QWindowSystemInterface::handleExposeEvent(m_window, m_platformWindow->geometry());
+        QWindowSystemInterface::flushWindowSystemEvents();
+    } else {
+        m_platformWindow->m_contentViewIsEmbedded = false;
+    }
+}
+
+- (void)viewWillMoveToWindow:(NSWindow *)newWindow
+{
+    // ### Merge "normal" window code path with this one for 5.1.
+    if (!(m_window->type() & Qt::SubWindow))
+        return;
+
+    if (newWindow) {
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                              selector:@selector(windowNotification:)
+                                              name:nil // Get all notifications
+                                              object:newWindow];
+    } else {
+        [[NSNotificationCenter defaultCenter] removeObserver:self name:nil object:[self window]];
+    }
+}
 - (void)updateGeometry
 {
     QRect geometry;
@@ -181,6 +211,9 @@ static QTouchDevice *touchDevice = 0;
         NSRect rect = [self frame];
         NSRect windowRect = [[self window] frame];
         geometry = QRect(windowRect.origin.x, qt_mac_flipYCoordinate(windowRect.origin.y + rect.size.height), rect.size.width, rect.size.height);
+    } else if (m_window->type() & Qt::SubWindow) {
+        // embedded child window, use the frame rect ### merge with case below
+        geometry = qt_mac_toQRect([self bounds]);
     } else {
         // child window, use the frame rect
         geometry = qt_mac_toQRect([self frame]);
@@ -198,6 +231,12 @@ static QTouchDevice *touchDevice = 0;
     // an infinite loop when this notification is triggered again.)
     m_platformWindow->QPlatformWindow::setGeometry(geometry);
 
+    // Don't send the geometry change if the QWindow is designated to be
+    // embedded in a foregin view hiearchy but has not actually been
+    // embedded yet - it's too early.
+    if ((m_window->type() & Qt::SubWindow) && !m_platformWindow->m_contentViewIsEmbedded)
+        return;
+
     // Send a geometry change event to Qt, if it's ready to handle events
     if (!m_platformWindow->m_inConstructor) {
         QWindowSystemInterface::handleGeometryChange(m_window, geometry);
@@ -322,7 +361,12 @@ static QTouchDevice *touchDevice = 0;
     );
     CGImageRef bsCGImage = m_backingStore->getBackingStoreCGImage();
     CGImageRef cleanImg = CGImageCreateWithImageInRect(bsCGImage, backingStoreRect);
-    CGContextSetBlendMode(cgContext, kCGBlendModeCopy);
+
+    // Optimization: Copy frame buffer content instead of blending for
+    // top-level windows where Qt fills the entire window content area.
+    if (m_platformWindow->m_nsWindow)
+        CGContextSetBlendMode(cgContext, kCGBlendModeCopy);
+
     CGContextDrawImage(cgContext, dirtyWindowRect, cleanImg);
 
     // Clean-up:

src/plugins/platforms/qnx/qqnxwindow.cpp

@@ -272,9 +272,9 @@ void QQnxWindow::setVisible(bool visible)
     window()->requestActivate();
 
     if (window()->isTopLevel()) {
-        if (visible) {
+        QWindowSystemInterface::handleExposeEvent(window(), window()->geometry());
-            QWindowSystemInterface::handleExposeEvent(window(), window()->geometry());
+
-        } else {
+        if (!visible) {
             // Flush the context, otherwise it won't disappear immediately
             screen_flush_context(m_screenContext, 0);
         }

src/plugins/platforms/windows/qwindowscontext.cpp

@@ -849,10 +849,10 @@ bool QWindowsContext::windowsProc(HWND hwnd, UINT message,
         return true;
     case QtWindows::ShowEvent:
         platformWindow->handleShown();
-        return true;
+        return false; // Indicate transient children should be shown by windows (SW_PARENTOPENING)
     case QtWindows::HideEvent:
         platformWindow->handleHidden();
-        return true;
+        return false;// Indicate transient children should be hidden by windows (SW_PARENTCLOSING)
     case QtWindows::CloseEvent:
         QWindowSystemInterface::handleCloseEvent(platformWindow->window());
         return true;

src/plugins/platforms/windows/qwindowsintegration.h

@@ -78,7 +78,7 @@ public:
 #  ifndef QT_NO_DRAGANDDROP
     virtual QPlatformDrag *drag() const;
 #  endif
-#endif !QT_NO_CLIPBOARD
+#endif // !QT_NO_CLIPBOARD
     virtual QPlatformInputContext *inputContext() const;
 #ifndef QT_NO_ACCESSIBILITY
     virtual QPlatformAccessibility *accessibility() const;

src/plugins/platforms/windows/qwindowswindow.cpp

@@ -64,6 +64,11 @@
 
 QT_BEGIN_NAMESPACE
 
+enum {
+    defaultWindowWidth = 160,
+    defaultWindowHeight = 160
+};
+
 Q_GUI_EXPORT HICON qt_pixmapToWinHICON(const QPixmap &);
 
 static QByteArray debugWinStyle(DWORD style)
@@ -198,17 +203,16 @@ static inline QSize clientSize(HWND hwnd)
     return qSizeOfRect(rect);
 }
 
-// from qwidget_win.cpp/maximum layout size check removed.
+// from qwidget_win.cpp
-static bool shouldShowMaximizeButton(Qt::WindowFlags flags)
+static bool shouldShowMaximizeButton(const QWindow *w)
 {
-    if (flags & Qt::MSWindowsFixedSizeDialogHint)
+    const Qt::WindowFlags flags = w->flags();
+    if ((flags & Qt::MSWindowsFixedSizeDialogHint) || !(flags & Qt::WindowMaximizeButtonHint))
         return false;
     // if the user explicitly asked for the maximize button, we try to add
     // it even if the window has fixed size.
-    if (flags & Qt::CustomizeWindowHint &&
+    return (flags & Qt::CustomizeWindowHint) ||
-        flags & Qt::WindowMaximizeButtonHint)
+        w->maximumSize() == QSize(QWINDOWSIZE_MAX, QWINDOWSIZE_MAX);
-        return true;
-    return flags & Qt::WindowMaximizeButtonHint;
 }
 
 // Set the WS_EX_LAYERED flag on a HWND if required. This is required for
@@ -427,7 +431,7 @@ void WindowCreationData::fromWindow(const QWindow *w, const Qt::WindowFlags flag
                     style |= WS_SYSMENU;
                 if (flags & Qt::WindowMinimizeButtonHint)
                     style |= WS_MINIMIZEBOX;
-                if (shouldShowMaximizeButton(flags))
+                if (shouldShowMaximizeButton(w))
                     style |= WS_MAXIMIZEBOX;
                 if (tool)
                     exStyle |= WS_EX_TOOLWINDOW;
@@ -468,6 +472,8 @@ QWindowsWindow::WindowData
 
     const QString windowClassName = QWindowsContext::instance()->registerWindowClass(w, isGL);
 
+    QRect rect = QPlatformWindow::initialGeometry(w, data.geometry, defaultWindowWidth, defaultWindowHeight);
+
     if (title.isEmpty() && (result.flags & Qt::WindowTitleHint))
         title = topLevel ? qAppName() : w->objectName();
 
@@ -476,14 +482,14 @@ QWindowsWindow::WindowData
 
     // Capture events before CreateWindowEx() returns. The context is cleared in
     // the QWindowsWindow constructor.
-    const QWindowCreationContextPtr context(new QWindowCreationContext(w, data.geometry, data.customMargins, style, exStyle));
+    const QWindowCreationContextPtr context(new QWindowCreationContext(w, rect, data.customMargins, style, exStyle));
     QWindowsContext::instance()->setWindowCreationContext(context);
 
     if (QWindowsContext::verboseWindows)
         qDebug().nospace()
                 << "CreateWindowEx: " << w << *this
                 << " class=" <<windowClassName << " title=" << title
-                << "\nrequested: " << data.geometry << ": "
+                << "\nrequested: " << rect << ": "
                 << context->frameWidth << 'x' <<  context->frameHeight
                 << '+' << context->frameX << '+' << context->frameY
                 << " custom margins: " << context->customMargins;
@@ -810,6 +816,7 @@ QWindowsWindow::QWindowsWindow(QWindow *aWindow, const WindowData &data) :
 QWindowsWindow::~QWindowsWindow()
 {
 #ifndef Q_OS_WINCE
+    QWindowSystemInterface::flushWindowSystemEvents();
     if (QWindowsContext::instance()->systemInfo() & QWindowsContext::SI_SupportsTouch)
         QWindowsContext::user32dll.unregisterTouchWindow(m_data.hwnd);
 #endif // !Q_OS_WINCE

src/plugins/platforms/xcb/qglxintegration.cpp

@@ -105,57 +105,6 @@ static Window createDummyWindow(QXcbScreen *screen, GLXFBConfig config)
     return window;
 }
 
-// Per-window data for active OpenGL contexts.
-struct QOpenGLContextData
-{
-    QOpenGLContextData(Display *display, Window window, GLXContext context)
-        : m_display(display),
-          m_window(window),
-          m_context(context)
-    {}
-
-    QOpenGLContextData()
-        : m_display(0),
-          m_window(0),
-          m_context(0)
-    {}
-
-    Display *m_display;
-    Window m_window;
-    GLXContext m_context;
-};
-
-static inline QOpenGLContextData currentOpenGLContextData()
-{
-    QOpenGLContextData result;
-    result.m_display = glXGetCurrentDisplay();
-    result.m_window = glXGetCurrentDrawable();
-    result.m_context = glXGetCurrentContext();
-    return result;
-}
-
-static inline QOpenGLContextData createDummyWindowOpenGLContextData(QXcbScreen *screen)
-{
-    QOpenGLContextData result;
-    result.m_display = DISPLAY_FROM_XCB(screen);
-
-    QSurfaceFormat format;
-    GLXFBConfig config = qglx_findConfig(DISPLAY_FROM_XCB(screen), screen->screenNumber(), format);
-    if (config) {
-        result.m_context = glXCreateNewContext(DISPLAY_FROM_XCB(screen), config, GLX_RGBA_TYPE, 0, true);
-        result.m_window = createDummyWindow(screen, config);
-    } else {
-        XVisualInfo *visualInfo = qglx_findVisualInfo(DISPLAY_FROM_XCB(screen), screen->screenNumber(), &format);
-        if (!visualInfo)
-            qFatal("Could not initialize GLX");
-        result.m_context = glXCreateContext(DISPLAY_FROM_XCB(screen), visualInfo, 0, true);
-        result.m_window = createDummyWindow(screen, visualInfo);
-        XFree(visualInfo);
-    }
-
-    return result;
-}
-
 static inline QByteArray getGlString(GLenum param)
 {
     if (const GLubyte *s = glGetString(param))
@@ -203,70 +152,7 @@ static void updateFormatFromContext(QSurfaceFormat &format)
         format.setProfile(QSurfaceFormat::CompatibilityProfile);
 }
 
-/*!
+QGLXContext::QGLXContext(QXcbScreen *screen, const QSurfaceFormat &format, QPlatformOpenGLContext *share)
-    \class QOpenGLTemporaryContext
-    \brief A temporary context that can be instantiated on the stack.
-
-    Functions like glGetString() only work if there is a current GL context.
-
-    \internal
-    \ingroup qt-lighthouse-xcb
-*/
-class QOpenGLTemporaryContext
-{
-    Q_DISABLE_COPY(QOpenGLTemporaryContext)
-public:
-    QOpenGLTemporaryContext(QXcbScreen *screen);
-    ~QOpenGLTemporaryContext();
-
-private:
-    const QOpenGLContextData m_previous;
-    const QOpenGLContextData m_current;
-};
-
-QOpenGLTemporaryContext::QOpenGLTemporaryContext(QXcbScreen *screen)
-    : m_previous(currentOpenGLContextData()),
-      m_current(createDummyWindowOpenGLContextData(screen))
-{
-    // Make our temporary context current on our temporary window
-    glXMakeCurrent(m_current.m_display, m_current.m_window, m_current.m_context);
-}
-
-QOpenGLTemporaryContext::~QOpenGLTemporaryContext()
-{
-    // Restore the previous context if possible, otherwise just release our temporary context
-    if (m_previous.m_display)
-        glXMakeCurrent(m_previous.m_display, m_previous.m_window, m_previous.m_context);
-    else
-        glXMakeCurrent(m_current.m_display, 0, 0);
-
-    // Destroy our temporary window
-    XDestroyWindow(m_current.m_display, m_current.m_window);
-
-    // Finally destroy our temporary context itself
-    glXDestroyContext(m_current.m_display, m_current.m_context);
-}
-
-QOpenGLDefaultContextInfo::QOpenGLDefaultContextInfo()
-    : vendor(getGlString(GL_VENDOR)),
-      renderer(getGlString(GL_RENDERER))
-{
-    updateFormatFromContext(format);
-}
-
-QOpenGLDefaultContextInfo *QOpenGLDefaultContextInfo::create(QXcbScreen *screen)
-{
-    // We need a current context for getGLString() to work. To have
-    // the QOpenGLDefaultContextInfo contain the latest supported
-    // context version, we rely upon the QOpenGLTemporaryContext to
-    // correctly obtain a context with the latest version
-    QScopedPointer<QOpenGLTemporaryContext> temporaryContext(new QOpenGLTemporaryContext(screen));
-    QOpenGLDefaultContextInfo *result = new QOpenGLDefaultContextInfo;
-    return result;
-}
-
-
-QGLXContext::QGLXContext(QXcbScreen *screen, const QSurfaceFormat &format, QPlatformOpenGLContext *share, QOpenGLDefaultContextInfo *defaultContextInfo)
     : QPlatformOpenGLContext()
     , m_screen(screen)
     , m_context(0)
@@ -294,51 +180,60 @@ QGLXContext::QGLXContext(QXcbScreen *screen, const QSurfaceFormat &format, QPlat
         QList<QByteArray> glxExt = QByteArray(glXQueryExtensionsString(DISPLAY_FROM_XCB(m_screen), m_screen->screenNumber())).split(' ');
         bool supportsProfiles = glxExt.contains("GLX_ARB_create_context_profile");
 
-        // Use glXCreateContextAttribsARB if is available
+        // Use glXCreateContextAttribsARB if available
         if (glxExt.contains("GLX_ARB_create_context") && glXCreateContextAttribsARB != 0) {
-            // We limit the requested version by the version of the static context as
+            // Try to create an OpenGL context for each known OpenGL version in descending
-            // glXCreateContextAttribsARB fails and returns NULL if the requested context
+            // order from the requested version.
-            // version is not supported. This means that we will get the closest supported
+            const int requestedVersion = format.majorVersion() * 10 + qMin(format.minorVersion(), 9);
-            // context format that that which was requested and is supported by the driver
-            const int maxSupportedVersion = (defaultContextInfo->format.majorVersion() << 8)
-                                          + defaultContextInfo->format.minorVersion();
-            const int requestedVersion = qMin((m_format.majorVersion() << 8) + m_format.minorVersion(),
-                                               maxSupportedVersion);
-            const int majorVersion = requestedVersion >> 8;
-            const int minorVersion = requestedVersion & 0xFF;
 
-            QVector<int> contextAttributes;
+            QVector<int> glVersions;
-            contextAttributes << GLX_CONTEXT_MAJOR_VERSION_ARB << majorVersion
+            if (requestedVersion > 43)
-                              << GLX_CONTEXT_MINOR_VERSION_ARB << minorVersion;
+                glVersions << requestedVersion;
 
-            // If asking for OpenGL 3.2 or newer we should also specify a profile
+            // Don't bother with versions below 2.0
-            if (supportsProfiles && (m_format.majorVersion() > 3 || (m_format.majorVersion() == 3 && m_format.minorVersion() > 1))) {
+            glVersions << 43 << 42 << 41 << 40 << 33 << 32 << 31 << 30 << 21 << 20;
-                if (m_format.profile() == QSurfaceFormat::CoreProfile)
-                    contextAttributes << GLX_CONTEXT_PROFILE_MASK_ARB << GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
-                else
-                    contextAttributes << GLX_CONTEXT_PROFILE_MASK_ARB << GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
-            }
 
-            int flags = 0;
+            for (int i = 0; !m_context && i < glVersions.count(); i++) {
+                const int version = glVersions[i];
+                if (version > requestedVersion)
+                    continue;
 
-            if (m_format.testOption(QSurfaceFormat::DebugContext))
+                const int majorVersion = version / 10;
-                flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
+                const int minorVersion = version % 10;
 
-            // A forward-compatible context may be requested for 3.0 and later
+                QVector<int> contextAttributes;
-            if (m_format.majorVersion() >= 3 && !m_format.testOption(QSurfaceFormat::DeprecatedFunctions))
+                contextAttributes << GLX_CONTEXT_MAJOR_VERSION_ARB << majorVersion
-                flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+                                  << GLX_CONTEXT_MINOR_VERSION_ARB << minorVersion;
 
-            if (flags != 0)
+                // If asking for OpenGL 3.2 or newer we should also specify a profile
-                contextAttributes << GLX_CONTEXT_FLAGS_ARB << flags;
+                if (version >= 32 && supportsProfiles) {
+                    if (m_format.profile() == QSurfaceFormat::CoreProfile)
+                        contextAttributes << GLX_CONTEXT_PROFILE_MASK_ARB << GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
+                    else
+                        contextAttributes << GLX_CONTEXT_PROFILE_MASK_ARB << GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
+                }
 
-            contextAttributes << None;
+                int flags = 0;
 
-            m_context = glXCreateContextAttribsARB(DISPLAY_FROM_XCB(screen), config, m_shareContext, true, contextAttributes.data());
+                if (m_format.testOption(QSurfaceFormat::DebugContext))
-            if (!m_context && m_shareContext) {
+                    flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
-                // re-try without a shared glx context
+
-                m_context = glXCreateContextAttribsARB(DISPLAY_FROM_XCB(screen), config, 0, true, contextAttributes.data());
+                // A forward-compatible context may be requested for 3.0 and later
-                if (m_context)
+                if (version >= 30 && !m_format.testOption(QSurfaceFormat::DeprecatedFunctions))
-                    m_shareContext = 0;
+                    flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+
+                if (flags != 0)
+                    contextAttributes << GLX_CONTEXT_FLAGS_ARB << flags;
+
+                contextAttributes << None;
+
+                m_context = glXCreateContextAttribsARB(DISPLAY_FROM_XCB(screen), config, m_shareContext, true, contextAttributes.data());
+                if (!m_context && m_shareContext) {
+                    // re-try without a shared glx context
+                    m_context = glXCreateContextAttribsARB(DISPLAY_FROM_XCB(screen), config, 0, true, contextAttributes.data());
+                    if (m_context)
+                        m_shareContext = 0;
+                }
             }
         }
 

src/plugins/platforms/xcb/qglxintegration.h

@@ -55,23 +55,10 @@
 
 QT_BEGIN_NAMESPACE
 
-class QOpenGLDefaultContextInfo
-{
-    Q_DISABLE_COPY(QOpenGLDefaultContextInfo)
-    QOpenGLDefaultContextInfo();
-public:
-    static QOpenGLDefaultContextInfo *create(QXcbScreen *screen);
-
-    const QByteArray vendor;
-    const QByteArray renderer;
-    QSurfaceFormat format;
-};
-
-
 class QGLXContext : public QPlatformOpenGLContext
 {
 public:
-    QGLXContext(QXcbScreen *xd, const QSurfaceFormat &format, QPlatformOpenGLContext *share, QOpenGLDefaultContextInfo *defaultContextInfo);
+    QGLXContext(QXcbScreen *xd, const QSurfaceFormat &format, QPlatformOpenGLContext *share);
     ~QGLXContext();
 
     bool makeCurrent(QPlatformSurface *surface);

src/plugins/platforms/xcb/qxcbconnection.cpp

@@ -222,7 +222,6 @@ void QXcbConnection::updateScreens()
     // Delete any existing screens which are not in activeScreens
     for (int i = m_screens.count() - 1; i >= 0; --i) {
         if (!activeScreens.contains(m_screens[i])) {
-            ((QXcbIntegration*)QGuiApplicationPrivate::platformIntegration())->removeDefaultOpenGLContextInfo(m_screens[i]);
             delete m_screens[i];
             m_screens.removeAt(i);
         }

src/plugins/platforms/xcb/qxcbintegration.cpp

@@ -123,9 +123,6 @@ QXcbIntegration::QXcbIntegration(const QStringList &parameters)
 
 QXcbIntegration::~QXcbIntegration()
 {
-#if !defined(QT_NO_OPENGL) && defined(XCB_USE_GLX)
-    qDeleteAll(m_defaultContextInfos);
-#endif
     qDeleteAll(m_connections);
 }
 
@@ -186,14 +183,7 @@ QPlatformOpenGLContext *QXcbIntegration::createPlatformOpenGLContext(QOpenGLCont
 {
     QXcbScreen *screen = static_cast<QXcbScreen *>(context->screen()->handle());
 #if defined(XCB_USE_GLX)
-    QOpenGLDefaultContextInfo *defaultContextInfo;
+    return new QGLXContext(screen, context->format(), context->shareHandle());
-    if (m_defaultContextInfos.contains(screen)) {
-        defaultContextInfo = m_defaultContextInfos.value(screen);
-    } else {
-        defaultContextInfo = QOpenGLDefaultContextInfo::create(screen);
-        m_defaultContextInfos.insert(screen, defaultContextInfo);
-    }
-    return new QGLXContext(screen, context->format(), context->shareHandle(), defaultContextInfo);
 #elif defined(XCB_USE_EGL)
     return new QEGLXcbPlatformContext(context->format(), context->shareHandle(),
         screen->connection()->egl_display(), screen->connection());
@@ -312,21 +302,4 @@ QPlatformTheme *QXcbIntegration::createPlatformTheme(const QString &name) const
     return QGenericUnixTheme::createUnixTheme(name);
 }
 
-/*!
-  Called by QXcbConnection prior to a QQnxScreen being deleted.
-
-  Destroys and cleans up any default OpenGL context info for this screen.
-*/
-void QXcbIntegration::removeDefaultOpenGLContextInfo(QXcbScreen *screen)
-{
-#if !defined(QT_NO_OPENGL) && defined(XCB_USE_GLX)
-    if (!m_defaultContextInfos.contains(screen))
-        return;
-    QOpenGLDefaultContextInfo* info = m_defaultContextInfos.take(screen);
-    delete info;
-#else
-    Q_UNUSED(screen);
-#endif
-}
-
 QT_END_NAMESPACE

src/plugins/platforms/xcb/qxcbintegration.h

@@ -52,10 +52,6 @@ class QAbstractEventDispatcher;
 class QXcbNativeInterface;
 class QXcbScreen;
 
-#if !defined(QT_NO_OPENGL) && defined(XCB_USE_GLX)
-class QOpenGLDefaultContextInfo;
-#endif
-
 class QXcbIntegration : public QPlatformIntegration
 {
 public:
@@ -99,8 +95,6 @@ public:
     QStringList themeNames() const;
     QPlatformTheme *createPlatformTheme(const QString &name) const;
 
-    void removeDefaultOpenGLContextInfo(QXcbScreen *screen);
-
 private:
     QList<QXcbConnection *> m_connections;
 
@@ -110,10 +104,6 @@ private:
     QScopedPointer<QPlatformInputContext> m_inputContext;
     QAbstractEventDispatcher *m_eventDispatcher;
 
-#if !defined(QT_NO_OPENGL) && defined(XCB_USE_GLX)
-    mutable QHash<QXcbScreen *, QOpenGLDefaultContextInfo *> m_defaultContextInfos;
-#endif
-
 #ifndef QT_NO_ACCESSIBILITY
     QScopedPointer<QPlatformAccessibility> m_accessibility;
 #endif

src/plugins/platforms/xcb/qxcbwindow.cpp

@@ -113,6 +113,10 @@
 #endif
 
 #define XCOORD_MAX 16383
+enum {
+    defaultWindowWidth = 160,
+    defaultWindowHeight = 160
+};
 
 //#ifdef NET_WM_STATE_DEBUG
 
@@ -219,8 +223,16 @@ void QXcbWindow::create()
     QRect rect = window()->geometry();
     QPlatformWindow::setGeometry(rect);
 
-    rect.setWidth(qBound(1, rect.width(), XCOORD_MAX));
+    QSize minimumSize = window()->minimumSize();
-    rect.setHeight(qBound(1, rect.height(), XCOORD_MAX));
+    if (rect.width() > 0 || rect.height() > 0) {
+        rect.setWidth(qBound(1, rect.width(), XCOORD_MAX));
+        rect.setHeight(qBound(1, rect.height(), XCOORD_MAX));
+    } else if (minimumSize.width() > 0 || minimumSize.height() > 0) {
+        rect.setSize(minimumSize);
+    } else {
+        rect.setWidth(defaultWindowWidth);
+        rect.setHeight(defaultWindowHeight);
+    }
 
     xcb_window_t xcb_parent_id = m_screen->root();
     if (parent())
@@ -436,15 +448,23 @@ void QXcbWindow::setGeometry(const QRect &rect)
     propagateSizeHints();
     const QRect wmGeometry = windowToWmGeometry(rect);
 
-    const quint32 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
+    if (qt_window_private(window())->positionAutomatic) {
-    const qint32 values[] = {
+        const quint32 mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
-        qBound<qint32>(-XCOORD_MAX, wmGeometry.x(),      XCOORD_MAX),
+        const qint32 values[] = {
-        qBound<qint32>(-XCOORD_MAX, wmGeometry.y(),      XCOORD_MAX),
+            qBound<qint32>(1,           wmGeometry.width(),  XCOORD_MAX),
-        qBound<qint32>(1,           wmGeometry.width(),  XCOORD_MAX),
+            qBound<qint32>(1,           wmGeometry.height(), XCOORD_MAX),
-        qBound<qint32>(1,           wmGeometry.height(), XCOORD_MAX),
+        };
-    };
+        Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, reinterpret_cast<const quint32*>(values)));
-
+    } else {
-    Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, reinterpret_cast<const quint32*>(values)));
+        const quint32 mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
+        const qint32 values[] = {
+            qBound<qint32>(-XCOORD_MAX, wmGeometry.x(),      XCOORD_MAX),
+            qBound<qint32>(-XCOORD_MAX, wmGeometry.y(),      XCOORD_MAX),
+            qBound<qint32>(1,           wmGeometry.width(),  XCOORD_MAX),
+            qBound<qint32>(1,           wmGeometry.height(), XCOORD_MAX),
+        };
+        Q_XCB_CALL(xcb_configure_window(xcb_connection(), m_window, mask, reinterpret_cast<const quint32*>(values)));
+    }
 
     xcb_flush(xcb_connection());
 }
@@ -563,6 +583,7 @@ void QXcbWindow::show()
             if (!transientXcbParent)
                 transientXcbParent = static_cast<QXcbScreen *>(screen())->clientLeader();
             if (transientXcbParent) { // ICCCM 4.1.2.6
+                m_gravity = XCB_GRAVITY_CENTER;
                 Q_XCB_CALL(xcb_change_property(xcb_connection(), XCB_PROP_MODE_REPLACE, m_window,
                                                XCB_ATOM_WM_TRANSIENT_FOR, XCB_ATOM_WINDOW, 32,
                                                1, &transientXcbParent));
@@ -1221,8 +1242,10 @@ void QXcbWindow::propagateSizeHints()
 
     QWindow *win = window();
 
-    xcb_size_hints_set_position(&hints, true, rect.x(), rect.y());
+    if (!qt_window_private(win)->positionAutomatic)
-    xcb_size_hints_set_size(&hints, true, rect.width(), rect.height());
+        xcb_size_hints_set_position(&hints, true, rect.x(), rect.y());
+    if (rect.width() < QWINDOWSIZE_MAX || rect.height() < QWINDOWSIZE_MAX)
+        xcb_size_hints_set_size(&hints, true, rect.width(), rect.height());
     xcb_size_hints_set_win_gravity(&hints, m_gravity);
 
     QSize minimumSize = win->minimumSize();

src/tools/moc/preprocessor.cpp

@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.org>
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the tools applications of the Qt Toolkit.
@@ -536,12 +537,14 @@ static Symbols tokenize(const QByteArray &input, int lineNum = 1, TokenizeMode m
     return symbols;
 }
 
-Symbols Preprocessor::macroExpand(Preprocessor *that, Symbols &toExpand, int &index, int lineNum, bool one)
+Symbols Preprocessor::macroExpand(Preprocessor *that, Symbols &toExpand, int &index,
+                                  int lineNum, bool one, const QSet<QByteArray> &excludeSymbols)
 {
     SymbolStack symbols;
     SafeSymbols sf;
     sf.symbols = toExpand;
     sf.index = index;
+    sf.excludedSymbols = excludeSymbols;
     symbols.push(sf);
 
     Symbols result;
@@ -664,7 +667,7 @@ Symbols Preprocessor::macroExpandIdentifier(Preprocessor *that, SymbolStack &sym
                     if (i == macro.symbols.size() - 1 || macro.symbols.at(i + 1).token != PP_HASHHASH) {
                         Symbols arg = arguments.at(index);
                         int idx = 1;
-                        expansion += macroExpand(that, arg, idx, lineNum, false);
+                        expansion += macroExpand(that, arg, idx, lineNum, false, symbols.excludeSymbols());
                     } else {
                         expansion += arguments.at(index);
                     }

src/tools/moc/preprocessor.h

@@ -85,7 +85,8 @@ public:
 
     void substituteUntilNewline(Symbols &substituted);
     static Symbols macroExpandIdentifier(Preprocessor *that, SymbolStack &symbols, int lineNum, QByteArray *macroName);
-    static Symbols macroExpand(Preprocessor *that, Symbols &toExpand, int &index, int lineNum, bool one);
+    static Symbols macroExpand(Preprocessor *that, Symbols &toExpand, int &index, int lineNum, bool one,
+                               const QSet<QByteArray> &excludeSymbols = QSet<QByteArray>());
 
     int evaluateCondition();
 

src/tools/moc/symbols.h

@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2013 Olivier Goffart <ogoffart@woboq.com>
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the tools applications of the Qt Toolkit.
@@ -134,6 +135,7 @@ typedef QVector<Symbol> Symbols;
 struct SafeSymbols {
     Symbols symbols;
     QByteArray expandedMacro;
+    QSet<QByteArray> excludedSymbols;
     int index;
 };
 
@@ -159,6 +161,7 @@ public:
     inline QByteArray unquotedLexem() { return symbol().unquotedLexem(); }
 
     bool dontReplaceSymbol(const QByteArray &name);
+    QSet<QByteArray> excludeSymbols();
 };
 
 inline bool SymbolStack::test(Token token)
@@ -178,12 +181,22 @@ inline bool SymbolStack::test(Token token)
 inline bool SymbolStack::dontReplaceSymbol(const QByteArray &name)
 {
     for (int i = 0; i < size(); ++i) {
-        if (name == at(i).expandedMacro)
+        if (name == at(i).expandedMacro || at(i).excludedSymbols.contains(name))
             return true;
     }
     return false;
 }
 
+inline QSet<QByteArray> SymbolStack::excludeSymbols()
+{
+    QSet<QByteArray> set;
+    for (int i = 0; i < size(); ++i) {
+        set << at(i).expandedMacro;
+        set += at(i).excludedSymbols;
+    }
+    return set;
+}
+
 QT_END_NAMESPACE
 
 #endif // SYMBOLS_H

src/tools/qdoc/cppcodemarker.cpp

@@ -1259,7 +1259,6 @@ QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode, Syno
         }
         else {
             FastSection all(qmlClassNode,QString(),QString(),"member","members");
-
             const QmlClassNode* current = qmlClassNode;
             while (current != 0) {
                 NodeList::ConstIterator c = current->childNodes().constBegin();
@@ -1271,9 +1270,9 @@ QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode, Syno
                             if ((*p)->type() == Node::QmlProperty) {
                                 QString key = current->name() + "::" + (*p)->name();
                                 key = sortName(*p, &key);
-                                if (!all.memberMap.contains(key))
+                                if (!all.memberMap.contains(key)) {
                                     all.memberMap.insert(key,*p);
-                                //insert(all,*p,style,Okay);
+                                }
                             }
                             ++p;
                         }
@@ -1281,23 +1280,21 @@ QList<Section> CppCodeMarker::qmlSections(const QmlClassNode* qmlClassNode, Syno
                     else {
                         QString key = current->name() + "::" + (*c)->name();
                         key = sortName(*c, &key);
-                        if (!all.memberMap.contains(key))
+                        if (!all.memberMap.contains(key)) {
                             all.memberMap.insert(key,*c);
-                        //insert(all,*c,style,Okay);
+                        }
                     }
                     ++c;
                 }
-                const DocNode* dn = current->qmlBaseNode();
+                current = current->qmlBaseNode();
-                if (dn) {
+                while (current) {
-                    if (dn->subType() == Node::QmlClass)
+                    if (current->isAbstract())
-                        current = static_cast<const QmlClassNode*>(dn);
+                        break;
-                    else {
+                    if (current->isInternal())
-                        dn->doc().location().warning(tr("Base class of QML class '%1' is ambgiguous").arg(current->name()));
+                        current = current->qmlBaseNode();
-                        current = 0;
+                    else
-                    }
+                        break;
                 }
-                else
-                    current = 0;
             }
             append(sections, all, true);
         }

src/tools/qdoc/ditaxmlgenerator.cpp

@@ -4198,7 +4198,10 @@ void DitaXmlGenerator::generateQmlInherits(const QmlClassNode* qcn, CodeMarker*
 {
     if (!qcn)
         return;
-    const DocNode* base = qcn->qmlBaseNode();
+    const QmlClassNode* base = qcn->qmlBaseNode();
+    while (base && base->isInternal()) {
+        base = base->qmlBaseNode();
+    }
     if (base) {
         writeStartTag(DT_qmlInherits);
         //writeStartTag(DT_qmlTypeDef);

src/tools/qdoc/doc/qdoc-manual.qdoc

@@ -65,6 +65,7 @@
           \li \l {C++ Specific Configuration Variables}
           \li \l {HTML Specific Configuration Variables}
           \li \l {Supporting Derived Projects}
+          \li \l {Example Manifest Files}
           \li \l {qt.qdocconf}
           \li \l {minimum.qdocconf}
           \li \l {Generating DITA XML Output}
@@ -7154,6 +7155,7 @@
     \li \l {22-qdoc-configuration-generalvariables.html#images.fileextensions-variable} {images.fileextensions}
     \li \l {22-qdoc-configuration-generalvariables.html#language-variable} {language}
     \li \l {22-qdoc-configuration-generalvariables.html#macro-variable} {macro}
+    \li \l {22-qdoc-configuration-generalvariables.html#manifestmeta-variable} {manifestmeta}
     \li \l {22-qdoc-configuration-generalvariables.html#outputdir-variable} {outputdir}
     \li \l {22-qdoc-configuration-generalvariables.html#outputformats-variable} {outputformats}
     \li \l {22-qdoc-configuration-generalvariables.html#sourcedirs-variable} {sourcedirs}
@@ -7850,6 +7852,14 @@
 
     See also \l {alias-variable} {alias}.
 
+    \target manifestmeta-variable
+    \section1 manifestmeta
+
+    The \c manifestmeta variable specifies additional meta-content
+    for the example manifest files generated by QDoc.
+
+    See the \l{Manifest Meta Content} section for more information.
+
     \target naturallanguage-variable
     \section1 naturallanguage
 
@@ -8472,6 +8482,7 @@
     \page 25-qdoc-configuration-derivedprojects.html
     \previouspage HTML Specific Configuration Variables
     \contentspage QDoc Manual
+    \nextpage Example Manifest Files
 
     \title Supporting Derived Projects
 
@@ -8609,6 +8620,88 @@
     write a new document.
 */
 
+/*!
+    \page 26-qdoc-configuration-example-manifest-files.html
+    \previouspage Supporting Derived Projects
+    \contentspage QDoc Manual
+
+    \title Example Manifest Files
+
+    QDoc generates XML files that contain information about all documented
+    examples and demos. These files, named \c {examples-manifest.xml} and
+    \c {demos-manifest.xml}, are used by Qt Creator to present a list of
+    examples in its welcome screen and to link to their documentation.
+
+    \section1 Manifest XML Structure
+
+    A manifest file has the following structure:
+
+    \code
+    <?xml version="1.0" encoding="UTF-8"?>
+    <instructionals module="QtGui">
+        <examples>
+            <example
+                name="Analog Clock Window Example"
+                docUrl="qthelp://org.qt-project.qtgui.502/qtgui/analogclock.html"
+                projectPath="gui/analogclock/analogclock.pro"
+                imageUrl="qthelp://org.qt-project.qtgui.502/qtgui/images/analogclock-window-example.png">
+                <description><![CDATA[The Analog Clock Window example shows how
+                    to draw the contents of a custom window.]]></description>
+                <tags>analog,clock,window</tags>
+                <fileToOpen>gui/analogclock/main.cpp</fileToOpen>
+            </example>
+            ...
+        </examples>
+    </instructionals>
+    \endcode
+
+    Each \c {<example>} element contains information about a name,
+    description, the location of the project file and documentation,
+    as well as a list of tags associated with the example.
+
+    \target metacontent
+    \section1 Manifest Meta Content
+
+    It is possible to augment the manifest files with additional
+    meta-content - that is, extra attributes and tags for selected
+    examples, using the \c manifestmeta configuration command.
+
+    One use case for meta-content is highlighting a number of prominent
+    examples. Another is improving search functionality by adding
+    relevant keywords as tags for a certain category of examples.
+
+    The examples for which meta-content is applied to is specified using
+    one or more filters. Matching examples to filters is done based on
+    names, with each example name prefixed with a module name and a
+    slash. Simple wildcard matching is supported; by using \c {*} at the
+    end it's possible to match multiple examples with a single string.
+
+    Example:
+
+    \code
+    manifestmeta.filters                = highlighted sql webkit global
+
+    manifestmeta.highlighted.names      = "QtGui/Analog Clock Window Example" \
+                                          "QtWidgets/Analog Clock Example"
+    manifestmeta.highlighted.attributes = isHighlighted:true
+
+    manifestmeta.sql.names              = "QtSql/*"
+    manifestmeta.sql.tags               = database,sql
+
+    manifestmeta.webkit.names           = "QtWebKitExamples/*"
+    manifestmeta.webkit.tags            = webkit
+
+    manifestmeta.global.names           = *
+    manifestmeta.global.tags            = qt5
+    \endcode
+
+    Above, an \c isHighlighted attribute is added to two examples. If
+    the attribute value is omitted, QDoc uses the string \c {true} by
+    default. Extra tags are added for Qt WebKit and Qt SQL examples, and
+    another tag is applied to all examples by using just \c {*} as the
+    match string.
+*/
+
 /*!
     \page 27-qdoc-commands-alphabetical.html
     \previouspage Introduction to QDoc

src/tools/qdoc/htmlgenerator.cpp

@@ -3870,7 +3870,10 @@ void HtmlGenerator::generateQmlInherits(const QmlClassNode* qcn, CodeMarker* mar
 {
     if (!qcn)
         return;
-    const DocNode* base = qcn->qmlBaseNode();
+    const QmlClassNode* base = qcn->qmlBaseNode();
+    while (base && base->isInternal()) {
+        base = base->qmlBaseNode();
+    }
     if (base) {
         Text text;
         text << Atom::ParaLeft << "Inherits ";

src/tools/qdoc/node.cpp

@@ -661,6 +661,16 @@ bool InnerNode::hasMembers() const
     return !members_.isEmpty();
 }
 
+/*!
+  Appends \a node to the members list, if and only if it
+  isn't already in the members list.
+ */
+void InnerNode::addMember(Node* node)
+{
+    if (!members_.contains(node))
+        members_.append(node);
+}
+
 /*!
   Returns true if this node's members collection contains at
   least one namespace node.
@@ -2161,10 +2171,13 @@ void QmlClassNode::subclasses(const QString& base, NodeList& subs)
   This function splits \a arg on the blank character to get a
   QML module name and version number. It then spilts the version
   number on the '.' character to get a major version number and
-  a minor vrsion number. Both version numbers must be present.
+  a minor vrsion number. Both major the major and minor version
-  It stores these components separately. If all three are found,
+  numbers should be present, but the minor version number is not
-  true is returned. If any of the three is not found or is not
+  absolutely necessary.
-  correct, false is returned.
+
+  It stores the three components separately in this node. If all
+  three are found, true is returned. If any of the three is not
+  found or is not in the correct format, false is returned.
  */
 bool Node::setQmlModuleInfo(const QString& arg)
 {
@@ -2184,6 +2197,20 @@ bool Node::setQmlModuleInfo(const QString& arg)
     return false;
 }
 
+/*!
+  If this QML type node has a base type node,
+  return the fully qualified name of that QML
+  type, i.e. <QML-module-name>::<QML-type-name>.
+ */
+QString QmlClassNode::qmlFullBaseName() const
+{
+    QString result;
+    if (baseNode_) {
+        result = baseNode_->qmlModuleIdentifier() + "::" + baseNode_->name();
+    }
+    return result;
+}
+
 /*!
   The name of this QML class node might be the same as the
   name of some other QML class node. If so, then this node's

src/tools/qdoc/node.h

@@ -65,7 +65,6 @@ typedef QList<Node*> NodeList;
 typedef QMap<QString, Node*> NodeMap;
 typedef QMultiMap<QString, Node*> NodeMultiMap;
 typedef QMultiMap<QString, const ExampleNode*> ExampleNodeMap;
-typedef QList<QPair<QString,QString> > ImportList;
 
 class Node
 {
@@ -206,7 +205,7 @@ public:
     virtual bool hasProperty(const QString& ) const { return false; }
     virtual void getMemberNamespaces(NodeMap& ) { }
     virtual void getMemberClasses(NodeMap& ) { }
-    bool isInternal() const;
+    virtual bool isInternal() const;
     bool isIndexNode() const { return indexNodeFlag_; }
     bool wasSeen() const { return seen_; }
     Type type() const { return nodeType_; }
@@ -241,6 +240,7 @@ public:
     QString guid() const;
     QString extractClassName(const QString &string) const;
     virtual QString qmlTypeName() const { return name_; }
+    virtual QString qmlFullBaseName() const { return QString(); }
     virtual QString qmlModuleName() const { return qmlModuleName_; }
     virtual QString qmlModuleVersion() const { return qmlModuleVersionMajor_ + "." + qmlModuleVersionMinor_; }
     virtual QString qmlModuleIdentifier() const { return qmlModuleName_ + qmlModuleVersionMajor_; }
@@ -333,7 +333,7 @@ public:
     const NodeList & childNodes() const { return children_; }
     const NodeList & relatedNodes() const { return related_; }
 
-    virtual void addMember(Node* node) { members_.append(node); }
+    virtual void addMember(Node* node);
     const NodeList& members() const { return members_; }
     virtual bool hasMembers() const;
     virtual bool hasNamespaces() const;
@@ -530,6 +530,26 @@ private:
     QString imageFileName_;
 };
 
+struct ImportRec {
+    QString name_;      // module name
+    QString version_;   // <major> . <minor>
+    QString importId_;  // "as" name
+    QString importUri_; // subdirectory of module directory
+
+    ImportRec(const QString& name,
+              const QString& version,
+              const QString& importId,
+              const QString& importUri)
+    : name_(name), version_(version), importId_(importId), importUri_(importUri) { }
+    QString& name() { return name_; }
+    QString& version() { return version_; }
+    QString& importId() { return importId_; }
+    QString& importUri() { return importUri_; }
+    bool isEmpty() const { return name_.isEmpty(); }
+};
+
+typedef QList<ImportRec> ImportList;
+
 class QmlClassNode : public DocNode
 {
 public:
@@ -543,12 +563,14 @@ public:
     virtual void clearCurrentChild();
     virtual bool isAbstract() const { return abstract_; }
     virtual void setAbstract(bool b) { abstract_ = b; }
+    virtual bool isInternal() const { return (status() == Internal); }
+    virtual QString qmlFullBaseName() const;
     const ImportList& importList() const { return importList_; }
     void setImportList(const ImportList& il) { importList_ = il; }
     const QString& qmlBaseName() const { return baseName_; }
     void setQmlBaseName(const QString& name) { baseName_ = name; }
-    const DocNode* qmlBaseNode() const { return baseNode_; }
+    const QmlClassNode* qmlBaseNode() const { return baseNode_; }
-    void setQmlBaseNode(DocNode* b) { baseNode_ = b; }
+    void setQmlBaseNode(QmlClassNode* b) { baseNode_ = b; }
     void requireCppClass() { cnodeRequired_ = true; }
     bool cppClassRequired() const { return cnodeRequired_; }
     static void addInheritedBy(const QString& base, Node* sub);
@@ -564,7 +586,7 @@ private:
     bool cnodeRequired_;
     ClassNode*    cnode_;
     QString      baseName_;
-    DocNode*     baseNode_;
+    QmlClassNode*       baseNode_;
     ImportList          importList_;
 };
 

src/tools/qdoc/qdocdatabase.cpp

@@ -291,18 +291,29 @@ DocNode* QDocDatabase::addToModule(const QString& name, Node* node)
  */
 DocNode* QDocDatabase::addToQmlModule(const QString& name, Node* node)
 {
+    QString longQmid, shortQmid;
+    QStringList dotSplit;
+    QStringList blankSplit = name.split(QLatin1Char(' '));
+    if (blankSplit.size() > 1) {
+        longQmid = blankSplit[0] + blankSplit[1];
+        dotSplit = blankSplit[1].split(QLatin1Char('.'));
+        shortQmid = blankSplit[0] + dotSplit[0];
+    }
     DocNode* dn = findQmlModule(name);
     dn->addMember(node);
     node->setQmlModuleInfo(name);
     if (node->subType() == Node::QmlClass) {
-        QString t = node->qmlModuleIdentifier() + "::" + node->name();
         QmlClassNode* n = static_cast<QmlClassNode*>(node);
-        if (!qmlTypeMap_.contains(t))
+        QString key = longQmid + "::" + node->name();
-            qmlTypeMap_.insert(t,n);
+        for (int i=0; i<2; ++i) {
-        if (!masterMap_.contains(t))
+            if (!qmlTypeMap_.contains(key))
-            masterMap_.insert(t,node);
+                qmlTypeMap_.insert(key,n);
-        if (!masterMap_.contains(node->name(),node))
+            if (!masterMap_.contains(key))
-            masterMap_.insert(node->name(),node);
+                masterMap_.insert(key,node);
+            if (!masterMap_.contains(node->name(),node))
+                masterMap_.insert(node->name(),node);
+            key = shortQmid + "::" + node->name();
+        }
     }
     return dn;
 }
@@ -332,7 +343,45 @@ QmlClassNode* QDocDatabase::findQmlType(const QString& qmid, const QString& name
         }
     }
     return 0;
+}
 
+/*!
+  Looks up the QML type node identified by the Qml module id
+  constructed from the strings in the \a import record and the
+  QML type \a name and returns a pointer to the QML type node.
+  If a QML type node is not found, 0 is returned.
+ */
+QmlClassNode* QDocDatabase::findQmlType(const ImportRec& import, const QString& name) const
+{
+    if (!import.isEmpty()) {
+        QStringList dotSplit;
+        dotSplit = name.split(QLatin1Char('.'));
+        QString qmName;
+        if (import.importUri_.isEmpty())
+            qmName = import.name_;
+        else
+            qmName = import.importUri_;
+        for (int i=0; i<dotSplit.size(); ++i) {
+            QString qmid = qmName + import.version_;
+            QString qualifiedName = qmid + "::" + dotSplit[i];
+            QmlClassNode* qcn = qmlTypeMap_.value(qualifiedName);
+            if (qcn) {
+                return qcn;
+            }
+            if (import.version_.size() > 1) {
+                int dot = import.version_.lastIndexOf(QChar('.'));
+                if (dot > 0) {
+                    qmid = import.name_ + import.version_.left(dot);
+                    qualifiedName = qmid + "::" + dotSplit[i];
+                    qcn = qmlTypeMap_.value(qualifiedName);
+                    if (qcn) {
+                        return qcn;
+                    }
+                }
+            }
+        }
+    }
+    return 0;
 }
 
 /*!
@@ -836,14 +885,28 @@ void QDocDatabase::resolveQmlInheritance(InnerNode* root)
         if (child->type() == Node::Document && child->subType() == Node::QmlClass) {
             QmlClassNode* qcn = static_cast<QmlClassNode*>(child);
             if ((qcn->qmlBaseNode() == 0) && !qcn->qmlBaseName().isEmpty()) {
-                QmlClassNode* bqcn = findQmlType(QString(), qcn->qmlBaseName());
+                QmlClassNode* bqcn = 0;
+                if (qcn->qmlBaseName().contains("::")) {
+                    bqcn =  qmlTypeMap_.value(qcn->qmlBaseName());
+                }
+                else {
+                    const ImportList& imports = qcn->importList();
+                    for (int i=0; i<imports.size(); ++i) {
+                        bqcn = findQmlType(imports[i], qcn->qmlBaseName());
+                        if (bqcn)
+                            break;
+                    }
+                }
+                if (bqcn == 0) {
+                    bqcn = findQmlType(QString(), qcn->qmlBaseName());
+                }
                 if (bqcn) {
                     qcn->setQmlBaseNode(bqcn);
                 }
 #if 0
                 else {
-                    qDebug() << "Unable to resolve QML base type:" << qcn->qmlBaseName()
+                    qDebug() << "Temporary error message (ignore): UNABLE to resolve QML base type:"
-                             << "for QML type:" << qcn->name();
+                             << qcn->qmlBaseName() << "for QML type:" << qcn->name();
                 }
 #endif
             }
@@ -851,6 +914,24 @@ void QDocDatabase::resolveQmlInheritance(InnerNode* root)
     }
 }
 
+#if 0
+void QDocDatabase::resolveQmlInheritance(InnerNode* root)
+{
+    // Dop we need recursion?
+    foreach (Node* child, root->childNodes()) {
+        if (child->type() == Node::Document && child->subType() == Node::QmlClass) {
+            QmlClassNode* qcn = static_cast<QmlClassNode*>(child);
+            if ((qcn->qmlBaseNode() == 0) && !qcn->qmlBaseName().isEmpty()) {
+                QmlClassNode* bqcn = findQmlType(QString(), qcn->qmlBaseName());
+                if (bqcn) {
+                    qcn->setQmlBaseNode(bqcn);
+                }
+            }
+        }
+    }
+}
+#endif
+
 /*!
  */
 void QDocDatabase::resolveTargets(InnerNode* root)

src/tools/qdoc/qdocdatabase.h

@@ -107,6 +107,7 @@ class QDocDatabase
     DocNode* addToQmlModule(const QString& name, Node* node);
 
     QmlClassNode* findQmlType(const QString& qmid, const QString& name) const;
+    QmlClassNode* findQmlType(const ImportRec& import, const QString& name) const;
 
     void findAllClasses(const InnerNode *node);
     void findAllFunctions(const InnerNode *node);

src/tools/qdoc/qdocindexfiles.cpp

@@ -190,6 +190,12 @@ void QDocIndexFiles::readIndexSection(const QDomElement& element,
              ((element.nodeName() == "page") && (element.attribute("subtype") == "qmlclass"))) {
         QmlClassNode* qcn = new QmlClassNode(parent, name);
         qcn->setTitle(element.attribute("title"));
+        QString qmlModuleName = element.attribute("qml-module-name");
+        QString qmlModuleVersion = element.attribute("qml-module-version");
+        qdb_->addToQmlModule(qmlModuleName + " " + qmlModuleVersion, qcn);
+        QString qmlFullBaseName = element.attribute("qml-base-type");
+        if (!qmlFullBaseName.isEmpty())
+            qcn->setQmlBaseName(qmlFullBaseName);
         if (element.hasAttribute("location"))
             name = element.attribute("location", QString());
         if (!indexUrl.isEmpty())
@@ -209,6 +215,31 @@ void QDocIndexFiles::readIndexSection(const QDomElement& element,
             location = Location(name);
         node = qbtn;
     }
+    else if (element.nodeName() == "qmlproperty") {
+        QmlClassNode* qcn = static_cast<QmlClassNode*>(parent);
+        QString type = element.attribute("type");
+        bool attached = false;
+        if (element.attribute("attached") == "true")
+            attached = true;
+        bool readonly = false;
+        if (element.attribute("writable") == "false")
+            readonly = true;
+        QmlPropertyNode* qpn = new QmlPropertyNode(qcn, name, type, attached);
+        qpn->setReadOnly(readonly);
+        node = qpn;
+    }
+    else if ((element.nodeName() == "qmlmethod") ||
+             (element.nodeName() == "qmlsignal") ||
+             (element.nodeName() == "qmlsignalhandler")) {
+        Node::Type t = Node::QmlMethod;
+        if (element.nodeName() == "qmlsignal")
+            t = Node::QmlSignal;
+        else if (element.nodeName() == "qmlsignalhandler")
+            t = Node::QmlSignalHandler;
+        bool attached = false;
+        FunctionNode* fn = new FunctionNode(t, parent, name, attached);
+        node = fn;
+    }
     else if (element.nodeName() == "page") {
         Node::SubType subtype;
         Node::PageType ptype = Node::NoPageType;
@@ -476,17 +507,22 @@ void QDocIndexFiles::readIndexSection(const QDomElement& element,
         InnerNode* inner = static_cast<InnerNode*>(node);
         QDomElement child = element.firstChildElement();
         while (!child.isNull()) {
-            if (element.nodeName() == "class")
+            if (element.nodeName() == "class") {
                 readIndexSection(child, inner, indexUrl);
-            else if (element.nodeName() == "qmlclass")
+            }
+            else if (element.nodeName() == "qmlclass") {
                 readIndexSection(child, inner, indexUrl);
-            else if (element.nodeName() == "page")
+            }
+            else if (element.nodeName() == "page") {
                 readIndexSection(child, inner, indexUrl);
-            else if (element.nodeName() == "namespace" && !name.isEmpty())
+            }
+            else if (element.nodeName() == "namespace" && !name.isEmpty()) {
                 // The root node in the index is a namespace with an empty name.
                 readIndexSection(child, inner, indexUrl);
-            else
+            }
+            else {
                 readIndexSection(child, parent, indexUrl);
+            }
             child = child.nextSiblingElement();
         }
     }
@@ -562,6 +598,9 @@ bool QDocIndexFiles::generateIndexSection(QXmlStreamWriter& writer,
         return false;
 
     QString nodeName;
+    QString qmlModuleName;
+    QString qmlModuleVersion;
+    QString qmlFullBaseName;
     switch (node->type()) {
     case Node::Namespace:
         nodeName = "namespace";
@@ -571,8 +610,12 @@ bool QDocIndexFiles::generateIndexSection(QXmlStreamWriter& writer,
         break;
     case Node::Document:
         nodeName = "page";
-        if (node->subType() == Node::QmlClass)
+        if (node->subType() == Node::QmlClass) {
             nodeName = "qmlclass";
+            qmlModuleName = node->qmlModuleName();
+            qmlModuleVersion = node->qmlModuleVersion();
+            qmlFullBaseName = node->qmlFullBaseName();
+        }
         else if (node->subType() == Node::QmlBasicType)
             nodeName = "qmlbasictype";
         break;
@@ -687,6 +730,12 @@ bool QDocIndexFiles::generateIndexSection(QXmlStreamWriter& writer,
     writer.writeAttribute("status", status);
 
     writer.writeAttribute("name", objName);
+    if (!qmlModuleName.isEmpty()) {
+        writer.writeAttribute("qml-module-name", qmlModuleName);
+        writer.writeAttribute("qml-module-version", qmlModuleVersion);
+        if (!qmlFullBaseName.isEmpty())
+            writer.writeAttribute("qml-base-type", qmlFullBaseName);
+    }
     QString fullName = node->fullDocumentName();
     if (fullName != objName)
         writer.writeAttribute("fullname", fullName);

src/tools/qdoc/qmlvisitor.cpp

@@ -373,6 +373,24 @@ void QmlDocVisitor::applyMetacommands(QQmlJS::AST::SourceLocation,
     }
 }
 
+/*!
+  Reconstruct the qualified \a id using dot notation
+  and return the fully qualified string.
+ */
+QString QmlDocVisitor::getFullyQualifiedId(QQmlJS::AST::UiQualifiedId *id)
+{
+    QString result;
+    if (id) {
+        result = id->name.toString();
+        id = id->next;
+        while (id != 0) {
+            result += QChar('.') + id->name.toString();
+            id = id->next;
+        }
+    }
+    return result;
+}
+
 /*!
   Begin the visit of the object \a definition, recording it in the
   qdoc database. Increment the object nesting level, which is used
@@ -381,7 +399,7 @@ void QmlDocVisitor::applyMetacommands(QQmlJS::AST::SourceLocation,
 */
 bool QmlDocVisitor::visit(QQmlJS::AST::UiObjectDefinition *definition)
 {
-    QString type = definition->qualifiedTypeNameId->name.toString();
+    QString type = getFullyQualifiedId(definition->qualifiedTypeNameId);
     nestingLevel++;
 
     if (current->type() == Node::Namespace) {
@@ -420,17 +438,18 @@ void QmlDocVisitor::endVisit(QQmlJS::AST::UiObjectDefinition *definition)
  */
 bool QmlDocVisitor::visit(QQmlJS::AST::UiImportList *imports)
 {
-    QQmlJS::AST::UiImport* imp = imports->import;
+    while (imports != 0) {
-    quint32 length =  imp->versionToken.offset - imp->fileNameToken.offset - 1;
+        QQmlJS::AST::UiImport* imp = imports->import;
-    QString module = document.mid(imp->fileNameToken.offset,length);
-    QString version = document.mid(imp->versionToken.offset, imp->versionToken.length);
-    if (version.size() > 1) {
-        int dot = version.lastIndexOf(QChar('.'));
-        if (dot > 0)
-            version = version.left(dot);
-    }
-    importList.append(QPair<QString, QString>(module, version));
 
+        QString name = document.mid(imp->fileNameToken.offset, imp->fileNameToken.length);
+        if (name[0] == '\"')
+            name = name.mid(1, name.length()-2);
+        QString version = document.mid(imp->versionToken.offset, imp->versionToken.length);
+        QString importId = document.mid(imp->importIdToken.offset, imp->importIdToken.length);
+        QString importUri = getFullyQualifiedId(imp->importUri);
+        importList.append(ImportRec(name, version, importId, importUri));
+        imports = imports->next;
+    }
     return true;
 }
 

src/tools/qdoc/qmlvisitor.h

@@ -97,6 +97,7 @@ public:
     void endVisit(QQmlJS::AST::UiQualifiedId *);
 
 private:
+    QString getFullyQualifiedId(QQmlJS::AST::UiQualifiedId *id);
     QQmlJS::AST::SourceLocation precedingComment(quint32 offset) const;
     bool applyDocumentation(QQmlJS::AST::SourceLocation location, Node *node);
     void applyMetacommands(QQmlJS::AST::SourceLocation location, Node* node, Doc& doc);
@@ -110,7 +111,7 @@ private:
     QString filePath;
     QString name;
     QString document;
-    QList<QPair<QString, QString> > importList;
+    ImportList importList;
     QSet<QString> commands;
     QSet<QString> topics;
     QSet<quint32> usedComments;

src/widgets/dialogs/qfiledialog.cpp

@@ -2968,7 +2968,11 @@ void QFileDialogPrivate::_q_enterDirectory(const QModelIndex &index)
             lineEdit()->clear();
         }
     } else {
-        q->accept();
+        // Do not accept when shift-clicking to multi-select a file in environments with single-click-activation (KDE)
+        if (!q->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick)
+            || q->fileMode() != QFileDialog::ExistingFiles || !(QGuiApplication::keyboardModifiers() & Qt::CTRL)) {
+            q->accept();
+        }
     }
 }
 

src/widgets/graphicsview/qgraphicsitem.cpp

@@ -7375,8 +7375,8 @@ void QGraphicsItem::updateMicroFocus()
 /*!
     This virtual function is called by QGraphicsItem to notify custom items
     that some part of the item's state changes. By reimplementing this
-    function, your can react to a change, and in some cases, (depending on \a
+    function, you can react to a change, and in some cases (depending on \a
-    change,) adjustments can be made.
+    change), adjustments can be made.
 
     \a change is the parameter of the item that is changing. \a value is the
     new value; the type of the value depends on \a change.

src/widgets/itemviews/qheaderview.cpp

@@ -1082,6 +1082,8 @@ int QHeaderView::logicalIndex(int visualIndex) const
 }
 
 /*!
+    \since 5.0
+
     If \a movable is true, the header may be moved by the user; otherwise it
     is fixed in place.
 
@@ -1105,6 +1107,8 @@ void QHeaderView::setSectionsMovable(bool movable)
 */
 
 /*!
+    \since 5.0
+
     Returns true if the header can be moved by the user; otherwise returns
     false.
 
@@ -1128,6 +1132,8 @@ bool QHeaderView::sectionsMovable() const
 */
 
 /*!
+    \since 5.0
+
     If \a clickable is true, the header will respond to single clicks.
 
     \sa sectionsClickable(), sectionClicked(), sectionPressed(),
@@ -1151,6 +1157,8 @@ void QHeaderView::setSectionsClickable(bool clickable)
 */
 
 /*!
+    \since 5.0
+
     Returns true if the header is clickable; otherwise returns false. A
     clickable header could be set up to allow the user to change the
     representation of the data in the view related to the header.
@@ -1187,6 +1195,8 @@ bool QHeaderView::highlightSections() const
 }
 
 /*!
+    \since 5.0
+
     Sets the constraints on how the header can be resized to those described
     by the given \a mode.
 
@@ -1205,6 +1215,8 @@ void QHeaderView::setSectionResizeMode(ResizeMode mode)
 }
 
 /*!
+    \since 5.0
+
     Sets the constraints on how the section specified by \a logicalIndex in
     the header can be resized to those described by the given \a mode. The logical
     index should exist at the time this function is called.
@@ -1259,6 +1271,8 @@ void QHeaderView::setSectionResizeMode(int logicalIndex, ResizeMode mode)
 */
 
 /*!
+    \since 5.0
+
     Returns the resize mode that applies to the section specified by the given
     \a logicalIndex.
 

src/widgets/kernel/qwidget_qpa.cpp

@@ -109,7 +109,10 @@ void QWidgetPrivate::create_sys(WId window, bool initializeWindow, bool destroyO
 
     win->setFlags(data.window_flags);
     fixPosIncludesFrame();
-    win->setGeometry(q->geometry());
+    if (q->testAttribute(Qt::WA_Moved))
+        win->setGeometry(q->geometry());
+    else
+        win->resize(q->size());
     win->setScreen(QGuiApplication::screens().value(topData()->screenIndex, 0));
 
     if (q->testAttribute(Qt::WA_TranslucentBackground)) {
@@ -466,19 +469,6 @@ void QWidget::activateWindow()
         wnd->requestActivate();
 }
 
-// Position top level windows at the center, avoid showing
-// Windows at the default 0,0 position excluding the frame.
-static inline QRect positionTopLevelWindow(QRect geometry, const QScreen *screen)
-{
-    if (screen && geometry.x() == 0 && geometry.y() == 0) {
-       const QRect availableGeometry = screen->availableGeometry();
-        if (availableGeometry.width() > geometry.width()
-            && availableGeometry.height() > geometry.height())
-            geometry.moveCenter(availableGeometry.center());
-    }
-    return geometry;
-}
-
 // move() was invoked with Qt::WA_WState_Created not set (frame geometry
 // unknown), that is, crect has a position including the frame.
 // If we can determine the frame strut, fix that and clear the flag.
@@ -529,16 +519,16 @@ void QWidgetPrivate::show_sys()
         if (q->isWindow())
             fixPosIncludesFrame();
         QRect geomRect = q->geometry();
-        if (q->isWindow()) {
+        if (!q->isWindow()) {
-            if (!q->testAttribute(Qt::WA_Moved))
-                geomRect = positionTopLevelWindow(geomRect, window->screen());
-        } else {
             QPoint topLeftOfWindow = q->mapTo(q->nativeParentWidget(),QPoint());
             geomRect.moveTopLeft(topLeftOfWindow);
         }
         const QRect windowRect = window->geometry();
         if (windowRect != geomRect) {
-            window->setGeometry(geomRect);
+            if (q->testAttribute(Qt::WA_Moved))
+                window->setGeometry(geomRect);
+            else
+                window->resize(geomRect.size());
         }
 
         if (QBackingStore *store = q->backingStore()) {

src/widgets/styles/qgtkstyle.cpp

@@ -1881,8 +1881,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
             GtkShadowType shadow = (option->state & State_Sunken || option->state & State_On ) ?
                                    GTK_SHADOW_IN : GTK_SHADOW_OUT;
-            const QHashableLatin1Literal comboBoxPath = comboBox->editable && QGtkStylePrivate::gtk_combo_box_entry_new ?
+            const QHashableLatin1Literal comboBoxPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry") : QHashableLatin1Literal("GtkComboBox");
-                        QHashableLatin1Literal("GtkComboBoxEntry") : QHashableLatin1Literal("GtkComboBox");
 
             // We use the gtk widget to position arrows and separators for us
             GtkWidget *gtkCombo = d->gtkWidget(comboBoxPath);
@@ -1890,8 +1889,8 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
             d->gtk_widget_set_direction(gtkCombo, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
             d->gtk_widget_size_allocate(gtkCombo, &geometry);
 
-            QHashableLatin1Literal buttonPath = comboBox->editable && QGtkStylePrivate::gtk_combo_box_entry_new ?
+            QHashableLatin1Literal buttonPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton")
-                        QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton") : QHashableLatin1Literal("GtkComboBox.GtkToggleButton");
+                                : QHashableLatin1Literal("GtkComboBox.GtkToggleButton");
             GtkWidget *gtkToggleButton = d->gtkWidget(buttonPath);
             d->gtk_widget_set_direction(gtkToggleButton, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
             if (gtkToggleButton && (appears_as_list || comboBox->editable)) {
@@ -1900,8 +1899,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                 // Draw the combo box as a line edit with a button next to it
                 if (comboBox->editable || appears_as_list) {
                     GtkStateType frameState = (state == GTK_STATE_PRELIGHT) ? GTK_STATE_NORMAL : state;
-                    QHashableLatin1Literal entryPath = comboBox->editable && QGtkStylePrivate::gtk_combo_box_entry_new ? QHashableLatin1Literal("GtkComboBoxEntry.GtkEntry")
+                    QHashableLatin1Literal entryPath = comboBox->editable ? QHashableLatin1Literal("GtkComboBoxEntry.GtkEntry") : QHashableLatin1Literal("GtkComboBox.GtkFrame");
-                            : comboBox->editable ? QHashableLatin1Literal("GtkComboBox.GtkEntry") : QHashableLatin1Literal("GtkComboBox.GtkFrame");
                     GtkWidget *gtkEntry = d->gtkWidget(entryPath);
                     d->gtk_widget_set_direction(gtkEntry, reverse ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
                     QRect frameRect = option->rect;
@@ -1969,7 +1967,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
 
                 // Draw the separator between label and arrows
-                QHashableLatin1Literal vSeparatorPath = comboBox->editable && QGtkStylePrivate::gtk_combo_box_entry_new
+                QHashableLatin1Literal vSeparatorPath = comboBox->editable
                     ? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton.GtkHBox.GtkVSeparator")
                     : QHashableLatin1Literal("GtkComboBox.GtkToggleButton.GtkHBox.GtkVSeparator");
 
@@ -2006,7 +2004,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
                     state = GTK_STATE_NORMAL;
 
                 QHashableLatin1Literal arrowPath("");
-                if (comboBox->editable && QGtkStylePrivate::gtk_combo_box_entry_new) {
+                if (comboBox->editable) {
                     if (appears_as_list)
                         arrowPath = QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton.GtkArrow");
                     else
@@ -2044,7 +2042,7 @@ void QGtkStyle::drawComplexControl(ComplexControl control, const QStyleOptionCom
 
                 if (sunken) {
                     int xoff, yoff;
-                    const QHashableLatin1Literal toggleButtonPath = comboBox->editable && QGtkStylePrivate::gtk_combo_box_entry_new
+                    const QHashableLatin1Literal toggleButtonPath = comboBox->editable
                             ? QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton")
                             : QHashableLatin1Literal("GtkComboBox.GtkToggleButton");
 
@@ -3812,15 +3810,19 @@ QRect QGtkStyle::subControlRect(ComplexControl control, const QStyleOptionComple
     case CC_ComboBox:
         if (const QStyleOptionComboBox *box = qstyleoption_cast<const QStyleOptionComboBox *>(option)) {
             // We employ the gtk widget to position arrows and separators for us
-            GtkWidget *gtkCombo = box->editable && QGtkStylePrivate::gtk_combo_box_entry_new ?
+            GtkWidget *gtkCombo = box->editable ? d->gtkWidget("GtkComboBoxEntry")
-                        d->gtkWidget("GtkComboBoxEntry") : d->gtkWidget("GtkComboBox");
+                                                : d->gtkWidget("GtkComboBox");
             d->gtk_widget_set_direction(gtkCombo, (option->direction == Qt::RightToLeft) ? GTK_TEXT_DIR_RTL : GTK_TEXT_DIR_LTR);
             GtkAllocation geometry = {0, 0, qMax(0, option->rect.width()), qMax(0, option->rect.height())};
             d->gtk_widget_size_allocate(gtkCombo, &geometry);
             int appears_as_list = !proxy()->styleHint(QStyle::SH_ComboBox_Popup, option, widget);
-            QHashableLatin1Literal arrowPath = box->editable && QGtkStylePrivate::gtk_combo_box_entry_new ?
+            QHashableLatin1Literal arrowPath("GtkComboBoxEntry.GtkToggleButton");
-                        QHashableLatin1Literal("GtkComboBoxEntry.GtkToggleButton") : box->editable || appears_as_list ?
+            if (!box->editable) {
-                            QHashableLatin1Literal("GtkComboBox.GtkToggleButton") : QHashableLatin1Literal("GtkComboBox.GtkToggleButton.GtkHBox.GtkArrow");
+                if (appears_as_list)
+                    arrowPath = "GtkComboBox.GtkToggleButton";
+                else
+                    arrowPath = "GtkComboBox.GtkToggleButton.GtkHBox.GtkArrow";
+            }
 
             GtkWidget *arrowWidget = d->gtkWidget(arrowPath);
             if (!arrowWidget)

src/widgets/styles/qgtkstyle_p.cpp

@@ -133,7 +133,6 @@ Ptr_gtk_separator_tool_item_new QGtkStylePrivate::gtk_separator_tool_item_new =
 Ptr_gtk_tree_view_new QGtkStylePrivate::gtk_tree_view_new = 0;
 Ptr_gtk_combo_box_new QGtkStylePrivate::gtk_combo_box_new = 0;
 Ptr_gtk_combo_box_entry_new QGtkStylePrivate::gtk_combo_box_entry_new = 0;
-Ptr_gtk_combo_box_new_with_entry QGtkStylePrivate::gtk_combo_box_new_with_entry = 0;
 Ptr_gtk_progress_bar_new QGtkStylePrivate::gtk_progress_bar_new = 0;
 Ptr_gtk_container_add QGtkStylePrivate::gtk_container_add = 0;
 Ptr_gtk_menu_shell_append QGtkStylePrivate::gtk_menu_shell_append = 0;
@@ -411,7 +410,6 @@ void QGtkStylePrivate::resolveGtk() const
     gtk_tree_view_new = (Ptr_gtk_tree_view_new)libgtk.resolve("gtk_tree_view_new");
     gtk_combo_box_new = (Ptr_gtk_combo_box_new)libgtk.resolve("gtk_combo_box_new");
     gtk_combo_box_entry_new = (Ptr_gtk_combo_box_entry_new)libgtk.resolve("gtk_combo_box_entry_new");
-    gtk_combo_box_new_with_entry = (Ptr_gtk_combo_box_entry_new)libgtk.resolve("gtk_combo_box_new_with_entry");
     gtk_range_get_adjustment = (Ptr_gtk_range_get_adjustment)libgtk.resolve("gtk_range_get_adjustment");
     gtk_range_set_adjustment = (Ptr_gtk_range_set_adjustment)libgtk.resolve("gtk_range_set_adjustment");
     gtk_range_set_inverted = (Ptr_gtk_range_set_inverted)libgtk.resolve("gtk_range_set_inverted");
@@ -575,10 +573,7 @@ void QGtkStylePrivate::initGtkWidgets() const
             addWidget(QGtkStylePrivate::gtk_check_button_new());
             addWidget(QGtkStylePrivate::gtk_radio_button_new(NULL));
             addWidget(QGtkStylePrivate::gtk_combo_box_new());
-            if (gtk_combo_box_entry_new)
+            addWidget(QGtkStylePrivate::gtk_combo_box_entry_new());
-                addWidget(QGtkStylePrivate::gtk_combo_box_entry_new());
-            if (gtk_combo_box_new_with_entry)
-                addWidget(QGtkStylePrivate::gtk_combo_box_new_with_entry());
             GtkWidget *entry = QGtkStylePrivate::gtk_entry_new();
             // gtk-im-context-none is supported in gtk+ since 2.19.5
             // and also exists in gtk3

src/widgets/styles/qgtkstyle_p_p.h

@@ -143,7 +143,6 @@ typedef GtkWidget* (*Ptr_gtk_menu_bar_new)(void);
 typedef GtkWidget* (*Ptr_gtk_menu_new)(void);
 typedef GtkWidget* (*Ptr_gtk_combo_box_new)(void);
 typedef GtkWidget* (*Ptr_gtk_combo_box_entry_new)(void);
-typedef GtkWidget* (*Ptr_gtk_combo_box_new_with_entry)(void);
 typedef GtkWidget* (*Ptr_gtk_toolbar_new)(void);
 typedef GtkWidget* (*Ptr_gtk_spin_button_new)(GtkAdjustment*, double, int);
 typedef GtkWidget* (*Ptr_gtk_button_new)(void);
@@ -380,7 +379,6 @@ public:
     static Ptr_gtk_tree_view_get_column gtk_tree_view_get_column;
     static Ptr_gtk_combo_box_new gtk_combo_box_new;
     static Ptr_gtk_combo_box_entry_new gtk_combo_box_entry_new;
-    static Ptr_gtk_combo_box_new_with_entry gtk_combo_box_new_with_entry;
     static Ptr_gtk_progress_bar_new gtk_progress_bar_new;
     static Ptr_gtk_container_add gtk_container_add;
     static Ptr_gtk_menu_shell_append gtk_menu_shell_append;

src/widgets/styles/qmacstyle_mac.mm

@@ -4257,7 +4257,7 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
             if (isIndeterminate || tdi.value < tdi.max) {
                 if (QProgressStyleAnimation *animation = qobject_cast<QProgressStyleAnimation*>(d->animation(opt->styleObject)))
                     tdi.trackInfo.progress.phase = animation->animationStep();
-                else
+                else if (opt->styleObject)
                     d->startAnimation(new QProgressStyleAnimation(d->animateSpeed(QMacStylePrivate::AquaProgressBar), opt->styleObject));
             } else {
                 d->stopAnimation(opt->styleObject);
@@ -5013,6 +5013,8 @@ void QMacStyle::drawComplexControl(ComplexControl cc, const QStyleOptionComplex
                                       bgColor.blue() < 128;
                 if (isDarkBg)
                     [scroller setKnobStyle:NSScrollerKnobStyleLight];
+                else
+                    [scroller setKnobStyle:NSScrollerKnobStyleDefault];
 
                 [scroller setControlSize:(tdi.kind == kThemeSmallScrollBar ? NSMiniControlSize
                                                                            : NSRegularControlSize)];

src/widgets/styles/qstylesheetstyle.cpp

@@ -2605,14 +2605,17 @@ static void updateObjects(const QList<const QObject *>& objects)
             styleSheetCaches->renderRulesCache.remove(object);
         }
     }
-    for (int i = 0; i < objects.size(); ++i) {
+
-        QObject *object = const_cast<QObject *>(objects.at(i));
+    QWidgetList widgets;
-        if (object == 0)
+    foreach (const QObject *object, objects) {
-            continue;
+        if (QWidget *w = qobject_cast<QWidget*>(const_cast<QObject*>(object)))
-        if (QWidget *widget = qobject_cast<QWidget *>(object))
+            widgets << w;
-            widget->style()->polish(widget);
+    }
-        QEvent event(QEvent::StyleChange);
+
-        QApplication::sendEvent(object, &event);
+    QEvent event(QEvent::StyleChange);
+    foreach (QWidget *widget, widgets) {
+        widget->style()->polish(widget);
+        QApplication::sendEvent(widget, &event);
     }
 }
 

src/widgets/styles/qwindowsvistastyle.cpp

@@ -520,7 +520,11 @@ void QWindowsVistaStyle::drawPrimitive(PrimitiveElement element, const QStyleOpt
         }
         break;
     case PE_Frame: {
+#ifndef QT_NO_ACCESSIBILITY
         if (QStyleHelper::isInstanceOf(option->styleObject, QAccessible::EditableText)) {
+#else
+        if (false) {
+#endif
             painter->save();
             int stateId = ETS_NORMAL;
             if (!(state & State_Enabled))

src/widgets/widgets/qabstractscrollarea.cpp

@@ -329,13 +329,13 @@ void QAbstractScrollAreaPrivate::layoutChildren()
 {
     Q_Q(QAbstractScrollArea);
     bool transient = q->style()->styleHint(QStyle::SH_ScrollBar_Transient, 0, vbar ? vbar : hbar);
-    bool needh = (hbarpolicy == Qt::ScrollBarAlwaysOn && !transient)
+    bool needh = (hbarpolicy != Qt::ScrollBarAlwaysOff) && ((hbarpolicy == Qt::ScrollBarAlwaysOn && !transient)
                  || ((hbarpolicy == Qt::ScrollBarAsNeeded || transient)
-                     && hbar->minimum() < hbar->maximum() && !hbar->sizeHint().isEmpty());
+                     && hbar->minimum() < hbar->maximum() && !hbar->sizeHint().isEmpty()));
 
-    bool needv = (vbarpolicy == Qt::ScrollBarAlwaysOn && !transient)
+    bool needv = (vbarpolicy != Qt::ScrollBarAlwaysOff) && ((vbarpolicy == Qt::ScrollBarAlwaysOn && !transient)
                  || ((vbarpolicy == Qt::ScrollBarAsNeeded || transient)
-                     && vbar->minimum() < vbar->maximum() && !vbar->sizeHint().isEmpty());
+                     && vbar->minimum() < vbar->maximum() && !vbar->sizeHint().isEmpty()));
 
     QStyleOption opt(0);
     opt.init(q);
@@ -1456,9 +1456,9 @@ void QAbstractScrollAreaPrivate::flashScrollBars()
 {
     Q_Q(QAbstractScrollArea);
     bool transient =  q->style()->styleHint(QStyle::SH_ScrollBar_Transient, 0, vbar ? vbar : hbar);
-    if (hbarpolicy == Qt::ScrollBarAsNeeded || transient)
+    if ((hbarpolicy != Qt::ScrollBarAlwaysOff) && (hbarpolicy == Qt::ScrollBarAsNeeded || transient))
         hbar->d_func()->flash();
-    if (vbarpolicy == Qt::ScrollBarAsNeeded || transient)
+    if ((vbarpolicy != Qt::ScrollBarAlwaysOff) && (vbarpolicy == Qt::ScrollBarAsNeeded || transient))
         vbar->d_func()->flash();
 }
 

src/widgets/widgets/qtextedit.h

@@ -84,7 +84,7 @@ class Q_WIDGETS_EXPORT QTextEdit : public QAbstractScrollArea
     Q_PROPERTY(bool acceptRichText READ acceptRichText WRITE setAcceptRichText)
     Q_PROPERTY(int cursorWidth READ cursorWidth WRITE setCursorWidth)
     Q_PROPERTY(Qt::TextInteractionFlags textInteractionFlags READ textInteractionFlags WRITE setTextInteractionFlags)
-    Q_PROPERTY(QTextDocument *document READ document WRITE setDocument)
+    Q_PROPERTY(QTextDocument *document READ document WRITE setDocument DESIGNABLE false)
 public:
     enum LineWrapMode {
         NoWrap,

tests/auto/cmake/test_multiple_find_package/CMakeLists.txt

@@ -5,5 +5,9 @@ project(test_multiple_find_package)
 
 find_package(Qt5Core REQUIRED)
 
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Core_EXECUTABLE_COMPILE_FLAGS}")
+
 add_subdirectory(subdir1)
 
+add_executable(exe1 "${CMAKE_CURRENT_SOURCE_DIR}/main.cpp")
+include_directories(${Qt5Core_INCLUDE_DIRS})

tests/auto/cmake/test_multiple_find_package/main.cpp

@@ -0,0 +1,47 @@
+/****************************************************************************
+**
+** Copyright (C) 2013 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Stephen Kelly <stephen.kelly@kdab.com>
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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
+** 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.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** 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$
+**
+****************************************************************************/
+
+#include <QtCore/QString>
+
+int main(int,char**)
+{
+    return 0;
+}