/****************************************************************************
** PropertyTextItem meta object code from reading C++ file 'standard input'
**
** Created by: The TQt Meta Object Compiler version 26 (TQt 3.5.0)
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#undef TQT_NO_COMPAT
#include "/tmp/buildd/tde-packaging/arch/tde-devel/tde-tdevelop/src/tdevelop-trinity-14.1.6/kdevdesigner/designer/propertyeditor.h"

#include <ntqmetaobject.h>
#include <ntqapplication.h>

#include <private/qucomextra_p.h>
#if !defined(Q_MOC_OUTPUT_REVISION) || (Q_MOC_OUTPUT_REVISION != 26)
#error "This file was generated using the moc from 3.5.0. It"
#error "cannot be used with the include files from this version of TQt."
#error "(The moc has changed too much.)"
#endif

const char *PropertyTextItem::className() const
{
    return "PropertyTextItem";
}

TQMetaObject *PropertyTextItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyTextItem( "PropertyTextItem", &PropertyTextItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyTextItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyTextItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyTextItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyTextItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyTextItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQUMethod slot_1 = {"getText", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private },
	{ "getText()", &slot_1, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyTextItem", parentObject,
	slot_tbl, 2,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyTextItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyTextItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyTextItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyTextItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    case 1: getText(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyTextItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyTextItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyTextItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyBoolItem::className() const
{
    return "PropertyBoolItem";
}

TQMetaObject *PropertyBoolItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyBoolItem( "PropertyBoolItem", &PropertyBoolItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyBoolItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyBoolItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyBoolItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyBoolItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyBoolItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyBoolItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyBoolItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyBoolItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyBoolItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyBoolItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyBoolItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyBoolItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyBoolItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyIntItem::className() const
{
    return "PropertyIntItem";
}

TQMetaObject *PropertyIntItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyIntItem( "PropertyIntItem", &PropertyIntItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyIntItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyIntItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyIntItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyIntItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyIntItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyIntItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyIntItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyIntItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyIntItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyIntItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyIntItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyIntItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyIntItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyLayoutItem::className() const
{
    return "PropertyLayoutItem";
}

TQMetaObject *PropertyLayoutItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyLayoutItem( "PropertyLayoutItem", &PropertyLayoutItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyLayoutItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyLayoutItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyLayoutItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyLayoutItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyLayoutItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyLayoutItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyLayoutItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyLayoutItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyLayoutItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyLayoutItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyLayoutItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyLayoutItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyLayoutItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyDoubleItem::className() const
{
    return "PropertyDoubleItem";
}

TQMetaObject *PropertyDoubleItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyDoubleItem( "PropertyDoubleItem", &PropertyDoubleItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyDoubleItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyDoubleItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyDoubleItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyDoubleItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyDoubleItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyDoubleItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyDoubleItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyDoubleItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyDoubleItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyDoubleItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyDoubleItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyDoubleItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyDoubleItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyListItem::className() const
{
    return "PropertyListItem";
}

TQMetaObject *PropertyListItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyListItem( "PropertyListItem", &PropertyListItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyListItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyListItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyListItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyListItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyListItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyListItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyListItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyListItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyListItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyListItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyListItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyListItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyListItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyFontItem::className() const
{
    return "PropertyFontItem";
}

TQMetaObject *PropertyFontItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyFontItem( "PropertyFontItem", &PropertyFontItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyFontItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyFontItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyFontItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyFontItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyFontItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"getFont", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "getFont()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyFontItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyFontItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyFontItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyFontItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyFontItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: getFont(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyFontItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyFontItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyFontItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyCoordItem::className() const
{
    return "PropertyCoordItem";
}

TQMetaObject *PropertyCoordItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyCoordItem( "PropertyCoordItem", &PropertyCoordItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyCoordItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyCoordItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyCoordItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyCoordItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyCoordItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    metaObj = TQMetaObject::new_metaobject(
	"PropertyCoordItem", parentObject,
	0, 0,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyCoordItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyCoordItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyCoordItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyCoordItem::tqt_invoke( int _id, TQUObject* _o )
{
    return TQObject::tqt_invoke(_id,_o);
}

bool PropertyCoordItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyCoordItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyCoordItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyColorItem::className() const
{
    return "PropertyColorItem";
}

TQMetaObject *PropertyColorItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyColorItem( "PropertyColorItem", &PropertyColorItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyColorItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyColorItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyColorItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyColorItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyColorItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"getColor", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "getColor()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyColorItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyColorItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyColorItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyColorItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyColorItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: getColor(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyColorItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyColorItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyColorItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyPixmapItem::className() const
{
    return "PropertyPixmapItem";
}

TQMetaObject *PropertyPixmapItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyPixmapItem( "PropertyPixmapItem", &PropertyPixmapItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyPixmapItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyPixmapItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyPixmapItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyPixmapItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyPixmapItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"getPixmap", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "getPixmap()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyPixmapItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyPixmapItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyPixmapItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyPixmapItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyPixmapItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: getPixmap(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyPixmapItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyPixmapItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyPixmapItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertySizePolicyItem::className() const
{
    return "PropertySizePolicyItem";
}

TQMetaObject *PropertySizePolicyItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertySizePolicyItem( "PropertySizePolicyItem", &PropertySizePolicyItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertySizePolicyItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertySizePolicyItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertySizePolicyItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertySizePolicyItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertySizePolicyItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    metaObj = TQMetaObject::new_metaobject(
	"PropertySizePolicyItem", parentObject,
	0, 0,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertySizePolicyItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertySizePolicyItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertySizePolicyItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertySizePolicyItem::tqt_invoke( int _id, TQUObject* _o )
{
    return TQObject::tqt_invoke(_id,_o);
}

bool PropertySizePolicyItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertySizePolicyItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertySizePolicyItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyPaletteItem::className() const
{
    return "PropertyPaletteItem";
}

TQMetaObject *PropertyPaletteItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyPaletteItem( "PropertyPaletteItem", &PropertyPaletteItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyPaletteItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyPaletteItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyPaletteItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyPaletteItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyPaletteItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"getPalette", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "getPalette()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyPaletteItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyPaletteItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyPaletteItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyPaletteItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyPaletteItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: getPalette(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyPaletteItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyPaletteItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyPaletteItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyCursorItem::className() const
{
    return "PropertyCursorItem";
}

TQMetaObject *PropertyCursorItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyCursorItem( "PropertyCursorItem", &PropertyCursorItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyCursorItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyCursorItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyCursorItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyCursorItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyCursorItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyCursorItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyCursorItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyCursorItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyCursorItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyCursorItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyCursorItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyCursorItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyCursorItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyKeysequenceItem::className() const
{
    return "PropertyKeysequenceItem";
}

TQMetaObject *PropertyKeysequenceItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyKeysequenceItem( "PropertyKeysequenceItem", &PropertyKeysequenceItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyKeysequenceItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyKeysequenceItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyKeysequenceItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyKeysequenceItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyKeysequenceItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyKeysequenceItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyKeysequenceItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyKeysequenceItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyKeysequenceItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyKeysequenceItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyKeysequenceItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyKeysequenceItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyKeysequenceItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyDatabaseItem::className() const
{
    return "PropertyDatabaseItem";
}

TQMetaObject *PropertyDatabaseItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyDatabaseItem( "PropertyDatabaseItem", &PropertyDatabaseItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyDatabaseItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyDatabaseItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyDatabaseItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyDatabaseItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyDatabaseItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    metaObj = TQMetaObject::new_metaobject(
	"PropertyDatabaseItem", parentObject,
	0, 0,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyDatabaseItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyDatabaseItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyDatabaseItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyDatabaseItem::tqt_invoke( int _id, TQUObject* _o )
{
    return TQObject::tqt_invoke(_id,_o);
}

bool PropertyDatabaseItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyDatabaseItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyDatabaseItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *EnumPopup::className() const
{
    return "EnumPopup";
}

TQMetaObject *EnumPopup::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_EnumPopup( "EnumPopup", &EnumPopup::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString EnumPopup::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "EnumPopup", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString EnumPopup::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "EnumPopup", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* EnumPopup::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQFrame::staticMetaObject();
    static const TQUMethod signal_0 = {"closed", 0, 0 };
    static const TQUMethod signal_1 = {"hidden", 0, 0 };
    static const TQMetaData signal_tbl[] = {
	{ "closed()", &signal_0, TQMetaData::Public },
	{ "hidden()", &signal_1, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"EnumPopup", parentObject,
	0, 0,
	signal_tbl, 2,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_EnumPopup.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* EnumPopup::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "EnumPopup" ) )
	return this;
    return TQFrame::tqt_cast( clname );
}

// TQ_SIGNAL closed
void EnumPopup::closed()
{
    activate_signal( staticMetaObject()->signalOffset() + 0 );
}

// TQ_SIGNAL hidden
void EnumPopup::hidden()
{
    activate_signal( staticMetaObject()->signalOffset() + 1 );
}

bool EnumPopup::tqt_invoke( int _id, TQUObject* _o )
{
    return TQFrame::tqt_invoke(_id,_o);
}

bool EnumPopup::tqt_emit( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: closed(); break;
    case 1: hidden(); break;
    default:
	return TQFrame::tqt_emit(_id,_o);
    }
    return true;
}
#ifndef TQT_NO_PROPERTIES

bool EnumPopup::tqt_property( int id, int f, TQVariant* v)
{
    return TQFrame::tqt_property( id, f, v);
}

bool EnumPopup::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *EnumBox::className() const
{
    return "EnumBox";
}

TQMetaObject *EnumBox::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_EnumBox( "EnumBox", &EnumBox::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString EnumBox::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "EnumBox", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString EnumBox::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "EnumBox", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* EnumBox::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQComboBox::staticMetaObject();
    static const TQUMethod slot_0 = {"restoreArrow", 0, 0 };
    static const TQUMethod slot_1 = {"popupHidden", 0, 0 };
    static const TQUMethod slot_2 = {"popupClosed", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "restoreArrow()", &slot_0, TQMetaData::Protected },
	{ "popupHidden()", &slot_1, TQMetaData::Protected },
	{ "popupClosed()", &slot_2, TQMetaData::Protected }
    };
    static const TQUMethod signal_0 = {"aboutToShowPopup", 0, 0 };
    static const TQUMethod signal_1 = {"valueChanged", 0, 0 };
    static const TQMetaData signal_tbl[] = {
	{ "aboutToShowPopup()", &signal_0, TQMetaData::Public },
	{ "valueChanged()", &signal_1, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"EnumBox", parentObject,
	slot_tbl, 3,
	signal_tbl, 2,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_EnumBox.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* EnumBox::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "EnumBox" ) )
	return this;
    return TQComboBox::tqt_cast( clname );
}

// TQ_SIGNAL aboutToShowPopup
void EnumBox::aboutToShowPopup()
{
    activate_signal( staticMetaObject()->signalOffset() + 0 );
}

// TQ_SIGNAL valueChanged
void EnumBox::valueChanged()
{
    activate_signal( staticMetaObject()->signalOffset() + 1 );
}

bool EnumBox::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: restoreArrow(); break;
    case 1: popupHidden(); break;
    case 2: popupClosed(); break;
    default:
	return TQComboBox::tqt_invoke( _id, _o );
    }
    return true;
}

bool EnumBox::tqt_emit( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: aboutToShowPopup(); break;
    case 1: valueChanged(); break;
    default:
	return TQComboBox::tqt_emit(_id,_o);
    }
    return true;
}
#ifndef TQT_NO_PROPERTIES

bool EnumBox::tqt_property( int id, int f, TQVariant* v)
{
    return TQComboBox::tqt_property( id, f, v);
}

bool EnumBox::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyEnumItem::className() const
{
    return "PropertyEnumItem";
}

TQMetaObject *PropertyEnumItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyEnumItem( "PropertyEnumItem", &PropertyEnumItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyEnumItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyEnumItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyEnumItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyEnumItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyEnumItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQUMethod slot_1 = {"insertEnums", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private },
	{ "insertEnums()", &slot_1, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyEnumItem", parentObject,
	slot_tbl, 2,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyEnumItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyEnumItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyEnumItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyEnumItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    case 1: insertEnums(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyEnumItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyEnumItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyEnumItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyList::className() const
{
    return "PropertyList";
}

TQMetaObject *PropertyList::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyList( "PropertyList", &PropertyList::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyList::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyList", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyList::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyList", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyList::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQListView::staticMetaObject();
    static const TQUMethod slot_0 = {"updateEditorSize", 0, 0 };
    static const TQUMethod slot_1 = {"resetProperty", 0, 0 };
    static const TQUMethod slot_2 = {"toggleSort", 0, 0 };
    static const TQUParameter param_slot_3[] = {
	{ "i", &static_QUType_ptr, "TQListViewItem", TQUParameter::In },
	{ "p", &static_QUType_varptr, "\x0e", TQUParameter::In },
	{ "c", &static_QUType_int, 0, TQUParameter::In }
    };
    static const TQUMethod slot_3 = {"itemPressed", 3, param_slot_3 };
    static const TQUParameter param_slot_4[] = {
	{ "i", &static_QUType_ptr, "TQListViewItem", TQUParameter::In }
    };
    static const TQUMethod slot_4 = {"toggleOpen", 1, param_slot_4 };
    static const TQUParameter param_slot_5[] = {
	{ 0, &static_QUType_bool, 0, TQUParameter::Out },
	{ "o", &static_QUType_ptr, "TQObject", TQUParameter::In },
	{ "e", &static_QUType_ptr, "TQEvent", TQUParameter::In }
    };
    static const TQUMethod slot_5 = {"eventFilter", 3, param_slot_5 };
    static const TQMetaData slot_tbl[] = {
	{ "updateEditorSize()", &slot_0, TQMetaData::Public },
	{ "resetProperty()", &slot_1, TQMetaData::Public },
	{ "toggleSort()", &slot_2, TQMetaData::Public },
	{ "itemPressed(TQListViewItem*,const TQPoint&,int)", &slot_3, TQMetaData::Private },
	{ "toggleOpen(TQListViewItem*)", &slot_4, TQMetaData::Private },
	{ "eventFilter(TQObject*,TQEvent*)", &slot_5, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyList", parentObject,
	slot_tbl, 6,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyList.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyList::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyList" ) )
	return this;
    return TQListView::tqt_cast( clname );
}

bool PropertyList::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: updateEditorSize(); break;
    case 1: resetProperty(); break;
    case 2: toggleSort(); break;
    case 3: itemPressed((TQListViewItem*)static_QUType_ptr.get(_o+1),(const TQPoint&)*((const TQPoint*)static_QUType_ptr.get(_o+2)),(int)static_QUType_int.get(_o+3)); break;
    case 4: toggleOpen((TQListViewItem*)static_QUType_ptr.get(_o+1)); break;
    case 5: static_QUType_bool.set(_o,eventFilter((TQObject*)static_QUType_ptr.get(_o+1),(TQEvent*)static_QUType_ptr.get(_o+2))); break;
    default:
	return TQListView::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyList::tqt_emit( int _id, TQUObject* _o )
{
    return TQListView::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyList::tqt_property( int id, int f, TQVariant* v)
{
    return TQListView::tqt_property( id, f, v);
}

bool PropertyList::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *EventList::className() const
{
    return "EventList";
}

TQMetaObject *EventList::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_EventList( "EventList", &EventList::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString EventList::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "EventList", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString EventList::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "EventList", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* EventList::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = HierarchyList::staticMetaObject();
    static const TQUParameter param_slot_0[] = {
	{ "i", &static_QUType_ptr, "TQListViewItem", TQUParameter::In }
    };
    static const TQUMethod slot_0 = {"objectClicked", 1, param_slot_0 };
    static const TQUParameter param_slot_1[] = {
	{ 0, &static_QUType_ptr, "TQListViewItem", TQUParameter::In },
	{ 0, &static_QUType_varptr, "\x0e", TQUParameter::In }
    };
    static const TQUMethod slot_1 = {"showRMBMenu", 2, param_slot_1 };
    static const TQUParameter param_slot_2[] = {
	{ "i", &static_QUType_ptr, "TQListViewItem", TQUParameter::In }
    };
    static const TQUMethod slot_2 = {"renamed", 1, param_slot_2 };
    static const TQMetaData slot_tbl[] = {
	{ "objectClicked(TQListViewItem*)", &slot_0, TQMetaData::Private },
	{ "showRMBMenu(TQListViewItem*,const TQPoint&)", &slot_1, TQMetaData::Private },
	{ "renamed(TQListViewItem*)", &slot_2, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"EventList", parentObject,
	slot_tbl, 3,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_EventList.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* EventList::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "EventList" ) )
	return this;
    return HierarchyList::tqt_cast( clname );
}

bool EventList::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: objectClicked((TQListViewItem*)static_QUType_ptr.get(_o+1)); break;
    case 1: showRMBMenu((TQListViewItem*)static_QUType_ptr.get(_o+1),(const TQPoint&)*((const TQPoint*)static_QUType_ptr.get(_o+2))); break;
    case 2: renamed((TQListViewItem*)static_QUType_ptr.get(_o+1)); break;
    default:
	return HierarchyList::tqt_invoke( _id, _o );
    }
    return true;
}

bool EventList::tqt_emit( int _id, TQUObject* _o )
{
    return HierarchyList::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool EventList::tqt_property( int id, int f, TQVariant* v)
{
    return HierarchyList::tqt_property( id, f, v);
}

bool EventList::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyEditor::className() const
{
    return "PropertyEditor";
}

TQMetaObject *PropertyEditor::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyEditor( "PropertyEditor", &PropertyEditor::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyEditor::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyEditor", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyEditor::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyEditor", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyEditor::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQTabWidget::staticMetaObject();
    static const TQUParameter param_slot_0[] = {
	{ "w", &static_QUType_ptr, "TQObject", TQUParameter::In },
	{ "fw", &static_QUType_ptr, "FormWindow", TQUParameter::In }
    };
    static const TQUMethod slot_0 = {"setWidget", 2, param_slot_0 };
    static const TQMetaData slot_tbl[] = {
	{ "setWidget(TQObject*,FormWindow*)", &slot_0, TQMetaData::Public }
    };
    static const TQUMethod signal_0 = {"hidden", 0, 0 };
    static const TQMetaData signal_tbl[] = {
	{ "hidden()", &signal_0, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyEditor", parentObject,
	slot_tbl, 1,
	signal_tbl, 1,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyEditor.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyEditor::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyEditor" ) )
	return this;
    return TQTabWidget::tqt_cast( clname );
}

// TQ_SIGNAL hidden
void PropertyEditor::hidden()
{
    activate_signal( staticMetaObject()->signalOffset() + 0 );
}

bool PropertyEditor::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setWidget((TQObject*)static_QUType_ptr.get(_o+1),(FormWindow*)static_QUType_ptr.get(_o+2)); break;
    default:
	return TQTabWidget::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyEditor::tqt_emit( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: hidden(); break;
    default:
	return TQTabWidget::tqt_emit(_id,_o);
    }
    return true;
}
#ifndef TQT_NO_PROPERTIES

bool PropertyEditor::tqt_property( int id, int f, TQVariant* v)
{
    return TQTabWidget::tqt_property( id, f, v);
}

bool PropertyEditor::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyDateItem::className() const
{
    return "PropertyDateItem";
}

TQMetaObject *PropertyDateItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyDateItem( "PropertyDateItem", &PropertyDateItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyDateItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyDateItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyDateItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyDateItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyDateItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyDateItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyDateItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyDateItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyDateItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyDateItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyDateItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyDateItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyDateItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyTimeItem::className() const
{
    return "PropertyTimeItem";
}

TQMetaObject *PropertyTimeItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyTimeItem( "PropertyTimeItem", &PropertyTimeItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyTimeItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyTimeItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyTimeItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyTimeItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyTimeItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyTimeItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyTimeItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyTimeItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyTimeItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyTimeItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyTimeItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyTimeItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyTimeItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES


const char *PropertyDateTimeItem::className() const
{
    return "PropertyDateTimeItem";
}

TQMetaObject *PropertyDateTimeItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_PropertyDateTimeItem( "PropertyDateTimeItem", &PropertyDateTimeItem::staticMetaObject );

#ifndef TQT_NO_TRANSLATION
TQString PropertyDateTimeItem::tr( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyDateTimeItem", s, c, TQApplication::DefaultCodec );
    else
	return TQString::fromLatin1( s );
}
#ifndef TQT_NO_TRANSLATION_UTF8
TQString PropertyDateTimeItem::trUtf8( const char *s, const char *c )
{
    if ( tqApp )
	return tqApp->translate( "PropertyDateTimeItem", s, c, TQApplication::UnicodeUTF8 );
    else
	return TQString::fromUtf8( s );
}
#endif // TQT_NO_TRANSLATION_UTF8

#endif // TQT_NO_TRANSLATION

TQMetaObject* PropertyDateTimeItem::staticMetaObject()
{
    if ( metaObj ) {
	return metaObj;
}
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->lock();
    if ( metaObj ) {
	if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
	return metaObj;
    }
#endif // TQT_THREAD_SUPPORT
    TQMetaObject* parentObject = TQObject::staticMetaObject();
    static const TQUMethod slot_0 = {"setValue", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "setValue()", &slot_0, TQMetaData::Private }
    };
    metaObj = TQMetaObject::new_metaobject(
	"PropertyDateTimeItem", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_PropertyDateTimeItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

void* PropertyDateTimeItem::tqt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "PropertyDateTimeItem" ) )
	return this;
    if ( !qstrcmp( clname, "PropertyItem" ) )
	return (PropertyItem*)this;
    return TQObject::tqt_cast( clname );
}

bool PropertyDateTimeItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue(); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

bool PropertyDateTimeItem::tqt_emit( int _id, TQUObject* _o )
{
    return TQObject::tqt_emit(_id,_o);
}
#ifndef TQT_NO_PROPERTIES

bool PropertyDateTimeItem::tqt_property( int id, int f, TQVariant* v)
{
    return TQObject::tqt_property( id, f, v);
}

bool PropertyDateTimeItem::tqt_static_property( TQObject* , int , int , TQVariant* ){ return false; }
#endif // TQT_NO_PROPERTIES
