← Back to branch summary

~ubuntu-branches/ubuntu/quantal/qgis/quantal

« back to all changes in this revision

Viewing changes to src/qgsmapcanvas.moc.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Steve Halasz
  • Date: 2004-12-21 09:46:27 UTC
  • Revision ID: james.westby@ubuntu.com-20041221094627-r9lb6mlz2o3yp8gn
Tags: upstream-0.6.0
Import upstream version 0.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/qgsmapcanvas.moc.cpp
 
1
/****************************************************************************
 
2
** QgsMapCanvas meta object code from reading C++ file 'qgsmapcanvas.h'
 
3
**
 
4
** Created: Fri Dec 17 09:40:20 2004
 
5
**      by: The Qt MOC ($Id: qt/moc_yacc.cpp   3.3.3   edited Aug 5 16:40 $)
 
6
**
 
7
** WARNING! All changes made in this file will be lost!
 
8
*****************************************************************************/
 
9
 
 
10
#undef QT_NO_COMPAT
 
11
#include "qgsmapcanvas.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.3. 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 *QgsMapCanvas::className() const
 
23
{
 
24
    return "QgsMapCanvas";
 
25
}
 
26
 
 
27
QMetaObject *QgsMapCanvas::metaObj = 0;
 
28
static QMetaObjectCleanUp cleanUp_QgsMapCanvas( "QgsMapCanvas", &QgsMapCanvas::staticMetaObject );
 
29
 
 
30
#ifndef QT_NO_TRANSLATION
 
31
QString QgsMapCanvas::tr( const char *s, const char *c )
 
32
{
 
33
    if ( qApp )
 
34
        return qApp->translate( "QgsMapCanvas", s, c, QApplication::DefaultCodec );
 
35
    else
 
36
        return QString::fromLatin1( s );
 
37
}
 
38
#ifndef QT_NO_TRANSLATION_UTF8
 
39
QString QgsMapCanvas::trUtf8( const char *s, const char *c )
 
