Added TQt4 HEAD

1 files changed, 1792 insertions, 0 deletions

diff --git a/tqtinterface/qt4/src/kernel/tqmetaobject.cpp b/tqtinterface/qt4/src/kernel/tqmetaobject.cpp
new file mode 100644
index 0000000..09d8439
--- /dev/null
+++ b/tqtinterface/qt4/src/kernel/tqmetaobject.cpp
@@ -0,0 +1,1792 @@
+/****************************************************************************
+**
+** Implementation of TQMetaObject class
+**
+** Created : 930419
+**
+** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA.
+**
+** 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 "tqmetaobject.h"
+#include "tqasciidict.h"
+
+#ifdef TQT_THREAD_SUPPORT
+#include <private/tqmutexpool_p.h>
+#endif // TQT_THREAD_SUPPORT
+
+#include <private/tqucom_p.h>
+
+#ifdef USE_QT4
+
+// #include <private/qt4_qmetaobject_p.h>
+
+/*!
+    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 );
+	int n = numProperties( super );
+	for( int i = 0; i < n; ++i ) {
+		if (property( i, super))
+			l.append( property( i, super)->name() );
+		else
+			l.append( "[TQt TQMetaObject::propertyNames was unable to find the Qt4 name for this property]" );
+	}
+	return l;
+}
+
+const char * TQMetaData::name() const {
+	return signature();		// Member name
+}
+
+const TQUMethod* TQMetaData::method() const {
+	// FIXME
+	// Verify that this routine accurately fills internal_method_information!
+	printf("[WARNING] const TQUMethod* TQMetaData::method() partially implemented!\n\r");
+
+	if (!internal_method_information) {
+		internal_method_information = new TQUMethod;
+		internal_method_information->parameters = 0;
+	}
+	internal_method_information->name = QMetaMethod::signature();
+	internal_method_information->count = QMetaMethod::parameterNames().count();
+	if (internal_method_information->parameters) {
+		for (int i=0; i<internal_method_information->count; i++) {
+			if (internal_method_information->parameters[i].type)
+				delete internal_method_information->parameters[i].type;
+		}
+		delete [] internal_method_information->parameters;
+	}
+	internal_method_information->parameters = new TQUParameter[internal_method_information->count];
+	for (int i=0; i<internal_method_information->count; i++) {
+		const_cast<TQUParameter&>(internal_method_information->parameters[i]).name = QMetaMethod::parameterNames().at(i).data();
+// 		const_cast<TQUParameter&>(internal_method_information->parameters[i]).type = new TQUType;
+// 		const_cast<TQUParameter&>(internal_method_information->parameters[i]).type.desc = QMetaMethod::parameterTypes().at(i).data();
+		const_cast<TQUParameter&>(internal_method_information->parameters[i]).typeExtra = 0;
+		const_cast<TQUParameter&>(internal_method_information->parameters[i]).inOut = 3;
+	}
+	return internal_method_information;
+}
+
+TQMetaEnum::TQMetaEnum() : QMetaEnum() { internal_item_list = 0; }
+
+uint TQMetaEnum::count() const {
+	return QMetaEnum::keyCount();
+}
+
+TQMetaEnum::Item* TQMetaEnum::items() const {
+	if (internal_item_list)
+		delete [] internal_item_list;
+	int internal_item_count = count();
+	internal_item_list = new Item[internal_item_count];
+	for (int i=0; i<internal_item_count;i++) {
+		internal_item_list[i].key = QMetaEnum::key(i);
+		internal_item_list[i].value = QMetaEnum::value(i);
+	}
+	return internal_item_list;
+}
+
+TQMetaData::TQMetaData() : QMetaMethod() {}
+
+TQMetaProperty::TQMetaProperty() : QMetaProperty() {}
+
+/*!
+    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 );
+    QMetaEnum ed = enumerator();
+    for( uint i = 0; i < ed.keyCount(); ++i ) {
+	uint j = 0;
+	while ( j < i && ed.value(j) != ed.value(i) )
+		++j;
+	if ( i == j )
+		l.append( ed.key(i) );
+    }
+    return l;
+}
+
+bool TQMetaProperty::isSetType() const {
+	return isFlagType ();
+}
+
+int TQMetaProperty::keyToValue( const char* key ) const {
+	return enumerator().keyToValue(key);
+}
+
+const char* TQMetaProperty::valueToKey( int value ) const {
+	return enumerator().valueToKey(value);
+}
+
+int TQMetaProperty::keysToValue( const TQStrList& keys_in ) const {
+	TQString tqs = "";
+	TQStrList keys = keys_in;
+	char *key;
+	for ( key = keys.first(); key; key = keys.next() ) {
+		tqs = tqs + "|" + key;
+	}
+	tqs.remove(0,1);
+	return enumerator().keysToValue(TQCString(tqs));
+}
+
+TQStrList TQMetaProperty::valueToKeys( int value ) const {
+	TQStrList keys;
+	QByteArray qba = enumerator().valueToKeys(value);
+	TQStringList keys_out = TQStringList::split("|", TQString(TQCString(qba)));
+	for ( TQStringList::Iterator it = keys_out.begin(); it != keys_out.end(); ++it ) {
+		keys.append(*it);
+	}
+	return keys;
+}
+
+bool TQMetaProperty::writable() const {
+	return isWritable();
+}
+
+const char* TQMetaProperty::type() const {
+	return QMetaProperty::typeName();
+}
+
+bool TQMetaProperty::designable( TQT_BASE_OBJECT_NAME *o ) const {
+	return isDesignable(o);
+}
+
+bool TQMetaProperty::scriptable( TQT_BASE_OBJECT_NAME *o ) const {
+	return isScriptable(o);
+}
+
+bool TQMetaProperty::stored( TQT_BASE_OBJECT_NAME *o ) const {
+	return isStored(o);
+}
+
+/*!\internal
+ */
+bool TQMetaProperty::stdSet() const
+{
+//     if ( !testFlags( Override ) || testFlags( Writable ) )
+// 	return testFlags( StdSet );
+//     const TQMetaObject* mo = (*meta);
+//     const TQMetaProperty* tqparent = mo->resolveProperty( this );
+//     return tqparent ? tqparent->stdSet() : FALSE;
+
+	// [FIXME]
+	printf("[WARNING] bool TQMetaProperty::stdSet() const unimplemented\n\r");
+	return FALSE;
+}
+
+TQMetaObject::TQMetaObject( const char * const class_name, TQMetaObject *superclass, const TQMetaData * const slot_data, int n_Q_SLOTS, const TQMetaData * const signal_data, int n_Q_SIGNALS,
+#ifndef TQT_NO_PROPERTIES
+  const TQMetaProperty *const prop_data, int n_props, const TQMetaEnum *const enum_data, int n_enums,
+#endif // TQT_NO_PROPERTIES
+  const TQClassInfo *const class_info, int n_info ) : QMetaObject() {
+	printf("[WARNING] TQMetaObject() constructor unimplemented\n\r");	// [FIXME]
+}
+
+#ifndef TQT_NO_PROPERTIES
+TQMetaObject::TQMetaObject( const char * const class_name, TQMetaObject *superclass, const TQMetaData * const slot_data, int n_Q_SLOTS, const TQMetaData * const signal_data, int n_Q_SIGNALS, const TQMetaProperty *const prop_data, int n_props, const TQMetaEnum *const enum_data, int n_enums, bool (*qt_static_property)(TQObject*, int, int, TQVariant*), const TQClassInfo *const class_info, int n_info ) : QMetaObject() {
+	printf("[WARNING] TQMetaObject() constructor unimplemented\n\r");	// [FIXME]
+}
+#endif // TQT_NO_PROPERTIES
+
+TQStrList TQMetaObject::slotNames( bool super ) const {
+	printf("[WARNING] TQStrList slotNames( bool super = FALSE ) unimplemented\n\r");
+	return TQStrList();
+}
+
+TQStrList TQMetaObject::signalNames( bool super ) const {
+	printf("[WARNING] TQStrList signalNames( bool super = FALSE ) const unimplemented\n\r");
+	return TQStrList();
+}
+
+/*!
+    Returns the number of Q_SLOTS for this class.
+
+    If \a super is TRUE, inherited Q_SLOTS are included.
+
+    \sa slotNames()
+*/
+int TQMetaObject::numSlots( bool super ) const	// number of Q_SLOTS
+{
+	int i;
+	int n=0;
+	for (i=0;i<methodCount();i++) {
+		if (method(i).methodType() == QMetaMethod::Slot) {
+			n++;
+		}
+	}
+
+	if ( !super || !superClass() )
+		return n;
+	return n + tqsuperClass()->numSlots( super );
+}
+
+/*!
+    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 classInfoCount() + ((super && tqsuperClass())?tqsuperClass()->numClassInfo(super):0);
+}
+
+/*!
+    Returns the number of Q_SIGNALS for this class.
+
+    If \a super is TRUE, inherited Q_SIGNALS are included.
+
+    \sa signalNames()
+*/
+int TQMetaObject::numSignals( bool super ) const	// number of Q_SIGNALS
+{
+	int i;
+	int n=0;
+	for (i=0;i<methodCount();i++) {
+		if (method(i).methodType() == QMetaMethod::Signal) {
+			n++;
+		}
+	}
+
+	if ( !super || !superClass() )
+		return n;
+	return n + tqsuperClass()->numSignals( super );
+}
+
+#if 0
+/*!  \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.
+
+  [FIXME]: Superclass handling is badly broken
+ */
+const TQMetaData* TQMetaObject::slot( int index, bool super ) const
+{
+    QMetaMethod mm;
+    const QMetaMethod *mr;
+    int idx = index - ( super ? methodOffset() : 0 );
+//    if ( slotDict && idx >= 0 && idx < (int) slotDict->count() ) {
+    if ( idx >= 0 && idx < numSlots(true) ) {
+//	return slotData + idx;
+        mm = method(idx);
+	mr = &mm;
+	return static_cast<const TQMetaData*>(mr);
+    }
+    if ( !super || !superClass() )
+	return 0;
+    return tqsuperClass()->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.
+
+  [FIXME]: Superclass handling is badly broken
+ */
+const TQMetaData* TQMetaObject::signal( int index, bool super ) const
+{
+    QMetaMethod mm;
+    const QMetaMethod *mr;
+    int idx = index - ( super ? methodOffset() : 0 );
+//    if ( signalDict && idx >= 0 && idx < (int) signalDict->count() ) {
+    if ( idx >= 0 && idx < numSignals(true) ) {
+//	return signalData + idx;
+        mm = method(idx);
+	mr = &mm;
+	return static_cast<const TQMetaData*>(mr);
+    }
+    if ( !super || !superClass() )
+	return 0;
+    return tqsuperClass()->signal( index, super );
+}
+#endif
+
+/*!  \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.
+
+  [FIXME]: Superclass handling is badly broken
+ */
+const TQMetaData* TQMetaObject::slot( int index, bool super ) const
+{
+    QMetaMethod mm;
+    const QMetaMethod *mr;
+    int idx = index - ( super ? methodOffset() : 0 );
+//    if ( slotDict && idx >= 0 && idx < (int) slotDict->count() ) {
+    if ( idx >= 0 && idx < numSlots(true) ) {
+//	return slotData + idx;
+        mm = method(idx);
+	mr = &mm;
+	return static_cast<const TQMetaData*>(mr);
+    }
+    if ( !super || !superClass() )
+	return 0;
+    return tqsuperClass()->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.
+
+  [FIXME]: Superclass handling is badly broken
+ */
+const TQMetaData* TQMetaObject::signal( int index, bool super ) const
+{
+    QMetaMethod mm;
+    const QMetaMethod *mr;
+    int idx = index - ( super ? methodOffset() : 0 );
+//    if ( signalDict && idx >= 0 && idx < (int) signalDict->count() ) {
+    if ( idx >= 0 && idx < numSignals(true) ) {
+//	return signalData + idx;
+        mm = method(idx);
+	mr = &mm;
+	return static_cast<const TQMetaData*>(mr);
+    }
+    if ( !super || !superClass() )
+	return 0;
+    return tqsuperClass()->signal( index, super );
+}
+
+/*! \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.
+
+  [FIXME]: Superclass handling is badly broken
+ */
+int TQMetaObject::tqfindSlot( const char* n, bool super ) const
+{
+//     TQStrList l( FALSE );
+//     int m = methodCount();
+//     for( int i = 0; i < m; ++i ) {
+// // 	if ( normalizedSignature(slot( i, super)->signature()) == QByteArray(n) ) {
+// 	if ( normalizedSignature(method(i).signature()) == QByteArray(n) ) {
+// 		if (method(i).methodType() == QMetaMethod::Slot) {
+// 			return i;
+// 		}
+// 	}
+//     }
+//     return -1;
+
+    if (super) printf("[WARNING] In TQMetaObject::tqfindSlot(), superclasses are not being searched for the slot\n\r");
+    return indexOfSlot(normalizedSignature(n));
+}
+
+/*! \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.
+
+  [FIXME]: Superclass handling is badly broken
+*/
+int TQMetaObject::tqfindSignal( const char* n, bool super ) const
+{
+//     TQStrList l( FALSE );
+//     int m = methodCount();
+//     for( int i = 0; i < m; ++i ) {
+// // 	if ( normalizedSignature(signal( i, super)->signature()) == QByteArray(n) ) {
+// 	if ( normalizedSignature(method(i).signature()) == QByteArray(n) ) {
+// 		if (method(i).methodType() == QMetaMethod::Signal) {
+// 			return i;
+// 		}
+// 	}
+//     }
+//     return -1;
+
+    if (super) printf("[WARNING] In TQMetaObject::tqfindSignal(), superclasses are not being searched for the signal\n\r");
+    return indexOfSignal(normalizedSignature(n));
+}
+
+#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 properties
+{
+    int i;
+    int n=0;
+    for (i=0;i<propertyCount();i++) {
+//	if (property(i).propertyType() == QMetaProperty::Property) {
+		n++;
+//	}
+    }
+
+    if ( !super || !superClass() )
+	return n;
+    return n + tqsuperClass()->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()
+
+    [FIXME]: Superclass handling is badly broken
+ */
+static QMetaProperty tqmo_propmethod_curprop;
+const TQMetaProperty* TQMetaObject::property( int index, bool super ) const
+{
+    QMetaProperty mp;
+    const QMetaProperty *pr;
+    int idx = index - ( super ? propertyOffset() : 0 );
+//    if ( d->propData && idx >= 0 && idx < (int)d->numPropData )
+    if ( idx >= 0 && idx < numProperties(true) )
+	tqmo_propmethod_curprop = QMetaObject::property(idx);
+	return static_cast<const TQMetaProperty*>(&tqmo_propmethod_curprop);
+    if ( !super || !superClass() )
+	return 0;
+    return tqsuperClass()->property( index, super );
+}
+
+int TQMetaObject::tqfindProperty( const char *name, bool super ) const {
+	TQ_UNUSED(name);
+	return indexOfProperty(name);
+}
+
+TQMetaObject * TQMetaObject::tqsuperClass() const {
+	return static_cast<TQMetaObject*>(const_cast<QMetaObject*>(superClass()));
+}
+
+const char * TQMetaObject::tqsuperClassName() const {
+	return static_cast<TQMetaObject*>(const_cast<QMetaObject*>(superClass()))->className();
+}
+
+#endif // QT_NO_PROPERTIES
+
+/*!
+    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 < QMetaObject::classInfoCount() )
+	return static_cast<TQClassInfo*>(&(QMetaObject::classInfo(index)));
+    if ( !super || !superClass() )
+	return 0;
+    return tqsuperClass()->classInfo( index - QMetaObject::classInfoCount(), 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 < QMetaObject::classInfoCount(); ++i ) {
+	if ( qstrcmp( QMetaObject::classInfo(i).name(), name ) == 0 )
+	    return QMetaObject::classInfo(i).value();
+    }
+    if ( !super || !superClass() )
+	return 0;
+    return tqsuperClass()->classInfo( name, super );
+}
+
+/*!\internal
+
+ */
+TQStrList TQMetaObject::enumeratorNames( bool super ) const
+{
+    TQStrList l( FALSE );
+
+    if ( tqsuperClass() && super ) {
+	TQStrList sl = tqsuperClass()->enumeratorNames( super );
+	for ( TQStrListIterator slit( sl ); slit.current(); ++slit )
+	    l.append( slit.current() );
+    }
+
+    for( int i = 0; i < QMetaObject::enumeratorCount(); ++i ) {
+// 	if ( d->enumData[i].items )
+   	if (QMetaObject::enumerator(i).name() != "")
+	    l.append( QMetaObject::enumerator(i).name() );
+    }
+
+    return l;
+}
+
+/*!\internal
+ */
+const TQMetaEnum* TQMetaObject::enumerator( const char* name, bool super ) const
+{
+    for( int i = 0; i < QMetaObject::enumeratorCount(); ++i )
+	if ( qstrcmp( QMetaObject::enumerator(i).name(), name ) == 0 )
+	    return static_cast<TQMetaEnum*>(&(QMetaObject::enumerator(i)));
+    if ( !super || !superClass() )
+	return 0;
+    return tqsuperClass()->enumerator( name, super );
+}
+
+#else // USE_QT4
+
+/*!
+  \class TQMetaData tqmetaobject.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 tqmetaobject.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 tqmetaobject.h
+    \brief The TQMetaObject class tqcontains meta information about TQt objects.
+
+    \ingroup objectmodel
+
+    The Meta Object System in TQt is responsible for the Q_SIGNALS and
+    Q_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 tqfind 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 Q_SIGNALS and Q_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 tqmoc.html tqmoc (Meta Object Compiler)\endlink
+
+*/
+
+
+/*****************************************************************************
+  The private object.
+ *****************************************************************************/
+
+// extra flags from tqmoc.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 TQT_NO_PROPERTIES
+	enumData(0), numEnumData(0),
+	propData(0),numPropData(0),
+	qt_static_property(0),
+#endif
+	classInfo(0), numClassInfo(0) {}
+#ifndef TQT_NO_PROPERTIES
+    const TQMetaEnum *enumData;
+    int numEnumData;
+    const TQMetaProperty *propData;
+    int numPropData;
+    bool (*qt_static_property)(TQObject*, int, int, TQVariant*);
+#endif
+    const TQClassInfo *classInfo;
+    int numClassInfo;
+};
+
+
+/*****************************************************************************
+  Internal dictionary for fast access to class members
+ *****************************************************************************/
+
+#if defined(TQ_CANNOT_DELETE_CONSTANT)
+typedef TQMetaData TQConstMetaData;
+#else
+typedef const TQMetaData TQConstMetaData;
+#endif
+
+class TQ_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_Q_SLOTS,
+			  const TQMetaData *const signal_data, int n_Q_SIGNALS,
+#ifndef TQT_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_Q_SLOTS );
+    signalDict = init( signalData = signal_data, n_Q_SIGNALS );
+
+    d = new TQMetaObjectPrivate;
+    reserved = 0;
+
+#ifndef TQT_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 TQT_NO_PROPERTIES
+    propertyoffset = superclass ? ( superclass->propertyOffset() + superclass->numProperties() ) : 0;
+#endif
+}
+
+#ifndef TQT_NO_PROPERTIES
+/*!\internal
+ */
+TQMetaObject::TQMetaObject( const char *const class_name, TQMetaObject *super_class,
+			  const TQMetaData *const slot_data, int n_Q_SLOTS,
+			  const TQMetaData *const signal_data, int n_Q_SIGNALS,
+			  const TQMetaProperty *const prop_data, int n_props,
+			  const TQMetaEnum *const enum_data, int n_enums,
+			  bool (*qt_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_Q_SLOTS );
+    signalDict = init( signalData = signal_data, n_Q_SIGNALS );
+
+    d = new TQMetaObjectPrivate;
+    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
+ */
+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 Q_SLOTS for this class.
+
+    If \a super is TRUE, inherited Q_SLOTS are included.
+
+    \sa slotNames()
+*/
+int TQMetaObject::numSlots( bool super ) const	// number of Q_SLOTS
+{
+    int n = slotDict ? slotDict->count() : 0;
+    if ( !super || !superclass )
+	return n;
+    return n + superclass->numSlots( super );
+}
+
+/*!
+    Returns the number of Q_SIGNALS for this class.
+
+    If \a super is TRUE, inherited Q_SIGNALS are included.
+
+    \sa signalNames()
+*/
+int TQMetaObject::numSignals( bool super ) const	// number of Q_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 Q_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 Q_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 Q_SIGNALS are included.
+*/
+int TQMetaObject::tqfindSignal( const char* n, bool super ) const
+{
+    const TQMetaObject *mo = this;
+    int offset = -1;
+
+    do {
+	const TQMetaData *md = mo->signalDict ? mo->signalDict->tqfind( n ) : 0;
+	if ( md ) {
+#if defined(TQT_CHECK_RANGE)
+	    if ( offset != -1 ) {
+		qWarning( "TQMetaObject::tqfindSignal:%s: Conflict with %s::%s",
+			  className(), mo->className(), n );
+		return offset;
+	    }
+#endif
+	    offset = mo->signalOffset() + ( md - mo->signalData );
+#if !defined(TQT_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 Q_SLOTS are included.
+ */
+int TQMetaObject::tqfindSlot( const char* n, bool super ) const
+{
+    const TQMetaData *md = slotDict ? slotDict->tqfind( n ) : 0;
+    if ( md )
+	return slotOffset() + ( md - slotData );
+    if ( !super || !superclass)
+	return -1;
+    return superclass->tqfindSlot( n, super );
+}
+
+/*!\internal
+ */
+TQMetaObject *TQMetaObject::new_metaobject( const char *classname,
+					  TQMetaObject *superclassobject,
+					  const TQMetaData * const slot_data, int n_Q_SLOTS,
+					  const TQMetaData * const signal_data, int n_Q_SIGNALS,
+#ifndef TQT_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_Q_SLOTS,
+			    signal_data, n_Q_SIGNALS,
+#ifndef TQT_NO_PROPERTIES
+			    prop_data, n_props,
+			    enum_data, n_enums,
+#endif
+			    class_info, n_info );
+}
+
+#ifndef TQT_NO_PROPERTIES
+/*!\internal
+ */
+TQMetaObject *TQMetaObject::new_metaobject( const char *classname,
+					  TQMetaObject *superclassobject,
+					  const TQMetaData * const slot_data, int n_Q_SLOTS,
+					  const TQMetaData * const signal_data, int n_Q_SIGNALS,
+					  const TQMetaProperty * const prop_data, int n_props,
+					  const TQMetaEnum * const enum_data, int n_enums,
+					  bool (*qt_static_property)(TQObject*, int, int, TQVariant*),
+					  const TQClassInfo * const class_info, int n_info )
+{
+    return new TQMetaObject( classname, superclassobject, slot_data, n_Q_SLOTS,
+			    signal_data, n_Q_SIGNALS,
+			    prop_data, n_props,
+			    enum_data, n_enums,
+			    qt_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 TQT_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 Q_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::tqfindProperty( 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->tqfindProperty( 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 tqparent 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->tqfindProperty( p->n, TRUE ), TRUE );
+}
+
+/*!\internal
+
+  \overload
+
+  The version of resolveProperty that is used by tqmoc generated code
+*/
+
+int TQMetaObject::resolveProperty( int index ) const
+{
+    if ( !superclass )
+	return -1;
+    const TQMetaProperty* p = d->propData + ( index - propertyOffset() );
+    return superclass->tqfindProperty( 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 Q_SIGNALS.
+
+    If \a super is TRUE, inherited Q_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 Q_SLOTS.
+
+    If \a super is TRUE, inherited Q_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 // TQT_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::tqmetaObject( 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->tqfind( 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->tqfind( class_name );
+}
+
+#ifndef TQT_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::qt_static_property( TQObject* o, int id, int f, TQVariant* 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 TQMetaProperty tqmetaobject.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* tqparent = mo->resolveProperty( this );
+    return tqparent ? tqparent->writable() : FALSE;
+}
+
+/*!\internal
+ */
+bool TQMetaProperty::stdSet() const
+{
+    if ( !testFlags( Override ) || testFlags( Writable ) )
+	return testFlags( StdSet );
+    const TQMetaObject* mo = (*meta);
+    const TQMetaProperty* tqparent = mo->resolveProperty( this );
+    return tqparent ? tqparent->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* tqparent = mo->resolveProperty( this );
+    return tqparent ? tqparent->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->qt_property( idx, 3, 0 );
+    }
+    if ( testFlags( DesignableOverride ) ) {
+	const TQMetaObject* mo = (*meta);
+	const TQMetaProperty* tqparent = mo->resolveProperty( this );
+	return tqparent ? tqparent->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->qt_property( idx, 4, 0 );
+    }
+    if ( testFlags( ScriptableOverride ) ) {
+	const TQMetaObject* mo = (*meta);
+	const TQMetaProperty* tqparent = mo->resolveProperty( this );
+	return tqparent ? tqparent->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->qt_property( idx, 5, 0 );
+    }
+    if ( testFlags( StoredOverride ) ) {
+	const TQMetaObject* mo = (*meta);
+	const TQMetaProperty* tqparent = mo->resolveProperty( this );
+	return tqparent ? tqparent->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->qt_property( idx, 2, 0 );
+}
+
+
+/*! \enum TQMetaProperty::Flags
+
+  \internal
+*/
+
+#endif // TQT_NO_PROPERTIES
+
+/*
+ * TQMetaObjectCleanUp is used as static global object in the tqmoc-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 )
+    : tqmetaObject( 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()
+    : tqmetaObject( 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 ( tqmetaObject ) {
+	delete *tqmetaObject;
+	*tqmetaObject = 0;
+	tqmetaObject = 0;
+    }
+}
+
+void TQMetaObjectCleanUp::setMetaObject( TQMetaObject *&mo )
+{
+#if defined(TQT_CHECK_RANGE)
+    if ( tqmetaObject )
+	qWarning( "TQMetaObjectCleanUp::setMetaObject: Double use of TQMetaObjectCleanUp!" );
+#endif
+    tqmetaObject = &mo;
+}
+
+#endif // USE_QT4