plugins/grass/qgsgrassmodule.moc.cpp

/****************************************************************************
** QgsGrassModule meta object code from reading C++ file 'qgsgrassmodule.h'
**
** Created: Fri Apr 7 17:20:38 2006
**      by: The Qt MOC ($Id: qt/moc_yacc.cpp   3.3.5   edited Sep 2 14:41 $)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

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

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

QMetaObject *QgsGrassModule::metaObj = 0;
static QMetaObjectCleanUp cleanUp_QgsGrassModule( "QgsGrassModule", &QgsGrassModule::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

QMetaObject* QgsGrassModule::staticMetaObject()
{
    if ( metaObj )
        return metaObj;
    QMetaObject* parentObject = QgsGrassModuleBase::staticMetaObject();
    static const QUMethod slot_0 = {"run", 0, 0 };
    static const QUMethod slot_1 = {"close", 0, 0 };
    static const QUMethod slot_2 = {"finished", 0, 0 };
    static const QUMethod slot_3 = {"readStdout", 0, 0 };
    static const QUMethod slot_4 = {"readStderr", 0, 0 };
    static const QMetaData slot_tbl[] = {
        { "run()", &slot_0, QMetaData::Public },
        { "close()", &slot_1, QMetaData::Public },
        { "finished()", &slot_2, QMetaData::Public },
        { "readStdout()", &slot_3, QMetaData::Public },
        { "readStderr()", &slot_4, QMetaData::Public }
    };
    metaObj = QMetaObject::new_metaobject(
        "QgsGrassModule", parentObject,
        slot_tbl, 5,
        0, 0,
#ifndef QT_NO_PROPERTIES
        0, 0,
        0, 0,
#endif // QT_NO_PROPERTIES
        0, 0 );
    cleanUp_QgsGrassModule.setMetaObject( metaObj );
    return metaObj;
}

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

bool QgsGrassModule::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: run(); break;
    case 1: close(); break;
    case 2: finished(); break;
    case 3: readStdout(); break;
    case 4: readStderr(); break;
    default:
        return QgsGrassModuleBase::qt_invoke( _id, _o );
    }
    return TRUE;
}

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

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

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


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

QMetaObject *QgsGrassModuleOption::metaObj = 0;
static QMetaObjectCleanUp cleanUp_QgsGrassModuleOption( "QgsGrassModuleOption", &QgsGrassModuleOption::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

void* QgsGrassModuleOption::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "QgsGrassModuleOption" ) )
        return this;
    if ( !qstrcmp( clname, "QgsGrassModuleItem" ) )
        return (QgsGrassModuleItem*)this;
    return QVGroupBox::qt_cast( clname );
}

bool QgsGrassModuleOption::qt_invoke( int _id, QUObject* _o )
{
    return QVGroupBox::qt_invoke(_id,_o);
}

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

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

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


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

QMetaObject *QgsGrassModuleFlag::metaObj = 0;
static QMetaObjectCleanUp cleanUp_QgsGrassModuleFlag( "QgsGrassModuleFlag", &QgsGrassModuleFlag::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

void* QgsGrassModuleFlag::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "QgsGrassModuleFlag" ) )
        return this;
    if ( !qstrcmp( clname, "QgsGrassModuleItem" ) )
        return (QgsGrassModuleItem*)this;
    return QCheckBox::qt_cast( clname );
}

bool QgsGrassModuleFlag::qt_invoke( int _id, QUObject* _o )
{
    return QCheckBox::qt_invoke(_id,_o);
}

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

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

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


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

QMetaObject *QgsGrassModuleInput::metaObj = 0;
static QMetaObjectCleanUp cleanUp_QgsGrassModuleInput( "QgsGrassModuleInput", &QgsGrassModuleInput::staticMetaObject );

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

#endif // QT_NO_TRANSLATION

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

void* QgsGrassModuleInput::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "QgsGrassModuleInput" ) )
        return this;
    if ( !qstrcmp( clname, "QgsGrassModuleItem" ) )
        return (QgsGrassModuleItem*)this;
    return QVGroupBox::qt_cast( clname );
}

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

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

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

bool QgsGrassModuleInput::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
#endif // QT_NO_PROPERTIES
1	/****************************************************************************
2	** QgsGrassModule meta object code from reading C++ file 'qgsgrassmodule.h'
3	**
4	** Created: Fri Apr 7 17:20:38 2006
5	** by: The Qt MOC ($Id: qt/moc_yacc.cpp 3.3.5 edited Sep 2 14:41 $)
6	**
7	** WARNING! All changes made in this file will be lost!
8	*****************************************************************************/
9
10	#undef QT_NO_COMPAT
11	#include "qgsgrassmodule.h"
12	#include <qmetaobject.h>
13	#include <qapplication.h>
14
15	#include <private/qucomextra_p.h>
16	#if !defined(Q_MOC_OUTPUT_REVISION) \|\| (Q_MOC_OUTPUT_REVISION != 26)
17	#error "This file was generated using the moc from 3.3.5. It"
18	#error "cannot be used with the include files from this version of Qt."
19	#error "(The moc has changed too much.)"
20	#endif
21
22	const char *QgsGrassModule::className() const
23	{
24	return "QgsGrassModule";
25	}
26
27	QMetaObject *QgsGrassModule::metaObj = 0;
28	static QMetaObjectCleanUp cleanUp_QgsGrassModule( "QgsGrassModule", &QgsGrassModule::staticMetaObject );
29
30	#ifndef QT_NO_TRANSLATION
31	QString QgsGrassModule::tr( const char s, const char c )
32	{
33	if ( qApp )
34	return qApp->translate( "QgsGrassModule", s, c, QApplication::DefaultCodec );
35	else
36	return QString::fromLatin1( s );
37	}
38	#ifndef QT_NO_TRANSLATION_UTF8
39	QString QgsGrassModule::trUtf8( const char s, const char c )
40	{
41	if ( qApp )
42	return qApp->translate( "QgsGrassModule", s, c, QApplication::UnicodeUTF8 );
43	else
44	return QString::fromUtf8( s );
45	}
46	#endif // QT_NO_TRANSLATION_UTF8
47
48	#endif // QT_NO_TRANSLATION
49
50	QMetaObject* QgsGrassModule::staticMetaObject()
51	{
52	if ( metaObj )
53	return metaObj;
54	QMetaObject* parentObject = QgsGrassModuleBase::staticMetaObject();
55	static const QUMethod slot_0 = {"run", 0, 0 };
56	static const QUMethod slot_1 = {"close", 0, 0 };
57	static const QUMethod slot_2 = {"finished", 0, 0 };
58	static const QUMethod slot_3 = {"readStdout", 0, 0 };
59	static const QUMethod slot_4 = {"readStderr", 0, 0 };
60	static const QMetaData slot_tbl[] = {
61	{ "run()", &slot_0, QMetaData::Public },
62	{ "close()", &slot_1, QMetaData::Public },
63	{ "finished()", &slot_2, QMetaData::Public },
64	{ "readStdout()", &slot_3, QMetaData::Public },
65	{ "readStderr()", &slot_4, QMetaData::Public }
66	};
67	metaObj = QMetaObject::new_metaobject(
68	"QgsGrassModule", parentObject,
69	slot_tbl, 5,
70	0, 0,
71	#ifndef QT_NO_PROPERTIES
72	0, 0,
73	0, 0,
74	#endif // QT_NO_PROPERTIES
75	0, 0 );
76	cleanUp_QgsGrassModule.setMetaObject( metaObj );
77	return metaObj;
78	}
79
80	void* QgsGrassModule::qt_cast( const char* clname )
81	{
82	if ( !qstrcmp( clname, "QgsGrassModule" ) )
83	return this;
84	return QgsGrassModuleBase::qt_cast( clname );
85	}
86
87	bool QgsGrassModule::qt_invoke( int _id, QUObject* _o )
88	{
89	switch ( _id - staticMetaObject()->slotOffset() ) {
90	case 0: run(); break;
91	case 1: close(); break;
92	case 2: finished(); break;
93	case 3: readStdout(); break;
94	case 4: readStderr(); break;
95	default:
96	return QgsGrassModuleBase::qt_invoke( _id, _o );
97	}
98	return TRUE;
99	}
100
101	bool QgsGrassModule::qt_emit( int _id, QUObject* _o )
102	{
103	return QgsGrassModuleBase::qt_emit(_id,_o);
104	}
105	#ifndef QT_NO_PROPERTIES
106
107	bool QgsGrassModule::qt_property( int id, int f, QVariant* v)
108	{
109	return QgsGrassModuleBase::qt_property( id, f, v);
110	}
111
112	bool QgsGrassModule::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
113	#endif // QT_NO_PROPERTIES
114
115
116	const char *QgsGrassModuleOption::className() const
117	{
118	return "QgsGrassModuleOption";
119	}
120
121	QMetaObject *QgsGrassModuleOption::metaObj = 0;
122	static QMetaObjectCleanUp cleanUp_QgsGrassModuleOption( "QgsGrassModuleOption", &QgsGrassModuleOption::staticMetaObject );
123
124	#ifndef QT_NO_TRANSLATION
125	QString QgsGrassModuleOption::tr( const char s, const char c )
126	{
127	if ( qApp )
128	return qApp->translate( "QgsGrassModuleOption", s, c, QApplication::DefaultCodec );
129	else
130	return QString::fromLatin1( s );
131	}
132	#ifndef QT_NO_TRANSLATION_UTF8
133	QString QgsGrassModuleOption::trUtf8( const char s, const char c )
134	{
135	if ( qApp )
136	return qApp->translate( "QgsGrassModuleOption", s, c, QApplication::UnicodeUTF8 );
137	else
138	return QString::fromUtf8( s );
139	}
140	#endif // QT_NO_TRANSLATION_UTF8
141
142	#endif // QT_NO_TRANSLATION
143
144	QMetaObject* QgsGrassModuleOption::staticMetaObject()
145	{
146	if ( metaObj )
147	return metaObj;
148	QMetaObject* parentObject = QVGroupBox::staticMetaObject();
149	metaObj = QMetaObject::new_metaobject(
150	"QgsGrassModuleOption", parentObject,
151	0, 0,
152	0, 0,
153	#ifndef QT_NO_PROPERTIES
154	0, 0,
155	0, 0,
156	#endif // QT_NO_PROPERTIES
157	0, 0 );
158	cleanUp_QgsGrassModuleOption.setMetaObject( metaObj );
159	return metaObj;
160	}
161
162	void* QgsGrassModuleOption::qt_cast( const char* clname )
163	{
164	if ( !qstrcmp( clname, "QgsGrassModuleOption" ) )
165	return this;
166	if ( !qstrcmp( clname, "QgsGrassModuleItem" ) )
167	return (QgsGrassModuleItem*)this;
168	return QVGroupBox::qt_cast( clname );
169	}
170
171	bool QgsGrassModuleOption::qt_invoke( int _id, QUObject* _o )
172	{
173	return QVGroupBox::qt_invoke(_id,_o);
174	}
175
176	bool QgsGrassModuleOption::qt_emit( int _id, QUObject* _o )
177	{
178	return QVGroupBox::qt_emit(_id,_o);
179	}
180	#ifndef QT_NO_PROPERTIES
181
182	bool QgsGrassModuleOption::qt_property( int id, int f, QVariant* v)
183	{
184	return QVGroupBox::qt_property( id, f, v);
185	}
186
187	bool QgsGrassModuleOption::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
188	#endif // QT_NO_PROPERTIES
189
190
191	const char *QgsGrassModuleFlag::className() const
192	{
193	return "QgsGrassModuleFlag";
194	}
195
196	QMetaObject *QgsGrassModuleFlag::metaObj = 0;
197	static QMetaObjectCleanUp cleanUp_QgsGrassModuleFlag( "QgsGrassModuleFlag", &QgsGrassModuleFlag::staticMetaObject );
198
199	#ifndef QT_NO_TRANSLATION
200	QString QgsGrassModuleFlag::tr( const char s, const char c )
201	{
202	if ( qApp )
203	return qApp->translate( "QgsGrassModuleFlag", s, c, QApplication::DefaultCodec );
204	else
205	return QString::fromLatin1( s );
206	}
207	#ifndef QT_NO_TRANSLATION_UTF8
208	QString QgsGrassModuleFlag::trUtf8( const char s, const char c )
209	{
210	if ( qApp )
211	return qApp->translate( "QgsGrassModuleFlag", s, c, QApplication::UnicodeUTF8 );
212	else
213	return QString::fromUtf8( s );
214	}
215	#endif // QT_NO_TRANSLATION_UTF8
216
217	#endif // QT_NO_TRANSLATION
218
219	QMetaObject* QgsGrassModuleFlag::staticMetaObject()
220	{
221	if ( metaObj )
222	return metaObj;
223	QMetaObject* parentObject = QCheckBox::staticMetaObject();
224	metaObj = QMetaObject::new_metaobject(
225	"QgsGrassModuleFlag", parentObject,
226	0, 0,
227	0, 0,
228	#ifndef QT_NO_PROPERTIES
229	0, 0,
230	0, 0,
231	#endif // QT_NO_PROPERTIES
232	0, 0 );
233	cleanUp_QgsGrassModuleFlag.setMetaObject( metaObj );
234	return metaObj;
235	}
236
237	void* QgsGrassModuleFlag::qt_cast( const char* clname )
238	{
239	if ( !qstrcmp( clname, "QgsGrassModuleFlag" ) )
240	return this;
241	if ( !qstrcmp( clname, "QgsGrassModuleItem" ) )
242	return (QgsGrassModuleItem*)this;
243	return QCheckBox::qt_cast( clname );
244	}
245
246	bool QgsGrassModuleFlag::qt_invoke( int _id, QUObject* _o )
247	{
248	return QCheckBox::qt_invoke(_id,_o);
249	}
250
251	bool QgsGrassModuleFlag::qt_emit( int _id, QUObject* _o )
252	{
253	return QCheckBox::qt_emit(_id,_o);
254	}
255	#ifndef QT_NO_PROPERTIES
256
257	bool QgsGrassModuleFlag::qt_property( int id, int f, QVariant* v)
258	{
259	return QCheckBox::qt_property( id, f, v);
260	}
261
262	bool QgsGrassModuleFlag::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
263	#endif // QT_NO_PROPERTIES
264
265
266	const char *QgsGrassModuleInput::className() const
267	{
268	return "QgsGrassModuleInput";
269	}
270
271	QMetaObject *QgsGrassModuleInput::metaObj = 0;
272	static QMetaObjectCleanUp cleanUp_QgsGrassModuleInput( "QgsGrassModuleInput", &QgsGrassModuleInput::staticMetaObject );
273
274	#ifndef QT_NO_TRANSLATION
275	QString QgsGrassModuleInput::tr( const char s, const char c )
276	{
277	if ( qApp )
278	return qApp->translate( "QgsGrassModuleInput", s, c, QApplication::DefaultCodec );
279	else
280	return QString::fromLatin1( s );
281	}
282	#ifndef QT_NO_TRANSLATION_UTF8
283	QString QgsGrassModuleInput::trUtf8( const char s, const char c )
284	{
285	if ( qApp )
286	return qApp->translate( "QgsGrassModuleInput", s, c, QApplication::UnicodeUTF8 );
287	else
288	return QString::fromUtf8( s );
289	}
290	#endif // QT_NO_TRANSLATION_UTF8
291
292	#endif // QT_NO_TRANSLATION
293
294	QMetaObject* QgsGrassModuleInput::staticMetaObject()
295	{
296	if ( metaObj )
297	return metaObj;
298	QMetaObject* parentObject = QVGroupBox::staticMetaObject();
299	static const QUMethod slot_0 = {"updateQgisLayers", 0, 0 };
300	static const QMetaData slot_tbl[] = {
301	{ "updateQgisLayers()", &slot_0, QMetaData::Public }
302	};
303	metaObj = QMetaObject::new_metaobject(
304	"QgsGrassModuleInput", parentObject,
305	slot_tbl, 1,
306	0, 0,
307	#ifndef QT_NO_PROPERTIES
308	0, 0,
309	0, 0,
310	#endif // QT_NO_PROPERTIES
311	0, 0 );
312	cleanUp_QgsGrassModuleInput.setMetaObject( metaObj );
313	return metaObj;
314	}
315
316	void* QgsGrassModuleInput::qt_cast( const char* clname )
317	{
318	if ( !qstrcmp( clname, "QgsGrassModuleInput" ) )
319	return this;
320	if ( !qstrcmp( clname, "QgsGrassModuleItem" ) )
321	return (QgsGrassModuleItem*)this;
322	return QVGroupBox::qt_cast( clname );
323	}
324
325	bool QgsGrassModuleInput::qt_invoke( int _id, QUObject* _o )
326	{
327	switch ( _id - staticMetaObject()->slotOffset() ) {
328	case 0: updateQgisLayers(); break;
329	default:
330	return QVGroupBox::qt_invoke( _id, _o );
331	}
332	return TRUE;
333	}
334
335	bool QgsGrassModuleInput::qt_emit( int _id, QUObject* _o )
336	{
337	return QVGroupBox::qt_emit(_id,_o);
338	}
339	#ifndef QT_NO_PROPERTIES
340
341	bool QgsGrassModuleInput::qt_property( int id, int f, QVariant* v)
342	{
343	return QVGroupBox::qt_property( id, f, v);
344	}
345
346	bool QgsGrassModuleInput::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
347	#endif // QT_NO_PROPERTIES