40
{
 
41
    if ( qApp )
 
42
        return qApp->translate( "QgsMapCanvas", 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* QgsMapCanvas::staticMetaObject()
 
51
{
 
52
    if ( metaObj )
 
53
        return metaObj;
 
54
    QMetaObject* parentObject = QWidget::staticMetaObject();
 
55
    static const QUParameter param_slot_0[] = {
 
56
        { "lyr", &static_QUType_ptr, "QgsMapLayer", QUParameter::In }
 
57
    };
 
58
    static const QUMethod slot_0 = {"addLayer", 1, param_slot_0 };
 
59
    static const QUParameter param_slot_1[] = {
 
60
        { "lyr", &static_QUType_ptr, "QgsMapLayerInterface", QUParameter::In }
 
61
    };
 
62
    static const QUMethod slot_1 = {"addLayer", 1, param_slot_1 };
 
63
    static const QUParameter param_slot_2[] = {
 
64
        { "key", &static_QUType_QString, 0, QUParameter::In }
 
65
    };
 
66
    static const QUMethod slot_2 = {"remove", 1, param_slot_2 };
 
67
    static const QUMethod slot_3 = {"removeAll", 0, 0 };
 
68
    static const QUMethod slot_4 = {"refresh", 0, 0 };
 
69
    static const QUParameter param_slot_5[] = {
 
70
        { "key", &static_QUType_QString, 0, QUParameter::In },
 
71
        { "obj", &static_QUType_ptr, "QgsAcetateObject", QUParameter::In }
 
72
    };
 
73
    static const QUMethod slot_5 = {"addAcetateObject", 2, param_slot_5 };
 
74
    static const QUMethod slot_6 = {"render", 0, 0 };
 
75
    static const QUParameter param_slot_7[] = {
 
76
        { "theQPaintDevice", &static_QUType_ptr, "QPaintDevice", QUParameter::In }
 
77
    };
 
78
    static const QUMethod slot_7 = {"render", 1, param_slot_7 };
 
79
    static const QUParameter param_slot_8[] = {
 
80
        { "theFileName", &static_QUType_QString, 0, QUParameter::In }
 
81
    };
 
82
    static const QUMethod slot_8 = {"saveAsImage", 1, param_slot_8 };
 
83
    static const QUParameter param_slot_9[] = {
 
84
        { "theFileName", &static_QUType_QString, 0, QUParameter::In },
 
85
        { "QPixmap", &static_QUType_varptr, "\x06", QUParameter::In }
 
86
    };
 
87
    static const QUMethod slot_9 = {"saveAsImage", 2, param_slot_9 };
 
88
    static const QUParameter param_slot_10[] = {
 
89
        { "theFileName", &static_QUType_QString, 0, QUParameter::In },
 
90
        { "QPixmap", &static_QUType_varptr, "\x06", QUParameter::In },
 
91
        { 0, &static_QUType_QString, 0, QUParameter::In }
 
92
    };
 
93
    static const QUMethod slot_10 = {"saveAsImage", 3, param_slot_10 };
 
94
    static const QUMethod slot_11 = {"layerStateChange", 0, 0 };
 
95
    static const QUParameter param_slot_12[] = {
 
96
        { "lv", &static_QUType_ptr, "QgsLegend", QUParameter::In }
 
97
    };
 
98
    static const QUMethod slot_12 = {"setZOrderFromLegend", 1, param_slot_12 };
 
99
    static const QUParameter param_slot_13[] = {
 
100
        { 0, &static_QUType_bool, 0, QUParameter::In }
 
101
    };
 
102
    static const QUMethod slot_13 = {"userInteractionAllowed", 1, param_slot_13 };
 
103
    static const QUParameter param_slot_14[] = {
 
104
        { 0, &static_QUType_bool, 0, QUParameter::Out }
 
105
    };
 
106
    static const QUMethod slot_14 = {"isUserInteractionAllowed", 1, param_slot_14 };
 
107
    static const QUParameter param_slot_15[] = {
 
108
        { "theFlag", &static_QUType_bool, 0, QUParameter::In }
 
109
    };
 
110
    static const QUMethod slot_15 = {"setRenderFlag", 1, param_slot_15 };
 
111
    static const QUParameter param_slot_16[] = {
 
112
        { 0, &static_QUType_bool, 0, QUParameter::Out }
 
113
    };
 
114
    static const QUMethod slot_16 = {"renderFlag", 1, param_slot_16 };
 
115
    static const QUParameter param_slot_17[] = {
 
116
        { "maplayer", &static_QUType_ptr, "QgsMapLayer", QUParameter::In },
 
117
        { "visible", &static_QUType_bool, 0, QUParameter::In }
 
118
    };
 
119
    static const QUMethod slot_17 = {"showInOverview", 2, param_slot_17 };
 
120
    static const QUMethod slot_18 = {"recalculateExtents", 0, 0 };
 
121
    static const QMetaData slot_tbl[] = {
 
122
        { "addLayer(QgsMapLayer*)", &slot_0, QMetaData::Public },
 
123
        { "addLayer(QgsMapLayerInterface*)", &slot_1, QMetaData::Public },
 
124
        { "remove(QString)", &slot_2, QMetaData::Public },
 
125
        { "removeAll()", &slot_3, QMetaData::Public },
 
126
        { "refresh()", &slot_4, QMetaData::Public },
 
127
        { "addAcetateObject(QString,QgsAcetateObject*)", &slot_5, QMetaData::Public },
 
128
        { "render()", &slot_6, QMetaData::Public },
 
129
        { "render(QPaintDevice*)", &slot_7, QMetaData::Public },
 
130
        { "saveAsImage(QString)", &slot_8, QMetaData::Public },
 
131
        { "saveAsImage(QString,QPixmap*)", &slot_9, QMetaData::Public },
 
132
        { "saveAsImage(QString,QPixmap*,QString)", &slot_10, QMetaData::Public },
 
133
        { "layerStateChange()", &slot_11, QMetaData::Public },
 
134
        { "setZOrderFromLegend(QgsLegend*)", &slot_12, QMetaData::Public },
 
135
        { "userInteractionAllowed(bool)", &slot_13, QMetaData::Public },
 
136
        { "isUserInteractionAllowed()", &slot_14, QMetaData::Public },
 
137
        { "setRenderFlag(bool)", &slot_15, QMetaData::Public },
 
138
        { "renderFlag()", &slot_16, QMetaData::Public },
 
139
        { "showInOverview(QgsMapLayer*,bool)", &slot_17, QMetaData::Public },
 
140
        { "recalculateExtents()", &slot_18, QMetaData::Public }
 
141
    };
 
142
    static const QUParameter param_signal_0[] = {
 
143
        { 0, &static_QUType_int, 0, QUParameter::In },
 
144
        { 0, &static_QUType_int, 0, QUParameter::In }
 
145
    };
 
146
    static const QUMethod signal_0 = {"setProgress", 2, param_signal_0 };
 
147
    static const QUParameter param_signal_1[] = {
 
148
        { "p", &static_QUType_ptr, "QgsPoint", QUParameter::InOut }
 
149
    };
 
150
    static const QUMethod signal_1 = {"xyCoordinates", 1, param_signal_1 };
 
151
    static const QUParameter param_signal_2[] = {
 
152
        { "p", &static_QUType_ptr, "QgsPoint", QUParameter::InOut }
 
153
    };
 
154
    static const QUMethod signal_2 = {"xyClickCoordinates", 1, param_signal_2 };
 
155
    static const QUParameter param_signal_3[] = {
 
156
        { 0, &static_QUType_QString, 0, QUParameter::In }
 
157
    };
 
158
    static const QUMethod signal_3 = {"scaleChanged", 1, param_signal_3 };
 
159
    static const QUParameter param_signal_4[] = {
 
160
        { 0, &static_QUType_ptr, "QgsRect", QUParameter::In }
 
161
    };
 
162
    static const QUMethod signal_4 = {"extentsChanged", 1, param_signal_4 };
 
163
    static const QUParameter param_signal_5[] = {
 
164
        { 0, &static_QUType_ptr, "QPainter", QUParameter::In }
 
165
    };
 
166
    static const QUMethod signal_5 = {"renderComplete", 1, param_signal_5 };
 
167
    static const QUParameter param_signal_6[] = {
 
168
        { "lyr", &static_QUType_ptr, "QgsMapLayer", QUParameter::In }
 
169
    };
 
170
    static const QUMethod signal_6 = {"addedLayer", 1, param_signal_6 };
 
171
    static const QUParameter param_signal_7[] = {
 
172
        { "layer_key", &static_QUType_QString, 0, QUParameter::In }
 
173
    };
 
174
    static const QUMethod signal_7 = {"removedLayer", 1, param_signal_7 };
 
175
    static const QUMethod signal_8 = {"removedAll", 0, 0 };
 
176
    static const QMetaData signal_tbl[] = {
 
177
        { "setProgress(int,int)", &signal_0, QMetaData::Public },
 
178
        { "xyCoordinates(QgsPoint&)", &signal_1, QMetaData::Public },
 
179
        { "xyClickCoordinates(QgsPoint&)", &signal_2, QMetaData::Public },
 
180
        { "scaleChanged(QString)", &signal_3, QMetaData::Public },
 
181
        { "extentsChanged(QgsRect)", &signal_4, QMetaData::Public },
 
182
        { "renderComplete(QPainter*)", &signal_5, QMetaData::Public },
 
183
        { "addedLayer(QgsMapLayer*)", &signal_6, QMetaData::Public },
 
184
        { "removedLayer(QString)", &signal_7, QMetaData::Public },
 
185
        { "removedAll()", &signal_8, QMetaData::Public }
 
186
    };
 
187
    metaObj = QMetaObject::new_metaobject(
 
188
        "QgsMapCanvas", parentObject,
 
189
        slot_tbl, 19,
 
190
        signal_tbl, 9,
 
191
#ifndef QT_NO_PROPERTIES
 
192
        0, 0,
 
193
        0, 0,
 
194
#endif // QT_NO_PROPERTIES
 
195
        0, 0 );
 
196
    cleanUp_QgsMapCanvas.setMetaObject( metaObj );
 
197
    return metaObj;
 
198
}
 
199
 
 
200
void* QgsMapCanvas::qt_cast( const char* clname )
 
201
{
 
202
    if ( !qstrcmp( clname, "QgsMapCanvas" ) )
 
203
        return this;
 
204
    return QWidget::qt_cast( clname );
 
205
}
 
206
 
 
207
#include <qobjectdefs.h>
 
208
#include <qsignalslotimp.h>
 
209
 
 
210
// SIGNAL setProgress
 
211
void QgsMapCanvas::setProgress( int t0, int t1 )
 
212
{
 
213
    if ( signalsBlocked() )
 
214
        return;
 
215
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
 
216
    if ( !clist )
 
217
        return;
 
218
    QUObject o[3];
 
219
    static_QUType_int.set(o+1,t0);
 
220
    static_QUType_int.set(o+2,t1);
 
221
    activate_signal( clist, o );
 
222
}
 
223
 
 
224
// SIGNAL xyCoordinates
 
225
void QgsMapCanvas::xyCoordinates( QgsPoint& t0 )
 
226
{
 
227
    if ( signalsBlocked() )
 
228
        return;
 
229
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 1 );
 
230
    if ( !clist )
 
231
        return;
 
232
    QUObject o[2];
 
233
    static_QUType_ptr.set(o+1,&t0);
 
234
    activate_signal( clist, o );
 
235
}
 
236
 
 
237
// SIGNAL xyClickCoordinates
 
238
void QgsMapCanvas::xyClickCoordinates( QgsPoint& t0 )
 
239
{
 
240
    if ( signalsBlocked() )
 
241
        return;
 
242
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 2 );
 
243
    if ( !clist )
 
244
        return;
 
245
    QUObject o[2];
 
246
    static_QUType_ptr.set(o+1,&t0);
 
247
    activate_signal( clist, o );
 
248
}
 
