qdeclarativemetatype.cpp File Reference

#include <QtDeclarative/qdeclarativeprivate.h>
#include "private/qdeclarativemetatype_p.h"
#include "private/qdeclarativeproxymetaobject_p.h"
#include "private/qdeclarativecustomparser_p.h"
#include "private/qdeclarativeguard_p.h"
#include "private/qdeclarativeengine_p.h"
#include "private/qdeclarativeitemsmodule_p.h"
#include "private/qdeclarativeutilmodule_p.h"
#include <QtCore/qdebug.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qmetaobject.h>
#include <QtCore/qbitarray.h>
#include <QtCore/qreadwritelock.h>
#include <qfileinfo.h>
#include <qdir.h>
#include <qmetatype.h>
#include <qobjectdefs.h>
#include <qdatetime.h>
#include <qbytearray.h>
#include <qreadwritelock.h>
#include <qstring.h>
#include <qstringlist.h>
#include <qvector.h>
#include <qlocale.h>
#include <QtCore/qcryptographichash.h>
#include <QtScript/qscriptvalue.h>
#include <ctype.h>
#include <qbitarray.h>
#include <qurl.h>
#include <qvariant.h>
#include <qsize.h>
#include <qpoint.h>
#include <qrect.h>
#include <qline.h>
#include <qvector3d.h>
#include <QtGui/qfont.h>
#include <QtGui/qpixmap.h>
#include <QtGui/qbrush.h>
#include <QtGui/qcolor.h>
#include <QtGui/qpalette.h>
#include <QtGui/qicon.h>
#include <QtGui/qimage.h>
#include <QtGui/qpolygon.h>
#include <QtGui/qregion.h>
#include <QtGui/qbitmap.h>
#include <QtGui/qcursor.h>
#include <QtGui/qsizepolicy.h>
#include <QtGui/qkeysequence.h>
#include <QtGui/qpen.h>
#include <QtGui/qtextformat.h>
#include <QtGui/qmatrix.h>
#include <QtGui/qtransform.h>
#include <QtGui/qmatrix4x4.h>
#include <QtGui/qvector2d.h>
#include <QtGui/qvector3d.h>
#include <QtGui/qvector4d.h>
#include <QtGui/qquaternion.h>

Go to the source code of this file.

Classes
struct	QDeclarativeMetaTypeData
struct	QDeclarativeMetaTypeData::ModuleInfo
struct	QDeclarativeRegisteredComponentData
class	QDeclarativeTypePrivate

Macros
#define	NS(x)   QT_PREPEND_NAMESPACE(x)

Functions
static void	clone (QMetaObjectBuilder &builder, const QMetaObject *mo, const QMetaObject *ignoreStart, const QMetaObject *ignoreEnd)
	for (int ii=mo->methodOffset();ii< mo->methodCount();++ii)
	Q_DECLARE_METATYPE (QScriptValue)
int	registerAutoParentFunction (QDeclarativePrivate::RegisterAutoParent &autoparent)
int	registerComponent (const QDeclarativePrivate::RegisterComponent &data)
int	registerInterface (const QDeclarativePrivate::RegisterInterface &interface)
int	registerType (const QDeclarativePrivate::RegisterType &type)

Macro Definition Documentation

NS

#define NS

(

x

)

QT_PREPEND_NAMESPACE(x)

Definition at line 90 of file qdeclarativemetatype.cpp.

Referenced by QDeclarativeMetaType::copy().

Function Documentation

clone()

static void clone ( QMetaObjectBuilder &  builder, const QMetaObject *  mo, const QMetaObject *  ignoreStart, const QMetaObject *  ignoreEnd  )

static

Definition at line 293 of file qdeclarativemetatype.cpp.

Referenced by QDeclarativeTypePrivate::init(), QStandardItem::isDropEnabled(), and QTestEvent::~QTestEvent().

