00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #undef QT_NO_COMPAT
00011 #include "PropertyList.h"
00012 #include <qmetaobject.h>
00013 #include <qapplication.h>
00014
00015 #include <private/qucomextra_p.h>
00016 #if !defined(Q_MOC_OUTPUT_REVISION) || (Q_MOC_OUTPUT_REVISION != 26)
00017 #error "This file was generated using the moc from 3.1.1. It"
00018 #error "cannot be used with the include files from this version of Qt."
00019 #error "(The moc has changed too much.)"
00020 #endif
00021
00022 const char *fun::PropertyList::className() const
00023 {
00024 return "fun::PropertyList";
00025 }
00026
00027 QMetaObject *fun::PropertyList::metaObj = 0;
00028 static QMetaObjectCleanUp cleanUp_fun__PropertyList( "fun::PropertyList", &fun::PropertyList::staticMetaObject );
00029
00030 #ifndef QT_NO_TRANSLATION
00031 QString fun::PropertyList::tr( const char *s, const char *c )
00032 {
00033 if ( qApp )
00034 return qApp->translate( "fun::PropertyList", s, c, QApplication::DefaultCodec );
00035 else
00036 return QString::fromLatin1( s );
00037 }
00038 #ifndef QT_NO_TRANSLATION_UTF8
00039 QString fun::PropertyList::trUtf8( const char *s, const char *c )
00040 {
00041 if ( qApp )
00042 return qApp->translate( "fun::PropertyList", s, c, QApplication::UnicodeUTF8 );
00043 else
00044 return QString::fromUtf8( s );
00045 }
00046 #endif // QT_NO_TRANSLATION_UTF8
00047
00048 #endif // QT_NO_TRANSLATION
00049
00050 QMetaObject* fun::PropertyList::staticMetaObject()
00051 {
00052 if ( metaObj )
00053 return metaObj;
00054 QMetaObject* parentObject = QObject::staticMetaObject();
00055 static const QUMethod slot_0 = {"slotEmitUpdate", 0, 0 };
00056 static const QUParameter param_slot_1[] = {
00057 { "key", &static_QUType_QString, 0, QUParameter::In },
00058 { "val", &static_QUType_QString, 0, QUParameter::In }
00059 };
00060 static const QUMethod slot_1 = {"set", 2, param_slot_1 };
00061 static const QUParameter param_slot_2[] = {
00062 { "key", &static_QUType_QString, 0, QUParameter::In },
00063 { "val", &static_QUType_QString, 0, QUParameter::In },
00064 { "comment", &static_QUType_QString, 0, QUParameter::In }
00065 };
00066 static const QUMethod slot_2 = {"set", 3, param_slot_2 };
00067 static const QUParameter param_slot_3[] = {
00068 { "key", &static_QUType_QString, 0, QUParameter::In },
00069 { "val", &static_QUType_int, 0, QUParameter::In }
00070 };
00071 static const QUMethod slot_3 = {"set", 2, param_slot_3 };
00072 static const QUParameter param_slot_4[] = {
00073 { "key", &static_QUType_QString, 0, QUParameter::In },
00074 { "val", &static_QUType_bool, 0, QUParameter::In }
00075 };
00076 static const QUMethod slot_4 = {"set", 2, param_slot_4 };
00077 static const QUParameter param_slot_5[] = {
00078 { "key", &static_QUType_QString, 0, QUParameter::In },
00079 { "val", &static_QUType_double, 0, QUParameter::In }
00080 };
00081 static const QUMethod slot_5 = {"set", 2, param_slot_5 };
00082 static const QUParameter param_slot_6[] = {
00083 { "key", &static_QUType_QString, 0, QUParameter::In },
00084 { "val", &static_QUType_varptr, "\x0a", QUParameter::In }
00085 };
00086 static const QUMethod slot_6 = {"set", 2, param_slot_6 };
00087 static const QUParameter param_slot_7[] = {
00088 { "key", &static_QUType_QString, 0, QUParameter::In },
00089 { "val", &static_QUType_varptr, "\x0e", QUParameter::In }
00090 };
00091 static const QUMethod slot_7 = {"set", 2, param_slot_7 };
00092 static const QUParameter param_slot_8[] = {
00093 { "key", &static_QUType_QString, 0, QUParameter::In },
00094 { "dflt", &static_QUType_varptr, "\x09", QUParameter::In }
00095 };
00096 static const QUMethod slot_8 = {"set", 2, param_slot_8 };
00097 static const QUParameter param_slot_9[] = {
00098 { "key", &static_QUType_QString, 0, QUParameter::In }
00099 };
00100 static const QUMethod slot_9 = {"unset", 1, param_slot_9 };
00101 static const QUParameter param_slot_10[] = {
00102 { "key", &static_QUType_QString, 0, QUParameter::In },
00103 { "comment", &static_QUType_QString, 0, QUParameter::In }
00104 };
00105 static const QUMethod slot_10 = {"setComment", 2, param_slot_10 };
00106 static const QUParameter param_slot_11[] = {
00107 { "needsSave", &static_QUType_bool, 0, QUParameter::In }
00108 };
00109 static const QUMethod slot_11 = {"setNeedsSave", 1, param_slot_11 };
00110 static const QUParameter param_slot_12[] = {
00111 { 0, &static_QUType_bool, 0, QUParameter::Out },
00112 { "config", &static_QUType_ptr, "PropertyList", QUParameter::In }
00113 };
00114 static const QUMethod slot_12 = {"mergeIn", 2, param_slot_12 };
00115 static const QUParameter param_slot_13[] = {
00116 { "ser", &static_QUType_ptr, "Deserializer", QUParameter::In }
00117 };
00118 static const QUMethod slot_13 = {"deserialize", 1, param_slot_13 };
00119 static const QUParameter param_slot_14[] = {
00120 { "ser", &static_QUType_ptr, "Serializer", QUParameter::InOut }
00121 };
00122 static const QUMethod slot_14 = {"serialize", 1, param_slot_14 };
00123 static const QMetaData slot_tbl[] = {
00124 { "slotEmitUpdate()", &slot_0, QMetaData::Public },
00125 { "set(const QString&,const QString&)", &slot_1, QMetaData::Public },
00126 { "set(const QString&,const QString&,const QString&)", &slot_2, QMetaData::Public },
00127 { "set(const QString&,int)", &slot_3, QMetaData::Public },
00128 { "set(const QString&,bool)", &slot_4, QMetaData::Public },
00129 { "set(const QString&,double)", &slot_5, QMetaData::Public },
00130 { "set(const QString&,const QColor&)", &slot_6, QMetaData::Public },
00131 { "set(const QString&,const QPoint&)", &slot_7, QMetaData::Public },
00132 { "set(const QString&,const QSize&)", &slot_8, QMetaData::Public },
00133 { "unset(const QString&)", &slot_9, QMetaData::Public },
00134 { "setComment(const QString&,const QString&)", &slot_10, QMetaData::Public },
00135 { "setNeedsSave(bool)", &slot_11, QMetaData::Public },
00136 { "mergeIn(const PropertyList*)", &slot_12, QMetaData::Public },
00137 { "deserialize(const Deserializer&)", &slot_13, QMetaData::Public },
00138 { "serialize(Serializer&)", &slot_14, QMetaData::Public }
00139 };
00140 static const QUParameter param_signal_0[] = {
00141 { 0, &static_QUType_QString, 0, QUParameter::In }
00142 };
00143 static const QUMethod signal_0 = {"signalChange", 1, param_signal_0 };
00144 static const QMetaData signal_tbl[] = {
00145 { "signalChange(const QString&)", &signal_0, QMetaData::Public }
00146 };
00147 metaObj = QMetaObject::new_metaobject(
00148 "fun::PropertyList", parentObject,
00149 slot_tbl, 15,
00150 signal_tbl, 1,
00151 #ifndef QT_NO_PROPERTIES
00152 0, 0,
00153 0, 0,
00154 #endif
00155 0, 0 );
00156 cleanUp_fun__PropertyList.setMetaObject( metaObj );
00157 return metaObj;
00158 }
00159
00160 void* fun::PropertyList::qt_cast( const char* clname )
00161 {
00162 if ( !qstrcmp( clname, "fun::PropertyList" ) )
00163 return this;
00164 if ( !qstrcmp( clname, "Serializable" ) )
00165 return (Serializable*)this;
00166 return QObject::qt_cast( clname );
00167 }
00168
00169
00170 void fun::PropertyList::signalChange( const QString& t0 )
00171 {
00172 activate_signal( staticMetaObject()->signalOffset() + 0, t0 );
00173 }
00174
00175 bool fun::PropertyList::qt_invoke( int _id, QUObject* _o )
00176 {
00177 switch ( _id - staticMetaObject()->slotOffset() ) {
00178 case 0: slotEmitUpdate(); break;
00179 case 1: set((const QString&)static_QUType_QString.get(_o+1),(const QString&)static_QUType_QString.get(_o+2)); break;
00180 case 2: set((const QString&)static_QUType_QString.get(_o+1),(const QString&)static_QUType_QString.get(_o+2),(const QString&)static_QUType_QString.get(_o+3)); break;
00181 case 3: set((const QString&)static_QUType_QString.get(_o+1),(int)static_QUType_int.get(_o+2)); break;
00182 case 4: set((const QString&)static_QUType_QString.get(_o+1),(bool)static_QUType_bool.get(_o+2)); break;
00183 case 5: set((const QString&)static_QUType_QString.get(_o+1),(double)static_QUType_double.get(_o+2)); break;
00184 case 6: set((const QString&)static_QUType_QString.get(_o+1),(const QColor&)*((const QColor*)static_QUType_ptr.get(_o+2))); break;
00185 case 7: set((const QString&)static_QUType_QString.get(_o+1),(const QPoint&)*((const QPoint*)static_QUType_ptr.get(_o+2))); break;
00186 case 8: set((const QString&)static_QUType_QString.get(_o+1),(const QSize&)*((const QSize*)static_QUType_ptr.get(_o+2))); break;
00187 case 9: unset((const QString&)static_QUType_QString.get(_o+1)); break;
00188 case 10: setComment((const QString&)static_QUType_QString.get(_o+1),(const QString&)static_QUType_QString.get(_o+2)); break;
00189 case 11: setNeedsSave((bool)static_QUType_bool.get(_o+1)); break;
00190 case 12: static_QUType_bool.set(_o,mergeIn((const PropertyList*)static_QUType_ptr.get(_o+1))); break;
00191 case 13: deserialize((const Deserializer&)*((const Deserializer*)static_QUType_ptr.get(_o+1))); break;
00192 case 14: serialize((Serializer&)*((Serializer*)static_QUType_ptr.get(_o+1))); break;
00193 default:
00194 return QObject::qt_invoke( _id, _o );
00195 }
00196 return TRUE;
00197 }
00198
00199 bool fun::PropertyList::qt_emit( int _id, QUObject* _o )
00200 {
00201 switch ( _id - staticMetaObject()->signalOffset() ) {
00202 case 0: signalChange((const QString&)static_QUType_QString.get(_o+1)); break;
00203 default:
00204 return QObject::qt_emit(_id,_o);
00205 }
00206 return TRUE;
00207 }
00208 #ifndef QT_NO_PROPERTIES
00209
00210 bool fun::PropertyList::qt_property( int id, int f, QVariant* v)
00211 {
00212 return QObject::qt_property( id, f, v);
00213 }
00214
00215 bool fun::PropertyList::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
00216 #endif // QT_NO_PROPERTIES
00217
00218
00219 const char *fun::KeyValuePair::className() const
00220 {
00221 return "fun::KeyValuePair";
00222 }
00223
00224 QMetaObject *fun::KeyValuePair::metaObj = 0;
00225 static QMetaObjectCleanUp cleanUp_fun__KeyValuePair( "fun::KeyValuePair", &fun::KeyValuePair::staticMetaObject );
00226
00227 #ifndef QT_NO_TRANSLATION
00228 QString fun::KeyValuePair::tr( const char *s, const char *c )
00229 {
00230 if ( qApp )
00231 return qApp->translate( "fun::KeyValuePair", s, c, QApplication::DefaultCodec );
00232 else
00233 return QString::fromLatin1( s );
00234 }
00235 #ifndef QT_NO_TRANSLATION_UTF8
00236 QString fun::KeyValuePair::trUtf8( const char *s, const char *c )
00237 {
00238 if ( qApp )
00239 return qApp->translate( "fun::KeyValuePair", s, c, QApplication::UnicodeUTF8 );
00240 else
00241 return QString::fromUtf8( s );
00242 }
00243 #endif // QT_NO_TRANSLATION_UTF8
00244
00245 #endif // QT_NO_TRANSLATION
00246
00247 QMetaObject* fun::KeyValuePair::staticMetaObject()
00248 {
00249 if ( metaObj )
00250 return metaObj;
00251 QMetaObject* parentObject = QObject::staticMetaObject();
00252 metaObj = QMetaObject::new_metaobject(
00253 "fun::KeyValuePair", parentObject,
00254 0, 0,
00255 0, 0,
00256 #ifndef QT_NO_PROPERTIES
00257 0, 0,
00258 0, 0,
00259 #endif
00260 0, 0 );
00261 cleanUp_fun__KeyValuePair.setMetaObject( metaObj );
00262 return metaObj;
00263 }
00264
00265 void* fun::KeyValuePair::qt_cast( const char* clname )
00266 {
00267 if ( !qstrcmp( clname, "fun::KeyValuePair" ) )
00268 return this;
00269 if ( !qstrcmp( clname, "Serializable" ) )
00270 return (Serializable*)this;
00271 return QObject::qt_cast( clname );
00272 }
00273
00274 bool fun::KeyValuePair::qt_invoke( int _id, QUObject* _o )
00275 {
00276 return QObject::qt_invoke(_id,_o);
00277 }
00278
00279 bool fun::KeyValuePair::qt_emit( int _id, QUObject* _o )
00280 {
00281 return QObject::qt_emit(_id,_o);
00282 }
00283 #ifndef QT_NO_PROPERTIES
00284
00285 bool fun::KeyValuePair::qt_property( int id, int f, QVariant* v)
00286 {
00287 return QObject::qt_property( id, f, v);
00288 }
00289
00290 bool fun::KeyValuePair::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
00291 #endif // QT_NO_PROPERTIES