249
 
 
250
// SIGNAL scaleChanged
 
251
void QgsMapCanvas::scaleChanged( QString t0 )
 
252
{
 
253
    activate_signal( staticMetaObject()->signalOffset() + 3, t0 );
 
254
}
 
255
 
 
256
// SIGNAL extentsChanged
 
257
void QgsMapCanvas::extentsChanged( QgsRect t0 )
 
258
{
 
259
    if ( signalsBlocked() )
 
260
        return;
 
261
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 4 );
 
262
    if ( !clist )
 
263
        return;
 
264
    QUObject o[2];
 
265
    static_QUType_ptr.set(o+1,&t0);
 
266
    activate_signal( clist, o );
 
267
}
 
268
 
 
269
// SIGNAL renderComplete
 
270
void QgsMapCanvas::renderComplete( QPainter* t0 )
 
271
{
 
272
    if ( signalsBlocked() )
 
273
        return;
 
274
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 5 );
 
275
    if ( !clist )
 
276
        return;
 
277
    QUObject o[2];
 
278
    static_QUType_ptr.set(o+1,t0);
 
279
    activate_signal( clist, o );
 
280
}
 
281
 
 
282
// SIGNAL addedLayer
 
283
void QgsMapCanvas::addedLayer( QgsMapLayer* t0 )
 
