You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
qt3/src/kernel/qmetaobject.cpp

1252 lines
32 KiB

/****************************************************************************
**
** Implementation of QMetaObject class
**
** Created : 930419
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of the kernel module of the Qt GUI Toolkit.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
** Software Foundation and appearing in the files LICENSE.GPL2
** and LICENSE.GPL3 included in the packaging of this file.
** Alternatively you may (at your option) use any later version
** of the GNU General Public License if such license has been
** publicly approved by Trolltech ASA (or its successors, if any)
** and the KDE Free Qt Foundation.
**
** Please review the following information to ensure GNU General
** Public Licensing requirements will be met:
** http://trolltech.com/products/qt/licenses/licensing/opensource/.
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
** or contact the sales department at sales@trolltech.com.
**
** This file may be used under the terms of the Q Public License as
** defined by Trolltech ASA and appearing in the file LICENSE.QPL
** included in the packaging of this file. Licensees holding valid Qt
** Commercial licenses may use this file in accordance with the Qt
** Commercial License Agreement provided with the Software.
**
** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
** herein.
**
**********************************************************************/
#include "qmetaobject.h"
#include "qasciidict.h"
#ifdef QT_THREAD_SUPPORT
#include <private/qmutexpool_p.h>
#endif // QT_THREAD_SUPPORT
/*!
\class QMetaData qmetaobject.h
\reentrant
\brief The QMetaData class provides information about a member function that is known to the meta object system.
\internal
The struct consists of three members, \e name, \e method and \e access:
\code
const char *name; // - member name
const QUMethod* method; // - detailed method description
enum Access { Private, Protected, Public };
Access access; // - access permission
\endcode
*/
/*!
\class QClassInfo qmetaobject.h
\brief The QClassInfo class provides a struct that stores some basic information about a single class.
\internal
The class information is a simple \e name - \e value pair:
\code
const char* name;
const char* value;
\endcode
*/
/*!
\class QMetaObject qmetaobject.h
\brief The QMetaObject class contains meta information about Qt objects.
\ingroup objectmodel
The Meta Object System in Qt is responsible for the signals and
slots inter-object communication mechanism, runtime type
information and the property system. All meta information in Qt is
kept in a single instance of QMetaObject per class.
This class is not normally required for application programming.
But if you write meta applications, such as scripting engines or
GUI builders, you might find these functions useful:
\list
\i className() to get the name of a class.
\i superClassName() to get the name of the superclass.
\i inherits(), the function called by QObject::inherits().
\i superClass() to access the superclass's meta object.
\i numSlots(), numSignals(), slotNames(), and signalNames() to get
information about a class's signals and slots.
\i property() and propertyNames() to obtain information about a
class's properties.
\endlist
Classes may have a list of name-value pairs of class information.
The number of pairs is returned by numClassInfo(), and values are
returned by classInfo().
\sa \link moc.html moc (Meta Object Compiler)\endlink
*/
/*****************************************************************************
The private object.
*****************************************************************************/
// extra flags from moc.y
enum Flags {
Invalid = 0x00000000,
Readable = 0x00000001,
Writable = 0x00000002,
EnumOrSet = 0x00000004,
UnresolvedEnum = 0x00000008,
StdSet = 0x00000100,
Override = 0x00000200,
NotDesignable = 0x00001000,
DesignableOverride = 0x00002000,
NotScriptable = 0x00004000,
ScriptableOverride = 0x00008000,
NotStored = 0x00010000,
StoredOverride = 0x00020000
};
static QAsciiDict<void> *qt_metaobjects = 0;
static int qt_metaobjects_count = 0;
class QMetaObjectPrivate
{
public:
QMetaObjectPrivate() :
#ifndef QT_NO_PROPERTIES
enumData(0), numEnumData(0),
propData(0),numPropData(0),
qt_static_property(0),
#endif
classInfo(0), numClassInfo(0) {}
#ifndef QT_NO_PROPERTIES
const QMetaEnum *enumData;
int numEnumData;
const QMetaProperty *propData;
int numPropData;
bool (*qt_static_property)(QObject*, int, int, QVariant*);
#endif
const QClassInfo *classInfo;
int numClassInfo;
};
/*****************************************************************************
Internal dictionary for fast access to class members
*****************************************************************************/
#if defined(Q_CANNOT_DELETE_CONSTANT)
typedef QMetaData QConstMetaData;
#else
typedef const QMetaData QConstMetaData;
#endif
class Q_EXPORT QMemberDict : public QAsciiDict<QConstMetaData>
{
public:
QMemberDict( int size = 17, bool cs = TRUE, bool ck = TRUE ) :
QAsciiDict<QConstMetaData>(size,cs,ck) {}
QMemberDict( const QMemberDict &dict ) : QAsciiDict<QConstMetaData>(dict) {}
~QMemberDict() { clear(); }
QMemberDict &operator=(const QMemberDict &dict)
{ return (QMemberDict&)QAsciiDict<QConstMetaData>::operator=(dict); }
};
/*
Calculate optimal dictionary size for n entries using prime numbers,
and assuming there are no more than 40 entries.
*/
static int optDictSize( int n )
{
if ( n < 6 )
n = 5;
else if ( n < 10 )
n = 11;
else if ( n < 14 )
n = 17;
else
n = 23;
return n;
}
/*****************************************************************************
QMetaObject member functions
*****************************************************************************/
/*!\internal
*/
QMetaObject::QMetaObject( const char *const class_name, QMetaObject *super_class,
const QMetaData *const slot_data, int n_slots,
const QMetaData *const signal_data, int n_signals,
#ifndef QT_NO_PROPERTIES
const QMetaProperty *const prop_data, int n_props,
const QMetaEnum *const enum_data, int n_enums,
#endif
const QClassInfo *const class_info, int n_info )
{
classname = class_name; // set meta data
superclass = super_class;
superclassname = superclass ? superclass->className() : 0;
slotDict = init( slotData = slot_data, n_slots );
signalDict = init( signalData = signal_data, n_signals );
d = new QMetaObjectPrivate;
reserved = 0;
#ifndef QT_NO_PROPERTIES
d->propData = prop_data;
d->numPropData = n_props;
d->enumData = enum_data;
d->numEnumData = n_enums;
#endif
d->classInfo = class_info;
d->numClassInfo = n_info;
signaloffset = superclass ? ( superclass->signalOffset() + superclass->numSignals() ) : 0;
slotoffset = superclass ? ( superclass->slotOffset() + superclass->numSlots() ) : 0;
#ifndef QT_NO_PROPERTIES
propertyoffset = superclass ? ( superclass->propertyOffset() + superclass->numProperties() ) : 0;
#endif
}
#ifndef QT_NO_PROPERTIES
/*!\internal
*/
QMetaObject::QMetaObject( const char *const class_name, QMetaObject *super_class,
const QMetaData *const slot_data, int n_slots,
const QMetaData *const signal_data, int n_signals,
const QMetaProperty *const prop_data, int n_props,
const QMetaEnum *const enum_data, int n_enums,
bool (*qt_static_property)(QObject*, int, int, QVariant*),
const QClassInfo *const class_info, int n_info )
{
classname = class_name; // set meta data
superclass = super_class;
superclassname = superclass ? superclass->className() : 0;
slotDict = init( slotData = slot_data, n_slots );
signalDict = init( signalData = signal_data, n_signals );
d = new QMetaObjectPrivate;
reserved = 0;
d->propData = prop_data;
d->numPropData = n_props;
d->enumData = enum_data;
d->numEnumData = n_enums;
d->qt_static_property = qt_static_property;
d->classInfo = class_info;
d->numClassInfo = n_info;
signaloffset = superclass ? ( superclass->signalOffset() + superclass->numSignals() ) : 0;
slotoffset = superclass ? ( superclass->slotOffset() + superclass->numSlots() ) : 0;
propertyoffset = superclass ? ( superclass->propertyOffset() + superclass->numProperties() ) : 0;
}
#endif
/*!\internal
*/
QMetaObject::~QMetaObject()
{
delete slotDict; // delete dicts
delete signalDict;
delete d;
#ifdef QT_THREAD_SUPPORT
QMutexLocker( qt_global_mutexpool ?
qt_global_mutexpool->get( &qt_metaobjects ) : 0 );
#endif // QT_THREAD_SUPPORT
if ( qt_metaobjects ) {
qt_metaobjects->remove( classname );
if ( qt_metaobjects->isEmpty() ) {
delete qt_metaobjects;
qt_metaobjects = 0;
}
}
// delete reserved; // Unused void*
}
/*!
\fn const char *QMetaObject::className() const
Returns the class name.
\sa QObject::className(), superClassName()
*/
/*!
\fn const char *QMetaObject::superClassName() const
Returns the class name of the superclass or 0 if there is no
superclass in the QObject hierachy.
\sa className()
*/
/*!
\fn QMetaObject *QMetaObject::superClass() const
Returns the meta object of the super class or 0 if there is no
such object.
*/
/*!
Returns the number of slots for this class.
If \a super is TRUE, inherited slots are included.
\sa slotNames()
*/
int QMetaObject::numSlots( bool super ) const // number of slots
{
int n = slotDict ? slotDict->count() : 0;
if ( !super || !superclass )
return n;
return n + superclass->numSlots( super );
}
/*!
Returns the number of signals for this class.
If \a super is TRUE, inherited signals are included.
\sa signalNames()
*/
int QMetaObject::numSignals( bool super ) const // number of signals
{
int n = signalDict ? signalDict->count() : 0;
if ( !super || !superclass )
return n;
return n + superclass->numSignals( super );
}
/*! \internal
Returns the meta data of the slot with the name \a n or 0 if no
such slot exists.
If \a super is TRUE, inherited slots are included.
*/
const QMetaData* QMetaObject::slot( int index, bool super ) const
{
int idx = index - ( super ? slotOffset() : 0 );
if ( slotDict && idx >= 0 && idx < (int) slotDict->count() ) {
return slotData + idx;
}
if ( !super || !superclass )
return 0;
return superclass->slot( index, super );
}
/*! \internal
Returns the meta data of the signal with the name \a n or 0 if no
such signal exists.
If \a super is TRUE, inherited signals are included.
*/
const QMetaData* QMetaObject::signal( int index, bool super ) const
{
int idx = index - ( super ? signalOffset() : 0 );
if ( signalDict && idx >= 0 && idx < (int) signalDict->count() ) {
return signalData + idx;
}
if ( !super || !superclass )
return 0;
return superclass->signal( index, super );
}
/*!
\fn int QMetaObject::signalOffset() const
\internal
Returns the signal offset for this metaobject.
*/
/*!
\fn int QMetaObject::propertyOffset() const
\internal
Returns the property offset for this metaobject.
*/
/*! \internal
Returns the index of the signal with name \n or -1 if no such signal exists.
If \a super is TRUE, inherited signals are included.
*/
int QMetaObject::findSignal( const char* n, bool super ) const
{
const QMetaObject *mo = this;
int offset = -1;
do {
const QMetaData *md = mo->signalDict ? mo->signalDict->find( n ) : 0;
if ( md ) {
#if defined(QT_CHECK_RANGE)
if ( offset != -1 ) {
qWarning( "QMetaObject::findSignal:%s: Conflict with %s::%s",
className(), mo->className(), n );
return offset;
}
#endif
offset = mo->signalOffset() + ( md - mo->signalData );
#if !defined(QT_CHECK_RANGE)
return offset;
#endif
}
} while ( super && (mo = mo->superclass) );
return offset;
}
/*!
\fn int QMetaObject::slotOffset() const
\internal
Returns the slot offset for this metaobject.
*/
/*! \internal
Returns the index of the slot with name \n or -1 if no such slot exists.
If \a super is TRUE, inherited slots are included.
*/
int QMetaObject::findSlot( const char* n, bool super ) const
{
const QMetaData *md = slotDict ? slotDict->find( n ) : 0;
if ( md )
return slotOffset() + ( md - slotData );
if ( !super || !superclass)
return -1;
return superclass->findSlot( n, super );
}
/*!\internal
*/
QMetaObject *QMetaObject::new_metaobject( const char *classname,
QMetaObject *superclassobject,
const QMetaData * const slot_data, int n_slots,
const QMetaData * const signal_data, int n_signals,
#ifndef QT_NO_PROPERTIES
const QMetaProperty * const prop_data, int n_props,
const QMetaEnum * const enum_data, int n_enums,
#endif
const QClassInfo * const class_info, int n_info )
{
return new QMetaObject( classname, superclassobject, slot_data, n_slots,
signal_data, n_signals,
#ifndef QT_NO_PROPERTIES
prop_data, n_props,
enum_data, n_enums,
#endif
class_info, n_info );
}
#ifndef QT_NO_PROPERTIES
/*!\internal
*/
QMetaObject *QMetaObject::new_metaobject( const char *classname,
QMetaObject *superclassobject,
const QMetaData * const slot_data, int n_slots,
const QMetaData * const signal_data, int n_signals,
const QMetaProperty * const prop_data, int n_props,
const QMetaEnum * const enum_data, int n_enums,
bool (*qt_static_property)(QObject*, int, int, QVariant*),
const QClassInfo * const class_info, int n_info )
{
return new QMetaObject( classname, superclassobject, slot_data, n_slots,
signal_data, n_signals,
prop_data, n_props,
enum_data, n_enums,
qt_static_property,
class_info, n_info );
}
#endif
/*!\internal
*/
QMemberDict *QMetaObject::init( const QMetaData * data, int n )
{
if ( n == 0 ) // nothing, then make no dict
return 0;
QMemberDict *dict = new QMemberDict( optDictSize(n), TRUE, FALSE );
Q_CHECK_PTR( dict );
while ( n-- ) { // put all members into dict
dict->insert( data->name, data );
data++;
}
return dict;
}
/*!
Returns the number of items of class information available for
this class.
If \a super is TRUE, inherited class information is included.
*/
int QMetaObject::numClassInfo( bool super ) const
{
return d->numClassInfo + ((super && superclass)?superclass->numClassInfo(super):0);
}
/*!
Returns the class information with index \a index or 0 if no such
information exists.
If \a super is TRUE, inherited class information is included.
*/
const QClassInfo* QMetaObject::classInfo( int index, bool super ) const
{
if ( index < 0 )
return 0;
if ( index < d->numClassInfo )
return &(d->classInfo[ index ]);
if ( !super || !superclass )
return 0;
return superclass->classInfo( index - d->numClassInfo, super );
}
/*!
\overload
Returns the class information with name \a name or 0 if no such
information exists.
If \a super is TRUE, inherited class information is included.
*/
const char* QMetaObject::classInfo( const char* name, bool super ) const
{
for( int i = 0; i < d->numClassInfo; ++i ) {
if ( qstrcmp( d->classInfo[i].name, name ) == 0 )
return d->classInfo[i].value;
}
if ( !super || !superclass )
return 0;
return superclass->classInfo( name, super );
}
#ifndef QT_NO_PROPERTIES
/*!
Returns the number of properties for this class.
If \a super is TRUE, inherited properties are included.
\sa propertyNames()
*/
int QMetaObject::numProperties( bool super ) const // number of signals
{
int n = d->numPropData;
if ( !super || !superclass )
return n;
return n + superclass->numProperties( super );
}
/*!
Returns the property meta data for the property at index \a index
or 0 if no such property exists.
If \a super is TRUE, inherited properties are included.
\sa propertyNames()
*/
const QMetaProperty* QMetaObject::property( int index, bool super ) const
{
int idx = index - ( super ? propertyOffset() : 0 );
if ( d->propData && idx >= 0 && idx < (int)d->numPropData )
return d->propData + idx;
if ( !super || !superclass )
return 0;
return superclass->property( index, super );
}
/*!
Returns the index for the property with name \a name or -1 if no
such property exists.
If \a super is TRUE, inherited properties are included.
\sa property(), propertyNames()
*/
int QMetaObject::findProperty( const char *name, bool super ) const
{
for( int i = 0; i < d->numPropData; ++i ) {
if ( d->propData[i].isValid() && qstrcmp( d->propData[i].name(), name ) == 0 ) {
return ( super ? propertyOffset() : 0 ) + i;
}
}
if ( !super || !superclass )
return -1;
return superclass->findProperty( name, super );
}
/*! \internal
Returns the index for the property \a prop
or -1 if the property can not be found.
If \a super is TRUE, inherited properties are included.
\sa property(), propertyNames()
*/
int QMetaObject::indexOfProperty( const QMetaProperty* prop, bool super ) const
{
if ( *prop->meta == this )
return ( super ? propertyOffset() : 0 ) + ( prop - d->propData);
if ( !super || !superclass )
return -1;
return superclass->indexOfProperty( prop, super );
}
/*!\internal
Returns the parent property of property \a p or 0, if the property
cannot be resolved.
\a p has to be contained in this meta object
*/
const QMetaProperty* QMetaObject::resolveProperty( const QMetaProperty* p ) const
{
if ( !superclass )
return 0;
return superclass->property( superclass->findProperty( p->n, TRUE ), TRUE );
}
/*!\internal
\overload
The version of resolveProperty that is used by moc generated code
*/
int QMetaObject::resolveProperty( int index ) const
{
if ( !superclass )
return -1;
const QMetaProperty* p = d->propData + ( index - propertyOffset() );
return superclass->findProperty( p->n, TRUE );
}
/*!
Returns a list with the names of all this class's properties.
If \a super is TRUE, inherited properties are included.
\sa property()
*/
QStrList QMetaObject::propertyNames( bool super ) const
{
QStrList l( FALSE );
if ( superclass && super ) {
QStrList sl = superclass->propertyNames( super );
for ( QStrListIterator slit( sl ); slit.current(); ++slit )
l.append( slit.current() );
}
for( int i = 0; i < d->numPropData; ++i ) {
if ( d->propData[i].isValid() )
l.append( d->propData[i].name() );
}
return l;
}
/*!
Returns a list with the names of all this class's signals.
If \a super is TRUE, inherited signals are included.
*/
QStrList QMetaObject::signalNames( bool super ) const
{
QStrList l( FALSE );
int n = numSignals( super );
for( int i = 0; i < n; ++i ) {
l.append( signal(i, super)->name );
}
return l;
}
/*!
Returns a list with the names of all this class's slots.
If \a super is TRUE, inherited slots are included.
\sa numSlots()
*/
QStrList QMetaObject::slotNames( bool super ) const
{
QStrList l( FALSE );
int n = numSlots( super );
for( int i = 0; i < n; ++i )
l.append( slot( i, super)->name );
return l;
}
/*!\internal
*/
int QMetaObject::numEnumerators( bool super ) const
{
int n = 0;
if ( superclass && super )
n += superclass->numEnumerators( super );
return n + d->numEnumData;
}
/*!\internal
*/
QStrList QMetaObject::enumeratorNames( bool super ) const
{
QStrList l( FALSE );
if ( superclass && super ) {
QStrList sl = superclass->enumeratorNames( super );
for ( QStrListIterator slit( sl ); slit.current(); ++slit )
l.append( slit.current() );
}
for( int i = 0; i < d->numEnumData; ++i ) {
if ( d->enumData[i].items )
l.append( d->enumData[i].name );
}
return l;
}
/*!\internal
*/
const QMetaEnum* QMetaObject::enumerator( const char* name, bool super ) const
{
for( int i = 0; i < d->numEnumData; ++i )
if ( qstrcmp( d->enumData[i].name, name ) == 0 )
return &(d->enumData[i]);
if ( !super || !superclass )
return 0;
return superclass->enumerator( name, super );
}
#endif // QT_NO_PROPERTIES
/*!
Returns TRUE if this class inherits \a clname within the meta
object inheritance chain; otherwise returns FALSE.
(A class is considered to inherit itself.)
*/
bool QMetaObject::inherits( const char* clname ) const
{
const QMetaObject *meta = this;
while ( meta ) {
if ( qstrcmp(clname, meta->className()) == 0 )
return TRUE;
meta = meta->superclass;
}
return FALSE;
}
/*! \internal */
QMetaObject *QMetaObject::metaObject( const char *class_name )
{
if ( !qt_metaobjects )
return 0;
#ifdef QT_THREAD_SUPPORT
QMutexLocker( qt_global_mutexpool ?
qt_global_mutexpool->get( &qt_metaobjects ) : 0 );
#endif // QT_THREAD_SUPPORT
QtStaticMetaObjectFunction func = (QtStaticMetaObjectFunction)qt_metaobjects->find( class_name );
if ( func )
return func();
return 0;
}
/*! \internal */
bool QMetaObject::hasMetaObject( const char *class_name )
{
if ( !qt_metaobjects )
return FALSE;
#ifdef QT_THREAD_SUPPORT
QMutexLocker( qt_global_mutexpool ?
qt_global_mutexpool->get( &qt_metaobjects ) : 0 );
#endif // QT_THREAD_SUPPORT
return !!qt_metaobjects->find( class_name );
}
#ifndef QT_NO_PROPERTIES
/*! \internal
### this functions will go away. It exists purely for the sake of meta
### object code generated with Qt 3.1.0
*/
bool QMetaObject::qt_static_property( QObject* o, int id, int f, QVariant* v)
{
if ( d->qt_static_property )
return d->qt_static_property( o, id, f, v );
else if ( o ) // compatibility
return o->qt_property( id, f, v );
else if ( superclass )
return superclass->qt_static_property( o, id, f, v );
switch ( f ) {
case 3: case 4: case 5:
return TRUE;
default:
return FALSE;
}
}
/*!
\class QMetaProperty qmetaobject.h
\brief The QMetaProperty class stores meta data about a property.
\ingroup objectmodel
Property meta data includes type(), name(), and whether a property
is writable(), designable() and stored().
The functions isSetType(), isEnumType() and enumKeys() provide
further information about a property's type. The conversion
functions keyToValue(), valueToKey(), keysToValue() and
valueToKeys() allow conversion between the integer representation
of an enumeration or set value and its literal representation.
Actual property values are set and received through QObject's set
and get functions. See QObject::setProperty() and
QObject::property() for details.
You receive meta property data through an object's meta object.
See QMetaObject::property() and QMetaObject::propertyNames() for
details.
*/
/*!
Returns the possible enumeration keys if this property is an
enumeration type (or a set type).
\sa isEnumType()
*/
QStrList QMetaProperty::enumKeys() const
{
QStrList l( FALSE );
const QMetaEnum* ed = enumData;
if ( !enumData && meta )
ed = (*meta)->enumerator( t, TRUE );
if ( !ed )
return l;
if ( ed != 0 ) {
for( uint i = 0; i < ed->count; ++i ) {
uint j = 0;
while ( j < i &&
ed->items[j].value != ed->items[i].value )
++j;
if ( i == j )
l.append( ed->items[i].key );
}
}
return l;
}
/*!
Converts the enumeration key \a key to its integer value.
For set types, use keysToValue().
\sa valueToKey(), isSetType(), keysToValue()
*/
int QMetaProperty::keyToValue( const char* key ) const
{
const QMetaEnum* ed = enumData;
if ( !enumData && meta )
ed = (*meta)->enumerator( t, TRUE );
if ( !ed )
return -1;
for ( uint i = 0; i < ed->count; ++i ) {
if ( !qstrcmp( key, ed->items[i].key) )
return ed->items[i].value;
}
return -1;
}
/*!
Converts the enumeration value \a value to its literal key.
For set types, use valueToKeys().
\sa valueToKey(), isSetType(), valueToKeys()
*/
const char* QMetaProperty::valueToKey( int value ) const
{
const QMetaEnum* ed = enumData;
if ( !enumData && meta )
ed = (*meta)->enumerator( t, TRUE );
if ( !ed )
return 0;
for ( uint i = 0; i < ed->count; ++i ) {
if ( value == ed->items[i].value )
return ed->items[i].key ;
}
return 0;
}
/*!
Converts the list of keys \a keys to their combined (OR-ed)
integer value.
\sa isSetType(), valueToKey(), keysToValue()
*/
int QMetaProperty::keysToValue( const QStrList& keys ) const
{
const QMetaEnum* ed = enumData;
if ( !enumData && meta )
ed = (*meta)->enumerator( t, TRUE );
if ( !ed )
return -1;
int value = 0;
for ( QStrListIterator it( keys ); it.current(); ++it ) {
uint i;
for( i = ed->count; i > 0; --i ) {
if ( !qstrcmp( it.current(), ed->items[i-1].key) ) {
value |= ed->items[i-1].value;
break;
}
}
if ( i == 0 )
value |= -1;
}
return value;
}
/*!
Converts the set value \a value to a list of keys.
\sa isSetType(), valueToKey(), valueToKeys()
*/
QStrList QMetaProperty::valueToKeys( int value ) const
{
QStrList keys;
const QMetaEnum* ed = enumData;
if ( !enumData && meta )
ed = (*meta)->enumerator( t, TRUE );
if ( !ed )
return keys;
int v = value;
for( uint i = ed->count; i > 0; --i ) {
int k = ed->items[i-1].value;
if ( ( k != 0 && (v & k) == k ) || ( k == value) ) {
v = v & ~k;
keys.append( ed->items[i-1].key );
}
}
return keys;
}
bool QMetaProperty::writable() const
{
if ( !testFlags( Override ) || testFlags( Writable ) )
return testFlags( Writable );
const QMetaObject* mo = (*meta);
const QMetaProperty* parent = mo->resolveProperty( this );
return parent ? parent->writable() : FALSE;
}
/*!\internal
*/
bool QMetaProperty::stdSet() const
{
if ( !testFlags( Override ) || testFlags( Writable ) )
return testFlags( StdSet );
const QMetaObject* mo = (*meta);
const QMetaProperty* parent = mo->resolveProperty( this );
return parent ? parent->stdSet() : FALSE;
}
/*!\internal
*/
int QMetaProperty::id() const
{
return _id < 0 ? (*meta)->indexOfProperty( this, TRUE ) : _id;
}
/*! \internal
*/
void QMetaProperty::clear()
{
t = n = 0;
meta = 0;
enumData = 0;
_id = -1;
flags = 0;
}
bool QMetaProperty::isValid() const
{
if ( testFlags( UnresolvedEnum ) ) {
if ( !enumData && (!meta || !(*meta)->enumerator( t, TRUE ) ) )
return FALSE;
}
if ( !testFlags( Override ) || testFlags( Readable ) )
return testFlags( Readable );
const QMetaObject* mo = (*meta);
const QMetaProperty* parent = mo->resolveProperty( this );
return parent ? parent->isValid() : FALSE;
}
bool QMetaProperty::isSetType() const
{
const QMetaEnum* ed = enumData;
if ( !enumData && meta )
ed = (*meta)->enumerator( t, TRUE );
return ( ed != 0 && ed->set );
}
bool QMetaProperty::isEnumType() const
{
return testFlags( EnumOrSet );
}
/*!
\fn const char* QMetaProperty::type() const
Returns the type of the property.
*/
/*!
\fn const char* QMetaProperty::name() const
Returns the name of the property.
*/
/*!
\fn bool QMetaProperty::writable() const
Returns TRUE if the property is writable; otherwise returns FALSE.
*/
/*! \fn bool QMetaProperty::isValid() const
\internal
Returns whether the property is valid.
*/
/*!
\fn bool QMetaProperty::isEnumType() const
Returns TRUE if the property's type is an enumeration value;
otherwise returns FALSE.
\sa isSetType(), enumKeys()
*/
/*!
\fn bool QMetaProperty::isSetType() const
Returns TRUE if the property's type is an enumeration value that
is used as set, i.e. if the enumeration values can be OR-ed
together; otherwise returns FALSE. A set type is implicitly also
an enum type.
\sa isEnumType(), enumKeys()
*/
/*! Returns TRUE if the property is designable for object \a o;
otherwise returns FALSE.
If no object \a o is given, the function returns a static
approximation.
*/
bool QMetaProperty::designable( QObject* o ) const
{
if ( !isValid() || !writable() )
return FALSE;
if ( o ) {
int idx = _id >= 0 ? _id : (*meta)->indexOfProperty( this, TRUE );
return idx >= 0 && o->qt_property( idx, 3, 0 );
}
if ( testFlags( DesignableOverride ) ) {
const QMetaObject* mo = (*meta);
const QMetaProperty* parent = mo->resolveProperty( this );
return parent ? parent->designable() : FALSE;
}
return !testFlags( NotDesignable );
}
/*!
Returns TRUE if the property is scriptable for object \a o;
otherwise returns FALSE.
If no object \a o is given, the function returns a static
approximation.
*/
bool QMetaProperty::scriptable( QObject* o ) const
{
if ( o ) {
int idx = _id >= 0 ? _id : (*meta)->indexOfProperty( this, TRUE );
return idx >= 0 && o->qt_property( idx, 4, 0 );
}
if ( testFlags( ScriptableOverride ) ) {
const QMetaObject* mo = (*meta);
const QMetaProperty* parent = mo->resolveProperty( this );
return parent ? parent->scriptable() : FALSE;
}
return !testFlags( NotScriptable );
}
/*!
Returns TRUE if the property shall be stored for object \a o;
otherwise returns FALSE.
If no object \a o is given, the function returns a static
approximation.
*/
bool QMetaProperty::stored( QObject* o ) const
{
if ( !isValid() || !writable() )
return FALSE;
if ( o ) {
int idx = _id >= 0 ? _id : (*meta)->indexOfProperty( this, TRUE );
return idx >= 0 && o->qt_property( idx, 5, 0 );
}
if ( testFlags( StoredOverride ) ) {
const QMetaObject* mo = (*meta);
const QMetaProperty* parent = mo->resolveProperty( this );
return parent ? parent->stored() : FALSE;
}
return !testFlags( NotStored );
}
/*!
Tries to reset the property for object \a o with a reset method.
On success, returns TRUE; otherwise returns FALSE.
Reset methods are optional, usually only a few properties support
them.
*/
bool QMetaProperty::reset( QObject* o ) const
{
if ( !o )
return FALSE;
int idx = _id >= 0 ? _id : (*meta)->indexOfProperty( this, TRUE );
if ( idx < 0 )
return 0;
return o->qt_property( idx, 2, 0 );
}
/*! \enum QMetaProperty::Flags
\internal
*/
#endif // QT_NO_PROPERTIES
/*
* QMetaObjectCleanUp is used as static global object in the moc-generated cpp
* files and deletes the QMetaObject provided with setMetaObject. It sets the
* QObject reference to the metaObj to NULL when it is destroyed.
*/
QMetaObjectCleanUp::QMetaObjectCleanUp( const char *mo_name, QtStaticMetaObjectFunction func )
: metaObject( 0 )
{
#ifdef QT_THREAD_SUPPORT
QMutexLocker( qt_global_mutexpool ?
qt_global_mutexpool->get( &qt_metaobjects ) : 0 );
#endif // QT_THREAD_SUPPORT
if ( !qt_metaobjects )
qt_metaobjects = new QAsciiDict<void>( 257 );
qt_metaobjects->insert( mo_name, (void*)func );
qt_metaobjects_count++;
}
QMetaObjectCleanUp::QMetaObjectCleanUp()
: metaObject( 0 )
{
}
/*! \fn bool QMetaProperty::testFlags( uint f ) const
\internal
*/
QMetaObjectCleanUp::~QMetaObjectCleanUp()
{
#ifdef QT_THREAD_SUPPORT
QMutexLocker( qt_global_mutexpool ?
qt_global_mutexpool->get( &qt_metaobjects ) : 0 );
#endif // QT_THREAD_SUPPORT
if ( !--qt_metaobjects_count ) {
delete qt_metaobjects;
qt_metaobjects = 0;
}
if ( metaObject ) {
delete *metaObject;
*metaObject = 0;
metaObject = 0;
}
}
void QMetaObjectCleanUp::setMetaObject( QMetaObject *&mo )
{
#if defined(QT_CHECK_RANGE)
if ( metaObject )
qWarning( "QMetaObjectCleanUp::setMetaObject: Double use of QMetaObjectCleanUp!" );
#endif
metaObject = &mo;
}