/****************************************************************************
** ConnectionItem 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/connectionitems.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 *ConnectionItem::className() const
{
    return "ConnectionItem";
}

TQMetaObject *ConnectionItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_ConnectionItem( "ConnectionItem", &ConnectionItem::staticMetaObject );

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

#endif // TQT_NO_TRANSLATION

TQMetaObject* ConnectionItem::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 TQUParameter param_slot_0[] = {
	{ "sender", &static_QUType_ptr, "TQObject", TQUParameter::In }
    };
    static const TQUMethod slot_0 = {"senderChanged", 1, param_slot_0 };
    static const TQUParameter param_slot_1[] = {
	{ "receiver", &static_QUType_ptr, "TQObject", TQUParameter::In }
    };
    static const TQUMethod slot_1 = {"receiverChanged", 1, param_slot_1 };
    static const TQUParameter param_slot_2[] = {
	{ "sig", &static_QUType_TQString, 0, TQUParameter::In }
    };
    static const TQUMethod slot_2 = {"signalChanged", 1, param_slot_2 };
    static const TQUParameter param_slot_3[] = {
	{ "slot", &static_QUType_TQString, 0, TQUParameter::In }
    };
    static const TQUMethod slot_3 = {"slotChanged", 1, param_slot_3 };
    static const TQMetaData slot_tbl[] = {
	{ "senderChanged(TQObject*)", &slot_0, TQMetaData::Public },
	{ "receiverChanged(TQObject*)", &slot_1, TQMetaData::Public },
	{ "signalChanged(const TQString&)", &slot_2, TQMetaData::Public },
	{ "slotChanged(const TQString&)", &slot_3, TQMetaData::Public }
    };
    static const TQUMethod signal_0 = {"changed", 0, 0 };
    static const TQMetaData signal_tbl[] = {
	{ "changed()", &signal_0, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"ConnectionItem", parentObject,
	slot_tbl, 4,
	signal_tbl, 1,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_ConnectionItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

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

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

bool ConnectionItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: senderChanged((TQObject*)static_QUType_ptr.get(_o+1)); break;
    case 1: receiverChanged((TQObject*)static_QUType_ptr.get(_o+1)); break;
    case 2: signalChanged((const TQString&)static_QUType_TQString.get(_o+1)); break;
    case 3: slotChanged((const TQString&)static_QUType_TQString.get(_o+1)); break;
    default:
	return TQObject::tqt_invoke( _id, _o );
    }
    return true;
}

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

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

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


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

TQMetaObject *SenderItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_SenderItem( "SenderItem", &SenderItem::staticMetaObject );

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

#endif // TQT_NO_TRANSLATION

TQMetaObject* SenderItem::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 = ConnectionItem::staticMetaObject();
    static const TQUParameter param_slot_0[] = {
	{ "sender", &static_QUType_TQString, 0, TQUParameter::In }
    };
    static const TQUMethod slot_0 = {"senderChanged", 1, param_slot_0 };
    static const TQMetaData slot_tbl[] = {
	{ "senderChanged(const TQString&)", &slot_0, TQMetaData::Private }
    };
    static const TQUParameter param_signal_0[] = {
	{ "sender", &static_QUType_ptr, "TQObject", TQUParameter::In }
    };
    static const TQUMethod signal_0 = {"currentSenderChanged", 1, param_signal_0 };
    static const TQMetaData signal_tbl[] = {
	{ "currentSenderChanged(TQObject*)", &signal_0, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"SenderItem", parentObject,
	slot_tbl, 1,
	signal_tbl, 1,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_SenderItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

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

#include <ntqobjectdefs.h>
#include <ntqsignalslotimp.h>

// TQ_SIGNAL currentSenderChanged
void SenderItem::currentSenderChanged( TQObject* t0 )
{
    if ( signalsBlocked() )
	return;
    TQConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
    if ( !clist )
	return;
    TQUObject o[2];
    static_QUType_ptr.set(o+1,t0);
    o[1].isLastObject = true;
    activate_signal( clist, o );
}

bool SenderItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: senderChanged((const TQString&)static_QUType_TQString.get(_o+1)); break;
    default:
	return ConnectionItem::tqt_invoke( _id, _o );
    }
    return true;
}

bool SenderItem::tqt_emit( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: currentSenderChanged((TQObject*)static_QUType_ptr.get(_o+1)); break;
    default:
	return ConnectionItem::tqt_emit(_id,_o);
    }
    return true;
}
#ifndef TQT_NO_PROPERTIES

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

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


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

TQMetaObject *ReceiverItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_ReceiverItem( "ReceiverItem", &ReceiverItem::staticMetaObject );

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

#endif // TQT_NO_TRANSLATION

TQMetaObject* ReceiverItem::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 = ConnectionItem::staticMetaObject();
    static const TQUParameter param_slot_0[] = {
	{ "receiver", &static_QUType_TQString, 0, TQUParameter::In }
    };
    static const TQUMethod slot_0 = {"receiverChanged", 1, param_slot_0 };
    static const TQMetaData slot_tbl[] = {
	{ "receiverChanged(const TQString&)", &slot_0, TQMetaData::Private }
    };
    static const TQUParameter param_signal_0[] = {
	{ "receiver", &static_QUType_ptr, "TQObject", TQUParameter::In }
    };
    static const TQUMethod signal_0 = {"currentReceiverChanged", 1, param_signal_0 };
    static const TQMetaData signal_tbl[] = {
	{ "currentReceiverChanged(TQObject*)", &signal_0, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"ReceiverItem", parentObject,
	slot_tbl, 1,
	signal_tbl, 1,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_ReceiverItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

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

// TQ_SIGNAL currentReceiverChanged
void ReceiverItem::currentReceiverChanged( TQObject* t0 )
{
    if ( signalsBlocked() )
	return;
    TQConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
    if ( !clist )
	return;
    TQUObject o[2];
    static_QUType_ptr.set(o+1,t0);
    o[1].isLastObject = true;
    activate_signal( clist, o );
}

bool ReceiverItem::tqt_invoke( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: receiverChanged((const TQString&)static_QUType_TQString.get(_o+1)); break;
    default:
	return ConnectionItem::tqt_invoke( _id, _o );
    }
    return true;
}

bool ReceiverItem::tqt_emit( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: currentReceiverChanged((TQObject*)static_QUType_ptr.get(_o+1)); break;
    default:
	return ConnectionItem::tqt_emit(_id,_o);
    }
    return true;
}
#ifndef TQT_NO_PROPERTIES

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

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


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

TQMetaObject *SignalItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_SignalItem( "SignalItem", &SignalItem::staticMetaObject );

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

#endif // TQT_NO_TRANSLATION

TQMetaObject* SignalItem::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 = ConnectionItem::staticMetaObject();
    static const TQUParameter param_signal_0[] = {
	{ 0, &static_QUType_TQString, 0, TQUParameter::In }
    };
    static const TQUMethod signal_0 = {"currentSignalChanged", 1, param_signal_0 };
    static const TQMetaData signal_tbl[] = {
	{ "currentSignalChanged(const TQString&)", &signal_0, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"SignalItem", parentObject,
	0, 0,
	signal_tbl, 1,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_SignalItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

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

// TQ_SIGNAL currentSignalChanged
void SignalItem::currentSignalChanged( const TQString& t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 0, t0 );
}

bool SignalItem::tqt_invoke( int _id, TQUObject* _o )
{
    return ConnectionItem::tqt_invoke(_id,_o);
}

bool SignalItem::tqt_emit( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: currentSignalChanged((const TQString&)static_QUType_TQString.get(_o+1)); break;
    default:
	return ConnectionItem::tqt_emit(_id,_o);
    }
    return true;
}
#ifndef TQT_NO_PROPERTIES

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

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


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

TQMetaObject *SlotItem::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_SlotItem( "SlotItem", &SlotItem::staticMetaObject );

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

#endif // TQT_NO_TRANSLATION

TQMetaObject* SlotItem::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 = ConnectionItem::staticMetaObject();
    static const TQUParameter param_signal_0[] = {
	{ 0, &static_QUType_TQString, 0, TQUParameter::In }
    };
    static const TQUMethod signal_0 = {"currentSlotChanged", 1, param_signal_0 };
    static const TQMetaData signal_tbl[] = {
	{ "currentSlotChanged(const TQString&)", &signal_0, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"SlotItem", parentObject,
	0, 0,
	signal_tbl, 1,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_SlotItem.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

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

// TQ_SIGNAL currentSlotChanged
void SlotItem::currentSlotChanged( const TQString& t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 0, t0 );
}

bool SlotItem::tqt_invoke( int _id, TQUObject* _o )
{
    return ConnectionItem::tqt_invoke(_id,_o);
}

bool SlotItem::tqt_emit( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: currentSlotChanged((const TQString&)static_QUType_TQString.get(_o+1)); break;
    default:
	return ConnectionItem::tqt_emit(_id,_o);
    }
    return true;
}
#ifndef TQT_NO_PROPERTIES

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

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


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

TQMetaObject *ConnectionContainer::metaObj = 0;
static TQMetaObjectCleanUp cleanUp_ConnectionContainer( "ConnectionContainer", &ConnectionContainer::staticMetaObject );

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

#endif // TQT_NO_TRANSLATION

TQMetaObject* ConnectionContainer::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 = {"somethingChanged", 0, 0 };
    static const TQMetaData slot_tbl[] = {
	{ "somethingChanged()", &slot_0, TQMetaData::Public }
    };
    static const TQUParameter param_signal_0[] = {
	{ "c", &static_QUType_ptr, "ConnectionContainer", TQUParameter::In }
    };
    static const TQUMethod signal_0 = {"changed", 1, param_signal_0 };
    static const TQMetaData signal_tbl[] = {
	{ "changed(ConnectionContainer*)", &signal_0, TQMetaData::Public }
    };
    metaObj = TQMetaObject::new_metaobject(
	"ConnectionContainer", parentObject,
	slot_tbl, 1,
	signal_tbl, 1,
#ifndef TQT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // TQT_NO_PROPERTIES
	0, 0 );
    cleanUp_ConnectionContainer.setMetaObject( metaObj );
#ifdef TQT_THREAD_SUPPORT
    if (tqt_sharedMetaObjectMutex) tqt_sharedMetaObjectMutex->unlock();
#endif // TQT_THREAD_SUPPORT
    return metaObj;
}

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

// TQ_SIGNAL changed
void ConnectionContainer::changed( ConnectionContainer* t0 )
{
    if ( signalsBlocked() )
	return;
    TQConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
    if ( !clist )
	return;
    TQUObject o[2];
    static_QUType_ptr.set(o+1,t0);
    o[1].isLastObject = true;
    activate_signal( clist, o );
}

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

bool ConnectionContainer::tqt_emit( int _id, TQUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: changed((ConnectionContainer*)static_QUType_ptr.get(_o+1)); break;
    default:
	return TQObject::tqt_emit(_id,_o);
    }
    return true;
}
#ifndef TQT_NO_PROPERTIES

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

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