{
    // Clone Q_CLASSINFO
    for (int ii = mo->classInfoOffset(); ii < mo->classInfoCount(); ++ii) {
        QMetaClassInfo info = mo->classInfo(ii);

        int otherIndex = ignoreEnd->indexOfClassInfo(info.name());
        if (otherIndex >= ignoreStart->classInfoOffset() + ignoreStart->classInfoCount()) {
            // Skip 
        } else {
            builder.addClassInfo(info.name(), info.value());
        }
    }

    // Clone int ii;; ii < mo->propertyCount(); ++ii) {
        QMetaProperty property = mo->property(ii);

        int otherIndex = ignoreEnd->indexOfProperty(property.name());
        if (otherIndex >= ignoreStart->propertyOffset() + ignoreStart->propertyCount()) {
            builder.addProperty(QByteArray("__qml_ignore__") + property.name(), QByteArray("void"));
            // Skip 
        } else {
            builder.addProperty(property);
        }
    }

for()

for

(

int

ii = mo->methodOffset(); ii < mo->methodCount(); ++ii

)

Definition at line 321 of file qdeclarativemetatype.cpp.

Referenced by QMacPixmapData::copy(), dither_to_Mono(), QX11PixmapData::fromImage(), getGlyphData(), QTreeView::keyboardSearch(), QTextLineItemIterator::next(), QHeaderView::sectionsInserted(), QByteArray::toHex(), QX11PixmapData::toImage(), and QTextEngine::width().

                                                                    {
        QMetaMethod method = mo->method(ii);

        // More complex - need to search name
        QByteArray name = method.signature();
        int parenIdx = name.indexOf('(');
        if (parenIdx != -1) name = name.left(parenIdx);


        bool found = false;

        for (int ii = ignoreStart->methodOffset() + ignoreStart->methodCount(); 
             !found && ii < ignoreEnd->methodOffset() + ignoreEnd->methodCount();
             ++ii) {

            QMetaMethod other = ignoreEnd->method(ii);
            QByteArray othername = other.signature();
            int parenIdx = othername.indexOf('(');
            if (parenIdx != -1) othername = othername.left(parenIdx);

            found = name == othername;
        }

        QMetaMethodBuilder m = builder.addMethod(method);
        if (found) // SKIP
            m.setAccess(QMetaMethod::Private);
    }

Q_DECLARE_METATYPE()

Q_DECLARE_METATYPE

(

QScriptValue

)

Referenced by QDeclarativeMetaType::qmlTypes().

registerAutoParentFunction()

int registerAutoParentFunction

(

QDeclarativePrivate::RegisterAutoParent &

autoparent

)

Definition at line 589 of file qdeclarativemetatype.cpp.

Referenced by QDeclarativePrivate::qmlregister().

{
    QWriteLocker lock(metaTypeDataLock());
    QDeclarativeMetaTypeData *data = metaTypeData();

    data->parentFunctions.append(autoparent.function);

    return data->parentFunctions.count() - 1;
}

registerComponent()

int registerComponent

(

const QDeclarativePrivate::RegisterComponent &

data

)

Definition at line 679 of file qdeclarativemetatype.cpp.

{
    if (data.typeName) {
        for (int ii = 0; data.typeName[ii]; ++ii) {
            if (!isalnum(data.typeName[ii])) {
                qWarning("qmlRegisterType(): Invalid QML type name \"%s\"", data.typeName);
                return 0;
            }
        }
    } else {
        qWarning("qmlRegisterType(): No QML type name for \"%s\"", data.url.toString().toLatin1().constData());
        return 0;
    }

    QWriteLocker lock(registeredComponentDataLock());
    QString path;
    // Relative paths are relative to application working directory
    if (data.url.isRelative() || data.url.scheme() == QLatin1String("file")) // Workaround QTBUG-11929
        path = QUrl::fromLocalFile(QDir::currentPath()+QLatin1String("/")).resolved(data.url).toString();
    else
        path = data.url.toString();
    QDeclarativeRegisteredComponentData *d = registeredComponentData();
    QDeclarativeDirParser::Component comp(
        QString::fromUtf8(data.typeName),
        path,
        data.majorVersion,
        data.minorVersion
    );

    QDeclarativeDirComponents* comps = d->registeredComponents.value(QByteArray(data.uri), 0);
    if (!comps)
        d->registeredComponents.insert(QByteArray(data.uri), comps = new QDeclarativeDirComponents);

    // Types added later should take precedence, like registerType
    comps->prepend(comp);

    return 1;
}

