diff options
Diffstat (limited to 'src/corelib/kernel')
25 files changed, 662 insertions, 287 deletions
diff --git a/src/corelib/kernel/kernel.pri b/src/corelib/kernel/kernel.pri index 55625f3571..0ece4a395c 100644 --- a/src/corelib/kernel/kernel.pri +++ b/src/corelib/kernel/kernel.pri @@ -99,20 +99,22 @@ winrt { } mac { + HEADERS += \ + kernel/qcore_mac_p.h + SOURCES += \ - kernel/qcoreapplication_mac.cpp -} + kernel/qcoreapplication_mac.cpp \ + kernel/qcore_mac.cpp + + OBJECTIVE_SOURCES += \ + kernel/qcore_mac_objc.mm + + LIBS_PRIVATE += -framework Foundation -mac:!nacl { - HEADERS += \ - kernel/qcore_mac_p.h - SOURCES += \ - kernel/qcore_mac.cpp - OBJECTIVE_SOURCES += \ - kernel/qcore_mac_objc.mm + osx: LIBS_PRIVATE += -framework CoreServices - # We need UIKit for UIDevice - ios: LIBS_PRIVATE += -framework UIKit + # We need UIKit for UIDevice + ios: LIBS_PRIVATE += -framework UIKit } nacl { diff --git a/src/corelib/kernel/qcore_mac_objc.mm b/src/corelib/kernel/qcore_mac_objc.mm index 73f8296021..8ac062a154 100644 --- a/src/corelib/kernel/qcore_mac_objc.mm +++ b/src/corelib/kernel/qcore_mac_objc.mm @@ -1,6 +1,7 @@ /**************************************************************************** ** - ** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). + ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). + ** Copyright (C) 2014 Petroules Corporation. ** Contact: http://www.qt-project.org/legal ** ** This file is part of the QtCore module of the Qt Toolkit. @@ -47,6 +48,8 @@ QT_BEGIN_NAMESPACE +typedef qint16 (*GestaltFunction)(quint32 selector, qint32 *response); + NSString *QCFString::toNSString(const QString &string) { // The const cast below is safe: CfStringRef is immutable and so is NSString. @@ -58,31 +61,49 @@ QString QCFString::toQString(const NSString *nsstr) return toQString(reinterpret_cast<CFStringRef>(nsstr)); } -#ifdef Q_OS_IOS -QSysInfo::MacVersion qt_ios_version() +QAppleOperatingSystemVersion qt_apple_os_version() { - NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; - - int major = 0, minor = 0; - NSArray *components = [[UIDevice currentDevice].systemVersion componentsSeparatedByString:@"."]; - switch ([components count]) { - case 3: - // We don't care about the patch version - case 2: - minor = [[components objectAtIndex:1] intValue]; - // fall through - case 1: - major = [[components objectAtIndex:0] intValue]; - break; - default: - Q_UNREACHABLE(); + QAppleOperatingSystemVersion v = {0, 0, 0}; +#if QT_MAC_PLATFORM_SDK_EQUAL_OR_ABOVE(__MAC_10_10, __IPHONE_8_0) + if ([NSProcessInfo instancesRespondToSelector:@selector(operatingSystemVersion)]) { + NSOperatingSystemVersion osv = NSProcessInfo.processInfo.operatingSystemVersion; + v.major = osv.majorVersion; + v.minor = osv.minorVersion; + v.patch = osv.patchVersion; + return v; } - - [pool release]; - - return QSysInfo::MacVersion(Q_MV_IOS(major, minor)); -} #endif + // Use temporary variables so we can return 0.0.0 (unknown version) + // in case of an error partway through determining the OS version + qint32 major = 0, minor = 0, patch = 0; +#if defined(Q_OS_IOS) + @autoreleasepool { + NSArray *parts = [UIDevice.currentDevice.systemVersion componentsSeparatedByString:@"."]; + major = parts.count > 0 ? [[parts objectAtIndex:0] intValue] : 0; + minor = parts.count > 1 ? [[parts objectAtIndex:1] intValue] : 0; + patch = parts.count > 2 ? [[parts objectAtIndex:2] intValue] : 0; + } +#elif defined(Q_OS_OSX) + static GestaltFunction pGestalt = 0; + if (!pGestalt) { + CFBundleRef b = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.CoreServices")); + pGestalt = reinterpret_cast<GestaltFunction>(CFBundleGetFunctionPointerForName(b, + CFSTR("Gestalt"))); + } + if (!pGestalt) + return v; + if (pGestalt('sys1', &major) != 0) + return v; + if (pGestalt('sys2', &minor) != 0) + return v; + if (pGestalt('sys3', &patch) != 0) + return v; +#endif + v.major = major; + v.minor = minor; + v.patch = patch; + return v; +} QT_END_NAMESPACE diff --git a/src/corelib/kernel/qcore_mac_p.h b/src/corelib/kernel/qcore_mac_p.h index 842e2ef9f1..9b13f8d2b1 100644 --- a/src/corelib/kernel/qcore_mac_p.h +++ b/src/corelib/kernel/qcore_mac_p.h @@ -135,9 +135,11 @@ private: QString string; }; -#ifdef Q_OS_IOS -QSysInfo::MacVersion qt_ios_version(); -#endif +typedef struct { + int major, minor, patch; +} QAppleOperatingSystemVersion; + +QAppleOperatingSystemVersion qt_apple_os_version(); QT_END_NAMESPACE diff --git a/src/corelib/kernel/qcoreapplication.h b/src/corelib/kernel/qcoreapplication.h index ff1dd5c43a..db1245430b 100644 --- a/src/corelib/kernel/qcoreapplication.h +++ b/src/corelib/kernel/qcoreapplication.h @@ -183,7 +183,7 @@ Q_SIGNALS: void applicationVersionChanged(); protected: - bool event(QEvent *); + bool event(QEvent *) Q_DECL_OVERRIDE; virtual bool compressEvent(QEvent *, QObject *receiver, QPostEventList *); #endif // QT_NO_QOBJECT diff --git a/src/corelib/kernel/qcoreevent.cpp b/src/corelib/kernel/qcoreevent.cpp index 191ceaa37b..93ab90fb94 100644 --- a/src/corelib/kernel/qcoreevent.cpp +++ b/src/corelib/kernel/qcoreevent.cpp @@ -183,6 +183,7 @@ QT_BEGIN_NAMESPACE \value ParentAboutToChange The widget parent is about to change. \value ParentChange The widget parent has changed. \value PlatformPanel A platform specific panel has been requested. + \value PlatformSurface A native platform surface has been created or is about to be destroyed (QPlatformSurfaceEvent). \value Polish The widget is polished. \value PolishRequest The widget should be polished. \value QueryWhatsThis The widget should accept the event if it has "What's This?" help. diff --git a/src/corelib/kernel/qcoreevent.h b/src/corelib/kernel/qcoreevent.h index 170f319ec9..0807721432 100644 --- a/src/corelib/kernel/qcoreevent.h +++ b/src/corelib/kernel/qcoreevent.h @@ -275,6 +275,8 @@ public: WindowChangeInternal = 215, // internal for QQuickWidget ScreenChangeInternal = 216, + PlatformSurface = 217, // Platform surface created or about to be destroyed + // 512 reserved for Qt Jambi's MetaCall event // 513 reserved for Qt Jambi's DeleteOnMainThread event diff --git a/src/corelib/kernel/qeventdispatcher_glib_p.h b/src/corelib/kernel/qeventdispatcher_glib_p.h index 50820f478b..5950a4221a 100644 --- a/src/corelib/kernel/qeventdispatcher_glib_p.h +++ b/src/corelib/kernel/qeventdispatcher_glib_p.h @@ -66,8 +66,8 @@ public: explicit QEventDispatcherGlib(GMainContext *context, QObject *parent = 0); ~QEventDispatcherGlib(); - bool processEvents(QEventLoop::ProcessEventsFlags flags); - bool hasPendingEvents(); + bool processEvents(QEventLoop::ProcessEventsFlags flags) Q_DECL_OVERRIDE; + bool hasPendingEvents() Q_DECL_OVERRIDE; void registerSocketNotifier(QSocketNotifier *socketNotifier) Q_DECL_FINAL; void unregisterSocketNotifier(QSocketNotifier *socketNotifier) Q_DECL_FINAL; diff --git a/src/corelib/kernel/qeventdispatcher_unix_p.h b/src/corelib/kernel/qeventdispatcher_unix_p.h index 37f180486e..3ec2c2eb3f 100644 --- a/src/corelib/kernel/qeventdispatcher_unix_p.h +++ b/src/corelib/kernel/qeventdispatcher_unix_p.h @@ -101,8 +101,8 @@ public: explicit QEventDispatcherUNIX(QObject *parent = 0); ~QEventDispatcherUNIX(); - bool processEvents(QEventLoop::ProcessEventsFlags flags); - bool hasPendingEvents(); + bool processEvents(QEventLoop::ProcessEventsFlags flags) Q_DECL_OVERRIDE; + bool hasPendingEvents() Q_DECL_OVERRIDE; void registerSocketNotifier(QSocketNotifier *notifier) FINAL_EXCEPT_BLACKBERRY; void unregisterSocketNotifier(QSocketNotifier *notifier) FINAL_EXCEPT_BLACKBERRY; @@ -116,7 +116,7 @@ public: void wakeUp() FINAL_EXCEPT_BLACKBERRY; void interrupt() Q_DECL_FINAL; - void flush(); + void flush() Q_DECL_OVERRIDE; protected: QEventDispatcherUNIX(QEventDispatcherUNIXPrivate &dd, QObject *parent = 0); diff --git a/src/corelib/kernel/qeventloop.h b/src/corelib/kernel/qeventloop.h index 31cd1d402a..be7a40e44d 100644 --- a/src/corelib/kernel/qeventloop.h +++ b/src/corelib/kernel/qeventloop.h @@ -70,7 +70,7 @@ public: void wakeUp(); - bool event(QEvent *event); + bool event(QEvent *event) Q_DECL_OVERRIDE; public Q_SLOTS: void quit(); diff --git a/src/corelib/kernel/qfunctions_wince.h b/src/corelib/kernel/qfunctions_wince.h index cc5e0ca83f..8cbde6c465 100644 --- a/src/corelib/kernel/qfunctions_wince.h +++ b/src/corelib/kernel/qfunctions_wince.h @@ -208,7 +208,7 @@ int qt_wince_SetErrorMode(int); bool qt_wince__chmod(const char *file, int mode); bool qt_wince__wchmod(const wchar_t *file, int mode); -#pragma warning(disable: 4273) +QT_WARNING_DISABLE_MSVC(4273) HANDLE qt_wince_CreateFileA(LPCSTR, DWORD, DWORD, LPSECURITY_ATTRIBUTES, DWORD, DWORD, HANDLE); // Printer ---------------------------------------------------------- diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp index b54cb0c344..3e2fb46143 100644 --- a/src/corelib/kernel/qmetaobject.cpp +++ b/src/corelib/kernel/qmetaobject.cpp @@ -1,6 +1,7 @@ /**************************************************************************** ** ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Copyright (C) 2014 Olivier Goffart <ogoffart@woboq.com> ** Contact: http://www.qt-project.org/legal ** ** This file is part of the QtCore module of the Qt Toolkit. @@ -2298,6 +2299,112 @@ bool QMetaMethod::invoke(QObject *object, */ /*! + \since 5.5 + + Invokes this method on a Q_GADGET. Returns \c true if the member could be invoked. + Returns \c false if there is no such member or the parameters did not match. + + The pointer \a gadget must point to an instance of the gadget class. + + The invocation is always synchronous. + + The return value of this method call is placed in \a + returnValue. You can pass up to ten arguments (\a val0, \a val1, + \a val2, \a val3, \a val4, \a val5, \a val6, \a val7, \a val8, + and \a val9) to this method call. + + \warning this method will not test the validity of the arguments: \a gadget + must be an instance of the class of the QMetaObject of which this QMetaMethod + has been constructed with. The arguments must have the same type as the ones + expected by the method, else, the behavior is undefined. + + \sa Q_ARG(), Q_RETURN_ARG(), qRegisterMetaType(), QMetaObject::invokeMethod() +*/ +bool QMetaMethod::invokeOnGadget(void* gadget, QGenericReturnArgument returnValue, QGenericArgument val0, QGenericArgument val1, QGenericArgument val2, QGenericArgument val3, QGenericArgument val4, QGenericArgument val5, QGenericArgument val6, QGenericArgument val7, QGenericArgument val8, QGenericArgument val9) const +{ + if (!gadget || !mobj) + return false; + + // check return type + if (returnValue.data()) { + const char *retType = typeName(); + if (qstrcmp(returnValue.name(), retType) != 0) { + // normalize the return value as well + QByteArray normalized = QMetaObject::normalizedType(returnValue.name()); + if (qstrcmp(normalized.constData(), retType) != 0) { + // String comparison failed, try compare the metatype. + int t = returnType(); + if (t == QMetaType::UnknownType || t != QMetaType::type(normalized)) + return false; + } + } + } + + // check argument count (we don't allow invoking a method if given too few arguments) + const char *typeNames[] = { + returnValue.name(), + val0.name(), + val1.name(), + val2.name(), + val3.name(), + val4.name(), + val5.name(), + val6.name(), + val7.name(), + val8.name(), + val9.name() + }; + int paramCount; + for (paramCount = 1; paramCount < MaximumParamCount; ++paramCount) { + if (qstrlen(typeNames[paramCount]) <= 0) + break; + } + if (paramCount <= QMetaMethodPrivate::get(this)->parameterCount()) + return false; + + // invoke! + void *param[] = { + returnValue.data(), + val0.data(), + val1.data(), + val2.data(), + val3.data(), + val4.data(), + val5.data(), + val6.data(), + val7.data(), + val8.data(), + val9.data() + }; + int idx_relative = QMetaMethodPrivate::get(this)->ownMethodIndex(); + Q_ASSERT(QMetaObjectPrivate::get(mobj)->revision >= 6); + QObjectPrivate::StaticMetaCallFunction callFunction = mobj->d.static_metacall; + if (!callFunction) + return false; + callFunction(reinterpret_cast<QObject*>(gadget), QMetaObject::InvokeMetaMethod, idx_relative, param); + return true; +} + +/*! + \fn bool QMetaMethod::invokeOnGadget(void *gadget, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) const + + \overload + \since 5.5 + + This overload invokes this method for a \a gadget and ignores return values. +*/ + +/*! \class QMetaEnum \inmodule QtCore \brief The QMetaEnum class provides meta-data about an enumerator. @@ -2713,9 +2820,8 @@ int QMetaProperty::userType() const if (isEnumType()) { type = QMetaType::type(qualifiedName(menum)); if (type == QMetaType::UnknownType) { - void *argv[] = { &type }; - mobj->static_metacall(QMetaObject::RegisterPropertyMetaType, idx, argv); - if (type == -1 || type == QMetaType::UnknownType) + type = registerPropertyType(); + if (type == QMetaType::UnknownType) return QVariant::Int; // Match behavior of QMetaType::type() } return type; @@ -2723,11 +2829,7 @@ int QMetaProperty::userType() const type = QMetaType::type(typeName()); if (type != QMetaType::UnknownType) return type; - void *argv[] = { &type }; - mobj->static_metacall(QMetaObject::RegisterPropertyMetaType, idx, argv); - if (type != -1) - return type; - return QMetaType::UnknownType; + return registerPropertyType(); } /*! @@ -2791,6 +2893,20 @@ bool QMetaProperty::hasStdCppSet() const } /*! + \internal + Executes metacall with QMetaObject::RegisterPropertyMetaType flag. + Returns id of registered type or QMetaType::UnknownType if a type + could not be registered for any reason. +*/ +int QMetaProperty::registerPropertyType() const +{ + int registerResult = -1; + void *argv[] = { ®isterResult }; + mobj->static_metacall(QMetaObject::RegisterPropertyMetaType, idx, argv); + return registerResult == -1 ? QMetaType::UnknownType : registerResult; +} + +/*! Returns the enumerator if this property's type is an enumerator type; otherwise the returned value is undefined. @@ -2835,15 +2951,11 @@ QVariant QMetaProperty::read(const QObject *object) const } if (t == QMetaType::UnknownType) { // Try to register the type and try again before reporting an error. - int registerResult = -1; - void *argv[] = { ®isterResult }; - QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::RegisterPropertyMetaType, - idx + mobj->propertyOffset(), argv); - if (registerResult == -1) { + t = registerPropertyType(); + if (t == QMetaType::UnknownType) { qWarning("QMetaProperty::read: Unable to handle unregistered datatype '%s' for property '%s::%s'", typeName, mobj->className(), name()); return QVariant(); } - t = registerResult; } } @@ -2861,8 +2973,12 @@ QVariant QMetaProperty::read(const QObject *object) const value = QVariant(t, (void*)0); argv[0] = value.data(); } - QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::ReadProperty, - idx + mobj->propertyOffset(), argv); + if (priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall) { + mobj->d.static_metacall(const_cast<QObject*>(object), QMetaObject::ReadProperty, idx, argv); + } else { + QMetaObject::metacall(const_cast<QObject*>(object), QMetaObject::ReadProperty, + idx + mobj->propertyOffset(), argv); + } if (status != -1) return value; @@ -2911,9 +3027,11 @@ bool QMetaProperty::write(QObject *object, const QVariant &value) const else { typeName = rawStringData(mobj, typeInfo & TypeNameIndexMask); t = QMetaType::type(typeName); + if (t == QMetaType::UnknownType) + t = registerPropertyType(); + if (t == QMetaType::UnknownType) + return false; } - if (t == QMetaType::UnknownType) - return false; if (t != QMetaType::QVariant && t != (uint)value.userType() && (t < QMetaType::User && !v.convert((QVariant::Type)t))) return false; } @@ -2932,7 +3050,11 @@ bool QMetaProperty::write(QObject *object, const QVariant &value) const argv[0] = &v; else argv[0] = v.data(); - QMetaObject::metacall(object, QMetaObject::WriteProperty, idx + mobj->propertyOffset(), argv); + if (priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall) + mobj->d.static_metacall(object, QMetaObject::WriteProperty, idx, argv); + else + QMetaObject::metacall(object, QMetaObject::WriteProperty, idx + mobj->propertyOffset(), argv); + return status; } @@ -2949,9 +3071,55 @@ bool QMetaProperty::reset(QObject *object) const if (!object || !mobj || !isResettable()) return false; void *argv[] = { 0 }; - QMetaObject::metacall(object, QMetaObject::ResetProperty, idx + mobj->propertyOffset(), argv); + if (priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall) + mobj->d.static_metacall(object, QMetaObject::ResetProperty, idx, argv); + else + QMetaObject::metacall(object, QMetaObject::ResetProperty, idx + mobj->propertyOffset(), argv); return true; } +/*! + \since 5.5 + + Reads the property's value from the given \a gadget. Returns the value + if it was able to read it; otherwise returns an invalid variant. + + This function should only be used if this is a property of a Q_GADGET +*/ +QVariant QMetaProperty::readOnGadget(const void *gadget) const +{ + Q_ASSERT(priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall); + return read(reinterpret_cast<const QObject*>(gadget)); +} + +/*! + \since 5.5 + + Writes \a value as the property's value to the given \a gadget. Returns + true if the write succeeded; otherwise returns \c false. + + This function should only be used if this is a property of a Q_GADGET +*/ +bool QMetaProperty::writeOnGadget(void *gadget, const QVariant &value) const +{ + Q_ASSERT(priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall); + return write(reinterpret_cast<QObject*>(gadget), value); +} + +/*! + \since 5.5 + + Resets the property for the given \a gadget with a reset method. + Returns \c true if the reset worked; otherwise returns \c false. + + Reset methods are optional; only a few properties support them. + + This function should only be used if this is a property of a Q_GADGET +*/ +bool QMetaProperty::resetOnGadget(void *gadget) const +{ + Q_ASSERT(priv(mobj->d.data)->flags & PropertyAccessInStaticMetaCall && mobj->d.static_metacall); + return reset(reinterpret_cast<QObject*>(gadget)); +} /*! Returns \c true if this property can be reset to a default value; otherwise diff --git a/src/corelib/kernel/qmetaobject.h b/src/corelib/kernel/qmetaobject.h index 2a874697c3..fdbcf5171d 100644 --- a/src/corelib/kernel/qmetaobject.h +++ b/src/corelib/kernel/qmetaobject.h @@ -1,6 +1,7 @@ /**************************************************************************** ** ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Copyright (C) 2014 Olivier Goffart <ogoffart@woboq.com> ** Contact: http://www.qt-project.org/legal ** ** This file is part of the QtCore module of the Qt Toolkit. @@ -131,6 +132,34 @@ public: val0, val1, val2, val3, val4, val5, val6, val7, val8, val9); } + bool invokeOnGadget(void *gadget, + QGenericReturnArgument returnValue, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) const; + inline bool invokeOnGadget(void *gadget, + QGenericArgument val0 = QGenericArgument(0), + QGenericArgument val1 = QGenericArgument(), + QGenericArgument val2 = QGenericArgument(), + QGenericArgument val3 = QGenericArgument(), + QGenericArgument val4 = QGenericArgument(), + QGenericArgument val5 = QGenericArgument(), + QGenericArgument val6 = QGenericArgument(), + QGenericArgument val7 = QGenericArgument(), + QGenericArgument val8 = QGenericArgument(), + QGenericArgument val9 = QGenericArgument()) const + { + return invokeOnGadget(gadget, QGenericReturnArgument(), + val0, val1, val2, val3, val4, val5, val6, val7, val8, val9); + } + inline bool isValid() const { return mobj != 0; } #ifdef Q_QDOC @@ -237,11 +266,17 @@ public: bool write(QObject *obj, const QVariant &value) const; bool reset(QObject *obj) const; + QVariant readOnGadget(const void *gadget) const; + bool writeOnGadget(void *gadget, const QVariant &value) const; + bool resetOnGadget(void *gadget) const; + bool hasStdCppSet() const; inline bool isValid() const { return isReadable(); } inline const QMetaObject *enclosingMetaObject() const { return mobj; } private: + int registerPropertyType() const; + const QMetaObject *mobj; uint handle; int idx; diff --git a/src/corelib/kernel/qmetaobject_p.h b/src/corelib/kernel/qmetaobject_p.h index c08838e456..45fe56ec8a 100644 --- a/src/corelib/kernel/qmetaobject_p.h +++ b/src/corelib/kernel/qmetaobject_p.h @@ -1,6 +1,7 @@ /**************************************************************************** ** ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Copyright (C) 2014 Olivier Goffart <ogoffart@woboq.com> ** Contact: http://www.qt-project.org/legal ** ** This file is part of the QtCore module of the Qt Toolkit. @@ -98,7 +99,8 @@ enum MethodFlags { enum MetaObjectFlags { DynamicMetaObject = 0x01, - RequiresVariantMetaObject = 0x02 + RequiresVariantMetaObject = 0x02, + PropertyAccessInStaticMetaCall = 0x04 // since Qt 5.5, property code is in the static metacall }; enum MetaDataFlags { diff --git a/src/corelib/kernel/qmetatype.cpp b/src/corelib/kernel/qmetatype.cpp index 311648c33a..294b1fc07c 100644 --- a/src/corelib/kernel/qmetatype.cpp +++ b/src/corelib/kernel/qmetatype.cpp @@ -283,10 +283,11 @@ struct DefinedTypesFilter { \value MovableType An instance of a type having this attribute can be safely moved by memcpy. \omitvalue SharedPointerToQObject \omitvalue IsEnumeration - \omitvalue PointerToQObject + \value PointerToQObject This type is a pointer to a derived of QObject \omitvalue WeakPointerToQObject \omitvalue TrackingPointerToQObject \omitvalue WasDeclaredAsMetaType + \value IsGadget This type is a Q_GADGET and it's corresponding QMetaObject can be accessed with QMetaType::metaObject Since 5.5. */ /*! @@ -363,8 +364,19 @@ struct DefinedTypesFilter { /*! \fn const QMetaObject *QMetaType::metaObject() const - \since 5.0 - \internal + \since 5.5 + + return a QMetaObject relative to this type. + + If the type is a pointer type to a subclass of QObject, flags contains + QMetaType::PointerToQObject and this function returns the corresponding QMetaObject. This can + be used to in combinaison with QMetaObject::construct to create QObject of this type. + + If the type is a Q_GADGET, flags contains QMetaType::IsGadget, and this function returns its + QMetaObject. This can be used to retrieve QMetaMethod and QMetaProperty and use them on a + pointer of this type. (given by QVariant::data for example) + + \sa QMetaType::metaObjectForType(), QMetaType::flags() */ /*! @@ -801,7 +813,7 @@ static inline int qMetaTypeStaticType(const char *typeName, int length) { int i = 0; while (types[i].typeName && ((length != types[i].typeNameLength) - || strcmp(typeName, types[i].typeName))) { + || memcmp(typeName, types[i].typeName, length))) { ++i; } return types[i].type; @@ -821,7 +833,7 @@ static int qMetaTypeCustomType_unlocked(const char *typeName, int length) for (int v = 0; v < ct->count(); ++v) { const QCustomTypeInfo &customInfo = ct->at(v); if ((length == customInfo.typeName.size()) - && !strcmp(typeName, customInfo.typeName.constData())) { + && !memcmp(typeName, customInfo.typeName.constData(), length)) { if (customInfo.alias >= 0) return customInfo.alias; return v + QMetaType::User; @@ -870,24 +882,43 @@ int QMetaType::registerType(const char *typeName, Deleter deleter, /*! - \internal - \since 5.0 + \internal + \since 5.0 + \overload + Don't use, kept for binary compatibility - Registers a user type for marshalling, with \a normalizedTypeName, a \a - deleter, a \a creator, a \a destructor, a \a constructor, and - a \a size. Returns the type's handle, or -1 if the type could - not be registered. Note that normalizedTypeName is not checked for - conformance with Qt's normalized format, so it must already - conform. - */ + ### TODO Qt6: remove me +*/ int QMetaType::registerNormalizedType(const NS(QByteArray) &normalizedTypeName, Deleter deleter, Creator creator, Destructor destructor, Constructor constructor, int size, TypeFlags flags, const QMetaObject *metaObject) { + Q_UNUSED(deleter); + Q_UNUSED(creator); + return registerNormalizedType(normalizedTypeName, destructor, constructor, size, flags, metaObject); +} + + +/*! + \internal + \since 5.5 + + Registers a user type for marshalling, with \a normalizedTypeName, + a \a destructor, a \a constructor, and a \a size. Returns the type's + handle, or -1 if the type could not be registered. + + \note normalizedTypeName is not checked for conformance with + Qt's normalized format, so it must already conform. + */ +int QMetaType::registerNormalizedType(const NS(QByteArray) &normalizedTypeName, + Destructor destructor, + Constructor constructor, + int size, TypeFlags flags, const QMetaObject *metaObject) +{ QVector<QCustomTypeInfo> *ct = customTypes(); - if (!ct || normalizedTypeName.isEmpty() || !deleter || !creator || !destructor || !constructor) + if (!ct || normalizedTypeName.isEmpty() || !destructor || !constructor) return -1; int idx = qMetaTypeStaticType(normalizedTypeName.constData(), @@ -902,8 +933,6 @@ int QMetaType::registerNormalizedType(const NS(QByteArray) &normalizedTypeName, if (idx == UnknownType) { QCustomTypeInfo inf; inf.typeName = normalizedTypeName; - inf.creator = creator; - inf.deleter = deleter; #ifndef QT_NO_DATASTREAM inf.loadOp = 0; inf.saveOp = 0; @@ -1004,8 +1033,6 @@ int QMetaType::registerNormalizedTypedef(const NS(QByteArray) &normalizedTypeNam QCustomTypeInfo inf; inf.typeName = normalizedTypeName; inf.alias = aliasId; - inf.creator = 0; - inf.deleter = 0; ct->append(inf); return aliasId; } @@ -1048,9 +1075,8 @@ bool QMetaType::isRegistered(int type) Implementation of QMetaType::type(). */ template <bool tryNormalizedType> -static inline int qMetaTypeTypeImpl(const char *typeName) +static inline int qMetaTypeTypeImpl(const char *typeName, int length) { - int length = qstrlen(typeName); if (!length) return QMetaType::UnknownType; int type = qMetaTypeStaticType(typeName, length); @@ -1080,7 +1106,7 @@ static inline int qMetaTypeTypeImpl(const char *typeName) */ int QMetaType::type(const char *typeName) { - return qMetaTypeTypeImpl</*tryNormalizedType=*/true>(typeName); + return qMetaTypeTypeImpl</*tryNormalizedType=*/true>(typeName, qstrlen(typeName)); } /*! @@ -1092,7 +1118,21 @@ int QMetaType::type(const char *typeName) */ int qMetaTypeTypeInternal(const char *typeName) { - return qMetaTypeTypeImpl</*tryNormalizedType=*/false>(typeName); + return qMetaTypeTypeImpl</*tryNormalizedType=*/false>(typeName, qstrlen(typeName)); +} + +/*! + \since 5.5 + \overload + + Returns a handle to the type called \a typeName, or 0 if there is + no such type. + + \sa isRegistered(), typeName() +*/ +int QMetaType::type(const QT_PREPEND_NAMESPACE(QByteArray) &typeName) +{ + return qMetaTypeTypeImpl</*tryNormalizedType=*/true>(typeName.constData(), typeName.size()); } #ifndef QT_NO_DATASTREAM @@ -1541,60 +1581,6 @@ bool QMetaType::load(QDataStream &stream, int type, void *data) return true; } #endif // QT_NO_DATASTREAM -namespace { -class TypeCreator { - template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> - struct CreatorImpl { - static void *Create(const int /* type */, const void *copy) - { - // Using QMetaTypeFunctionHelper<T>::Create adds function call cost, even if it is a template (gcc). - // This "copy" check is moved out from the switcher by compiler (at least by gcc) - return copy ? new T(*static_cast<const T*>(copy)) : new T(); - } - }; - template<typename T> - struct CreatorImpl<T, /* IsAcceptedType = */ false> { - static void *Create(const int type, const void *copy) - { - if (QModulesPrivate::QTypeModuleInfo<T>::IsGui) { - if (Q_LIKELY(qMetaTypeGuiHelper)) - return qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].creator(copy); - } - if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget) { - if (Q_LIKELY(qMetaTypeWidgetsHelper)) - return qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].creator(copy); - } - // This point can be reached only for known types that definition is not available, for example - // in bootstrap mode. We have no other choice then ignore it. - return 0; - } - }; -public: - TypeCreator(const int type) - : m_type(type) - {} - - template<typename T> - void *delegate(const T *copy) { return CreatorImpl<T>::Create(m_type, copy); } - void *delegate(const void*) { return 0; } - void *delegate(const QMetaTypeSwitcher::UnknownType *) { return 0; } - void *delegate(const QMetaTypeSwitcher::NotBuiltinType *copy) - { - QMetaType::Creator creator; - const QVector<QCustomTypeInfo> * const ct = customTypes(); - { - QReadLocker locker(customTypesLock()); - if (Q_UNLIKELY(m_type < QMetaType::User || !ct || ct->count() <= m_type - QMetaType::User)) - return 0; - creator = ct->at(m_type - QMetaType::User).creator; - } - Q_ASSERT_X(creator, "void *QMetaType::create(int type, const void *copy)", "The type was not properly registered"); - return creator(copy); - } -private: - const int m_type; -}; -} // namespace /*! Returns a copy of \a copy, assuming it is of type \a type. If \a @@ -1604,65 +1590,11 @@ private: */ void *QMetaType::create(int type, const void *copy) { - TypeCreator typeCreator(type); - return QMetaTypeSwitcher::switcher<void*>(typeCreator, type, copy); + QMetaType info(type); + int size = info.sizeOf(); + return info.construct(operator new(size), copy); } -namespace { -class TypeDestroyer { - template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> - struct DestroyerImpl { - static void Destroy(const int /* type */, void *where) { QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Delete(where); } - }; - template<typename T> - struct DestroyerImpl<T, /* IsAcceptedType = */ false> { - static void Destroy(const int type, void *where) - { - if (QModulesPrivate::QTypeModuleInfo<T>::IsGui) { - if (Q_LIKELY(qMetaTypeGuiHelper)) - qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].deleter(where); - return; - } - if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget) { - if (Q_LIKELY(qMetaTypeWidgetsHelper)) - qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].deleter(where); - return; - } - // This point can be reached only for known types that definition is not available, for example - // in bootstrap mode. We have no other choice then ignore it. - } - }; -public: - TypeDestroyer(const int type) - : m_type(type) - {} - - template<typename T> - void delegate(const T *where) { DestroyerImpl<T>::Destroy(m_type, const_cast<T*>(where)); } - void delegate(const void *) {} - void delegate(const QMetaTypeSwitcher::UnknownType*) {} - void delegate(const QMetaTypeSwitcher::NotBuiltinType *where) { customTypeDestroyer(m_type, (void*)where); } - -private: - static void customTypeDestroyer(const int type, void *where) - { - QMetaType::Destructor deleter; - const QVector<QCustomTypeInfo> * const ct = customTypes(); - { - QReadLocker locker(customTypesLock()); - if (Q_UNLIKELY(type < QMetaType::User || !ct || ct->count() <= type - QMetaType::User)) - return; - deleter = ct->at(type - QMetaType::User).deleter; - } - Q_ASSERT_X(deleter, "void QMetaType::destroy(int type, void *data)", "The type was not properly registered"); - deleter(where); - } - - const int m_type; -}; -} // namespace - - /*! Destroys the \a data, assuming it is of the \a type given. @@ -1670,8 +1602,9 @@ private: */ void QMetaType::destroy(int type, void *data) { - TypeDestroyer deleter(type); - QMetaTypeSwitcher::switcher<void>(deleter, type, data); + QMetaType info(type); + info.destruct(data); + operator delete(data); } namespace { @@ -1969,8 +1902,27 @@ public: MetaObject(const int type) : m_type(type) {} + + template<typename T, bool IsAcceptedType = DefinedTypesFilter::Acceptor<T>::IsAccepted> + struct MetaObjectImpl + { + static const QMetaObject *MetaObject(int /*type*/) + { return QtPrivate::MetaObjectForType<T>::value(); } + }; template<typename T> - const QMetaObject *delegate(const T*) { return QtPrivate::MetaObjectForType<T>::value(); } + struct MetaObjectImpl<T, /* IsAcceptedType = */ false> + { + static const QMetaObject *MetaObject(int type) { + if (QModulesPrivate::QTypeModuleInfo<T>::IsGui) + return Q_LIKELY(qMetaTypeGuiHelper) ? qMetaTypeGuiHelper[type - QMetaType::FirstGuiType].metaObject : 0; + if (QModulesPrivate::QTypeModuleInfo<T>::IsWidget) + return Q_LIKELY(qMetaTypeWidgetsHelper) ? qMetaTypeWidgetsHelper[type - QMetaType::FirstWidgetsType].metaObject : 0; + return 0; + } + }; + + template <typename T> + const QMetaObject *delegate(const T *) { return MetaObjectImpl<T>::MetaObject(m_type); } const QMetaObject *delegate(const void*) { return 0; } const QMetaObject *delegate(const QMetaTypeSwitcher::UnknownType*) { return 0; } const QMetaObject *delegate(const QMetaTypeSwitcher::NotBuiltinType*) { return customMetaObject(m_type); } @@ -1993,7 +1945,9 @@ private: /*! \since 5.0 - Returns QMetaObject of a given \a type, if the \a type is a pointer to type derived from QObject. + returns QMetaType::metaObject for \a type + + \sa metaObject() */ const QMetaObject *QMetaType::metaObjectForType(int type) { @@ -2200,10 +2154,10 @@ QMetaType QMetaType::typeInfo(const int type) { TypeInfo typeInfo(type); QMetaTypeSwitcher::switcher<void>(typeInfo, type, 0); - return typeInfo.info.creator ? QMetaType(QMetaType::NoExtensionFlags + return typeInfo.info.constructor ? QMetaType(static_cast<ExtensionFlag>(QMetaType::CreateEx | QMetaType::DestroyEx) , static_cast<const QMetaTypeInterface *>(0) // typeInfo::info is a temporary variable, we can't return address of it. - , typeInfo.info.creator - , typeInfo.info.deleter + , 0 // unused + , 0 // unused , typeInfo.info.saveOp , typeInfo.info.loadOp , typeInfo.info.constructor @@ -2245,8 +2199,8 @@ QMetaType::QMetaType(const int typeId) Copy constructs a QMetaType object. */ QMetaType::QMetaType(const QMetaType &other) - : m_creator(other.m_creator) - , m_deleter(other.m_deleter) + : m_creator_unused(other.m_creator_unused) + , m_deleter_unused(other.m_deleter_unused) , m_saveOp(other.m_saveOp) , m_loadOp(other.m_loadOp) , m_constructor(other.m_constructor) @@ -2261,8 +2215,8 @@ QMetaType::QMetaType(const QMetaType &other) QMetaType &QMetaType::operator =(const QMetaType &other) { - m_creator = other.m_creator; - m_deleter = other.m_deleter; + m_creator_unused = other.m_creator_unused; + m_deleter_unused = other.m_deleter_unused; m_saveOp = other.m_saveOp; m_loadOp = other.m_loadOp; m_constructor = other.m_constructor; @@ -2311,11 +2265,14 @@ void QMetaType::dtor() Method used for future binary compatible extensions. The function may be called during QMetaType::create to force library call from inlined code. + + ### TODO Qt6 remove the extension */ void *QMetaType::createExtended(const void *copy) const { - Q_UNUSED(copy); - return 0; + if (m_typeId == QMetaType::UnknownType) + return 0; + return m_constructor(operator new(m_size), copy); } /*! @@ -2324,10 +2281,13 @@ void *QMetaType::createExtended(const void *copy) const Method used for future binary compatible extensions. The function may be called during QMetaType::destroy to force library call from inlined code. + + ### TODO Qt6 remove the extension */ void QMetaType::destroyExtended(void *data) const { - Q_UNUSED(data); + m_destructor(data); + operator delete(data); } /*! diff --git a/src/corelib/kernel/qmetatype.h b/src/corelib/kernel/qmetatype.h index 7a45e21253..0e817da8ce 100644 --- a/src/corelib/kernel/qmetatype.h +++ b/src/corelib/kernel/qmetatype.h @@ -1,6 +1,7 @@ /**************************************************************************** ** ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). +** Copyright (C) 2014 Olivier Goffart <ogoffart@woboq.com> ** Contact: http://www.qt-project.org/legal ** ** This file is part of the QtCore module of the Qt Toolkit. @@ -62,6 +63,7 @@ template <typename T> inline Q_DECL_CONSTEXPR int qMetaTypeId(); // F is a tuple: (QMetaType::TypeName, QMetaType::TypeNameID, RealType) +// ### Qt6: reorder the types to match the C++ integral type ranking #define QT_FOR_EACH_STATIC_PRIMITIVE_TYPE(F)\ F(Void, 43, void) \ F(Bool, 1, bool) \ @@ -435,7 +437,8 @@ public: SharedPointerToQObject = 0x20, WeakPointerToQObject = 0x40, TrackingPointerToQObject = 0x80, - WasDeclaredAsMetaType = 0x100 + WasDeclaredAsMetaType = 0x100, + IsGadget = 0x200 }; Q_DECLARE_FLAGS(TypeFlags, TypeFlag) @@ -469,9 +472,19 @@ public: int size, QMetaType::TypeFlags flags, const QMetaObject *metaObject); + static int registerNormalizedType(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName, Destructor destructor, + Constructor constructor, + int size, + QMetaType::TypeFlags flags, + const QMetaObject *metaObject); static int registerTypedef(const char *typeName, int aliasId); static int registerNormalizedTypedef(const QT_PREPEND_NAMESPACE(QByteArray) &normalizedTypeName, int aliasId); static int type(const char *typeName); +#ifndef Q_QDOC + static int type(const QT_PREPEND_NAMESPACE(QByteArray) &typeName); +#else + static int type(const QByteArray &typeName); +#endif static const char *typeName(int type); static int sizeOf(int type); static TypeFlags typeFlags(int type); @@ -661,8 +674,8 @@ public: static void unregisterConverterFunction(int from, int to); private: - Creator m_creator; - Deleter m_deleter; + Creator m_creator_unused; + Deleter m_deleter_unused; SaveOperator m_saveOp; LoadOperator m_loadOp; Constructor m_constructor; @@ -702,18 +715,6 @@ ConverterFunctor<From, To, UnaryFunction>::~ConverterFunctor() namespace QtMetaTypePrivate { template <typename T, bool Accepted = true> struct QMetaTypeFunctionHelper { - static void Delete(void *t) - { - delete static_cast<T*>(t); - } - - static void *Create(const void *t) - { - if (t) - return new T(*static_cast<const T*>(t)); - return new T(); - } - static void Destruct(void *t) { Q_UNUSED(t) // Silence MSVC that warns for POD types. @@ -741,8 +742,6 @@ struct QMetaTypeFunctionHelper { template <typename T> struct QMetaTypeFunctionHelper<T, /* Accepted */ false> { - static void Delete(void *) {} - static void *Create(const void *) { return 0; } static void Destruct(void *) {} static void *Construct(void *, const void *) { return 0; } #ifndef QT_NO_DATASTREAM @@ -1330,14 +1329,27 @@ namespace QtPrivate enum { Value = sizeof(checkType(static_cast<T*>(0))) == sizeof(yes_type) }; }; - template<typename T, bool = IsPointerToTypeDerivedFromQObject<T>::Value> + template<typename T> + struct IsGadgetHelper + { + template<typename X> static typename X::QtGadgetHelper *checkType(X*); + static char checkType(void*); + enum { Value = sizeof(checkType(static_cast<T*>(0))) == sizeof(void*) }; + }; + + template<typename T, typename Enable = void> struct MetaObjectForType { static inline const QMetaObject *value() { return 0; } }; template<typename T> - struct MetaObjectForType<T*, /* isPointerToTypeDerivedFromQObject = */ true> + struct MetaObjectForType<T*, typename QEnableIf<IsPointerToTypeDerivedFromQObject<T*>::Value>::Type> + { + static inline const QMetaObject *value() { return &T::staticMetaObject; } + }; + template<typename T> + struct MetaObjectForType<T, typename QEnableIf<IsGadgetHelper<T>::Value>::Type> { static inline const QMetaObject *value() { return &T::staticMetaObject; } }; @@ -1512,6 +1524,9 @@ struct QMetaTypeId2 template <typename T> struct QMetaTypeId2<const T&> : QMetaTypeId2<T> {}; +template <typename T> +struct QMetaTypeId2<T&> { enum {Defined = false }; }; + namespace QtPrivate { template <typename T, bool Defined = QMetaTypeId2<T>::Defined> struct QMetaTypeIdHelper { @@ -1545,6 +1560,7 @@ namespace QtPrivate { | (IsWeakPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::WeakPointerToQObject : 0) | (IsTrackingPointerToTypeDerivedFromQObject<T>::Value ? QMetaType::TrackingPointerToQObject : 0) | (Q_IS_ENUM(T) ? QMetaType::IsEnumeration : 0) + | (IsGadgetHelper<T>::Value ? QMetaType::IsGadget : 0) }; }; @@ -1594,8 +1610,6 @@ int qRegisterNormalizedMetaType(const QT_PREPEND_NAMESPACE(QByteArray) &normaliz flags |= QMetaType::WasDeclaredAsMetaType; const int id = QMetaType::registerNormalizedType(normalizedTypeName, - QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Delete, - QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Create, QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Destruct, QtMetaTypePrivate::QMetaTypeFunctionHelper<T>::Construct, int(sizeof(T)), @@ -1964,8 +1978,8 @@ inline QMetaType::QMetaType(const ExtensionFlag extensionFlags, const QMetaTypeI uint theTypeFlags, int typeId, const QMetaObject *_metaObject) - : m_creator(creator) - , m_deleter(deleter) + : m_creator_unused(creator) + , m_deleter_unused(deleter) , m_saveOp(saveOp) , m_loadOp(loadOp) , m_constructor(constructor) @@ -1999,16 +2013,14 @@ inline bool QMetaType::isRegistered() const inline void *QMetaType::create(const void *copy) const { - if (Q_UNLIKELY(isExtended(CreateEx))) - return createExtended(copy); - return m_creator(copy); + // ### TODO Qt6 remove the extension + return createExtended(copy); } inline void QMetaType::destroy(void *data) const { - if (Q_UNLIKELY(isExtended(DestroyEx))) - return destroyExtended(data); - m_deleter(data); + // ### TODO Qt6 remove the extension + destroyExtended(data); } inline void *QMetaType::construct(void *where, const void *copy) const diff --git a/src/corelib/kernel/qmetatype_p.h b/src/corelib/kernel/qmetatype_p.h index c75d5ee792..97c0a08729 100644 --- a/src/corelib/kernel/qmetatype_p.h +++ b/src/corelib/kernel/qmetatype_p.h @@ -114,8 +114,6 @@ QT_FOR_EACH_STATIC_WIDGETS_CLASS(QT_DECLARE_WIDGETS_MODULE_TYPES_ITER) class QMetaTypeInterface { public: - QMetaType::Creator creator; - QMetaType::Deleter deleter; QMetaType::SaveOperator saveOp; QMetaType::LoadOperator loadOp; QMetaType::Constructor constructor; @@ -148,8 +146,6 @@ public: #define QT_METATYPE_INTERFACE_INIT_IMPL(Type, DATASTREAM_DELEGATE) \ { \ - /*creator*/(QtMetaTypePrivate::QMetaTypeFunctionHelper<Type, QtMetaTypePrivate::TypeDefinition<Type>::IsAvailable>::Create), \ - /*deleter*/(QtMetaTypePrivate::QMetaTypeFunctionHelper<Type, QtMetaTypePrivate::TypeDefinition<Type>::IsAvailable>::Delete), \ DATASTREAM_DELEGATE(Type) \ /*constructor*/(QtMetaTypePrivate::QMetaTypeFunctionHelper<Type, QtMetaTypePrivate::TypeDefinition<Type>::IsAvailable>::Construct), \ /*destructor*/(QtMetaTypePrivate::QMetaTypeFunctionHelper<Type, QtMetaTypePrivate::TypeDefinition<Type>::IsAvailable>::Destruct), \ @@ -173,8 +169,6 @@ public: #define QT_METATYPE_INTERFACE_INIT_NO_DATASTREAM(Type) QT_METATYPE_INTERFACE_INIT_IMPL(Type, QT_METATYPE_INTERFACE_INIT_EMPTY_DATASTREAM_IMPL) #define QT_METATYPE_INTERFACE_INIT_EMPTY() \ { \ - /*creator*/ 0, \ - /*deleter*/ 0, \ QT_METATYPE_INTERFACE_INIT_EMPTY_DATASTREAM_IMPL(void) \ /*constructor*/ 0, \ /*destructor*/ 0, \ diff --git a/src/corelib/kernel/qmimedata.cpp b/src/corelib/kernel/qmimedata.cpp index 15fdf57747..45aec88429 100644 --- a/src/corelib/kernel/qmimedata.cpp +++ b/src/corelib/kernel/qmimedata.cpp @@ -286,6 +286,11 @@ QVariant QMimeDataPrivate::retrieveTypedData(const QString &format, QVariant::Ty The \c value declaration of each format describes the way in which the data is encoded. + In some cases (e.g. dropping multiple email attachments), multiple data + values are available. They can be accessed by adding an \c index value: + + \snippet code/src_corelib_kernel_qmimedata.cpp 8 + On Windows, the MIME format does not always map directly to the clipboard formats. Qt provides QWinMime to map clipboard formats to open-standard MIME formats. Similarly, the diff --git a/src/corelib/kernel/qobject.cpp b/src/corelib/kernel/qobject.cpp index 492031d7fe..223de0c8e0 100644 --- a/src/corelib/kernel/qobject.cpp +++ b/src/corelib/kernel/qobject.cpp @@ -2661,8 +2661,8 @@ QMetaObject::Connection QObject::connect(const QObject *sender, const char *sign const char *method_arg = method; ++method; // skip code - QByteArray methodName; QArgumentTypeArray methodTypes; + QByteArray methodName = QMetaObjectPrivate::decodeMethodSignature(method, methodTypes); const QMetaObject *rmeta = receiver->metaObject(); int method_index_relative = -1; Q_ASSERT(QMetaObjectPrivate::get(rmeta)->revision >= 7); @@ -4093,14 +4093,16 @@ QObjectUserData* QObject::userData(uint id) const #ifndef QT_NO_DEBUG_STREAM -QDebug operator<<(QDebug dbg, const QObject *o) { +QDebug operator<<(QDebug dbg, const QObject *o) +{ + QDebugStateSaver saver(dbg); if (!o) - return dbg << "QObject(0x0) "; + return dbg << "QObject(0x0)"; dbg.nospace() << o->metaObject()->className() << '(' << (void *)o; if (!o->objectName().isEmpty()) dbg << ", name = " << o->objectName(); dbg << ')'; - return dbg.space(); + return dbg; } #endif diff --git a/src/corelib/kernel/qobject_p.h b/src/corelib/kernel/qobject_p.h index ba26ff7bfb..b663bc8d8c 100644 --- a/src/corelib/kernel/qobject_p.h +++ b/src/corelib/kernel/qobject_p.h @@ -414,9 +414,9 @@ struct Q_CORE_EXPORT QDynamicMetaObjectData struct Q_CORE_EXPORT QAbstractDynamicMetaObject : public QDynamicMetaObjectData, public QMetaObject { - virtual QAbstractDynamicMetaObject *toDynamicMetaObject(QObject *) { return this; } + virtual QAbstractDynamicMetaObject *toDynamicMetaObject(QObject *) Q_DECL_OVERRIDE { return this; } virtual int createProperty(const char *, const char *) { return -1; } - virtual int metaCall(QObject *, QMetaObject::Call c, int _id, void **a) + virtual int metaCall(QObject *, QMetaObject::Call c, int _id, void **a) Q_DECL_OVERRIDE { return metaCall(c, _id, a); } virtual int metaCall(QMetaObject::Call, int _id, void **) { return _id; } // Compat overload }; diff --git a/src/corelib/kernel/qobjectdefs.h b/src/corelib/kernel/qobjectdefs.h index 25e43d0ca0..84e7a65a54 100644 --- a/src/corelib/kernel/qobjectdefs.h +++ b/src/corelib/kernel/qobjectdefs.h @@ -138,15 +138,24 @@ inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {} # define Q_DECL_HIDDEN_STATIC_METACALL Q_DECL_HIDDEN #endif +#if defined(Q_CC_CLANG) && Q_CC_CLANG >= 306 +# define Q_OBJECT_NO_OVERRIDE_WARNING QT_WARNING_DISABLE_CLANG("-Winconsistent-missing-override") +#else +# define Q_OBJECT_NO_OVERRIDE_WARNING +#endif + /* qmake ignore Q_OBJECT */ #define Q_OBJECT \ public: \ Q_OBJECT_CHECK \ + QT_WARNING_PUSH \ + Q_OBJECT_NO_OVERRIDE_WARNING \ static const QMetaObject staticMetaObject; \ virtual const QMetaObject *metaObject() const; \ virtual void *qt_metacast(const char *); \ - QT_TR_FUNCTIONS \ virtual int qt_metacall(QMetaObject::Call, int, void **); \ + QT_WARNING_POP \ + QT_TR_FUNCTIONS \ private: \ Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); \ struct QPrivateSignal {}; @@ -159,7 +168,9 @@ private: \ #define Q_GADGET \ public: \ static const QMetaObject staticMetaObject; \ -private: + typedef void QtGadgetHelper; \ +private: \ + Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); #endif // QT_NO_META_MACROS #else // Q_MOC_RUN diff --git a/src/corelib/kernel/qsocketnotifier.h b/src/corelib/kernel/qsocketnotifier.h index 57535b0d71..978e2912cc 100644 --- a/src/corelib/kernel/qsocketnotifier.h +++ b/src/corelib/kernel/qsocketnotifier.h @@ -66,7 +66,7 @@ Q_SIGNALS: ); protected: - bool event(QEvent *); + bool event(QEvent *) Q_DECL_OVERRIDE; private: Q_DISABLE_COPY(QSocketNotifier) diff --git a/src/corelib/kernel/qtimer.cpp b/src/corelib/kernel/qtimer.cpp index 0803cf302e..cb9219df14 100644 --- a/src/corelib/kernel/qtimer.cpp +++ b/src/corelib/kernel/qtimer.cpp @@ -263,7 +263,7 @@ public: Q_SIGNALS: void timeout(); protected: - void timerEvent(QTimerEvent *); + void timerEvent(QTimerEvent *) Q_DECL_OVERRIDE; }; QSingleShotTimer::QSingleShotTimer(int msec, Qt::TimerType timerType, const QObject *r, const char *member) diff --git a/src/corelib/kernel/qtimer.h b/src/corelib/kernel/qtimer.h index 2890f3ef08..a48113abf6 100644 --- a/src/corelib/kernel/qtimer.h +++ b/src/corelib/kernel/qtimer.h @@ -148,7 +148,7 @@ Q_SIGNALS: ); protected: - void timerEvent(QTimerEvent *); + void timerEvent(QTimerEvent *) Q_DECL_OVERRIDE; private: Q_DISABLE_COPY(QTimer) diff --git a/src/corelib/kernel/qtranslator.cpp b/src/corelib/kernel/qtranslator.cpp index c2d8397ae0..a9c608384a 100644 --- a/src/corelib/kernel/qtranslator.cpp +++ b/src/corelib/kernel/qtranslator.cpp @@ -273,6 +273,7 @@ static uint numerusHelper(int n, const uchar *rules, uint rulesSize) } Q_ASSERT(false); + return 0; } class QTranslatorPrivate : public QObjectPrivate diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp index 2ac1bb11fb..1e71bb8978 100644 --- a/src/corelib/kernel/qvariant.cpp +++ b/src/corelib/kernel/qvariant.cpp @@ -69,13 +69,18 @@ QT_BEGIN_NAMESPACE -#ifndef DBL_DIG -# define DBL_DIG 10 +#ifndef DBL_MANT_DIG +# define DBL_MANT_DIG 53 #endif -#ifndef FLT_DIG -# define FLT_DIG 6 +#ifndef FLT_MANT_DIG +# define FLT_MANT_DIG 24 #endif +const int log10_2_10000 = 30103; // log10(2) * 100000 +// same as C++11 std::numeric_limits<T>::max_digits10 +const int max_digits10_double = (DBL_MANT_DIG * log10_2_10000) / 100000 + 2; +const int max_digits10_float = (FLT_MANT_DIG * log10_2_10000) / 100000 + 2; + namespace { class HandlersManager { @@ -215,8 +220,9 @@ static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok) return qlonglong(qMetaTypeUNumber(d)); } - if (QMetaType::typeFlags(d->type) & QMetaType::IsEnumeration) { - switch (QMetaType::sizeOf(d->type)) { + QMetaType typeInfo(d->type); + if (typeInfo.flags() & QMetaType::IsEnumeration) { + switch (typeInfo.sizeOf()) { case 1: return d->is_shared ? *reinterpret_cast<signed char *>(d->data.shared->ptr) : d->data.sc; case 2: @@ -232,6 +238,26 @@ static qlonglong qConvertToNumber(const QVariant::Private *d, bool *ok) return Q_INT64_C(0); } +static qreal qConvertToRealNumber(const QVariant::Private *d, bool *ok) +{ + *ok = true; + switch (uint(d->type)) { + case QVariant::Double: + return qreal(d->data.d); + case QMetaType::Float: + return qreal(d->data.f); + case QVariant::ULongLong: + case QVariant::UInt: + case QMetaType::UChar: + case QMetaType::UShort: + case QMetaType::ULong: + return qreal(qMetaTypeUNumber(d)); + default: + // includes enum conversion as well as invalid types + return qreal(qConvertToNumber(d, ok)); + } +} + static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok) { *ok = true; @@ -263,8 +289,9 @@ static qulonglong qConvertToUnsignedNumber(const QVariant::Private *d, bool *ok) return qMetaTypeUNumber(d); } - if (QMetaType::typeFlags(d->type) & QMetaType::IsEnumeration) { - switch (QMetaType::sizeOf(d->type)) { + QMetaType typeInfo(d->type); + if (typeInfo.flags() & QMetaType::IsEnumeration) { + switch (typeInfo.sizeOf()) { case 1: return d->is_shared ? *reinterpret_cast<uchar *>(d->data.shared->ptr) : d->data.uc; case 2: @@ -355,10 +382,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) *str = QString::number(qMetaTypeUNumber(d)); break; case QMetaType::Float: - *str = QString::number(d->data.f, 'g', FLT_DIG); + *str = QString::number(d->data.f, 'g', max_digits10_float); break; case QVariant::Double: - *str = QString::number(d->data.d, 'g', DBL_DIG); + *str = QString::number(d->data.d, 'g', max_digits10_double); break; #if !defined(QT_NO_DATESTRING) case QVariant::Date: @@ -535,10 +562,10 @@ static bool convert(const QVariant::Private *d, int t, void *result, bool *ok) *ba = v_cast<QString>(d)->toUtf8(); break; case QVariant::Double: - *ba = QByteArray::number(d->data.d, 'g', DBL_DIG); + *ba = QByteArray::number(d->data.d, 'g', max_digits10_double); break; case QMetaType::Float: - *ba = QByteArray::number(d->data.f, 'g', FLT_DIG); + *ba = QByteArray::number(d->data.f, 'g', max_digits10_float); break; case QMetaType::Char: case QMetaType::SChar: @@ -3133,8 +3160,22 @@ bool QVariant::convert(const int type, void *ptr) const static bool qIsNumericType(uint tp) { - return (tp >= QVariant::Bool && tp <= QVariant::Double) - || (tp >= QMetaType::Long && tp <= QMetaType::Float); + static const qulonglong numericTypeBits = + Q_UINT64_C(1) << QMetaType::Bool | + Q_UINT64_C(1) << QMetaType::Double | + Q_UINT64_C(1) << QMetaType::Float | + Q_UINT64_C(1) << QMetaType::Char | + Q_UINT64_C(1) << QMetaType::SChar | + Q_UINT64_C(1) << QMetaType::UChar | + Q_UINT64_C(1) << QMetaType::Short | + Q_UINT64_C(1) << QMetaType::UShort | + Q_UINT64_C(1) << QMetaType::Int | + Q_UINT64_C(1) << QMetaType::UInt | + Q_UINT64_C(1) << QMetaType::Long | + Q_UINT64_C(1) << QMetaType::ULong | + Q_UINT64_C(1) << QMetaType::LongLong | + Q_UINT64_C(1) << QMetaType::ULongLong; + return tp < (CHAR_BIT * sizeof numericTypeBits) ? numericTypeBits & (Q_UINT64_C(1) << tp) : false; } static bool qIsFloatingPoint(uint tp) @@ -3142,22 +3183,133 @@ static bool qIsFloatingPoint(uint tp) return tp == QVariant::Double || tp == QMetaType::Float; } +static int normalizeLowerRanks(uint tp) +{ + static const qulonglong numericTypeBits = + Q_UINT64_C(1) << QMetaType::Bool | + Q_UINT64_C(1) << QMetaType::Char | + Q_UINT64_C(1) << QMetaType::SChar | + Q_UINT64_C(1) << QMetaType::UChar | + Q_UINT64_C(1) << QMetaType::Short | + Q_UINT64_C(1) << QMetaType::UShort; + return numericTypeBits & (Q_UINT64_C(1) << tp) ? QVariant::Int : tp; +} + +static int normalizeLong(uint tp) +{ + const uint IntType = sizeof(long) == sizeof(int) ? QVariant::Int : QVariant::LongLong; + const uint UIntType = sizeof(ulong) == sizeof(uint) ? QVariant::UInt : QVariant::ULongLong; + return tp == QMetaType::Long ? IntType : + tp == QMetaType::ULong ? UIntType : tp; +} + +static int numericTypePromotion(uint t1, uint t2) +{ + Q_ASSERT(qIsNumericType(t1)); + Q_ASSERT(qIsNumericType(t2)); + + // C++ integral ranks: (4.13 Integer conversion rank [conv.rank]) + // bool < signed char < short < int < long < long long + // unsigneds have the same rank as their signed counterparts + // C++ integral promotion rules (4.5 Integral Promotions [conv.prom]) + // - any type with rank less than int can be converted to int or unsigned int + // 5 Expressions [expr] paragraph 9: + // - if either operand is double, the other shall be converted to double + // - " " float, " " " float + // - if both operands have the same type, no further conversion is needed. + // - if both are signed or if both are unsigned, convert to the one with highest rank + // - if the unsigned has higher or same rank, convert the signed to the unsigned one + // - if the signed can represent all values of the unsigned, convert to the signed + // - otherwise, convert to the unsigned corresponding to the rank of the signed + + // floating point: we deviate from the C++ standard by always using qreal + if (qIsFloatingPoint(t1) || qIsFloatingPoint(t2)) + return QMetaType::QReal; + + // integral rules: + // for all platforms we support, int can always hold the values of lower-ranked types + t1 = normalizeLowerRanks(t1); + t2 = normalizeLowerRanks(t2); + + // normalize long / ulong: in all platforms we run, they're either the same as int or as long long + t1 = normalizeLong(t1); + t2 = normalizeLong(t2); + + // implement the other rules + // the four possibilities are Int, UInt, LongLong and ULongLong + // if any of the two is ULongLong, then it wins (highest rank, unsigned) + // otherwise, if one of the two is LongLong, then the other is either LongLong too or lower-ranked + // otherwise, if one of the two is UInt, then the other is either UInt too or Int + if (t1 == QVariant::ULongLong || t2 == QVariant::ULongLong) + return QVariant::ULongLong; + if (t1 == QVariant::LongLong || t2 == QVariant::LongLong) + return QVariant::LongLong; + if (t1 == QVariant::UInt || t2 == QVariant::UInt) + return QVariant::UInt; + return QVariant::Int; +} + +static int integralCompare(uint promotedType, const QVariant::Private *d1, const QVariant::Private *d2) +{ + // use toLongLong to retrieve the data, it gets us all the bits + bool ok; + qlonglong l1 = qConvertToNumber(d1, &ok); + Q_ASSERT(ok); + + qlonglong l2 = qConvertToNumber(d2, &ok); + Q_ASSERT(ok); + + if (promotedType == QVariant::Int) + return int(l1) < int(l2) ? -1 : int(l1) == int(l2) ? 0 : 1; + if (promotedType == QVariant::UInt) + return uint(l1) < uint(l2) ? -1 : uint(l1) == uint(l2) ? 0 : 1; + if (promotedType == QVariant::LongLong) + return l1 < l2 ? -1 : l1 == l2 ? 0 : 1; + if (promotedType == QVariant::ULongLong) + return qulonglong(l1) < qulonglong(l2) ? -1 : qulonglong(l1) == qulonglong(l2) ? 0 : 1; + + Q_UNREACHABLE(); + return 0; +} + +static int numericCompare(const QVariant::Private *d1, const QVariant::Private *d2) +{ + uint promotedType = numericTypePromotion(d1->type, d2->type); + if (promotedType != QMetaType::QReal) + return integralCompare(promotedType, d1, d2); + + // qreal comparisons + bool ok; + qreal r1 = qConvertToRealNumber(d1, &ok); + Q_ASSERT(ok); + qreal r2 = qConvertToRealNumber(d2, &ok); + Q_ASSERT(ok); + if (qFuzzyCompare(r1, r2)) + return 0; + return r1 < r2 ? -1 : 1; +} + /*! \internal */ bool QVariant::cmp(const QVariant &v) const { + // try numerics first, with C++ type promotion rules (no conversion) + if (qIsNumericType(d.type) && qIsNumericType(v.d.type)) + return numericCompare(&d, &v.d) == 0; + QVariant v1 = *this; QVariant v2 = v; if (d.type != v2.d.type) { - if (qIsNumericType(d.type) && qIsNumericType(v.d.type)) { - if (qIsFloatingPoint(d.type) || qIsFloatingPoint(v.d.type)) - return qFuzzyCompare(toReal(), v.toReal()); - else - return toLongLong() == v.toLongLong(); + if (v2.canConvert(v1.d.type)) { + if (!v2.convert(v1.d.type)) + return false; + } else { + // try the opposite conversion, it might work + qSwap(v1, v2); + if (!v2.convert(v1.d.type)) + return false; } - if (!v2.canConvert(v1.d.type) || !v2.convert(v1.d.type)) - return false; } if (v1.d.type >= QMetaType::User) { int result; @@ -3172,10 +3324,17 @@ bool QVariant::cmp(const QVariant &v) const */ int QVariant::compare(const QVariant &v) const { + // try numerics first, with C++ type promotion rules (no conversion) + if (qIsNumericType(d.type) && qIsNumericType(v.d.type)) + return numericCompare(&d, &v.d); + + // check for equality next, as more types implement operator== than operator< if (cmp(v)) return 0; + QVariant v1 = *this; QVariant v2 = v; + if (v1.d.type != v2.d.type) { // if both types differ, try to convert if (v2.canConvert(v1.d.type)) { @@ -3197,18 +3356,16 @@ int QVariant::compare(const QVariant &v) const } return r; } + + // did we end up with two numerics? If so, restart + if (qIsNumericType(v1.d.type) && qIsNumericType(v2.d.type)) + return v1.compare(v2); } if (v1.d.type >= QMetaType::User) { int result; if (QMetaType::compare(QT_PREPEND_NAMESPACE(constData(d)), QT_PREPEND_NAMESPACE(constData(v2.d)), d.type, &result)) return result; } - if (qIsNumericType(v1.d.type)) { - if (qIsFloatingPoint(v1.d.type)) - return v1.toReal() < v2.toReal() ? -1 : 1; - else - return v1.toLongLong() < v2.toLongLong() ? -1 : 1; - } switch (v1.d.type) { case QVariant::Date: return v1.toDate() < v2.toDate() ? -1 : 1; |