From f4cf9fe05bb3f32fabea4e54dd92d368967a80da Mon Sep 17 00:00:00 2001 From: Adrian Dudau Date: Thu, 26 Jun 2014 14:36:22 +0200 Subject: initial commit for Enea Linux 4.0 Migrated from the internal git server on the daisy-enea branch Signed-off-by: Adrian Dudau --- meta/recipes-qt/qt4/nativesdk-qt4-tools.inc | 127 + meta/recipes-qt/qt4/nativesdk-qt4-tools_4.8.5.bb | 6 + ...embedded-usage-doesn-t-work-outside-of-Qt.patch | 73 + ...stvideoconnector-fixed-buffers-allocation.patch | 34 + ...nnecessary-rpaths-from-qml_device-example.patch | 28 + .../fix_metaobjectbuilder_build_err.patch | 4707 ++++++++++++++++++++ .../qt4/qt-mobility-1.2.0/gcc-scope.patch | 48 + .../qt-mobility-1.2.0/qt-mobility-configure.patch | 17 + .../qt-mobility-1.2.0/qt-mobility-no-opengl.patch | 38 + .../qt-mobility-1.2.0/qt-mobility-no-xvideo.patch | 26 + meta/recipes-qt/qt4/qt-mobility-embedded_1.2.0.bb | 11 + meta/recipes-qt/qt4/qt-mobility-x11_1.2.0.bb | 10 + meta/recipes-qt/qt4/qt-mobility_1.2.0.inc | 109 + meta/recipes-qt/qt4/qt4-4.8.5.inc | 63 + ...o-allow-to-set-qt.conf-from-the-outside-u.patch | 43 + ...tty_qws-fix-build-with-old-kernel-headers.patch | 50 + ...003-webkit2-set-OUTPUT_DIR-value-if-empty.patch | 34 + ...make-is-already-built-in-qt4-tools-native.patch | 29 + ...e-set-LFLAGS-to-pick-up-zlib-from-staging.patch | 28 + ...se-OE_QMAKE_-values-to-specify-Qt-utility.patch | 38 + ...-const-usage-that-causes-compile-failure-.patch | 34 + ...llow-building-a-separate-qmake-for-the-ta.patch | 29 + ...e-fix-source-file-references-in-qmake.pri.patch | 52 + ...ack-to-not-use-the-pg_config-of-the-host-.patch | 42 + .../qt4-4.8.5/0011-freetype-host-includes.patch | 29 + .../qt4/qt4-4.8.5/0012-Add-2bpp-support.patch | 318 ++ .../0013-configure-add-crossarch-option.patch | 47 + ...tions-fix-phony-translation-linking-error.patch | 41 + ...-configure-add-nostrip-for-debug-packages.patch | 32 + .../qt4-4.8.5/0016-configure-eval-QMAKE_CXX.patch | 37 + ...nsure-we-identify-the-compiler-as-g-in-co.patch | 46 + ...ure-make-pulseaudio-a-configurable-option.patch | 46 + ...xes-for-gcc-4.7.0-particularly-on-qemux86.patch | 63 + ...0020-webkit-disable-the-fuse-ld-gold-flag.patch | 41 + ...ake-qt4-native-work-with-long-building-pa.patch | 95 + ...-of-0-width-polylines-from-outside-the-de.patch | 148 + ...art-fix-data-corruption-in-readData-metho.patch | 43 + ...Pixel.y-is-also-initalized-to-1-when-nece.patch | 48 + ...ned-selection-region-with-text-when-cente.patch | 75 + ...ls.pro-disable-qmeegographicssystemhelper.patch | 28 + meta/recipes-qt/qt4/qt4-4.8.5/g++.conf | 61 + meta/recipes-qt/qt4/qt4-4.8.5/linux.conf | 66 + meta/recipes-qt/qt4/qt4-4.8.5/qte.sh | 7 + meta/recipes-qt/qt4/qt4-embedded.inc | 73 + meta/recipes-qt/qt4/qt4-embedded_4.8.5.bb | 9 + meta/recipes-qt/qt4/qt4-native.inc | 114 + meta/recipes-qt/qt4/qt4-native_4.8.5.bb | 6 + meta/recipes-qt/qt4/qt4-x11-free.inc | 39 + meta/recipes-qt/qt4/qt4-x11-free_4.8.5.bb | 9 + meta/recipes-qt/qt4/qt4.inc | 393 ++ meta/recipes-qt/qt4/qt4_arch.inc | 21 + 51 files changed, 7611 insertions(+) create mode 100644 meta/recipes-qt/qt4/nativesdk-qt4-tools.inc create mode 100644 meta/recipes-qt/qt4/nativesdk-qt4-tools_4.8.5.bb create mode 100644 meta/recipes-qt/qt4/qt-mobility-1.2.0/0001-fix-embedded-usage-doesn-t-work-outside-of-Qt.patch create mode 100644 meta/recipes-qt/qt4/qt-mobility-1.2.0/0001-gstvideoconnector-fixed-buffers-allocation.patch create mode 100644 meta/recipes-qt/qt4/qt-mobility-1.2.0/0002-Remove-unnecessary-rpaths-from-qml_device-example.patch create mode 100644 meta/recipes-qt/qt4/qt-mobility-1.2.0/fix_metaobjectbuilder_build_err.patch create mode 100644 meta/recipes-qt/qt4/qt-mobility-1.2.0/gcc-scope.patch create mode 100644 meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-configure.patch create mode 100644 meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-no-opengl.patch create mode 100644 meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-no-xvideo.patch create mode 100644 meta/recipes-qt/qt4/qt-mobility-embedded_1.2.0.bb create mode 100644 meta/recipes-qt/qt4/qt-mobility-x11_1.2.0.bb create mode 100644 meta/recipes-qt/qt4/qt-mobility_1.2.0.inc create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5.inc create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0001-qlibraryinfo-allow-to-set-qt.conf-from-the-outside-u.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0002-qkbdtty_qws-fix-build-with-old-kernel-headers.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0003-webkit2-set-OUTPUT_DIR-value-if-empty.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0004-configure-qmake-is-already-built-in-qt4-tools-native.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0005-configure-set-LFLAGS-to-pick-up-zlib-from-staging.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0006-configure-Use-OE_QMAKE_-values-to-specify-Qt-utility.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0007-dbus-Remove-const-usage-that-causes-compile-failure-.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0008-qmake.pro-Allow-building-a-separate-qmake-for-the-ta.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0009-qmake-fix-source-file-references-in-qmake.pri.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0010-configure-Hack-to-not-use-the-pg_config-of-the-host-.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0011-freetype-host-includes.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0012-Add-2bpp-support.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0013-configure-add-crossarch-option.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0014-translations-fix-phony-translation-linking-error.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0015-configure-add-nostrip-for-debug-packages.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0016-configure-eval-QMAKE_CXX.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0017-configure-ensure-we-identify-the-compiler-as-g-in-co.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0018-configure-make-pulseaudio-a-configurable-option.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0019-Fixes-for-gcc-4.7.0-particularly-on-qemux86.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0020-webkit-disable-the-fuse-ld-gold-flag.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0021-configure-make-qt4-native-work-with-long-building-pa.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0022-Fix-drawing-of-0-width-polylines-from-outside-the-de.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0023-QHttpMultiPart-fix-data-corruption-in-readData-metho.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0024-Ensure-lastPixel.y-is-also-initalized-to-1-when-nece.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0025-Fix-misaligned-selection-region-with-text-when-cente.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/0027-tools.pro-disable-qmeegographicssystemhelper.patch create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/g++.conf create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/linux.conf create mode 100644 meta/recipes-qt/qt4/qt4-4.8.5/qte.sh create mode 100644 meta/recipes-qt/qt4/qt4-embedded.inc create mode 100644 meta/recipes-qt/qt4/qt4-embedded_4.8.5.bb create mode 100644 meta/recipes-qt/qt4/qt4-native.inc create mode 100644 meta/recipes-qt/qt4/qt4-native_4.8.5.bb create mode 100644 meta/recipes-qt/qt4/qt4-x11-free.inc create mode 100644 meta/recipes-qt/qt4/qt4-x11-free_4.8.5.bb create mode 100644 meta/recipes-qt/qt4/qt4.inc create mode 100644 meta/recipes-qt/qt4/qt4_arch.inc (limited to 'meta/recipes-qt/qt4') diff --git a/meta/recipes-qt/qt4/nativesdk-qt4-tools.inc b/meta/recipes-qt/qt4/nativesdk-qt4-tools.inc new file mode 100644 index 0000000000..1c9ee2e6ea --- /dev/null +++ b/meta/recipes-qt/qt4/nativesdk-qt4-tools.inc @@ -0,0 +1,127 @@ +SUMMARY = "SDK tools for Qt version 4.x" +DEPENDS = "nativesdk-zlib nativesdk-dbus nativesdk-libx11 qt4-native" +SECTION = "libs" +HOMEPAGE = "http://qt-project.org/" +LICENSE = "LGPLv2.1 | GPLv3" + +INC_PR = "r13" + +FILESEXTRAPATHS =. "${FILE_DIRNAME}/qt4-${PV}:" + +inherit nativesdk qmake2 + +SRC_URI = "http://download.qt-project.org/official_releases/qt/4.8/${PV}/qt-everywhere-opensource-src-${PV}.tar.gz \ + file://0001-qlibraryinfo-allow-to-set-qt.conf-from-the-outside-u.patch \ + file://0004-configure-qmake-is-already-built-in-qt4-tools-native.patch \ + file://0005-configure-set-LFLAGS-to-pick-up-zlib-from-staging.patch \ + file://0006-configure-Use-OE_QMAKE_-values-to-specify-Qt-utility.patch \ + file://0007-dbus-Remove-const-usage-that-causes-compile-failure-.patch \ + file://0008-qmake.pro-Allow-building-a-separate-qmake-for-the-ta.patch \ + file://g++.conf \ + file://linux.conf" + +S = "${WORKDIR}/qt-everywhere-opensource-src-${PV}" + +LIC_FILES_CHKSUM = "file://LICENSE.LGPL;md5=fbc093901857fcd118f065f900982c24 \ + file://LICENSE.GPL3;md5=6e1694ee338db410417517884918d4d2 \ + file://LGPL_EXCEPTION.txt;md5=0145c4d1b6f96a661c2c139dfb268fb6" + +require qt4_arch.inc + +# FIXME: make it work with "${STAGING_BINDIR_NATIVE}/pkg-config --cflags dbus-1" +EXTRA_OECONF = "-prefix ${prefix} \ + -qt-libjpeg -system-zlib \ + -no-libjpeg -no-libpng -no-libmng -no-libtiff \ + -no-accessibility \ + -no-cups \ + -no-exceptions \ + -no-nas-sound \ + -no-nis -no-openssl \ + -verbose -release -fast -static \ + -platform ${TARGET_OS}-oe-g++ \ + -xplatform ${TARGET_OS}-oe-g++ \ + -arch ${QT_ARCH} \ + -embedded -no-freetype -no-glib -no-iconv \ + -qt3support \ + -I${STAGING_DIR_HOST}${SDKPATHNATIVE}/usr/include/dbus-1.0 \ + -I${STAGING_DIR_HOST}${SDKPATHNATIVE}/usr/lib/dbus-1.0/include" + +# yank default -e, otherwise we get the following error: +# moc_qbuffer.cpp: No such file or directory +EXTRA_OEMAKE = " " + +do_configure() { + # Avoid problems with Qt 4.8.0 configure setting QMAKE_LINK from LD (since we want the linker to be g++) + unset LD + + if [ ! -e mkspecs/${TARGET_OS}-oe-g++ ]; then + ln -sf linux-g++ mkspecs/${TARGET_OS}-oe-g++ + fi + + cp ../g++.conf mkspecs/common + cp ../linux.conf mkspecs/common + + if [ -f mkspecs/common/g++-base.conf ] ; then + # don't use host g++ even during configure (4.8.0+) + sed -i -e "s#= g++#= ${CXX}#" mkspecs/common/g++-base.conf + sed -i -e "s#= gcc#= ${CC}#" mkspecs/common/g++-base.conf + fi + + # Use qmake from qt4-native for building + if [ ! -e bin/qmake ]; then + ln -sf ${STAGING_BINDIR_NATIVE}/qmake2 bin/qmake + fi + set_arch + (echo o; echo yes) | CC="${CC}" CXX="${CXX}" ./configure ${EXTRA_OECONF} || die "Configuring qt failed. EXTRA_OECONF was ${EXTRA_OECONF}" +} + +TOBUILD = "\ + src/tools/bootstrap \ + src/tools/moc \ + src/corelib \ + src/sql \ + src/dbus \ + src/qt3support \ + src/xml \ + src/tools/uic \ + src/tools/rcc \ + src/network \ + src/gui \ + src/tools/uic3 \ + tools/linguist/lrelease \ + tools/linguist/lupdate \ + tools/qdbus \ +" + +do_compile() { + for i in ${TOBUILD}; do + cd ${S}/$i && oe_runmake CC="${CC}" CXX="${CXX}" + done + + # Build nativesdk qmake + export QMAKESPEC="${S}/mkspecs/${TARGET_OS}-oe-g++" + cd ${S}/qmake + ${OE_QMAKE_QMAKE} + oe_runmake CC="${CC}" CXX="${CXX}" + cd ${S} +} + +do_install() { + install -d ${D}${bindir} + install -m 0755 bin/qmake2 ${D}${bindir}/qmake2 + for i in moc uic uic3 rcc lrelease lupdate qdbuscpp2xml qdbusxml2cpp; do + install -m 0755 bin/${i} ${D}${bindir}/${i}4 + done + + (cd ${D}${bindir}; \ + ln -s qmake2 qmake; \ + for i in moc uic uic3 rcc lrelease lupdate qdbuscpp2xml qdbusxml2cpp; do \ + ln -s ${i}4 ${i}; \ + done) + + install -d ${D}${sysconfdir} + cat >${D}${sysconfdir}/qt.conf < +Date: Tue, 10 May 2011 14:54:49 +1000 +Subject: [PATCH] fix !embedded usage (doesn't work outside of Qt) + +embedded is part of QT_CONFIG and not CONFIG + +Task-number: QTMOBILITY-1586 +--- +Upstream-Status: Backport +https://qt.gitorious.org/qt-mobility/qt-mobility/commit/de2b568a4f14f38ae26960f543277bd2ac57c9d6 +EB: refreshed the patch for it to apply properly + + plugins/multimedia/gstreamer/gstreamer.pro | 2 +- + src/systeminfo/systeminfo.pro | 6 +++--- + tests/auto/auto.pro | 2 +- + 3 files changed, 5 insertions(+), 5 deletions(-) + +Index: qt-mobility-opensource-src-1.2.0/plugins/multimedia/gstreamer/gstreamer.pro +=================================================================== +--- qt-mobility-opensource-src-1.2.0.orig/plugins/multimedia/gstreamer/gstreamer.pro 2013-09-19 10:34:40.880862884 +0200 ++++ qt-mobility-opensource-src-1.2.0/plugins/multimedia/gstreamer/gstreamer.pro 2013-09-19 10:35:22.844862550 +0200 +@@ -85,7 +85,7 @@ + qgstutils.cpp + + +-!win32:!embedded:!mac:!symbian:!simulator:!contains(QT_CONFIG, qpa) { ++!win32:!contains(QT_CONFIG,embedded):!mac:!symbian:!simulator:!contains(QT_CONFIG, qpa) { + LIBS += -lXv -lX11 -lXext + + HEADERS += \ +Index: qt-mobility-opensource-src-1.2.0/src/systeminfo/systeminfo.pro +=================================================================== +--- qt-mobility-opensource-src-1.2.0.orig/src/systeminfo/systeminfo.pro 2013-09-19 10:34:40.884862884 +0200 ++++ qt-mobility-opensource-src-1.2.0/src/systeminfo/systeminfo.pro 2013-09-19 10:36:05.480862210 +0200 +@@ -101,7 +101,7 @@ + LIBS += -lblkid + } + +- !embedded:!contains(QT_CONFIG,qpa): { ++ !contains(QT_CONFIG,embedded):!contains(QT_CONFIG,qpa): { + LIBS += -lX11 -lXrandr + } + +@@ -154,7 +154,7 @@ + #for now... udisks + } else { + DEFINES += QT_NO_UDISKS +- !embedded:!contains(QT_CONFIG,qpa): LIBS += -lX11 -lXrandr ++ !contains(QT_CONFIG,embedded):!contains(QT_CONFIG,qpa): LIBS += -lX11 -lXrandr + } + + contains(connman_enabled, yes): { +@@ -165,7 +165,7 @@ + } + } else { + DEFINES += QT_NO_NETWORKMANAGER QT_NO_UDISKS QT_NO_CONNMAN +- !embedded:!contains(QT_CONFIG,qpa): LIBS += -lX11 -lXrandr ++ !contains(QT_CONFIG,embedded):!contains(QT_CONFIG,qpa): LIBS += -lX11 -lXrandr + } + } + +Index: qt-mobility-opensource-src-1.2.0/tests/auto/auto.pro +=================================================================== +--- qt-mobility-opensource-src-1.2.0.orig/tests/auto/auto.pro 2013-09-19 10:34:40.884862884 +0200 ++++ qt-mobility-opensource-src-1.2.0/tests/auto/auto.pro 2013-09-19 10:35:22.844862550 +0200 +@@ -21,5 +21,5 @@ + # which require that the autotest is run on the same machine + # doing the build - i.e. cross-compilation is not allowed. + win32|mac|linux-g++* { +- !embedded:!maemo5:!maemo6:SUBDIRS+=host.pro ++ !contains(QT_CONFIG,embedded):!maemo5:!maemo6:SUBDIRS+=host.pro + } diff --git a/meta/recipes-qt/qt4/qt-mobility-1.2.0/0001-gstvideoconnector-fixed-buffers-allocation.patch b/meta/recipes-qt/qt4/qt-mobility-1.2.0/0001-gstvideoconnector-fixed-buffers-allocation.patch new file mode 100644 index 0000000000..2df76fc778 --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-1.2.0/0001-gstvideoconnector-fixed-buffers-allocation.patch @@ -0,0 +1,34 @@ +Upstream-Status: Submitted [QTMOBILITY-1611] + +From b308508b49afa9a129b4e4589c57cd107d1320b8 Mon Sep 17 00:00:00 2001 +From: Dmytro Poplavskiy +Date: Fri, 6 May 2011 10:35:11 +1000 +Subject: [PATCH] gstvideoconnector: fixed buffers allocation + +It should not be necessary, but at least theora video decoder doesn't +iniatilize *buf, while gst_pad_alloc_buffer relies on buf being NULL. + +Task-number: QTMOBILITY-1611 +Reviewed-by: Michael Goddard +--- + plugins/multimedia/gstreamer/gstvideoconnector.c | 4 ++++ + 1 files changed, 4 insertions(+), 0 deletions(-) + +diff --git a/plugins/multimedia/gstreamer/gstvideoconnector.c b/plugins/multimedia/gstreamer/gstvideoconnector.c +index ddf68e0..9f8ceae 100644 +--- a/plugins/multimedia/gstreamer/gstvideoconnector.c ++++ b/plugins/multimedia/gstreamer/gstvideoconnector.c +@@ -186,6 +186,10 @@ gst_video_connector_buffer_alloc (GstPad * pad, guint64 offset, guint size, + GstFlowReturn res = GST_FLOW_OK; + element = GST_VIDEO_CONNECTOR (GST_PAD_PARENT (pad)); + ++ if (!buf) ++ return GST_FLOW_ERROR; ++ *buf = NULL; ++ + GST_OBJECT_LOCK (element); + gst_object_ref(element->srcpad); + GST_OBJECT_UNLOCK (element); +-- +1.7.4.1 + diff --git a/meta/recipes-qt/qt4/qt-mobility-1.2.0/0002-Remove-unnecessary-rpaths-from-qml_device-example.patch b/meta/recipes-qt/qt4/qt-mobility-1.2.0/0002-Remove-unnecessary-rpaths-from-qml_device-example.patch new file mode 100644 index 0000000000..a411640b73 --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-1.2.0/0002-Remove-unnecessary-rpaths-from-qml_device-example.patch @@ -0,0 +1,28 @@ +From 92e0c611f4969c716616d64df64831387e5b1632 Mon Sep 17 00:00:00 2001 +From: Paul Eggleton +Date: Fri, 16 Mar 2012 10:24:00 +0000 +Subject: [PATCH] Remove unnecessary rpaths from qml_device example + +These can't be valid in any case. + +Upstream-Status: Pending + +Signed-off-by: Paul Eggleton +--- + examples/declarative-systeminfo/device/device.pro | 3 --- + 1 files changed, 0 insertions(+), 3 deletions(-) + +diff --git a/examples/declarative-systeminfo/device/device.pro b/examples/declarative-systeminfo/device/device.pro +index 698e5fb..05be9b7 100644 +--- a/examples/declarative-systeminfo/device/device.pro ++++ b/examples/declarative-systeminfo/device/device.pro +@@ -17,6 +17,3 @@ symbian { + } + RESOURCES += device.qrc + +-QMAKE_LFLAGS_DEBUG += "-Wl,-rpath,/home/user/qt/lib" +-QMAKE_LFLAGS_RPATH += "-Wl,-rpath,/home/user/qt/lib" +-QMAKE_LFLAGS_RELEASE += "-Wl,-rpath,/home/user/qt/lib" +-- +1.7.5.4 + diff --git a/meta/recipes-qt/qt4/qt-mobility-1.2.0/fix_metaobjectbuilder_build_err.patch b/meta/recipes-qt/qt4/qt-mobility-1.2.0/fix_metaobjectbuilder_build_err.patch new file mode 100644 index 0000000000..cffb06706f --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-1.2.0/fix_metaobjectbuilder_build_err.patch @@ -0,0 +1,4707 @@ +Fix metaobjectbuilder build errors against Qt 4.8 and 4.7 + +Error message: +ipc/qmetaobjectbuilder.cpp:803:65: error: invalid conversion from \ +'QMetaObjectExtraData::StaticMetacallFunction {aka void (*)(QObject*, \ +QMetaObject::Call, int, void**)}' to 'QtMobility::QMetaObjectBuilder:: \ +StaticMetacallFunction {aka int (*)(QMetaObject::Call, int, void**)} + +Upstream-commit: +http://qt.gitorious.org/qt-mobility/qt-mobility/commit/f102053b28009b3094b0e5777177208afa6097c5 + +Task-number: QTMOBILITY-1990 + +Upstream-Status: Backport + +Signed-off-by: Wenzong Fan +------------------------------------------------------ +diff --git a/plugins/declarative/common/dynamicproperties.pri b/plugins/declarative/common/dynamicproperties.pri +index 52737a3..4bd06de 100644 +--- a/plugins/declarative/common/dynamicproperties.pri ++++ b/plugins/declarative/common/dynamicproperties.pri +@@ -1,6 +1,8 @@ + INCLUDEPATH += ../../../plugins/declarative/common/dynamicproperties/ +-HEADERS += ../../../plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject_p.h \ +- ../../../plugins/declarative/common/dynamicproperties/qmetaobjectbuilder_p.h +-SOURCES += ../../../plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp \ +- ../../../src/serviceframework/ipc/qmetaobjectbuilder.cpp +- ++HEADERS += ../../../plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject_p.h ++SOURCES += ../../../plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp ++include(../../../src/serviceframework/ipc/metaobjectbuilder.pri) ++INCLUDEPATH += ../../../src/serviceframework/$$OBJECTBUILDER_INCLUDEPATH ++DEPENDPATH += ../../../src/serviceframework/$$OBJECTBUILDER_DEPENDPATH ++HEADERS += ../../../src/serviceframework/$$OBJECTBUILDER_HEADERS ++SOURCES += ../../../src/serviceframework/$$OBJECTBUILDER_SOURCES +diff --git a/plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp b/plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp +index 79a2064..9eb6810 100644 +--- a/plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp ++++ b/plugins/declarative/common/dynamicproperties/qdeclarativeopenmetaobject.cpp +@@ -65,8 +65,7 @@ public: + { + int id = mob.propertyCount(); + mob.addSignal("__" + QByteArray::number(id) + "()"); +- QMetaPropertyBuilder build = mob.addProperty(name, type, id); +- build.setDynamic(true); ++ mob.addProperty(name, type, id); + qFree(mem); + mem = mob.toMetaObject(); + +diff --git a/plugins/declarative/common/dynamicproperties/qmetaobjectbuilder_p.h b/plugins/declarative/common/dynamicproperties/qmetaobjectbuilder_p.h +deleted file mode 100644 +index bd937e4..0000000 +--- a/plugins/declarative/common/dynamicproperties/qmetaobjectbuilder_p.h ++++ /dev/null +@@ -1,48 +0,0 @@ +-/**************************************************************************** +-** +-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +-** All rights reserved. +-** Contact: Nokia Corporation (qt-info@nokia.com) +-** +-** This file is part of the Qt Mobility Components. +-** +-** $QT_BEGIN_LICENSE:LGPL$ +-** No Commercial Usage +-** This file contains pre-release code and may not be distributed. +-** You may use this file in accordance with the terms and conditions +-** contained in the Technology Preview License Agreement accompanying +-** this package. +-** +-** 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, Nokia gives you certain additional +-** rights. These rights are described in the Nokia Qt LGPL Exception +-** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +-** +-** If you have questions regarding the use of this file, please contact +-** Nokia at qt-info@nokia.com. +-** +-** +-** +-** +-** +-** +-** +-** +-** $QT_END_LICENSE$ +-** +-****************************************************************************/ +- +-/* +-This header gets used in a number of different QML plugins +-and also in the source tree of Mobility itself. +- +-So this header is just a wrapper to grab it from there. +-*/ +-#include "../../../../src/serviceframework/ipc/qmetaobjectbuilder_p.h" +diff --git a/src/serviceframework/ipc/ipc.pri b/src/serviceframework/ipc/ipc.pri +index 28b910f..d809f59 100644 +--- a/src/serviceframework/ipc/ipc.pri ++++ b/src/serviceframework/ipc/ipc.pri +@@ -25,9 +25,14 @@ else { + } + } + ++include(metaobjectbuilder.pri) ++INCLUDEPATH += $$OBJECTBUILDER_INCLUDEPATH ++DEPENDPATH += $$OBJECTBUILDER_DEPENDPATH ++PRIVATE_HEADERS += $$OBJECTBUILDER_HEADERS ++SOURCES += $$OBJECTBUILDER_SOURCES ++ + PRIVATE_HEADERS += ipc/qslotinvoker_p.h \ + ipc/qsignalintercepter_p.h \ +- ipc/qmetaobjectbuilder_p.h \ + ipc/instancemanager_p.h \ + ipc/qservicepackage_p.h \ + ipc/proxyobject_p.h \ +@@ -37,7 +42,6 @@ PRIVATE_HEADERS += ipc/qslotinvoker_p.h \ + + SOURCES += ipc/qslotinvoker.cpp \ + ipc/qsignalintercepter.cpp \ +- ipc/qmetaobjectbuilder.cpp \ + ipc/instancemanager.cpp \ + ipc/qservicepackage.cpp \ + ipc/proxyobject.cpp \ +diff --git a/src/serviceframework/ipc/metaobjectbuilder.pri b/src/serviceframework/ipc/metaobjectbuilder.pri +new file mode 100644 +index 0000000..cc905f9 +--- /dev/null ++++ b/src/serviceframework/ipc/metaobjectbuilder.pri +@@ -0,0 +1,12 @@ ++#check version for 4.7 ... ++contains(QT_MAJOR_VERSION, 4):lessThan(QT_MINOR_VERSION, 8) { ++ OBJECTBUILDER_INCLUDEPATH += ipc ++ OBJECTBUILDER_DEPENDPATH += ipc ++ OBJECTBUILDER_HEADERS += ipc/qmetaobjectbuilder_47_p.h ++ OBJECTBUILDER_SOURCES += ipc/qmetaobjectbuilder_47.cpp ++} else { ++ OBJECTBUILDER_INCLUDEPATH += ipc ++ OBJECTBUILDER_DEPENDPATH += ipc ++ OBJECTBUILDER_HEADERS += ipc/qmetaobjectbuilder_p.h ++ OBJECTBUILDER_SOURCES += ipc/qmetaobjectbuilder.cpp ++} +diff --git a/src/serviceframework/ipc/qmetaobjectbuilder.cpp b/src/serviceframework/ipc/qmetaobjectbuilder.cpp +index b19eb1a..6ffaa20 100644 +--- a/src/serviceframework/ipc/qmetaobjectbuilder.cpp ++++ b/src/serviceframework/ipc/qmetaobjectbuilder.cpp +@@ -117,6 +117,8 @@ enum PropertyFlags { + EnumOrFlag = 0x00000008, + StdCppSet = 0x00000100, + // Override = 0x00000200, ++ Constant = 0x00000400, ++ Final = 0x00000800, + Designable = 0x00001000, + ResolveDesignable = 0x00002000, + Scriptable = 0x00004000, +@@ -128,7 +130,7 @@ enum PropertyFlags { + User = 0x00100000, + ResolveUser = 0x00200000, + Notify = 0x00400000, +- Dynamic = 0x00800000 ++ Revisioned = 0x00800000 + }; + + enum MethodFlags { +@@ -145,7 +147,8 @@ enum MethodFlags { + + MethodCompatibility = 0x10, + MethodCloned = 0x20, +- MethodScriptable = 0x40 ++ MethodScriptable = 0x40, ++ MethodRevisioned = 0x80 + }; + + struct QMetaObjectPrivate +@@ -623,6 +626,8 @@ QMetaPropertyBuilder QMetaObjectBuilder::addProperty(const QMetaProperty& protot + property.setUser(prototype.isUser()); + property.setStdCppSet(prototype.hasStdCppSet()); + property.setEnumOrFlag(prototype.isEnumType()); ++ property.setConstant(prototype.isConstant()); ++ property.setFinal(prototype.isFinal()); + if (prototype.hasNotifySignal()) { + // Find an existing method for the notify signal, or add a new one. + QMetaMethod method = prototype.notifySignal(); +@@ -796,7 +801,7 @@ void QMetaObjectBuilder::addMetaObject + } + + if ((members & StaticMetacall) != 0) { +- if (priv(prototype->d.data)->revision >= 2) { ++ if (priv(prototype->d.data)->revision >= 6) { + const QMetaObjectExtraData *extra = + (const QMetaObjectExtraData *)(prototype->d.extradata); + if (extra && extra->static_metacall) +@@ -1266,8 +1271,8 @@ static int buildMetaObject(QMetaObjectBuilderPrivate *d, char *buf, + char *str = reinterpret_cast(buf + size); + if (buf) { + if (relocatable) { +- meta->d.stringdata = reinterpret_cast((intptr_t)size); +- meta->d.data = reinterpret_cast((intptr_t)pmetaSize); ++ meta->d.stringdata = reinterpret_cast((quintptr)size); ++ meta->d.data = reinterpret_cast((quintptr)pmetaSize); + } else { + meta->d.stringdata = str; + meta->d.data = reinterpret_cast(data); +@@ -1504,8 +1509,8 @@ void QMetaObjectBuilder::fromRelocatableData(QMetaObject *output, + const char *buf = data.constData(); + const QMetaObject *dataMo = reinterpret_cast(buf); + +- intptr_t stringdataOffset = (intptr_t)dataMo->d.stringdata; +- intptr_t dataOffset = (intptr_t)dataMo->d.data; ++ quintptr stringdataOffset = (quintptr)dataMo->d.stringdata; ++ quintptr dataOffset = (quintptr)dataMo->d.data; + + output->d.superdata = superclass; + output->d.stringdata = buf + stringdataOffset; +@@ -2289,16 +2294,27 @@ bool QMetaPropertyBuilder::isEnumOrFlag() const + } + + /*! +- Returns true if the property has the dynamic flag set; +- otherwise returns false. The default value is false. ++ Returns true if the property is constant; otherwise returns false. ++ The default value is false. ++*/ ++bool QMetaPropertyBuilder::isConstant() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Constant); ++ else ++ return false; ++} + +- \sa setDynamic() ++/*! ++ Returns true if the property is final; otherwise returns false. ++ The default value is false. + */ +-bool QMetaPropertyBuilder::isDynamic() const ++bool QMetaPropertyBuilder::isFinal() const + { + QMetaPropertyBuilderPrivate *d = d_func(); + if (d) +- return d->flag(Dynamic); ++ return d->flag(Final); + else + return false; + } +@@ -2427,16 +2443,27 @@ void QMetaPropertyBuilder::setEnumOrFlag(bool value) + } + + /*! +- Sets this property to have the dynamic flag if \a value is +- true. ++ Sets the \c CONSTANT flag on this property to \a value. ++ ++ \sa isConstant() ++*/ ++void QMetaPropertyBuilder::setConstant(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Constant, value); ++} ++ ++/*! ++ Sets the \c FINAL flag on this property to \a value. + +- \sa isDynamic() ++ \sa isFinal() + */ +-void QMetaPropertyBuilder::setDynamic(bool value) ++void QMetaPropertyBuilder::setFinal(bool value) + { + QMetaPropertyBuilderPrivate *d = d_func(); + if (d) +- d->setFlag(Dynamic, value); ++ d->setFlag(Final, value); + } + + /*! +diff --git a/src/serviceframework/ipc/qmetaobjectbuilder_47.cpp b/src/serviceframework/ipc/qmetaobjectbuilder_47.cpp +new file mode 100644 +index 0000000..509d6c6 +--- /dev/null ++++ b/src/serviceframework/ipc/qmetaobjectbuilder_47.cpp +@@ -0,0 +1,2583 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). ++** All rights reserved. ++** Contact: Nokia Corporation (qt-info@nokia.com) ++** ++** This file is part of the QtDeclarative module of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** No Commercial Usage ++** This file contains pre-release code and may not be distributed. ++** You may use this file in accordance with the terms and conditions ++** contained in the Technology Preview License Agreement accompanying ++** this package. ++** ++** 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, Nokia gives you certain additional ++** rights. These rights are described in the Nokia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** If you have questions regarding the use of this file, please contact ++** Nokia at qt-info@nokia.com. ++** ++** ++** ++** ++** ++** ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#include "qmetaobjectbuilder_47_p.h" ++#include ++ ++#ifndef Q_OS_WIN ++#include ++#endif ++ ++QTM_BEGIN_NAMESPACE ++ ++/*! ++ \class QMetaObjectBuilder ++ \internal ++ \brief The QMetaObjectBuilder class supports building QMetaObject objects at runtime. ++ \since 1.1 ++ ++*/ ++ ++/*! ++ \enum QMetaObjectBuilder::AddMember ++ This enum defines which members of QMetaObject should be copied by QMetaObjectBuilder::addMetaObject() ++ ++ \value ClassName Add the class name. ++ \value SuperClass Add the super class. ++ \value Methods Add methods that aren't signals or slots. ++ \value Signals Add signals. ++ \value Slots Add slots. ++ \value Constructors Add constructors. ++ \value Properties Add properties. ++ \value Enumerators Add enumerators. ++ \value ClassInfos Add items of class information. ++ \value RelatedMetaObjects Add related meta objects. ++ \value StaticMetacall Add the static metacall function. ++ \value PublicMethods Add public methods (ignored for signals). ++ \value ProtectedMethods Add protected methods (ignored for signals). ++ \value PrivateMethods All private methods (ignored for signals). ++ \value AllMembers Add all members. ++ \value AllPrimaryMembers Add everything except the class name, super class, and static metacall function. ++*/ ++ ++// copied from moc's generator.cpp ++uint qvariant_nameToType(const char* name) ++{ ++ if (!name) ++ return 0; ++ ++ if (strcmp(name, "QVariant") == 0) ++ return 0xffffffff; ++ if (strcmp(name, "QCString") == 0) ++ return QMetaType::QByteArray; ++ if (strcmp(name, "Q_LLONG") == 0) ++ return QMetaType::LongLong; ++ if (strcmp(name, "Q_ULLONG") == 0) ++ return QMetaType::ULongLong; ++ if (strcmp(name, "QIconSet") == 0) ++ return QMetaType::QIcon; ++ ++ uint tp = QMetaType::type(name); ++ return tp < QMetaType::User ? tp : 0; ++} ++ ++/* ++ Returns true if the type is a QVariant types. ++*/ ++bool isVariantType(const char* type) ++{ ++ return qvariant_nameToType(type) != 0; ++} ++ ++// copied from qmetaobject.cpp ++// do not touch without touching the moc as well ++enum PropertyFlags { ++ Invalid = 0x00000000, ++ Readable = 0x00000001, ++ Writable = 0x00000002, ++ Resettable = 0x00000004, ++ EnumOrFlag = 0x00000008, ++ StdCppSet = 0x00000100, ++// Override = 0x00000200, ++ Designable = 0x00001000, ++ ResolveDesignable = 0x00002000, ++ Scriptable = 0x00004000, ++ ResolveScriptable = 0x00008000, ++ Stored = 0x00010000, ++ ResolveStored = 0x00020000, ++ Editable = 0x00040000, ++ ResolveEditable = 0x00080000, ++ User = 0x00100000, ++ ResolveUser = 0x00200000, ++ Notify = 0x00400000, ++ Dynamic = 0x00800000 ++}; ++ ++enum MethodFlags { ++ AccessPrivate = 0x00, ++ AccessProtected = 0x01, ++ AccessPublic = 0x02, ++ AccessMask = 0x03, //mask ++ ++ MethodMethod = 0x00, ++ MethodSignal = 0x04, ++ MethodSlot = 0x08, ++ MethodConstructor = 0x0c, ++ MethodTypeMask = 0x0c, ++ ++ MethodCompatibility = 0x10, ++ MethodCloned = 0x20, ++ MethodScriptable = 0x40 ++}; ++ ++struct QMetaObjectPrivate ++{ ++ int revision; ++ int className; ++ int classInfoCount, classInfoData; ++ int methodCount, methodData; ++ int propertyCount, propertyData; ++ int enumeratorCount, enumeratorData; ++ int constructorCount, constructorData; ++ int flags; ++}; ++ ++static inline const QMetaObjectPrivate *priv(const uint* data) ++{ return reinterpret_cast(data); } ++// end of copied lines from qmetaobject.cpp ++ ++class QMetaMethodBuilderPrivate ++{ ++public: ++ QMetaMethodBuilderPrivate ++ (QMetaMethod::MethodType _methodType, ++ const QByteArray& _signature, ++ const QByteArray& _returnType = QByteArray(), ++ QMetaMethod::Access _access = QMetaMethod::Public) ++ : signature(QMetaObject::normalizedSignature(_signature.constData())), ++ returnType(QMetaObject::normalizedType(_returnType)), ++ attributes(((int)_access) | (((int)_methodType) << 2)) ++ { ++ } ++ ++ QByteArray signature; ++ QByteArray returnType; ++ QList parameterNames; ++ QByteArray tag; ++ int attributes; ++ ++ QMetaMethod::MethodType methodType() const ++ { ++ return (QMetaMethod::MethodType)((attributes & MethodTypeMask) >> 2); ++ } ++ ++ QMetaMethod::Access access() const ++ { ++ return (QMetaMethod::Access)(attributes & AccessMask); ++ } ++ ++ void setAccess(QMetaMethod::Access value) ++ { ++ attributes = ((attributes & ~AccessMask) | (int)value); ++ } ++}; ++ ++class QMetaPropertyBuilderPrivate ++{ ++public: ++ QMetaPropertyBuilderPrivate ++ (const QByteArray& _name, const QByteArray& _type, int notifierIdx=-1) ++ : name(_name), ++ type(QMetaObject::normalizedType(_type.constData())), ++ flags(Readable | Writable | Scriptable), notifySignal(-1) ++ { ++ if (notifierIdx >= 0) { ++ flags |= Notify; ++ notifySignal = notifierIdx; ++ } ++ } ++ ++ QByteArray name; ++ QByteArray type; ++ int flags; ++ int notifySignal; ++ ++ bool flag(int f) const ++ { ++ return ((flags & f) != 0); ++ } ++ ++ void setFlag(int f, bool value) ++ { ++ if (value) ++ flags |= f; ++ else ++ flags &= ~f; ++ } ++}; ++ ++class QMetaEnumBuilderPrivate ++{ ++public: ++ QMetaEnumBuilderPrivate(const QByteArray& _name) ++ : name(_name), isFlag(false) ++ { ++ } ++ ++ QByteArray name; ++ bool isFlag; ++ QList keys; ++ QList values; ++}; ++ ++class QMetaObjectBuilderPrivate ++{ ++public: ++ QMetaObjectBuilderPrivate() ++ : flags(0) ++ { ++ superClass = &QObject::staticMetaObject; ++ staticMetacallFunction = 0; ++ } ++ ++ QByteArray className; ++ const QMetaObject *superClass; ++ QMetaObjectBuilder::StaticMetacallFunction staticMetacallFunction; ++ QList methods; ++ QList constructors; ++ QList properties; ++ QList classInfoNames; ++ QList classInfoValues; ++ QList enumerators; ++#ifdef Q_NO_DATA_RELOCATION ++ QList relatedMetaObjects; ++#else ++ QList relatedMetaObjects; ++#endif ++ int flags; ++}; ++ ++/*! ++ Constructs a new QMetaObjectBuilder. ++*/ ++QMetaObjectBuilder::QMetaObjectBuilder() ++{ ++ d = new QMetaObjectBuilderPrivate(); ++} ++ ++/*! ++ Constructs a new QMetaObjectBuilder which is a copy of the ++ meta object information in \a prototype. Note: the super class ++ contents for \a prototype are not copied, only the immediate ++ class that is defined by \a prototype. ++ ++ The \a members parameter indicates which members of \a prototype ++ should be added. The default is AllMembers. ++ ++ \sa addMetaObject() ++*/ ++QMetaObjectBuilder::QMetaObjectBuilder ++ (const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members) ++{ ++ d = new QMetaObjectBuilderPrivate(); ++ addMetaObject(prototype, members); ++} ++ ++/*! ++ Destroys this meta object builder. ++*/ ++QMetaObjectBuilder::~QMetaObjectBuilder() ++{ ++ delete d; ++} ++ ++/*! ++ Returns the name of the class being constructed by this ++ meta object builder. The default value is an empty QByteArray. ++ ++ \sa setClassName(), superClass() ++*/ ++QByteArray QMetaObjectBuilder::className() const ++{ ++ return d->className; ++} ++ ++/*! ++ Sets the \a name of the class being constructed by this ++ meta object builder. ++ ++ \sa className(), setSuperClass() ++*/ ++void QMetaObjectBuilder::setClassName(const QByteArray& name) ++{ ++ d->className = name; ++} ++ ++/*! ++ Returns the superclass meta object of the class being constructed ++ by this meta object builder. The default value is the meta object ++ for QObject. ++ ++ \sa setSuperClass(), className() ++*/ ++const QMetaObject *QMetaObjectBuilder::superClass() const ++{ ++ return d->superClass; ++} ++ ++/*! ++ Sets the superclass meta object of the class being constructed ++ by this meta object builder to \a meta. The \a meta parameter ++ must not be null. ++ ++ \sa superClass(), setClassName() ++*/ ++void QMetaObjectBuilder::setSuperClass(const QMetaObject *meta) ++{ ++ Q_ASSERT(meta); ++ d->superClass = meta; ++} ++ ++/*! ++ Returns the flags of the class being constructed by this meta object ++ builder. ++ ++ \sa setFlags() ++*/ ++QMetaObjectBuilder::MetaObjectFlags QMetaObjectBuilder::flags() const ++{ ++ return (QMetaObjectBuilder::MetaObjectFlags)d->flags; ++} ++ ++/*! ++ Sets the \a flags of the class being constructed by this meta object ++ builder. ++ ++ \sa flags() ++*/ ++void QMetaObjectBuilder::setFlags(MetaObjectFlags flags) ++{ ++ d->flags = flags; ++} ++ ++/*! ++ Returns the number of methods in this class, excluding the number ++ of methods in the base class. These include signals and slots ++ as well as normal member functions. ++ ++ \sa addMethod(), method(), removeMethod(), indexOfMethod() ++*/ ++int QMetaObjectBuilder::methodCount() const ++{ ++ return d->methods.size(); ++} ++ ++/*! ++ Returns the number of constructors in this class. ++ ++ \sa addConstructor(), constructor(), removeConstructor(), indexOfConstructor() ++*/ ++int QMetaObjectBuilder::constructorCount() const ++{ ++ return d->constructors.size(); ++} ++ ++/*! ++ Returns the number of properties in this class, excluding the number ++ of properties in the base class. ++ ++ \sa addProperty(), property(), removeProperty(), indexOfProperty() ++*/ ++int QMetaObjectBuilder::propertyCount() const ++{ ++ return d->properties.size(); ++} ++ ++/*! ++ Returns the number of enumerators in this class, excluding the ++ number of enumerators in the base class. ++ ++ \sa addEnumerator(), enumerator(), removeEnumerator() ++ \sa indexOfEnumerator() ++*/ ++int QMetaObjectBuilder::enumeratorCount() const ++{ ++ return d->enumerators.size(); ++} ++ ++/*! ++ Returns the number of items of class information in this class, ++ exclusing the number of items of class information in the base class. ++ ++ \sa addClassInfo(), classInfoName(), classInfoValue(), removeClassInfo() ++ \sa indexOfClassInfo() ++*/ ++int QMetaObjectBuilder::classInfoCount() const ++{ ++ return d->classInfoNames.size(); ++} ++ ++/*! ++ Returns the number of related meta objects that are associated ++ with this class. ++ ++ Related meta objects are used when resolving the enumerated type ++ associated with a property, where the enumerated type is in a ++ different class from the property. ++ ++ \sa addRelatedMetaObject(), relatedMetaObject() ++ \sa removeRelatedMetaObject() ++*/ ++int QMetaObjectBuilder::relatedMetaObjectCount() const ++{ ++ return d->relatedMetaObjects.size(); ++} ++ ++/*! ++ Adds a new public method to this class with the specified \a signature. ++ Returns an object that can be used to adjust the other attributes ++ of the method. The \a signature will be normalized before it is ++ added to the class. ++ ++ \sa method(), methodCount(), removeMethod(), indexOfMethod() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addMethod(const QByteArray& signature) ++{ ++ int index = d->methods.size(); ++ d->methods.append(QMetaMethodBuilderPrivate(QMetaMethod::Method, signature)); ++ return QMetaMethodBuilder(this, index); ++} ++ ++/*! ++ Adds a new public method to this class with the specified ++ \a signature and \a returnType. Returns an object that can be ++ used to adjust the other attributes of the method. The \a signature ++ and \a returnType will be normalized before they are added to ++ the class. If \a returnType is empty, then it indicates that ++ the method has \c{void} as its return type. ++ ++ \sa method(), methodCount(), removeMethod(), indexOfMethod() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addMethod ++ (const QByteArray& signature, const QByteArray& returnType) ++{ ++ int index = d->methods.size(); ++ d->methods.append(QMetaMethodBuilderPrivate ++ (QMetaMethod::Method, signature, returnType)); ++ return QMetaMethodBuilder(this, index); ++} ++ ++/*! ++ Adds a new public method to this class that has the same information as ++ \a prototype. This is used to clone the methods of an existing ++ QMetaObject. Returns an object that can be used to adjust the ++ attributes of the method. ++ ++ This function will detect if \a prototype is an ordinary method, ++ signal, slot, or constructor and act accordingly. ++ ++ \sa method(), methodCount(), removeMethod(), indexOfMethod() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addMethod(const QMetaMethod& prototype) ++{ ++ QMetaMethodBuilder method; ++ if (prototype.methodType() == QMetaMethod::Method) ++ method = addMethod(prototype.signature()); ++ else if (prototype.methodType() == QMetaMethod::Signal) ++ method = addSignal(prototype.signature()); ++ else if (prototype.methodType() == QMetaMethod::Slot) ++ method = addSlot(prototype.signature()); ++ else if (prototype.methodType() == QMetaMethod::Constructor) ++ method = addConstructor(prototype.signature()); ++ method.setReturnType(prototype.typeName()); ++ method.setParameterNames(prototype.parameterNames()); ++ method.setTag(prototype.tag()); ++ method.setAccess(prototype.access()); ++ method.setAttributes(prototype.attributes()); ++ return method; ++} ++ ++/*! ++ Adds a new public slot to this class with the specified \a signature. ++ Returns an object that can be used to adjust the other attributes ++ of the slot. The \a signature will be normalized before it is ++ added to the class. ++ ++ \sa addMethod(), addSignal(), indexOfSlot() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addSlot(const QByteArray& signature) ++{ ++ int index = d->methods.size(); ++ d->methods.append(QMetaMethodBuilderPrivate(QMetaMethod::Slot, signature)); ++ return QMetaMethodBuilder(this, index); ++} ++ ++/*! ++ Adds a new signal to this class with the specified \a signature. ++ Returns an object that can be used to adjust the other attributes ++ of the signal. The \a signature will be normalized before it is ++ added to the class. ++ ++ \sa addMethod(), addSlot(), indexOfSignal() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addSignal(const QByteArray& signature) ++{ ++ int index = d->methods.size(); ++ d->methods.append(QMetaMethodBuilderPrivate ++ (QMetaMethod::Signal, signature, QByteArray(), QMetaMethod::Protected)); ++ return QMetaMethodBuilder(this, index); ++} ++ ++/*! ++ Adds a new constructor to this class with the specified \a signature. ++ Returns an object that can be used to adjust the other attributes ++ of the constructor. The \a signature will be normalized before it is ++ added to the class. ++ ++ \sa constructor(), constructorCount(), removeConstructor() ++ \sa indexOfConstructor() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addConstructor(const QByteArray& signature) ++{ ++ int index = d->constructors.size(); ++ d->constructors.append(QMetaMethodBuilderPrivate(QMetaMethod::Constructor, signature)); ++ return QMetaMethodBuilder(this, -(index + 1)); ++} ++ ++/*! ++ Adds a new constructor to this class that has the same information as ++ \a prototype. This is used to clone the constructors of an existing ++ QMetaObject. Returns an object that can be used to adjust the ++ attributes of the constructor. ++ ++ This function requires that \a prototype be a constructor. ++ ++ \sa constructor(), constructorCount(), removeConstructor() ++ \sa indexOfConstructor() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::addConstructor(const QMetaMethod& prototype) ++{ ++ Q_ASSERT(prototype.methodType() == QMetaMethod::Constructor); ++ QMetaMethodBuilder ctor = addConstructor(prototype.signature()); ++ ctor.setReturnType(prototype.typeName()); ++ ctor.setParameterNames(prototype.parameterNames()); ++ ctor.setTag(prototype.tag()); ++ ctor.setAccess(prototype.access()); ++ ctor.setAttributes(prototype.attributes()); ++ return ctor; ++} ++ ++/*! ++ Adds a new readable/writable property to this class with the ++ specified \a name and \a type. Returns an object that can be used ++ to adjust the other attributes of the property. The \a type will ++ be normalized before it is added to the class. \a notifierId will ++ be registered as the property's \e notify signal. ++ ++ \sa property(), propertyCount(), removeProperty(), indexOfProperty() ++*/ ++QMetaPropertyBuilder QMetaObjectBuilder::addProperty ++ (const QByteArray& name, const QByteArray& type, int notifierId) ++{ ++ int index = d->properties.size(); ++ d->properties.append(QMetaPropertyBuilderPrivate(name, type, notifierId)); ++ return QMetaPropertyBuilder(this, index); ++} ++ ++/*! ++ Adds a new property to this class that has the same information as ++ \a prototype. This is used to clone the properties of an existing ++ QMetaObject. Returns an object that can be used to adjust the ++ attributes of the property. ++ ++ \sa property(), propertyCount(), removeProperty(), indexOfProperty() ++*/ ++QMetaPropertyBuilder QMetaObjectBuilder::addProperty(const QMetaProperty& prototype) ++{ ++ QMetaPropertyBuilder property = addProperty(prototype.name(), prototype.typeName()); ++ property.setReadable(prototype.isReadable()); ++ property.setWritable(prototype.isWritable()); ++ property.setResettable(prototype.isResettable()); ++ property.setDesignable(prototype.isDesignable()); ++ property.setScriptable(prototype.isScriptable()); ++ property.setStored(prototype.isStored()); ++ property.setEditable(prototype.isEditable()); ++ property.setUser(prototype.isUser()); ++ property.setStdCppSet(prototype.hasStdCppSet()); ++ property.setEnumOrFlag(prototype.isEnumType()); ++ if (prototype.hasNotifySignal()) { ++ // Find an existing method for the notify signal, or add a new one. ++ QMetaMethod method = prototype.notifySignal(); ++ int index = indexOfMethod(method.signature()); ++ if (index == -1) ++ index = addMethod(method).index(); ++ d->properties[property._index].notifySignal = index; ++ d->properties[property._index].setFlag(Notify, true); ++ } ++ return property; ++} ++ ++/*! ++ Adds a new enumerator to this class with the specified ++ \a name. Returns an object that can be used to adjust ++ the other attributes of the enumerator. ++ ++ \sa enumerator(), enumeratorCount(), removeEnumerator(), ++ \sa indexOfEnumerator() ++*/ ++QMetaEnumBuilder QMetaObjectBuilder::addEnumerator(const QByteArray& name) ++{ ++ int index = d->enumerators.size(); ++ d->enumerators.append(QMetaEnumBuilderPrivate(name)); ++ return QMetaEnumBuilder(this, index); ++} ++ ++/*! ++ Adds a new enumerator to this class that has the same information as ++ \a prototype. This is used to clone the enumerators of an existing ++ QMetaObject. Returns an object that can be used to adjust the ++ attributes of the enumerator. ++ ++ \sa enumerator(), enumeratorCount(), removeEnumerator(), ++ \sa indexOfEnumerator() ++*/ ++QMetaEnumBuilder QMetaObjectBuilder::addEnumerator(const QMetaEnum& prototype) ++{ ++ QMetaEnumBuilder en = addEnumerator(prototype.name()); ++ en.setIsFlag(prototype.isFlag()); ++ int count = prototype.keyCount(); ++ for (int index = 0; index < count; ++index) ++ en.addKey(prototype.key(index), prototype.value(index)); ++ return en; ++} ++ ++/*! ++ Adds \a name and \a value as an item of class information to this class. ++ Returns the index of the new item of class information. ++ ++ \sa classInfoCount(), classInfoName(), classInfoValue(), removeClassInfo() ++ \sa indexOfClassInfo() ++*/ ++int QMetaObjectBuilder::addClassInfo(const QByteArray& name, const QByteArray& value) ++{ ++ int index = d->classInfoNames.size(); ++ d->classInfoNames += name; ++ d->classInfoValues += value; ++ return index; ++} ++ ++/*! ++ Adds \a meta to this class as a related meta object. Returns ++ the index of the new related meta object entry. ++ ++ Related meta objects are used when resolving the enumerated type ++ associated with a property, where the enumerated type is in a ++ different class from the property. ++ ++ \sa relatedMetaObjectCount(), relatedMetaObject() ++ \sa removeRelatedMetaObject() ++*/ ++#ifdef Q_NO_DATA_RELOCATION ++int QMetaObjectBuilder::addRelatedMetaObject(const QMetaObjectAccessor &meta) ++#else ++int QMetaObjectBuilder::addRelatedMetaObject(const QMetaObject *meta) ++#endif ++{ ++ Q_ASSERT(meta); ++ int index = d->relatedMetaObjects.size(); ++ d->relatedMetaObjects.append(meta); ++ return index; ++} ++ ++/*! ++ Adds the contents of \a prototype to this meta object builder. ++ This function is useful for cloning the contents of an existing QMetaObject. ++ ++ The \a members parameter indicates which members of \a prototype ++ should be added. The default is AllMembers. ++*/ ++void QMetaObjectBuilder::addMetaObject ++ (const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members) ++{ ++ Q_ASSERT(prototype); ++ int index; ++ ++ if ((members & ClassName) != 0) ++ d->className = prototype->className(); ++ ++ if ((members & SuperClass) != 0) ++ d->superClass = prototype->superClass(); ++ ++ if ((members & (Methods | Signals | Slots)) != 0) { ++ for (index = prototype->methodOffset(); index < prototype->methodCount(); ++index) { ++ QMetaMethod method = prototype->method(index); ++ if (method.methodType() != QMetaMethod::Signal) { ++ if (method.access() == QMetaMethod::Public && (members & PublicMethods) == 0) ++ continue; ++ if (method.access() == QMetaMethod::Private && (members & PrivateMethods) == 0) ++ continue; ++ if (method.access() == QMetaMethod::Protected && (members & ProtectedMethods) == 0) ++ continue; ++ } ++ if (method.methodType() == QMetaMethod::Method && (members & Methods) != 0) { ++ addMethod(method); ++ } else if (method.methodType() == QMetaMethod::Signal && ++ (members & Signals) != 0) { ++ addMethod(method); ++ } else if (method.methodType() == QMetaMethod::Slot && ++ (members & Slots) != 0) { ++ addMethod(method); ++ } ++ } ++ } ++ ++ if ((members & Constructors) != 0) { ++ for (index = 0; index < prototype->constructorCount(); ++index) ++ addConstructor(prototype->constructor(index)); ++ } ++ ++ if ((members & Properties) != 0) { ++ for (index = prototype->propertyOffset(); index < prototype->propertyCount(); ++index) ++ addProperty(prototype->property(index)); ++ } ++ ++ if ((members & Enumerators) != 0) { ++ for (index = prototype->enumeratorOffset(); index < prototype->enumeratorCount(); ++index) ++ addEnumerator(prototype->enumerator(index)); ++ } ++ ++ if ((members & ClassInfos) != 0) { ++ for (index = prototype->classInfoOffset(); index < prototype->classInfoCount(); ++index) { ++ QMetaClassInfo ci = prototype->classInfo(index); ++ addClassInfo(ci.name(), ci.value()); ++ } ++ } ++ ++ if ((members & RelatedMetaObjects) != 0) { ++#ifdef Q_NO_DATA_RELOCATION ++ const QMetaObjectAccessor *objects = 0; ++#else ++ const QMetaObject **objects; ++ if (priv(prototype->d.data)->revision < 2) { ++ objects = (const QMetaObject **)(prototype->d.extradata); ++ } else ++#endif ++ { ++ const QMetaObjectExtraData *extra = (const QMetaObjectExtraData *)(prototype->d.extradata); ++ if (extra) ++ objects = extra->objects; ++ else ++ objects = 0; ++ } ++ if (objects) { ++ while (*objects != 0) { ++ addRelatedMetaObject(*objects); ++ ++objects; ++ } ++ } ++ } ++ ++ if ((members & StaticMetacall) != 0) { ++ if (priv(prototype->d.data)->revision >= 2) { ++ const QMetaObjectExtraData *extra = ++ (const QMetaObjectExtraData *)(prototype->d.extradata); ++ if (extra && extra->static_metacall) ++ setStaticMetacallFunction(extra->static_metacall); ++ } ++ } ++} ++ ++/*! ++ Returns the method at \a index in this class. ++ ++ \sa methodCount(), addMethod(), removeMethod(), indexOfMethod() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::method(int index) const ++{ ++ if (index >= 0 && index < d->methods.size()) ++ return QMetaMethodBuilder(this, index); ++ else ++ return QMetaMethodBuilder(); ++} ++ ++/*! ++ Returns the constructor at \a index in this class. ++ ++ \sa methodCount(), addMethod(), removeMethod(), indexOfConstructor() ++*/ ++QMetaMethodBuilder QMetaObjectBuilder::constructor(int index) const ++{ ++ if (index >= 0 && index < d->constructors.size()) ++ return QMetaMethodBuilder(this, -(index + 1)); ++ else ++ return QMetaMethodBuilder(); ++} ++ ++/*! ++ Returns the property at \a index in this class. ++ ++ \sa methodCount(), addMethod(), removeMethod(), indexOfProperty() ++*/ ++QMetaPropertyBuilder QMetaObjectBuilder::property(int index) const ++{ ++ if (index >= 0 && index < d->properties.size()) ++ return QMetaPropertyBuilder(this, index); ++ else ++ return QMetaPropertyBuilder(); ++} ++ ++/*! ++ Returns the enumerator at \a index in this class. ++ ++ \sa enumeratorCount(), addEnumerator(), removeEnumerator() ++ \sa indexOfEnumerator() ++*/ ++QMetaEnumBuilder QMetaObjectBuilder::enumerator(int index) const ++{ ++ if (index >= 0 && index < d->enumerators.size()) ++ return QMetaEnumBuilder(this, index); ++ else ++ return QMetaEnumBuilder(); ++} ++ ++/*! ++ Returns the related meta object at \a index in this class. ++ ++ Related meta objects are used when resolving the enumerated type ++ associated with a property, where the enumerated type is in a ++ different class from the property. ++ ++ \sa relatedMetaObjectCount(), addRelatedMetaObject() ++ \sa removeRelatedMetaObject() ++*/ ++const QMetaObject *QMetaObjectBuilder::relatedMetaObject(int index) const ++{ ++ if (index >= 0 && index < d->relatedMetaObjects.size()) ++#ifdef Q_NO_DATA_RELOCATION ++ return &((*(d->relatedMetaObjects[index]))()); ++#else ++ return d->relatedMetaObjects[index]; ++#endif ++ else ++ return 0; ++} ++ ++/*! ++ Returns the name of the item of class information at \a index ++ in this class. ++ ++ \sa classInfoCount(), addClassInfo(), classInfoValue(), removeClassInfo() ++ \sa indexOfClassInfo() ++*/ ++QByteArray QMetaObjectBuilder::classInfoName(int index) const ++{ ++ if (index >= 0 && index < d->classInfoNames.size()) ++ return d->classInfoNames[index]; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Returns the value of the item of class information at \a index ++ in this class. ++ ++ \sa classInfoCount(), addClassInfo(), classInfoName(), removeClassInfo() ++ \sa indexOfClassInfo() ++*/ ++QByteArray QMetaObjectBuilder::classInfoValue(int index) const ++{ ++ if (index >= 0 && index < d->classInfoValues.size()) ++ return d->classInfoValues[index]; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Removes the method at \a index from this class. The indices of ++ all following methods will be adjusted downwards by 1. If the ++ method is registered as a notify signal on a property, then the ++ notify signal will be removed from the property. ++ ++ \sa methodCount(), addMethod(), method(), indexOfMethod() ++*/ ++void QMetaObjectBuilder::removeMethod(int index) ++{ ++ if (index >= 0 && index < d->methods.size()) { ++ d->methods.removeAt(index); ++ for (int prop = 0; prop < d->properties.size(); ++prop) { ++ // Adjust the indices of property notify signal references. ++ if (d->properties[prop].notifySignal == index) { ++ d->properties[prop].notifySignal = -1; ++ d->properties[prop].setFlag(Notify, false); ++ } else if (d->properties[prop].notifySignal > index) ++ (d->properties[prop].notifySignal)--; ++ } ++ } ++} ++ ++/*! ++ Removes the constructor at \a index from this class. The indices of ++ all following constructors will be adjusted downwards by 1. ++ ++ \sa constructorCount(), addConstructor(), constructor() ++ \sa indexOfConstructor() ++*/ ++void QMetaObjectBuilder::removeConstructor(int index) ++{ ++ if (index >= 0 && index < d->constructors.size()) ++ d->constructors.removeAt(index); ++} ++ ++/*! ++ Removes the property at \a index from this class. The indices of ++ all following properties will be adjusted downwards by 1. ++ ++ \sa propertyCount(), addProperty(), property(), indexOfProperty() ++*/ ++void QMetaObjectBuilder::removeProperty(int index) ++{ ++ if (index >= 0 && index < d->properties.size()) ++ d->properties.removeAt(index); ++} ++ ++/*! ++ Removes the enumerator at \a index from this class. The indices of ++ all following enumerators will be adjusted downwards by 1. ++ ++ \sa enumertorCount(), addEnumerator(), enumerator() ++ \sa indexOfEnumerator() ++*/ ++void QMetaObjectBuilder::removeEnumerator(int index) ++{ ++ if (index >= 0 && index < d->enumerators.size()) ++ d->enumerators.removeAt(index); ++} ++ ++/*! ++ Removes the item of class information at \a index from this class. ++ The indices of all following items will be adjusted downwards by 1. ++ ++ \sa classInfoCount(), addClassInfo(), classInfoName(), classInfoValue() ++ \sa indexOfClassInfo() ++*/ ++void QMetaObjectBuilder::removeClassInfo(int index) ++{ ++ if (index >= 0 && index < d->classInfoNames.size()) { ++ d->classInfoNames.removeAt(index); ++ d->classInfoValues.removeAt(index); ++ } ++} ++ ++/*! ++ Removes the related meta object at \a index from this class. ++ The indices of all following related meta objects will be adjusted ++ downwards by 1. ++ ++ Related meta objects are used when resolving the enumerated type ++ associated with a property, where the enumerated type is in a ++ different class from the property. ++ ++ \sa relatedMetaObjectCount(), addRelatedMetaObject() ++ \sa relatedMetaObject() ++*/ ++void QMetaObjectBuilder::removeRelatedMetaObject(int index) ++{ ++ if (index >= 0 && index < d->relatedMetaObjects.size()) ++ d->relatedMetaObjects.removeAt(index); ++} ++ ++/*! ++ Finds a method with the specified \a signature and returns its index; ++ otherwise returns -1. The \a signature will be normalized by this method. ++ ++ \sa method(), methodCount(), addMethod(), removeMethod() ++*/ ++int QMetaObjectBuilder::indexOfMethod(const QByteArray& signature) ++{ ++ QByteArray sig = QMetaObject::normalizedSignature(signature); ++ for (int index = 0; index < d->methods.size(); ++index) { ++ if (sig == d->methods[index].signature) ++ return index; ++ } ++ return -1; ++} ++ ++/*! ++ Finds a signal with the specified \a signature and returns its index; ++ otherwise returns -1. The \a signature will be normalized by this method. ++ ++ \sa indexOfMethod(), indexOfSlot() ++*/ ++int QMetaObjectBuilder::indexOfSignal(const QByteArray& signature) ++{ ++ QByteArray sig = QMetaObject::normalizedSignature(signature); ++ for (int index = 0; index < d->methods.size(); ++index) { ++ if (sig == d->methods[index].signature && ++ d->methods[index].methodType() == QMetaMethod::Signal) ++ return index; ++ } ++ return -1; ++} ++ ++/*! ++ Finds a slot with the specified \a signature and returns its index; ++ otherwise returns -1. The \a signature will be normalized by this method. ++ ++ \sa indexOfMethod(), indexOfSignal() ++*/ ++int QMetaObjectBuilder::indexOfSlot(const QByteArray& signature) ++{ ++ QByteArray sig = QMetaObject::normalizedSignature(signature); ++ for (int index = 0; index < d->methods.size(); ++index) { ++ if (sig == d->methods[index].signature && ++ d->methods[index].methodType() == QMetaMethod::Slot) ++ return index; ++ } ++ return -1; ++} ++ ++/*! ++ Finds a constructor with the specified \a signature and returns its index; ++ otherwise returns -1. The \a signature will be normalized by this method. ++ ++ \sa constructor(), constructorCount(), addConstructor(), removeConstructor() ++*/ ++int QMetaObjectBuilder::indexOfConstructor(const QByteArray& signature) ++{ ++ QByteArray sig = QMetaObject::normalizedSignature(signature); ++ for (int index = 0; index < d->constructors.size(); ++index) { ++ if (sig == d->constructors[index].signature) ++ return index; ++ } ++ return -1; ++} ++ ++/*! ++ Finds a property with the specified \a name and returns its index; ++ otherwise returns -1. ++ ++ \sa property(), propertyCount(), addProperty(), removeProperty() ++*/ ++int QMetaObjectBuilder::indexOfProperty(const QByteArray& name) ++{ ++ for (int index = 0; index < d->properties.size(); ++index) { ++ if (name == d->properties[index].name) ++ return index; ++ } ++ return -1; ++} ++ ++/*! ++ Finds an enumerator with the specified \a name and returns its index; ++ otherwise returns -1. ++ ++ \sa enumertor(), enumeratorCount(), addEnumerator(), removeEnumerator() ++*/ ++int QMetaObjectBuilder::indexOfEnumerator(const QByteArray& name) ++{ ++ for (int index = 0; index < d->enumerators.size(); ++index) { ++ if (name == d->enumerators[index].name) ++ return index; ++ } ++ return -1; ++} ++ ++/*! ++ Finds an item of class information with the specified \a name and ++ returns its index; otherwise returns -1. ++ ++ \sa classInfoName(), classInfoValue(), classInfoCount(), addClassInfo() ++ \sa removeClassInfo() ++*/ ++int QMetaObjectBuilder::indexOfClassInfo(const QByteArray& name) ++{ ++ for (int index = 0; index < d->classInfoNames.size(); ++index) { ++ if (name == d->classInfoNames[index]) ++ return index; ++ } ++ return -1; ++} ++ ++// Align on a specific type boundary. ++#define ALIGN(size,type) \ ++ (size) = ((size) + sizeof(type) - 1) & ~(sizeof(type) - 1) ++ ++// Build a string into a QMetaObject representation. Returns the ++// position in the string table where the string was placed. ++static int buildString ++ (char *buf, char *str, int *offset, const QByteArray& value, int empty) ++{ ++ if (value.size() == 0 && empty >= 0) ++ return empty; ++ if (buf) { ++ memcpy(str + *offset, value.constData(), value.size()); ++ str[*offset + value.size()] = '\0'; ++ } ++ int posn = *offset; ++ *offset += value.size() + 1; ++ return posn; ++} ++ ++// Build the parameter array string for a method. ++static QByteArray buildParameterNames ++ (const QByteArray& signature, const QList& parameterNames) ++{ ++ // If the parameter name list is specified, then concatenate them. ++ if (!parameterNames.isEmpty()) { ++ QByteArray names; ++ bool first = true; ++ foreach (const QByteArray &name, parameterNames) { ++ if (first) ++ first = false; ++ else ++ names += (char)','; ++ names += name; ++ } ++ return names; ++ } ++ ++ // Count commas in the signature, excluding those inside template arguments. ++ int index = signature.indexOf('('); ++ if (index < 0) ++ return QByteArray(); ++ ++index; ++ if (index >= signature.size()) ++ return QByteArray(); ++ if (signature[index] == ')') ++ return QByteArray(); ++ int count = 1; ++ int brackets = 0; ++ while (index < signature.size() && signature[index] != ',') { ++ char ch = signature[index++]; ++ if (ch == '<') ++ ++brackets; ++ else if (ch == '>') ++ --brackets; ++ else if (ch == ',' && brackets <= 0) ++ ++count; ++ } ++ return QByteArray(count - 1, ','); ++} ++ ++// Build a QMetaObject in "buf" based on the information in "d". ++// If "buf" is null, then return the number of bytes needed to ++// build the QMetaObject. Returns -1 if the metaobject if ++// relocatable is set, but the metaobject contains extradata. ++static int buildMetaObject(QMetaObjectBuilderPrivate *d, char *buf, ++ bool relocatable) ++{ ++ int size = 0; ++ int dataIndex; ++ int enumIndex; ++ int index; ++ bool hasNotifySignals = false; ++ ++ if (relocatable && ++ (d->relatedMetaObjects.size() > 0 || d->staticMetacallFunction)) ++ return -1; ++ ++ // Create the main QMetaObject structure at the start of the buffer. ++ QMetaObject *meta = reinterpret_cast(buf); ++ size += sizeof(QMetaObject); ++ ALIGN(size, int); ++ if (buf) { ++ if (!relocatable) meta->d.superdata = d->superClass; ++ meta->d.extradata = 0; ++ } ++ ++ // Populate the QMetaObjectPrivate structure. ++ QMetaObjectPrivate *pmeta ++ = reinterpret_cast(buf + size); ++ int pmetaSize = size; ++ dataIndex = 13; // Number of fields in the QMetaObjectPrivate. ++ for (index = 0; index < d->properties.size(); ++index) { ++ if (d->properties[index].notifySignal != -1) { ++ hasNotifySignals = true; ++ break; ++ } ++ } ++ if (buf) { ++ pmeta->revision = 3; ++ pmeta->flags = d->flags; ++ pmeta->className = 0; // Class name is always the first string. ++ ++ pmeta->classInfoCount = d->classInfoNames.size(); ++ pmeta->classInfoData = dataIndex; ++ dataIndex += 2 * d->classInfoNames.size(); ++ ++ pmeta->methodCount = d->methods.size(); ++ pmeta->methodData = dataIndex; ++ dataIndex += 5 * d->methods.size(); ++ ++ pmeta->propertyCount = d->properties.size(); ++ pmeta->propertyData = dataIndex; ++ dataIndex += 3 * d->properties.size(); ++ if (hasNotifySignals) ++ dataIndex += d->properties.size(); ++ ++ pmeta->enumeratorCount = d->enumerators.size(); ++ pmeta->enumeratorData = dataIndex; ++ dataIndex += 4 * d->enumerators.size(); ++ ++ pmeta->constructorCount = d->constructors.size(); ++ pmeta->constructorData = dataIndex; ++ dataIndex += 5 * d->constructors.size(); ++ } else { ++ dataIndex += 2 * d->classInfoNames.size(); ++ dataIndex += 5 * d->methods.size(); ++ dataIndex += 3 * d->properties.size(); ++ if (hasNotifySignals) ++ dataIndex += d->properties.size(); ++ dataIndex += 4 * d->enumerators.size(); ++ dataIndex += 5 * d->constructors.size(); ++ } ++ ++ // Allocate space for the enumerator key names and values. ++ enumIndex = dataIndex; ++ for (index = 0; index < d->enumerators.size(); ++index) { ++ QMetaEnumBuilderPrivate *enumerator = &(d->enumerators[index]); ++ dataIndex += 2 * enumerator->keys.size(); ++ } ++ ++ // Zero terminator at the end of the data offset table. ++ ++dataIndex; ++ ++ // Find the start of the data and string tables. ++ int *data = reinterpret_cast(pmeta); ++ size += dataIndex * sizeof(int); ++ char *str = reinterpret_cast(buf + size); ++ if (buf) { ++ if (relocatable) { ++ meta->d.stringdata = reinterpret_cast((intptr_t)size); ++ meta->d.data = reinterpret_cast((intptr_t)pmetaSize); ++ } else { ++ meta->d.stringdata = str; ++ meta->d.data = reinterpret_cast(data); ++ } ++ } ++ ++ // Reset the current data position to just past the QMetaObjectPrivate. ++ dataIndex = 13; ++ ++ // Add the class name to the string table. ++ int offset = 0; ++ buildString(buf, str, &offset, d->className, -1); ++ ++ // Add a common empty string, which is used to indicate "void" ++ // method returns, empty tag strings, etc. ++ int empty = buildString(buf, str, &offset, QByteArray(), -1); ++ ++ // Output the class infos, ++ for (index = 0; index < d->classInfoNames.size(); ++index) { ++ int name = buildString(buf, str, &offset, d->classInfoNames[index], empty); ++ int value = buildString(buf, str, &offset, d->classInfoValues[index], empty); ++ if (buf) { ++ data[dataIndex] = name; ++ data[dataIndex + 1] = value; ++ } ++ dataIndex += 2; ++ } ++ ++ // Output the methods in the class. ++ for (index = 0; index < d->methods.size(); ++index) { ++ QMetaMethodBuilderPrivate *method = &(d->methods[index]); ++ int sig = buildString(buf, str, &offset, method->signature, empty); ++ int params; ++ QByteArray names = buildParameterNames ++ (method->signature, method->parameterNames); ++ params = buildString(buf, str, &offset, names, empty); ++ int ret = buildString(buf, str, &offset, method->returnType, empty); ++ int tag = buildString(buf, str, &offset, method->tag, empty); ++ int attrs = method->attributes; ++ if (buf) { ++ data[dataIndex] = sig; ++ data[dataIndex + 1] = params; ++ data[dataIndex + 2] = ret; ++ data[dataIndex + 3] = tag; ++ data[dataIndex + 4] = attrs; ++ } ++ dataIndex += 5; ++ } ++ ++ // Output the properties in the class. ++ for (index = 0; index < d->properties.size(); ++index) { ++ QMetaPropertyBuilderPrivate *prop = &(d->properties[index]); ++ int name = buildString(buf, str, &offset, prop->name, empty); ++ int type = buildString(buf, str, &offset, prop->type, empty); ++ int flags = prop->flags; ++ ++ if (!isVariantType(prop->type)) { ++ flags |= EnumOrFlag; ++ } else { ++ flags |= qvariant_nameToType(prop->type) << 24; ++ } ++ ++ if (buf) { ++ data[dataIndex] = name; ++ data[dataIndex + 1] = type; ++ data[dataIndex + 2] = flags; ++ } ++ dataIndex += 3; ++ } ++ if (hasNotifySignals) { ++ for (index = 0; index < d->properties.size(); ++index) { ++ QMetaPropertyBuilderPrivate *prop = &(d->properties[index]); ++ if (buf) { ++ if (prop->notifySignal != -1) ++ data[dataIndex] = prop->notifySignal; ++ else ++ data[dataIndex] = 0; ++ } ++ ++dataIndex; ++ } ++ } ++ ++ // Output the enumerators in the class. ++ for (index = 0; index < d->enumerators.size(); ++index) { ++ QMetaEnumBuilderPrivate *enumerator = &(d->enumerators[index]); ++ int name = buildString(buf, str, &offset, enumerator->name, empty); ++ int isFlag = (int)(enumerator->isFlag); ++ int count = enumerator->keys.size(); ++ int enumOffset = enumIndex; ++ if (buf) { ++ data[dataIndex] = name; ++ data[dataIndex + 1] = isFlag; ++ data[dataIndex + 2] = count; ++ data[dataIndex + 3] = enumOffset; ++ } ++ for (int key = 0; key < count; ++key) { ++ int keyIndex = buildString(buf, str, &offset, enumerator->keys[key], empty); ++ if (buf) { ++ data[enumOffset++] = keyIndex; ++ data[enumOffset++] = enumerator->values[key]; ++ } ++ } ++ dataIndex += 4; ++ enumIndex += 2 * count; ++ } ++ ++ // Output the constructors in the class. ++ for (index = 0; index < d->constructors.size(); ++index) { ++ QMetaMethodBuilderPrivate *method = &(d->constructors[index]); ++ int sig = buildString(buf, str, &offset, method->signature, empty); ++ int params; ++ QByteArray names = buildParameterNames ++ (method->signature, method->parameterNames); ++ params = buildString(buf, str, &offset, names, empty); ++ int ret = buildString(buf, str, &offset, method->returnType, empty); ++ int tag = buildString(buf, str, &offset, method->tag, empty); ++ int attrs = method->attributes; ++ if (buf) { ++ data[dataIndex] = sig; ++ data[dataIndex + 1] = params; ++ data[dataIndex + 2] = ret; ++ data[dataIndex + 3] = tag; ++ data[dataIndex + 4] = attrs; ++ } ++ dataIndex += 5; ++ } ++ ++ // One more empty string to act as a terminator. ++ buildString(buf, str, &offset, QByteArray(), -1); ++ size += offset; ++ ++ // Output the zero terminator in the data array. ++ if (buf) ++ data[enumIndex] = 0; ++ ++ // Create the extradata block if we need one. ++ if (d->relatedMetaObjects.size() > 0 || d->staticMetacallFunction) { ++ ALIGN(size, QMetaObject **); ++ ALIGN(size, QMetaObjectBuilder::StaticMetacallFunction); ++ QMetaObjectExtraData *extra = ++ reinterpret_cast(buf + size); ++ size += sizeof(QMetaObjectExtraData); ++ ALIGN(size, QMetaObject *); ++#ifdef Q_NO_DATA_RELOCATION ++ QMetaObjectAccessor *objects = ++ reinterpret_cast(buf + size); ++#else ++ const QMetaObject **objects = ++ reinterpret_cast(buf + size); ++#endif ++ if (buf) { ++ if (d->relatedMetaObjects.size() > 0) { ++ extra->objects = objects; ++ for (index = 0; index < d->relatedMetaObjects.size(); ++index) ++ objects[index] = d->relatedMetaObjects[index]; ++ objects[index] = 0; ++ } else { ++ extra->objects = 0; ++ } ++ extra->static_metacall = d->staticMetacallFunction; ++ meta->d.extradata = reinterpret_cast(extra); ++ } ++ if (d->relatedMetaObjects.size() > 0) ++ size += sizeof(QMetaObject *) * (d->relatedMetaObjects.size() + 1); ++ } ++ ++ // Align the final size and return it. ++ ALIGN(size, void *); ++ return size; ++} ++ ++/*! ++ Converts this meta object builder into a concrete QMetaObject. ++ The return value should be deallocated using qFree() once it ++ is no longer needed. ++ ++ The returned meta object is a snapshot of the state of the ++ QMetaObjectBuilder. Any further modifications to the QMetaObjectBuilder ++ will not be reflected in previous meta objects returned by ++ this method. ++*/ ++QMetaObject *QMetaObjectBuilder::toMetaObject() const ++{ ++ int size = buildMetaObject(d, 0, false); ++ char *buf = reinterpret_cast(qMalloc(size)); ++ buildMetaObject(d, buf, false); ++ return reinterpret_cast(buf); ++} ++ ++/* ++ \internal ++ ++ Converts this meta object builder into relocatable data. This data can ++ be stored, copied and later passed to fromRelocatableData() to create a ++ concrete QMetaObject. ++ ++ The data is specific to the architecture on which it was created, but is not ++ specific to the process that created it. Not all meta object builder's can ++ be converted to data in this way. If \a ok is provided, it will be set to ++ true if the conversion succeeds, and false otherwise. If a ++ staticMetacallFunction() or any relatedMetaObject()'s are specified the ++ conversion to relocatable data will fail. ++*/ ++QByteArray QMetaObjectBuilder::toRelocatableData(bool *ok) const ++{ ++ int size = buildMetaObject(d, 0, true); ++ if (size == -1) { ++ if (ok) *ok = false; ++ return QByteArray(); ++ } ++ ++ QByteArray data; ++ data.resize(size); ++ char *buf = data.data(); ++ buildMetaObject(d, buf, true); ++ if (ok) *ok = true; ++ return data; ++} ++ ++/* ++ \internal ++ ++ Sets the \a data returned from toRelocatableData() onto a concrete ++ QMetaObject instance, \a output. As the meta object's super class is not ++ saved in the relocatable data, it must be passed as \a superClass. ++*/ ++void QMetaObjectBuilder::fromRelocatableData(QMetaObject *output, ++ const QMetaObject *superclass, ++ const QByteArray &data) ++{ ++ if (!output) ++ return; ++ ++ const char *buf = data.constData(); ++ const QMetaObject *dataMo = reinterpret_cast(buf); ++ ++ intptr_t stringdataOffset = (intptr_t)dataMo->d.stringdata; ++ intptr_t dataOffset = (intptr_t)dataMo->d.data; ++ ++ output->d.superdata = superclass; ++ output->d.stringdata = buf + stringdataOffset; ++ output->d.data = reinterpret_cast(buf + dataOffset); ++} ++ ++/*! ++ \typedef QMetaObjectBuilder::StaticMetacallFunction ++ ++ Typedef for static metacall functions. The three parameters are ++ the call type value, the constructor index, and the ++ array of parameters. ++*/ ++ ++/*! ++ Returns the static metacall function to use to construct objects ++ of this class. The default value is null. ++ ++ \sa setStaticMetacallFunction() ++*/ ++QMetaObjectBuilder::StaticMetacallFunction QMetaObjectBuilder::staticMetacallFunction() const ++{ ++ return d->staticMetacallFunction; ++} ++ ++/*! ++ Sets the static metacall function to use to construct objects ++ of this class to \a value. The default value is null. ++ ++ \sa staticMetacallFunction() ++*/ ++void QMetaObjectBuilder::setStaticMetacallFunction ++ (QMetaObjectBuilder::StaticMetacallFunction value) ++{ ++ d->staticMetacallFunction = value; ++} ++ ++#ifndef QT_NO_DATASTREAM ++ ++/*! ++ Serializes the contents of the meta object builder onto \a stream. ++ ++ \sa deserialize() ++*/ ++void QMetaObjectBuilder::serialize(QDataStream& stream) const ++{ ++ int index; ++ ++ // Write the class and super class names. ++ stream << d->className; ++ if (d->superClass) ++ stream << QByteArray(d->superClass->className()); ++ else ++ stream << QByteArray(); ++ ++ // Write the counts for each type of class member. ++ stream << d->classInfoNames.size(); ++ stream << d->methods.size(); ++ stream << d->properties.size(); ++ stream << d->enumerators.size(); ++ stream << d->constructors.size(); ++ stream << d->relatedMetaObjects.size(); ++ ++ // Write the items of class information. ++ for (index = 0; index < d->classInfoNames.size(); ++index) { ++ stream << d->classInfoNames[index]; ++ stream << d->classInfoValues[index]; ++ } ++ ++ // Write the methods. ++ for (index = 0; index < d->methods.size(); ++index) { ++ const QMetaMethodBuilderPrivate *method = &(d->methods[index]); ++ stream << method->signature; ++ stream << method->returnType; ++ stream << method->parameterNames; ++ stream << method->tag; ++ stream << method->attributes; ++ } ++ ++ // Write the properties. ++ for (index = 0; index < d->properties.size(); ++index) { ++ const QMetaPropertyBuilderPrivate *property = &(d->properties[index]); ++ stream << property->name; ++ stream << property->type; ++ stream << property->flags; ++ stream << property->notifySignal; ++ } ++ ++ // Write the enumerators. ++ for (index = 0; index < d->enumerators.size(); ++index) { ++ const QMetaEnumBuilderPrivate *enumerator = &(d->enumerators[index]); ++ stream << enumerator->name; ++ stream << enumerator->isFlag; ++ stream << enumerator->keys; ++ stream << enumerator->values; ++ } ++ ++ // Write the constructors. ++ for (index = 0; index < d->constructors.size(); ++index) { ++ const QMetaMethodBuilderPrivate *method = &(d->constructors[index]); ++ stream << method->signature; ++ stream << method->returnType; ++ stream << method->parameterNames; ++ stream << method->tag; ++ stream << method->attributes; ++ } ++ ++ // Write the related meta objects. ++#ifdef Q_NO_DATA_RELOCATION ++ //the related meta objects will be function pointers ++ //which you have to add to the builder manually. ++ //e.g. ++ //builder2.addRelatedMetaObject(QLocale::getStaticMetaObject); ++#else ++ for (index = 0; index < d->relatedMetaObjects.size(); ++index) { ++ const QMetaObject *meta = d->relatedMetaObjects[index]; ++ stream << QByteArray(meta->className()); ++ } ++#endif ++ ++ // Add an extra empty QByteArray for additional data in future versions. ++ // This should help maintain backwards compatibility, allowing older ++ // versions to read newer data. ++ stream << QByteArray(); ++} ++ ++// Resolve a class name using the name reference map. ++static const QMetaObject *resolveClassName ++ (const QMap& references, ++ const QByteArray& name) ++{ ++ if (name == QByteArray("QObject")) ++ return &QObject::staticMetaObject; ++ else ++ return references.value(name, 0); ++} ++ ++/*! ++ Deserializes a meta object builder from \a stream into ++ this meta object builder. ++ ++ The \a references parameter specifies a mapping from class names ++ to QMetaObject instances for resolving the super class name and ++ related meta objects in the object that is deserialized. ++ The meta object for QObject is implicitly added to \a references ++ and does not need to be supplied. ++ ++ The QDataStream::status() value on \a stream will be set to ++ QDataStream::ReadCorruptData if the input data is corrupt. ++ The status will be set to QDataStream::ReadPastEnd if the ++ input was exhausted before the full meta object was read. ++ ++ \sa serialize() ++*/ ++void QMetaObjectBuilder::deserialize ++ (QDataStream& stream, ++ const QMap& references) ++{ ++ QByteArray name; ++ const QMetaObject *cl; ++ int index; ++ ++ // Clear all members in the builder to their default states. ++ d->className.clear(); ++ d->superClass = &QObject::staticMetaObject; ++ d->classInfoNames.clear(); ++ d->classInfoValues.clear(); ++ d->methods.clear(); ++ d->properties.clear(); ++ d->enumerators.clear(); ++ d->constructors.clear(); ++ d->relatedMetaObjects.clear(); ++ d->staticMetacallFunction = 0; ++ ++ // Read the class and super class names. ++ stream >> d->className; ++ stream >> name; ++ if (name.isEmpty()) { ++ d->superClass = 0; ++ } else if ((cl = resolveClassName(references, name)) != 0) { ++ d->superClass = cl; ++ } else { ++ stream.setStatus(QDataStream::ReadCorruptData); ++ return; ++ } ++ ++ // Read the counts for each type of class member. ++ int classInfoCount, methodCount, propertyCount; ++ int enumeratorCount, constructorCount, relatedMetaObjectCount; ++ stream >> classInfoCount; ++ stream >> methodCount; ++ stream >> propertyCount; ++ stream >> enumeratorCount; ++ stream >> constructorCount; ++ stream >> relatedMetaObjectCount; ++ if (classInfoCount < 0 || methodCount < 0 || ++ propertyCount < 0 || enumeratorCount < 0 || ++ constructorCount < 0 || relatedMetaObjectCount < 0) { ++ stream.setStatus(QDataStream::ReadCorruptData); ++ return; ++ } ++ ++ // Read the items of class information. ++ for (index = 0; index < classInfoCount; ++index) { ++ if (stream.status() != QDataStream::Ok) ++ return; ++ QByteArray value; ++ stream >> name; ++ stream >> value; ++ addClassInfo(name, value); ++ } ++ ++ // Read the member methods. ++ for (index = 0; index < methodCount; ++index) { ++ if (stream.status() != QDataStream::Ok) ++ return; ++ stream >> name; ++ addMethod(name); ++ QMetaMethodBuilderPrivate *method = &(d->methods[index]); ++ stream >> method->returnType; ++ stream >> method->parameterNames; ++ stream >> method->tag; ++ stream >> method->attributes; ++ if (method->methodType() == QMetaMethod::Constructor) { ++ // Cannot add a constructor in this set of methods. ++ stream.setStatus(QDataStream::ReadCorruptData); ++ return; ++ } ++ } ++ ++ // Read the properties. ++ for (index = 0; index < propertyCount; ++index) { ++ if (stream.status() != QDataStream::Ok) ++ return; ++ QByteArray type; ++ stream >> name; ++ stream >> type; ++ addProperty(name, type); ++ QMetaPropertyBuilderPrivate *property = &(d->properties[index]); ++ stream >> property->flags; ++ stream >> property->notifySignal; ++ if (property->notifySignal < -1 || ++ property->notifySignal >= d->methods.size()) { ++ // Notify signal method index is out of range. ++ stream.setStatus(QDataStream::ReadCorruptData); ++ return; ++ } ++ if (property->notifySignal >= 0 && ++ d->methods[property->notifySignal].methodType() != QMetaMethod::Signal) { ++ // Notify signal method index does not refer to a signal. ++ stream.setStatus(QDataStream::ReadCorruptData); ++ return; ++ } ++ } ++ ++ // Read the enumerators. ++ for (index = 0; index < enumeratorCount; ++index) { ++ if (stream.status() != QDataStream::Ok) ++ return; ++ stream >> name; ++ addEnumerator(name); ++ QMetaEnumBuilderPrivate *enumerator = &(d->enumerators[index]); ++ stream >> enumerator->isFlag; ++ stream >> enumerator->keys; ++ stream >> enumerator->values; ++ if (enumerator->keys.size() != enumerator->values.size()) { ++ // Mismatch between number of keys and number of values. ++ stream.setStatus(QDataStream::ReadCorruptData); ++ return; ++ } ++ } ++ ++ // Read the constructor methods. ++ for (index = 0; index < constructorCount; ++index) { ++ if (stream.status() != QDataStream::Ok) ++ return; ++ stream >> name; ++ addConstructor(name); ++ QMetaMethodBuilderPrivate *method = &(d->constructors[index]); ++ stream >> method->returnType; ++ stream >> method->parameterNames; ++ stream >> method->tag; ++ stream >> method->attributes; ++ if (method->methodType() != QMetaMethod::Constructor) { ++ // The type must be Constructor. ++ stream.setStatus(QDataStream::ReadCorruptData); ++ return; ++ } ++ } ++ ++ // Read the related meta objects. ++#ifdef Q_NO_DATA_RELOCATION ++ //the related meta objects will be function pointers ++ //which you have to add to the builder manually. ++ //e.g. ++ //builder2.addRelatedMetaObject(QLocale::getStaticMetaObject); ++#else ++ for (index = 0; index < relatedMetaObjectCount; ++index) { ++ if (stream.status() != QDataStream::Ok) ++ return; ++ stream >> name; ++ cl = resolveClassName(references, name); ++ if (!cl) { ++ stream.setStatus(QDataStream::ReadCorruptData); ++ return; ++ } ++ addRelatedMetaObject(cl); ++ } ++#endif ++ ++ // Read the extra data block, which is reserved for future use. ++ stream >> name; ++} ++ ++#endif // !QT_NO_DATASTREAM ++ ++/*! ++ \class QMetaMethodBuilder ++ \internal ++ \brief The QMetaMethodBuilder class enables modifications to a method definition on a meta object builder. ++*/ ++ ++QMetaMethodBuilderPrivate *QMetaMethodBuilder::d_func() const ++{ ++ // Positive indices indicate methods, negative indices indicate constructors. ++ if (_mobj && _index >= 0 && _index < _mobj->d->methods.size()) ++ return &(_mobj->d->methods[_index]); ++ else if (_mobj && -_index >= 1 && -_index <= _mobj->d->constructors.size()) ++ return &(_mobj->d->constructors[(-_index) - 1]); ++ else ++ return 0; ++} ++ ++/*! ++ \fn QMetaMethodBuilder::QMetaMethodBuilder() ++ \internal ++*/ ++ ++/*! ++ Returns the index of this method within its QMetaObjectBuilder. ++*/ ++int QMetaMethodBuilder::index() const ++{ ++ if (_index >= 0) ++ return _index; // Method, signal, or slot ++ else ++ return (-_index) - 1; // Constructor ++} ++ ++/*! ++ Returns the type of this method (signal, slot, method, or constructor). ++*/ ++QMetaMethod::MethodType QMetaMethodBuilder::methodType() const ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ return d->methodType(); ++ else ++ return QMetaMethod::Method; ++} ++ ++/*! ++ Returns the signature of this method. ++ ++ \sa parameterNames(), returnType() ++*/ ++QByteArray QMetaMethodBuilder::signature() const ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ return d->signature; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Returns the return type for this method; empty if the method's ++ return type is \c{void}. ++ ++ \sa setReturnType(), signature() ++*/ ++QByteArray QMetaMethodBuilder::returnType() const ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ return d->returnType; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Sets the return type for this method to \a value. If \a value ++ is empty, then the method's return type is \c{void}. The \a value ++ will be normalized before it is added to the method. ++ ++ \sa returnType(), signature() ++*/ ++void QMetaMethodBuilder::setReturnType(const QByteArray& value) ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ d->returnType = QMetaObject::normalizedType(value); ++} ++ ++/*! ++ Returns the list of parameter names for this method. ++ ++ \sa setParameterNames() ++*/ ++QList QMetaMethodBuilder::parameterNames() const ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ return d->parameterNames; ++ else ++ return QList(); ++} ++ ++/*! ++ Sets the list of parameter names for this method to \a value. ++ ++ \sa parameterNames() ++*/ ++void QMetaMethodBuilder::setParameterNames(const QList& value) ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ d->parameterNames = value; ++} ++ ++/*! ++ Returns the tag associated with this method. ++ ++ \sa setTag() ++*/ ++QByteArray QMetaMethodBuilder::tag() const ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ return d->tag; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Sets the tag associated with this method to \a value. ++ ++ \sa setTag() ++*/ ++void QMetaMethodBuilder::setTag(const QByteArray& value) ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ d->tag = value; ++} ++ ++/*! ++ Returns the access specification of this method (private, protected, ++ or public). The default value is QMetaMethod::Public for methods, ++ slots, and constructors. The default value is QMetaMethod::Protected ++ for signals. ++ ++ \sa setAccess() ++*/ ++QMetaMethod::Access QMetaMethodBuilder::access() const ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ return d->access(); ++ else ++ return QMetaMethod::Public; ++} ++ ++/*! ++ Sets the access specification of this method (private, protected, ++ or public) to \a value. If the method is a signal, this function ++ will be ignored. ++ ++ \sa access() ++*/ ++void QMetaMethodBuilder::setAccess(QMetaMethod::Access value) ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d && d->methodType() != QMetaMethod::Signal) ++ d->setAccess(value); ++} ++ ++/*! ++ Returns the additional attributes for this method. ++ ++ \sa setAttributes() ++*/ ++int QMetaMethodBuilder::attributes() const ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ return (d->attributes >> 4); ++ else ++ return 0; ++} ++ ++/*! ++ Sets the additional attributes for this method to \a value. ++ ++ \sa attributes() ++*/ ++void QMetaMethodBuilder::setAttributes(int value) ++{ ++ QMetaMethodBuilderPrivate *d = d_func(); ++ if (d) ++ d->attributes = ((d->attributes & 0x0f) | (value << 4)); ++} ++ ++/*! ++ \class QMetaPropertyBuilder ++ \internal ++ \brief The QMetaPropertyBuilder class enables modifications to a property definition on a meta object builder. ++*/ ++ ++QMetaPropertyBuilderPrivate *QMetaPropertyBuilder::d_func() const ++{ ++ if (_mobj && _index >= 0 && _index < _mobj->d->properties.size()) ++ return &(_mobj->d->properties[_index]); ++ else ++ return 0; ++} ++ ++/*! ++ \fn QMetaPropertyBuilder::QMetaPropertyBuilder() ++ \internal ++*/ ++ ++/*! ++ \fn int QMetaPropertyBuilder::index() const ++ ++ Returns the index of this property within its QMetaObjectBuilder. ++*/ ++ ++/*! ++ Returns the name associated with this property. ++ ++ \sa type() ++*/ ++QByteArray QMetaPropertyBuilder::name() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->name; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Returns the type associated with this property. ++ ++ \sa name() ++*/ ++QByteArray QMetaPropertyBuilder::type() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->type; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Returns true if this property has a notify signal; false otherwise. ++ ++ \sa notifySignal(), setNotifySignal(), removeNotifySignal() ++*/ ++bool QMetaPropertyBuilder::hasNotifySignal() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Notify); ++ else ++ return false; ++} ++ ++/*! ++ Returns the notify signal associated with this property. ++ ++ \sa hasNotifySignal(), setNotifySignal(), removeNotifySignal() ++*/ ++QMetaMethodBuilder QMetaPropertyBuilder::notifySignal() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d && d->notifySignal >= 0) ++ return QMetaMethodBuilder(_mobj, d->notifySignal); ++ else ++ return QMetaMethodBuilder(); ++} ++ ++/*! ++ Sets the notify signal associated with this property to \a value. ++ ++ \sa hasNotifySignal(), notifySignal(), removeNotifySignal() ++*/ ++void QMetaPropertyBuilder::setNotifySignal(const QMetaMethodBuilder& value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) { ++ if (value._mobj) { ++ d->notifySignal = value._index; ++ d->setFlag(Notify, true); ++ } else { ++ d->notifySignal = -1; ++ d->setFlag(Notify, false); ++ } ++ } ++} ++ ++/*! ++ Removes the notify signal from this property. ++ ++ \sa hasNotifySignal(), notifySignal(), setNotifySignal() ++*/ ++void QMetaPropertyBuilder::removeNotifySignal() ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) { ++ d->notifySignal = -1; ++ d->setFlag(Notify, false); ++ } ++} ++ ++/*! ++ Returns true if this property is readable; otherwise returns false. ++ The default value is true. ++ ++ \sa setReadable(), isWritable() ++*/ ++bool QMetaPropertyBuilder::isReadable() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Readable); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if this property is writable; otherwise returns false. ++ The default value is true. ++ ++ \sa setWritable(), isReadable() ++*/ ++bool QMetaPropertyBuilder::isWritable() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Writable); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if this property can be reset to a default value; otherwise ++ returns false. The default value is false. ++ ++ \sa setResettable() ++*/ ++bool QMetaPropertyBuilder::isResettable() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Resettable); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if this property is designable; otherwise returns false. ++ This default value is false. ++ ++ \sa setDesignable(), isScriptable(), isStored() ++*/ ++bool QMetaPropertyBuilder::isDesignable() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Designable); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if the property is scriptable; otherwise returns false. ++ This default value is true. ++ ++ \sa setScriptable(), isDesignable(), isStored() ++*/ ++bool QMetaPropertyBuilder::isScriptable() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Scriptable); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if the property is stored; otherwise returns false. ++ This default value is false. ++ ++ \sa setStored(), isDesignable(), isScriptable() ++*/ ++bool QMetaPropertyBuilder::isStored() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Stored); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if the property is editable; otherwise returns false. ++ This default value is false. ++ ++ \sa setEditable(), isDesignable(), isScriptable(), isStored() ++*/ ++bool QMetaPropertyBuilder::isEditable() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Editable); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if this property is designated as the \c USER ++ property, i.e., the one that the user can edit or that is ++ significant in some other way. Otherwise it returns ++ false. This default value is false. ++ ++ \sa setUser(), isDesignable(), isScriptable() ++*/ ++bool QMetaPropertyBuilder::isUser() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(User); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if the property has a C++ setter function that ++ follows Qt's standard "name" / "setName" pattern. Designer and uic ++ query hasStdCppSet() in order to avoid expensive ++ QObject::setProperty() calls. All properties in Qt [should] follow ++ this pattern. The default value is false. ++ ++ \sa setStdCppSet() ++*/ ++bool QMetaPropertyBuilder::hasStdCppSet() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(StdCppSet); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if the property is an enumerator or flag type; ++ otherwise returns false. This default value is false. ++ ++ \sa setEnumOrFlag() ++*/ ++bool QMetaPropertyBuilder::isEnumOrFlag() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(EnumOrFlag); ++ else ++ return false; ++} ++ ++/*! ++ Returns true if the property has the dynamic flag set; ++ otherwise returns false. The default value is false. ++ ++ \sa setDynamic() ++*/ ++bool QMetaPropertyBuilder::isDynamic() const ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ return d->flag(Dynamic); ++ else ++ return false; ++} ++ ++/*! ++ Sets this property to readable if \a value is true. ++ ++ \sa isReadable(), setWritable() ++*/ ++void QMetaPropertyBuilder::setReadable(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Readable, value); ++} ++ ++/*! ++ Sets this property to writable if \a value is true. ++ ++ \sa isWritable(), setReadable() ++*/ ++void QMetaPropertyBuilder::setWritable(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Writable, value); ++} ++ ++/*! ++ Sets this property to resettable if \a value is true. ++ ++ \sa isResettable() ++*/ ++void QMetaPropertyBuilder::setResettable(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Resettable, value); ++} ++ ++/*! ++ Sets this property to designable if \a value is true. ++ ++ \sa isDesignable(), setScriptable(), setStored() ++*/ ++void QMetaPropertyBuilder::setDesignable(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Designable, value); ++} ++ ++/*! ++ Sets this property to scriptable if \a value is true. ++ ++ \sa isScriptable(), setDesignable(), setStored() ++*/ ++void QMetaPropertyBuilder::setScriptable(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Scriptable, value); ++} ++ ++/*! ++ Sets this property to storable if \a value is true. ++ ++ \sa isStored(), setDesignable(), setScriptable() ++*/ ++void QMetaPropertyBuilder::setStored(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Stored, value); ++} ++ ++/*! ++ Sets this property to editable if \a value is true. ++ ++ \sa isEditable(), setDesignable(), setScriptable(), setStored() ++*/ ++void QMetaPropertyBuilder::setEditable(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Editable, value); ++} ++ ++/*! ++ Sets the \c USER flag on this property to \a value. ++ ++ \sa isUser(), setDesignable(), setScriptable() ++*/ ++void QMetaPropertyBuilder::setUser(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(User, value); ++} ++ ++/*! ++ Sets the C++ setter flag on this property to \a value, which is ++ true if the property has a C++ setter function that follows Qt's ++ standard "name" / "setName" pattern. ++ ++ \sa hasStdCppSet() ++*/ ++void QMetaPropertyBuilder::setStdCppSet(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(StdCppSet, value); ++} ++ ++/*! ++ Sets this property to be of an enumerator or flag type if ++ \a value is true. ++ ++ \sa isEnumOrFlag() ++*/ ++void QMetaPropertyBuilder::setEnumOrFlag(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(EnumOrFlag, value); ++} ++ ++/*! ++ Sets this property to have the dynamic flag if \a value is ++ true. ++ ++ \sa isDynamic() ++*/ ++void QMetaPropertyBuilder::setDynamic(bool value) ++{ ++ QMetaPropertyBuilderPrivate *d = d_func(); ++ if (d) ++ d->setFlag(Dynamic, value); ++} ++ ++/*! ++ \class QMetaEnumBuilder ++ \internal ++ \brief The QMetaEnumBuilder class enables modifications to an enumerator definition on a meta object builder. ++*/ ++ ++QMetaEnumBuilderPrivate *QMetaEnumBuilder::d_func() const ++{ ++ if (_mobj && _index >= 0 && _index < _mobj->d->enumerators.size()) ++ return &(_mobj->d->enumerators[_index]); ++ else ++ return 0; ++} ++ ++/*! ++ \fn QMetaEnumBuilder::QMetaEnumBuilder() ++ \internal ++*/ ++ ++/*! ++ \fn int QMetaEnumBuilder::index() const ++ ++ Returns the index of this enumerator within its QMetaObjectBuilder. ++*/ ++ ++/*! ++ Returns the name of the enumerator (without the scope). ++*/ ++QByteArray QMetaEnumBuilder::name() const ++{ ++ QMetaEnumBuilderPrivate *d = d_func(); ++ if (d) ++ return d->name; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Returns true if this enumerator is used as a flag; otherwise returns ++ false. ++ ++ \sa setIsFlag() ++*/ ++bool QMetaEnumBuilder::isFlag() const ++{ ++ QMetaEnumBuilderPrivate *d = d_func(); ++ if (d) ++ return d->isFlag; ++ else ++ return false; ++} ++ ++/*! ++ Sets this enumerator to be used as a flag if \a value is true. ++ ++ \sa isFlag() ++*/ ++void QMetaEnumBuilder::setIsFlag(bool value) ++{ ++ QMetaEnumBuilderPrivate *d = d_func(); ++ if (d) ++ d->isFlag = value; ++} ++ ++/*! ++ Returns the number of keys. ++ ++ \sa key(), addKey() ++*/ ++int QMetaEnumBuilder::keyCount() const ++{ ++ QMetaEnumBuilderPrivate *d = d_func(); ++ if (d) ++ return d->keys.size(); ++ else ++ return 0; ++} ++ ++/*! ++ Returns the key with the given \a index, or an empty QByteArray ++ if no such key exists. ++ ++ \sa keyCount(), addKey(), value() ++*/ ++QByteArray QMetaEnumBuilder::key(int index) const ++{ ++ QMetaEnumBuilderPrivate *d = d_func(); ++ if (d && index >= 0 && index < d->keys.size()) ++ return d->keys[index]; ++ else ++ return QByteArray(); ++} ++ ++/*! ++ Returns the value with the given \a index; or returns -1 if there ++ is no such value. ++ ++ \sa keyCount(), addKey(), key() ++*/ ++int QMetaEnumBuilder::value(int index) const ++{ ++ QMetaEnumBuilderPrivate *d = d_func(); ++ if (d && index >= 0 && index < d->keys.size()) ++ return d->values[index]; ++ else ++ return -1; ++} ++ ++/*! ++ Adds a new key called \a name to this enumerator, associated ++ with \a value. Returns the index of the new key. ++ ++ \sa keyCount(), key(), value(), removeKey() ++*/ ++int QMetaEnumBuilder::addKey(const QByteArray& name, int value) ++{ ++ QMetaEnumBuilderPrivate *d = d_func(); ++ if (d) { ++ int index = d->keys.size(); ++ d->keys += name; ++ d->values += value; ++ return index; ++ } else { ++ return -1; ++ } ++} ++ ++/*! ++ Removes the key at \a index from this enumerator. ++ ++ \sa addKey() ++*/ ++void QMetaEnumBuilder::removeKey(int index) ++{ ++ QMetaEnumBuilderPrivate *d = d_func(); ++ if (d && index >= 0 && index < d->keys.size()) { ++ d->keys.removeAt(index); ++ d->values.removeAt(index); ++ } ++} ++ ++QTM_END_NAMESPACE +diff --git a/src/serviceframework/ipc/qmetaobjectbuilder_47_p.h b/src/serviceframework/ipc/qmetaobjectbuilder_47_p.h +new file mode 100644 +index 0000000..5f25e0f +--- /dev/null ++++ b/src/serviceframework/ipc/qmetaobjectbuilder_47_p.h +@@ -0,0 +1,338 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). ++** All rights reserved. ++** Contact: Nokia Corporation (qt-info@nokia.com) ++** ++** This file is part of the Qt Mobility Components. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** No Commercial Usage ++** This file contains pre-release code and may not be distributed. ++** You may use this file in accordance with the terms and conditions ++** contained in the Technology Preview License Agreement accompanying ++** this package. ++** ++** 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, Nokia gives you certain additional ++** rights. These rights are described in the Nokia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** If you have questions regarding the use of this file, please contact ++** Nokia at qt-info@nokia.com. ++** ++** ++** ++** ++** ++** ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++#ifndef QMETAOBJECTBUILDER_H ++#define QMETAOBJECTBUILDER_H ++ ++// ++// W A R N I N G ++// ------------- ++// ++// This file is not part of the Qt API. It exists for the convenience ++// of moc. This header file may change from version to version without notice, ++// or even be removed. ++// ++// We mean it. ++// ++ ++#include ++#include ++#include ++#include ++#include ++ ++QTM_BEGIN_NAMESPACE ++ ++class QMetaObjectBuilderPrivate; ++class QMetaMethodBuilder; ++class QMetaMethodBuilderPrivate; ++class QMetaPropertyBuilder; ++class QMetaPropertyBuilderPrivate; ++class QMetaEnumBuilder; ++class QMetaEnumBuilderPrivate; ++ ++#ifdef IGNORE_METAOBJECTBUILDER_EXPORT ++ class QMetaObjectBuilder ++#else ++ class QM_AUTOTEST_EXPORT QMetaObjectBuilder ++#endif ++{ ++public: ++ enum AddMember ++ { ++ ClassName = 0x00000001, ++ SuperClass = 0x00000002, ++ Methods = 0x00000004, ++ Signals = 0x00000008, ++ Slots = 0x00000010, ++ Constructors = 0x00000020, ++ Properties = 0x00000040, ++ Enumerators = 0x00000080, ++ ClassInfos = 0x00000100, ++ RelatedMetaObjects = 0x00000200, ++ StaticMetacall = 0x00000400, ++ PublicMethods = 0x00000800, ++ ProtectedMethods = 0x00001000, ++ PrivateMethods = 0x00002000, ++ AllMembers = 0x7FFFFFFF, ++ AllPrimaryMembers = 0x7FFFFBFC ++ }; ++ Q_DECLARE_FLAGS(AddMembers, AddMember) ++ ++ enum MetaObjectFlag { ++ DynamicMetaObject = 0x01 ++ }; ++ Q_DECLARE_FLAGS(MetaObjectFlags, MetaObjectFlag) ++ ++ QMetaObjectBuilder(); ++ explicit QMetaObjectBuilder(const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members = AllMembers); ++ virtual ~QMetaObjectBuilder(); ++ ++ QByteArray className() const; ++ void setClassName(const QByteArray& name); ++ ++ const QMetaObject *superClass() const; ++ void setSuperClass(const QMetaObject *meta); ++ ++ MetaObjectFlags flags() const; ++ void setFlags(MetaObjectFlags); ++ ++ int methodCount() const; ++ int constructorCount() const; ++ int propertyCount() const; ++ int enumeratorCount() const; ++ int classInfoCount() const; ++ int relatedMetaObjectCount() const; ++ ++ QMetaMethodBuilder addMethod(const QByteArray& signature); ++ QMetaMethodBuilder addMethod(const QByteArray& signature, const QByteArray& returnType); ++ QMetaMethodBuilder addMethod(const QMetaMethod& prototype); ++ ++ QMetaMethodBuilder addSlot(const QByteArray& signature); ++ QMetaMethodBuilder addSignal(const QByteArray& signature); ++ ++ QMetaMethodBuilder addConstructor(const QByteArray& signature); ++ QMetaMethodBuilder addConstructor(const QMetaMethod& prototype); ++ ++ QMetaPropertyBuilder addProperty(const QByteArray& name, const QByteArray& type, int notifierId=-1); ++ QMetaPropertyBuilder addProperty(const QMetaProperty& prototype); ++ ++ QMetaEnumBuilder addEnumerator(const QByteArray& name); ++ QMetaEnumBuilder addEnumerator(const QMetaEnum& prototype); ++ ++ int addClassInfo(const QByteArray& name, const QByteArray& value); ++ ++#ifdef Q_NO_DATA_RELOCATION ++ int addRelatedMetaObject(const QMetaObjectAccessor &meta); ++#else ++ int addRelatedMetaObject(const QMetaObject *meta); ++#endif ++ ++ void addMetaObject(const QMetaObject *prototype, QMetaObjectBuilder::AddMembers members = AllMembers); ++ ++ QMetaMethodBuilder method(int index) const; ++ QMetaMethodBuilder constructor(int index) const; ++ QMetaPropertyBuilder property(int index) const; ++ QMetaEnumBuilder enumerator(int index) const; ++ const QMetaObject *relatedMetaObject(int index) const; ++ ++ QByteArray classInfoName(int index) const; ++ QByteArray classInfoValue(int index) const; ++ ++ void removeMethod(int index); ++ void removeConstructor(int index); ++ void removeProperty(int index); ++ void removeEnumerator(int index); ++ void removeClassInfo(int index); ++ void removeRelatedMetaObject(int index); ++ ++ int indexOfMethod(const QByteArray& signature); ++ int indexOfSignal(const QByteArray& signature); ++ int indexOfSlot(const QByteArray& signature); ++ int indexOfConstructor(const QByteArray& signature); ++ int indexOfProperty(const QByteArray& name); ++ int indexOfEnumerator(const QByteArray& name); ++ int indexOfClassInfo(const QByteArray& name); ++ ++ typedef int (*StaticMetacallFunction)(QMetaObject::Call, int, void **); ++ ++ QMetaObjectBuilder::StaticMetacallFunction staticMetacallFunction() const; ++ void setStaticMetacallFunction(QMetaObjectBuilder::StaticMetacallFunction value); ++ ++ QMetaObject *toMetaObject() const; ++ QByteArray toRelocatableData(bool * = 0) const; ++ static void fromRelocatableData(QMetaObject *, const QMetaObject *, const QByteArray &); ++ ++#ifndef QT_NO_DATASTREAM ++ void serialize(QDataStream& stream) const; ++ void deserialize ++ (QDataStream& stream, ++ const QMap& references); ++#endif ++ ++private: ++ Q_DISABLE_COPY(QMetaObjectBuilder) ++ ++ QMetaObjectBuilderPrivate *d; ++ ++ friend class QMetaMethodBuilder; ++ friend class QMetaPropertyBuilder; ++ friend class QMetaEnumBuilder; ++}; ++ ++#ifdef IGNORE_METAOBJECTBUILDER_EXPORT ++ class QMetaMethodBuilder ++#else ++ class QM_AUTOTEST_EXPORT QMetaMethodBuilder ++#endif ++{ ++public: ++ QMetaMethodBuilder() : _mobj(0), _index(0) {} ++ ++ int index() const; ++ ++ QMetaMethod::MethodType methodType() const; ++ QByteArray signature() const; ++ ++ QByteArray returnType() const; ++ void setReturnType(const QByteArray& value); ++ ++ QList parameterNames() const; ++ void setParameterNames(const QList& value); ++ ++ QByteArray tag() const; ++ void setTag(const QByteArray& value); ++ ++ QMetaMethod::Access access() const; ++ void setAccess(QMetaMethod::Access value); ++ ++ int attributes() const; ++ void setAttributes(int value); ++ ++private: ++ const QMetaObjectBuilder *_mobj; ++ int _index; ++ ++ friend class QMetaObjectBuilder; ++ friend class QMetaPropertyBuilder; ++ ++ QMetaMethodBuilder(const QMetaObjectBuilder *mobj, int index) ++ : _mobj(mobj), _index(index) {} ++ ++ QMetaMethodBuilderPrivate *d_func() const; ++}; ++ ++#ifdef IGNORE_METAOBJECTBUILDER_EXPORT ++ class QMetaPropertyBuilder ++#else ++ class QM_AUTOTEST_EXPORT QMetaPropertyBuilder ++#endif ++{ ++public: ++ QMetaPropertyBuilder() : _mobj(0), _index(0) {} ++ ++ int index() const { return _index; } ++ ++ QByteArray name() const; ++ QByteArray type() const; ++ ++ bool hasNotifySignal() const; ++ QMetaMethodBuilder notifySignal() const; ++ void setNotifySignal(const QMetaMethodBuilder& value); ++ void removeNotifySignal(); ++ ++ bool isReadable() const; ++ bool isWritable() const; ++ bool isResettable() const; ++ bool isDesignable() const; ++ bool isScriptable() const; ++ bool isStored() const; ++ bool isEditable() const; ++ bool isUser() const; ++ bool hasStdCppSet() const; ++ bool isEnumOrFlag() const; ++ bool isDynamic() const; ++ ++ void setReadable(bool value); ++ void setWritable(bool value); ++ void setResettable(bool value); ++ void setDesignable(bool value); ++ void setScriptable(bool value); ++ void setStored(bool value); ++ void setEditable(bool value); ++ void setUser(bool value); ++ void setStdCppSet(bool value); ++ void setEnumOrFlag(bool value); ++ void setDynamic(bool value); ++ ++private: ++ const QMetaObjectBuilder *_mobj; ++ int _index; ++ ++ friend class QMetaObjectBuilder; ++ ++ QMetaPropertyBuilder(const QMetaObjectBuilder *mobj, int index) ++ : _mobj(mobj), _index(index) {} ++ ++ QMetaPropertyBuilderPrivate *d_func() const; ++}; ++ ++#ifdef IGNORE_METAOBJECTBUILDER_EXPORT ++ class QMetaEnumBuilder ++#else ++ class QM_AUTOTEST_EXPORT QMetaEnumBuilder ++#endif ++{ ++public: ++ QMetaEnumBuilder() : _mobj(0), _index(0) {} ++ ++ int index() const { return _index; } ++ ++ QByteArray name() const; ++ ++ bool isFlag() const; ++ void setIsFlag(bool value); ++ ++ int keyCount() const; ++ QByteArray key(int index) const; ++ int value(int index) const; ++ ++ int addKey(const QByteArray& name, int value); ++ void removeKey(int index); ++ ++private: ++ const QMetaObjectBuilder *_mobj; ++ int _index; ++ ++ friend class QMetaObjectBuilder; ++ ++ QMetaEnumBuilder(const QMetaObjectBuilder *mobj, int index) ++ : _mobj(mobj), _index(index) {} ++ ++ QMetaEnumBuilderPrivate *d_func() const; ++}; ++ ++Q_DECLARE_OPERATORS_FOR_FLAGS(QMetaObjectBuilder::AddMembers) ++Q_DECLARE_OPERATORS_FOR_FLAGS(QMetaObjectBuilder::MetaObjectFlags) ++ ++QTM_END_NAMESPACE ++ ++#endif +diff --git a/src/serviceframework/ipc/qmetaobjectbuilder_p.h b/src/serviceframework/ipc/qmetaobjectbuilder_p.h +index 5f25e0f..7f29ddc 100644 +--- a/src/serviceframework/ipc/qmetaobjectbuilder_p.h ++++ b/src/serviceframework/ipc/qmetaobjectbuilder_p.h +@@ -69,6 +69,8 @@ class QMetaPropertyBuilderPrivate; + class QMetaEnumBuilder; + class QMetaEnumBuilderPrivate; + ++typedef const QMetaObject& (*QMetaObjectAccessor)(); ++ + #ifdef IGNORE_METAOBJECTBUILDER_EXPORT + class QMetaObjectBuilder + #else +@@ -172,7 +174,7 @@ public: + int indexOfEnumerator(const QByteArray& name); + int indexOfClassInfo(const QByteArray& name); + +- typedef int (*StaticMetacallFunction)(QMetaObject::Call, int, void **); ++ typedef QMetaObjectExtraData::StaticMetacallFunction StaticMetacallFunction; + + QMetaObjectBuilder::StaticMetacallFunction staticMetacallFunction() const; + void setStaticMetacallFunction(QMetaObjectBuilder::StaticMetacallFunction value); +@@ -269,7 +271,8 @@ public: + bool isUser() const; + bool hasStdCppSet() const; + bool isEnumOrFlag() const; +- bool isDynamic() const; ++ bool isConstant() const; ++ bool isFinal() const; + + void setReadable(bool value); + void setWritable(bool value); +@@ -281,7 +284,8 @@ public: + void setUser(bool value); + void setStdCppSet(bool value); + void setEnumOrFlag(bool value); +- void setDynamic(bool value); ++ void setConstant(bool value); ++ void setFinal(bool value); + + private: + const QMetaObjectBuilder *_mobj; +diff --git a/tests/auto/qmetaobjectbuilder/qmetaobjectbuilder.pro b/tests/auto/qmetaobjectbuilder/qmetaobjectbuilder.pro +index 4cbc03a..fa6123b 100644 +--- a/tests/auto/qmetaobjectbuilder/qmetaobjectbuilder.pro ++++ b/tests/auto/qmetaobjectbuilder/qmetaobjectbuilder.pro +@@ -9,7 +9,11 @@ QT = core + include(../../../common.pri) + + # Input +-SOURCES += tst_qmetaobjectbuilder.cpp ++contains(QT_MAJOR_VERSION, 4):lessThan(QT_MINOR_VERSION, 8) { ++ SOURCES += tst_qmetaobjectbuilder_47.cpp ++} else { ++ SOURCES += tst_qmetaobjectbuilder.cpp ++} + + CONFIG += mobility + MOBILITY = serviceframework +diff --git a/tests/auto/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp b/tests/auto/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp +index 48ba43c..470d9e5 100644 +--- a/tests/auto/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp ++++ b/tests/auto/qmetaobjectbuilder/tst_qmetaobjectbuilder.cpp +@@ -149,9 +149,9 @@ void tst_QMetaObjectBuilder::mocVersionCheck() + // whenenver moc changes. Once QMetaObjectBuilder has been + // updated, this test can be changed to check for the next version. + int version = int(QObject::staticMetaObject.d.data[0]); +- QVERIFY(version == 4 || version == 5); ++ QVERIFY(version == 4 || version == 5 || version == 6); + version = int(staticMetaObject.d.data[0]); +- QVERIFY(version == 4 || version == 5); ++ QVERIFY(version == 4 || version == 5 || version == 6); + } + + void tst_QMetaObjectBuilder::create() +@@ -555,7 +555,8 @@ void tst_QMetaObjectBuilder::property() + QVERIFY(!nullProp.isUser()); + QVERIFY(!nullProp.hasStdCppSet()); + QVERIFY(!nullProp.isEnumOrFlag()); +- QVERIFY(!nullProp.isDynamic()); ++ QVERIFY(!nullProp.isConstant()); ++ QVERIFY(!nullProp.isFinal()); + QCOMPARE(nullProp.index(), 0); + + // Add a property and check its attributes. +@@ -573,7 +574,8 @@ void tst_QMetaObjectBuilder::property() + QVERIFY(!prop1.isUser()); + QVERIFY(!prop1.hasStdCppSet()); + QVERIFY(!prop1.isEnumOrFlag()); +- QVERIFY(!prop1.isDynamic()); ++ QVERIFY(!prop1.isConstant()); ++ QVERIFY(!prop1.isFinal()); + QCOMPARE(prop1.index(), 0); + QCOMPARE(builder.propertyCount(), 1); + +@@ -592,7 +594,8 @@ void tst_QMetaObjectBuilder::property() + QVERIFY(!prop2.isUser()); + QVERIFY(!prop2.hasStdCppSet()); + QVERIFY(!prop2.isEnumOrFlag()); +- QVERIFY(!prop2.isDynamic()); ++ QVERIFY(!prop2.isConstant()); ++ QVERIFY(!prop2.isFinal()); + QCOMPARE(prop2.index(), 1); + QCOMPARE(builder.propertyCount(), 2); + +@@ -614,7 +617,8 @@ void tst_QMetaObjectBuilder::property() + prop1.setUser(true); + prop1.setStdCppSet(true); + prop1.setEnumOrFlag(true); +- prop1.setDynamic(true); ++ prop1.setConstant(true); ++ prop1.setFinal(true); + + // Check that prop1 is changed, but prop2 is not. + QCOMPARE(prop1.name(), QByteArray("foo")); +@@ -629,7 +633,8 @@ void tst_QMetaObjectBuilder::property() + QVERIFY(prop1.isUser()); + QVERIFY(prop1.hasStdCppSet()); + QVERIFY(prop1.isEnumOrFlag()); +- QVERIFY(prop1.isDynamic()); ++ QVERIFY(prop1.isConstant()); ++ QVERIFY(prop1.isFinal()); + QVERIFY(prop2.isReadable()); + QVERIFY(prop2.isWritable()); + QCOMPARE(prop2.name(), QByteArray("bar")); +@@ -642,7 +647,8 @@ void tst_QMetaObjectBuilder::property() + QVERIFY(!prop2.isUser()); + QVERIFY(!prop2.hasStdCppSet()); + QVERIFY(!prop2.isEnumOrFlag()); +- QVERIFY(!prop2.isDynamic()); ++ QVERIFY(!prop2.isConstant()); ++ QVERIFY(!prop2.isFinal()); + + // Remove prop1 and check that prop2 becomes index 0. + builder.removeProperty(0); +@@ -658,7 +664,8 @@ void tst_QMetaObjectBuilder::property() + QVERIFY(!prop2.isUser()); + QVERIFY(!prop2.hasStdCppSet()); + QVERIFY(!prop2.isEnumOrFlag()); +- QVERIFY(!prop2.isDynamic()); ++ QVERIFY(!prop2.isConstant()); ++ QVERIFY(!prop2.isFinal()); + QCOMPARE(prop2.index(), 0); + + // Perform index-based lookup again. +@@ -682,7 +689,8 @@ void tst_QMetaObjectBuilder::property() + prop2.setUser(false); \ + prop2.setStdCppSet(false); \ + prop2.setEnumOrFlag(false); \ +- prop2.setDynamic(false); \ ++ prop2.setConstant(false); \ ++ prop2.setFinal(false); \ + } while (0) + #define COUNT_FLAGS() \ + ((prop2.isReadable() ? 1 : 0) + \ +@@ -695,7 +703,8 @@ void tst_QMetaObjectBuilder::property() + (prop2.isUser() ? 1 : 0) + \ + (prop2.hasStdCppSet() ? 1 : 0) + \ + (prop2.isEnumOrFlag() ? 1 : 0) + \ +- (prop2.isDynamic() ? 1 : 0)) ++ (prop2.isConstant() ? 1 : 0) + \ ++ (prop2.isFinal() ? 1 : 0)) + #define CHECK_FLAG(setFunc,isFunc) \ + do { \ + CLEAR_FLAGS(); \ +@@ -714,7 +723,8 @@ void tst_QMetaObjectBuilder::property() + CHECK_FLAG(setUser, isUser); + CHECK_FLAG(setStdCppSet, hasStdCppSet); + CHECK_FLAG(setEnumOrFlag, isEnumOrFlag); +- CHECK_FLAG(setDynamic, isDynamic); ++ CHECK_FLAG(setConstant, isConstant); ++ CHECK_FLAG(setFinal, isFinal); + + // Check that nothing else changed. + QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Properties)); +@@ -958,9 +968,9 @@ void tst_QMetaObjectBuilder::relatedMetaObject() + QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::RelatedMetaObjects)); + } + +-static int smetacall(QMetaObject::Call, int, void **) ++static void smetacall(QObject *, QMetaObject::Call, int, void **) + { +- return 0; ++ return; + } + + void tst_QMetaObjectBuilder::staticMetacall() +@@ -1263,8 +1273,8 @@ bool tst_QMetaObjectBuilder::sameMetaObject + if (extra1 && extra2) { + if (extra1->static_metacall != extra2->static_metacall) + return false; +- //objects1 = extra1->objects; +- //objects2 = extra1->objects; ++ objects1 = extra1->objects; ++ objects2 = extra1->objects; + } + } else if (meta1->d.data[0] == meta2->d.data[0] && meta1->d.data[0] == 1) { + objects1 = (const QMetaObject **)(meta1->d.extradata); +diff --git a/tests/auto/qmetaobjectbuilder/tst_qmetaobjectbuilder_47.cpp b/tests/auto/qmetaobjectbuilder/tst_qmetaobjectbuilder_47.cpp +new file mode 100644 +index 0000000..96a7eca +--- /dev/null ++++ b/tests/auto/qmetaobjectbuilder/tst_qmetaobjectbuilder_47.cpp +@@ -0,0 +1,1283 @@ ++/**************************************************************************** ++** ++** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). ++** All rights reserved. ++** Contact: Nokia Corporation (qt-info@nokia.com) ++** ++** This file is part of the test suite of the Qt Toolkit. ++** ++** $QT_BEGIN_LICENSE:LGPL$ ++** No Commercial Usage ++** This file contains pre-release code and may not be distributed. ++** You may use this file in accordance with the terms and conditions ++** contained in the Technology Preview License Agreement accompanying ++** this package. ++** ++** 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, Nokia gives you certain additional ++** rights. These rights are described in the Nokia Qt LGPL Exception ++** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. ++** ++** If you have questions regarding the use of this file, please contact ++** Nokia at qt-info@nokia.com. ++** ++** ++** ++** ++** ++** ++** ++** ++** $QT_END_LICENSE$ ++** ++****************************************************************************/ ++ ++//TESTED_COMPONENT=src/serviceframework ++ ++#include ++#include ++#include ++#include ++ ++QTM_USE_NAMESPACE ++ ++class tst_QMetaObjectBuilder : public QObject ++{ ++ Q_OBJECT ++public: ++ tst_QMetaObjectBuilder() {} ++ ~tst_QMetaObjectBuilder() {} ++ ++private slots: ++ void mocVersionCheck(); ++ void create(); ++ void className(); ++ void superClass(); ++ void flags(); ++ void method(); ++ void slot(); ++ void signal(); ++ void constructor(); ++ void property(); ++ void notifySignal(); ++ void enumerator(); ++ void classInfo(); ++ void relatedMetaObject(); ++ void staticMetacall(); ++ void copyMetaObject(); ++ void serialize(); ++ void removeNotifySignal(); ++ ++private: ++ static bool checkForSideEffects ++ (const QMetaObjectBuilder& builder, ++ QMetaObjectBuilder::AddMembers members); ++ static bool sameMetaObject ++ (const QMetaObject *meta1, const QMetaObject *meta2); ++}; ++ ++#ifdef Q_NO_DATA_RELOCATION ++const QMetaObject *meta; ++#endif ++ ++// Dummy class that has something of every type of thing moc can generate. ++class SomethingOfEverything : public QObject ++{ ++ Q_OBJECT ++ Q_CLASSINFO("ci_foo", "ABC") ++ Q_CLASSINFO("ci_bar", "DEF") ++ Q_PROPERTY(QString prop READ prop WRITE setProp NOTIFY propChanged) ++ Q_PROPERTY(QString prop2 READ prop WRITE setProp) ++ Q_PROPERTY(SomethingEnum eprop READ eprop) ++ Q_PROPERTY(SomethingFlagEnum fprop READ fprop) ++ Q_PROPERTY(QLocale::Language language READ language) ++ Q_ENUMS(SomethingEnum) ++ Q_FLAGS(SomethingFlagEnum) ++public: ++ Q_INVOKABLE SomethingOfEverything() {} ++ ~SomethingOfEverything() {} ++ ++ enum SomethingEnum ++ { ++ GHI, ++ JKL = 10 ++ }; ++ ++ enum SomethingFlagEnum ++ { ++ XYZ = 1, ++ UVW = 8 ++ }; ++ ++ Q_INVOKABLE Q_SCRIPTABLE void method1() {} ++ ++ QString prop() const { return QString(); } ++ void setProp(const QString& v) { Q_UNUSED(v); } ++ ++ SomethingOfEverything::SomethingEnum eprop() const { return GHI; } ++ SomethingOfEverything::SomethingFlagEnum fprop() const { return XYZ; } ++ QLocale::Language language() const { return QLocale::English; } ++ ++public slots: ++ void slot1(const QString&) {} ++ void slot2(int, const QString&) {} ++ ++private slots: ++ void slot3() {} ++ ++protected slots: ++ Q_SCRIPTABLE void slot4(int) {} ++ void slot5(int a, const QString& b) { Q_UNUSED(a); Q_UNUSED(b); } ++ ++signals: ++ void sig1(); ++ void sig2(int x, const QString& y); ++ void propChanged(const QString&); ++}; ++ ++void tst_QMetaObjectBuilder::mocVersionCheck() ++{ ++ // This test will fail when the moc version number is changed. ++ // It is intended as a reminder to also update QMetaObjectBuilder ++ // whenenver moc changes. Once QMetaObjectBuilder has been ++ // updated, this test can be changed to check for the next version. ++ int version = int(QObject::staticMetaObject.d.data[0]); ++ QVERIFY(version == 4 || version == 5 || version == 6); ++ version = int(staticMetaObject.d.data[0]); ++ QVERIFY(version == 4 || version == 5 || version == 6); ++} ++ ++void tst_QMetaObjectBuilder::create() ++{ ++ QMetaObjectBuilder builder; ++ QVERIFY(builder.className().isEmpty()); ++ QVERIFY(builder.superClass() == &QObject::staticMetaObject); ++ QCOMPARE(builder.methodCount(), 0); ++ QCOMPARE(builder.constructorCount(), 0); ++ QCOMPARE(builder.propertyCount(), 0); ++ QCOMPARE(builder.enumeratorCount(), 0); ++ QCOMPARE(builder.classInfoCount(), 0); ++ QCOMPARE(builder.relatedMetaObjectCount(), 0); ++ QVERIFY(builder.staticMetacallFunction() == 0); ++} ++ ++void tst_QMetaObjectBuilder::className() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Change the class name. ++ builder.setClassName("Foo"); ++ QCOMPARE(builder.className(), QByteArray("Foo")); ++ ++ // Change it again. ++ builder.setClassName("Bar"); ++ QCOMPARE(builder.className(), QByteArray("Bar")); ++ ++ // Clone the class name off a static QMetaObject. ++ builder.addMetaObject(&QObject::staticMetaObject, QMetaObjectBuilder::ClassName); ++ QCOMPARE(builder.className(), QByteArray("QObject")); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::ClassName)); ++} ++ ++void tst_QMetaObjectBuilder::superClass() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Change the super class. ++ builder.setSuperClass(&QObject::staticMetaObject); ++ QVERIFY(builder.superClass() == &QObject::staticMetaObject); ++ ++ // Change it again. ++ builder.setSuperClass(&staticMetaObject); ++ QVERIFY(builder.superClass() == &staticMetaObject); ++ ++ // Clone the super class off a static QMetaObject. ++ builder.addMetaObject(&QObject::staticMetaObject, QMetaObjectBuilder::SuperClass); ++ QVERIFY(builder.superClass() == 0); ++ builder.addMetaObject(&staticMetaObject, QMetaObjectBuilder::SuperClass); ++ QVERIFY(builder.superClass() == staticMetaObject.superClass()); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::SuperClass)); ++} ++ ++void tst_QMetaObjectBuilder::flags() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Check default ++ QVERIFY(builder.flags() == 0); ++ ++ // Set flags ++ builder.setFlags(QMetaObjectBuilder::DynamicMetaObject); ++ QVERIFY(builder.flags() == QMetaObjectBuilder::DynamicMetaObject); ++} ++ ++void tst_QMetaObjectBuilder::method() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Check null method ++ QMetaMethodBuilder nullMethod; ++ QCOMPARE(nullMethod.signature(), QByteArray()); ++ QVERIFY(nullMethod.methodType() == QMetaMethod::Method); ++ QVERIFY(nullMethod.returnType().isEmpty()); ++ QVERIFY(nullMethod.parameterNames().isEmpty()); ++ QVERIFY(nullMethod.tag().isEmpty()); ++ QVERIFY(nullMethod.access() == QMetaMethod::Public); ++ QCOMPARE(nullMethod.attributes(), 0); ++ QCOMPARE(nullMethod.index(), 0); ++ ++ // Add a method and check its attributes. ++ QMetaMethodBuilder method1 = builder.addMethod("foo(const QString&, int)"); ++ QCOMPARE(method1.signature(), QByteArray("foo(QString,int)")); ++ QVERIFY(method1.methodType() == QMetaMethod::Method); ++ QVERIFY(method1.returnType().isEmpty()); ++ QVERIFY(method1.parameterNames().isEmpty()); ++ QVERIFY(method1.tag().isEmpty()); ++ QVERIFY(method1.access() == QMetaMethod::Public); ++ QCOMPARE(method1.attributes(), 0); ++ QCOMPARE(method1.index(), 0); ++ QCOMPARE(builder.methodCount(), 1); ++ ++ // Add another method and check again. ++ QMetaMethodBuilder method2 = builder.addMethod("bar(QString)", "int"); ++ QCOMPARE(method2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(method2.methodType() == QMetaMethod::Method); ++ QCOMPARE(method2.returnType(), QByteArray("int")); ++ QVERIFY(method2.parameterNames().isEmpty()); ++ QVERIFY(method2.tag().isEmpty()); ++ QVERIFY(method2.access() == QMetaMethod::Public); ++ QCOMPARE(method2.attributes(), 0); ++ QCOMPARE(method2.index(), 1); ++ QCOMPARE(builder.methodCount(), 2); ++ ++ // Perform index-based lookup. ++ QCOMPARE(builder.indexOfMethod("foo(const QString&, int)"), 0); ++ QCOMPARE(builder.indexOfMethod("bar(QString)"), 1); ++ QCOMPARE(builder.indexOfMethod("baz()"), -1); ++ ++ // Modify the attributes on method1. ++ method1.setReturnType("int"); ++ method1.setParameterNames(QList() << "a" << "b"); ++ method1.setTag("tag"); ++ method1.setAccess(QMetaMethod::Private); ++ method1.setAttributes(42); ++ ++ // Check that method1 is changed, but method2 is not. ++ QCOMPARE(method1.signature(), QByteArray("foo(QString,int)")); ++ QVERIFY(method1.methodType() == QMetaMethod::Method); ++ QCOMPARE(method1.returnType(), QByteArray("int")); ++ QCOMPARE(method1.parameterNames(), QList() << "a" << "b"); ++ QCOMPARE(method1.tag(), QByteArray("tag")); ++ QVERIFY(method1.access() == QMetaMethod::Private); ++ QCOMPARE(method1.attributes(), 42); ++ QCOMPARE(method1.index(), 0); ++ QCOMPARE(method2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(method2.methodType() == QMetaMethod::Method); ++ QCOMPARE(method2.returnType(), QByteArray("int")); ++ QVERIFY(method2.parameterNames().isEmpty()); ++ QVERIFY(method2.tag().isEmpty()); ++ QVERIFY(method2.access() == QMetaMethod::Public); ++ QCOMPARE(method2.attributes(), 0); ++ QCOMPARE(method2.index(), 1); ++ QCOMPARE(builder.methodCount(), 2); ++ ++ // Modify the attributes on method2. ++ method2.setReturnType("QString"); ++ method2.setParameterNames(QList() << "c"); ++ method2.setTag("Q_FOO"); ++ method2.setAccess(QMetaMethod::Protected); ++ method2.setAttributes(24); ++ ++ // This time check that only method2 changed. ++ QCOMPARE(method1.signature(), QByteArray("foo(QString,int)")); ++ QVERIFY(method1.methodType() == QMetaMethod::Method); ++ QCOMPARE(method1.returnType(), QByteArray("int")); ++ QCOMPARE(method1.parameterNames(), QList() << "a" << "b"); ++ QCOMPARE(method1.tag(), QByteArray("tag")); ++ QVERIFY(method1.access() == QMetaMethod::Private); ++ QCOMPARE(method1.attributes(), 42); ++ QCOMPARE(method1.index(), 0); ++ QCOMPARE(method2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(method2.methodType() == QMetaMethod::Method); ++ QCOMPARE(method2.returnType(), QByteArray("QString")); ++ QCOMPARE(method2.parameterNames(), QList() << "c"); ++ QCOMPARE(method2.tag(), QByteArray("Q_FOO")); ++ QVERIFY(method2.access() == QMetaMethod::Protected); ++ QCOMPARE(method2.attributes(), 24); ++ QCOMPARE(method2.index(), 1); ++ QCOMPARE(builder.methodCount(), 2); ++ ++ // Remove method1 and check that method2 becomes index 0. ++ builder.removeMethod(0); ++ QCOMPARE(builder.methodCount(), 1); ++ method2 = builder.method(0); ++ QCOMPARE(method2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(method2.methodType() == QMetaMethod::Method); ++ QCOMPARE(method2.returnType(), QByteArray("QString")); ++ QCOMPARE(method2.parameterNames(), QList() << "c"); ++ QCOMPARE(method2.tag(), QByteArray("Q_FOO")); ++ QVERIFY(method2.access() == QMetaMethod::Protected); ++ QCOMPARE(method2.attributes(), 24); ++ QCOMPARE(method2.index(), 0); ++ ++ // Perform index-based lookup again. ++ QCOMPARE(builder.indexOfMethod("foo(const QString&, int)"), -1); ++ QCOMPARE(builder.indexOfMethod("bar(QString)"), 0); ++ QCOMPARE(builder.indexOfMethod("baz()"), -1); ++ QCOMPARE(builder.method(0).signature(), QByteArray("bar(QString)")); ++ QCOMPARE(builder.method(9).signature(), QByteArray()); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Methods)); ++} ++ ++void tst_QMetaObjectBuilder::slot() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Add a slot and check its attributes. ++ QMetaMethodBuilder method1 = builder.addSlot("foo(const QString&, int)"); ++ QCOMPARE(method1.signature(), QByteArray("foo(QString,int)")); ++ QVERIFY(method1.methodType() == QMetaMethod::Slot); ++ QVERIFY(method1.returnType().isEmpty()); ++ QVERIFY(method1.parameterNames().isEmpty()); ++ QVERIFY(method1.tag().isEmpty()); ++ QVERIFY(method1.access() == QMetaMethod::Public); ++ QCOMPARE(method1.attributes(), 0); ++ QCOMPARE(method1.index(), 0); ++ QCOMPARE(builder.methodCount(), 1); ++ ++ // Add another slot and check again. ++ QMetaMethodBuilder method2 = builder.addSlot("bar(QString)"); ++ QCOMPARE(method2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(method2.methodType() == QMetaMethod::Slot); ++ QVERIFY(method2.returnType().isEmpty()); ++ QVERIFY(method2.parameterNames().isEmpty()); ++ QVERIFY(method2.tag().isEmpty()); ++ QVERIFY(method2.access() == QMetaMethod::Public); ++ QCOMPARE(method2.attributes(), 0); ++ QCOMPARE(method2.index(), 1); ++ QCOMPARE(builder.methodCount(), 2); ++ ++ // Perform index-based lookup ++ QCOMPARE(builder.indexOfSlot("foo(const QString &, int)"), 0); ++ QCOMPARE(builder.indexOfSlot("bar(QString)"), 1); ++ QCOMPARE(builder.indexOfSlot("baz()"), -1); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Methods)); ++} ++ ++void tst_QMetaObjectBuilder::signal() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Add a signal and check its attributes. ++ QMetaMethodBuilder method1 = builder.addSignal("foo(const QString&, int)"); ++ QCOMPARE(method1.signature(), QByteArray("foo(QString,int)")); ++ QVERIFY(method1.methodType() == QMetaMethod::Signal); ++ QVERIFY(method1.returnType().isEmpty()); ++ QVERIFY(method1.parameterNames().isEmpty()); ++ QVERIFY(method1.tag().isEmpty()); ++ QVERIFY(method1.access() == QMetaMethod::Protected); ++ QCOMPARE(method1.attributes(), 0); ++ QCOMPARE(method1.index(), 0); ++ QCOMPARE(builder.methodCount(), 1); ++ ++ // Add another signal and check again. ++ QMetaMethodBuilder method2 = builder.addSignal("bar(QString)"); ++ QCOMPARE(method2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(method2.methodType() == QMetaMethod::Signal); ++ QVERIFY(method2.returnType().isEmpty()); ++ QVERIFY(method2.parameterNames().isEmpty()); ++ QVERIFY(method2.tag().isEmpty()); ++ QVERIFY(method2.access() == QMetaMethod::Protected); ++ QCOMPARE(method2.attributes(), 0); ++ QCOMPARE(method2.index(), 1); ++ QCOMPARE(builder.methodCount(), 2); ++ ++ // Perform index-based lookup ++ QCOMPARE(builder.indexOfSignal("foo(const QString &, int)"), 0); ++ QCOMPARE(builder.indexOfSignal("bar(QString)"), 1); ++ QCOMPARE(builder.indexOfSignal("baz()"), -1); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Methods)); ++} ++ ++void tst_QMetaObjectBuilder::constructor() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Add a constructor and check its attributes. ++ QMetaMethodBuilder ctor1 = builder.addConstructor("foo(const QString&, int)"); ++ QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)")); ++ QVERIFY(ctor1.methodType() == QMetaMethod::Constructor); ++ QVERIFY(ctor1.returnType().isEmpty()); ++ QVERIFY(ctor1.parameterNames().isEmpty()); ++ QVERIFY(ctor1.tag().isEmpty()); ++ QVERIFY(ctor1.access() == QMetaMethod::Public); ++ QCOMPARE(ctor1.attributes(), 0); ++ QCOMPARE(ctor1.index(), 0); ++ QCOMPARE(builder.constructorCount(), 1); ++ ++ // Add another constructor and check again. ++ QMetaMethodBuilder ctor2 = builder.addConstructor("bar(QString)"); ++ QCOMPARE(ctor2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(ctor2.methodType() == QMetaMethod::Constructor); ++ QVERIFY(ctor2.returnType().isEmpty()); ++ QVERIFY(ctor2.parameterNames().isEmpty()); ++ QVERIFY(ctor2.tag().isEmpty()); ++ QVERIFY(ctor2.access() == QMetaMethod::Public); ++ QCOMPARE(ctor2.attributes(), 0); ++ QCOMPARE(ctor2.index(), 1); ++ QCOMPARE(builder.constructorCount(), 2); ++ ++ // Perform index-based lookup. ++ QCOMPARE(builder.indexOfConstructor("foo(const QString&, int)"), 0); ++ QCOMPARE(builder.indexOfConstructor("bar(QString)"), 1); ++ QCOMPARE(builder.indexOfConstructor("baz()"), -1); ++ QCOMPARE(builder.constructor(1).signature(), QByteArray("bar(QString)")); ++ QCOMPARE(builder.constructor(9).signature(), QByteArray()); ++ ++ // Modify the attributes on ctor1. ++ ctor1.setReturnType("int"); ++ ctor1.setParameterNames(QList() << "a" << "b"); ++ ctor1.setTag("tag"); ++ ctor1.setAccess(QMetaMethod::Private); ++ ctor1.setAttributes(42); ++ ++ // Check that ctor1 is changed, but ctor2 is not. ++ QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)")); ++ QVERIFY(ctor1.methodType() == QMetaMethod::Constructor); ++ QCOMPARE(ctor1.returnType(), QByteArray("int")); ++ QCOMPARE(ctor1.parameterNames(), QList() << "a" << "b"); ++ QCOMPARE(ctor1.tag(), QByteArray("tag")); ++ QVERIFY(ctor1.access() == QMetaMethod::Private); ++ QCOMPARE(ctor1.attributes(), 42); ++ QCOMPARE(ctor1.index(), 0); ++ QCOMPARE(ctor2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(ctor2.methodType() == QMetaMethod::Constructor); ++ QVERIFY(ctor2.returnType().isEmpty()); ++ QVERIFY(ctor2.parameterNames().isEmpty()); ++ QVERIFY(ctor2.tag().isEmpty()); ++ QVERIFY(ctor2.access() == QMetaMethod::Public); ++ QCOMPARE(ctor2.attributes(), 0); ++ QCOMPARE(ctor2.index(), 1); ++ QCOMPARE(builder.constructorCount(), 2); ++ ++ // Modify the attributes on ctor2. ++ ctor2.setReturnType("QString"); ++ ctor2.setParameterNames(QList() << "c"); ++ ctor2.setTag("Q_FOO"); ++ ctor2.setAccess(QMetaMethod::Protected); ++ ctor2.setAttributes(24); ++ ++ // This time check that only ctor2 changed. ++ QCOMPARE(ctor1.signature(), QByteArray("foo(QString,int)")); ++ QVERIFY(ctor1.methodType() == QMetaMethod::Constructor); ++ QCOMPARE(ctor1.returnType(), QByteArray("int")); ++ QCOMPARE(ctor1.parameterNames(), QList() << "a" << "b"); ++ QCOMPARE(ctor1.tag(), QByteArray("tag")); ++ QVERIFY(ctor1.access() == QMetaMethod::Private); ++ QCOMPARE(ctor1.attributes(), 42); ++ QCOMPARE(ctor1.index(), 0); ++ QCOMPARE(ctor2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(ctor2.methodType() == QMetaMethod::Constructor); ++ QCOMPARE(ctor2.returnType(), QByteArray("QString")); ++ QCOMPARE(ctor2.parameterNames(), QList() << "c"); ++ QCOMPARE(ctor2.tag(), QByteArray("Q_FOO")); ++ QVERIFY(ctor2.access() == QMetaMethod::Protected); ++ QCOMPARE(ctor2.attributes(), 24); ++ QCOMPARE(ctor2.index(), 1); ++ QCOMPARE(builder.constructorCount(), 2); ++ ++ // Remove ctor1 and check that ctor2 becomes index 0. ++ builder.removeConstructor(0); ++ QCOMPARE(builder.constructorCount(), 1); ++ ctor2 = builder.constructor(0); ++ QCOMPARE(ctor2.signature(), QByteArray("bar(QString)")); ++ QVERIFY(ctor2.methodType() == QMetaMethod::Constructor); ++ QCOMPARE(ctor2.returnType(), QByteArray("QString")); ++ QCOMPARE(ctor2.parameterNames(), QList() << "c"); ++ QCOMPARE(ctor2.tag(), QByteArray("Q_FOO")); ++ QVERIFY(ctor2.access() == QMetaMethod::Protected); ++ QCOMPARE(ctor2.attributes(), 24); ++ QCOMPARE(ctor2.index(), 0); ++ ++ // Perform index-based lookup again. ++ QCOMPARE(builder.indexOfConstructor("foo(const QString&, int)"), -1); ++ QCOMPARE(builder.indexOfConstructor("bar(QString)"), 0); ++ QCOMPARE(builder.indexOfConstructor("baz()"), -1); ++ ++ // Add constructor from prototype ++ QMetaMethod prototype = SomethingOfEverything::staticMetaObject.constructor(0); ++ QMetaMethodBuilder prototypeConstructor = builder.addMethod(prototype); ++ QCOMPARE(builder.constructorCount(), 2); ++ ++ QCOMPARE(prototypeConstructor.signature(), QByteArray("SomethingOfEverything()")); ++ QVERIFY(prototypeConstructor.methodType() == QMetaMethod::Constructor); ++ QCOMPARE(prototypeConstructor.returnType(), QByteArray()); ++ QVERIFY(prototypeConstructor.access() == QMetaMethod::Public); ++ QCOMPARE(prototypeConstructor.index(), 1); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Constructors)); ++} ++ ++void tst_QMetaObjectBuilder::property() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Null property builder ++ QMetaPropertyBuilder nullProp; ++ QCOMPARE(nullProp.name(), QByteArray()); ++ QCOMPARE(nullProp.type(), QByteArray()); ++ QVERIFY(!nullProp.hasNotifySignal()); ++ QVERIFY(!nullProp.isReadable()); ++ QVERIFY(!nullProp.isWritable()); ++ QVERIFY(!nullProp.isResettable()); ++ QVERIFY(!nullProp.isDesignable()); ++ QVERIFY(!nullProp.isScriptable()); ++ QVERIFY(!nullProp.isStored()); ++ QVERIFY(!nullProp.isEditable()); ++ QVERIFY(!nullProp.isUser()); ++ QVERIFY(!nullProp.hasStdCppSet()); ++ QVERIFY(!nullProp.isEnumOrFlag()); ++ QCOMPARE(nullProp.index(), 0); ++ ++ // Add a property and check its attributes. ++ QMetaPropertyBuilder prop1 = builder.addProperty("foo", "const QString &"); ++ QCOMPARE(prop1.name(), QByteArray("foo")); ++ QCOMPARE(prop1.type(), QByteArray("QString")); ++ QVERIFY(!prop1.hasNotifySignal()); ++ QVERIFY(prop1.isReadable()); ++ QVERIFY(prop1.isWritable()); ++ QVERIFY(!prop1.isResettable()); ++ QVERIFY(!prop1.isDesignable()); ++ QVERIFY(prop1.isScriptable()); ++ QVERIFY(!prop1.isStored()); ++ QVERIFY(!prop1.isEditable()); ++ QVERIFY(!prop1.isUser()); ++ QVERIFY(!prop1.hasStdCppSet()); ++ QVERIFY(!prop1.isEnumOrFlag()); ++ ++ QCOMPARE(prop1.index(), 0); ++ QCOMPARE(builder.propertyCount(), 1); ++ ++ // Add another property and check again. ++ QMetaPropertyBuilder prop2 = builder.addProperty("bar", "int"); ++ QCOMPARE(prop2.name(), QByteArray("bar")); ++ QCOMPARE(prop2.type(), QByteArray("int")); ++ QVERIFY(!prop2.hasNotifySignal()); ++ QVERIFY(prop2.isReadable()); ++ QVERIFY(prop2.isWritable()); ++ QVERIFY(!prop2.isResettable()); ++ QVERIFY(!prop2.isDesignable()); ++ QVERIFY(prop2.isScriptable()); ++ QVERIFY(!prop2.isStored()); ++ QVERIFY(!prop2.isEditable()); ++ QVERIFY(!prop2.isUser()); ++ QVERIFY(!prop2.hasStdCppSet()); ++ QVERIFY(!prop2.isEnumOrFlag()); ++ ++ QCOMPARE(prop2.index(), 1); ++ QCOMPARE(builder.propertyCount(), 2); ++ ++ // Perform index-based lookup. ++ QCOMPARE(builder.indexOfProperty("foo"), 0); ++ QCOMPARE(builder.indexOfProperty("bar"), 1); ++ QCOMPARE(builder.indexOfProperty("baz"), -1); ++ QCOMPARE(builder.property(1).name(), QByteArray("bar")); ++ QCOMPARE(builder.property(9).name(), QByteArray()); ++ ++ // Modify the attributes on prop1. ++ prop1.setReadable(false); ++ prop1.setWritable(false); ++ prop1.setResettable(true); ++ prop1.setDesignable(true); ++ prop1.setScriptable(false); ++ prop1.setStored(true); ++ prop1.setEditable(true); ++ prop1.setUser(true); ++ prop1.setStdCppSet(true); ++ prop1.setEnumOrFlag(true); ++ ++ // Check that prop1 is changed, but prop2 is not. ++ QCOMPARE(prop1.name(), QByteArray("foo")); ++ QCOMPARE(prop1.type(), QByteArray("QString")); ++ QVERIFY(!prop1.isReadable()); ++ QVERIFY(!prop1.isWritable()); ++ QVERIFY(prop1.isResettable()); ++ QVERIFY(prop1.isDesignable()); ++ QVERIFY(!prop1.isScriptable()); ++ QVERIFY(prop1.isStored()); ++ QVERIFY(prop1.isEditable()); ++ QVERIFY(prop1.isUser()); ++ QVERIFY(prop1.hasStdCppSet()); ++ QVERIFY(prop1.isEnumOrFlag()); ++ QVERIFY(prop2.isReadable()); ++ QVERIFY(prop2.isWritable()); ++ QCOMPARE(prop2.name(), QByteArray("bar")); ++ QCOMPARE(prop2.type(), QByteArray("int")); ++ QVERIFY(!prop2.isResettable()); ++ QVERIFY(!prop2.isDesignable()); ++ QVERIFY(prop2.isScriptable()); ++ QVERIFY(!prop2.isStored()); ++ QVERIFY(!prop2.isEditable()); ++ QVERIFY(!prop2.isUser()); ++ QVERIFY(!prop2.hasStdCppSet()); ++ QVERIFY(!prop2.isEnumOrFlag()); ++ ++ // Remove prop1 and check that prop2 becomes index 0. ++ builder.removeProperty(0); ++ QCOMPARE(builder.propertyCount(), 1); ++ prop2 = builder.property(0); ++ QCOMPARE(prop2.name(), QByteArray("bar")); ++ QCOMPARE(prop2.type(), QByteArray("int")); ++ QVERIFY(!prop2.isResettable()); ++ QVERIFY(!prop2.isDesignable()); ++ QVERIFY(prop2.isScriptable()); ++ QVERIFY(!prop2.isStored()); ++ QVERIFY(!prop2.isEditable()); ++ QVERIFY(!prop2.isUser()); ++ QVERIFY(!prop2.hasStdCppSet()); ++ QVERIFY(!prop2.isEnumOrFlag()); ++ QCOMPARE(prop2.index(), 0); ++ ++ // Perform index-based lookup again. ++ QCOMPARE(builder.indexOfProperty("foo"), -1); ++ QCOMPARE(builder.indexOfProperty("bar"), 0); ++ QCOMPARE(builder.indexOfProperty("baz"), -1); ++ ++ // Check for side-effects between the flags on prop2. ++ // Setting a flag to true shouldn't set any of the others to true. ++ // This checks for cut-and-paste bugs in the implementation where ++ // the flag code was pasted but the flag name was not changed. ++#define CLEAR_FLAGS() \ ++ do { \ ++ prop2.setReadable(false); \ ++ prop2.setWritable(false); \ ++ prop2.setResettable(false); \ ++ prop2.setDesignable(false); \ ++ prop2.setScriptable(false); \ ++ prop2.setStored(false); \ ++ prop2.setEditable(false); \ ++ prop2.setUser(false); \ ++ prop2.setStdCppSet(false); \ ++ prop2.setEnumOrFlag(false); \ ++ } while (0) ++#define COUNT_FLAGS() \ ++ ((prop2.isReadable() ? 1 : 0) + \ ++ (prop2.isWritable() ? 1 : 0) + \ ++ (prop2.isResettable() ? 1 : 0) + \ ++ (prop2.isDesignable() ? 1 : 0) + \ ++ (prop2.isScriptable() ? 1 : 0) + \ ++ (prop2.isStored() ? 1 : 0) + \ ++ (prop2.isEditable() ? 1 : 0) + \ ++ (prop2.isUser() ? 1 : 0) + \ ++ (prop2.hasStdCppSet() ? 1 : 0) + \ ++ (prop2.isEnumOrFlag() ? 1 : 0)) ++#define CHECK_FLAG(setFunc,isFunc) \ ++ do { \ ++ CLEAR_FLAGS(); \ ++ QCOMPARE(COUNT_FLAGS(), 0); \ ++ prop2.setFunc(true); \ ++ QVERIFY(prop2.isFunc()); \ ++ QCOMPARE(COUNT_FLAGS(), 1); \ ++ } while (0) ++ CHECK_FLAG(setReadable, isReadable); ++ CHECK_FLAG(setWritable, isWritable); ++ CHECK_FLAG(setResettable, isResettable); ++ CHECK_FLAG(setDesignable, isDesignable); ++ CHECK_FLAG(setScriptable, isScriptable); ++ CHECK_FLAG(setStored, isStored); ++ CHECK_FLAG(setEditable, isEditable); ++ CHECK_FLAG(setUser, isUser); ++ CHECK_FLAG(setStdCppSet, hasStdCppSet); ++ CHECK_FLAG(setEnumOrFlag, isEnumOrFlag); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Properties)); ++ ++ // Add property from prototype ++ QMetaProperty prototype = SomethingOfEverything::staticMetaObject.property(1); ++ QVERIFY(prototype.name() == QByteArray("prop")); ++ QMetaPropertyBuilder prototypeProp = builder.addProperty(prototype); ++ QCOMPARE(prototypeProp.name(), QByteArray("prop")); ++ QVERIFY(prototypeProp.hasNotifySignal()); ++ QCOMPARE(prototypeProp.notifySignal().signature(), QByteArray("propChanged(QString)")); ++ QCOMPARE(builder.methodCount(), 1); ++ QCOMPARE(builder.method(0).signature(), QByteArray("propChanged(QString)")); ++} ++ ++void tst_QMetaObjectBuilder::notifySignal() ++{ ++ QMetaObjectBuilder builder; ++ ++ QMetaPropertyBuilder prop = builder.addProperty("foo", "const QString &"); ++ builder.addSlot("setFoo(QString)"); ++ QMetaMethodBuilder notify = builder.addSignal("fooChanged(QString)"); ++ ++ QVERIFY(!prop.hasNotifySignal()); ++ QCOMPARE(prop.notifySignal().index(), 0); ++ ++ prop.setNotifySignal(notify); ++ QVERIFY(prop.hasNotifySignal()); ++ QCOMPARE(prop.notifySignal().index(), 1); ++ ++ prop.setNotifySignal(QMetaMethodBuilder()); ++ QVERIFY(!prop.hasNotifySignal()); ++ QCOMPARE(prop.notifySignal().index(), 0); ++ ++ prop.setNotifySignal(notify); ++ prop.removeNotifySignal(); ++ QVERIFY(!prop.hasNotifySignal()); ++ QCOMPARE(prop.notifySignal().index(), 0); ++ ++ QCOMPARE(builder.methodCount(), 2); ++ QCOMPARE(builder.propertyCount(), 1); ++ ++ // Check that nothing else changed except methods and properties. ++ QVERIFY(checkForSideEffects ++ (builder, QMetaObjectBuilder::Methods | QMetaObjectBuilder::Properties)); ++} ++ ++void tst_QMetaObjectBuilder::enumerator() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Add an enumerator and check its attributes. ++ QMetaEnumBuilder enum1 = builder.addEnumerator("foo"); ++ QCOMPARE(enum1.name(), QByteArray("foo")); ++ QVERIFY(!enum1.isFlag()); ++ QCOMPARE(enum1.keyCount(), 0); ++ QCOMPARE(enum1.index(), 0); ++ QCOMPARE(builder.enumeratorCount(), 1); ++ ++ // Add another enumerator and check again. ++ QMetaEnumBuilder enum2 = builder.addEnumerator("bar"); ++ QCOMPARE(enum2.name(), QByteArray("bar")); ++ QVERIFY(!enum2.isFlag()); ++ QCOMPARE(enum2.keyCount(), 0); ++ QCOMPARE(enum2.index(), 1); ++ QCOMPARE(builder.enumeratorCount(), 2); ++ ++ // Perform index-based lookup. ++ QCOMPARE(builder.indexOfEnumerator("foo"), 0); ++ QCOMPARE(builder.indexOfEnumerator("bar"), 1); ++ QCOMPARE(builder.indexOfEnumerator("baz"), -1); ++ QCOMPARE(builder.enumerator(1).name(), QByteArray("bar")); ++ QCOMPARE(builder.enumerator(9).name(), QByteArray()); ++ ++ // Modify the attributes on enum1. ++ enum1.setIsFlag(true); ++ QCOMPARE(enum1.addKey("ABC", 0), 0); ++ QCOMPARE(enum1.addKey("DEF", 1), 1); ++ QCOMPARE(enum1.addKey("GHI", -1), 2); ++ ++ // Check that enum1 is changed, but enum2 is not. ++ QCOMPARE(enum1.name(), QByteArray("foo")); ++ QVERIFY(enum1.isFlag()); ++ QCOMPARE(enum1.keyCount(), 3); ++ QCOMPARE(enum1.index(), 0); ++ QCOMPARE(enum1.key(0), QByteArray("ABC")); ++ QCOMPARE(enum1.key(1), QByteArray("DEF")); ++ QCOMPARE(enum1.key(2), QByteArray("GHI")); ++ QCOMPARE(enum1.key(3), QByteArray()); ++ QCOMPARE(enum1.value(0), 0); ++ QCOMPARE(enum1.value(1), 1); ++ QCOMPARE(enum1.value(2), -1); ++ QCOMPARE(enum2.name(), QByteArray("bar")); ++ QVERIFY(!enum2.isFlag()); ++ QCOMPARE(enum2.keyCount(), 0); ++ QCOMPARE(enum2.index(), 1); ++ ++ // Modify the attributes on enum2. ++ enum2.setIsFlag(true); ++ QCOMPARE(enum2.addKey("XYZ", 10), 0); ++ QCOMPARE(enum2.addKey("UVW", 19), 1); ++ ++ // This time check that only method2 changed. ++ QCOMPARE(enum1.name(), QByteArray("foo")); ++ QVERIFY(enum1.isFlag()); ++ QCOMPARE(enum1.keyCount(), 3); ++ QCOMPARE(enum1.index(), 0); ++ QCOMPARE(enum1.key(0), QByteArray("ABC")); ++ QCOMPARE(enum1.key(1), QByteArray("DEF")); ++ QCOMPARE(enum1.key(2), QByteArray("GHI")); ++ QCOMPARE(enum1.key(3), QByteArray()); ++ QCOMPARE(enum1.value(0), 0); ++ QCOMPARE(enum1.value(1), 1); ++ QCOMPARE(enum1.value(2), -1); ++ QCOMPARE(enum2.name(), QByteArray("bar")); ++ QVERIFY(enum2.isFlag()); ++ QCOMPARE(enum2.keyCount(), 2); ++ QCOMPARE(enum2.index(), 1); ++ QCOMPARE(enum2.key(0), QByteArray("XYZ")); ++ QCOMPARE(enum2.key(1), QByteArray("UVW")); ++ QCOMPARE(enum2.key(2), QByteArray()); ++ QCOMPARE(enum2.value(0), 10); ++ QCOMPARE(enum2.value(1), 19); ++ ++ // Remove enum1 key ++ enum1.removeKey(2); ++ QCOMPARE(enum1.name(), QByteArray("foo")); ++ QVERIFY(enum1.isFlag()); ++ QCOMPARE(enum1.keyCount(), 2); ++ QCOMPARE(enum1.index(), 0); ++ QCOMPARE(enum1.key(0), QByteArray("ABC")); ++ QCOMPARE(enum1.key(1), QByteArray("DEF")); ++ QCOMPARE(enum1.key(2), QByteArray()); ++ QCOMPARE(enum1.value(0), 0); ++ QCOMPARE(enum1.value(1), 1); ++ QCOMPARE(enum1.value(2), -1); ++ QCOMPARE(enum2.name(), QByteArray("bar")); ++ QVERIFY(enum2.isFlag()); ++ QCOMPARE(enum2.keyCount(), 2); ++ QCOMPARE(enum2.index(), 1); ++ QCOMPARE(enum2.key(0), QByteArray("XYZ")); ++ QCOMPARE(enum2.key(1), QByteArray("UVW")); ++ QCOMPARE(enum2.key(2), QByteArray()); ++ QCOMPARE(enum2.value(0), 10); ++ QCOMPARE(enum2.value(1), 19); ++ ++ // Remove enum1 and check that enum2 becomes index 0. ++ builder.removeEnumerator(0); ++ QCOMPARE(builder.enumeratorCount(), 1); ++ enum2 = builder.enumerator(0); ++ QCOMPARE(enum2.name(), QByteArray("bar")); ++ QVERIFY(enum2.isFlag()); ++ QCOMPARE(enum2.keyCount(), 2); ++ QCOMPARE(enum2.index(), 0); ++ QCOMPARE(enum2.key(0), QByteArray("XYZ")); ++ QCOMPARE(enum2.key(1), QByteArray("UVW")); ++ QCOMPARE(enum2.key(2), QByteArray()); ++ QCOMPARE(enum2.value(0), 10); ++ QCOMPARE(enum2.value(1), 19); ++ ++ // Perform index-based lookup again. ++ QCOMPARE(builder.indexOfEnumerator("foo"), -1); ++ QCOMPARE(builder.indexOfEnumerator("bar"), 0); ++ QCOMPARE(builder.indexOfEnumerator("baz"), -1); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::Enumerators)); ++} ++ ++void tst_QMetaObjectBuilder::classInfo() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Add two items of class information and check their attributes. ++ QCOMPARE(builder.addClassInfo("foo", "value1"), 0); ++ QCOMPARE(builder.addClassInfo("bar", "value2"), 1); ++ QCOMPARE(builder.classInfoName(0), QByteArray("foo")); ++ QCOMPARE(builder.classInfoValue(0), QByteArray("value1")); ++ QCOMPARE(builder.classInfoName(1), QByteArray("bar")); ++ QCOMPARE(builder.classInfoValue(1), QByteArray("value2")); ++ QCOMPARE(builder.classInfoName(9), QByteArray()); ++ QCOMPARE(builder.classInfoValue(9), QByteArray()); ++ QCOMPARE(builder.classInfoCount(), 2); ++ ++ // Perform index-based lookup. ++ QCOMPARE(builder.indexOfClassInfo("foo"), 0); ++ QCOMPARE(builder.indexOfClassInfo("bar"), 1); ++ QCOMPARE(builder.indexOfClassInfo("baz"), -1); ++ ++ // Remove the first one and check again. ++ builder.removeClassInfo(0); ++ QCOMPARE(builder.classInfoName(0), QByteArray("bar")); ++ QCOMPARE(builder.classInfoValue(0), QByteArray("value2")); ++ QCOMPARE(builder.classInfoCount(), 1); ++ ++ // Perform index-based lookup again. ++ QCOMPARE(builder.indexOfClassInfo("foo"), -1); ++ QCOMPARE(builder.indexOfClassInfo("bar"), 0); ++ QCOMPARE(builder.indexOfClassInfo("baz"), -1); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::ClassInfos)); ++} ++ ++#ifdef Q_NO_DATA_RELOCATION ++const QMetaObject& staticMetaObjectGlobal() ++{ ++ return QObject::staticMetaObject; ++} ++ ++const QMetaObject& staticMetaObjectLocal() ++{ ++ return *meta; ++} ++#endif ++ ++ ++void tst_QMetaObjectBuilder::relatedMetaObject() ++{ ++ QMetaObjectBuilder builder; ++ ++ // Add two related meta objects and check their attributes. ++#ifdef Q_NO_DATA_RELOCATION ++ meta = &staticMetaObject; ++ QCOMPARE(builder.addRelatedMetaObject(&staticMetaObjectGlobal), 0); ++ QCOMPARE(builder.addRelatedMetaObject(&staticMetaObjectLocal), 1); ++#else ++ QCOMPARE(builder.addRelatedMetaObject(&QObject::staticMetaObject), 0); ++ QCOMPARE(builder.addRelatedMetaObject(&staticMetaObject), 1); ++#endif ++ QVERIFY(builder.relatedMetaObject(0) == &QObject::staticMetaObject); ++ QVERIFY(builder.relatedMetaObject(1) == &staticMetaObject); ++ QCOMPARE(builder.relatedMetaObjectCount(), 2); ++ ++ // Remove the first one and check again. ++ builder.removeRelatedMetaObject(0); ++ QVERIFY(builder.relatedMetaObject(0) == &staticMetaObject); ++ QCOMPARE(builder.relatedMetaObjectCount(), 1); ++ ++ // Check that nothing else changed. ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::RelatedMetaObjects)); ++} ++ ++static int smetacall(QMetaObject::Call, int, void **) ++{ ++ return 0; ++} ++ ++void tst_QMetaObjectBuilder::staticMetacall() ++{ ++ QMetaObjectBuilder builder; ++ QVERIFY(!builder.staticMetacallFunction()); ++ builder.setStaticMetacallFunction(smetacall); ++ QVERIFY(builder.staticMetacallFunction() == smetacall); ++ QVERIFY(checkForSideEffects(builder, QMetaObjectBuilder::StaticMetacall)); ++} ++ ++// Copy the entire contents of a static QMetaObject and then check ++// that QMetaObjectBuilder will produce an exact copy as output. ++void tst_QMetaObjectBuilder::copyMetaObject() ++{ ++ QMetaObjectBuilder builder(&QObject::staticMetaObject); ++ QMetaObject *meta = builder.toMetaObject(); ++ QVERIFY(sameMetaObject(meta, &QObject::staticMetaObject)); ++ qFree(meta); ++ ++ QMetaObjectBuilder builder2(&staticMetaObject); ++ meta = builder2.toMetaObject(); ++ QVERIFY(sameMetaObject(meta, &staticMetaObject)); ++ qFree(meta); ++ ++ QMetaObjectBuilder builder3(&SomethingOfEverything::staticMetaObject); ++ meta = builder3.toMetaObject(); ++ QVERIFY(sameMetaObject(meta, &SomethingOfEverything::staticMetaObject)); ++ qFree(meta); ++} ++ ++// Serialize and deserialize a meta object and check that ++// it round-trips to the exact same value. ++void tst_QMetaObjectBuilder::serialize() ++{ ++ // Full QMetaObjectBuilder ++ { ++ QMetaObjectBuilder builder(&SomethingOfEverything::staticMetaObject); ++ QMetaObject *meta = builder.toMetaObject(); ++ ++ QByteArray data; ++ QDataStream stream(&data, QIODevice::WriteOnly | QIODevice::Append); ++ builder.serialize(stream); ++ ++ QMetaObjectBuilder builder2; ++ QDataStream stream2(data); ++ QMap references; ++ references.insert(QByteArray("QLocale"), &QLocale::staticMetaObject); ++ builder2.deserialize(stream2, references); ++#ifdef Q_NO_DATA_RELOCATION ++ //the related meta objects will be function pointers ++ //which you have to add to the builder manually. ++ builder2.addRelatedMetaObject(QLocale::getStaticMetaObject); ++#endif ++ builder2.setStaticMetacallFunction(builder.staticMetacallFunction()); ++ QMetaObject *meta2 = builder2.toMetaObject(); ++ ++ QVERIFY(sameMetaObject(meta, meta2)); ++ qFree(meta); ++ qFree(meta2); ++ } ++ ++ // Partial QMetaObjectBuilder ++ { ++ QMetaObjectBuilder builder; ++ builder.setClassName("Test"); ++ builder.addProperty("foo", "int"); ++ ++ QByteArray data; ++ QDataStream stream(&data, QIODevice::WriteOnly | QIODevice::Append); ++ builder.serialize(stream); ++ ++ QMetaObjectBuilder builder2; ++ QDataStream stream2(data); ++ builder2.deserialize(stream2, QMap()); ++ ++ QCOMPARE(builder.superClass(), builder2.superClass()); ++ QCOMPARE(builder.className(), builder2.className()); ++ QCOMPARE(builder.propertyCount(), builder2.propertyCount()); ++ QCOMPARE(builder.property(0).name(), builder2.property(0).name()); ++ QCOMPARE(builder.property(0).type(), builder2.property(0).type()); ++ } ++} ++ ++// Check that removing a method updates notify signals appropriately ++void tst_QMetaObjectBuilder::removeNotifySignal() ++{ ++ QMetaObjectBuilder builder; ++ ++ QMetaMethodBuilder method1 = builder.addSignal("foo(const QString&, int)"); ++ QMetaMethodBuilder method2 = builder.addSignal("bar(QString)"); ++ ++ // Setup property ++ QMetaPropertyBuilder prop = builder.addProperty("prop", "const QString &"); ++ prop.setNotifySignal(method2); ++ QVERIFY(prop.hasNotifySignal()); ++ QCOMPARE(prop.notifySignal().index(), 1); ++ ++ // Remove non-notify signal ++ builder.removeMethod(0); ++ QVERIFY(prop.hasNotifySignal()); ++ QCOMPARE(prop.notifySignal().index(), 0); ++ ++ // Remove notify signal ++ builder.removeMethod(0); ++ QVERIFY(!prop.hasNotifySignal()); ++} ++ ++// Check that the only changes to a "builder" relative to the default ++// state is specified by "members". ++bool tst_QMetaObjectBuilder::checkForSideEffects ++ (const QMetaObjectBuilder& builder, ++ QMetaObjectBuilder::AddMembers members) ++{ ++ if ((members & QMetaObjectBuilder::ClassName) == 0) { ++ if (!builder.className().isEmpty()) ++ return false; ++ } ++ ++ if ((members & QMetaObjectBuilder::SuperClass) == 0) { ++ if (builder.superClass() != &QObject::staticMetaObject) ++ return false; ++ } ++ ++ if ((members & QMetaObjectBuilder::Methods) == 0) { ++ if (builder.methodCount() != 0) ++ return false; ++ } ++ ++ if ((members & QMetaObjectBuilder::Constructors) == 0) { ++ if (builder.constructorCount() != 0) ++ return false; ++ } ++ ++ if ((members & QMetaObjectBuilder::Properties) == 0) { ++ if (builder.propertyCount() != 0) ++ return false; ++ } ++ ++ if ((members & QMetaObjectBuilder::Enumerators) == 0) { ++ if (builder.enumeratorCount() != 0) ++ return false; ++ } ++ ++ if ((members & QMetaObjectBuilder::ClassInfos) == 0) { ++ if (builder.classInfoCount() != 0) ++ return false; ++ } ++ ++ if ((members & QMetaObjectBuilder::RelatedMetaObjects) == 0) { ++ if (builder.relatedMetaObjectCount() != 0) ++ return false; ++ } ++ ++ if ((members & QMetaObjectBuilder::StaticMetacall) == 0) { ++ if (builder.staticMetacallFunction() != 0) ++ return false; ++ } ++ ++ return true; ++} ++ ++static bool sameMethod(const QMetaMethod& method1, const QMetaMethod& method2) ++{ ++ if (QByteArray(method1.signature()) != QByteArray(method2.signature())) ++ return false; ++ ++ if (QByteArray(method1.typeName()) != QByteArray(method2.typeName())) ++ return false; ++ ++ if (method1.parameterNames() != method2.parameterNames()) ++ return false; ++ ++ if (QByteArray(method1.tag()) != QByteArray(method2.tag())) ++ return false; ++ ++ if (method1.access() != method2.access()) ++ return false; ++ ++ if (method1.methodType() != method2.methodType()) ++ return false; ++ ++ if (method1.attributes() != method2.attributes()) ++ return false; ++ ++ return true; ++} ++ ++static bool sameProperty(const QMetaProperty& prop1, const QMetaProperty& prop2) ++{ ++ if (QByteArray(prop1.name()) != QByteArray(prop2.name())) ++ return false; ++ ++ if (QByteArray(prop1.typeName()) != QByteArray(prop2.typeName())) ++ return false; ++ ++ if (prop1.isReadable() != prop2.isReadable() || ++ prop1.isWritable() != prop2.isWritable() || ++ prop1.isResettable() != prop2.isResettable() || ++ prop1.isDesignable() != prop2.isDesignable() || ++ prop1.isScriptable() != prop2.isScriptable() || ++ prop1.isStored() != prop2.isStored() || ++ prop1.isEditable() != prop2.isEditable() || ++ prop1.isUser() != prop2.isUser() || ++ prop1.isFlagType() != prop2.isFlagType() || ++ prop1.isEnumType() != prop2.isEnumType() || ++ prop1.hasNotifySignal() != prop2.hasNotifySignal() || ++ prop1.hasStdCppSet() != prop2.hasStdCppSet()) ++ return false; ++ ++ if (prop1.hasNotifySignal()) { ++ if (prop1.notifySignalIndex() != prop2.notifySignalIndex()) ++ return false; ++ } ++ ++ return true; ++} ++ ++static bool sameEnumerator(const QMetaEnum& enum1, const QMetaEnum& enum2) ++{ ++ if (QByteArray(enum1.name()) != QByteArray(enum2.name())) ++ return false; ++ ++ if (enum1.isFlag() != enum2.isFlag()) ++ return false; ++ ++ if (enum1.keyCount() != enum2.keyCount()) ++ return false; ++ ++ for (int index = 0; index < enum1.keyCount(); ++index) { ++ if (QByteArray(enum1.key(index)) != QByteArray(enum2.key(index))) ++ return false; ++ if (enum1.value(index) != enum2.value(index)) ++ return false; ++ } ++ ++ if (QByteArray(enum1.scope()) != QByteArray(enum2.scope())) ++ return false; ++ ++ return true; ++} ++ ++// Determine if two meta objects are identical. ++bool tst_QMetaObjectBuilder::sameMetaObject ++ (const QMetaObject *meta1, const QMetaObject *meta2) ++{ ++ int index; ++ ++ if (strcmp(meta1->className(), meta2->className()) != 0) ++ return false; ++ ++ if (meta1->superClass() != meta2->superClass()) ++ return false; ++ ++ if (meta1->constructorCount() != meta2->constructorCount() || ++ meta1->methodCount() != meta2->methodCount() || ++ meta1->enumeratorCount() != meta2->enumeratorCount() || ++ meta1->propertyCount() != meta2->propertyCount() || ++ meta1->classInfoCount() != meta2->classInfoCount()) ++ return false; ++ ++ for (index = 0; index < meta1->constructorCount(); ++index) { ++ if (!sameMethod(meta1->constructor(index), meta2->constructor(index))) ++ return false; ++ } ++ ++ for (index = 0; index < meta1->methodCount(); ++index) { ++ if (!sameMethod(meta1->method(index), meta2->method(index))) ++ return false; ++ } ++ ++ for (index = 0; index < meta1->propertyCount(); ++index) { ++ if (!sameProperty(meta1->property(index), meta2->property(index))) ++ return false; ++ } ++ ++ for (index = 0; index < meta1->enumeratorCount(); ++index) { ++ if (!sameEnumerator(meta1->enumerator(index), meta2->enumerator(index))) ++ return false; ++ } ++ ++ for (index = 0; index < meta1->classInfoCount(); ++index) { ++ if (QByteArray(meta1->classInfo(index).name()) != ++ QByteArray(meta2->classInfo(index).name())) ++ return false; ++ if (QByteArray(meta1->classInfo(index).value()) != ++ QByteArray(meta2->classInfo(index).value())) ++ return false; ++ } ++ ++ const QMetaObject **objects1 = 0; ++ const QMetaObject **objects2 = 0; ++ if (meta1->d.data[0] == meta2->d.data[0] && meta1->d.data[0] >= 2) { ++ QMetaObjectExtraData *extra1 = (QMetaObjectExtraData *)(meta1->d.extradata); ++ QMetaObjectExtraData *extra2 = (QMetaObjectExtraData *)(meta2->d.extradata); ++ if (extra1 && !extra2) ++ return false; ++ if (extra2 && !extra1) ++ return false; ++ if (extra1 && extra2) { ++ if (extra1->static_metacall != extra2->static_metacall) ++ return false; ++ //objects1 = extra1->objects; ++ //objects2 = extra1->objects; ++ } ++ } else if (meta1->d.data[0] == meta2->d.data[0] && meta1->d.data[0] == 1) { ++ objects1 = (const QMetaObject **)(meta1->d.extradata); ++ objects2 = (const QMetaObject **)(meta2->d.extradata); ++ } ++ if (objects1 && !objects2) ++ return false; ++ if (objects2 && !objects1) ++ return false; ++ if (objects1 && objects2) { ++ while (*objects1 != 0 && *objects2 != 0) { ++ if (*objects1 != *objects2) ++ return false; ++ ++objects1; ++ ++objects2; ++ } ++ } ++ ++ return true; ++} ++ ++QTEST_MAIN(tst_QMetaObjectBuilder) ++ ++#include "tst_qmetaobjectbuilder_47.moc" diff --git a/meta/recipes-qt/qt4/qt-mobility-1.2.0/gcc-scope.patch b/meta/recipes-qt/qt4/qt-mobility-1.2.0/gcc-scope.patch new file mode 100644 index 0000000000..f01ee9f4df --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-1.2.0/gcc-scope.patch @@ -0,0 +1,48 @@ + +Fixes issues like below + +| qaudiooutput_pulse.cpp: In member function 'bool QPulseAudioOutput::open()': +| qaudiooutput_pulse.cpp:255:75: error: '::getpid' has not been declared +| make[3]: *** [../../../build/Debug/qtmedia_pulse/qaudiooutput_pulse.o] Error 1 + +Signed-off-by: Khem Raj + +Upstream-Status: Pending + +Index: qt-mobility-opensource-src-1.2.0/plugins/multimedia/pulseaudio/qaudiooutput_pulse.cpp +=================================================================== +--- qt-mobility-opensource-src-1.2.0.orig/plugins/multimedia/pulseaudio/qaudiooutput_pulse.cpp 2012-03-31 07:26:24.457018348 -0700 ++++ qt-mobility-opensource-src-1.2.0/plugins/multimedia/pulseaudio/qaudiooutput_pulse.cpp 2012-03-31 07:27:53.309022654 -0700 +@@ -46,7 +46,7 @@ + #include "qaudiodeviceinfo_pulse.h" + #include "qpulseaudioengine.h" + #include "qpulsehelpers.h" +- ++#include + QT_BEGIN_NAMESPACE + + const int PeriodTimeMs = 20; +Index: qt-mobility-opensource-src-1.2.0/plugins/multimedia/pulseaudio/qaudioinput_pulse.cpp +=================================================================== +--- qt-mobility-opensource-src-1.2.0.orig/plugins/multimedia/pulseaudio/qaudioinput_pulse.cpp 2012-03-31 07:29:19.997026831 -0700 ++++ qt-mobility-opensource-src-1.2.0/plugins/multimedia/pulseaudio/qaudioinput_pulse.cpp 2012-03-31 07:29:39.541027625 -0700 +@@ -46,6 +46,7 @@ + #include "qaudiodeviceinfo_pulse.h" + #include "qpulseaudioengine.h" + #include "qpulsehelpers.h" ++#include + + QT_BEGIN_NAMESPACE + +Index: qt-mobility-opensource-src-1.2.0/plugins/multimedia/pulseaudio/qpulseaudioengine.cpp +=================================================================== +--- qt-mobility-opensource-src-1.2.0.orig/plugins/multimedia/pulseaudio/qpulseaudioengine.cpp 2012-03-31 07:33:24.805038719 -0700 ++++ qt-mobility-opensource-src-1.2.0/plugins/multimedia/pulseaudio/qpulseaudioengine.cpp 2012-03-31 07:33:46.889039783 -0700 +@@ -46,6 +46,7 @@ + #include "qaudiodeviceinfo_pulse.h" + #include "qaudiooutput_pulse.h" + #include "qpulsehelpers.h" ++#include + + QT_BEGIN_NAMESPACE + diff --git a/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-configure.patch b/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-configure.patch new file mode 100644 index 0000000000..d61ec03341 --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-configure.patch @@ -0,0 +1,17 @@ +When building qt-mobility, the qa_configure stage failed because the catalogue /usr/lib +is used in some Makefiles within configure tests. We manually removed this catalogue. + +Upstream-Status: Inappropriate [embedded] +Signed-off-by: Dmitry Cherukhin + +--- qt-mobility-opensource-src-1.2.0/configure.orig 2011-05-10 10:06:01.000000000 +0200 ++++ qt-mobility-opensource-src-1.2.0/configure 2011-11-08 12:34:56.347645968 +0100 +@@ -583,6 +583,8 @@ + fi + + $QMAKE_EXEC $QMKSPEC "$relpath/config.tests/$2/$2.pro" 2>> "$CONFIG_LOG" >> "$CONFIG_LOG" ++ cp Makefile Makefile.old ++ sed -e 's@-L/usr/lib@@' Makefile + printf " ." + "$MAKE" clean >> "$CONFIG_LOG" + printf "." diff --git a/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-no-opengl.patch b/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-no-opengl.patch new file mode 100644 index 0000000000..1724995072 --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-no-opengl.patch @@ -0,0 +1,38 @@ +Upstream-Status: Inappropriate [configuration] + +diff --git a/examples/declarative-camera/declarative-camera.pro b/examples/declarative-camera/declarative-camera.pro +index 8164fbc..54fd8ad 100644 +--- a/examples/declarative-camera/declarative-camera.pro ++++ b/examples/declarative-camera/declarative-camera.pro +@@ -5,10 +5,10 @@ TEMPLATE=app + + QT += declarative network + +-!maemo5 { +- contains(QT_CONFIG, opengl) { +- QT += opengl +- } ++contains(QT_CONFIG, opengl): !maemo5 { ++ QT += opengl ++} else { ++ DEFINES += QT_NO_OPENGL + } + + win32 { +diff --git a/examples/videographicsitem/videographicsitem.pro b/examples/videographicsitem/videographicsitem.pro +index 8461beb..eedee2f 100644 +--- a/examples/videographicsitem/videographicsitem.pro ++++ b/examples/videographicsitem/videographicsitem.pro +@@ -9,7 +9,11 @@ MOBILITY = multimedia + + QMAKE_RPATHDIR += $$DESTDIR + +-!symbian:contains(QT_CONFIG, opengl): QT += opengl ++contains(QT_CONFIG, opengl): !symbian { ++ QT += opengl ++} else { ++ DEFINES += QT_NO_OPENGL ++} + + HEADERS += videoplayer.h \ + videoitem.h diff --git a/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-no-xvideo.patch b/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-no-xvideo.patch new file mode 100644 index 0000000000..6046752aa7 --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-1.2.0/qt-mobility-no-xvideo.patch @@ -0,0 +1,26 @@ +QMake pro files don't explicitly define QT_NO_XVIDEO if the +configuration lacks xvideo, but plugins code relies on this define. + +Signed-off-by: Hongxu Jia +Upstream-Status: Inappropriate [configuration] +--- + plugins/multimedia/gstreamer/gstreamer.pro | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/plugins/multimedia/gstreamer/gstreamer.pro b/plugins/multimedia/gstreamer/gstreamer.pro +--- a/plugins/multimedia/gstreamer/gstreamer.pro ++++ b/plugins/multimedia/gstreamer/gstreamer.pro +@@ -19,6 +19,10 @@ LIBS += \ + -lasound + } + ++unix:!contains(QT_CONFIG, xvideo) { ++ DEFINES += QT_NO_XVIDEO ++} ++ + CONFIG += link_pkgconfig + + PKGCONFIG += \ +-- +1.8.1.2 + diff --git a/meta/recipes-qt/qt4/qt-mobility-embedded_1.2.0.bb b/meta/recipes-qt/qt4/qt-mobility-embedded_1.2.0.bb new file mode 100644 index 0000000000..998de2a055 --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-embedded_1.2.0.bb @@ -0,0 +1,11 @@ +SUMMARY = "Mobile device API extensions for Qt/Embedded 4.x" +DEPENDS = "qt4-embedded" +SECTION = "libs" +qtm_embedded := "embedded" +qtm_dir = "qtopia" +qtm_glflags := "-=opengl" +qtm_extra_config := "gstreamer-photography_enabled = no" + +inherit qt4e +require qt-mobility_${PV}.inc + diff --git a/meta/recipes-qt/qt4/qt-mobility-x11_1.2.0.bb b/meta/recipes-qt/qt4/qt-mobility-x11_1.2.0.bb new file mode 100644 index 0000000000..5fe7bc98bd --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility-x11_1.2.0.bb @@ -0,0 +1,10 @@ +SUMMARY = "Mobile device API extensions for Qt/X11 4.x" +DEPENDS = "qt4-x11-free" +SECTION = "x11/libs" +qtm_embedded := "" +qtm_dir = "qt4" +qtm_glflags := "${@base_contains('DISTRO_FEATURES', 'opengl', '+=opengl', '-=opengl', d)} " +qtm_extra_config := "" + +inherit qt4x11 +require qt-mobility_${PV}.inc diff --git a/meta/recipes-qt/qt4/qt-mobility_1.2.0.inc b/meta/recipes-qt/qt4/qt-mobility_1.2.0.inc new file mode 100644 index 0000000000..ff63d2b0d0 --- /dev/null +++ b/meta/recipes-qt/qt4/qt-mobility_1.2.0.inc @@ -0,0 +1,109 @@ +HOMEPAGE = "http://qt-project.org/" +DEPENDS = "gstreamer util-linux" + +PACKAGECONFIG ??= "${@base_contains('DISTRO_FEATURES', 'pulseaudio', 'pulseaudio', '', d)} \ + ${@base_contains('DISTRO_FEATURES', 'bluetooth', 'bluetooth', '', d)}" +PACKAGECONFIG[bluetooth] = ",,bluez4" +PACKAGECONFIG[pulseaudio] = ",,pulseaudio" + +LICENSE = "LGPLv2.1" +LIC_FILES_CHKSUM = "file://LICENSE.LGPL;md5=fbc093901857fcd118f065f900982c24 \ + file://LGPL_EXCEPTION.txt;md5=411080a56ff917a5a1aa08c98acae354" + +FILESEXTRAPATHS =. "${FILE_DIRNAME}/qt-mobility-${PV}:" +SRC_URI = "http://get.qt.nokia.com/qt/add-ons/qt-mobility-opensource-src-${PV}.tar.gz \ + file://qt-mobility-configure.patch \ + file://0001-gstvideoconnector-fixed-buffers-allocation.patch \ + file://0002-Remove-unnecessary-rpaths-from-qml_device-example.patch \ + file://qt-mobility-no-opengl.patch \ + file://gcc-scope.patch \ + file://qt-mobility-no-xvideo.patch \ + file://fix_metaobjectbuilder_build_err.patch \ + file://0001-fix-embedded-usage-doesn-t-work-outside-of-Qt.patch \ + " + +SRC_URI[md5sum]="ea5db5a8d3dd4709c2926dceda646bd8" +SRC_URI[sha256sum]="ee3c88975e04139ac9589f76d4be646d44fcbc4c8c1cf2db621abc154cf0ba44" + +PR = "r8" + +S = "${WORKDIR}/qt-mobility-opensource-src-${PV}" + +qtm_bin := "/usr/bin/${qtm_dir}" +qtm_lib := "/usr/lib" +qtm_include := "/usr/include/${qtm_dir}" +qtm_examples := "/usr/bin/${qtm_dir}/examples/QtMobility" +qtm_demos := "/usr/bin/${qtm_dir}/demos/QtMobility" +qtm_plugins := "/usr/lib/${qtm_dir}/plugins/QtMobility" +qtm_data := "/usr/share/${qtm_dir}" +qtm_imports := "/usr/lib/${qtm_dir}/imports" + +QTM_MODULES_LIST ?= "bearer contacts gallery location publishsubscribe messaging multimedia \ +systeminfo serviceframework sensors versit organizer feedback connectivity" + +do_configure_prepend() { + cp qtmobility.pro qtmobility.pro.old + sed -e 's@...QT_INSTALL_DATA.@${qtm_data}@' qtmobility.pro + for NAME in plugins/declarative/*/*.pro + do + cp $NAME $NAME.old + sed -e 's@...QT_INSTALL_IMPORTS.@${qtm_imports}@' <$NAME.old >$NAME + done + cp staticconfig.pri staticconfig.pri.old + echo "include(${STAGING_DATADIR}/${qtm_dir}/mkspecs/qconfig.pri)" >staticconfig.pri + cat staticconfig.pri.old >>staticconfig.pri + + cat > features/platformconfig/oe.pri <>./config.pri + echo QT_MOBILITY_LIB = ${qtm_lib} >>./config.pri + echo QT_MOBILITY_INCLUDE = ${qtm_include} >>./config.pri + echo QT_MOBILITY_PLUGINS = ${qtm_plugins} >>./config.pri + echo QT_MOBILITY_EXAMPLES = ${qtm_examples} >>./config.pri + echo QT_MOBILITY_DEMOS = ${qtm_demos} >>./config.pri + echo QT_CONFIG ${qtm_glflags} >>./config.pri + echo CONFIG += ${qtm_embedded} >>./config.pri +} + +do_install() { + for NAME in */*.prf + do + cp $NAME $NAME.old + sed -e 's@/usr@${STAGING_BINDIR}/..@' <$NAME.old >$NAME + done + oe_runmake install INSTALL_ROOT=${D} +} + +PACKAGES = "${PN}-dbg ${PN} ${PN}-dev" + +FILES_${PN}-dbg = "${qtm_bin}/.debug ${qtm_examples}/.debug ${qtm_demos}/.debug \ + ${qtm_lib}/.debug ${qtm_plugins}/*/.debug ${qtm_imports}/*/.debug \ + ${qtm_imports}/*/*/.debug ${bindir}/.debug /usr/src/debug" +FILES_${PN} = "${qtm_bin} ${qtm_examples} ${qtm_demos} ${qtm_lib}/*.so.1* ${qtm_plugins} ${qtm_imports}" +FILES_${PN}-dev = "${exec_prefix}" diff --git a/meta/recipes-qt/qt4/qt4-4.8.5.inc b/meta/recipes-qt/qt4/qt4-4.8.5.inc new file mode 100644 index 0000000000..dcbf26ff12 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5.inc @@ -0,0 +1,63 @@ +LICENSE = "LGPLv2.1 | GPLv3" +LIC_FILES_CHKSUM = "file://LICENSE.LGPL;md5=fbc093901857fcd118f065f900982c24 \ + file://LICENSE.GPL3;md5=6e1694ee338db410417517884918d4d2 \ + file://LGPL_EXCEPTION.txt;md5=0145c4d1b6f96a661c2c139dfb268fb6" + +FILESEXTRAPATHS =. "${FILE_DIRNAME}/qt4-${PV}:" + +SRC_URI = "http://download.qt-project.org/official_releases/qt/4.8/${PV}/qt-everywhere-opensource-src-${PV}.tar.gz \ + file://0003-webkit2-set-OUTPUT_DIR-value-if-empty.patch \ + file://0004-configure-qmake-is-already-built-in-qt4-tools-native.patch \ + file://0008-qmake.pro-Allow-building-a-separate-qmake-for-the-ta.patch \ + file://0009-qmake-fix-source-file-references-in-qmake.pri.patch \ + file://0010-configure-Hack-to-not-use-the-pg_config-of-the-host-.patch \ + file://0011-freetype-host-includes.patch \ + file://0012-Add-2bpp-support.patch \ + file://0013-configure-add-crossarch-option.patch \ + file://0014-translations-fix-phony-translation-linking-error.patch \ + file://0015-configure-add-nostrip-for-debug-packages.patch \ + file://0016-configure-eval-QMAKE_CXX.patch \ + file://0017-configure-ensure-we-identify-the-compiler-as-g-in-co.patch \ + file://0018-configure-make-pulseaudio-a-configurable-option.patch \ + file://0019-Fixes-for-gcc-4.7.0-particularly-on-qemux86.patch \ + file://0020-webkit-disable-the-fuse-ld-gold-flag.patch \ + file://0022-Fix-drawing-of-0-width-polylines-from-outside-the-de.patch \ + file://0023-QHttpMultiPart-fix-data-corruption-in-readData-metho.patch \ + file://0024-Ensure-lastPixel.y-is-also-initalized-to-1-when-nece.patch \ + file://0025-Fix-misaligned-selection-region-with-text-when-cente.patch \ + file://0027-tools.pro-disable-qmeegographicssystemhelper.patch \ + file://g++.conf \ + file://linux.conf \ + " + +SRC_URI[md5sum] = "1864987bdbb2f58f8ae8b350dfdbe133" +SRC_URI[sha256sum] = "eb728f8268831dc4373be6403b7dd5d5dde03c169ad6882f9a8cb560df6aa138" + +S = "${WORKDIR}/qt-everywhere-opensource-src-${PV}" + +FILES_${QT_BASE_NAME}-tools_append = " ${bindir}/qml ${bindir}/qmlplugindump" +FILES_${QT_BASE_NAME}-tools-dbg_append = " ${bindir}/.debug/qml ${bindir}/.debug/qmlplugindump" + +PACKAGES_append = " ${QT_BASE_NAME}-tests-dbg ${QT_BASE_NAME}-tests" +FILES_${QT_BASE_NAME}-tests-dbg = "${prefix}/tests/qt4/*/.debug" +FILES_${QT_BASE_NAME}-tests = "${prefix}/tests/qt4/*" + +do_configure_prepend() { + for pro in $(find ${S} -name "*.pro") ; do + sed -i \ + -e 's:$$QT_BUILD_TREE/bin/lrelease:${OE_QMAKE_LRELEASE}:g' \ + -e 's:qtPrepareTool(LRELEASE, lrelease):LRELEASE = ${OE_QMAKE_LRELEASE}:g' $pro + done + + sed -i s:SEDME:${S}: ${WORKDIR}/linux.conf + sed -i \ + -e /QMAKE_MOC\ /d \ + -e /QMAKE_UIC\ /d \ + -e /QMAKE_UIC3\ /d \ + -e /QMAKE_RCC\ /d \ + ${S}/configure + + # Avoid problems with Qt 4.8.0 configure setting QMAKE_LINK from LD (since we want the linker to be g++) + unset LD +} + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0001-qlibraryinfo-allow-to-set-qt.conf-from-the-outside-u.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0001-qlibraryinfo-allow-to-set-qt.conf-from-the-outside-u.patch new file mode 100644 index 0000000000..d8b0a09d17 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0001-qlibraryinfo-allow-to-set-qt.conf-from-the-outside-u.patch @@ -0,0 +1,43 @@ +From 55097d27e8b746b3d5ff437939caf1fa43c0d62b Mon Sep 17 00:00:00 2001 +From: Holger Freyther +Date: Wed, 26 Sep 2012 17:22:30 +0200 +Subject: [PATCH 01/21] qlibraryinfo: allow to set qt.conf from the outside + using the environment + +Allow to set a qt.conf from the outside using the environment. This allows +to inject new prefixes and other paths into qmake. This is needed when using +the same qmake binary to build qt/x11 and qt/embedded + +Upstream-Status: Pending + +Signed-off-by: Martin Jansa +--- + src/corelib/global/qlibraryinfo.cpp | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/src/corelib/global/qlibraryinfo.cpp b/src/corelib/global/qlibraryinfo.cpp +index 180dc39..4adad35 100644 +--- a/src/corelib/global/qlibraryinfo.cpp ++++ b/src/corelib/global/qlibraryinfo.cpp +@@ -54,6 +54,7 @@ + QT_BEGIN_NAMESPACE + extern QString qmake_libraryInfoFile(); + QT_END_NAMESPACE ++#include + #else + # include "qcoreapplication.h" + #endif +@@ -112,6 +113,10 @@ QSettings *QLibraryInfoPrivate::findConfiguration() + #ifdef BOOTSTRAPPING + if(!QFile::exists(qtconfig)) + qtconfig = qmake_libraryInfoFile(); ++ if (!QFile::exists(qtconfig)) { ++ QByteArray config = getenv("QT_CONF_PATH"); ++ qtconfig = QFile::decodeName(config); ++ } + #else + if (!QFile::exists(qtconfig) && QCoreApplication::instance()) { + #ifdef Q_OS_MAC +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0002-qkbdtty_qws-fix-build-with-old-kernel-headers.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0002-qkbdtty_qws-fix-build-with-old-kernel-headers.patch new file mode 100644 index 0000000000..98fc88738f --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0002-qkbdtty_qws-fix-build-with-old-kernel-headers.patch @@ -0,0 +1,50 @@ +From 5e6b1051afa3099a02a758b0596236759d70670e Mon Sep 17 00:00:00 2001 +From: Wenzong Fan +Date: Wed, 26 Sep 2012 20:18:08 +0200 +Subject: [PATCH 02/21] qkbdtty_qws: fix build with old kernel headers + +This issue is that with C++ compiler process an old version of kernel +header file, coincidently that file has a variable named 'new': + +* 'embedded/qkbdtty_qws.cpp' include 'linux/vt.h'; +* '/usr/include/linux/vt.h' has below code on SLED-11.x: + + unsigned int new; + +On mostly hosts it has been changed to: new -> newev. + +Upstream-Status: Pending + +Signed-off-by: Wenzong Fan +Signed-off-by: Martin Jansa +--- + src/gui/embedded/qkbdtty_qws.cpp | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/src/gui/embedded/qkbdtty_qws.cpp b/src/gui/embedded/qkbdtty_qws.cpp +index a46811b..762138f 100644 +--- a/src/gui/embedded/qkbdtty_qws.cpp ++++ b/src/gui/embedded/qkbdtty_qws.cpp +@@ -54,8 +54,20 @@ + + #if defined Q_OS_LINUX + # include ++ ++/* Workaround kernel headers using "new" as variable name. The problem ++ is specific to SLED-11, other distros use "newev" rather than "new" */ ++#ifdef __cplusplus ++#warning "workaround kernel headers using new as variable name on SLED 11" ++#define new newev ++#endif ++ + # include //TODO: move vt handling somewhere else (QLinuxFbScreen?) + ++#ifdef __cplusplus ++#undef new ++#endif ++ + # include "qscreen_qws.h" + # include "qwindowsystem_qws.h" + # include "qapplication.h" +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0003-webkit2-set-OUTPUT_DIR-value-if-empty.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0003-webkit2-set-OUTPUT_DIR-value-if-empty.patch new file mode 100644 index 0000000000..ecaea51e08 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0003-webkit2-set-OUTPUT_DIR-value-if-empty.patch @@ -0,0 +1,34 @@ +From b6805e883c078f7647d9234aca4e3513ebd1c9bf Mon Sep 17 00:00:00 2001 +From: Martin Jansa +Date: Tue, 1 May 2012 07:48:15 +0200 +Subject: [PATCH 03/21] webkit2: set OUTPUT_DIR value if empty + +Without this do_configure was trying to create /include/WebCore/libdummy.prl in root of build host filesystem +now it's in proper place ${WORKDIR}/qt-everywhere-opensource-src-4.8.1/src/3rdparty/webkit/include/WebCore/libdummy.prl + +First reported here: +http://www.mail-archive.com/openembedded-devel@lists.openembedded.org/msg24436.html + +Upstream-Status: Pending + +Signed-off-by: Martin Jansa +--- + src/3rdparty/webkit/Source/WebKit2/DerivedSources.pro | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/src/3rdparty/webkit/Source/WebKit2/DerivedSources.pro b/src/3rdparty/webkit/Source/WebKit2/DerivedSources.pro +index 006a88c..5e17193 100644 +--- a/src/3rdparty/webkit/Source/WebKit2/DerivedSources.pro ++++ b/src/3rdparty/webkit/Source/WebKit2/DerivedSources.pro +@@ -3,6 +3,8 @@ TARGET = dummy + + CONFIG -= debug_and_release + ++isEmpty(OUTPUT_DIR): OUTPUT_DIR = ../.. ++ + CONFIG(standalone_package) { + isEmpty(WEBKIT2_GENERATED_SOURCES_DIR):WEBKIT2_GENERATED_SOURCES_DIR = $$PWD/generated + isEmpty(WC_GENERATED_SOURCES_DIR):WC_GENERATED_SOURCES_DIR = $$PWD/../WebCore/generated +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0004-configure-qmake-is-already-built-in-qt4-tools-native.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0004-configure-qmake-is-already-built-in-qt4-tools-native.patch new file mode 100644 index 0000000000..1eb8a5843a --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0004-configure-qmake-is-already-built-in-qt4-tools-native.patch @@ -0,0 +1,29 @@ +From af699c6e8cf9fb28d6f8b789bf33d53b47edaec7 Mon Sep 17 00:00:00 2001 +From: Michael Krelin +Date: Wed, 26 Sep 2012 20:24:20 +0200 +Subject: [PATCH 04/21] configure: qmake is already built in qt4-tools-native, + so disable it + +Upstream-Status: Inappropriate [configuration] + +Signed-off-by: Martin Jansa +--- + configure | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/configure b/configure +index e3d464b..cc04b27 100755 +--- a/configure ++++ b/configure +@@ -4899,7 +4899,7 @@ setBootstrapVariable() + } + + # build qmake +-if true; then ###[ '!' -f "$outpath/bin/qmake" ]; ++if false; then ###[ '!' -f "$outpath/bin/qmake" ]; + echo "Creating qmake. Please wait..." + + OLD_QCONFIG_H= +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0005-configure-set-LFLAGS-to-pick-up-zlib-from-staging.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0005-configure-set-LFLAGS-to-pick-up-zlib-from-staging.patch new file mode 100644 index 0000000000..1a8f2b7f94 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0005-configure-set-LFLAGS-to-pick-up-zlib-from-staging.patch @@ -0,0 +1,28 @@ +From ac93237bc90ea7773c0ef5275962baba01d4a9c7 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Jeremy=20Lain=C3=A9?= +Date: Wed, 26 Sep 2012 20:27:44 +0200 +Subject: [PATCH 05/21] configure: set LFLAGS to pick up zlib from staging + +Upstream-Status: Pending + +Signed-off-by: Martin Jansa +--- + configure | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/configure b/configure +index cc04b27..5a7c4ee 100755 +--- a/configure ++++ b/configure +@@ -690,7 +690,7 @@ fi + # initalize variables + #------------------------------------------------------------------------------- + +-SYSTEM_VARIABLES="RANLIB STRIP OBJDUMP LD CC CXX CFLAGS CXXFLAGS LDFLAGS" ++SYSTEM_VARIABLES="RANLIB STRIP OBJDUMP LD CC CXX CFLAGS CXXFLAGS LDFLAGS LFLAGS" + for varname in $SYSTEM_VARIABLES; do + qmakevarname="${varname}" + # use LDFLAGS for autoconf compat, but qmake uses QMAKE_LFLAGS +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0006-configure-Use-OE_QMAKE_-values-to-specify-Qt-utility.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0006-configure-Use-OE_QMAKE_-values-to-specify-Qt-utility.patch new file mode 100644 index 0000000000..90ebf75095 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0006-configure-Use-OE_QMAKE_-values-to-specify-Qt-utility.patch @@ -0,0 +1,38 @@ +From 0bc0db83812b5900dc4e6ffa96bdeab46b6adcae Mon Sep 17 00:00:00 2001 +From: Paul Eggleton +Date: Wed, 26 Sep 2012 20:29:09 +0200 +Subject: [PATCH 06/21] configure: Use OE_QMAKE_* values to specify Qt utility + paths + +Upstream-Status: Inappropriate [configuration] + +Signed-off-by: Paul Eggleton +Signed-off-by: Martin Jansa +--- + configure | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +diff --git a/configure b/configure +index 5a7c4ee..db4d044 100755 +--- a/configure ++++ b/configure +@@ -8683,11 +8683,11 @@ QMAKE_ABSOLUTE_SOURCE_ROOT = \$\$QT_SOURCE_TREE + QMAKE_MOC_SRC = \$\$QT_BUILD_TREE/src/moc + + #local paths that cannot be queried from the QT_INSTALL_* properties while building QTDIR +-QMAKE_MOC = \$\$QT_BUILD_TREE/bin/moc +-QMAKE_UIC = \$\$QT_BUILD_TREE/bin/uic +-QMAKE_UIC3 = \$\$QT_BUILD_TREE/bin/uic3 +-QMAKE_RCC = \$\$QT_BUILD_TREE/bin/rcc +-QMAKE_QDBUSXML2CPP = \$\$QT_BUILD_TREE/bin/qdbusxml2cpp ++QMAKE_MOC = \${OE_QMAKE_MOC} ++QMAKE_UIC = \${OE_QMAKE_UIC} ++QMAKE_UIC3 = \${OE_QMAKE_UIC3} ++QMAKE_RCC = \${OE_QMAKE_RCC} ++QMAKE_QDBUSXML2CPP = \${OE_QMAKE_QDBUSXML2CPP} + QMAKE_INCDIR_QT = \$\$QT_BUILD_TREE/include + QMAKE_LIBDIR_QT = \$\$QT_BUILD_TREE/lib + +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0007-dbus-Remove-const-usage-that-causes-compile-failure-.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0007-dbus-Remove-const-usage-that-causes-compile-failure-.patch new file mode 100644 index 0000000000..7d3b336f77 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0007-dbus-Remove-const-usage-that-causes-compile-failure-.patch @@ -0,0 +1,34 @@ +From 2011bb8029480af1d1266f258e5a5f5cef7392d3 Mon Sep 17 00:00:00 2001 +From: Pavel Heimlich +Date: Wed, 26 Sep 2012 20:31:10 +0200 +Subject: [PATCH 07/21] dbus: Remove "const" usage that causes compile failure + building nativesdk-qt4-tools + +Patch has apparently been rejected upstream, not because it is invalid +but because the submitter did not submit a merge request for it, so the +validity of the patch upstream is uncertain. For further details see: +http://bugreports.qt.nokia.com/browse/QTBUG-17962 + +Upstream-Status: Denied [possible retry] + +Signed-off-by: Martin Jansa +--- + src/dbus/qdbusintegrator.cpp | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/dbus/qdbusintegrator.cpp b/src/dbus/qdbusintegrator.cpp +index 0f0b647..aa4cbab 100644 +--- a/src/dbus/qdbusintegrator.cpp ++++ b/src/dbus/qdbusintegrator.cpp +@@ -73,7 +73,7 @@ QT_BEGIN_NAMESPACE + static bool isDebugging; + #define qDBusDebug if (!::isDebugging); else qDebug + +-Q_GLOBAL_STATIC_WITH_ARGS(const QString, orgFreedesktopDBusString, (QLatin1String(DBUS_SERVICE_DBUS))) ++Q_GLOBAL_STATIC_WITH_ARGS(QString, orgFreedesktopDBusString, (QLatin1String(DBUS_SERVICE_DBUS))) + + static inline QString dbusServiceString() + { return *orgFreedesktopDBusString(); } +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0008-qmake.pro-Allow-building-a-separate-qmake-for-the-ta.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0008-qmake.pro-Allow-building-a-separate-qmake-for-the-ta.patch new file mode 100644 index 0000000000..ec07f41403 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0008-qmake.pro-Allow-building-a-separate-qmake-for-the-ta.patch @@ -0,0 +1,29 @@ +From 64ce5d0e7c19436b928a2a0d9d192f56be3c9bb2 Mon Sep 17 00:00:00 2001 +From: Paul Eggleton +Date: Wed, 26 Sep 2012 20:32:41 +0200 +Subject: [PATCH 08/21] qmake.pro: Allow building a separate qmake for the + target + +Upstream-Status: Inappropriate [config] + +Signed-off-by: Paul Eggleton +Signed-off-by: Martin Jansa +--- + qmake/qmake.pro | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/qmake/qmake.pro b/qmake/qmake.pro +index 38e0fce..53b1ffb 100644 +--- a/qmake/qmake.pro ++++ b/qmake/qmake.pro +@@ -7,6 +7,7 @@ CONFIG += console bootstrap + CONFIG -= qt shared app_bundle uic + DEFINES += QT_BUILD_QMAKE QT_BOOTSTRAPPED + DESTDIR = ../bin/ ++TARGET = qmake2 + + OBJECTS_DIR = . + MOC_DIR = . +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0009-qmake-fix-source-file-references-in-qmake.pri.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0009-qmake-fix-source-file-references-in-qmake.pri.patch new file mode 100644 index 0000000000..45b8c10fbe --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0009-qmake-fix-source-file-references-in-qmake.pri.patch @@ -0,0 +1,52 @@ +From e129dc0d6cde69dd15d1836c4111e0526fc29161 Mon Sep 17 00:00:00 2001 +From: Paul Eggleton +Date: Wed, 26 Sep 2012 20:33:49 +0200 +Subject: [PATCH 09/21] qmake: fix source file references in qmake.pri + +Fix duplicate entries in SOURCES and HEADERS, and fix the source file +list for the split of qlocale.cpp. + +Upstream-Status: Pending + +Signed-off-by: Paul Eggleton +Signed-off-by: Martin Jansa +--- + qmake/qmake.pri | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/qmake/qmake.pri b/qmake/qmake.pri +index 31f67f4..9081669 100644 +--- a/qmake/qmake.pri ++++ b/qmake/qmake.pri +@@ -22,8 +22,7 @@ SOURCES += project.cpp property.cpp main.cpp generators/makefile.cpp \ + generators/symbian/initprojectdeploy_symbian.cpp \ + generators/integrity/gbuild.cpp \ + windows/registry.cpp \ +- symbian/epocroot.cpp \ +- generators/integrity/gbuild.cpp ++ symbian/epocroot.cpp + + HEADERS += project.h property.h generators/makefile.h \ + generators/unix/unixmake.h meta.h option.h cachekeys.h \ +@@ -40,8 +39,7 @@ HEADERS += project.h property.h generators/makefile.h \ + generators/symbian/initprojectdeploy_symbian.h \ + generators/integrity/gbuild.h \ + windows/registry_p.h \ +- symbian/epocroot_p.h \ +- generators/integrity/gbuild.h ++ symbian/epocroot_p.h + + contains(QT_EDITION, OpenSource) { + DEFINES += QMAKE_OPENSOURCE_EDITION +@@ -72,6 +70,8 @@ bootstrap { #Qt code + qlist.cpp \ + qlinkedlist.cpp \ + qlocale.cpp \ ++ qlocale_tools.cpp \ ++ qlocale_unix.cpp \ + qmalloc.cpp \ + qmap.cpp \ + qmetatype.cpp \ +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0010-configure-Hack-to-not-use-the-pg_config-of-the-host-.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0010-configure-Hack-to-not-use-the-pg_config-of-the-host-.patch new file mode 100644 index 0000000000..1d2ddab490 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0010-configure-Hack-to-not-use-the-pg_config-of-the-host-.patch @@ -0,0 +1,42 @@ +From 4888791d1899f781af710dd8813887dea52fda59 Mon Sep 17 00:00:00 2001 +From: Holger Freyther +Date: Wed, 26 Sep 2012 20:36:38 +0200 +Subject: [PATCH 10/21] configure: Hack to not use the pg_config of the host + system which will add /usr/include + +pg_config is a native binary so using that when cross compiling +will always fail. The commented out fix would do, but for OE +our -platform and -xplatform is the same so we are actually not +really cross compiling. Just comment out the test, we are passing +the location to the postgres headers and if they are okay we +will pad. + +Upstream-Status: Inappropriate [configuration] + +Signed-off-by: Martin Jansa +--- + configure | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/configure b/configure +index db4d044..35a8fe7 100755 +--- a/configure ++++ b/configure +@@ -5511,10 +5511,10 @@ for _SQLDR in $CFG_SQL_AVAILABLE; do + psql) + if [ "$CFG_SQL_psql" != "no" ]; then + # Be careful not to use native pg_config when cross building. +- if [ "$XPLATFORM_MINGW" != "yes" ] && "$WHICH" pg_config >/dev/null 2>&1; then +- QT_CFLAGS_PSQL=`pg_config --includedir 2>/dev/null` +- QT_LFLAGS_PSQL=`pg_config --libdir 2>/dev/null` +- fi ++# if [ "$XPLATFORM_MINGW" != "yes" ] && "$WHICH" pg_config >/dev/null 2>&1; then ++# QT_CFLAGS_PSQL=`pg_config --includedir 2>/dev/null` ++# QT_LFLAGS_PSQL=`pg_config --libdir 2>/dev/null` ++# fi + [ -z "$QT_CFLAGS_PSQL" ] || QT_CFLAGS_PSQL="-I$QT_CFLAGS_PSQL" + [ -z "$QT_LFLAGS_PSQL" ] || QT_LFLAGS_PSQL="-L$QT_LFLAGS_PSQL" + # But, respect PSQL_LIBS if set +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0011-freetype-host-includes.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0011-freetype-host-includes.patch new file mode 100644 index 0000000000..e0879c5615 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0011-freetype-host-includes.patch @@ -0,0 +1,29 @@ +From 3fcffa79e6a5f0448cbfe2bb33fe1218f5dae61d Mon Sep 17 00:00:00 2001 +From: Michael Krelin +Date: Mon, 4 Jun 2007 14:48:50 +0200 +Subject: [PATCH 11/21] freetype host includes + +Host include path should not be used in cross compiling case. + +Ported from OE by: Yu Ke +Upstream-Status: Pending + +Signed-off-by: Martin Jansa +--- + config.tests/unix/freetype/freetype.pri | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/config.tests/unix/freetype/freetype.pri b/config.tests/unix/freetype/freetype.pri +index 7ef1cf9..b362fcd 100644 +--- a/config.tests/unix/freetype/freetype.pri ++++ b/config.tests/unix/freetype/freetype.pri +@@ -1,5 +1,5 @@ + !cross_compile { +- TRY_INCLUDEPATHS = /include /usr/include $$QMAKE_INCDIR $$QMAKE_INCDIR_X11 $$INCLUDEPATH ++ TRY_INCLUDEPATHS = $$QMAKE_INCDIR $$QMAKE_INCDIR_X11 $$INCLUDEPATH + # LSB doesn't allow using headers from /include or /usr/include + linux-lsb-g++:TRY_INCLUDEPATHS = $$QMAKE_INCDIR $$QMAKE_INCDIR_X11 $$INCLUDEPATH + for(p, TRY_INCLUDEPATHS) { +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0012-Add-2bpp-support.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0012-Add-2bpp-support.patch new file mode 100644 index 0000000000..8402eab635 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0012-Add-2bpp-support.patch @@ -0,0 +1,318 @@ +From 8744273fc452eb54bbeeb7d15823009ce926c6fa Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Jeremy=20Lain=C3=A9?= +Date: Wed, 26 Sep 2012 20:39:21 +0200 +Subject: [PATCH 12/21] Add 2bpp support + +Submitted upstream but rejected as being "out of scope": +http://bugreports.qt.nokia.com/browse/QTBUG-3468 + +Upstream-Status: Denied + +Signed-off-by: Martin Jansa +--- + configure | 5 +- + src/gui/embedded/qscreen_qws.cpp | 211 ++++++++++++++++++++++++++++++++ + src/gui/embedded/qscreenlinuxfb_qws.cpp | 4 +- + 3 files changed, 216 insertions(+), 4 deletions(-) + +diff --git a/configure b/configure +index 35a8fe7..79c1c7b 100755 +--- a/configure ++++ b/configure +@@ -7063,6 +7063,7 @@ if [ "$CFG_QWS_DEPTHS" = "prompted" -a "$PROMPT_FOR_DEPTHS" = "yes" ]; then + echo "Choose pixel-depths to support:" + echo + echo " 1. 1bpp, black/white" ++ echo " 2. 2bpp, grayscale" + echo " 4. 4bpp, grayscale" + echo " 8. 8bpp, paletted" + echo " 12. 12bpp, rgb 4-4-4" +@@ -7081,11 +7082,11 @@ if [ "$CFG_QWS_DEPTHS" = "prompted" -a "$PROMPT_FOR_DEPTHS" = "yes" ]; then + fi + if [ -n "$CFG_QWS_DEPTHS" -a "$PLATFORM_QWS" = "yes" ]; then + if [ "$CFG_QWS_DEPTHS" = "all" ]; then +- CFG_QWS_DEPTHS="1 4 8 12 15 16 18 24 32 generic" ++ CFG_QWS_DEPTHS="1 2 4 8 12 15 16 18 24 32 generic" + fi + for D in `echo "$CFG_QWS_DEPTHS" | sed -e 's/,/ /g'`; do + case $D in +- 1|4|8|12|15|16|18|24|32) QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QWS_DEPTH_$D";; ++ 1|2|4|8|12|15|16|18|24|32) QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QWS_DEPTH_$D";; + generic) QCONFIG_FLAGS="$QCONFIG_FLAGS QT_QWS_DEPTH_GENERIC";; + esac + done +diff --git a/src/gui/embedded/qscreen_qws.cpp b/src/gui/embedded/qscreen_qws.cpp +index b307bf2..88950b3 100644 +--- a/src/gui/embedded/qscreen_qws.cpp ++++ b/src/gui/embedded/qscreen_qws.cpp +@@ -469,6 +469,58 @@ static void solidFill_gray4(QScreen *screen, const QColor &color, + } + #endif // QT_QWS_DEPTH_4 + ++#ifdef QT_QWS_DEPTH_2 ++static inline void qt_rectfill_gray2(quint8 *dest, quint8 value, ++ int x, int y, int width, int height, ++ int stride) ++{ ++ const int pixelsPerByte = 4; ++ const int alignWidth = qMin(width, (4 - (x & 3)) & 3); ++ const int doAlign = (alignWidth > 0 ? 1 : 0); ++ const int alignStart = pixelsPerByte - 1 - (x & 3); ++ const int alignStop = alignStart - (alignWidth - 1); ++ const quint8 alignMask = ((1 << (2 * alignWidth)) - 1) << (2 * alignStop); ++ const int tailWidth = (width - alignWidth) & 3; ++ const int doTail = (tailWidth > 0 ? 1 : 0); ++ const quint8 tailMask = (1 << (2 * (pixelsPerByte - tailWidth))) - 1; ++ const int width8 = (width - alignWidth) / pixelsPerByte; ++ ++ dest += y * stride + x / pixelsPerByte; ++ stride -= (doAlign + width8); ++ ++ for (int j = 0; j < height; ++j) { ++ if (doAlign) { ++ *dest = (*dest & ~alignMask) | (value & alignMask); ++ ++dest; ++ } ++ if (width8) { ++ qt_memfill(dest, value, width8); ++ dest += width8; ++ } ++ if (doTail) ++ *dest = (*dest & tailMask) | (value & ~tailMask); ++ dest += stride; ++ } ++} ++ ++static void solidFill_gray2(QScreen *screen, const QColor &color, ++ const QRegion ®ion) ++{ ++ quint8 *dest = reinterpret_cast(screen->base()); ++ const quint8 c = qGray(color.rgba()) >> 6; ++ const quint8 c8 = (c << 6) | (c << 4) | (c << 2) | c; ++ ++ const int stride = screen->linestep(); ++ const QVector rects = region.rects(); ++ ++ for (int i = 0; i < rects.size(); ++i) { ++ const QRect r = rects.at(i); ++ qt_rectfill_gray2(dest, c8, r.x(), r.y(), r.width(), r.height(), ++ stride); ++ } ++} ++#endif // QT_QWS_DEPTH_2 ++ + #ifdef QT_QWS_DEPTH_1 + static inline void qt_rectfill_mono(quint8 *dest, quint8 value, + int x, int y, int width, int height, +@@ -576,6 +628,11 @@ void qt_solidFill_setup(QScreen *screen, const QColor &color, + screen->d_ptr->solidFill = solidFill_gray4; + break; + #endif ++#ifdef QT_QWS_DEPTH_2 ++ case 2: ++ screen->d_ptr->solidFill = solidFill_gray2; ++ break; ++#endif + #ifdef QT_QWS_DEPTH_1 + case 1: + screen->d_ptr->solidFill = solidFill_mono; +@@ -1006,6 +1063,149 @@ static void blit_4(QScreen *screen, const QImage &image, + } + #endif // QT_QWS_DEPTH_4 + ++#ifdef QT_QWS_DEPTH_2 ++ ++struct qgray2 { quint8 dummy; } Q_PACKED; ++ ++template ++static inline quint8 qt_convertToGray2(SRC color); ++ ++template <> ++inline quint8 qt_convertToGray2(quint32 color) ++{ ++ return qGray(color) >> 6; ++} ++ ++template <> ++inline quint8 qt_convertToGray2(quint16 color) ++{ ++ const int r = (color & 0xf800) >> 11; ++ const int g = (color & 0x07e0) >> 6; // only keep 5 bit ++ const int b = (color & 0x001f); ++ return (r * 11 + g * 16 + b * 5) >> 8; ++} ++ ++template <> ++inline quint8 qt_convertToGray2(qrgb444 color) ++{ ++ return qt_convertToGray2(quint32(color)); ++} ++ ++template <> ++inline quint8 qt_convertToGray2(qargb4444 color) ++{ ++ return qt_convertToGray2(quint32(color)); ++} ++ ++template ++static inline void qt_rectconvert_gray2(qgray2 *dest2, const SRC *src, ++ int x, int y, int width, int height, ++ int dstStride, int srcStride) ++{ ++ const int pixelsPerByte = 4; ++ quint8 *dest8 = reinterpret_cast(dest2) ++ + y * dstStride + x / pixelsPerByte; ++ const int alignWidth = qMin(width, (4 - (x & 3)) & 3); ++ const int doAlign = (alignWidth > 0 ? 1 : 0); ++ const int alignStart = pixelsPerByte - 1 - (x & 3); ++ const int alignStop = alignStart - (alignWidth - 1); ++ const quint8 alignMask = ((1 << (2 * alignWidth)) - 1) << (2 * alignStop); ++ const int tailWidth = (width - alignWidth) & 3; ++ const int doTail = (tailWidth > 0 ? 1 : 0); ++ const quint8 tailMask = (1 << (2 * (pixelsPerByte - tailWidth))) - 1; ++ const int width8 = (width - alignWidth) / pixelsPerByte; ++ ++ srcStride = srcStride / sizeof(SRC) - (width8 * pixelsPerByte + alignWidth); ++ dstStride -= (width8 + doAlign); ++ ++ for (int j = 0; j < height; ++j) { ++ if (doAlign) { ++ quint8 d = *dest8 & ~alignMask; ++ for (int i = alignStart; i >= alignStop; --i) ++ d |= qt_convertToGray2(*src++) << (2 * i); ++ *dest8++ = d; ++ } ++ for (int i = 0; i < width8; ++i) { ++ *dest8 = (qt_convertToGray2(src[0]) << 6) ++ | (qt_convertToGray2(src[1]) << 4) ++ | (qt_convertToGray2(src[2]) << 2) ++ | (qt_convertToGray2(src[3])); ++ src += 4; ++ ++dest8; ++ } ++ if (doTail) { ++ quint8 d = *dest8 & tailMask; ++ switch (tailWidth) { ++ case 3: d |= qt_convertToGray2(src[2]) << 2; ++ case 2: d |= qt_convertToGray2(src[1]) << 4; ++ case 1: d |= qt_convertToGray2(src[0]) << 6; ++ } ++ *dest8 = d; ++ } ++ ++ dest8 += dstStride; ++ src += srcStride; ++ } ++} ++ ++template <> ++void qt_rectconvert(qgray2 *dest, const quint32 *src, ++ int x, int y, int width, int height, ++ int dstStride, int srcStride) ++{ ++ qt_rectconvert_gray2(dest, src, x, y, width, height, ++ dstStride, srcStride); ++} ++ ++template <> ++void qt_rectconvert(qgray2 *dest, const quint16 *src, ++ int x, int y, int width, int height, ++ int dstStride, int srcStride) ++{ ++ qt_rectconvert_gray2(dest, src, x, y, width, height, ++ dstStride, srcStride); ++} ++ ++template <> ++void qt_rectconvert(qgray2 *dest, const qrgb444 *src, ++ int x, int y, int width, int height, ++ int dstStride, int srcStride) ++{ ++ qt_rectconvert_gray2(dest, src, x, y, width, height, ++ dstStride, srcStride); ++} ++ ++template <> ++void qt_rectconvert(qgray2 *dest, const qargb4444 *src, ++ int x, int y, int width, int height, ++ int dstStride, int srcStride) ++{ ++ qt_rectconvert_gray2(dest, src, x, y, width, height, ++ dstStride, srcStride); ++} ++ ++static void blit_2(QScreen *screen, const QImage &image, ++ const QPoint &topLeft, const QRegion ®ion) ++{ ++ switch (image.format()) { ++ case QImage::Format_ARGB32_Premultiplied: ++ blit_template(screen, image, topLeft, region); ++ return; ++ case QImage::Format_RGB16: ++ blit_template(screen, image, topLeft, region); ++ return; ++ case QImage::Format_RGB444: ++ blit_template(screen, image, topLeft, region); ++ return; ++ case QImage::Format_ARGB4444_Premultiplied: ++ blit_template(screen, image, topLeft, region); ++ return; ++ default: ++ qCritical("blit_2(): Image format %d not supported!", image.format()); ++ } ++} ++#endif // QT_QWS_DEPTH_2 ++ + #ifdef QT_QWS_DEPTH_1 + + struct qmono { quint8 dummy; } Q_PACKED; +@@ -1259,6 +1459,11 @@ void qt_blit_setup(QScreen *screen, const QImage &image, + screen->d_ptr->blit = blit_4; + break; + #endif ++#ifdef QT_QWS_DEPTH_2 ++ case 2: ++ screen->d_ptr->blit = blit_2; ++ break; ++#endif + #ifdef QT_QWS_DEPTH_1 + case 1: + screen->d_ptr->blit = blit_1; +@@ -2146,6 +2351,8 @@ int QScreen::alloc(unsigned int r,unsigned int g,unsigned int b) + } + } else if (d == 4) { + ret = qGray(r, g, b) >> 4; ++ } else if (d == 2) { ++ ret = qGray(r, g, b) >> 6; + } else if (d == 1) { + ret = qGray(r, g, b) >= 128; + } else { +@@ -2216,6 +2423,10 @@ bool QScreen::supportsDepth(int d) const + } else if(d==1) { + return true; + #endif ++#ifdef QT_QWS_DEPTH_2 ++ } else if(d==2) { ++ return true; ++#endif + #ifdef QT_QWS_DEPTH_4 + } else if(d==4) { + return true; +diff --git a/src/gui/embedded/qscreenlinuxfb_qws.cpp b/src/gui/embedded/qscreenlinuxfb_qws.cpp +index 6f3caad..14159ee 100644 +--- a/src/gui/embedded/qscreenlinuxfb_qws.cpp ++++ b/src/gui/embedded/qscreenlinuxfb_qws.cpp +@@ -466,8 +466,8 @@ bool QLinuxFbScreen::connect(const QString &displaySpec) + setupOffScreen(); + + // Now read in palette +- if((vinfo.bits_per_pixel==8) || (vinfo.bits_per_pixel==4)) { +- screencols= (vinfo.bits_per_pixel==8) ? 256 : 16; ++ if((vinfo.bits_per_pixel==8) || (vinfo.bits_per_pixel==4) || (vinfo.bits_per_pixel==2)) { ++ screencols= 1 << vinfo.bits_per_pixel; + int loopc; + ::fb_cmap startcmap; + startcmap.start=0; +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0013-configure-add-crossarch-option.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0013-configure-add-crossarch-option.patch new file mode 100644 index 0000000000..aa464fd1ed --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0013-configure-add-crossarch-option.patch @@ -0,0 +1,47 @@ +From 549342fa380ed2a9ad41be3d04ee2f0585f6a465 Mon Sep 17 00:00:00 2001 +From: Michael Lauer +Date: Wed, 26 Sep 2012 20:41:32 +0200 +Subject: [PATCH 13/21] configure: add "-crossarch" option + +Upstream-Status: Pending + +Signed-off-by: Martin Jansa +--- + configure | 7 ++++++- + 1 file changed, 6 insertions(+), 1 deletion(-) + +diff --git a/configure b/configure +index 79c1c7b..7983c3d 100755 +--- a/configure ++++ b/configure +@@ -1153,7 +1153,7 @@ while [ "$#" -gt 0 ]; do + shift + VAL=$1 + ;; +- -prefix|-docdir|-headerdir|-plugindir|-importdir|-datadir|-libdir|-bindir|-translationdir|-sysconfdir|-examplesdir|-demosdir|-depths|-make|-nomake|-platform|-xplatform|-device-option|-buildkey|-sdk|-arch|-host-arch|-mysql_config|-sysroot) ++ -prefix|-docdir|-headerdir|-plugindir|-importdir|-datadir|-libdir|-bindir|-translationdir|-sysconfdir|-examplesdir|-demosdir|-depths|-make|-nomake|-platform|-xplatform|-device-option|-buildkey|-sdk|-arch|-host-arch|-mysql_config|-sysroot|-crossarch) + VAR=`echo $1 | sed "s,^-\(.*\),\1,"` + shift + VAL="$1" +@@ -1709,6 +1709,9 @@ while [ "$#" -gt 0 ]; do + DEV_VAL=`echo $VAL | sed "s,^.*=\(.*\),\1,"` + DeviceVar set $DEV_VAR $DEV_VAL + ;; ++ crossarch) ++ CROSSARCH="$VAL" ++ ;; + debug-and-release) + if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then + CFG_DEBUG_RELEASE="$VAL" +@@ -3324,6 +3327,8 @@ arm*) + ;; + esac + ++CFG_ARCH="$CROSSARCH" ++ + if [ -d "$relpath/src/corelib/arch/$CFG_ARCH" ]; then + if [ "$OPT_VERBOSE" = "yes" ]; then + echo " '$CFG_ARCH' is supported" +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0014-translations-fix-phony-translation-linking-error.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0014-translations-fix-phony-translation-linking-error.patch new file mode 100644 index 0000000000..66724a8ecf --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0014-translations-fix-phony-translation-linking-error.patch @@ -0,0 +1,41 @@ +From 21af8f6d21b28a53041affb11b58d6316023fa92 Mon Sep 17 00:00:00 2001 +From: Otavio Salvador +Date: Wed, 26 Sep 2012 20:45:10 +0200 +Subject: [PATCH 14/21] translations: fix phony translation linking error + + | .../usr/lib/crt1.o: In function `_start': + | .../../sysdeps/i386/elf/start.S:115: undefined reference to `main' + | collect2: ld returned 1 exit status + +Upstream-Status: Pending + +Signed-off-by: Martin Jansa +--- + translations/translations.pro | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/translations/translations.pro b/translations/translations.pro +index dc99beb..0d98829 100644 +--- a/translations/translations.pro ++++ b/translations/translations.pro +@@ -101,7 +101,7 @@ updateqm.name = LRELEASE ${QMAKE_FILE_IN} + updateqm.CONFIG += no_link + QMAKE_EXTRA_COMPILERS += updateqm + +-isEmpty(vcproj) { ++!isEmpty(vcproj) { + QMAKE_LINK = @: IGNORE THIS LINE + OBJECTS_DIR = + win32:CONFIG -= embed_manifest_exe +@@ -111,7 +111,7 @@ isEmpty(vcproj) { + phony_src.input = PHONY_DEPS + phony_src.output = phony.c + phony_src.variable_out = GENERATED_SOURCES +- phony_src.commands = echo int main() { return 0; } > phony.c ++ phony_src.commands = echo \"int main() { return 0; }\" > phony.c + phony_src.name = CREATE phony.c + phony_src.CONFIG += combine + QMAKE_EXTRA_COMPILERS += phony_src +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0015-configure-add-nostrip-for-debug-packages.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0015-configure-add-nostrip-for-debug-packages.patch new file mode 100644 index 0000000000..b5db49128c --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0015-configure-add-nostrip-for-debug-packages.patch @@ -0,0 +1,32 @@ +From 9250fed086a4a8a645a972764a9bf34e4566ec2e Mon Sep 17 00:00:00 2001 +From: Fathi Boudra +Date: Wed, 26 Sep 2012 20:46:14 +0200 +Subject: [PATCH 15/21] configure: add nostrip for debug packages + +Qt is built in release mode and strip files by default. +Set CONFIG+=nostrip to avoid the stripping and +let dh_strip do it to generate debug packages. + +Upstream-Status: Inappropriate [Configuration] + +Signed-off-by: Martin Jansa +--- + configure | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/configure b/configure +index 7983c3d..d02824b 100755 +--- a/configure ++++ b/configure +@@ -710,6 +710,8 @@ mkdir -p "$outpath/config.tests" + rm -f "$outpath/config.tests/.qmake.cache" + cp "$QMAKE_VARS_FILE" "$outpath/config.tests/.qmake.cache" + ++QMakeVar add CONFIG nostrip ++ + QMakeVar add styles "cde mac motif plastique cleanlooks windows" + QMakeVar add decorations "default windows styled" + QMakeVar add mouse-drivers "pc" +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0016-configure-eval-QMAKE_CXX.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0016-configure-eval-QMAKE_CXX.patch new file mode 100644 index 0000000000..9c3de47b4b --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0016-configure-eval-QMAKE_CXX.patch @@ -0,0 +1,37 @@ +From 8403634a71f067eec514b6d2193cf41e281dff8e Mon Sep 17 00:00:00 2001 +From: Paul Eggleton +Date: Wed, 26 Sep 2012 20:47:08 +0200 +Subject: [PATCH 16/21] configure: eval QMAKE_CXX + +Allow expansion of $(...) references in QMAKE_CXX (currently its value +is $(OE_QMAKE_CXX)) in order to allow compiler version check to succeed +which allows WebKit to be enabled. + +Upstream-Status: Pending + +Signed-off-by: Paul Eggleton +Signed-off-by: Martin Jansa + +Conflicts: + configure +--- + configure | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/configure b/configure +index d02824b..891d6e7 100755 +--- a/configure ++++ b/configure +@@ -3409,7 +3409,8 @@ else + CFG_FRAMEWORK=no + fi + +-QMAKE_CONF_COMPILER=`getXQMakeConf QMAKE_CXX` ++QMAKE_CONF_COMPILER=`getXQMakeConf QMAKE_CXX | sed -n 's/$[(]\([0-9a-zA-Z_]*\)[)]/$\1/pg'` ++QMAKE_CONF_COMPILER=`eval "echo $QMAKE_CONF_COMPILER"` + TEST_COMPILER="$CXX" + + [ -z "$TEST_COMPILER" ] && TEST_COMPILER=$QMAKE_CONF_COMPILER +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0017-configure-ensure-we-identify-the-compiler-as-g-in-co.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0017-configure-ensure-we-identify-the-compiler-as-g-in-co.patch new file mode 100644 index 0000000000..9471966660 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0017-configure-ensure-we-identify-the-compiler-as-g-in-co.patch @@ -0,0 +1,46 @@ +From d2bb701b551402f0befddd0e906423596bdc0df7 Mon Sep 17 00:00:00 2001 +From: Paul Eggleton +Date: Wed, 26 Sep 2012 20:48:37 +0200 +Subject: [PATCH 17/21] configure: ensure we identify the compiler as g++ in + configure + +Our PLATFORM in OE is ${TARGET_OS}-oe-g++, and previously the configure +script was interpreting from this that the compiler was "oe-g++" and +thus +g++ specific checks were not being run since this string did not match; +among other things this resulted in a compiler version check in the +QtWebKit build code not working, and hence the following error at build +time: + +./wtf/NullPtr.h:48:1: error: identifier 'nullptr' will become a keyword +in C++0x [-Werror=c++0x-compat] + +The easiest thing since our PLATFORM is entirely artificial is to just +force COMPILER to "g++" in the configure script if it is detected as +"oe-g++". + +Upstream-Status: Inappropriate [configuration] + +Signed-off-by: Paul Eggleton +Signed-off-by: Martin Jansa +--- + configure | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/configure b/configure +index 891d6e7..7031898 100755 +--- a/configure ++++ b/configure +@@ -7592,6 +7592,9 @@ elif [ "$XPLATFORM" != "$PLATFORM" ]; then + else + COMPILER=`echo $PLATFORM | cut -f 2- -d-` + fi ++case $COMPILER in ++ *oe-g++) COMPILER="g++" ;; ++esac + if [ "$CFG_EXCEPTIONS" = "unspecified" -a "$PLATFORM_QWS" = "yes" ]; then + CFG_EXCEPTIONS=no + fi +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0018-configure-make-pulseaudio-a-configurable-option.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0018-configure-make-pulseaudio-a-configurable-option.patch new file mode 100644 index 0000000000..19cdd4c57d --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0018-configure-make-pulseaudio-a-configurable-option.patch @@ -0,0 +1,46 @@ +From d6dc1a7d6594d7e395347732a3e553fc82ccab3d Mon Sep 17 00:00:00 2001 +From: Paul Eggleton +Date: Tue, 28 Feb 2012 15:10:24 +0000 +Subject: [PATCH 18/21] configure: make pulseaudio a configurable option + +Allows disabling pulseaudio support within phonon at configure time. +(This is the Qt 4.8.0 version.) + +Upstream-Status: Pending + +Signed-off-by: Paul Eggleton +Signed-off-by: Martin Jansa +--- + configure | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +diff --git a/configure b/configure +index 7031898..a4a42f1 100755 +--- a/configure ++++ b/configure +@@ -1139,7 +1139,7 @@ while [ "$#" -gt 0 ]; do + VAL=no + ;; + #Qt style yes options +- -incremental|-qvfb|-profile|-shared|-static|-sm|-xinerama|-xshape|-xsync|-xinput|-egl|-reduce-exports|-pch|-separate-debug-info|-stl|-freetype|-xcursor|-xfixes|-xrandr|-xrender|-mitshm|-fontconfig|-xkb|-nis|-qdbus|-dbus|-dbus-linked|-glib|-gstreamer|-gtkstyle|-cups|-iconv|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-accessibility|-confirm-license|-gnumake|-framework|-qt3support|-debug-and-release|-exceptions|-cocoa|-carbon|-universal|-harfbuzz|-prefix-install|-silent|-armfpa|-optimized-qmake|-dwarf2|-reduce-relocations|-sse|-openssl|-openssl-linked|-ptmalloc|-xmlpatterns|-phonon|-phonon-backend|-multimedia|-audio-backend|-svg|-declarative|-declarative-debug|-javascript-jit|-script|-scripttools|-rpath|-force-pkg-config|-s60|-usedeffiles|-icu) ++ -incremental|-qvfb|-profile|-shared|-static|-sm|-xinerama|-xshape|-xsync|-xinput|-egl|-reduce-exports|-pch|-separate-debug-info|-stl|-freetype|-xcursor|-xfixes|-xrandr|-xrender|-mitshm|-fontconfig|-xkb|-nis|-qdbus|-dbus|-dbus-linked|-glib|-gstreamer|-pulseaudio|-gtkstyle|-cups|-iconv|-largefile|-h|-help|-v|-verbose|-debug|-release|-fast|-accessibility|-confirm-license|-gnumake|-framework|-qt3support|-debug-and-release|-exceptions|-cocoa|-carbon|-universal|-harfbuzz|-prefix-install|-silent|-armfpa|-optimized-qmake|-dwarf2|-reduce-relocations|-sse|-openssl|-openssl-linked|-ptmalloc|-xmlpatterns|-phonon|-phonon-backend|-multimedia|-audio-backend|-svg|-declarative|-declarative-debug|-javascript-jit|-script|-scripttools|-rpath|-force-pkg-config|-s60|-usedeffiles|-icu) + VAR=`echo $1 | sed "s,^-\(.*\),\1,"` + VAL=yes + ;; +@@ -2120,6 +2120,13 @@ while [ "$#" -gt 0 ]; do + UNKNOWN_OPT=yes + fi + ;; ++ pulseaudio) ++ if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then ++ CFG_PULSEAUDIO="$VAL" ++ else ++ UNKNOWN_OPT=yes ++ fi ++ ;; + gtkstyle) + if [ "$VAL" = "yes" ] || [ "$VAL" = "no" ]; then + CFG_QGTKSTYLE="$VAL" +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0019-Fixes-for-gcc-4.7.0-particularly-on-qemux86.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0019-Fixes-for-gcc-4.7.0-particularly-on-qemux86.patch new file mode 100644 index 0000000000..a83d2470a1 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0019-Fixes-for-gcc-4.7.0-particularly-on-qemux86.patch @@ -0,0 +1,63 @@ +From 1f1da2f24d3028b250dbc2e98e2b7e37862b3771 Mon Sep 17 00:00:00 2001 +From: Richard Purdie +Date: Wed, 26 Sep 2012 20:54:38 +0200 +Subject: [PATCH 19/21] Fixes for gcc 4.7.0, particularly on qemux86 + +Origin: upstream, http://trac.webkit.org/changeset/93631 +Origin: upstream, http://trac.webkit.org/changeset/113848 + +Bug: https://bugs.webkit.org/show_bug.cgi?id=62168 +Bug: https://bugs.webkit.org/show_bug.cgi?id=83584 + +RP 2012/04/30 + +Upstream-Status: Backport + +Signed-off-by: Martin Jansa +--- + src/3rdparty/webkit/Source/WebCore/dom/Element.cpp | 2 +- + src/3rdparty/webkit/Source/WebCore/html/HTMLImageElement.cpp | 2 +- + .../webkit/Source/WebCore/platform/graphics/TiledBackingStoreClient.h | 1 + + 3 files changed, 3 insertions(+), 2 deletions(-) + +diff --git a/src/3rdparty/webkit/Source/WebCore/dom/Element.cpp b/src/3rdparty/webkit/Source/WebCore/dom/Element.cpp +index 32e47ca..b8e7389 100644 +--- a/src/3rdparty/webkit/Source/WebCore/dom/Element.cpp ++++ b/src/3rdparty/webkit/Source/WebCore/dom/Element.cpp +@@ -1080,7 +1080,7 @@ void Element::recalcStyle(StyleChange change) + { + // Ref currentStyle in case it would otherwise be deleted when setRenderStyle() is called. + RefPtr currentStyle(renderStyle()); +- bool hasParentStyle = parentNodeForRenderingAndStyle() ? parentNodeForRenderingAndStyle()->renderStyle() : false; ++ bool hasParentStyle = parentNodeForRenderingAndStyle() ? static_cast(parentNodeForRenderingAndStyle()->renderStyle()) : false; + bool hasDirectAdjacentRules = currentStyle && currentStyle->childrenAffectedByDirectAdjacentRules(); + bool hasIndirectAdjacentRules = currentStyle && currentStyle->childrenAffectedByForwardPositionalRules(); + +diff --git a/src/3rdparty/webkit/Source/WebCore/html/HTMLImageElement.cpp b/src/3rdparty/webkit/Source/WebCore/html/HTMLImageElement.cpp +index d66075e..ab8f111 100644 +--- a/src/3rdparty/webkit/Source/WebCore/html/HTMLImageElement.cpp ++++ b/src/3rdparty/webkit/Source/WebCore/html/HTMLImageElement.cpp +@@ -74,7 +74,7 @@ PassRefPtr HTMLImageElement::createForJSConstructor(Document* + RefPtr image = adoptRef(new HTMLImageElement(imgTag, document)); + if (optionalWidth) + image->setWidth(*optionalWidth); +- if (optionalHeight > 0) ++ if (optionalHeight) + image->setHeight(*optionalHeight); + return image.release(); + } +diff --git a/src/3rdparty/webkit/Source/WebCore/platform/graphics/TiledBackingStoreClient.h b/src/3rdparty/webkit/Source/WebCore/platform/graphics/TiledBackingStoreClient.h +index 6087ec3..6d748f6 100644 +--- a/src/3rdparty/webkit/Source/WebCore/platform/graphics/TiledBackingStoreClient.h ++++ b/src/3rdparty/webkit/Source/WebCore/platform/graphics/TiledBackingStoreClient.h +@@ -25,6 +25,7 @@ namespace WebCore { + #if ENABLE(TILED_BACKING_STORE) + class TiledBackingStoreClient { + public: ++ virtual ~TiledBackingStoreClient() { } + virtual void tiledBackingStorePaintBegin() = 0; + virtual void tiledBackingStorePaint(GraphicsContext*, const IntRect&) = 0; + virtual void tiledBackingStorePaintEnd(const Vector& paintedArea) = 0; +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0020-webkit-disable-the-fuse-ld-gold-flag.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0020-webkit-disable-the-fuse-ld-gold-flag.patch new file mode 100644 index 0000000000..92eddebaec --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0020-webkit-disable-the-fuse-ld-gold-flag.patch @@ -0,0 +1,41 @@ +From d90b496f9ffdc828928ef84afad43260ea67ec1f Mon Sep 17 00:00:00 2001 +From: Ken Werner +Date: Wed, 26 Sep 2012 20:55:21 +0200 +Subject: [PATCH 20/21] webkit: disable the -fuse-ld=gold flag + +This option is a Debian/Ubuntu specific extension to the g++ and causes upstream GCC to throw an error. + +Upstream-Status: Pending + +Signed-off-by: Ken Werner +Signed-off-by: Martin Jansa +--- + src/3rdparty/webkit/Source/common.pri | 12 ++++++------ + 1 file changed, 6 insertions(+), 6 deletions(-) + +diff --git a/src/3rdparty/webkit/Source/common.pri b/src/3rdparty/webkit/Source/common.pri +index 0f62e14..d81a1f0 100644 +--- a/src/3rdparty/webkit/Source/common.pri ++++ b/src/3rdparty/webkit/Source/common.pri +@@ -3,12 +3,12 @@ + contains(JAVASCRIPTCORE_JIT,yes): DEFINES+=ENABLE_JIT=1 + contains(JAVASCRIPTCORE_JIT,no): DEFINES+=ENABLE_JIT=0 + +-linux-g++ { +-isEmpty($$(SBOX_DPKG_INST_ARCH)):exists(/usr/bin/ld.gold) { +- message(Using gold linker) +- QMAKE_LFLAGS+=-fuse-ld=gold +-} +-} ++#linux-g++ { ++#isEmpty($$(SBOX_DPKG_INST_ARCH)):exists(/usr/bin/ld.gold) { ++# message(Using gold linker) ++# QMAKE_LFLAGS+=-fuse-ld=gold ++#} ++#} + + # We use this flag on production branches + # See https://bugs.webkit.org/show_bug.cgi?id=60824 +-- +1.8.0 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0021-configure-make-qt4-native-work-with-long-building-pa.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0021-configure-make-qt4-native-work-with-long-building-pa.patch new file mode 100644 index 0000000000..dbc90227a5 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0021-configure-make-qt4-native-work-with-long-building-pa.patch @@ -0,0 +1,95 @@ +From 6742ac7ea6fd1e9c82ecb5305f84e721242f857d Mon Sep 17 00:00:00 2001 +From: Chen Qi +Date: Wed, 5 Dec 2012 07:48:15 +0200 +Subject: [PATCH 21/21] configure: make qt4-native work with long building + path. + +Upstream-Status: Submitted + +Reference: https://bugreports.qt-project.org/browse/QTBUG-28292 + +Signed-off-by: Chen Qi +Signed-off-by: Martin Jansa +--- + configure | 52 ++++++++++++++++++++++++++-------------------------- + 1 file changed, 26 insertions(+), 26 deletions(-) + +diff --git a/configure b/configure +index a4a42f1..2358563 100755 +--- a/configure ++++ b/configure +@@ -4779,8 +4779,8 @@ DEMOS_PATH_STR=`"$relpath/config.tests/unix/padstring" 268 "qt_demopath=$QT_INST + TODAY=`date +%Y-%m-%d` + cat > "$outpath/src/corelib/global/qconfig.cpp.new" <> "$outpath/src/corelib/global/qconfig.cpp.new" < +Date: Thu, 4 Jul 2013 16:20:40 +1000 +Subject: [PATCH] Fix drawing of 0-width polylines from outside the devicerect. + +This was broken by a previous fix which aimed to fix gaps in +polylines with tiny line segments. The result was that we +skipped updating the origin point when stroke() didn't produce +pixels which accidentally included the case of the line +being completely outside the deviceRect. I fixed this +by returning the value of clipLine in drawLine to the caller +so we could still update the origin for this case. + +Upstream-Status: Accepted [https://codereview.qt-project.org/#change,60427] +Signed-off-by: Jonathan Liu + +Task-number: QTBUG-31579 +Change-Id: Iac29436f042da7658bbeaf9370351dc6f2c95065 +(cherry picked from qtbase/900cccfd459fcbdbc4aa3d313afe12cfbf68fd87) +--- + src/gui/painting/qcosmeticstroker.cpp | 42 ++++++++++++++++++++++------------- + src/gui/painting/qcosmeticstroker_p.h | 2 +- + 2 files changed, 27 insertions(+), 17 deletions(-) + +diff --git a/src/gui/painting/qcosmeticstroker.cpp b/src/gui/painting/qcosmeticstroker.cpp +index 0061ecb..4413170 100644 +--- a/src/gui/painting/qcosmeticstroker.cpp ++++ b/src/gui/painting/qcosmeticstroker.cpp +@@ -133,10 +133,15 @@ struct NoDasher { + + }; + ++/* ++ * The return value is the result of the clipLine() call performed at the start ++ * of each of the two functions, aka "false" means completely outside the devices ++ * rect. ++ */ + template +-static void drawLine(QCosmeticStroker *stroker, qreal x1, qreal y1, qreal x2, qreal y2, int caps); ++static bool drawLine(QCosmeticStroker *stroker, qreal x1, qreal y1, qreal x2, qreal y2, int caps); + template +-static void drawLineAA(QCosmeticStroker *stroker, qreal x1, qreal y1, qreal x2, qreal y2, int caps); ++static bool drawLineAA(QCosmeticStroker *stroker, qreal x1, qreal y1, qreal x2, qreal y2, int caps); + + inline void drawPixel(QCosmeticStroker *stroker, int x, int y, int coverage) + { +@@ -602,17 +607,20 @@ void QCosmeticStroker::drawPath(const QVectorPath &path) + caps |= CapEnd; + + QCosmeticStroker::Point last = this->lastPixel; +- stroke(this, p.x(), p.y(), p2.x(), p2.y(), caps); ++ bool unclipped = stroke(this, p.x(), p.y(), p2.x(), p2.y(), caps); + + /* fix for gaps in polylines with fastpen and aliased in a sequence + of points with small distances: if current point p2 has been dropped +- out, keep last non dropped point p. */ +- if (fastPenAliased) { +- if (last.x != lastPixel.x || last.y != lastPixel.y || +- points == begin + 2 || points == end - 2 ) { +- { +- p = p2; +- } ++ out, keep last non dropped point p. ++ ++ However, if the line was completely outside the devicerect, we ++ still need to update p to avoid drawing the line after this one from ++ a bad starting position. ++ */ ++ if (fastPenAliased && unclipped) { ++ if (last.x != lastPixel.x || last.y != lastPixel.y ++ || points == begin + 2 || points == end - 2) { ++ p = p2; + } + } else { + p = p2; +@@ -720,10 +728,10 @@ static inline void capAdjust(int caps, int &x1, int &x2, int &y, int yinc) + the drawing shifts from horizontal to vertical or back. + */ + template +-static void drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2, qreal ry2, int caps) ++static bool drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2, qreal ry2, int caps) + { + if (stroker->clipLine(rx1, ry1, rx2, ry2)) +- return; ++ return false; + + static const int half = 31; + int x1 = toF26Dot6(rx1) + half; +@@ -813,7 +821,7 @@ static void drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2, + } else { + // horizontal + if (!dx) +- return; ++ return true; + + QCosmeticStroker::Direction dir = QCosmeticStroker::LeftToRight; + +@@ -886,14 +894,15 @@ static void drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2, + } + } + stroker->lastPixel = last; ++ return true; + } + + + template +-static void drawLineAA(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2, qreal ry2, int caps) ++static bool drawLineAA(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2, qreal ry2, int caps) + { + if (stroker->clipLine(rx1, ry1, rx2, ry2)) +- return; ++ return false; + + int x1 = toF26Dot6(rx1); + int y1 = toF26Dot6(ry1); +@@ -967,7 +976,7 @@ static void drawLineAA(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx + } else { + // horizontal + if (!dx) +- return; ++ return true; + + int yinc = F16Dot16FixedDiv(dy, dx); + +@@ -1029,6 +1038,7 @@ static void drawLineAA(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx + drawPixel(stroker, x, (y>>16) + 1, alpha * alphaEnd >> 6); + } + } ++ return true; + } + + QT_END_NAMESPACE +diff --git a/src/gui/painting/qcosmeticstroker_p.h b/src/gui/painting/qcosmeticstroker_p.h +index 870738b..3216856 100644 +--- a/src/gui/painting/qcosmeticstroker_p.h ++++ b/src/gui/painting/qcosmeticstroker_p.h +@@ -56,7 +56,7 @@ QT_MODULE(Gui) + class QCosmeticStroker; + + +-typedef void (*StrokeLine)(QCosmeticStroker *stroker, qreal x1, qreal y1, qreal x2, qreal y2, int caps); ++typedef bool (*StrokeLine)(QCosmeticStroker *stroker, qreal x1, qreal y1, qreal x2, qreal y2, int caps); + + class QCosmeticStroker + { +-- +1.8.3.2 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0023-QHttpMultiPart-fix-data-corruption-in-readData-metho.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0023-QHttpMultiPart-fix-data-corruption-in-readData-metho.patch new file mode 100644 index 0000000000..c3c002e8a1 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0023-QHttpMultiPart-fix-data-corruption-in-readData-metho.patch @@ -0,0 +1,43 @@ +From 1f40ed553e618c3b0511c7db4b4fd26c2d2b65bf Mon Sep 17 00:00:00 2001 +From: Peter Hartmann +Date: Thu, 25 Jul 2013 12:05:29 -0400 +Subject: [PATCH] QHttpMultiPart: fix data corruption in readData method + +When readData() is called repeatedly, we need to keep track which +part of the multipart message we are currently reading from. +Hereby we also need to take the boundary size into account, and not +only the size of the multipart; otherwise we would skip a not +completely read part. This would then later lead to advancing the +read pointer by negative indexes and data loss. + +Upstream-Status: Accepted [https://codereview.qt-project.org/#change,61861] +Signed-off-by: Jonathan Liu + +Task-number: QTBUG-32534 +Change-Id: Ibb6dff16adaf4ea67181d23d1d0c8459e33a0ed0 +Reviewed-by: Jonathan Liu +Reviewed-by: Shane Kearns +(cherry picked from qtbase/af96c6fed931564c95037539f07e9c8e33c69529) +Reviewed-by: Thiago Macieira +--- + src/network/access/qhttpmultipart.cpp | 3 +- + tests/auto/qnetworkreply/tst_qnetworkreply.cpp | 44 ++++++++++++++++++++++++++ + 2 files changed, 46 insertions(+), 1 deletion(-) + +diff --git a/src/network/access/qhttpmultipart.cpp b/src/network/access/qhttpmultipart.cpp +index 635129a..b25e917 100644 +--- a/src/network/access/qhttpmultipart.cpp ++++ b/src/network/access/qhttpmultipart.cpp +@@ -488,7 +488,8 @@ qint64 QHttpMultiPartIODevice::readData(char *data, qint64 maxSize) + + // skip the parts we have already read + while (index < multiPart->parts.count() && +- readPointer >= partOffsets.at(index) + multiPart->parts.at(index).d->size()) ++ readPointer >= partOffsets.at(index) + multiPart->parts.at(index).d->size() ++ + multiPart->boundary.count() + 6) // 6 == 2 boundary dashes, \r\n after boundary, \r\n after multipart + index++; + + // read the data +-- +1.8.3.4 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0024-Ensure-lastPixel.y-is-also-initalized-to-1-when-nece.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0024-Ensure-lastPixel.y-is-also-initalized-to-1-when-nece.patch new file mode 100644 index 0000000000..7825205310 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0024-Ensure-lastPixel.y-is-also-initalized-to-1-when-nece.patch @@ -0,0 +1,48 @@ +From 0726127285413829f58618b5b82fb3e2da0c3a74 Mon Sep 17 00:00:00 2001 +From: Andy Shaw +Date: Tue, 8 Oct 2013 15:45:42 +0200 +Subject: [PATCH] Ensure lastPixel.y is also initalized to -1 when necessary + +Task-number: QTBUG-31579 + +Upstream-Status: Accepted [https://codereview.qt-project.org/#change,67624] +Signed-off-by: Jonathan Liu + +Change-Id: Ia4916ac0d384ea523bbfad0dafbc90044da7ec3e +Reviewed-by: Gunnar Sletta +(cherry picked from qtbase/f0b950144dde85b65df0c3cf83f7c8df0e94bbbf) +--- + src/gui/painting/qcosmeticstroker.cpp | 3 +++ + 1 file changed, 3 insertions(+) + +diff --git a/src/gui/painting/qcosmeticstroker.cpp b/src/gui/painting/qcosmeticstroker.cpp +index 4413170..36616d4 100644 +--- a/src/gui/painting/qcosmeticstroker.cpp ++++ b/src/gui/painting/qcosmeticstroker.cpp +@@ -305,6 +305,7 @@ void QCosmeticStroker::setup() + ymax = deviceRect.bottom() + 2; + + lastPixel.x = -1; ++ lastPixel.y = -1; + } + + // returns true if the whole line gets clipped away +@@ -533,6 +534,7 @@ void QCosmeticStroker::drawPath(const QVectorPath &path) + QPointF p = QPointF(points[0], points[1]) * state->matrix; + patternOffset = state->lastPen.dashOffset()*64; + lastPixel.x = -1; ++ lastPixel.y = -1; + + bool closed; + const QPainterPath::ElementType *e = subPath(type, end, points, &closed); +@@ -587,6 +589,7 @@ void QCosmeticStroker::drawPath(const QVectorPath &path) + QPointF movedTo = p; + patternOffset = state->lastPen.dashOffset()*64; + lastPixel.x = -1; ++ lastPixel.y = -1; + + const qreal *begin = points; + const qreal *end = points + 2*path.elementCount(); +-- +1.8.4 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0025-Fix-misaligned-selection-region-with-text-when-cente.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0025-Fix-misaligned-selection-region-with-text-when-cente.patch new file mode 100644 index 0000000000..964bcf8efb --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0025-Fix-misaligned-selection-region-with-text-when-cente.patch @@ -0,0 +1,75 @@ +From c368cbad3a505d44894ff150dc25c74d0174ca15 Mon Sep 17 00:00:00 2001 +From: Jonathan Liu +Date: Wed, 23 Oct 2013 00:28:17 +1100 +Subject: [PATCH] Fix misaligned selection region with text when centered + +If the text is centered, the x/y position in the selection QRectF may +be a multiple of 0.5 which is rounded up. This rounding causes +misalignment of the selection region with the text. + +The alignment is fixed by using qFloor on the x and y components. + +Upstream-Status: Accepted [https://codereview.qt-project.org/#change,68935] +Signed-off-by: Jonathan Liu + +Task-number: QTBUG-34218 +Task-number: QTBUG-34234 +Change-Id: I4f2fadeb38602f62a93773c6e5faecf03b28069f +Reviewed-by: Gunnar Sletta +(cherry picked from qtbase/5d8a882c11201a29475c5ea71cfb76c9de6573f5) +--- + src/gui/text/qtextlayout.cpp | 19 ++++++++++++++----- + 1 file changed, 14 insertions(+), 5 deletions(-) + +diff --git a/src/gui/text/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp +index 3d340cb..8d652ea 100644 +--- a/src/gui/text/qtextlayout.cpp ++++ b/src/gui/text/qtextlayout.cpp +@@ -44,6 +44,7 @@ + + #include + #include ++#include + #include + #include + #include +@@ -979,15 +980,23 @@ static void addSelectedRegionsToPath(QTextEngine *eng, int lineNumber, const QPo + continue; + } + +- if (lastSelectionWidth > 0) +- region->addRect(boundingRect & QRectF(lastSelectionX.toReal(), selectionY, lastSelectionWidth.toReal(), lineHeight)); ++ if (lastSelectionWidth > 0) { ++ QRectF rect = boundingRect & QRectF(lastSelectionX.toReal(), selectionY, lastSelectionWidth.toReal(), lineHeight); ++ rect.moveLeft(qFloor(rect.left())); ++ rect.moveTop(qFloor(rect.top())); ++ region->addRect(rect); ++ } + + lastSelectionX = selectionX; + lastSelectionWidth = selectionWidth; + } + } +- if (lastSelectionWidth > 0) +- region->addRect(boundingRect & QRectF(lastSelectionX.toReal(), selectionY, lastSelectionWidth.toReal(), lineHeight)); ++ if (lastSelectionWidth > 0) { ++ QRectF rect = boundingRect & QRectF(lastSelectionX.toReal(), selectionY, lastSelectionWidth.toReal(), lineHeight); ++ rect.moveLeft(qFloor(rect.left())); ++ rect.moveTop(qFloor(rect.top())); ++ region->addRect(rect); ++ } + } + + static inline QRectF clipIfValid(const QRectF &rect, const QRectF &clip) +@@ -2081,7 +2090,7 @@ static void setPenAndDrawBackground(QPainter *p, const QPen &defaultPen, const Q + + QBrush bg = chf.background(); + if (bg.style() != Qt::NoBrush && !chf.property(SuppressBackground).toBool()) +- p->fillRect(r, bg); ++ p->fillRect(QRectF(qFloor(r.x()), qFloor(r.y()), r.width(), r.height()), bg); + if (c.style() != Qt::NoBrush) { + p->setPen(QPen(c, 0)); + } +-- +1.8.4 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/0027-tools.pro-disable-qmeegographicssystemhelper.patch b/meta/recipes-qt/qt4/qt4-4.8.5/0027-tools.pro-disable-qmeegographicssystemhelper.patch new file mode 100644 index 0000000000..6e30aeed02 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/0027-tools.pro-disable-qmeegographicssystemhelper.patch @@ -0,0 +1,28 @@ +From 0460e2a5f13aaf0081c3c9fec89280046842ddbb Mon Sep 17 00:00:00 2001 +From: Paul Eggleton +Date: Wed, 3 Jul 2013 17:48:30 +0100 +Subject: [PATCH] tools.pro: disable qmeegographicssystemhelper + +We don't want this enabled just because we have EGL and OpenGL ES 2.0 +enabled. + +Upstream-Status: Inappropriate [config] + +Signed-off-by: Paul Eggleton +--- + tools/tools.pro | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/tools/tools.pro b/tools/tools.pro +index 0e27053..2d3f36d 100644 +--- a/tools/tools.pro ++++ b/tools/tools.pro +@@ -49,4 +49,4 @@ QTDIR_build:REQUIRES = "contains(QT_CONFIG, full-config)" + + !win32:!embedded:!mac:!symbian:CONFIG += x11 + +-x11:contains(QT_CONFIG, opengles2):contains(QT_CONFIG, egl):SUBDIRS += qmeegographicssystemhelper ++#x11:contains(QT_CONFIG, opengles2):contains(QT_CONFIG, egl):SUBDIRS += qmeegographicssystemhelper +-- +1.8.1.2 + diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/g++.conf b/meta/recipes-qt/qt4/qt4-4.8.5/g++.conf new file mode 100644 index 0000000000..8755031017 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/g++.conf @@ -0,0 +1,61 @@ +# +# qmake configuration for common gcc +# + +QMAKE_COMPILER = gcc + +QMAKE_CC = $(OE_QMAKE_CC) +QMAKE_CFLAGS += -pipe $(OE_QMAKE_CFLAGS) +QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += $(OE_QMAKE_CFLAGS) +QMAKE_CFLAGS_DEPS += -M +QMAKE_CFLAGS_WARN_ON += -Wall -W +QMAKE_CFLAGS_WARN_OFF += -w +QMAKE_CFLAGS_RELEASE += +QMAKE_CFLAGS_DEBUG += -g +QMAKE_CFLAGS_SHLIB += -fPIC +QMAKE_CFLAGS_STATIC_LIB += -fPIC +QMAKE_CFLAGS_YACC += -Wno-unused -Wno-parentheses +QMAKE_CFLAGS_HIDESYMS += -fvisibility=hidden +QMAKE_CFLAGS_PRECOMPILE += -x c-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT} +QMAKE_CFLAGS_USE_PRECOMPILE += -include ${QMAKE_PCH_OUTPUT_BASE} + +QMAKE_CXX = $(OE_QMAKE_CXX) +QMAKE_CXXFLAGS += $$QMAKE_CFLAGS $(OE_QMAKE_CXXFLAGS) +QMAKE_CXXFLAGS_DEPS += $$QMAKE_CFLAGS_DEPS +QMAKE_CXXFLAGS_WARN_ON += $$QMAKE_CFLAGS_WARN_ON +QMAKE_CXXFLAGS_WARN_OFF += $$QMAKE_CFLAGS_WARN_OFF +QMAKE_CXXFLAGS_RELEASE += $$QMAKE_CFLAGS_RELEASE +QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO +QMAKE_CXXFLAGS_DEBUG += $$QMAKE_CFLAGS_DEBUG +QMAKE_CXXFLAGS_SHLIB += $$QMAKE_CFLAGS_SHLIB +QMAKE_CXXFLAGS_STATIC_LIB += $$QMAKE_CFLAGS_STATIC_LIB +QMAKE_CXXFLAGS_YACC += $$QMAKE_CFLAGS_YACC +QMAKE_CXXFLAGS_HIDESYMS += $$QMAKE_CFLAGS_HIDESYMS -fvisibility-inlines-hidden +QMAKE_CXXFLAGS_PRECOMPILE += -x c++-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT} +QMAKE_CXXFLAGS_USE_PRECOMPILE = $$QMAKE_CFLAGS_USE_PRECOMPILE + +QMAKE_LINK = $(OE_QMAKE_LINK) +QMAKE_LINK_SHLIB = $(OE_QMAKE_LINK) +QMAKE_LINK_C = $(OE_QMAKE_LINK) +QMAKE_LINK_C_SHLIB = $(OE_QMAKE_LINK) +QMAKE_LFLAGS += $(OE_QMAKE_LDFLAGS) +QMAKE_LFLAGS_RELEASE += +QMAKE_LFLAGS_DEBUG += +QMAKE_LFLAGS_APP += +QMAKE_LFLAGS_NOUNDEF += -Wl,--no-undefined +QMAKE_LFLAGS_RPATH = -Wl,-rpath-link, + +QMAKE_PCH_OUTPUT_EXT = .gch + +# -Bsymbolic-functions (ld) support +QMAKE_LFLAGS_BSYMBOLIC_FUNC = -Wl,-Bsymbolic-functions +QMAKE_LFLAGS_DYNAMIC_LIST = -Wl,--dynamic-list, + +# do not depend on gdb +CONFIG -= gdb_dwarf_index + +# some linking helper... +CONFIG += rpath_libdirs + +# for the SDK +isEmpty(QMAKE_QT_CONFIG):QMAKE_QT_CONFIG = $(OE_QMAKE_QT_CONFIG) diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/linux.conf b/meta/recipes-qt/qt4/qt4-4.8.5/linux.conf new file mode 100644 index 0000000000..86703813ca --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/linux.conf @@ -0,0 +1,66 @@ +# +# qmake configuration for common linux +# + +QMAKE_CFLAGS_THREAD += -D_REENTRANT +QMAKE_CXXFLAGS_THREAD += $$QMAKE_CFLAGS_THREAD + +QMAKE_INCDIR = +QMAKE_LIBDIR = +QMAKE_INCDIR_X11 = +QMAKE_LIBDIR_X11 = +QMAKE_INCDIR_QT = $(OE_QMAKE_INCDIR_QT) +QMAKE_LIBDIR_QT = $(OE_QMAKE_LIBDIR_QT) +QMAKE_INCDIR_OPENGL = +QMAKE_LIBDIR_OPENGL = +QMAKE_INCDIR_OPENGL_ES1 = $$QMAKE_INCDIR_OPENGL +QMAKE_LIBDIR_OPENGL_ES1 = $$QMAKE_LIBDIR_OPENGL +QMAKE_INCDIR_OPENGL_ES2 = $$QMAKE_INCDIR_OPENGL +QMAKE_LIBDIR_OPENGL_ES2 = $$QMAKE_LIBDIR_OPENGL +QMAKE_INCDIR_EGL = +QMAKE_LIBDIR_EGL = +QMAKE_INCDIR_OPENVG = +QMAKE_LIBDIR_OPENVG = + + +QMAKE_LIBS = +QMAKE_LIBS_DYNLOAD = -ldl +QMAKE_LIBS_X11 = $(OE_QMAKE_LIBS_X11) +QMAKE_LIBS_X11SM = $(OE_QMAKE_LIBS_X11SM) +QMAKE_LIBS_NIS = -lnsl +QMAKE_LIBS_EGL = -lEGL +QMAKE_LIBS_OPENGL = -lGL +QMAKE_LIBS_OPENGL_QT = -lGL +QMAKE_LIBS_OPENGL_ES1 = -lGLES_CM +QMAKE_LIBS_OPENGL_ES2 = -lGLESv2 +QMAKE_LIBS_OPENVG = -lOpenVG +QMAKE_LIBS_THREAD = -lpthread + +QMAKE_MOC = $(OE_QMAKE_MOC) +QMAKE_UIC = $(OE_QMAKE_UIC) +QMAKE_UIC3 = $(OE_QMAKE_UIC3) +QMAKE_RCC = $(OE_QMAKE_RCC) +QMAKE_QDBUSCPP2XML = $(OE_QMAKE_QDBUSCPP2XML) +QMAKE_QDBUSXML2CPP = $(OE_QMAKE_QDBUSXML2CPP) + +QMAKE_AR = $(OE_QMAKE_AR) cqs +QMAKE_OBJCOPY = objcopy +QMAKE_RANLIB = + +QMAKE_TAR = tar -cf +QMAKE_GZIP = gzip -9f + +QMAKE_COPY = cp -f +QMAKE_COPY_FILE = $(COPY) +QMAKE_COPY_DIR = $(COPY) -r +QMAKE_MOVE = mv -f +QMAKE_DEL_FILE = rm -f +QMAKE_DEL_DIR = rmdir +QMAKE_STRIP = $(OE_QMAKE_STRIP) +QMAKE_STRIPFLAGS_LIB += --strip-unneeded +QMAKE_CHK_DIR_EXISTS = test -d +QMAKE_MKDIR = mkdir -p +QMAKE_INSTALL_FILE = install -m 644 -p +QMAKE_INSTALL_PROGRAM = install -m 755 -p + +include(unix.conf) diff --git a/meta/recipes-qt/qt4/qt4-4.8.5/qte.sh b/meta/recipes-qt/qt4/qt4-4.8.5/qte.sh new file mode 100644 index 0000000000..21d6ecbd6a --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-4.8.5/qte.sh @@ -0,0 +1,7 @@ +#!/bin/sh + +if [ -e /dev/input/touchscreen0 ] +then + QWS_MOUSE_PROTO=Tslib:/dev/input/touchscreen0 + export QWS_MOUSE_PROTO +fi diff --git a/meta/recipes-qt/qt4/qt4-embedded.inc b/meta/recipes-qt/qt4/qt4-embedded.inc new file mode 100644 index 0000000000..e87de4b379 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-embedded.inc @@ -0,0 +1,73 @@ +SUMMARY = "Cross-platform UI toolkit and application framework (framebuffer version)" +DESCRIPTION = "Qt is a versatile cross-platform application framework -- this is the embedded (framebuffer) version." +SECTION = "libs" +HOMEPAGE = "http://qt-project.org/" +DEPENDS += "directfb tslib" +INC_PR = "r52" + +QT4EDEPENDS = "" +QT_BASE_LIB ?= "libqt-embedded" + +# Set necessary variables in the profile +SRC_URI += "file://qte.sh" + +QT_EMBEDDED_FLAGS ?= " \ + -embedded $QT_ARCH \ + -qtlibinfix ${QT_LIBINFIX} \ +" +QT_EMBEDDED_EXTRA_FLAGS ?= " \ + -plugin-gfx-transformed -plugin-gfx-qvfb -plugin-gfx-vnc -plugin-gfx-directfb \ + -plugin-mouse-tslib -qt-mouse-pc -qt-mouse-qvfb -qt-mouse-linuxinput \ + -qt-kbd-tty -qt-kbd-linuxinput \ +" +QT_EMBEDDED_KEYPAD_FLAGS ?= " \ + -DQT_KEYPAD_NAVIGATION \ +" + +QT_CONFIG_FLAGS += "${QT_EMBEDDED_FLAGS} ${QT_EMBEDDED_EXTRA_FLAGS} ${QT_EMBEDDED_KEYPAD_FLAGS}" + +require qt4.inc + +do_install_append() { + install -d ${D}/${libdir}/fonts + touch ${D}/${libdir}/fonts/fontdir + + install -d ${D}${sysconfdir}/profile.d/ + install -m 0755 ${WORKDIR}/qte.sh ${D}${sysconfdir}/profile.d/ +} + +# We put the qte profile into it's own package as we don't want to install all qt stuff +# with depending on the global package qt4-embedded +PACKAGES += " ${PN}-conf" +FILES_${PN}-conf += " ${sysconfdir}/profile.d/qte.sh" +RRECOMMENDS_${PN} += " ${PN}-conf" + +OTHER_PACKAGES += "\ + ${QT_BASE_NAME}-fonts \ + ${QT_BASE_NAME}-fonts-ttf-vera \ + ${QT_BASE_NAME}-fonts-ttf-dejavu \ + ${QT_BASE_NAME}-fonts-pfa \ + ${QT_BASE_NAME}-fonts-pfb \ + ${QT_BASE_NAME}-fonts-qpf" + +RRECOMMENDS_${QT_BASE_NAME}-fonts = " \ + ${QT_BASE_NAME}-fonts-ttf-vera \ + ${QT_BASE_NAME}-fonts-ttf-dejavu \ + ${QT_BASE_NAME}-fonts-pfa \ + ${QT_BASE_NAME}-fonts-pfb \ + ${QT_BASE_NAME}-fonts-qpf" +RRECOMMENDS_${QT_BASE_NAME}-demos += " \ + ${QT_BASE_NAME}-fonts" + +ALLOW_EMPTY_${QT_BASE_NAME}-fonts = "1" +PACKAGES_DYNAMIC += "^${QT_BASE_NAME}-fonts-.*" + +FILES_${QT_BASE_NAME}-fonts-ttf-vera = "${libdir}/fonts/Vera*.ttf" +FILES_${QT_BASE_NAME}-fonts-ttf-dejavu = "${libdir}/fonts/DejaVu*.ttf" +FILES_${QT_BASE_NAME}-fonts-pfa = "${libdir}/fonts/*.pfa" +FILES_${QT_BASE_NAME}-fonts-pfb = "${libdir}/fonts/*.pfb" +FILES_${QT_BASE_NAME}-fonts-qpf = "${libdir}/fonts/*.qpf*" +FILES_${QT_BASE_NAME}-fonts = "${libdir}/fonts/README ${libdir}/fonts/fontdir" + +inherit qt4e + diff --git a/meta/recipes-qt/qt4/qt4-embedded_4.8.5.bb b/meta/recipes-qt/qt4/qt4-embedded_4.8.5.bb new file mode 100644 index 0000000000..1435d857ce --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-embedded_4.8.5.bb @@ -0,0 +1,9 @@ +require qt4-${PV}.inc +require qt4-embedded.inc + +QT_CONFIG_FLAGS_append_arm = "${@bb.utils.contains("TUNE_FEATURES", "neon", "", " -no-neon" ,d)}" + +QT_CONFIG_FLAGS += " \ + -exceptions \ +" + diff --git a/meta/recipes-qt/qt4/qt4-native.inc b/meta/recipes-qt/qt4/qt4-native.inc new file mode 100644 index 0000000000..bb16da666a --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-native.inc @@ -0,0 +1,114 @@ +SUMMARY = "Qt version 4 tools and support files for the build host" +DEPENDS = "zlib-native dbus-native" +SECTION = "libs" +HOMEPAGE = "http://qt-project.org/" +PROVIDES = "qt4-tools-native" + +LICENSE = "LGPLv2.1 | GPLv3" +LIC_FILES_CHKSUM = "file://LICENSE.LGPL;md5=fbc093901857fcd118f065f900982c24 \ + file://LICENSE.GPL3;md5=6e1694ee338db410417517884918d4d2 \ + file://LGPL_EXCEPTION.txt;md5=0145c4d1b6f96a661c2c139dfb268fb6" + +INC_PR = "r20" + +inherit native + +SRC_URI = "http://download.qt-project.org/official_releases/qt/4.8/${PV}/qt-everywhere-opensource-src-${PV}.tar.gz \ + file://0001-qlibraryinfo-allow-to-set-qt.conf-from-the-outside-u.patch \ + file://0002-qkbdtty_qws-fix-build-with-old-kernel-headers.patch \ + file://0003-webkit2-set-OUTPUT_DIR-value-if-empty.patch \ + file://0021-configure-make-qt4-native-work-with-long-building-pa.patch \ + file://g++.conf \ + file://linux.conf \ + " +S = "${WORKDIR}/qt-everywhere-opensource-src-${PV}" + +EXTRA_OECONF = "-prefix ${prefix} \ + -bindir ${bindir} \ + -libdir ${libdir} \ + -datadir ${datadir}/qt4 \ + -sysconfdir ${sysconfdir}/qt4 \ + -docdir ${docdir}/qt4 \ + -headerdir ${includedir}/qt4 \ + -plugindir ${libdir}/qt4/plugins \ + -importdir ${libdir}/qt4/imports \ + -translationdir ${datadir}/qt4/translations \ + -examplesdir ${bindir}/qt4/examples \ + -demosdir ${bindir}/qt4/demos \ + -L ${STAGING_LIBDIR_NATIVE} \ + -I ${STAGING_INCDIR_NATIVE} \ + -qt-libjpeg -system-zlib \ + -no-libjpeg -no-libpng -no-libmng -no-libtiff \ + -no-accessibility \ + -no-cups \ + -no-nas-sound \ + -no-nis -no-openssl \ + -verbose -release \ + -embedded -no-freetype -no-glib -no-iconv \ + -exceptions -xmlpatterns \ + -qt3support \ + -no-fast -silent -no-rpath" + +# yank default -e, otherwise we get the following error: +# moc_qbuffer.cpp: No such file or directory +EXTRA_OEMAKE = " " + +do_configure() { + # Avoid problems with Qt 4.8.0 configure setting QMAKE_LINK from LD (since we want the linker to be g++) + unset LD + + (echo o; echo yes) | ./configure ${EXTRA_OECONF} || die "Configuring qt failed. EXTRA_OECONF was ${EXTRA_OECONF}" +} + +TOBUILD = "\ + src/tools/moc \ + src/corelib \ + src/sql \ + src/xml \ + src/network \ + src/tools/uic \ + src/tools/rcc \ + src/xmlpatterns \ + src/dbus \ + src/gui \ + src/testlib \ + src/qt3support \ + src/tools/uic3 \ + tools/linguist/lconvert \ + tools/linguist/lrelease \ + tools/linguist/lupdate \ + tools/qdbus/qdbuscpp2xml \ + tools/qdbus/qdbusxml2cpp \ + tools/xmlpatterns \ +" + +do_compile() { + for i in ${TOBUILD}; do + cd ${S}/$i && oe_runmake CC="${CC}" CXX="${CXX}" + done +} + +do_install() { + install -d ${D}${bindir}/ + install -m 0755 bin/qmake ${D}${bindir}/qmake2 + for i in moc uic uic3 rcc lconvert lrelease lupdate qdbuscpp2xml qdbusxml2cpp xmlpatterns; do + install -m 0755 bin/${i} ${D}${bindir}/${i}4 + done + + install -d ${D}${datadir}/qt4/ + cp -PfR mkspecs ${D}${datadir}/qt4/ + ln -sf linux-g++ ${D}${datadir}/qt4/mkspecs/${BUILD_OS}-oe-g++ + if [ -f ${D}${datadir}/qt4/mkspecs/common/g++-unix.conf ] ; then + # mkspecs were refactored for 4.8.0 + cp -f ${WORKDIR}/g++.conf ${D}${datadir}/qt4/mkspecs/common/g++-unix.conf + else + cp -f ${WORKDIR}/g++.conf ${D}${datadir}/qt4/mkspecs/common/g++.conf + fi + cp -f ${WORKDIR}/linux.conf ${D}${datadir}/qt4/mkspecs/common/ + + install -m 0644 tools/porting/src/q3porting.xml ${D}${datadir}/qt4/ + + for i in ${TOBUILD}; do + cd ${S}/$i && oe_runmake install INSTALL_ROOT=${D} + done +} diff --git a/meta/recipes-qt/qt4/qt4-native_4.8.5.bb b/meta/recipes-qt/qt4/qt4-native_4.8.5.bb new file mode 100644 index 0000000000..2443cc4b10 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-native_4.8.5.bb @@ -0,0 +1,6 @@ +require qt4-native.inc + +TOBUILD := "src/tools/bootstrap ${TOBUILD}" + +SRC_URI[md5sum] = "1864987bdbb2f58f8ae8b350dfdbe133" +SRC_URI[sha256sum] = "eb728f8268831dc4373be6403b7dd5d5dde03c169ad6882f9a8cb560df6aa138" diff --git a/meta/recipes-qt/qt4/qt4-x11-free.inc b/meta/recipes-qt/qt4/qt4-x11-free.inc new file mode 100644 index 0000000000..73ed2bcbd9 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-x11-free.inc @@ -0,0 +1,39 @@ +require qt4.inc + +SUMMARY = "Cross-platform UI toolkit and application framework (X11 version)" +DESCRIPTION = "Qt is a versatile cross-platform application framework -- this is the X11 version." +HOMEPAGE = "http://qt-project.org/" +SECTION = "x11/libs" +DEPENDS += "virtual/libgl virtual/libx11 fontconfig libxft libxext libxrender libxrandr libxcursor" +PROVIDES += "qt4-x11" +QT4DEPENDS = "" + +INC_PR = "r50" + +QT_GLFLAGS ?= "${@base_contains('DISTRO_FEATURES', 'opengl', '-opengl', '-no-opengl', d)} " +QT_GLFLAGS_qemux86 = "-opengl" +QT_GLFLAGS_qemuppc = "-opengl" +QT_X11_FLAGS ?= "-no-xinerama -no-xkb -no-gtkstyle" +QT_CONFIG_FLAGS += "${QT_X11_FLAGS}" +QT_BASE_LIB ?= "libqt" + +# required by kdelibs4 +QT_KDE_FLAGS ?= "-accessibility -sm" +QT_DISTRO_FLAGS ?= "${QT_KDE_FLAGS}" + +inherit qt4x11 + +do_install_append() { + # fix pkgconfig, libtool and prl files + sed -i -e 's#I/usr/include#Iincludedir}#g' \ + -e 's#Iin#I${in#g' \ + ${D}${libdir}/*.la ${D}${libdir}/*.prl ${D}${libdir}/pkgconfig/*.pc + + # QT abuses $includedir to point to its headers, which breaks pkgconfig sysroot, so + # manually fix it up here: + for pc in ${D}${libdir}/pkgconfig/*.pc ; do + sed -i -e "s:prefix}include/${QT_BASE_NAME}/$(basename $pc .pc):prefix}/include:" \ + -e "s,Cflags: ,Cflags: -IP{includedir}/${QT_BASE_NAME}/$(basename $pc .pc) ," \ + -e 's:IP{:I${:g' $pc + done +} diff --git a/meta/recipes-qt/qt4/qt4-x11-free_4.8.5.bb b/meta/recipes-qt/qt4/qt4-x11-free_4.8.5.bb new file mode 100644 index 0000000000..5cb5e6817d --- /dev/null +++ b/meta/recipes-qt/qt4/qt4-x11-free_4.8.5.bb @@ -0,0 +1,9 @@ +require qt4-x11-free.inc +require qt4-${PV}.inc + +QT_CONFIG_FLAGS_append_arm = "${@bb.utils.contains("TUNE_FEATURES", "neon", "", " -no-neon" ,d)}" + +QT_CONFIG_FLAGS += " \ + -no-embedded \ + -xrandr \ + -x11" diff --git a/meta/recipes-qt/qt4/qt4.inc b/meta/recipes-qt/qt4/qt4.inc new file mode 100644 index 0000000000..9a10138e94 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4.inc @@ -0,0 +1,393 @@ +inherit qmake_base + +DEPENDS += "qt4-tools-native freetype jpeg libpng zlib dbus openssl glib-2.0 gstreamer gst-plugins-base sqlite3 tiff icu" +DEPENDS += "${@base_contains('DISTRO_FEATURES', 'pulseaudio', 'pulseaudio', '', d)}" + +require qt4_arch.inc + +QT_DISTRO_FLAGS ?= "-no-accessibility -no-sm" +QT_DISTRO_FLAGS_linuxstdbase = "-sm" + +QT_SQL_DRIVER_FLAGS ?= "-no-sql-ibase -no-sql-mysql -no-sql-psql -no-sql-odbc -plugin-sql-sqlite -system-sqlite" + +QT_GLFLAGS ?= "" + + +QT_QT3SUPPORT ?= "-qt3support" +QT_XML ?= "-xmlpatterns" +QT_WEBKIT ?= "-webkit" +QT_PHONON ?= "-phonon" +QT_DBUS ?= "-qdbus" +QT_MULTIMEDIA ?= "${@base_contains('DISTRO_FEATURES', 'pulseaudio', '-pulseaudio', '-no-pulseaudio', d)}" + +QT_CONFIG_FLAGS += "-release -no-cups -reduce-relocations \ + -shared -no-nas-sound -no-nis \ + -system-libjpeg -system-libpng -system-libtiff -system-zlib \ + -no-pch -stl -glib -icu \ + -no-rpath -silent \ + ${QT_DBUS} \ + ${QT_QT3SUPPORT} \ + ${QT_WEBKIT} \ + ${QT_PHONON} \ + ${QT_XML} \ + ${QT_MULTIMEDIA} \ + ${QT_SQL_DRIVER_FLAGS} \ + ${QT_DISTRO_FLAGS} \ + ${QT_GLFLAGS}" + +EXTRA_OEMAKE = "-e" + +EXTRA_ENV = 'QMAKE="${STAGING_BINDIR_NATIVE}/qmake2 -after \ + INCPATH+=${STAGING_INCDIR}/freetype2 LIBS+=-L${STAGING_LIBDIR}" \ + QMAKESPEC="${QMAKESPEC}" LINK="${CXX} -Wl,-rpath-link,${STAGING_LIBDIR}" \ + AR="${TARGET_PREFIX}ar cqs" \ + MOC="${STAGING_BINDIR_NATIVE}/moc4" UIC="${STAGING_BINDIR_NATIVE}/uic4" MAKE="make -e"' + +export QT_CONF_PATH="${WORKDIR}/qt.conf" + +# Library packages +QT_LIB_NAMES = "Qt3Support QtAssistantClient QtCLucene QtCore QtDBus QtDesigner QtDesignerComponents QtGui QtHelp QtNetwork QtOpenGL QtScript QtScriptTools QtSql QtSvg QtTest QtUiTools QtWebKit QtXml QtXmlPatterns phonon QtMultimedia QtOpenVG QtMediaServices QtDeclarative" + +QT_EXTRA_LIBS = "pvrQWSWSEGL" + +python __anonymous () { + lib_packages = [] + dev_packages = [] + dbg_packages = [] + staticdev_packages = [] + for name in d.getVar("QT_LIB_NAMES", True).split(): + pkg = d.getVar("QT_BASE_LIB", True) + name.lower().replace("qt", "").replace("_", "-") + "4" + # NOTE: the headers for QtAssistantClient are different + incname = name.replace("QtAssistantClient", "QtAssistant") + d.setVar("FILES_%s" % pkg, "${libdir}/lib%(name)s${QT_LIBINFIX}.so.*" % locals()) + d.setVar("FILES_%s-dev" % pkg, """${libdir}/lib%(name)s${QT_LIBINFIX}.prl + ${libdir}/lib%(name)s${QT_LIBINFIX}.la + ${libdir}/lib%(name)s${QT_LIBINFIX}.so + ${includedir}/${QT_DIR_NAME}/%(incname)s + ${libdir}/pkgconfig/%(name)s${QT_LIBINFIX}.pc""" % locals()) + d.setVar("FILES_%s-staticdev" % pkg, "${libdir}/lib%(name)s${QT_LIBINFIX}.a" % locals()) + d.setVar("FILES_%s-dbg" % pkg, "${libdir}/.debug/lib%(name)s${QT_LIBINFIX}.so*" % locals()) + d.setVar("RRECOMMENDS_%s-dbg" % pkg, "${PN}-dbg") + lib_packages.append(pkg) + dev_packages.append("%s-dev" % pkg) + dbg_packages.append("%s-dbg" % pkg) + staticdev_packages.append("%s-staticdev" % pkg) + for name in d.getVar("OTHER_PACKAGES", True).split(): + dbg_packages.append("%s-dbg" % name) + staticdev_packages.append("%s-staticdev" % name) + + for name in d.getVar("QT_EXTRA_LIBS", True).split(): + pkg = d.getVar("QT_BASE_LIB", True) + name.lower().replace("qt", "").replace("_", "-") + "4" + d.setVar("FILES_%s" % pkg, "${libdir}/lib%(name)s.so.*" % locals()) + d.setVar("FILES_%s-staticdev" % pkg, "${libdir}/lib%(name)s.a" % locals()) + d.setVar("FILES_%s-dev" % pkg, """${libdir}/lib%(name)s.prl + ${libdir}/lib%(name)s.la + ${libdir}/lib%(name)s.so + ${includedir}/${QT_DIR_NAME}/%(incname)s + ${libdir}/pkgconfig/%(name)s.pc""" % locals()) + d.setVar("FILES_%s-dbg" % pkg, "${libdir}/.debug/lib%(name)s.so*" % locals()) + d.setVar("RRECOMMENDS_%s-dbg" % pkg, "${PN}-dbg") + lib_packages.append(pkg) + dev_packages.append("%s-dev" % pkg) + dbg_packages.append("%s-dbg" % pkg) + staticdev_packages.append("%s-staticdev" % pkg) + + d.setVar("LIB_PACKAGES", " ".join(lib_packages)) + d.setVar("DEV_PACKAGES", " ".join(dev_packages)) + d.setVar("DBG_PACKAGES", " ".join(dbg_packages)) + d.setVar("STATICDEV_PACKAGES", " ".join(staticdev_packages)) +} + +OTHER_PACKAGES = "\ + ${QT_BASE_NAME}-tools \ + ${QT_BASE_NAME}-assistant \ + ${QT_BASE_NAME}-common \ + ${QT_BASE_NAME}-dbus \ + ${QT_BASE_NAME}-demos \ + ${QT_BASE_NAME}-designer \ + ${QT_BASE_NAME}-examples \ + ${QT_BASE_NAME}-linguist \ + ${QT_BASE_NAME}-makeqpf \ + ${QT_BASE_NAME}-mkspecs \ + ${QT_BASE_NAME}-pixeltool \ + ${QT_BASE_NAME}-qmlviewer \ + ${QT_BASE_NAME}-xmlpatterns \ + ${QT_BASE_NAME}-qt3to4 \ + ${QT_BASE_NAME}-qml-plugins" + +#We prepend so ${QT_BASE_NAME}-demos-doc comes before ${PN}-doc,so the packaging of FILES_ get done before. +PACKAGES =+ "${QT_BASE_NAME}-demos-doc" +PACKAGES += " \ + ${LIB_PACKAGES} \ + ${DEV_PACKAGES} \ + ${DBG_PACKAGES} \ + ${STATICDEV_PACKAGES} \ + ${OTHER_PACKAGES}" + +PACKAGES_DYNAMIC += "^${QT_BASE_NAME}-plugin-.* ^${QT_BASE_NAME}-translation-.* ^${QT_BASE_NAME}-phrasebook-.*" + +ALLOW_EMPTY_${PN} = "1" +FILES_${PN} = "" +FILES_${PN}-dev = "${includedir}/${QT_DIR_NAME}/Qt/*" +FILES_${PN}-dbg = "/usr/src/debug/" +FILES_${QT_BASE_NAME}-demos-doc = "${docdir}/${QT_DIR_NAME}/qch/qt.qch" +RRECOMMENDS_${PN} = "${LIB_PACKAGES} ${OTHER_PACKAGES}" +RRECOMMENDS_${PN}-dev = "${DEV_PACKAGES}" +RRECOMMENDS_${PN}-dbg = "${DBG_PACKAGES}" +RRECOMMENDS_${QT_BASE_LIB}core4_append_libc-glibc = " eglibc-gconv-utf-16" +RRECOMMENDS_${QT_BASE_NAME}-demos += " \ + ${QT_BASE_NAME}-examples \ + ${QT_BASE_NAME}-plugin-sqldriver-sqlite \ + ${QT_BASE_NAME}-plugin-imageformat-jpeg \ + ${QT_BASE_NAME}-qml-plugins \ + ${QT_BASE_NAME}-assistant \ + ${QT_BASE_NAME}-demos-doc" +RRECOMMENDS_${QT_BASE_NAME}-examples += " \ + ${QT_BASE_NAME}-plugin-sqldriver-sqlite \ + ${QT_BASE_NAME}-plugin-imageformat-jpeg \ + ${QT_BASE_NAME}-qml-plugins" +RRECOMMENDS_${QT_BASE_NAME}-qmlviewer += " \ + ${QT_BASE_NAME}-qml-plugins" +RRECOMMENDS_${QT_BASE_NAME}-doc += " \ + ${QT_BASE_NAME}-demos-doc" + +RPROVIDES_${QT_BASE_NAME}-tools += "qmake2" +RREPLACES_${QT_BASE_NAME}-tools += "qmake2" + +FILES_${QT_BASE_NAME}-tools = "${bindir}/qttracereplay ${bindir}/qdoc* ${bindir}/qmake ${bindir}/moc ${bindir}/uic* ${bindir}/rcc" +FILES_${QT_BASE_NAME}-tools-dbg = "${bindir}/.debug/qttracereplay ${bindir}/.debug/qdoc* ${bindir}/.debug/qmake ${bindir}/.debug/uic* ${bindir}/.debug/moc ${bindir}/.debug/rcc" +FILES_${QT_BASE_NAME}-assistant = "${bindir}/*assistant* ${bindir}/qcollectiongenerator ${bindir}/qhelpconverter ${bindir}/qhelpgenerator" +FILES_${QT_BASE_NAME}-assistant-dbg = "${bindir}/.debug/*assistant* ${bindir}/.debug/qcollectiongenerator ${bindir}/.debug/qhelpconverter ${bindir}/.debug/qhelpgenerator" +FILES_${QT_BASE_NAME}-common = "${bindir}/qtconfig" +FILES_${QT_BASE_NAME}-common-dbg = "${bindir}/.debug/qtconfig" +FILES_${QT_BASE_NAME}-dbus = "${bindir}/qdbus ${bindir}/qdbusxml2cpp ${bindir}/qdbuscpp2xml ${bindir}/qdbusviewer" +FILES_${QT_BASE_NAME}-dbus-dbg = "${bindir}/.debug/qdbus ${bindir}/.debug/qdbusxml2cpp ${bindir}/.debug/qdbuscpp2xml ${bindir}/.debug/qdbusviewer" +FILES_${QT_BASE_NAME}-demos = "${bindir}/qtdemo* ${bindir}/${QT_DIR_NAME}/demos/*" +FILES_${QT_BASE_NAME}-demos-staticdev = "${bindir}/${QT_DIR_NAME}/demos/shared/libdemo_shared.a" +FILES_${QT_BASE_NAME}-demos-dbg = "${bindir}/.debug/qtdemo* ${bindir}/${QT_DIR_NAME}/demos/.debug/* ${bindir}/${QT_DIR_NAME}/demos/*/.debug ${bindir}/${QT_DIR_NAME}/demos/*/*/.debug ${bindir}/${QT_DIR_NAME}/demos/*/*/*/.debug" +FILES_${QT_BASE_NAME}-designer = "${bindir}/*designer*" +FILES_${QT_BASE_NAME}-designer-dbg = "${bindir}/.debug/*designer*" +FILES_${QT_BASE_NAME}-examples = "${bindir}/${QT_DIR_NAME}/examples/*" +FILES_${QT_BASE_NAME}-examples-staticdev = "${bindir}/${QT_DIR_NAME}/examples/tools/plugandpaint/plugins/libpnp_basictools.a" +FILES_${QT_BASE_NAME}-examples-dbg = "${bindir}/${QT_DIR_NAME}/examples/.debug ${bindir}/${QT_DIR_NAME}/examples/*/.debug ${bindir}/${QT_DIR_NAME}/examples/*/*/.debug ${bindir}/${QT_DIR_NAME}/examples/*/*/*/.debug ${bindir}/${QT_DIR_NAME}/examples/*/*/*/*/.debug ${bindir}/${QT_DIR_NAME}/examples/declarative/*/*/*/*/*/.debug/* ${bindir}/${QT_DIR_NAME}/examples/declarative/*/*/*/*/.debug/*" +FILES_${QT_BASE_NAME}-linguist = "${bindir}/*linguist* ${bindir}/lrelease ${bindir}/lupdate ${bindir}/lconvert ${bindir}/qm2ts" +FILES_${QT_BASE_NAME}-linguist-dbg = "${bindir}/.debug/*linguist* ${bindir}/.debug/lrelease ${bindir}/.debug/lupdate ${bindir}/.debug/lconvert ${bindir}/.debug/qm2ts" +FILES_${QT_BASE_NAME}-pixeltool = "${bindir}/pixeltool" +FILES_${QT_BASE_NAME}-pixeltool-dbg = "${bindir}/.debug/pixeltool" +FILES_${QT_BASE_NAME}-qt3to4 = "${bindir}/qt3to4 ${datadir}/${QT_DIR_NAME}/q3porting.xml" +FILES_${QT_BASE_NAME}-qt3to4-dbg = "${bindir}/.debug/qt3to4" +FILES_${QT_BASE_NAME}-qmlviewer = "${bindir}/qmlviewer" +FILES_${QT_BASE_NAME}-qmlviewer-dbg = "${bindir}/.debug/qmlviewer" +FILES_${QT_BASE_NAME}-makeqpf = "${bindir}/makeqpf" +FILES_${QT_BASE_NAME}-makeqpf-dbg = "${bindir}/.debug/makeqpf" +FILES_${QT_BASE_NAME}-mkspecs = "${datadir}/${QT_DIR_NAME}/mkspecs/* ${datadir}/${QT_DIR_NAME}/environment-setup" +FILES_${QT_BASE_NAME}-xmlpatterns = "${bindir}/xmlpatterns*" +FILES_${QT_BASE_NAME}-xmlpatterns-dbg = "${bindir}/.debug/xmlpatterns*" +FILES_${QT_BASE_NAME}-qml-plugins = "${libdir}/${QT_DIR_NAME}/imports/* ${libdir}/${QT_DIR_NAME}/plugins/qmltooling/*" +FILES_${QT_BASE_NAME}-qml-plugins-dbg = "${libdir}/${QT_DIR_NAME}/imports/*/*/*/.debug/* ${libdir}/${QT_DIR_NAME}/imports/*/.debug ${libdir}/${QT_DIR_NAME}/plugins/qmltooling/.debug" +INSANE_SKIP_${MLPREFIX}${QT_BASE_NAME}-examples += "libdir" +INSANE_SKIP_${MLPREFIX}${QT_BASE_NAME}-examples-dbg += "libdir" + +# License options, to be set by the recipe if different values are needed +QT_LICENSE_FILE ?= "" +QT_LICENSE_FLAGS ?= "-opensource" + +do_configure() { + unset QMAKESPEC + unset QTDIR + + set_arch + set_endian + + if [ ! -e bin/qmake ]; then + ln -sf ${STAGING_BINDIR_NATIVE}/qmake2 bin/qmake + fi + + if [ ! -e mkspecs/${TARGET_OS}-oe-g++ ]; then + ln -sf linux-g++ mkspecs/${TARGET_OS}-oe-g++ + fi + + if [ -f mkspecs/common/g++-unix.conf ] ; then + # mkspecs were refactored for 4.8.0 + cp -f ${WORKDIR}/g++.conf mkspecs/common/g++-unix.conf + else + cp -f ${WORKDIR}/g++.conf mkspecs/common/g++.conf + fi + cp -f ${WORKDIR}/linux.conf mkspecs/common/ + + echo "[Paths]" > $QT_CONF_PATH + echo "Prefix=${prefix}" >> $QT_CONF_PATH + echo "Documentation=${docdir}/${QT_DIR_NAME}" >> $QT_CONF_PATH + echo "Headers=${includedir}/${QT_DIR_NAME}" >> $QT_CONF_PATH + echo "Libraries=${libdir}" >> $QT_CONF_PATH + echo "Binaries=${bindir}" >> $QT_CONF_PATH + echo "Plugins=${libdir}/${QT_DIR_NAME}/plugins" >> $QT_CONF_PATH + echo "Imports=${libdir}/${QT_DIR_NAME}/imports" >> $QT_CONF_PATH + echo "Data=${datadir}/${QT_DIR_NAME}" >> $QT_CONF_PATH + echo "Translations=${datadir}/${QT_DIR_NAME}/translations" >> $QT_CONF_PATH + echo "Settings=${sysconfdir}/${QT_DIR_NAME}" >> $QT_CONF_PATH + echo "Examples=${bindir}/${QT_DIR_NAME}/examples" >> $QT_CONF_PATH + echo "Demos=${bindir}/${QT_DIR_NAME}/demos" >> $QT_CONF_PATH + + ${EXTRA_QMAKE_MUNGE}|| true + + echo yes | QT_LICENSE_FILE="${QT_LICENSE_FILE}" ./configure -v \ + -prefix ${prefix} \ + -bindir ${bindir} \ + -libdir ${libdir} \ + -datadir ${datadir}/${QT_DIR_NAME} \ + -sysconfdir ${sysconfdir}/${QT_DIR_NAME} \ + -docdir ${docdir}/${QT_DIR_NAME} \ + -headerdir ${includedir}/${QT_DIR_NAME} \ + -plugindir ${libdir}/${QT_DIR_NAME}/plugins \ + -importdir ${libdir}/${QT_DIR_NAME}/imports \ + -translationdir ${datadir}/${QT_DIR_NAME}/translations \ + -examplesdir ${bindir}/${QT_DIR_NAME}/examples \ + -demosdir ${bindir}/${QT_DIR_NAME}/demos \ + -platform ${TARGET_OS}-oe-g++ \ + -xplatform ${TARGET_OS}-oe-g++ \ + ${QT_ENDIAN} \ + -crossarch ${QT_ARCH} \ + ${QT_LICENSE_FLAGS} \ + ${QT_CONFIG_FLAGS} -no-fast \ + -L${STAGING_LIBDIR} -I${STAGING_INCDIR} \ + -I${STAGING_INCDIR}/freetype2 +} + +do_compile() { + # Fixup missing wsegl header in some SGX SDKs + if ! [ -e ${STAGING_INCDIR}/wsegl.h ] ; then + cp src/3rdparty/powervr/wsegl.h src/plugins/gfxdrivers/powervr/QWSWSEGL/ + fi + + unset CFLAGS CXXFLAGS + + oe_runmake ${EXTRA_ENV} + + # Build target qmake + export QMAKESPEC="${S}/mkspecs/${TARGET_OS}-oe-g++" + cd ${S}/qmake + ${OE_QMAKE_QMAKE} + oe_runmake CC="${CC}" CXX="${CXX}" + cd ${S} +} + +python populate_packages_prepend() { + translation_dir = d.expand('${datadir}/${QT_DIR_NAME}/translations/') + translation_name = d.expand('${QT_BASE_NAME}-translation-%s') + do_split_packages(d, translation_dir, '^(assistant|designer|linguist|qt|qtconfig|qvfb)_(.*)\.qm$', translation_name, '${PN} translation for %s', extra_depends='' ) + + phrasebook_dir = d.expand('${datadir}/${QT_DIR_NAME}/phrasebooks/') + phrasebook_name = d.expand('${QT_BASE_NAME}-phrasebook-%s') + + if os.path.exists("%s%s" % (d.expand('${D}'), phrasebook_dir)): + do_split_packages(d, phrasebook_dir, '^(.*)\.qph$', phrasebook_name, '${PN} phrasebook for %s', extra_depends='' ) + else: + bb.note("The path does not exist:", d.expand('${D}'), phrasebook_dir) + + # Package all the plugins and their -dbg version and create a meta package + def qtopia_split(path, name, glob): + """ + Split the package into a normal and -dbg package and then add the + new packages to the meta package. + """ + plugin_dir = d.expand('${libdir}/${QT_DIR_NAME}/plugins/%s/' % path) + if not os.path.exists("%s%s" % (d.expand('${D}'), plugin_dir)): + bb.note("The path does not exist:", d.expand('${D}'), plugin_dir) + return + + plugin_name = d.expand('${QT_BASE_NAME}-plugin-%s-%%s' % name) + dev_packages = [] + dev_hook = lambda file,pkg,b,c,d:dev_packages.append((file,pkg)) + do_split_packages(d, plugin_dir, glob, plugin_name, '${PN} %s for %%s' % name, extra_depends='', hook=dev_hook) + # Create a -dbg package as well + plugin_dir_dbg = d.expand('${libdir}/${QT_DIR_NAME}/plugins/%s/.debug' % path) + packages = d.getVar('PACKAGES') + for (file,package) in dev_packages: + packages = "%s %s-dbg" % (packages, package) + file_name = os.path.join(plugin_dir_dbg, os.path.basename(file)) + d.setVar("FILES_%s-dbg" % package, file_name) + d.setVar("DESCRIPTION_%s-dbg" % package, "${PN} %s for %s" % (name, package)) + + d.setVar('PACKAGES', packages) + + qtopia_split('accessible', 'accessible', '^libq(.*)\.so$') + qtopia_split('codecs', 'codec', '^libq(.*)\.so$') + qtopia_split('decorations', 'decoration', '^libqdecoration(.*)\.so$') + qtopia_split('designer', 'designer', '^lib(.*)\.so$') + qtopia_split('gfxdrivers', 'gfxdriver', '^libq(.*)\.so$') + qtopia_split('graphicssystems','graphicssystems', '^libq(.*)\.so$') + qtopia_split('kbddrivers', 'kbddriver', '^libq(.*)kbddriver\.so$') + qtopia_split('mousedrivers', 'mousedriver', '^libq(.*)mousedriver\.so$') + qtopia_split('iconengines', 'iconengine', '^libq(.*)\.so$') + qtopia_split('imageformats', 'imageformat', '^libq(.*)\.so$') + qtopia_split('inputmethods', 'inputmethod', '^libq(.*)\.so$') + qtopia_split('sqldrivers', 'sqldriver', '^libq(.*)\.so$') + qtopia_split('script', 'script', '^libqtscript(.*)\.so$') + qtopia_split('styles', 'style', '^libq(.*)\.so$') + qtopia_split('phonon_backend','phonon-backend','^libphonon_(.*)\.so$') + qtopia_split('bearer', 'bearer', '^libq(.*)bearer\.so$') +} + +do_install() { + oe_runmake install INSTALL_ROOT=${D} + + # Install a proper target version of qmake + rm ${D}/${bindir}/qmake + install -m 0755 bin/qmake2 ${D}${bindir}/qmake + + # fix pkgconfig, libtool and prl files + sed -i -e 's#-L${S}/lib/\?##g' \ + -e 's#-L${STAGING_LIBDIR}/\?##g' \ + -e 's#STAGING_LIBDIR}#libdir}'#g \ + -e 's#-L${libdir}/\?##g' \ + -e s#'$(OE_QMAKE_LIBS_X11)'#"${OE_QMAKE_LIBS_X11}"#g \ + -e 's#" -Wl,-rpath-link,${S}/lib/\?"##g' \ + -e 's#" -Wl,-rpath-link,${libdir}/\?"##g' \ + -e 's#Iin#I${in#g' \ + -e 's#-L\.\./\.\./WebCore/release\s\+-L\.\./\.\./JavaScriptCore/release\s\+-lwebcore##g' \ + -e 's#-ljscore##g' \ + ${D}${libdir}/*.la ${D}${libdir}/*.prl ${D}${libdir}/pkgconfig/*.pc + + sed -i -e s#" -Wl,-rpath-link,${S}/lib"##g \ + ${D}${datadir}/${QT_DIR_NAME}/mkspecs/common/linux.conf + + # fix pkgconfig files + sed -i -e s#"moc_location=.*$"#"moc_location=${bindir}/moc4"# \ + -e s#"uic_location=.*$"#"uic_location=${bindir}/uic4"# \ + ${D}${libdir}/pkgconfig/*.pc + for name in ${QT_LIB_NAMES}; do + sed -i -e /Requires/s#"${name}"#"${name}${QT_LIBINFIX}"#g ${D}${libdir}/pkgconfig/*.pc + done + + # QT abuses $includedir to point to its headers, which breaks pkgconfig sysroot, so manually fix it up here: + for pc in ${D}${libdir}/pkgconfig/*.pc ; do + sed -i -e "s:prefix}/include/${QT_DIR_NAME}/$(basename $pc .pc):prefix}/include:" \ + -e 's:IP{:I${:g' $pc + done + + #Append an E to the qtdemo file + if [ -n "${QT_LIBINFIX}" ] ; then + [ -f ${D}${bindir}/qtdemo ] && mv ${D}${bindir}/qtdemo ${D}${bindir}/qtdemo${QT_LIBINFIX} + fi + + script="${D}/${datadir}/${QT_DIR_NAME}/environment-setup" + touch $script + echo 'export QT_DIR_NAME=${QT_DIR_NAME}' >> $script + echo 'export QT_LIBINFIX=${QT_LIBINFIX}' >> $script + echo 'export OE_QMAKE_AR=ar' >> $script + echo 'export OE_QMAKE_CC=gcc' >> $script + echo 'export OE_QMAKE_CXX=g++' >> $script + echo 'export OE_QMAKE_LINK=g++' >> $script + echo 'export OE_QMAKE_LIBDIR_QT=${libdir}' >> $script + echo 'export OE_QMAKE_INCDIR_QT=${includedir}/${QT_DIR_NAME}' >> $script + echo 'export OE_QMAKE_MOC=${bindir}/moc' >> $script + echo 'export OE_QMAKE_UIC=${bindir}/uic' >> $script + echo 'export OE_QMAKE_UIC3=${bindir}/uic3' >> $script + echo 'export OE_QMAKE_RCC=${bindir}/rcc' >> $script + echo 'export OE_QMAKE_QDBUSCPP2XML=${bindir}/qdbuscpp2xml' >> $script + echo 'export OE_QMAKE_QDBUSXML2CPP=${bindir}/qdbusxml2cpp' >> $script + echo 'export OE_QMAKE_QT_CONFIG=${datadir}/${QT_DIR_NAME}/mkspecs/qconfig.pri' >> $script + echo 'export QMAKESPEC=${datadir}/${QT_DIR_NAME}/mkspecs/linux-g++' >> $script + chmod 0755 $script +} diff --git a/meta/recipes-qt/qt4/qt4_arch.inc b/meta/recipes-qt/qt4/qt4_arch.inc new file mode 100644 index 0000000000..c1d35ab726 --- /dev/null +++ b/meta/recipes-qt/qt4/qt4_arch.inc @@ -0,0 +1,21 @@ +inherit siteinfo + +ARM_INSTRUCTION_SET = "arm" + +set_arch() { + case ${TARGET_ARCH} in + arm*) QT_ARCH=arm ;; + i*86*) QT_ARCH=i386 ;; + mips*) QT_ARCH=mips ;; + powerpc*) QT_ARCH=powerpc ;; + x86_64*) QT_ARCH=x86_64 ;; + esac +} + +set_endian() { + if [ ${SITEINFO_ENDIANNESS} = "le" ] ; then + QT_ENDIAN="-little-endian" + elif [ ${SITEINFO_ENDIANNESS} = "be" ] ; then + QT_ENDIAN="-big-endian" + fi +} -- cgit v1.2.3-54-g00ecf