registerInterface()

int registerInterface

(

const QDeclarativePrivate::RegisterInterface &

interface

)

Definition at line 599 of file qdeclarativemetatype.cpp.

Referenced by QAccessibleHierarchyManager::registerInterface(), QAccessible::updateAccessibility(), and QAccessibleHierarchyManager::~QAccessibleHierarchyManager().

{
    if (interface.version > 0) 
        qFatal("qmlRegisterType(): Cannot mix incompatible QML versions.");

    QWriteLocker lock(metaTypeDataLock());
    QDeclarativeMetaTypeData *data = metaTypeData();

    int index = data->types.count();

    QDeclarativeType *type = new QDeclarativeType(index, interface);

    data->types.append(type);
    data->idToType.insert(type->typeId(), type);
    data->idToType.insert(type->qListTypeId(), type);
    // XXX No insertMulti, so no multi-version interfaces?
    if (!type->qmlTypeName().isEmpty())
        data->nameToType.insert(type->qmlTypeName(), type);

    if (data->interfaces.size() <= interface.typeId)
        data->interfaces.resize(interface.typeId + 16);
    if (data->lists.size() <= interface.listId)
        data->lists.resize(interface.listId + 16);
    data->interfaces.setBit(interface.typeId, true);
    data->lists.setBit(interface.listId, true);

    return index;
}

registerType()

int registerType

(

const QDeclarativePrivate::RegisterType &

type

)

Definition at line 628 of file qdeclarativemetatype.cpp.

{
    if (type.elementName) {
        for (int ii = 0; type.elementName[ii]; ++ii) {
            if (!isalnum(type.elementName[ii])) {
                qWarning("qmlRegisterType(): Invalid QML element name \"%s\"", type.elementName);
                return -1;
            }
        }
    }

    QWriteLocker lock(metaTypeDataLock());
    QDeclarativeMetaTypeData *data = metaTypeData();
    int index = data->types.count();

    QDeclarativeType *dtype = new QDeclarativeType(index, type);

    data->types.append(dtype);
    data->idToType.insert(dtype->typeId(), dtype);
    if (dtype->qListTypeId()) data->idToType.insert(dtype->qListTypeId(), dtype);

    if (!dtype->qmlTypeName().isEmpty())
        data->nameToType.insertMulti(dtype->qmlTypeName(), dtype);

    data->metaObjectToType.insertMulti(dtype->baseMetaObject(), dtype);

    if (data->objects.size() <= type.typeId)
        data->objects.resize(type.typeId + 16);
    if (data->lists.size() <= type.listId)
        data->lists.resize(type.listId + 16);
    data->objects.setBit(type.typeId, true);
    if (type.listId) data->lists.setBit(type.listId, true);

    if (type.uri) {
        QByteArray mod(type.uri);
        QDeclarativeMetaTypeData::ModuleInfoHash::Iterator it = data->modules.find(mod);
        if (it == data->modules.end()) {
            // New module
            data->modules.insert(mod, QDeclarativeMetaTypeData::ModuleInfo(type.versionMajor,type.versionMinor));
        } else if ((*it).vmajor_max < type.versionMajor || ((*it).vmajor_max == type.versionMajor && (*it).vminor_max < type.versionMinor)) {
            // Newer module
            data->modules.insert(mod, QDeclarativeMetaTypeData::ModuleInfo((*it).vmajor_min, (*it).vminor_min, type.versionMajor, type.versionMinor));
        } else if ((*it).vmajor_min > type.versionMajor || ((*it).vmajor_min == type.versionMajor && (*it).vminor_min > type.versionMinor)) {
            // Older module
            data->modules.insert(mod, QDeclarativeMetaTypeData::ModuleInfo(type.versionMajor, type.versionMinor, (*it).vmajor_min, (*it).vminor_min));
        }
    }

    return index;
}