00001
00002
00003
00004
00005
00006
00007 #define R__DICTIONARY_FILENAME geomdIgeombuilderdIsrcdIG__GeomBuilder
00008 #include "RConfig.h"
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010
00011 #define private public
00012 #define protected public
00013 #endif
00014
00015
00016 namespace std {} using namespace std;
00017 #include "G__GeomBuilder.h"
00018
00019 #include "TClass.h"
00020 #include "TBuffer.h"
00021 #include "TMemberInspector.h"
00022 #include "TError.h"
00023
00024 #ifndef G__ROOT
00025 #define G__ROOT
00026 #endif
00027
00028 #include "RtypesImp.h"
00029 #include "TIsAProxy.h"
00030
00031
00032
00033 namespace ROOT {
00034 namespace Shadow {
00035 }
00036 }
00037
00038
00039 namespace ROOT {
00040 void TGeoTabManager_ShowMembers(void *obj, TMemberInspector &R__insp);
00041 static void delete_TGeoTabManager(void *p);
00042 static void deleteArray_TGeoTabManager(void *p);
00043 static void destruct_TGeoTabManager(void *p);
00044 static void streamer_TGeoTabManager(TBuffer &buf, void *obj);
00045
00046
00047 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTabManager*)
00048 {
00049 ::TGeoTabManager *ptr = 0;
00050 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTabManager >(0);
00051 static ::ROOT::TGenericClassInfo
00052 instance("TGeoTabManager", ::TGeoTabManager::Class_Version(), "include/TGeoTabManager.h", 54,
00053 typeid(::TGeoTabManager), DefineBehavior(ptr, ptr),
00054 &::TGeoTabManager::Dictionary, isa_proxy, 0,
00055 sizeof(::TGeoTabManager) );
00056 instance.SetDelete(&delete_TGeoTabManager);
00057 instance.SetDeleteArray(&deleteArray_TGeoTabManager);
00058 instance.SetDestructor(&destruct_TGeoTabManager);
00059 instance.SetStreamerFunc(&streamer_TGeoTabManager);
00060 return &instance;
00061 }
00062 TGenericClassInfo *GenerateInitInstance(const ::TGeoTabManager*)
00063 {
00064 return GenerateInitInstanceLocal((::TGeoTabManager*)0);
00065 }
00066
00067 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTabManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00068 }
00069
00070 namespace ROOT {
00071 void TGeoGedFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
00072 static void delete_TGeoGedFrame(void *p);
00073 static void deleteArray_TGeoGedFrame(void *p);
00074 static void destruct_TGeoGedFrame(void *p);
00075 static void streamer_TGeoGedFrame(TBuffer &buf, void *obj);
00076
00077
00078 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoGedFrame*)
00079 {
00080 ::TGeoGedFrame *ptr = 0;
00081 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoGedFrame >(0);
00082 static ::ROOT::TGenericClassInfo
00083 instance("TGeoGedFrame", ::TGeoGedFrame::Class_Version(), "include/TGeoGedFrame.h", 23,
00084 typeid(::TGeoGedFrame), DefineBehavior(ptr, ptr),
00085 &::TGeoGedFrame::Dictionary, isa_proxy, 0,
00086 sizeof(::TGeoGedFrame) );
00087 instance.SetDelete(&delete_TGeoGedFrame);
00088 instance.SetDeleteArray(&deleteArray_TGeoGedFrame);
00089 instance.SetDestructor(&destruct_TGeoGedFrame);
00090 instance.SetStreamerFunc(&streamer_TGeoGedFrame);
00091 return &instance;
00092 }
00093 TGenericClassInfo *GenerateInitInstance(const ::TGeoGedFrame*)
00094 {
00095 return GenerateInitInstanceLocal((::TGeoGedFrame*)0);
00096 }
00097
00098 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoGedFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00099 }
00100
00101 namespace ROOT {
00102 void TGeoVolumeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00103 static void *new_TGeoVolumeEditor(void *p = 0);
00104 static void *newArray_TGeoVolumeEditor(Long_t size, void *p);
00105 static void delete_TGeoVolumeEditor(void *p);
00106 static void deleteArray_TGeoVolumeEditor(void *p);
00107 static void destruct_TGeoVolumeEditor(void *p);
00108 static void streamer_TGeoVolumeEditor(TBuffer &buf, void *obj);
00109
00110
00111 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoVolumeEditor*)
00112 {
00113 ::TGeoVolumeEditor *ptr = 0;
00114 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoVolumeEditor >(0);
00115 static ::ROOT::TGenericClassInfo
00116 instance("TGeoVolumeEditor", ::TGeoVolumeEditor::Class_Version(), "include/TGeoVolumeEditor.h", 48,
00117 typeid(::TGeoVolumeEditor), DefineBehavior(ptr, ptr),
00118 &::TGeoVolumeEditor::Dictionary, isa_proxy, 0,
00119 sizeof(::TGeoVolumeEditor) );
00120 instance.SetNew(&new_TGeoVolumeEditor);
00121 instance.SetNewArray(&newArray_TGeoVolumeEditor);
00122 instance.SetDelete(&delete_TGeoVolumeEditor);
00123 instance.SetDeleteArray(&deleteArray_TGeoVolumeEditor);
00124 instance.SetDestructor(&destruct_TGeoVolumeEditor);
00125 instance.SetStreamerFunc(&streamer_TGeoVolumeEditor);
00126 return &instance;
00127 }
00128 TGenericClassInfo *GenerateInitInstance(const ::TGeoVolumeEditor*)
00129 {
00130 return GenerateInitInstanceLocal((::TGeoVolumeEditor*)0);
00131 }
00132
00133 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoVolumeEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00134 }
00135
00136 namespace ROOT {
00137 void TGeoBBoxEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00138 static void *new_TGeoBBoxEditor(void *p = 0);
00139 static void *newArray_TGeoBBoxEditor(Long_t size, void *p);
00140 static void delete_TGeoBBoxEditor(void *p);
00141 static void deleteArray_TGeoBBoxEditor(void *p);
00142 static void destruct_TGeoBBoxEditor(void *p);
00143 static void streamer_TGeoBBoxEditor(TBuffer &buf, void *obj);
00144
00145
00146 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoBBoxEditor*)
00147 {
00148 ::TGeoBBoxEditor *ptr = 0;
00149 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoBBoxEditor >(0);
00150 static ::ROOT::TGenericClassInfo
00151 instance("TGeoBBoxEditor", ::TGeoBBoxEditor::Class_Version(), "include/TGeoBBoxEditor.h", 39,
00152 typeid(::TGeoBBoxEditor), DefineBehavior(ptr, ptr),
00153 &::TGeoBBoxEditor::Dictionary, isa_proxy, 0,
00154 sizeof(::TGeoBBoxEditor) );
00155 instance.SetNew(&new_TGeoBBoxEditor);
00156 instance.SetNewArray(&newArray_TGeoBBoxEditor);
00157 instance.SetDelete(&delete_TGeoBBoxEditor);
00158 instance.SetDeleteArray(&deleteArray_TGeoBBoxEditor);
00159 instance.SetDestructor(&destruct_TGeoBBoxEditor);
00160 instance.SetStreamerFunc(&streamer_TGeoBBoxEditor);
00161 return &instance;
00162 }
00163 TGenericClassInfo *GenerateInitInstance(const ::TGeoBBoxEditor*)
00164 {
00165 return GenerateInitInstanceLocal((::TGeoBBoxEditor*)0);
00166 }
00167
00168 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoBBoxEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00169 }
00170
00171 namespace ROOT {
00172 void TGeoMediumEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00173 static void *new_TGeoMediumEditor(void *p = 0);
00174 static void *newArray_TGeoMediumEditor(Long_t size, void *p);
00175 static void delete_TGeoMediumEditor(void *p);
00176 static void deleteArray_TGeoMediumEditor(void *p);
00177 static void destruct_TGeoMediumEditor(void *p);
00178 static void streamer_TGeoMediumEditor(TBuffer &buf, void *obj);
00179
00180
00181 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoMediumEditor*)
00182 {
00183 ::TGeoMediumEditor *ptr = 0;
00184 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoMediumEditor >(0);
00185 static ::ROOT::TGenericClassInfo
00186 instance("TGeoMediumEditor", ::TGeoMediumEditor::Class_Version(), "include/TGeoMediumEditor.h", 42,
00187 typeid(::TGeoMediumEditor), DefineBehavior(ptr, ptr),
00188 &::TGeoMediumEditor::Dictionary, isa_proxy, 0,
00189 sizeof(::TGeoMediumEditor) );
00190 instance.SetNew(&new_TGeoMediumEditor);
00191 instance.SetNewArray(&newArray_TGeoMediumEditor);
00192 instance.SetDelete(&delete_TGeoMediumEditor);
00193 instance.SetDeleteArray(&deleteArray_TGeoMediumEditor);
00194 instance.SetDestructor(&destruct_TGeoMediumEditor);
00195 instance.SetStreamerFunc(&streamer_TGeoMediumEditor);
00196 return &instance;
00197 }
00198 TGenericClassInfo *GenerateInitInstance(const ::TGeoMediumEditor*)
00199 {
00200 return GenerateInitInstanceLocal((::TGeoMediumEditor*)0);
00201 }
00202
00203 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoMediumEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00204 }
00205
00206 namespace ROOT {
00207 void TGeoNodeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00208 static void *new_TGeoNodeEditor(void *p = 0);
00209 static void *newArray_TGeoNodeEditor(Long_t size, void *p);
00210 static void delete_TGeoNodeEditor(void *p);
00211 static void deleteArray_TGeoNodeEditor(void *p);
00212 static void destruct_TGeoNodeEditor(void *p);
00213 static void streamer_TGeoNodeEditor(TBuffer &buf, void *obj);
00214
00215
00216 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoNodeEditor*)
00217 {
00218 ::TGeoNodeEditor *ptr = 0;
00219 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoNodeEditor >(0);
00220 static ::ROOT::TGenericClassInfo
00221 instance("TGeoNodeEditor", ::TGeoNodeEditor::Class_Version(), "include/TGeoNodeEditor.h", 42,
00222 typeid(::TGeoNodeEditor), DefineBehavior(ptr, ptr),
00223 &::TGeoNodeEditor::Dictionary, isa_proxy, 0,
00224 sizeof(::TGeoNodeEditor) );
00225 instance.SetNew(&new_TGeoNodeEditor);
00226 instance.SetNewArray(&newArray_TGeoNodeEditor);
00227 instance.SetDelete(&delete_TGeoNodeEditor);
00228 instance.SetDeleteArray(&deleteArray_TGeoNodeEditor);
00229 instance.SetDestructor(&destruct_TGeoNodeEditor);
00230 instance.SetStreamerFunc(&streamer_TGeoNodeEditor);
00231 return &instance;
00232 }
00233 TGenericClassInfo *GenerateInitInstance(const ::TGeoNodeEditor*)
00234 {
00235 return GenerateInitInstanceLocal((::TGeoNodeEditor*)0);
00236 }
00237
00238 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoNodeEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00239 }
00240
00241 namespace ROOT {
00242 void TGeoTranslationEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00243 static void *new_TGeoTranslationEditor(void *p = 0);
00244 static void *newArray_TGeoTranslationEditor(Long_t size, void *p);
00245 static void delete_TGeoTranslationEditor(void *p);
00246 static void deleteArray_TGeoTranslationEditor(void *p);
00247 static void destruct_TGeoTranslationEditor(void *p);
00248 static void streamer_TGeoTranslationEditor(TBuffer &buf, void *obj);
00249
00250
00251 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTranslationEditor*)
00252 {
00253 ::TGeoTranslationEditor *ptr = 0;
00254 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTranslationEditor >(0);
00255 static ::ROOT::TGenericClassInfo
00256 instance("TGeoTranslationEditor", ::TGeoTranslationEditor::Class_Version(), "include/TGeoMatrixEditor.h", 41,
00257 typeid(::TGeoTranslationEditor), DefineBehavior(ptr, ptr),
00258 &::TGeoTranslationEditor::Dictionary, isa_proxy, 0,
00259 sizeof(::TGeoTranslationEditor) );
00260 instance.SetNew(&new_TGeoTranslationEditor);
00261 instance.SetNewArray(&newArray_TGeoTranslationEditor);
00262 instance.SetDelete(&delete_TGeoTranslationEditor);
00263 instance.SetDeleteArray(&deleteArray_TGeoTranslationEditor);
00264 instance.SetDestructor(&destruct_TGeoTranslationEditor);
00265 instance.SetStreamerFunc(&streamer_TGeoTranslationEditor);
00266 return &instance;
00267 }
00268 TGenericClassInfo *GenerateInitInstance(const ::TGeoTranslationEditor*)
00269 {
00270 return GenerateInitInstanceLocal((::TGeoTranslationEditor*)0);
00271 }
00272
00273 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTranslationEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00274 }
00275
00276 namespace ROOT {
00277 void TGeoRotationEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00278 static void *new_TGeoRotationEditor(void *p = 0);
00279 static void *newArray_TGeoRotationEditor(Long_t size, void *p);
00280 static void delete_TGeoRotationEditor(void *p);
00281 static void deleteArray_TGeoRotationEditor(void *p);
00282 static void destruct_TGeoRotationEditor(void *p);
00283 static void streamer_TGeoRotationEditor(TBuffer &buf, void *obj);
00284
00285
00286 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoRotationEditor*)
00287 {
00288 ::TGeoRotationEditor *ptr = 0;
00289 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoRotationEditor >(0);
00290 static ::ROOT::TGenericClassInfo
00291 instance("TGeoRotationEditor", ::TGeoRotationEditor::Class_Version(), "include/TGeoMatrixEditor.h", 91,
00292 typeid(::TGeoRotationEditor), DefineBehavior(ptr, ptr),
00293 &::TGeoRotationEditor::Dictionary, isa_proxy, 0,
00294 sizeof(::TGeoRotationEditor) );
00295 instance.SetNew(&new_TGeoRotationEditor);
00296 instance.SetNewArray(&newArray_TGeoRotationEditor);
00297 instance.SetDelete(&delete_TGeoRotationEditor);
00298 instance.SetDeleteArray(&deleteArray_TGeoRotationEditor);
00299 instance.SetDestructor(&destruct_TGeoRotationEditor);
00300 instance.SetStreamerFunc(&streamer_TGeoRotationEditor);
00301 return &instance;
00302 }
00303 TGenericClassInfo *GenerateInitInstance(const ::TGeoRotationEditor*)
00304 {
00305 return GenerateInitInstanceLocal((::TGeoRotationEditor*)0);
00306 }
00307
00308 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoRotationEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00309 }
00310
00311 namespace ROOT {
00312 void TGeoCombiTransEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00313 static void *new_TGeoCombiTransEditor(void *p = 0);
00314 static void *newArray_TGeoCombiTransEditor(Long_t size, void *p);
00315 static void delete_TGeoCombiTransEditor(void *p);
00316 static void deleteArray_TGeoCombiTransEditor(void *p);
00317 static void destruct_TGeoCombiTransEditor(void *p);
00318 static void streamer_TGeoCombiTransEditor(TBuffer &buf, void *obj);
00319
00320
00321 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoCombiTransEditor*)
00322 {
00323 ::TGeoCombiTransEditor *ptr = 0;
00324 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoCombiTransEditor >(0);
00325 static ::ROOT::TGenericClassInfo
00326 instance("TGeoCombiTransEditor", ::TGeoCombiTransEditor::Class_Version(), "include/TGeoMatrixEditor.h", 149,
00327 typeid(::TGeoCombiTransEditor), DefineBehavior(ptr, ptr),
00328 &::TGeoCombiTransEditor::Dictionary, isa_proxy, 0,
00329 sizeof(::TGeoCombiTransEditor) );
00330 instance.SetNew(&new_TGeoCombiTransEditor);
00331 instance.SetNewArray(&newArray_TGeoCombiTransEditor);
00332 instance.SetDelete(&delete_TGeoCombiTransEditor);
00333 instance.SetDeleteArray(&deleteArray_TGeoCombiTransEditor);
00334 instance.SetDestructor(&destruct_TGeoCombiTransEditor);
00335 instance.SetStreamerFunc(&streamer_TGeoCombiTransEditor);
00336 return &instance;
00337 }
00338 TGenericClassInfo *GenerateInitInstance(const ::TGeoCombiTransEditor*)
00339 {
00340 return GenerateInitInstanceLocal((::TGeoCombiTransEditor*)0);
00341 }
00342
00343 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoCombiTransEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00344 }
00345
00346 namespace ROOT {
00347 void TGeoManagerEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00348 static void *new_TGeoManagerEditor(void *p = 0);
00349 static void *newArray_TGeoManagerEditor(Long_t size, void *p);
00350 static void delete_TGeoManagerEditor(void *p);
00351 static void deleteArray_TGeoManagerEditor(void *p);
00352 static void destruct_TGeoManagerEditor(void *p);
00353 static void streamer_TGeoManagerEditor(TBuffer &buf, void *obj);
00354
00355
00356 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoManagerEditor*)
00357 {
00358 ::TGeoManagerEditor *ptr = 0;
00359 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoManagerEditor >(0);
00360 static ::ROOT::TGenericClassInfo
00361 instance("TGeoManagerEditor", ::TGeoManagerEditor::Class_Version(), "include/TGeoManagerEditor.h", 48,
00362 typeid(::TGeoManagerEditor), DefineBehavior(ptr, ptr),
00363 &::TGeoManagerEditor::Dictionary, isa_proxy, 0,
00364 sizeof(::TGeoManagerEditor) );
00365 instance.SetNew(&new_TGeoManagerEditor);
00366 instance.SetNewArray(&newArray_TGeoManagerEditor);
00367 instance.SetDelete(&delete_TGeoManagerEditor);
00368 instance.SetDeleteArray(&deleteArray_TGeoManagerEditor);
00369 instance.SetDestructor(&destruct_TGeoManagerEditor);
00370 instance.SetStreamerFunc(&streamer_TGeoManagerEditor);
00371 return &instance;
00372 }
00373 TGenericClassInfo *GenerateInitInstance(const ::TGeoManagerEditor*)
00374 {
00375 return GenerateInitInstanceLocal((::TGeoManagerEditor*)0);
00376 }
00377
00378 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoManagerEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00379 }
00380
00381 namespace ROOT {
00382 void TGeoTubeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00383 static void *new_TGeoTubeEditor(void *p = 0);
00384 static void *newArray_TGeoTubeEditor(Long_t size, void *p);
00385 static void delete_TGeoTubeEditor(void *p);
00386 static void deleteArray_TGeoTubeEditor(void *p);
00387 static void destruct_TGeoTubeEditor(void *p);
00388 static void streamer_TGeoTubeEditor(TBuffer &buf, void *obj);
00389
00390
00391 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTubeEditor*)
00392 {
00393 ::TGeoTubeEditor *ptr = 0;
00394 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTubeEditor >(0);
00395 static ::ROOT::TGenericClassInfo
00396 instance("TGeoTubeEditor", ::TGeoTubeEditor::Class_Version(), "include/TGeoTubeEditor.h", 39,
00397 typeid(::TGeoTubeEditor), DefineBehavior(ptr, ptr),
00398 &::TGeoTubeEditor::Dictionary, isa_proxy, 0,
00399 sizeof(::TGeoTubeEditor) );
00400 instance.SetNew(&new_TGeoTubeEditor);
00401 instance.SetNewArray(&newArray_TGeoTubeEditor);
00402 instance.SetDelete(&delete_TGeoTubeEditor);
00403 instance.SetDeleteArray(&deleteArray_TGeoTubeEditor);
00404 instance.SetDestructor(&destruct_TGeoTubeEditor);
00405 instance.SetStreamerFunc(&streamer_TGeoTubeEditor);
00406 return &instance;
00407 }
00408 TGenericClassInfo *GenerateInitInstance(const ::TGeoTubeEditor*)
00409 {
00410 return GenerateInitInstanceLocal((::TGeoTubeEditor*)0);
00411 }
00412
00413 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTubeEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00414 }
00415
00416 namespace ROOT {
00417 void TGeoTubeSegEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00418 static void *new_TGeoTubeSegEditor(void *p = 0);
00419 static void *newArray_TGeoTubeSegEditor(Long_t size, void *p);
00420 static void delete_TGeoTubeSegEditor(void *p);
00421 static void deleteArray_TGeoTubeSegEditor(void *p);
00422 static void destruct_TGeoTubeSegEditor(void *p);
00423 static void streamer_TGeoTubeSegEditor(TBuffer &buf, void *obj);
00424
00425
00426 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTubeSegEditor*)
00427 {
00428 ::TGeoTubeSegEditor *ptr = 0;
00429 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTubeSegEditor >(0);
00430 static ::ROOT::TGenericClassInfo
00431 instance("TGeoTubeSegEditor", ::TGeoTubeSegEditor::Class_Version(), "include/TGeoTubeEditor.h", 93,
00432 typeid(::TGeoTubeSegEditor), DefineBehavior(ptr, ptr),
00433 &::TGeoTubeSegEditor::Dictionary, isa_proxy, 0,
00434 sizeof(::TGeoTubeSegEditor) );
00435 instance.SetNew(&new_TGeoTubeSegEditor);
00436 instance.SetNewArray(&newArray_TGeoTubeSegEditor);
00437 instance.SetDelete(&delete_TGeoTubeSegEditor);
00438 instance.SetDeleteArray(&deleteArray_TGeoTubeSegEditor);
00439 instance.SetDestructor(&destruct_TGeoTubeSegEditor);
00440 instance.SetStreamerFunc(&streamer_TGeoTubeSegEditor);
00441 return &instance;
00442 }
00443 TGenericClassInfo *GenerateInitInstance(const ::TGeoTubeSegEditor*)
00444 {
00445 return GenerateInitInstanceLocal((::TGeoTubeSegEditor*)0);
00446 }
00447
00448 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTubeSegEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00449 }
00450
00451 namespace ROOT {
00452 void TGeoCtubEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00453 static void *new_TGeoCtubEditor(void *p = 0);
00454 static void *newArray_TGeoCtubEditor(Long_t size, void *p);
00455 static void delete_TGeoCtubEditor(void *p);
00456 static void deleteArray_TGeoCtubEditor(void *p);
00457 static void destruct_TGeoCtubEditor(void *p);
00458 static void streamer_TGeoCtubEditor(TBuffer &buf, void *obj);
00459
00460
00461 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoCtubEditor*)
00462 {
00463 ::TGeoCtubEditor *ptr = 0;
00464 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoCtubEditor >(0);
00465 static ::ROOT::TGenericClassInfo
00466 instance("TGeoCtubEditor", ::TGeoCtubEditor::Class_Version(), "include/TGeoTubeEditor.h", 131,
00467 typeid(::TGeoCtubEditor), DefineBehavior(ptr, ptr),
00468 &::TGeoCtubEditor::Dictionary, isa_proxy, 0,
00469 sizeof(::TGeoCtubEditor) );
00470 instance.SetNew(&new_TGeoCtubEditor);
00471 instance.SetNewArray(&newArray_TGeoCtubEditor);
00472 instance.SetDelete(&delete_TGeoCtubEditor);
00473 instance.SetDeleteArray(&deleteArray_TGeoCtubEditor);
00474 instance.SetDestructor(&destruct_TGeoCtubEditor);
00475 instance.SetStreamerFunc(&streamer_TGeoCtubEditor);
00476 return &instance;
00477 }
00478 TGenericClassInfo *GenerateInitInstance(const ::TGeoCtubEditor*)
00479 {
00480 return GenerateInitInstanceLocal((::TGeoCtubEditor*)0);
00481 }
00482
00483 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoCtubEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00484 }
00485
00486 namespace ROOT {
00487 void TGeoConeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00488 static void *new_TGeoConeEditor(void *p = 0);
00489 static void *newArray_TGeoConeEditor(Long_t size, void *p);
00490 static void delete_TGeoConeEditor(void *p);
00491 static void deleteArray_TGeoConeEditor(void *p);
00492 static void destruct_TGeoConeEditor(void *p);
00493 static void streamer_TGeoConeEditor(TBuffer &buf, void *obj);
00494
00495
00496 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoConeEditor*)
00497 {
00498 ::TGeoConeEditor *ptr = 0;
00499 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoConeEditor >(0);
00500 static ::ROOT::TGenericClassInfo
00501 instance("TGeoConeEditor", ::TGeoConeEditor::Class_Version(), "include/TGeoConeEditor.h", 40,
00502 typeid(::TGeoConeEditor), DefineBehavior(ptr, ptr),
00503 &::TGeoConeEditor::Dictionary, isa_proxy, 0,
00504 sizeof(::TGeoConeEditor) );
00505 instance.SetNew(&new_TGeoConeEditor);
00506 instance.SetNewArray(&newArray_TGeoConeEditor);
00507 instance.SetDelete(&delete_TGeoConeEditor);
00508 instance.SetDeleteArray(&deleteArray_TGeoConeEditor);
00509 instance.SetDestructor(&destruct_TGeoConeEditor);
00510 instance.SetStreamerFunc(&streamer_TGeoConeEditor);
00511 return &instance;
00512 }
00513 TGenericClassInfo *GenerateInitInstance(const ::TGeoConeEditor*)
00514 {
00515 return GenerateInitInstanceLocal((::TGeoConeEditor*)0);
00516 }
00517
00518 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoConeEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00519 }
00520
00521 namespace ROOT {
00522 void TGeoConeSegEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00523 static void *new_TGeoConeSegEditor(void *p = 0);
00524 static void *newArray_TGeoConeSegEditor(Long_t size, void *p);
00525 static void delete_TGeoConeSegEditor(void *p);
00526 static void deleteArray_TGeoConeSegEditor(void *p);
00527 static void destruct_TGeoConeSegEditor(void *p);
00528 static void streamer_TGeoConeSegEditor(TBuffer &buf, void *obj);
00529
00530
00531 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoConeSegEditor*)
00532 {
00533 ::TGeoConeSegEditor *ptr = 0;
00534 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoConeSegEditor >(0);
00535 static ::ROOT::TGenericClassInfo
00536 instance("TGeoConeSegEditor", ::TGeoConeSegEditor::Class_Version(), "include/TGeoConeEditor.h", 99,
00537 typeid(::TGeoConeSegEditor), DefineBehavior(ptr, ptr),
00538 &::TGeoConeSegEditor::Dictionary, isa_proxy, 0,
00539 sizeof(::TGeoConeSegEditor) );
00540 instance.SetNew(&new_TGeoConeSegEditor);
00541 instance.SetNewArray(&newArray_TGeoConeSegEditor);
00542 instance.SetDelete(&delete_TGeoConeSegEditor);
00543 instance.SetDeleteArray(&deleteArray_TGeoConeSegEditor);
00544 instance.SetDestructor(&destruct_TGeoConeSegEditor);
00545 instance.SetStreamerFunc(&streamer_TGeoConeSegEditor);
00546 return &instance;
00547 }
00548 TGenericClassInfo *GenerateInitInstance(const ::TGeoConeSegEditor*)
00549 {
00550 return GenerateInitInstanceLocal((::TGeoConeSegEditor*)0);
00551 }
00552
00553 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoConeSegEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00554 }
00555
00556 namespace ROOT {
00557 void TGeoTrd1Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
00558 static void *new_TGeoTrd1Editor(void *p = 0);
00559 static void *newArray_TGeoTrd1Editor(Long_t size, void *p);
00560 static void delete_TGeoTrd1Editor(void *p);
00561 static void deleteArray_TGeoTrd1Editor(void *p);
00562 static void destruct_TGeoTrd1Editor(void *p);
00563 static void streamer_TGeoTrd1Editor(TBuffer &buf, void *obj);
00564
00565
00566 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTrd1Editor*)
00567 {
00568 ::TGeoTrd1Editor *ptr = 0;
00569 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTrd1Editor >(0);
00570 static ::ROOT::TGenericClassInfo
00571 instance("TGeoTrd1Editor", ::TGeoTrd1Editor::Class_Version(), "include/TGeoTrd1Editor.h", 39,
00572 typeid(::TGeoTrd1Editor), DefineBehavior(ptr, ptr),
00573 &::TGeoTrd1Editor::Dictionary, isa_proxy, 0,
00574 sizeof(::TGeoTrd1Editor) );
00575 instance.SetNew(&new_TGeoTrd1Editor);
00576 instance.SetNewArray(&newArray_TGeoTrd1Editor);
00577 instance.SetDelete(&delete_TGeoTrd1Editor);
00578 instance.SetDeleteArray(&deleteArray_TGeoTrd1Editor);
00579 instance.SetDestructor(&destruct_TGeoTrd1Editor);
00580 instance.SetStreamerFunc(&streamer_TGeoTrd1Editor);
00581 return &instance;
00582 }
00583 TGenericClassInfo *GenerateInitInstance(const ::TGeoTrd1Editor*)
00584 {
00585 return GenerateInitInstanceLocal((::TGeoTrd1Editor*)0);
00586 }
00587
00588 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTrd1Editor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00589 }
00590
00591 namespace ROOT {
00592 void TGeoTrd2Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
00593 static void *new_TGeoTrd2Editor(void *p = 0);
00594 static void *newArray_TGeoTrd2Editor(Long_t size, void *p);
00595 static void delete_TGeoTrd2Editor(void *p);
00596 static void deleteArray_TGeoTrd2Editor(void *p);
00597 static void destruct_TGeoTrd2Editor(void *p);
00598 static void streamer_TGeoTrd2Editor(TBuffer &buf, void *obj);
00599
00600
00601 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTrd2Editor*)
00602 {
00603 ::TGeoTrd2Editor *ptr = 0;
00604 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTrd2Editor >(0);
00605 static ::ROOT::TGenericClassInfo
00606 instance("TGeoTrd2Editor", ::TGeoTrd2Editor::Class_Version(), "include/TGeoTrd2Editor.h", 39,
00607 typeid(::TGeoTrd2Editor), DefineBehavior(ptr, ptr),
00608 &::TGeoTrd2Editor::Dictionary, isa_proxy, 0,
00609 sizeof(::TGeoTrd2Editor) );
00610 instance.SetNew(&new_TGeoTrd2Editor);
00611 instance.SetNewArray(&newArray_TGeoTrd2Editor);
00612 instance.SetDelete(&delete_TGeoTrd2Editor);
00613 instance.SetDeleteArray(&deleteArray_TGeoTrd2Editor);
00614 instance.SetDestructor(&destruct_TGeoTrd2Editor);
00615 instance.SetStreamerFunc(&streamer_TGeoTrd2Editor);
00616 return &instance;
00617 }
00618 TGenericClassInfo *GenerateInitInstance(const ::TGeoTrd2Editor*)
00619 {
00620 return GenerateInitInstanceLocal((::TGeoTrd2Editor*)0);
00621 }
00622
00623 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTrd2Editor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00624 }
00625
00626 namespace ROOT {
00627 void TGeoMaterialEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00628 static void *new_TGeoMaterialEditor(void *p = 0);
00629 static void *newArray_TGeoMaterialEditor(Long_t size, void *p);
00630 static void delete_TGeoMaterialEditor(void *p);
00631 static void deleteArray_TGeoMaterialEditor(void *p);
00632 static void destruct_TGeoMaterialEditor(void *p);
00633 static void streamer_TGeoMaterialEditor(TBuffer &buf, void *obj);
00634
00635
00636 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoMaterialEditor*)
00637 {
00638 ::TGeoMaterialEditor *ptr = 0;
00639 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoMaterialEditor >(0);
00640 static ::ROOT::TGenericClassInfo
00641 instance("TGeoMaterialEditor", ::TGeoMaterialEditor::Class_Version(), "include/TGeoMaterialEditor.h", 39,
00642 typeid(::TGeoMaterialEditor), DefineBehavior(ptr, ptr),
00643 &::TGeoMaterialEditor::Dictionary, isa_proxy, 0,
00644 sizeof(::TGeoMaterialEditor) );
00645 instance.SetNew(&new_TGeoMaterialEditor);
00646 instance.SetNewArray(&newArray_TGeoMaterialEditor);
00647 instance.SetDelete(&delete_TGeoMaterialEditor);
00648 instance.SetDeleteArray(&deleteArray_TGeoMaterialEditor);
00649 instance.SetDestructor(&destruct_TGeoMaterialEditor);
00650 instance.SetStreamerFunc(&streamer_TGeoMaterialEditor);
00651 return &instance;
00652 }
00653 TGenericClassInfo *GenerateInitInstance(const ::TGeoMaterialEditor*)
00654 {
00655 return GenerateInitInstanceLocal((::TGeoMaterialEditor*)0);
00656 }
00657
00658 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoMaterialEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00659 }
00660
00661 namespace ROOT {
00662 void TGeoMixtureEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00663 static void *new_TGeoMixtureEditor(void *p = 0);
00664 static void *newArray_TGeoMixtureEditor(Long_t size, void *p);
00665 static void delete_TGeoMixtureEditor(void *p);
00666 static void deleteArray_TGeoMixtureEditor(void *p);
00667 static void destruct_TGeoMixtureEditor(void *p);
00668 static void streamer_TGeoMixtureEditor(TBuffer &buf, void *obj);
00669
00670
00671 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoMixtureEditor*)
00672 {
00673 ::TGeoMixtureEditor *ptr = 0;
00674 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoMixtureEditor >(0);
00675 static ::ROOT::TGenericClassInfo
00676 instance("TGeoMixtureEditor", ::TGeoMixtureEditor::Class_Version(), "include/TGeoMaterialEditor.h", 103,
00677 typeid(::TGeoMixtureEditor), DefineBehavior(ptr, ptr),
00678 &::TGeoMixtureEditor::Dictionary, isa_proxy, 0,
00679 sizeof(::TGeoMixtureEditor) );
00680 instance.SetNew(&new_TGeoMixtureEditor);
00681 instance.SetNewArray(&newArray_TGeoMixtureEditor);
00682 instance.SetDelete(&delete_TGeoMixtureEditor);
00683 instance.SetDeleteArray(&deleteArray_TGeoMixtureEditor);
00684 instance.SetDestructor(&destruct_TGeoMixtureEditor);
00685 instance.SetStreamerFunc(&streamer_TGeoMixtureEditor);
00686 return &instance;
00687 }
00688 TGenericClassInfo *GenerateInitInstance(const ::TGeoMixtureEditor*)
00689 {
00690 return GenerateInitInstanceLocal((::TGeoMixtureEditor*)0);
00691 }
00692
00693 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoMixtureEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00694 }
00695
00696 namespace ROOT {
00697 void TGeoTreeDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
00698 static void delete_TGeoTreeDialog(void *p);
00699 static void deleteArray_TGeoTreeDialog(void *p);
00700 static void destruct_TGeoTreeDialog(void *p);
00701 static void streamer_TGeoTreeDialog(TBuffer &buf, void *obj);
00702
00703
00704 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTreeDialog*)
00705 {
00706 ::TGeoTreeDialog *ptr = 0;
00707 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTreeDialog >(0);
00708 static ::ROOT::TGenericClassInfo
00709 instance("TGeoTreeDialog", ::TGeoTreeDialog::Class_Version(), "include/TGeoTabManager.h", 104,
00710 typeid(::TGeoTreeDialog), DefineBehavior(ptr, ptr),
00711 &::TGeoTreeDialog::Dictionary, isa_proxy, 0,
00712 sizeof(::TGeoTreeDialog) );
00713 instance.SetDelete(&delete_TGeoTreeDialog);
00714 instance.SetDeleteArray(&deleteArray_TGeoTreeDialog);
00715 instance.SetDestructor(&destruct_TGeoTreeDialog);
00716 instance.SetStreamerFunc(&streamer_TGeoTreeDialog);
00717 return &instance;
00718 }
00719 TGenericClassInfo *GenerateInitInstance(const ::TGeoTreeDialog*)
00720 {
00721 return GenerateInitInstanceLocal((::TGeoTreeDialog*)0);
00722 }
00723
00724 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTreeDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00725 }
00726
00727 namespace ROOT {
00728 void TGeoTransientPanel_ShowMembers(void *obj, TMemberInspector &R__insp);
00729 static void delete_TGeoTransientPanel(void *p);
00730 static void deleteArray_TGeoTransientPanel(void *p);
00731 static void destruct_TGeoTransientPanel(void *p);
00732 static void streamer_TGeoTransientPanel(TBuffer &buf, void *obj);
00733
00734
00735 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTransientPanel*)
00736 {
00737 ::TGeoTransientPanel *ptr = 0;
00738 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTransientPanel >(0);
00739 static ::ROOT::TGenericClassInfo
00740 instance("TGeoTransientPanel", ::TGeoTransientPanel::Class_Version(), "include/TGeoTabManager.h", 262,
00741 typeid(::TGeoTransientPanel), DefineBehavior(ptr, ptr),
00742 &::TGeoTransientPanel::Dictionary, isa_proxy, 0,
00743 sizeof(::TGeoTransientPanel) );
00744 instance.SetDelete(&delete_TGeoTransientPanel);
00745 instance.SetDeleteArray(&deleteArray_TGeoTransientPanel);
00746 instance.SetDestructor(&destruct_TGeoTransientPanel);
00747 instance.SetStreamerFunc(&streamer_TGeoTransientPanel);
00748 return &instance;
00749 }
00750 TGenericClassInfo *GenerateInitInstance(const ::TGeoTransientPanel*)
00751 {
00752 return GenerateInitInstanceLocal((::TGeoTransientPanel*)0);
00753 }
00754
00755 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTransientPanel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00756 }
00757
00758 namespace ROOT {
00759 void TGeoVolumeDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
00760 static void delete_TGeoVolumeDialog(void *p);
00761 static void deleteArray_TGeoVolumeDialog(void *p);
00762 static void destruct_TGeoVolumeDialog(void *p);
00763 static void streamer_TGeoVolumeDialog(TBuffer &buf, void *obj);
00764
00765
00766 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoVolumeDialog*)
00767 {
00768 ::TGeoVolumeDialog *ptr = 0;
00769 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoVolumeDialog >(0);
00770 static ::ROOT::TGenericClassInfo
00771 instance("TGeoVolumeDialog", ::TGeoVolumeDialog::Class_Version(), "include/TGeoTabManager.h", 137,
00772 typeid(::TGeoVolumeDialog), DefineBehavior(ptr, ptr),
00773 &::TGeoVolumeDialog::Dictionary, isa_proxy, 0,
00774 sizeof(::TGeoVolumeDialog) );
00775 instance.SetDelete(&delete_TGeoVolumeDialog);
00776 instance.SetDeleteArray(&deleteArray_TGeoVolumeDialog);
00777 instance.SetDestructor(&destruct_TGeoVolumeDialog);
00778 instance.SetStreamerFunc(&streamer_TGeoVolumeDialog);
00779 return &instance;
00780 }
00781 TGenericClassInfo *GenerateInitInstance(const ::TGeoVolumeDialog*)
00782 {
00783 return GenerateInitInstanceLocal((::TGeoVolumeDialog*)0);
00784 }
00785
00786 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoVolumeDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00787 }
00788
00789 namespace ROOT {
00790 void TGeoShapeDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
00791 static void delete_TGeoShapeDialog(void *p);
00792 static void deleteArray_TGeoShapeDialog(void *p);
00793 static void destruct_TGeoShapeDialog(void *p);
00794 static void streamer_TGeoShapeDialog(TBuffer &buf, void *obj);
00795
00796
00797 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoShapeDialog*)
00798 {
00799 ::TGeoShapeDialog *ptr = 0;
00800 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoShapeDialog >(0);
00801 static ::ROOT::TGenericClassInfo
00802 instance("TGeoShapeDialog", ::TGeoShapeDialog::Class_Version(), "include/TGeoTabManager.h", 162,
00803 typeid(::TGeoShapeDialog), DefineBehavior(ptr, ptr),
00804 &::TGeoShapeDialog::Dictionary, isa_proxy, 0,
00805 sizeof(::TGeoShapeDialog) );
00806 instance.SetDelete(&delete_TGeoShapeDialog);
00807 instance.SetDeleteArray(&deleteArray_TGeoShapeDialog);
00808 instance.SetDestructor(&destruct_TGeoShapeDialog);
00809 instance.SetStreamerFunc(&streamer_TGeoShapeDialog);
00810 return &instance;
00811 }
00812 TGenericClassInfo *GenerateInitInstance(const ::TGeoShapeDialog*)
00813 {
00814 return GenerateInitInstanceLocal((::TGeoShapeDialog*)0);
00815 }
00816
00817 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoShapeDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00818 }
00819
00820 namespace ROOT {
00821 void TGeoMediumDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
00822 static void delete_TGeoMediumDialog(void *p);
00823 static void deleteArray_TGeoMediumDialog(void *p);
00824 static void destruct_TGeoMediumDialog(void *p);
00825 static void streamer_TGeoMediumDialog(TBuffer &buf, void *obj);
00826
00827
00828 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoMediumDialog*)
00829 {
00830 ::TGeoMediumDialog *ptr = 0;
00831 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoMediumDialog >(0);
00832 static ::ROOT::TGenericClassInfo
00833 instance("TGeoMediumDialog", ::TGeoMediumDialog::Class_Version(), "include/TGeoTabManager.h", 187,
00834 typeid(::TGeoMediumDialog), DefineBehavior(ptr, ptr),
00835 &::TGeoMediumDialog::Dictionary, isa_proxy, 0,
00836 sizeof(::TGeoMediumDialog) );
00837 instance.SetDelete(&delete_TGeoMediumDialog);
00838 instance.SetDeleteArray(&deleteArray_TGeoMediumDialog);
00839 instance.SetDestructor(&destruct_TGeoMediumDialog);
00840 instance.SetStreamerFunc(&streamer_TGeoMediumDialog);
00841 return &instance;
00842 }
00843 TGenericClassInfo *GenerateInitInstance(const ::TGeoMediumDialog*)
00844 {
00845 return GenerateInitInstanceLocal((::TGeoMediumDialog*)0);
00846 }
00847
00848 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoMediumDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00849 }
00850
00851 namespace ROOT {
00852 void TGeoMaterialDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
00853 static void delete_TGeoMaterialDialog(void *p);
00854 static void deleteArray_TGeoMaterialDialog(void *p);
00855 static void destruct_TGeoMaterialDialog(void *p);
00856 static void streamer_TGeoMaterialDialog(TBuffer &buf, void *obj);
00857
00858
00859 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoMaterialDialog*)
00860 {
00861 ::TGeoMaterialDialog *ptr = 0;
00862 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoMaterialDialog >(0);
00863 static ::ROOT::TGenericClassInfo
00864 instance("TGeoMaterialDialog", ::TGeoMaterialDialog::Class_Version(), "include/TGeoTabManager.h", 212,
00865 typeid(::TGeoMaterialDialog), DefineBehavior(ptr, ptr),
00866 &::TGeoMaterialDialog::Dictionary, isa_proxy, 0,
00867 sizeof(::TGeoMaterialDialog) );
00868 instance.SetDelete(&delete_TGeoMaterialDialog);
00869 instance.SetDeleteArray(&deleteArray_TGeoMaterialDialog);
00870 instance.SetDestructor(&destruct_TGeoMaterialDialog);
00871 instance.SetStreamerFunc(&streamer_TGeoMaterialDialog);
00872 return &instance;
00873 }
00874 TGenericClassInfo *GenerateInitInstance(const ::TGeoMaterialDialog*)
00875 {
00876 return GenerateInitInstanceLocal((::TGeoMaterialDialog*)0);
00877 }
00878
00879 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoMaterialDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00880 }
00881
00882 namespace ROOT {
00883 void TGeoMatrixDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
00884 static void delete_TGeoMatrixDialog(void *p);
00885 static void deleteArray_TGeoMatrixDialog(void *p);
00886 static void destruct_TGeoMatrixDialog(void *p);
00887 static void streamer_TGeoMatrixDialog(TBuffer &buf, void *obj);
00888
00889
00890 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoMatrixDialog*)
00891 {
00892 ::TGeoMatrixDialog *ptr = 0;
00893 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoMatrixDialog >(0);
00894 static ::ROOT::TGenericClassInfo
00895 instance("TGeoMatrixDialog", ::TGeoMatrixDialog::Class_Version(), "include/TGeoTabManager.h", 237,
00896 typeid(::TGeoMatrixDialog), DefineBehavior(ptr, ptr),
00897 &::TGeoMatrixDialog::Dictionary, isa_proxy, 0,
00898 sizeof(::TGeoMatrixDialog) );
00899 instance.SetDelete(&delete_TGeoMatrixDialog);
00900 instance.SetDeleteArray(&deleteArray_TGeoMatrixDialog);
00901 instance.SetDestructor(&destruct_TGeoMatrixDialog);
00902 instance.SetStreamerFunc(&streamer_TGeoMatrixDialog);
00903 return &instance;
00904 }
00905 TGenericClassInfo *GenerateInitInstance(const ::TGeoMatrixDialog*)
00906 {
00907 return GenerateInitInstanceLocal((::TGeoMatrixDialog*)0);
00908 }
00909
00910 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoMatrixDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00911 }
00912
00913 namespace ROOT {
00914 void TGeoSphereEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00915 static void *new_TGeoSphereEditor(void *p = 0);
00916 static void *newArray_TGeoSphereEditor(Long_t size, void *p);
00917 static void delete_TGeoSphereEditor(void *p);
00918 static void deleteArray_TGeoSphereEditor(void *p);
00919 static void destruct_TGeoSphereEditor(void *p);
00920 static void streamer_TGeoSphereEditor(TBuffer &buf, void *obj);
00921
00922
00923 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoSphereEditor*)
00924 {
00925 ::TGeoSphereEditor *ptr = 0;
00926 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoSphereEditor >(0);
00927 static ::ROOT::TGenericClassInfo
00928 instance("TGeoSphereEditor", ::TGeoSphereEditor::Class_Version(), "include/TGeoSphereEditor.h", 40,
00929 typeid(::TGeoSphereEditor), DefineBehavior(ptr, ptr),
00930 &::TGeoSphereEditor::Dictionary, isa_proxy, 0,
00931 sizeof(::TGeoSphereEditor) );
00932 instance.SetNew(&new_TGeoSphereEditor);
00933 instance.SetNewArray(&newArray_TGeoSphereEditor);
00934 instance.SetDelete(&delete_TGeoSphereEditor);
00935 instance.SetDeleteArray(&deleteArray_TGeoSphereEditor);
00936 instance.SetDestructor(&destruct_TGeoSphereEditor);
00937 instance.SetStreamerFunc(&streamer_TGeoSphereEditor);
00938 return &instance;
00939 }
00940 TGenericClassInfo *GenerateInitInstance(const ::TGeoSphereEditor*)
00941 {
00942 return GenerateInitInstanceLocal((::TGeoSphereEditor*)0);
00943 }
00944
00945 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoSphereEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00946 }
00947
00948 namespace ROOT {
00949 void TGeoPconSection_ShowMembers(void *obj, TMemberInspector &R__insp);
00950 static void delete_TGeoPconSection(void *p);
00951 static void deleteArray_TGeoPconSection(void *p);
00952 static void destruct_TGeoPconSection(void *p);
00953 static void streamer_TGeoPconSection(TBuffer &buf, void *obj);
00954
00955
00956 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPconSection*)
00957 {
00958 ::TGeoPconSection *ptr = 0;
00959 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPconSection >(0);
00960 static ::ROOT::TGenericClassInfo
00961 instance("TGeoPconSection", ::TGeoPconSection::Class_Version(), "include/TGeoPconEditor.h", 101,
00962 typeid(::TGeoPconSection), DefineBehavior(ptr, ptr),
00963 &::TGeoPconSection::Dictionary, isa_proxy, 0,
00964 sizeof(::TGeoPconSection) );
00965 instance.SetDelete(&delete_TGeoPconSection);
00966 instance.SetDeleteArray(&deleteArray_TGeoPconSection);
00967 instance.SetDestructor(&destruct_TGeoPconSection);
00968 instance.SetStreamerFunc(&streamer_TGeoPconSection);
00969 return &instance;
00970 }
00971 TGenericClassInfo *GenerateInitInstance(const ::TGeoPconSection*)
00972 {
00973 return GenerateInitInstanceLocal((::TGeoPconSection*)0);
00974 }
00975
00976 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPconSection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00977 }
00978
00979 namespace ROOT {
00980 void TGeoPconEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00981 static void *new_TGeoPconEditor(void *p = 0);
00982 static void *newArray_TGeoPconEditor(Long_t size, void *p);
00983 static void delete_TGeoPconEditor(void *p);
00984 static void deleteArray_TGeoPconEditor(void *p);
00985 static void destruct_TGeoPconEditor(void *p);
00986 static void streamer_TGeoPconEditor(TBuffer &buf, void *obj);
00987
00988
00989 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPconEditor*)
00990 {
00991 ::TGeoPconEditor *ptr = 0;
00992 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPconEditor >(0);
00993 static ::ROOT::TGenericClassInfo
00994 instance("TGeoPconEditor", ::TGeoPconEditor::Class_Version(), "include/TGeoPconEditor.h", 41,
00995 typeid(::TGeoPconEditor), DefineBehavior(ptr, ptr),
00996 &::TGeoPconEditor::Dictionary, isa_proxy, 0,
00997 sizeof(::TGeoPconEditor) );
00998 instance.SetNew(&new_TGeoPconEditor);
00999 instance.SetNewArray(&newArray_TGeoPconEditor);
01000 instance.SetDelete(&delete_TGeoPconEditor);
01001 instance.SetDeleteArray(&deleteArray_TGeoPconEditor);
01002 instance.SetDestructor(&destruct_TGeoPconEditor);
01003 instance.SetStreamerFunc(&streamer_TGeoPconEditor);
01004 return &instance;
01005 }
01006 TGenericClassInfo *GenerateInitInstance(const ::TGeoPconEditor*)
01007 {
01008 return GenerateInitInstanceLocal((::TGeoPconEditor*)0);
01009 }
01010
01011 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPconEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01012 }
01013
01014 namespace ROOT {
01015 void TGeoParaEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
01016 static void *new_TGeoParaEditor(void *p = 0);
01017 static void *newArray_TGeoParaEditor(Long_t size, void *p);
01018 static void delete_TGeoParaEditor(void *p);
01019 static void deleteArray_TGeoParaEditor(void *p);
01020 static void destruct_TGeoParaEditor(void *p);
01021 static void streamer_TGeoParaEditor(TBuffer &buf, void *obj);
01022
01023
01024 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoParaEditor*)
01025 {
01026 ::TGeoParaEditor *ptr = 0;
01027 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoParaEditor >(0);
01028 static ::ROOT::TGenericClassInfo
01029 instance("TGeoParaEditor", ::TGeoParaEditor::Class_Version(), "include/TGeoParaEditor.h", 39,
01030 typeid(::TGeoParaEditor), DefineBehavior(ptr, ptr),
01031 &::TGeoParaEditor::Dictionary, isa_proxy, 0,
01032 sizeof(::TGeoParaEditor) );
01033 instance.SetNew(&new_TGeoParaEditor);
01034 instance.SetNewArray(&newArray_TGeoParaEditor);
01035 instance.SetDelete(&delete_TGeoParaEditor);
01036 instance.SetDeleteArray(&deleteArray_TGeoParaEditor);
01037 instance.SetDestructor(&destruct_TGeoParaEditor);
01038 instance.SetStreamerFunc(&streamer_TGeoParaEditor);
01039 return &instance;
01040 }
01041 TGenericClassInfo *GenerateInitInstance(const ::TGeoParaEditor*)
01042 {
01043 return GenerateInitInstanceLocal((::TGeoParaEditor*)0);
01044 }
01045
01046 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoParaEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01047 }
01048
01049 namespace ROOT {
01050 void TGeoTorusEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
01051 static void *new_TGeoTorusEditor(void *p = 0);
01052 static void *newArray_TGeoTorusEditor(Long_t size, void *p);
01053 static void delete_TGeoTorusEditor(void *p);
01054 static void deleteArray_TGeoTorusEditor(void *p);
01055 static void destruct_TGeoTorusEditor(void *p);
01056 static void streamer_TGeoTorusEditor(TBuffer &buf, void *obj);
01057
01058
01059 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTorusEditor*)
01060 {
01061 ::TGeoTorusEditor *ptr = 0;
01062 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTorusEditor >(0);
01063 static ::ROOT::TGenericClassInfo
01064 instance("TGeoTorusEditor", ::TGeoTorusEditor::Class_Version(), "include/TGeoTorusEditor.h", 39,
01065 typeid(::TGeoTorusEditor), DefineBehavior(ptr, ptr),
01066 &::TGeoTorusEditor::Dictionary, isa_proxy, 0,
01067 sizeof(::TGeoTorusEditor) );
01068 instance.SetNew(&new_TGeoTorusEditor);
01069 instance.SetNewArray(&newArray_TGeoTorusEditor);
01070 instance.SetDelete(&delete_TGeoTorusEditor);
01071 instance.SetDeleteArray(&deleteArray_TGeoTorusEditor);
01072 instance.SetDestructor(&destruct_TGeoTorusEditor);
01073 instance.SetStreamerFunc(&streamer_TGeoTorusEditor);
01074 return &instance;
01075 }
01076 TGenericClassInfo *GenerateInitInstance(const ::TGeoTorusEditor*)
01077 {
01078 return GenerateInitInstanceLocal((::TGeoTorusEditor*)0);
01079 }
01080
01081 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTorusEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01082 }
01083
01084 namespace ROOT {
01085 void TGeoEltuEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
01086 static void *new_TGeoEltuEditor(void *p = 0);
01087 static void *newArray_TGeoEltuEditor(Long_t size, void *p);
01088 static void delete_TGeoEltuEditor(void *p);
01089 static void deleteArray_TGeoEltuEditor(void *p);
01090 static void destruct_TGeoEltuEditor(void *p);
01091 static void streamer_TGeoEltuEditor(TBuffer &buf, void *obj);
01092
01093
01094 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoEltuEditor*)
01095 {
01096 ::TGeoEltuEditor *ptr = 0;
01097 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoEltuEditor >(0);
01098 static ::ROOT::TGenericClassInfo
01099 instance("TGeoEltuEditor", ::TGeoEltuEditor::Class_Version(), "include/TGeoEltuEditor.h", 39,
01100 typeid(::TGeoEltuEditor), DefineBehavior(ptr, ptr),
01101 &::TGeoEltuEditor::Dictionary, isa_proxy, 0,
01102 sizeof(::TGeoEltuEditor) );
01103 instance.SetNew(&new_TGeoEltuEditor);
01104 instance.SetNewArray(&newArray_TGeoEltuEditor);
01105 instance.SetDelete(&delete_TGeoEltuEditor);
01106 instance.SetDeleteArray(&deleteArray_TGeoEltuEditor);
01107 instance.SetDestructor(&destruct_TGeoEltuEditor);
01108 instance.SetStreamerFunc(&streamer_TGeoEltuEditor);
01109 return &instance;
01110 }
01111 TGenericClassInfo *GenerateInitInstance(const ::TGeoEltuEditor*)
01112 {
01113 return GenerateInitInstanceLocal((::TGeoEltuEditor*)0);
01114 }
01115
01116 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoEltuEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01117 }
01118
01119 namespace ROOT {
01120 void TGeoHypeEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
01121 static void *new_TGeoHypeEditor(void *p = 0);
01122 static void *newArray_TGeoHypeEditor(Long_t size, void *p);
01123 static void delete_TGeoHypeEditor(void *p);
01124 static void deleteArray_TGeoHypeEditor(void *p);
01125 static void destruct_TGeoHypeEditor(void *p);
01126 static void streamer_TGeoHypeEditor(TBuffer &buf, void *obj);
01127
01128
01129 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoHypeEditor*)
01130 {
01131 ::TGeoHypeEditor *ptr = 0;
01132 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoHypeEditor >(0);
01133 static ::ROOT::TGenericClassInfo
01134 instance("TGeoHypeEditor", ::TGeoHypeEditor::Class_Version(), "include/TGeoHypeEditor.h", 39,
01135 typeid(::TGeoHypeEditor), DefineBehavior(ptr, ptr),
01136 &::TGeoHypeEditor::Dictionary, isa_proxy, 0,
01137 sizeof(::TGeoHypeEditor) );
01138 instance.SetNew(&new_TGeoHypeEditor);
01139 instance.SetNewArray(&newArray_TGeoHypeEditor);
01140 instance.SetDelete(&delete_TGeoHypeEditor);
01141 instance.SetDeleteArray(&deleteArray_TGeoHypeEditor);
01142 instance.SetDestructor(&destruct_TGeoHypeEditor);
01143 instance.SetStreamerFunc(&streamer_TGeoHypeEditor);
01144 return &instance;
01145 }
01146 TGenericClassInfo *GenerateInitInstance(const ::TGeoHypeEditor*)
01147 {
01148 return GenerateInitInstanceLocal((::TGeoHypeEditor*)0);
01149 }
01150
01151 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoHypeEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01152 }
01153
01154 namespace ROOT {
01155 void TGeoPgonEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
01156 static void *new_TGeoPgonEditor(void *p = 0);
01157 static void *newArray_TGeoPgonEditor(Long_t size, void *p);
01158 static void delete_TGeoPgonEditor(void *p);
01159 static void deleteArray_TGeoPgonEditor(void *p);
01160 static void destruct_TGeoPgonEditor(void *p);
01161 static void streamer_TGeoPgonEditor(TBuffer &buf, void *obj);
01162
01163
01164 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoPgonEditor*)
01165 {
01166 ::TGeoPgonEditor *ptr = 0;
01167 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoPgonEditor >(0);
01168 static ::ROOT::TGenericClassInfo
01169 instance("TGeoPgonEditor", ::TGeoPgonEditor::Class_Version(), "include/TGeoPgonEditor.h", 32,
01170 typeid(::TGeoPgonEditor), DefineBehavior(ptr, ptr),
01171 &::TGeoPgonEditor::Dictionary, isa_proxy, 0,
01172 sizeof(::TGeoPgonEditor) );
01173 instance.SetNew(&new_TGeoPgonEditor);
01174 instance.SetNewArray(&newArray_TGeoPgonEditor);
01175 instance.SetDelete(&delete_TGeoPgonEditor);
01176 instance.SetDeleteArray(&deleteArray_TGeoPgonEditor);
01177 instance.SetDestructor(&destruct_TGeoPgonEditor);
01178 instance.SetStreamerFunc(&streamer_TGeoPgonEditor);
01179 return &instance;
01180 }
01181 TGenericClassInfo *GenerateInitInstance(const ::TGeoPgonEditor*)
01182 {
01183 return GenerateInitInstanceLocal((::TGeoPgonEditor*)0);
01184 }
01185
01186 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoPgonEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01187 }
01188
01189 namespace ROOT {
01190 void TGeoTrapEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
01191 static void *new_TGeoTrapEditor(void *p = 0);
01192 static void *newArray_TGeoTrapEditor(Long_t size, void *p);
01193 static void delete_TGeoTrapEditor(void *p);
01194 static void deleteArray_TGeoTrapEditor(void *p);
01195 static void destruct_TGeoTrapEditor(void *p);
01196 static void streamer_TGeoTrapEditor(TBuffer &buf, void *obj);
01197
01198
01199 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoTrapEditor*)
01200 {
01201 ::TGeoTrapEditor *ptr = 0;
01202 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoTrapEditor >(0);
01203 static ::ROOT::TGenericClassInfo
01204 instance("TGeoTrapEditor", ::TGeoTrapEditor::Class_Version(), "include/TGeoTrapEditor.h", 39,
01205 typeid(::TGeoTrapEditor), DefineBehavior(ptr, ptr),
01206 &::TGeoTrapEditor::Dictionary, isa_proxy, 0,
01207 sizeof(::TGeoTrapEditor) );
01208 instance.SetNew(&new_TGeoTrapEditor);
01209 instance.SetNewArray(&newArray_TGeoTrapEditor);
01210 instance.SetDelete(&delete_TGeoTrapEditor);
01211 instance.SetDeleteArray(&deleteArray_TGeoTrapEditor);
01212 instance.SetDestructor(&destruct_TGeoTrapEditor);
01213 instance.SetStreamerFunc(&streamer_TGeoTrapEditor);
01214 return &instance;
01215 }
01216 TGenericClassInfo *GenerateInitInstance(const ::TGeoTrapEditor*)
01217 {
01218 return GenerateInitInstanceLocal((::TGeoTrapEditor*)0);
01219 }
01220
01221 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoTrapEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01222 }
01223
01224 namespace ROOT {
01225 void TGeoGtraEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
01226 static void *new_TGeoGtraEditor(void *p = 0);
01227 static void *newArray_TGeoGtraEditor(Long_t size, void *p);
01228 static void delete_TGeoGtraEditor(void *p);
01229 static void deleteArray_TGeoGtraEditor(void *p);
01230 static void destruct_TGeoGtraEditor(void *p);
01231 static void streamer_TGeoGtraEditor(TBuffer &buf, void *obj);
01232
01233
01234 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGeoGtraEditor*)
01235 {
01236 ::TGeoGtraEditor *ptr = 0;
01237 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGeoGtraEditor >(0);
01238 static ::ROOT::TGenericClassInfo
01239 instance("TGeoGtraEditor", ::TGeoGtraEditor::Class_Version(), "include/TGeoTrapEditor.h", 100,
01240 typeid(::TGeoGtraEditor), DefineBehavior(ptr, ptr),
01241 &::TGeoGtraEditor::Dictionary, isa_proxy, 0,
01242 sizeof(::TGeoGtraEditor) );
01243 instance.SetNew(&new_TGeoGtraEditor);
01244 instance.SetNewArray(&newArray_TGeoGtraEditor);
01245 instance.SetDelete(&delete_TGeoGtraEditor);
01246 instance.SetDeleteArray(&deleteArray_TGeoGtraEditor);
01247 instance.SetDestructor(&destruct_TGeoGtraEditor);
01248 instance.SetStreamerFunc(&streamer_TGeoGtraEditor);
01249 return &instance;
01250 }
01251 TGenericClassInfo *GenerateInitInstance(const ::TGeoGtraEditor*)
01252 {
01253 return GenerateInitInstanceLocal((::TGeoGtraEditor*)0);
01254 }
01255
01256 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGeoGtraEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01257 }
01258
01259
01260 TClass *TGeoTabManager::fgIsA = 0;
01261
01262
01263 const char *TGeoTabManager::Class_Name()
01264 {
01265 return "TGeoTabManager";
01266 }
01267
01268
01269 const char *TGeoTabManager::ImplFileName()
01270 {
01271 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTabManager*)0x0)->GetImplFileName();
01272 }
01273
01274
01275 int TGeoTabManager::ImplFileLine()
01276 {
01277 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTabManager*)0x0)->GetImplFileLine();
01278 }
01279
01280
01281 void TGeoTabManager::Dictionary()
01282 {
01283 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTabManager*)0x0)->GetClass();
01284 }
01285
01286
01287 TClass *TGeoTabManager::Class()
01288 {
01289 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTabManager*)0x0)->GetClass();
01290 return fgIsA;
01291 }
01292
01293
01294 TClass *TGeoGedFrame::fgIsA = 0;
01295
01296
01297 const char *TGeoGedFrame::Class_Name()
01298 {
01299 return "TGeoGedFrame";
01300 }
01301
01302
01303 const char *TGeoGedFrame::ImplFileName()
01304 {
01305 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoGedFrame*)0x0)->GetImplFileName();
01306 }
01307
01308
01309 int TGeoGedFrame::ImplFileLine()
01310 {
01311 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoGedFrame*)0x0)->GetImplFileLine();
01312 }
01313
01314
01315 void TGeoGedFrame::Dictionary()
01316 {
01317 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoGedFrame*)0x0)->GetClass();
01318 }
01319
01320
01321 TClass *TGeoGedFrame::Class()
01322 {
01323 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoGedFrame*)0x0)->GetClass();
01324 return fgIsA;
01325 }
01326
01327
01328 TClass *TGeoVolumeEditor::fgIsA = 0;
01329
01330
01331 const char *TGeoVolumeEditor::Class_Name()
01332 {
01333 return "TGeoVolumeEditor";
01334 }
01335
01336
01337 const char *TGeoVolumeEditor::ImplFileName()
01338 {
01339 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoVolumeEditor*)0x0)->GetImplFileName();
01340 }
01341
01342
01343 int TGeoVolumeEditor::ImplFileLine()
01344 {
01345 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoVolumeEditor*)0x0)->GetImplFileLine();
01346 }
01347
01348
01349 void TGeoVolumeEditor::Dictionary()
01350 {
01351 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoVolumeEditor*)0x0)->GetClass();
01352 }
01353
01354
01355 TClass *TGeoVolumeEditor::Class()
01356 {
01357 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoVolumeEditor*)0x0)->GetClass();
01358 return fgIsA;
01359 }
01360
01361
01362 TClass *TGeoBBoxEditor::fgIsA = 0;
01363
01364
01365 const char *TGeoBBoxEditor::Class_Name()
01366 {
01367 return "TGeoBBoxEditor";
01368 }
01369
01370
01371 const char *TGeoBBoxEditor::ImplFileName()
01372 {
01373 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoBBoxEditor*)0x0)->GetImplFileName();
01374 }
01375
01376
01377 int TGeoBBoxEditor::ImplFileLine()
01378 {
01379 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoBBoxEditor*)0x0)->GetImplFileLine();
01380 }
01381
01382
01383 void TGeoBBoxEditor::Dictionary()
01384 {
01385 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoBBoxEditor*)0x0)->GetClass();
01386 }
01387
01388
01389 TClass *TGeoBBoxEditor::Class()
01390 {
01391 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoBBoxEditor*)0x0)->GetClass();
01392 return fgIsA;
01393 }
01394
01395
01396 TClass *TGeoMediumEditor::fgIsA = 0;
01397
01398
01399 const char *TGeoMediumEditor::Class_Name()
01400 {
01401 return "TGeoMediumEditor";
01402 }
01403
01404
01405 const char *TGeoMediumEditor::ImplFileName()
01406 {
01407 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMediumEditor*)0x0)->GetImplFileName();
01408 }
01409
01410
01411 int TGeoMediumEditor::ImplFileLine()
01412 {
01413 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMediumEditor*)0x0)->GetImplFileLine();
01414 }
01415
01416
01417 void TGeoMediumEditor::Dictionary()
01418 {
01419 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMediumEditor*)0x0)->GetClass();
01420 }
01421
01422
01423 TClass *TGeoMediumEditor::Class()
01424 {
01425 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMediumEditor*)0x0)->GetClass();
01426 return fgIsA;
01427 }
01428
01429
01430 TClass *TGeoNodeEditor::fgIsA = 0;
01431
01432
01433 const char *TGeoNodeEditor::Class_Name()
01434 {
01435 return "TGeoNodeEditor";
01436 }
01437
01438
01439 const char *TGeoNodeEditor::ImplFileName()
01440 {
01441 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoNodeEditor*)0x0)->GetImplFileName();
01442 }
01443
01444
01445 int TGeoNodeEditor::ImplFileLine()
01446 {
01447 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoNodeEditor*)0x0)->GetImplFileLine();
01448 }
01449
01450
01451 void TGeoNodeEditor::Dictionary()
01452 {
01453 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoNodeEditor*)0x0)->GetClass();
01454 }
01455
01456
01457 TClass *TGeoNodeEditor::Class()
01458 {
01459 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoNodeEditor*)0x0)->GetClass();
01460 return fgIsA;
01461 }
01462
01463
01464 TClass *TGeoTranslationEditor::fgIsA = 0;
01465
01466
01467 const char *TGeoTranslationEditor::Class_Name()
01468 {
01469 return "TGeoTranslationEditor";
01470 }
01471
01472
01473 const char *TGeoTranslationEditor::ImplFileName()
01474 {
01475 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTranslationEditor*)0x0)->GetImplFileName();
01476 }
01477
01478
01479 int TGeoTranslationEditor::ImplFileLine()
01480 {
01481 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTranslationEditor*)0x0)->GetImplFileLine();
01482 }
01483
01484
01485 void TGeoTranslationEditor::Dictionary()
01486 {
01487 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTranslationEditor*)0x0)->GetClass();
01488 }
01489
01490
01491 TClass *TGeoTranslationEditor::Class()
01492 {
01493 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTranslationEditor*)0x0)->GetClass();
01494 return fgIsA;
01495 }
01496
01497
01498 TClass *TGeoRotationEditor::fgIsA = 0;
01499
01500
01501 const char *TGeoRotationEditor::Class_Name()
01502 {
01503 return "TGeoRotationEditor";
01504 }
01505
01506
01507 const char *TGeoRotationEditor::ImplFileName()
01508 {
01509 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoRotationEditor*)0x0)->GetImplFileName();
01510 }
01511
01512
01513 int TGeoRotationEditor::ImplFileLine()
01514 {
01515 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoRotationEditor*)0x0)->GetImplFileLine();
01516 }
01517
01518
01519 void TGeoRotationEditor::Dictionary()
01520 {
01521 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoRotationEditor*)0x0)->GetClass();
01522 }
01523
01524
01525 TClass *TGeoRotationEditor::Class()
01526 {
01527 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoRotationEditor*)0x0)->GetClass();
01528 return fgIsA;
01529 }
01530
01531
01532 TClass *TGeoCombiTransEditor::fgIsA = 0;
01533
01534
01535 const char *TGeoCombiTransEditor::Class_Name()
01536 {
01537 return "TGeoCombiTransEditor";
01538 }
01539
01540
01541 const char *TGeoCombiTransEditor::ImplFileName()
01542 {
01543 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoCombiTransEditor*)0x0)->GetImplFileName();
01544 }
01545
01546
01547 int TGeoCombiTransEditor::ImplFileLine()
01548 {
01549 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoCombiTransEditor*)0x0)->GetImplFileLine();
01550 }
01551
01552
01553 void TGeoCombiTransEditor::Dictionary()
01554 {
01555 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoCombiTransEditor*)0x0)->GetClass();
01556 }
01557
01558
01559 TClass *TGeoCombiTransEditor::Class()
01560 {
01561 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoCombiTransEditor*)0x0)->GetClass();
01562 return fgIsA;
01563 }
01564
01565
01566 TClass *TGeoManagerEditor::fgIsA = 0;
01567
01568
01569 const char *TGeoManagerEditor::Class_Name()
01570 {
01571 return "TGeoManagerEditor";
01572 }
01573
01574
01575 const char *TGeoManagerEditor::ImplFileName()
01576 {
01577 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoManagerEditor*)0x0)->GetImplFileName();
01578 }
01579
01580
01581 int TGeoManagerEditor::ImplFileLine()
01582 {
01583 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoManagerEditor*)0x0)->GetImplFileLine();
01584 }
01585
01586
01587 void TGeoManagerEditor::Dictionary()
01588 {
01589 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoManagerEditor*)0x0)->GetClass();
01590 }
01591
01592
01593 TClass *TGeoManagerEditor::Class()
01594 {
01595 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoManagerEditor*)0x0)->GetClass();
01596 return fgIsA;
01597 }
01598
01599
01600 TClass *TGeoTubeEditor::fgIsA = 0;
01601
01602
01603 const char *TGeoTubeEditor::Class_Name()
01604 {
01605 return "TGeoTubeEditor";
01606 }
01607
01608
01609 const char *TGeoTubeEditor::ImplFileName()
01610 {
01611 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTubeEditor*)0x0)->GetImplFileName();
01612 }
01613
01614
01615 int TGeoTubeEditor::ImplFileLine()
01616 {
01617 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTubeEditor*)0x0)->GetImplFileLine();
01618 }
01619
01620
01621 void TGeoTubeEditor::Dictionary()
01622 {
01623 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTubeEditor*)0x0)->GetClass();
01624 }
01625
01626
01627 TClass *TGeoTubeEditor::Class()
01628 {
01629 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTubeEditor*)0x0)->GetClass();
01630 return fgIsA;
01631 }
01632
01633
01634 TClass *TGeoTubeSegEditor::fgIsA = 0;
01635
01636
01637 const char *TGeoTubeSegEditor::Class_Name()
01638 {
01639 return "TGeoTubeSegEditor";
01640 }
01641
01642
01643 const char *TGeoTubeSegEditor::ImplFileName()
01644 {
01645 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTubeSegEditor*)0x0)->GetImplFileName();
01646 }
01647
01648
01649 int TGeoTubeSegEditor::ImplFileLine()
01650 {
01651 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTubeSegEditor*)0x0)->GetImplFileLine();
01652 }
01653
01654
01655 void TGeoTubeSegEditor::Dictionary()
01656 {
01657 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTubeSegEditor*)0x0)->GetClass();
01658 }
01659
01660
01661 TClass *TGeoTubeSegEditor::Class()
01662 {
01663 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTubeSegEditor*)0x0)->GetClass();
01664 return fgIsA;
01665 }
01666
01667
01668 TClass *TGeoCtubEditor::fgIsA = 0;
01669
01670
01671 const char *TGeoCtubEditor::Class_Name()
01672 {
01673 return "TGeoCtubEditor";
01674 }
01675
01676
01677 const char *TGeoCtubEditor::ImplFileName()
01678 {
01679 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoCtubEditor*)0x0)->GetImplFileName();
01680 }
01681
01682
01683 int TGeoCtubEditor::ImplFileLine()
01684 {
01685 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoCtubEditor*)0x0)->GetImplFileLine();
01686 }
01687
01688
01689 void TGeoCtubEditor::Dictionary()
01690 {
01691 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoCtubEditor*)0x0)->GetClass();
01692 }
01693
01694
01695 TClass *TGeoCtubEditor::Class()
01696 {
01697 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoCtubEditor*)0x0)->GetClass();
01698 return fgIsA;
01699 }
01700
01701
01702 TClass *TGeoConeEditor::fgIsA = 0;
01703
01704
01705 const char *TGeoConeEditor::Class_Name()
01706 {
01707 return "TGeoConeEditor";
01708 }
01709
01710
01711 const char *TGeoConeEditor::ImplFileName()
01712 {
01713 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoConeEditor*)0x0)->GetImplFileName();
01714 }
01715
01716
01717 int TGeoConeEditor::ImplFileLine()
01718 {
01719 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoConeEditor*)0x0)->GetImplFileLine();
01720 }
01721
01722
01723 void TGeoConeEditor::Dictionary()
01724 {
01725 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoConeEditor*)0x0)->GetClass();
01726 }
01727
01728
01729 TClass *TGeoConeEditor::Class()
01730 {
01731 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoConeEditor*)0x0)->GetClass();
01732 return fgIsA;
01733 }
01734
01735
01736 TClass *TGeoConeSegEditor::fgIsA = 0;
01737
01738
01739 const char *TGeoConeSegEditor::Class_Name()
01740 {
01741 return "TGeoConeSegEditor";
01742 }
01743
01744
01745 const char *TGeoConeSegEditor::ImplFileName()
01746 {
01747 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoConeSegEditor*)0x0)->GetImplFileName();
01748 }
01749
01750
01751 int TGeoConeSegEditor::ImplFileLine()
01752 {
01753 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoConeSegEditor*)0x0)->GetImplFileLine();
01754 }
01755
01756
01757 void TGeoConeSegEditor::Dictionary()
01758 {
01759 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoConeSegEditor*)0x0)->GetClass();
01760 }
01761
01762
01763 TClass *TGeoConeSegEditor::Class()
01764 {
01765 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoConeSegEditor*)0x0)->GetClass();
01766 return fgIsA;
01767 }
01768
01769
01770 TClass *TGeoTrd1Editor::fgIsA = 0;
01771
01772
01773 const char *TGeoTrd1Editor::Class_Name()
01774 {
01775 return "TGeoTrd1Editor";
01776 }
01777
01778
01779 const char *TGeoTrd1Editor::ImplFileName()
01780 {
01781 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrd1Editor*)0x0)->GetImplFileName();
01782 }
01783
01784
01785 int TGeoTrd1Editor::ImplFileLine()
01786 {
01787 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrd1Editor*)0x0)->GetImplFileLine();
01788 }
01789
01790
01791 void TGeoTrd1Editor::Dictionary()
01792 {
01793 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrd1Editor*)0x0)->GetClass();
01794 }
01795
01796
01797 TClass *TGeoTrd1Editor::Class()
01798 {
01799 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrd1Editor*)0x0)->GetClass();
01800 return fgIsA;
01801 }
01802
01803
01804 TClass *TGeoTrd2Editor::fgIsA = 0;
01805
01806
01807 const char *TGeoTrd2Editor::Class_Name()
01808 {
01809 return "TGeoTrd2Editor";
01810 }
01811
01812
01813 const char *TGeoTrd2Editor::ImplFileName()
01814 {
01815 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrd2Editor*)0x0)->GetImplFileName();
01816 }
01817
01818
01819 int TGeoTrd2Editor::ImplFileLine()
01820 {
01821 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrd2Editor*)0x0)->GetImplFileLine();
01822 }
01823
01824
01825 void TGeoTrd2Editor::Dictionary()
01826 {
01827 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrd2Editor*)0x0)->GetClass();
01828 }
01829
01830
01831 TClass *TGeoTrd2Editor::Class()
01832 {
01833 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrd2Editor*)0x0)->GetClass();
01834 return fgIsA;
01835 }
01836
01837
01838 TClass *TGeoMaterialEditor::fgIsA = 0;
01839
01840
01841 const char *TGeoMaterialEditor::Class_Name()
01842 {
01843 return "TGeoMaterialEditor";
01844 }
01845
01846
01847 const char *TGeoMaterialEditor::ImplFileName()
01848 {
01849 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMaterialEditor*)0x0)->GetImplFileName();
01850 }
01851
01852
01853 int TGeoMaterialEditor::ImplFileLine()
01854 {
01855 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMaterialEditor*)0x0)->GetImplFileLine();
01856 }
01857
01858
01859 void TGeoMaterialEditor::Dictionary()
01860 {
01861 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMaterialEditor*)0x0)->GetClass();
01862 }
01863
01864
01865 TClass *TGeoMaterialEditor::Class()
01866 {
01867 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMaterialEditor*)0x0)->GetClass();
01868 return fgIsA;
01869 }
01870
01871
01872 TClass *TGeoMixtureEditor::fgIsA = 0;
01873
01874
01875 const char *TGeoMixtureEditor::Class_Name()
01876 {
01877 return "TGeoMixtureEditor";
01878 }
01879
01880
01881 const char *TGeoMixtureEditor::ImplFileName()
01882 {
01883 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMixtureEditor*)0x0)->GetImplFileName();
01884 }
01885
01886
01887 int TGeoMixtureEditor::ImplFileLine()
01888 {
01889 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMixtureEditor*)0x0)->GetImplFileLine();
01890 }
01891
01892
01893 void TGeoMixtureEditor::Dictionary()
01894 {
01895 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMixtureEditor*)0x0)->GetClass();
01896 }
01897
01898
01899 TClass *TGeoMixtureEditor::Class()
01900 {
01901 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMixtureEditor*)0x0)->GetClass();
01902 return fgIsA;
01903 }
01904
01905
01906 TClass *TGeoTreeDialog::fgIsA = 0;
01907
01908
01909 const char *TGeoTreeDialog::Class_Name()
01910 {
01911 return "TGeoTreeDialog";
01912 }
01913
01914
01915 const char *TGeoTreeDialog::ImplFileName()
01916 {
01917 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTreeDialog*)0x0)->GetImplFileName();
01918 }
01919
01920
01921 int TGeoTreeDialog::ImplFileLine()
01922 {
01923 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTreeDialog*)0x0)->GetImplFileLine();
01924 }
01925
01926
01927 void TGeoTreeDialog::Dictionary()
01928 {
01929 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTreeDialog*)0x0)->GetClass();
01930 }
01931
01932
01933 TClass *TGeoTreeDialog::Class()
01934 {
01935 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTreeDialog*)0x0)->GetClass();
01936 return fgIsA;
01937 }
01938
01939
01940 TClass *TGeoTransientPanel::fgIsA = 0;
01941
01942
01943 const char *TGeoTransientPanel::Class_Name()
01944 {
01945 return "TGeoTransientPanel";
01946 }
01947
01948
01949 const char *TGeoTransientPanel::ImplFileName()
01950 {
01951 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTransientPanel*)0x0)->GetImplFileName();
01952 }
01953
01954
01955 int TGeoTransientPanel::ImplFileLine()
01956 {
01957 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTransientPanel*)0x0)->GetImplFileLine();
01958 }
01959
01960
01961 void TGeoTransientPanel::Dictionary()
01962 {
01963 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTransientPanel*)0x0)->GetClass();
01964 }
01965
01966
01967 TClass *TGeoTransientPanel::Class()
01968 {
01969 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTransientPanel*)0x0)->GetClass();
01970 return fgIsA;
01971 }
01972
01973
01974 TClass *TGeoVolumeDialog::fgIsA = 0;
01975
01976
01977 const char *TGeoVolumeDialog::Class_Name()
01978 {
01979 return "TGeoVolumeDialog";
01980 }
01981
01982
01983 const char *TGeoVolumeDialog::ImplFileName()
01984 {
01985 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoVolumeDialog*)0x0)->GetImplFileName();
01986 }
01987
01988
01989 int TGeoVolumeDialog::ImplFileLine()
01990 {
01991 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoVolumeDialog*)0x0)->GetImplFileLine();
01992 }
01993
01994
01995 void TGeoVolumeDialog::Dictionary()
01996 {
01997 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoVolumeDialog*)0x0)->GetClass();
01998 }
01999
02000
02001 TClass *TGeoVolumeDialog::Class()
02002 {
02003 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoVolumeDialog*)0x0)->GetClass();
02004 return fgIsA;
02005 }
02006
02007
02008 TClass *TGeoShapeDialog::fgIsA = 0;
02009
02010
02011 const char *TGeoShapeDialog::Class_Name()
02012 {
02013 return "TGeoShapeDialog";
02014 }
02015
02016
02017 const char *TGeoShapeDialog::ImplFileName()
02018 {
02019 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoShapeDialog*)0x0)->GetImplFileName();
02020 }
02021
02022
02023 int TGeoShapeDialog::ImplFileLine()
02024 {
02025 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoShapeDialog*)0x0)->GetImplFileLine();
02026 }
02027
02028
02029 void TGeoShapeDialog::Dictionary()
02030 {
02031 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoShapeDialog*)0x0)->GetClass();
02032 }
02033
02034
02035 TClass *TGeoShapeDialog::Class()
02036 {
02037 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoShapeDialog*)0x0)->GetClass();
02038 return fgIsA;
02039 }
02040
02041
02042 TClass *TGeoMediumDialog::fgIsA = 0;
02043
02044
02045 const char *TGeoMediumDialog::Class_Name()
02046 {
02047 return "TGeoMediumDialog";
02048 }
02049
02050
02051 const char *TGeoMediumDialog::ImplFileName()
02052 {
02053 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMediumDialog*)0x0)->GetImplFileName();
02054 }
02055
02056
02057 int TGeoMediumDialog::ImplFileLine()
02058 {
02059 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMediumDialog*)0x0)->GetImplFileLine();
02060 }
02061
02062
02063 void TGeoMediumDialog::Dictionary()
02064 {
02065 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMediumDialog*)0x0)->GetClass();
02066 }
02067
02068
02069 TClass *TGeoMediumDialog::Class()
02070 {
02071 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMediumDialog*)0x0)->GetClass();
02072 return fgIsA;
02073 }
02074
02075
02076 TClass *TGeoMaterialDialog::fgIsA = 0;
02077
02078
02079 const char *TGeoMaterialDialog::Class_Name()
02080 {
02081 return "TGeoMaterialDialog";
02082 }
02083
02084
02085 const char *TGeoMaterialDialog::ImplFileName()
02086 {
02087 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMaterialDialog*)0x0)->GetImplFileName();
02088 }
02089
02090
02091 int TGeoMaterialDialog::ImplFileLine()
02092 {
02093 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMaterialDialog*)0x0)->GetImplFileLine();
02094 }
02095
02096
02097 void TGeoMaterialDialog::Dictionary()
02098 {
02099 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMaterialDialog*)0x0)->GetClass();
02100 }
02101
02102
02103 TClass *TGeoMaterialDialog::Class()
02104 {
02105 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMaterialDialog*)0x0)->GetClass();
02106 return fgIsA;
02107 }
02108
02109
02110 TClass *TGeoMatrixDialog::fgIsA = 0;
02111
02112
02113 const char *TGeoMatrixDialog::Class_Name()
02114 {
02115 return "TGeoMatrixDialog";
02116 }
02117
02118
02119 const char *TGeoMatrixDialog::ImplFileName()
02120 {
02121 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMatrixDialog*)0x0)->GetImplFileName();
02122 }
02123
02124
02125 int TGeoMatrixDialog::ImplFileLine()
02126 {
02127 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoMatrixDialog*)0x0)->GetImplFileLine();
02128 }
02129
02130
02131 void TGeoMatrixDialog::Dictionary()
02132 {
02133 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMatrixDialog*)0x0)->GetClass();
02134 }
02135
02136
02137 TClass *TGeoMatrixDialog::Class()
02138 {
02139 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoMatrixDialog*)0x0)->GetClass();
02140 return fgIsA;
02141 }
02142
02143
02144 TClass *TGeoSphereEditor::fgIsA = 0;
02145
02146
02147 const char *TGeoSphereEditor::Class_Name()
02148 {
02149 return "TGeoSphereEditor";
02150 }
02151
02152
02153 const char *TGeoSphereEditor::ImplFileName()
02154 {
02155 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoSphereEditor*)0x0)->GetImplFileName();
02156 }
02157
02158
02159 int TGeoSphereEditor::ImplFileLine()
02160 {
02161 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoSphereEditor*)0x0)->GetImplFileLine();
02162 }
02163
02164
02165 void TGeoSphereEditor::Dictionary()
02166 {
02167 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoSphereEditor*)0x0)->GetClass();
02168 }
02169
02170
02171 TClass *TGeoSphereEditor::Class()
02172 {
02173 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoSphereEditor*)0x0)->GetClass();
02174 return fgIsA;
02175 }
02176
02177
02178 TClass *TGeoPconSection::fgIsA = 0;
02179
02180
02181 const char *TGeoPconSection::Class_Name()
02182 {
02183 return "TGeoPconSection";
02184 }
02185
02186
02187 const char *TGeoPconSection::ImplFileName()
02188 {
02189 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPconSection*)0x0)->GetImplFileName();
02190 }
02191
02192
02193 int TGeoPconSection::ImplFileLine()
02194 {
02195 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPconSection*)0x0)->GetImplFileLine();
02196 }
02197
02198
02199 void TGeoPconSection::Dictionary()
02200 {
02201 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPconSection*)0x0)->GetClass();
02202 }
02203
02204
02205 TClass *TGeoPconSection::Class()
02206 {
02207 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPconSection*)0x0)->GetClass();
02208 return fgIsA;
02209 }
02210
02211
02212 TClass *TGeoPconEditor::fgIsA = 0;
02213
02214
02215 const char *TGeoPconEditor::Class_Name()
02216 {
02217 return "TGeoPconEditor";
02218 }
02219
02220
02221 const char *TGeoPconEditor::ImplFileName()
02222 {
02223 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPconEditor*)0x0)->GetImplFileName();
02224 }
02225
02226
02227 int TGeoPconEditor::ImplFileLine()
02228 {
02229 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPconEditor*)0x0)->GetImplFileLine();
02230 }
02231
02232
02233 void TGeoPconEditor::Dictionary()
02234 {
02235 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPconEditor*)0x0)->GetClass();
02236 }
02237
02238
02239 TClass *TGeoPconEditor::Class()
02240 {
02241 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPconEditor*)0x0)->GetClass();
02242 return fgIsA;
02243 }
02244
02245
02246 TClass *TGeoParaEditor::fgIsA = 0;
02247
02248
02249 const char *TGeoParaEditor::Class_Name()
02250 {
02251 return "TGeoParaEditor";
02252 }
02253
02254
02255 const char *TGeoParaEditor::ImplFileName()
02256 {
02257 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoParaEditor*)0x0)->GetImplFileName();
02258 }
02259
02260
02261 int TGeoParaEditor::ImplFileLine()
02262 {
02263 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoParaEditor*)0x0)->GetImplFileLine();
02264 }
02265
02266
02267 void TGeoParaEditor::Dictionary()
02268 {
02269 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoParaEditor*)0x0)->GetClass();
02270 }
02271
02272
02273 TClass *TGeoParaEditor::Class()
02274 {
02275 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoParaEditor*)0x0)->GetClass();
02276 return fgIsA;
02277 }
02278
02279
02280 TClass *TGeoTorusEditor::fgIsA = 0;
02281
02282
02283 const char *TGeoTorusEditor::Class_Name()
02284 {
02285 return "TGeoTorusEditor";
02286 }
02287
02288
02289 const char *TGeoTorusEditor::ImplFileName()
02290 {
02291 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTorusEditor*)0x0)->GetImplFileName();
02292 }
02293
02294
02295 int TGeoTorusEditor::ImplFileLine()
02296 {
02297 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTorusEditor*)0x0)->GetImplFileLine();
02298 }
02299
02300
02301 void TGeoTorusEditor::Dictionary()
02302 {
02303 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTorusEditor*)0x0)->GetClass();
02304 }
02305
02306
02307 TClass *TGeoTorusEditor::Class()
02308 {
02309 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTorusEditor*)0x0)->GetClass();
02310 return fgIsA;
02311 }
02312
02313
02314 TClass *TGeoEltuEditor::fgIsA = 0;
02315
02316
02317 const char *TGeoEltuEditor::Class_Name()
02318 {
02319 return "TGeoEltuEditor";
02320 }
02321
02322
02323 const char *TGeoEltuEditor::ImplFileName()
02324 {
02325 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoEltuEditor*)0x0)->GetImplFileName();
02326 }
02327
02328
02329 int TGeoEltuEditor::ImplFileLine()
02330 {
02331 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoEltuEditor*)0x0)->GetImplFileLine();
02332 }
02333
02334
02335 void TGeoEltuEditor::Dictionary()
02336 {
02337 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoEltuEditor*)0x0)->GetClass();
02338 }
02339
02340
02341 TClass *TGeoEltuEditor::Class()
02342 {
02343 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoEltuEditor*)0x0)->GetClass();
02344 return fgIsA;
02345 }
02346
02347
02348 TClass *TGeoHypeEditor::fgIsA = 0;
02349
02350
02351 const char *TGeoHypeEditor::Class_Name()
02352 {
02353 return "TGeoHypeEditor";
02354 }
02355
02356
02357 const char *TGeoHypeEditor::ImplFileName()
02358 {
02359 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoHypeEditor*)0x0)->GetImplFileName();
02360 }
02361
02362
02363 int TGeoHypeEditor::ImplFileLine()
02364 {
02365 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoHypeEditor*)0x0)->GetImplFileLine();
02366 }
02367
02368
02369 void TGeoHypeEditor::Dictionary()
02370 {
02371 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoHypeEditor*)0x0)->GetClass();
02372 }
02373
02374
02375 TClass *TGeoHypeEditor::Class()
02376 {
02377 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoHypeEditor*)0x0)->GetClass();
02378 return fgIsA;
02379 }
02380
02381
02382 TClass *TGeoPgonEditor::fgIsA = 0;
02383
02384
02385 const char *TGeoPgonEditor::Class_Name()
02386 {
02387 return "TGeoPgonEditor";
02388 }
02389
02390
02391 const char *TGeoPgonEditor::ImplFileName()
02392 {
02393 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPgonEditor*)0x0)->GetImplFileName();
02394 }
02395
02396
02397 int TGeoPgonEditor::ImplFileLine()
02398 {
02399 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoPgonEditor*)0x0)->GetImplFileLine();
02400 }
02401
02402
02403 void TGeoPgonEditor::Dictionary()
02404 {
02405 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPgonEditor*)0x0)->GetClass();
02406 }
02407
02408
02409 TClass *TGeoPgonEditor::Class()
02410 {
02411 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoPgonEditor*)0x0)->GetClass();
02412 return fgIsA;
02413 }
02414
02415
02416 TClass *TGeoTrapEditor::fgIsA = 0;
02417
02418
02419 const char *TGeoTrapEditor::Class_Name()
02420 {
02421 return "TGeoTrapEditor";
02422 }
02423
02424
02425 const char *TGeoTrapEditor::ImplFileName()
02426 {
02427 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrapEditor*)0x0)->GetImplFileName();
02428 }
02429
02430
02431 int TGeoTrapEditor::ImplFileLine()
02432 {
02433 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrapEditor*)0x0)->GetImplFileLine();
02434 }
02435
02436
02437 void TGeoTrapEditor::Dictionary()
02438 {
02439 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrapEditor*)0x0)->GetClass();
02440 }
02441
02442
02443 TClass *TGeoTrapEditor::Class()
02444 {
02445 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoTrapEditor*)0x0)->GetClass();
02446 return fgIsA;
02447 }
02448
02449
02450 TClass *TGeoGtraEditor::fgIsA = 0;
02451
02452
02453 const char *TGeoGtraEditor::Class_Name()
02454 {
02455 return "TGeoGtraEditor";
02456 }
02457
02458
02459 const char *TGeoGtraEditor::ImplFileName()
02460 {
02461 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoGtraEditor*)0x0)->GetImplFileName();
02462 }
02463
02464
02465 int TGeoGtraEditor::ImplFileLine()
02466 {
02467 return ::ROOT::GenerateInitInstanceLocal((const ::TGeoGtraEditor*)0x0)->GetImplFileLine();
02468 }
02469
02470
02471 void TGeoGtraEditor::Dictionary()
02472 {
02473 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoGtraEditor*)0x0)->GetClass();
02474 }
02475
02476
02477 TClass *TGeoGtraEditor::Class()
02478 {
02479 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGeoGtraEditor*)0x0)->GetClass();
02480 return fgIsA;
02481 }
02482
02483
02484 void TGeoVolumeEditor::Streamer(TBuffer &R__b)
02485 {
02486
02487
02488 TGeoGedFrame::Streamer(R__b);
02489 }
02490
02491
02492 void TGeoVolumeEditor::ShowMembers(TMemberInspector &R__insp)
02493 {
02494
02495 TClass *R__cl = ::TGeoVolumeEditor::IsA();
02496 if (R__cl || R__insp.IsA()) { }
02497 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeometry", &fGeometry);
02498 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolume", &fVolume);
02499 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
02500 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsAssembly", &fIsAssembly);
02501 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsDivided", &fIsDivided);
02502 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCategories", &fCategories);
02503 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeName", &fVolumeName);
02504 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedShape", &fSelectedShape);
02505 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelShape", &fLSelShape);
02506 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelShape", &fBSelShape);
02507 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMedium", &fSelectedMedium);
02508 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMedium", &fLSelMedium);
02509 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMedium", &fBSelMedium);
02510 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedVolume", &fSelectedVolume);
02511 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelVolume", &fLSelVolume);
02512 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelVolume", &fBSelVolume);
02513 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMatrix", &fSelectedMatrix);
02514 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMatrix", &fLSelMatrix);
02515 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMatrix", &fBSelMatrix);
02516 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCopyNumber", &fCopyNumber);
02517 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddNode", &fAddNode);
02518 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditShape", &fEditShape);
02519 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMedium", &fEditMedium);
02520 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeList", &fNodeList);
02521 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMatrix", &fEditMatrix);
02522 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRemoveNode", &fRemoveNode);
02523 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBVis[2]", &fBVis);
02524 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBView[3]", &fBView);
02525 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBRaytrace", &fBRaytrace);
02526 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBAuto", &fBAuto);
02527 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEVisLevel", &fEVisLevel);
02528 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyDiv", &fApplyDiv);
02529 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDivName", &fDivName);
02530 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBDiv[3]", &fBDiv);
02531 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDivFrom", &fEDivFrom);
02532 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDivStep", &fEDivStep);
02533 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDivN", &fEDivN);
02534 TGeoGedFrame::ShowMembers(R__insp);
02535 }
02536
02537 namespace ROOT {
02538
02539 static void *new_TGeoVolumeEditor(void *p) {
02540 return p ? new(p) ::TGeoVolumeEditor : new ::TGeoVolumeEditor;
02541 }
02542 static void *newArray_TGeoVolumeEditor(Long_t nElements, void *p) {
02543 return p ? new(p) ::TGeoVolumeEditor[nElements] : new ::TGeoVolumeEditor[nElements];
02544 }
02545
02546 static void delete_TGeoVolumeEditor(void *p) {
02547 delete ((::TGeoVolumeEditor*)p);
02548 }
02549 static void deleteArray_TGeoVolumeEditor(void *p) {
02550 delete [] ((::TGeoVolumeEditor*)p);
02551 }
02552 static void destruct_TGeoVolumeEditor(void *p) {
02553 typedef ::TGeoVolumeEditor current_t;
02554 ((current_t*)p)->~current_t();
02555 }
02556
02557 static void streamer_TGeoVolumeEditor(TBuffer &buf, void *obj) {
02558 ((::TGeoVolumeEditor*)obj)->::TGeoVolumeEditor::Streamer(buf);
02559 }
02560 }
02561
02562
02563 void TGeoBBoxEditor::Streamer(TBuffer &R__b)
02564 {
02565
02566
02567 TGeoGedFrame::Streamer(R__b);
02568 }
02569
02570
02571 void TGeoBBoxEditor::ShowMembers(TMemberInspector &R__insp)
02572 {
02573
02574 TClass *R__cl = ::TGeoBBoxEditor::IsA();
02575 if (R__cl || R__insp.IsA()) { }
02576 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi", &fDxi);
02577 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi", &fDyi);
02578 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
02579 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrigi[3]", fOrigi);
02580 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
02581 R__insp.InspectMember(fNamei, "fNamei.");
02582 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
02583 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
02584 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
02585 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
02586 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxDx", &fBoxDx);
02587 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxDy", &fBoxDy);
02588 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxDz", &fBoxDz);
02589 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxOx", &fBoxOx);
02590 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxOy", &fBoxOy);
02591 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBoxOz", &fBoxOz);
02592 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
02593 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
02594 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
02595 TGeoGedFrame::ShowMembers(R__insp);
02596 }
02597
02598 namespace ROOT {
02599
02600 static void *new_TGeoBBoxEditor(void *p) {
02601 return p ? new(p) ::TGeoBBoxEditor : new ::TGeoBBoxEditor;
02602 }
02603 static void *newArray_TGeoBBoxEditor(Long_t nElements, void *p) {
02604 return p ? new(p) ::TGeoBBoxEditor[nElements] : new ::TGeoBBoxEditor[nElements];
02605 }
02606
02607 static void delete_TGeoBBoxEditor(void *p) {
02608 delete ((::TGeoBBoxEditor*)p);
02609 }
02610 static void deleteArray_TGeoBBoxEditor(void *p) {
02611 delete [] ((::TGeoBBoxEditor*)p);
02612 }
02613 static void destruct_TGeoBBoxEditor(void *p) {
02614 typedef ::TGeoBBoxEditor current_t;
02615 ((current_t*)p)->~current_t();
02616 }
02617
02618 static void streamer_TGeoBBoxEditor(TBuffer &buf, void *obj) {
02619 ((::TGeoBBoxEditor*)obj)->::TGeoBBoxEditor::Streamer(buf);
02620 }
02621 }
02622
02623
02624 void TGeoTubeEditor::Streamer(TBuffer &R__b)
02625 {
02626
02627
02628 TGeoGedFrame::Streamer(R__b);
02629 }
02630
02631
02632 void TGeoTubeEditor::ShowMembers(TMemberInspector &R__insp)
02633 {
02634
02635 TClass *R__cl = ::TGeoTubeEditor::IsA();
02636 if (R__cl || R__insp.IsA()) { }
02637 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini", &fRmini);
02638 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi", &fRmaxi);
02639 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
02640 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
02641 R__insp.InspectMember(fNamei, "fNamei.");
02642 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
02643 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
02644 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
02645 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
02646 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin", &fERmin);
02647 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax", &fERmax);
02648 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
02649 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
02650 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
02651 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBFrame", &fBFrame);
02652 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
02653 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDFrame", &fDFrame);
02654 TGeoGedFrame::ShowMembers(R__insp);
02655 }
02656
02657 namespace ROOT {
02658
02659 static void *new_TGeoTubeEditor(void *p) {
02660 return p ? new(p) ::TGeoTubeEditor : new ::TGeoTubeEditor;
02661 }
02662 static void *newArray_TGeoTubeEditor(Long_t nElements, void *p) {
02663 return p ? new(p) ::TGeoTubeEditor[nElements] : new ::TGeoTubeEditor[nElements];
02664 }
02665
02666 static void delete_TGeoTubeEditor(void *p) {
02667 delete ((::TGeoTubeEditor*)p);
02668 }
02669 static void deleteArray_TGeoTubeEditor(void *p) {
02670 delete [] ((::TGeoTubeEditor*)p);
02671 }
02672 static void destruct_TGeoTubeEditor(void *p) {
02673 typedef ::TGeoTubeEditor current_t;
02674 ((current_t*)p)->~current_t();
02675 }
02676
02677 static void streamer_TGeoTubeEditor(TBuffer &buf, void *obj) {
02678 ((::TGeoTubeEditor*)obj)->::TGeoTubeEditor::Streamer(buf);
02679 }
02680 }
02681
02682
02683 void TGeoTubeSegEditor::Streamer(TBuffer &R__b)
02684 {
02685
02686
02687 TGeoTubeEditor::Streamer(R__b);
02688 }
02689
02690
02691 void TGeoTubeSegEditor::ShowMembers(TMemberInspector &R__insp)
02692 {
02693
02694 TClass *R__cl = ::TGeoTubeSegEditor::IsA();
02695 if (R__cl || R__insp.IsA()) { }
02696 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLock", &fLock);
02697 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPmini", &fPmini);
02698 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPmaxi", &fPmaxi);
02699 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSPhi", &fSPhi);
02700 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
02701 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi2", &fEPhi2);
02702 TGeoTubeEditor::ShowMembers(R__insp);
02703 }
02704
02705 namespace ROOT {
02706
02707 static void *new_TGeoTubeSegEditor(void *p) {
02708 return p ? new(p) ::TGeoTubeSegEditor : new ::TGeoTubeSegEditor;
02709 }
02710 static void *newArray_TGeoTubeSegEditor(Long_t nElements, void *p) {
02711 return p ? new(p) ::TGeoTubeSegEditor[nElements] : new ::TGeoTubeSegEditor[nElements];
02712 }
02713
02714 static void delete_TGeoTubeSegEditor(void *p) {
02715 delete ((::TGeoTubeSegEditor*)p);
02716 }
02717 static void deleteArray_TGeoTubeSegEditor(void *p) {
02718 delete [] ((::TGeoTubeSegEditor*)p);
02719 }
02720 static void destruct_TGeoTubeSegEditor(void *p) {
02721 typedef ::TGeoTubeSegEditor current_t;
02722 ((current_t*)p)->~current_t();
02723 }
02724
02725 static void streamer_TGeoTubeSegEditor(TBuffer &buf, void *obj) {
02726 ((::TGeoTubeSegEditor*)obj)->::TGeoTubeSegEditor::Streamer(buf);
02727 }
02728 }
02729
02730
02731 void TGeoCtubEditor::Streamer(TBuffer &R__b)
02732 {
02733
02734
02735 TGeoTubeSegEditor::Streamer(R__b);
02736 }
02737
02738
02739 void TGeoCtubEditor::ShowMembers(TMemberInspector &R__insp)
02740 {
02741
02742 TClass *R__cl = ::TGeoCtubEditor::IsA();
02743 if (R__cl || R__insp.IsA()) { }
02744 R__insp.Inspect(R__cl, R__insp.GetParent(), "fThlo", &fThlo);
02745 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhlo", &fPhlo);
02746 R__insp.Inspect(R__cl, R__insp.GetParent(), "fThhi", &fThhi);
02747 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhhi", &fPhhi);
02748 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEThlo", &fEThlo);
02749 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhlo", &fEPhlo);
02750 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEThhi", &fEThhi);
02751 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhhi", &fEPhhi);
02752 TGeoTubeSegEditor::ShowMembers(R__insp);
02753 }
02754
02755 namespace ROOT {
02756
02757 static void *new_TGeoCtubEditor(void *p) {
02758 return p ? new(p) ::TGeoCtubEditor : new ::TGeoCtubEditor;
02759 }
02760 static void *newArray_TGeoCtubEditor(Long_t nElements, void *p) {
02761 return p ? new(p) ::TGeoCtubEditor[nElements] : new ::TGeoCtubEditor[nElements];
02762 }
02763
02764 static void delete_TGeoCtubEditor(void *p) {
02765 delete ((::TGeoCtubEditor*)p);
02766 }
02767 static void deleteArray_TGeoCtubEditor(void *p) {
02768 delete [] ((::TGeoCtubEditor*)p);
02769 }
02770 static void destruct_TGeoCtubEditor(void *p) {
02771 typedef ::TGeoCtubEditor current_t;
02772 ((current_t*)p)->~current_t();
02773 }
02774
02775 static void streamer_TGeoCtubEditor(TBuffer &buf, void *obj) {
02776 ((::TGeoCtubEditor*)obj)->::TGeoCtubEditor::Streamer(buf);
02777 }
02778 }
02779
02780
02781 void TGeoEltuEditor::Streamer(TBuffer &R__b)
02782 {
02783
02784
02785 TGeoGedFrame::Streamer(R__b);
02786 }
02787
02788
02789 void TGeoEltuEditor::ShowMembers(TMemberInspector &R__insp)
02790 {
02791
02792 TClass *R__cl = ::TGeoEltuEditor::IsA();
02793 if (R__cl || R__insp.IsA()) { }
02794 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAi", &fAi);
02795 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBi", &fBi);
02796 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
02797 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
02798 R__insp.InspectMember(fNamei, "fNamei.");
02799 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
02800 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
02801 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
02802 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
02803 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEA", &fEA);
02804 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEB", &fEB);
02805 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
02806 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
02807 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
02808 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
02809 TGeoGedFrame::ShowMembers(R__insp);
02810 }
02811
02812 namespace ROOT {
02813
02814 static void *new_TGeoEltuEditor(void *p) {
02815 return p ? new(p) ::TGeoEltuEditor : new ::TGeoEltuEditor;
02816 }
02817 static void *newArray_TGeoEltuEditor(Long_t nElements, void *p) {
02818 return p ? new(p) ::TGeoEltuEditor[nElements] : new ::TGeoEltuEditor[nElements];
02819 }
02820
02821 static void delete_TGeoEltuEditor(void *p) {
02822 delete ((::TGeoEltuEditor*)p);
02823 }
02824 static void deleteArray_TGeoEltuEditor(void *p) {
02825 delete [] ((::TGeoEltuEditor*)p);
02826 }
02827 static void destruct_TGeoEltuEditor(void *p) {
02828 typedef ::TGeoEltuEditor current_t;
02829 ((current_t*)p)->~current_t();
02830 }
02831
02832 static void streamer_TGeoEltuEditor(TBuffer &buf, void *obj) {
02833 ((::TGeoEltuEditor*)obj)->::TGeoEltuEditor::Streamer(buf);
02834 }
02835 }
02836
02837
02838 void TGeoHypeEditor::Streamer(TBuffer &R__b)
02839 {
02840
02841
02842 TGeoGedFrame::Streamer(R__b);
02843 }
02844
02845
02846 void TGeoHypeEditor::ShowMembers(TMemberInspector &R__insp)
02847 {
02848
02849 TClass *R__cl = ::TGeoHypeEditor::IsA();
02850 if (R__cl || R__insp.IsA()) { }
02851 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRini", &fRini);
02852 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRouti", &fRouti);
02853 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
02854 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStIni", &fStIni);
02855 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStOuti", &fStOuti);
02856 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
02857 R__insp.InspectMember(fNamei, "fNamei.");
02858 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
02859 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
02860 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
02861 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
02862 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERin", &fERin);
02863 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERout", &fERout);
02864 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
02865 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEStIn", &fEStIn);
02866 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEStOut", &fEStOut);
02867 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
02868 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
02869 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
02870 TGeoGedFrame::ShowMembers(R__insp);
02871 }
02872
02873 namespace ROOT {
02874
02875 static void *new_TGeoHypeEditor(void *p) {
02876 return p ? new(p) ::TGeoHypeEditor : new ::TGeoHypeEditor;
02877 }
02878 static void *newArray_TGeoHypeEditor(Long_t nElements, void *p) {
02879 return p ? new(p) ::TGeoHypeEditor[nElements] : new ::TGeoHypeEditor[nElements];
02880 }
02881
02882 static void delete_TGeoHypeEditor(void *p) {
02883 delete ((::TGeoHypeEditor*)p);
02884 }
02885 static void deleteArray_TGeoHypeEditor(void *p) {
02886 delete [] ((::TGeoHypeEditor*)p);
02887 }
02888 static void destruct_TGeoHypeEditor(void *p) {
02889 typedef ::TGeoHypeEditor current_t;
02890 ((current_t*)p)->~current_t();
02891 }
02892
02893 static void streamer_TGeoHypeEditor(TBuffer &buf, void *obj) {
02894 ((::TGeoHypeEditor*)obj)->::TGeoHypeEditor::Streamer(buf);
02895 }
02896 }
02897
02898
02899 void TGeoConeEditor::Streamer(TBuffer &R__b)
02900 {
02901
02902
02903 TGeoGedFrame::Streamer(R__b);
02904 }
02905
02906
02907 void TGeoConeEditor::ShowMembers(TMemberInspector &R__insp)
02908 {
02909
02910 TClass *R__cl = ::TGeoConeEditor::IsA();
02911 if (R__cl || R__insp.IsA()) { }
02912 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini1", &fRmini1);
02913 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi1", &fRmaxi1);
02914 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini2", &fRmini2);
02915 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi2", &fRmaxi2);
02916 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
02917 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
02918 R__insp.InspectMember(fNamei, "fNamei.");
02919 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
02920 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
02921 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
02922 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
02923 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin1", &fERmin1);
02924 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin2", &fERmin2);
02925 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax1", &fERmax1);
02926 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax2", &fERmax2);
02927 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
02928 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
02929 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
02930 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBFrame", &fBFrame);
02931 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
02932 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDFrame", &fDFrame);
02933 TGeoGedFrame::ShowMembers(R__insp);
02934 }
02935
02936 namespace ROOT {
02937
02938 static void *new_TGeoConeEditor(void *p) {
02939 return p ? new(p) ::TGeoConeEditor : new ::TGeoConeEditor;
02940 }
02941 static void *newArray_TGeoConeEditor(Long_t nElements, void *p) {
02942 return p ? new(p) ::TGeoConeEditor[nElements] : new ::TGeoConeEditor[nElements];
02943 }
02944
02945 static void delete_TGeoConeEditor(void *p) {
02946 delete ((::TGeoConeEditor*)p);
02947 }
02948 static void deleteArray_TGeoConeEditor(void *p) {
02949 delete [] ((::TGeoConeEditor*)p);
02950 }
02951 static void destruct_TGeoConeEditor(void *p) {
02952 typedef ::TGeoConeEditor current_t;
02953 ((current_t*)p)->~current_t();
02954 }
02955
02956 static void streamer_TGeoConeEditor(TBuffer &buf, void *obj) {
02957 ((::TGeoConeEditor*)obj)->::TGeoConeEditor::Streamer(buf);
02958 }
02959 }
02960
02961
02962 void TGeoConeSegEditor::Streamer(TBuffer &R__b)
02963 {
02964
02965
02966 TGeoConeEditor::Streamer(R__b);
02967 }
02968
02969
02970 void TGeoConeSegEditor::ShowMembers(TMemberInspector &R__insp)
02971 {
02972
02973 TClass *R__cl = ::TGeoConeSegEditor::IsA();
02974 if (R__cl || R__insp.IsA()) { }
02975 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLock", &fLock);
02976 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPmini", &fPmini);
02977 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPmaxi", &fPmaxi);
02978 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSPhi", &fSPhi);
02979 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
02980 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi2", &fEPhi2);
02981 TGeoConeEditor::ShowMembers(R__insp);
02982 }
02983
02984 namespace ROOT {
02985
02986 static void *new_TGeoConeSegEditor(void *p) {
02987 return p ? new(p) ::TGeoConeSegEditor : new ::TGeoConeSegEditor;
02988 }
02989 static void *newArray_TGeoConeSegEditor(Long_t nElements, void *p) {
02990 return p ? new(p) ::TGeoConeSegEditor[nElements] : new ::TGeoConeSegEditor[nElements];
02991 }
02992
02993 static void delete_TGeoConeSegEditor(void *p) {
02994 delete ((::TGeoConeSegEditor*)p);
02995 }
02996 static void deleteArray_TGeoConeSegEditor(void *p) {
02997 delete [] ((::TGeoConeSegEditor*)p);
02998 }
02999 static void destruct_TGeoConeSegEditor(void *p) {
03000 typedef ::TGeoConeSegEditor current_t;
03001 ((current_t*)p)->~current_t();
03002 }
03003
03004 static void streamer_TGeoConeSegEditor(TBuffer &buf, void *obj) {
03005 ((::TGeoConeSegEditor*)obj)->::TGeoConeSegEditor::Streamer(buf);
03006 }
03007 }
03008
03009
03010 void TGeoTrd1Editor::Streamer(TBuffer &R__b)
03011 {
03012
03013
03014 TGeoGedFrame::Streamer(R__b);
03015 }
03016
03017
03018 void TGeoTrd1Editor::ShowMembers(TMemberInspector &R__insp)
03019 {
03020
03021 TClass *R__cl = ::TGeoTrd1Editor::IsA();
03022 if (R__cl || R__insp.IsA()) { }
03023 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi1", &fDxi1);
03024 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi2", &fDxi2);
03025 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi", &fDyi);
03026 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
03027 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03028 R__insp.InspectMember(fNamei, "fNamei.");
03029 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
03030 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03031 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
03032 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
03033 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx1", &fEDx1);
03034 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx2", &fEDx2);
03035 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDy", &fEDy);
03036 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
03037 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03038 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03039 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
03040 TGeoGedFrame::ShowMembers(R__insp);
03041 }
03042
03043 namespace ROOT {
03044
03045 static void *new_TGeoTrd1Editor(void *p) {
03046 return p ? new(p) ::TGeoTrd1Editor : new ::TGeoTrd1Editor;
03047 }
03048 static void *newArray_TGeoTrd1Editor(Long_t nElements, void *p) {
03049 return p ? new(p) ::TGeoTrd1Editor[nElements] : new ::TGeoTrd1Editor[nElements];
03050 }
03051
03052 static void delete_TGeoTrd1Editor(void *p) {
03053 delete ((::TGeoTrd1Editor*)p);
03054 }
03055 static void deleteArray_TGeoTrd1Editor(void *p) {
03056 delete [] ((::TGeoTrd1Editor*)p);
03057 }
03058 static void destruct_TGeoTrd1Editor(void *p) {
03059 typedef ::TGeoTrd1Editor current_t;
03060 ((current_t*)p)->~current_t();
03061 }
03062
03063 static void streamer_TGeoTrd1Editor(TBuffer &buf, void *obj) {
03064 ((::TGeoTrd1Editor*)obj)->::TGeoTrd1Editor::Streamer(buf);
03065 }
03066 }
03067
03068
03069 void TGeoParaEditor::Streamer(TBuffer &R__b)
03070 {
03071
03072
03073 TGeoGedFrame::Streamer(R__b);
03074 }
03075
03076
03077 void TGeoParaEditor::ShowMembers(TMemberInspector &R__insp)
03078 {
03079
03080 TClass *R__cl = ::TGeoParaEditor::IsA();
03081 if (R__cl || R__insp.IsA()) { }
03082 R__insp.Inspect(R__cl, R__insp.GetParent(), "fXi", &fXi);
03083 R__insp.Inspect(R__cl, R__insp.GetParent(), "fYi", &fYi);
03084 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZi", &fZi);
03085 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlphai", &fAlphai);
03086 R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetai", &fThetai);
03087 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhii", &fPhii);
03088 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03089 R__insp.InspectMember(fNamei, "fNamei.");
03090 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
03091 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03092 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
03093 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
03094 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx", &fEDx);
03095 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDy", &fEDy);
03096 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
03097 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEAlpha", &fEAlpha);
03098 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETheta", &fETheta);
03099 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi", &fEPhi);
03100 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03101 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03102 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
03103 TGeoGedFrame::ShowMembers(R__insp);
03104 }
03105
03106 namespace ROOT {
03107
03108 static void *new_TGeoParaEditor(void *p) {
03109 return p ? new(p) ::TGeoParaEditor : new ::TGeoParaEditor;
03110 }
03111 static void *newArray_TGeoParaEditor(Long_t nElements, void *p) {
03112 return p ? new(p) ::TGeoParaEditor[nElements] : new ::TGeoParaEditor[nElements];
03113 }
03114
03115 static void delete_TGeoParaEditor(void *p) {
03116 delete ((::TGeoParaEditor*)p);
03117 }
03118 static void deleteArray_TGeoParaEditor(void *p) {
03119 delete [] ((::TGeoParaEditor*)p);
03120 }
03121 static void destruct_TGeoParaEditor(void *p) {
03122 typedef ::TGeoParaEditor current_t;
03123 ((current_t*)p)->~current_t();
03124 }
03125
03126 static void streamer_TGeoParaEditor(TBuffer &buf, void *obj) {
03127 ((::TGeoParaEditor*)obj)->::TGeoParaEditor::Streamer(buf);
03128 }
03129 }
03130
03131
03132 void TGeoTorusEditor::Streamer(TBuffer &R__b)
03133 {
03134
03135
03136 TGeoGedFrame::Streamer(R__b);
03137 }
03138
03139
03140 void TGeoTorusEditor::ShowMembers(TMemberInspector &R__insp)
03141 {
03142
03143 TClass *R__cl = ::TGeoTorusEditor::IsA();
03144 if (R__cl || R__insp.IsA()) { }
03145 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRi", &fRi);
03146 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini", &fRmini);
03147 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi", &fRmaxi);
03148 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1i", &fPhi1i);
03149 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDphii", &fDphii);
03150 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03151 R__insp.InspectMember(fNamei, "fNamei.");
03152 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
03153 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03154 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
03155 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
03156 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fER", &fER);
03157 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin", &fERmin);
03158 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax", &fERmax);
03159 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
03160 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDphi", &fEDphi);
03161 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03162 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03163 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
03164 TGeoGedFrame::ShowMembers(R__insp);
03165 }
03166
03167 namespace ROOT {
03168
03169 static void *new_TGeoTorusEditor(void *p) {
03170 return p ? new(p) ::TGeoTorusEditor : new ::TGeoTorusEditor;
03171 }
03172 static void *newArray_TGeoTorusEditor(Long_t nElements, void *p) {
03173 return p ? new(p) ::TGeoTorusEditor[nElements] : new ::TGeoTorusEditor[nElements];
03174 }
03175
03176 static void delete_TGeoTorusEditor(void *p) {
03177 delete ((::TGeoTorusEditor*)p);
03178 }
03179 static void deleteArray_TGeoTorusEditor(void *p) {
03180 delete [] ((::TGeoTorusEditor*)p);
03181 }
03182 static void destruct_TGeoTorusEditor(void *p) {
03183 typedef ::TGeoTorusEditor current_t;
03184 ((current_t*)p)->~current_t();
03185 }
03186
03187 static void streamer_TGeoTorusEditor(TBuffer &buf, void *obj) {
03188 ((::TGeoTorusEditor*)obj)->::TGeoTorusEditor::Streamer(buf);
03189 }
03190 }
03191
03192
03193 void TGeoPconEditor::Streamer(TBuffer &R__b)
03194 {
03195
03196
03197 TGeoGedFrame::Streamer(R__b);
03198 }
03199
03200
03201 void TGeoPconEditor::ShowMembers(TMemberInspector &R__insp)
03202 {
03203
03204 TClass *R__cl = ::TGeoPconEditor::IsA();
03205 if (R__cl || R__insp.IsA()) { }
03206 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsecti", &fNsecti);
03207 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1i", &fPhi1i);
03208 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDPhii", &fDPhii);
03209 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZi", &fZi);
03210 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmini", &fRmini);
03211 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmaxi", &fRmaxi);
03212 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsections", &fNsections);
03213 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSections", &fSections);
03214 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCan", &fCan);
03215 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
03216 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03217 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
03218 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLHsect", &fLHsect);
03219 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
03220 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fENz", &fENz);
03221 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
03222 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDPhi", &fEDPhi);
03223 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03224 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03225 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBFrame", &fBFrame);
03226 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
03227 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDFrame", &fDFrame);
03228 TGeoGedFrame::ShowMembers(R__insp);
03229 }
03230
03231 namespace ROOT {
03232
03233 static void *new_TGeoPconEditor(void *p) {
03234 return p ? new(p) ::TGeoPconEditor : new ::TGeoPconEditor;
03235 }
03236 static void *newArray_TGeoPconEditor(Long_t nElements, void *p) {
03237 return p ? new(p) ::TGeoPconEditor[nElements] : new ::TGeoPconEditor[nElements];
03238 }
03239
03240 static void delete_TGeoPconEditor(void *p) {
03241 delete ((::TGeoPconEditor*)p);
03242 }
03243 static void deleteArray_TGeoPconEditor(void *p) {
03244 delete [] ((::TGeoPconEditor*)p);
03245 }
03246 static void destruct_TGeoPconEditor(void *p) {
03247 typedef ::TGeoPconEditor current_t;
03248 ((current_t*)p)->~current_t();
03249 }
03250
03251 static void streamer_TGeoPconEditor(TBuffer &buf, void *obj) {
03252 ((::TGeoPconEditor*)obj)->::TGeoPconEditor::Streamer(buf);
03253 }
03254 }
03255
03256
03257 void TGeoPconSection::Streamer(TBuffer &R__b)
03258 {
03259
03260
03261 TGCompositeFrame::Streamer(R__b);
03262 TGWidget::Streamer(R__b);
03263 }
03264
03265
03266 void TGeoPconSection::ShowMembers(TMemberInspector &R__insp)
03267 {
03268
03269 TClass *R__cl = ::TGeoPconSection::IsA();
03270 if (R__cl || R__insp.IsA()) { }
03271 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumber", &fNumber);
03272 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEZ", &fEZ);
03273 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin", &fERmin);
03274 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax", &fERmax);
03275 TGCompositeFrame::ShowMembers(R__insp);
03276 TGWidget::ShowMembers(R__insp);
03277 }
03278
03279 namespace ROOT {
03280
03281 static void delete_TGeoPconSection(void *p) {
03282 delete ((::TGeoPconSection*)p);
03283 }
03284 static void deleteArray_TGeoPconSection(void *p) {
03285 delete [] ((::TGeoPconSection*)p);
03286 }
03287 static void destruct_TGeoPconSection(void *p) {
03288 typedef ::TGeoPconSection current_t;
03289 ((current_t*)p)->~current_t();
03290 }
03291
03292 static void streamer_TGeoPconSection(TBuffer &buf, void *obj) {
03293 ((::TGeoPconSection*)obj)->::TGeoPconSection::Streamer(buf);
03294 }
03295 }
03296
03297
03298 void TGeoPgonEditor::Streamer(TBuffer &R__b)
03299 {
03300
03301
03302 TGeoPconEditor::Streamer(R__b);
03303 }
03304
03305
03306 void TGeoPgonEditor::ShowMembers(TMemberInspector &R__insp)
03307 {
03308
03309 TClass *R__cl = ::TGeoPgonEditor::IsA();
03310 if (R__cl || R__insp.IsA()) { }
03311 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNedgesi", &fNedgesi);
03312 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fENedges", &fENedges);
03313 TGeoPconEditor::ShowMembers(R__insp);
03314 }
03315
03316 namespace ROOT {
03317
03318 static void *new_TGeoPgonEditor(void *p) {
03319 return p ? new(p) ::TGeoPgonEditor : new ::TGeoPgonEditor;
03320 }
03321 static void *newArray_TGeoPgonEditor(Long_t nElements, void *p) {
03322 return p ? new(p) ::TGeoPgonEditor[nElements] : new ::TGeoPgonEditor[nElements];
03323 }
03324
03325 static void delete_TGeoPgonEditor(void *p) {
03326 delete ((::TGeoPgonEditor*)p);
03327 }
03328 static void deleteArray_TGeoPgonEditor(void *p) {
03329 delete [] ((::TGeoPgonEditor*)p);
03330 }
03331 static void destruct_TGeoPgonEditor(void *p) {
03332 typedef ::TGeoPgonEditor current_t;
03333 ((current_t*)p)->~current_t();
03334 }
03335
03336 static void streamer_TGeoPgonEditor(TBuffer &buf, void *obj) {
03337 ((::TGeoPgonEditor*)obj)->::TGeoPgonEditor::Streamer(buf);
03338 }
03339 }
03340
03341
03342 void TGeoTrd2Editor::Streamer(TBuffer &R__b)
03343 {
03344
03345
03346 TGeoGedFrame::Streamer(R__b);
03347 }
03348
03349
03350 void TGeoTrd2Editor::ShowMembers(TMemberInspector &R__insp)
03351 {
03352
03353 TClass *R__cl = ::TGeoTrd2Editor::IsA();
03354 if (R__cl || R__insp.IsA()) { }
03355 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi1", &fDxi1);
03356 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi2", &fDxi2);
03357 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi1", &fDyi1);
03358 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi2", &fDyi2);
03359 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
03360 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03361 R__insp.InspectMember(fNamei, "fNamei.");
03362 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
03363 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03364 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
03365 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
03366 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx1", &fEDx1);
03367 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDx2", &fEDx2);
03368 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDy1", &fEDy1);
03369 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDy2", &fEDy2);
03370 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
03371 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03372 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03373 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
03374 TGeoGedFrame::ShowMembers(R__insp);
03375 }
03376
03377 namespace ROOT {
03378
03379 static void *new_TGeoTrd2Editor(void *p) {
03380 return p ? new(p) ::TGeoTrd2Editor : new ::TGeoTrd2Editor;
03381 }
03382 static void *newArray_TGeoTrd2Editor(Long_t nElements, void *p) {
03383 return p ? new(p) ::TGeoTrd2Editor[nElements] : new ::TGeoTrd2Editor[nElements];
03384 }
03385
03386 static void delete_TGeoTrd2Editor(void *p) {
03387 delete ((::TGeoTrd2Editor*)p);
03388 }
03389 static void deleteArray_TGeoTrd2Editor(void *p) {
03390 delete [] ((::TGeoTrd2Editor*)p);
03391 }
03392 static void destruct_TGeoTrd2Editor(void *p) {
03393 typedef ::TGeoTrd2Editor current_t;
03394 ((current_t*)p)->~current_t();
03395 }
03396
03397 static void streamer_TGeoTrd2Editor(TBuffer &buf, void *obj) {
03398 ((::TGeoTrd2Editor*)obj)->::TGeoTrd2Editor::Streamer(buf);
03399 }
03400 }
03401
03402
03403 void TGeoTrapEditor::Streamer(TBuffer &R__b)
03404 {
03405
03406
03407 TGeoGedFrame::Streamer(R__b);
03408 }
03409
03410
03411 void TGeoTrapEditor::ShowMembers(TMemberInspector &R__insp)
03412 {
03413
03414 TClass *R__cl = ::TGeoTrapEditor::IsA();
03415 if (R__cl || R__insp.IsA()) { }
03416 R__insp.Inspect(R__cl, R__insp.GetParent(), "fH1i", &fH1i);
03417 R__insp.Inspect(R__cl, R__insp.GetParent(), "fBl1i", &fBl1i);
03418 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTl1i", &fTl1i);
03419 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
03420 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSci", &fSci);
03421 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha1i", &fAlpha1i);
03422 R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetai", &fThetai);
03423 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhii", &fPhii);
03424 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03425 R__insp.InspectMember(fNamei, "fNamei.");
03426 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
03427 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03428 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
03429 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
03430 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEH1", &fEH1);
03431 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEBl1", &fEBl1);
03432 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETl1", &fETl1);
03433 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fESc1", &fESc1);
03434 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fESc2", &fESc2);
03435 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEDz", &fEDz);
03436 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEAlpha1", &fEAlpha1);
03437 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETheta", &fETheta);
03438 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi", &fEPhi);
03439 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03440 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03441 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBFrame", &fBFrame);
03442 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
03443 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDFrame", &fDFrame);
03444 TGeoGedFrame::ShowMembers(R__insp);
03445 }
03446
03447 namespace ROOT {
03448
03449 static void *new_TGeoTrapEditor(void *p) {
03450 return p ? new(p) ::TGeoTrapEditor : new ::TGeoTrapEditor;
03451 }
03452 static void *newArray_TGeoTrapEditor(Long_t nElements, void *p) {
03453 return p ? new(p) ::TGeoTrapEditor[nElements] : new ::TGeoTrapEditor[nElements];
03454 }
03455
03456 static void delete_TGeoTrapEditor(void *p) {
03457 delete ((::TGeoTrapEditor*)p);
03458 }
03459 static void deleteArray_TGeoTrapEditor(void *p) {
03460 delete [] ((::TGeoTrapEditor*)p);
03461 }
03462 static void destruct_TGeoTrapEditor(void *p) {
03463 typedef ::TGeoTrapEditor current_t;
03464 ((current_t*)p)->~current_t();
03465 }
03466
03467 static void streamer_TGeoTrapEditor(TBuffer &buf, void *obj) {
03468 ((::TGeoTrapEditor*)obj)->::TGeoTrapEditor::Streamer(buf);
03469 }
03470 }
03471
03472
03473 void TGeoGtraEditor::Streamer(TBuffer &R__b)
03474 {
03475
03476
03477 TGeoTrapEditor::Streamer(R__b);
03478 }
03479
03480
03481 void TGeoGtraEditor::ShowMembers(TMemberInspector &R__insp)
03482 {
03483
03484 TClass *R__cl = ::TGeoGtraEditor::IsA();
03485 if (R__cl || R__insp.IsA()) { }
03486 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTwisti", &fTwisti);
03487 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETwist", &fETwist);
03488 TGeoTrapEditor::ShowMembers(R__insp);
03489 }
03490
03491 namespace ROOT {
03492
03493 static void *new_TGeoGtraEditor(void *p) {
03494 return p ? new(p) ::TGeoGtraEditor : new ::TGeoGtraEditor;
03495 }
03496 static void *newArray_TGeoGtraEditor(Long_t nElements, void *p) {
03497 return p ? new(p) ::TGeoGtraEditor[nElements] : new ::TGeoGtraEditor[nElements];
03498 }
03499
03500 static void delete_TGeoGtraEditor(void *p) {
03501 delete ((::TGeoGtraEditor*)p);
03502 }
03503 static void deleteArray_TGeoGtraEditor(void *p) {
03504 delete [] ((::TGeoGtraEditor*)p);
03505 }
03506 static void destruct_TGeoGtraEditor(void *p) {
03507 typedef ::TGeoGtraEditor current_t;
03508 ((current_t*)p)->~current_t();
03509 }
03510
03511 static void streamer_TGeoGtraEditor(TBuffer &buf, void *obj) {
03512 ((::TGeoGtraEditor*)obj)->::TGeoGtraEditor::Streamer(buf);
03513 }
03514 }
03515
03516
03517 void TGeoSphereEditor::Streamer(TBuffer &R__b)
03518 {
03519
03520
03521 TGeoGedFrame::Streamer(R__b);
03522 }
03523
03524
03525 void TGeoSphereEditor::ShowMembers(TMemberInspector &R__insp)
03526 {
03527
03528 TClass *R__cl = ::TGeoSphereEditor::IsA();
03529 if (R__cl || R__insp.IsA()) { }
03530 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmini", &fRmini);
03531 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmaxi", &fRmaxi);
03532 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta1i", &fTheta1i);
03533 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta2i", &fTheta2i);
03534 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi1i", &fPhi1i);
03535 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhi2i", &fPhi2i);
03536 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03537 R__insp.InspectMember(fNamei, "fNamei.");
03538 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
03539 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03540 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShapeEditable", &fIsShapeEditable);
03541 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLock", &fLock);
03542 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeName", &fShapeName);
03543 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmin", &fERmin);
03544 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fERmax", &fERmax);
03545 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETheta1", &fETheta1);
03546 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fETheta2", &fETheta2);
03547 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi1", &fEPhi1);
03548 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEPhi2", &fEPhi2);
03549 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSPhi", &fSPhi);
03550 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSTheta", &fSTheta);
03551 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03552 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03553 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelayed", &fDelayed);
03554 TGeoGedFrame::ShowMembers(R__insp);
03555 }
03556
03557 namespace ROOT {
03558
03559 static void *new_TGeoSphereEditor(void *p) {
03560 return p ? new(p) ::TGeoSphereEditor : new ::TGeoSphereEditor;
03561 }
03562 static void *newArray_TGeoSphereEditor(Long_t nElements, void *p) {
03563 return p ? new(p) ::TGeoSphereEditor[nElements] : new ::TGeoSphereEditor[nElements];
03564 }
03565
03566 static void delete_TGeoSphereEditor(void *p) {
03567 delete ((::TGeoSphereEditor*)p);
03568 }
03569 static void deleteArray_TGeoSphereEditor(void *p) {
03570 delete [] ((::TGeoSphereEditor*)p);
03571 }
03572 static void destruct_TGeoSphereEditor(void *p) {
03573 typedef ::TGeoSphereEditor current_t;
03574 ((current_t*)p)->~current_t();
03575 }
03576
03577 static void streamer_TGeoSphereEditor(TBuffer &buf, void *obj) {
03578 ((::TGeoSphereEditor*)obj)->::TGeoSphereEditor::Streamer(buf);
03579 }
03580 }
03581
03582
03583 void TGeoMediumEditor::Streamer(TBuffer &R__b)
03584 {
03585
03586
03587 TGeoGedFrame::Streamer(R__b);
03588 }
03589
03590
03591 void TGeoMediumEditor::ShowMembers(TMemberInspector &R__insp)
03592 {
03593
03594 TClass *R__cl = ::TGeoMediumEditor::IsA();
03595 if (R__cl || R__insp.IsA()) { }
03596 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedium", &fMedium);
03597 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
03598 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03599 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedName", &fMedName);
03600 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedId", &fMedId);
03601 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMaterial", &fSelectedMaterial);
03602 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMaterial", &fLSelMaterial);
03603 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMaterial", &fBSelMaterial);
03604 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMaterial", &fEditMaterial);
03605 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedSensitive", &fMedSensitive);
03606 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMagfldOption", &fMagfldOption);
03607 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedFieldm", &fMedFieldm);
03608 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedTmaxfd", &fMedTmaxfd);
03609 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedStemax", &fMedStemax);
03610 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedDeemax", &fMedDeemax);
03611 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedEpsil", &fMedEpsil);
03612 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMedStmin", &fMedStmin);
03613 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03614 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03615 TGeoGedFrame::ShowMembers(R__insp);
03616 }
03617
03618 namespace ROOT {
03619
03620 static void *new_TGeoMediumEditor(void *p) {
03621 return p ? new(p) ::TGeoMediumEditor : new ::TGeoMediumEditor;
03622 }
03623 static void *newArray_TGeoMediumEditor(Long_t nElements, void *p) {
03624 return p ? new(p) ::TGeoMediumEditor[nElements] : new ::TGeoMediumEditor[nElements];
03625 }
03626
03627 static void delete_TGeoMediumEditor(void *p) {
03628 delete ((::TGeoMediumEditor*)p);
03629 }
03630 static void deleteArray_TGeoMediumEditor(void *p) {
03631 delete [] ((::TGeoMediumEditor*)p);
03632 }
03633 static void destruct_TGeoMediumEditor(void *p) {
03634 typedef ::TGeoMediumEditor current_t;
03635 ((current_t*)p)->~current_t();
03636 }
03637
03638 static void streamer_TGeoMediumEditor(TBuffer &buf, void *obj) {
03639 ((::TGeoMediumEditor*)obj)->::TGeoMediumEditor::Streamer(buf);
03640 }
03641 }
03642
03643
03644 void TGeoMaterialEditor::Streamer(TBuffer &R__b)
03645 {
03646
03647
03648 TGeoGedFrame::Streamer(R__b);
03649 }
03650
03651
03652 void TGeoMaterialEditor::ShowMembers(TMemberInspector &R__insp)
03653 {
03654
03655 TClass *R__cl = ::TGeoMaterialEditor::IsA();
03656 if (R__cl || R__insp.IsA()) { }
03657 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAi", &fAi);
03658 R__insp.Inspect(R__cl, R__insp.GetParent(), "fZi", &fZi);
03659 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatei", &fStatei);
03660 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDensityi", &fDensityi);
03661 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTempi", &fTempi);
03662 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPresi", &fPresi);
03663 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03664 R__insp.InspectMember(fNamei, "fNamei.");
03665 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterial", &fMaterial);
03666 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03667 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsMaterialEditable", &fIsMaterialEditable);
03668 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialName", &fMaterialName);
03669 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatA", &fMatA);
03670 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatZ", &fMatZ);
03671 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatState", &fMatState);
03672 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatDensity", &fMatDensity);
03673 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatTemperature", &fMatTemperature);
03674 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatPressure", &fMatPressure);
03675 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatRadLen", &fMatRadLen);
03676 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatAbsLen", &fMatAbsLen);
03677 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f23", &f23);
03678 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03679 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03680 TGeoGedFrame::ShowMembers(R__insp);
03681 }
03682
03683 namespace ROOT {
03684
03685 static void *new_TGeoMaterialEditor(void *p) {
03686 return p ? new(p) ::TGeoMaterialEditor : new ::TGeoMaterialEditor;
03687 }
03688 static void *newArray_TGeoMaterialEditor(Long_t nElements, void *p) {
03689 return p ? new(p) ::TGeoMaterialEditor[nElements] : new ::TGeoMaterialEditor[nElements];
03690 }
03691
03692 static void delete_TGeoMaterialEditor(void *p) {
03693 delete ((::TGeoMaterialEditor*)p);
03694 }
03695 static void deleteArray_TGeoMaterialEditor(void *p) {
03696 delete [] ((::TGeoMaterialEditor*)p);
03697 }
03698 static void destruct_TGeoMaterialEditor(void *p) {
03699 typedef ::TGeoMaterialEditor current_t;
03700 ((current_t*)p)->~current_t();
03701 }
03702
03703 static void streamer_TGeoMaterialEditor(TBuffer &buf, void *obj) {
03704 ((::TGeoMaterialEditor*)obj)->::TGeoMaterialEditor::Streamer(buf);
03705 }
03706 }
03707
03708
03709 void TGeoMixtureEditor::Streamer(TBuffer &R__b)
03710 {
03711
03712
03713 TGeoMaterialEditor::Streamer(R__b);
03714 }
03715
03716
03717 void TGeoMixtureEditor::ShowMembers(TMemberInspector &R__insp)
03718 {
03719
03720 TClass *R__cl = ::TGeoMixtureEditor::IsA();
03721 if (R__cl || R__insp.IsA()) { }
03722 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMixture", &fMixture);
03723 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMixElem", &fMixElem);
03724 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNelem", &fNelem);
03725 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAelem", &fAelem);
03726 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZelem", &fZelem);
03727 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChkFraction", &fChkFraction);
03728 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNEFraction", &fNEFraction);
03729 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChkNatoms", &fChkNatoms);
03730 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNENatoms", &fNENatoms);
03731 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBAddElem", &fBAddElem);
03732 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fComps", &fComps);
03733 TGeoMaterialEditor::ShowMembers(R__insp);
03734 }
03735
03736 namespace ROOT {
03737
03738 static void *new_TGeoMixtureEditor(void *p) {
03739 return p ? new(p) ::TGeoMixtureEditor : new ::TGeoMixtureEditor;
03740 }
03741 static void *newArray_TGeoMixtureEditor(Long_t nElements, void *p) {
03742 return p ? new(p) ::TGeoMixtureEditor[nElements] : new ::TGeoMixtureEditor[nElements];
03743 }
03744
03745 static void delete_TGeoMixtureEditor(void *p) {
03746 delete ((::TGeoMixtureEditor*)p);
03747 }
03748 static void deleteArray_TGeoMixtureEditor(void *p) {
03749 delete [] ((::TGeoMixtureEditor*)p);
03750 }
03751 static void destruct_TGeoMixtureEditor(void *p) {
03752 typedef ::TGeoMixtureEditor current_t;
03753 ((current_t*)p)->~current_t();
03754 }
03755
03756 static void streamer_TGeoMixtureEditor(TBuffer &buf, void *obj) {
03757 ((::TGeoMixtureEditor*)obj)->::TGeoMixtureEditor::Streamer(buf);
03758 }
03759 }
03760
03761
03762 void TGeoNodeEditor::Streamer(TBuffer &R__b)
03763 {
03764
03765
03766 TGeoGedFrame::Streamer(R__b);
03767 }
03768
03769
03770 void TGeoNodeEditor::ShowMembers(TMemberInspector &R__insp)
03771 {
03772
03773 TClass *R__cl = ::TGeoNodeEditor::IsA();
03774 if (R__cl || R__insp.IsA()) { }
03775 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNode", &fNode);
03776 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
03777 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeName", &fNodeName);
03778 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeNumber", &fNodeNumber);
03779 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedVolume", &fSelectedVolume);
03780 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelVolume", &fLSelVolume);
03781 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelVolume", &fBSelVolume);
03782 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMother", &fSelectedMother);
03783 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMother", &fLSelMother);
03784 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMother", &fBSelMother);
03785 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMatrix", &fSelectedMatrix);
03786 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMatrix", &fLSelMatrix);
03787 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMatrix", &fBSelMatrix);
03788 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMother", &fEditMother);
03789 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditVolume", &fEditVolume);
03790 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMatrix", &fEditMatrix);
03791 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03792 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
03793 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03794 TGeoGedFrame::ShowMembers(R__insp);
03795 }
03796
03797 namespace ROOT {
03798
03799 static void *new_TGeoNodeEditor(void *p) {
03800 return p ? new(p) ::TGeoNodeEditor : new ::TGeoNodeEditor;
03801 }
03802 static void *newArray_TGeoNodeEditor(Long_t nElements, void *p) {
03803 return p ? new(p) ::TGeoNodeEditor[nElements] : new ::TGeoNodeEditor[nElements];
03804 }
03805
03806 static void delete_TGeoNodeEditor(void *p) {
03807 delete ((::TGeoNodeEditor*)p);
03808 }
03809 static void deleteArray_TGeoNodeEditor(void *p) {
03810 delete [] ((::TGeoNodeEditor*)p);
03811 }
03812 static void destruct_TGeoNodeEditor(void *p) {
03813 typedef ::TGeoNodeEditor current_t;
03814 ((current_t*)p)->~current_t();
03815 }
03816
03817 static void streamer_TGeoNodeEditor(TBuffer &buf, void *obj) {
03818 ((::TGeoNodeEditor*)obj)->::TGeoNodeEditor::Streamer(buf);
03819 }
03820 }
03821
03822
03823 void TGeoTranslationEditor::Streamer(TBuffer &R__b)
03824 {
03825
03826
03827 TGeoGedFrame::Streamer(R__b);
03828 }
03829
03830
03831 void TGeoTranslationEditor::ShowMembers(TMemberInspector &R__insp)
03832 {
03833
03834 TClass *R__cl = ::TGeoTranslationEditor::IsA();
03835 if (R__cl || R__insp.IsA()) { }
03836 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi", &fDxi);
03837 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi", &fDyi);
03838 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
03839 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03840 R__insp.InspectMember(fNamei, "fNamei.");
03841 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTranslation", &fTranslation);
03842 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03843 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
03844 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransName", &fTransName);
03845 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDx", &fTransDx);
03846 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDy", &fTransDy);
03847 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDz", &fTransDz);
03848 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03849 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
03850 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03851 TGeoGedFrame::ShowMembers(R__insp);
03852 }
03853
03854 namespace ROOT {
03855
03856 static void *new_TGeoTranslationEditor(void *p) {
03857 return p ? new(p) ::TGeoTranslationEditor : new ::TGeoTranslationEditor;
03858 }
03859 static void *newArray_TGeoTranslationEditor(Long_t nElements, void *p) {
03860 return p ? new(p) ::TGeoTranslationEditor[nElements] : new ::TGeoTranslationEditor[nElements];
03861 }
03862
03863 static void delete_TGeoTranslationEditor(void *p) {
03864 delete ((::TGeoTranslationEditor*)p);
03865 }
03866 static void deleteArray_TGeoTranslationEditor(void *p) {
03867 delete [] ((::TGeoTranslationEditor*)p);
03868 }
03869 static void destruct_TGeoTranslationEditor(void *p) {
03870 typedef ::TGeoTranslationEditor current_t;
03871 ((current_t*)p)->~current_t();
03872 }
03873
03874 static void streamer_TGeoTranslationEditor(TBuffer &buf, void *obj) {
03875 ((::TGeoTranslationEditor*)obj)->::TGeoTranslationEditor::Streamer(buf);
03876 }
03877 }
03878
03879
03880 void TGeoRotationEditor::Streamer(TBuffer &R__b)
03881 {
03882
03883
03884 TGeoGedFrame::Streamer(R__b);
03885 }
03886
03887
03888 void TGeoRotationEditor::ShowMembers(TMemberInspector &R__insp)
03889 {
03890
03891 TClass *R__cl = ::TGeoRotationEditor::IsA();
03892 if (R__cl || R__insp.IsA()) { }
03893 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhii", &fPhii);
03894 R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetai", &fThetai);
03895 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsii", &fPsii);
03896 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleX", &fAngleX);
03897 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleY", &fAngleY);
03898 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleZ", &fAngleZ);
03899 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03900 R__insp.InspectMember(fNamei, "fNamei.");
03901 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotation", &fRotation);
03902 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03903 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
03904 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotName", &fRotName);
03905 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotPhi", &fRotPhi);
03906 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotTheta", &fRotTheta);
03907 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotPsi", &fRotPsi);
03908 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotAxis", &fRotAxis);
03909 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotX", &fRotX);
03910 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotY", &fRotY);
03911 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotZ", &fRotZ);
03912 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03913 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
03914 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03915 TGeoGedFrame::ShowMembers(R__insp);
03916 }
03917
03918 namespace ROOT {
03919
03920 static void *new_TGeoRotationEditor(void *p) {
03921 return p ? new(p) ::TGeoRotationEditor : new ::TGeoRotationEditor;
03922 }
03923 static void *newArray_TGeoRotationEditor(Long_t nElements, void *p) {
03924 return p ? new(p) ::TGeoRotationEditor[nElements] : new ::TGeoRotationEditor[nElements];
03925 }
03926
03927 static void delete_TGeoRotationEditor(void *p) {
03928 delete ((::TGeoRotationEditor*)p);
03929 }
03930 static void deleteArray_TGeoRotationEditor(void *p) {
03931 delete [] ((::TGeoRotationEditor*)p);
03932 }
03933 static void destruct_TGeoRotationEditor(void *p) {
03934 typedef ::TGeoRotationEditor current_t;
03935 ((current_t*)p)->~current_t();
03936 }
03937
03938 static void streamer_TGeoRotationEditor(TBuffer &buf, void *obj) {
03939 ((::TGeoRotationEditor*)obj)->::TGeoRotationEditor::Streamer(buf);
03940 }
03941 }
03942
03943
03944 void TGeoCombiTransEditor::Streamer(TBuffer &R__b)
03945 {
03946
03947
03948 TGeoGedFrame::Streamer(R__b);
03949 }
03950
03951
03952 void TGeoCombiTransEditor::ShowMembers(TMemberInspector &R__insp)
03953 {
03954
03955 TClass *R__cl = ::TGeoCombiTransEditor::IsA();
03956 if (R__cl || R__insp.IsA()) { }
03957 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDxi", &fDxi);
03958 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDyi", &fDyi);
03959 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDzi", &fDzi);
03960 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPhii", &fPhii);
03961 R__insp.Inspect(R__cl, R__insp.GetParent(), "fThetai", &fThetai);
03962 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPsii", &fPsii);
03963 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleX", &fAngleX);
03964 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleY", &fAngleY);
03965 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAngleZ", &fAngleZ);
03966 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNamei", &fNamei);
03967 R__insp.InspectMember(fNamei, "fNamei.");
03968 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCombi", &fCombi);
03969 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
03970 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsEditable", &fIsEditable);
03971 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotName", &fRotName);
03972 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDx", &fTransDx);
03973 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDy", &fTransDy);
03974 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransDz", &fTransDz);
03975 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotPhi", &fRotPhi);
03976 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotTheta", &fRotTheta);
03977 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotPsi", &fRotPsi);
03978 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotAxis", &fRotAxis);
03979 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotX", &fRotX);
03980 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotY", &fRotY);
03981 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotZ", &fRotZ);
03982 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03983 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
03984 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUndo", &fUndo);
03985 TGeoGedFrame::ShowMembers(R__insp);
03986 }
03987
03988 namespace ROOT {
03989
03990 static void *new_TGeoCombiTransEditor(void *p) {
03991 return p ? new(p) ::TGeoCombiTransEditor : new ::TGeoCombiTransEditor;
03992 }
03993 static void *newArray_TGeoCombiTransEditor(Long_t nElements, void *p) {
03994 return p ? new(p) ::TGeoCombiTransEditor[nElements] : new ::TGeoCombiTransEditor[nElements];
03995 }
03996
03997 static void delete_TGeoCombiTransEditor(void *p) {
03998 delete ((::TGeoCombiTransEditor*)p);
03999 }
04000 static void deleteArray_TGeoCombiTransEditor(void *p) {
04001 delete [] ((::TGeoCombiTransEditor*)p);
04002 }
04003 static void destruct_TGeoCombiTransEditor(void *p) {
04004 typedef ::TGeoCombiTransEditor current_t;
04005 ((current_t*)p)->~current_t();
04006 }
04007
04008 static void streamer_TGeoCombiTransEditor(TBuffer &buf, void *obj) {
04009 ((::TGeoCombiTransEditor*)obj)->::TGeoCombiTransEditor::Streamer(buf);
04010 }
04011 }
04012
04013
04014 void TGeoManagerEditor::Streamer(TBuffer &R__b)
04015 {
04016
04017
04018 TGedFrame::Streamer(R__b);
04019 }
04020
04021
04022 void TGeoManagerEditor::ShowMembers(TMemberInspector &R__insp)
04023 {
04024
04025 TClass *R__cl = ::TGeoManagerEditor::IsA();
04026 if (R__cl || R__insp.IsA()) { }
04027 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGeometry", &fGeometry);
04028 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabMgr", &fTabMgr);
04029 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
04030 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeTab", &fVolumeTab);
04031 R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsModified", &fIsModified);
04032 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCategories", &fCategories);
04033 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManagerName", &fManagerName);
04034 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManagerTitle", &fManagerTitle);
04035 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMediumName", &fMediumName);
04036 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixName", &fMatrixName);
04037 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialName", &fMaterialName);
04038 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeName", &fVolumeName);
04039 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMaterial", &fSelectedMaterial);
04040 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMaterial2", &fSelectedMaterial2);
04041 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMaterial", &fLSelMaterial);
04042 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMaterial2", &fLSelMaterial2);
04043 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMaterial", &fBSelMaterial);
04044 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMaterial2", &fBSelMaterial2);
04045 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedVolume", &fSelectedVolume);
04046 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelVolume", &fLSelVolume);
04047 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelVolume", &fBSelVolume);
04048 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedShape", &fSelectedShape);
04049 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedShape2", &fSelectedShape2);
04050 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelShape", &fLSelShape);
04051 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelShape2", &fLSelShape2);
04052 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelShape", &fBSelShape);
04053 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelShape2", &fBSelShape2);
04054 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMatrix", &fSelectedMatrix);
04055 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMatrix", &fLSelMatrix);
04056 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMatrix", &fBSelMatrix);
04057 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMedium", &fSelectedMedium);
04058 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectedMedium2", &fSelectedMedium2);
04059 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMedium", &fLSelMedium);
04060 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelMedium2", &fLSelMedium2);
04061 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMedium", &fBSelMedium);
04062 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelMedium2", &fBSelMedium2);
04063 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapeButton[21]", &fShapeButton);
04064 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixButton[3]", &fMatrixButton);
04065 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeButton[2]", &fVolumeButton);
04066 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialButton[2]", &fMaterialButton);
04067 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExportOption[2]", &fExportOption);
04068 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExportButton", &fExportButton);
04069 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElementList", &fElementList);
04070 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryDensity", &fEntryDensity);
04071 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMediumButton", &fMediumButton);
04072 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMediumId", &fMediumId);
04073 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditShape", &fEditShape);
04074 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMedium", &fEditMedium);
04075 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMaterial", &fEditMaterial);
04076 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditMatrix", &fEditMatrix);
04077 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditVolume", &fEditVolume);
04078 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSetTopVolume", &fSetTopVolume);
04079 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLSelTop", &fLSelTop);
04080 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBSelTop", &fBSelTop);
04081 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCloseGeometry", &fCloseGeometry);
04082 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f2", &f2);
04083 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3", &f3);
04084 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f4", &f4);
04085 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f5", &f5);
04086 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f6", &f6);
04087 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f7", &f7);
04088 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConnectedCanvas", &fConnectedCanvas);
04089 TGedFrame::ShowMembers(R__insp);
04090 }
04091
04092 namespace ROOT {
04093
04094 static void *new_TGeoManagerEditor(void *p) {
04095 return p ? new(p) ::TGeoManagerEditor : new ::TGeoManagerEditor;
04096 }
04097 static void *newArray_TGeoManagerEditor(Long_t nElements, void *p) {
04098 return p ? new(p) ::TGeoManagerEditor[nElements] : new ::TGeoManagerEditor[nElements];
04099 }
04100
04101 static void delete_TGeoManagerEditor(void *p) {
04102 delete ((::TGeoManagerEditor*)p);
04103 }
04104 static void deleteArray_TGeoManagerEditor(void *p) {
04105 delete [] ((::TGeoManagerEditor*)p);
04106 }
04107 static void destruct_TGeoManagerEditor(void *p) {
04108 typedef ::TGeoManagerEditor current_t;
04109 ((current_t*)p)->~current_t();
04110 }
04111
04112 static void streamer_TGeoManagerEditor(TBuffer &buf, void *obj) {
04113 ((::TGeoManagerEditor*)obj)->::TGeoManagerEditor::Streamer(buf);
04114 }
04115 }
04116
04117
04118 void TGeoTabManager::Streamer(TBuffer &R__b)
04119 {
04120
04121
04122 TObject::Streamer(R__b);
04123 }
04124
04125
04126 void TGeoTabManager::ShowMembers(TMemberInspector &R__insp)
04127 {
04128
04129 TClass *R__cl = ::TGeoTabManager::IsA();
04130 if (R__cl || R__insp.IsA()) { }
04131 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGedEditor", &fGedEditor);
04132 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
04133 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
04134 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolume", &fVolume);
04135 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShapePanel", &fShapePanel);
04136 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMediumPanel", &fMediumPanel);
04137 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaterialPanel", &fMaterialPanel);
04138 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMatrixPanel", &fMatrixPanel);
04139 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVolumeTab", &fVolumeTab);
04140 TObject::ShowMembers(R__insp);
04141 }
04142
04143 namespace ROOT {
04144
04145 static void delete_TGeoTabManager(void *p) {
04146 delete ((::TGeoTabManager*)p);
04147 }
04148 static void deleteArray_TGeoTabManager(void *p) {
04149 delete [] ((::TGeoTabManager*)p);
04150 }
04151 static void destruct_TGeoTabManager(void *p) {
04152 typedef ::TGeoTabManager current_t;
04153 ((current_t*)p)->~current_t();
04154 }
04155
04156 static void streamer_TGeoTabManager(TBuffer &buf, void *obj) {
04157 ((::TGeoTabManager*)obj)->::TGeoTabManager::Streamer(buf);
04158 }
04159 }
04160
04161
04162 void TGeoTransientPanel::Streamer(TBuffer &R__b)
04163 {
04164
04165
04166 TGMainFrame::Streamer(R__b);
04167 }
04168
04169
04170 void TGeoTransientPanel::ShowMembers(TMemberInspector &R__insp)
04171 {
04172
04173 TClass *R__cl = ::TGeoTransientPanel::IsA();
04174 if (R__cl || R__insp.IsA()) { }
04175 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGedEditor", &fGedEditor);
04176 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCan", &fCan);
04177 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
04178 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabContainer", &fTabContainer);
04179 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStyle", &fStyle);
04180 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModel", &fModel);
04181 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClose", &fClose);
04182 TGMainFrame::ShowMembers(R__insp);
04183 }
04184
04185 namespace ROOT {
04186
04187 static void delete_TGeoTransientPanel(void *p) {
04188 delete ((::TGeoTransientPanel*)p);
04189 }
04190 static void deleteArray_TGeoTransientPanel(void *p) {
04191 delete [] ((::TGeoTransientPanel*)p);
04192 }
04193 static void destruct_TGeoTransientPanel(void *p) {
04194 typedef ::TGeoTransientPanel current_t;
04195 ((current_t*)p)->~current_t();
04196 }
04197
04198 static void streamer_TGeoTransientPanel(TBuffer &buf, void *obj) {
04199 ((::TGeoTransientPanel*)obj)->::TGeoTransientPanel::Streamer(buf);
04200 }
04201 }
04202
04203
04204 void TGeoTreeDialog::Streamer(TBuffer &R__b)
04205 {
04206
04207
04208 TGTransientFrame::Streamer(R__b);
04209 }
04210
04211
04212 void TGeoTreeDialog::ShowMembers(TMemberInspector &R__insp)
04213 {
04214
04215 TClass *R__cl = ::TGeoTreeDialog::IsA();
04216 if (R__cl || R__insp.IsA()) { }
04217 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
04218 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObjLabel", &fObjLabel);
04219 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLT", &fLT);
04220 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f1", &f1);
04221 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClose", &fClose);
04222 TGTransientFrame::ShowMembers(R__insp);
04223 }
04224
04225 namespace ROOT {
04226
04227 static void delete_TGeoTreeDialog(void *p) {
04228 delete ((::TGeoTreeDialog*)p);
04229 }
04230 static void deleteArray_TGeoTreeDialog(void *p) {
04231 delete [] ((::TGeoTreeDialog*)p);
04232 }
04233 static void destruct_TGeoTreeDialog(void *p) {
04234 typedef ::TGeoTreeDialog current_t;
04235 ((current_t*)p)->~current_t();
04236 }
04237
04238 static void streamer_TGeoTreeDialog(TBuffer &buf, void *obj) {
04239 ((::TGeoTreeDialog*)obj)->::TGeoTreeDialog::Streamer(buf);
04240 }
04241 }
04242
04243
04244 void TGeoVolumeDialog::Streamer(TBuffer &R__b)
04245 {
04246
04247
04248 TGeoTreeDialog::Streamer(R__b);
04249 }
04250
04251
04252 void TGeoVolumeDialog::ShowMembers(TMemberInspector &R__insp)
04253 {
04254
04255 TClass *R__cl = ::TGeoVolumeDialog::IsA();
04256 if (R__cl || R__insp.IsA()) { }
04257 TGeoTreeDialog::ShowMembers(R__insp);
04258 }
04259
04260 namespace ROOT {
04261
04262 static void delete_TGeoVolumeDialog(void *p) {
04263 delete ((::TGeoVolumeDialog*)p);
04264 }
04265 static void deleteArray_TGeoVolumeDialog(void *p) {
04266 delete [] ((::TGeoVolumeDialog*)p);
04267 }
04268 static void destruct_TGeoVolumeDialog(void *p) {
04269 typedef ::TGeoVolumeDialog current_t;
04270 ((current_t*)p)->~current_t();
04271 }
04272
04273 static void streamer_TGeoVolumeDialog(TBuffer &buf, void *obj) {
04274 ((::TGeoVolumeDialog*)obj)->::TGeoVolumeDialog::Streamer(buf);
04275 }
04276 }
04277
04278
04279 void TGeoShapeDialog::Streamer(TBuffer &R__b)
04280 {
04281
04282
04283 TGeoTreeDialog::Streamer(R__b);
04284 }
04285
04286
04287 void TGeoShapeDialog::ShowMembers(TMemberInspector &R__insp)
04288 {
04289
04290 TClass *R__cl = ::TGeoShapeDialog::IsA();
04291 if (R__cl || R__insp.IsA()) { }
04292 TGeoTreeDialog::ShowMembers(R__insp);
04293 }
04294
04295 namespace ROOT {
04296
04297 static void delete_TGeoShapeDialog(void *p) {
04298 delete ((::TGeoShapeDialog*)p);
04299 }
04300 static void deleteArray_TGeoShapeDialog(void *p) {
04301 delete [] ((::TGeoShapeDialog*)p);
04302 }
04303 static void destruct_TGeoShapeDialog(void *p) {
04304 typedef ::TGeoShapeDialog current_t;
04305 ((current_t*)p)->~current_t();
04306 }
04307
04308 static void streamer_TGeoShapeDialog(TBuffer &buf, void *obj) {
04309 ((::TGeoShapeDialog*)obj)->::TGeoShapeDialog::Streamer(buf);
04310 }
04311 }
04312
04313
04314 void TGeoMatrixDialog::Streamer(TBuffer &R__b)
04315 {
04316
04317
04318 TGeoTreeDialog::Streamer(R__b);
04319 }
04320
04321
04322 void TGeoMatrixDialog::ShowMembers(TMemberInspector &R__insp)
04323 {
04324
04325 TClass *R__cl = ::TGeoMatrixDialog::IsA();
04326 if (R__cl || R__insp.IsA()) { }
04327 TGeoTreeDialog::ShowMembers(R__insp);
04328 }
04329
04330 namespace ROOT {
04331
04332 static void delete_TGeoMatrixDialog(void *p) {
04333 delete ((::TGeoMatrixDialog*)p);
04334 }
04335 static void deleteArray_TGeoMatrixDialog(void *p) {
04336 delete [] ((::TGeoMatrixDialog*)p);
04337 }
04338 static void destruct_TGeoMatrixDialog(void *p) {
04339 typedef ::TGeoMatrixDialog current_t;
04340 ((current_t*)p)->~current_t();
04341 }
04342
04343 static void streamer_TGeoMatrixDialog(TBuffer &buf, void *obj) {
04344 ((::TGeoMatrixDialog*)obj)->::TGeoMatrixDialog::Streamer(buf);
04345 }
04346 }
04347
04348
04349 void TGeoMediumDialog::Streamer(TBuffer &R__b)
04350 {
04351
04352
04353 TGeoTreeDialog::Streamer(R__b);
04354 }
04355
04356
04357 void TGeoMediumDialog::ShowMembers(TMemberInspector &R__insp)
04358 {
04359
04360 TClass *R__cl = ::TGeoMediumDialog::IsA();
04361 if (R__cl || R__insp.IsA()) { }
04362 TGeoTreeDialog::ShowMembers(R__insp);
04363 }
04364
04365 namespace ROOT {
04366
04367 static void delete_TGeoMediumDialog(void *p) {
04368 delete ((::TGeoMediumDialog*)p);
04369 }
04370 static void deleteArray_TGeoMediumDialog(void *p) {
04371 delete [] ((::TGeoMediumDialog*)p);
04372 }
04373 static void destruct_TGeoMediumDialog(void *p) {
04374 typedef ::TGeoMediumDialog current_t;
04375 ((current_t*)p)->~current_t();
04376 }
04377
04378 static void streamer_TGeoMediumDialog(TBuffer &buf, void *obj) {
04379 ((::TGeoMediumDialog*)obj)->::TGeoMediumDialog::Streamer(buf);
04380 }
04381 }
04382
04383
04384 void TGeoMaterialDialog::Streamer(TBuffer &R__b)
04385 {
04386
04387
04388 TGeoTreeDialog::Streamer(R__b);
04389 }
04390
04391
04392 void TGeoMaterialDialog::ShowMembers(TMemberInspector &R__insp)
04393 {
04394
04395 TClass *R__cl = ::TGeoMaterialDialog::IsA();
04396 if (R__cl || R__insp.IsA()) { }
04397 TGeoTreeDialog::ShowMembers(R__insp);
04398 }
04399
04400 namespace ROOT {
04401
04402 static void delete_TGeoMaterialDialog(void *p) {
04403 delete ((::TGeoMaterialDialog*)p);
04404 }
04405 static void deleteArray_TGeoMaterialDialog(void *p) {
04406 delete [] ((::TGeoMaterialDialog*)p);
04407 }
04408 static void destruct_TGeoMaterialDialog(void *p) {
04409 typedef ::TGeoMaterialDialog current_t;
04410 ((current_t*)p)->~current_t();
04411 }
04412
04413 static void streamer_TGeoMaterialDialog(TBuffer &buf, void *obj) {
04414 ((::TGeoMaterialDialog*)obj)->::TGeoMaterialDialog::Streamer(buf);
04415 }
04416 }
04417
04418
04419 void TGeoGedFrame::Streamer(TBuffer &R__b)
04420 {
04421
04422
04423 TGedFrame::Streamer(R__b);
04424 }
04425
04426
04427 void TGeoGedFrame::ShowMembers(TMemberInspector &R__insp)
04428 {
04429
04430 TClass *R__cl = ::TGeoGedFrame::IsA();
04431 if (R__cl || R__insp.IsA()) { }
04432 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
04433 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabMgr", &fTabMgr);
04434 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
04435 TGedFrame::ShowMembers(R__insp);
04436 }
04437
04438 namespace ROOT {
04439
04440 static void delete_TGeoGedFrame(void *p) {
04441 delete ((::TGeoGedFrame*)p);
04442 }
04443 static void deleteArray_TGeoGedFrame(void *p) {
04444 delete [] ((::TGeoGedFrame*)p);
04445 }
04446 static void destruct_TGeoGedFrame(void *p) {
04447 typedef ::TGeoGedFrame current_t;
04448 ((current_t*)p)->~current_t();
04449 }
04450
04451 static void streamer_TGeoGedFrame(TBuffer &buf, void *obj) {
04452 ((::TGeoGedFrame*)obj)->::TGeoGedFrame::Streamer(buf);
04453 }
04454 }
04455
04456
04457
04458
04459
04460
04461
04462
04463 #ifdef G__MEMTEST
04464 #undef malloc
04465 #undef free
04466 #endif
04467
04468 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
04469 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
04470 #endif
04471
04472 extern "C" void G__cpp_reset_tagtableG__GeomBuilder();
04473
04474 extern "C" void G__set_cpp_environmentG__GeomBuilder() {
04475 G__add_compiledheader("TObject.h");
04476 G__add_compiledheader("TMemberInspector.h");
04477 G__add_compiledheader("TGeoVolumeEditor.h");
04478 G__add_compiledheader("TGeoBBoxEditor.h");
04479 G__add_compiledheader("TGeoMediumEditor.h");
04480 G__add_compiledheader("TGeoNodeEditor.h");
04481 G__add_compiledheader("TGeoMatrixEditor.h");
04482 G__add_compiledheader("TGeoManagerEditor.h");
04483 G__add_compiledheader("TGeoTubeEditor.h");
04484 G__add_compiledheader("TGeoConeEditor.h");
04485 G__add_compiledheader("TGeoTrd1Editor.h");
04486 G__add_compiledheader("TGeoTrd2Editor.h");
04487 G__add_compiledheader("TGeoMaterialEditor.h");
04488 G__add_compiledheader("TGeoTabManager.h");
04489 G__add_compiledheader("TGeoSphereEditor.h");
04490 G__add_compiledheader("TGeoPconEditor.h");
04491 G__add_compiledheader("TGeoParaEditor.h");
04492 G__add_compiledheader("TGeoTorusEditor.h");
04493 G__add_compiledheader("TGeoEltuEditor.h");
04494 G__add_compiledheader("TGeoHypeEditor.h");
04495 G__add_compiledheader("TGeoPgonEditor.h");
04496 G__add_compiledheader("TGeoTrapEditor.h");
04497 G__add_compiledheader("TGeoGedFrame.h");
04498 G__cpp_reset_tagtableG__GeomBuilder();
04499 }
04500 #include <new>
04501 extern "C" int G__cpp_dllrevG__GeomBuilder() { return(30051515); }
04502
04503
04504
04505
04506
04507
04508 static int G__G__GeomBuilder_233_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04509 {
04510 TGeoTabManager* p = NULL;
04511 char* gvp = (char*) G__getgvp();
04512
04513 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04514 p = new TGeoTabManager((TGedEditor*) G__int(libp->para[0]));
04515 } else {
04516 p = new((void*) gvp) TGeoTabManager((TGedEditor*) G__int(libp->para[0]));
04517 }
04518 result7->obj.i = (long) p;
04519 result7->ref = (long) p;
04520 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager));
04521 return(1 || funcname || hash || result7 || libp) ;
04522 }
04523
04524 static int G__G__GeomBuilder_233_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04525 {
04526 G__letint(result7, 85, (long) TGeoTabManager::GetMakeTabManager((TGedEditor*) G__int(libp->para[0])));
04527 return(1 || funcname || hash || result7 || libp) ;
04528 }
04529
04530 static int G__G__GeomBuilder_233_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04531 {
04532 TGeoTabManager::Cleanup((TGCompositeFrame*) G__int(libp->para[0]));
04533 G__setnull(result7);
04534 return(1 || funcname || hash || result7 || libp) ;
04535 }
04536
04537 static int G__G__GeomBuilder_233_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04538 {
04539 G__letint(result7, 85, (long) ((const TGeoTabManager*) G__getstructoffset())->GetPad());
04540 return(1 || funcname || hash || result7 || libp) ;
04541 }
04542
04543 static int G__G__GeomBuilder_233_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04544 {
04545 G__letint(result7, 85, (long) ((const TGeoTabManager*) G__getstructoffset())->GetTab());
04546 return(1 || funcname || hash || result7 || libp) ;
04547 }
04548
04549 static int G__G__GeomBuilder_233_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04550 {
04551 G__letint(result7, 105, (long) ((const TGeoTabManager*) G__getstructoffset())->GetTabIndex());
04552 return(1 || funcname || hash || result7 || libp) ;
04553 }
04554
04555 static int G__G__GeomBuilder_233_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04556 {
04557 TGeoTabManager::MoveFrame((TGCompositeFrame*) G__int(libp->para[0]), (TGCompositeFrame*) G__int(libp->para[1]));
04558 G__setnull(result7);
04559 return(1 || funcname || hash || result7 || libp) ;
04560 }
04561
04562 static int G__G__GeomBuilder_233_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04563 {
04564 switch (libp->paran) {
04565 case 1:
04566 ((TGeoTabManager*) G__getstructoffset())->SetVolTabEnabled((Bool_t) G__int(libp->para[0]));
04567 G__setnull(result7);
04568 break;
04569 case 0:
04570 ((TGeoTabManager*) G__getstructoffset())->SetVolTabEnabled();
04571 G__setnull(result7);
04572 break;
04573 }
04574 return(1 || funcname || hash || result7 || libp) ;
04575 }
04576
04577 static int G__G__GeomBuilder_233_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04578 {
04579 ((TGeoTabManager*) G__getstructoffset())->SetModel((TObject*) G__int(libp->para[0]));
04580 G__setnull(result7);
04581 return(1 || funcname || hash || result7 || libp) ;
04582 }
04583
04584 static int G__G__GeomBuilder_233_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04585 {
04586 ((TGeoTabManager*) G__getstructoffset())->SetTab();
04587 G__setnull(result7);
04588 return(1 || funcname || hash || result7 || libp) ;
04589 }
04590
04591 static int G__G__GeomBuilder_233_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04592 {
04593 ((TGeoTabManager*) G__getstructoffset())->GetShapeEditor((TGeoShape*) G__int(libp->para[0]));
04594 G__setnull(result7);
04595 return(1 || funcname || hash || result7 || libp) ;
04596 }
04597
04598 static int G__G__GeomBuilder_233_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04599 {
04600 ((TGeoTabManager*) G__getstructoffset())->GetVolumeEditor((TGeoVolume*) G__int(libp->para[0]));
04601 G__setnull(result7);
04602 return(1 || funcname || hash || result7 || libp) ;
04603 }
04604
04605 static int G__G__GeomBuilder_233_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04606 {
04607 ((TGeoTabManager*) G__getstructoffset())->GetMatrixEditor((TGeoMatrix*) G__int(libp->para[0]));
04608 G__setnull(result7);
04609 return(1 || funcname || hash || result7 || libp) ;
04610 }
04611
04612 static int G__G__GeomBuilder_233_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04613 {
04614 ((TGeoTabManager*) G__getstructoffset())->GetMediumEditor((TGeoMedium*) G__int(libp->para[0]));
04615 G__setnull(result7);
04616 return(1 || funcname || hash || result7 || libp) ;
04617 }
04618
04619 static int G__G__GeomBuilder_233_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04620 {
04621 ((TGeoTabManager*) G__getstructoffset())->GetMaterialEditor((TGeoMaterial*) G__int(libp->para[0]));
04622 G__setnull(result7);
04623 return(1 || funcname || hash || result7 || libp) ;
04624 }
04625
04626 static int G__G__GeomBuilder_233_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04627 {
04628 G__letint(result7, 85, (long) ((const TGeoTabManager*) G__getstructoffset())->GetVolumeTab());
04629 return(1 || funcname || hash || result7 || libp) ;
04630 }
04631
04632 static int G__G__GeomBuilder_233_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04633 {
04634 G__letint(result7, 85, (long) ((const TGeoTabManager*) G__getstructoffset())->GetVolume());
04635 return(1 || funcname || hash || result7 || libp) ;
04636 }
04637
04638 static int G__G__GeomBuilder_233_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04639 {
04640 G__letint(result7, 85, (long) TGeoTabManager::Class());
04641 return(1 || funcname || hash || result7 || libp) ;
04642 }
04643
04644 static int G__G__GeomBuilder_233_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04645 {
04646 G__letint(result7, 67, (long) TGeoTabManager::Class_Name());
04647 return(1 || funcname || hash || result7 || libp) ;
04648 }
04649
04650 static int G__G__GeomBuilder_233_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04651 {
04652 G__letint(result7, 115, (long) TGeoTabManager::Class_Version());
04653 return(1 || funcname || hash || result7 || libp) ;
04654 }
04655
04656 static int G__G__GeomBuilder_233_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04657 {
04658 TGeoTabManager::Dictionary();
04659 G__setnull(result7);
04660 return(1 || funcname || hash || result7 || libp) ;
04661 }
04662
04663 static int G__G__GeomBuilder_233_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04664 {
04665 ((TGeoTabManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04666 G__setnull(result7);
04667 return(1 || funcname || hash || result7 || libp) ;
04668 }
04669
04670 static int G__G__GeomBuilder_233_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04671 {
04672 G__letint(result7, 67, (long) TGeoTabManager::DeclFileName());
04673 return(1 || funcname || hash || result7 || libp) ;
04674 }
04675
04676 static int G__G__GeomBuilder_233_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04677 {
04678 G__letint(result7, 105, (long) TGeoTabManager::ImplFileLine());
04679 return(1 || funcname || hash || result7 || libp) ;
04680 }
04681
04682 static int G__G__GeomBuilder_233_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04683 {
04684 G__letint(result7, 67, (long) TGeoTabManager::ImplFileName());
04685 return(1 || funcname || hash || result7 || libp) ;
04686 }
04687
04688 static int G__G__GeomBuilder_233_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04689 {
04690 G__letint(result7, 105, (long) TGeoTabManager::DeclFileLine());
04691 return(1 || funcname || hash || result7 || libp) ;
04692 }
04693
04694
04695 typedef TGeoTabManager G__TTGeoTabManager;
04696 static int G__G__GeomBuilder_233_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04697 {
04698 char* gvp = (char*) G__getgvp();
04699 long soff = G__getstructoffset();
04700 int n = G__getaryconstruct();
04701
04702
04703
04704
04705
04706 if (!soff) {
04707 return(1);
04708 }
04709 if (n) {
04710 if (gvp == (char*)G__PVOID) {
04711 delete[] (TGeoTabManager*) soff;
04712 } else {
04713 G__setgvp((long) G__PVOID);
04714 for (int i = n - 1; i >= 0; --i) {
04715 ((TGeoTabManager*) (soff+(sizeof(TGeoTabManager)*i)))->~G__TTGeoTabManager();
04716 }
04717 G__setgvp((long)gvp);
04718 }
04719 } else {
04720 if (gvp == (char*)G__PVOID) {
04721 delete (TGeoTabManager*) soff;
04722 } else {
04723 G__setgvp((long) G__PVOID);
04724 ((TGeoTabManager*) (soff))->~G__TTGeoTabManager();
04725 G__setgvp((long)gvp);
04726 }
04727 }
04728 G__setnull(result7);
04729 return(1 || funcname || hash || result7 || libp) ;
04730 }
04731
04732
04733
04734 static int G__G__GeomBuilder_234_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04735 {
04736 switch (libp->paran) {
04737 case 1:
04738 ((TGeoGedFrame*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
04739 G__setnull(result7);
04740 break;
04741 case 0:
04742 ((TGeoGedFrame*) G__getstructoffset())->SetActive();
04743 G__setnull(result7);
04744 break;
04745 }
04746 return(1 || funcname || hash || result7 || libp) ;
04747 }
04748
04749 static int G__G__GeomBuilder_234_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04750 {
04751 G__letint(result7, 85, (long) TGeoGedFrame::Class());
04752 return(1 || funcname || hash || result7 || libp) ;
04753 }
04754
04755 static int G__G__GeomBuilder_234_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04756 {
04757 G__letint(result7, 67, (long) TGeoGedFrame::Class_Name());
04758 return(1 || funcname || hash || result7 || libp) ;
04759 }
04760
04761 static int G__G__GeomBuilder_234_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04762 {
04763 G__letint(result7, 115, (long) TGeoGedFrame::Class_Version());
04764 return(1 || funcname || hash || result7 || libp) ;
04765 }
04766
04767 static int G__G__GeomBuilder_234_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04768 {
04769 TGeoGedFrame::Dictionary();
04770 G__setnull(result7);
04771 return(1 || funcname || hash || result7 || libp) ;
04772 }
04773
04774 static int G__G__GeomBuilder_234_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04775 {
04776 ((TGeoGedFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04777 G__setnull(result7);
04778 return(1 || funcname || hash || result7 || libp) ;
04779 }
04780
04781 static int G__G__GeomBuilder_234_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04782 {
04783 G__letint(result7, 67, (long) TGeoGedFrame::DeclFileName());
04784 return(1 || funcname || hash || result7 || libp) ;
04785 }
04786
04787 static int G__G__GeomBuilder_234_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04788 {
04789 G__letint(result7, 105, (long) TGeoGedFrame::ImplFileLine());
04790 return(1 || funcname || hash || result7 || libp) ;
04791 }
04792
04793 static int G__G__GeomBuilder_234_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04794 {
04795 G__letint(result7, 67, (long) TGeoGedFrame::ImplFileName());
04796 return(1 || funcname || hash || result7 || libp) ;
04797 }
04798
04799 static int G__G__GeomBuilder_234_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04800 {
04801 G__letint(result7, 105, (long) TGeoGedFrame::DeclFileLine());
04802 return(1 || funcname || hash || result7 || libp) ;
04803 }
04804
04805
04806 typedef TGeoGedFrame G__TTGeoGedFrame;
04807 static int G__G__GeomBuilder_234_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04808 {
04809 char* gvp = (char*) G__getgvp();
04810 long soff = G__getstructoffset();
04811 int n = G__getaryconstruct();
04812
04813
04814
04815
04816
04817 if (!soff) {
04818 return(1);
04819 }
04820 if (n) {
04821 if (gvp == (char*)G__PVOID) {
04822 delete[] (TGeoGedFrame*) soff;
04823 } else {
04824 G__setgvp((long) G__PVOID);
04825 for (int i = n - 1; i >= 0; --i) {
04826 ((TGeoGedFrame*) (soff+(sizeof(TGeoGedFrame)*i)))->~G__TTGeoGedFrame();
04827 }
04828 G__setgvp((long)gvp);
04829 }
04830 } else {
04831 if (gvp == (char*)G__PVOID) {
04832 delete (TGeoGedFrame*) soff;
04833 } else {
04834 G__setgvp((long) G__PVOID);
04835 ((TGeoGedFrame*) (soff))->~G__TTGeoGedFrame();
04836 G__setgvp((long)gvp);
04837 }
04838 }
04839 G__setnull(result7);
04840 return(1 || funcname || hash || result7 || libp) ;
04841 }
04842
04843
04844
04845 static int G__G__GeomBuilder_249_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04846 {
04847 TGeoVolumeEditor* p = NULL;
04848 char* gvp = (char*) G__getgvp();
04849 switch (libp->paran) {
04850 case 5:
04851
04852 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04853 p = new TGeoVolumeEditor(
04854 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04855 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
04856 , (Pixel_t) G__int(libp->para[4]));
04857 } else {
04858 p = new((void*) gvp) TGeoVolumeEditor(
04859 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04860 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
04861 , (Pixel_t) G__int(libp->para[4]));
04862 }
04863 break;
04864 case 4:
04865
04866 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04867 p = new TGeoVolumeEditor(
04868 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04869 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
04870 } else {
04871 p = new((void*) gvp) TGeoVolumeEditor(
04872 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04873 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
04874 }
04875 break;
04876 case 3:
04877
04878 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04879 p = new TGeoVolumeEditor(
04880 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04881 , (Int_t) G__int(libp->para[2]));
04882 } else {
04883 p = new((void*) gvp) TGeoVolumeEditor(
04884 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04885 , (Int_t) G__int(libp->para[2]));
04886 }
04887 break;
04888 case 2:
04889
04890 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04891 p = new TGeoVolumeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04892 } else {
04893 p = new((void*) gvp) TGeoVolumeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04894 }
04895 break;
04896 case 1:
04897
04898 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04899 p = new TGeoVolumeEditor((TGWindow*) G__int(libp->para[0]));
04900 } else {
04901 p = new((void*) gvp) TGeoVolumeEditor((TGWindow*) G__int(libp->para[0]));
04902 }
04903 break;
04904 case 0:
04905 int n = G__getaryconstruct();
04906 if (n) {
04907 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04908 p = new TGeoVolumeEditor[n];
04909 } else {
04910 p = new((void*) gvp) TGeoVolumeEditor[n];
04911 }
04912 } else {
04913 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04914 p = new TGeoVolumeEditor;
04915 } else {
04916 p = new((void*) gvp) TGeoVolumeEditor;
04917 }
04918 }
04919 break;
04920 }
04921 result7->obj.i = (long) p;
04922 result7->ref = (long) p;
04923 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor));
04924 return(1 || funcname || hash || result7 || libp) ;
04925 }
04926
04927 static int G__G__GeomBuilder_249_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04928 {
04929 ((TGeoVolumeEditor*) G__getstructoffset())->DoAddNode();
04930 G__setnull(result7);
04931 return(1 || funcname || hash || result7 || libp) ;
04932 }
04933
04934 static int G__G__GeomBuilder_249_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04935 {
04936 ((TGeoVolumeEditor*) G__getstructoffset())->DoVolumeName();
04937 G__setnull(result7);
04938 return(1 || funcname || hash || result7 || libp) ;
04939 }
04940
04941 static int G__G__GeomBuilder_249_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04942 {
04943 ((TGeoVolumeEditor*) G__getstructoffset())->DoSelectShape();
04944 G__setnull(result7);
04945 return(1 || funcname || hash || result7 || libp) ;
04946 }
04947
04948 static int G__G__GeomBuilder_249_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04949 {
04950 ((TGeoVolumeEditor*) G__getstructoffset())->DoSelectMedium();
04951 G__setnull(result7);
04952 return(1 || funcname || hash || result7 || libp) ;
04953 }
04954
04955 static int G__G__GeomBuilder_249_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04956 {
04957 ((TGeoVolumeEditor*) G__getstructoffset())->DoSelectMatrix();
04958 G__setnull(result7);
04959 return(1 || funcname || hash || result7 || libp) ;
04960 }
04961
04962 static int G__G__GeomBuilder_249_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04963 {
04964 ((TGeoVolumeEditor*) G__getstructoffset())->DoSelectVolume();
04965 G__setnull(result7);
04966 return(1 || funcname || hash || result7 || libp) ;
04967 }
04968
04969 static int G__G__GeomBuilder_249_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04970 {
04971 ((TGeoVolumeEditor*) G__getstructoffset())->DoEditShape();
04972 G__setnull(result7);
04973 return(1 || funcname || hash || result7 || libp) ;
04974 }
04975
04976 static int G__G__GeomBuilder_249_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04977 {
04978 ((TGeoVolumeEditor*) G__getstructoffset())->DoEditMedium();
04979 G__setnull(result7);
04980 return(1 || funcname || hash || result7 || libp) ;
04981 }
04982
04983 static int G__G__GeomBuilder_249_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04984 {
04985 ((TGeoVolumeEditor*) G__getstructoffset())->DoEditMatrix();
04986 G__setnull(result7);
04987 return(1 || funcname || hash || result7 || libp) ;
04988 }
04989
04990 static int G__G__GeomBuilder_249_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04991 {
04992 ((TGeoVolumeEditor*) G__getstructoffset())->DoRemoveNode();
04993 G__setnull(result7);
04994 return(1 || funcname || hash || result7 || libp) ;
04995 }
04996
04997 static int G__G__GeomBuilder_249_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04998 {
04999 ((TGeoVolumeEditor*) G__getstructoffset())->DoVisVolume();
05000 G__setnull(result7);
05001 return(1 || funcname || hash || result7 || libp) ;
05002 }
05003
05004 static int G__G__GeomBuilder_249_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05005 {
05006 ((TGeoVolumeEditor*) G__getstructoffset())->DoVisDaughters();
05007 G__setnull(result7);
05008 return(1 || funcname || hash || result7 || libp) ;
05009 }
05010
05011 static int G__G__GeomBuilder_249_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05012 {
05013 ((TGeoVolumeEditor*) G__getstructoffset())->DoVisAuto();
05014 G__setnull(result7);
05015 return(1 || funcname || hash || result7 || libp) ;
05016 }
05017
05018 static int G__G__GeomBuilder_249_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05019 {
05020 ((TGeoVolumeEditor*) G__getstructoffset())->DoVisLevel();
05021 G__setnull(result7);
05022 return(1 || funcname || hash || result7 || libp) ;
05023 }
05024
05025 static int G__G__GeomBuilder_249_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05026 {
05027 ((TGeoVolumeEditor*) G__getstructoffset())->DoViewAll();
05028 G__setnull(result7);
05029 return(1 || funcname || hash || result7 || libp) ;
05030 }
05031
05032 static int G__G__GeomBuilder_249_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05033 {
05034 ((TGeoVolumeEditor*) G__getstructoffset())->DoViewLeaves();
05035 G__setnull(result7);
05036 return(1 || funcname || hash || result7 || libp) ;
05037 }
05038
05039 static int G__G__GeomBuilder_249_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05040 {
05041 ((TGeoVolumeEditor*) G__getstructoffset())->DoViewOnly();
05042 G__setnull(result7);
05043 return(1 || funcname || hash || result7 || libp) ;
05044 }
05045
05046 static int G__G__GeomBuilder_249_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05047 {
05048 ((TGeoVolumeEditor*) G__getstructoffset())->DoDivSelAxis();
05049 G__setnull(result7);
05050 return(1 || funcname || hash || result7 || libp) ;
05051 }
05052
05053 static int G__G__GeomBuilder_249_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05054 {
05055 ((TGeoVolumeEditor*) G__getstructoffset())->DoDivFromTo();
05056 G__setnull(result7);
05057 return(1 || funcname || hash || result7 || libp) ;
05058 }
05059
05060 static int G__G__GeomBuilder_249_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05061 {
05062 ((TGeoVolumeEditor*) G__getstructoffset())->DoDivStep();
05063 G__setnull(result7);
05064 return(1 || funcname || hash || result7 || libp) ;
05065 }
05066
05067 static int G__G__GeomBuilder_249_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05068 {
05069 ((TGeoVolumeEditor*) G__getstructoffset())->DoDivN();
05070 G__setnull(result7);
05071 return(1 || funcname || hash || result7 || libp) ;
05072 }
05073
05074 static int G__G__GeomBuilder_249_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05075 {
05076 ((TGeoVolumeEditor*) G__getstructoffset())->DoDivName();
05077 G__setnull(result7);
05078 return(1 || funcname || hash || result7 || libp) ;
05079 }
05080
05081 static int G__G__GeomBuilder_249_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05082 {
05083 ((TGeoVolumeEditor*) G__getstructoffset())->DoApplyDiv();
05084 G__setnull(result7);
05085 return(1 || funcname || hash || result7 || libp) ;
05086 }
05087
05088 static int G__G__GeomBuilder_249_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05089 {
05090 ((TGeoVolumeEditor*) G__getstructoffset())->DoRaytrace();
05091 G__setnull(result7);
05092 return(1 || funcname || hash || result7 || libp) ;
05093 }
05094
05095 static int G__G__GeomBuilder_249_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05096 {
05097 G__letint(result7, 85, (long) TGeoVolumeEditor::Class());
05098 return(1 || funcname || hash || result7 || libp) ;
05099 }
05100
05101 static int G__G__GeomBuilder_249_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05102 {
05103 G__letint(result7, 67, (long) TGeoVolumeEditor::Class_Name());
05104 return(1 || funcname || hash || result7 || libp) ;
05105 }
05106
05107 static int G__G__GeomBuilder_249_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05108 {
05109 G__letint(result7, 115, (long) TGeoVolumeEditor::Class_Version());
05110 return(1 || funcname || hash || result7 || libp) ;
05111 }
05112
05113 static int G__G__GeomBuilder_249_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05114 {
05115 TGeoVolumeEditor::Dictionary();
05116 G__setnull(result7);
05117 return(1 || funcname || hash || result7 || libp) ;
05118 }
05119
05120 static int G__G__GeomBuilder_249_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05121 {
05122 ((TGeoVolumeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05123 G__setnull(result7);
05124 return(1 || funcname || hash || result7 || libp) ;
05125 }
05126
05127 static int G__G__GeomBuilder_249_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05128 {
05129 G__letint(result7, 67, (long) TGeoVolumeEditor::DeclFileName());
05130 return(1 || funcname || hash || result7 || libp) ;
05131 }
05132
05133 static int G__G__GeomBuilder_249_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05134 {
05135 G__letint(result7, 105, (long) TGeoVolumeEditor::ImplFileLine());
05136 return(1 || funcname || hash || result7 || libp) ;
05137 }
05138
05139 static int G__G__GeomBuilder_249_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05140 {
05141 G__letint(result7, 67, (long) TGeoVolumeEditor::ImplFileName());
05142 return(1 || funcname || hash || result7 || libp) ;
05143 }
05144
05145 static int G__G__GeomBuilder_249_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05146 {
05147 G__letint(result7, 105, (long) TGeoVolumeEditor::DeclFileLine());
05148 return(1 || funcname || hash || result7 || libp) ;
05149 }
05150
05151
05152 typedef TGeoVolumeEditor G__TTGeoVolumeEditor;
05153 static int G__G__GeomBuilder_249_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05154 {
05155 char* gvp = (char*) G__getgvp();
05156 long soff = G__getstructoffset();
05157 int n = G__getaryconstruct();
05158
05159
05160
05161
05162
05163 if (!soff) {
05164 return(1);
05165 }
05166 if (n) {
05167 if (gvp == (char*)G__PVOID) {
05168 delete[] (TGeoVolumeEditor*) soff;
05169 } else {
05170 G__setgvp((long) G__PVOID);
05171 for (int i = n - 1; i >= 0; --i) {
05172 ((TGeoVolumeEditor*) (soff+(sizeof(TGeoVolumeEditor)*i)))->~G__TTGeoVolumeEditor();
05173 }
05174 G__setgvp((long)gvp);
05175 }
05176 } else {
05177 if (gvp == (char*)G__PVOID) {
05178 delete (TGeoVolumeEditor*) soff;
05179 } else {
05180 G__setgvp((long) G__PVOID);
05181 ((TGeoVolumeEditor*) (soff))->~G__TTGeoVolumeEditor();
05182 G__setgvp((long)gvp);
05183 }
05184 }
05185 G__setnull(result7);
05186 return(1 || funcname || hash || result7 || libp) ;
05187 }
05188
05189
05190
05191 static int G__G__GeomBuilder_251_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05192 {
05193 TGeoBBoxEditor* p = NULL;
05194 char* gvp = (char*) G__getgvp();
05195 switch (libp->paran) {
05196 case 5:
05197
05198 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05199 p = new TGeoBBoxEditor(
05200 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05201 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05202 , (Pixel_t) G__int(libp->para[4]));
05203 } else {
05204 p = new((void*) gvp) TGeoBBoxEditor(
05205 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05206 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05207 , (Pixel_t) G__int(libp->para[4]));
05208 }
05209 break;
05210 case 4:
05211
05212 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05213 p = new TGeoBBoxEditor(
05214 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05215 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05216 } else {
05217 p = new((void*) gvp) TGeoBBoxEditor(
05218 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05219 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05220 }
05221 break;
05222 case 3:
05223
05224 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05225 p = new TGeoBBoxEditor(
05226 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05227 , (Int_t) G__int(libp->para[2]));
05228 } else {
05229 p = new((void*) gvp) TGeoBBoxEditor(
05230 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05231 , (Int_t) G__int(libp->para[2]));
05232 }
05233 break;
05234 case 2:
05235
05236 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05237 p = new TGeoBBoxEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05238 } else {
05239 p = new((void*) gvp) TGeoBBoxEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05240 }
05241 break;
05242 case 1:
05243
05244 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05245 p = new TGeoBBoxEditor((TGWindow*) G__int(libp->para[0]));
05246 } else {
05247 p = new((void*) gvp) TGeoBBoxEditor((TGWindow*) G__int(libp->para[0]));
05248 }
05249 break;
05250 case 0:
05251 int n = G__getaryconstruct();
05252 if (n) {
05253 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05254 p = new TGeoBBoxEditor[n];
05255 } else {
05256 p = new((void*) gvp) TGeoBBoxEditor[n];
05257 }
05258 } else {
05259 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05260 p = new TGeoBBoxEditor;
05261 } else {
05262 p = new((void*) gvp) TGeoBBoxEditor;
05263 }
05264 }
05265 break;
05266 }
05267 result7->obj.i = (long) p;
05268 result7->ref = (long) p;
05269 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor));
05270 return(1 || funcname || hash || result7 || libp) ;
05271 }
05272
05273 static int G__G__GeomBuilder_251_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05274 {
05275 ((TGeoBBoxEditor*) G__getstructoffset())->DoDx();
05276 G__setnull(result7);
05277 return(1 || funcname || hash || result7 || libp) ;
05278 }
05279
05280 static int G__G__GeomBuilder_251_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05281 {
05282 ((TGeoBBoxEditor*) G__getstructoffset())->DoDy();
05283 G__setnull(result7);
05284 return(1 || funcname || hash || result7 || libp) ;
05285 }
05286
05287 static int G__G__GeomBuilder_251_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05288 {
05289 ((TGeoBBoxEditor*) G__getstructoffset())->DoDz();
05290 G__setnull(result7);
05291 return(1 || funcname || hash || result7 || libp) ;
05292 }
05293
05294 static int G__G__GeomBuilder_251_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05295 {
05296 ((TGeoBBoxEditor*) G__getstructoffset())->DoOx();
05297 G__setnull(result7);
05298 return(1 || funcname || hash || result7 || libp) ;
05299 }
05300
05301 static int G__G__GeomBuilder_251_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05302 {
05303 ((TGeoBBoxEditor*) G__getstructoffset())->DoOy();
05304 G__setnull(result7);
05305 return(1 || funcname || hash || result7 || libp) ;
05306 }
05307
05308 static int G__G__GeomBuilder_251_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05309 {
05310 ((TGeoBBoxEditor*) G__getstructoffset())->DoOz();
05311 G__setnull(result7);
05312 return(1 || funcname || hash || result7 || libp) ;
05313 }
05314
05315 static int G__G__GeomBuilder_251_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05316 {
05317 ((TGeoBBoxEditor*) G__getstructoffset())->DoModified();
05318 G__setnull(result7);
05319 return(1 || funcname || hash || result7 || libp) ;
05320 }
05321
05322 static int G__G__GeomBuilder_251_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05323 {
05324 ((TGeoBBoxEditor*) G__getstructoffset())->DoName();
05325 G__setnull(result7);
05326 return(1 || funcname || hash || result7 || libp) ;
05327 }
05328
05329 static int G__G__GeomBuilder_251_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05330 {
05331 ((TGeoBBoxEditor*) G__getstructoffset())->DoApply();
05332 G__setnull(result7);
05333 return(1 || funcname || hash || result7 || libp) ;
05334 }
05335
05336 static int G__G__GeomBuilder_251_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05337 {
05338 ((TGeoBBoxEditor*) G__getstructoffset())->DoUndo();
05339 G__setnull(result7);
05340 return(1 || funcname || hash || result7 || libp) ;
05341 }
05342
05343 static int G__G__GeomBuilder_251_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05344 {
05345 G__letint(result7, 85, (long) TGeoBBoxEditor::Class());
05346 return(1 || funcname || hash || result7 || libp) ;
05347 }
05348
05349 static int G__G__GeomBuilder_251_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05350 {
05351 G__letint(result7, 67, (long) TGeoBBoxEditor::Class_Name());
05352 return(1 || funcname || hash || result7 || libp) ;
05353 }
05354
05355 static int G__G__GeomBuilder_251_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05356 {
05357 G__letint(result7, 115, (long) TGeoBBoxEditor::Class_Version());
05358 return(1 || funcname || hash || result7 || libp) ;
05359 }
05360
05361 static int G__G__GeomBuilder_251_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05362 {
05363 TGeoBBoxEditor::Dictionary();
05364 G__setnull(result7);
05365 return(1 || funcname || hash || result7 || libp) ;
05366 }
05367
05368 static int G__G__GeomBuilder_251_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05369 {
05370 ((TGeoBBoxEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05371 G__setnull(result7);
05372 return(1 || funcname || hash || result7 || libp) ;
05373 }
05374
05375 static int G__G__GeomBuilder_251_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05376 {
05377 G__letint(result7, 67, (long) TGeoBBoxEditor::DeclFileName());
05378 return(1 || funcname || hash || result7 || libp) ;
05379 }
05380
05381 static int G__G__GeomBuilder_251_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05382 {
05383 G__letint(result7, 105, (long) TGeoBBoxEditor::ImplFileLine());
05384 return(1 || funcname || hash || result7 || libp) ;
05385 }
05386
05387 static int G__G__GeomBuilder_251_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05388 {
05389 G__letint(result7, 67, (long) TGeoBBoxEditor::ImplFileName());
05390 return(1 || funcname || hash || result7 || libp) ;
05391 }
05392
05393 static int G__G__GeomBuilder_251_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05394 {
05395 G__letint(result7, 105, (long) TGeoBBoxEditor::DeclFileLine());
05396 return(1 || funcname || hash || result7 || libp) ;
05397 }
05398
05399
05400 typedef TGeoBBoxEditor G__TTGeoBBoxEditor;
05401 static int G__G__GeomBuilder_251_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05402 {
05403 char* gvp = (char*) G__getgvp();
05404 long soff = G__getstructoffset();
05405 int n = G__getaryconstruct();
05406
05407
05408
05409
05410
05411 if (!soff) {
05412 return(1);
05413 }
05414 if (n) {
05415 if (gvp == (char*)G__PVOID) {
05416 delete[] (TGeoBBoxEditor*) soff;
05417 } else {
05418 G__setgvp((long) G__PVOID);
05419 for (int i = n - 1; i >= 0; --i) {
05420 ((TGeoBBoxEditor*) (soff+(sizeof(TGeoBBoxEditor)*i)))->~G__TTGeoBBoxEditor();
05421 }
05422 G__setgvp((long)gvp);
05423 }
05424 } else {
05425 if (gvp == (char*)G__PVOID) {
05426 delete (TGeoBBoxEditor*) soff;
05427 } else {
05428 G__setgvp((long) G__PVOID);
05429 ((TGeoBBoxEditor*) (soff))->~G__TTGeoBBoxEditor();
05430 G__setgvp((long)gvp);
05431 }
05432 }
05433 G__setnull(result7);
05434 return(1 || funcname || hash || result7 || libp) ;
05435 }
05436
05437
05438
05439 static int G__G__GeomBuilder_252_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05440 {
05441 TGeoMediumEditor* p = NULL;
05442 char* gvp = (char*) G__getgvp();
05443 switch (libp->paran) {
05444 case 5:
05445
05446 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05447 p = new TGeoMediumEditor(
05448 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05449 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05450 , (Pixel_t) G__int(libp->para[4]));
05451 } else {
05452 p = new((void*) gvp) TGeoMediumEditor(
05453 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05454 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05455 , (Pixel_t) G__int(libp->para[4]));
05456 }
05457 break;
05458 case 4:
05459
05460 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05461 p = new TGeoMediumEditor(
05462 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05463 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05464 } else {
05465 p = new((void*) gvp) TGeoMediumEditor(
05466 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05467 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05468 }
05469 break;
05470 case 3:
05471
05472 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05473 p = new TGeoMediumEditor(
05474 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05475 , (Int_t) G__int(libp->para[2]));
05476 } else {
05477 p = new((void*) gvp) TGeoMediumEditor(
05478 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05479 , (Int_t) G__int(libp->para[2]));
05480 }
05481 break;
05482 case 2:
05483
05484 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05485 p = new TGeoMediumEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05486 } else {
05487 p = new((void*) gvp) TGeoMediumEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05488 }
05489 break;
05490 case 1:
05491
05492 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05493 p = new TGeoMediumEditor((TGWindow*) G__int(libp->para[0]));
05494 } else {
05495 p = new((void*) gvp) TGeoMediumEditor((TGWindow*) G__int(libp->para[0]));
05496 }
05497 break;
05498 case 0:
05499 int n = G__getaryconstruct();
05500 if (n) {
05501 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05502 p = new TGeoMediumEditor[n];
05503 } else {
05504 p = new((void*) gvp) TGeoMediumEditor[n];
05505 }
05506 } else {
05507 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05508 p = new TGeoMediumEditor;
05509 } else {
05510 p = new((void*) gvp) TGeoMediumEditor;
05511 }
05512 }
05513 break;
05514 }
05515 result7->obj.i = (long) p;
05516 result7->ref = (long) p;
05517 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor));
05518 return(1 || funcname || hash || result7 || libp) ;
05519 }
05520
05521 static int G__G__GeomBuilder_252_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05522 {
05523 ((TGeoMediumEditor*) G__getstructoffset())->DoEditMaterial();
05524 G__setnull(result7);
05525 return(1 || funcname || hash || result7 || libp) ;
05526 }
05527
05528 static int G__G__GeomBuilder_252_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05529 {
05530 ((TGeoMediumEditor*) G__getstructoffset())->DoSelectMaterial();
05531 G__setnull(result7);
05532 return(1 || funcname || hash || result7 || libp) ;
05533 }
05534
05535 static int G__G__GeomBuilder_252_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05536 {
05537 ((TGeoMediumEditor*) G__getstructoffset())->DoMedName();
05538 G__setnull(result7);
05539 return(1 || funcname || hash || result7 || libp) ;
05540 }
05541
05542 static int G__G__GeomBuilder_252_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05543 {
05544 ((TGeoMediumEditor*) G__getstructoffset())->DoMedId();
05545 G__setnull(result7);
05546 return(1 || funcname || hash || result7 || libp) ;
05547 }
05548
05549 static int G__G__GeomBuilder_252_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05550 {
05551 ((TGeoMediumEditor*) G__getstructoffset())->DoToggleSensitive();
05552 G__setnull(result7);
05553 return(1 || funcname || hash || result7 || libp) ;
05554 }
05555
05556 static int G__G__GeomBuilder_252_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05557 {
05558 ((TGeoMediumEditor*) G__getstructoffset())->DoMagfldSelect((Int_t) G__int(libp->para[0]));
05559 G__setnull(result7);
05560 return(1 || funcname || hash || result7 || libp) ;
05561 }
05562
05563 static int G__G__GeomBuilder_252_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05564 {
05565 ((TGeoMediumEditor*) G__getstructoffset())->DoFieldm();
05566 G__setnull(result7);
05567 return(1 || funcname || hash || result7 || libp) ;
05568 }
05569
05570 static int G__G__GeomBuilder_252_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05571 {
05572 ((TGeoMediumEditor*) G__getstructoffset())->DoTmaxfd();
05573 G__setnull(result7);
05574 return(1 || funcname || hash || result7 || libp) ;
05575 }
05576
05577 static int G__G__GeomBuilder_252_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05578 {
05579 ((TGeoMediumEditor*) G__getstructoffset())->DoStemax();
05580 G__setnull(result7);
05581 return(1 || funcname || hash || result7 || libp) ;
05582 }
05583
05584 static int G__G__GeomBuilder_252_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05585 {
05586 ((TGeoMediumEditor*) G__getstructoffset())->DoDeemax();
05587 G__setnull(result7);
05588 return(1 || funcname || hash || result7 || libp) ;
05589 }
05590
05591 static int G__G__GeomBuilder_252_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05592 {
05593 ((TGeoMediumEditor*) G__getstructoffset())->DoEpsil();
05594 G__setnull(result7);
05595 return(1 || funcname || hash || result7 || libp) ;
05596 }
05597
05598 static int G__G__GeomBuilder_252_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05599 {
05600 ((TGeoMediumEditor*) G__getstructoffset())->DoStmin();
05601 G__setnull(result7);
05602 return(1 || funcname || hash || result7 || libp) ;
05603 }
05604
05605 static int G__G__GeomBuilder_252_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05606 {
05607 ((TGeoMediumEditor*) G__getstructoffset())->DoApply();
05608 G__setnull(result7);
05609 return(1 || funcname || hash || result7 || libp) ;
05610 }
05611
05612 static int G__G__GeomBuilder_252_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05613 {
05614 ((TGeoMediumEditor*) G__getstructoffset())->DoUndo();
05615 G__setnull(result7);
05616 return(1 || funcname || hash || result7 || libp) ;
05617 }
05618
05619 static int G__G__GeomBuilder_252_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05620 {
05621 G__letint(result7, 85, (long) TGeoMediumEditor::Class());
05622 return(1 || funcname || hash || result7 || libp) ;
05623 }
05624
05625 static int G__G__GeomBuilder_252_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05626 {
05627 G__letint(result7, 67, (long) TGeoMediumEditor::Class_Name());
05628 return(1 || funcname || hash || result7 || libp) ;
05629 }
05630
05631 static int G__G__GeomBuilder_252_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05632 {
05633 G__letint(result7, 115, (long) TGeoMediumEditor::Class_Version());
05634 return(1 || funcname || hash || result7 || libp) ;
05635 }
05636
05637 static int G__G__GeomBuilder_252_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05638 {
05639 TGeoMediumEditor::Dictionary();
05640 G__setnull(result7);
05641 return(1 || funcname || hash || result7 || libp) ;
05642 }
05643
05644 static int G__G__GeomBuilder_252_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05645 {
05646 ((TGeoMediumEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05647 G__setnull(result7);
05648 return(1 || funcname || hash || result7 || libp) ;
05649 }
05650
05651 static int G__G__GeomBuilder_252_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05652 {
05653 G__letint(result7, 67, (long) TGeoMediumEditor::DeclFileName());
05654 return(1 || funcname || hash || result7 || libp) ;
05655 }
05656
05657 static int G__G__GeomBuilder_252_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05658 {
05659 G__letint(result7, 105, (long) TGeoMediumEditor::ImplFileLine());
05660 return(1 || funcname || hash || result7 || libp) ;
05661 }
05662
05663 static int G__G__GeomBuilder_252_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05664 {
05665 G__letint(result7, 67, (long) TGeoMediumEditor::ImplFileName());
05666 return(1 || funcname || hash || result7 || libp) ;
05667 }
05668
05669 static int G__G__GeomBuilder_252_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05670 {
05671 G__letint(result7, 105, (long) TGeoMediumEditor::DeclFileLine());
05672 return(1 || funcname || hash || result7 || libp) ;
05673 }
05674
05675
05676 typedef TGeoMediumEditor G__TTGeoMediumEditor;
05677 static int G__G__GeomBuilder_252_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05678 {
05679 char* gvp = (char*) G__getgvp();
05680 long soff = G__getstructoffset();
05681 int n = G__getaryconstruct();
05682
05683
05684
05685
05686
05687 if (!soff) {
05688 return(1);
05689 }
05690 if (n) {
05691 if (gvp == (char*)G__PVOID) {
05692 delete[] (TGeoMediumEditor*) soff;
05693 } else {
05694 G__setgvp((long) G__PVOID);
05695 for (int i = n - 1; i >= 0; --i) {
05696 ((TGeoMediumEditor*) (soff+(sizeof(TGeoMediumEditor)*i)))->~G__TTGeoMediumEditor();
05697 }
05698 G__setgvp((long)gvp);
05699 }
05700 } else {
05701 if (gvp == (char*)G__PVOID) {
05702 delete (TGeoMediumEditor*) soff;
05703 } else {
05704 G__setgvp((long) G__PVOID);
05705 ((TGeoMediumEditor*) (soff))->~G__TTGeoMediumEditor();
05706 G__setgvp((long)gvp);
05707 }
05708 }
05709 G__setnull(result7);
05710 return(1 || funcname || hash || result7 || libp) ;
05711 }
05712
05713
05714
05715 static int G__G__GeomBuilder_254_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05716 {
05717 TGeoNodeEditor* p = NULL;
05718 char* gvp = (char*) G__getgvp();
05719 switch (libp->paran) {
05720 case 5:
05721
05722 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05723 p = new TGeoNodeEditor(
05724 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05725 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05726 , (Pixel_t) G__int(libp->para[4]));
05727 } else {
05728 p = new((void*) gvp) TGeoNodeEditor(
05729 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05730 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05731 , (Pixel_t) G__int(libp->para[4]));
05732 }
05733 break;
05734 case 4:
05735
05736 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05737 p = new TGeoNodeEditor(
05738 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05739 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05740 } else {
05741 p = new((void*) gvp) TGeoNodeEditor(
05742 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05743 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05744 }
05745 break;
05746 case 3:
05747
05748 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05749 p = new TGeoNodeEditor(
05750 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05751 , (Int_t) G__int(libp->para[2]));
05752 } else {
05753 p = new((void*) gvp) TGeoNodeEditor(
05754 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05755 , (Int_t) G__int(libp->para[2]));
05756 }
05757 break;
05758 case 2:
05759
05760 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05761 p = new TGeoNodeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05762 } else {
05763 p = new((void*) gvp) TGeoNodeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05764 }
05765 break;
05766 case 1:
05767
05768 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05769 p = new TGeoNodeEditor((TGWindow*) G__int(libp->para[0]));
05770 } else {
05771 p = new((void*) gvp) TGeoNodeEditor((TGWindow*) G__int(libp->para[0]));
05772 }
05773 break;
05774 case 0:
05775 int n = G__getaryconstruct();
05776 if (n) {
05777 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05778 p = new TGeoNodeEditor[n];
05779 } else {
05780 p = new((void*) gvp) TGeoNodeEditor[n];
05781 }
05782 } else {
05783 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05784 p = new TGeoNodeEditor;
05785 } else {
05786 p = new((void*) gvp) TGeoNodeEditor;
05787 }
05788 }
05789 break;
05790 }
05791 result7->obj.i = (long) p;
05792 result7->ref = (long) p;
05793 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor));
05794 return(1 || funcname || hash || result7 || libp) ;
05795 }
05796
05797 static int G__G__GeomBuilder_254_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05798 {
05799 ((TGeoNodeEditor*) G__getstructoffset())->DoEditMother();
05800 G__setnull(result7);
05801 return(1 || funcname || hash || result7 || libp) ;
05802 }
05803
05804 static int G__G__GeomBuilder_254_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05805 {
05806 ((TGeoNodeEditor*) G__getstructoffset())->DoEditVolume();
05807 G__setnull(result7);
05808 return(1 || funcname || hash || result7 || libp) ;
05809 }
05810
05811 static int G__G__GeomBuilder_254_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05812 {
05813 ((TGeoNodeEditor*) G__getstructoffset())->DoEditMatrix();
05814 G__setnull(result7);
05815 return(1 || funcname || hash || result7 || libp) ;
05816 }
05817
05818 static int G__G__GeomBuilder_254_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05819 {
05820 ((TGeoNodeEditor*) G__getstructoffset())->DoSelectMother();
05821 G__setnull(result7);
05822 return(1 || funcname || hash || result7 || libp) ;
05823 }
05824
05825 static int G__G__GeomBuilder_254_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05826 {
05827 ((TGeoNodeEditor*) G__getstructoffset())->DoSelectVolume();
05828 G__setnull(result7);
05829 return(1 || funcname || hash || result7 || libp) ;
05830 }
05831
05832 static int G__G__GeomBuilder_254_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05833 {
05834 ((TGeoNodeEditor*) G__getstructoffset())->DoSelectMatrix();
05835 G__setnull(result7);
05836 return(1 || funcname || hash || result7 || libp) ;
05837 }
05838
05839 static int G__G__GeomBuilder_254_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05840 {
05841 ((TGeoNodeEditor*) G__getstructoffset())->DoNodeName();
05842 G__setnull(result7);
05843 return(1 || funcname || hash || result7 || libp) ;
05844 }
05845
05846 static int G__G__GeomBuilder_254_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05847 {
05848 ((TGeoNodeEditor*) G__getstructoffset())->DoNodeNumber();
05849 G__setnull(result7);
05850 return(1 || funcname || hash || result7 || libp) ;
05851 }
05852
05853 static int G__G__GeomBuilder_254_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05854 {
05855 ((TGeoNodeEditor*) G__getstructoffset())->DoApply();
05856 G__setnull(result7);
05857 return(1 || funcname || hash || result7 || libp) ;
05858 }
05859
05860 static int G__G__GeomBuilder_254_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05861 {
05862 ((TGeoNodeEditor*) G__getstructoffset())->DoUndo();
05863 G__setnull(result7);
05864 return(1 || funcname || hash || result7 || libp) ;
05865 }
05866
05867 static int G__G__GeomBuilder_254_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05868 {
05869 G__letint(result7, 85, (long) TGeoNodeEditor::Class());
05870 return(1 || funcname || hash || result7 || libp) ;
05871 }
05872
05873 static int G__G__GeomBuilder_254_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05874 {
05875 G__letint(result7, 67, (long) TGeoNodeEditor::Class_Name());
05876 return(1 || funcname || hash || result7 || libp) ;
05877 }
05878
05879 static int G__G__GeomBuilder_254_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05880 {
05881 G__letint(result7, 115, (long) TGeoNodeEditor::Class_Version());
05882 return(1 || funcname || hash || result7 || libp) ;
05883 }
05884
05885 static int G__G__GeomBuilder_254_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05886 {
05887 TGeoNodeEditor::Dictionary();
05888 G__setnull(result7);
05889 return(1 || funcname || hash || result7 || libp) ;
05890 }
05891
05892 static int G__G__GeomBuilder_254_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05893 {
05894 ((TGeoNodeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05895 G__setnull(result7);
05896 return(1 || funcname || hash || result7 || libp) ;
05897 }
05898
05899 static int G__G__GeomBuilder_254_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05900 {
05901 G__letint(result7, 67, (long) TGeoNodeEditor::DeclFileName());
05902 return(1 || funcname || hash || result7 || libp) ;
05903 }
05904
05905 static int G__G__GeomBuilder_254_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05906 {
05907 G__letint(result7, 105, (long) TGeoNodeEditor::ImplFileLine());
05908 return(1 || funcname || hash || result7 || libp) ;
05909 }
05910
05911 static int G__G__GeomBuilder_254_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05912 {
05913 G__letint(result7, 67, (long) TGeoNodeEditor::ImplFileName());
05914 return(1 || funcname || hash || result7 || libp) ;
05915 }
05916
05917 static int G__G__GeomBuilder_254_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05918 {
05919 G__letint(result7, 105, (long) TGeoNodeEditor::DeclFileLine());
05920 return(1 || funcname || hash || result7 || libp) ;
05921 }
05922
05923
05924 typedef TGeoNodeEditor G__TTGeoNodeEditor;
05925 static int G__G__GeomBuilder_254_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05926 {
05927 char* gvp = (char*) G__getgvp();
05928 long soff = G__getstructoffset();
05929 int n = G__getaryconstruct();
05930
05931
05932
05933
05934
05935 if (!soff) {
05936 return(1);
05937 }
05938 if (n) {
05939 if (gvp == (char*)G__PVOID) {
05940 delete[] (TGeoNodeEditor*) soff;
05941 } else {
05942 G__setgvp((long) G__PVOID);
05943 for (int i = n - 1; i >= 0; --i) {
05944 ((TGeoNodeEditor*) (soff+(sizeof(TGeoNodeEditor)*i)))->~G__TTGeoNodeEditor();
05945 }
05946 G__setgvp((long)gvp);
05947 }
05948 } else {
05949 if (gvp == (char*)G__PVOID) {
05950 delete (TGeoNodeEditor*) soff;
05951 } else {
05952 G__setgvp((long) G__PVOID);
05953 ((TGeoNodeEditor*) (soff))->~G__TTGeoNodeEditor();
05954 G__setgvp((long)gvp);
05955 }
05956 }
05957 G__setnull(result7);
05958 return(1 || funcname || hash || result7 || libp) ;
05959 }
05960
05961
05962
05963 static int G__G__GeomBuilder_258_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05964 {
05965 TGeoTranslationEditor* p = NULL;
05966 char* gvp = (char*) G__getgvp();
05967 switch (libp->paran) {
05968 case 5:
05969
05970 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05971 p = new TGeoTranslationEditor(
05972 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05973 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05974 , (Pixel_t) G__int(libp->para[4]));
05975 } else {
05976 p = new((void*) gvp) TGeoTranslationEditor(
05977 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05978 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05979 , (Pixel_t) G__int(libp->para[4]));
05980 }
05981 break;
05982 case 4:
05983
05984 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05985 p = new TGeoTranslationEditor(
05986 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05987 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05988 } else {
05989 p = new((void*) gvp) TGeoTranslationEditor(
05990 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05991 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05992 }
05993 break;
05994 case 3:
05995
05996 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05997 p = new TGeoTranslationEditor(
05998 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05999 , (Int_t) G__int(libp->para[2]));
06000 } else {
06001 p = new((void*) gvp) TGeoTranslationEditor(
06002 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06003 , (Int_t) G__int(libp->para[2]));
06004 }
06005 break;
06006 case 2:
06007
06008 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06009 p = new TGeoTranslationEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06010 } else {
06011 p = new((void*) gvp) TGeoTranslationEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06012 }
06013 break;
06014 case 1:
06015
06016 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06017 p = new TGeoTranslationEditor((TGWindow*) G__int(libp->para[0]));
06018 } else {
06019 p = new((void*) gvp) TGeoTranslationEditor((TGWindow*) G__int(libp->para[0]));
06020 }
06021 break;
06022 case 0:
06023 int n = G__getaryconstruct();
06024 if (n) {
06025 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06026 p = new TGeoTranslationEditor[n];
06027 } else {
06028 p = new((void*) gvp) TGeoTranslationEditor[n];
06029 }
06030 } else {
06031 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06032 p = new TGeoTranslationEditor;
06033 } else {
06034 p = new((void*) gvp) TGeoTranslationEditor;
06035 }
06036 }
06037 break;
06038 }
06039 result7->obj.i = (long) p;
06040 result7->ref = (long) p;
06041 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor));
06042 return(1 || funcname || hash || result7 || libp) ;
06043 }
06044
06045 static int G__G__GeomBuilder_258_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06046 {
06047 ((TGeoTranslationEditor*) G__getstructoffset())->DoDx();
06048 G__setnull(result7);
06049 return(1 || funcname || hash || result7 || libp) ;
06050 }
06051
06052 static int G__G__GeomBuilder_258_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06053 {
06054 ((TGeoTranslationEditor*) G__getstructoffset())->DoDy();
06055 G__setnull(result7);
06056 return(1 || funcname || hash || result7 || libp) ;
06057 }
06058
06059 static int G__G__GeomBuilder_258_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06060 {
06061 ((TGeoTranslationEditor*) G__getstructoffset())->DoDz();
06062 G__setnull(result7);
06063 return(1 || funcname || hash || result7 || libp) ;
06064 }
06065
06066 static int G__G__GeomBuilder_258_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06067 {
06068 ((TGeoTranslationEditor*) G__getstructoffset())->DoModified();
06069 G__setnull(result7);
06070 return(1 || funcname || hash || result7 || libp) ;
06071 }
06072
06073 static int G__G__GeomBuilder_258_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06074 {
06075 ((TGeoTranslationEditor*) G__getstructoffset())->DoName();
06076 G__setnull(result7);
06077 return(1 || funcname || hash || result7 || libp) ;
06078 }
06079
06080 static int G__G__GeomBuilder_258_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06081 {
06082 G__letint(result7, 103, (long) ((TGeoTranslationEditor*) G__getstructoffset())->DoParameters());
06083 return(1 || funcname || hash || result7 || libp) ;
06084 }
06085
06086 static int G__G__GeomBuilder_258_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06087 {
06088 ((TGeoTranslationEditor*) G__getstructoffset())->DoApply();
06089 G__setnull(result7);
06090 return(1 || funcname || hash || result7 || libp) ;
06091 }
06092
06093 static int G__G__GeomBuilder_258_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06094 {
06095 ((TGeoTranslationEditor*) G__getstructoffset())->DoCancel();
06096 G__setnull(result7);
06097 return(1 || funcname || hash || result7 || libp) ;
06098 }
06099
06100 static int G__G__GeomBuilder_258_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06101 {
06102 ((TGeoTranslationEditor*) G__getstructoffset())->DoUndo();
06103 G__setnull(result7);
06104 return(1 || funcname || hash || result7 || libp) ;
06105 }
06106
06107 static int G__G__GeomBuilder_258_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06108 {
06109 G__letint(result7, 85, (long) TGeoTranslationEditor::Class());
06110 return(1 || funcname || hash || result7 || libp) ;
06111 }
06112
06113 static int G__G__GeomBuilder_258_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06114 {
06115 G__letint(result7, 67, (long) TGeoTranslationEditor::Class_Name());
06116 return(1 || funcname || hash || result7 || libp) ;
06117 }
06118
06119 static int G__G__GeomBuilder_258_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06120 {
06121 G__letint(result7, 115, (long) TGeoTranslationEditor::Class_Version());
06122 return(1 || funcname || hash || result7 || libp) ;
06123 }
06124
06125 static int G__G__GeomBuilder_258_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06126 {
06127 TGeoTranslationEditor::Dictionary();
06128 G__setnull(result7);
06129 return(1 || funcname || hash || result7 || libp) ;
06130 }
06131
06132 static int G__G__GeomBuilder_258_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06133 {
06134 ((TGeoTranslationEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06135 G__setnull(result7);
06136 return(1 || funcname || hash || result7 || libp) ;
06137 }
06138
06139 static int G__G__GeomBuilder_258_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06140 {
06141 G__letint(result7, 67, (long) TGeoTranslationEditor::DeclFileName());
06142 return(1 || funcname || hash || result7 || libp) ;
06143 }
06144
06145 static int G__G__GeomBuilder_258_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06146 {
06147 G__letint(result7, 105, (long) TGeoTranslationEditor::ImplFileLine());
06148 return(1 || funcname || hash || result7 || libp) ;
06149 }
06150
06151 static int G__G__GeomBuilder_258_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06152 {
06153 G__letint(result7, 67, (long) TGeoTranslationEditor::ImplFileName());
06154 return(1 || funcname || hash || result7 || libp) ;
06155 }
06156
06157 static int G__G__GeomBuilder_258_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06158 {
06159 G__letint(result7, 105, (long) TGeoTranslationEditor::DeclFileLine());
06160 return(1 || funcname || hash || result7 || libp) ;
06161 }
06162
06163
06164 typedef TGeoTranslationEditor G__TTGeoTranslationEditor;
06165 static int G__G__GeomBuilder_258_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06166 {
06167 char* gvp = (char*) G__getgvp();
06168 long soff = G__getstructoffset();
06169 int n = G__getaryconstruct();
06170
06171
06172
06173
06174
06175 if (!soff) {
06176 return(1);
06177 }
06178 if (n) {
06179 if (gvp == (char*)G__PVOID) {
06180 delete[] (TGeoTranslationEditor*) soff;
06181 } else {
06182 G__setgvp((long) G__PVOID);
06183 for (int i = n - 1; i >= 0; --i) {
06184 ((TGeoTranslationEditor*) (soff+(sizeof(TGeoTranslationEditor)*i)))->~G__TTGeoTranslationEditor();
06185 }
06186 G__setgvp((long)gvp);
06187 }
06188 } else {
06189 if (gvp == (char*)G__PVOID) {
06190 delete (TGeoTranslationEditor*) soff;
06191 } else {
06192 G__setgvp((long) G__PVOID);
06193 ((TGeoTranslationEditor*) (soff))->~G__TTGeoTranslationEditor();
06194 G__setgvp((long)gvp);
06195 }
06196 }
06197 G__setnull(result7);
06198 return(1 || funcname || hash || result7 || libp) ;
06199 }
06200
06201
06202
06203 static int G__G__GeomBuilder_259_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06204 {
06205 TGeoRotationEditor* p = NULL;
06206 char* gvp = (char*) G__getgvp();
06207 switch (libp->paran) {
06208 case 5:
06209
06210 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06211 p = new TGeoRotationEditor(
06212 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06213 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06214 , (Pixel_t) G__int(libp->para[4]));
06215 } else {
06216 p = new((void*) gvp) TGeoRotationEditor(
06217 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06218 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06219 , (Pixel_t) G__int(libp->para[4]));
06220 }
06221 break;
06222 case 4:
06223
06224 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06225 p = new TGeoRotationEditor(
06226 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06227 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06228 } else {
06229 p = new((void*) gvp) TGeoRotationEditor(
06230 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06231 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06232 }
06233 break;
06234 case 3:
06235
06236 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06237 p = new TGeoRotationEditor(
06238 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06239 , (Int_t) G__int(libp->para[2]));
06240 } else {
06241 p = new((void*) gvp) TGeoRotationEditor(
06242 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06243 , (Int_t) G__int(libp->para[2]));
06244 }
06245 break;
06246 case 2:
06247
06248 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06249 p = new TGeoRotationEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06250 } else {
06251 p = new((void*) gvp) TGeoRotationEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06252 }
06253 break;
06254 case 1:
06255
06256 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06257 p = new TGeoRotationEditor((TGWindow*) G__int(libp->para[0]));
06258 } else {
06259 p = new((void*) gvp) TGeoRotationEditor((TGWindow*) G__int(libp->para[0]));
06260 }
06261 break;
06262 case 0:
06263 int n = G__getaryconstruct();
06264 if (n) {
06265 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06266 p = new TGeoRotationEditor[n];
06267 } else {
06268 p = new((void*) gvp) TGeoRotationEditor[n];
06269 }
06270 } else {
06271 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06272 p = new TGeoRotationEditor;
06273 } else {
06274 p = new((void*) gvp) TGeoRotationEditor;
06275 }
06276 }
06277 break;
06278 }
06279 result7->obj.i = (long) p;
06280 result7->ref = (long) p;
06281 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor));
06282 return(1 || funcname || hash || result7 || libp) ;
06283 }
06284
06285 static int G__G__GeomBuilder_259_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06286 {
06287 ((TGeoRotationEditor*) G__getstructoffset())->DoRotPhi();
06288 G__setnull(result7);
06289 return(1 || funcname || hash || result7 || libp) ;
06290 }
06291
06292 static int G__G__GeomBuilder_259_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06293 {
06294 ((TGeoRotationEditor*) G__getstructoffset())->DoRotTheta();
06295 G__setnull(result7);
06296 return(1 || funcname || hash || result7 || libp) ;
06297 }
06298
06299 static int G__G__GeomBuilder_259_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06300 {
06301 ((TGeoRotationEditor*) G__getstructoffset())->DoRotPsi();
06302 G__setnull(result7);
06303 return(1 || funcname || hash || result7 || libp) ;
06304 }
06305
06306 static int G__G__GeomBuilder_259_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06307 {
06308 ((TGeoRotationEditor*) G__getstructoffset())->DoRotAngle();
06309 G__setnull(result7);
06310 return(1 || funcname || hash || result7 || libp) ;
06311 }
06312
06313 static int G__G__GeomBuilder_259_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06314 {
06315 ((TGeoRotationEditor*) G__getstructoffset())->DoModified();
06316 G__setnull(result7);
06317 return(1 || funcname || hash || result7 || libp) ;
06318 }
06319
06320 static int G__G__GeomBuilder_259_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06321 {
06322 ((TGeoRotationEditor*) G__getstructoffset())->DoName();
06323 G__setnull(result7);
06324 return(1 || funcname || hash || result7 || libp) ;
06325 }
06326
06327 static int G__G__GeomBuilder_259_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06328 {
06329 G__letint(result7, 103, (long) ((TGeoRotationEditor*) G__getstructoffset())->DoParameters());
06330 return(1 || funcname || hash || result7 || libp) ;
06331 }
06332
06333 static int G__G__GeomBuilder_259_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06334 {
06335 ((TGeoRotationEditor*) G__getstructoffset())->DoApply();
06336 G__setnull(result7);
06337 return(1 || funcname || hash || result7 || libp) ;
06338 }
06339
06340 static int G__G__GeomBuilder_259_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06341 {
06342 ((TGeoRotationEditor*) G__getstructoffset())->DoCancel();
06343 G__setnull(result7);
06344 return(1 || funcname || hash || result7 || libp) ;
06345 }
06346
06347 static int G__G__GeomBuilder_259_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06348 {
06349 ((TGeoRotationEditor*) G__getstructoffset())->DoUndo();
06350 G__setnull(result7);
06351 return(1 || funcname || hash || result7 || libp) ;
06352 }
06353
06354 static int G__G__GeomBuilder_259_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06355 {
06356 G__letint(result7, 85, (long) TGeoRotationEditor::Class());
06357 return(1 || funcname || hash || result7 || libp) ;
06358 }
06359
06360 static int G__G__GeomBuilder_259_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06361 {
06362 G__letint(result7, 67, (long) TGeoRotationEditor::Class_Name());
06363 return(1 || funcname || hash || result7 || libp) ;
06364 }
06365
06366 static int G__G__GeomBuilder_259_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06367 {
06368 G__letint(result7, 115, (long) TGeoRotationEditor::Class_Version());
06369 return(1 || funcname || hash || result7 || libp) ;
06370 }
06371
06372 static int G__G__GeomBuilder_259_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06373 {
06374 TGeoRotationEditor::Dictionary();
06375 G__setnull(result7);
06376 return(1 || funcname || hash || result7 || libp) ;
06377 }
06378
06379 static int G__G__GeomBuilder_259_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06380 {
06381 ((TGeoRotationEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06382 G__setnull(result7);
06383 return(1 || funcname || hash || result7 || libp) ;
06384 }
06385
06386 static int G__G__GeomBuilder_259_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06387 {
06388 G__letint(result7, 67, (long) TGeoRotationEditor::DeclFileName());
06389 return(1 || funcname || hash || result7 || libp) ;
06390 }
06391
06392 static int G__G__GeomBuilder_259_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06393 {
06394 G__letint(result7, 105, (long) TGeoRotationEditor::ImplFileLine());
06395 return(1 || funcname || hash || result7 || libp) ;
06396 }
06397
06398 static int G__G__GeomBuilder_259_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06399 {
06400 G__letint(result7, 67, (long) TGeoRotationEditor::ImplFileName());
06401 return(1 || funcname || hash || result7 || libp) ;
06402 }
06403
06404 static int G__G__GeomBuilder_259_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06405 {
06406 G__letint(result7, 105, (long) TGeoRotationEditor::DeclFileLine());
06407 return(1 || funcname || hash || result7 || libp) ;
06408 }
06409
06410
06411 typedef TGeoRotationEditor G__TTGeoRotationEditor;
06412 static int G__G__GeomBuilder_259_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06413 {
06414 char* gvp = (char*) G__getgvp();
06415 long soff = G__getstructoffset();
06416 int n = G__getaryconstruct();
06417
06418
06419
06420
06421
06422 if (!soff) {
06423 return(1);
06424 }
06425 if (n) {
06426 if (gvp == (char*)G__PVOID) {
06427 delete[] (TGeoRotationEditor*) soff;
06428 } else {
06429 G__setgvp((long) G__PVOID);
06430 for (int i = n - 1; i >= 0; --i) {
06431 ((TGeoRotationEditor*) (soff+(sizeof(TGeoRotationEditor)*i)))->~G__TTGeoRotationEditor();
06432 }
06433 G__setgvp((long)gvp);
06434 }
06435 } else {
06436 if (gvp == (char*)G__PVOID) {
06437 delete (TGeoRotationEditor*) soff;
06438 } else {
06439 G__setgvp((long) G__PVOID);
06440 ((TGeoRotationEditor*) (soff))->~G__TTGeoRotationEditor();
06441 G__setgvp((long)gvp);
06442 }
06443 }
06444 G__setnull(result7);
06445 return(1 || funcname || hash || result7 || libp) ;
06446 }
06447
06448
06449
06450 static int G__G__GeomBuilder_260_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06451 {
06452 TGeoCombiTransEditor* p = NULL;
06453 char* gvp = (char*) G__getgvp();
06454 switch (libp->paran) {
06455 case 5:
06456
06457 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06458 p = new TGeoCombiTransEditor(
06459 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06460 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06461 , (Pixel_t) G__int(libp->para[4]));
06462 } else {
06463 p = new((void*) gvp) TGeoCombiTransEditor(
06464 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06465 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06466 , (Pixel_t) G__int(libp->para[4]));
06467 }
06468 break;
06469 case 4:
06470
06471 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06472 p = new TGeoCombiTransEditor(
06473 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06474 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06475 } else {
06476 p = new((void*) gvp) TGeoCombiTransEditor(
06477 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06478 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06479 }
06480 break;
06481 case 3:
06482
06483 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06484 p = new TGeoCombiTransEditor(
06485 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06486 , (Int_t) G__int(libp->para[2]));
06487 } else {
06488 p = new((void*) gvp) TGeoCombiTransEditor(
06489 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06490 , (Int_t) G__int(libp->para[2]));
06491 }
06492 break;
06493 case 2:
06494
06495 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06496 p = new TGeoCombiTransEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06497 } else {
06498 p = new((void*) gvp) TGeoCombiTransEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06499 }
06500 break;
06501 case 1:
06502
06503 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06504 p = new TGeoCombiTransEditor((TGWindow*) G__int(libp->para[0]));
06505 } else {
06506 p = new((void*) gvp) TGeoCombiTransEditor((TGWindow*) G__int(libp->para[0]));
06507 }
06508 break;
06509 case 0:
06510 int n = G__getaryconstruct();
06511 if (n) {
06512 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06513 p = new TGeoCombiTransEditor[n];
06514 } else {
06515 p = new((void*) gvp) TGeoCombiTransEditor[n];
06516 }
06517 } else {
06518 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06519 p = new TGeoCombiTransEditor;
06520 } else {
06521 p = new((void*) gvp) TGeoCombiTransEditor;
06522 }
06523 }
06524 break;
06525 }
06526 result7->obj.i = (long) p;
06527 result7->ref = (long) p;
06528 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor));
06529 return(1 || funcname || hash || result7 || libp) ;
06530 }
06531
06532 static int G__G__GeomBuilder_260_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06533 {
06534 ((TGeoCombiTransEditor*) G__getstructoffset())->DoDx();
06535 G__setnull(result7);
06536 return(1 || funcname || hash || result7 || libp) ;
06537 }
06538
06539 static int G__G__GeomBuilder_260_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06540 {
06541 ((TGeoCombiTransEditor*) G__getstructoffset())->DoDy();
06542 G__setnull(result7);
06543 return(1 || funcname || hash || result7 || libp) ;
06544 }
06545
06546 static int G__G__GeomBuilder_260_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06547 {
06548 ((TGeoCombiTransEditor*) G__getstructoffset())->DoDz();
06549 G__setnull(result7);
06550 return(1 || funcname || hash || result7 || libp) ;
06551 }
06552
06553 static int G__G__GeomBuilder_260_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06554 {
06555 ((TGeoCombiTransEditor*) G__getstructoffset())->DoRotPhi();
06556 G__setnull(result7);
06557 return(1 || funcname || hash || result7 || libp) ;
06558 }
06559
06560 static int G__G__GeomBuilder_260_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06561 {
06562 ((TGeoCombiTransEditor*) G__getstructoffset())->DoRotTheta();
06563 G__setnull(result7);
06564 return(1 || funcname || hash || result7 || libp) ;
06565 }
06566
06567 static int G__G__GeomBuilder_260_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06568 {
06569 ((TGeoCombiTransEditor*) G__getstructoffset())->DoRotPsi();
06570 G__setnull(result7);
06571 return(1 || funcname || hash || result7 || libp) ;
06572 }
06573
06574 static int G__G__GeomBuilder_260_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06575 {
06576 ((TGeoCombiTransEditor*) G__getstructoffset())->DoRotAngle();
06577 G__setnull(result7);
06578 return(1 || funcname || hash || result7 || libp) ;
06579 }
06580
06581 static int G__G__GeomBuilder_260_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06582 {
06583 ((TGeoCombiTransEditor*) G__getstructoffset())->DoModified();
06584 G__setnull(result7);
06585 return(1 || funcname || hash || result7 || libp) ;
06586 }
06587
06588 static int G__G__GeomBuilder_260_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06589 {
06590 ((TGeoCombiTransEditor*) G__getstructoffset())->DoName();
06591 G__setnull(result7);
06592 return(1 || funcname || hash || result7 || libp) ;
06593 }
06594
06595 static int G__G__GeomBuilder_260_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06596 {
06597 G__letint(result7, 103, (long) ((TGeoCombiTransEditor*) G__getstructoffset())->DoParameters());
06598 return(1 || funcname || hash || result7 || libp) ;
06599 }
06600
06601 static int G__G__GeomBuilder_260_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06602 {
06603 ((TGeoCombiTransEditor*) G__getstructoffset())->DoApply();
06604 G__setnull(result7);
06605 return(1 || funcname || hash || result7 || libp) ;
06606 }
06607
06608 static int G__G__GeomBuilder_260_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06609 {
06610 ((TGeoCombiTransEditor*) G__getstructoffset())->DoCancel();
06611 G__setnull(result7);
06612 return(1 || funcname || hash || result7 || libp) ;
06613 }
06614
06615 static int G__G__GeomBuilder_260_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06616 {
06617 ((TGeoCombiTransEditor*) G__getstructoffset())->DoUndo();
06618 G__setnull(result7);
06619 return(1 || funcname || hash || result7 || libp) ;
06620 }
06621
06622 static int G__G__GeomBuilder_260_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06623 {
06624 G__letint(result7, 85, (long) TGeoCombiTransEditor::Class());
06625 return(1 || funcname || hash || result7 || libp) ;
06626 }
06627
06628 static int G__G__GeomBuilder_260_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06629 {
06630 G__letint(result7, 67, (long) TGeoCombiTransEditor::Class_Name());
06631 return(1 || funcname || hash || result7 || libp) ;
06632 }
06633
06634 static int G__G__GeomBuilder_260_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06635 {
06636 G__letint(result7, 115, (long) TGeoCombiTransEditor::Class_Version());
06637 return(1 || funcname || hash || result7 || libp) ;
06638 }
06639
06640 static int G__G__GeomBuilder_260_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06641 {
06642 TGeoCombiTransEditor::Dictionary();
06643 G__setnull(result7);
06644 return(1 || funcname || hash || result7 || libp) ;
06645 }
06646
06647 static int G__G__GeomBuilder_260_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06648 {
06649 ((TGeoCombiTransEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06650 G__setnull(result7);
06651 return(1 || funcname || hash || result7 || libp) ;
06652 }
06653
06654 static int G__G__GeomBuilder_260_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06655 {
06656 G__letint(result7, 67, (long) TGeoCombiTransEditor::DeclFileName());
06657 return(1 || funcname || hash || result7 || libp) ;
06658 }
06659
06660 static int G__G__GeomBuilder_260_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06661 {
06662 G__letint(result7, 105, (long) TGeoCombiTransEditor::ImplFileLine());
06663 return(1 || funcname || hash || result7 || libp) ;
06664 }
06665
06666 static int G__G__GeomBuilder_260_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06667 {
06668 G__letint(result7, 67, (long) TGeoCombiTransEditor::ImplFileName());
06669 return(1 || funcname || hash || result7 || libp) ;
06670 }
06671
06672 static int G__G__GeomBuilder_260_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06673 {
06674 G__letint(result7, 105, (long) TGeoCombiTransEditor::DeclFileLine());
06675 return(1 || funcname || hash || result7 || libp) ;
06676 }
06677
06678
06679 typedef TGeoCombiTransEditor G__TTGeoCombiTransEditor;
06680 static int G__G__GeomBuilder_260_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06681 {
06682 char* gvp = (char*) G__getgvp();
06683 long soff = G__getstructoffset();
06684 int n = G__getaryconstruct();
06685
06686
06687
06688
06689
06690 if (!soff) {
06691 return(1);
06692 }
06693 if (n) {
06694 if (gvp == (char*)G__PVOID) {
06695 delete[] (TGeoCombiTransEditor*) soff;
06696 } else {
06697 G__setgvp((long) G__PVOID);
06698 for (int i = n - 1; i >= 0; --i) {
06699 ((TGeoCombiTransEditor*) (soff+(sizeof(TGeoCombiTransEditor)*i)))->~G__TTGeoCombiTransEditor();
06700 }
06701 G__setgvp((long)gvp);
06702 }
06703 } else {
06704 if (gvp == (char*)G__PVOID) {
06705 delete (TGeoCombiTransEditor*) soff;
06706 } else {
06707 G__setgvp((long) G__PVOID);
06708 ((TGeoCombiTransEditor*) (soff))->~G__TTGeoCombiTransEditor();
06709 G__setgvp((long)gvp);
06710 }
06711 }
06712 G__setnull(result7);
06713 return(1 || funcname || hash || result7 || libp) ;
06714 }
06715
06716
06717
06718 static int G__G__GeomBuilder_261_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06719 {
06720 TGeoManagerEditor* p = NULL;
06721 char* gvp = (char*) G__getgvp();
06722 switch (libp->paran) {
06723 case 5:
06724
06725 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06726 p = new TGeoManagerEditor(
06727 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06728 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06729 , (Pixel_t) G__int(libp->para[4]));
06730 } else {
06731 p = new((void*) gvp) TGeoManagerEditor(
06732 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06733 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06734 , (Pixel_t) G__int(libp->para[4]));
06735 }
06736 break;
06737 case 4:
06738
06739 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06740 p = new TGeoManagerEditor(
06741 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06742 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06743 } else {
06744 p = new((void*) gvp) TGeoManagerEditor(
06745 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06746 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06747 }
06748 break;
06749 case 3:
06750
06751 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06752 p = new TGeoManagerEditor(
06753 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06754 , (Int_t) G__int(libp->para[2]));
06755 } else {
06756 p = new((void*) gvp) TGeoManagerEditor(
06757 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06758 , (Int_t) G__int(libp->para[2]));
06759 }
06760 break;
06761 case 2:
06762
06763 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06764 p = new TGeoManagerEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06765 } else {
06766 p = new((void*) gvp) TGeoManagerEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06767 }
06768 break;
06769 case 1:
06770
06771 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06772 p = new TGeoManagerEditor((TGWindow*) G__int(libp->para[0]));
06773 } else {
06774 p = new((void*) gvp) TGeoManagerEditor((TGWindow*) G__int(libp->para[0]));
06775 }
06776 break;
06777 case 0:
06778 int n = G__getaryconstruct();
06779 if (n) {
06780 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06781 p = new TGeoManagerEditor[n];
06782 } else {
06783 p = new((void*) gvp) TGeoManagerEditor[n];
06784 }
06785 } else {
06786 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06787 p = new TGeoManagerEditor;
06788 } else {
06789 p = new((void*) gvp) TGeoManagerEditor;
06790 }
06791 }
06792 break;
06793 }
06794 result7->obj.i = (long) p;
06795 result7->ref = (long) p;
06796 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor));
06797 return(1 || funcname || hash || result7 || libp) ;
06798 }
06799
06800 static int G__G__GeomBuilder_261_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06801 {
06802 TGeoManagerEditor::LoadLib();
06803 G__setnull(result7);
06804 return(1 || funcname || hash || result7 || libp) ;
06805 }
06806
06807 static int G__G__GeomBuilder_261_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06808 {
06809 ((TGeoManagerEditor*) G__getstructoffset())->SelectedSlot((TVirtualPad*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
06810 , (Int_t) G__int(libp->para[2]));
06811 G__setnull(result7);
06812 return(1 || funcname || hash || result7 || libp) ;
06813 }
06814
06815 static int G__G__GeomBuilder_261_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06816 {
06817 ((TGeoManagerEditor*) G__getstructoffset())->ConnectSelected((TCanvas*) G__int(libp->para[0]));
06818 G__setnull(result7);
06819 return(1 || funcname || hash || result7 || libp) ;
06820 }
06821
06822 static int G__G__GeomBuilder_261_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06823 {
06824 ((TGeoManagerEditor*) G__getstructoffset())->DisconnectSelected();
06825 G__setnull(result7);
06826 return(1 || funcname || hash || result7 || libp) ;
06827 }
06828
06829 static int G__G__GeomBuilder_261_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06830 {
06831 ((TGeoManagerEditor*) G__getstructoffset())->DoName();
06832 G__setnull(result7);
06833 return(1 || funcname || hash || result7 || libp) ;
06834 }
06835
06836 static int G__G__GeomBuilder_261_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06837 {
06838 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateBox();
06839 G__setnull(result7);
06840 return(1 || funcname || hash || result7 || libp) ;
06841 }
06842
06843 static int G__G__GeomBuilder_261_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06844 {
06845 ((TGeoManagerEditor*) G__getstructoffset())->DoCreatePara();
06846 G__setnull(result7);
06847 return(1 || funcname || hash || result7 || libp) ;
06848 }
06849
06850 static int G__G__GeomBuilder_261_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06851 {
06852 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateTrd1();
06853 G__setnull(result7);
06854 return(1 || funcname || hash || result7 || libp) ;
06855 }
06856
06857 static int G__G__GeomBuilder_261_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06858 {
06859 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateTrd2();
06860 G__setnull(result7);
06861 return(1 || funcname || hash || result7 || libp) ;
06862 }
06863
06864 static int G__G__GeomBuilder_261_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06865 {
06866 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateTrap();
06867 G__setnull(result7);
06868 return(1 || funcname || hash || result7 || libp) ;
06869 }
06870
06871 static int G__G__GeomBuilder_261_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06872 {
06873 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateGtra();
06874 G__setnull(result7);
06875 return(1 || funcname || hash || result7 || libp) ;
06876 }
06877
06878 static int G__G__GeomBuilder_261_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06879 {
06880 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateXtru();
06881 G__setnull(result7);
06882 return(1 || funcname || hash || result7 || libp) ;
06883 }
06884
06885 static int G__G__GeomBuilder_261_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06886 {
06887 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateArb8();
06888 G__setnull(result7);
06889 return(1 || funcname || hash || result7 || libp) ;
06890 }
06891
06892 static int G__G__GeomBuilder_261_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06893 {
06894 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateTube();
06895 G__setnull(result7);
06896 return(1 || funcname || hash || result7 || libp) ;
06897 }
06898
06899 static int G__G__GeomBuilder_261_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06900 {
06901 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateTubs();
06902 G__setnull(result7);
06903 return(1 || funcname || hash || result7 || libp) ;
06904 }
06905
06906 static int G__G__GeomBuilder_261_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06907 {
06908 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateCone();
06909 G__setnull(result7);
06910 return(1 || funcname || hash || result7 || libp) ;
06911 }
06912
06913 static int G__G__GeomBuilder_261_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06914 {
06915 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateCons();
06916 G__setnull(result7);
06917 return(1 || funcname || hash || result7 || libp) ;
06918 }
06919
06920 static int G__G__GeomBuilder_261_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06921 {
06922 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateSphe();
06923 G__setnull(result7);
06924 return(1 || funcname || hash || result7 || libp) ;
06925 }
06926
06927 static int G__G__GeomBuilder_261_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06928 {
06929 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateCtub();
06930 G__setnull(result7);
06931 return(1 || funcname || hash || result7 || libp) ;
06932 }
06933
06934 static int G__G__GeomBuilder_261_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06935 {
06936 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateEltu();
06937 G__setnull(result7);
06938 return(1 || funcname || hash || result7 || libp) ;
06939 }
06940
06941 static int G__G__GeomBuilder_261_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06942 {
06943 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateTorus();
06944 G__setnull(result7);
06945 return(1 || funcname || hash || result7 || libp) ;
06946 }
06947
06948 static int G__G__GeomBuilder_261_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06949 {
06950 ((TGeoManagerEditor*) G__getstructoffset())->DoCreatePcon();
06951 G__setnull(result7);
06952 return(1 || funcname || hash || result7 || libp) ;
06953 }
06954
06955 static int G__G__GeomBuilder_261_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06956 {
06957 ((TGeoManagerEditor*) G__getstructoffset())->DoCreatePgon();
06958 G__setnull(result7);
06959 return(1 || funcname || hash || result7 || libp) ;
06960 }
06961
06962 static int G__G__GeomBuilder_261_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06963 {
06964 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateHype();
06965 G__setnull(result7);
06966 return(1 || funcname || hash || result7 || libp) ;
06967 }
06968
06969 static int G__G__GeomBuilder_261_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06970 {
06971 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateParab();
06972 G__setnull(result7);
06973 return(1 || funcname || hash || result7 || libp) ;
06974 }
06975
06976 static int G__G__GeomBuilder_261_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06977 {
06978 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateComposite();
06979 G__setnull(result7);
06980 return(1 || funcname || hash || result7 || libp) ;
06981 }
06982
06983 static int G__G__GeomBuilder_261_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06984 {
06985 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateMaterial();
06986 G__setnull(result7);
06987 return(1 || funcname || hash || result7 || libp) ;
06988 }
06989
06990 static int G__G__GeomBuilder_261_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06991 {
06992 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateMixture();
06993 G__setnull(result7);
06994 return(1 || funcname || hash || result7 || libp) ;
06995 }
06996
06997 static int G__G__GeomBuilder_261_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06998 {
06999 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateMedium();
07000 G__setnull(result7);
07001 return(1 || funcname || hash || result7 || libp) ;
07002 }
07003
07004 static int G__G__GeomBuilder_261_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07005 {
07006 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateTranslation();
07007 G__setnull(result7);
07008 return(1 || funcname || hash || result7 || libp) ;
07009 }
07010
07011 static int G__G__GeomBuilder_261_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07012 {
07013 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateRotation();
07014 G__setnull(result7);
07015 return(1 || funcname || hash || result7 || libp) ;
07016 }
07017
07018 static int G__G__GeomBuilder_261_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07019 {
07020 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateCombi();
07021 G__setnull(result7);
07022 return(1 || funcname || hash || result7 || libp) ;
07023 }
07024
07025 static int G__G__GeomBuilder_261_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07026 {
07027 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateVolume();
07028 G__setnull(result7);
07029 return(1 || funcname || hash || result7 || libp) ;
07030 }
07031
07032 static int G__G__GeomBuilder_261_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07033 {
07034 ((TGeoManagerEditor*) G__getstructoffset())->DoCreateAssembly();
07035 G__setnull(result7);
07036 return(1 || funcname || hash || result7 || libp) ;
07037 }
07038
07039 static int G__G__GeomBuilder_261_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07040 {
07041 ((TGeoManagerEditor*) G__getstructoffset())->DoEditShape();
07042 G__setnull(result7);
07043 return(1 || funcname || hash || result7 || libp) ;
07044 }
07045
07046 static int G__G__GeomBuilder_261_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07047 {
07048 ((TGeoManagerEditor*) G__getstructoffset())->DoEditVolume();
07049 G__setnull(result7);
07050 return(1 || funcname || hash || result7 || libp) ;
07051 }
07052
07053 static int G__G__GeomBuilder_261_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07054 {
07055 ((TGeoManagerEditor*) G__getstructoffset())->DoEditMedium();
07056 G__setnull(result7);
07057 return(1 || funcname || hash || result7 || libp) ;
07058 }
07059
07060 static int G__G__GeomBuilder_261_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07061 {
07062 ((TGeoManagerEditor*) G__getstructoffset())->DoEditMaterial();
07063 G__setnull(result7);
07064 return(1 || funcname || hash || result7 || libp) ;
07065 }
07066
07067 static int G__G__GeomBuilder_261_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07068 {
07069 ((TGeoManagerEditor*) G__getstructoffset())->DoEditMatrix();
07070 G__setnull(result7);
07071 return(1 || funcname || hash || result7 || libp) ;
07072 }
07073
07074 static int G__G__GeomBuilder_261_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07075 {
07076 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectShape();
07077 G__setnull(result7);
07078 return(1 || funcname || hash || result7 || libp) ;
07079 }
07080
07081 static int G__G__GeomBuilder_261_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07082 {
07083 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectShape2();
07084 G__setnull(result7);
07085 return(1 || funcname || hash || result7 || libp) ;
07086 }
07087
07088 static int G__G__GeomBuilder_261_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07089 {
07090 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectVolume();
07091 G__setnull(result7);
07092 return(1 || funcname || hash || result7 || libp) ;
07093 }
07094
07095 static int G__G__GeomBuilder_261_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07096 {
07097 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectMatrix();
07098 G__setnull(result7);
07099 return(1 || funcname || hash || result7 || libp) ;
07100 }
07101
07102 static int G__G__GeomBuilder_261_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07103 {
07104 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectMaterial();
07105 G__setnull(result7);
07106 return(1 || funcname || hash || result7 || libp) ;
07107 }
07108
07109 static int G__G__GeomBuilder_261_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07110 {
07111 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectMaterial2();
07112 G__setnull(result7);
07113 return(1 || funcname || hash || result7 || libp) ;
07114 }
07115
07116 static int G__G__GeomBuilder_261_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07117 {
07118 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectMedium();
07119 G__setnull(result7);
07120 return(1 || funcname || hash || result7 || libp) ;
07121 }
07122
07123 static int G__G__GeomBuilder_261_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07124 {
07125 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectMedium2();
07126 G__setnull(result7);
07127 return(1 || funcname || hash || result7 || libp) ;
07128 }
07129
07130 static int G__G__GeomBuilder_261_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07131 {
07132 ((TGeoManagerEditor*) G__getstructoffset())->DoSetTopVolume();
07133 G__setnull(result7);
07134 return(1 || funcname || hash || result7 || libp) ;
07135 }
07136
07137 static int G__G__GeomBuilder_261_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07138 {
07139 ((TGeoManagerEditor*) G__getstructoffset())->DoSelectTopVolume();
07140 G__setnull(result7);
07141 return(1 || funcname || hash || result7 || libp) ;
07142 }
07143
07144 static int G__G__GeomBuilder_261_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07145 {
07146 ((TGeoManagerEditor*) G__getstructoffset())->DoExportGeometry();
07147 G__setnull(result7);
07148 return(1 || funcname || hash || result7 || libp) ;
07149 }
07150
07151 static int G__G__GeomBuilder_261_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07152 {
07153 ((TGeoManagerEditor*) G__getstructoffset())->DoCloseGeometry();
07154 G__setnull(result7);
07155 return(1 || funcname || hash || result7 || libp) ;
07156 }
07157
07158 static int G__G__GeomBuilder_261_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07159 {
07160 G__letint(result7, 85, (long) TGeoManagerEditor::Class());
07161 return(1 || funcname || hash || result7 || libp) ;
07162 }
07163
07164 static int G__G__GeomBuilder_261_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07165 {
07166 G__letint(result7, 67, (long) TGeoManagerEditor::Class_Name());
07167 return(1 || funcname || hash || result7 || libp) ;
07168 }
07169
07170 static int G__G__GeomBuilder_261_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07171 {
07172 G__letint(result7, 115, (long) TGeoManagerEditor::Class_Version());
07173 return(1 || funcname || hash || result7 || libp) ;
07174 }
07175
07176 static int G__G__GeomBuilder_261_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07177 {
07178 TGeoManagerEditor::Dictionary();
07179 G__setnull(result7);
07180 return(1 || funcname || hash || result7 || libp) ;
07181 }
07182
07183 static int G__G__GeomBuilder_261_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07184 {
07185 ((TGeoManagerEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07186 G__setnull(result7);
07187 return(1 || funcname || hash || result7 || libp) ;
07188 }
07189
07190 static int G__G__GeomBuilder_261_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07191 {
07192 G__letint(result7, 67, (long) TGeoManagerEditor::DeclFileName());
07193 return(1 || funcname || hash || result7 || libp) ;
07194 }
07195
07196 static int G__G__GeomBuilder_261_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07197 {
07198 G__letint(result7, 105, (long) TGeoManagerEditor::ImplFileLine());
07199 return(1 || funcname || hash || result7 || libp) ;
07200 }
07201
07202 static int G__G__GeomBuilder_261_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07203 {
07204 G__letint(result7, 67, (long) TGeoManagerEditor::ImplFileName());
07205 return(1 || funcname || hash || result7 || libp) ;
07206 }
07207
07208 static int G__G__GeomBuilder_261_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07209 {
07210 G__letint(result7, 105, (long) TGeoManagerEditor::DeclFileLine());
07211 return(1 || funcname || hash || result7 || libp) ;
07212 }
07213
07214
07215 typedef TGeoManagerEditor G__TTGeoManagerEditor;
07216 static int G__G__GeomBuilder_261_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07217 {
07218 char* gvp = (char*) G__getgvp();
07219 long soff = G__getstructoffset();
07220 int n = G__getaryconstruct();
07221
07222
07223
07224
07225
07226 if (!soff) {
07227 return(1);
07228 }
07229 if (n) {
07230 if (gvp == (char*)G__PVOID) {
07231 delete[] (TGeoManagerEditor*) soff;
07232 } else {
07233 G__setgvp((long) G__PVOID);
07234 for (int i = n - 1; i >= 0; --i) {
07235 ((TGeoManagerEditor*) (soff+(sizeof(TGeoManagerEditor)*i)))->~G__TTGeoManagerEditor();
07236 }
07237 G__setgvp((long)gvp);
07238 }
07239 } else {
07240 if (gvp == (char*)G__PVOID) {
07241 delete (TGeoManagerEditor*) soff;
07242 } else {
07243 G__setgvp((long) G__PVOID);
07244 ((TGeoManagerEditor*) (soff))->~G__TTGeoManagerEditor();
07245 G__setgvp((long)gvp);
07246 }
07247 }
07248 G__setnull(result7);
07249 return(1 || funcname || hash || result7 || libp) ;
07250 }
07251
07252
07253
07254 static int G__G__GeomBuilder_263_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07255 {
07256 TGeoTubeEditor* p = NULL;
07257 char* gvp = (char*) G__getgvp();
07258 switch (libp->paran) {
07259 case 5:
07260
07261 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07262 p = new TGeoTubeEditor(
07263 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07264 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07265 , (Pixel_t) G__int(libp->para[4]));
07266 } else {
07267 p = new((void*) gvp) TGeoTubeEditor(
07268 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07269 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07270 , (Pixel_t) G__int(libp->para[4]));
07271 }
07272 break;
07273 case 4:
07274
07275 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07276 p = new TGeoTubeEditor(
07277 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07278 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07279 } else {
07280 p = new((void*) gvp) TGeoTubeEditor(
07281 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07282 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07283 }
07284 break;
07285 case 3:
07286
07287 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07288 p = new TGeoTubeEditor(
07289 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07290 , (Int_t) G__int(libp->para[2]));
07291 } else {
07292 p = new((void*) gvp) TGeoTubeEditor(
07293 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07294 , (Int_t) G__int(libp->para[2]));
07295 }
07296 break;
07297 case 2:
07298
07299 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07300 p = new TGeoTubeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07301 } else {
07302 p = new((void*) gvp) TGeoTubeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07303 }
07304 break;
07305 case 1:
07306
07307 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07308 p = new TGeoTubeEditor((TGWindow*) G__int(libp->para[0]));
07309 } else {
07310 p = new((void*) gvp) TGeoTubeEditor((TGWindow*) G__int(libp->para[0]));
07311 }
07312 break;
07313 case 0:
07314 int n = G__getaryconstruct();
07315 if (n) {
07316 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07317 p = new TGeoTubeEditor[n];
07318 } else {
07319 p = new((void*) gvp) TGeoTubeEditor[n];
07320 }
07321 } else {
07322 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07323 p = new TGeoTubeEditor;
07324 } else {
07325 p = new((void*) gvp) TGeoTubeEditor;
07326 }
07327 }
07328 break;
07329 }
07330 result7->obj.i = (long) p;
07331 result7->ref = (long) p;
07332 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor));
07333 return(1 || funcname || hash || result7 || libp) ;
07334 }
07335
07336 static int G__G__GeomBuilder_263_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07337 {
07338 ((TGeoTubeEditor*) G__getstructoffset())->DoRmin();
07339 G__setnull(result7);
07340 return(1 || funcname || hash || result7 || libp) ;
07341 }
07342
07343 static int G__G__GeomBuilder_263_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07344 {
07345 ((TGeoTubeEditor*) G__getstructoffset())->DoRmax();
07346 G__setnull(result7);
07347 return(1 || funcname || hash || result7 || libp) ;
07348 }
07349
07350 static int G__G__GeomBuilder_263_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07351 {
07352 ((TGeoTubeEditor*) G__getstructoffset())->DoDz();
07353 G__setnull(result7);
07354 return(1 || funcname || hash || result7 || libp) ;
07355 }
07356
07357 static int G__G__GeomBuilder_263_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07358 {
07359 ((TGeoTubeEditor*) G__getstructoffset())->DoModified();
07360 G__setnull(result7);
07361 return(1 || funcname || hash || result7 || libp) ;
07362 }
07363
07364 static int G__G__GeomBuilder_263_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07365 {
07366 ((TGeoTubeEditor*) G__getstructoffset())->DoName();
07367 G__setnull(result7);
07368 return(1 || funcname || hash || result7 || libp) ;
07369 }
07370
07371 static int G__G__GeomBuilder_263_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07372 {
07373 ((TGeoTubeEditor*) G__getstructoffset())->DoApply();
07374 G__setnull(result7);
07375 return(1 || funcname || hash || result7 || libp) ;
07376 }
07377
07378 static int G__G__GeomBuilder_263_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07379 {
07380 ((TGeoTubeEditor*) G__getstructoffset())->DoUndo();
07381 G__setnull(result7);
07382 return(1 || funcname || hash || result7 || libp) ;
07383 }
07384
07385 static int G__G__GeomBuilder_263_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07386 {
07387 G__letint(result7, 85, (long) TGeoTubeEditor::Class());
07388 return(1 || funcname || hash || result7 || libp) ;
07389 }
07390
07391 static int G__G__GeomBuilder_263_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07392 {
07393 G__letint(result7, 67, (long) TGeoTubeEditor::Class_Name());
07394 return(1 || funcname || hash || result7 || libp) ;
07395 }
07396
07397 static int G__G__GeomBuilder_263_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07398 {
07399 G__letint(result7, 115, (long) TGeoTubeEditor::Class_Version());
07400 return(1 || funcname || hash || result7 || libp) ;
07401 }
07402
07403 static int G__G__GeomBuilder_263_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07404 {
07405 TGeoTubeEditor::Dictionary();
07406 G__setnull(result7);
07407 return(1 || funcname || hash || result7 || libp) ;
07408 }
07409
07410 static int G__G__GeomBuilder_263_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07411 {
07412 ((TGeoTubeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07413 G__setnull(result7);
07414 return(1 || funcname || hash || result7 || libp) ;
07415 }
07416
07417 static int G__G__GeomBuilder_263_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07418 {
07419 G__letint(result7, 67, (long) TGeoTubeEditor::DeclFileName());
07420 return(1 || funcname || hash || result7 || libp) ;
07421 }
07422
07423 static int G__G__GeomBuilder_263_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07424 {
07425 G__letint(result7, 105, (long) TGeoTubeEditor::ImplFileLine());
07426 return(1 || funcname || hash || result7 || libp) ;
07427 }
07428
07429 static int G__G__GeomBuilder_263_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07430 {
07431 G__letint(result7, 67, (long) TGeoTubeEditor::ImplFileName());
07432 return(1 || funcname || hash || result7 || libp) ;
07433 }
07434
07435 static int G__G__GeomBuilder_263_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07436 {
07437 G__letint(result7, 105, (long) TGeoTubeEditor::DeclFileLine());
07438 return(1 || funcname || hash || result7 || libp) ;
07439 }
07440
07441
07442 typedef TGeoTubeEditor G__TTGeoTubeEditor;
07443 static int G__G__GeomBuilder_263_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07444 {
07445 char* gvp = (char*) G__getgvp();
07446 long soff = G__getstructoffset();
07447 int n = G__getaryconstruct();
07448
07449
07450
07451
07452
07453 if (!soff) {
07454 return(1);
07455 }
07456 if (n) {
07457 if (gvp == (char*)G__PVOID) {
07458 delete[] (TGeoTubeEditor*) soff;
07459 } else {
07460 G__setgvp((long) G__PVOID);
07461 for (int i = n - 1; i >= 0; --i) {
07462 ((TGeoTubeEditor*) (soff+(sizeof(TGeoTubeEditor)*i)))->~G__TTGeoTubeEditor();
07463 }
07464 G__setgvp((long)gvp);
07465 }
07466 } else {
07467 if (gvp == (char*)G__PVOID) {
07468 delete (TGeoTubeEditor*) soff;
07469 } else {
07470 G__setgvp((long) G__PVOID);
07471 ((TGeoTubeEditor*) (soff))->~G__TTGeoTubeEditor();
07472 G__setgvp((long)gvp);
07473 }
07474 }
07475 G__setnull(result7);
07476 return(1 || funcname || hash || result7 || libp) ;
07477 }
07478
07479
07480
07481 static int G__G__GeomBuilder_265_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07482 {
07483 TGeoTubeSegEditor* p = NULL;
07484 char* gvp = (char*) G__getgvp();
07485 switch (libp->paran) {
07486 case 5:
07487
07488 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07489 p = new TGeoTubeSegEditor(
07490 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07491 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07492 , (Pixel_t) G__int(libp->para[4]));
07493 } else {
07494 p = new((void*) gvp) TGeoTubeSegEditor(
07495 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07496 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07497 , (Pixel_t) G__int(libp->para[4]));
07498 }
07499 break;
07500 case 4:
07501
07502 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07503 p = new TGeoTubeSegEditor(
07504 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07505 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07506 } else {
07507 p = new((void*) gvp) TGeoTubeSegEditor(
07508 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07509 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07510 }
07511 break;
07512 case 3:
07513
07514 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07515 p = new TGeoTubeSegEditor(
07516 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07517 , (Int_t) G__int(libp->para[2]));
07518 } else {
07519 p = new((void*) gvp) TGeoTubeSegEditor(
07520 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07521 , (Int_t) G__int(libp->para[2]));
07522 }
07523 break;
07524 case 2:
07525
07526 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07527 p = new TGeoTubeSegEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07528 } else {
07529 p = new((void*) gvp) TGeoTubeSegEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07530 }
07531 break;
07532 case 1:
07533
07534 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07535 p = new TGeoTubeSegEditor((TGWindow*) G__int(libp->para[0]));
07536 } else {
07537 p = new((void*) gvp) TGeoTubeSegEditor((TGWindow*) G__int(libp->para[0]));
07538 }
07539 break;
07540 case 0:
07541 int n = G__getaryconstruct();
07542 if (n) {
07543 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07544 p = new TGeoTubeSegEditor[n];
07545 } else {
07546 p = new((void*) gvp) TGeoTubeSegEditor[n];
07547 }
07548 } else {
07549 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07550 p = new TGeoTubeSegEditor;
07551 } else {
07552 p = new((void*) gvp) TGeoTubeSegEditor;
07553 }
07554 }
07555 break;
07556 }
07557 result7->obj.i = (long) p;
07558 result7->ref = (long) p;
07559 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor));
07560 return(1 || funcname || hash || result7 || libp) ;
07561 }
07562
07563 static int G__G__GeomBuilder_265_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07564 {
07565 ((TGeoTubeSegEditor*) G__getstructoffset())->DoPhi();
07566 G__setnull(result7);
07567 return(1 || funcname || hash || result7 || libp) ;
07568 }
07569
07570 static int G__G__GeomBuilder_265_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07571 {
07572 ((TGeoTubeSegEditor*) G__getstructoffset())->DoPhi1();
07573 G__setnull(result7);
07574 return(1 || funcname || hash || result7 || libp) ;
07575 }
07576
07577 static int G__G__GeomBuilder_265_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07578 {
07579 ((TGeoTubeSegEditor*) G__getstructoffset())->DoPhi2();
07580 G__setnull(result7);
07581 return(1 || funcname || hash || result7 || libp) ;
07582 }
07583
07584 static int G__G__GeomBuilder_265_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07585 {
07586 G__letint(result7, 85, (long) TGeoTubeSegEditor::Class());
07587 return(1 || funcname || hash || result7 || libp) ;
07588 }
07589
07590 static int G__G__GeomBuilder_265_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07591 {
07592 G__letint(result7, 67, (long) TGeoTubeSegEditor::Class_Name());
07593 return(1 || funcname || hash || result7 || libp) ;
07594 }
07595
07596 static int G__G__GeomBuilder_265_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07597 {
07598 G__letint(result7, 115, (long) TGeoTubeSegEditor::Class_Version());
07599 return(1 || funcname || hash || result7 || libp) ;
07600 }
07601
07602 static int G__G__GeomBuilder_265_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07603 {
07604 TGeoTubeSegEditor::Dictionary();
07605 G__setnull(result7);
07606 return(1 || funcname || hash || result7 || libp) ;
07607 }
07608
07609 static int G__G__GeomBuilder_265_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07610 {
07611 ((TGeoTubeSegEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07612 G__setnull(result7);
07613 return(1 || funcname || hash || result7 || libp) ;
07614 }
07615
07616 static int G__G__GeomBuilder_265_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07617 {
07618 G__letint(result7, 67, (long) TGeoTubeSegEditor::DeclFileName());
07619 return(1 || funcname || hash || result7 || libp) ;
07620 }
07621
07622 static int G__G__GeomBuilder_265_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07623 {
07624 G__letint(result7, 105, (long) TGeoTubeSegEditor::ImplFileLine());
07625 return(1 || funcname || hash || result7 || libp) ;
07626 }
07627
07628 static int G__G__GeomBuilder_265_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07629 {
07630 G__letint(result7, 67, (long) TGeoTubeSegEditor::ImplFileName());
07631 return(1 || funcname || hash || result7 || libp) ;
07632 }
07633
07634 static int G__G__GeomBuilder_265_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07635 {
07636 G__letint(result7, 105, (long) TGeoTubeSegEditor::DeclFileLine());
07637 return(1 || funcname || hash || result7 || libp) ;
07638 }
07639
07640
07641 typedef TGeoTubeSegEditor G__TTGeoTubeSegEditor;
07642 static int G__G__GeomBuilder_265_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07643 {
07644 char* gvp = (char*) G__getgvp();
07645 long soff = G__getstructoffset();
07646 int n = G__getaryconstruct();
07647
07648
07649
07650
07651
07652 if (!soff) {
07653 return(1);
07654 }
07655 if (n) {
07656 if (gvp == (char*)G__PVOID) {
07657 delete[] (TGeoTubeSegEditor*) soff;
07658 } else {
07659 G__setgvp((long) G__PVOID);
07660 for (int i = n - 1; i >= 0; --i) {
07661 ((TGeoTubeSegEditor*) (soff+(sizeof(TGeoTubeSegEditor)*i)))->~G__TTGeoTubeSegEditor();
07662 }
07663 G__setgvp((long)gvp);
07664 }
07665 } else {
07666 if (gvp == (char*)G__PVOID) {
07667 delete (TGeoTubeSegEditor*) soff;
07668 } else {
07669 G__setgvp((long) G__PVOID);
07670 ((TGeoTubeSegEditor*) (soff))->~G__TTGeoTubeSegEditor();
07671 G__setgvp((long)gvp);
07672 }
07673 }
07674 G__setnull(result7);
07675 return(1 || funcname || hash || result7 || libp) ;
07676 }
07677
07678
07679
07680 static int G__G__GeomBuilder_266_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07681 {
07682 TGeoCtubEditor* p = NULL;
07683 char* gvp = (char*) G__getgvp();
07684 switch (libp->paran) {
07685 case 5:
07686
07687 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07688 p = new TGeoCtubEditor(
07689 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07690 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07691 , (Pixel_t) G__int(libp->para[4]));
07692 } else {
07693 p = new((void*) gvp) TGeoCtubEditor(
07694 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07695 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07696 , (Pixel_t) G__int(libp->para[4]));
07697 }
07698 break;
07699 case 4:
07700
07701 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07702 p = new TGeoCtubEditor(
07703 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07704 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07705 } else {
07706 p = new((void*) gvp) TGeoCtubEditor(
07707 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07708 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07709 }
07710 break;
07711 case 3:
07712
07713 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07714 p = new TGeoCtubEditor(
07715 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07716 , (Int_t) G__int(libp->para[2]));
07717 } else {
07718 p = new((void*) gvp) TGeoCtubEditor(
07719 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07720 , (Int_t) G__int(libp->para[2]));
07721 }
07722 break;
07723 case 2:
07724
07725 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07726 p = new TGeoCtubEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07727 } else {
07728 p = new((void*) gvp) TGeoCtubEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07729 }
07730 break;
07731 case 1:
07732
07733 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07734 p = new TGeoCtubEditor((TGWindow*) G__int(libp->para[0]));
07735 } else {
07736 p = new((void*) gvp) TGeoCtubEditor((TGWindow*) G__int(libp->para[0]));
07737 }
07738 break;
07739 case 0:
07740 int n = G__getaryconstruct();
07741 if (n) {
07742 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07743 p = new TGeoCtubEditor[n];
07744 } else {
07745 p = new((void*) gvp) TGeoCtubEditor[n];
07746 }
07747 } else {
07748 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07749 p = new TGeoCtubEditor;
07750 } else {
07751 p = new((void*) gvp) TGeoCtubEditor;
07752 }
07753 }
07754 break;
07755 }
07756 result7->obj.i = (long) p;
07757 result7->ref = (long) p;
07758 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor));
07759 return(1 || funcname || hash || result7 || libp) ;
07760 }
07761
07762 static int G__G__GeomBuilder_266_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07763 {
07764 ((TGeoCtubEditor*) G__getstructoffset())->DoThlo();
07765 G__setnull(result7);
07766 return(1 || funcname || hash || result7 || libp) ;
07767 }
07768
07769 static int G__G__GeomBuilder_266_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07770 {
07771 ((TGeoCtubEditor*) G__getstructoffset())->DoPhlo();
07772 G__setnull(result7);
07773 return(1 || funcname || hash || result7 || libp) ;
07774 }
07775
07776 static int G__G__GeomBuilder_266_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07777 {
07778 ((TGeoCtubEditor*) G__getstructoffset())->DoThhi();
07779 G__setnull(result7);
07780 return(1 || funcname || hash || result7 || libp) ;
07781 }
07782
07783 static int G__G__GeomBuilder_266_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07784 {
07785 ((TGeoCtubEditor*) G__getstructoffset())->DoPhhi();
07786 G__setnull(result7);
07787 return(1 || funcname || hash || result7 || libp) ;
07788 }
07789
07790 static int G__G__GeomBuilder_266_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07791 {
07792 G__letint(result7, 85, (long) TGeoCtubEditor::Class());
07793 return(1 || funcname || hash || result7 || libp) ;
07794 }
07795
07796 static int G__G__GeomBuilder_266_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07797 {
07798 G__letint(result7, 67, (long) TGeoCtubEditor::Class_Name());
07799 return(1 || funcname || hash || result7 || libp) ;
07800 }
07801
07802 static int G__G__GeomBuilder_266_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07803 {
07804 G__letint(result7, 115, (long) TGeoCtubEditor::Class_Version());
07805 return(1 || funcname || hash || result7 || libp) ;
07806 }
07807
07808 static int G__G__GeomBuilder_266_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07809 {
07810 TGeoCtubEditor::Dictionary();
07811 G__setnull(result7);
07812 return(1 || funcname || hash || result7 || libp) ;
07813 }
07814
07815 static int G__G__GeomBuilder_266_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07816 {
07817 ((TGeoCtubEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07818 G__setnull(result7);
07819 return(1 || funcname || hash || result7 || libp) ;
07820 }
07821
07822 static int G__G__GeomBuilder_266_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07823 {
07824 G__letint(result7, 67, (long) TGeoCtubEditor::DeclFileName());
07825 return(1 || funcname || hash || result7 || libp) ;
07826 }
07827
07828 static int G__G__GeomBuilder_266_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07829 {
07830 G__letint(result7, 105, (long) TGeoCtubEditor::ImplFileLine());
07831 return(1 || funcname || hash || result7 || libp) ;
07832 }
07833
07834 static int G__G__GeomBuilder_266_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07835 {
07836 G__letint(result7, 67, (long) TGeoCtubEditor::ImplFileName());
07837 return(1 || funcname || hash || result7 || libp) ;
07838 }
07839
07840 static int G__G__GeomBuilder_266_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07841 {
07842 G__letint(result7, 105, (long) TGeoCtubEditor::DeclFileLine());
07843 return(1 || funcname || hash || result7 || libp) ;
07844 }
07845
07846
07847 typedef TGeoCtubEditor G__TTGeoCtubEditor;
07848 static int G__G__GeomBuilder_266_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07849 {
07850 char* gvp = (char*) G__getgvp();
07851 long soff = G__getstructoffset();
07852 int n = G__getaryconstruct();
07853
07854
07855
07856
07857
07858 if (!soff) {
07859 return(1);
07860 }
07861 if (n) {
07862 if (gvp == (char*)G__PVOID) {
07863 delete[] (TGeoCtubEditor*) soff;
07864 } else {
07865 G__setgvp((long) G__PVOID);
07866 for (int i = n - 1; i >= 0; --i) {
07867 ((TGeoCtubEditor*) (soff+(sizeof(TGeoCtubEditor)*i)))->~G__TTGeoCtubEditor();
07868 }
07869 G__setgvp((long)gvp);
07870 }
07871 } else {
07872 if (gvp == (char*)G__PVOID) {
07873 delete (TGeoCtubEditor*) soff;
07874 } else {
07875 G__setgvp((long) G__PVOID);
07876 ((TGeoCtubEditor*) (soff))->~G__TTGeoCtubEditor();
07877 G__setgvp((long)gvp);
07878 }
07879 }
07880 G__setnull(result7);
07881 return(1 || funcname || hash || result7 || libp) ;
07882 }
07883
07884
07885
07886 static int G__G__GeomBuilder_269_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07887 {
07888 TGeoConeEditor* p = NULL;
07889 char* gvp = (char*) G__getgvp();
07890 switch (libp->paran) {
07891 case 5:
07892
07893 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07894 p = new TGeoConeEditor(
07895 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07896 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07897 , (Pixel_t) G__int(libp->para[4]));
07898 } else {
07899 p = new((void*) gvp) TGeoConeEditor(
07900 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07901 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07902 , (Pixel_t) G__int(libp->para[4]));
07903 }
07904 break;
07905 case 4:
07906
07907 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07908 p = new TGeoConeEditor(
07909 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07910 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07911 } else {
07912 p = new((void*) gvp) TGeoConeEditor(
07913 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07914 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07915 }
07916 break;
07917 case 3:
07918
07919 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07920 p = new TGeoConeEditor(
07921 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07922 , (Int_t) G__int(libp->para[2]));
07923 } else {
07924 p = new((void*) gvp) TGeoConeEditor(
07925 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07926 , (Int_t) G__int(libp->para[2]));
07927 }
07928 break;
07929 case 2:
07930
07931 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07932 p = new TGeoConeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07933 } else {
07934 p = new((void*) gvp) TGeoConeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07935 }
07936 break;
07937 case 1:
07938
07939 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07940 p = new TGeoConeEditor((TGWindow*) G__int(libp->para[0]));
07941 } else {
07942 p = new((void*) gvp) TGeoConeEditor((TGWindow*) G__int(libp->para[0]));
07943 }
07944 break;
07945 case 0:
07946 int n = G__getaryconstruct();
07947 if (n) {
07948 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07949 p = new TGeoConeEditor[n];
07950 } else {
07951 p = new((void*) gvp) TGeoConeEditor[n];
07952 }
07953 } else {
07954 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07955 p = new TGeoConeEditor;
07956 } else {
07957 p = new((void*) gvp) TGeoConeEditor;
07958 }
07959 }
07960 break;
07961 }
07962 result7->obj.i = (long) p;
07963 result7->ref = (long) p;
07964 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor));
07965 return(1 || funcname || hash || result7 || libp) ;
07966 }
07967
07968 static int G__G__GeomBuilder_269_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07969 {
07970 ((TGeoConeEditor*) G__getstructoffset())->DoRmin1();
07971 G__setnull(result7);
07972 return(1 || funcname || hash || result7 || libp) ;
07973 }
07974
07975 static int G__G__GeomBuilder_269_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07976 {
07977 ((TGeoConeEditor*) G__getstructoffset())->DoRmin2();
07978 G__setnull(result7);
07979 return(1 || funcname || hash || result7 || libp) ;
07980 }
07981
07982 static int G__G__GeomBuilder_269_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07983 {
07984 ((TGeoConeEditor*) G__getstructoffset())->DoRmax1();
07985 G__setnull(result7);
07986 return(1 || funcname || hash || result7 || libp) ;
07987 }
07988
07989 static int G__G__GeomBuilder_269_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07990 {
07991 ((TGeoConeEditor*) G__getstructoffset())->DoRmax2();
07992 G__setnull(result7);
07993 return(1 || funcname || hash || result7 || libp) ;
07994 }
07995
07996 static int G__G__GeomBuilder_269_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07997 {
07998 ((TGeoConeEditor*) G__getstructoffset())->DoDz();
07999 G__setnull(result7);
08000 return(1 || funcname || hash || result7 || libp) ;
08001 }
08002
08003 static int G__G__GeomBuilder_269_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08004 {
08005 ((TGeoConeEditor*) G__getstructoffset())->DoModified();
08006 G__setnull(result7);
08007 return(1 || funcname || hash || result7 || libp) ;
08008 }
08009
08010 static int G__G__GeomBuilder_269_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08011 {
08012 ((TGeoConeEditor*) G__getstructoffset())->DoName();
08013 G__setnull(result7);
08014 return(1 || funcname || hash || result7 || libp) ;
08015 }
08016
08017 static int G__G__GeomBuilder_269_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08018 {
08019 ((TGeoConeEditor*) G__getstructoffset())->DoApply();
08020 G__setnull(result7);
08021 return(1 || funcname || hash || result7 || libp) ;
08022 }
08023
08024 static int G__G__GeomBuilder_269_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08025 {
08026 ((TGeoConeEditor*) G__getstructoffset())->DoUndo();
08027 G__setnull(result7);
08028 return(1 || funcname || hash || result7 || libp) ;
08029 }
08030
08031 static int G__G__GeomBuilder_269_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08032 {
08033 G__letint(result7, 85, (long) TGeoConeEditor::Class());
08034 return(1 || funcname || hash || result7 || libp) ;
08035 }
08036
08037 static int G__G__GeomBuilder_269_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08038 {
08039 G__letint(result7, 67, (long) TGeoConeEditor::Class_Name());
08040 return(1 || funcname || hash || result7 || libp) ;
08041 }
08042
08043 static int G__G__GeomBuilder_269_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08044 {
08045 G__letint(result7, 115, (long) TGeoConeEditor::Class_Version());
08046 return(1 || funcname || hash || result7 || libp) ;
08047 }
08048
08049 static int G__G__GeomBuilder_269_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08050 {
08051 TGeoConeEditor::Dictionary();
08052 G__setnull(result7);
08053 return(1 || funcname || hash || result7 || libp) ;
08054 }
08055
08056 static int G__G__GeomBuilder_269_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08057 {
08058 ((TGeoConeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08059 G__setnull(result7);
08060 return(1 || funcname || hash || result7 || libp) ;
08061 }
08062
08063 static int G__G__GeomBuilder_269_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08064 {
08065 G__letint(result7, 67, (long) TGeoConeEditor::DeclFileName());
08066 return(1 || funcname || hash || result7 || libp) ;
08067 }
08068
08069 static int G__G__GeomBuilder_269_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08070 {
08071 G__letint(result7, 105, (long) TGeoConeEditor::ImplFileLine());
08072 return(1 || funcname || hash || result7 || libp) ;
08073 }
08074
08075 static int G__G__GeomBuilder_269_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08076 {
08077 G__letint(result7, 67, (long) TGeoConeEditor::ImplFileName());
08078 return(1 || funcname || hash || result7 || libp) ;
08079 }
08080
08081 static int G__G__GeomBuilder_269_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08082 {
08083 G__letint(result7, 105, (long) TGeoConeEditor::DeclFileLine());
08084 return(1 || funcname || hash || result7 || libp) ;
08085 }
08086
08087
08088 typedef TGeoConeEditor G__TTGeoConeEditor;
08089 static int G__G__GeomBuilder_269_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08090 {
08091 char* gvp = (char*) G__getgvp();
08092 long soff = G__getstructoffset();
08093 int n = G__getaryconstruct();
08094
08095
08096
08097
08098
08099 if (!soff) {
08100 return(1);
08101 }
08102 if (n) {
08103 if (gvp == (char*)G__PVOID) {
08104 delete[] (TGeoConeEditor*) soff;
08105 } else {
08106 G__setgvp((long) G__PVOID);
08107 for (int i = n - 1; i >= 0; --i) {
08108 ((TGeoConeEditor*) (soff+(sizeof(TGeoConeEditor)*i)))->~G__TTGeoConeEditor();
08109 }
08110 G__setgvp((long)gvp);
08111 }
08112 } else {
08113 if (gvp == (char*)G__PVOID) {
08114 delete (TGeoConeEditor*) soff;
08115 } else {
08116 G__setgvp((long) G__PVOID);
08117 ((TGeoConeEditor*) (soff))->~G__TTGeoConeEditor();
08118 G__setgvp((long)gvp);
08119 }
08120 }
08121 G__setnull(result7);
08122 return(1 || funcname || hash || result7 || libp) ;
08123 }
08124
08125
08126
08127 static int G__G__GeomBuilder_270_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08128 {
08129 TGeoConeSegEditor* p = NULL;
08130 char* gvp = (char*) G__getgvp();
08131 switch (libp->paran) {
08132 case 5:
08133
08134 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08135 p = new TGeoConeSegEditor(
08136 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08137 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08138 , (Pixel_t) G__int(libp->para[4]));
08139 } else {
08140 p = new((void*) gvp) TGeoConeSegEditor(
08141 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08142 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08143 , (Pixel_t) G__int(libp->para[4]));
08144 }
08145 break;
08146 case 4:
08147
08148 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08149 p = new TGeoConeSegEditor(
08150 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08151 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08152 } else {
08153 p = new((void*) gvp) TGeoConeSegEditor(
08154 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08155 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08156 }
08157 break;
08158 case 3:
08159
08160 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08161 p = new TGeoConeSegEditor(
08162 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08163 , (Int_t) G__int(libp->para[2]));
08164 } else {
08165 p = new((void*) gvp) TGeoConeSegEditor(
08166 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08167 , (Int_t) G__int(libp->para[2]));
08168 }
08169 break;
08170 case 2:
08171
08172 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08173 p = new TGeoConeSegEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08174 } else {
08175 p = new((void*) gvp) TGeoConeSegEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08176 }
08177 break;
08178 case 1:
08179
08180 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08181 p = new TGeoConeSegEditor((TGWindow*) G__int(libp->para[0]));
08182 } else {
08183 p = new((void*) gvp) TGeoConeSegEditor((TGWindow*) G__int(libp->para[0]));
08184 }
08185 break;
08186 case 0:
08187 int n = G__getaryconstruct();
08188 if (n) {
08189 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08190 p = new TGeoConeSegEditor[n];
08191 } else {
08192 p = new((void*) gvp) TGeoConeSegEditor[n];
08193 }
08194 } else {
08195 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08196 p = new TGeoConeSegEditor;
08197 } else {
08198 p = new((void*) gvp) TGeoConeSegEditor;
08199 }
08200 }
08201 break;
08202 }
08203 result7->obj.i = (long) p;
08204 result7->ref = (long) p;
08205 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor));
08206 return(1 || funcname || hash || result7 || libp) ;
08207 }
08208
08209 static int G__G__GeomBuilder_270_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08210 {
08211 ((TGeoConeSegEditor*) G__getstructoffset())->DoPhi();
08212 G__setnull(result7);
08213 return(1 || funcname || hash || result7 || libp) ;
08214 }
08215
08216 static int G__G__GeomBuilder_270_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08217 {
08218 ((TGeoConeSegEditor*) G__getstructoffset())->DoPhi1();
08219 G__setnull(result7);
08220 return(1 || funcname || hash || result7 || libp) ;
08221 }
08222
08223 static int G__G__GeomBuilder_270_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08224 {
08225 ((TGeoConeSegEditor*) G__getstructoffset())->DoPhi2();
08226 G__setnull(result7);
08227 return(1 || funcname || hash || result7 || libp) ;
08228 }
08229
08230 static int G__G__GeomBuilder_270_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08231 {
08232 G__letint(result7, 85, (long) TGeoConeSegEditor::Class());
08233 return(1 || funcname || hash || result7 || libp) ;
08234 }
08235
08236 static int G__G__GeomBuilder_270_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08237 {
08238 G__letint(result7, 67, (long) TGeoConeSegEditor::Class_Name());
08239 return(1 || funcname || hash || result7 || libp) ;
08240 }
08241
08242 static int G__G__GeomBuilder_270_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08243 {
08244 G__letint(result7, 115, (long) TGeoConeSegEditor::Class_Version());
08245 return(1 || funcname || hash || result7 || libp) ;
08246 }
08247
08248 static int G__G__GeomBuilder_270_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08249 {
08250 TGeoConeSegEditor::Dictionary();
08251 G__setnull(result7);
08252 return(1 || funcname || hash || result7 || libp) ;
08253 }
08254
08255 static int G__G__GeomBuilder_270_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08256 {
08257 ((TGeoConeSegEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08258 G__setnull(result7);
08259 return(1 || funcname || hash || result7 || libp) ;
08260 }
08261
08262 static int G__G__GeomBuilder_270_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08263 {
08264 G__letint(result7, 67, (long) TGeoConeSegEditor::DeclFileName());
08265 return(1 || funcname || hash || result7 || libp) ;
08266 }
08267
08268 static int G__G__GeomBuilder_270_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08269 {
08270 G__letint(result7, 105, (long) TGeoConeSegEditor::ImplFileLine());
08271 return(1 || funcname || hash || result7 || libp) ;
08272 }
08273
08274 static int G__G__GeomBuilder_270_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08275 {
08276 G__letint(result7, 67, (long) TGeoConeSegEditor::ImplFileName());
08277 return(1 || funcname || hash || result7 || libp) ;
08278 }
08279
08280 static int G__G__GeomBuilder_270_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08281 {
08282 G__letint(result7, 105, (long) TGeoConeSegEditor::DeclFileLine());
08283 return(1 || funcname || hash || result7 || libp) ;
08284 }
08285
08286
08287 typedef TGeoConeSegEditor G__TTGeoConeSegEditor;
08288 static int G__G__GeomBuilder_270_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08289 {
08290 char* gvp = (char*) G__getgvp();
08291 long soff = G__getstructoffset();
08292 int n = G__getaryconstruct();
08293
08294
08295
08296
08297
08298 if (!soff) {
08299 return(1);
08300 }
08301 if (n) {
08302 if (gvp == (char*)G__PVOID) {
08303 delete[] (TGeoConeSegEditor*) soff;
08304 } else {
08305 G__setgvp((long) G__PVOID);
08306 for (int i = n - 1; i >= 0; --i) {
08307 ((TGeoConeSegEditor*) (soff+(sizeof(TGeoConeSegEditor)*i)))->~G__TTGeoConeSegEditor();
08308 }
08309 G__setgvp((long)gvp);
08310 }
08311 } else {
08312 if (gvp == (char*)G__PVOID) {
08313 delete (TGeoConeSegEditor*) soff;
08314 } else {
08315 G__setgvp((long) G__PVOID);
08316 ((TGeoConeSegEditor*) (soff))->~G__TTGeoConeSegEditor();
08317 G__setgvp((long)gvp);
08318 }
08319 }
08320 G__setnull(result7);
08321 return(1 || funcname || hash || result7 || libp) ;
08322 }
08323
08324
08325
08326 static int G__G__GeomBuilder_272_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08327 {
08328 TGeoTrd1Editor* p = NULL;
08329 char* gvp = (char*) G__getgvp();
08330 switch (libp->paran) {
08331 case 5:
08332
08333 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08334 p = new TGeoTrd1Editor(
08335 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08336 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08337 , (Pixel_t) G__int(libp->para[4]));
08338 } else {
08339 p = new((void*) gvp) TGeoTrd1Editor(
08340 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08341 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08342 , (Pixel_t) G__int(libp->para[4]));
08343 }
08344 break;
08345 case 4:
08346
08347 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08348 p = new TGeoTrd1Editor(
08349 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08350 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08351 } else {
08352 p = new((void*) gvp) TGeoTrd1Editor(
08353 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08354 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08355 }
08356 break;
08357 case 3:
08358
08359 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08360 p = new TGeoTrd1Editor(
08361 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08362 , (Int_t) G__int(libp->para[2]));
08363 } else {
08364 p = new((void*) gvp) TGeoTrd1Editor(
08365 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08366 , (Int_t) G__int(libp->para[2]));
08367 }
08368 break;
08369 case 2:
08370
08371 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08372 p = new TGeoTrd1Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08373 } else {
08374 p = new((void*) gvp) TGeoTrd1Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08375 }
08376 break;
08377 case 1:
08378
08379 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08380 p = new TGeoTrd1Editor((TGWindow*) G__int(libp->para[0]));
08381 } else {
08382 p = new((void*) gvp) TGeoTrd1Editor((TGWindow*) G__int(libp->para[0]));
08383 }
08384 break;
08385 case 0:
08386 int n = G__getaryconstruct();
08387 if (n) {
08388 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08389 p = new TGeoTrd1Editor[n];
08390 } else {
08391 p = new((void*) gvp) TGeoTrd1Editor[n];
08392 }
08393 } else {
08394 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08395 p = new TGeoTrd1Editor;
08396 } else {
08397 p = new((void*) gvp) TGeoTrd1Editor;
08398 }
08399 }
08400 break;
08401 }
08402 result7->obj.i = (long) p;
08403 result7->ref = (long) p;
08404 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor));
08405 return(1 || funcname || hash || result7 || libp) ;
08406 }
08407
08408 static int G__G__GeomBuilder_272_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08409 {
08410 ((TGeoTrd1Editor*) G__getstructoffset())->DoDx1();
08411 G__setnull(result7);
08412 return(1 || funcname || hash || result7 || libp) ;
08413 }
08414
08415 static int G__G__GeomBuilder_272_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08416 {
08417 ((TGeoTrd1Editor*) G__getstructoffset())->DoDx2();
08418 G__setnull(result7);
08419 return(1 || funcname || hash || result7 || libp) ;
08420 }
08421
08422 static int G__G__GeomBuilder_272_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08423 {
08424 ((TGeoTrd1Editor*) G__getstructoffset())->DoDy();
08425 G__setnull(result7);
08426 return(1 || funcname || hash || result7 || libp) ;
08427 }
08428
08429 static int G__G__GeomBuilder_272_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08430 {
08431 ((TGeoTrd1Editor*) G__getstructoffset())->DoDz();
08432 G__setnull(result7);
08433 return(1 || funcname || hash || result7 || libp) ;
08434 }
08435
08436 static int G__G__GeomBuilder_272_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08437 {
08438 ((TGeoTrd1Editor*) G__getstructoffset())->DoModified();
08439 G__setnull(result7);
08440 return(1 || funcname || hash || result7 || libp) ;
08441 }
08442
08443 static int G__G__GeomBuilder_272_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08444 {
08445 ((TGeoTrd1Editor*) G__getstructoffset())->DoName();
08446 G__setnull(result7);
08447 return(1 || funcname || hash || result7 || libp) ;
08448 }
08449
08450 static int G__G__GeomBuilder_272_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08451 {
08452 ((TGeoTrd1Editor*) G__getstructoffset())->DoApply();
08453 G__setnull(result7);
08454 return(1 || funcname || hash || result7 || libp) ;
08455 }
08456
08457 static int G__G__GeomBuilder_272_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08458 {
08459 ((TGeoTrd1Editor*) G__getstructoffset())->DoUndo();
08460 G__setnull(result7);
08461 return(1 || funcname || hash || result7 || libp) ;
08462 }
08463
08464 static int G__G__GeomBuilder_272_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08465 {
08466 G__letint(result7, 85, (long) TGeoTrd1Editor::Class());
08467 return(1 || funcname || hash || result7 || libp) ;
08468 }
08469
08470 static int G__G__GeomBuilder_272_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08471 {
08472 G__letint(result7, 67, (long) TGeoTrd1Editor::Class_Name());
08473 return(1 || funcname || hash || result7 || libp) ;
08474 }
08475
08476 static int G__G__GeomBuilder_272_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08477 {
08478 G__letint(result7, 115, (long) TGeoTrd1Editor::Class_Version());
08479 return(1 || funcname || hash || result7 || libp) ;
08480 }
08481
08482 static int G__G__GeomBuilder_272_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08483 {
08484 TGeoTrd1Editor::Dictionary();
08485 G__setnull(result7);
08486 return(1 || funcname || hash || result7 || libp) ;
08487 }
08488
08489 static int G__G__GeomBuilder_272_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08490 {
08491 ((TGeoTrd1Editor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08492 G__setnull(result7);
08493 return(1 || funcname || hash || result7 || libp) ;
08494 }
08495
08496 static int G__G__GeomBuilder_272_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08497 {
08498 G__letint(result7, 67, (long) TGeoTrd1Editor::DeclFileName());
08499 return(1 || funcname || hash || result7 || libp) ;
08500 }
08501
08502 static int G__G__GeomBuilder_272_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08503 {
08504 G__letint(result7, 105, (long) TGeoTrd1Editor::ImplFileLine());
08505 return(1 || funcname || hash || result7 || libp) ;
08506 }
08507
08508 static int G__G__GeomBuilder_272_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08509 {
08510 G__letint(result7, 67, (long) TGeoTrd1Editor::ImplFileName());
08511 return(1 || funcname || hash || result7 || libp) ;
08512 }
08513
08514 static int G__G__GeomBuilder_272_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08515 {
08516 G__letint(result7, 105, (long) TGeoTrd1Editor::DeclFileLine());
08517 return(1 || funcname || hash || result7 || libp) ;
08518 }
08519
08520
08521 typedef TGeoTrd1Editor G__TTGeoTrd1Editor;
08522 static int G__G__GeomBuilder_272_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08523 {
08524 char* gvp = (char*) G__getgvp();
08525 long soff = G__getstructoffset();
08526 int n = G__getaryconstruct();
08527
08528
08529
08530
08531
08532 if (!soff) {
08533 return(1);
08534 }
08535 if (n) {
08536 if (gvp == (char*)G__PVOID) {
08537 delete[] (TGeoTrd1Editor*) soff;
08538 } else {
08539 G__setgvp((long) G__PVOID);
08540 for (int i = n - 1; i >= 0; --i) {
08541 ((TGeoTrd1Editor*) (soff+(sizeof(TGeoTrd1Editor)*i)))->~G__TTGeoTrd1Editor();
08542 }
08543 G__setgvp((long)gvp);
08544 }
08545 } else {
08546 if (gvp == (char*)G__PVOID) {
08547 delete (TGeoTrd1Editor*) soff;
08548 } else {
08549 G__setgvp((long) G__PVOID);
08550 ((TGeoTrd1Editor*) (soff))->~G__TTGeoTrd1Editor();
08551 G__setgvp((long)gvp);
08552 }
08553 }
08554 G__setnull(result7);
08555 return(1 || funcname || hash || result7 || libp) ;
08556 }
08557
08558
08559
08560 static int G__G__GeomBuilder_274_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08561 {
08562 TGeoTrd2Editor* p = NULL;
08563 char* gvp = (char*) G__getgvp();
08564 switch (libp->paran) {
08565 case 5:
08566
08567 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08568 p = new TGeoTrd2Editor(
08569 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08570 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08571 , (Pixel_t) G__int(libp->para[4]));
08572 } else {
08573 p = new((void*) gvp) TGeoTrd2Editor(
08574 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08575 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08576 , (Pixel_t) G__int(libp->para[4]));
08577 }
08578 break;
08579 case 4:
08580
08581 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08582 p = new TGeoTrd2Editor(
08583 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08584 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08585 } else {
08586 p = new((void*) gvp) TGeoTrd2Editor(
08587 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08588 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08589 }
08590 break;
08591 case 3:
08592
08593 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08594 p = new TGeoTrd2Editor(
08595 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08596 , (Int_t) G__int(libp->para[2]));
08597 } else {
08598 p = new((void*) gvp) TGeoTrd2Editor(
08599 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08600 , (Int_t) G__int(libp->para[2]));
08601 }
08602 break;
08603 case 2:
08604
08605 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08606 p = new TGeoTrd2Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08607 } else {
08608 p = new((void*) gvp) TGeoTrd2Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08609 }
08610 break;
08611 case 1:
08612
08613 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08614 p = new TGeoTrd2Editor((TGWindow*) G__int(libp->para[0]));
08615 } else {
08616 p = new((void*) gvp) TGeoTrd2Editor((TGWindow*) G__int(libp->para[0]));
08617 }
08618 break;
08619 case 0:
08620 int n = G__getaryconstruct();
08621 if (n) {
08622 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08623 p = new TGeoTrd2Editor[n];
08624 } else {
08625 p = new((void*) gvp) TGeoTrd2Editor[n];
08626 }
08627 } else {
08628 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08629 p = new TGeoTrd2Editor;
08630 } else {
08631 p = new((void*) gvp) TGeoTrd2Editor;
08632 }
08633 }
08634 break;
08635 }
08636 result7->obj.i = (long) p;
08637 result7->ref = (long) p;
08638 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor));
08639 return(1 || funcname || hash || result7 || libp) ;
08640 }
08641
08642 static int G__G__GeomBuilder_274_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08643 {
08644 ((TGeoTrd2Editor*) G__getstructoffset())->DoDx1();
08645 G__setnull(result7);
08646 return(1 || funcname || hash || result7 || libp) ;
08647 }
08648
08649 static int G__G__GeomBuilder_274_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08650 {
08651 ((TGeoTrd2Editor*) G__getstructoffset())->DoDx2();
08652 G__setnull(result7);
08653 return(1 || funcname || hash || result7 || libp) ;
08654 }
08655
08656 static int G__G__GeomBuilder_274_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08657 {
08658 ((TGeoTrd2Editor*) G__getstructoffset())->DoDy1();
08659 G__setnull(result7);
08660 return(1 || funcname || hash || result7 || libp) ;
08661 }
08662
08663 static int G__G__GeomBuilder_274_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08664 {
08665 ((TGeoTrd2Editor*) G__getstructoffset())->DoDy2();
08666 G__setnull(result7);
08667 return(1 || funcname || hash || result7 || libp) ;
08668 }
08669
08670 static int G__G__GeomBuilder_274_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08671 {
08672 ((TGeoTrd2Editor*) G__getstructoffset())->DoDz();
08673 G__setnull(result7);
08674 return(1 || funcname || hash || result7 || libp) ;
08675 }
08676
08677 static int G__G__GeomBuilder_274_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08678 {
08679 ((TGeoTrd2Editor*) G__getstructoffset())->DoModified();
08680 G__setnull(result7);
08681 return(1 || funcname || hash || result7 || libp) ;
08682 }
08683
08684 static int G__G__GeomBuilder_274_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08685 {
08686 ((TGeoTrd2Editor*) G__getstructoffset())->DoName();
08687 G__setnull(result7);
08688 return(1 || funcname || hash || result7 || libp) ;
08689 }
08690
08691 static int G__G__GeomBuilder_274_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08692 {
08693 ((TGeoTrd2Editor*) G__getstructoffset())->DoApply();
08694 G__setnull(result7);
08695 return(1 || funcname || hash || result7 || libp) ;
08696 }
08697
08698 static int G__G__GeomBuilder_274_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08699 {
08700 ((TGeoTrd2Editor*) G__getstructoffset())->DoUndo();
08701 G__setnull(result7);
08702 return(1 || funcname || hash || result7 || libp) ;
08703 }
08704
08705 static int G__G__GeomBuilder_274_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08706 {
08707 G__letint(result7, 85, (long) TGeoTrd2Editor::Class());
08708 return(1 || funcname || hash || result7 || libp) ;
08709 }
08710
08711 static int G__G__GeomBuilder_274_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08712 {
08713 G__letint(result7, 67, (long) TGeoTrd2Editor::Class_Name());
08714 return(1 || funcname || hash || result7 || libp) ;
08715 }
08716
08717 static int G__G__GeomBuilder_274_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08718 {
08719 G__letint(result7, 115, (long) TGeoTrd2Editor::Class_Version());
08720 return(1 || funcname || hash || result7 || libp) ;
08721 }
08722
08723 static int G__G__GeomBuilder_274_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08724 {
08725 TGeoTrd2Editor::Dictionary();
08726 G__setnull(result7);
08727 return(1 || funcname || hash || result7 || libp) ;
08728 }
08729
08730 static int G__G__GeomBuilder_274_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08731 {
08732 ((TGeoTrd2Editor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08733 G__setnull(result7);
08734 return(1 || funcname || hash || result7 || libp) ;
08735 }
08736
08737 static int G__G__GeomBuilder_274_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08738 {
08739 G__letint(result7, 67, (long) TGeoTrd2Editor::DeclFileName());
08740 return(1 || funcname || hash || result7 || libp) ;
08741 }
08742
08743 static int G__G__GeomBuilder_274_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08744 {
08745 G__letint(result7, 105, (long) TGeoTrd2Editor::ImplFileLine());
08746 return(1 || funcname || hash || result7 || libp) ;
08747 }
08748
08749 static int G__G__GeomBuilder_274_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08750 {
08751 G__letint(result7, 67, (long) TGeoTrd2Editor::ImplFileName());
08752 return(1 || funcname || hash || result7 || libp) ;
08753 }
08754
08755 static int G__G__GeomBuilder_274_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08756 {
08757 G__letint(result7, 105, (long) TGeoTrd2Editor::DeclFileLine());
08758 return(1 || funcname || hash || result7 || libp) ;
08759 }
08760
08761
08762 typedef TGeoTrd2Editor G__TTGeoTrd2Editor;
08763 static int G__G__GeomBuilder_274_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08764 {
08765 char* gvp = (char*) G__getgvp();
08766 long soff = G__getstructoffset();
08767 int n = G__getaryconstruct();
08768
08769
08770
08771
08772
08773 if (!soff) {
08774 return(1);
08775 }
08776 if (n) {
08777 if (gvp == (char*)G__PVOID) {
08778 delete[] (TGeoTrd2Editor*) soff;
08779 } else {
08780 G__setgvp((long) G__PVOID);
08781 for (int i = n - 1; i >= 0; --i) {
08782 ((TGeoTrd2Editor*) (soff+(sizeof(TGeoTrd2Editor)*i)))->~G__TTGeoTrd2Editor();
08783 }
08784 G__setgvp((long)gvp);
08785 }
08786 } else {
08787 if (gvp == (char*)G__PVOID) {
08788 delete (TGeoTrd2Editor*) soff;
08789 } else {
08790 G__setgvp((long) G__PVOID);
08791 ((TGeoTrd2Editor*) (soff))->~G__TTGeoTrd2Editor();
08792 G__setgvp((long)gvp);
08793 }
08794 }
08795 G__setnull(result7);
08796 return(1 || funcname || hash || result7 || libp) ;
08797 }
08798
08799
08800
08801 static int G__G__GeomBuilder_276_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08802 {
08803 TGeoMaterialEditor* p = NULL;
08804 char* gvp = (char*) G__getgvp();
08805 switch (libp->paran) {
08806 case 5:
08807
08808 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08809 p = new TGeoMaterialEditor(
08810 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08811 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08812 , (Pixel_t) G__int(libp->para[4]));
08813 } else {
08814 p = new((void*) gvp) TGeoMaterialEditor(
08815 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08816 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08817 , (Pixel_t) G__int(libp->para[4]));
08818 }
08819 break;
08820 case 4:
08821
08822 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08823 p = new TGeoMaterialEditor(
08824 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08825 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08826 } else {
08827 p = new((void*) gvp) TGeoMaterialEditor(
08828 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08829 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08830 }
08831 break;
08832 case 3:
08833
08834 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08835 p = new TGeoMaterialEditor(
08836 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08837 , (Int_t) G__int(libp->para[2]));
08838 } else {
08839 p = new((void*) gvp) TGeoMaterialEditor(
08840 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08841 , (Int_t) G__int(libp->para[2]));
08842 }
08843 break;
08844 case 2:
08845
08846 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08847 p = new TGeoMaterialEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08848 } else {
08849 p = new((void*) gvp) TGeoMaterialEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08850 }
08851 break;
08852 case 1:
08853
08854 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08855 p = new TGeoMaterialEditor((TGWindow*) G__int(libp->para[0]));
08856 } else {
08857 p = new((void*) gvp) TGeoMaterialEditor((TGWindow*) G__int(libp->para[0]));
08858 }
08859 break;
08860 case 0:
08861 int n = G__getaryconstruct();
08862 if (n) {
08863 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08864 p = new TGeoMaterialEditor[n];
08865 } else {
08866 p = new((void*) gvp) TGeoMaterialEditor[n];
08867 }
08868 } else {
08869 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08870 p = new TGeoMaterialEditor;
08871 } else {
08872 p = new((void*) gvp) TGeoMaterialEditor;
08873 }
08874 }
08875 break;
08876 }
08877 result7->obj.i = (long) p;
08878 result7->ref = (long) p;
08879 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor));
08880 return(1 || funcname || hash || result7 || libp) ;
08881 }
08882
08883 static int G__G__GeomBuilder_276_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08884 {
08885 ((TGeoMaterialEditor*) G__getstructoffset())->DoA();
08886 G__setnull(result7);
08887 return(1 || funcname || hash || result7 || libp) ;
08888 }
08889
08890 static int G__G__GeomBuilder_276_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08891 {
08892 ((TGeoMaterialEditor*) G__getstructoffset())->DoZ();
08893 G__setnull(result7);
08894 return(1 || funcname || hash || result7 || libp) ;
08895 }
08896
08897 static int G__G__GeomBuilder_276_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08898 {
08899 ((TGeoMaterialEditor*) G__getstructoffset())->DoDensity();
08900 G__setnull(result7);
08901 return(1 || funcname || hash || result7 || libp) ;
08902 }
08903
08904 static int G__G__GeomBuilder_276_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08905 {
08906 ((TGeoMaterialEditor*) G__getstructoffset())->DoModified();
08907 G__setnull(result7);
08908 return(1 || funcname || hash || result7 || libp) ;
08909 }
08910
08911 static int G__G__GeomBuilder_276_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08912 {
08913 ((TGeoMaterialEditor*) G__getstructoffset())->DoName();
08914 G__setnull(result7);
08915 return(1 || funcname || hash || result7 || libp) ;
08916 }
08917
08918 static int G__G__GeomBuilder_276_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08919 {
08920 ((TGeoMaterialEditor*) G__getstructoffset())->DoRadAbs();
08921 G__setnull(result7);
08922 return(1 || funcname || hash || result7 || libp) ;
08923 }
08924
08925 static int G__G__GeomBuilder_276_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08926 {
08927 ((TGeoMaterialEditor*) G__getstructoffset())->DoState((Int_t) G__int(libp->para[0]));
08928 G__setnull(result7);
08929 return(1 || funcname || hash || result7 || libp) ;
08930 }
08931
08932 static int G__G__GeomBuilder_276_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08933 {
08934 ((TGeoMaterialEditor*) G__getstructoffset())->DoTemperature();
08935 G__setnull(result7);
08936 return(1 || funcname || hash || result7 || libp) ;
08937 }
08938
08939 static int G__G__GeomBuilder_276_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08940 {
08941 ((TGeoMaterialEditor*) G__getstructoffset())->DoPressure();
08942 G__setnull(result7);
08943 return(1 || funcname || hash || result7 || libp) ;
08944 }
08945
08946 static int G__G__GeomBuilder_276_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08947 {
08948 ((TGeoMaterialEditor*) G__getstructoffset())->DoApply();
08949 G__setnull(result7);
08950 return(1 || funcname || hash || result7 || libp) ;
08951 }
08952
08953 static int G__G__GeomBuilder_276_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08954 {
08955 ((TGeoMaterialEditor*) G__getstructoffset())->DoUndo();
08956 G__setnull(result7);
08957 return(1 || funcname || hash || result7 || libp) ;
08958 }
08959
08960 static int G__G__GeomBuilder_276_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08961 {
08962 G__letint(result7, 85, (long) TGeoMaterialEditor::Class());
08963 return(1 || funcname || hash || result7 || libp) ;
08964 }
08965
08966 static int G__G__GeomBuilder_276_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08967 {
08968 G__letint(result7, 67, (long) TGeoMaterialEditor::Class_Name());
08969 return(1 || funcname || hash || result7 || libp) ;
08970 }
08971
08972 static int G__G__GeomBuilder_276_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08973 {
08974 G__letint(result7, 115, (long) TGeoMaterialEditor::Class_Version());
08975 return(1 || funcname || hash || result7 || libp) ;
08976 }
08977
08978 static int G__G__GeomBuilder_276_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08979 {
08980 TGeoMaterialEditor::Dictionary();
08981 G__setnull(result7);
08982 return(1 || funcname || hash || result7 || libp) ;
08983 }
08984
08985 static int G__G__GeomBuilder_276_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08986 {
08987 ((TGeoMaterialEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08988 G__setnull(result7);
08989 return(1 || funcname || hash || result7 || libp) ;
08990 }
08991
08992 static int G__G__GeomBuilder_276_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08993 {
08994 G__letint(result7, 67, (long) TGeoMaterialEditor::DeclFileName());
08995 return(1 || funcname || hash || result7 || libp) ;
08996 }
08997
08998 static int G__G__GeomBuilder_276_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08999 {
09000 G__letint(result7, 105, (long) TGeoMaterialEditor::ImplFileLine());
09001 return(1 || funcname || hash || result7 || libp) ;
09002 }
09003
09004 static int G__G__GeomBuilder_276_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09005 {
09006 G__letint(result7, 67, (long) TGeoMaterialEditor::ImplFileName());
09007 return(1 || funcname || hash || result7 || libp) ;
09008 }
09009
09010 static int G__G__GeomBuilder_276_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09011 {
09012 G__letint(result7, 105, (long) TGeoMaterialEditor::DeclFileLine());
09013 return(1 || funcname || hash || result7 || libp) ;
09014 }
09015
09016
09017 typedef TGeoMaterialEditor G__TTGeoMaterialEditor;
09018 static int G__G__GeomBuilder_276_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09019 {
09020 char* gvp = (char*) G__getgvp();
09021 long soff = G__getstructoffset();
09022 int n = G__getaryconstruct();
09023
09024
09025
09026
09027
09028 if (!soff) {
09029 return(1);
09030 }
09031 if (n) {
09032 if (gvp == (char*)G__PVOID) {
09033 delete[] (TGeoMaterialEditor*) soff;
09034 } else {
09035 G__setgvp((long) G__PVOID);
09036 for (int i = n - 1; i >= 0; --i) {
09037 ((TGeoMaterialEditor*) (soff+(sizeof(TGeoMaterialEditor)*i)))->~G__TTGeoMaterialEditor();
09038 }
09039 G__setgvp((long)gvp);
09040 }
09041 } else {
09042 if (gvp == (char*)G__PVOID) {
09043 delete (TGeoMaterialEditor*) soff;
09044 } else {
09045 G__setgvp((long) G__PVOID);
09046 ((TGeoMaterialEditor*) (soff))->~G__TTGeoMaterialEditor();
09047 G__setgvp((long)gvp);
09048 }
09049 }
09050 G__setnull(result7);
09051 return(1 || funcname || hash || result7 || libp) ;
09052 }
09053
09054
09055
09056 static int G__G__GeomBuilder_278_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09057 {
09058 TGeoMixtureEditor* p = NULL;
09059 char* gvp = (char*) G__getgvp();
09060 switch (libp->paran) {
09061 case 5:
09062
09063 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09064 p = new TGeoMixtureEditor(
09065 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09066 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
09067 , (Pixel_t) G__int(libp->para[4]));
09068 } else {
09069 p = new((void*) gvp) TGeoMixtureEditor(
09070 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09071 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
09072 , (Pixel_t) G__int(libp->para[4]));
09073 }
09074 break;
09075 case 4:
09076
09077 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09078 p = new TGeoMixtureEditor(
09079 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09080 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09081 } else {
09082 p = new((void*) gvp) TGeoMixtureEditor(
09083 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09084 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09085 }
09086 break;
09087 case 3:
09088
09089 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09090 p = new TGeoMixtureEditor(
09091 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09092 , (Int_t) G__int(libp->para[2]));
09093 } else {
09094 p = new((void*) gvp) TGeoMixtureEditor(
09095 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09096 , (Int_t) G__int(libp->para[2]));
09097 }
09098 break;
09099 case 2:
09100
09101 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09102 p = new TGeoMixtureEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09103 } else {
09104 p = new((void*) gvp) TGeoMixtureEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09105 }
09106 break;
09107 case 1:
09108
09109 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09110 p = new TGeoMixtureEditor((TGWindow*) G__int(libp->para[0]));
09111 } else {
09112 p = new((void*) gvp) TGeoMixtureEditor((TGWindow*) G__int(libp->para[0]));
09113 }
09114 break;
09115 case 0:
09116 int n = G__getaryconstruct();
09117 if (n) {
09118 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09119 p = new TGeoMixtureEditor[n];
09120 } else {
09121 p = new((void*) gvp) TGeoMixtureEditor[n];
09122 }
09123 } else {
09124 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09125 p = new TGeoMixtureEditor;
09126 } else {
09127 p = new((void*) gvp) TGeoMixtureEditor;
09128 }
09129 }
09130 break;
09131 }
09132 result7->obj.i = (long) p;
09133 result7->ref = (long) p;
09134 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor));
09135 return(1 || funcname || hash || result7 || libp) ;
09136 }
09137
09138 static int G__G__GeomBuilder_278_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09139 {
09140 ((TGeoMixtureEditor*) G__getstructoffset())->UpdateElements();
09141 G__setnull(result7);
09142 return(1 || funcname || hash || result7 || libp) ;
09143 }
09144
09145 static int G__G__GeomBuilder_278_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09146 {
09147 ((TGeoMixtureEditor*) G__getstructoffset())->DoApply1();
09148 G__setnull(result7);
09149 return(1 || funcname || hash || result7 || libp) ;
09150 }
09151
09152 static int G__G__GeomBuilder_278_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09153 {
09154 ((TGeoMixtureEditor*) G__getstructoffset())->DoUndo1();
09155 G__setnull(result7);
09156 return(1 || funcname || hash || result7 || libp) ;
09157 }
09158
09159 static int G__G__GeomBuilder_278_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09160 {
09161 ((TGeoMixtureEditor*) G__getstructoffset())->DoChkFraction();
09162 G__setnull(result7);
09163 return(1 || funcname || hash || result7 || libp) ;
09164 }
09165
09166 static int G__G__GeomBuilder_278_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09167 {
09168 ((TGeoMixtureEditor*) G__getstructoffset())->DoChkNatoms();
09169 G__setnull(result7);
09170 return(1 || funcname || hash || result7 || libp) ;
09171 }
09172
09173 static int G__G__GeomBuilder_278_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09174 {
09175 ((TGeoMixtureEditor*) G__getstructoffset())->DoFraction();
09176 G__setnull(result7);
09177 return(1 || funcname || hash || result7 || libp) ;
09178 }
09179
09180 static int G__G__GeomBuilder_278_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09181 {
09182 ((TGeoMixtureEditor*) G__getstructoffset())->DoNatoms();
09183 G__setnull(result7);
09184 return(1 || funcname || hash || result7 || libp) ;
09185 }
09186
09187 static int G__G__GeomBuilder_278_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09188 {
09189 ((TGeoMixtureEditor*) G__getstructoffset())->DoSelectElement((Int_t) G__int(libp->para[0]));
09190 G__setnull(result7);
09191 return(1 || funcname || hash || result7 || libp) ;
09192 }
09193
09194 static int G__G__GeomBuilder_278_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09195 {
09196 ((TGeoMixtureEditor*) G__getstructoffset())->DoAddElem();
09197 G__setnull(result7);
09198 return(1 || funcname || hash || result7 || libp) ;
09199 }
09200
09201 static int G__G__GeomBuilder_278_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09202 {
09203 G__letint(result7, 85, (long) TGeoMixtureEditor::Class());
09204 return(1 || funcname || hash || result7 || libp) ;
09205 }
09206
09207 static int G__G__GeomBuilder_278_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09208 {
09209 G__letint(result7, 67, (long) TGeoMixtureEditor::Class_Name());
09210 return(1 || funcname || hash || result7 || libp) ;
09211 }
09212
09213 static int G__G__GeomBuilder_278_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09214 {
09215 G__letint(result7, 115, (long) TGeoMixtureEditor::Class_Version());
09216 return(1 || funcname || hash || result7 || libp) ;
09217 }
09218
09219 static int G__G__GeomBuilder_278_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09220 {
09221 TGeoMixtureEditor::Dictionary();
09222 G__setnull(result7);
09223 return(1 || funcname || hash || result7 || libp) ;
09224 }
09225
09226 static int G__G__GeomBuilder_278_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09227 {
09228 ((TGeoMixtureEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09229 G__setnull(result7);
09230 return(1 || funcname || hash || result7 || libp) ;
09231 }
09232
09233 static int G__G__GeomBuilder_278_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09234 {
09235 G__letint(result7, 67, (long) TGeoMixtureEditor::DeclFileName());
09236 return(1 || funcname || hash || result7 || libp) ;
09237 }
09238
09239 static int G__G__GeomBuilder_278_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09240 {
09241 G__letint(result7, 105, (long) TGeoMixtureEditor::ImplFileLine());
09242 return(1 || funcname || hash || result7 || libp) ;
09243 }
09244
09245 static int G__G__GeomBuilder_278_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09246 {
09247 G__letint(result7, 67, (long) TGeoMixtureEditor::ImplFileName());
09248 return(1 || funcname || hash || result7 || libp) ;
09249 }
09250
09251 static int G__G__GeomBuilder_278_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09252 {
09253 G__letint(result7, 105, (long) TGeoMixtureEditor::DeclFileLine());
09254 return(1 || funcname || hash || result7 || libp) ;
09255 }
09256
09257
09258 typedef TGeoMixtureEditor G__TTGeoMixtureEditor;
09259 static int G__G__GeomBuilder_278_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09260 {
09261 char* gvp = (char*) G__getgvp();
09262 long soff = G__getstructoffset();
09263 int n = G__getaryconstruct();
09264
09265
09266
09267
09268
09269 if (!soff) {
09270 return(1);
09271 }
09272 if (n) {
09273 if (gvp == (char*)G__PVOID) {
09274 delete[] (TGeoMixtureEditor*) soff;
09275 } else {
09276 G__setgvp((long) G__PVOID);
09277 for (int i = n - 1; i >= 0; --i) {
09278 ((TGeoMixtureEditor*) (soff+(sizeof(TGeoMixtureEditor)*i)))->~G__TTGeoMixtureEditor();
09279 }
09280 G__setgvp((long)gvp);
09281 }
09282 } else {
09283 if (gvp == (char*)G__PVOID) {
09284 delete (TGeoMixtureEditor*) soff;
09285 } else {
09286 G__setgvp((long) G__PVOID);
09287 ((TGeoMixtureEditor*) (soff))->~G__TTGeoMixtureEditor();
09288 G__setgvp((long)gvp);
09289 }
09290 }
09291 G__setnull(result7);
09292 return(1 || funcname || hash || result7 || libp) ;
09293 }
09294
09295
09296
09297 static int G__G__GeomBuilder_286_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09298 {
09299 G__letint(result7, 85, (long) TGeoTreeDialog::GetSelected());
09300 return(1 || funcname || hash || result7 || libp) ;
09301 }
09302
09303 static int G__G__GeomBuilder_286_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09304 {
09305 ((TGeoTreeDialog*) G__getstructoffset())->DoClose();
09306 G__setnull(result7);
09307 return(1 || funcname || hash || result7 || libp) ;
09308 }
09309
09310 static int G__G__GeomBuilder_286_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09311 {
09312 ((TGeoTreeDialog*) G__getstructoffset())->DoItemClick((TGListTreeItem*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09313 G__setnull(result7);
09314 return(1 || funcname || hash || result7 || libp) ;
09315 }
09316
09317 static int G__G__GeomBuilder_286_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09318 {
09319 ((TGeoTreeDialog*) G__getstructoffset())->DoSelect((TGListTreeItem*) G__int(libp->para[0]));
09320 G__setnull(result7);
09321 return(1 || funcname || hash || result7 || libp) ;
09322 }
09323
09324 static int G__G__GeomBuilder_286_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09325 {
09326 G__letint(result7, 85, (long) TGeoTreeDialog::Class());
09327 return(1 || funcname || hash || result7 || libp) ;
09328 }
09329
09330 static int G__G__GeomBuilder_286_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09331 {
09332 G__letint(result7, 67, (long) TGeoTreeDialog::Class_Name());
09333 return(1 || funcname || hash || result7 || libp) ;
09334 }
09335
09336 static int G__G__GeomBuilder_286_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09337 {
09338 G__letint(result7, 115, (long) TGeoTreeDialog::Class_Version());
09339 return(1 || funcname || hash || result7 || libp) ;
09340 }
09341
09342 static int G__G__GeomBuilder_286_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09343 {
09344 TGeoTreeDialog::Dictionary();
09345 G__setnull(result7);
09346 return(1 || funcname || hash || result7 || libp) ;
09347 }
09348
09349 static int G__G__GeomBuilder_286_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09350 {
09351 ((TGeoTreeDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09352 G__setnull(result7);
09353 return(1 || funcname || hash || result7 || libp) ;
09354 }
09355
09356 static int G__G__GeomBuilder_286_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09357 {
09358 G__letint(result7, 67, (long) TGeoTreeDialog::DeclFileName());
09359 return(1 || funcname || hash || result7 || libp) ;
09360 }
09361
09362 static int G__G__GeomBuilder_286_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09363 {
09364 G__letint(result7, 105, (long) TGeoTreeDialog::ImplFileLine());
09365 return(1 || funcname || hash || result7 || libp) ;
09366 }
09367
09368 static int G__G__GeomBuilder_286_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09369 {
09370 G__letint(result7, 67, (long) TGeoTreeDialog::ImplFileName());
09371 return(1 || funcname || hash || result7 || libp) ;
09372 }
09373
09374 static int G__G__GeomBuilder_286_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09375 {
09376 G__letint(result7, 105, (long) TGeoTreeDialog::DeclFileLine());
09377 return(1 || funcname || hash || result7 || libp) ;
09378 }
09379
09380
09381 typedef TGeoTreeDialog G__TTGeoTreeDialog;
09382 static int G__G__GeomBuilder_286_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09383 {
09384 char* gvp = (char*) G__getgvp();
09385 long soff = G__getstructoffset();
09386 int n = G__getaryconstruct();
09387
09388
09389
09390
09391
09392 if (!soff) {
09393 return(1);
09394 }
09395 if (n) {
09396 if (gvp == (char*)G__PVOID) {
09397 delete[] (TGeoTreeDialog*) soff;
09398 } else {
09399 G__setgvp((long) G__PVOID);
09400 for (int i = n - 1; i >= 0; --i) {
09401 ((TGeoTreeDialog*) (soff+(sizeof(TGeoTreeDialog)*i)))->~G__TTGeoTreeDialog();
09402 }
09403 G__setgvp((long)gvp);
09404 }
09405 } else {
09406 if (gvp == (char*)G__PVOID) {
09407 delete (TGeoTreeDialog*) soff;
09408 } else {
09409 G__setgvp((long) G__PVOID);
09410 ((TGeoTreeDialog*) (soff))->~G__TTGeoTreeDialog();
09411 G__setgvp((long)gvp);
09412 }
09413 }
09414 G__setnull(result7);
09415 return(1 || funcname || hash || result7 || libp) ;
09416 }
09417
09418
09419
09420 static int G__G__GeomBuilder_287_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09421 {
09422 TGeoTransientPanel* p = NULL;
09423 char* gvp = (char*) G__getgvp();
09424
09425 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09426 p = new TGeoTransientPanel(
09427 (TGedEditor*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09428 , (TObject*) G__int(libp->para[2]));
09429 } else {
09430 p = new((void*) gvp) TGeoTransientPanel(
09431 (TGedEditor*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09432 , (TObject*) G__int(libp->para[2]));
09433 }
09434 result7->obj.i = (long) p;
09435 result7->ref = (long) p;
09436 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel));
09437 return(1 || funcname || hash || result7 || libp) ;
09438 }
09439
09440 static int G__G__GeomBuilder_287_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09441 {
09442 ((TGeoTransientPanel*) G__getstructoffset())->DeleteEditors();
09443 G__setnull(result7);
09444 return(1 || funcname || hash || result7 || libp) ;
09445 }
09446
09447 static int G__G__GeomBuilder_287_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09448 {
09449 G__letint(result7, 85, (long) ((const TGeoTransientPanel*) G__getstructoffset())->GetTab());
09450 return(1 || funcname || hash || result7 || libp) ;
09451 }
09452
09453 static int G__G__GeomBuilder_287_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09454 {
09455 G__letint(result7, 85, (long) ((const TGeoTransientPanel*) G__getstructoffset())->GetStyle());
09456 return(1 || funcname || hash || result7 || libp) ;
09457 }
09458
09459 static int G__G__GeomBuilder_287_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09460 {
09461 G__letint(result7, 85, (long) ((const TGeoTransientPanel*) G__getstructoffset())->GetModel());
09462 return(1 || funcname || hash || result7 || libp) ;
09463 }
09464
09465 static int G__G__GeomBuilder_287_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09466 {
09467 ((TGeoTransientPanel*) G__getstructoffset())->GetEditors((TClass*) G__int(libp->para[0]));
09468 G__setnull(result7);
09469 return(1 || funcname || hash || result7 || libp) ;
09470 }
09471
09472 static int G__G__GeomBuilder_287_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09473 {
09474 ((TGeoTransientPanel*) G__getstructoffset())->Hide();
09475 G__setnull(result7);
09476 return(1 || funcname || hash || result7 || libp) ;
09477 }
09478
09479 static int G__G__GeomBuilder_287_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09480 {
09481 ((TGeoTransientPanel*) G__getstructoffset())->Show();
09482 G__setnull(result7);
09483 return(1 || funcname || hash || result7 || libp) ;
09484 }
09485
09486 static int G__G__GeomBuilder_287_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09487 {
09488 ((TGeoTransientPanel*) G__getstructoffset())->SetModel((TObject*) G__int(libp->para[0]));
09489 G__setnull(result7);
09490 return(1 || funcname || hash || result7 || libp) ;
09491 }
09492
09493 static int G__G__GeomBuilder_287_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09494 {
09495 G__letint(result7, 85, (long) TGeoTransientPanel::Class());
09496 return(1 || funcname || hash || result7 || libp) ;
09497 }
09498
09499 static int G__G__GeomBuilder_287_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09500 {
09501 G__letint(result7, 67, (long) TGeoTransientPanel::Class_Name());
09502 return(1 || funcname || hash || result7 || libp) ;
09503 }
09504
09505 static int G__G__GeomBuilder_287_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09506 {
09507 G__letint(result7, 115, (long) TGeoTransientPanel::Class_Version());
09508 return(1 || funcname || hash || result7 || libp) ;
09509 }
09510
09511 static int G__G__GeomBuilder_287_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09512 {
09513 TGeoTransientPanel::Dictionary();
09514 G__setnull(result7);
09515 return(1 || funcname || hash || result7 || libp) ;
09516 }
09517
09518 static int G__G__GeomBuilder_287_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09519 {
09520 ((TGeoTransientPanel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09521 G__setnull(result7);
09522 return(1 || funcname || hash || result7 || libp) ;
09523 }
09524
09525 static int G__G__GeomBuilder_287_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09526 {
09527 G__letint(result7, 67, (long) TGeoTransientPanel::DeclFileName());
09528 return(1 || funcname || hash || result7 || libp) ;
09529 }
09530
09531 static int G__G__GeomBuilder_287_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09532 {
09533 G__letint(result7, 105, (long) TGeoTransientPanel::ImplFileLine());
09534 return(1 || funcname || hash || result7 || libp) ;
09535 }
09536
09537 static int G__G__GeomBuilder_287_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09538 {
09539 G__letint(result7, 67, (long) TGeoTransientPanel::ImplFileName());
09540 return(1 || funcname || hash || result7 || libp) ;
09541 }
09542
09543 static int G__G__GeomBuilder_287_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09544 {
09545 G__letint(result7, 105, (long) TGeoTransientPanel::DeclFileLine());
09546 return(1 || funcname || hash || result7 || libp) ;
09547 }
09548
09549
09550 typedef TGeoTransientPanel G__TTGeoTransientPanel;
09551 static int G__G__GeomBuilder_287_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09552 {
09553 char* gvp = (char*) G__getgvp();
09554 long soff = G__getstructoffset();
09555 int n = G__getaryconstruct();
09556
09557
09558
09559
09560
09561 if (!soff) {
09562 return(1);
09563 }
09564 if (n) {
09565 if (gvp == (char*)G__PVOID) {
09566 delete[] (TGeoTransientPanel*) soff;
09567 } else {
09568 G__setgvp((long) G__PVOID);
09569 for (int i = n - 1; i >= 0; --i) {
09570 ((TGeoTransientPanel*) (soff+(sizeof(TGeoTransientPanel)*i)))->~G__TTGeoTransientPanel();
09571 }
09572 G__setgvp((long)gvp);
09573 }
09574 } else {
09575 if (gvp == (char*)G__PVOID) {
09576 delete (TGeoTransientPanel*) soff;
09577 } else {
09578 G__setgvp((long) G__PVOID);
09579 ((TGeoTransientPanel*) (soff))->~G__TTGeoTransientPanel();
09580 G__setgvp((long)gvp);
09581 }
09582 }
09583 G__setnull(result7);
09584 return(1 || funcname || hash || result7 || libp) ;
09585 }
09586
09587
09588
09589 static int G__G__GeomBuilder_288_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09590 {
09591 TGeoVolumeDialog* p = NULL;
09592 char* gvp = (char*) G__getgvp();
09593 switch (libp->paran) {
09594 case 4:
09595
09596 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09597 p = new TGeoVolumeDialog(
09598 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09599 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09600 } else {
09601 p = new((void*) gvp) TGeoVolumeDialog(
09602 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09603 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09604 }
09605 break;
09606 case 3:
09607
09608 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09609 p = new TGeoVolumeDialog(
09610 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09611 , (UInt_t) G__int(libp->para[2]));
09612 } else {
09613 p = new((void*) gvp) TGeoVolumeDialog(
09614 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09615 , (UInt_t) G__int(libp->para[2]));
09616 }
09617 break;
09618 case 2:
09619
09620 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09621 p = new TGeoVolumeDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
09622 } else {
09623 p = new((void*) gvp) TGeoVolumeDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
09624 }
09625 break;
09626 }
09627 result7->obj.i = (long) p;
09628 result7->ref = (long) p;
09629 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog));
09630 return(1 || funcname || hash || result7 || libp) ;
09631 }
09632
09633 static int G__G__GeomBuilder_288_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09634 {
09635 G__letint(result7, 85, (long) TGeoVolumeDialog::Class());
09636 return(1 || funcname || hash || result7 || libp) ;
09637 }
09638
09639 static int G__G__GeomBuilder_288_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09640 {
09641 G__letint(result7, 67, (long) TGeoVolumeDialog::Class_Name());
09642 return(1 || funcname || hash || result7 || libp) ;
09643 }
09644
09645 static int G__G__GeomBuilder_288_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09646 {
09647 G__letint(result7, 115, (long) TGeoVolumeDialog::Class_Version());
09648 return(1 || funcname || hash || result7 || libp) ;
09649 }
09650
09651 static int G__G__GeomBuilder_288_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09652 {
09653 TGeoVolumeDialog::Dictionary();
09654 G__setnull(result7);
09655 return(1 || funcname || hash || result7 || libp) ;
09656 }
09657
09658 static int G__G__GeomBuilder_288_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09659 {
09660 ((TGeoVolumeDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09661 G__setnull(result7);
09662 return(1 || funcname || hash || result7 || libp) ;
09663 }
09664
09665 static int G__G__GeomBuilder_288_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09666 {
09667 G__letint(result7, 67, (long) TGeoVolumeDialog::DeclFileName());
09668 return(1 || funcname || hash || result7 || libp) ;
09669 }
09670
09671 static int G__G__GeomBuilder_288_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09672 {
09673 G__letint(result7, 105, (long) TGeoVolumeDialog::ImplFileLine());
09674 return(1 || funcname || hash || result7 || libp) ;
09675 }
09676
09677 static int G__G__GeomBuilder_288_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09678 {
09679 G__letint(result7, 67, (long) TGeoVolumeDialog::ImplFileName());
09680 return(1 || funcname || hash || result7 || libp) ;
09681 }
09682
09683 static int G__G__GeomBuilder_288_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09684 {
09685 G__letint(result7, 105, (long) TGeoVolumeDialog::DeclFileLine());
09686 return(1 || funcname || hash || result7 || libp) ;
09687 }
09688
09689
09690 typedef TGeoVolumeDialog G__TTGeoVolumeDialog;
09691 static int G__G__GeomBuilder_288_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09692 {
09693 char* gvp = (char*) G__getgvp();
09694 long soff = G__getstructoffset();
09695 int n = G__getaryconstruct();
09696
09697
09698
09699
09700
09701 if (!soff) {
09702 return(1);
09703 }
09704 if (n) {
09705 if (gvp == (char*)G__PVOID) {
09706 delete[] (TGeoVolumeDialog*) soff;
09707 } else {
09708 G__setgvp((long) G__PVOID);
09709 for (int i = n - 1; i >= 0; --i) {
09710 ((TGeoVolumeDialog*) (soff+(sizeof(TGeoVolumeDialog)*i)))->~G__TTGeoVolumeDialog();
09711 }
09712 G__setgvp((long)gvp);
09713 }
09714 } else {
09715 if (gvp == (char*)G__PVOID) {
09716 delete (TGeoVolumeDialog*) soff;
09717 } else {
09718 G__setgvp((long) G__PVOID);
09719 ((TGeoVolumeDialog*) (soff))->~G__TTGeoVolumeDialog();
09720 G__setgvp((long)gvp);
09721 }
09722 }
09723 G__setnull(result7);
09724 return(1 || funcname || hash || result7 || libp) ;
09725 }
09726
09727
09728
09729 static int G__G__GeomBuilder_289_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09730 {
09731 TGeoShapeDialog* p = NULL;
09732 char* gvp = (char*) G__getgvp();
09733 switch (libp->paran) {
09734 case 4:
09735
09736 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09737 p = new TGeoShapeDialog(
09738 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09739 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09740 } else {
09741 p = new((void*) gvp) TGeoShapeDialog(
09742 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09743 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09744 }
09745 break;
09746 case 3:
09747
09748 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09749 p = new TGeoShapeDialog(
09750 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09751 , (UInt_t) G__int(libp->para[2]));
09752 } else {
09753 p = new((void*) gvp) TGeoShapeDialog(
09754 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09755 , (UInt_t) G__int(libp->para[2]));
09756 }
09757 break;
09758 case 2:
09759
09760 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09761 p = new TGeoShapeDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
09762 } else {
09763 p = new((void*) gvp) TGeoShapeDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
09764 }
09765 break;
09766 }
09767 result7->obj.i = (long) p;
09768 result7->ref = (long) p;
09769 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog));
09770 return(1 || funcname || hash || result7 || libp) ;
09771 }
09772
09773 static int G__G__GeomBuilder_289_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09774 {
09775 G__letint(result7, 85, (long) TGeoShapeDialog::Class());
09776 return(1 || funcname || hash || result7 || libp) ;
09777 }
09778
09779 static int G__G__GeomBuilder_289_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09780 {
09781 G__letint(result7, 67, (long) TGeoShapeDialog::Class_Name());
09782 return(1 || funcname || hash || result7 || libp) ;
09783 }
09784
09785 static int G__G__GeomBuilder_289_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09786 {
09787 G__letint(result7, 115, (long) TGeoShapeDialog::Class_Version());
09788 return(1 || funcname || hash || result7 || libp) ;
09789 }
09790
09791 static int G__G__GeomBuilder_289_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09792 {
09793 TGeoShapeDialog::Dictionary();
09794 G__setnull(result7);
09795 return(1 || funcname || hash || result7 || libp) ;
09796 }
09797
09798 static int G__G__GeomBuilder_289_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09799 {
09800 ((TGeoShapeDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09801 G__setnull(result7);
09802 return(1 || funcname || hash || result7 || libp) ;
09803 }
09804
09805 static int G__G__GeomBuilder_289_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09806 {
09807 G__letint(result7, 67, (long) TGeoShapeDialog::DeclFileName());
09808 return(1 || funcname || hash || result7 || libp) ;
09809 }
09810
09811 static int G__G__GeomBuilder_289_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09812 {
09813 G__letint(result7, 105, (long) TGeoShapeDialog::ImplFileLine());
09814 return(1 || funcname || hash || result7 || libp) ;
09815 }
09816
09817 static int G__G__GeomBuilder_289_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09818 {
09819 G__letint(result7, 67, (long) TGeoShapeDialog::ImplFileName());
09820 return(1 || funcname || hash || result7 || libp) ;
09821 }
09822
09823 static int G__G__GeomBuilder_289_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09824 {
09825 G__letint(result7, 105, (long) TGeoShapeDialog::DeclFileLine());
09826 return(1 || funcname || hash || result7 || libp) ;
09827 }
09828
09829
09830 typedef TGeoShapeDialog G__TTGeoShapeDialog;
09831 static int G__G__GeomBuilder_289_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09832 {
09833 char* gvp = (char*) G__getgvp();
09834 long soff = G__getstructoffset();
09835 int n = G__getaryconstruct();
09836
09837
09838
09839
09840
09841 if (!soff) {
09842 return(1);
09843 }
09844 if (n) {
09845 if (gvp == (char*)G__PVOID) {
09846 delete[] (TGeoShapeDialog*) soff;
09847 } else {
09848 G__setgvp((long) G__PVOID);
09849 for (int i = n - 1; i >= 0; --i) {
09850 ((TGeoShapeDialog*) (soff+(sizeof(TGeoShapeDialog)*i)))->~G__TTGeoShapeDialog();
09851 }
09852 G__setgvp((long)gvp);
09853 }
09854 } else {
09855 if (gvp == (char*)G__PVOID) {
09856 delete (TGeoShapeDialog*) soff;
09857 } else {
09858 G__setgvp((long) G__PVOID);
09859 ((TGeoShapeDialog*) (soff))->~G__TTGeoShapeDialog();
09860 G__setgvp((long)gvp);
09861 }
09862 }
09863 G__setnull(result7);
09864 return(1 || funcname || hash || result7 || libp) ;
09865 }
09866
09867
09868
09869 static int G__G__GeomBuilder_290_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09870 {
09871 TGeoMediumDialog* p = NULL;
09872 char* gvp = (char*) G__getgvp();
09873 switch (libp->paran) {
09874 case 4:
09875
09876 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09877 p = new TGeoMediumDialog(
09878 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09879 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09880 } else {
09881 p = new((void*) gvp) TGeoMediumDialog(
09882 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09883 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09884 }
09885 break;
09886 case 3:
09887
09888 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09889 p = new TGeoMediumDialog(
09890 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09891 , (UInt_t) G__int(libp->para[2]));
09892 } else {
09893 p = new((void*) gvp) TGeoMediumDialog(
09894 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
09895 , (UInt_t) G__int(libp->para[2]));
09896 }
09897 break;
09898 case 2:
09899
09900 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09901 p = new TGeoMediumDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
09902 } else {
09903 p = new((void*) gvp) TGeoMediumDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
09904 }
09905 break;
09906 }
09907 result7->obj.i = (long) p;
09908 result7->ref = (long) p;
09909 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog));
09910 return(1 || funcname || hash || result7 || libp) ;
09911 }
09912
09913 static int G__G__GeomBuilder_290_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09914 {
09915 G__letint(result7, 85, (long) TGeoMediumDialog::Class());
09916 return(1 || funcname || hash || result7 || libp) ;
09917 }
09918
09919 static int G__G__GeomBuilder_290_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09920 {
09921 G__letint(result7, 67, (long) TGeoMediumDialog::Class_Name());
09922 return(1 || funcname || hash || result7 || libp) ;
09923 }
09924
09925 static int G__G__GeomBuilder_290_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09926 {
09927 G__letint(result7, 115, (long) TGeoMediumDialog::Class_Version());
09928 return(1 || funcname || hash || result7 || libp) ;
09929 }
09930
09931 static int G__G__GeomBuilder_290_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09932 {
09933 TGeoMediumDialog::Dictionary();
09934 G__setnull(result7);
09935 return(1 || funcname || hash || result7 || libp) ;
09936 }
09937
09938 static int G__G__GeomBuilder_290_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09939 {
09940 ((TGeoMediumDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09941 G__setnull(result7);
09942 return(1 || funcname || hash || result7 || libp) ;
09943 }
09944
09945 static int G__G__GeomBuilder_290_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09946 {
09947 G__letint(result7, 67, (long) TGeoMediumDialog::DeclFileName());
09948 return(1 || funcname || hash || result7 || libp) ;
09949 }
09950
09951 static int G__G__GeomBuilder_290_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09952 {
09953 G__letint(result7, 105, (long) TGeoMediumDialog::ImplFileLine());
09954 return(1 || funcname || hash || result7 || libp) ;
09955 }
09956
09957 static int G__G__GeomBuilder_290_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09958 {
09959 G__letint(result7, 67, (long) TGeoMediumDialog::ImplFileName());
09960 return(1 || funcname || hash || result7 || libp) ;
09961 }
09962
09963 static int G__G__GeomBuilder_290_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09964 {
09965 G__letint(result7, 105, (long) TGeoMediumDialog::DeclFileLine());
09966 return(1 || funcname || hash || result7 || libp) ;
09967 }
09968
09969
09970 typedef TGeoMediumDialog G__TTGeoMediumDialog;
09971 static int G__G__GeomBuilder_290_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09972 {
09973 char* gvp = (char*) G__getgvp();
09974 long soff = G__getstructoffset();
09975 int n = G__getaryconstruct();
09976
09977
09978
09979
09980
09981 if (!soff) {
09982 return(1);
09983 }
09984 if (n) {
09985 if (gvp == (char*)G__PVOID) {
09986 delete[] (TGeoMediumDialog*) soff;
09987 } else {
09988 G__setgvp((long) G__PVOID);
09989 for (int i = n - 1; i >= 0; --i) {
09990 ((TGeoMediumDialog*) (soff+(sizeof(TGeoMediumDialog)*i)))->~G__TTGeoMediumDialog();
09991 }
09992 G__setgvp((long)gvp);
09993 }
09994 } else {
09995 if (gvp == (char*)G__PVOID) {
09996 delete (TGeoMediumDialog*) soff;
09997 } else {
09998 G__setgvp((long) G__PVOID);
09999 ((TGeoMediumDialog*) (soff))->~G__TTGeoMediumDialog();
10000 G__setgvp((long)gvp);
10001 }
10002 }
10003 G__setnull(result7);
10004 return(1 || funcname || hash || result7 || libp) ;
10005 }
10006
10007
10008
10009 static int G__G__GeomBuilder_291_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10010 {
10011 TGeoMaterialDialog* p = NULL;
10012 char* gvp = (char*) G__getgvp();
10013 switch (libp->paran) {
10014 case 4:
10015
10016 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10017 p = new TGeoMaterialDialog(
10018 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
10019 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10020 } else {
10021 p = new((void*) gvp) TGeoMaterialDialog(
10022 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
10023 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10024 }
10025 break;
10026 case 3:
10027
10028 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10029 p = new TGeoMaterialDialog(
10030 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
10031 , (UInt_t) G__int(libp->para[2]));
10032 } else {
10033 p = new((void*) gvp) TGeoMaterialDialog(
10034 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
10035 , (UInt_t) G__int(libp->para[2]));
10036 }
10037 break;
10038 case 2:
10039
10040 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10041 p = new TGeoMaterialDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
10042 } else {
10043 p = new((void*) gvp) TGeoMaterialDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
10044 }
10045 break;
10046 }
10047 result7->obj.i = (long) p;
10048 result7->ref = (long) p;
10049 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog));
10050 return(1 || funcname || hash || result7 || libp) ;
10051 }
10052
10053 static int G__G__GeomBuilder_291_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10054 {
10055 G__letint(result7, 85, (long) TGeoMaterialDialog::Class());
10056 return(1 || funcname || hash || result7 || libp) ;
10057 }
10058
10059 static int G__G__GeomBuilder_291_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10060 {
10061 G__letint(result7, 67, (long) TGeoMaterialDialog::Class_Name());
10062 return(1 || funcname || hash || result7 || libp) ;
10063 }
10064
10065 static int G__G__GeomBuilder_291_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10066 {
10067 G__letint(result7, 115, (long) TGeoMaterialDialog::Class_Version());
10068 return(1 || funcname || hash || result7 || libp) ;
10069 }
10070
10071 static int G__G__GeomBuilder_291_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10072 {
10073 TGeoMaterialDialog::Dictionary();
10074 G__setnull(result7);
10075 return(1 || funcname || hash || result7 || libp) ;
10076 }
10077
10078 static int G__G__GeomBuilder_291_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10079 {
10080 ((TGeoMaterialDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10081 G__setnull(result7);
10082 return(1 || funcname || hash || result7 || libp) ;
10083 }
10084
10085 static int G__G__GeomBuilder_291_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10086 {
10087 G__letint(result7, 67, (long) TGeoMaterialDialog::DeclFileName());
10088 return(1 || funcname || hash || result7 || libp) ;
10089 }
10090
10091 static int G__G__GeomBuilder_291_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10092 {
10093 G__letint(result7, 105, (long) TGeoMaterialDialog::ImplFileLine());
10094 return(1 || funcname || hash || result7 || libp) ;
10095 }
10096
10097 static int G__G__GeomBuilder_291_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10098 {
10099 G__letint(result7, 67, (long) TGeoMaterialDialog::ImplFileName());
10100 return(1 || funcname || hash || result7 || libp) ;
10101 }
10102
10103 static int G__G__GeomBuilder_291_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10104 {
10105 G__letint(result7, 105, (long) TGeoMaterialDialog::DeclFileLine());
10106 return(1 || funcname || hash || result7 || libp) ;
10107 }
10108
10109
10110 typedef TGeoMaterialDialog G__TTGeoMaterialDialog;
10111 static int G__G__GeomBuilder_291_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10112 {
10113 char* gvp = (char*) G__getgvp();
10114 long soff = G__getstructoffset();
10115 int n = G__getaryconstruct();
10116
10117
10118
10119
10120
10121 if (!soff) {
10122 return(1);
10123 }
10124 if (n) {
10125 if (gvp == (char*)G__PVOID) {
10126 delete[] (TGeoMaterialDialog*) soff;
10127 } else {
10128 G__setgvp((long) G__PVOID);
10129 for (int i = n - 1; i >= 0; --i) {
10130 ((TGeoMaterialDialog*) (soff+(sizeof(TGeoMaterialDialog)*i)))->~G__TTGeoMaterialDialog();
10131 }
10132 G__setgvp((long)gvp);
10133 }
10134 } else {
10135 if (gvp == (char*)G__PVOID) {
10136 delete (TGeoMaterialDialog*) soff;
10137 } else {
10138 G__setgvp((long) G__PVOID);
10139 ((TGeoMaterialDialog*) (soff))->~G__TTGeoMaterialDialog();
10140 G__setgvp((long)gvp);
10141 }
10142 }
10143 G__setnull(result7);
10144 return(1 || funcname || hash || result7 || libp) ;
10145 }
10146
10147
10148
10149 static int G__G__GeomBuilder_292_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10150 {
10151 TGeoMatrixDialog* p = NULL;
10152 char* gvp = (char*) G__getgvp();
10153 switch (libp->paran) {
10154 case 4:
10155
10156 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10157 p = new TGeoMatrixDialog(
10158 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
10159 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10160 } else {
10161 p = new((void*) gvp) TGeoMatrixDialog(
10162 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
10163 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10164 }
10165 break;
10166 case 3:
10167
10168 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10169 p = new TGeoMatrixDialog(
10170 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
10171 , (UInt_t) G__int(libp->para[2]));
10172 } else {
10173 p = new((void*) gvp) TGeoMatrixDialog(
10174 (TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
10175 , (UInt_t) G__int(libp->para[2]));
10176 }
10177 break;
10178 case 2:
10179
10180 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10181 p = new TGeoMatrixDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
10182 } else {
10183 p = new((void*) gvp) TGeoMatrixDialog((TGFrame*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1]));
10184 }
10185 break;
10186 }
10187 result7->obj.i = (long) p;
10188 result7->ref = (long) p;
10189 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog));
10190 return(1 || funcname || hash || result7 || libp) ;
10191 }
10192
10193 static int G__G__GeomBuilder_292_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10194 {
10195 G__letint(result7, 85, (long) TGeoMatrixDialog::Class());
10196 return(1 || funcname || hash || result7 || libp) ;
10197 }
10198
10199 static int G__G__GeomBuilder_292_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10200 {
10201 G__letint(result7, 67, (long) TGeoMatrixDialog::Class_Name());
10202 return(1 || funcname || hash || result7 || libp) ;
10203 }
10204
10205 static int G__G__GeomBuilder_292_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10206 {
10207 G__letint(result7, 115, (long) TGeoMatrixDialog::Class_Version());
10208 return(1 || funcname || hash || result7 || libp) ;
10209 }
10210
10211 static int G__G__GeomBuilder_292_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10212 {
10213 TGeoMatrixDialog::Dictionary();
10214 G__setnull(result7);
10215 return(1 || funcname || hash || result7 || libp) ;
10216 }
10217
10218 static int G__G__GeomBuilder_292_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10219 {
10220 ((TGeoMatrixDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10221 G__setnull(result7);
10222 return(1 || funcname || hash || result7 || libp) ;
10223 }
10224
10225 static int G__G__GeomBuilder_292_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10226 {
10227 G__letint(result7, 67, (long) TGeoMatrixDialog::DeclFileName());
10228 return(1 || funcname || hash || result7 || libp) ;
10229 }
10230
10231 static int G__G__GeomBuilder_292_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10232 {
10233 G__letint(result7, 105, (long) TGeoMatrixDialog::ImplFileLine());
10234 return(1 || funcname || hash || result7 || libp) ;
10235 }
10236
10237 static int G__G__GeomBuilder_292_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10238 {
10239 G__letint(result7, 67, (long) TGeoMatrixDialog::ImplFileName());
10240 return(1 || funcname || hash || result7 || libp) ;
10241 }
10242
10243 static int G__G__GeomBuilder_292_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10244 {
10245 G__letint(result7, 105, (long) TGeoMatrixDialog::DeclFileLine());
10246 return(1 || funcname || hash || result7 || libp) ;
10247 }
10248
10249
10250 typedef TGeoMatrixDialog G__TTGeoMatrixDialog;
10251 static int G__G__GeomBuilder_292_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10252 {
10253 char* gvp = (char*) G__getgvp();
10254 long soff = G__getstructoffset();
10255 int n = G__getaryconstruct();
10256
10257
10258
10259
10260
10261 if (!soff) {
10262 return(1);
10263 }
10264 if (n) {
10265 if (gvp == (char*)G__PVOID) {
10266 delete[] (TGeoMatrixDialog*) soff;
10267 } else {
10268 G__setgvp((long) G__PVOID);
10269 for (int i = n - 1; i >= 0; --i) {
10270 ((TGeoMatrixDialog*) (soff+(sizeof(TGeoMatrixDialog)*i)))->~G__TTGeoMatrixDialog();
10271 }
10272 G__setgvp((long)gvp);
10273 }
10274 } else {
10275 if (gvp == (char*)G__PVOID) {
10276 delete (TGeoMatrixDialog*) soff;
10277 } else {
10278 G__setgvp((long) G__PVOID);
10279 ((TGeoMatrixDialog*) (soff))->~G__TTGeoMatrixDialog();
10280 G__setgvp((long)gvp);
10281 }
10282 }
10283 G__setnull(result7);
10284 return(1 || funcname || hash || result7 || libp) ;
10285 }
10286
10287
10288
10289 static int G__G__GeomBuilder_294_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10290 {
10291 TGeoSphereEditor* p = NULL;
10292 char* gvp = (char*) G__getgvp();
10293 switch (libp->paran) {
10294 case 5:
10295
10296 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10297 p = new TGeoSphereEditor(
10298 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10299 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10300 , (Pixel_t) G__int(libp->para[4]));
10301 } else {
10302 p = new((void*) gvp) TGeoSphereEditor(
10303 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10304 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10305 , (Pixel_t) G__int(libp->para[4]));
10306 }
10307 break;
10308 case 4:
10309
10310 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10311 p = new TGeoSphereEditor(
10312 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10313 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10314 } else {
10315 p = new((void*) gvp) TGeoSphereEditor(
10316 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10317 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10318 }
10319 break;
10320 case 3:
10321
10322 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10323 p = new TGeoSphereEditor(
10324 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10325 , (Int_t) G__int(libp->para[2]));
10326 } else {
10327 p = new((void*) gvp) TGeoSphereEditor(
10328 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10329 , (Int_t) G__int(libp->para[2]));
10330 }
10331 break;
10332 case 2:
10333
10334 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10335 p = new TGeoSphereEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10336 } else {
10337 p = new((void*) gvp) TGeoSphereEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10338 }
10339 break;
10340 case 1:
10341
10342 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10343 p = new TGeoSphereEditor((TGWindow*) G__int(libp->para[0]));
10344 } else {
10345 p = new((void*) gvp) TGeoSphereEditor((TGWindow*) G__int(libp->para[0]));
10346 }
10347 break;
10348 case 0:
10349 int n = G__getaryconstruct();
10350 if (n) {
10351 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10352 p = new TGeoSphereEditor[n];
10353 } else {
10354 p = new((void*) gvp) TGeoSphereEditor[n];
10355 }
10356 } else {
10357 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10358 p = new TGeoSphereEditor;
10359 } else {
10360 p = new((void*) gvp) TGeoSphereEditor;
10361 }
10362 }
10363 break;
10364 }
10365 result7->obj.i = (long) p;
10366 result7->ref = (long) p;
10367 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor));
10368 return(1 || funcname || hash || result7 || libp) ;
10369 }
10370
10371 static int G__G__GeomBuilder_294_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10372 {
10373 ((TGeoSphereEditor*) G__getstructoffset())->DoRmin();
10374 G__setnull(result7);
10375 return(1 || funcname || hash || result7 || libp) ;
10376 }
10377
10378 static int G__G__GeomBuilder_294_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10379 {
10380 ((TGeoSphereEditor*) G__getstructoffset())->DoRmax();
10381 G__setnull(result7);
10382 return(1 || funcname || hash || result7 || libp) ;
10383 }
10384
10385 static int G__G__GeomBuilder_294_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10386 {
10387 ((TGeoSphereEditor*) G__getstructoffset())->DoPhi();
10388 G__setnull(result7);
10389 return(1 || funcname || hash || result7 || libp) ;
10390 }
10391
10392 static int G__G__GeomBuilder_294_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10393 {
10394 ((TGeoSphereEditor*) G__getstructoffset())->DoTheta();
10395 G__setnull(result7);
10396 return(1 || funcname || hash || result7 || libp) ;
10397 }
10398
10399 static int G__G__GeomBuilder_294_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10400 {
10401 ((TGeoSphereEditor*) G__getstructoffset())->DoTheta1();
10402 G__setnull(result7);
10403 return(1 || funcname || hash || result7 || libp) ;
10404 }
10405
10406 static int G__G__GeomBuilder_294_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10407 {
10408 ((TGeoSphereEditor*) G__getstructoffset())->DoTheta2();
10409 G__setnull(result7);
10410 return(1 || funcname || hash || result7 || libp) ;
10411 }
10412
10413 static int G__G__GeomBuilder_294_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10414 {
10415 ((TGeoSphereEditor*) G__getstructoffset())->DoPhi1();
10416 G__setnull(result7);
10417 return(1 || funcname || hash || result7 || libp) ;
10418 }
10419
10420 static int G__G__GeomBuilder_294_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10421 {
10422 ((TGeoSphereEditor*) G__getstructoffset())->DoPhi2();
10423 G__setnull(result7);
10424 return(1 || funcname || hash || result7 || libp) ;
10425 }
10426
10427 static int G__G__GeomBuilder_294_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10428 {
10429 ((TGeoSphereEditor*) G__getstructoffset())->DoModified();
10430 G__setnull(result7);
10431 return(1 || funcname || hash || result7 || libp) ;
10432 }
10433
10434 static int G__G__GeomBuilder_294_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10435 {
10436 ((TGeoSphereEditor*) G__getstructoffset())->DoName();
10437 G__setnull(result7);
10438 return(1 || funcname || hash || result7 || libp) ;
10439 }
10440
10441 static int G__G__GeomBuilder_294_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10442 {
10443 ((TGeoSphereEditor*) G__getstructoffset())->DoApply();
10444 G__setnull(result7);
10445 return(1 || funcname || hash || result7 || libp) ;
10446 }
10447
10448 static int G__G__GeomBuilder_294_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10449 {
10450 ((TGeoSphereEditor*) G__getstructoffset())->DoUndo();
10451 G__setnull(result7);
10452 return(1 || funcname || hash || result7 || libp) ;
10453 }
10454
10455 static int G__G__GeomBuilder_294_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10456 {
10457 G__letint(result7, 85, (long) TGeoSphereEditor::Class());
10458 return(1 || funcname || hash || result7 || libp) ;
10459 }
10460
10461 static int G__G__GeomBuilder_294_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10462 {
10463 G__letint(result7, 67, (long) TGeoSphereEditor::Class_Name());
10464 return(1 || funcname || hash || result7 || libp) ;
10465 }
10466
10467 static int G__G__GeomBuilder_294_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10468 {
10469 G__letint(result7, 115, (long) TGeoSphereEditor::Class_Version());
10470 return(1 || funcname || hash || result7 || libp) ;
10471 }
10472
10473 static int G__G__GeomBuilder_294_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10474 {
10475 TGeoSphereEditor::Dictionary();
10476 G__setnull(result7);
10477 return(1 || funcname || hash || result7 || libp) ;
10478 }
10479
10480 static int G__G__GeomBuilder_294_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10481 {
10482 ((TGeoSphereEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10483 G__setnull(result7);
10484 return(1 || funcname || hash || result7 || libp) ;
10485 }
10486
10487 static int G__G__GeomBuilder_294_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10488 {
10489 G__letint(result7, 67, (long) TGeoSphereEditor::DeclFileName());
10490 return(1 || funcname || hash || result7 || libp) ;
10491 }
10492
10493 static int G__G__GeomBuilder_294_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10494 {
10495 G__letint(result7, 105, (long) TGeoSphereEditor::ImplFileLine());
10496 return(1 || funcname || hash || result7 || libp) ;
10497 }
10498
10499 static int G__G__GeomBuilder_294_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10500 {
10501 G__letint(result7, 67, (long) TGeoSphereEditor::ImplFileName());
10502 return(1 || funcname || hash || result7 || libp) ;
10503 }
10504
10505 static int G__G__GeomBuilder_294_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10506 {
10507 G__letint(result7, 105, (long) TGeoSphereEditor::DeclFileLine());
10508 return(1 || funcname || hash || result7 || libp) ;
10509 }
10510
10511
10512 typedef TGeoSphereEditor G__TTGeoSphereEditor;
10513 static int G__G__GeomBuilder_294_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10514 {
10515 char* gvp = (char*) G__getgvp();
10516 long soff = G__getstructoffset();
10517 int n = G__getaryconstruct();
10518
10519
10520
10521
10522
10523 if (!soff) {
10524 return(1);
10525 }
10526 if (n) {
10527 if (gvp == (char*)G__PVOID) {
10528 delete[] (TGeoSphereEditor*) soff;
10529 } else {
10530 G__setgvp((long) G__PVOID);
10531 for (int i = n - 1; i >= 0; --i) {
10532 ((TGeoSphereEditor*) (soff+(sizeof(TGeoSphereEditor)*i)))->~G__TTGeoSphereEditor();
10533 }
10534 G__setgvp((long)gvp);
10535 }
10536 } else {
10537 if (gvp == (char*)G__PVOID) {
10538 delete (TGeoSphereEditor*) soff;
10539 } else {
10540 G__setgvp((long) G__PVOID);
10541 ((TGeoSphereEditor*) (soff))->~G__TTGeoSphereEditor();
10542 G__setgvp((long)gvp);
10543 }
10544 }
10545 G__setnull(result7);
10546 return(1 || funcname || hash || result7 || libp) ;
10547 }
10548
10549
10550
10551 static int G__G__GeomBuilder_296_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10552 {
10553 TGeoPconSection* p = NULL;
10554 char* gvp = (char*) G__getgvp();
10555
10556 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10557 p = new TGeoPconSection(
10558 (TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
10559 , (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
10560 } else {
10561 p = new((void*) gvp) TGeoPconSection(
10562 (TGWindow*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
10563 , (UInt_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
10564 }
10565 result7->obj.i = (long) p;
10566 result7->ref = (long) p;
10567 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection));
10568 return(1 || funcname || hash || result7 || libp) ;
10569 }
10570
10571 static int G__G__GeomBuilder_296_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10572 {
10573 ((TGeoPconSection*) G__getstructoffset())->HideDaughters();
10574 G__setnull(result7);
10575 return(1 || funcname || hash || result7 || libp) ;
10576 }
10577
10578 static int G__G__GeomBuilder_296_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10579 {
10580 G__letdouble(result7, 100, (double) ((const TGeoPconSection*) G__getstructoffset())->GetZ());
10581 return(1 || funcname || hash || result7 || libp) ;
10582 }
10583
10584 static int G__G__GeomBuilder_296_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10585 {
10586 G__letdouble(result7, 100, (double) ((const TGeoPconSection*) G__getstructoffset())->GetRmin());
10587 return(1 || funcname || hash || result7 || libp) ;
10588 }
10589
10590 static int G__G__GeomBuilder_296_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10591 {
10592 G__letdouble(result7, 100, (double) ((const TGeoPconSection*) G__getstructoffset())->GetRmax());
10593 return(1 || funcname || hash || result7 || libp) ;
10594 }
10595
10596 static int G__G__GeomBuilder_296_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10597 {
10598 ((TGeoPconSection*) G__getstructoffset())->SetZ((Double_t) G__double(libp->para[0]));
10599 G__setnull(result7);
10600 return(1 || funcname || hash || result7 || libp) ;
10601 }
10602
10603 static int G__G__GeomBuilder_296_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10604 {
10605 ((TGeoPconSection*) G__getstructoffset())->SetRmin((Double_t) G__double(libp->para[0]));
10606 G__setnull(result7);
10607 return(1 || funcname || hash || result7 || libp) ;
10608 }
10609
10610 static int G__G__GeomBuilder_296_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10611 {
10612 ((TGeoPconSection*) G__getstructoffset())->SetRmax((Double_t) G__double(libp->para[0]));
10613 G__setnull(result7);
10614 return(1 || funcname || hash || result7 || libp) ;
10615 }
10616
10617 static int G__G__GeomBuilder_296_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10618 {
10619 ((TGeoPconSection*) G__getstructoffset())->DoZ();
10620 G__setnull(result7);
10621 return(1 || funcname || hash || result7 || libp) ;
10622 }
10623
10624 static int G__G__GeomBuilder_296_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10625 {
10626 ((TGeoPconSection*) G__getstructoffset())->DoRmin();
10627 G__setnull(result7);
10628 return(1 || funcname || hash || result7 || libp) ;
10629 }
10630
10631 static int G__G__GeomBuilder_296_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10632 {
10633 ((TGeoPconSection*) G__getstructoffset())->DoRmax();
10634 G__setnull(result7);
10635 return(1 || funcname || hash || result7 || libp) ;
10636 }
10637
10638 static int G__G__GeomBuilder_296_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10639 {
10640 ((TGeoPconSection*) G__getstructoffset())->Changed((Int_t) G__int(libp->para[0]));
10641 G__setnull(result7);
10642 return(1 || funcname || hash || result7 || libp) ;
10643 }
10644
10645 static int G__G__GeomBuilder_296_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10646 {
10647 G__letint(result7, 85, (long) TGeoPconSection::Class());
10648 return(1 || funcname || hash || result7 || libp) ;
10649 }
10650
10651 static int G__G__GeomBuilder_296_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10652 {
10653 G__letint(result7, 67, (long) TGeoPconSection::Class_Name());
10654 return(1 || funcname || hash || result7 || libp) ;
10655 }
10656
10657 static int G__G__GeomBuilder_296_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10658 {
10659 G__letint(result7, 115, (long) TGeoPconSection::Class_Version());
10660 return(1 || funcname || hash || result7 || libp) ;
10661 }
10662
10663 static int G__G__GeomBuilder_296_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10664 {
10665 TGeoPconSection::Dictionary();
10666 G__setnull(result7);
10667 return(1 || funcname || hash || result7 || libp) ;
10668 }
10669
10670 static int G__G__GeomBuilder_296_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10671 {
10672 ((TGeoPconSection*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10673 G__setnull(result7);
10674 return(1 || funcname || hash || result7 || libp) ;
10675 }
10676
10677 static int G__G__GeomBuilder_296_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10678 {
10679 G__letint(result7, 67, (long) TGeoPconSection::DeclFileName());
10680 return(1 || funcname || hash || result7 || libp) ;
10681 }
10682
10683 static int G__G__GeomBuilder_296_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10684 {
10685 G__letint(result7, 105, (long) TGeoPconSection::ImplFileLine());
10686 return(1 || funcname || hash || result7 || libp) ;
10687 }
10688
10689 static int G__G__GeomBuilder_296_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10690 {
10691 G__letint(result7, 67, (long) TGeoPconSection::ImplFileName());
10692 return(1 || funcname || hash || result7 || libp) ;
10693 }
10694
10695 static int G__G__GeomBuilder_296_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10696 {
10697 G__letint(result7, 105, (long) TGeoPconSection::DeclFileLine());
10698 return(1 || funcname || hash || result7 || libp) ;
10699 }
10700
10701
10702 typedef TGeoPconSection G__TTGeoPconSection;
10703 static int G__G__GeomBuilder_296_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10704 {
10705 char* gvp = (char*) G__getgvp();
10706 long soff = G__getstructoffset();
10707 int n = G__getaryconstruct();
10708
10709
10710
10711
10712
10713 if (!soff) {
10714 return(1);
10715 }
10716 if (n) {
10717 if (gvp == (char*)G__PVOID) {
10718 delete[] (TGeoPconSection*) soff;
10719 } else {
10720 G__setgvp((long) G__PVOID);
10721 for (int i = n - 1; i >= 0; --i) {
10722 ((TGeoPconSection*) (soff+(sizeof(TGeoPconSection)*i)))->~G__TTGeoPconSection();
10723 }
10724 G__setgvp((long)gvp);
10725 }
10726 } else {
10727 if (gvp == (char*)G__PVOID) {
10728 delete (TGeoPconSection*) soff;
10729 } else {
10730 G__setgvp((long) G__PVOID);
10731 ((TGeoPconSection*) (soff))->~G__TTGeoPconSection();
10732 G__setgvp((long)gvp);
10733 }
10734 }
10735 G__setnull(result7);
10736 return(1 || funcname || hash || result7 || libp) ;
10737 }
10738
10739
10740
10741 static int G__G__GeomBuilder_297_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10742 {
10743 TGeoPconEditor* p = NULL;
10744 char* gvp = (char*) G__getgvp();
10745 switch (libp->paran) {
10746 case 5:
10747
10748 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10749 p = new TGeoPconEditor(
10750 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10751 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10752 , (Pixel_t) G__int(libp->para[4]));
10753 } else {
10754 p = new((void*) gvp) TGeoPconEditor(
10755 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10756 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10757 , (Pixel_t) G__int(libp->para[4]));
10758 }
10759 break;
10760 case 4:
10761
10762 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10763 p = new TGeoPconEditor(
10764 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10765 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10766 } else {
10767 p = new((void*) gvp) TGeoPconEditor(
10768 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10769 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10770 }
10771 break;
10772 case 3:
10773
10774 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10775 p = new TGeoPconEditor(
10776 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10777 , (Int_t) G__int(libp->para[2]));
10778 } else {
10779 p = new((void*) gvp) TGeoPconEditor(
10780 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10781 , (Int_t) G__int(libp->para[2]));
10782 }
10783 break;
10784 case 2:
10785
10786 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10787 p = new TGeoPconEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10788 } else {
10789 p = new((void*) gvp) TGeoPconEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10790 }
10791 break;
10792 case 1:
10793
10794 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10795 p = new TGeoPconEditor((TGWindow*) G__int(libp->para[0]));
10796 } else {
10797 p = new((void*) gvp) TGeoPconEditor((TGWindow*) G__int(libp->para[0]));
10798 }
10799 break;
10800 case 0:
10801 int n = G__getaryconstruct();
10802 if (n) {
10803 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10804 p = new TGeoPconEditor[n];
10805 } else {
10806 p = new((void*) gvp) TGeoPconEditor[n];
10807 }
10808 } else {
10809 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10810 p = new TGeoPconEditor;
10811 } else {
10812 p = new((void*) gvp) TGeoPconEditor;
10813 }
10814 }
10815 break;
10816 }
10817 result7->obj.i = (long) p;
10818 result7->ref = (long) p;
10819 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor));
10820 return(1 || funcname || hash || result7 || libp) ;
10821 }
10822
10823 static int G__G__GeomBuilder_297_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10824 {
10825 ((TGeoPconEditor*) G__getstructoffset())->DoModified();
10826 G__setnull(result7);
10827 return(1 || funcname || hash || result7 || libp) ;
10828 }
10829
10830 static int G__G__GeomBuilder_297_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10831 {
10832 ((TGeoPconEditor*) G__getstructoffset())->DoName();
10833 G__setnull(result7);
10834 return(1 || funcname || hash || result7 || libp) ;
10835 }
10836
10837 static int G__G__GeomBuilder_297_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10838 {
10839 ((TGeoPconEditor*) G__getstructoffset())->DoNz();
10840 G__setnull(result7);
10841 return(1 || funcname || hash || result7 || libp) ;
10842 }
10843
10844 static int G__G__GeomBuilder_297_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10845 {
10846 ((TGeoPconEditor*) G__getstructoffset())->DoPhi();
10847 G__setnull(result7);
10848 return(1 || funcname || hash || result7 || libp) ;
10849 }
10850
10851 static int G__G__GeomBuilder_297_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10852 {
10853 ((TGeoPconEditor*) G__getstructoffset())->DoSectionChange((Int_t) G__int(libp->para[0]));
10854 G__setnull(result7);
10855 return(1 || funcname || hash || result7 || libp) ;
10856 }
10857
10858 static int G__G__GeomBuilder_297_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10859 {
10860 ((TGeoPconEditor*) G__getstructoffset())->DoApply();
10861 G__setnull(result7);
10862 return(1 || funcname || hash || result7 || libp) ;
10863 }
10864
10865 static int G__G__GeomBuilder_297_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10866 {
10867 ((TGeoPconEditor*) G__getstructoffset())->DoUndo();
10868 G__setnull(result7);
10869 return(1 || funcname || hash || result7 || libp) ;
10870 }
10871
10872 static int G__G__GeomBuilder_297_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10873 {
10874 G__letint(result7, 85, (long) TGeoPconEditor::Class());
10875 return(1 || funcname || hash || result7 || libp) ;
10876 }
10877
10878 static int G__G__GeomBuilder_297_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10879 {
10880 G__letint(result7, 67, (long) TGeoPconEditor::Class_Name());
10881 return(1 || funcname || hash || result7 || libp) ;
10882 }
10883
10884 static int G__G__GeomBuilder_297_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10885 {
10886 G__letint(result7, 115, (long) TGeoPconEditor::Class_Version());
10887 return(1 || funcname || hash || result7 || libp) ;
10888 }
10889
10890 static int G__G__GeomBuilder_297_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10891 {
10892 TGeoPconEditor::Dictionary();
10893 G__setnull(result7);
10894 return(1 || funcname || hash || result7 || libp) ;
10895 }
10896
10897 static int G__G__GeomBuilder_297_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10898 {
10899 ((TGeoPconEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10900 G__setnull(result7);
10901 return(1 || funcname || hash || result7 || libp) ;
10902 }
10903
10904 static int G__G__GeomBuilder_297_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10905 {
10906 G__letint(result7, 67, (long) TGeoPconEditor::DeclFileName());
10907 return(1 || funcname || hash || result7 || libp) ;
10908 }
10909
10910 static int G__G__GeomBuilder_297_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10911 {
10912 G__letint(result7, 105, (long) TGeoPconEditor::ImplFileLine());
10913 return(1 || funcname || hash || result7 || libp) ;
10914 }
10915
10916 static int G__G__GeomBuilder_297_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10917 {
10918 G__letint(result7, 67, (long) TGeoPconEditor::ImplFileName());
10919 return(1 || funcname || hash || result7 || libp) ;
10920 }
10921
10922 static int G__G__GeomBuilder_297_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10923 {
10924 G__letint(result7, 105, (long) TGeoPconEditor::DeclFileLine());
10925 return(1 || funcname || hash || result7 || libp) ;
10926 }
10927
10928
10929 typedef TGeoPconEditor G__TTGeoPconEditor;
10930 static int G__G__GeomBuilder_297_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10931 {
10932 char* gvp = (char*) G__getgvp();
10933 long soff = G__getstructoffset();
10934 int n = G__getaryconstruct();
10935
10936
10937
10938
10939
10940 if (!soff) {
10941 return(1);
10942 }
10943 if (n) {
10944 if (gvp == (char*)G__PVOID) {
10945 delete[] (TGeoPconEditor*) soff;
10946 } else {
10947 G__setgvp((long) G__PVOID);
10948 for (int i = n - 1; i >= 0; --i) {
10949 ((TGeoPconEditor*) (soff+(sizeof(TGeoPconEditor)*i)))->~G__TTGeoPconEditor();
10950 }
10951 G__setgvp((long)gvp);
10952 }
10953 } else {
10954 if (gvp == (char*)G__PVOID) {
10955 delete (TGeoPconEditor*) soff;
10956 } else {
10957 G__setgvp((long) G__PVOID);
10958 ((TGeoPconEditor*) (soff))->~G__TTGeoPconEditor();
10959 G__setgvp((long)gvp);
10960 }
10961 }
10962 G__setnull(result7);
10963 return(1 || funcname || hash || result7 || libp) ;
10964 }
10965
10966
10967
10968 static int G__G__GeomBuilder_299_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10969 {
10970 TGeoParaEditor* p = NULL;
10971 char* gvp = (char*) G__getgvp();
10972 switch (libp->paran) {
10973 case 5:
10974
10975 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10976 p = new TGeoParaEditor(
10977 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10978 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10979 , (Pixel_t) G__int(libp->para[4]));
10980 } else {
10981 p = new((void*) gvp) TGeoParaEditor(
10982 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10983 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10984 , (Pixel_t) G__int(libp->para[4]));
10985 }
10986 break;
10987 case 4:
10988
10989 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10990 p = new TGeoParaEditor(
10991 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10992 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10993 } else {
10994 p = new((void*) gvp) TGeoParaEditor(
10995 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10996 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10997 }
10998 break;
10999 case 3:
11000
11001 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11002 p = new TGeoParaEditor(
11003 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11004 , (Int_t) G__int(libp->para[2]));
11005 } else {
11006 p = new((void*) gvp) TGeoParaEditor(
11007 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11008 , (Int_t) G__int(libp->para[2]));
11009 }
11010 break;
11011 case 2:
11012
11013 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11014 p = new TGeoParaEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11015 } else {
11016 p = new((void*) gvp) TGeoParaEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11017 }
11018 break;
11019 case 1:
11020
11021 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11022 p = new TGeoParaEditor((TGWindow*) G__int(libp->para[0]));
11023 } else {
11024 p = new((void*) gvp) TGeoParaEditor((TGWindow*) G__int(libp->para[0]));
11025 }
11026 break;
11027 case 0:
11028 int n = G__getaryconstruct();
11029 if (n) {
11030 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11031 p = new TGeoParaEditor[n];
11032 } else {
11033 p = new((void*) gvp) TGeoParaEditor[n];
11034 }
11035 } else {
11036 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11037 p = new TGeoParaEditor;
11038 } else {
11039 p = new((void*) gvp) TGeoParaEditor;
11040 }
11041 }
11042 break;
11043 }
11044 result7->obj.i = (long) p;
11045 result7->ref = (long) p;
11046 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor));
11047 return(1 || funcname || hash || result7 || libp) ;
11048 }
11049
11050 static int G__G__GeomBuilder_299_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11051 {
11052 ((TGeoParaEditor*) G__getstructoffset())->DoX();
11053 G__setnull(result7);
11054 return(1 || funcname || hash || result7 || libp) ;
11055 }
11056
11057 static int G__G__GeomBuilder_299_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11058 {
11059 ((TGeoParaEditor*) G__getstructoffset())->DoY();
11060 G__setnull(result7);
11061 return(1 || funcname || hash || result7 || libp) ;
11062 }
11063
11064 static int G__G__GeomBuilder_299_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11065 {
11066 ((TGeoParaEditor*) G__getstructoffset())->DoZ();
11067 G__setnull(result7);
11068 return(1 || funcname || hash || result7 || libp) ;
11069 }
11070
11071 static int G__G__GeomBuilder_299_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11072 {
11073 ((TGeoParaEditor*) G__getstructoffset())->DoAlpha();
11074 G__setnull(result7);
11075 return(1 || funcname || hash || result7 || libp) ;
11076 }
11077
11078 static int G__G__GeomBuilder_299_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11079 {
11080 ((TGeoParaEditor*) G__getstructoffset())->DoTheta();
11081 G__setnull(result7);
11082 return(1 || funcname || hash || result7 || libp) ;
11083 }
11084
11085 static int G__G__GeomBuilder_299_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11086 {
11087 ((TGeoParaEditor*) G__getstructoffset())->DoPhi();
11088 G__setnull(result7);
11089 return(1 || funcname || hash || result7 || libp) ;
11090 }
11091
11092 static int G__G__GeomBuilder_299_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11093 {
11094 ((TGeoParaEditor*) G__getstructoffset())->DoModified();
11095 G__setnull(result7);
11096 return(1 || funcname || hash || result7 || libp) ;
11097 }
11098
11099 static int G__G__GeomBuilder_299_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11100 {
11101 ((TGeoParaEditor*) G__getstructoffset())->DoName();
11102 G__setnull(result7);
11103 return(1 || funcname || hash || result7 || libp) ;
11104 }
11105
11106 static int G__G__GeomBuilder_299_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11107 {
11108 ((TGeoParaEditor*) G__getstructoffset())->DoApply();
11109 G__setnull(result7);
11110 return(1 || funcname || hash || result7 || libp) ;
11111 }
11112
11113 static int G__G__GeomBuilder_299_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11114 {
11115 ((TGeoParaEditor*) G__getstructoffset())->DoUndo();
11116 G__setnull(result7);
11117 return(1 || funcname || hash || result7 || libp) ;
11118 }
11119
11120 static int G__G__GeomBuilder_299_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11121 {
11122 G__letint(result7, 85, (long) TGeoParaEditor::Class());
11123 return(1 || funcname || hash || result7 || libp) ;
11124 }
11125
11126 static int G__G__GeomBuilder_299_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11127 {
11128 G__letint(result7, 67, (long) TGeoParaEditor::Class_Name());
11129 return(1 || funcname || hash || result7 || libp) ;
11130 }
11131
11132 static int G__G__GeomBuilder_299_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11133 {
11134 G__letint(result7, 115, (long) TGeoParaEditor::Class_Version());
11135 return(1 || funcname || hash || result7 || libp) ;
11136 }
11137
11138 static int G__G__GeomBuilder_299_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11139 {
11140 TGeoParaEditor::Dictionary();
11141 G__setnull(result7);
11142 return(1 || funcname || hash || result7 || libp) ;
11143 }
11144
11145 static int G__G__GeomBuilder_299_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11146 {
11147 ((TGeoParaEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11148 G__setnull(result7);
11149 return(1 || funcname || hash || result7 || libp) ;
11150 }
11151
11152 static int G__G__GeomBuilder_299_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11153 {
11154 G__letint(result7, 67, (long) TGeoParaEditor::DeclFileName());
11155 return(1 || funcname || hash || result7 || libp) ;
11156 }
11157
11158 static int G__G__GeomBuilder_299_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11159 {
11160 G__letint(result7, 105, (long) TGeoParaEditor::ImplFileLine());
11161 return(1 || funcname || hash || result7 || libp) ;
11162 }
11163
11164 static int G__G__GeomBuilder_299_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11165 {
11166 G__letint(result7, 67, (long) TGeoParaEditor::ImplFileName());
11167 return(1 || funcname || hash || result7 || libp) ;
11168 }
11169
11170 static int G__G__GeomBuilder_299_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11171 {
11172 G__letint(result7, 105, (long) TGeoParaEditor::DeclFileLine());
11173 return(1 || funcname || hash || result7 || libp) ;
11174 }
11175
11176
11177 typedef TGeoParaEditor G__TTGeoParaEditor;
11178 static int G__G__GeomBuilder_299_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11179 {
11180 char* gvp = (char*) G__getgvp();
11181 long soff = G__getstructoffset();
11182 int n = G__getaryconstruct();
11183
11184
11185
11186
11187
11188 if (!soff) {
11189 return(1);
11190 }
11191 if (n) {
11192 if (gvp == (char*)G__PVOID) {
11193 delete[] (TGeoParaEditor*) soff;
11194 } else {
11195 G__setgvp((long) G__PVOID);
11196 for (int i = n - 1; i >= 0; --i) {
11197 ((TGeoParaEditor*) (soff+(sizeof(TGeoParaEditor)*i)))->~G__TTGeoParaEditor();
11198 }
11199 G__setgvp((long)gvp);
11200 }
11201 } else {
11202 if (gvp == (char*)G__PVOID) {
11203 delete (TGeoParaEditor*) soff;
11204 } else {
11205 G__setgvp((long) G__PVOID);
11206 ((TGeoParaEditor*) (soff))->~G__TTGeoParaEditor();
11207 G__setgvp((long)gvp);
11208 }
11209 }
11210 G__setnull(result7);
11211 return(1 || funcname || hash || result7 || libp) ;
11212 }
11213
11214
11215
11216 static int G__G__GeomBuilder_301_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11217 {
11218 TGeoTorusEditor* p = NULL;
11219 char* gvp = (char*) G__getgvp();
11220 switch (libp->paran) {
11221 case 5:
11222
11223 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11224 p = new TGeoTorusEditor(
11225 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11226 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
11227 , (Pixel_t) G__int(libp->para[4]));
11228 } else {
11229 p = new((void*) gvp) TGeoTorusEditor(
11230 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11231 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
11232 , (Pixel_t) G__int(libp->para[4]));
11233 }
11234 break;
11235 case 4:
11236
11237 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11238 p = new TGeoTorusEditor(
11239 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11240 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11241 } else {
11242 p = new((void*) gvp) TGeoTorusEditor(
11243 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11244 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11245 }
11246 break;
11247 case 3:
11248
11249 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11250 p = new TGeoTorusEditor(
11251 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11252 , (Int_t) G__int(libp->para[2]));
11253 } else {
11254 p = new((void*) gvp) TGeoTorusEditor(
11255 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11256 , (Int_t) G__int(libp->para[2]));
11257 }
11258 break;
11259 case 2:
11260
11261 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11262 p = new TGeoTorusEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11263 } else {
11264 p = new((void*) gvp) TGeoTorusEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11265 }
11266 break;
11267 case 1:
11268
11269 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11270 p = new TGeoTorusEditor((TGWindow*) G__int(libp->para[0]));
11271 } else {
11272 p = new((void*) gvp) TGeoTorusEditor((TGWindow*) G__int(libp->para[0]));
11273 }
11274 break;
11275 case 0:
11276 int n = G__getaryconstruct();
11277 if (n) {
11278 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11279 p = new TGeoTorusEditor[n];
11280 } else {
11281 p = new((void*) gvp) TGeoTorusEditor[n];
11282 }
11283 } else {
11284 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11285 p = new TGeoTorusEditor;
11286 } else {
11287 p = new((void*) gvp) TGeoTorusEditor;
11288 }
11289 }
11290 break;
11291 }
11292 result7->obj.i = (long) p;
11293 result7->ref = (long) p;
11294 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor));
11295 return(1 || funcname || hash || result7 || libp) ;
11296 }
11297
11298 static int G__G__GeomBuilder_301_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11299 {
11300 ((TGeoTorusEditor*) G__getstructoffset())->DoR();
11301 G__setnull(result7);
11302 return(1 || funcname || hash || result7 || libp) ;
11303 }
11304
11305 static int G__G__GeomBuilder_301_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11306 {
11307 ((TGeoTorusEditor*) G__getstructoffset())->DoRmin();
11308 G__setnull(result7);
11309 return(1 || funcname || hash || result7 || libp) ;
11310 }
11311
11312 static int G__G__GeomBuilder_301_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11313 {
11314 ((TGeoTorusEditor*) G__getstructoffset())->DoRmax();
11315 G__setnull(result7);
11316 return(1 || funcname || hash || result7 || libp) ;
11317 }
11318
11319 static int G__G__GeomBuilder_301_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11320 {
11321 ((TGeoTorusEditor*) G__getstructoffset())->DoPhi1();
11322 G__setnull(result7);
11323 return(1 || funcname || hash || result7 || libp) ;
11324 }
11325
11326 static int G__G__GeomBuilder_301_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11327 {
11328 ((TGeoTorusEditor*) G__getstructoffset())->DoDphi();
11329 G__setnull(result7);
11330 return(1 || funcname || hash || result7 || libp) ;
11331 }
11332
11333 static int G__G__GeomBuilder_301_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11334 {
11335 ((TGeoTorusEditor*) G__getstructoffset())->DoModified();
11336 G__setnull(result7);
11337 return(1 || funcname || hash || result7 || libp) ;
11338 }
11339
11340 static int G__G__GeomBuilder_301_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11341 {
11342 ((TGeoTorusEditor*) G__getstructoffset())->DoName();
11343 G__setnull(result7);
11344 return(1 || funcname || hash || result7 || libp) ;
11345 }
11346
11347 static int G__G__GeomBuilder_301_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11348 {
11349 ((TGeoTorusEditor*) G__getstructoffset())->DoApply();
11350 G__setnull(result7);
11351 return(1 || funcname || hash || result7 || libp) ;
11352 }
11353
11354 static int G__G__GeomBuilder_301_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11355 {
11356 ((TGeoTorusEditor*) G__getstructoffset())->DoUndo();
11357 G__setnull(result7);
11358 return(1 || funcname || hash || result7 || libp) ;
11359 }
11360
11361 static int G__G__GeomBuilder_301_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11362 {
11363 G__letint(result7, 85, (long) TGeoTorusEditor::Class());
11364 return(1 || funcname || hash || result7 || libp) ;
11365 }
11366
11367 static int G__G__GeomBuilder_301_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11368 {
11369 G__letint(result7, 67, (long) TGeoTorusEditor::Class_Name());
11370 return(1 || funcname || hash || result7 || libp) ;
11371 }
11372
11373 static int G__G__GeomBuilder_301_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11374 {
11375 G__letint(result7, 115, (long) TGeoTorusEditor::Class_Version());
11376 return(1 || funcname || hash || result7 || libp) ;
11377 }
11378
11379 static int G__G__GeomBuilder_301_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11380 {
11381 TGeoTorusEditor::Dictionary();
11382 G__setnull(result7);
11383 return(1 || funcname || hash || result7 || libp) ;
11384 }
11385
11386 static int G__G__GeomBuilder_301_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11387 {
11388 ((TGeoTorusEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11389 G__setnull(result7);
11390 return(1 || funcname || hash || result7 || libp) ;
11391 }
11392
11393 static int G__G__GeomBuilder_301_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11394 {
11395 G__letint(result7, 67, (long) TGeoTorusEditor::DeclFileName());
11396 return(1 || funcname || hash || result7 || libp) ;
11397 }
11398
11399 static int G__G__GeomBuilder_301_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11400 {
11401 G__letint(result7, 105, (long) TGeoTorusEditor::ImplFileLine());
11402 return(1 || funcname || hash || result7 || libp) ;
11403 }
11404
11405 static int G__G__GeomBuilder_301_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11406 {
11407 G__letint(result7, 67, (long) TGeoTorusEditor::ImplFileName());
11408 return(1 || funcname || hash || result7 || libp) ;
11409 }
11410
11411 static int G__G__GeomBuilder_301_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11412 {
11413 G__letint(result7, 105, (long) TGeoTorusEditor::DeclFileLine());
11414 return(1 || funcname || hash || result7 || libp) ;
11415 }
11416
11417
11418 typedef TGeoTorusEditor G__TTGeoTorusEditor;
11419 static int G__G__GeomBuilder_301_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11420 {
11421 char* gvp = (char*) G__getgvp();
11422 long soff = G__getstructoffset();
11423 int n = G__getaryconstruct();
11424
11425
11426
11427
11428
11429 if (!soff) {
11430 return(1);
11431 }
11432 if (n) {
11433 if (gvp == (char*)G__PVOID) {
11434 delete[] (TGeoTorusEditor*) soff;
11435 } else {
11436 G__setgvp((long) G__PVOID);
11437 for (int i = n - 1; i >= 0; --i) {
11438 ((TGeoTorusEditor*) (soff+(sizeof(TGeoTorusEditor)*i)))->~G__TTGeoTorusEditor();
11439 }
11440 G__setgvp((long)gvp);
11441 }
11442 } else {
11443 if (gvp == (char*)G__PVOID) {
11444 delete (TGeoTorusEditor*) soff;
11445 } else {
11446 G__setgvp((long) G__PVOID);
11447 ((TGeoTorusEditor*) (soff))->~G__TTGeoTorusEditor();
11448 G__setgvp((long)gvp);
11449 }
11450 }
11451 G__setnull(result7);
11452 return(1 || funcname || hash || result7 || libp) ;
11453 }
11454
11455
11456
11457 static int G__G__GeomBuilder_303_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11458 {
11459 TGeoEltuEditor* p = NULL;
11460 char* gvp = (char*) G__getgvp();
11461 switch (libp->paran) {
11462 case 5:
11463
11464 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11465 p = new TGeoEltuEditor(
11466 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11467 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
11468 , (Pixel_t) G__int(libp->para[4]));
11469 } else {
11470 p = new((void*) gvp) TGeoEltuEditor(
11471 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11472 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
11473 , (Pixel_t) G__int(libp->para[4]));
11474 }
11475 break;
11476 case 4:
11477
11478 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11479 p = new TGeoEltuEditor(
11480 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11481 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11482 } else {
11483 p = new((void*) gvp) TGeoEltuEditor(
11484 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11485 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11486 }
11487 break;
11488 case 3:
11489
11490 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11491 p = new TGeoEltuEditor(
11492 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11493 , (Int_t) G__int(libp->para[2]));
11494 } else {
11495 p = new((void*) gvp) TGeoEltuEditor(
11496 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11497 , (Int_t) G__int(libp->para[2]));
11498 }
11499 break;
11500 case 2:
11501
11502 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11503 p = new TGeoEltuEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11504 } else {
11505 p = new((void*) gvp) TGeoEltuEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11506 }
11507 break;
11508 case 1:
11509
11510 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11511 p = new TGeoEltuEditor((TGWindow*) G__int(libp->para[0]));
11512 } else {
11513 p = new((void*) gvp) TGeoEltuEditor((TGWindow*) G__int(libp->para[0]));
11514 }
11515 break;
11516 case 0:
11517 int n = G__getaryconstruct();
11518 if (n) {
11519 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11520 p = new TGeoEltuEditor[n];
11521 } else {
11522 p = new((void*) gvp) TGeoEltuEditor[n];
11523 }
11524 } else {
11525 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11526 p = new TGeoEltuEditor;
11527 } else {
11528 p = new((void*) gvp) TGeoEltuEditor;
11529 }
11530 }
11531 break;
11532 }
11533 result7->obj.i = (long) p;
11534 result7->ref = (long) p;
11535 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor));
11536 return(1 || funcname || hash || result7 || libp) ;
11537 }
11538
11539 static int G__G__GeomBuilder_303_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11540 {
11541 ((TGeoEltuEditor*) G__getstructoffset())->DoA();
11542 G__setnull(result7);
11543 return(1 || funcname || hash || result7 || libp) ;
11544 }
11545
11546 static int G__G__GeomBuilder_303_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11547 {
11548 ((TGeoEltuEditor*) G__getstructoffset())->DoB();
11549 G__setnull(result7);
11550 return(1 || funcname || hash || result7 || libp) ;
11551 }
11552
11553 static int G__G__GeomBuilder_303_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11554 {
11555 ((TGeoEltuEditor*) G__getstructoffset())->DoDz();
11556 G__setnull(result7);
11557 return(1 || funcname || hash || result7 || libp) ;
11558 }
11559
11560 static int G__G__GeomBuilder_303_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11561 {
11562 ((TGeoEltuEditor*) G__getstructoffset())->DoModified();
11563 G__setnull(result7);
11564 return(1 || funcname || hash || result7 || libp) ;
11565 }
11566
11567 static int G__G__GeomBuilder_303_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11568 {
11569 ((TGeoEltuEditor*) G__getstructoffset())->DoName();
11570 G__setnull(result7);
11571 return(1 || funcname || hash || result7 || libp) ;
11572 }
11573
11574 static int G__G__GeomBuilder_303_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11575 {
11576 ((TGeoEltuEditor*) G__getstructoffset())->DoApply();
11577 G__setnull(result7);
11578 return(1 || funcname || hash || result7 || libp) ;
11579 }
11580
11581 static int G__G__GeomBuilder_303_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11582 {
11583 ((TGeoEltuEditor*) G__getstructoffset())->DoUndo();
11584 G__setnull(result7);
11585 return(1 || funcname || hash || result7 || libp) ;
11586 }
11587
11588 static int G__G__GeomBuilder_303_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11589 {
11590 G__letint(result7, 85, (long) TGeoEltuEditor::Class());
11591 return(1 || funcname || hash || result7 || libp) ;
11592 }
11593
11594 static int G__G__GeomBuilder_303_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11595 {
11596 G__letint(result7, 67, (long) TGeoEltuEditor::Class_Name());
11597 return(1 || funcname || hash || result7 || libp) ;
11598 }
11599
11600 static int G__G__GeomBuilder_303_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11601 {
11602 G__letint(result7, 115, (long) TGeoEltuEditor::Class_Version());
11603 return(1 || funcname || hash || result7 || libp) ;
11604 }
11605
11606 static int G__G__GeomBuilder_303_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11607 {
11608 TGeoEltuEditor::Dictionary();
11609 G__setnull(result7);
11610 return(1 || funcname || hash || result7 || libp) ;
11611 }
11612
11613 static int G__G__GeomBuilder_303_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11614 {
11615 ((TGeoEltuEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11616 G__setnull(result7);
11617 return(1 || funcname || hash || result7 || libp) ;
11618 }
11619
11620 static int G__G__GeomBuilder_303_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11621 {
11622 G__letint(result7, 67, (long) TGeoEltuEditor::DeclFileName());
11623 return(1 || funcname || hash || result7 || libp) ;
11624 }
11625
11626 static int G__G__GeomBuilder_303_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11627 {
11628 G__letint(result7, 105, (long) TGeoEltuEditor::ImplFileLine());
11629 return(1 || funcname || hash || result7 || libp) ;
11630 }
11631
11632 static int G__G__GeomBuilder_303_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11633 {
11634 G__letint(result7, 67, (long) TGeoEltuEditor::ImplFileName());
11635 return(1 || funcname || hash || result7 || libp) ;
11636 }
11637
11638 static int G__G__GeomBuilder_303_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11639 {
11640 G__letint(result7, 105, (long) TGeoEltuEditor::DeclFileLine());
11641 return(1 || funcname || hash || result7 || libp) ;
11642 }
11643
11644
11645 typedef TGeoEltuEditor G__TTGeoEltuEditor;
11646 static int G__G__GeomBuilder_303_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11647 {
11648 char* gvp = (char*) G__getgvp();
11649 long soff = G__getstructoffset();
11650 int n = G__getaryconstruct();
11651
11652
11653
11654
11655
11656 if (!soff) {
11657 return(1);
11658 }
11659 if (n) {
11660 if (gvp == (char*)G__PVOID) {
11661 delete[] (TGeoEltuEditor*) soff;
11662 } else {
11663 G__setgvp((long) G__PVOID);
11664 for (int i = n - 1; i >= 0; --i) {
11665 ((TGeoEltuEditor*) (soff+(sizeof(TGeoEltuEditor)*i)))->~G__TTGeoEltuEditor();
11666 }
11667 G__setgvp((long)gvp);
11668 }
11669 } else {
11670 if (gvp == (char*)G__PVOID) {
11671 delete (TGeoEltuEditor*) soff;
11672 } else {
11673 G__setgvp((long) G__PVOID);
11674 ((TGeoEltuEditor*) (soff))->~G__TTGeoEltuEditor();
11675 G__setgvp((long)gvp);
11676 }
11677 }
11678 G__setnull(result7);
11679 return(1 || funcname || hash || result7 || libp) ;
11680 }
11681
11682
11683
11684 static int G__G__GeomBuilder_305_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11685 {
11686 TGeoHypeEditor* p = NULL;
11687 char* gvp = (char*) G__getgvp();
11688 switch (libp->paran) {
11689 case 5:
11690
11691 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11692 p = new TGeoHypeEditor(
11693 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11694 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
11695 , (Pixel_t) G__int(libp->para[4]));
11696 } else {
11697 p = new((void*) gvp) TGeoHypeEditor(
11698 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11699 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
11700 , (Pixel_t) G__int(libp->para[4]));
11701 }
11702 break;
11703 case 4:
11704
11705 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11706 p = new TGeoHypeEditor(
11707 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11708 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11709 } else {
11710 p = new((void*) gvp) TGeoHypeEditor(
11711 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11712 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11713 }
11714 break;
11715 case 3:
11716
11717 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11718 p = new TGeoHypeEditor(
11719 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11720 , (Int_t) G__int(libp->para[2]));
11721 } else {
11722 p = new((void*) gvp) TGeoHypeEditor(
11723 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11724 , (Int_t) G__int(libp->para[2]));
11725 }
11726 break;
11727 case 2:
11728
11729 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11730 p = new TGeoHypeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11731 } else {
11732 p = new((void*) gvp) TGeoHypeEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11733 }
11734 break;
11735 case 1:
11736
11737 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11738 p = new TGeoHypeEditor((TGWindow*) G__int(libp->para[0]));
11739 } else {
11740 p = new((void*) gvp) TGeoHypeEditor((TGWindow*) G__int(libp->para[0]));
11741 }
11742 break;
11743 case 0:
11744 int n = G__getaryconstruct();
11745 if (n) {
11746 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11747 p = new TGeoHypeEditor[n];
11748 } else {
11749 p = new((void*) gvp) TGeoHypeEditor[n];
11750 }
11751 } else {
11752 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11753 p = new TGeoHypeEditor;
11754 } else {
11755 p = new((void*) gvp) TGeoHypeEditor;
11756 }
11757 }
11758 break;
11759 }
11760 result7->obj.i = (long) p;
11761 result7->ref = (long) p;
11762 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor));
11763 return(1 || funcname || hash || result7 || libp) ;
11764 }
11765
11766 static int G__G__GeomBuilder_305_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11767 {
11768 ((TGeoHypeEditor*) G__getstructoffset())->DoRin();
11769 G__setnull(result7);
11770 return(1 || funcname || hash || result7 || libp) ;
11771 }
11772
11773 static int G__G__GeomBuilder_305_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11774 {
11775 ((TGeoHypeEditor*) G__getstructoffset())->DoRout();
11776 G__setnull(result7);
11777 return(1 || funcname || hash || result7 || libp) ;
11778 }
11779
11780 static int G__G__GeomBuilder_305_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11781 {
11782 ((TGeoHypeEditor*) G__getstructoffset())->DoDz();
11783 G__setnull(result7);
11784 return(1 || funcname || hash || result7 || libp) ;
11785 }
11786
11787 static int G__G__GeomBuilder_305_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11788 {
11789 ((TGeoHypeEditor*) G__getstructoffset())->DoStIn();
11790 G__setnull(result7);
11791 return(1 || funcname || hash || result7 || libp) ;
11792 }
11793
11794 static int G__G__GeomBuilder_305_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11795 {
11796 ((TGeoHypeEditor*) G__getstructoffset())->DoStOut();
11797 G__setnull(result7);
11798 return(1 || funcname || hash || result7 || libp) ;
11799 }
11800
11801 static int G__G__GeomBuilder_305_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11802 {
11803 ((TGeoHypeEditor*) G__getstructoffset())->DoModified();
11804 G__setnull(result7);
11805 return(1 || funcname || hash || result7 || libp) ;
11806 }
11807
11808 static int G__G__GeomBuilder_305_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11809 {
11810 ((TGeoHypeEditor*) G__getstructoffset())->DoName();
11811 G__setnull(result7);
11812 return(1 || funcname || hash || result7 || libp) ;
11813 }
11814
11815 static int G__G__GeomBuilder_305_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11816 {
11817 ((TGeoHypeEditor*) G__getstructoffset())->DoApply();
11818 G__setnull(result7);
11819 return(1 || funcname || hash || result7 || libp) ;
11820 }
11821
11822 static int G__G__GeomBuilder_305_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11823 {
11824 ((TGeoHypeEditor*) G__getstructoffset())->DoUndo();
11825 G__setnull(result7);
11826 return(1 || funcname || hash || result7 || libp) ;
11827 }
11828
11829 static int G__G__GeomBuilder_305_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11830 {
11831 G__letint(result7, 85, (long) TGeoHypeEditor::Class());
11832 return(1 || funcname || hash || result7 || libp) ;
11833 }
11834
11835 static int G__G__GeomBuilder_305_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11836 {
11837 G__letint(result7, 67, (long) TGeoHypeEditor::Class_Name());
11838 return(1 || funcname || hash || result7 || libp) ;
11839 }
11840
11841 static int G__G__GeomBuilder_305_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11842 {
11843 G__letint(result7, 115, (long) TGeoHypeEditor::Class_Version());
11844 return(1 || funcname || hash || result7 || libp) ;
11845 }
11846
11847 static int G__G__GeomBuilder_305_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11848 {
11849 TGeoHypeEditor::Dictionary();
11850 G__setnull(result7);
11851 return(1 || funcname || hash || result7 || libp) ;
11852 }
11853
11854 static int G__G__GeomBuilder_305_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11855 {
11856 ((TGeoHypeEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11857 G__setnull(result7);
11858 return(1 || funcname || hash || result7 || libp) ;
11859 }
11860
11861 static int G__G__GeomBuilder_305_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11862 {
11863 G__letint(result7, 67, (long) TGeoHypeEditor::DeclFileName());
11864 return(1 || funcname || hash || result7 || libp) ;
11865 }
11866
11867 static int G__G__GeomBuilder_305_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11868 {
11869 G__letint(result7, 105, (long) TGeoHypeEditor::ImplFileLine());
11870 return(1 || funcname || hash || result7 || libp) ;
11871 }
11872
11873 static int G__G__GeomBuilder_305_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11874 {
11875 G__letint(result7, 67, (long) TGeoHypeEditor::ImplFileName());
11876 return(1 || funcname || hash || result7 || libp) ;
11877 }
11878
11879 static int G__G__GeomBuilder_305_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11880 {
11881 G__letint(result7, 105, (long) TGeoHypeEditor::DeclFileLine());
11882 return(1 || funcname || hash || result7 || libp) ;
11883 }
11884
11885
11886 typedef TGeoHypeEditor G__TTGeoHypeEditor;
11887 static int G__G__GeomBuilder_305_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11888 {
11889 char* gvp = (char*) G__getgvp();
11890 long soff = G__getstructoffset();
11891 int n = G__getaryconstruct();
11892
11893
11894
11895
11896
11897 if (!soff) {
11898 return(1);
11899 }
11900 if (n) {
11901 if (gvp == (char*)G__PVOID) {
11902 delete[] (TGeoHypeEditor*) soff;
11903 } else {
11904 G__setgvp((long) G__PVOID);
11905 for (int i = n - 1; i >= 0; --i) {
11906 ((TGeoHypeEditor*) (soff+(sizeof(TGeoHypeEditor)*i)))->~G__TTGeoHypeEditor();
11907 }
11908 G__setgvp((long)gvp);
11909 }
11910 } else {
11911 if (gvp == (char*)G__PVOID) {
11912 delete (TGeoHypeEditor*) soff;
11913 } else {
11914 G__setgvp((long) G__PVOID);
11915 ((TGeoHypeEditor*) (soff))->~G__TTGeoHypeEditor();
11916 G__setgvp((long)gvp);
11917 }
11918 }
11919 G__setnull(result7);
11920 return(1 || funcname || hash || result7 || libp) ;
11921 }
11922
11923
11924
11925 static int G__G__GeomBuilder_306_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11926 {
11927 TGeoPgonEditor* p = NULL;
11928 char* gvp = (char*) G__getgvp();
11929 switch (libp->paran) {
11930 case 5:
11931
11932 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11933 p = new TGeoPgonEditor(
11934 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11935 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
11936 , (Pixel_t) G__int(libp->para[4]));
11937 } else {
11938 p = new((void*) gvp) TGeoPgonEditor(
11939 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11940 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
11941 , (Pixel_t) G__int(libp->para[4]));
11942 }
11943 break;
11944 case 4:
11945
11946 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11947 p = new TGeoPgonEditor(
11948 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11949 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11950 } else {
11951 p = new((void*) gvp) TGeoPgonEditor(
11952 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11953 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
11954 }
11955 break;
11956 case 3:
11957
11958 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11959 p = new TGeoPgonEditor(
11960 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11961 , (Int_t) G__int(libp->para[2]));
11962 } else {
11963 p = new((void*) gvp) TGeoPgonEditor(
11964 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
11965 , (Int_t) G__int(libp->para[2]));
11966 }
11967 break;
11968 case 2:
11969
11970 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11971 p = new TGeoPgonEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11972 } else {
11973 p = new((void*) gvp) TGeoPgonEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11974 }
11975 break;
11976 case 1:
11977
11978 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11979 p = new TGeoPgonEditor((TGWindow*) G__int(libp->para[0]));
11980 } else {
11981 p = new((void*) gvp) TGeoPgonEditor((TGWindow*) G__int(libp->para[0]));
11982 }
11983 break;
11984 case 0:
11985 int n = G__getaryconstruct();
11986 if (n) {
11987 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11988 p = new TGeoPgonEditor[n];
11989 } else {
11990 p = new((void*) gvp) TGeoPgonEditor[n];
11991 }
11992 } else {
11993 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11994 p = new TGeoPgonEditor;
11995 } else {
11996 p = new((void*) gvp) TGeoPgonEditor;
11997 }
11998 }
11999 break;
12000 }
12001 result7->obj.i = (long) p;
12002 result7->ref = (long) p;
12003 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor));
12004 return(1 || funcname || hash || result7 || libp) ;
12005 }
12006
12007 static int G__G__GeomBuilder_306_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12008 {
12009 ((TGeoPgonEditor*) G__getstructoffset())->DoNedges();
12010 G__setnull(result7);
12011 return(1 || funcname || hash || result7 || libp) ;
12012 }
12013
12014 static int G__G__GeomBuilder_306_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12015 {
12016 G__letint(result7, 85, (long) TGeoPgonEditor::Class());
12017 return(1 || funcname || hash || result7 || libp) ;
12018 }
12019
12020 static int G__G__GeomBuilder_306_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12021 {
12022 G__letint(result7, 67, (long) TGeoPgonEditor::Class_Name());
12023 return(1 || funcname || hash || result7 || libp) ;
12024 }
12025
12026 static int G__G__GeomBuilder_306_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12027 {
12028 G__letint(result7, 115, (long) TGeoPgonEditor::Class_Version());
12029 return(1 || funcname || hash || result7 || libp) ;
12030 }
12031
12032 static int G__G__GeomBuilder_306_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12033 {
12034 TGeoPgonEditor::Dictionary();
12035 G__setnull(result7);
12036 return(1 || funcname || hash || result7 || libp) ;
12037 }
12038
12039 static int G__G__GeomBuilder_306_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12040 {
12041 ((TGeoPgonEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12042 G__setnull(result7);
12043 return(1 || funcname || hash || result7 || libp) ;
12044 }
12045
12046 static int G__G__GeomBuilder_306_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12047 {
12048 G__letint(result7, 67, (long) TGeoPgonEditor::DeclFileName());
12049 return(1 || funcname || hash || result7 || libp) ;
12050 }
12051
12052 static int G__G__GeomBuilder_306_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12053 {
12054 G__letint(result7, 105, (long) TGeoPgonEditor::ImplFileLine());
12055 return(1 || funcname || hash || result7 || libp) ;
12056 }
12057
12058 static int G__G__GeomBuilder_306_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12059 {
12060 G__letint(result7, 67, (long) TGeoPgonEditor::ImplFileName());
12061 return(1 || funcname || hash || result7 || libp) ;
12062 }
12063
12064 static int G__G__GeomBuilder_306_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12065 {
12066 G__letint(result7, 105, (long) TGeoPgonEditor::DeclFileLine());
12067 return(1 || funcname || hash || result7 || libp) ;
12068 }
12069
12070
12071 typedef TGeoPgonEditor G__TTGeoPgonEditor;
12072 static int G__G__GeomBuilder_306_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12073 {
12074 char* gvp = (char*) G__getgvp();
12075 long soff = G__getstructoffset();
12076 int n = G__getaryconstruct();
12077
12078
12079
12080
12081
12082 if (!soff) {
12083 return(1);
12084 }
12085 if (n) {
12086 if (gvp == (char*)G__PVOID) {
12087 delete[] (TGeoPgonEditor*) soff;
12088 } else {
12089 G__setgvp((long) G__PVOID);
12090 for (int i = n - 1; i >= 0; --i) {
12091 ((TGeoPgonEditor*) (soff+(sizeof(TGeoPgonEditor)*i)))->~G__TTGeoPgonEditor();
12092 }
12093 G__setgvp((long)gvp);
12094 }
12095 } else {
12096 if (gvp == (char*)G__PVOID) {
12097 delete (TGeoPgonEditor*) soff;
12098 } else {
12099 G__setgvp((long) G__PVOID);
12100 ((TGeoPgonEditor*) (soff))->~G__TTGeoPgonEditor();
12101 G__setgvp((long)gvp);
12102 }
12103 }
12104 G__setnull(result7);
12105 return(1 || funcname || hash || result7 || libp) ;
12106 }
12107
12108
12109
12110 static int G__G__GeomBuilder_308_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12111 {
12112 TGeoTrapEditor* p = NULL;
12113 char* gvp = (char*) G__getgvp();
12114 switch (libp->paran) {
12115 case 5:
12116
12117 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12118 p = new TGeoTrapEditor(
12119 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12120 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
12121 , (Pixel_t) G__int(libp->para[4]));
12122 } else {
12123 p = new((void*) gvp) TGeoTrapEditor(
12124 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12125 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
12126 , (Pixel_t) G__int(libp->para[4]));
12127 }
12128 break;
12129 case 4:
12130
12131 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12132 p = new TGeoTrapEditor(
12133 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12134 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
12135 } else {
12136 p = new((void*) gvp) TGeoTrapEditor(
12137 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12138 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
12139 }
12140 break;
12141 case 3:
12142
12143 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12144 p = new TGeoTrapEditor(
12145 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12146 , (Int_t) G__int(libp->para[2]));
12147 } else {
12148 p = new((void*) gvp) TGeoTrapEditor(
12149 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12150 , (Int_t) G__int(libp->para[2]));
12151 }
12152 break;
12153 case 2:
12154
12155 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12156 p = new TGeoTrapEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
12157 } else {
12158 p = new((void*) gvp) TGeoTrapEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
12159 }
12160 break;
12161 case 1:
12162
12163 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12164 p = new TGeoTrapEditor((TGWindow*) G__int(libp->para[0]));
12165 } else {
12166 p = new((void*) gvp) TGeoTrapEditor((TGWindow*) G__int(libp->para[0]));
12167 }
12168 break;
12169 case 0:
12170 int n = G__getaryconstruct();
12171 if (n) {
12172 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12173 p = new TGeoTrapEditor[n];
12174 } else {
12175 p = new((void*) gvp) TGeoTrapEditor[n];
12176 }
12177 } else {
12178 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12179 p = new TGeoTrapEditor;
12180 } else {
12181 p = new((void*) gvp) TGeoTrapEditor;
12182 }
12183 }
12184 break;
12185 }
12186 result7->obj.i = (long) p;
12187 result7->ref = (long) p;
12188 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor));
12189 return(1 || funcname || hash || result7 || libp) ;
12190 }
12191
12192 static int G__G__GeomBuilder_308_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12193 {
12194 ((TGeoTrapEditor*) G__getstructoffset())->DoH1();
12195 G__setnull(result7);
12196 return(1 || funcname || hash || result7 || libp) ;
12197 }
12198
12199 static int G__G__GeomBuilder_308_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12200 {
12201 ((TGeoTrapEditor*) G__getstructoffset())->DoBl1();
12202 G__setnull(result7);
12203 return(1 || funcname || hash || result7 || libp) ;
12204 }
12205
12206 static int G__G__GeomBuilder_308_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12207 {
12208 ((TGeoTrapEditor*) G__getstructoffset())->DoTl1();
12209 G__setnull(result7);
12210 return(1 || funcname || hash || result7 || libp) ;
12211 }
12212
12213 static int G__G__GeomBuilder_308_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12214 {
12215 ((TGeoTrapEditor*) G__getstructoffset())->DoDz();
12216 G__setnull(result7);
12217 return(1 || funcname || hash || result7 || libp) ;
12218 }
12219
12220 static int G__G__GeomBuilder_308_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12221 {
12222 ((TGeoTrapEditor*) G__getstructoffset())->DoSc1();
12223 G__setnull(result7);
12224 return(1 || funcname || hash || result7 || libp) ;
12225 }
12226
12227 static int G__G__GeomBuilder_308_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12228 {
12229 ((TGeoTrapEditor*) G__getstructoffset())->DoSc2();
12230 G__setnull(result7);
12231 return(1 || funcname || hash || result7 || libp) ;
12232 }
12233
12234 static int G__G__GeomBuilder_308_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12235 {
12236 ((TGeoTrapEditor*) G__getstructoffset())->DoAlpha1();
12237 G__setnull(result7);
12238 return(1 || funcname || hash || result7 || libp) ;
12239 }
12240
12241 static int G__G__GeomBuilder_308_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12242 {
12243 ((TGeoTrapEditor*) G__getstructoffset())->DoTheta();
12244 G__setnull(result7);
12245 return(1 || funcname || hash || result7 || libp) ;
12246 }
12247
12248 static int G__G__GeomBuilder_308_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12249 {
12250 ((TGeoTrapEditor*) G__getstructoffset())->DoPhi();
12251 G__setnull(result7);
12252 return(1 || funcname || hash || result7 || libp) ;
12253 }
12254
12255 static int G__G__GeomBuilder_308_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12256 {
12257 ((TGeoTrapEditor*) G__getstructoffset())->DoModified();
12258 G__setnull(result7);
12259 return(1 || funcname || hash || result7 || libp) ;
12260 }
12261
12262 static int G__G__GeomBuilder_308_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12263 {
12264 ((TGeoTrapEditor*) G__getstructoffset())->DoName();
12265 G__setnull(result7);
12266 return(1 || funcname || hash || result7 || libp) ;
12267 }
12268
12269 static int G__G__GeomBuilder_308_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12270 {
12271 ((TGeoTrapEditor*) G__getstructoffset())->DoApply();
12272 G__setnull(result7);
12273 return(1 || funcname || hash || result7 || libp) ;
12274 }
12275
12276 static int G__G__GeomBuilder_308_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12277 {
12278 ((TGeoTrapEditor*) G__getstructoffset())->DoUndo();
12279 G__setnull(result7);
12280 return(1 || funcname || hash || result7 || libp) ;
12281 }
12282
12283 static int G__G__GeomBuilder_308_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12284 {
12285 G__letint(result7, 85, (long) TGeoTrapEditor::Class());
12286 return(1 || funcname || hash || result7 || libp) ;
12287 }
12288
12289 static int G__G__GeomBuilder_308_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12290 {
12291 G__letint(result7, 67, (long) TGeoTrapEditor::Class_Name());
12292 return(1 || funcname || hash || result7 || libp) ;
12293 }
12294
12295 static int G__G__GeomBuilder_308_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12296 {
12297 G__letint(result7, 115, (long) TGeoTrapEditor::Class_Version());
12298 return(1 || funcname || hash || result7 || libp) ;
12299 }
12300
12301 static int G__G__GeomBuilder_308_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12302 {
12303 TGeoTrapEditor::Dictionary();
12304 G__setnull(result7);
12305 return(1 || funcname || hash || result7 || libp) ;
12306 }
12307
12308 static int G__G__GeomBuilder_308_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12309 {
12310 ((TGeoTrapEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12311 G__setnull(result7);
12312 return(1 || funcname || hash || result7 || libp) ;
12313 }
12314
12315 static int G__G__GeomBuilder_308_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12316 {
12317 G__letint(result7, 67, (long) TGeoTrapEditor::DeclFileName());
12318 return(1 || funcname || hash || result7 || libp) ;
12319 }
12320
12321 static int G__G__GeomBuilder_308_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12322 {
12323 G__letint(result7, 105, (long) TGeoTrapEditor::ImplFileLine());
12324 return(1 || funcname || hash || result7 || libp) ;
12325 }
12326
12327 static int G__G__GeomBuilder_308_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12328 {
12329 G__letint(result7, 67, (long) TGeoTrapEditor::ImplFileName());
12330 return(1 || funcname || hash || result7 || libp) ;
12331 }
12332
12333 static int G__G__GeomBuilder_308_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12334 {
12335 G__letint(result7, 105, (long) TGeoTrapEditor::DeclFileLine());
12336 return(1 || funcname || hash || result7 || libp) ;
12337 }
12338
12339
12340 typedef TGeoTrapEditor G__TTGeoTrapEditor;
12341 static int G__G__GeomBuilder_308_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12342 {
12343 char* gvp = (char*) G__getgvp();
12344 long soff = G__getstructoffset();
12345 int n = G__getaryconstruct();
12346
12347
12348
12349
12350
12351 if (!soff) {
12352 return(1);
12353 }
12354 if (n) {
12355 if (gvp == (char*)G__PVOID) {
12356 delete[] (TGeoTrapEditor*) soff;
12357 } else {
12358 G__setgvp((long) G__PVOID);
12359 for (int i = n - 1; i >= 0; --i) {
12360 ((TGeoTrapEditor*) (soff+(sizeof(TGeoTrapEditor)*i)))->~G__TTGeoTrapEditor();
12361 }
12362 G__setgvp((long)gvp);
12363 }
12364 } else {
12365 if (gvp == (char*)G__PVOID) {
12366 delete (TGeoTrapEditor*) soff;
12367 } else {
12368 G__setgvp((long) G__PVOID);
12369 ((TGeoTrapEditor*) (soff))->~G__TTGeoTrapEditor();
12370 G__setgvp((long)gvp);
12371 }
12372 }
12373 G__setnull(result7);
12374 return(1 || funcname || hash || result7 || libp) ;
12375 }
12376
12377
12378
12379 static int G__G__GeomBuilder_309_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12380 {
12381 TGeoGtraEditor* p = NULL;
12382 char* gvp = (char*) G__getgvp();
12383 switch (libp->paran) {
12384 case 5:
12385
12386 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12387 p = new TGeoGtraEditor(
12388 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12389 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
12390 , (Pixel_t) G__int(libp->para[4]));
12391 } else {
12392 p = new((void*) gvp) TGeoGtraEditor(
12393 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12394 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
12395 , (Pixel_t) G__int(libp->para[4]));
12396 }
12397 break;
12398 case 4:
12399
12400 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12401 p = new TGeoGtraEditor(
12402 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12403 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
12404 } else {
12405 p = new((void*) gvp) TGeoGtraEditor(
12406 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12407 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
12408 }
12409 break;
12410 case 3:
12411
12412 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12413 p = new TGeoGtraEditor(
12414 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12415 , (Int_t) G__int(libp->para[2]));
12416 } else {
12417 p = new((void*) gvp) TGeoGtraEditor(
12418 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12419 , (Int_t) G__int(libp->para[2]));
12420 }
12421 break;
12422 case 2:
12423
12424 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12425 p = new TGeoGtraEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
12426 } else {
12427 p = new((void*) gvp) TGeoGtraEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
12428 }
12429 break;
12430 case 1:
12431
12432 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12433 p = new TGeoGtraEditor((TGWindow*) G__int(libp->para[0]));
12434 } else {
12435 p = new((void*) gvp) TGeoGtraEditor((TGWindow*) G__int(libp->para[0]));
12436 }
12437 break;
12438 case 0:
12439 int n = G__getaryconstruct();
12440 if (n) {
12441 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12442 p = new TGeoGtraEditor[n];
12443 } else {
12444 p = new((void*) gvp) TGeoGtraEditor[n];
12445 }
12446 } else {
12447 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12448 p = new TGeoGtraEditor;
12449 } else {
12450 p = new((void*) gvp) TGeoGtraEditor;
12451 }
12452 }
12453 break;
12454 }
12455 result7->obj.i = (long) p;
12456 result7->ref = (long) p;
12457 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor));
12458 return(1 || funcname || hash || result7 || libp) ;
12459 }
12460
12461 static int G__G__GeomBuilder_309_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12462 {
12463 ((TGeoGtraEditor*) G__getstructoffset())->DoTwist();
12464 G__setnull(result7);
12465 return(1 || funcname || hash || result7 || libp) ;
12466 }
12467
12468 static int G__G__GeomBuilder_309_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12469 {
12470 G__letint(result7, 85, (long) TGeoGtraEditor::Class());
12471 return(1 || funcname || hash || result7 || libp) ;
12472 }
12473
12474 static int G__G__GeomBuilder_309_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12475 {
12476 G__letint(result7, 67, (long) TGeoGtraEditor::Class_Name());
12477 return(1 || funcname || hash || result7 || libp) ;
12478 }
12479
12480 static int G__G__GeomBuilder_309_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12481 {
12482 G__letint(result7, 115, (long) TGeoGtraEditor::Class_Version());
12483 return(1 || funcname || hash || result7 || libp) ;
12484 }
12485
12486 static int G__G__GeomBuilder_309_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12487 {
12488 TGeoGtraEditor::Dictionary();
12489 G__setnull(result7);
12490 return(1 || funcname || hash || result7 || libp) ;
12491 }
12492
12493 static int G__G__GeomBuilder_309_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12494 {
12495 ((TGeoGtraEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12496 G__setnull(result7);
12497 return(1 || funcname || hash || result7 || libp) ;
12498 }
12499
12500 static int G__G__GeomBuilder_309_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12501 {
12502 G__letint(result7, 67, (long) TGeoGtraEditor::DeclFileName());
12503 return(1 || funcname || hash || result7 || libp) ;
12504 }
12505
12506 static int G__G__GeomBuilder_309_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12507 {
12508 G__letint(result7, 105, (long) TGeoGtraEditor::ImplFileLine());
12509 return(1 || funcname || hash || result7 || libp) ;
12510 }
12511
12512 static int G__G__GeomBuilder_309_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12513 {
12514 G__letint(result7, 67, (long) TGeoGtraEditor::ImplFileName());
12515 return(1 || funcname || hash || result7 || libp) ;
12516 }
12517
12518 static int G__G__GeomBuilder_309_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12519 {
12520 G__letint(result7, 105, (long) TGeoGtraEditor::DeclFileLine());
12521 return(1 || funcname || hash || result7 || libp) ;
12522 }
12523
12524
12525 typedef TGeoGtraEditor G__TTGeoGtraEditor;
12526 static int G__G__GeomBuilder_309_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12527 {
12528 char* gvp = (char*) G__getgvp();
12529 long soff = G__getstructoffset();
12530 int n = G__getaryconstruct();
12531
12532
12533
12534
12535
12536 if (!soff) {
12537 return(1);
12538 }
12539 if (n) {
12540 if (gvp == (char*)G__PVOID) {
12541 delete[] (TGeoGtraEditor*) soff;
12542 } else {
12543 G__setgvp((long) G__PVOID);
12544 for (int i = n - 1; i >= 0; --i) {
12545 ((TGeoGtraEditor*) (soff+(sizeof(TGeoGtraEditor)*i)))->~G__TTGeoGtraEditor();
12546 }
12547 G__setgvp((long)gvp);
12548 }
12549 } else {
12550 if (gvp == (char*)G__PVOID) {
12551 delete (TGeoGtraEditor*) soff;
12552 } else {
12553 G__setgvp((long) G__PVOID);
12554 ((TGeoGtraEditor*) (soff))->~G__TTGeoGtraEditor();
12555 G__setgvp((long)gvp);
12556 }
12557 }
12558 G__setnull(result7);
12559 return(1 || funcname || hash || result7 || libp) ;
12560 }
12561
12562
12563
12564
12565
12566
12567
12568
12569
12570
12571
12572
12573
12574
12575
12576
12577
12578
12579
12580
12581
12582
12583
12584
12585
12586
12587
12588
12589
12590
12591
12592
12593
12594
12595
12596
12597
12598
12599
12600
12601
12602
12603
12604
12605
12606
12607
12608
12609
12610
12611
12612
12613
12614
12615
12616
12617
12618
12619
12620
12621
12622
12623
12624
12625
12626
12627
12628
12629
12630
12631
12632
12633
12634
12635
12636
12637
12638
12639
12640
12641
12642
12643
12644
12645
12646
12647
12648 class G__Sizep2memfuncG__GeomBuilder {
12649 public:
12650 G__Sizep2memfuncG__GeomBuilder(): p(&G__Sizep2memfuncG__GeomBuilder::sizep2memfunc) {}
12651 size_t sizep2memfunc() { return(sizeof(p)); }
12652 private:
12653 size_t (G__Sizep2memfuncG__GeomBuilder::*p)();
12654 };
12655
12656 size_t G__get_sizep2memfuncG__GeomBuilder()
12657 {
12658 G__Sizep2memfuncG__GeomBuilder a;
12659 G__setsizep2memfunc((int)a.sizep2memfunc());
12660 return((size_t)a.sizep2memfunc());
12661 }
12662
12663
12664
12665
12666
12667
12668
12669
12670
12671
12672
12673 extern "C" void G__cpp_setup_inheritanceG__GeomBuilder() {
12674
12675
12676 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager))) {
12677 TGeoTabManager *G__Lderived;
12678 G__Lderived=(TGeoTabManager*)0x1000;
12679 {
12680 TObject *G__Lpbase=(TObject*)G__Lderived;
12681 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
12682 }
12683 }
12684 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame))) {
12685 TGeoGedFrame *G__Lderived;
12686 G__Lderived=(TGeoGedFrame*)0x1000;
12687 {
12688 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12689 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12690 }
12691 {
12692 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12693 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12694 }
12695 {
12696 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12697 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12698 }
12699 {
12700 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12701 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12702 }
12703 {
12704 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12705 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12706 }
12707 {
12708 TObject *G__Lpbase=(TObject*)G__Lderived;
12709 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12710 }
12711 {
12712 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12713 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12714 }
12715 }
12716 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor))) {
12717 TGeoVolumeEditor *G__Lderived;
12718 G__Lderived=(TGeoVolumeEditor*)0x1000;
12719 {
12720 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
12721 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12722 }
12723 {
12724 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12725 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12726 }
12727 {
12728 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12729 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12730 }
12731 {
12732 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12733 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12734 }
12735 {
12736 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12737 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12738 }
12739 {
12740 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12741 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12742 }
12743 {
12744 TObject *G__Lpbase=(TObject*)G__Lderived;
12745 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12746 }
12747 {
12748 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12749 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12750 }
12751 }
12752 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor))) {
12753 TGeoBBoxEditor *G__Lderived;
12754 G__Lderived=(TGeoBBoxEditor*)0x1000;
12755 {
12756 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
12757 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12758 }
12759 {
12760 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12761 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12762 }
12763 {
12764 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12765 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12766 }
12767 {
12768 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12769 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12770 }
12771 {
12772 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12773 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12774 }
12775 {
12776 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12777 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12778 }
12779 {
12780 TObject *G__Lpbase=(TObject*)G__Lderived;
12781 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12782 }
12783 {
12784 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12785 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12786 }
12787 }
12788 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor))) {
12789 TGeoMediumEditor *G__Lderived;
12790 G__Lderived=(TGeoMediumEditor*)0x1000;
12791 {
12792 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
12793 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12794 }
12795 {
12796 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12797 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12798 }
12799 {
12800 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12801 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12802 }
12803 {
12804 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12805 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12806 }
12807 {
12808 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12809 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12810 }
12811 {
12812 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12813 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12814 }
12815 {
12816 TObject *G__Lpbase=(TObject*)G__Lderived;
12817 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12818 }
12819 {
12820 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12821 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12822 }
12823 }
12824 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor))) {
12825 TGeoNodeEditor *G__Lderived;
12826 G__Lderived=(TGeoNodeEditor*)0x1000;
12827 {
12828 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
12829 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12830 }
12831 {
12832 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12833 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12834 }
12835 {
12836 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12837 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12838 }
12839 {
12840 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12841 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12842 }
12843 {
12844 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12845 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12846 }
12847 {
12848 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12849 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12850 }
12851 {
12852 TObject *G__Lpbase=(TObject*)G__Lderived;
12853 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12854 }
12855 {
12856 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12857 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12858 }
12859 }
12860 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor))) {
12861 TGeoTranslationEditor *G__Lderived;
12862 G__Lderived=(TGeoTranslationEditor*)0x1000;
12863 {
12864 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
12865 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12866 }
12867 {
12868 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12869 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12870 }
12871 {
12872 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12873 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12874 }
12875 {
12876 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12877 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12878 }
12879 {
12880 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12881 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12882 }
12883 {
12884 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12885 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12886 }
12887 {
12888 TObject *G__Lpbase=(TObject*)G__Lderived;
12889 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12890 }
12891 {
12892 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12893 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12894 }
12895 }
12896 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor))) {
12897 TGeoRotationEditor *G__Lderived;
12898 G__Lderived=(TGeoRotationEditor*)0x1000;
12899 {
12900 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
12901 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12902 }
12903 {
12904 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12905 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12906 }
12907 {
12908 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12909 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12910 }
12911 {
12912 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12913 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12914 }
12915 {
12916 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12917 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12918 }
12919 {
12920 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12921 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12922 }
12923 {
12924 TObject *G__Lpbase=(TObject*)G__Lderived;
12925 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12926 }
12927 {
12928 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12929 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12930 }
12931 }
12932 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor))) {
12933 TGeoCombiTransEditor *G__Lderived;
12934 G__Lderived=(TGeoCombiTransEditor*)0x1000;
12935 {
12936 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
12937 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12938 }
12939 {
12940 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12941 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12942 }
12943 {
12944 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12945 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12946 }
12947 {
12948 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12949 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12950 }
12951 {
12952 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12953 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12954 }
12955 {
12956 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12957 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12958 }
12959 {
12960 TObject *G__Lpbase=(TObject*)G__Lderived;
12961 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12962 }
12963 {
12964 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12965 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12966 }
12967 }
12968 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor))) {
12969 TGeoManagerEditor *G__Lderived;
12970 G__Lderived=(TGeoManagerEditor*)0x1000;
12971 {
12972 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12973 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12974 }
12975 {
12976 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12977 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12978 }
12979 {
12980 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12981 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12982 }
12983 {
12984 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12985 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12986 }
12987 {
12988 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12989 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12990 }
12991 {
12992 TObject *G__Lpbase=(TObject*)G__Lderived;
12993 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12994 }
12995 {
12996 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12997 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12998 }
12999 }
13000 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor))) {
13001 TGeoTubeEditor *G__Lderived;
13002 G__Lderived=(TGeoTubeEditor*)0x1000;
13003 {
13004 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13005 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13006 }
13007 {
13008 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13009 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13010 }
13011 {
13012 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13013 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13014 }
13015 {
13016 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13017 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13018 }
13019 {
13020 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13021 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13022 }
13023 {
13024 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13025 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13026 }
13027 {
13028 TObject *G__Lpbase=(TObject*)G__Lderived;
13029 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13030 }
13031 {
13032 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13033 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13034 }
13035 }
13036 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor))) {
13037 TGeoTubeSegEditor *G__Lderived;
13038 G__Lderived=(TGeoTubeSegEditor*)0x1000;
13039 {
13040 TGeoTubeEditor *G__Lpbase=(TGeoTubeEditor*)G__Lderived;
13041 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
13042 }
13043 {
13044 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13045 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13046 }
13047 {
13048 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13049 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13050 }
13051 {
13052 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13053 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13054 }
13055 {
13056 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13057 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13058 }
13059 {
13060 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13061 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13062 }
13063 {
13064 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13065 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13066 }
13067 {
13068 TObject *G__Lpbase=(TObject*)G__Lderived;
13069 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13070 }
13071 {
13072 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13073 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13074 }
13075 }
13076 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor))) {
13077 TGeoCtubEditor *G__Lderived;
13078 G__Lderived=(TGeoCtubEditor*)0x1000;
13079 {
13080 TGeoTubeSegEditor *G__Lpbase=(TGeoTubeSegEditor*)G__Lderived;
13081 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
13082 }
13083 {
13084 TGeoTubeEditor *G__Lpbase=(TGeoTubeEditor*)G__Lderived;
13085 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor),(long)G__Lpbase-(long)G__Lderived,1,0);
13086 }
13087 {
13088 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13089 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13090 }
13091 {
13092 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13093 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13094 }
13095 {
13096 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13097 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13098 }
13099 {
13100 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13101 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13102 }
13103 {
13104 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13105 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13106 }
13107 {
13108 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13109 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13110 }
13111 {
13112 TObject *G__Lpbase=(TObject*)G__Lderived;
13113 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13114 }
13115 {
13116 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13117 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13118 }
13119 }
13120 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor))) {
13121 TGeoConeEditor *G__Lderived;
13122 G__Lderived=(TGeoConeEditor*)0x1000;
13123 {
13124 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13125 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13126 }
13127 {
13128 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13129 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13130 }
13131 {
13132 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13133 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13134 }
13135 {
13136 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13137 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13138 }
13139 {
13140 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13141 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13142 }
13143 {
13144 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13145 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13146 }
13147 {
13148 TObject *G__Lpbase=(TObject*)G__Lderived;
13149 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13150 }
13151 {
13152 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13153 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13154 }
13155 }
13156 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor))) {
13157 TGeoConeSegEditor *G__Lderived;
13158 G__Lderived=(TGeoConeSegEditor*)0x1000;
13159 {
13160 TGeoConeEditor *G__Lpbase=(TGeoConeEditor*)G__Lderived;
13161 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
13162 }
13163 {
13164 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13165 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13166 }
13167 {
13168 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13169 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13170 }
13171 {
13172 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13173 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13174 }
13175 {
13176 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13177 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13178 }
13179 {
13180 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13181 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13182 }
13183 {
13184 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13185 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13186 }
13187 {
13188 TObject *G__Lpbase=(TObject*)G__Lderived;
13189 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13190 }
13191 {
13192 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13193 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13194 }
13195 }
13196 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor))) {
13197 TGeoTrd1Editor *G__Lderived;
13198 G__Lderived=(TGeoTrd1Editor*)0x1000;
13199 {
13200 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13201 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13202 }
13203 {
13204 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13205 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13206 }
13207 {
13208 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13209 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13210 }
13211 {
13212 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13213 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13214 }
13215 {
13216 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13217 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13218 }
13219 {
13220 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13221 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13222 }
13223 {
13224 TObject *G__Lpbase=(TObject*)G__Lderived;
13225 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13226 }
13227 {
13228 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13229 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13230 }
13231 }
13232 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor))) {
13233 TGeoTrd2Editor *G__Lderived;
13234 G__Lderived=(TGeoTrd2Editor*)0x1000;
13235 {
13236 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13237 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13238 }
13239 {
13240 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13241 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13242 }
13243 {
13244 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13245 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13246 }
13247 {
13248 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13249 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13250 }
13251 {
13252 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13253 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13254 }
13255 {
13256 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13257 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13258 }
13259 {
13260 TObject *G__Lpbase=(TObject*)G__Lderived;
13261 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13262 }
13263 {
13264 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13265 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13266 }
13267 }
13268 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor))) {
13269 TGeoMaterialEditor *G__Lderived;
13270 G__Lderived=(TGeoMaterialEditor*)0x1000;
13271 {
13272 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13273 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13274 }
13275 {
13276 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13277 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13278 }
13279 {
13280 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13281 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13282 }
13283 {
13284 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13285 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13286 }
13287 {
13288 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13289 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13290 }
13291 {
13292 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13293 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13294 }
13295 {
13296 TObject *G__Lpbase=(TObject*)G__Lderived;
13297 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13298 }
13299 {
13300 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13301 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13302 }
13303 }
13304 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor))) {
13305 TGeoMixtureEditor *G__Lderived;
13306 G__Lderived=(TGeoMixtureEditor*)0x1000;
13307 {
13308 TGeoMaterialEditor *G__Lpbase=(TGeoMaterialEditor*)G__Lderived;
13309 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
13310 }
13311 {
13312 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13313 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13314 }
13315 {
13316 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13317 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13318 }
13319 {
13320 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13321 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13322 }
13323 {
13324 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13325 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13326 }
13327 {
13328 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13329 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13330 }
13331 {
13332 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13333 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13334 }
13335 {
13336 TObject *G__Lpbase=(TObject*)G__Lderived;
13337 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13338 }
13339 {
13340 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13341 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13342 }
13343 }
13344 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog))) {
13345 TGeoTreeDialog *G__Lderived;
13346 G__Lderived=(TGeoTreeDialog*)0x1000;
13347 {
13348 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
13349 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13350 }
13351 {
13352 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13353 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13354 }
13355 {
13356 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13357 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13358 }
13359 {
13360 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13361 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13362 }
13363 {
13364 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13365 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13366 }
13367 {
13368 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13369 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13370 }
13371 {
13372 TObject *G__Lpbase=(TObject*)G__Lderived;
13373 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13374 }
13375 {
13376 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13377 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13378 }
13379 }
13380 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel))) {
13381 TGeoTransientPanel *G__Lderived;
13382 G__Lderived=(TGeoTransientPanel*)0x1000;
13383 {
13384 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13385 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13386 }
13387 {
13388 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13389 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13390 }
13391 {
13392 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13393 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13394 }
13395 {
13396 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13397 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13398 }
13399 {
13400 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13401 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13402 }
13403 {
13404 TObject *G__Lpbase=(TObject*)G__Lderived;
13405 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13406 }
13407 {
13408 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13409 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13410 }
13411 }
13412 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog))) {
13413 TGeoVolumeDialog *G__Lderived;
13414 G__Lderived=(TGeoVolumeDialog*)0x1000;
13415 {
13416 TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
13417 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
13418 }
13419 {
13420 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
13421 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13422 }
13423 {
13424 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13425 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13426 }
13427 {
13428 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13429 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13430 }
13431 {
13432 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13433 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13434 }
13435 {
13436 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13437 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13438 }
13439 {
13440 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13441 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13442 }
13443 {
13444 TObject *G__Lpbase=(TObject*)G__Lderived;
13445 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13446 }
13447 {
13448 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13449 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13450 }
13451 }
13452 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog))) {
13453 TGeoShapeDialog *G__Lderived;
13454 G__Lderived=(TGeoShapeDialog*)0x1000;
13455 {
13456 TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
13457 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
13458 }
13459 {
13460 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
13461 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13462 }
13463 {
13464 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13465 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13466 }
13467 {
13468 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13469 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13470 }
13471 {
13472 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13473 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13474 }
13475 {
13476 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13477 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13478 }
13479 {
13480 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13481 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13482 }
13483 {
13484 TObject *G__Lpbase=(TObject*)G__Lderived;
13485 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13486 }
13487 {
13488 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13489 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13490 }
13491 }
13492 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog))) {
13493 TGeoMediumDialog *G__Lderived;
13494 G__Lderived=(TGeoMediumDialog*)0x1000;
13495 {
13496 TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
13497 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
13498 }
13499 {
13500 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
13501 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13502 }
13503 {
13504 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13505 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13506 }
13507 {
13508 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13509 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13510 }
13511 {
13512 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13513 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13514 }
13515 {
13516 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13517 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13518 }
13519 {
13520 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13521 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13522 }
13523 {
13524 TObject *G__Lpbase=(TObject*)G__Lderived;
13525 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13526 }
13527 {
13528 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13529 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13530 }
13531 }
13532 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog))) {
13533 TGeoMaterialDialog *G__Lderived;
13534 G__Lderived=(TGeoMaterialDialog*)0x1000;
13535 {
13536 TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
13537 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
13538 }
13539 {
13540 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
13541 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13542 }
13543 {
13544 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13545 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13546 }
13547 {
13548 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13549 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13550 }
13551 {
13552 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13553 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13554 }
13555 {
13556 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13557 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13558 }
13559 {
13560 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13561 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13562 }
13563 {
13564 TObject *G__Lpbase=(TObject*)G__Lderived;
13565 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13566 }
13567 {
13568 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13569 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13570 }
13571 }
13572 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog))) {
13573 TGeoMatrixDialog *G__Lderived;
13574 G__Lderived=(TGeoMatrixDialog*)0x1000;
13575 {
13576 TGeoTreeDialog *G__Lpbase=(TGeoTreeDialog*)G__Lderived;
13577 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog),(long)G__Lpbase-(long)G__Lderived,1,1);
13578 }
13579 {
13580 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
13581 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13582 }
13583 {
13584 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13585 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13586 }
13587 {
13588 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13589 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13590 }
13591 {
13592 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13593 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13594 }
13595 {
13596 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13597 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13598 }
13599 {
13600 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13601 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13602 }
13603 {
13604 TObject *G__Lpbase=(TObject*)G__Lderived;
13605 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13606 }
13607 {
13608 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13609 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13610 }
13611 }
13612 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor))) {
13613 TGeoSphereEditor *G__Lderived;
13614 G__Lderived=(TGeoSphereEditor*)0x1000;
13615 {
13616 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13617 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13618 }
13619 {
13620 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13621 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13622 }
13623 {
13624 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13625 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13626 }
13627 {
13628 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13629 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13630 }
13631 {
13632 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13633 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13634 }
13635 {
13636 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13637 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13638 }
13639 {
13640 TObject *G__Lpbase=(TObject*)G__Lderived;
13641 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13642 }
13643 {
13644 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13645 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13646 }
13647 }
13648 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection))) {
13649 TGeoPconSection *G__Lderived;
13650 G__Lderived=(TGeoPconSection*)0x1000;
13651 {
13652 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13653 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13654 }
13655 {
13656 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13657 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13658 }
13659 {
13660 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13661 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13662 }
13663 {
13664 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13665 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13666 }
13667 {
13668 TObject *G__Lpbase=(TObject*)G__Lderived;
13669 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13670 }
13671 {
13672 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13673 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13674 }
13675 {
13676 TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
13677 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
13678 }
13679 }
13680 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor))) {
13681 TGeoPconEditor *G__Lderived;
13682 G__Lderived=(TGeoPconEditor*)0x1000;
13683 {
13684 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13685 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13686 }
13687 {
13688 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13689 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13690 }
13691 {
13692 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13693 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13694 }
13695 {
13696 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13697 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13698 }
13699 {
13700 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13701 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13702 }
13703 {
13704 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13705 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13706 }
13707 {
13708 TObject *G__Lpbase=(TObject*)G__Lderived;
13709 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13710 }
13711 {
13712 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13713 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13714 }
13715 }
13716 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor))) {
13717 TGeoParaEditor *G__Lderived;
13718 G__Lderived=(TGeoParaEditor*)0x1000;
13719 {
13720 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13721 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13722 }
13723 {
13724 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13725 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13726 }
13727 {
13728 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13729 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13730 }
13731 {
13732 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13733 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13734 }
13735 {
13736 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13737 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13738 }
13739 {
13740 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13741 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13742 }
13743 {
13744 TObject *G__Lpbase=(TObject*)G__Lderived;
13745 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13746 }
13747 {
13748 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13749 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13750 }
13751 }
13752 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor))) {
13753 TGeoTorusEditor *G__Lderived;
13754 G__Lderived=(TGeoTorusEditor*)0x1000;
13755 {
13756 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13757 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13758 }
13759 {
13760 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13761 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13762 }
13763 {
13764 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13765 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13766 }
13767 {
13768 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13769 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13770 }
13771 {
13772 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13773 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13774 }
13775 {
13776 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13777 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13778 }
13779 {
13780 TObject *G__Lpbase=(TObject*)G__Lderived;
13781 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13782 }
13783 {
13784 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13785 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13786 }
13787 }
13788 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor))) {
13789 TGeoEltuEditor *G__Lderived;
13790 G__Lderived=(TGeoEltuEditor*)0x1000;
13791 {
13792 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13793 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13794 }
13795 {
13796 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13797 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13798 }
13799 {
13800 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13801 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13802 }
13803 {
13804 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13805 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13806 }
13807 {
13808 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13809 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13810 }
13811 {
13812 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13813 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13814 }
13815 {
13816 TObject *G__Lpbase=(TObject*)G__Lderived;
13817 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13818 }
13819 {
13820 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13821 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13822 }
13823 }
13824 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor))) {
13825 TGeoHypeEditor *G__Lderived;
13826 G__Lderived=(TGeoHypeEditor*)0x1000;
13827 {
13828 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13829 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13830 }
13831 {
13832 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13833 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13834 }
13835 {
13836 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13837 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13838 }
13839 {
13840 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13841 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13842 }
13843 {
13844 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13845 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13846 }
13847 {
13848 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13849 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13850 }
13851 {
13852 TObject *G__Lpbase=(TObject*)G__Lderived;
13853 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13854 }
13855 {
13856 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13857 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13858 }
13859 }
13860 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor))) {
13861 TGeoPgonEditor *G__Lderived;
13862 G__Lderived=(TGeoPgonEditor*)0x1000;
13863 {
13864 TGeoPconEditor *G__Lpbase=(TGeoPconEditor*)G__Lderived;
13865 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
13866 }
13867 {
13868 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13869 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13870 }
13871 {
13872 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13873 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13874 }
13875 {
13876 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13877 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13878 }
13879 {
13880 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13881 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13882 }
13883 {
13884 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13885 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13886 }
13887 {
13888 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13889 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13890 }
13891 {
13892 TObject *G__Lpbase=(TObject*)G__Lderived;
13893 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13894 }
13895 {
13896 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13897 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13898 }
13899 }
13900 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor))) {
13901 TGeoTrapEditor *G__Lderived;
13902 G__Lderived=(TGeoTrapEditor*)0x1000;
13903 {
13904 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13905 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13906 }
13907 {
13908 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13909 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13910 }
13911 {
13912 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13913 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13914 }
13915 {
13916 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13917 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13918 }
13919 {
13920 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13921 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13922 }
13923 {
13924 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13925 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13926 }
13927 {
13928 TObject *G__Lpbase=(TObject*)G__Lderived;
13929 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13930 }
13931 {
13932 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13933 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13934 }
13935 }
13936 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor))) {
13937 TGeoGtraEditor *G__Lderived;
13938 G__Lderived=(TGeoGtraEditor*)0x1000;
13939 {
13940 TGeoTrapEditor *G__Lpbase=(TGeoTrapEditor*)G__Lderived;
13941 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
13942 }
13943 {
13944 TGeoGedFrame *G__Lpbase=(TGeoGedFrame*)G__Lderived;
13945 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13946 }
13947 {
13948 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13949 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13950 }
13951 {
13952 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13953 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13954 }
13955 {
13956 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13957 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13958 }
13959 {
13960 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13961 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13962 }
13963 {
13964 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13965 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13966 }
13967 {
13968 TObject *G__Lpbase=(TObject*)G__Lderived;
13969 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13970 }
13971 {
13972 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13973 G__inheritance_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor),G__get_linked_tagnum(&G__G__GeomBuilderLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13974 }
13975 }
13976 }
13977
13978
13979
13980
13981 extern "C" void G__cpp_setup_typetableG__GeomBuilder() {
13982
13983
13984 G__search_typename2("Int_t",105,-1,0,-1);
13985 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
13986 G__search_typename2("UInt_t",104,-1,0,-1);
13987 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
13988 G__search_typename2("Double_t",100,-1,0,-1);
13989 G__setnewtype(-1,"Double 8 bytes",0);
13990 G__search_typename2("Bool_t",103,-1,0,-1);
13991 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
13992 G__search_typename2("Version_t",115,-1,0,-1);
13993 G__setnewtype(-1,"Class version identifier (short)",0);
13994 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
13995 G__setnewtype(-1,NULL,0);
13996 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
13997 G__setnewtype(-1,NULL,0);
13998 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
13999 G__setnewtype(-1,NULL,0);
14000 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
14001 G__setnewtype(-1,NULL,0);
14002 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
14003 G__setnewtype(-1,NULL,0);
14004 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
14005 G__setnewtype(-1,NULL,0);
14006 G__search_typename2("Pixel_t",107,-1,0,-1);
14007 G__setnewtype(-1,"Pixel value",0);
14008 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14009 G__setnewtype(-1,NULL,0);
14010 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14011 G__setnewtype(-1,NULL,0);
14012 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14013 G__setnewtype(-1,NULL,0);
14014 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
14015 G__setnewtype(-1,NULL,0);
14016 }
14017
14018
14019
14020
14021
14022
14023
14024
14025 static void G__setup_memvarTGeoTabManager(void) {
14026 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager));
14027 { TGeoTabManager *p; p=(TGeoTabManager*)0x1000; if (p) { }
14028 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedEditor),-1,-1,4,"fGedEditor=",0,"Parent editor");
14029 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TVirtualPad),-1,-1,4,"fPad=",0,"Pad to which this applies");
14030 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab),-1,-1,4,"fTab=",0,"Parent tab");
14031 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,4,"fVolume=",0,"Edited volume");
14032 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),-1,-1,4,"fShapePanel=",0,"Panel for editing shapes");
14033 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),-1,-1,4,"fMediumPanel=",0,"Panel for editing media");
14034 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),-1,-1,4,"fMaterialPanel=",0,"Panel for editing materials");
14035 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel),-1,-1,4,"fMatrixPanel=",0,"Panel for editing matrices");
14036 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,4,"fVolumeTab=",0,"Volume tab");
14037 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TMap),-1,-2,4,"fgEditorToMgrMap=",0,"Map from ged-editor to associated tab-manager");
14038 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14039 }
14040 G__tag_memvar_reset();
14041 }
14042
14043
14044
14045 static void G__setup_memvarTGeoGedFrame(void) {
14046 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame));
14047 { TGeoGedFrame *p; p=(TGeoGedFrame*)0x1000; if (p) { }
14048 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab),-1,-1,2,"fTab=",0,"tab of the ged-editor");
14049 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager),-1,-1,2,"fTabMgr=",0,"tab manager corresponding to ged-editor");
14050 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TVirtualPad),-1,-1,2,"fPad=",0,"selected pad, if exists");
14051 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14052 }
14053 G__tag_memvar_reset();
14054 }
14055
14056
14057
14058 static void G__setup_memvarTGeoVolumeEditor(void) {
14059 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor));
14060 { TGeoVolumeEditor *p; p=(TGeoVolumeEditor*)0x1000; if (p) { }
14061 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManager),-1,-1,2,"fGeometry=",0,"Selected geometry manager");
14062 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fVolume=",0,"Volume object");
14063 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14064 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsAssembly=",0,"Flag that the volume is an assembly");
14065 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsDivided=",0,"Flag that the volume is divided");
14066 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGShutter),-1,-1,2,"fCategories=",0,"Categories shutter");
14067 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fVolumeName=",0,"Volume name text entry");
14068 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShape),-1,-1,2,"fSelectedShape=",0,"Selected shape");
14069 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelShape=",0,"Selected shape label");
14070 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelShape=",0,"Button for selecting a shape");
14071 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMedium),-1,-1,2,"fSelectedMedium=",0,"Selected medium");
14072 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMedium=",0,"Selected medium label");
14073 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMedium=",0,"Button for selecting a medium");
14074 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fSelectedVolume=",0,"Selected volume");
14075 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelVolume=",0,"Selected volume label");
14076 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelVolume=",0,"Button for selecting a volume");
14077 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrix),-1,-1,2,"fSelectedMatrix=",0,"Selected matrix");
14078 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMatrix=",0,"Selected matrix label");
14079 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMatrix=",0,"Button for selecting a matrix");
14080 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fCopyNumber=",0,"Node copy number");
14081 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fAddNode=",0,"Button for adding a node");
14082 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditShape=",0,"Check button for shape editing");
14083 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMedium=",0,"Check button for medium editing");
14084 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fNodeList=",0,"Daughters combo box");
14085 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMatrix=",0,"Button for editing the position of a daughter");
14086 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fRemoveNode=",0,"Button for removing a daughter");
14087 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fBVis[2]=",0,"Buttons for setting vis. on/off");
14088 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fBView[3]=",0,"Radio for selecting view options");
14089 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fBRaytrace=",0,"Raytracing on/off");
14090 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fBAuto=",0,"Check button for auto vis level");
14091 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEVisLevel=",0,"Number entry for visibility level");
14092 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApplyDiv=",0,"Button for applying division settings");
14093 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fDivName=",0,"Division volume name text entry");
14094 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fBDiv[3]=",0,"Radio for selecting division type");
14095 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDivFrom=",0,"Number entry for division start");
14096 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDivStep=",0,"Number entry for division step");
14097 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDivN=",0,"Number entry for division Nslices");
14098 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14099 }
14100 G__tag_memvar_reset();
14101 }
14102
14103
14104
14105 static void G__setup_memvarTGeoBBoxEditor(void) {
14106 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor));
14107 { TGeoBBoxEditor *p; p=(TGeoBBoxEditor*)0x1000; if (p) { }
14108 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi=",0,"Initial box dx");
14109 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi=",0,"Initial box dy");
14110 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial box dz");
14111 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fOrigi[3]=",0,"Initial origin");
14112 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14113 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBox),-1,-1,2,"fShape=",0,"Shape object");
14114 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14115 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14116 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14117 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxDx=",0,"Number entry for box DX");
14118 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxDy=",0,"Number entry for box DY");
14119 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxDz=",0,"Number entry for box DZ");
14120 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxOx=",0,"Number entry for box OX");
14121 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxOy=",0,"Number entry for box OY");
14122 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fBoxOz=",0,"Number entry for box OZ");
14123 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14124 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14125 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14126 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14127 }
14128 G__tag_memvar_reset();
14129 }
14130
14131
14132
14133 static void G__setup_memvarTGeoMediumEditor(void) {
14134 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor));
14135 { TGeoMediumEditor *p; p=(TGeoMediumEditor*)0x1000; if (p) { }
14136 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMedium),-1,-1,2,"fMedium=",0,"Medium object");
14137 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that the medium can be changed");
14138 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Modified flag");
14139 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMedName=",0,"Medium name text entry");
14140 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedId=",0,"Number entry for medium id");
14141 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterial),-1,-1,2,"fSelectedMaterial=",0,"Selected material");
14142 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMaterial=",0,"Selected material label");
14143 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMaterial=",0,"Button for selecting a material");
14144 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMaterial=",0,"Check button for material editing");
14145 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fMedSensitive=",0,"Check button for sensitivity");
14146 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fMagfldOption=",0,"Combo box with magnetic field options");
14147 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedFieldm=",0,"Number entry for fieldm");
14148 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedTmaxfd=",0,"Number entry for tmaxfd");
14149 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedStemax=",0,"Number entry for stemax");
14150 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedDeemax=",0,"Number entry for deemax");
14151 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedEpsil=",0,"Number entry for epsil");
14152 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMedStmin=",0,"Number entry for stmin");
14153 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14154 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14155 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14156 }
14157 G__tag_memvar_reset();
14158 }
14159
14160
14161
14162 static void G__setup_memvarTGeoNodeEditor(void) {
14163 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor));
14164 { TGeoNodeEditor *p; p=(TGeoNodeEditor*)0x1000; if (p) { }
14165 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNode),-1,-1,2,"fNode=",0,"Node object");
14166 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that the medium can be changed");
14167 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fNodeName=",0,"Node name text entry");
14168 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fNodeNumber=",0,"Copy number ");
14169 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fSelectedVolume=",0,"Selected volume");
14170 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelVolume=",0,"Selected volume label");
14171 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelVolume=",0,"Button for selecting a volume");
14172 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fSelectedMother=",0,"Selected mother");
14173 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMother=",0,"Selected mother label");
14174 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMother=",0,"Button for selecting a mother volume");
14175 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrix),-1,-1,2,"fSelectedMatrix=",0,"Selected matrix");
14176 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMatrix=",0,"Selected matrix label");
14177 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMatrix=",0,"Button for selecting a matrix");
14178 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMother=",0,"Check button for editing mother volume");
14179 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditVolume=",0,"Check button for volume editing");
14180 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMatrix=",0,"Check button for matrix editing");
14181 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14182 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button");
14183 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14184 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14185 }
14186 G__tag_memvar_reset();
14187 }
14188
14189
14190
14191 static void G__setup_memvarTGeoTranslationEditor(void) {
14192 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor));
14193 { TGeoTranslationEditor *p; p=(TGeoTranslationEditor*)0x1000; if (p) { }
14194 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi=",0,"Initial dx");
14195 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi=",0,"Initial dy");
14196 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial dz");
14197 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14198 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslation),-1,-1,2,"fTranslation=",0,"Translation object");
14199 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that this was modified");
14200 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that this can be changed");
14201 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fTransName=",0,"Translation name text entry");
14202 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDx=",0,"Number entry for box DX");
14203 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDy=",0,"Number entry for box DY");
14204 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDz=",0,"Number entry for box DZ");
14205 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14206 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button");
14207 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14208 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14209 }
14210 G__tag_memvar_reset();
14211 }
14212
14213
14214
14215 static void G__setup_memvarTGeoRotationEditor(void) {
14216 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor));
14217 { TGeoRotationEditor *p; p=(TGeoRotationEditor*)0x1000; if (p) { }
14218 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhii=",0,"Initial phi (Euler rotation angle about Z)");
14219 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetai=",0,"Initial theta (Euler rotation angle about new X)");
14220 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPsii=",0,"Initial dz (Euler rotation angle about new Z)");
14221 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleX=",0,"New rotation angle about X");
14222 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleY=",0,"New rotation angle about Y");
14223 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleZ=",0,"New rotation angle about Z");
14224 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14225 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotation),-1,-1,2,"fRotation=",0,"Rotation object");
14226 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that this was modified");
14227 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that this can be changed");
14228 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fRotName=",0,"Translation name text entry");
14229 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotPhi=",0,"Number entry for phi angle");
14230 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotTheta=",0,"Number entry for theta angle");
14231 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotPsi=",0,"Number entry for psi angle");
14232 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotAxis=",0,"Number entry for rotation angle about one axis");
14233 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotX=",0,"Rotation about X selected");
14234 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotY=",0,"Rotation about Y selected");
14235 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotZ=",0,"Rotation about Z selected");
14236 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14237 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button");
14238 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14239 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14240 }
14241 G__tag_memvar_reset();
14242 }
14243
14244
14245
14246 static void G__setup_memvarTGeoCombiTransEditor(void) {
14247 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor));
14248 { TGeoCombiTransEditor *p; p=(TGeoCombiTransEditor*)0x1000; if (p) { }
14249 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi=",0,"Initial dx");
14250 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi=",0,"Initial dy");
14251 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial dz");
14252 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhii=",0,"Initial phi (Euler rotation angle about Z)");
14253 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetai=",0,"Initial theta (Euler rotation angle about new X)");
14254 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPsii=",0,"Initial dz (Euler rotation angle about new Z)");
14255 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleX=",0,"New rotation angle about X");
14256 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleY=",0,"New rotation angle about Y");
14257 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAngleZ=",0,"New rotation angle about Z");
14258 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14259 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTrans),-1,-1,2,"fCombi=",0,"Combi object");
14260 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that this was modified");
14261 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsEditable=",0,"Flag that this can be changed");
14262 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fRotName=",0,"Translation name text entry");
14263 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDx=",0,"Number entry for box DX");
14264 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDy=",0,"Number entry for box DY");
14265 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fTransDz=",0,"Number entry for box DZ");
14266 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotPhi=",0,"Number entry for phi angle");
14267 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotTheta=",0,"Number entry for theta angle");
14268 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotPsi=",0,"Number entry for psi angle");
14269 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fRotAxis=",0,"Number entry for rotation angle about one axis");
14270 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotX=",0,"Rotation about X selected");
14271 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotY=",0,"Rotation about Y selected");
14272 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fRotZ=",0,"Rotation about Z selected");
14273 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14274 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button");
14275 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14276 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14277 }
14278 G__tag_memvar_reset();
14279 }
14280
14281
14282
14283 static void G__setup_memvarTGeoManagerEditor(void) {
14284 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor));
14285 { TGeoManagerEditor *p; p=(TGeoManagerEditor*)0x1000; if (p) { }
14286 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManager),-1,-1,2,"fGeometry=",0,"Selected geometry manager");
14287 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager),-1,-1,2,"fTabMgr=",0,"Tab manager");
14288 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab),-1,-1,2,"fTab=",0,"TGTab of GedEditor");
14289 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fVolumeTab=",0,"Tab of Volume tab");
14290 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that manager was modified");
14291 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGShutter),-1,-1,2,"fCategories=",0,"Categories shutter");
14292 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fManagerName=",0,"Name text entry");
14293 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fManagerTitle=",0,"Title text entry");
14294 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMediumName=",0,"Medium name text entry");
14295 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMatrixName=",0,"Matrix name text entry");
14296 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMaterialName=",0,"Material name text entry");
14297 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fVolumeName=",0,"Volume name text entry");
14298 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterial),-1,-1,2,"fSelectedMaterial=",0,"Selected material");
14299 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterial),-1,-1,2,"fSelectedMaterial2=",0,"Selected material for medium creation");
14300 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMaterial=",0,"Selected material label");
14301 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMaterial2=",0,"Selected material label");
14302 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMaterial=",0,"Button for selecting a material");
14303 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMaterial2=",0,"Button for selecting a material");
14304 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume),-1,-1,2,"fSelectedVolume=",0,"Selected volume");
14305 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelVolume=",0,"Selected volume label");
14306 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelVolume=",0,"Button for selecting a volume");
14307 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShape),-1,-1,2,"fSelectedShape=",0,"Selected shape");
14308 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShape),-1,-1,2,"fSelectedShape2=",0,"Selected shape for volume creation");
14309 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelShape=",0,"Selected shape label");
14310 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelShape2=",0,"Selected shape label");
14311 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelShape=",0,"Button for selecting a shape");
14312 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelShape2=",0,"Button for selecting a shape");
14313 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrix),-1,-1,2,"fSelectedMatrix=",0,"Selected matrix");
14314 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMatrix=",0,"Selected matrix label");
14315 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMatrix=",0,"Button for selecting a matrix");
14316 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMedium),-1,-1,2,"fSelectedMedium=",0,"Selected medium");
14317 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMedium),-1,-1,2,"fSelectedMedium2=",0,"Selected medium for volume creation");
14318 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMedium=",0,"Selected medium label");
14319 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelMedium2=",0,"Selected medium label");
14320 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMedium=",0,"Button for selecting a medium");
14321 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelMedium2=",0,"Button for selecting a medium");
14322 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fShapeButton[21]=",0,"List of shape buttons");
14323 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fMatrixButton[3]=",0,"List of matrix buttons");
14324 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fVolumeButton[2]=",0,"List of volume buttons");
14325 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fMaterialButton[2]=",0,"List of material buttons");
14326 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGRadioButton),-1,-1,2,"fExportOption[2]=",0,"Export option buttons");
14327 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fExportButton=",0,"Button to export geometry");
14328 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fElementList=",0,"Combo box for elements");
14329 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEntryDensity=",0,"Number entry for material density");
14330 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fMediumButton=",0,"Button to create a medium");
14331 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMediumId=",0,"Medium ID number entry");
14332 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditShape=",0,"Button for editing selected shape");
14333 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMedium=",0,"Button for editing a medium");
14334 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMaterial=",0,"Button for editing a material");
14335 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditMatrix=",0,"Button for editing a matrix");
14336 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fEditVolume=",0,"Button for editing a volume");
14337 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fSetTopVolume=",0,"Button for setting top volume");
14338 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fLSelTop=",0,"Selected top volume");
14339 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGPictureButton),-1,-1,2,"fBSelTop=",0,"Button for selecting top volume");
14340 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fCloseGeometry=",0,"Button for closing the geometry");
14341 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f2=",0,"Parent frame for shape editing");
14342 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f3=",0,"Parent frame for volume editing");
14343 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f4=",0,"Parent frame for materials editing");
14344 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f5=",0,"Parent frame for media editing");
14345 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f6=",0,"Parent frame for matrices editing");
14346 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f7=",0,"Parent frame for closing geometry");
14347 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TCanvas),-1,-1,2,"fConnectedCanvas=",0,"Canvas connected to SelectedSlot()");
14348 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14349 }
14350 G__tag_memvar_reset();
14351 }
14352
14353
14354
14355 static void G__setup_memvarTGeoTubeEditor(void) {
14356 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor));
14357 { TGeoTubeEditor *p; p=(TGeoTubeEditor*)0x1000; if (p) { }
14358 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini=",0,"Initial inner radius");
14359 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi=",0,"Initial outer radius");
14360 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial box dz");
14361 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14362 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTube),-1,-1,2,"fShape=",0,"Shape object");
14363 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14364 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14365 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14366 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin=",0,"Number entry for rmin");
14367 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax=",0,"Number entry for rmax");
14368 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
14369 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14370 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14371 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fBFrame=",0,"Frame containing Apply/Undo");
14372 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14373 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fDFrame=",0,"Frame containing Delayed draw");
14374 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14375 }
14376 G__tag_memvar_reset();
14377 }
14378
14379
14380
14381 static void G__setup_memvarTGeoTubeSegEditor(void) {
14382 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor));
14383 { TGeoTubeSegEditor *p; p=(TGeoTubeSegEditor*)0x1000; if (p) { }
14384 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLock=",0,"Phi lock");
14385 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmini=",0,"Initial phi min");
14386 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmaxi=",0,"Initial phi max");
14387 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGDoubleVSlider),-1,-1,2,"fSPhi=",0,"Phi slider");
14388 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
14389 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi2=",0,"Number entry for phi2 ");
14390 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14391 }
14392 G__tag_memvar_reset();
14393 }
14394
14395
14396
14397 static void G__setup_memvarTGeoCtubEditor(void) {
14398 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor));
14399 { TGeoCtubEditor *p; p=(TGeoCtubEditor*)0x1000; if (p) { }
14400 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThlo=",0,"Theta angle of the normal to the lower plane (90, 180)");
14401 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhlo=",0,"Phi angle of the normal to lower Z plane");
14402 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThhi=",0,"Theta angle of the normal to the upper plane (0, 90)");
14403 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhhi=",0,"Phi angle of the normal to upper Z plane");
14404 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEThlo=",0,"Number entry for thlo");
14405 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhlo=",0,"Number entry for phlo");
14406 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEThhi=",0,"Number entry for thhi");
14407 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhhi=",0,"Number entry for phhi");
14408 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14409 }
14410 G__tag_memvar_reset();
14411 }
14412
14413
14414
14415 static void G__setup_memvarTGeoConeEditor(void) {
14416 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor));
14417 { TGeoConeEditor *p; p=(TGeoConeEditor*)0x1000; if (p) { }
14418 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini1=",0,"Initial inner radius at -dz");
14419 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi1=",0,"Initial outer radius at -dz");
14420 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini2=",0,"Initial inner radius at +dz");
14421 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi2=",0,"Initial outer radius at +dz");
14422 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial box dz");
14423 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14424 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCone),-1,-1,2,"fShape=",0,"Shape object");
14425 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14426 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14427 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14428 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin1=",0,"Number entry for rmin1");
14429 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin2=",0,"Number entry for rmin2");
14430 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax1=",0,"Number entry for rmax1");
14431 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax2=",0,"Number entry for rmax2");
14432 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
14433 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14434 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14435 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fBFrame=",0,"Frame containing Apply/Undo");
14436 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14437 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fDFrame=",0,"Frame containing Delayed draw");
14438 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14439 }
14440 G__tag_memvar_reset();
14441 }
14442
14443
14444
14445 static void G__setup_memvarTGeoConeSegEditor(void) {
14446 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor));
14447 { TGeoConeSegEditor *p; p=(TGeoConeSegEditor*)0x1000; if (p) { }
14448 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLock=",0,"Phi lock");
14449 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmini=",0,"Initial phi min");
14450 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmaxi=",0,"Initial phi max");
14451 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGDoubleVSlider),-1,-1,2,"fSPhi=",0,"Phi slider");
14452 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
14453 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi2=",0,"Number entry for phi2 ");
14454 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14455 }
14456 G__tag_memvar_reset();
14457 }
14458
14459
14460
14461 static void G__setup_memvarTGeoTrd1Editor(void) {
14462 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor));
14463 { TGeoTrd1Editor *p; p=(TGeoTrd1Editor*)0x1000; if (p) { }
14464 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi1=",0,"Initial dx1");
14465 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi2=",0,"Initial dx2");
14466 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi=",0,"Initial dy");
14467 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial dz");
14468 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14469 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1),-1,-1,2,"fShape=",0,"Shape object");
14470 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14471 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14472 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14473 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx1=",0,"Number entry for DX1");
14474 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx2=",0,"Number entry for DX2 ");
14475 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDy=",0,"Number entry for DY");
14476 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
14477 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14478 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14479 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14480 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14481 }
14482 G__tag_memvar_reset();
14483 }
14484
14485
14486
14487 static void G__setup_memvarTGeoTrd2Editor(void) {
14488 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor));
14489 { TGeoTrd2Editor *p; p=(TGeoTrd2Editor*)0x1000; if (p) { }
14490 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi1=",0,"Initial dx1");
14491 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDxi2=",0,"Initial dx2");
14492 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi1=",0,"Initial dy1");
14493 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDyi2=",0,"Initial dy2");
14494 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial dz");
14495 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14496 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2),-1,-1,2,"fShape=",0,"Shape object");
14497 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14498 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14499 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14500 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx1=",0,"Number entry for DX1");
14501 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx2=",0,"Number entry for DX2 ");
14502 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDy1=",0,"Number entry for DY1");
14503 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDy2=",0,"Number entry for DY1");
14504 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
14505 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14506 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14507 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14508 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14509 }
14510 G__tag_memvar_reset();
14511 }
14512
14513
14514
14515 static void G__setup_memvarTGeoMaterialEditor(void) {
14516 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor));
14517 { TGeoMaterialEditor *p; p=(TGeoMaterialEditor*)0x1000; if (p) { }
14518 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAi=",0,"Initial atomic mass");
14519 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fZi=",0,"Initial Z");
14520 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStatei=",0,"Initial material state");
14521 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDensityi=",0,"Initial density");
14522 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTempi=",0,"Initial temperature");
14523 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPresi=",0,"Initial pressure");
14524 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14525 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterial),-1,-1,2,"fMaterial=",0,"Material object");
14526 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that material was modified");
14527 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsMaterialEditable=",0,"Flag that the material can be changed");
14528 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fMaterialName=",0,"Material name text entry");
14529 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatA=",0,"Number entry for A");
14530 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatZ=",0,"Number entry for Z");
14531 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fMatState=",0,"Material state");
14532 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatDensity=",0,"Number entry for density");
14533 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatTemperature=",0,"Number entry for temperature");
14534 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatPressure=",0,"Number entry for pressure");
14535 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatRadLen=",0,"Number entry for radiation length");
14536 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fMatAbsLen=",0,"Number entry for absorbtion length");
14537 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f23=",0,"Frame for buttons");
14538 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14539 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14540 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14541 }
14542 G__tag_memvar_reset();
14543 }
14544
14545
14546
14547 static void G__setup_memvarTGeoMixtureEditor(void) {
14548 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor));
14549 { TGeoMixtureEditor *p; p=(TGeoMixtureEditor*)0x1000; if (p) { }
14550 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixture),-1,-1,2,"fMixture=",0,"Mixture object ");
14551 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGComboBox),-1,-1,2,"fMixElem=",0,"Combo box for elements");
14552 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fNelem=",0,"Label for number of elements");
14553 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fAelem=",0,"Label for A");
14554 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fZelem=",0,"Label for Z");
14555 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fChkFraction=",0,"Check button for fraction by wght.");
14556 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fNEFraction=",0,"Number entry for fraction value");
14557 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fChkNatoms=",0,"Check button for number of atoms");
14558 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fNENatoms=",0,"Number entry for number of atoms");
14559 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fBAddElem=",0,"Buttom for adding element as component");
14560 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fComps=",0,"Frame with components");
14561 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14562 }
14563 G__tag_memvar_reset();
14564 }
14565
14566
14567
14568 static void G__setup_memvarTGeoTreeDialog(void) {
14569 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog));
14570 { TGeoTreeDialog *p; p=(TGeoTreeDialog*)0x1000; if (p) { }
14571 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),-1,-2,2,"fgSelectedObj=",0,"Selected object");
14572 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCanvas),-1,-1,2,"fCanvas=",0,"TGCanvas containing the list tree");
14573 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLabel),-1,-1,2,"fObjLabel=",0,"Label for selected object");
14574 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGListTree),-1,-1,2,"fLT=",0,"List tree for selecting");
14575 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"f1=",0,"Composite frame containing the selection");
14576 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fClose=",0,"Close button");
14577 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14578 }
14579 G__tag_memvar_reset();
14580 }
14581
14582
14583
14584 static void G__setup_memvarTGeoTransientPanel(void) {
14585 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel));
14586 { TGeoTransientPanel *p; p=(TGeoTransientPanel*)0x1000; if (p) { }
14587 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGedEditor),-1,-1,4,"fGedEditor=",0,"ged-editor steering this panel");
14588 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCanvas),-1,-1,4,"fCan=",0,"TGCanvas containing a TGTab");
14589 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab),-1,-1,4,"fTab=",0,"tab widget holding the editor");
14590 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,4,"fTabContainer=",0,"main tab container");
14591 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,4,"fStyle=",0,"style tab container frame");
14592 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject),-1,-1,4,"fModel=",0,"selected object");
14593 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,4,"fClose=",0,"close button");
14594 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14595 }
14596 G__tag_memvar_reset();
14597 }
14598
14599
14600
14601 static void G__setup_memvarTGeoVolumeDialog(void) {
14602 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog));
14603 { TGeoVolumeDialog *p; p=(TGeoVolumeDialog*)0x1000; if (p) { }
14604 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14605 }
14606 G__tag_memvar_reset();
14607 }
14608
14609
14610
14611 static void G__setup_memvarTGeoShapeDialog(void) {
14612 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog));
14613 { TGeoShapeDialog *p; p=(TGeoShapeDialog*)0x1000; if (p) { }
14614 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14615 }
14616 G__tag_memvar_reset();
14617 }
14618
14619
14620
14621 static void G__setup_memvarTGeoMediumDialog(void) {
14622 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog));
14623 { TGeoMediumDialog *p; p=(TGeoMediumDialog*)0x1000; if (p) { }
14624 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14625 }
14626 G__tag_memvar_reset();
14627 }
14628
14629
14630
14631 static void G__setup_memvarTGeoMaterialDialog(void) {
14632 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog));
14633 { TGeoMaterialDialog *p; p=(TGeoMaterialDialog*)0x1000; if (p) { }
14634 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14635 }
14636 G__tag_memvar_reset();
14637 }
14638
14639
14640
14641 static void G__setup_memvarTGeoMatrixDialog(void) {
14642 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog));
14643 { TGeoMatrixDialog *p; p=(TGeoMatrixDialog*)0x1000; if (p) { }
14644 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14645 }
14646 G__tag_memvar_reset();
14647 }
14648
14649
14650
14651 static void G__setup_memvarTGeoSphereEditor(void) {
14652 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor));
14653 { TGeoSphereEditor *p; p=(TGeoSphereEditor*)0x1000; if (p) { }
14654 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini=",0,"Initial inner radius");
14655 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi=",0,"Initial outer radius");
14656 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta1i=",0,"Initial lower theta limit");
14657 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTheta2i=",0,"Initial higher theta limit ");
14658 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1i=",0,"Initial lower phi limit");
14659 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi2i=",0,"Initial higher phi limit ");
14660 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14661 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphere),-1,-1,2,"fShape=",0,"Shape object");
14662 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14663 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14664 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLock=",0,"Lock");
14665 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14666 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin=",0,"Number entry for rmin");
14667 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax=",0,"Number entry for rmax");
14668 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETheta1=",0,"Number entry for Theta1");
14669 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETheta2=",0,"Number entry for Theta2");
14670 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
14671 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi2=",0,"Number entry for phi2");
14672 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGDoubleVSlider),-1,-1,2,"fSPhi=",0,"Phi slider");
14673 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGDoubleVSlider),-1,-1,2,"fSTheta=",0,"Theta slider ");
14674 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14675 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14676 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14677 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14678 }
14679 G__tag_memvar_reset();
14680 }
14681
14682
14683
14684 static void G__setup_memvarTGeoPconSection(void) {
14685 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection));
14686 { TGeoPconSection *p; p=(TGeoPconSection*)0x1000; if (p) { }
14687 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNumber=",0,"Id for the section");
14688 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEZ=",0,"Number entry for Z position");
14689 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin=",0,"Number entry for Rmin position");
14690 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax=",0,"Number entry for Rmax position");
14691 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14692 }
14693 G__tag_memvar_reset();
14694 }
14695
14696
14697
14698 static void G__setup_memvarTGeoPconEditor(void) {
14699 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor));
14700 { TGeoPconEditor *p; p=(TGeoPconEditor*)0x1000; if (p) { }
14701 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsecti=",0,"Initial number of sections");
14702 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1i=",0,"Initial Phi1");
14703 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDPhii=",0,"Initial Dphi");
14704 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZi=",0,"Initial Z positions");
14705 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini=",0,"Initial Rmin values");
14706 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi=",0,"Initial Rmax values ");
14707 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNsections=",0,"Number of Z sections");
14708 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TObjArray),-1,-1,2,"fSections=",0,"List of section frames");
14709 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCanvas),-1,-1,2,"fCan=",0,"sections container");
14710 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPcon),-1,-1,2,"fShape=",0,"Shape object");
14711 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14712 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14713 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGLayoutHints),-1,-1,2,"fLHsect=",0,"Layout hints for sections");
14714 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14715 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fENz=",0,"Number entry for nsections");
14716 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
14717 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDPhi=",0,"Number entry for dphi ");
14718 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14719 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14720 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fBFrame=",0,"Frame containing Apply/Undo");
14721 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14722 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fDFrame=",0,"Frame containing Delayed draw");
14723 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14724 }
14725 G__tag_memvar_reset();
14726 }
14727
14728
14729
14730 static void G__setup_memvarTGeoParaEditor(void) {
14731 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor));
14732 { TGeoParaEditor *p; p=(TGeoParaEditor*)0x1000; if (p) { }
14733 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXi=",0,"Initial X");
14734 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fYi=",0,"Initial Y");
14735 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fZi=",0,"Initial Z");
14736 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlphai=",0,"Initial alpha");
14737 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetai=",0,"Initial theta");
14738 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhii=",0,"Initial phi");
14739 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14740 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPara),-1,-1,2,"fShape=",0,"Shape object");
14741 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14742 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14743 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14744 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDx=",0,"Number entry for DX2 ");
14745 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDy=",0,"Number entry for DY");
14746 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
14747 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEAlpha=",0,"Number entry for Alpha");
14748 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETheta=",0,"Number entry for Theta ");
14749 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi=",0,"Number entry for Theta ");
14750 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14751 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14752 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14753 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14754 }
14755 G__tag_memvar_reset();
14756 }
14757
14758
14759
14760 static void G__setup_memvarTGeoTorusEditor(void) {
14761 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor));
14762 { TGeoTorusEditor *p; p=(TGeoTorusEditor*)0x1000; if (p) { }
14763 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRi=",0,"Initial axial radius");
14764 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmini=",0,"Initial inner radius");
14765 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRmaxi=",0,"Initial outer radius");
14766 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhi1i=",0,"Initial starting phi1");
14767 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDphii=",0,"Initial phi extent");
14768 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14769 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorus),-1,-1,2,"fShape=",0,"Shape object");
14770 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14771 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14772 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14773 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fER=",0,"Number entry for R");
14774 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmin=",0,"Number entry for Rmin");
14775 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERmax=",0,"Number entry for Rmax");
14776 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi1=",0,"Number entry for phi1");
14777 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDphi=",0,"Number entry for Dphi ");
14778 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14779 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14780 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14781 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14782 }
14783 G__tag_memvar_reset();
14784 }
14785
14786
14787
14788 static void G__setup_memvarTGeoEltuEditor(void) {
14789 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor));
14790 { TGeoEltuEditor *p; p=(TGeoEltuEditor*)0x1000; if (p) { }
14791 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAi=",0,"Initial semi-axis of the ellipse along x");
14792 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBi=",0,"Initial semi-axis of the ellipse along y");
14793 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial half length in z");
14794 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14795 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltu),-1,-1,2,"fShape=",0,"Shape object");
14796 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14797 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14798 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14799 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEA=",0,"Number entry for A");
14800 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEB=",0,"Number entry for B");
14801 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
14802 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14803 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14804 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14805 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14806 }
14807 G__tag_memvar_reset();
14808 }
14809
14810
14811
14812 static void G__setup_memvarTGeoHypeEditor(void) {
14813 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor));
14814 { TGeoHypeEditor *p; p=(TGeoHypeEditor*)0x1000; if (p) { }
14815 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRini=",0,"Initial inner radius ");
14816 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRouti=",0,"Initial outer radius ");
14817 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial half length Dz");
14818 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStIni=",0,"Initial stereo angle for inner surface");
14819 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fStOuti=",0,"Initial stereo angle for outer surface");
14820 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14821 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHype),-1,-1,2,"fShape=",0,"Shape object");
14822 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14823 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14824 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14825 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERin=",0,"Number entry for Rin");
14826 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fERout=",0,"Number entry for Rout");
14827 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for Dz");
14828 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEStIn=",0,"Number entry for StIn");
14829 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEStOut=",0,"Number entry for StOut");
14830 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14831 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14832 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14833 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14834 }
14835 G__tag_memvar_reset();
14836 }
14837
14838
14839
14840 static void G__setup_memvarTGeoPgonEditor(void) {
14841 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor));
14842 { TGeoPgonEditor *p; p=(TGeoPgonEditor*)0x1000; if (p) { }
14843 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNedgesi=",0,"Initial number of edges");
14844 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fENedges=",0,"Number entry for nsections");
14845 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14846 }
14847 G__tag_memvar_reset();
14848 }
14849
14850
14851
14852 static void G__setup_memvarTGeoTrapEditor(void) {
14853 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor));
14854 { TGeoTrapEditor *p; p=(TGeoTrapEditor*)0x1000; if (p) { }
14855 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fH1i=",0,"Initial half length in y at low z");
14856 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBl1i=",0,"Initial half length in x at low z and y low edge");
14857 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTl1i=",0,"Initial half length in x at low z and y high edge");
14858 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fDzi=",0,"Initial Dz");
14859 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSci=",0,"Initial scale factor for upper face");
14860 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlpha1i=",0,"Initial angle between centers of x edges an y axis at low z");
14861 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fThetai=",0,"Initial theta");
14862 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPhii=",0,"Initial phi");
14863 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TString),-1,-1,2,"fNamei=",0,"Initial name");
14864 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrap),-1,-1,2,"fShape=",0,"Shape object");
14865 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsModified=",0,"Flag that volume was modified");
14866 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsShapeEditable=",0,"Flag that the shape can be changed");
14867 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextEntry),-1,-1,2,"fShapeName=",0,"Shape name text entry");
14868 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEH1=",0,"Number entry for H1 ");
14869 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEBl1=",0,"Number entry for Bl1");
14870 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETl1=",0,"Number entry for Tl1");
14871 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fESc1=",0,"Number entry for lower scale");
14872 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fESc2=",0,"Number entry for upper scale");
14873 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEDz=",0,"Number entry for DZ");
14874 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEAlpha1=",0,"Number entry for Alpha1");
14875 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETheta=",0,"Number entry for Theta ");
14876 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fEPhi=",0,"Number entry for Theta ");
14877 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept changes");
14878 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTextButton),-1,-1,2,"fUndo=",0,"Undo-Button");
14879 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fBFrame=",0,"Frame containing Apply/Undo");
14880 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCheckButton),-1,-1,2,"fDelayed=",0,"Check button for delayed draw");
14881 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame),-1,-1,2,"fDFrame=",0,"Frame containing Delayed draw");
14882 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14883 }
14884 G__tag_memvar_reset();
14885 }
14886
14887
14888
14889 static void G__setup_memvarTGeoGtraEditor(void) {
14890 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor));
14891 { TGeoGtraEditor *p; p=(TGeoGtraEditor*)0x1000; if (p) { }
14892 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fTwisti=",0,"Initial twist angle");
14893 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TGNumberEntry),-1,-1,2,"fETwist=",0,"Number entry for H1 ");
14894 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14895 }
14896 G__tag_memvar_reset();
14897 }
14898
14899 extern "C" void G__cpp_setup_memvarG__GeomBuilder() {
14900 }
14901
14902
14903
14904
14905
14906
14907
14908
14909
14910
14911
14912
14913 static void G__setup_memfuncTGeoTabManager(void) {
14914
14915 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager));
14916 G__memfunc_setup("GetEditors",1018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
14917 G__memfunc_setup("TGeoTabManager",1345,G__G__GeomBuilder_233_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager), -1, 0, 1, 1, 1, 0, "U 'TGedEditor' - 0 - ged", (char*)NULL, (void*) NULL, 0);
14918 G__memfunc_setup("GetMakeTabManager",1648,G__G__GeomBuilder_233_0_3, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTabManager), -1, 0, 1, 3, 1, 0, "U 'TGedEditor' - 0 - ged", (char*)NULL, (void*) G__func2void( (TGeoTabManager* (*)(TGedEditor*))(&TGeoTabManager::GetMakeTabManager) ), 0);
14919 G__memfunc_setup("Cleanup",712,G__G__GeomBuilder_233_0_4, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TGCompositeFrame' - 0 - frame", (char*)NULL, (void*) G__func2void( (void (*)(TGCompositeFrame*))(&TGeoTabManager::Cleanup) ), 0);
14920 G__memfunc_setup("GetPad",565,G__G__GeomBuilder_233_0_5, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14921 G__memfunc_setup("GetTab",567,G__G__GeomBuilder_233_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14922 G__memfunc_setup("GetTabIndex",1071,G__G__GeomBuilder_233_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14923 G__memfunc_setup("MoveFrame",898,G__G__GeomBuilder_233_0_8, 121, -1, -1, 0, 2, 3, 1, 0,
14924 "U 'TGCompositeFrame' - 0 - fr U 'TGCompositeFrame' - 0 - p", (char*)NULL, (void*) G__func2void( (void (*)(TGCompositeFrame*, TGCompositeFrame*))(&TGeoTabManager::MoveFrame) ), 0);
14925 G__memfunc_setup("SetVolTabEnabled",1567,G__G__GeomBuilder_233_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' flag", (char*)NULL, (void*) NULL, 0);
14926 G__memfunc_setup("SetModel",797,G__G__GeomBuilder_233_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 0);
14927 G__memfunc_setup("SetTab",579,G__G__GeomBuilder_233_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14928 G__memfunc_setup("GetShapeEditor",1400,G__G__GeomBuilder_233_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoShape' - 0 - shape", (char*)NULL, (void*) NULL, 0);
14929 G__memfunc_setup("GetVolumeEditor",1535,G__G__GeomBuilder_233_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoVolume' - 0 - vol", (char*)NULL, (void*) NULL, 0);
14930 G__memfunc_setup("GetMatrixEditor",1532,G__G__GeomBuilder_233_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMatrix' - 0 - matrix", (char*)NULL, (void*) NULL, 0);
14931 G__memfunc_setup("GetMediumEditor",1512,G__G__GeomBuilder_233_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMedium' - 0 - medium", (char*)NULL, (void*) NULL, 0);
14932 G__memfunc_setup("GetMaterialEditor",1718,G__G__GeomBuilder_233_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGeoMaterial' - 0 - material", (char*)NULL, (void*) NULL, 0);
14933 G__memfunc_setup("GetVolumeTab",1199,G__G__GeomBuilder_233_0_17, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14934 G__memfunc_setup("GetVolume",920,G__G__GeomBuilder_233_0_18, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolume), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14935 G__memfunc_setup("Class",502,G__G__GeomBuilder_233_0_19, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTabManager::Class) ), 0);
14936 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_233_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTabManager::Class_Name) ), 0);
14937 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_233_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTabManager::Class_Version) ), 0);
14938 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_233_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTabManager::Dictionary) ), 0);
14939 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14940 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14941 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14942 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_233_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14943 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_233_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTabManager::DeclFileName) ), 0);
14944 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_233_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTabManager::ImplFileLine) ), 0);
14945 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_233_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTabManager::ImplFileName) ), 0);
14946 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_233_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTabManager::DeclFileLine) ), 0);
14947
14948 G__memfunc_setup("~TGeoTabManager", 1471, G__G__GeomBuilder_233_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14949 G__tag_memfunc_reset();
14950 }
14951
14952 static void G__setup_memfuncTGeoGedFrame(void) {
14953
14954 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGedFrame));
14955 G__memfunc_setup("SetActive",904,G__G__GeomBuilder_234_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' active", (char*)NULL, (void*) NULL, 1);
14956 G__memfunc_setup("Update",611,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14957 G__memfunc_setup("Class",502,G__G__GeomBuilder_234_0_4, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoGedFrame::Class) ), 0);
14958 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_234_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGedFrame::Class_Name) ), 0);
14959 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_234_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoGedFrame::Class_Version) ), 0);
14960 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_234_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoGedFrame::Dictionary) ), 0);
14961 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14962 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
14963 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
14964 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_234_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14965 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_234_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGedFrame::DeclFileName) ), 0);
14966 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_234_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGedFrame::ImplFileLine) ), 0);
14967 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_234_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGedFrame::ImplFileName) ), 0);
14968 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_234_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGedFrame::DeclFileLine) ), 0);
14969
14970 G__memfunc_setup("~TGeoGedFrame", 1256, G__G__GeomBuilder_234_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
14971 G__tag_memfunc_reset();
14972 }
14973
14974 static void G__setup_memfuncTGeoVolumeEditor(void) {
14975
14976 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor));
14977 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
14978 G__memfunc_setup("TGeoVolumeEditor",1614,G__G__GeomBuilder_249_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeEditor), -1, 0, 5, 1, 1, 0,
14979 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14980 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14981 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14982 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
14983 G__memfunc_setup("ActivateBaseClassEditors",2428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
14984 G__memfunc_setup("DoAddNode",834,G__G__GeomBuilder_249_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14985 G__memfunc_setup("DoVolumeName",1196,G__G__GeomBuilder_249_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14986 G__memfunc_setup("DoSelectShape",1284,G__G__GeomBuilder_249_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14987 G__memfunc_setup("DoSelectMedium",1396,G__G__GeomBuilder_249_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14988 G__memfunc_setup("DoSelectMatrix",1416,G__G__GeomBuilder_249_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14989 G__memfunc_setup("DoSelectVolume",1419,G__G__GeomBuilder_249_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14990 G__memfunc_setup("DoEditShape",1066,G__G__GeomBuilder_249_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14991 G__memfunc_setup("DoEditMedium",1178,G__G__GeomBuilder_249_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14992 G__memfunc_setup("DoEditMatrix",1198,G__G__GeomBuilder_249_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14993 G__memfunc_setup("DoRemoveNode",1191,G__G__GeomBuilder_249_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14994 G__memfunc_setup("DoVisVolume",1117,G__G__GeomBuilder_249_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14995 G__memfunc_setup("DoVisDaughters",1420,G__G__GeomBuilder_249_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14996 G__memfunc_setup("DoVisAuto",894,G__G__GeomBuilder_249_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14997 G__memfunc_setup("DoVisLevel",989,G__G__GeomBuilder_249_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14998 G__memfunc_setup("DoViewAll",871,G__G__GeomBuilder_249_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14999 G__memfunc_setup("DoViewLeaves",1198,G__G__GeomBuilder_249_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15000 G__memfunc_setup("DoViewOnly",1008,G__G__GeomBuilder_249_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15001 G__memfunc_setup("DoDivSelAxis",1167,G__G__GeomBuilder_249_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15002 G__memfunc_setup("DoDivFromTo",1069,G__G__GeomBuilder_249_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15003 G__memfunc_setup("DoDivStep",882,G__G__GeomBuilder_249_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15004 G__memfunc_setup("DoDivN",548,G__G__GeomBuilder_249_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15005 G__memfunc_setup("DoDivName",855,G__G__GeomBuilder_249_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15006 G__memfunc_setup("DoApplyDiv",988,G__G__GeomBuilder_249_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15007 G__memfunc_setup("DoRaytrace",1006,G__G__GeomBuilder_249_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15008 G__memfunc_setup("Class",502,G__G__GeomBuilder_249_0_29, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoVolumeEditor::Class) ), 0);
15009 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_249_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeEditor::Class_Name) ), 0);
15010 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_249_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoVolumeEditor::Class_Version) ), 0);
15011 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_249_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoVolumeEditor::Dictionary) ), 0);
15012 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15013 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15014 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15015 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_249_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15016 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_249_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeEditor::DeclFileName) ), 0);
15017 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_249_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeEditor::ImplFileLine) ), 0);
15018 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_249_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeEditor::ImplFileName) ), 0);
15019 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_249_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeEditor::DeclFileLine) ), 0);
15020
15021 G__memfunc_setup("~TGeoVolumeEditor", 1740, G__G__GeomBuilder_249_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15022 G__tag_memfunc_reset();
15023 }
15024
15025 static void G__setup_memfuncTGeoBBoxEditor(void) {
15026
15027 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor));
15028 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15029 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15030 G__memfunc_setup("TGeoBBoxEditor",1345,G__G__GeomBuilder_251_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoBBoxEditor), -1, 0, 5, 1, 1, 0,
15031 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15032 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15033 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15034 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15035 G__memfunc_setup("DoDx",367,G__G__GeomBuilder_251_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15036 G__memfunc_setup("DoDy",368,G__G__GeomBuilder_251_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15037 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_251_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15038 G__memfunc_setup("DoOx",378,G__G__GeomBuilder_251_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15039 G__memfunc_setup("DoOy",379,G__G__GeomBuilder_251_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15040 G__memfunc_setup("DoOz",380,G__G__GeomBuilder_251_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15041 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_251_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15042 G__memfunc_setup("DoName",564,G__G__GeomBuilder_251_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15043 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_251_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15044 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_251_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15045 G__memfunc_setup("Class",502,G__G__GeomBuilder_251_0_15, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoBBoxEditor::Class) ), 0);
15046 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_251_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBoxEditor::Class_Name) ), 0);
15047 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_251_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoBBoxEditor::Class_Version) ), 0);
15048 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_251_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoBBoxEditor::Dictionary) ), 0);
15049 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15050 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15051 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15052 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_251_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15053 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_251_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBoxEditor::DeclFileName) ), 0);
15054 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_251_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBBoxEditor::ImplFileLine) ), 0);
15055 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_251_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoBBoxEditor::ImplFileName) ), 0);
15056 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_251_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoBBoxEditor::DeclFileLine) ), 0);
15057
15058 G__memfunc_setup("~TGeoBBoxEditor", 1471, G__G__GeomBuilder_251_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15059 G__tag_memfunc_reset();
15060 }
15061
15062 static void G__setup_memfuncTGeoMediumEditor(void) {
15063
15064 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor));
15065 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15066 G__memfunc_setup("TGeoMediumEditor",1591,G__G__GeomBuilder_252_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumEditor), -1, 0, 5, 1, 1, 0,
15067 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15068 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15069 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15070 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15071 G__memfunc_setup("DoEditMaterial",1384,G__G__GeomBuilder_252_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15072 G__memfunc_setup("DoSelectMaterial",1602,G__G__GeomBuilder_252_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15073 G__memfunc_setup("DoMedName",842,G__G__GeomBuilder_252_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15074 G__memfunc_setup("DoMedId",630,G__G__GeomBuilder_252_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15075 G__memfunc_setup("DoToggleSensitive",1743,G__G__GeomBuilder_252_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15076 G__memfunc_setup("DoMagfldSelect",1374,G__G__GeomBuilder_252_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ientry", (char*)NULL, (void*) NULL, 0);
15077 G__memfunc_setup("DoFieldm",772,G__G__GeomBuilder_252_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15078 G__memfunc_setup("DoTmaxfd",791,G__G__GeomBuilder_252_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15079 G__memfunc_setup("DoStemax",805,G__G__GeomBuilder_252_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15080 G__memfunc_setup("DoDeemax",775,G__G__GeomBuilder_252_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15081 G__memfunc_setup("DoEpsil",688,G__G__GeomBuilder_252_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15082 G__memfunc_setup("DoStmin",702,G__G__GeomBuilder_252_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15083 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_252_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15084 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_252_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15085 G__memfunc_setup("Class",502,G__G__GeomBuilder_252_0_18, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMediumEditor::Class) ), 0);
15086 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_252_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumEditor::Class_Name) ), 0);
15087 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_252_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMediumEditor::Class_Version) ), 0);
15088 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_252_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMediumEditor::Dictionary) ), 0);
15089 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15090 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15091 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15092 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_252_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15093 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_252_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumEditor::DeclFileName) ), 0);
15094 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_252_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMediumEditor::ImplFileLine) ), 0);
15095 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_252_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumEditor::ImplFileName) ), 0);
15096 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_252_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMediumEditor::DeclFileLine) ), 0);
15097
15098 G__memfunc_setup("~TGeoMediumEditor", 1717, G__G__GeomBuilder_252_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15099 G__tag_memfunc_reset();
15100 }
15101
15102 static void G__setup_memfuncTGeoNodeEditor(void) {
15103
15104 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor));
15105 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15106 G__memfunc_setup("TGeoNodeEditor",1372,G__G__GeomBuilder_254_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoNodeEditor), -1, 0, 5, 1, 1, 0,
15107 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15108 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15109 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15110 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15111 G__memfunc_setup("DoEditMother",1192,G__G__GeomBuilder_254_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15112 G__memfunc_setup("DoEditVolume",1201,G__G__GeomBuilder_254_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15113 G__memfunc_setup("DoEditMatrix",1198,G__G__GeomBuilder_254_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15114 G__memfunc_setup("DoSelectMother",1410,G__G__GeomBuilder_254_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15115 G__memfunc_setup("DoSelectVolume",1419,G__G__GeomBuilder_254_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15116 G__memfunc_setup("DoSelectMatrix",1416,G__G__GeomBuilder_254_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15117 G__memfunc_setup("DoNodeName",954,G__G__GeomBuilder_254_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15118 G__memfunc_setup("DoNodeNumber",1186,G__G__GeomBuilder_254_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15119 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_254_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15120 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_254_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15121 G__memfunc_setup("Class",502,G__G__GeomBuilder_254_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoNodeEditor::Class) ), 0);
15122 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_254_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeEditor::Class_Name) ), 0);
15123 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_254_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoNodeEditor::Class_Version) ), 0);
15124 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_254_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoNodeEditor::Dictionary) ), 0);
15125 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15126 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15127 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15128 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_254_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15129 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_254_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeEditor::DeclFileName) ), 0);
15130 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_254_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeEditor::ImplFileLine) ), 0);
15131 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_254_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoNodeEditor::ImplFileName) ), 0);
15132 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_254_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoNodeEditor::DeclFileLine) ), 0);
15133
15134 G__memfunc_setup("~TGeoNodeEditor", 1498, G__G__GeomBuilder_254_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15135 G__tag_memfunc_reset();
15136 }
15137
15138 static void G__setup_memfuncTGeoTranslationEditor(void) {
15139
15140 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor));
15141 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15142 G__memfunc_setup("TGeoTranslationEditor",2149,G__G__GeomBuilder_258_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTranslationEditor), -1, 0, 5, 1, 1, 0,
15143 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15144 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15145 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15146 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15147 G__memfunc_setup("DoDx",367,G__G__GeomBuilder_258_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15148 G__memfunc_setup("DoDy",368,G__G__GeomBuilder_258_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15149 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_258_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15150 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_258_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15151 G__memfunc_setup("DoName",564,G__G__GeomBuilder_258_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15152 G__memfunc_setup("DoParameters",1223,G__G__GeomBuilder_258_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15153 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_258_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15154 G__memfunc_setup("DoCancel",761,G__G__GeomBuilder_258_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15155 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_258_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15156 G__memfunc_setup("Class",502,G__G__GeomBuilder_258_0_13, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTranslationEditor::Class) ), 0);
15157 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_258_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslationEditor::Class_Name) ), 0);
15158 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_258_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTranslationEditor::Class_Version) ), 0);
15159 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_258_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTranslationEditor::Dictionary) ), 0);
15160 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15161 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15162 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15163 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_258_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15164 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_258_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslationEditor::DeclFileName) ), 0);
15165 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_258_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTranslationEditor::ImplFileLine) ), 0);
15166 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_258_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTranslationEditor::ImplFileName) ), 0);
15167 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_258_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTranslationEditor::DeclFileLine) ), 0);
15168
15169 G__memfunc_setup("~TGeoTranslationEditor", 2275, G__G__GeomBuilder_258_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15170 G__tag_memfunc_reset();
15171 }
15172
15173 static void G__setup_memfuncTGeoRotationEditor(void) {
15174
15175 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor));
15176 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15177 G__memfunc_setup("TGeoRotationEditor",1830,G__G__GeomBuilder_259_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoRotationEditor), -1, 0, 5, 1, 1, 0,
15178 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15179 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15180 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15181 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15182 G__memfunc_setup("DoRotPhi",777,G__G__GeomBuilder_259_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15183 G__memfunc_setup("DoRotTheta",990,G__G__GeomBuilder_259_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15184 G__memfunc_setup("DoRotPsi",788,G__G__GeomBuilder_259_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15185 G__memfunc_setup("DoRotAngle",975,G__G__GeomBuilder_259_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15186 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_259_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15187 G__memfunc_setup("DoName",564,G__G__GeomBuilder_259_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15188 G__memfunc_setup("DoParameters",1223,G__G__GeomBuilder_259_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15189 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_259_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15190 G__memfunc_setup("DoCancel",761,G__G__GeomBuilder_259_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15191 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_259_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15192 G__memfunc_setup("Class",502,G__G__GeomBuilder_259_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoRotationEditor::Class) ), 0);
15193 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_259_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotationEditor::Class_Name) ), 0);
15194 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_259_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoRotationEditor::Class_Version) ), 0);
15195 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_259_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoRotationEditor::Dictionary) ), 0);
15196 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15197 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15198 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15199 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_259_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15200 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_259_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotationEditor::DeclFileName) ), 0);
15201 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_259_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoRotationEditor::ImplFileLine) ), 0);
15202 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_259_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoRotationEditor::ImplFileName) ), 0);
15203 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_259_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoRotationEditor::DeclFileLine) ), 0);
15204
15205 G__memfunc_setup("~TGeoRotationEditor", 1956, G__G__GeomBuilder_259_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15206 G__tag_memfunc_reset();
15207 }
15208
15209 static void G__setup_memfuncTGeoCombiTransEditor(void) {
15210
15211 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor));
15212 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15213 G__memfunc_setup("TGeoCombiTransEditor",1992,G__G__GeomBuilder_260_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCombiTransEditor), -1, 0, 5, 1, 1, 0,
15214 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15215 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15216 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15217 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15218 G__memfunc_setup("DoDx",367,G__G__GeomBuilder_260_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15219 G__memfunc_setup("DoDy",368,G__G__GeomBuilder_260_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15220 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_260_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15221 G__memfunc_setup("DoRotPhi",777,G__G__GeomBuilder_260_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15222 G__memfunc_setup("DoRotTheta",990,G__G__GeomBuilder_260_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15223 G__memfunc_setup("DoRotPsi",788,G__G__GeomBuilder_260_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15224 G__memfunc_setup("DoRotAngle",975,G__G__GeomBuilder_260_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15225 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_260_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15226 G__memfunc_setup("DoName",564,G__G__GeomBuilder_260_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15227 G__memfunc_setup("DoParameters",1223,G__G__GeomBuilder_260_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15228 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_260_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15229 G__memfunc_setup("DoCancel",761,G__G__GeomBuilder_260_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15230 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_260_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15231 G__memfunc_setup("Class",502,G__G__GeomBuilder_260_0_17, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCombiTransEditor::Class) ), 0);
15232 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_260_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTransEditor::Class_Name) ), 0);
15233 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_260_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCombiTransEditor::Class_Version) ), 0);
15234 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_260_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCombiTransEditor::Dictionary) ), 0);
15235 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15236 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15237 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15238 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_260_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15239 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_260_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTransEditor::DeclFileName) ), 0);
15240 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_260_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCombiTransEditor::ImplFileLine) ), 0);
15241 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_260_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCombiTransEditor::ImplFileName) ), 0);
15242 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_260_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCombiTransEditor::DeclFileLine) ), 0);
15243
15244 G__memfunc_setup("~TGeoCombiTransEditor", 2118, G__G__GeomBuilder_260_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15245 G__tag_memfunc_reset();
15246 }
15247
15248 static void G__setup_memfuncTGeoManagerEditor(void) {
15249
15250 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor));
15251 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15252 G__memfunc_setup("ShowSelectShape",1522,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
15253 G__memfunc_setup("ShowSelectVolume",1657,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
15254 G__memfunc_setup("ShowSelectMaterial",1840,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
15255 G__memfunc_setup("ShowSelectMedium",1634,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
15256 G__memfunc_setup("ShowSelectMatrix",1654,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' show", (char*)NULL, (void*) NULL, 0);
15257 G__memfunc_setup("TGeoManagerEditor",1681,G__G__GeomBuilder_261_0_7, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoManagerEditor), -1, 0, 5, 1, 1, 0,
15258 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15259 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15260 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15261 G__memfunc_setup("LoadLib",663,G__G__GeomBuilder_261_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoManagerEditor::LoadLib) ), 0);
15262 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15263 G__memfunc_setup("SelectedSlot",1227,G__G__GeomBuilder_261_0_10, 121, -1, -1, 0, 3, 1, 1, 0,
15264 "U 'TVirtualPad' - 0 - pad U 'TObject' - 0 - obj "
15265 "i - 'Int_t' 0 - event", (char*)NULL, (void*) NULL, 1);
15266 G__memfunc_setup("ConnectSelected",1523,G__G__GeomBuilder_261_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 - c", (char*)NULL, (void*) NULL, 0);
15267 G__memfunc_setup("DisconnectSelected",1843,G__G__GeomBuilder_261_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15268 G__memfunc_setup("DoName",564,G__G__GeomBuilder_261_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15269 G__memfunc_setup("DoCreateBox",1072,G__G__GeomBuilder_261_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15270 G__memfunc_setup("DoCreatePara",1163,G__G__GeomBuilder_261_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15271 G__memfunc_setup("DoCreateTrd1",1122,G__G__GeomBuilder_261_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15272 G__memfunc_setup("DoCreateTrd2",1123,G__G__GeomBuilder_261_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15273 G__memfunc_setup("DoCreateTrap",1182,G__G__GeomBuilder_261_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15274 G__memfunc_setup("DoCreateGtra",1173,G__G__GeomBuilder_261_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15275 G__memfunc_setup("DoCreateXtru",1210,G__G__GeomBuilder_261_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15276 G__memfunc_setup("DoCreateArb8",1108,G__G__GeomBuilder_261_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15277 G__memfunc_setup("DoCreateTube",1175,G__G__GeomBuilder_261_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15278 G__memfunc_setup("DoCreateTubs",1189,G__G__GeomBuilder_261_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15279 G__memfunc_setup("DoCreateCone",1164,G__G__GeomBuilder_261_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15280 G__memfunc_setup("DoCreateCons",1178,G__G__GeomBuilder_261_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15281 G__memfunc_setup("DoCreateSphe",1175,G__G__GeomBuilder_261_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15282 G__memfunc_setup("DoCreateCtub",1173,G__G__GeomBuilder_261_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15283 G__memfunc_setup("DoCreateEltu",1185,G__G__GeomBuilder_261_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15284 G__memfunc_setup("DoCreateTorus",1316,G__G__GeomBuilder_261_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15285 G__memfunc_setup("DoCreatePcon",1175,G__G__GeomBuilder_261_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15286 G__memfunc_setup("DoCreatePgon",1179,G__G__GeomBuilder_261_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15287 G__memfunc_setup("DoCreateHype",1181,G__G__GeomBuilder_261_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15288 G__memfunc_setup("DoCreateParab",1261,G__G__GeomBuilder_261_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15289 G__memfunc_setup("DoCreateComposite",1722,G__G__GeomBuilder_261_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15290 G__memfunc_setup("DoCreateMaterial",1590,G__G__GeomBuilder_261_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15291 G__memfunc_setup("DoCreateMixture",1525,G__G__GeomBuilder_261_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15292 G__memfunc_setup("DoCreateMedium",1384,G__G__GeomBuilder_261_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15293 G__memfunc_setup("DoCreateTranslation",1942,G__G__GeomBuilder_261_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15294 G__memfunc_setup("DoCreateRotation",1623,G__G__GeomBuilder_261_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15295 G__memfunc_setup("DoCreateCombi",1265,G__G__GeomBuilder_261_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15296 G__memfunc_setup("DoCreateVolume",1407,G__G__GeomBuilder_261_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15297 G__memfunc_setup("DoCreateAssembly",1607,G__G__GeomBuilder_261_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15298 G__memfunc_setup("DoEditShape",1066,G__G__GeomBuilder_261_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15299 G__memfunc_setup("DoEditVolume",1201,G__G__GeomBuilder_261_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15300 G__memfunc_setup("DoEditMedium",1178,G__G__GeomBuilder_261_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15301 G__memfunc_setup("DoEditMaterial",1384,G__G__GeomBuilder_261_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15302 G__memfunc_setup("DoEditMatrix",1198,G__G__GeomBuilder_261_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15303 G__memfunc_setup("DoSelectShape",1284,G__G__GeomBuilder_261_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15304 G__memfunc_setup("DoSelectShape2",1334,G__G__GeomBuilder_261_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15305 G__memfunc_setup("DoSelectVolume",1419,G__G__GeomBuilder_261_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15306 G__memfunc_setup("DoSelectMatrix",1416,G__G__GeomBuilder_261_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15307 G__memfunc_setup("DoSelectMaterial",1602,G__G__GeomBuilder_261_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15308 G__memfunc_setup("DoSelectMaterial2",1652,G__G__GeomBuilder_261_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15309 G__memfunc_setup("DoSelectMedium",1396,G__G__GeomBuilder_261_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15310 G__memfunc_setup("DoSelectMedium2",1446,G__G__GeomBuilder_261_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15311 G__memfunc_setup("DoSetTopVolume",1418,G__G__GeomBuilder_261_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15312 G__memfunc_setup("DoSelectTopVolume",1726,G__G__GeomBuilder_261_0_57, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15313 G__memfunc_setup("DoExportGeometry",1665,G__G__GeomBuilder_261_0_58, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15314 G__memfunc_setup("DoCloseGeometry",1525,G__G__GeomBuilder_261_0_59, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15315 G__memfunc_setup("Class",502,G__G__GeomBuilder_261_0_60, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoManagerEditor::Class) ), 0);
15316 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_261_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManagerEditor::Class_Name) ), 0);
15317 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_261_0_62, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoManagerEditor::Class_Version) ), 0);
15318 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_261_0_63, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoManagerEditor::Dictionary) ), 0);
15319 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15320 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15321 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15322 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_261_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15323 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_261_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManagerEditor::DeclFileName) ), 0);
15324 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_261_0_69, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoManagerEditor::ImplFileLine) ), 0);
15325 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_261_0_70, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoManagerEditor::ImplFileName) ), 0);
15326 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_261_0_71, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoManagerEditor::DeclFileLine) ), 0);
15327
15328 G__memfunc_setup("~TGeoManagerEditor", 1807, G__G__GeomBuilder_261_0_72, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15329 G__tag_memfunc_reset();
15330 }
15331
15332 static void G__setup_memfuncTGeoTubeEditor(void) {
15333
15334 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor));
15335 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15336 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15337 G__memfunc_setup("TGeoTubeEditor",1382,G__G__GeomBuilder_263_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeEditor), -1, 0, 5, 1, 1, 0,
15338 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15339 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15340 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15341 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15342 G__memfunc_setup("DoRmin",585,G__G__GeomBuilder_263_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15343 G__memfunc_setup("DoRmax",587,G__G__GeomBuilder_263_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15344 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_263_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15345 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_263_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15346 G__memfunc_setup("DoName",564,G__G__GeomBuilder_263_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15347 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_263_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15348 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_263_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15349 G__memfunc_setup("Class",502,G__G__GeomBuilder_263_0_12, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTubeEditor::Class) ), 0);
15350 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_263_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeEditor::Class_Name) ), 0);
15351 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_263_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTubeEditor::Class_Version) ), 0);
15352 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_263_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTubeEditor::Dictionary) ), 0);
15353 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15354 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15355 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15356 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_263_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15357 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_263_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeEditor::DeclFileName) ), 0);
15358 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_263_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeEditor::ImplFileLine) ), 0);
15359 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_263_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeEditor::ImplFileName) ), 0);
15360 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_263_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeEditor::DeclFileLine) ), 0);
15361
15362 G__memfunc_setup("~TGeoTubeEditor", 1508, G__G__GeomBuilder_263_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15363 G__tag_memfunc_reset();
15364 }
15365
15366 static void G__setup_memfuncTGeoTubeSegEditor(void) {
15367
15368 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor));
15369 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15370 G__memfunc_setup("TGeoTubeSegEditor",1669,G__G__GeomBuilder_265_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTubeSegEditor), -1, 0, 5, 1, 1, 0,
15371 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15372 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15373 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15374 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15375 G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_265_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15376 G__memfunc_setup("DoPhi1",517,G__G__GeomBuilder_265_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15377 G__memfunc_setup("DoPhi2",518,G__G__GeomBuilder_265_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15378 G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15379 G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15380 G__memfunc_setup("Class",502,G__G__GeomBuilder_265_0_9, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTubeSegEditor::Class) ), 0);
15381 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_265_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSegEditor::Class_Name) ), 0);
15382 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_265_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTubeSegEditor::Class_Version) ), 0);
15383 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_265_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTubeSegEditor::Dictionary) ), 0);
15384 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15385 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15386 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15387 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_265_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15388 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_265_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSegEditor::DeclFileName) ), 0);
15389 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_265_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeSegEditor::ImplFileLine) ), 0);
15390 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_265_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTubeSegEditor::ImplFileName) ), 0);
15391 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_265_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTubeSegEditor::DeclFileLine) ), 0);
15392
15393 G__memfunc_setup("~TGeoTubeSegEditor", 1795, G__G__GeomBuilder_265_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15394 G__tag_memfunc_reset();
15395 }
15396
15397 static void G__setup_memfuncTGeoCtubEditor(void) {
15398
15399 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor));
15400 G__memfunc_setup("TGeoCtubEditor",1380,G__G__GeomBuilder_266_0_1, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoCtubEditor), -1, 0, 5, 1, 1, 0,
15401 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15402 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15403 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15404 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15405 G__memfunc_setup("DoThlo",586,G__G__GeomBuilder_266_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15406 G__memfunc_setup("DoPhlo",582,G__G__GeomBuilder_266_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15407 G__memfunc_setup("DoThhi",576,G__G__GeomBuilder_266_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15408 G__memfunc_setup("DoPhhi",572,G__G__GeomBuilder_266_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15409 G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15410 G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15411 G__memfunc_setup("Class",502,G__G__GeomBuilder_266_0_9, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoCtubEditor::Class) ), 0);
15412 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_266_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtubEditor::Class_Name) ), 0);
15413 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_266_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoCtubEditor::Class_Version) ), 0);
15414 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_266_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoCtubEditor::Dictionary) ), 0);
15415 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15416 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15417 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15418 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_266_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15419 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_266_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtubEditor::DeclFileName) ), 0);
15420 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_266_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCtubEditor::ImplFileLine) ), 0);
15421 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_266_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoCtubEditor::ImplFileName) ), 0);
15422 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_266_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoCtubEditor::DeclFileLine) ), 0);
15423
15424 G__memfunc_setup("~TGeoCtubEditor", 1506, G__G__GeomBuilder_266_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15425 G__tag_memfunc_reset();
15426 }
15427
15428 static void G__setup_memfuncTGeoConeEditor(void) {
15429
15430 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor));
15431 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15432 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15433 G__memfunc_setup("TGeoConeEditor",1371,G__G__GeomBuilder_269_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeEditor), -1, 0, 5, 1, 1, 0,
15434 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15435 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15436 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15437 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15438 G__memfunc_setup("DoRmin1",634,G__G__GeomBuilder_269_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15439 G__memfunc_setup("DoRmin2",635,G__G__GeomBuilder_269_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15440 G__memfunc_setup("DoRmax1",636,G__G__GeomBuilder_269_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15441 G__memfunc_setup("DoRmax2",637,G__G__GeomBuilder_269_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15442 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_269_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15443 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_269_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15444 G__memfunc_setup("DoName",564,G__G__GeomBuilder_269_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15445 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_269_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15446 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_269_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15447 G__memfunc_setup("Class",502,G__G__GeomBuilder_269_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoConeEditor::Class) ), 0);
15448 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_269_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeEditor::Class_Name) ), 0);
15449 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_269_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoConeEditor::Class_Version) ), 0);
15450 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_269_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoConeEditor::Dictionary) ), 0);
15451 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15452 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15453 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15454 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_269_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15455 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_269_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeEditor::DeclFileName) ), 0);
15456 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_269_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeEditor::ImplFileLine) ), 0);
15457 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_269_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeEditor::ImplFileName) ), 0);
15458 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_269_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeEditor::DeclFileLine) ), 0);
15459
15460 G__memfunc_setup("~TGeoConeEditor", 1497, G__G__GeomBuilder_269_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15461 G__tag_memfunc_reset();
15462 }
15463
15464 static void G__setup_memfuncTGeoConeSegEditor(void) {
15465
15466 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor));
15467 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15468 G__memfunc_setup("TGeoConeSegEditor",1658,G__G__GeomBuilder_270_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoConeSegEditor), -1, 0, 5, 1, 1, 0,
15469 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15470 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15471 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15472 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15473 G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_270_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15474 G__memfunc_setup("DoPhi1",517,G__G__GeomBuilder_270_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15475 G__memfunc_setup("DoPhi2",518,G__G__GeomBuilder_270_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15476 G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15477 G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15478 G__memfunc_setup("Class",502,G__G__GeomBuilder_270_0_9, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoConeSegEditor::Class) ), 0);
15479 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_270_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSegEditor::Class_Name) ), 0);
15480 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_270_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoConeSegEditor::Class_Version) ), 0);
15481 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_270_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoConeSegEditor::Dictionary) ), 0);
15482 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15483 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15484 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15485 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_270_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15486 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_270_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSegEditor::DeclFileName) ), 0);
15487 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_270_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeSegEditor::ImplFileLine) ), 0);
15488 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_270_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoConeSegEditor::ImplFileName) ), 0);
15489 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_270_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoConeSegEditor::DeclFileLine) ), 0);
15490
15491 G__memfunc_setup("~TGeoConeSegEditor", 1784, G__G__GeomBuilder_270_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15492 G__tag_memfunc_reset();
15493 }
15494
15495 static void G__setup_memfuncTGeoTrd1Editor(void) {
15496
15497 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor));
15498 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15499 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15500 G__memfunc_setup("TGeoTrd1Editor",1329,G__G__GeomBuilder_272_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd1Editor), -1, 0, 5, 1, 1, 0,
15501 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15502 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15503 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15504 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15505 G__memfunc_setup("DoDx1",416,G__G__GeomBuilder_272_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15506 G__memfunc_setup("DoDx2",417,G__G__GeomBuilder_272_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15507 G__memfunc_setup("DoDy",368,G__G__GeomBuilder_272_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15508 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_272_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15509 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_272_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15510 G__memfunc_setup("DoName",564,G__G__GeomBuilder_272_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15511 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_272_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15512 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_272_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15513 G__memfunc_setup("Class",502,G__G__GeomBuilder_272_0_13, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrd1Editor::Class) ), 0);
15514 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_272_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1Editor::Class_Name) ), 0);
15515 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_272_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrd1Editor::Class_Version) ), 0);
15516 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_272_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrd1Editor::Dictionary) ), 0);
15517 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15518 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15519 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15520 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_272_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15521 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_272_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1Editor::DeclFileName) ), 0);
15522 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_272_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd1Editor::ImplFileLine) ), 0);
15523 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_272_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd1Editor::ImplFileName) ), 0);
15524 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_272_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd1Editor::DeclFileLine) ), 0);
15525
15526 G__memfunc_setup("~TGeoTrd1Editor", 1455, G__G__GeomBuilder_272_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15527 G__tag_memfunc_reset();
15528 }
15529
15530 static void G__setup_memfuncTGeoTrd2Editor(void) {
15531
15532 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor));
15533 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15534 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15535 G__memfunc_setup("TGeoTrd2Editor",1330,G__G__GeomBuilder_274_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrd2Editor), -1, 0, 5, 1, 1, 0,
15536 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15537 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15538 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15539 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15540 G__memfunc_setup("DoDx1",416,G__G__GeomBuilder_274_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15541 G__memfunc_setup("DoDx2",417,G__G__GeomBuilder_274_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15542 G__memfunc_setup("DoDy1",417,G__G__GeomBuilder_274_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15543 G__memfunc_setup("DoDy2",418,G__G__GeomBuilder_274_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15544 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_274_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15545 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_274_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15546 G__memfunc_setup("DoName",564,G__G__GeomBuilder_274_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15547 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_274_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15548 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_274_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15549 G__memfunc_setup("Class",502,G__G__GeomBuilder_274_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrd2Editor::Class) ), 0);
15550 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_274_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2Editor::Class_Name) ), 0);
15551 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_274_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrd2Editor::Class_Version) ), 0);
15552 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_274_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrd2Editor::Dictionary) ), 0);
15553 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15554 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15555 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15556 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_274_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15557 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_274_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2Editor::DeclFileName) ), 0);
15558 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_274_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd2Editor::ImplFileLine) ), 0);
15559 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_274_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrd2Editor::ImplFileName) ), 0);
15560 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_274_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrd2Editor::DeclFileLine) ), 0);
15561
15562 G__memfunc_setup("~TGeoTrd2Editor", 1456, G__G__GeomBuilder_274_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15563 G__tag_memfunc_reset();
15564 }
15565
15566 static void G__setup_memfuncTGeoMaterialEditor(void) {
15567
15568 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor));
15569 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15570 G__memfunc_setup("TGeoMaterialEditor",1797,G__G__GeomBuilder_276_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialEditor), -1, 0, 5, 1, 1, 0,
15571 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15572 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15573 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15574 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15575 G__memfunc_setup("DoA",244,G__G__GeomBuilder_276_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15576 G__memfunc_setup("DoZ",269,G__G__GeomBuilder_276_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15577 G__memfunc_setup("DoDensity",915,G__G__GeomBuilder_276_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15578 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_276_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15579 G__memfunc_setup("DoName",564,G__G__GeomBuilder_276_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15580 G__memfunc_setup("DoRadAbs",736,G__G__GeomBuilder_276_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15581 G__memfunc_setup("DoState",692,G__G__GeomBuilder_276_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - state", (char*)NULL, (void*) NULL, 0);
15582 G__memfunc_setup("DoTemperature",1345,G__G__GeomBuilder_276_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15583 G__memfunc_setup("DoPressure",1036,G__G__GeomBuilder_276_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15584 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_276_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15585 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_276_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15586 G__memfunc_setup("Class",502,G__G__GeomBuilder_276_0_15, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMaterialEditor::Class) ), 0);
15587 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_276_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialEditor::Class_Name) ), 0);
15588 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_276_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMaterialEditor::Class_Version) ), 0);
15589 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_276_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMaterialEditor::Dictionary) ), 0);
15590 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15591 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15592 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15593 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_276_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15594 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_276_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialEditor::DeclFileName) ), 0);
15595 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_276_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterialEditor::ImplFileLine) ), 0);
15596 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_276_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialEditor::ImplFileName) ), 0);
15597 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_276_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterialEditor::DeclFileLine) ), 0);
15598
15599 G__memfunc_setup("~TGeoMaterialEditor", 1923, G__G__GeomBuilder_276_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15600 G__tag_memfunc_reset();
15601 }
15602
15603 static void G__setup_memfuncTGeoMixtureEditor(void) {
15604
15605 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor));
15606 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15607 G__memfunc_setup("TGeoMixtureEditor",1732,G__G__GeomBuilder_278_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMixtureEditor), -1, 0, 5, 1, 1, 0,
15608 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15609 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15610 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15611 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15612 G__memfunc_setup("UpdateElements",1440,G__G__GeomBuilder_278_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15613 G__memfunc_setup("DoApply1",746,G__G__GeomBuilder_278_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15614 G__memfunc_setup("DoUndo1",634,G__G__GeomBuilder_278_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15615 G__memfunc_setup("DoChkFraction",1279,G__G__GeomBuilder_278_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15616 G__memfunc_setup("DoChkNatoms",1083,G__G__GeomBuilder_278_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15617 G__memfunc_setup("DoFraction",1001,G__G__GeomBuilder_278_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15618 G__memfunc_setup("DoNatoms",805,G__G__GeomBuilder_278_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15619 G__memfunc_setup("DoSelectElement",1501,G__G__GeomBuilder_278_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - iel", (char*)NULL, (void*) NULL, 0);
15620 G__memfunc_setup("DoAddElem",831,G__G__GeomBuilder_278_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15621 G__memfunc_setup("Class",502,G__G__GeomBuilder_278_0_13, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMixtureEditor::Class) ), 0);
15622 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_278_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixtureEditor::Class_Name) ), 0);
15623 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_278_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMixtureEditor::Class_Version) ), 0);
15624 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_278_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMixtureEditor::Dictionary) ), 0);
15625 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15626 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15627 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15628 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_278_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15629 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_278_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixtureEditor::DeclFileName) ), 0);
15630 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_278_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMixtureEditor::ImplFileLine) ), 0);
15631 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_278_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMixtureEditor::ImplFileName) ), 0);
15632 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_278_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMixtureEditor::DeclFileLine) ), 0);
15633
15634 G__memfunc_setup("~TGeoMixtureEditor", 1858, G__G__GeomBuilder_278_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15635 G__tag_memfunc_reset();
15636 }
15637
15638 static void G__setup_memfuncTGeoTreeDialog(void) {
15639
15640 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTreeDialog));
15641 G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
15642 G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
15643 G__memfunc_setup("GetSelected",1097,G__G__GeomBuilder_286_0_4, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TObject* (*)())(&TGeoTreeDialog::GetSelected) ), 0);
15644 G__memfunc_setup("DoClose",681,G__G__GeomBuilder_286_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
15645 G__memfunc_setup("DoItemClick",1064,G__G__GeomBuilder_286_0_6, 121, -1, -1, 0, 2, 1, 1, 0,
15646 "U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 3);
15647 G__memfunc_setup("DoSelect",787,G__G__GeomBuilder_286_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGListTreeItem' - 0 - item", (char*)NULL, (void*) NULL, 0);
15648 G__memfunc_setup("Class",502,G__G__GeomBuilder_286_0_8, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTreeDialog::Class) ), 0);
15649 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_286_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTreeDialog::Class_Name) ), 0);
15650 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_286_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTreeDialog::Class_Version) ), 0);
15651 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_286_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTreeDialog::Dictionary) ), 0);
15652 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15653 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15654 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15655 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_286_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15656 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_286_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTreeDialog::DeclFileName) ), 0);
15657 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_286_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTreeDialog::ImplFileLine) ), 0);
15658 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_286_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTreeDialog::ImplFileName) ), 0);
15659 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_286_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTreeDialog::DeclFileLine) ), 0);
15660
15661 G__memfunc_setup("~TGeoTreeDialog", 1485, G__G__GeomBuilder_286_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15662 G__tag_memfunc_reset();
15663 }
15664
15665 static void G__setup_memfuncTGeoTransientPanel(void) {
15666
15667 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel));
15668 G__memfunc_setup("TGeoTransientPanel",1815,G__G__GeomBuilder_287_0_1, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTransientPanel), -1, 0, 3, 1, 1, 0,
15669 "U 'TGedEditor' - 0 - ged C - - 10 - name "
15670 "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
15671 G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15672 G__memfunc_setup("DeleteEditors",1325,G__G__GeomBuilder_287_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15673 G__memfunc_setup("GetTab",567,G__G__GeomBuilder_287_0_4, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15674 G__memfunc_setup("GetStyle",817,G__G__GeomBuilder_287_0_5, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGCompositeFrame), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15675 G__memfunc_setup("GetModel",785,G__G__GeomBuilder_287_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15676 G__memfunc_setup("GetEditors",1018,G__G__GeomBuilder_287_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 0);
15677 G__memfunc_setup("Hide",378,G__G__GeomBuilder_287_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15678 G__memfunc_setup("Show",417,G__G__GeomBuilder_287_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15679 G__memfunc_setup("SetModel",797,G__G__GeomBuilder_287_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 0);
15680 G__memfunc_setup("Class",502,G__G__GeomBuilder_287_0_11, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTransientPanel::Class) ), 0);
15681 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_287_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTransientPanel::Class_Name) ), 0);
15682 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_287_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTransientPanel::Class_Version) ), 0);
15683 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_287_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTransientPanel::Dictionary) ), 0);
15684 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15685 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15686 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15687 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_287_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15688 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_287_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTransientPanel::DeclFileName) ), 0);
15689 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_287_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTransientPanel::ImplFileLine) ), 0);
15690 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_287_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTransientPanel::ImplFileName) ), 0);
15691 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_287_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTransientPanel::DeclFileLine) ), 0);
15692
15693 G__memfunc_setup("~TGeoTransientPanel", 1941, G__G__GeomBuilder_287_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15694 G__tag_memfunc_reset();
15695 }
15696
15697 static void G__setup_memfuncTGeoVolumeDialog(void) {
15698
15699 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog));
15700 G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15701 G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15702 G__memfunc_setup("TGeoVolumeDialog",1591,G__G__GeomBuilder_288_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoVolumeDialog), -1, 0, 4, 1, 1, 0,
15703 "U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
15704 "h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
15705 G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15706 G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15707 "U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
15708 G__memfunc_setup("Class",502,G__G__GeomBuilder_288_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoVolumeDialog::Class) ), 0);
15709 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_288_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeDialog::Class_Name) ), 0);
15710 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_288_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoVolumeDialog::Class_Version) ), 0);
15711 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_288_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoVolumeDialog::Dictionary) ), 0);
15712 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15713 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15714 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15715 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_288_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15716 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_288_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeDialog::DeclFileName) ), 0);
15717 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_288_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeDialog::ImplFileLine) ), 0);
15718 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_288_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoVolumeDialog::ImplFileName) ), 0);
15719 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_288_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoVolumeDialog::DeclFileLine) ), 0);
15720
15721 G__memfunc_setup("~TGeoVolumeDialog", 1717, G__G__GeomBuilder_288_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15722 G__tag_memfunc_reset();
15723 }
15724
15725 static void G__setup_memfuncTGeoShapeDialog(void) {
15726
15727 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog));
15728 G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15729 G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15730 G__memfunc_setup("TGeoShapeDialog",1456,G__G__GeomBuilder_289_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoShapeDialog), -1, 0, 4, 1, 1, 0,
15731 "U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
15732 "h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
15733 G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15734 G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15735 "U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
15736 G__memfunc_setup("Class",502,G__G__GeomBuilder_289_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoShapeDialog::Class) ), 0);
15737 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_289_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeDialog::Class_Name) ), 0);
15738 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_289_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoShapeDialog::Class_Version) ), 0);
15739 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_289_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoShapeDialog::Dictionary) ), 0);
15740 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15741 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15742 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15743 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_289_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15744 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_289_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeDialog::DeclFileName) ), 0);
15745 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_289_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoShapeDialog::ImplFileLine) ), 0);
15746 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_289_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoShapeDialog::ImplFileName) ), 0);
15747 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_289_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoShapeDialog::DeclFileLine) ), 0);
15748
15749 G__memfunc_setup("~TGeoShapeDialog", 1582, G__G__GeomBuilder_289_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15750 G__tag_memfunc_reset();
15751 }
15752
15753 static void G__setup_memfuncTGeoMediumDialog(void) {
15754
15755 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog));
15756 G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15757 G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15758 G__memfunc_setup("TGeoMediumDialog",1568,G__G__GeomBuilder_290_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMediumDialog), -1, 0, 4, 1, 1, 0,
15759 "U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
15760 "h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
15761 G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15762 G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15763 "U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
15764 G__memfunc_setup("Class",502,G__G__GeomBuilder_290_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMediumDialog::Class) ), 0);
15765 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_290_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumDialog::Class_Name) ), 0);
15766 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_290_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMediumDialog::Class_Version) ), 0);
15767 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_290_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMediumDialog::Dictionary) ), 0);
15768 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15769 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15770 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15771 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_290_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15772 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_290_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumDialog::DeclFileName) ), 0);
15773 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_290_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMediumDialog::ImplFileLine) ), 0);
15774 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_290_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMediumDialog::ImplFileName) ), 0);
15775 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_290_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMediumDialog::DeclFileLine) ), 0);
15776
15777 G__memfunc_setup("~TGeoMediumDialog", 1694, G__G__GeomBuilder_290_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15778 G__tag_memfunc_reset();
15779 }
15780
15781 static void G__setup_memfuncTGeoMaterialDialog(void) {
15782
15783 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog));
15784 G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15785 G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15786 G__memfunc_setup("TGeoMaterialDialog",1774,G__G__GeomBuilder_291_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMaterialDialog), -1, 0, 4, 1, 1, 0,
15787 "U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
15788 "h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
15789 G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15790 G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15791 "U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
15792 G__memfunc_setup("Class",502,G__G__GeomBuilder_291_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMaterialDialog::Class) ), 0);
15793 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_291_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialDialog::Class_Name) ), 0);
15794 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_291_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMaterialDialog::Class_Version) ), 0);
15795 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_291_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMaterialDialog::Dictionary) ), 0);
15796 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15797 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15798 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15799 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_291_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15800 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_291_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialDialog::DeclFileName) ), 0);
15801 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_291_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterialDialog::ImplFileLine) ), 0);
15802 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_291_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMaterialDialog::ImplFileName) ), 0);
15803 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_291_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMaterialDialog::DeclFileLine) ), 0);
15804
15805 G__memfunc_setup("~TGeoMaterialDialog", 1900, G__G__GeomBuilder_291_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15806 G__tag_memfunc_reset();
15807 }
15808
15809 static void G__setup_memfuncTGeoMatrixDialog(void) {
15810
15811 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog));
15812 G__memfunc_setup("BuildListTree",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15813 G__memfunc_setup("ConnectSignalsToSlots",2163,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15814 G__memfunc_setup("TGeoMatrixDialog",1588,G__G__GeomBuilder_292_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoMatrixDialog), -1, 0, 4, 1, 1, 0,
15815 "U 'TGFrame' - 0 - caller U 'TGWindow' - 10 - main "
15816 "h - 'UInt_t' 0 '1' w h - 'UInt_t' 0 '1' h", (char*)NULL, (void*) NULL, 0);
15817 G__memfunc_setup("DoClose",681,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15818 G__memfunc_setup("DoItemClick",1064,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
15819 "U 'TGListTreeItem' - 0 - item i - 'Int_t' 0 - btn", (char*)NULL, (void*) NULL, 1);
15820 G__memfunc_setup("Class",502,G__G__GeomBuilder_292_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoMatrixDialog::Class) ), 0);
15821 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_292_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrixDialog::Class_Name) ), 0);
15822 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_292_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoMatrixDialog::Class_Version) ), 0);
15823 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_292_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoMatrixDialog::Dictionary) ), 0);
15824 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15825 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15826 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15827 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_292_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15828 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_292_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrixDialog::DeclFileName) ), 0);
15829 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_292_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMatrixDialog::ImplFileLine) ), 0);
15830 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_292_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoMatrixDialog::ImplFileName) ), 0);
15831 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_292_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoMatrixDialog::DeclFileLine) ), 0);
15832
15833 G__memfunc_setup("~TGeoMatrixDialog", 1714, G__G__GeomBuilder_292_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15834 G__tag_memfunc_reset();
15835 }
15836
15837 static void G__setup_memfuncTGeoSphereEditor(void) {
15838
15839 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor));
15840 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15841 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15842 G__memfunc_setup("TGeoSphereEditor",1597,G__G__GeomBuilder_294_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoSphereEditor), -1, 0, 5, 1, 1, 0,
15843 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15844 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15845 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15846 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15847 G__memfunc_setup("DoRmin",585,G__G__GeomBuilder_294_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15848 G__memfunc_setup("DoRmax",587,G__G__GeomBuilder_294_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15849 G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_294_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15850 G__memfunc_setup("DoTheta",681,G__G__GeomBuilder_294_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15851 G__memfunc_setup("DoTheta1",730,G__G__GeomBuilder_294_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15852 G__memfunc_setup("DoTheta2",731,G__G__GeomBuilder_294_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15853 G__memfunc_setup("DoPhi1",517,G__G__GeomBuilder_294_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15854 G__memfunc_setup("DoPhi2",518,G__G__GeomBuilder_294_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15855 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_294_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15856 G__memfunc_setup("DoName",564,G__G__GeomBuilder_294_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15857 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_294_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15858 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_294_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15859 G__memfunc_setup("Class",502,G__G__GeomBuilder_294_0_17, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoSphereEditor::Class) ), 0);
15860 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_294_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphereEditor::Class_Name) ), 0);
15861 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_294_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoSphereEditor::Class_Version) ), 0);
15862 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_294_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoSphereEditor::Dictionary) ), 0);
15863 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15864 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15865 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15866 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_294_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15867 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_294_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphereEditor::DeclFileName) ), 0);
15868 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_294_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoSphereEditor::ImplFileLine) ), 0);
15869 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_294_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoSphereEditor::ImplFileName) ), 0);
15870 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_294_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoSphereEditor::DeclFileLine) ), 0);
15871
15872 G__memfunc_setup("~TGeoSphereEditor", 1723, G__G__GeomBuilder_294_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15873 G__tag_memfunc_reset();
15874 }
15875
15876 static void G__setup_memfuncTGeoPconSection(void) {
15877
15878 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection));
15879 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15880 G__memfunc_setup("TGeoPconSection",1492,G__G__GeomBuilder_296_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconSection), -1, 0, 4, 1, 1, 0,
15881 "U 'TGWindow' - 10 - p h - 'UInt_t' 0 - w "
15882 "h - 'UInt_t' 0 - h i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15883 G__memfunc_setup("HideDaughters",1313,G__G__GeomBuilder_296_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15884 G__memfunc_setup("GetZ",378,G__G__GeomBuilder_296_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15885 G__memfunc_setup("GetRmin",694,G__G__GeomBuilder_296_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15886 G__memfunc_setup("GetRmax",696,G__G__GeomBuilder_296_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15887 G__memfunc_setup("SetZ",390,G__G__GeomBuilder_296_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - z", (char*)NULL, (void*) NULL, 0);
15888 G__memfunc_setup("SetRmin",706,G__G__GeomBuilder_296_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rmin", (char*)NULL, (void*) NULL, 0);
15889 G__memfunc_setup("SetRmax",708,G__G__GeomBuilder_296_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rmax", (char*)NULL, (void*) NULL, 0);
15890 G__memfunc_setup("DoZ",269,G__G__GeomBuilder_296_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15891 G__memfunc_setup("DoRmin",585,G__G__GeomBuilder_296_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15892 G__memfunc_setup("DoRmax",587,G__G__GeomBuilder_296_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15893 G__memfunc_setup("Changed",682,G__G__GeomBuilder_296_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", "*SIGNAL*", (void*) NULL, 1);
15894 G__memfunc_setup("Class",502,G__G__GeomBuilder_296_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPconSection::Class) ), 0);
15895 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_296_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconSection::Class_Name) ), 0);
15896 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_296_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPconSection::Class_Version) ), 0);
15897 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_296_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPconSection::Dictionary) ), 0);
15898 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15899 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15900 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15901 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_296_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15902 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_296_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconSection::DeclFileName) ), 0);
15903 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_296_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPconSection::ImplFileLine) ), 0);
15904 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_296_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconSection::ImplFileName) ), 0);
15905 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_296_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPconSection::DeclFileLine) ), 0);
15906
15907 G__memfunc_setup("~TGeoPconSection", 1618, G__G__GeomBuilder_296_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15908 G__tag_memfunc_reset();
15909 }
15910
15911 static void G__setup_memfuncTGeoPconEditor(void) {
15912
15913 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor));
15914 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15915 G__memfunc_setup("CheckSections",1318,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kFALSE' change", (char*)NULL, (void*) NULL, 0);
15916 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15917 G__memfunc_setup("CreateSections",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - inew", (char*)NULL, (void*) NULL, 0);
15918 G__memfunc_setup("UpdateSections",1451,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
15919 G__memfunc_setup("CreateEdges",1084,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15920 G__memfunc_setup("TGeoPconEditor",1382,G__G__GeomBuilder_297_0_7, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPconEditor), -1, 0, 5, 1, 1, 0,
15921 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15922 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15923 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15924 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15925 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_297_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15926 G__memfunc_setup("DoName",564,G__G__GeomBuilder_297_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15927 G__memfunc_setup("DoNz",379,G__G__GeomBuilder_297_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15928 G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_297_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15929 G__memfunc_setup("DoSectionChange",1486,G__G__GeomBuilder_297_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
15930 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_297_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15931 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_297_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15932 G__memfunc_setup("Class",502,G__G__GeomBuilder_297_0_16, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPconEditor::Class) ), 0);
15933 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_297_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconEditor::Class_Name) ), 0);
15934 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_297_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPconEditor::Class_Version) ), 0);
15935 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_297_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPconEditor::Dictionary) ), 0);
15936 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15937 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15938 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15939 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_297_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15940 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_297_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconEditor::DeclFileName) ), 0);
15941 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_297_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPconEditor::ImplFileLine) ), 0);
15942 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_297_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPconEditor::ImplFileName) ), 0);
15943 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_297_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPconEditor::DeclFileLine) ), 0);
15944
15945 G__memfunc_setup("~TGeoPconEditor", 1508, G__G__GeomBuilder_297_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15946 G__tag_memfunc_reset();
15947 }
15948
15949 static void G__setup_memfuncTGeoParaEditor(void) {
15950
15951 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor));
15952 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15953 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15954 G__memfunc_setup("TGeoParaEditor",1370,G__G__GeomBuilder_299_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoParaEditor), -1, 0, 5, 1, 1, 0,
15955 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15956 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15957 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15958 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15959 G__memfunc_setup("DoX",267,G__G__GeomBuilder_299_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15960 G__memfunc_setup("DoY",268,G__G__GeomBuilder_299_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15961 G__memfunc_setup("DoZ",269,G__G__GeomBuilder_299_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15962 G__memfunc_setup("DoAlpha",665,G__G__GeomBuilder_299_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15963 G__memfunc_setup("DoTheta",681,G__G__GeomBuilder_299_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15964 G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_299_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15965 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_299_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15966 G__memfunc_setup("DoName",564,G__G__GeomBuilder_299_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15967 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_299_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15968 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_299_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15969 G__memfunc_setup("Class",502,G__G__GeomBuilder_299_0_15, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoParaEditor::Class) ), 0);
15970 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_299_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaEditor::Class_Name) ), 0);
15971 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_299_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoParaEditor::Class_Version) ), 0);
15972 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_299_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoParaEditor::Dictionary) ), 0);
15973 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15974 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
15975 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
15976 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_299_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15977 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_299_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaEditor::DeclFileName) ), 0);
15978 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_299_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoParaEditor::ImplFileLine) ), 0);
15979 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_299_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoParaEditor::ImplFileName) ), 0);
15980 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_299_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoParaEditor::DeclFileLine) ), 0);
15981
15982 G__memfunc_setup("~TGeoParaEditor", 1496, G__G__GeomBuilder_299_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15983 G__tag_memfunc_reset();
15984 }
15985
15986 static void G__setup_memfuncTGeoTorusEditor(void) {
15987
15988 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor));
15989 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
15990 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
15991 G__memfunc_setup("TGeoTorusEditor",1523,G__G__GeomBuilder_301_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTorusEditor), -1, 0, 5, 1, 1, 0,
15992 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15993 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15994 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15995 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
15996 G__memfunc_setup("DoR",261,G__G__GeomBuilder_301_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15997 G__memfunc_setup("DoRmin",585,G__G__GeomBuilder_301_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15998 G__memfunc_setup("DoRmax",587,G__G__GeomBuilder_301_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15999 G__memfunc_setup("DoPhi1",517,G__G__GeomBuilder_301_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16000 G__memfunc_setup("DoDphi",568,G__G__GeomBuilder_301_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16001 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_301_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16002 G__memfunc_setup("DoName",564,G__G__GeomBuilder_301_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16003 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_301_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16004 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_301_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16005 G__memfunc_setup("Class",502,G__G__GeomBuilder_301_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTorusEditor::Class) ), 0);
16006 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_301_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorusEditor::Class_Name) ), 0);
16007 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_301_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTorusEditor::Class_Version) ), 0);
16008 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_301_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTorusEditor::Dictionary) ), 0);
16009 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16010 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
16011 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
16012 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_301_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
16013 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_301_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorusEditor::DeclFileName) ), 0);
16014 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_301_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTorusEditor::ImplFileLine) ), 0);
16015 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_301_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTorusEditor::ImplFileName) ), 0);
16016 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_301_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTorusEditor::DeclFileLine) ), 0);
16017
16018 G__memfunc_setup("~TGeoTorusEditor", 1649, G__G__GeomBuilder_301_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16019 G__tag_memfunc_reset();
16020 }
16021
16022 static void G__setup_memfuncTGeoEltuEditor(void) {
16023
16024 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor));
16025 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
16026 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
16027 G__memfunc_setup("TGeoEltuEditor",1392,G__G__GeomBuilder_303_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoEltuEditor), -1, 0, 5, 1, 1, 0,
16028 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
16029 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
16030 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
16031 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
16032 G__memfunc_setup("DoA",244,G__G__GeomBuilder_303_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16033 G__memfunc_setup("DoB",245,G__G__GeomBuilder_303_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16034 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_303_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16035 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_303_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16036 G__memfunc_setup("DoName",564,G__G__GeomBuilder_303_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16037 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_303_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16038 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_303_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16039 G__memfunc_setup("Class",502,G__G__GeomBuilder_303_0_12, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoEltuEditor::Class) ), 0);
16040 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_303_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltuEditor::Class_Name) ), 0);
16041 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_303_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoEltuEditor::Class_Version) ), 0);
16042 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_303_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoEltuEditor::Dictionary) ), 0);
16043 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16044 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
16045 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
16046 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_303_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
16047 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_303_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltuEditor::DeclFileName) ), 0);
16048 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_303_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoEltuEditor::ImplFileLine) ), 0);
16049 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_303_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoEltuEditor::ImplFileName) ), 0);
16050 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_303_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoEltuEditor::DeclFileLine) ), 0);
16051
16052 G__memfunc_setup("~TGeoEltuEditor", 1518, G__G__GeomBuilder_303_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16053 G__tag_memfunc_reset();
16054 }
16055
16056 static void G__setup_memfuncTGeoHypeEditor(void) {
16057
16058 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor));
16059 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
16060 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
16061 G__memfunc_setup("TGeoHypeEditor",1388,G__G__GeomBuilder_305_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoHypeEditor), -1, 0, 5, 1, 1, 0,
16062 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
16063 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
16064 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
16065 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
16066 G__memfunc_setup("DoRin",476,G__G__GeomBuilder_305_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16067 G__memfunc_setup("DoRout",605,G__G__GeomBuilder_305_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16068 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_305_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16069 G__memfunc_setup("DoStIn",561,G__G__GeomBuilder_305_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16070 G__memfunc_setup("DoStOut",690,G__G__GeomBuilder_305_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16071 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_305_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16072 G__memfunc_setup("DoName",564,G__G__GeomBuilder_305_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16073 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_305_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16074 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_305_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16075 G__memfunc_setup("Class",502,G__G__GeomBuilder_305_0_14, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoHypeEditor::Class) ), 0);
16076 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_305_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHypeEditor::Class_Name) ), 0);
16077 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_305_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoHypeEditor::Class_Version) ), 0);
16078 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_305_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoHypeEditor::Dictionary) ), 0);
16079 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16080 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
16081 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
16082 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_305_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
16083 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_305_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHypeEditor::DeclFileName) ), 0);
16084 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_305_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHypeEditor::ImplFileLine) ), 0);
16085 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_305_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoHypeEditor::ImplFileName) ), 0);
16086 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_305_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoHypeEditor::DeclFileLine) ), 0);
16087
16088 G__memfunc_setup("~TGeoHypeEditor", 1514, G__G__GeomBuilder_305_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16089 G__tag_memfunc_reset();
16090 }
16091
16092 static void G__setup_memfuncTGeoPgonEditor(void) {
16093
16094 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor));
16095 G__memfunc_setup("CreateEdges",1084,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
16096 G__memfunc_setup("TGeoPgonEditor",1386,G__G__GeomBuilder_306_0_2, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoPgonEditor), -1, 0, 5, 1, 1, 0,
16097 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
16098 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
16099 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
16100 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
16101 G__memfunc_setup("DoNedges",777,G__G__GeomBuilder_306_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16102 G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16103 G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16104 G__memfunc_setup("Class",502,G__G__GeomBuilder_306_0_7, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoPgonEditor::Class) ), 0);
16105 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_306_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgonEditor::Class_Name) ), 0);
16106 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_306_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoPgonEditor::Class_Version) ), 0);
16107 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_306_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoPgonEditor::Dictionary) ), 0);
16108 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16109 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
16110 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
16111 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_306_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
16112 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_306_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgonEditor::DeclFileName) ), 0);
16113 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_306_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPgonEditor::ImplFileLine) ), 0);
16114 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_306_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoPgonEditor::ImplFileName) ), 0);
16115 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_306_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoPgonEditor::DeclFileLine) ), 0);
16116
16117 G__memfunc_setup("~TGeoPgonEditor", 1512, G__G__GeomBuilder_306_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16118 G__tag_memfunc_reset();
16119 }
16120
16121 static void G__setup_memfuncTGeoTrapEditor(void) {
16122
16123 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor));
16124 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Connect the signals to the slots", (void*) NULL, 1);
16125 G__memfunc_setup("IsDelayed",884,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
16126 G__memfunc_setup("TGeoTrapEditor",1389,G__G__GeomBuilder_308_0_3, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoTrapEditor), -1, 0, 5, 1, 1, 0,
16127 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
16128 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
16129 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
16130 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
16131 G__memfunc_setup("DoH1",300,G__G__GeomBuilder_308_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16132 G__memfunc_setup("DoBl1",402,G__G__GeomBuilder_308_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16133 G__memfunc_setup("DoTl1",420,G__G__GeomBuilder_308_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16134 G__memfunc_setup("DoDz",369,G__G__GeomBuilder_308_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16135 G__memfunc_setup("DoSc1",410,G__G__GeomBuilder_308_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16136 G__memfunc_setup("DoSc2",411,G__G__GeomBuilder_308_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16137 G__memfunc_setup("DoAlpha1",714,G__G__GeomBuilder_308_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16138 G__memfunc_setup("DoTheta",681,G__G__GeomBuilder_308_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16139 G__memfunc_setup("DoPhi",468,G__G__GeomBuilder_308_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16140 G__memfunc_setup("DoModified",980,G__G__GeomBuilder_308_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16141 G__memfunc_setup("DoName",564,G__G__GeomBuilder_308_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16142 G__memfunc_setup("DoApply",697,G__G__GeomBuilder_308_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16143 G__memfunc_setup("DoUndo",585,G__G__GeomBuilder_308_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16144 G__memfunc_setup("Class",502,G__G__GeomBuilder_308_0_18, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoTrapEditor::Class) ), 0);
16145 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_308_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrapEditor::Class_Name) ), 0);
16146 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_308_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoTrapEditor::Class_Version) ), 0);
16147 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_308_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoTrapEditor::Dictionary) ), 0);
16148 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16149 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
16150 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
16151 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_308_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
16152 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_308_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrapEditor::DeclFileName) ), 0);
16153 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_308_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrapEditor::ImplFileLine) ), 0);
16154 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_308_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoTrapEditor::ImplFileName) ), 0);
16155 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_308_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoTrapEditor::DeclFileLine) ), 0);
16156
16157 G__memfunc_setup("~TGeoTrapEditor", 1515, G__G__GeomBuilder_308_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16158 G__tag_memfunc_reset();
16159 }
16160
16161 static void G__setup_memfuncTGeoGtraEditor(void) {
16162
16163 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor));
16164 G__memfunc_setup("TGeoGtraEditor",1380,G__G__GeomBuilder_309_0_1, 105, G__get_linked_tagnum(&G__G__GeomBuilderLN_TGeoGtraEditor), -1, 0, 5, 1, 1, 0,
16165 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
16166 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
16167 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
16168 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
16169 G__memfunc_setup("DoTwist",718,G__G__GeomBuilder_309_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16170 G__memfunc_setup("DoApply",697,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16171 G__memfunc_setup("DoUndo",585,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16172 G__memfunc_setup("Class",502,G__G__GeomBuilder_309_0_6, 85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGeoGtraEditor::Class) ), 0);
16173 G__memfunc_setup("Class_Name",982,G__G__GeomBuilder_309_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtraEditor::Class_Name) ), 0);
16174 G__memfunc_setup("Class_Version",1339,G__G__GeomBuilder_309_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGeoGtraEditor::Class_Version) ), 0);
16175 G__memfunc_setup("Dictionary",1046,G__G__GeomBuilder_309_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGeoGtraEditor::Dictionary) ), 0);
16176 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GeomBuilderLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16177 G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
16178 G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
16179 G__memfunc_setup("StreamerNVirtual",1656,G__G__GeomBuilder_309_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
16180 G__memfunc_setup("DeclFileName",1145,G__G__GeomBuilder_309_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtraEditor::DeclFileName) ), 0);
16181 G__memfunc_setup("ImplFileLine",1178,G__G__GeomBuilder_309_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGtraEditor::ImplFileLine) ), 0);
16182 G__memfunc_setup("ImplFileName",1171,G__G__GeomBuilder_309_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGeoGtraEditor::ImplFileName) ), 0);
16183 G__memfunc_setup("DeclFileLine",1152,G__G__GeomBuilder_309_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGeoGtraEditor::DeclFileLine) ), 0);
16184
16185 G__memfunc_setup("~TGeoGtraEditor", 1506, G__G__GeomBuilder_309_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16186 G__tag_memfunc_reset();
16187 }
16188
16189
16190
16191
16192
16193 extern "C" void G__cpp_setup_memfuncG__GeomBuilder() {
16194 }
16195
16196
16197
16198
16199 static void G__cpp_setup_global0() {
16200
16201
16202 G__resetplocal();
16203
16204 }
16205
16206 static void G__cpp_setup_global1() {
16207 }
16208
16209 static void G__cpp_setup_global2() {
16210 }
16211
16212 static void G__cpp_setup_global3() {
16213 }
16214
16215 static void G__cpp_setup_global4() {
16216 }
16217
16218 static void G__cpp_setup_global5() {
16219
16220 G__resetglobalenv();
16221 }
16222 extern "C" void G__cpp_setup_globalG__GeomBuilder() {
16223 G__cpp_setup_global0();
16224 G__cpp_setup_global1();
16225 G__cpp_setup_global2();
16226 G__cpp_setup_global3();
16227 G__cpp_setup_global4();
16228 G__cpp_setup_global5();
16229 }
16230
16231
16232
16233
16234 static void G__cpp_setup_func0() {
16235 G__lastifuncposition();
16236
16237 }
16238
16239 static void G__cpp_setup_func1() {
16240 }
16241
16242 static void G__cpp_setup_func2() {
16243 }
16244
16245 static void G__cpp_setup_func3() {
16246
16247 G__resetifuncposition();
16248 }
16249
16250 extern "C" void G__cpp_setup_funcG__GeomBuilder() {
16251 G__cpp_setup_func0();
16252 G__cpp_setup_func1();
16253 G__cpp_setup_func2();
16254 G__cpp_setup_func3();
16255 }
16256
16257
16258
16259
16260
16261 G__linked_taginfo G__G__GeomBuilderLN_TClass = { "TClass" , 99 , -1 };
16262 G__linked_taginfo G__G__GeomBuilderLN_TBuffer = { "TBuffer" , 99 , -1 };
16263 G__linked_taginfo G__G__GeomBuilderLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
16264 G__linked_taginfo G__G__GeomBuilderLN_TObject = { "TObject" , 99 , -1 };
16265 G__linked_taginfo G__G__GeomBuilderLN_TString = { "TString" , 99 , -1 };
16266 G__linked_taginfo G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
16267 G__linked_taginfo G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
16268 G__linked_taginfo G__G__GeomBuilderLN_TObjArray = { "TObjArray" , 99 , -1 };
16269 G__linked_taginfo G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
16270 G__linked_taginfo G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
16271 G__linked_taginfo G__G__GeomBuilderLN_TGWindow = { "TGWindow" , 99 , -1 };
16272 G__linked_taginfo G__G__GeomBuilderLN_TGWidget = { "TGWidget" , 99 , -1 };
16273 G__linked_taginfo G__G__GeomBuilderLN_TGObject = { "TGObject" , 99 , -1 };
16274 G__linked_taginfo G__G__GeomBuilderLN_TQObject = { "TQObject" , 99 , -1 };
16275 G__linked_taginfo G__G__GeomBuilderLN_TGFrame = { "TGFrame" , 99 , -1 };
16276 G__linked_taginfo G__G__GeomBuilderLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
16277 G__linked_taginfo G__G__GeomBuilderLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
16278 G__linked_taginfo G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
16279 G__linked_taginfo G__G__GeomBuilderLN_TGTextButton = { "TGTextButton" , 99 , -1 };
16280 G__linked_taginfo G__G__GeomBuilderLN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
16281 G__linked_taginfo G__G__GeomBuilderLN_TGTransientFrame = { "TGTransientFrame" , 99 , -1 };
16282 G__linked_taginfo G__G__GeomBuilderLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
16283 G__linked_taginfo G__G__GeomBuilderLN_TCanvas = { "TCanvas" , 99 , -1 };
16284 G__linked_taginfo G__G__GeomBuilderLN_TGLabel = { "TGLabel" , 99 , -1 };
16285 G__linked_taginfo G__G__GeomBuilderLN_TGTab = { "TGTab" , 99 , -1 };
16286 G__linked_taginfo G__G__GeomBuilderLN_TGedEditor = { "TGedEditor" , 99 , -1 };
16287 G__linked_taginfo G__G__GeomBuilderLN_TGedFrame = { "TGedFrame" , 99 , -1 };
16288 G__linked_taginfo G__G__GeomBuilderLN_TGeoTabManager = { "TGeoTabManager" , 99 , -1 };
16289 G__linked_taginfo G__G__GeomBuilderLN_TGeoGedFrame = { "TGeoGedFrame" , 99 , -1 };
16290 G__linked_taginfo G__G__GeomBuilderLN_TGeoManager = { "TGeoManager" , 99 , -1 };
16291 G__linked_taginfo G__G__GeomBuilderLN_TGeoVolume = { "TGeoVolume" , 99 , -1 };
16292 G__linked_taginfo G__G__GeomBuilderLN_TGeoShape = { "TGeoShape" , 99 , -1 };
16293 G__linked_taginfo G__G__GeomBuilderLN_TGeoMedium = { "TGeoMedium" , 99 , -1 };
16294 G__linked_taginfo G__G__GeomBuilderLN_TGeoMaterial = { "TGeoMaterial" , 99 , -1 };
16295 G__linked_taginfo G__G__GeomBuilderLN_TGeoMatrix = { "TGeoMatrix" , 99 , -1 };
16296 G__linked_taginfo G__G__GeomBuilderLN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
16297 G__linked_taginfo G__G__GeomBuilderLN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 };
16298 G__linked_taginfo G__G__GeomBuilderLN_TGComboBox = { "TGComboBox" , 99 , -1 };
16299 G__linked_taginfo G__G__GeomBuilderLN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
16300 G__linked_taginfo G__G__GeomBuilderLN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
16301 G__linked_taginfo G__G__GeomBuilderLN_TGRadioButton = { "TGRadioButton" , 99 , -1 };
16302 G__linked_taginfo G__G__GeomBuilderLN_TGShutter = { "TGShutter" , 99 , -1 };
16303 G__linked_taginfo G__G__GeomBuilderLN_TGeoVolumeEditor = { "TGeoVolumeEditor" , 99 , -1 };
16304 G__linked_taginfo G__G__GeomBuilderLN_TGeoBBox = { "TGeoBBox" , 99 , -1 };
16305 G__linked_taginfo G__G__GeomBuilderLN_TGeoBBoxEditor = { "TGeoBBoxEditor" , 99 , -1 };
16306 G__linked_taginfo G__G__GeomBuilderLN_TGeoMediumEditor = { "TGeoMediumEditor" , 99 , -1 };
16307 G__linked_taginfo G__G__GeomBuilderLN_TGeoNode = { "TGeoNode" , 99 , -1 };
16308 G__linked_taginfo G__G__GeomBuilderLN_TGeoNodeEditor = { "TGeoNodeEditor" , 99 , -1 };
16309 G__linked_taginfo G__G__GeomBuilderLN_TGeoTranslation = { "TGeoTranslation" , 99 , -1 };
16310 G__linked_taginfo G__G__GeomBuilderLN_TGeoRotation = { "TGeoRotation" , 99 , -1 };
16311 G__linked_taginfo G__G__GeomBuilderLN_TGeoCombiTrans = { "TGeoCombiTrans" , 99 , -1 };
16312 G__linked_taginfo G__G__GeomBuilderLN_TGeoTranslationEditor = { "TGeoTranslationEditor" , 99 , -1 };
16313 G__linked_taginfo G__G__GeomBuilderLN_TGeoRotationEditor = { "TGeoRotationEditor" , 99 , -1 };
16314 G__linked_taginfo G__G__GeomBuilderLN_TGeoCombiTransEditor = { "TGeoCombiTransEditor" , 99 , -1 };
16315 G__linked_taginfo G__G__GeomBuilderLN_TGeoManagerEditor = { "TGeoManagerEditor" , 99 , -1 };
16316 G__linked_taginfo G__G__GeomBuilderLN_TGeoTube = { "TGeoTube" , 99 , -1 };
16317 G__linked_taginfo G__G__GeomBuilderLN_TGeoTubeEditor = { "TGeoTubeEditor" , 99 , -1 };
16318 G__linked_taginfo G__G__GeomBuilderLN_TGDoubleVSlider = { "TGDoubleVSlider" , 99 , -1 };
16319 G__linked_taginfo G__G__GeomBuilderLN_TGeoTubeSegEditor = { "TGeoTubeSegEditor" , 99 , -1 };
16320 G__linked_taginfo G__G__GeomBuilderLN_TGeoCtubEditor = { "TGeoCtubEditor" , 99 , -1 };
16321 G__linked_taginfo G__G__GeomBuilderLN_TGeoCone = { "TGeoCone" , 99 , -1 };
16322 G__linked_taginfo G__G__GeomBuilderLN_TGeoConeEditor = { "TGeoConeEditor" , 99 , -1 };
16323 G__linked_taginfo G__G__GeomBuilderLN_TGeoConeSegEditor = { "TGeoConeSegEditor" , 99 , -1 };
16324 G__linked_taginfo G__G__GeomBuilderLN_TGeoTrd1 = { "TGeoTrd1" , 99 , -1 };
16325 G__linked_taginfo G__G__GeomBuilderLN_TGeoTrd1Editor = { "TGeoTrd1Editor" , 99 , -1 };
16326 G__linked_taginfo G__G__GeomBuilderLN_TGeoTrd2 = { "TGeoTrd2" , 99 , -1 };
16327 G__linked_taginfo G__G__GeomBuilderLN_TGeoTrd2Editor = { "TGeoTrd2Editor" , 99 , -1 };
16328 G__linked_taginfo G__G__GeomBuilderLN_TGCanvas = { "TGCanvas" , 99 , -1 };
16329 G__linked_taginfo G__G__GeomBuilderLN_TGeoMaterialEditor = { "TGeoMaterialEditor" , 99 , -1 };
16330 G__linked_taginfo G__G__GeomBuilderLN_TGeoMixture = { "TGeoMixture" , 99 , -1 };
16331 G__linked_taginfo G__G__GeomBuilderLN_TGeoMixtureEditor = { "TGeoMixtureEditor" , 99 , -1 };
16332 G__linked_taginfo G__G__GeomBuilderLN_TMap = { "TMap" , 99 , -1 };
16333 G__linked_taginfo G__G__GeomBuilderLN_TGListTree = { "TGListTree" , 99 , -1 };
16334 G__linked_taginfo G__G__GeomBuilderLN_TGListTreeItem = { "TGListTreeItem" , 99 , -1 };
16335 G__linked_taginfo G__G__GeomBuilderLN_TGeoTreeDialog = { "TGeoTreeDialog" , 99 , -1 };
16336 G__linked_taginfo G__G__GeomBuilderLN_TGeoTransientPanel = { "TGeoTransientPanel" , 99 , -1 };
16337 G__linked_taginfo G__G__GeomBuilderLN_TGeoVolumeDialog = { "TGeoVolumeDialog" , 99 , -1 };
16338 G__linked_taginfo G__G__GeomBuilderLN_TGeoShapeDialog = { "TGeoShapeDialog" , 99 , -1 };
16339 G__linked_taginfo G__G__GeomBuilderLN_TGeoMediumDialog = { "TGeoMediumDialog" , 99 , -1 };
16340 G__linked_taginfo G__G__GeomBuilderLN_TGeoMaterialDialog = { "TGeoMaterialDialog" , 99 , -1 };
16341 G__linked_taginfo G__G__GeomBuilderLN_TGeoMatrixDialog = { "TGeoMatrixDialog" , 99 , -1 };
16342 G__linked_taginfo G__G__GeomBuilderLN_TGeoSphere = { "TGeoSphere" , 99 , -1 };
16343 G__linked_taginfo G__G__GeomBuilderLN_TGeoSphereEditor = { "TGeoSphereEditor" , 99 , -1 };
16344 G__linked_taginfo G__G__GeomBuilderLN_TGeoPcon = { "TGeoPcon" , 99 , -1 };
16345 G__linked_taginfo G__G__GeomBuilderLN_TGeoPconSection = { "TGeoPconSection" , 99 , -1 };
16346 G__linked_taginfo G__G__GeomBuilderLN_TGeoPconEditor = { "TGeoPconEditor" , 99 , -1 };
16347 G__linked_taginfo G__G__GeomBuilderLN_TGeoPara = { "TGeoPara" , 99 , -1 };
16348 G__linked_taginfo G__G__GeomBuilderLN_TGeoParaEditor = { "TGeoParaEditor" , 99 , -1 };
16349 G__linked_taginfo G__G__GeomBuilderLN_TGeoTorus = { "TGeoTorus" , 99 , -1 };
16350 G__linked_taginfo G__G__GeomBuilderLN_TGeoTorusEditor = { "TGeoTorusEditor" , 99 , -1 };
16351 G__linked_taginfo G__G__GeomBuilderLN_TGeoEltu = { "TGeoEltu" , 99 , -1 };
16352 G__linked_taginfo G__G__GeomBuilderLN_TGeoEltuEditor = { "TGeoEltuEditor" , 99 , -1 };
16353 G__linked_taginfo G__G__GeomBuilderLN_TGeoHype = { "TGeoHype" , 99 , -1 };
16354 G__linked_taginfo G__G__GeomBuilderLN_TGeoHypeEditor = { "TGeoHypeEditor" , 99 , -1 };
16355 G__linked_taginfo G__G__GeomBuilderLN_TGeoPgonEditor = { "TGeoPgonEditor" , 99 , -1 };
16356 G__linked_taginfo G__G__GeomBuilderLN_TGeoTrap = { "TGeoTrap" , 99 , -1 };
16357 G__linked_taginfo G__G__GeomBuilderLN_TGeoTrapEditor = { "TGeoTrapEditor" , 99 , -1 };
16358 G__linked_taginfo G__G__GeomBuilderLN_TGeoGtraEditor = { "TGeoGtraEditor" , 99 , -1 };
16359
16360
16361 extern "C" void G__cpp_reset_tagtableG__GeomBuilder() {
16362 G__G__GeomBuilderLN_TClass.tagnum = -1 ;
16363 G__G__GeomBuilderLN_TBuffer.tagnum = -1 ;
16364 G__G__GeomBuilderLN_TMemberInspector.tagnum = -1 ;
16365 G__G__GeomBuilderLN_TObject.tagnum = -1 ;
16366 G__G__GeomBuilderLN_TString.tagnum = -1 ;
16367 G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
16368 G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
16369 G__G__GeomBuilderLN_TObjArray.tagnum = -1 ;
16370 G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
16371 G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
16372 G__G__GeomBuilderLN_TGWindow.tagnum = -1 ;
16373 G__G__GeomBuilderLN_TGWidget.tagnum = -1 ;
16374 G__G__GeomBuilderLN_TGObject.tagnum = -1 ;
16375 G__G__GeomBuilderLN_TQObject.tagnum = -1 ;
16376 G__G__GeomBuilderLN_TGFrame.tagnum = -1 ;
16377 G__G__GeomBuilderLN_TGCompositeFrame.tagnum = -1 ;
16378 G__G__GeomBuilderLN_TGLayoutHints.tagnum = -1 ;
16379 G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
16380 G__G__GeomBuilderLN_TGTextButton.tagnum = -1 ;
16381 G__G__GeomBuilderLN_TGMainFrame.tagnum = -1 ;
16382 G__G__GeomBuilderLN_TGTransientFrame.tagnum = -1 ;
16383 G__G__GeomBuilderLN_TVirtualPad.tagnum = -1 ;
16384 G__G__GeomBuilderLN_TCanvas.tagnum = -1 ;
16385 G__G__GeomBuilderLN_TGLabel.tagnum = -1 ;
16386 G__G__GeomBuilderLN_TGTab.tagnum = -1 ;
16387 G__G__GeomBuilderLN_TGedEditor.tagnum = -1 ;
16388 G__G__GeomBuilderLN_TGedFrame.tagnum = -1 ;
16389 G__G__GeomBuilderLN_TGeoTabManager.tagnum = -1 ;
16390 G__G__GeomBuilderLN_TGeoGedFrame.tagnum = -1 ;
16391 G__G__GeomBuilderLN_TGeoManager.tagnum = -1 ;
16392 G__G__GeomBuilderLN_TGeoVolume.tagnum = -1 ;
16393 G__G__GeomBuilderLN_TGeoShape.tagnum = -1 ;
16394 G__G__GeomBuilderLN_TGeoMedium.tagnum = -1 ;
16395 G__G__GeomBuilderLN_TGeoMaterial.tagnum = -1 ;
16396 G__G__GeomBuilderLN_TGeoMatrix.tagnum = -1 ;
16397 G__G__GeomBuilderLN_TGTextEntry.tagnum = -1 ;
16398 G__G__GeomBuilderLN_TGNumberEntry.tagnum = -1 ;
16399 G__G__GeomBuilderLN_TGComboBox.tagnum = -1 ;
16400 G__G__GeomBuilderLN_TGPictureButton.tagnum = -1 ;
16401 G__G__GeomBuilderLN_TGCheckButton.tagnum = -1 ;
16402 G__G__GeomBuilderLN_TGRadioButton.tagnum = -1 ;
16403 G__G__GeomBuilderLN_TGShutter.tagnum = -1 ;
16404 G__G__GeomBuilderLN_TGeoVolumeEditor.tagnum = -1 ;
16405 G__G__GeomBuilderLN_TGeoBBox.tagnum = -1 ;
16406 G__G__GeomBuilderLN_TGeoBBoxEditor.tagnum = -1 ;
16407 G__G__GeomBuilderLN_TGeoMediumEditor.tagnum = -1 ;
16408 G__G__GeomBuilderLN_TGeoNode.tagnum = -1 ;
16409 G__G__GeomBuilderLN_TGeoNodeEditor.tagnum = -1 ;
16410 G__G__GeomBuilderLN_TGeoTranslation.tagnum = -1 ;
16411 G__G__GeomBuilderLN_TGeoRotation.tagnum = -1 ;
16412 G__G__GeomBuilderLN_TGeoCombiTrans.tagnum = -1 ;
16413 G__G__GeomBuilderLN_TGeoTranslationEditor.tagnum = -1 ;
16414 G__G__GeomBuilderLN_TGeoRotationEditor.tagnum = -1 ;
16415 G__G__GeomBuilderLN_TGeoCombiTransEditor.tagnum = -1 ;
16416 G__G__GeomBuilderLN_TGeoManagerEditor.tagnum = -1 ;
16417 G__G__GeomBuilderLN_TGeoTube.tagnum = -1 ;
16418 G__G__GeomBuilderLN_TGeoTubeEditor.tagnum = -1 ;
16419 G__G__GeomBuilderLN_TGDoubleVSlider.tagnum = -1 ;
16420 G__G__GeomBuilderLN_TGeoTubeSegEditor.tagnum = -1 ;
16421 G__G__GeomBuilderLN_TGeoCtubEditor.tagnum = -1 ;
16422 G__G__GeomBuilderLN_TGeoCone.tagnum = -1 ;
16423 G__G__GeomBuilderLN_TGeoConeEditor.tagnum = -1 ;
16424 G__G__GeomBuilderLN_TGeoConeSegEditor.tagnum = -1 ;
16425 G__G__GeomBuilderLN_TGeoTrd1.tagnum = -1 ;
16426 G__G__GeomBuilderLN_TGeoTrd1Editor.tagnum = -1 ;
16427 G__G__GeomBuilderLN_TGeoTrd2.tagnum = -1 ;
16428 G__G__GeomBuilderLN_TGeoTrd2Editor.tagnum = -1 ;
16429 G__G__GeomBuilderLN_TGCanvas.tagnum = -1 ;
16430 G__G__GeomBuilderLN_TGeoMaterialEditor.tagnum = -1 ;
16431 G__G__GeomBuilderLN_TGeoMixture.tagnum = -1 ;
16432 G__G__GeomBuilderLN_TGeoMixtureEditor.tagnum = -1 ;
16433 G__G__GeomBuilderLN_TMap.tagnum = -1 ;
16434 G__G__GeomBuilderLN_TGListTree.tagnum = -1 ;
16435 G__G__GeomBuilderLN_TGListTreeItem.tagnum = -1 ;
16436 G__G__GeomBuilderLN_TGeoTreeDialog.tagnum = -1 ;
16437 G__G__GeomBuilderLN_TGeoTransientPanel.tagnum = -1 ;
16438 G__G__GeomBuilderLN_TGeoVolumeDialog.tagnum = -1 ;
16439 G__G__GeomBuilderLN_TGeoShapeDialog.tagnum = -1 ;
16440 G__G__GeomBuilderLN_TGeoMediumDialog.tagnum = -1 ;
16441 G__G__GeomBuilderLN_TGeoMaterialDialog.tagnum = -1 ;
16442 G__G__GeomBuilderLN_TGeoMatrixDialog.tagnum = -1 ;
16443 G__G__GeomBuilderLN_TGeoSphere.tagnum = -1 ;
16444 G__G__GeomBuilderLN_TGeoSphereEditor.tagnum = -1 ;
16445 G__G__GeomBuilderLN_TGeoPcon.tagnum = -1 ;
16446 G__G__GeomBuilderLN_TGeoPconSection.tagnum = -1 ;
16447 G__G__GeomBuilderLN_TGeoPconEditor.tagnum = -1 ;
16448 G__G__GeomBuilderLN_TGeoPara.tagnum = -1 ;
16449 G__G__GeomBuilderLN_TGeoParaEditor.tagnum = -1 ;
16450 G__G__GeomBuilderLN_TGeoTorus.tagnum = -1 ;
16451 G__G__GeomBuilderLN_TGeoTorusEditor.tagnum = -1 ;
16452 G__G__GeomBuilderLN_TGeoEltu.tagnum = -1 ;
16453 G__G__GeomBuilderLN_TGeoEltuEditor.tagnum = -1 ;
16454 G__G__GeomBuilderLN_TGeoHype.tagnum = -1 ;
16455 G__G__GeomBuilderLN_TGeoHypeEditor.tagnum = -1 ;
16456 G__G__GeomBuilderLN_TGeoPgonEditor.tagnum = -1 ;
16457 G__G__GeomBuilderLN_TGeoTrap.tagnum = -1 ;
16458 G__G__GeomBuilderLN_TGeoTrapEditor.tagnum = -1 ;
16459 G__G__GeomBuilderLN_TGeoGtraEditor.tagnum = -1 ;
16460 }
16461
16462
16463 extern "C" void G__cpp_setup_tagtableG__GeomBuilder() {
16464
16465
16466 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TClass);
16467 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TBuffer);
16468 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TMemberInspector);
16469 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TObject);
16470 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TString);
16471 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
16472 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
16473 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TObjArray);
16474 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
16475 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
16476 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGWindow);
16477 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGWidget);
16478 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGObject);
16479 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TQObject);
16480 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGFrame);
16481 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGCompositeFrame);
16482 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGLayoutHints);
16483 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
16484 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGTextButton);
16485 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGMainFrame);
16486 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGTransientFrame);
16487 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TVirtualPad);
16488 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TCanvas);
16489 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGLabel);
16490 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGTab);
16491 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGedEditor);
16492 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGedFrame);
16493 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTabManager),sizeof(TGeoTabManager),-1,62464,"Tab manager for geometry editors",G__setup_memvarTGeoTabManager,G__setup_memfuncTGeoTabManager);
16494 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoGedFrame),sizeof(TGeoGedFrame),-1,61697,"Common base-class for geombuilder editors.",G__setup_memvarTGeoGedFrame,G__setup_memfuncTGeoGedFrame);
16495 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoManager);
16496 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoVolume);
16497 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoShape);
16498 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMedium);
16499 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMaterial);
16500 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMatrix);
16501 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGTextEntry);
16502 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGNumberEntry);
16503 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGComboBox);
16504 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGPictureButton);
16505 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGCheckButton);
16506 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGRadioButton);
16507 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGShutter);
16508 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoVolumeEditor),sizeof(TGeoVolumeEditor),-1,62720,"TGeoVolume editor",G__setup_memvarTGeoVolumeEditor,G__setup_memfuncTGeoVolumeEditor);
16509 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoBBox);
16510 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoBBoxEditor),sizeof(TGeoBBoxEditor),-1,62720,"TGeoBBox editor",G__setup_memvarTGeoBBoxEditor,G__setup_memfuncTGeoBBoxEditor);
16511 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMediumEditor),sizeof(TGeoMediumEditor),-1,62720,"TGeoMedium editor",G__setup_memvarTGeoMediumEditor,G__setup_memfuncTGeoMediumEditor);
16512 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoNode);
16513 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoNodeEditor),sizeof(TGeoNodeEditor),-1,62720,"TGeoNode editor",G__setup_memvarTGeoNodeEditor,G__setup_memfuncTGeoNodeEditor);
16514 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTranslation);
16515 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoRotation);
16516 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoCombiTrans);
16517 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTranslationEditor),sizeof(TGeoTranslationEditor),-1,62720,"TGeoTranslation editor",G__setup_memvarTGeoTranslationEditor,G__setup_memfuncTGeoTranslationEditor);
16518 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoRotationEditor),sizeof(TGeoRotationEditor),-1,62720,"TGeoRotation editor",G__setup_memvarTGeoRotationEditor,G__setup_memfuncTGeoRotationEditor);
16519 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoCombiTransEditor),sizeof(TGeoCombiTransEditor),-1,62720,"TGeoCombiTrans editor",G__setup_memvarTGeoCombiTransEditor,G__setup_memfuncTGeoCombiTransEditor);
16520 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoManagerEditor),sizeof(TGeoManagerEditor),-1,62720,"TGeoManager editor",G__setup_memvarTGeoManagerEditor,G__setup_memfuncTGeoManagerEditor);
16521 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTube);
16522 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTubeEditor),sizeof(TGeoTubeEditor),-1,62720,"TGeoTube editor",G__setup_memvarTGeoTubeEditor,G__setup_memfuncTGeoTubeEditor);
16523 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGDoubleVSlider);
16524 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTubeSegEditor),sizeof(TGeoTubeSegEditor),-1,62720,"TGeoTubeSeg editor",G__setup_memvarTGeoTubeSegEditor,G__setup_memfuncTGeoTubeSegEditor);
16525 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoCtubEditor),sizeof(TGeoCtubEditor),-1,62720,"TGeoCtub editor",G__setup_memvarTGeoCtubEditor,G__setup_memfuncTGeoCtubEditor);
16526 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoCone);
16527 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoConeEditor),sizeof(TGeoConeEditor),-1,62720,"TGeoCone editor",G__setup_memvarTGeoConeEditor,G__setup_memfuncTGeoConeEditor);
16528 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoConeSegEditor),sizeof(TGeoConeSegEditor),-1,62720,"TGeoConeSeg editor",G__setup_memvarTGeoConeSegEditor,G__setup_memfuncTGeoConeSegEditor);
16529 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrd1);
16530 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrd1Editor),sizeof(TGeoTrd1Editor),-1,62720,"TGeoTrd1 editor",G__setup_memvarTGeoTrd1Editor,G__setup_memfuncTGeoTrd1Editor);
16531 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrd2);
16532 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrd2Editor),sizeof(TGeoTrd2Editor),-1,62720,"TGeoTrd2 editor",G__setup_memvarTGeoTrd2Editor,G__setup_memfuncTGeoTrd2Editor);
16533 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGCanvas);
16534 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMaterialEditor),sizeof(TGeoMaterialEditor),-1,62720,"TGeoMaterial editor",G__setup_memvarTGeoMaterialEditor,G__setup_memfuncTGeoMaterialEditor);
16535 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMixture);
16536 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMixtureEditor),sizeof(TGeoMixtureEditor),-1,62720,"TGeoMixture editor",G__setup_memvarTGeoMixtureEditor,G__setup_memfuncTGeoMixtureEditor);
16537 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TMap);
16538 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGListTree);
16539 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGListTreeItem);
16540 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTreeDialog),sizeof(TGeoTreeDialog),-1,62468,"List-Tree based dialog",G__setup_memvarTGeoTreeDialog,G__setup_memfuncTGeoTreeDialog);
16541 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTransientPanel),sizeof(TGeoTransientPanel),-1,62464,"List-Tree based dialog",G__setup_memvarTGeoTransientPanel,G__setup_memfuncTGeoTransientPanel);
16542 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoVolumeDialog),sizeof(TGeoVolumeDialog),-1,62464,"List-Tree based volume dialog",G__setup_memvarTGeoVolumeDialog,G__setup_memfuncTGeoVolumeDialog);
16543 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoShapeDialog),sizeof(TGeoShapeDialog),-1,62464,"List-Tree based shape dialog",G__setup_memvarTGeoShapeDialog,G__setup_memfuncTGeoShapeDialog);
16544 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMediumDialog),sizeof(TGeoMediumDialog),-1,62464,"List-Tree based medium dialog",G__setup_memvarTGeoMediumDialog,G__setup_memfuncTGeoMediumDialog);
16545 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMaterialDialog),sizeof(TGeoMaterialDialog),-1,62464,"List-Tree based material dialog",G__setup_memvarTGeoMaterialDialog,G__setup_memfuncTGeoMaterialDialog);
16546 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoMatrixDialog),sizeof(TGeoMatrixDialog),-1,62464,"List-Tree based matrix dialog",G__setup_memvarTGeoMatrixDialog,G__setup_memfuncTGeoMatrixDialog);
16547 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoSphere);
16548 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoSphereEditor),sizeof(TGeoSphereEditor),-1,62720,"TGeoSphere editor",G__setup_memvarTGeoSphereEditor,G__setup_memfuncTGeoSphereEditor);
16549 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPcon);
16550 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPconSection),sizeof(TGeoPconSection),-1,62464,"TGeoPcon section",G__setup_memvarTGeoPconSection,G__setup_memfuncTGeoPconSection);
16551 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPconEditor),sizeof(TGeoPconEditor),-1,62720,"TGeoPcon editor",G__setup_memvarTGeoPconEditor,G__setup_memfuncTGeoPconEditor);
16552 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPara);
16553 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoParaEditor),sizeof(TGeoParaEditor),-1,62720,"TGeoPara editor",G__setup_memvarTGeoParaEditor,G__setup_memfuncTGeoParaEditor);
16554 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTorus);
16555 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTorusEditor),sizeof(TGeoTorusEditor),-1,62720,"TGeoTorus editor",G__setup_memvarTGeoTorusEditor,G__setup_memfuncTGeoTorusEditor);
16556 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoEltu);
16557 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoEltuEditor),sizeof(TGeoEltuEditor),-1,62720,"TGeoEltu editor",G__setup_memvarTGeoEltuEditor,G__setup_memfuncTGeoEltuEditor);
16558 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoHype);
16559 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoHypeEditor),sizeof(TGeoHypeEditor),-1,62720,"TGeoHype editor",G__setup_memvarTGeoHypeEditor,G__setup_memfuncTGeoHypeEditor);
16560 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoPgonEditor),sizeof(TGeoPgonEditor),-1,62720,"TGeoPgon editor",G__setup_memvarTGeoPgonEditor,G__setup_memfuncTGeoPgonEditor);
16561 G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrap);
16562 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoTrapEditor),sizeof(TGeoTrapEditor),-1,62720,"TGeoTrap editor",G__setup_memvarTGeoTrapEditor,G__setup_memfuncTGeoTrapEditor);
16563 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GeomBuilderLN_TGeoGtraEditor),sizeof(TGeoGtraEditor),-1,62720,"TGeoGtra editor",G__setup_memvarTGeoGtraEditor,G__setup_memfuncTGeoGtraEditor);
16564 }
16565 extern "C" void G__cpp_setupG__GeomBuilder(void) {
16566 G__check_setup_version(30051515,"G__cpp_setupG__GeomBuilder()");
16567 G__set_cpp_environmentG__GeomBuilder();
16568 G__cpp_setup_tagtableG__GeomBuilder();
16569
16570 G__cpp_setup_inheritanceG__GeomBuilder();
16571
16572 G__cpp_setup_typetableG__GeomBuilder();
16573
16574 G__cpp_setup_memvarG__GeomBuilder();
16575
16576 G__cpp_setup_memfuncG__GeomBuilder();
16577 G__cpp_setup_globalG__GeomBuilder();
16578 G__cpp_setup_funcG__GeomBuilder();
16579
16580 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__GeomBuilder();
16581 return;
16582 }
16583 class G__cpp_setup_initG__GeomBuilder {
16584 public:
16585 G__cpp_setup_initG__GeomBuilder() { G__add_setup_func("G__GeomBuilder",(G__incsetup)(&G__cpp_setupG__GeomBuilder)); G__call_setup_funcs(); }
16586 ~G__cpp_setup_initG__GeomBuilder() { G__remove_setup_func("G__GeomBuilder"); }
16587 };
16588 G__cpp_setup_initG__GeomBuilder G__cpp_setup_initializerG__GeomBuilder;
16589
