← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/valkyrie/oneiric

« back to all changes in this revision

Viewing changes to valkyrie/tool_utils/vk_process.moc.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Hai Zaar
  • Date: 2009-05-06 14:48:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090506144800-vw617m4d4qa2pam3
Tags: upstream-1.4.0
Import upstream version 1.4.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
valkyrie/tool_utils/vk_process.moc.cpp
 
1
/****************************************************************************
 
2
** VKProcessManager meta object code from reading C++ file 'vk_process.h'
 
3
**
 
4
** Created: Sat Feb 21 11:49:29 2009
 
5
**      by: The Qt MOC ($Id: qt/moc_yacc.cpp   3.3.8   edited Feb 2 14:59 $)
 
6
**
 
7
** WARNING! All changes made in this file will be lost!
 
8
*****************************************************************************/
 
9
 
 
10
#undef QT_NO_COMPAT
 
11
#include "vk_process.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.8b. 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 *VKProcessManager::className() const
 
23
{
 
24
    return "VKProcessManager";
 
25
}
 
26
 
 
27
QMetaObject *VKProcessManager::metaObj = 0;
 
28
static QMetaObjectCleanUp cleanUp_VKProcessManager( "VKProcessManager", &VKProcessManager::staticMetaObject );
 
29
 
 
30
#ifndef QT_NO_TRANSLATION
 
31
QString VKProcessManager::tr( const char *s, const char *c )
 
32
{
 
33
    if ( qApp )
 
34
        return qApp->translate( "VKProcessManager", s, c, QApplication::DefaultCodec );
 
35
    else
 
36
        return QString::fromLatin1( s );
 
37
}
 
38
#ifndef QT_NO_TRANSLATION_UTF8
 
39
QString VKProcessManager::trUtf8( const char *s, const char *c )
 