284
{
 
285
    if ( signalsBlocked() )
 
286
        return;
 
287
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 6 );
 
288
    if ( !clist )
 
289
        return;
 
290
    QUObject o[2];
 
291
    static_QUType_ptr.set(o+1,t0);
 
292
    activate_signal( clist, o );
 
293
}
 
294
 
 
295
// SIGNAL removedLayer
 
296
void QgsMapCanvas::removedLayer( QString t0 )
 
297
{
 
298
    activate_signal( staticMetaObject()->signalOffset() + 7, t0 );
 
299
}
 
300
 
 
301
// SIGNAL removedAll
 
302
void QgsMapCanvas::removedAll()
 
303
{
 
304
    activate_signal( staticMetaObject()->signalOffset() + 8 );
 
305
}
 
306
 
 
307
bool QgsMapCanvas::qt_invoke( int _id, QUObject* _o )
 
308
{
 
309
    switch ( _id - staticMetaObject()->slotOffset() ) {
 
310
    case 0: addLayer((QgsMapLayer*)static_QUType_ptr.get(_o+1)); break;
 
311
    case 1: addLayer((QgsMapLayerInterface*)static_QUType_ptr.get(_o+1)); break;
 
312
    case 2: remove((QString)static_QUType_QString.get(_o+1)); break;
 
313
    case 3: removeAll(); break;
 
314
    case 4: refresh(); break;
 
315
    case 5: addAcetateObject((QString)static_QUType_QString.get(_o+1),(QgsAcetateObject*)static_QUType_ptr.get(_o+2)); break;
 
316
    case 6: render(); break;
 
317
    case 7: render((QPaintDevice*)static_QUType_ptr.get(_o+1)); break;
 
318
    case 8: saveAsImage((QString)static_QUType_QString.get(_o+1)); break;
 
319
    case 9: saveAsImage((QString)static_QUType_QString.get(_o+1),(QPixmap*)static_QUType_varptr.get(_o+2)); break;
 
320
    case 10: saveAsImage((QString)static_QUType_QString.get(_o+1),(QPixmap*)static_QUType_varptr.get(_o+2),(QString)static_QUType_QString.get(_o+3)); break;
 
321
    case 11: layerStateChange(); break;
 
322
    case 12: setZOrderFromLegend((QgsLegend*)static_QUType_ptr.get(_o+1)); break;
 
323
    case 13: userInteractionAllowed((bool)static_QUType_bool.get(_o+1)); break;
 
324
    case 14: static_QUType_bool.set(_o,isUserInteractionAllowed()); break;
 
325
    case 15: setRenderFlag((bool)static_QUType_bool.get(_o+1)); break;
 
326
    case 16: static_QUType_bool.set(_o,renderFlag()); break;
 
327
    case 17: showInOverview((QgsMapLayer*)static_QUType_ptr.get(_o+1),(bool)static_QUType_bool.get(_o+2)); break;
 
328
    case 18: recalculateExtents(); break;
 
329
    default:
 
330
        return QWidget::qt_invoke( _id, _o );
 
331
    }
 
332
    return TRUE;
 
333
}
 
