00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #undef QT_NO_COMPAT
00011 #include "../include/MonitorWindow.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.3.8b. 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 *ClientTable::className() const
00023 {
00024 return "ClientTable";
00025 }
00026
00027 QMetaObject *ClientTable::metaObj = 0;
00028 static QMetaObjectCleanUp cleanUp_ClientTable( "ClientTable", &ClientTable::staticMetaObject );
00029
00030 #ifndef QT_NO_TRANSLATION
00031 QString ClientTable::tr( const char *s, const char *c )
00032 {
00033 if ( qApp )
00034 return qApp->translate( "ClientTable", s, c, QApplication::DefaultCodec );
00035 else
00036 return QString::fromLatin1( s );
00037 }
00038 #ifndef QT_NO_TRANSLATION_UTF8
00039 QString ClientTable::trUtf8( const char *s, const char *c )
00040 {
00041 if ( qApp )
00042 return qApp->translate( "ClientTable", 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* ClientTable::staticMetaObject()
00051 {
00052 if ( metaObj )
00053 return metaObj;
00054 QMetaObject* parentObject = QTable::staticMetaObject();
00055 metaObj = QMetaObject::new_metaobject(
00056 "ClientTable", parentObject,
00057 0, 0,
00058 0, 0,
00059 #ifndef QT_NO_PROPERTIES
00060 0, 0,
00061 0, 0,
00062 #endif
00063 0, 0 );
00064 cleanUp_ClientTable.setMetaObject( metaObj );
00065 return metaObj;
00066 }
00067
00068 void* ClientTable::qt_cast( const char* clname )
00069 {
00070 if ( !qstrcmp( clname, "ClientTable" ) )
00071 return this;
00072 return QTable::qt_cast( clname );
00073 }
00074
00075 bool ClientTable::qt_invoke( int _id, QUObject* _o )
00076 {
00077 return QTable::qt_invoke(_id,_o);
00078 }
00079
00080 bool ClientTable::qt_emit( int _id, QUObject* _o )
00081 {
00082 return QTable::qt_emit(_id,_o);
00083 }
00084 #ifndef QT_NO_PROPERTIES
00085
00086 bool ClientTable::qt_property( int id, int f, QVariant* v)
00087 {
00088 return QTable::qt_property( id, f, v);
00089 }
00090
00091 bool ClientTable::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
00092 #endif // QT_NO_PROPERTIES
00093
00094
00095 const char *StorageTable::className() const
00096 {
00097 return "StorageTable";
00098 }
00099
00100 QMetaObject *StorageTable::metaObj = 0;
00101 static QMetaObjectCleanUp cleanUp_StorageTable( "StorageTable", &StorageTable::staticMetaObject );
00102
00103 #ifndef QT_NO_TRANSLATION
00104 QString StorageTable::tr( const char *s, const char *c )
00105 {
00106 if ( qApp )
00107 return qApp->translate( "StorageTable", s, c, QApplication::DefaultCodec );
00108 else
00109 return QString::fromLatin1( s );
00110 }
00111 #ifndef QT_NO_TRANSLATION_UTF8
00112 QString StorageTable::trUtf8( const char *s, const char *c )
00113 {
00114 if ( qApp )
00115 return qApp->translate( "StorageTable", s, c, QApplication::UnicodeUTF8 );
00116 else
00117 return QString::fromUtf8( s );
00118 }
00119 #endif // QT_NO_TRANSLATION_UTF8
00120
00121 #endif // QT_NO_TRANSLATION
00122
00123 QMetaObject* StorageTable::staticMetaObject()
00124 {
00125 if ( metaObj )
00126 return metaObj;
00127 QMetaObject* parentObject = QTable::staticMetaObject();
00128 static const QUMethod slot_0 = {"clear", 0, 0 };
00129 static const QMetaData slot_tbl[] = {
00130 { "clear()", &slot_0, QMetaData::Private }
00131 };
00132 metaObj = QMetaObject::new_metaobject(
00133 "StorageTable", parentObject,
00134 slot_tbl, 1,
00135 0, 0,
00136 #ifndef QT_NO_PROPERTIES
00137 0, 0,
00138 0, 0,
00139 #endif
00140 0, 0 );
00141 cleanUp_StorageTable.setMetaObject( metaObj );
00142 return metaObj;
00143 }
00144
00145 void* StorageTable::qt_cast( const char* clname )
00146 {
00147 if ( !qstrcmp( clname, "StorageTable" ) )
00148 return this;
00149 return QTable::qt_cast( clname );
00150 }
00151
00152 bool StorageTable::qt_invoke( int _id, QUObject* _o )
00153 {
00154 switch ( _id - staticMetaObject()->slotOffset() ) {
00155 case 0: clear(); break;
00156 default:
00157 return QTable::qt_invoke( _id, _o );
00158 }
00159 return TRUE;
00160 }
00161
00162 bool StorageTable::qt_emit( int _id, QUObject* _o )
00163 {
00164 return QTable::qt_emit(_id,_o);
00165 }
00166 #ifndef QT_NO_PROPERTIES
00167
00168 bool StorageTable::qt_property( int id, int f, QVariant* v)
00169 {
00170 return QTable::qt_property( id, f, v);
00171 }
00172
00173 bool StorageTable::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
00174 #endif // QT_NO_PROPERTIES
00175
00176
00177 const char *MonitorWindow::className() const
00178 {
00179 return "MonitorWindow";
00180 }
00181
00182 QMetaObject *MonitorWindow::metaObj = 0;
00183 static QMetaObjectCleanUp cleanUp_MonitorWindow( "MonitorWindow", &MonitorWindow::staticMetaObject );
00184
00185 #ifndef QT_NO_TRANSLATION
00186 QString MonitorWindow::tr( const char *s, const char *c )
00187 {
00188 if ( qApp )
00189 return qApp->translate( "MonitorWindow", s, c, QApplication::DefaultCodec );
00190 else
00191 return QString::fromLatin1( s );
00192 }
00193 #ifndef QT_NO_TRANSLATION_UTF8
00194 QString MonitorWindow::trUtf8( const char *s, const char *c )
00195 {
00196 if ( qApp )
00197 return qApp->translate( "MonitorWindow", s, c, QApplication::UnicodeUTF8 );
00198 else
00199 return QString::fromUtf8( s );
00200 }
00201 #endif // QT_NO_TRANSLATION_UTF8
00202
00203 #endif // QT_NO_TRANSLATION
00204
00205 QMetaObject* MonitorWindow::staticMetaObject()
00206 {
00207 if ( metaObj )
00208 return metaObj;
00209 QMetaObject* parentObject = QMainWindow::staticMetaObject();
00210 static const QUParameter param_slot_0[] = {
00211 { 0, &static_QUType_bool, 0, QUParameter::Out }
00212 };
00213 static const QUMethod slot_0 = {"refresh", 1, param_slot_0 };
00214 static const QUParameter param_slot_1[] = {
00215 { "id", &static_QUType_int, 0, QUParameter::In }
00216 };
00217 static const QUMethod slot_1 = {"buttonSelected", 1, param_slot_1 };
00218 static const QUMethod slot_2 = {"generateStats", 0, 0 };
00219 static const QUMethod slot_3 = {"saveGraph", 0, 0 };
00220 static const QUParameter param_slot_4[] = {
00221 { 0, &static_QUType_int, 0, QUParameter::In }
00222 };
00223 static const QUMethod slot_4 = {"setUpdateInterval", 1, param_slot_4 };
00224 static const QMetaData slot_tbl[] = {
00225 { "refresh()", &slot_0, QMetaData::Private },
00226 { "buttonSelected(int)", &slot_1, QMetaData::Private },
00227 { "generateStats()", &slot_2, QMetaData::Private },
00228 { "saveGraph()", &slot_3, QMetaData::Private },
00229 { "setUpdateInterval(int)", &slot_4, QMetaData::Public }
00230 };
00231 static const QUMethod signal_0 = {"showQueue", 0, 0 };
00232 static const QUMethod signal_1 = {"hideQueue", 0, 0 };
00233 static const QMetaData signal_tbl[] = {
00234 { "showQueue()", &signal_0, QMetaData::Public },
00235 { "hideQueue()", &signal_1, QMetaData::Public }
00236 };
00237 metaObj = QMetaObject::new_metaobject(
00238 "MonitorWindow", parentObject,
00239 slot_tbl, 5,
00240 signal_tbl, 2,
00241 #ifndef QT_NO_PROPERTIES
00242 0, 0,
00243 0, 0,
00244 #endif
00245 0, 0 );
00246 cleanUp_MonitorWindow.setMetaObject( metaObj );
00247 return metaObj;
00248 }
00249
00250 void* MonitorWindow::qt_cast( const char* clname )
00251 {
00252 if ( !qstrcmp( clname, "MonitorWindow" ) )
00253 return this;
00254 if ( !qstrcmp( clname, "RioExplorer" ) )
00255 return (RioExplorer*)this;
00256 return QMainWindow::qt_cast( clname );
00257 }
00258
00259
00260 void MonitorWindow::showQueue()
00261 {
00262 activate_signal( staticMetaObject()->signalOffset() + 0 );
00263 }
00264
00265
00266 void MonitorWindow::hideQueue()
00267 {
00268 activate_signal( staticMetaObject()->signalOffset() + 1 );
00269 }
00270
00271 bool MonitorWindow::qt_invoke( int _id, QUObject* _o )
00272 {
00273 switch ( _id - staticMetaObject()->slotOffset() ) {
00274 case 0: static_QUType_bool.set(_o,refresh()); break;
00275 case 1: buttonSelected((int)static_QUType_int.get(_o+1)); break;
00276 case 2: generateStats(); break;
00277 case 3: saveGraph(); break;
00278 case 4: setUpdateInterval((int)static_QUType_int.get(_o+1)); break;
00279 default:
00280 return QMainWindow::qt_invoke( _id, _o );
00281 }
00282 return TRUE;
00283 }
00284
00285 bool MonitorWindow::qt_emit( int _id, QUObject* _o )
00286 {
00287 switch ( _id - staticMetaObject()->signalOffset() ) {
00288 case 0: showQueue(); break;
00289 case 1: hideQueue(); break;
00290 default:
00291 return QMainWindow::qt_emit(_id,_o);
00292 }
00293 return TRUE;
00294 }
00295 #ifndef QT_NO_PROPERTIES
00296
00297 bool MonitorWindow::qt_property( int id, int f, QVariant* v)
00298 {
00299 return QMainWindow::qt_property( id, f, v);
00300 }
00301
00302 bool MonitorWindow::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
00303 #endif // QT_NO_PROPERTIES