← Back to branch summary

~ubuntu-branches/ubuntu/lucid/qt-x11-free/lucid

« back to all changes in this revision

Viewing changes to src/.moc/release-shared-mt/moc_qaction.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2009-11-09 14:37:51 UTC
  • mfrom: (0.32.3 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091109143751-ocohpw4y0j4yi20w
Tags: 3:3.3.8-b-6ubuntu1
https://launchpad.net/bugs/209227
* Merge with Debian, remaining changes:
 - Add kubuntu_06_fglrx_0_size_screen.dpatch work around fglrx reporting a 0 size screen.
   Closes https://bugs.launchpad.net/ubuntu/+source/qt-x11-free/+bug/81686
 - Add kubuntu_09_flickerfree_qiconview.dpatch to add
   double-buffering for the icon redraw - prevents flicker on window
   redrawing (LP: #209227)
 - No firebird/ibase build (remove build-dep, control entry, ibase
   ./configure option), firebird is not in Ubuntu main
 - Add debian/qt_plugins_3.3rc and debian/qtrc to set default style to plastique, edit libqt3-mt.install to install them

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/.moc/release-shared-mt/moc_qaction.cpp
1
 
/****************************************************************************
2
 
** QAction meta object code from reading C++ file 'qaction.h'
3
 
**
4
 
** Created: Fri May 2 11:45:32 2008
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 "../../widgets/qaction.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
 
#include <qvariant.h>
23
 
const char *QAction::className() const
24
 
{
25
 
    return "QAction";
26
 
}
27
 
 
28
 
QMetaObject *QAction::metaObj = 0;
29
 
static QMetaObjectCleanUp cleanUp_QAction( "QAction", &QAction::staticMetaObject );
30
 
 
31
 
#ifndef QT_NO_TRANSLATION
32
 
QString QAction::tr( const char *s, const char *c )
33
 
{
34
 
    if ( qApp )
35
 
        return qApp->translate( "QAction", s, c, QApplication::DefaultCodec );
36
 
    else
37
 
        return QString::fromLatin1( s );
38
 
}
39
 
#ifndef QT_NO_TRANSLATION_UTF8
40
 
QString QAction::trUtf8( const char *s, const char *c )
41
 
{
42
 
    if ( qApp )
43
 
        return qApp->translate( "QAction", s, c, QApplication::UnicodeUTF8 );
44
 
    else
45
 
        return QString::fromUtf8( s );
46
 
}
47
 
#endif // QT_NO_TRANSLATION_UTF8
48
 
 
49
 
#endif // QT_NO_TRANSLATION
50
 
 
51
 
QMetaObject* QAction::staticMetaObject()
52
 
{
53
 
    if ( metaObj )
54
 
        return metaObj;
55
 
    QMetaObject* parentObject = QObject::staticMetaObject();
56
 
    static const QUMethod slot_0 = {"activate", 0, 0 };
57
 
    static const QUMethod slot_1 = {"toggle", 0, 0 };
58
 
    static const QUParameter param_slot_2[] = {
59
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
60
 
    };
61
 
    static const QUMethod slot_2 = {"setOn", 1, param_slot_2 };
62
 
    static const QUParameter param_slot_3[] = {
63
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
64
 
    };
65
 
    static const QUMethod slot_3 = {"setEnabled", 1, param_slot_3 };
66
 
    static const QUParameter param_slot_4[] = {
67
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
68
 
    };
69
 
    static const QUMethod slot_4 = {"setDisabled", 1, param_slot_4 };
70
 
    static const QUParameter param_slot_5[] = {
71
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
72
 
    };
73
 
    static const QUMethod slot_5 = {"setVisible", 1, param_slot_5 };
74
 
    static const QUMethod slot_6 = {"internalActivation", 0, 0 };
75
 
    static const QUParameter param_slot_7[] = {
76
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
77
 
    };
78
 
    static const QUMethod slot_7 = {"toolButtonToggled", 1, param_slot_7 };
79
 
    static const QUMethod slot_8 = {"objectDestroyed", 0, 0 };
80
 
    static const QUParameter param_slot_9[] = {
81
 
        { "id", &static_QUType_int, 0, QUParameter::In }
82
 
    };
83
 
    static const QUMethod slot_9 = {"menuStatusText", 1, param_slot_9 };
84
 
    static const QUParameter param_slot_10[] = {
85
 
        { 0, &static_QUType_QString, 0, QUParameter::In }
86
 
    };
87
 
    static const QUMethod slot_10 = {"showStatusText", 1, param_slot_10 };
88
 
    static const QUMethod slot_11 = {"clearStatusText", 0, 0 };
89
 
    static const QMetaData slot_tbl[] = {
90
 
        { "activate()", &slot_0, QMetaData::Public },
91
 
        { "toggle()", &slot_1, QMetaData::Public },
92
 
        { "setOn(bool)", &slot_2, QMetaData::Public },
93
 
        { "setEnabled(bool)", &slot_3, QMetaData::Public },
94
 
        { "setDisabled(bool)", &slot_4, QMetaData::Public },
95
 
        { "setVisible(bool)", &slot_5, QMetaData::Public },
96
 
        { "internalActivation()", &slot_6, QMetaData::Private },
97
 
        { "toolButtonToggled(bool)", &slot_7, QMetaData::Private },
98
 
        { "objectDestroyed()", &slot_8, QMetaData::Private },
99
 
        { "menuStatusText(int)", &slot_9, QMetaData::Private },
100
 
        { "showStatusText(const QString&)", &slot_10, QMetaData::Private },
101
 
        { "clearStatusText()", &slot_11, QMetaData::Private }
102
 
    };
103
 
    static const QUMethod signal_0 = {"activated", 0, 0 };
104
 
    static const QUParameter param_signal_1[] = {
105
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
106
 
    };
107
 
    static const QUMethod signal_1 = {"toggled", 1, param_signal_1 };
108
 
    static const QMetaData signal_tbl[] = {
109
 
        { "activated()", &signal_0, QMetaData::Public },
110
 
        { "toggled(bool)", &signal_1, QMetaData::Public }
111
 
    };
112
 
#ifndef QT_NO_PROPERTIES
113
 
    static const QMetaProperty props_tbl[11] = {
114
 
        { "bool","toggleAction", 0x12000103, &QAction::metaObj, 0, -1 },
115
 
        { "bool","on", 0x12000103, &QAction::metaObj, 0, -1 },
116
 
        { "bool","enabled", 0x12000103, &QAction::metaObj, 0, -1 },
117
 
        { "QIconSet","iconSet", 0xd000103, &QAction::metaObj, 0, -1 },
118
 
        { "QString","text", 0x3000103, &QAction::metaObj, 0, -1 },
119
 
        { "QString","menuText", 0x3000103, &QAction::metaObj, 0, -1 },
120
 
        { "QString","toolTip", 0x3000103, &QAction::metaObj, 0, -1 },
121
 
        { "QString","statusTip", 0x3000103, &QAction::metaObj, 0, -1 },
122
 
        { "QString","whatsThis", 0x3000103, &QAction::metaObj, 0, -1 },
123
 
        { "QKeySequence","accel", 0x1f000103, &QAction::metaObj, 0, -1 },
124
 
        { "bool","visible", 0x12000103, &QAction::metaObj, 0, -1 }
125
 
    };
126
 
#endif // QT_NO_PROPERTIES
127
 
    metaObj = QMetaObject::new_metaobject(
128
 
        "QAction", parentObject,
129
 
        slot_tbl, 12,
130
 
        signal_tbl, 2,
131
 
#ifndef QT_NO_PROPERTIES
132
 
        props_tbl, 11,
133
 
        0, 0,
134
 
#endif // QT_NO_PROPERTIES
135
 
        0, 0 );
136
 
    cleanUp_QAction.setMetaObject( metaObj );
137
 
    return metaObj;
138
 
}
139
 
 
140
 
void* QAction::qt_cast( const char* clname )
141
 
{
142
 
    if ( !qstrcmp( clname, "QAction" ) )
143
 
        return this;
144
 
    return QObject::qt_cast( clname );
145
 
}
146
 
 
147
 
// SIGNAL activated
148
 
void QAction::activated()
149
 
{
150
 
    activate_signal( staticMetaObject()->signalOffset() + 0 );
151
 
}
152
 
 
153
 
// SIGNAL toggled
154
 
void QAction::toggled( bool t0 )
155
 
{
156
 
    activate_signal_bool( staticMetaObject()->signalOffset() + 1, t0 );
157
 
}
158
 
 
159
 
bool QAction::qt_invoke( int _id, QUObject* _o )
160
 
{
161
 
    switch ( _id - staticMetaObject()->slotOffset() ) {
162
 
    case 0: activate(); break;
163
 
    case 1: toggle(); break;
164
 
    case 2: setOn((bool)static_QUType_bool.get(_o+1)); break;
165
 
    case 3: setEnabled((bool)static_QUType_bool.get(_o+1)); break;
166
 
    case 4: setDisabled((bool)static_QUType_bool.get(_o+1)); break;
167
 
    case 5: setVisible((bool)static_QUType_bool.get(_o+1)); break;
168
 
    case 6: internalActivation(); break;
169
 
    case 7: toolButtonToggled((bool)static_QUType_bool.get(_o+1)); break;
170
 
    case 8: objectDestroyed(); break;
171
 
    case 9: menuStatusText((int)static_QUType_int.get(_o+1)); break;
172
 
    case 10: showStatusText((const QString&)static_QUType_QString.get(_o+1)); break;
173
 
    case 11: clearStatusText(); break;
174
 
    default:
175
 
        return QObject::qt_invoke( _id, _o );
176
 
    }
177
 
    return TRUE;
178
 
}
179
 
 
180
 
bool QAction::qt_emit( int _id, QUObject* _o )
181
 
{
182
 
    switch ( _id - staticMetaObject()->signalOffset() ) {
183
 
    case 0: activated(); break;
184
 
    case 1: toggled((bool)static_QUType_bool.get(_o+1)); break;
185
 
    default:
186
 
        return QObject::qt_emit(_id,_o);
187
 
    }
188
 
    return TRUE;
189
 
}
190
 
#ifndef QT_NO_PROPERTIES
191
 
 
192
 
bool QAction::qt_property( int id, int f, QVariant* v)
193
 
{
194
 
    switch ( id - staticMetaObject()->propertyOffset() ) {
195
 
    case 0: switch( f ) {
196
 
        case 0: setToggleAction(v->asBool()); break;
197
 
        case 1: *v = QVariant( this->isToggleAction(), 0 ); break;
198
 
        case 3: case 4: case 5: break;
199
 
        default: return FALSE;
200
 
    } break;
201
 
    case 1: switch( f ) {
202
 
        case 0: setOn(v->asBool()); break;
203
 
        case 1: *v = QVariant( this->isOn(), 0 ); break;
204
 
        case 3: case 4: case 5: break;
205
 
        default: return FALSE;
206
 
    } break;
207
 
    case 2: switch( f ) {
208
 
        case 0: setEnabled(v->asBool()); break;
209
 
        case 1: *v = QVariant( this->isEnabled(), 0 ); break;
210
 
        case 3: case 4: case 5: break;
211
 
        default: return FALSE;
212
 
    } break;
213
 
    case 3: switch( f ) {
214
 
        case 0: setIconSet(v->asIconSet()); break;
215
 
        case 1: *v = QVariant( this->iconSet() ); break;
216
 
        case 3: case 4: case 5: break;
217
 
        default: return FALSE;
218
 
    } break;
219
 
    case 4: switch( f ) {
220
 
        case 0: setText(v->asString()); break;
221
 
        case 1: *v = QVariant( this->text() ); break;
222
 
        case 3: case 4: case 5: break;
223
 
        default: return FALSE;
224
 
    } break;
225
 
    case 5: switch( f ) {
226
 
        case 0: setMenuText(v->asString()); break;
227
 
        case 1: *v = QVariant( this->menuText() ); break;
228
 
        case 3: case 4: case 5: break;
229
 
        default: return FALSE;
230
 
    } break;
231
 
    case 6: switch( f ) {
232
 
        case 0: setToolTip(v->asString()); break;
233
 
        case 1: *v = QVariant( this->toolTip() ); break;
234
 
        case 3: case 4: case 5: break;
235
 
        default: return FALSE;
236
 
    } break;
237
 
    case 7: switch( f ) {
238
 
        case 0: setStatusTip(v->asString()); break;
239
 
        case 1: *v = QVariant( this->statusTip() ); break;
240
 
        case 3: case 4: case 5: break;
241
 
        default: return FALSE;
242
 
    } break;
243
 
    case 8: switch( f ) {
244
 
        case 0: setWhatsThis(v->asString()); break;
245
 
        case 1: *v = QVariant( this->whatsThis() ); break;
246
 
        case 3: case 4: case 5: break;
247
 
        default: return FALSE;
248
 
    } break;
249
 
    case 9: switch( f ) {
250
 
        case 0: setAccel(v->asKeySequence()); break;
251
 
        case 1: *v = QVariant( this->accel() ); break;
252
 
        case 3: case 4: case 5: break;
253
 
        default: return FALSE;
254
 
    } break;
255
 
    case 10: switch( f ) {
256
 
        case 0: setVisible(v->asBool()); break;
257
 
        case 1: *v = QVariant( this->isVisible(), 0 ); break;
258
 
        case 3: case 4: case 5: break;
259
 
        default: return FALSE;
260
 
    } break;
261
 
    default:
262
 
        return QObject::qt_property( id, f, v );
263
 
    }
264
 
    return TRUE;
265
 
}
266
 
 
267
 
bool QAction::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
268
 
#endif // QT_NO_PROPERTIES
269
 
 
270
 
 
271
 
const char *QActionGroup::className() const
272
 
{
273
 
    return "QActionGroup";
274
 
}
275
 
 
276
 
QMetaObject *QActionGroup::metaObj = 0;
277
 
static QMetaObjectCleanUp cleanUp_QActionGroup( "QActionGroup", &QActionGroup::staticMetaObject );
278
 
 
279
 
#ifndef QT_NO_TRANSLATION
280
 
QString QActionGroup::tr( const char *s, const char *c )
281
 
{
282
 
    if ( qApp )
283
 
        return qApp->translate( "QActionGroup", s, c, QApplication::DefaultCodec );
284
 
    else
285
 
        return QString::fromLatin1( s );
286
 
}
287
 
#ifndef QT_NO_TRANSLATION_UTF8
288
 
QString QActionGroup::trUtf8( const char *s, const char *c )
289
 
{
290
 
    if ( qApp )
291
 
        return qApp->translate( "QActionGroup", s, c, QApplication::UnicodeUTF8 );
292
 
    else
293
 
        return QString::fromUtf8( s );
294
 
}
295
 
#endif // QT_NO_TRANSLATION_UTF8
296
 
 
297
 
#endif // QT_NO_TRANSLATION
298
 
 
299
 
QMetaObject* QActionGroup::staticMetaObject()
300
 
{
301
 
    if ( metaObj )
302
 
        return metaObj;
303
 
    QMetaObject* parentObject = QAction::staticMetaObject();
304
 
    static const QUParameter param_slot_0[] = {
305
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
306
 
    };
307
 
    static const QUMethod slot_0 = {"childToggled", 1, param_slot_0 };
308
 
    static const QUMethod slot_1 = {"childDestroyed", 0, 0 };
309
 
    static const QUParameter param_slot_2[] = {
310
 
        { 0, &static_QUType_int, 0, QUParameter::In }
311
 
    };
312
 
    static const QUMethod slot_2 = {"internalComboBoxActivated", 1, param_slot_2 };
313
 
    static const QUParameter param_slot_3[] = {
314
 
        { 0, &static_QUType_int, 0, QUParameter::In }
315
 
    };
316
 
    static const QUMethod slot_3 = {"internalComboBoxHighlighted", 1, param_slot_3 };
317
 
    static const QUParameter param_slot_4[] = {
318
 
        { 0, &static_QUType_ptr, "QAction", QUParameter::In }
319
 
    };
320
 
    static const QUMethod slot_4 = {"internalToggle", 1, param_slot_4 };
321
 
    static const QUMethod slot_5 = {"objectDestroyed", 0, 0 };
322
 
    static const QMetaData slot_tbl[] = {
323
 
        { "childToggled(bool)", &slot_0, QMetaData::Private },
324
 
        { "childDestroyed()", &slot_1, QMetaData::Private },
325
 
        { "internalComboBoxActivated(int)", &slot_2, QMetaData::Private },
326
 
        { "internalComboBoxHighlighted(int)", &slot_3, QMetaData::Private },
327
 
        { "internalToggle(QAction*)", &slot_4, QMetaData::Private },
328
 
        { "objectDestroyed()", &slot_5, QMetaData::Private }
329
 
    };
330
 
    static const QUParameter param_signal_0[] = {
331
 
        { 0, &static_QUType_ptr, "QAction", QUParameter::In }
332
 
    };
333
 
    static const QUMethod signal_0 = {"selected", 1, param_signal_0 };
334
 
    static const QMetaData signal_tbl[] = {
335
 
        { "selected(QAction*)", &signal_0, QMetaData::Protected }
336
 
    };
337
 
#ifndef QT_NO_PROPERTIES
338
 
    static const QMetaProperty props_tbl[2] = {
339
 
        { "bool","exclusive", 0x12000103, &QActionGroup::metaObj, 0, -1 },
340
 
        { "bool","usesDropDown", 0x12000103, &QActionGroup::metaObj, 0, -1 }
341
 
    };
342
 
#endif // QT_NO_PROPERTIES
343
 
    metaObj = QMetaObject::new_metaobject(
344
 
        "QActionGroup", parentObject,
345
 
        slot_tbl, 6,
346
 
        signal_tbl, 1,
347
 
#ifndef QT_NO_PROPERTIES
348
 
        props_tbl, 2,
349
 
        0, 0,
350
 
#endif // QT_NO_PROPERTIES
351
 
        0, 0 );
352
 
    cleanUp_QActionGroup.setMetaObject( metaObj );
353
 
    return metaObj;
354
 
}
355
 
 
356
 
void* QActionGroup::qt_cast( const char* clname )
357
 
{
358
 
    if ( !qstrcmp( clname, "QActionGroup" ) )
359
 
        return this;
360
 
    return QAction::qt_cast( clname );
361
 
}
362
 
 
363
 
#include <qobjectdefs.h>
364
 
#include <qsignalslotimp.h>
365
 
 
366
 
// SIGNAL selected
367
 
void QActionGroup::selected( QAction* t0 )
368
 
{
369
 
    if ( signalsBlocked() )
370
 
        return;
371
 
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
372
 
    if ( !clist )
373
 
        return;
374
 
    QUObject o[2];
375
 
    static_QUType_ptr.set(o+1,t0);
376
 
    activate_signal( clist, o );
377
 
}
378
 
 
379
 
bool QActionGroup::qt_invoke( int _id, QUObject* _o )
380
 
{
381
 
    switch ( _id - staticMetaObject()->slotOffset() ) {
382
 
    case 0: childToggled((bool)static_QUType_bool.get(_o+1)); break;
383
 
    case 1: childDestroyed(); break;
384
 
    case 2: internalComboBoxActivated((int)static_QUType_int.get(_o+1)); break;
385
 
    case 3: internalComboBoxHighlighted((int)static_QUType_int.get(_o+1)); break;
386
 
    case 4: internalToggle((QAction*)static_QUType_ptr.get(_o+1)); break;
387
 
    case 5: objectDestroyed(); break;
388
 
    default:
389
 
        return QAction::qt_invoke( _id, _o );
390
 
    }
391
 
    return TRUE;
392
 
}
393
 
 
394
 
bool QActionGroup::qt_emit( int _id, QUObject* _o )
395
 
{
396
 
    switch ( _id - staticMetaObject()->signalOffset() ) {
397
 
    case 0: selected((QAction*)static_QUType_ptr.get(_o+1)); break;
398
 
    default:
399
 
        return QAction::qt_emit(_id,_o);
400
 
    }
401
 
    return TRUE;
402
 
}
403
 
#ifndef QT_NO_PROPERTIES
404
 
 
405
 
bool QActionGroup::qt_property( int id, int f, QVariant* v)
406
 
{
407
 
    switch ( id - staticMetaObject()->propertyOffset() ) {
408
 
    case 0: switch( f ) {
409
 
        case 0: setExclusive(v->asBool()); break;
410
 
        case 1: *v = QVariant( this->isExclusive(), 0 ); break;
411
 
        case 3: case 4: case 5: break;
412
 
        default: return FALSE;
413
 
    } break;
414
 
    case 1: switch( f ) {
415
 
        case 0: setUsesDropDown(v->asBool()); break;
416
 
        case 1: *v = QVariant( this->usesDropDown(), 0 ); break;
417
 
        case 3: case 4: case 5: break;
418
 
        default: return FALSE;
419
 
    } break;
420
 
    default:
421
 
        return QAction::qt_property( id, f, v );
422
 
    }
423
 
    return TRUE;
424
 
}
425
 
 
426
 
bool QActionGroup::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
427
 
#endif // QT_NO_PROPERTIES