/****************************************************************************
** VideoSourceSelector meta object code from reading C++ file 'videosource.h'
**
** Created: Fri Jan 9 04:23:04 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 "videosource.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 *VideoSourceSelector::className() const
{
    return "VideoSourceSelector";
}

QMetaObject *VideoSourceSelector::metaObj = 0;
static QMetaObjectCleanUp cleanUp_VideoSourceSelector( "VideoSourceSelector", &VideoSourceSelector::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* VideoSourceSelector::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = ComboBoxSetting::staticMetaObject();
    metaObj = QMetaObject::new_metaobject(
	"VideoSourceSelector", parentObject,
	0, 0,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_VideoSourceSelector.setMetaObject( metaObj );
    return metaObj;
}

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

bool VideoSourceSelector::qt_invoke( int _id, QUObject* _o )
{
    return ComboBoxSetting::qt_invoke(_id,_o);
}

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

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

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


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

QMetaObject *FreqTableSelector::metaObj = 0;
static QMetaObjectCleanUp cleanUp_FreqTableSelector( "FreqTableSelector", &FreqTableSelector::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* FreqTableSelector::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = ComboBoxSetting::staticMetaObject();
    metaObj = QMetaObject::new_metaobject(
	"FreqTableSelector", parentObject,
	0, 0,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_FreqTableSelector.setMetaObject( metaObj );
    return metaObj;
}

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

bool FreqTableSelector::qt_invoke( int _id, QUObject* _o )
{
    return ComboBoxSetting::qt_invoke(_id,_o);
}

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

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

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


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

QMetaObject *DataDirectLineupSelector::metaObj = 0;
static QMetaObjectCleanUp cleanUp_DataDirectLineupSelector( "DataDirectLineupSelector", &DataDirectLineupSelector::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* DataDirectLineupSelector::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = ComboBoxSetting::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "uid", &static_QUType_QString, 0, QUParameter::In },
	{ "pwd", &static_QUType_QString, 0, QUParameter::In },
	{ "source", &static_QUType_int, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"fillSelections", 3, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "fillSelections(const QString&,const QString&,int)", &slot_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"DataDirectLineupSelector", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_DataDirectLineupSelector.setMetaObject( metaObj );
    return metaObj;
}

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

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

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

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

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


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

QMetaObject *DataDirect_config::metaObj = 0;
static QMetaObjectCleanUp cleanUp_DataDirect_config( "DataDirect_config", &DataDirect_config::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* DataDirect_config::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = VerticalConfigurationGroup::staticMetaObject();
    static const QUMethod slot_0 = {"fillDataDirectLineupSelector", 0, 0 };
    static const QMetaData slot_tbl[] = {
	{ "fillDataDirectLineupSelector()", &slot_0, QMetaData::Protected }
    };
    metaObj = QMetaObject::new_metaobject(
	"DataDirect_config", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_DataDirect_config.setMetaObject( metaObj );
    return metaObj;
}

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

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

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

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

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


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

QMetaObject *TunerCardInput::metaObj = 0;
static QMetaObjectCleanUp cleanUp_TunerCardInput( "TunerCardInput", &TunerCardInput::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

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

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

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

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

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


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

QMetaObject *SingleCardInput::metaObj = 0;
static QMetaObjectCleanUp cleanUp_SingleCardInput( "SingleCardInput", &SingleCardInput::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

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

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

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

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

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


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

QMetaObject *DVBAudioDevice::metaObj = 0;
static QMetaObjectCleanUp cleanUp_DVBAudioDevice( "DVBAudioDevice", &DVBAudioDevice::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* DVBAudioDevice::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = LineEditSetting::staticMetaObject();
    metaObj = QMetaObject::new_metaobject(
	"DVBAudioDevice", parentObject,
	0, 0,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_DVBAudioDevice.setMetaObject( metaObj );
    return metaObj;
}

void* DVBAudioDevice::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "DVBAudioDevice" ) )
	return this;
    if ( !qstrcmp( clname, "CaptureCardDBStorage" ) )
	return (CaptureCardDBStorage*)this;
    return LineEditSetting::qt_cast( clname );
}

bool DVBAudioDevice::qt_invoke( int _id, QUObject* _o )
{
    return LineEditSetting::qt_invoke(_id,_o);
}

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

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

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


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

QMetaObject *DVBVbiDevice::metaObj = 0;
static QMetaObjectCleanUp cleanUp_DVBVbiDevice( "DVBVbiDevice", &DVBVbiDevice::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* DVBVbiDevice::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = LineEditSetting::staticMetaObject();
    metaObj = QMetaObject::new_metaobject(
	"DVBVbiDevice", parentObject,
	0, 0,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_DVBVbiDevice.setMetaObject( metaObj );
    return metaObj;
}

void* DVBVbiDevice::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "DVBVbiDevice" ) )
	return this;
    if ( !qstrcmp( clname, "CaptureCardDBStorage" ) )
	return (CaptureCardDBStorage*)this;
    return LineEditSetting::qt_cast( clname );
}

bool DVBVbiDevice::qt_invoke( int _id, QUObject* _o )
{
    return LineEditSetting::qt_invoke(_id,_o);
}

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

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

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


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

QMetaObject *V4LConfigurationGroup::metaObj = 0;
static QMetaObjectCleanUp cleanUp_V4LConfigurationGroup( "V4LConfigurationGroup", &V4LConfigurationGroup::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

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

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

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

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

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


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

QMetaObject *MPEGConfigurationGroup::metaObj = 0;
static QMetaObjectCleanUp cleanUp_MPEGConfigurationGroup( "MPEGConfigurationGroup", &MPEGConfigurationGroup::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

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

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

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

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

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


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

QMetaObject *DVBConfigurationGroup::metaObj = 0;
static QMetaObjectCleanUp cleanUp_DVBConfigurationGroup( "DVBConfigurationGroup", &DVBConfigurationGroup::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* DVBConfigurationGroup::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = VerticalConfigurationGroup::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "cardNumber", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"probeCard", 1, param_slot_0 };
    static const QUMethod slot_1 = {"DiSEqCPanel", 0, 0 };
    static const QMetaData slot_tbl[] = {
	{ "probeCard(const QString&)", &slot_0, QMetaData::Public },
	{ "DiSEqCPanel()", &slot_1, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"DVBConfigurationGroup", parentObject,
	slot_tbl, 2,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_DVBConfigurationGroup.setMetaObject( metaObj );
    return metaObj;
}

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

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

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

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

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


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

QMetaObject *FirewireModel::metaObj = 0;
static QMetaObjectCleanUp cleanUp_FirewireModel( "FirewireModel", &FirewireModel::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

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

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

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

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

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


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

QMetaObject *FirewireDesc::metaObj = 0;
static QMetaObjectCleanUp cleanUp_FirewireDesc( "FirewireDesc", &FirewireDesc::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

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

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

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

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

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


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

QMetaObject *CaptureCardGroup::metaObj = 0;
static QMetaObjectCleanUp cleanUp_CaptureCardGroup( "CaptureCardGroup", &CaptureCardGroup::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* CaptureCardGroup::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = TriggeredConfigurationGroup::staticMetaObject();
    static const QUParameter param_slot_0[] = {
	{ "value", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_0 = {"triggerChanged", 1, param_slot_0 };
    static const QMetaData slot_tbl[] = {
	{ "triggerChanged(const QString&)", &slot_0, QMetaData::Protected }
    };
    metaObj = QMetaObject::new_metaobject(
	"CaptureCardGroup", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_CaptureCardGroup.setMetaObject( metaObj );
    return metaObj;
}

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

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

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

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

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


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

QMetaObject *CaptureCard::metaObj = 0;
static QMetaObjectCleanUp cleanUp_CaptureCard( "CaptureCard", &CaptureCard::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* CaptureCard::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = QObject::staticMetaObject();
    static const QUMethod slot_0 = {"recorderOptionsPanel", 0, 0 };
    static const QMetaData slot_tbl[] = {
	{ "recorderOptionsPanel()", &slot_0, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"CaptureCard", parentObject,
	slot_tbl, 1,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_CaptureCard.setMetaObject( metaObj );
    return metaObj;
}

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

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

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

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

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


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

QMetaObject *CaptureCardEditor::metaObj = 0;
static QMetaObjectCleanUp cleanUp_CaptureCardEditor( "CaptureCardEditor", &CaptureCardEditor::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* CaptureCardEditor::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = QObject::staticMetaObject();
    static const QUMethod slot_0 = {"menu", 0, 0 };
    static const QUMethod slot_1 = {"edit", 0, 0 };
    static const QUMethod slot_2 = {"del", 0, 0 };
    static const QMetaData slot_tbl[] = {
	{ "menu()", &slot_0, QMetaData::Public },
	{ "edit()", &slot_1, QMetaData::Public },
	{ "del()", &slot_2, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"CaptureCardEditor", parentObject,
	slot_tbl, 3,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_CaptureCardEditor.setMetaObject( metaObj );
    return metaObj;
}

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

bool CaptureCardEditor::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: menu(); break;
    case 1: edit(); break;
    case 2: del(); break;
    default:
	return QObject::qt_invoke( _id, _o );
    }
    return TRUE;
}

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

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

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


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

QMetaObject *VideoSourceEditor::metaObj = 0;
static QMetaObjectCleanUp cleanUp_VideoSourceEditor( "VideoSourceEditor", &VideoSourceEditor::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* VideoSourceEditor::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = QObject::staticMetaObject();
    static const QUMethod slot_0 = {"menu", 0, 0 };
    static const QUMethod slot_1 = {"edit", 0, 0 };
    static const QUMethod slot_2 = {"del", 0, 0 };
    static const QMetaData slot_tbl[] = {
	{ "menu()", &slot_0, QMetaData::Public },
	{ "edit()", &slot_1, QMetaData::Public },
	{ "del()", &slot_2, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"VideoSourceEditor", parentObject,
	slot_tbl, 3,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_VideoSourceEditor.setMetaObject( metaObj );
    return metaObj;
}

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

bool VideoSourceEditor::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: menu(); break;
    case 1: edit(); break;
    case 2: del(); break;
    default:
	return QObject::qt_invoke( _id, _o );
    }
    return TRUE;
}

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

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

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


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

QMetaObject *CardInputEditor::metaObj = 0;
static QMetaObjectCleanUp cleanUp_CardInputEditor( "CardInputEditor", &CardInputEditor::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* CardInputEditor::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = QObject::staticMetaObject();
    metaObj = QMetaObject::new_metaobject(
	"CardInputEditor", parentObject,
	0, 0,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_CardInputEditor.setMetaObject( metaObj );
    return metaObj;
}

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

bool CardInputEditor::qt_invoke( int _id, QUObject* _o )
{
    return QObject::qt_invoke(_id,_o);
}

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

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

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


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

QMetaObject *StartingChannel::metaObj = 0;
static QMetaObjectCleanUp cleanUp_StartingChannel( "StartingChannel", &StartingChannel::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

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

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

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

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

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


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

QMetaObject *CardInput::metaObj = 0;
static QMetaObjectCleanUp cleanUp_CardInput( "CardInput", &CardInput::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* CardInput::staticMetaObject()
{
    if ( metaObj )
	return metaObj;
    QMetaObject* parentObject = QObject::staticMetaObject();
    static const QUMethod slot_0 = {"CreateNewInputGroup", 0, 0 };
    static const QUMethod slot_1 = {"channelScanner", 0, 0 };
    static const QUMethod slot_2 = {"sourceFetch", 0, 0 };
    static const QUParameter param_slot_3[] = {
	{ "sourceid", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_3 = {"SetSourceID", 1, param_slot_3 };
    static const QMetaData slot_tbl[] = {
	{ "CreateNewInputGroup()", &slot_0, QMetaData::Public },
	{ "channelScanner()", &slot_1, QMetaData::Public },
	{ "sourceFetch()", &slot_2, QMetaData::Public },
	{ "SetSourceID(const QString&)", &slot_3, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
	"CardInput", parentObject,
	slot_tbl, 4,
	0, 0,
#ifndef QT_NO_PROPERTIES
	0, 0,
	0, 0,
#endif // QT_NO_PROPERTIES
	0, 0 );
    cleanUp_CardInput.setMetaObject( metaObj );
    return metaObj;
}

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

bool CardInput::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: CreateNewInputGroup(); break;
    case 1: channelScanner(); break;
    case 2: sourceFetch(); break;
    case 3: SetSourceID((const QString&)static_QUType_QString.get(_o+1)); break;
    default:
	return QObject::qt_invoke( _id, _o );
    }
    return TRUE;
}

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

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

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