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.
1252 lines
32 KiB
1252 lines
32 KiB
/****************************************************************************
|
|
**
|
|
** Implementation of TQMetaObject class
|
|
**
|
|
** Created : 930419
|
|
**
|
|
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
|
|
**
|
|
** This file is part of the kernel module of the TQt 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 TQt 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.TQPL
|
|
** included in the packaging of this file. Licensees holding valid TQt
|
|
** Commercial licenses may use this file in accordance with the TQt
|
|
** 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 "ntqmetaobject.h"
|
|
#include "ntqasciidict.h"
|
|
|
|
#ifdef TQT_THREAD_SUPPORT
|
|
#include <private/qmutexpool_p.h>
|
|
#endif // TQT_THREAD_SUPPORT
|
|
|
|
/*!
|
|
\class TQMetaData ntqmetaobject.h
|
|
\reentrant
|
|
|
|
\brief The TQMetaData 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 TQUMethod* method; // - detailed method description
|
|
enum Access { Private, Protected, Public };
|
|
Access access; // - access permission
|
|
\endcode
|
|
*/
|
|
|
|
/*!
|
|
\class TQClassInfo ntqmetaobject.h
|
|
|
|
\brief The TQClassInfo 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 TQMetaObject ntqmetaobject.h
|
|
\brief The TQMetaObject class contains meta information about TQt objects.
|
|
|
|
\ingroup objectmodel
|
|
|
|
The Meta Object System in TQt is responsible for the signals and
|
|
slots inter-object communication mechanism, runtime type
|
|
information and the property system. All meta information in TQt is
|
|
kept in a single instance of TQMetaObject 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 TQObject::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 TQAsciiDict<void> *qt_metaobjects = 0;
|
|
static int qt_metaobjects_count = 0;
|
|
|
|
class TQMetaObjectPrivate
|
|
{
|
|
public:
|
|
TQMetaObjectPrivate() :
|
|
#ifndef QT_NO_PROPERTIES
|
|
enumData(0), numEnumData(0),
|
|
propData(0),numPropData(0),
|
|
tqt_static_property(0),
|
|
#endif
|
|
classInfo(0), numClassInfo(0) {}
|
|
#ifndef QT_NO_PROPERTIES
|
|
const TQMetaEnum *enumData;
|
|
int numEnumData;
|
|
const TQMetaProperty *propData;
|
|
int numPropData;
|
|
bool (*tqt_static_property)(TQObject*, int, int, TQVariant*);
|
|
#endif
|
|
const TQClassInfo *classInfo;
|
|
int numClassInfo;
|
|
};
|
|
|
|
|
|
/*****************************************************************************
|
|
Internal dictionary for fast access to class members
|
|
*****************************************************************************/
|
|
|
|
#if defined(Q_CANNOT_DELETE_CONSTANT)
|
|
typedef TQMetaData TQConstMetaData;
|
|
#else
|
|
typedef const TQMetaData TQConstMetaData;
|
|
#endif
|
|
|
|
class Q_EXPORT TQMemberDict : public TQAsciiDict<TQConstMetaData>
|
|
{
|
|
public:
|
|
TQMemberDict( int size = 17, bool cs = TRUE, bool ck = TRUE ) :
|
|
TQAsciiDict<TQConstMetaData>(size,cs,ck) {}
|
|
TQMemberDict( const TQMemberDict &dict ) : TQAsciiDict<TQConstMetaData>(dict) {}
|
|
~TQMemberDict() { clear(); }
|
|
TQMemberDict &operator=(const TQMemberDict &dict)
|
|
{ return (TQMemberDict&)TQAsciiDict<TQConstMetaData>::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;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
TQMetaObject member functions
|
|
*****************************************************************************/
|
|
|
|
/*!\internal
|
|
*/
|
|
TQMetaObject::TQMetaObject( const char *const class_name, TQMetaObject *super_class,
|
|
const TQMetaData *const slot_data, int n_slots,
|
|
const TQMetaData *const signal_data, int n_signals,
|
|
#ifndef QT_NO_PROPERTIES
|
|
const TQMetaProperty *const prop_data, int n_props,
|
|
const TQMetaEnum *const enum_data, int n_enums,
|
|
#endif
|
|
const TQClassInfo *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 TQMetaObjectPrivate;
|
|
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
|
|
*/
|
|
TQMetaObject::TQMetaObject( const char *const class_name, TQMetaObject *super_class,
|
|
const TQMetaData *const slot_data, int n_slots,
|
|
const TQMetaData *const signal_data, int n_signals,
|
|
const TQMetaProperty *const prop_data, int n_props,
|
|
const TQMetaEnum *const enum_data, int n_enums,
|
|
bool (*tqt_static_property)(TQObject*, int, int, TQVariant*),
|
|
const TQClassInfo *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 TQMetaObjectPrivate;
|
|
reserved = 0;
|
|
|
|
d->propData = prop_data;
|
|
d->numPropData = n_props;
|
|
d->enumData = enum_data;
|
|
d->numEnumData = n_enums;
|
|
d->tqt_static_property = tqt_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
|
|
*/
|
|
TQMetaObject::~TQMetaObject()
|
|
{
|
|
delete slotDict; // delete dicts
|
|
delete signalDict;
|
|
delete d;
|
|
#ifdef TQT_THREAD_SUPPORT
|
|
TQMutexLocker( tqt_global_mutexpool ?
|
|
tqt_global_mutexpool->get( &qt_metaobjects ) : 0 );
|
|
#endif // TQT_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 *TQMetaObject::className() const
|
|
|
|
Returns the class name.
|
|
|
|
\sa TQObject::className(), superClassName()
|
|
*/
|
|
|
|
/*!
|
|
\fn const char *TQMetaObject::superClassName() const
|
|
|
|
Returns the class name of the superclass or 0 if there is no
|
|
superclass in the TQObject hierachy.
|
|
|
|
\sa className()
|
|
*/
|
|
|
|
/*!
|
|
\fn TQMetaObject *TQMetaObject::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 TQMetaObject::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 TQMetaObject::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 TQMetaData* TQMetaObject::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 TQMetaData* TQMetaObject::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 TQMetaObject::signalOffset() const
|
|
|
|
\internal
|
|
|
|
Returns the signal offset for this metaobject.
|
|
|
|
*/
|
|
|
|
/*!
|
|
\fn int TQMetaObject::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 TQMetaObject::findSignal( const char* n, bool super ) const
|
|
{
|
|
const TQMetaObject *mo = this;
|
|
int offset = -1;
|
|
|
|
do {
|
|
const TQMetaData *md = mo->signalDict ? mo->signalDict->find( n ) : 0;
|
|
if ( md ) {
|
|
#if defined(QT_CHECK_RANGE)
|
|
if ( offset != -1 ) {
|
|
tqWarning( "TQMetaObject::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 TQMetaObject::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 TQMetaObject::findSlot( const char* n, bool super ) const
|
|
{
|
|
const TQMetaData *md = slotDict ? slotDict->find( n ) : 0;
|
|
if ( md )
|
|
return slotOffset() + ( md - slotData );
|
|
if ( !super || !superclass)
|
|
return -1;
|
|
return superclass->findSlot( n, super );
|
|
}
|
|
|
|
/*!\internal
|
|
*/
|
|
TQMetaObject *TQMetaObject::new_metaobject( const char *classname,
|
|
TQMetaObject *superclassobject,
|
|
const TQMetaData * const slot_data, int n_slots,
|
|
const TQMetaData * const signal_data, int n_signals,
|
|
#ifndef QT_NO_PROPERTIES
|
|
const TQMetaProperty * const prop_data, int n_props,
|
|
const TQMetaEnum * const enum_data, int n_enums,
|
|
#endif
|
|
const TQClassInfo * const class_info, int n_info )
|
|
{
|
|
return new TQMetaObject( 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
|
|
*/
|
|
TQMetaObject *TQMetaObject::new_metaobject( const char *classname,
|
|
TQMetaObject *superclassobject,
|
|
const TQMetaData * const slot_data, int n_slots,
|
|
const TQMetaData * const signal_data, int n_signals,
|
|
const TQMetaProperty * const prop_data, int n_props,
|
|
const TQMetaEnum * const enum_data, int n_enums,
|
|
bool (*tqt_static_property)(TQObject*, int, int, TQVariant*),
|
|
const TQClassInfo * const class_info, int n_info )
|
|
{
|
|
return new TQMetaObject( classname, superclassobject, slot_data, n_slots,
|
|
signal_data, n_signals,
|
|
prop_data, n_props,
|
|
enum_data, n_enums,
|
|
tqt_static_property,
|
|
class_info, n_info );
|
|
}
|
|
#endif
|
|
|
|
/*!\internal
|
|
*/
|
|
TQMemberDict *TQMetaObject::init( const TQMetaData * data, int n )
|
|
{
|
|
if ( n == 0 ) // nothing, then make no dict
|
|
return 0;
|
|
TQMemberDict *dict = new TQMemberDict( optDictSize(n), TRUE, FALSE );
|
|
TQ_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 TQMetaObject::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 TQClassInfo* TQMetaObject::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* TQMetaObject::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 TQMetaObject::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 TQMetaProperty* TQMetaObject::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 TQMetaObject::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 TQMetaObject::indexOfProperty( const TQMetaProperty* 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 TQMetaProperty* TQMetaObject::resolveProperty( const TQMetaProperty* 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 TQMetaObject::resolveProperty( int index ) const
|
|
{
|
|
if ( !superclass )
|
|
return -1;
|
|
const TQMetaProperty* 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()
|
|
*/
|
|
TQStrList TQMetaObject::propertyNames( bool super ) const
|
|
{
|
|
TQStrList l( FALSE );
|
|
|
|
if ( superclass && super ) {
|
|
TQStrList sl = superclass->propertyNames( super );
|
|
for ( TQStrListIterator 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.
|
|
*/
|
|
TQStrList TQMetaObject::signalNames( bool super ) const
|
|
{
|
|
TQStrList 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()
|
|
*/
|
|
TQStrList TQMetaObject::slotNames( bool super ) const
|
|
{
|
|
TQStrList l( FALSE );
|
|
int n = numSlots( super );
|
|
for( int i = 0; i < n; ++i )
|
|
l.append( slot( i, super)->name );
|
|
return l;
|
|
}
|
|
|
|
/*!\internal
|
|
|
|
*/
|
|
|
|
int TQMetaObject::numEnumerators( bool super ) const
|
|
{
|
|
int n = 0;
|
|
if ( superclass && super )
|
|
n += superclass->numEnumerators( super );
|
|
return n + d->numEnumData;
|
|
}
|
|
|
|
/*!\internal
|
|
|
|
*/
|
|
TQStrList TQMetaObject::enumeratorNames( bool super ) const
|
|
{
|
|
TQStrList l( FALSE );
|
|
|
|
if ( superclass && super ) {
|
|
TQStrList sl = superclass->enumeratorNames( super );
|
|
for ( TQStrListIterator 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 TQMetaEnum* TQMetaObject::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 TQMetaObject::inherits( const char* clname ) const
|
|
{
|
|
const TQMetaObject *meta = this;
|
|
while ( meta ) {
|
|
if ( qstrcmp(clname, meta->className()) == 0 )
|
|
return TRUE;
|
|
meta = meta->superclass;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*! \internal */
|
|
|
|
TQMetaObject *TQMetaObject::metaObject( const char *class_name )
|
|
{
|
|
if ( !qt_metaobjects )
|
|
return 0;
|
|
#ifdef TQT_THREAD_SUPPORT
|
|
TQMutexLocker( tqt_global_mutexpool ?
|
|
tqt_global_mutexpool->get( &qt_metaobjects ) : 0 );
|
|
#endif // TQT_THREAD_SUPPORT
|
|
TQtStaticMetaObjectFunction func = (TQtStaticMetaObjectFunction)qt_metaobjects->find( class_name );
|
|
if ( func )
|
|
return func();
|
|
return 0;
|
|
}
|
|
|
|
/*! \internal */
|
|
bool TQMetaObject::hasMetaObject( const char *class_name )
|
|
{
|
|
if ( !qt_metaobjects )
|
|
return FALSE;
|
|
#ifdef TQT_THREAD_SUPPORT
|
|
TQMutexLocker( tqt_global_mutexpool ?
|
|
tqt_global_mutexpool->get( &qt_metaobjects ) : 0 );
|
|
#endif // TQT_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 TQt 3.1.0
|
|
*/
|
|
bool TQMetaObject::tqt_static_property( TQObject* o, int id, int f, TQVariant* v)
|
|
{
|
|
if ( d->tqt_static_property )
|
|
return d->tqt_static_property( o, id, f, v );
|
|
else if ( o ) // compatibility
|
|
return o->tqt_property( id, f, v );
|
|
else if ( superclass )
|
|
return superclass->tqt_static_property( o, id, f, v );
|
|
switch ( f ) {
|
|
case 3: case 4: case 5:
|
|
return TRUE;
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
/*!
|
|
\class TQMetaProperty ntqmetaobject.h
|
|
|
|
\brief The TQMetaProperty 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 TQObject's set
|
|
and get functions. See TQObject::setProperty() and
|
|
TQObject::property() for details.
|
|
|
|
You receive meta property data through an object's meta object.
|
|
See TQMetaObject::property() and TQMetaObject::propertyNames() for
|
|
details.
|
|
*/
|
|
|
|
/*!
|
|
Returns the possible enumeration keys if this property is an
|
|
enumeration type (or a set type).
|
|
|
|
\sa isEnumType()
|
|
*/
|
|
TQStrList TQMetaProperty::enumKeys() const
|
|
{
|
|
TQStrList l( FALSE );
|
|
const TQMetaEnum* 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 TQMetaProperty::keyToValue( const char* key ) const
|
|
{
|
|
const TQMetaEnum* 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* TQMetaProperty::valueToKey( int value ) const
|
|
{
|
|
const TQMetaEnum* 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 TQMetaProperty::keysToValue( const TQStrList& keys ) const
|
|
{
|
|
const TQMetaEnum* ed = enumData;
|
|
if ( !enumData && meta )
|
|
ed = (*meta)->enumerator( t, TRUE );
|
|
if ( !ed )
|
|
return -1;
|
|
int value = 0;
|
|
for ( TQStrListIterator 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()
|
|
*/
|
|
TQStrList TQMetaProperty::valueToKeys( int value ) const
|
|
{
|
|
TQStrList keys;
|
|
const TQMetaEnum* 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 TQMetaProperty::writable() const
|
|
{
|
|
if ( !testFlags( Override ) || testFlags( Writable ) )
|
|
return testFlags( Writable );
|
|
const TQMetaObject* mo = (*meta);
|
|
const TQMetaProperty* parent = mo->resolveProperty( this );
|
|
return parent ? parent->writable() : FALSE;
|
|
}
|
|
|
|
/*!\internal
|
|
*/
|
|
bool TQMetaProperty::stdSet() const
|
|
{
|
|
if ( !testFlags( Override ) || testFlags( Writable ) )
|
|
return testFlags( StdSet );
|
|
const TQMetaObject* mo = (*meta);
|
|
const TQMetaProperty* parent = mo->resolveProperty( this );
|
|
return parent ? parent->stdSet() : FALSE;
|
|
}
|
|
|
|
/*!\internal
|
|
*/
|
|
int TQMetaProperty::id() const
|
|
{
|
|
return _id < 0 ? (*meta)->indexOfProperty( this, TRUE ) : _id;
|
|
}
|
|
|
|
/*! \internal
|
|
*/
|
|
void TQMetaProperty::clear()
|
|
{
|
|
t = n = 0;
|
|
meta = 0;
|
|
enumData = 0;
|
|
_id = -1;
|
|
flags = 0;
|
|
}
|
|
|
|
bool TQMetaProperty::isValid() const
|
|
{
|
|
if ( testFlags( UnresolvedEnum ) ) {
|
|
if ( !enumData && (!meta || !(*meta)->enumerator( t, TRUE ) ) )
|
|
return FALSE;
|
|
}
|
|
if ( !testFlags( Override ) || testFlags( Readable ) )
|
|
return testFlags( Readable );
|
|
const TQMetaObject* mo = (*meta);
|
|
const TQMetaProperty* parent = mo->resolveProperty( this );
|
|
return parent ? parent->isValid() : FALSE;
|
|
}
|
|
|
|
bool TQMetaProperty::isSetType() const
|
|
{
|
|
const TQMetaEnum* ed = enumData;
|
|
if ( !enumData && meta )
|
|
ed = (*meta)->enumerator( t, TRUE );
|
|
return ( ed != 0 && ed->set );
|
|
}
|
|
|
|
bool TQMetaProperty::isEnumType() const
|
|
{
|
|
return testFlags( EnumOrSet );
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
\fn const char* TQMetaProperty::type() const
|
|
|
|
Returns the type of the property.
|
|
*/
|
|
|
|
/*!
|
|
\fn const char* TQMetaProperty::name() const
|
|
|
|
Returns the name of the property.
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQMetaProperty::writable() const
|
|
|
|
Returns TRUE if the property is writable; otherwise returns FALSE.
|
|
|
|
*/
|
|
|
|
/*! \fn bool TQMetaProperty::isValid() const
|
|
|
|
\internal
|
|
|
|
Returns whether the property is valid.
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQMetaProperty::isEnumType() const
|
|
|
|
Returns TRUE if the property's type is an enumeration value;
|
|
otherwise returns FALSE.
|
|
|
|
\sa isSetType(), enumKeys()
|
|
*/
|
|
|
|
/*!
|
|
\fn bool TQMetaProperty::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 TQMetaProperty::designable( TQObject* o ) const
|
|
{
|
|
if ( !isValid() || !writable() )
|
|
return FALSE;
|
|
if ( o ) {
|
|
int idx = _id >= 0 ? _id : (*meta)->indexOfProperty( this, TRUE );
|
|
return idx >= 0 && o->tqt_property( idx, 3, 0 );
|
|
}
|
|
if ( testFlags( DesignableOverride ) ) {
|
|
const TQMetaObject* mo = (*meta);
|
|
const TQMetaProperty* 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 TQMetaProperty::scriptable( TQObject* o ) const
|
|
{
|
|
if ( o ) {
|
|
int idx = _id >= 0 ? _id : (*meta)->indexOfProperty( this, TRUE );
|
|
return idx >= 0 && o->tqt_property( idx, 4, 0 );
|
|
}
|
|
if ( testFlags( ScriptableOverride ) ) {
|
|
const TQMetaObject* mo = (*meta);
|
|
const TQMetaProperty* 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 TQMetaProperty::stored( TQObject* o ) const
|
|
{
|
|
if ( !isValid() || !writable() )
|
|
return FALSE;
|
|
if ( o ) {
|
|
int idx = _id >= 0 ? _id : (*meta)->indexOfProperty( this, TRUE );
|
|
return idx >= 0 && o->tqt_property( idx, 5, 0 );
|
|
}
|
|
if ( testFlags( StoredOverride ) ) {
|
|
const TQMetaObject* mo = (*meta);
|
|
const TQMetaProperty* 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 TQMetaProperty::reset( TQObject* o ) const
|
|
{
|
|
if ( !o )
|
|
return FALSE;
|
|
int idx = _id >= 0 ? _id : (*meta)->indexOfProperty( this, TRUE );
|
|
if ( idx < 0 )
|
|
return 0;
|
|
return o->tqt_property( idx, 2, 0 );
|
|
}
|
|
|
|
|
|
/*! \enum TQMetaProperty::Flags
|
|
|
|
\internal
|
|
*/
|
|
|
|
#endif // QT_NO_PROPERTIES
|
|
|
|
/*
|
|
* TQMetaObjectCleanUp is used as static global object in the moc-generated cpp
|
|
* files and deletes the TQMetaObject provided with setMetaObject. It sets the
|
|
* TQObject reference to the metaObj to NULL when it is destroyed.
|
|
*/
|
|
TQMetaObjectCleanUp::TQMetaObjectCleanUp( const char *mo_name, TQtStaticMetaObjectFunction func )
|
|
: metaObject( 0 )
|
|
{
|
|
#ifdef TQT_THREAD_SUPPORT
|
|
TQMutexLocker( tqt_global_mutexpool ?
|
|
tqt_global_mutexpool->get( &qt_metaobjects ) : 0 );
|
|
#endif // TQT_THREAD_SUPPORT
|
|
if ( !qt_metaobjects )
|
|
qt_metaobjects = new TQAsciiDict<void>( 257 );
|
|
qt_metaobjects->insert( mo_name, (void*)func );
|
|
|
|
qt_metaobjects_count++;
|
|
}
|
|
|
|
TQMetaObjectCleanUp::TQMetaObjectCleanUp()
|
|
: metaObject( 0 )
|
|
{
|
|
}
|
|
|
|
/*! \fn bool TQMetaProperty::testFlags( uint f ) const
|
|
\internal
|
|
*/
|
|
|
|
TQMetaObjectCleanUp::~TQMetaObjectCleanUp()
|
|
{
|
|
#ifdef TQT_THREAD_SUPPORT
|
|
TQMutexLocker( tqt_global_mutexpool ?
|
|
tqt_global_mutexpool->get( &qt_metaobjects ) : 0 );
|
|
#endif // TQT_THREAD_SUPPORT
|
|
if ( !--qt_metaobjects_count ) {
|
|
delete qt_metaobjects;
|
|
qt_metaobjects = 0;
|
|
}
|
|
if ( metaObject ) {
|
|
delete *metaObject;
|
|
*metaObject = 0;
|
|
metaObject = 0;
|
|
}
|
|
}
|
|
|
|
void TQMetaObjectCleanUp::setMetaObject( TQMetaObject *&mo )
|
|
{
|
|
#if defined(QT_CHECK_RANGE)
|
|
if (metaObject && metaObject != &mo)
|
|
tqWarning( "TQMetaObjectCleanUp::setMetaObject: Double use of TQMetaObjectCleanUp!" );
|
|
#endif
|
|
metaObject = &mo;
|
|
}
|