← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/.moc/debug-shared-mt/moc_qwidget.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/debug-shared-mt/moc_qwidget.cpp
1
 
/****************************************************************************
2
 
** QWidget meta object code from reading C++ file 'qwidget.h'
3
 
**
4
 
** Created: Mon Jan 21 16:30:33 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 "../../kernel/qwidget.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 *QWidget::className() const
24
 
{
25
 
    return "QWidget";
26
 
}
27
 
 
28
 
QMetaObject *QWidget::metaObj = 0;
29
 
static QMetaObjectCleanUp cleanUp_QWidget( "QWidget", &QWidget::staticMetaObject );
30
 
 
31
 
#ifndef QT_NO_TRANSLATION
32
 
QString QWidget::tr( const char *s, const char *c )
33
 
{
34
 
    if ( qApp )
35
 
        return qApp->translate( "QWidget", s, c, QApplication::DefaultCodec );
36
 
    else
37
 
        return QString::fromLatin1( s );
38
 
}
39
 
#ifndef QT_NO_TRANSLATION_UTF8
40
 
QString QWidget::trUtf8( const char *s, const char *c )
41
 
{
42
 
    if ( qApp )
43
 
        return qApp->translate( "QWidget", 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* QWidget::staticMetaObject()
52
 
{
53
 
    if ( metaObj )
54
 
        return metaObj;
55
 
    QMetaObject* parentObject = QObject::staticMetaObject();
56
 
#ifndef QT_NO_PROPERTIES
57
 
    static const QMetaEnum::Item enum_0[] = {
58
 
        { "NoFocus",  (int) QWidget::NoFocus },
59
 
        { "TabFocus",  (int) QWidget::TabFocus },
60
 
        { "ClickFocus",  (int) QWidget::ClickFocus },
61
 
        { "StrongFocus",  (int) QWidget::StrongFocus },
62
 
        { "WheelFocus",  (int) QWidget::WheelFocus }
63
 
    };
64
 
    static const QMetaEnum::Item enum_1[] = {
65
 
        { "WidgetOrigin",  (int) QWidget::WidgetOrigin },
66
 
        { "ParentOrigin",  (int) QWidget::ParentOrigin },
67
 
        { "WindowOrigin",  (int) QWidget::WindowOrigin },
68
 
        { "AncestorOrigin",  (int) QWidget::AncestorOrigin }
69
 
    };
70
 
    static const QMetaEnum enum_tbl[] = {
71
 
        { "FocusPolicy", 5, enum_0, FALSE },
72
 
        { "BackgroundOrigin", 4, enum_1, FALSE }
73
 
    };
74
 
#endif // QT_NO_PROPERTIES
75
 
    static const QUParameter param_slot_0[] = {
76
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
77
 
    };
78
 
    static const QUMethod slot_0 = {"setEnabled", 1, param_slot_0 };
79
 
    static const QUParameter param_slot_1[] = {
80
 
        { 0, &static_QUType_bool, 0, QUParameter::In }
81
 
    };
82
 
    static const QUMethod slot_1 = {"setDisabled", 1, param_slot_1 };
83
 
    static const QUParameter param_slot_2[] = {
84
 
        { 0, &static_QUType_QString, 0, QUParameter::In }
85
 
    };
86
 
    static const QUMethod slot_2 = {"setCaption", 1, param_slot_2 };
87
 
    static const QUParameter param_slot_3[] = {
88
 
        { 0, &static_QUType_varptr, "\x06", QUParameter::In }
89
 
    };
90
 
    static const QUMethod slot_3 = {"setIcon", 1, param_slot_3 };
91
 
    static const QUParameter param_slot_4[] = {
92
 
        { 0, &static_QUType_QString, 0, QUParameter::In }
93
 
    };
94
 
    static const QUMethod slot_4 = {"setIconText", 1, param_slot_4 };
95
 
    static const QUParameter param_slot_5[] = {
96
 
        { "enable", &static_QUType_bool, 0, QUParameter::In }
97
 
    };
98
 
    static const QUMethod slot_5 = {"setMouseTracking", 1, param_slot_5 };
99
 
    static const QUMethod slot_6 = {"setFocus", 0, 0 };
100
 
    static const QUMethod slot_7 = {"clearFocus", 0, 0 };
101
 
    static const QUParameter param_slot_8[] = {
102
 
        { "enable", &static_QUType_bool, 0, QUParameter::In }
103
 
    };
104
 
    static const QUMethod slot_8 = {"setUpdatesEnabled", 1, param_slot_8 };
105
 
    static const QUMethod slot_9 = {"update", 0, 0 };
106
 
    static const QUParameter param_slot_10[] = {
107
 
        { "x", &static_QUType_int, 0, QUParameter::In },
108
 
        { "y", &static_QUType_int, 0, QUParameter::In },
109
 
        { "w", &static_QUType_int, 0, QUParameter::In },
110
 
        { "h", &static_QUType_int, 0, QUParameter::In }
111
 
    };
112
 
    static const QUMethod slot_10 = {"update", 4, param_slot_10 };
113
 
    static const QUParameter param_slot_11[] = {
114
 
        { 0, &static_QUType_varptr, "\x08", QUParameter::In }
115
 
    };
116
 
    static const QUMethod slot_11 = {"update", 1, param_slot_11 };
117
 
    static const QUMethod slot_12 = {"repaint", 0, 0 };
118
 
    static const QUParameter param_slot_13[] = {
119
 
        { "erase", &static_QUType_bool, 0, QUParameter::In }
120
 
    };
121
 
    static const QUMethod slot_13 = {"repaint", 1, param_slot_13 };
122
 
    static const QUParameter param_slot_14[] = {
123
 
        { "x", &static_QUType_int, 0, QUParameter::In },
124
 
        { "y", &static_QUType_int, 0, QUParameter::In },
125
 
        { "w", &static_QUType_int, 0, QUParameter::In },
126
 
        { "h", &static_QUType_int, 0, QUParameter::In }
127
 
    };
128
 
    static const QUMethod slot_14 = {"repaint", 4, param_slot_14 };
129
 
    static const QUParameter param_slot_15[] = {
130
 
        { "x", &static_QUType_int, 0, QUParameter::In },
131
 
        { "y", &static_QUType_int, 0, QUParameter::In },
132
 
        { "w", &static_QUType_int, 0, QUParameter::In },
133
 
        { "h", &static_QUType_int, 0, QUParameter::In },
134
 
        { "erase", &static_QUType_bool, 0, QUParameter::In }
135
 
    };
136
 
    static const QUMethod slot_15 = {"repaint", 5, param_slot_15 };
137
 
    static const QUParameter param_slot_16[] = {
138
 
        { 0, &static_QUType_varptr, "\x08", QUParameter::In }
139
 
    };
140
 
    static const QUMethod slot_16 = {"repaint", 1, param_slot_16 };
141
 
    static const QUParameter param_slot_17[] = {
142
 
        { 0, &static_QUType_varptr, "\x08", QUParameter::In },
143
 
        { "erase", &static_QUType_bool, 0, QUParameter::In }
144
 
    };
145
 
    static const QUMethod slot_17 = {"repaint", 2, param_slot_17 };
146
 
    static const QUParameter param_slot_18[] = {
147
 
        { 0, &static_QUType_varptr, "\x16", QUParameter::In }
148
 
    };
149
 
    static const QUMethod slot_18 = {"repaint", 1, param_slot_18 };
150
 
    static const QUParameter param_slot_19[] = {
151
 
        { 0, &static_QUType_varptr, "\x16", QUParameter::In },
152
 
        { "erase", &static_QUType_bool, 0, QUParameter::In }
153
 
    };
154
 
    static const QUMethod slot_19 = {"repaint", 2, param_slot_19 };
155
 
    static const QUMethod slot_20 = {"show", 0, 0 };
156
 
    static const QUMethod slot_21 = {"hide", 0, 0 };
157
 
    static const QUParameter param_slot_22[] = {
158
 
        { "show", &static_QUType_bool, 0, QUParameter::In }
159
 
    };
160
 
    static const QUMethod slot_22 = {"setShown", 1, param_slot_22 };
161
 
    static const QUParameter param_slot_23[] = {
162
 
        { "hide", &static_QUType_bool, 0, QUParameter::In }
163
 
    };
164
 
    static const QUMethod slot_23 = {"setHidden", 1, param_slot_23 };
165
 
    static const QUMethod slot_24 = {"iconify", 0, 0 };
166
 
    static const QUMethod slot_25 = {"showMinimized", 0, 0 };
167
 
    static const QUMethod slot_26 = {"showMaximized", 0, 0 };
168
 
    static const QUMethod slot_27 = {"showFullScreen", 0, 0 };
169
 
    static const QUMethod slot_28 = {"showNormal", 0, 0 };
170
 
    static const QUMethod slot_29 = {"polish", 0, 0 };
171
 
    static const QUMethod slot_30 = {"constPolish", 0, 0 };
172
 
    static const QUParameter param_slot_31[] = {
173
 
        { 0, &static_QUType_bool, 0, QUParameter::Out }
174
 
    };
175
 
    static const QUMethod slot_31 = {"close", 1, param_slot_31 };
176
 
    static const QUMethod slot_32 = {"raise", 0, 0 };
177
 
    static const QUMethod slot_33 = {"lower", 0, 0 };
178
 
    static const QUParameter param_slot_34[] = {
179
 
        { 0, &static_QUType_ptr, "QWidget", QUParameter::In }
180
 
    };
181
 
    static const QUMethod slot_34 = {"stackUnder", 1, param_slot_34 };
182
 
    static const QUParameter param_slot_35[] = {
183
 
        { "x", &static_QUType_int, 0, QUParameter::In },
184
 
        { "y", &static_QUType_int, 0, QUParameter::In }
185
 
    };
186
 
    static const QUMethod slot_35 = {"move", 2, param_slot_35 };
187
 
    static const QUParameter param_slot_36[] = {
188
 
        { 0, &static_QUType_varptr, "\x0e", QUParameter::In }
189
 
    };
190
 
    static const QUMethod slot_36 = {"move", 1, param_slot_36 };
191
 
    static const QUParameter param_slot_37[] = {
192
 
        { "w", &static_QUType_int, 0, QUParameter::In },
193
 
        { "h", &static_QUType_int, 0, QUParameter::In }
194
 
    };
195
 
    static const QUMethod slot_37 = {"resize", 2, param_slot_37 };
196
 
    static const QUParameter param_slot_38[] = {
197
 
        { 0, &static_QUType_varptr, "\x09", QUParameter::In }
198
 
    };
199
 
    static const QUMethod slot_38 = {"resize", 1, param_slot_38 };
200
 
    static const QUParameter param_slot_39[] = {
201
 
        { "x", &static_QUType_int, 0, QUParameter::In },
202
 
        { "y", &static_QUType_int, 0, QUParameter::In },
203
 
        { "w", &static_QUType_int, 0, QUParameter::In },
204
 
        { "h", &static_QUType_int, 0, QUParameter::In }
205
 
    };
206
 
    static const QUMethod slot_39 = {"setGeometry", 4, param_slot_39 };
207
 
    static const QUParameter param_slot_40[] = {
208
 
        { 0, &static_QUType_varptr, "\x08", QUParameter::In }
209
 
    };
210
 
    static const QUMethod slot_40 = {"setGeometry", 1, param_slot_40 };
211
 
    static const QUMethod slot_41 = {"adjustSize", 0, 0 };
212
 
    static const QUMethod slot_42 = {"focusProxyDestroyed", 0, 0 };
213
 
    static const QUMethod slot_43 = {"destroyInputContext", 0, 0 };
214
 
    static const QMetaData slot_tbl[] = {
215
 
        { "setEnabled(bool)", &slot_0, QMetaData::Public },
216
 
        { "setDisabled(bool)", &slot_1, QMetaData::Public },
217
 
        { "setCaption(const QString&)", &slot_2, QMetaData::Public },
218
 
        { "setIcon(const QPixmap&)", &slot_3, QMetaData::Public },
219
 
        { "setIconText(const QString&)", &slot_4, QMetaData::Public },
220
 
        { "setMouseTracking(bool)", &slot_5, QMetaData::Public },
221
 
        { "setFocus()", &slot_6, QMetaData::Public },
222
 
        { "clearFocus()", &slot_7, QMetaData::Public },
223
 
        { "setUpdatesEnabled(bool)", &slot_8, QMetaData::Public },
224
 
        { "update()", &slot_9, QMetaData::Public },
225
 
        { "update(int,int,int,int)", &slot_10, QMetaData::Public },
226
 
        { "update(const QRect&)", &slot_11, QMetaData::Public },
227
 
        { "repaint()", &slot_12, QMetaData::Public },
228
 
        { "repaint(bool)", &slot_13, QMetaData::Public },
229
 
        { "repaint(int,int,int,int)", &slot_14, QMetaData::Public },
230
 
        { "repaint(int,int,int,int,bool)", &slot_15, QMetaData::Public },
231
 
        { "repaint(const QRect&)", &slot_16, QMetaData::Public },
232
 
        { "repaint(const QRect&,bool)", &slot_17, QMetaData::Public },
233
 
        { "repaint(const QRegion&)", &slot_18, QMetaData::Public },
234
 
        { "repaint(const QRegion&,bool)", &slot_19, QMetaData::Public },
235
 
        { "show()", &slot_20, QMetaData::Public },
236
 
        { "hide()", &slot_21, QMetaData::Public },
237
 
        { "setShown(bool)", &slot_22, QMetaData::Public },
238
 
        { "setHidden(bool)", &slot_23, QMetaData::Public },
239
 
        { "iconify()", &slot_24, QMetaData::Public },
240
 
        { "showMinimized()", &slot_25, QMetaData::Public },
241
 
        { "showMaximized()", &slot_26, QMetaData::Public },
242
 
        { "showFullScreen()", &slot_27, QMetaData::Public },
243
 
        { "showNormal()", &slot_28, QMetaData::Public },
244
 
        { "polish()", &slot_29, QMetaData::Public },
245
 
        { "constPolish()", &slot_30, QMetaData::Public },
246
 
        { "close()", &slot_31, QMetaData::Public },
247
 
        { "raise()", &slot_32, QMetaData::Public },
248
 
        { "lower()", &slot_33, QMetaData::Public },
249
 
        { "stackUnder(QWidget*)", &slot_34, QMetaData::Public },
250
 
        { "move(int,int)", &slot_35, QMetaData::Public },
251
 
        { "move(const QPoint&)", &slot_36, QMetaData::Public },
252
 
        { "resize(int,int)", &slot_37, QMetaData::Public },
253
 
        { "resize(const QSize&)", &slot_38, QMetaData::Public },
254
 
        { "setGeometry(int,int,int,int)", &slot_39, QMetaData::Public },
255
 
        { "setGeometry(const QRect&)", &slot_40, QMetaData::Public },
256
 
        { "adjustSize()", &slot_41, QMetaData::Public },
257
 
        { "focusProxyDestroyed()", &slot_42, QMetaData::Private },
258
 
        { "destroyInputContext()", &slot_43, QMetaData::Private }
259
 
    };
260
 
#ifndef QT_NO_PROPERTIES
261
 
    static const QMetaProperty props_tbl[65] = {
262
 
        { "bool","isTopLevel", 0x12000001, &QWidget::metaObj, 0, -1 },
263
 
        { "bool","isDialog", 0x12000001, &QWidget::metaObj, 0, -1 },
264
 
        { "bool","isModal", 0x12000001, &QWidget::metaObj, 0, -1 },
265
 
        { "bool","isPopup", 0x12000001, &QWidget::metaObj, 0, -1 },
266
 
        { "bool","isDesktop", 0x12000001, &QWidget::metaObj, 0, -1 },
267
 
        { "bool","enabled", 0x12000103, &QWidget::metaObj, 0, -1 },
268
 
        { "QRect","geometry", 0x8000103, &QWidget::metaObj, 0, -1 },
269
 
        { "QRect","frameGeometry", 0x8000001, &QWidget::metaObj, 0, -1 },
270
 
        { "int","x", 0x10000001, &QWidget::metaObj, 0, -1 },
271
 
        { "int","y", 0x10000001, &QWidget::metaObj, 0, -1 },
272
 
        { "QPoint","pos", 0xe011003, &QWidget::metaObj, 0, -1 },
273
 
        { "QSize","frameSize", 0x9000001, &QWidget::metaObj, 0, -1 },
274
 
        { "QSize","size", 0x9011003, &QWidget::metaObj, 0, -1 },
275
 
        { "int","width", 0x10000001, &QWidget::metaObj, 0, -1 },
276
 
        { "int","height", 0x10000001, &QWidget::metaObj, 0, -1 },
277
 
        { "QRect","rect", 0x8000001, &QWidget::metaObj, 0, -1 },
278
 
        { "QRect","childrenRect", 0x8000001, &QWidget::metaObj, 0, -1 },
279
 
        { "QRegion","childrenRegion", 0x16000001, &QWidget::metaObj, 0, -1 },
280
 
        { "QSizePolicy","sizePolicy", 0x19000103, &QWidget::metaObj, 0, -1 },
281
 
        { "QSize","minimumSize", 0x9000103, &QWidget::metaObj, 0, -1 },
282
 
        { "QSize","maximumSize", 0x9000103, &QWidget::metaObj, 0, -1 },
283
 
        { "int","minimumWidth", 0x10011103, &QWidget::metaObj, 0, -1 },
284
 
        { "int","minimumHeight", 0x10011103, &QWidget::metaObj, 0, -1 },
285
 
        { "int","maximumWidth", 0x10011103, &QWidget::metaObj, 0, -1 },
286
 
        { "int","maximumHeight", 0x10011103, &QWidget::metaObj, 0, -1 },
287
 
        { "QSize","sizeIncrement", 0x9000103, &QWidget::metaObj, 0, -1 },
288
 
        { "QSize","baseSize", 0x9000103, &QWidget::metaObj, 0, -1 },
289
 
        { "BackgroundMode","backgroundMode", 0x1107, &QWidget::metaObj, 0, -1 },
290
 
        { "QColor","paletteForegroundColor", 0xa000103, &QWidget::metaObj, 0, -1 },
291
 
        { "QColor","paletteBackgroundColor", 0xa000103, &QWidget::metaObj, 0, -1 },
292
 
        { "QPixmap","paletteBackgroundPixmap", 0x6000103, &QWidget::metaObj, 0, -1 },
293
 
        { "QBrush","backgroundBrush", 0x7000001, &QWidget::metaObj, 0, -1 },
294
 
        { "QColorGroup","colorGroup", 0xc000001, &QWidget::metaObj, 0, -1 },
295
 
        { "QPalette","palette", 0xb000103, &QWidget::metaObj, 0, -1 },
296
 
        { "BackgroundOrigin","backgroundOrigin", 0x0107, &QWidget::metaObj, &enum_tbl[1], -1 },
297
 
        { "bool","ownPalette", 0x12000001, &QWidget::metaObj, 0, -1 },
298
 
        { "QFont","font", 0x5000103, &QWidget::metaObj, 0, -1 },
299
 
        { "bool","ownFont", 0x12000001, &QWidget::metaObj, 0, -1 },
300
 
        { "QCursor","cursor", 0x18000103, &QWidget::metaObj, 0, -1 },
301
 
        { "bool","ownCursor", 0x12000001, &QWidget::metaObj, 0, -1 },
302
 
        { "QString","caption", 0x3000103, &QWidget::metaObj, 0, -1 },
303
 
        { "QPixmap","icon", 0x6000103, &QWidget::metaObj, 0, -1 },
304
 
        { "QString","iconText", 0x3000103, &QWidget::metaObj, 0, -1 },
305
 
        { "bool","mouseTracking", 0x12000103, &QWidget::metaObj, 0, -1 },
306
 
        { "bool","underMouse", 0x12000001, &QWidget::metaObj, 0, -1 },
307
 
        { "bool","isActiveWindow", 0x12000001, &QWidget::metaObj, 0, -1 },
308
 
        { "bool","focusEnabled", 0x12000001, &QWidget::metaObj, 0, -1 },
309
 
        { "FocusPolicy","focusPolicy", 0x0107, &QWidget::metaObj, &enum_tbl[0], -1 },
310
 
        { "bool","focus", 0x12000001, &QWidget::metaObj, 0, -1 },
311
 
        { "bool","updatesEnabled", 0x12001103, &QWidget::metaObj, 0, -1 },
312
 
        { "bool","visible", 0x12000001, &QWidget::metaObj, 0, -1 },
313
 
        { "QRect","visibleRect", 0x8000001, &QWidget::metaObj, 0, -1 },
314
 
        { "bool","hidden", 0x12005103, &QWidget::metaObj, 0, -1 },
315
 
        { "bool","shown", 0x12005103, &QWidget::metaObj, 0, -1 },
316
 
        { "bool","minimized", 0x12000001, &QWidget::metaObj, 0, -1 },
317
 
        { "bool","maximized", 0x12000001, &QWidget::metaObj, 0, -1 },
318
 
        { "bool","fullScreen", 0x12000001, &QWidget::metaObj, 0, -1 },
319
 
        { "QSize","sizeHint", 0x9000001, &QWidget::metaObj, 0, -1 },
320
 
        { "QSize","minimumSizeHint", 0x9000001, &QWidget::metaObj, 0, -1 },
321
 
        { "QRect","microFocusHint", 0x8000001, &QWidget::metaObj, 0, -1 },
322
 
        { "bool","acceptDrops", 0x12000103, &QWidget::metaObj, 0, -1 },
323
 
        { "bool","autoMask", 0x12005103, &QWidget::metaObj, 0, -1 },
324
 
        { "bool","customWhatsThis", 0x12000001, &QWidget::metaObj, 0, -1 },
325
 
        { "bool","inputMethodEnabled", 0x12005103, &QWidget::metaObj, 0, -1 },
326
 
        { "double","windowOpacity", 0x13001103, &QWidget::metaObj, 0, -1 }
327
 
    };
328
 
#endif // QT_NO_PROPERTIES
329
 
    metaObj = QMetaObject::new_metaobject(
330
 
        "QWidget", parentObject,
331
 
        slot_tbl, 44,
332
 
        0, 0,
333
 
#ifndef QT_NO_PROPERTIES
334
 
        props_tbl, 65,
335
 
        enum_tbl, 2,
336
 
#endif // QT_NO_PROPERTIES
337
 
        0, 0 );
338
 
    cleanUp_QWidget.setMetaObject( metaObj );
339
 
    return metaObj;
340
 
}
341
 
 
342
 
void* QWidget::qt_cast( const char* clname )
343
 
{
344
 
    if ( !qstrcmp( clname, "QWidget" ) )
345
 
        return this;
346
 
    if ( !qstrcmp( clname, "QPaintDevice" ) )
347
 
        return (QPaintDevice*)this;
348
 
    return QObject::qt_cast( clname );
349
 
}
350
 
 
351
 
bool QWidget::qt_invoke( int _id, QUObject* _o )
352
 
{
353
 
    switch ( _id - staticMetaObject()->slotOffset() ) {
354
 
    case 0: setEnabled((bool)static_QUType_bool.get(_o+1)); break;
355
 
    case 1: setDisabled((bool)static_QUType_bool.get(_o+1)); break;
356
 
    case 2: setCaption((const QString&)static_QUType_QString.get(_o+1)); break;
357
 
    case 3: setIcon((const QPixmap&)*((const QPixmap*)static_QUType_ptr.get(_o+1))); break;
358
 
    case 4: setIconText((const QString&)static_QUType_QString.get(_o+1)); break;
359
 
    case 5: setMouseTracking((bool)static_QUType_bool.get(_o+1)); break;
360
 
    case 6: setFocus(); break;
361
 
    case 7: clearFocus(); break;
362
 
    case 8: setUpdatesEnabled((bool)static_QUType_bool.get(_o+1)); break;
363
 
    case 9: update(); break;
364
 
    case 10: update((int)static_QUType_int.get(_o+1),(int)static_QUType_int.get(_o+2),(int)static_QUType_int.get(_o+3),(int)static_QUType_int.get(_o+4)); break;
365
 
    case 11: update((const QRect&)*((const QRect*)static_QUType_ptr.get(_o+1))); break;
366
 
    case 12: repaint(); break;
367
 
    case 13: repaint((bool)static_QUType_bool.get(_o+1)); break;
368
 
    case 14: repaint((int)static_QUType_int.get(_o+1),(int)static_QUType_int.get(_o+2),(int)static_QUType_int.get(_o+3),(int)static_QUType_int.get(_o+4)); break;
369
 
    case 15: repaint((int)static_QUType_int.get(_o+1),(int)static_QUType_int.get(_o+2),(int)static_QUType_int.get(_o+3),(int)static_QUType_int.get(_o+4),(bool)static_QUType_bool.get(_o+5)); break;
370
 
    case 16: repaint((const QRect&)*((const QRect*)static_QUType_ptr.get(_o+1))); break;
371
 
    case 17: repaint((const QRect&)*((const QRect*)static_QUType_ptr.get(_o+1)),(bool)static_QUType_bool.get(_o+2)); break;
372
 
    case 18: repaint((const QRegion&)*((const QRegion*)static_QUType_ptr.get(_o+1))); break;
373
 
    case 19: repaint((const QRegion&)*((const QRegion*)static_QUType_ptr.get(_o+1)),(bool)static_QUType_bool.get(_o+2)); break;
374
 
    case 20: show(); break;
375
 
    case 21: hide(); break;
376
 
    case 22: setShown((bool)static_QUType_bool.get(_o+1)); break;
377
 
    case 23: setHidden((bool)static_QUType_bool.get(_o+1)); break;
378
 
    case 24: iconify(); break;
379
 
    case 25: showMinimized(); break;
380
 
    case 26: showMaximized(); break;
381
 
    case 27: showFullScreen(); break;
382
 
    case 28: showNormal(); break;
383
 
    case 29: polish(); break;
384
 
    case 30: constPolish(); break;
385
 
    case 31: static_QUType_bool.set(_o,close()); break;
386
 
    case 32: raise(); break;
387
 
    case 33: lower(); break;
388
 
    case 34: stackUnder((QWidget*)static_QUType_ptr.get(_o+1)); break;
389
 
    case 35: move((int)static_QUType_int.get(_o+1),(int)static_QUType_int.get(_o+2)); break;
390
 
    case 36: move((const QPoint&)*((const QPoint*)static_QUType_ptr.get(_o+1))); break;
391
 
    case 37: resize((int)static_QUType_int.get(_o+1),(int)static_QUType_int.get(_o+2)); break;
392
 
    case 38: resize((const QSize&)*((const QSize*)static_QUType_ptr.get(_o+1))); break;
393
 
    case 39: setGeometry((int)static_QUType_int.get(_o+1),(int)static_QUType_int.get(_o+2),(int)static_QUType_int.get(_o+3),(int)static_QUType_int.get(_o+4)); break;
394
 
    case 40: setGeometry((const QRect&)*((const QRect*)static_QUType_ptr.get(_o+1))); break;
395
 
    case 41: adjustSize(); break;
396
 
    case 42: focusProxyDestroyed(); break;
397
 
    case 43: destroyInputContext(); break;
398
 
    default:
399
 
        return QObject::qt_invoke( _id, _o );
400
 
    }
401
 
    return TRUE;
402
 
}
403
 
 
404
 
bool QWidget::qt_emit( int _id, QUObject* _o )
405
 
{
406
 
    return QObject::qt_emit(_id,_o);
407
 
}
408
 
#ifndef QT_NO_PROPERTIES
409
 
 
410
 
bool QWidget::qt_property( int id, int f, QVariant* v)
411
 
{
412
 
    switch ( id - staticMetaObject()->propertyOffset() ) {
413
 
    case 0: switch( f ) {
414
 
        case 1: *v = QVariant( this->isTopLevel(), 0 ); break;
415
 
        case 3: case 4: case 5: break;
416
 
        default: return FALSE;
417
 
    } break;
418
 
    case 1: switch( f ) {
419
 
        case 1: *v = QVariant( this->isDialog(), 0 ); break;
420
 
        case 3: case 4: case 5: break;
421
 
        default: return FALSE;
422
 
    } break;
423
 
    case 2: switch( f ) {
424
 
        case 1: *v = QVariant( this->isModal(), 0 ); break;
425
 
        case 3: case 4: case 5: break;
426
 
        default: return FALSE;
427
 
    } break;
428
 
    case 3: switch( f ) {
429
 
        case 1: *v = QVariant( this->isPopup(), 0 ); break;
430
 
        case 3: case 4: case 5: break;
431
 
        default: return FALSE;
432
 
    } break;
433
 
    case 4: switch( f ) {
434
 
        case 1: *v = QVariant( this->isDesktop(), 0 ); break;
435
 
        case 3: case 4: case 5: break;
436
 
        default: return FALSE;
437
 
    } break;
438
 
    case 5: switch( f ) {
439
 
        case 0: setEnabled(v->asBool()); break;
440
 
        case 1: *v = QVariant( this->isEnabled(), 0 ); break;
441
 
        case 3: case 4: case 5: break;
442
 
        default: return FALSE;
443
 
    } break;
444
 
    case 6: switch( f ) {
445
 
        case 0: setGeometry(v->asRect()); break;
446
 
        case 1: *v = QVariant( this->geometry() ); break;
447
 
        case 3: case 4: case 5: break;
448
 
        default: return FALSE;
449
 
    } break;
450
 
    case 7: switch( f ) {
451
 
        case 1: *v = QVariant( this->frameGeometry() ); break;
452
 
        case 3: case 4: case 5: break;
453
 
        default: return FALSE;
454
 
    } break;
455
 
    case 8: switch( f ) {
456
 
        case 1: *v = QVariant( this->x() ); break;
457
 
        case 3: case 4: case 5: break;
458
 
        default: return FALSE;
459
 
    } break;
460
 
    case 9: switch( f ) {
461
 
        case 1: *v = QVariant( this->y() ); break;
462
 
        case 3: case 4: case 5: break;
463
 
        default: return FALSE;
464
 
    } break;
465
 
    case 10: switch( f ) {
466
 
        case 0: move(v->asPoint()); break;
467
 
        case 1: *v = QVariant( this->pos() ); break;
468
 
        case 4: break;
469
 
        default: return FALSE;
470
 
    } break;
471
 
    case 11: switch( f ) {
472
 
        case 1: *v = QVariant( this->frameSize() ); break;
473
 
        case 3: case 4: case 5: break;
474
 
        default: return FALSE;
475
 
    } break;
476
 
    case 12: switch( f ) {
477
 
        case 0: resize(v->asSize()); break;
478
 
        case 1: *v = QVariant( this->size() ); break;
479
 
        case 4: break;
480
 
        default: return FALSE;
481
 
    } break;
482
 
    case 13: switch( f ) {
483
 
        case 1: *v = QVariant( this->width() ); break;
484
 
        case 3: case 4: case 5: break;
485
 
        default: return FALSE;
486
 
    } break;
487
 
    case 14: switch( f ) {
488
 
        case 1: *v = QVariant( this->height() ); break;
489
 
        case 3: case 4: case 5: break;
490
 
        default: return FALSE;
491
 
    } break;
492
 
    case 15: switch( f ) {
493
 
        case 1: *v = QVariant( this->rect() ); break;
494
 
        case 3: case 4: case 5: break;
495
 
        default: return FALSE;
496
 
    } break;
497
 
    case 16: switch( f ) {
498
 
        case 1: *v = QVariant( this->childrenRect() ); break;
499
 
        case 3: case 4: case 5: break;
500
 
        default: return FALSE;
501
 
    } break;
502
 
    case 17: switch( f ) {
503
 
        case 1: *v = QVariant( this->childrenRegion() ); break;
504
 
        case 3: case 4: case 5: break;
505
 
        default: return FALSE;
506
 
    } break;
507
 
    case 18: switch( f ) {
508
 
        case 0: setSizePolicy(v->asSizePolicy()); break;
509
 
        case 1: *v = QVariant( this->sizePolicy() ); break;
510
 
        case 3: case 4: case 5: break;
511
 
        default: return FALSE;
512
 
    } break;
513
 
    case 19: switch( f ) {
514
 
        case 0: setMinimumSize(v->asSize()); break;
515
 
        case 1: *v = QVariant( this->minimumSize() ); break;
516
 
        case 3: case 4: case 5: break;
517
 
        default: return FALSE;
518
 
    } break;
519
 
    case 20: switch( f ) {
520
 
        case 0: setMaximumSize(v->asSize()); break;
521
 
        case 1: *v = QVariant( this->maximumSize() ); break;
522
 
        case 3: case 4: case 5: break;
523
 
        default: return FALSE;
524
 
    } break;
525
 
    case 21: switch( f ) {
526
 
        case 0: setMinimumWidth(v->asInt()); break;
527
 
        case 1: *v = QVariant( this->minimumWidth() ); break;
528
 
        case 4: break;
529
 
        default: return FALSE;
530
 
    } break;
531
 
    case 22: switch( f ) {
532
 
        case 0: setMinimumHeight(v->asInt()); break;
533
 
        case 1: *v = QVariant( this->minimumHeight() ); break;
534
 
        case 4: break;
535
 
        default: return FALSE;
536
 
    } break;
537
 
    case 23: switch( f ) {
538
 
        case 0: setMaximumWidth(v->asInt()); break;
539
 
        case 1: *v = QVariant( this->maximumWidth() ); break;
540
 
        case 4: break;
541
 
        default: return FALSE;
542
 
    } break;
543
 
    case 24: switch( f ) {
544
 
        case 0: setMaximumHeight(v->asInt()); break;
545
 
        case 1: *v = QVariant( this->maximumHeight() ); break;
546
 
        case 4: break;
547
 
        default: return FALSE;
548
 
    } break;
549
 
    case 25: switch( f ) {
550
 
        case 0: setSizeIncrement(v->asSize()); break;
551
 
        case 1: *v = QVariant( this->sizeIncrement() ); break;
552
 
        case 3: case 4: case 5: break;
553
 
        default: return FALSE;
554
 
    } break;
555
 
    case 26: switch( f ) {
556
 
        case 0: setBaseSize(v->asSize()); break;
557
 
        case 1: *v = QVariant( this->baseSize() ); break;
558
 
        case 3: case 4: case 5: break;
559
 
        default: return FALSE;
560
 
    } break;
561
 
    case 27: switch( f ) {
562
 
        case 0: setBackgroundMode((BackgroundMode&)v->asInt()); break;
563
 
        case 1: *v = QVariant( (int)this->backgroundMode() ); break;
564
 
        case 4: case 5: break;
565
 
        default: return FALSE;
566
 
    } break;
567
 
    case 28: switch( f ) {
568
 
        case 0: setPaletteForegroundColor(v->asColor()); break;
569
 
        case 1: *v = QVariant( this->paletteForegroundColor() ); break;
570
 
        case 2: this->unsetPalette(); break;
571
 
        case 3: case 4: case 5: break;
572
 
        default: return FALSE;
573
 
    } break;
574
 
    case 29: switch( f ) {
575
 
        case 0: setPaletteBackgroundColor(v->asColor()); break;
576
 
        case 1: *v = QVariant( this->paletteBackgroundColor() ); break;
577
 
        case 2: this->unsetPalette(); break;
578
 
        case 3: case 4: case 5: break;
579
 
        default: return FALSE;
580
 
    } break;
581
 
    case 30: switch( f ) {
582
 
        case 0: setPaletteBackgroundPixmap(v->asPixmap()); break;
583
 
        case 1: if ( this->paletteBackgroundPixmap() ) *v = QVariant( *paletteBackgroundPixmap() ); break;
584
 
        case 2: this->unsetPalette(); break;
585
 
        case 3: case 4: case 5: break;
586
 
        default: return FALSE;
587
 
    } break;
588
 
    case 31: switch( f ) {
589
 
        case 1: *v = QVariant( this->backgroundBrush() ); break;
590
 
        case 3: case 4: case 5: break;
591
 
        default: return FALSE;
592
 
    } break;
593
 
    case 32: switch( f ) {
594
 
        case 1: *v = QVariant( this->colorGroup() ); break;
595
 
        case 3: case 4: case 5: break;
596
 
        default: return FALSE;
597
 
    } break;
598
 
    case 33: switch( f ) {
599
 
        case 0: setPalette(v->asPalette()); break;
600
 
        case 1: *v = QVariant( this->palette() ); break;
601
 
        case 2: this->unsetPalette(); break;
602
 
        case 5: return this->ownPalette();
603
 
        case 3: case 4: break;
604
 
        default: return FALSE;
605
 
    } break;
606
 
    case 34: switch( f ) {
607
 
        case 0: setBackgroundOrigin((BackgroundOrigin&)v->asInt()); break;
608
 
        case 1: *v = QVariant( (int)this->backgroundOrigin() ); break;
609
 
        case 3: case 4: case 5: break;
610
 
        default: return FALSE;
611
 
    } break;
612
 
    case 35: switch( f ) {
613
 
        case 1: *v = QVariant( this->ownPalette(), 0 ); break;
614
 
        case 3: case 4: case 5: break;
615
 
        default: return FALSE;
616
 
    } break;
617
 
    case 36: switch( f ) {
618
 
        case 0: setFont(v->asFont()); break;
619
 
        case 1: *v = QVariant( this->font() ); break;
620
 
        case 2: this->unsetFont(); break;
621
 
        case 5: return this->ownFont();
622
 
        case 3: case 4: break;
623
 
        default: return FALSE;
624
 
    } break;
625
 
    case 37: switch( f ) {
626
 
        case 1: *v = QVariant( this->ownFont(), 0 ); break;
627
 
        case 3: case 4: case 5: break;
628
 
        default: return FALSE;
629
 
    } break;
630
 
    case 38: switch( f ) {
631
 
        case 0: setCursor(v->asCursor()); break;
632
 
        case 1: *v = QVariant( this->cursor() ); break;
633
 
        case 2: this->unsetCursor(); break;
634
 
        case 5: return this->ownCursor();
635
 
        case 3: case 4: break;
636
 
        default: return FALSE;
637
 
    } break;
638
 
    case 39: switch( f ) {
639
 
        case 1: *v = QVariant( this->ownCursor(), 0 ); break;
640
 
        case 3: case 4: case 5: break;
641
 
        default: return FALSE;
642
 
    } break;
643
 
    case 40: switch( f ) {
644
 
        case 0: setCaption(v->asString()); break;
645
 
        case 1: *v = QVariant( this->caption() ); break;
646
 
        case 3: case 4: case 5: break;
647
 
        default: return FALSE;
648
 
    } break;
649
 
    case 41: switch( f ) {
650
 
        case 0: setIcon(v->asPixmap()); break;
651
 
        case 1: if ( this->icon() ) *v = QVariant( *icon() ); break;
652
 
        case 3: case 4: case 5: break;
653
 
        default: return FALSE;
654
 
    } break;
655
 
    case 42: switch( f ) {
656
 
        case 0: setIconText(v->asString()); break;
657
 
        case 1: *v = QVariant( this->iconText() ); break;
658
 
        case 3: case 4: case 5: break;
659
 
        default: return FALSE;
660
 
    } break;
661
 
    case 43: switch( f ) {
662
 
        case 0: setMouseTracking(v->asBool()); break;
663
 
        case 1: *v = QVariant( this->hasMouseTracking(), 0 ); break;
664
 
        case 3: case 4: case 5: break;
665
 
        default: return FALSE;
666
 
    } break;
667
 
    case 44: switch( f ) {
668
 
        case 1: *v = QVariant( this->hasMouse(), 0 ); break;
669
 
        case 3: case 4: case 5: break;
670
 
        default: return FALSE;
671
 
    } break;
672
 
    case 45: switch( f ) {
673
 
        case 1: *v = QVariant( this->isActiveWindow(), 0 ); break;
674
 
        case 3: case 4: case 5: break;
675
 
        default: return FALSE;
676
 
    } break;
677
 
    case 46: switch( f ) {
678
 
        case 1: *v = QVariant( this->isFocusEnabled(), 0 ); break;
679
 
        case 3: case 4: case 5: break;
680
 
        default: return FALSE;
681
 
    } break;
682
 
    case 47: switch( f ) {
683
 
        case 0: setFocusPolicy((FocusPolicy&)v->asInt()); break;
684
 
        case 1: *v = QVariant( (int)this->focusPolicy() ); break;
685
 
        case 3: case 4: case 5: break;
686
 
        default: return FALSE;
687
 
    } break;
688
 
    case 48: switch( f ) {
689
 
        case 1: *v = QVariant( this->hasFocus(), 0 ); break;
690
 
        case 3: case 4: case 5: break;
691
 
        default: return FALSE;
692
 
    } break;
693
 
    case 49: switch( f ) {
694
 
        case 0: setUpdatesEnabled(v->asBool()); break;
695
 
        case 1: *v = QVariant( this->isUpdatesEnabled(), 0 ); break;
696
 
        case 4: case 5: break;
697
 
        default: return FALSE;
698
 
    } break;
699
 
    case 50: switch( f ) {
700
 
        case 1: *v = QVariant( this->isVisible(), 0 ); break;
701
 
        case 3: case 4: case 5: break;
702
 
        default: return FALSE;
703
 
    } break;
704
 
    case 51: switch( f ) {
705
 
        case 1: *v = QVariant( this->visibleRect() ); break;
706
 
        case 3: case 4: case 5: break;
707
 
        default: return FALSE;
708
 
    } break;
709
 
    case 52: switch( f ) {
710
 
        case 0: setHidden(v->asBool()); break;
711
 
        case 1: *v = QVariant( this->isHidden(), 0 ); break;
712
 
        case 5: break;
713
 
        default: return FALSE;
714
 
    } break;
715
 
    case 53: switch( f ) {
716
 
        case 0: setShown(v->asBool()); break;
717
 
        case 1: *v = QVariant( this->isShown(), 0 ); break;
718
 
        case 5: break;
719
 
        default: return FALSE;
720
 
    } break;
721
 
    case 54: switch( f ) {
722
 
        case 1: *v = QVariant( this->isMinimized(), 0 ); break;
723
 
        case 3: case 4: case 5: break;
724
 
        default: return FALSE;
725
 
    } break;
726
 
    case 55: switch( f ) {
727
 
        case 1: *v = QVariant( this->isMaximized(), 0 ); break;
728
 
        case 3: case 4: case 5: break;
729
 
        default: return FALSE;
730
 
    } break;
731
 
    case 56: switch( f ) {
732
 
        case 1: *v = QVariant( this->isFullScreen(), 0 ); break;
733
 
        case 3: case 4: case 5: break;
734
 
        default: return FALSE;
735
 
    } break;
736
 
    case 57: switch( f ) {
737
 
        case 1: *v = QVariant( this->sizeHint() ); break;
738
 
        case 3: case 4: case 5: break;
739
 
        default: return FALSE;
740
 
    } break;
741
 
    case 58: switch( f ) {
742
 
        case 1: *v = QVariant( this->minimumSizeHint() ); break;
743
 
        case 3: case 4: case 5: break;
744
 
        default: return FALSE;
745
 
    } break;
746
 
    case 59: switch( f ) {
747
 
        case 1: *v = QVariant( this->microFocusHint() ); break;
748
 
        case 3: case 4: case 5: break;
749
 
        default: return FALSE;
750
 
    } break;
751
 
    case 60: switch( f ) {
752
 
        case 0: setAcceptDrops(v->asBool()); break;
753
 
        case 1: *v = QVariant( this->acceptDrops(), 0 ); break;
754
 
        case 3: case 4: case 5: break;
755
 
        default: return FALSE;
756
 
    } break;
757
 
    case 61: switch( f ) {
758
 
        case 0: setAutoMask(v->asBool()); break;
759
 
        case 1: *v = QVariant( this->autoMask(), 0 ); break;
760
 
        case 5: break;
761
 
        default: return FALSE;
762
 
    } break;
763
 
    case 62: switch( f ) {
764
 
        case 1: *v = QVariant( this->customWhatsThis(), 0 ); break;
765
 
        case 3: case 4: case 5: break;
766
 
        default: return FALSE;
767
 
    } break;
768
 
    case 63: switch( f ) {
769
 
        case 0: setInputMethodEnabled(v->asBool()); break;
770
 
        case 1: *v = QVariant( this->isInputMethodEnabled(), 0 ); break;
771
 
        case 5: break;
772
 
        default: return FALSE;
773
 
    } break;
774
 
    case 64: switch( f ) {
775
 
        case 0: setWindowOpacity(v->asDouble()); break;
776
 
        case 1: *v = QVariant( this->windowOpacity() ); break;
777
 
        case 4: case 5: break;
778
 
        default: return FALSE;
779
 
    } break;
780
 
    default:
781
 
        return QObject::qt_property( id, f, v );
782
 
    }
783
 
    return TRUE;
784
 
}
785
 
 
786
 
bool QWidget::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
787
 
#endif // QT_NO_PROPERTIES