40
{
 
41
    if ( qApp )
 
42
        return qApp->translate( "VKProcessManager", 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* VKProcessManager::staticMetaObject()
 
51
{
 
52
    if ( metaObj )
 
53
        return metaObj;
 
54
    QMetaObject* parentObject = QObject::staticMetaObject();
 
55
    static const QUMethod slot_0 = {"removeMe", 0, 0 };
 
56
    static const QUParameter param_slot_1[] = {
 
57
        { 0, &static_QUType_int, 0, QUParameter::In }
 
58
    };
 
59
    static const QUMethod slot_1 = {"sigchldHnd", 1, param_slot_1 };
 
60
    static const QMetaData slot_tbl[] = {
 
61
        { "removeMe()", &slot_0, QMetaData::Public },
 
62
        { "sigchldHnd(int)", &slot_1, QMetaData::Public }
 
63
    };
 
64
    metaObj = QMetaObject::new_metaobject(
 
65
        "VKProcessManager", parentObject,
 
66
        slot_tbl, 2,
 
67
        0, 0,
 
68
#ifndef QT_NO_PROPERTIES
 
69
        0, 0,
 
70
        0, 0,
 
71
#endif // QT_NO_PROPERTIES
 
72
        0, 0 );
 
73
    cleanUp_VKProcessManager.setMetaObject( metaObj );
 
74
    return metaObj;
 
75
}
 
76
 
 
77
void* VKProcessManager::qt_cast( const char* clname )
 
78
{
 
79
    if ( !qstrcmp( clname, "VKProcessManager" ) )
 
80
        return this;
 
81
    return QObject::qt_cast( clname );
 
82
}
 
83
 
 
84
bool VKProcessManager::qt_invoke( int _id, QUObject* _o )
 
85
{
 
86
    switch ( _id - staticMetaObject()->slotOffset() ) {
 
87
    case 0: removeMe(); break;
 
88
    case 1: sigchldHnd((int)static_QUType_int.get(_o+1)); break;
 
89
    default:
 
90
        return QObject::qt_invoke( _id, _o );
 
91
    }
 
92
    return TRUE;
 
93
}
 
94
 
 
95
bool VKProcessManager::qt_emit( int _id, QUObject* _o )
 
96
{
 
97
    return QObject::qt_emit(_id,_o);
 
98
}
 
99
#ifndef QT_NO_PROPERTIES
 
100
 
 
101
bool VKProcessManager::qt_property( int id, int f, QVariant* v)
 
102
{
 
103
    return QObject::qt_property( id, f, v);
 
104
}
 
105
 
 
106
bool VKProcessManager::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
 
107
#endif // QT_NO_PROPERTIES
 
108
 
 
109
 
 
110
const char *VKProcess::className() const
 
111
{
 
112
    return "VKProcess";
 
113
}
 
114
 
 
115
QMetaObject *VKProcess::metaObj = 0;
 
116
static QMetaObjectCleanUp cleanUp_VKProcess( "VKProcess", &VKProcess::staticMetaObject );
 
117
 
 
118
#ifndef QT_NO_TRANSLATION
 
119
QString VKProcess::tr( const char *s, const char *c )
 
120
{
 
121
    if ( qApp )
 
122
        return qApp->translate( "VKProcess", s, c, QApplication::DefaultCodec );
 
123
    else
 
124
        return QString::fromLatin1( s );
 
125
}
 
126
#ifndef QT_NO_TRANSLATION_UTF8
 
127
QString VKProcess::trUtf8( const char *s, const char *c )
 
128
{
 
129
    if ( qApp )
 
130
        return qApp->translate( "VKProcess", s, c, QApplication::UnicodeUTF8 );
 
131
    else
 
132
        return QString::fromUtf8( s );
 
133
}
 
134
#endif // QT_NO_TRANSLATION_UTF8
 
135
 
 
136
#endif // QT_NO_TRANSLATION
 
137
 
 
138
QMetaObject* VKProcess::staticMetaObject()
 
139
{
 
140
    if ( metaObj )
 
141
        return metaObj;
 
142
    QMetaObject* parentObject = QObject::staticMetaObject();
 
143
    static const QUMethod slot_0 = {"stop", 0, 0 };
 
144
    static const QUParameter param_slot_1[] = {
 
145
        { "msec_kill_timeout", &static_QUType_int, 0, QUParameter::In }
 
146
    };
 
147
    static const QUMethod slot_1 = {"stop", 1, param_slot_1 };
 
148
    static const QUMethod slot_2 = {"tryTerminate", 0, 0 };
 
149
    static const QUMethod slot_3 = {"kill", 0, 0 };
 
150
    static const QUParameter param_slot_4[] = {
 
151
        { "buf", &static_QUType_varptr, "\x1d", QUParameter::In }
 
152
    };
 
153
    static const QUMethod slot_4 = {"writeToFDin", 1, param_slot_4 };
 
154
    static const QUParameter param_slot_5[] = {
 
155
        { "buf", &static_QUType_QString, 0, QUParameter::In }
 
156
    };
 
157
    static const QUMethod slot_5 = {"writeToFDin", 1, param_slot_5 };
 
158
    static const QUMethod slot_6 = {"closeFDin", 0, 0 };
 
159
    static const QUParameter param_slot_7[] = {
 
160
        { "buf", &static_QUType_varptr, "\x1d", QUParameter::In }
 
161
    };
 
162
    static const QUMethod slot_7 = {"writeToStdin", 1, param_slot_7 };
 
163
    static const QUParameter param_slot_8[] = {
 
164
        { "buf", &static_QUType_QString, 0, QUParameter::In }
 
165
    };
 
166
    static const QUMethod slot_8 = {"writeToStdin", 1, param_slot_8 };
 
167
    static const QUMethod slot_9 = {"closeStdin", 0, 0 };
 
168
    static const QUParameter param_slot_10[] = {
 
169
        { "fd", &static_QUType_int, 0, QUParameter::In }
 
170
    };
 
171
    static const QUMethod slot_10 = {"socketRead", 1, param_slot_10 };
 
172
    static const QUParameter param_slot_11[] = {
 
173
        { "fd", &static_QUType_int, 0, QUParameter::In }
 
174
    };
 
175
    static const QUMethod slot_11 = {"socketWrite", 1, param_slot_11 };
 
176
    static const QUMethod slot_12 = {"timeout", 0, 0 };
 
177
    static const QUMethod slot_13 = {"closeStdinLaunch", 0, 0 };
 
178
    static const QMetaData slot_tbl[] = {
 
179
        { "stop()", &slot_0, QMetaData::Public },
 
180
        { "stop(int)", &slot_1, QMetaData::Public },
 
181
        { "tryTerminate()", &slot_2, QMetaData::Public },
 
182
        { "kill()", &slot_3, QMetaData::Public },
 
183
        { "writeToFDin(const QByteArray&)", &slot_4, QMetaData::Public },
 
184
        { "writeToFDin(const QString&)", &slot_5, QMetaData::Public },
 
185
        { "closeFDin()", &slot_6, QMetaData::Public },
 
186
        { "writeToStdin(const QByteArray&)", &slot_7, QMetaData::Public },
 
187
        { "writeToStdin(const QString&)", &slot_8, QMetaData::Public },
 
188
        { "closeStdin()", &slot_9, QMetaData::Public },
 
189
        { "socketRead(int)", &slot_10, QMetaData::Private },
 
190
        { "socketWrite(int)", &slot_11, QMetaData::Private },
 
191
        { "timeout()", &slot_12, QMetaData::Private },
 
192
        { "closeStdinLaunch()", &slot_13, QMetaData::Private }
 
193
    };
 
194
    static const QUMethod signal_0 = {"readyReadFDout", 0, 0 };
 
195
    static const QUMethod signal_1 = {"readyReadStdout", 0, 0 };
 
196
    static const QUMethod signal_2 = {"readyReadStderr", 0, 0 };
 
197
    static const QUMethod signal_3 = {"processExited", 0, 0 };
 
198
    static const QUMethod signal_4 = {"wroteToFDin", 0, 0 };
 
199
    static const QUMethod signal_5 = {"wroteToStdin", 0, 0 };
 
200
    static const QUMethod signal_6 = {"launchFinished", 0, 0 };
 
201
    static const QMetaData signal_tbl[] = {
 
202
        { "readyReadFDout()", &signal_0, QMetaData::Public },
 
203
        { "readyReadStdout()", &signal_1, QMetaData::Public },
 
204
        { "readyReadStderr()", &signal_2, QMetaData::Public },
 
205
        { "processExited()", &signal_3, QMetaData::Public },
 
206
        { "wroteToFDin()", &signal_4, QMetaData::Public },
 
207
        { "wroteToStdin()", &signal_5, QMetaData::Public },
 
208
        { "launchFinished()", &signal_6, QMetaData::Public }
 
209
    };
 
210
    metaObj = QMetaObject::new_metaobject(
 
211
        "VKProcess", parentObject,
 
212
        slot_tbl, 14,
 
213
        signal_tbl, 7,
 
214
#ifndef QT_NO_PROPERTIES
 
215
        0, 0,
 
216
        0, 0,
 
217
#endif // QT_NO_PROPERTIES
 
218
        0, 0 );
 
219
    cleanUp_VKProcess.setMetaObject( metaObj );
 
220
    return metaObj;
 
221
}
 
222
 
 
223
void* VKProcess::qt_cast( const char* clname )
 
224
{
 
225
    if ( !qstrcmp( clname, "VKProcess" ) )
 
226
        return this;
 
227
    return QObject::qt_cast( clname );
 
228
}
 
229
 
 
230
// SIGNAL readyReadFDout
 
231
void VKProcess::readyReadFDout()
 
232
{
 
233
    activate_signal( staticMetaObject()->signalOffset() + 0 );
 
234
}
 
235
 
 
236
// SIGNAL readyReadStdout
 
237
void VKProcess::readyReadStdout()
 
238
{
 
239
    activate_signal( staticMetaObject()->signalOffset() + 1 );
 
240
}
 
241
 
 
242
// SIGNAL readyReadStderr
 
243
void VKProcess::readyReadStderr()
 
244
{
 
245
    activate_signal( staticMetaObject()->signalOffset() + 2 );
 
246
}
 
247
 
 
248
// SIGNAL processExited
 
249
void VKProcess::processExited()
 
250
{
 
251
    activate_signal( staticMetaObject()->signalOffset() + 3 );
 
252
}
 
253
 
 
254
// SIGNAL wroteToFDin
 
255
void VKProcess::wroteToFDin()
 
256
{
 
257
    activate_signal( staticMetaObject()->signalOffset() + 4 );
 
258
}
 
259
 
 
260
// SIGNAL wroteToStdin
 
261
void VKProcess::wroteToStdin()
 
262
{
 
263
    activate_signal( staticMetaObject()->signalOffset() + 5 );
 
264
}
 
265
 
 
266
// SIGNAL launchFinished
 
267
void VKProcess::launchFinished()
 
268
{
 
269
    activate_signal( staticMetaObject()->signalOffset() + 6 );
 
270
}
 
271
 
 
272
bool VKProcess::qt_invoke( int _id, QUObject* _o )
 
273
{
 
274
    switch ( _id - staticMetaObject()->slotOffset() ) {
 
275
    case 0: stop(); break;
 
276
    case 1: stop((int)static_QUType_int.get(_o+1)); break;
 
277
    case 2: tryTerminate(); break;
 
278
    case 3: kill(); break;
 
279
    case 4: writeToFDin((const QByteArray&)*((const QByteArray*)static_QUType_ptr.get(_o+1))); break;
 
280
    case 5: writeToFDin((const QString&)static_QUType_QString.get(_o+1)); break;
 
281
    case 6: closeFDin(); break;
 
282
    case 7: writeToStdin((const QByteArray&)*((const QByteArray*)static_QUType_ptr.get(_o+1))); break;
 
283
    case 8: writeToStdin((const QString&)static_QUType_QString.get(_o+1)); break;
 
284
    case 9: closeStdin(); break;
 
285
    case 10: socketRead((int)static_QUType_int.get(_o+1)); break;
 
286
    case 11: socketWrite((int)static_QUType_int.get(_o+1)); break;
 
287
    case 12: timeout(); break;
 
288
    case 13: closeStdinLaunch(); break;
 
289
    default:
 
290
        return QObject::qt_invoke( _id, _o );
 
291
    }
 
292
    return TRUE;
 
293
}
 
294
 
 
295
bool VKProcess::qt_emit( int _id, QUObject* _o )
 
296
{
 
297
    switch ( _id - staticMetaObject()->signalOffset() ) {
 
298
    case 0: readyReadFDout(); break;
 
299
    case 1: readyReadStdout(); break;
 
300
    case 2: readyReadStderr(); break;
 
301
    case 3: processExited(); break;
 
302
    case 4: wroteToFDin(); break;
 
303
    case 5: wroteToStdin(); break;
 
304
    case 6: launchFinished(); break;
 
305
    default:
 
306
        return QObject::qt_emit(_id,_o);
 
307
    }
 
308
    return TRUE;
 
309
}
 
310
#ifndef QT_NO_PROPERTIES
 
311
 
 
312
bool VKProcess::qt_property( int id, int f, QVariant* v)
 
313
{
 
314
    return QObject::qt_property( id, f, v);
 
315
}
 
316
 
 
317
bool VKProcess::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
 
318
#endif // QT_NO_PROPERTIES