334
 
 
335
bool QgsMapCanvas::qt_emit( int _id, QUObject* _o )
 
336
{
 
337
    switch ( _id - staticMetaObject()->signalOffset() ) {
 
338
    case 0: setProgress((int)static_QUType_int.get(_o+1),(int)static_QUType_int.get(_o+2)); break;
 
339
    case 1: xyCoordinates((QgsPoint&)*((QgsPoint*)static_QUType_ptr.get(_o+1))); break;
 
340
    case 2: xyClickCoordinates((QgsPoint&)*((QgsPoint*)static_QUType_ptr.get(_o+1))); break;
 
341
    case 3: scaleChanged((QString)static_QUType_QString.get(_o+1)); break;
 
342
    case 4: extentsChanged((QgsRect)(*((QgsRect*)static_QUType_ptr.get(_o+1)))); break;
 
343
    case 5: renderComplete((QPainter*)static_QUType_ptr.get(_o+1)); break;
 
344
    case 6: addedLayer((QgsMapLayer*)static_QUType_ptr.get(_o+1)); break;
 
345
    case 7: removedLayer((QString)static_QUType_QString.get(_o+1)); break;
 
346
    case 8: removedAll(); break;
 
347
    default:
 
348
        return QWidget::qt_emit(_id,_o);
 
349
    }
 
350
    return TRUE;
 
351
}
 
352
#ifndef QT_NO_PROPERTIES
 
353
 
 
354
bool QgsMapCanvas::qt_property( int id, int f, QVariant* v)
 
355
{
 
356
    return QWidget::qt_property( id, f, v);
 
357
}
 
358
 
 
359
bool QgsMapCanvas::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
 
360
#endif // QT_NO_PROPERTIES