/****************************************************************************
** Configurable meta object code from reading C++ file 'settings.h'
**
** Created: Fri Jan 9 04:15:43 2009
**      by: The Qt MOC ($Id: qt/moc_yacc.cpp   3.3.8   edited Feb 2 14:59 $)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#undef QT_NO_COMPAT
#include "settings.h"
#include <qmetaobject.h>
#include <qapplication.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.3.8. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

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

QMetaObject *Configurable::metaObj = 0;
static QMetaObjectCleanUp cleanUp_Configurable( "Configurable", &Configurable::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString Configurable::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "Configurable", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString Configurable::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "Configurable", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* Configurable::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = QObject::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "val", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"enableOnSet", 1, param_slot_0 };
    static const QUParameter param_slot_1[] = {
	{ "val", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_1 = {"enableOnUnset", 1, param_slot_1 };
    static const QUParameter param_slot_2[] = {
	{ "obj", &static_QUType_ptr, "QObject", QUParameter::In }
    };
    static const QUMethod slot_2 = {"widgetDeleted", 1, param_slot_2 };
    static const QMetaData slot_tbl[] = {
	{ "enableOnSet(const QString&)", &slot_0, QMetaData::Public },
	{ "enableOnUnset(const QString&)", &slot_1, QMetaData::Public },
	{ "widgetDeleted(QObject*)", &slot_2, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"Configurable", parentObject,
	slot_tbl, 3,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_Configurable.setMetaObject( metaObj );
    return metaObj;
}

void* Configurable::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "Configurable" ) )
	return this;
    return QObject::qt_cast( clname );
}

bool Configurable::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: enableOnSet((const QString&)static_QUType_QString.get(_o+1)); break;
    case 1: enableOnUnset((const QString&)static_QUType_QString.get(_o+1)); break;
    case 2: widgetDeleted((QObject*)static_QUType_ptr.get(_o+1)); break;
    default:
	return QObject::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool Configurable::qt_emit( int _id, QUObject* _o )
{
    return QObject::qt_emit(_id,_o);
}
#ifndef QT_NO_PROPERTIES

bool Configurable::qt_property( int id, int f, QVariant* v)
{
    return QObject::qt_property( id, f, v);
}

bool Configurable::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *Setting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_Setting( "Setting", &Setting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString Setting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "Setting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString Setting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "Setting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* Setting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = Configurable::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "newValue", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"setValue", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "setValue(const QString&)", &slot_0, QMetaData::Public }
    };
    static const QUParameter param_signal_0[] = {
	{ 0, &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod signal_0 = {"valueChanged", 1, param_signal_0 };
    static const QMetaData signal_tbl[] = {
	{ "valueChanged(const QString&)", &signal_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"Setting", parentObject,
	slot_tbl, 1,
	signal_tbl, 1,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_Setting.setMetaObject( metaObj );
    return metaObj;
}

void* Setting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "Setting" ) )
	return this;
    return Configurable::qt_cast( clname );
}

// SIGNAL valueChanged
void Setting::valueChanged( const QString& t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 0, t0 );
}

bool Setting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue((const QString&)static_QUType_QString.get(_o+1)); break;
    default:
	return Configurable::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool Setting::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: valueChanged((const QString&)static_QUType_QString.get(_o+1)); break;
    default:
	return Configurable::qt_emit(_id,_o);
    }
    return TRUE;
}
#ifndef QT_NO_PROPERTIES

bool Setting::qt_property( int id, int f, QVariant* v)
{
    return Configurable::qt_property( id, f, v);
}

bool Setting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *IntegerSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_IntegerSetting( "IntegerSetting", &IntegerSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString IntegerSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "IntegerSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString IntegerSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "IntegerSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* IntegerSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = Setting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "newValue", &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"setValue", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "setValue(int)", &slot_0, QMetaData::Public }
    };
    static const QUParameter param_signal_0[] = {
	{ "newValue", &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod signal_0 = {"valueChanged", 1, param_signal_0 };
    static const QMetaData signal_tbl[] = {
	{ "valueChanged(int)", &signal_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"IntegerSetting", parentObject,
	slot_tbl, 1,
	signal_tbl, 1,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_IntegerSetting.setMetaObject( metaObj );
    return metaObj;
}

void* IntegerSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "IntegerSetting" ) )
	return this;
    return Setting::qt_cast( clname );
}

// SIGNAL valueChanged
void IntegerSetting::valueChanged( int t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 0, t0 );
}

bool IntegerSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue((int)static_QUType_int.get(_o+1)); break;
    default:
	return Setting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool IntegerSetting::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: valueChanged((int)static_QUType_int.get(_o+1)); break;
    default:
	return Setting::qt_emit(_id,_o);
    }
    return TRUE;
}
#ifndef QT_NO_PROPERTIES

bool IntegerSetting::qt_property( int id, int f, QVariant* v)
{
    return Setting::qt_property( id, f, v);
}

bool IntegerSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *SpinBoxSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_SpinBoxSetting( "SpinBoxSetting", &SpinBoxSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString SpinBoxSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "SpinBoxSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString SpinBoxSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "SpinBoxSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* SpinBoxSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = BoundedIntegerSetting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "newValue", &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"relayValueChanged", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "relayValueChanged(int)", &slot_0, QMetaData::Private }
    };
    static const QUParameter param_signal_0[] = {
	{ "name", &static_QUType_QString, 0, QUParameter::In },
	{ "newValue", &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod signal_0 = {"valueChanged", 2, param_signal_0 };
    static const QMetaData signal_tbl[] = {
	{ "valueChanged(const QString&,int)", &signal_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"SpinBoxSetting", parentObject,
	slot_tbl, 1,
	signal_tbl, 1,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_SpinBoxSetting.setMetaObject( metaObj );
    return metaObj;
}

void* SpinBoxSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "SpinBoxSetting" ) )
	return this;
    return BoundedIntegerSetting::qt_cast( clname );
}

#include <qobjectdefs.h>
#include <qsignalslotimp.h>

// SIGNAL valueChanged
void SpinBoxSetting::valueChanged( const QString& t0, int t1 )
{
    if ( signalsBlocked() )
	return;
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
    if ( !clist )
	return;
    QUObject o[3];
    static_QUType_QString.set(o+1,t0);
    static_QUType_int.set(o+2,t1);
    activate_signal( clist, o );
}

bool SpinBoxSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: relayValueChanged((int)static_QUType_int.get(_o+1)); break;
    default:
	return BoundedIntegerSetting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool SpinBoxSetting::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: valueChanged((const QString&)static_QUType_QString.get(_o+1),(int)static_QUType_int.get(_o+2)); break;
    default:
	return BoundedIntegerSetting::qt_emit(_id,_o);
    }
    return TRUE;
}
#ifndef QT_NO_PROPERTIES

bool SpinBoxSetting::qt_property( int id, int f, QVariant* v)
{
    return BoundedIntegerSetting::qt_property( id, f, v);
}

bool SpinBoxSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *SelectSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_SelectSetting( "SelectSetting", &SelectSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString SelectSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "SelectSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString SelectSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "SelectSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* SelectSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = Setting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "newValue", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"setValue", 1, param_slot_0 };
    static const QUParameter param_slot_1[] = {
	{ "which", &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod slot_1 = {"setValue", 1, param_slot_1 };
    static const QUParameter param_slot_2[] = {
	{ 0, &static_QUType_QString, 0, QUParameter::Out }
    };
    static const QUMethod slot_2 = {"getSelectionLabel", 1, param_slot_2 };
    static const QUParameter param_slot_3[] = {
	{ 0, &static_QUType_int, 0, QUParameter::Out },
	{ "value", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_3 = {"getValueIndex", 2, param_slot_3 };
    static const QMetaData slot_tbl[] = {
	{ "setValue(const QString&)", &slot_0, QMetaData::Public },
	{ "setValue(int)", &slot_1, QMetaData::Public },
	{ "getSelectionLabel()", &slot_2, QMetaData::Public },
	{ "getValueIndex(QString)", &slot_3, QMetaData::Public }
    };
    static const QUParameter param_signal_0[] = {
	{ "label", &static_QUType_QString, 0, QUParameter::In },
	{ "value", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod signal_0 = {"selectionAdded", 2, param_signal_0 };
    static const QUParameter param_signal_1[] = {
	{ "label", &static_QUType_QString, 0, QUParameter::In },
	{ "value", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod signal_1 = {"selectionRemoved", 2, param_signal_1 };
    static const QUMethod signal_2 = {"selectionsCleared", 0, 0 };
    static const QMetaData signal_tbl[] = {
	{ "selectionAdded(const QString&,QString)", &signal_0, QMetaData::Public },
	{ "selectionRemoved(const QString&,const QString&)", &signal_1, QMetaData::Public },
	{ "selectionsCleared()", &signal_2, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"SelectSetting", parentObject,
	slot_tbl, 4,
	signal_tbl, 3,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_SelectSetting.setMetaObject( metaObj );
    return metaObj;
}

void* SelectSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "SelectSetting" ) )
	return this;
    return Setting::qt_cast( clname );
}

// SIGNAL selectionAdded
void SelectSetting::selectionAdded( const QString& t0, QString t1 )
{
    if ( signalsBlocked() )
	return;
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
    if ( !clist )
	return;
    QUObject o[3];
    static_QUType_QString.set(o+1,t0);
    static_QUType_QString.set(o+2,t1);
    activate_signal( clist, o );
}

// SIGNAL selectionRemoved
void SelectSetting::selectionRemoved( const QString& t0, const QString& t1 )
{
    if ( signalsBlocked() )
	return;
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 1 );
    if ( !clist )
	return;
    QUObject o[3];
    static_QUType_QString.set(o+1,t0);
    static_QUType_QString.set(o+2,t1);
    activate_signal( clist, o );
}

// SIGNAL selectionsCleared
void SelectSetting::selectionsCleared()
{
    activate_signal( staticMetaObject()->signalOffset() + 2 );
}

bool SelectSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue((const QString&)static_QUType_QString.get(_o+1)); break;
    case 1: setValue((int)static_QUType_int.get(_o+1)); break;
    case 2: static_QUType_QString.set(_o,getSelectionLabel()); break;
    case 3: static_QUType_int.set(_o,getValueIndex((QString)static_QUType_QString.get(_o+1))); break;
    default:
	return Setting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool SelectSetting::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: selectionAdded((const QString&)static_QUType_QString.get(_o+1),(QString)static_QUType_QString.get(_o+2)); break;
    case 1: selectionRemoved((const QString&)static_QUType_QString.get(_o+1),(const QString&)static_QUType_QString.get(_o+2)); break;
    case 2: selectionsCleared(); break;
    default:
	return Setting::qt_emit(_id,_o);
    }
    return TRUE;
}
#ifndef QT_NO_PROPERTIES

bool SelectSetting::qt_property( int id, int f, QVariant* v)
{
    return Setting::qt_property( id, f, v);
}

bool SelectSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *ComboBoxSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_ComboBoxSetting( "ComboBoxSetting", &ComboBoxSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString ComboBoxSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "ComboBoxSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString ComboBoxSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "ComboBoxSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* ComboBoxSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = SelectSetting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "label", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"addSelection", 1, param_slot_0 };
    static const QUParameter param_slot_1[] = {
	{ "label", &static_QUType_QString, 0, QUParameter::In },
	{ "value", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_1 = {"addSelection", 2, param_slot_1 };
    static const QUParameter param_slot_2[] = {
	{ "label", &static_QUType_QString, 0, QUParameter::In },
	{ "value", &static_QUType_QString, 0, QUParameter::In },
	{ "select", &static_QUType_bool, 0, QUParameter::In }
    };
    static const QUMethod slot_2 = {"addSelection", 3, param_slot_2 };
    static const QUParameter param_slot_3[] = {
	{ 0, &static_QUType_bool, 0, QUParameter::Out },
	{ "label", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_3 = {"removeSelection", 2, param_slot_3 };
    static const QUParameter param_slot_4[] = {
	{ 0, &static_QUType_bool, 0, QUParameter::Out },
	{ "label", &static_QUType_QString, 0, QUParameter::In },
	{ "value", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_4 = {"removeSelection", 3, param_slot_4 };
    static const QMetaData slot_tbl[] = {
	{ "addSelection(const QString&)", &slot_0, QMetaData::Public },
	{ "addSelection(const QString&,QString)", &slot_1, QMetaData::Public },
	{ "addSelection(const QString&,QString,bool)", &slot_2, QMetaData::Public },
	{ "removeSelection(const QString&)", &slot_3, QMetaData::Public },
	{ "removeSelection(const QString&,QString)", &slot_4, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"ComboBoxSetting", parentObject,
	slot_tbl, 5,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_ComboBoxSetting.setMetaObject( metaObj );
    return metaObj;
}

void* ComboBoxSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "ComboBoxSetting" ) )
	return this;
    return SelectSetting::qt_cast( clname );
}

bool ComboBoxSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: addSelection((const QString&)static_QUType_QString.get(_o+1)); break;
    case 1: addSelection((const QString&)static_QUType_QString.get(_o+1),(QString)static_QUType_QString.get(_o+2)); break;
    case 2: addSelection((const QString&)static_QUType_QString.get(_o+1),(QString)static_QUType_QString.get(_o+2),(bool)static_QUType_bool.get(_o+3)); break;
    case 3: static_QUType_bool.set(_o,removeSelection((const QString&)static_QUType_QString.get(_o+1))); break;
    case 4: static_QUType_bool.set(_o,removeSelection((const QString&)static_QUType_QString.get(_o+1),(QString)static_QUType_QString.get(_o+2))); break;
    default:
	return SelectSetting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool ComboBoxSetting::qt_emit( int _id, QUObject* _o )
{
    return SelectSetting::qt_emit(_id,_o);
}
#ifndef QT_NO_PROPERTIES

bool ComboBoxSetting::qt_property( int id, int f, QVariant* v)
{
    return SelectSetting::qt_property( id, f, v);
}

bool ComboBoxSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *ListBoxSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_ListBoxSetting( "ListBoxSetting", &ListBoxSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString ListBoxSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "ListBoxSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString ListBoxSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "ListBoxSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* ListBoxSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = SelectSetting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "label", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"addSelection", 1, param_slot_0 };
    static const QUParameter param_slot_1[] = {
	{ "label", &static_QUType_QString, 0, QUParameter::In },
	{ "value", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_1 = {"addSelection", 2, param_slot_1 };
    static const QUParameter param_slot_2[] = {
	{ "label", &static_QUType_QString, 0, QUParameter::In },
	{ "value", &static_QUType_QString, 0, QUParameter::In },
	{ "select", &static_QUType_bool, 0, QUParameter::In }
    };
    static const QUMethod slot_2 = {"addSelection", 3, param_slot_2 };
    static const QUParameter param_slot_3[] = {
	{ "index", &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod slot_3 = {"setValueByIndex", 1, param_slot_3 };
    static const QMetaData slot_tbl[] = {
	{ "addSelection(const QString&)", &slot_0, QMetaData::Public },
	{ "addSelection(const QString&,QString)", &slot_1, QMetaData::Public },
	{ "addSelection(const QString&,QString,bool)", &slot_2, QMetaData::Public },
	{ "setValueByIndex(int)", &slot_3, QMetaData::Public }
    };
    static const QUParameter param_signal_0[] = {
	{ 0, &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod signal_0 = {"accepted", 1, param_signal_0 };
    static const QUParameter param_signal_1[] = {
	{ 0, &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod signal_1 = {"menuButtonPressed", 1, param_signal_1 };
    static const QUParameter param_signal_2[] = {
	{ 0, &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod signal_2 = {"editButtonPressed", 1, param_signal_2 };
    static const QUParameter param_signal_3[] = {
	{ 0, &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod signal_3 = {"deleteButtonPressed", 1, param_signal_3 };
    static const QMetaData signal_tbl[] = {
	{ "accepted(int)", &signal_0, QMetaData::Public },
	{ "menuButtonPressed(int)", &signal_1, QMetaData::Public },
	{ "editButtonPressed(int)", &signal_2, QMetaData::Public },
	{ "deleteButtonPressed(int)", &signal_3, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"ListBoxSetting", parentObject,
	slot_tbl, 4,
	signal_tbl, 4,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_ListBoxSetting.setMetaObject( metaObj );
    return metaObj;
}

void* ListBoxSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "ListBoxSetting" ) )
	return this;
    return SelectSetting::qt_cast( clname );
}

// SIGNAL accepted
void ListBoxSetting::accepted( int t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 0, t0 );
}

// SIGNAL menuButtonPressed
void ListBoxSetting::menuButtonPressed( int t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 1, t0 );
}

// SIGNAL editButtonPressed
void ListBoxSetting::editButtonPressed( int t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 2, t0 );
}

// SIGNAL deleteButtonPressed
void ListBoxSetting::deleteButtonPressed( int t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 3, t0 );
}

bool ListBoxSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: addSelection((const QString&)static_QUType_QString.get(_o+1)); break;
    case 1: addSelection((const QString&)static_QUType_QString.get(_o+1),(QString)static_QUType_QString.get(_o+2)); break;
    case 2: addSelection((const QString&)static_QUType_QString.get(_o+1),(QString)static_QUType_QString.get(_o+2),(bool)static_QUType_bool.get(_o+3)); break;
    case 3: setValueByIndex((int)static_QUType_int.get(_o+1)); break;
    default:
	return SelectSetting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool ListBoxSetting::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: accepted((int)static_QUType_int.get(_o+1)); break;
    case 1: menuButtonPressed((int)static_QUType_int.get(_o+1)); break;
    case 2: editButtonPressed((int)static_QUType_int.get(_o+1)); break;
    case 3: deleteButtonPressed((int)static_QUType_int.get(_o+1)); break;
    default:
	return SelectSetting::qt_emit(_id,_o);
    }
    return TRUE;
}
#ifndef QT_NO_PROPERTIES

bool ListBoxSetting::qt_property( int id, int f, QVariant* v)
{
    return SelectSetting::qt_property( id, f, v);
}

bool ListBoxSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *ImageSelectSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_ImageSelectSetting( "ImageSelectSetting", &ImageSelectSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString ImageSelectSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "ImageSelectSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString ImageSelectSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "ImageSelectSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* ImageSelectSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = SelectSetting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ 0, &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"imageSet", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "imageSet(int)", &slot_0, QMetaData::Protected }
    };
    metaObj = QMetaObject::new_metaobject(
	"ImageSelectSetting", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_ImageSelectSetting.setMetaObject( metaObj );
    return metaObj;
}

void* ImageSelectSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "ImageSelectSetting" ) )
	return this;
    return SelectSetting::qt_cast( clname );
}

bool ImageSelectSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: imageSet((int)static_QUType_int.get(_o+1)); break;
    default:
	return SelectSetting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool ImageSelectSetting::qt_emit( int _id, QUObject* _o )
{
    return SelectSetting::qt_emit(_id,_o);
}
#ifndef QT_NO_PROPERTIES

bool ImageSelectSetting::qt_property( int id, int f, QVariant* v)
{
    return SelectSetting::qt_property( id, f, v);
}

bool ImageSelectSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *BooleanSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_BooleanSetting( "BooleanSetting", &BooleanSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString BooleanSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "BooleanSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString BooleanSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "BooleanSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* BooleanSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = Setting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "check", &static_QUType_bool, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"setValue", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "setValue(bool)", &slot_0, QMetaData::Public }
    };
    static const QUParameter param_signal_0[] = {
	{ 0, &static_QUType_bool, 0, QUParameter::In }
    };
    static const QUMethod signal_0 = {"valueChanged", 1, param_signal_0 };
    static const QMetaData signal_tbl[] = {
	{ "valueChanged(bool)", &signal_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"BooleanSetting", parentObject,
	slot_tbl, 1,
	signal_tbl, 1,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_BooleanSetting.setMetaObject( metaObj );
    return metaObj;
}

void* BooleanSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "BooleanSetting" ) )
	return this;
    return Setting::qt_cast( clname );
}

// SIGNAL valueChanged
void BooleanSetting::valueChanged( bool t0 )
{
    activate_signal_bool( staticMetaObject()->signalOffset() + 0, t0 );
}

bool BooleanSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue((bool)static_QUType_bool.get(_o+1)); break;
    default:
	return Setting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool BooleanSetting::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: valueChanged((bool)static_QUType_bool.get(_o+1)); break;
    default:
	return Setting::qt_emit(_id,_o);
    }
    return TRUE;
}
#ifndef QT_NO_PROPERTIES

bool BooleanSetting::qt_property( int id, int f, QVariant* v)
{
    return Setting::qt_property( id, f, v);
}

bool BooleanSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *DateSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_DateSetting( "DateSetting", &DateSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString DateSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "DateSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString DateSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "DateSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* DateSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = Setting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "newValue", &static_QUType_varptr, "\x1a", QUParameter::In }
    };
    static const QUMethod slot_0 = {"setValue", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "setValue(const QDate&)", &slot_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"DateSetting", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_DateSetting.setMetaObject( metaObj );
    return metaObj;
}

void* DateSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "DateSetting" ) )
	return this;
    return Setting::qt_cast( clname );
}

bool DateSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue((const QDate&)*((const QDate*)static_QUType_ptr.get(_o+1))); break;
    default:
	return Setting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool DateSetting::qt_emit( int _id, QUObject* _o )
{
    return Setting::qt_emit(_id,_o);
}
#ifndef QT_NO_PROPERTIES

bool DateSetting::qt_property( int id, int f, QVariant* v)
{
    return Setting::qt_property( id, f, v);
}

bool DateSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *TimeSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_TimeSetting( "TimeSetting", &TimeSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString TimeSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "TimeSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString TimeSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "TimeSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* TimeSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = Setting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "newValue", &static_QUType_varptr, "\x1b", QUParameter::In }
    };
    static const QUMethod slot_0 = {"setValue", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "setValue(const QTime&)", &slot_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"TimeSetting", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_TimeSetting.setMetaObject( metaObj );
    return metaObj;
}

void* TimeSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "TimeSetting" ) )
	return this;
    return Setting::qt_cast( clname );
}

bool TimeSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setValue((const QTime&)*((const QTime*)static_QUType_ptr.get(_o+1))); break;
    default:
	return Setting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool TimeSetting::qt_emit( int _id, QUObject* _o )
{
    return Setting::qt_emit(_id,_o);
}
#ifndef QT_NO_PROPERTIES

bool TimeSetting::qt_property( int id, int f, QVariant* v)
{
    return Setting::qt_property( id, f, v);
}

bool TimeSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *ButtonSetting::metaObj = 0;
static QMetaObjectCleanUp cleanUp_ButtonSetting( "ButtonSetting", &ButtonSetting::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString ButtonSetting::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "ButtonSetting", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString ButtonSetting::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "ButtonSetting", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* ButtonSetting::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = Setting::staticMetaObject();
    static const QUMethod slot_0 = {"SendPressedString", 0, 0 };
    static const QMetaData slot_tbl[] = {
	{ "SendPressedString()", &slot_0, QMetaData::Protected }
    };
    static const QUMethod signal_0 = {"pressed", 0, 0 };
    static const QUParameter param_signal_1[] = {
	{ "name", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod signal_1 = {"pressed", 1, param_signal_1 };
    static const QMetaData signal_tbl[] = {
	{ "pressed()", &signal_0, QMetaData::Public },
	{ "pressed(QString)", &signal_1, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"ButtonSetting", parentObject,
	slot_tbl, 1,
	signal_tbl, 2,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_ButtonSetting.setMetaObject( metaObj );
    return metaObj;
}

void* ButtonSetting::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "ButtonSetting" ) )
	return this;
    return Setting::qt_cast( clname );
}

// SIGNAL pressed
void ButtonSetting::pressed()
{
    activate_signal( staticMetaObject()->signalOffset() + 0 );
}

// SIGNAL pressed
void ButtonSetting::pressed( QString t0 )
{
    activate_signal( staticMetaObject()->signalOffset() + 1, t0 );
}

bool ButtonSetting::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: SendPressedString(); break;
    default:
	return Setting::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool ButtonSetting::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: pressed(); break;
    case 1: pressed((QString)static_QUType_QString.get(_o+1)); break;
    default:
	return Setting::qt_emit(_id,_o);
    }
    return TRUE;
}
#ifndef QT_NO_PROPERTIES

bool ButtonSetting::qt_property( int id, int f, QVariant* v)
{
    return Setting::qt_property( id, f, v);
}

bool ButtonSetting::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES


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

QMetaObject *HostRefreshRateComboBox::metaObj = 0;
static QMetaObjectCleanUp cleanUp_HostRefreshRateComboBox( "HostRefreshRateComboBox", &HostRefreshRateComboBox::staticMetaObject );

#ifndef QT_NO_TRANSLATION
QString HostRefreshRateComboBox::tr( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "HostRefreshRateComboBox", s, c, QApplication::DefaultCodec );
    else
	return QString::fromLatin1( s );
}
#ifndef QT_NO_TRANSLATION_UTF8
QString HostRefreshRateComboBox::trUtf8( const char *s, const char *c )
{
    if ( qApp )
	return qApp->translate( "HostRefreshRateComboBox", s, c, QApplication::UnicodeUTF8 );
    else
	return QString::fromUtf8( s );
}
#endif // QT_NO_TRANSLATION_UTF8

#endif // QT_NO_TRANSLATION

QMetaObject* HostRefreshRateComboBox::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = HostComboBox::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "resolution", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"ChangeResolution", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "ChangeResolution(const QString&)", &slot_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"HostRefreshRateComboBox", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_HostRefreshRateComboBox.setMetaObject( metaObj );
    return metaObj;
}

void* HostRefreshRateComboBox::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "HostRefreshRateComboBox" ) )
	return this;
    return HostComboBox::qt_cast( clname );
}

bool HostRefreshRateComboBox::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: ChangeResolution((const QString&)static_QUType_QString.get(_o+1)); break;
    default:
	return HostComboBox::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool HostRefreshRateComboBox::qt_emit( int _id, QUObject* _o )
{
    return HostComboBox::qt_emit(_id,_o);
}
#ifndef QT_NO_PROPERTIES

bool HostRefreshRateComboBox::qt_property( int id, int f, QVariant* v)
{
    return HostComboBox::qt_property( id, f, v);
}

bool HostRefreshRateComboBox::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES
