00001
00002
00003
00004
00005
00006
00007 #define R__DICTIONARY_FILENAME guidIgeddIsrcdIG__Ged
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__Ged.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 TGedEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00041 static void *new_TGedEditor(void *p = 0);
00042 static void *newArray_TGedEditor(Long_t size, void *p);
00043 static void delete_TGedEditor(void *p);
00044 static void deleteArray_TGedEditor(void *p);
00045 static void destruct_TGedEditor(void *p);
00046 static void streamer_TGedEditor(TBuffer &buf, void *obj);
00047
00048
00049 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedEditor*)
00050 {
00051 ::TGedEditor *ptr = 0;
00052 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedEditor >(0);
00053 static ::ROOT::TGenericClassInfo
00054 instance("TGedEditor", ::TGedEditor::Class_Version(), "include/TGedEditor.h", 50,
00055 typeid(::TGedEditor), DefineBehavior(ptr, ptr),
00056 &::TGedEditor::Dictionary, isa_proxy, 0,
00057 sizeof(::TGedEditor) );
00058 instance.SetNew(&new_TGedEditor);
00059 instance.SetNewArray(&newArray_TGedEditor);
00060 instance.SetDelete(&delete_TGedEditor);
00061 instance.SetDeleteArray(&deleteArray_TGedEditor);
00062 instance.SetDestructor(&destruct_TGedEditor);
00063 instance.SetStreamerFunc(&streamer_TGedEditor);
00064 return &instance;
00065 }
00066 TGenericClassInfo *GenerateInitInstance(const ::TGedEditor*)
00067 {
00068 return GenerateInitInstanceLocal((::TGedEditor*)0);
00069 }
00070
00071 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00072 }
00073
00074 namespace ROOT {
00075 void TGedFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
00076 static void delete_TGedFrame(void *p);
00077 static void deleteArray_TGedFrame(void *p);
00078 static void destruct_TGedFrame(void *p);
00079 static void streamer_TGedFrame(TBuffer &buf, void *obj);
00080
00081
00082 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedFrame*)
00083 {
00084 ::TGedFrame *ptr = 0;
00085 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedFrame >(0);
00086 static ::ROOT::TGenericClassInfo
00087 instance("TGedFrame", ::TGedFrame::Class_Version(), "include/TGedFrame.h", 35,
00088 typeid(::TGedFrame), DefineBehavior(ptr, ptr),
00089 &::TGedFrame::Dictionary, isa_proxy, 0,
00090 sizeof(::TGedFrame) );
00091 instance.SetDelete(&delete_TGedFrame);
00092 instance.SetDeleteArray(&deleteArray_TGedFrame);
00093 instance.SetDestructor(&destruct_TGedFrame);
00094 instance.SetStreamerFunc(&streamer_TGedFrame);
00095 return &instance;
00096 }
00097 TGenericClassInfo *GenerateInitInstance(const ::TGedFrame*)
00098 {
00099 return GenerateInitInstanceLocal((::TGedFrame*)0);
00100 }
00101
00102 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00103 }
00104
00105 namespace ROOT {
00106 void TGedNameFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
00107 static void *new_TGedNameFrame(void *p = 0);
00108 static void *newArray_TGedNameFrame(Long_t size, void *p);
00109 static void delete_TGedNameFrame(void *p);
00110 static void deleteArray_TGedNameFrame(void *p);
00111 static void destruct_TGedNameFrame(void *p);
00112 static void streamer_TGedNameFrame(TBuffer &buf, void *obj);
00113
00114
00115 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedNameFrame*)
00116 {
00117 ::TGedNameFrame *ptr = 0;
00118 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedNameFrame >(0);
00119 static ::ROOT::TGenericClassInfo
00120 instance("TGedNameFrame", ::TGedNameFrame::Class_Version(), "include/TGedFrame.h", 94,
00121 typeid(::TGedNameFrame), DefineBehavior(ptr, ptr),
00122 &::TGedNameFrame::Dictionary, isa_proxy, 0,
00123 sizeof(::TGedNameFrame) );
00124 instance.SetNew(&new_TGedNameFrame);
00125 instance.SetNewArray(&newArray_TGedNameFrame);
00126 instance.SetDelete(&delete_TGedNameFrame);
00127 instance.SetDeleteArray(&deleteArray_TGedNameFrame);
00128 instance.SetDestructor(&destruct_TGedNameFrame);
00129 instance.SetStreamerFunc(&streamer_TGedNameFrame);
00130 return &instance;
00131 }
00132 TGenericClassInfo *GenerateInitInstance(const ::TGedNameFrame*)
00133 {
00134 return GenerateInitInstanceLocal((::TGedNameFrame*)0);
00135 }
00136
00137 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedNameFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00138 }
00139
00140 namespace ROOT {
00141 void TArrowEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00142 static void *new_TArrowEditor(void *p = 0);
00143 static void *newArray_TArrowEditor(Long_t size, void *p);
00144 static void delete_TArrowEditor(void *p);
00145 static void deleteArray_TArrowEditor(void *p);
00146 static void destruct_TArrowEditor(void *p);
00147 static void streamer_TArrowEditor(TBuffer &buf, void *obj);
00148
00149
00150 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TArrowEditor*)
00151 {
00152 ::TArrowEditor *ptr = 0;
00153 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TArrowEditor >(0);
00154 static ::ROOT::TGenericClassInfo
00155 instance("TArrowEditor", ::TArrowEditor::Class_Version(), "include/TArrowEditor.h", 31,
00156 typeid(::TArrowEditor), DefineBehavior(ptr, ptr),
00157 &::TArrowEditor::Dictionary, isa_proxy, 0,
00158 sizeof(::TArrowEditor) );
00159 instance.SetNew(&new_TArrowEditor);
00160 instance.SetNewArray(&newArray_TArrowEditor);
00161 instance.SetDelete(&delete_TArrowEditor);
00162 instance.SetDeleteArray(&deleteArray_TArrowEditor);
00163 instance.SetDestructor(&destruct_TArrowEditor);
00164 instance.SetStreamerFunc(&streamer_TArrowEditor);
00165 return &instance;
00166 }
00167 TGenericClassInfo *GenerateInitInstance(const ::TArrowEditor*)
00168 {
00169 return GenerateInitInstanceLocal((::TArrowEditor*)0);
00170 }
00171
00172 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TArrowEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00173 }
00174
00175 namespace ROOT {
00176 void TGedPatternSelect_ShowMembers(void *obj, TMemberInspector &R__insp);
00177 static void delete_TGedPatternSelect(void *p);
00178 static void deleteArray_TGedPatternSelect(void *p);
00179 static void destruct_TGedPatternSelect(void *p);
00180 static void streamer_TGedPatternSelect(TBuffer &buf, void *obj);
00181
00182
00183 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedPatternSelect*)
00184 {
00185 ::TGedPatternSelect *ptr = 0;
00186 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedPatternSelect >(0);
00187 static ::ROOT::TGenericClassInfo
00188 instance("TGedPatternSelect", ::TGedPatternSelect::Class_Version(), "include/TGedPatternSelect.h", 151,
00189 typeid(::TGedPatternSelect), DefineBehavior(ptr, ptr),
00190 &::TGedPatternSelect::Dictionary, isa_proxy, 0,
00191 sizeof(::TGedPatternSelect) );
00192 instance.SetDelete(&delete_TGedPatternSelect);
00193 instance.SetDeleteArray(&deleteArray_TGedPatternSelect);
00194 instance.SetDestructor(&destruct_TGedPatternSelect);
00195 instance.SetStreamerFunc(&streamer_TGedPatternSelect);
00196 return &instance;
00197 }
00198 TGenericClassInfo *GenerateInitInstance(const ::TGedPatternSelect*)
00199 {
00200 return GenerateInitInstanceLocal((::TGedPatternSelect*)0);
00201 }
00202
00203 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedPatternSelect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00204 }
00205
00206 namespace ROOT {
00207 void TAttFillEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00208 static void *new_TAttFillEditor(void *p = 0);
00209 static void *newArray_TAttFillEditor(Long_t size, void *p);
00210 static void delete_TAttFillEditor(void *p);
00211 static void deleteArray_TAttFillEditor(void *p);
00212 static void destruct_TAttFillEditor(void *p);
00213 static void streamer_TAttFillEditor(TBuffer &buf, void *obj);
00214
00215
00216 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TAttFillEditor*)
00217 {
00218 ::TAttFillEditor *ptr = 0;
00219 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TAttFillEditor >(0);
00220 static ::ROOT::TGenericClassInfo
00221 instance("TAttFillEditor", ::TAttFillEditor::Class_Version(), "include/TAttFillEditor.h", 32,
00222 typeid(::TAttFillEditor), DefineBehavior(ptr, ptr),
00223 &::TAttFillEditor::Dictionary, isa_proxy, 0,
00224 sizeof(::TAttFillEditor) );
00225 instance.SetNew(&new_TAttFillEditor);
00226 instance.SetNewArray(&newArray_TAttFillEditor);
00227 instance.SetDelete(&delete_TAttFillEditor);
00228 instance.SetDeleteArray(&deleteArray_TAttFillEditor);
00229 instance.SetDestructor(&destruct_TAttFillEditor);
00230 instance.SetStreamerFunc(&streamer_TAttFillEditor);
00231 return &instance;
00232 }
00233 TGenericClassInfo *GenerateInitInstance(const ::TAttFillEditor*)
00234 {
00235 return GenerateInitInstanceLocal((::TAttFillEditor*)0);
00236 }
00237
00238 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TAttFillEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00239 }
00240
00241 namespace ROOT {
00242 void TAttLineEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00243 static void *new_TAttLineEditor(void *p = 0);
00244 static void *newArray_TAttLineEditor(Long_t size, void *p);
00245 static void delete_TAttLineEditor(void *p);
00246 static void deleteArray_TAttLineEditor(void *p);
00247 static void destruct_TAttLineEditor(void *p);
00248 static void streamer_TAttLineEditor(TBuffer &buf, void *obj);
00249
00250
00251 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TAttLineEditor*)
00252 {
00253 ::TAttLineEditor *ptr = 0;
00254 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TAttLineEditor >(0);
00255 static ::ROOT::TGenericClassInfo
00256 instance("TAttLineEditor", ::TAttLineEditor::Class_Version(), "include/TAttLineEditor.h", 32,
00257 typeid(::TAttLineEditor), DefineBehavior(ptr, ptr),
00258 &::TAttLineEditor::Dictionary, isa_proxy, 0,
00259 sizeof(::TAttLineEditor) );
00260 instance.SetNew(&new_TAttLineEditor);
00261 instance.SetNewArray(&newArray_TAttLineEditor);
00262 instance.SetDelete(&delete_TAttLineEditor);
00263 instance.SetDeleteArray(&deleteArray_TAttLineEditor);
00264 instance.SetDestructor(&destruct_TAttLineEditor);
00265 instance.SetStreamerFunc(&streamer_TAttLineEditor);
00266 return &instance;
00267 }
00268 TGenericClassInfo *GenerateInitInstance(const ::TAttLineEditor*)
00269 {
00270 return GenerateInitInstanceLocal((::TAttLineEditor*)0);
00271 }
00272
00273 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TAttLineEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00274 }
00275
00276 namespace ROOT {
00277 void TGedMarkerSelect_ShowMembers(void *obj, TMemberInspector &R__insp);
00278 static void delete_TGedMarkerSelect(void *p);
00279 static void deleteArray_TGedMarkerSelect(void *p);
00280 static void destruct_TGedMarkerSelect(void *p);
00281 static void streamer_TGedMarkerSelect(TBuffer &buf, void *obj);
00282
00283
00284 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedMarkerSelect*)
00285 {
00286 ::TGedMarkerSelect *ptr = 0;
00287 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedMarkerSelect >(0);
00288 static ::ROOT::TGenericClassInfo
00289 instance("TGedMarkerSelect", ::TGedMarkerSelect::Class_Version(), "include/TGedMarkerSelect.h", 56,
00290 typeid(::TGedMarkerSelect), DefineBehavior(ptr, ptr),
00291 &::TGedMarkerSelect::Dictionary, isa_proxy, 0,
00292 sizeof(::TGedMarkerSelect) );
00293 instance.SetDelete(&delete_TGedMarkerSelect);
00294 instance.SetDeleteArray(&deleteArray_TGedMarkerSelect);
00295 instance.SetDestructor(&destruct_TGedMarkerSelect);
00296 instance.SetStreamerFunc(&streamer_TGedMarkerSelect);
00297 return &instance;
00298 }
00299 TGenericClassInfo *GenerateInitInstance(const ::TGedMarkerSelect*)
00300 {
00301 return GenerateInitInstanceLocal((::TGedMarkerSelect*)0);
00302 }
00303
00304 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedMarkerSelect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00305 }
00306
00307 namespace ROOT {
00308 void TAttMarkerEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00309 static void *new_TAttMarkerEditor(void *p = 0);
00310 static void *newArray_TAttMarkerEditor(Long_t size, void *p);
00311 static void delete_TAttMarkerEditor(void *p);
00312 static void deleteArray_TAttMarkerEditor(void *p);
00313 static void destruct_TAttMarkerEditor(void *p);
00314 static void streamer_TAttMarkerEditor(TBuffer &buf, void *obj);
00315
00316
00317 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TAttMarkerEditor*)
00318 {
00319 ::TAttMarkerEditor *ptr = 0;
00320 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TAttMarkerEditor >(0);
00321 static ::ROOT::TGenericClassInfo
00322 instance("TAttMarkerEditor", ::TAttMarkerEditor::Class_Version(), "include/TAttMarkerEditor.h", 32,
00323 typeid(::TAttMarkerEditor), DefineBehavior(ptr, ptr),
00324 &::TAttMarkerEditor::Dictionary, isa_proxy, 0,
00325 sizeof(::TAttMarkerEditor) );
00326 instance.SetNew(&new_TAttMarkerEditor);
00327 instance.SetNewArray(&newArray_TAttMarkerEditor);
00328 instance.SetDelete(&delete_TAttMarkerEditor);
00329 instance.SetDeleteArray(&deleteArray_TAttMarkerEditor);
00330 instance.SetDestructor(&destruct_TAttMarkerEditor);
00331 instance.SetStreamerFunc(&streamer_TAttMarkerEditor);
00332 return &instance;
00333 }
00334 TGenericClassInfo *GenerateInitInstance(const ::TAttMarkerEditor*)
00335 {
00336 return GenerateInitInstanceLocal((::TAttMarkerEditor*)0);
00337 }
00338
00339 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TAttMarkerEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00340 }
00341
00342 namespace ROOT {
00343 void TAttTextEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00344 static void *new_TAttTextEditor(void *p = 0);
00345 static void *newArray_TAttTextEditor(Long_t size, void *p);
00346 static void delete_TAttTextEditor(void *p);
00347 static void deleteArray_TAttTextEditor(void *p);
00348 static void destruct_TAttTextEditor(void *p);
00349 static void streamer_TAttTextEditor(TBuffer &buf, void *obj);
00350
00351
00352 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TAttTextEditor*)
00353 {
00354 ::TAttTextEditor *ptr = 0;
00355 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TAttTextEditor >(0);
00356 static ::ROOT::TGenericClassInfo
00357 instance("TAttTextEditor", ::TAttTextEditor::Class_Version(), "include/TAttTextEditor.h", 32,
00358 typeid(::TAttTextEditor), DefineBehavior(ptr, ptr),
00359 &::TAttTextEditor::Dictionary, isa_proxy, 0,
00360 sizeof(::TAttTextEditor) );
00361 instance.SetNew(&new_TAttTextEditor);
00362 instance.SetNewArray(&newArray_TAttTextEditor);
00363 instance.SetDelete(&delete_TAttTextEditor);
00364 instance.SetDeleteArray(&deleteArray_TAttTextEditor);
00365 instance.SetDestructor(&destruct_TAttTextEditor);
00366 instance.SetStreamerFunc(&streamer_TAttTextEditor);
00367 return &instance;
00368 }
00369 TGenericClassInfo *GenerateInitInstance(const ::TAttTextEditor*)
00370 {
00371 return GenerateInitInstanceLocal((::TAttTextEditor*)0);
00372 }
00373
00374 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TAttTextEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00375 }
00376
00377 namespace ROOT {
00378 void TAxisEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00379 static void *new_TAxisEditor(void *p = 0);
00380 static void *newArray_TAxisEditor(Long_t size, void *p);
00381 static void delete_TAxisEditor(void *p);
00382 static void deleteArray_TAxisEditor(void *p);
00383 static void destruct_TAxisEditor(void *p);
00384 static void streamer_TAxisEditor(TBuffer &buf, void *obj);
00385
00386
00387 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TAxisEditor*)
00388 {
00389 ::TAxisEditor *ptr = 0;
00390 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TAxisEditor >(0);
00391 static ::ROOT::TGenericClassInfo
00392 instance("TAxisEditor", ::TAxisEditor::Class_Version(), "include/TAxisEditor.h", 37,
00393 typeid(::TAxisEditor), DefineBehavior(ptr, ptr),
00394 &::TAxisEditor::Dictionary, isa_proxy, 0,
00395 sizeof(::TAxisEditor) );
00396 instance.SetNew(&new_TAxisEditor);
00397 instance.SetNewArray(&newArray_TAxisEditor);
00398 instance.SetDelete(&delete_TAxisEditor);
00399 instance.SetDeleteArray(&deleteArray_TAxisEditor);
00400 instance.SetDestructor(&destruct_TAxisEditor);
00401 instance.SetStreamerFunc(&streamer_TAxisEditor);
00402 return &instance;
00403 }
00404 TGenericClassInfo *GenerateInitInstance(const ::TAxisEditor*)
00405 {
00406 return GenerateInitInstanceLocal((::TAxisEditor*)0);
00407 }
00408
00409 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TAxisEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00410 }
00411
00412 namespace ROOT {
00413 void TCurlyArcEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00414 static void *new_TCurlyArcEditor(void *p = 0);
00415 static void *newArray_TCurlyArcEditor(Long_t size, void *p);
00416 static void delete_TCurlyArcEditor(void *p);
00417 static void deleteArray_TCurlyArcEditor(void *p);
00418 static void destruct_TCurlyArcEditor(void *p);
00419 static void streamer_TCurlyArcEditor(TBuffer &buf, void *obj);
00420
00421
00422 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCurlyArcEditor*)
00423 {
00424 ::TCurlyArcEditor *ptr = 0;
00425 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCurlyArcEditor >(0);
00426 static ::ROOT::TGenericClassInfo
00427 instance("TCurlyArcEditor", ::TCurlyArcEditor::Class_Version(), "include/TCurlyArcEditor.h", 30,
00428 typeid(::TCurlyArcEditor), DefineBehavior(ptr, ptr),
00429 &::TCurlyArcEditor::Dictionary, isa_proxy, 0,
00430 sizeof(::TCurlyArcEditor) );
00431 instance.SetNew(&new_TCurlyArcEditor);
00432 instance.SetNewArray(&newArray_TCurlyArcEditor);
00433 instance.SetDelete(&delete_TCurlyArcEditor);
00434 instance.SetDeleteArray(&deleteArray_TCurlyArcEditor);
00435 instance.SetDestructor(&destruct_TCurlyArcEditor);
00436 instance.SetStreamerFunc(&streamer_TCurlyArcEditor);
00437 return &instance;
00438 }
00439 TGenericClassInfo *GenerateInitInstance(const ::TCurlyArcEditor*)
00440 {
00441 return GenerateInitInstanceLocal((::TCurlyArcEditor*)0);
00442 }
00443
00444 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCurlyArcEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00445 }
00446
00447 namespace ROOT {
00448 void TCurlyLineEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00449 static void *new_TCurlyLineEditor(void *p = 0);
00450 static void *newArray_TCurlyLineEditor(Long_t size, void *p);
00451 static void delete_TCurlyLineEditor(void *p);
00452 static void deleteArray_TCurlyLineEditor(void *p);
00453 static void destruct_TCurlyLineEditor(void *p);
00454 static void streamer_TCurlyLineEditor(TBuffer &buf, void *obj);
00455
00456
00457 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCurlyLineEditor*)
00458 {
00459 ::TCurlyLineEditor *ptr = 0;
00460 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCurlyLineEditor >(0);
00461 static ::ROOT::TGenericClassInfo
00462 instance("TCurlyLineEditor", ::TCurlyLineEditor::Class_Version(), "include/TCurlyLineEditor.h", 31,
00463 typeid(::TCurlyLineEditor), DefineBehavior(ptr, ptr),
00464 &::TCurlyLineEditor::Dictionary, isa_proxy, 0,
00465 sizeof(::TCurlyLineEditor) );
00466 instance.SetNew(&new_TCurlyLineEditor);
00467 instance.SetNewArray(&newArray_TCurlyLineEditor);
00468 instance.SetDelete(&delete_TCurlyLineEditor);
00469 instance.SetDeleteArray(&deleteArray_TCurlyLineEditor);
00470 instance.SetDestructor(&destruct_TCurlyLineEditor);
00471 instance.SetStreamerFunc(&streamer_TCurlyLineEditor);
00472 return &instance;
00473 }
00474 TGenericClassInfo *GenerateInitInstance(const ::TCurlyLineEditor*)
00475 {
00476 return GenerateInitInstanceLocal((::TCurlyLineEditor*)0);
00477 }
00478
00479 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCurlyLineEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00480 }
00481
00482 namespace ROOT {
00483 void TF1Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
00484 static void *new_TF1Editor(void *p = 0);
00485 static void *newArray_TF1Editor(Long_t size, void *p);
00486 static void delete_TF1Editor(void *p);
00487 static void deleteArray_TF1Editor(void *p);
00488 static void destruct_TF1Editor(void *p);
00489 static void streamer_TF1Editor(TBuffer &buf, void *obj);
00490
00491
00492 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TF1Editor*)
00493 {
00494 ::TF1Editor *ptr = 0;
00495 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TF1Editor >(0);
00496 static ::ROOT::TGenericClassInfo
00497 instance("TF1Editor", ::TF1Editor::Class_Version(), "include/TF1Editor.h", 36,
00498 typeid(::TF1Editor), DefineBehavior(ptr, ptr),
00499 &::TF1Editor::Dictionary, isa_proxy, 0,
00500 sizeof(::TF1Editor) );
00501 instance.SetNew(&new_TF1Editor);
00502 instance.SetNewArray(&newArray_TF1Editor);
00503 instance.SetDelete(&delete_TF1Editor);
00504 instance.SetDeleteArray(&deleteArray_TF1Editor);
00505 instance.SetDestructor(&destruct_TF1Editor);
00506 instance.SetStreamerFunc(&streamer_TF1Editor);
00507 return &instance;
00508 }
00509 TGenericClassInfo *GenerateInitInstance(const ::TF1Editor*)
00510 {
00511 return GenerateInitInstanceLocal((::TF1Editor*)0);
00512 }
00513
00514 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TF1Editor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00515 }
00516
00517 namespace ROOT {
00518 void TFrameEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00519 static void *new_TFrameEditor(void *p = 0);
00520 static void *newArray_TFrameEditor(Long_t size, void *p);
00521 static void delete_TFrameEditor(void *p);
00522 static void deleteArray_TFrameEditor(void *p);
00523 static void destruct_TFrameEditor(void *p);
00524 static void streamer_TFrameEditor(TBuffer &buf, void *obj);
00525
00526
00527 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFrameEditor*)
00528 {
00529 ::TFrameEditor *ptr = 0;
00530 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFrameEditor >(0);
00531 static ::ROOT::TGenericClassInfo
00532 instance("TFrameEditor", ::TFrameEditor::Class_Version(), "include/TFrameEditor.h", 35,
00533 typeid(::TFrameEditor), DefineBehavior(ptr, ptr),
00534 &::TFrameEditor::Dictionary, isa_proxy, 0,
00535 sizeof(::TFrameEditor) );
00536 instance.SetNew(&new_TFrameEditor);
00537 instance.SetNewArray(&newArray_TFrameEditor);
00538 instance.SetDelete(&delete_TFrameEditor);
00539 instance.SetDeleteArray(&deleteArray_TFrameEditor);
00540 instance.SetDestructor(&destruct_TFrameEditor);
00541 instance.SetStreamerFunc(&streamer_TFrameEditor);
00542 return &instance;
00543 }
00544 TGenericClassInfo *GenerateInitInstance(const ::TFrameEditor*)
00545 {
00546 return GenerateInitInstanceLocal((::TFrameEditor*)0);
00547 }
00548
00549 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFrameEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00550 }
00551
00552 namespace ROOT {
00553 void TFunctionParametersDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
00554 static void delete_TFunctionParametersDialog(void *p);
00555 static void deleteArray_TFunctionParametersDialog(void *p);
00556 static void destruct_TFunctionParametersDialog(void *p);
00557 static void streamer_TFunctionParametersDialog(TBuffer &buf, void *obj);
00558
00559
00560 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFunctionParametersDialog*)
00561 {
00562 ::TFunctionParametersDialog *ptr = 0;
00563 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFunctionParametersDialog >(0);
00564 static ::ROOT::TGenericClassInfo
00565 instance("TFunctionParametersDialog", ::TFunctionParametersDialog::Class_Version(), "include/TFunctionParametersDialog.h", 38,
00566 typeid(::TFunctionParametersDialog), DefineBehavior(ptr, ptr),
00567 &::TFunctionParametersDialog::Dictionary, isa_proxy, 0,
00568 sizeof(::TFunctionParametersDialog) );
00569 instance.SetDelete(&delete_TFunctionParametersDialog);
00570 instance.SetDeleteArray(&deleteArray_TFunctionParametersDialog);
00571 instance.SetDestructor(&destruct_TFunctionParametersDialog);
00572 instance.SetStreamerFunc(&streamer_TFunctionParametersDialog);
00573 return &instance;
00574 }
00575 TGenericClassInfo *GenerateInitInstance(const ::TFunctionParametersDialog*)
00576 {
00577 return GenerateInitInstanceLocal((::TFunctionParametersDialog*)0);
00578 }
00579
00580 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFunctionParametersDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00581 }
00582
00583 namespace ROOT {
00584 void TGedPopup_ShowMembers(void *obj, TMemberInspector &R__insp);
00585 static void delete_TGedPopup(void *p);
00586 static void deleteArray_TGedPopup(void *p);
00587 static void destruct_TGedPopup(void *p);
00588 static void streamer_TGedPopup(TBuffer &buf, void *obj);
00589
00590
00591 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedPopup*)
00592 {
00593 ::TGedPopup *ptr = 0;
00594 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedPopup >(0);
00595 static ::ROOT::TGenericClassInfo
00596 instance("TGedPopup", ::TGedPopup::Class_Version(), "include/TGedPatternSelect.h", 51,
00597 typeid(::TGedPopup), DefineBehavior(ptr, ptr),
00598 &::TGedPopup::Dictionary, isa_proxy, 0,
00599 sizeof(::TGedPopup) );
00600 instance.SetDelete(&delete_TGedPopup);
00601 instance.SetDeleteArray(&deleteArray_TGedPopup);
00602 instance.SetDestructor(&destruct_TGedPopup);
00603 instance.SetStreamerFunc(&streamer_TGedPopup);
00604 return &instance;
00605 }
00606 TGenericClassInfo *GenerateInitInstance(const ::TGedPopup*)
00607 {
00608 return GenerateInitInstanceLocal((::TGedPopup*)0);
00609 }
00610
00611 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedPopup*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00612 }
00613
00614 namespace ROOT {
00615 void TGedPatternFrame_ShowMembers(void *obj, TMemberInspector &R__insp);
00616 static void delete_TGedPatternFrame(void *p);
00617 static void deleteArray_TGedPatternFrame(void *p);
00618 static void destruct_TGedPatternFrame(void *p);
00619 static void streamer_TGedPatternFrame(TBuffer &buf, void *obj);
00620
00621
00622 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedPatternFrame*)
00623 {
00624 ::TGedPatternFrame *ptr = 0;
00625 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedPatternFrame >(0);
00626 static ::ROOT::TGenericClassInfo
00627 instance("TGedPatternFrame", ::TGedPatternFrame::Class_Version(), "include/TGedPatternSelect.h", 69,
00628 typeid(::TGedPatternFrame), DefineBehavior(ptr, ptr),
00629 &::TGedPatternFrame::Dictionary, isa_proxy, 0,
00630 sizeof(::TGedPatternFrame) );
00631 instance.SetDelete(&delete_TGedPatternFrame);
00632 instance.SetDeleteArray(&deleteArray_TGedPatternFrame);
00633 instance.SetDestructor(&destruct_TGedPatternFrame);
00634 instance.SetStreamerFunc(&streamer_TGedPatternFrame);
00635 return &instance;
00636 }
00637 TGenericClassInfo *GenerateInitInstance(const ::TGedPatternFrame*)
00638 {
00639 return GenerateInitInstanceLocal((::TGedPatternFrame*)0);
00640 }
00641
00642 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedPatternFrame*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00643 }
00644
00645 namespace ROOT {
00646 void TGedPatternSelector_ShowMembers(void *obj, TMemberInspector &R__insp);
00647 static void delete_TGedPatternSelector(void *p);
00648 static void deleteArray_TGedPatternSelector(void *p);
00649 static void destruct_TGedPatternSelector(void *p);
00650 static void streamer_TGedPatternSelector(TBuffer &buf, void *obj);
00651
00652
00653 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedPatternSelector*)
00654 {
00655 ::TGedPatternSelector *ptr = 0;
00656 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedPatternSelector >(0);
00657 static ::ROOT::TGenericClassInfo
00658 instance("TGedPatternSelector", ::TGedPatternSelector::Class_Version(), "include/TGedPatternSelect.h", 97,
00659 typeid(::TGedPatternSelector), DefineBehavior(ptr, ptr),
00660 &::TGedPatternSelector::Dictionary, isa_proxy, 0,
00661 sizeof(::TGedPatternSelector) );
00662 instance.SetDelete(&delete_TGedPatternSelector);
00663 instance.SetDeleteArray(&deleteArray_TGedPatternSelector);
00664 instance.SetDestructor(&destruct_TGedPatternSelector);
00665 instance.SetStreamerFunc(&streamer_TGedPatternSelector);
00666 return &instance;
00667 }
00668 TGenericClassInfo *GenerateInitInstance(const ::TGedPatternSelector*)
00669 {
00670 return GenerateInitInstanceLocal((::TGedPatternSelector*)0);
00671 }
00672
00673 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedPatternSelector*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00674 }
00675
00676 namespace ROOT {
00677 void TGedPatternPopup_ShowMembers(void *obj, TMemberInspector &R__insp);
00678 static void delete_TGedPatternPopup(void *p);
00679 static void deleteArray_TGedPatternPopup(void *p);
00680 static void destruct_TGedPatternPopup(void *p);
00681 static void streamer_TGedPatternPopup(TBuffer &buf, void *obj);
00682
00683
00684 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedPatternPopup*)
00685 {
00686 ::TGedPatternPopup *ptr = 0;
00687 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedPatternPopup >(0);
00688 static ::ROOT::TGenericClassInfo
00689 instance("TGedPatternPopup", ::TGedPatternPopup::Class_Version(), "include/TGedPatternSelect.h", 115,
00690 typeid(::TGedPatternPopup), DefineBehavior(ptr, ptr),
00691 &::TGedPatternPopup::Dictionary, isa_proxy, 0,
00692 sizeof(::TGedPatternPopup) );
00693 instance.SetDelete(&delete_TGedPatternPopup);
00694 instance.SetDeleteArray(&deleteArray_TGedPatternPopup);
00695 instance.SetDestructor(&destruct_TGedPatternPopup);
00696 instance.SetStreamerFunc(&streamer_TGedPatternPopup);
00697 return &instance;
00698 }
00699 TGenericClassInfo *GenerateInitInstance(const ::TGedPatternPopup*)
00700 {
00701 return GenerateInitInstanceLocal((::TGedPatternPopup*)0);
00702 }
00703
00704 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedPatternPopup*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00705 }
00706
00707 namespace ROOT {
00708 void TGedSelect_ShowMembers(void *obj, TMemberInspector &R__insp);
00709 static void delete_TGedSelect(void *p);
00710 static void deleteArray_TGedSelect(void *p);
00711 static void destruct_TGedSelect(void *p);
00712 static void streamer_TGedSelect(TBuffer &buf, void *obj);
00713
00714
00715 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedSelect*)
00716 {
00717 ::TGedSelect *ptr = 0;
00718 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedSelect >(0);
00719 static ::ROOT::TGenericClassInfo
00720 instance("TGedSelect", ::TGedSelect::Class_Version(), "include/TGedPatternSelect.h", 129,
00721 typeid(::TGedSelect), DefineBehavior(ptr, ptr),
00722 &::TGedSelect::Dictionary, isa_proxy, 0,
00723 sizeof(::TGedSelect) );
00724 instance.SetDelete(&delete_TGedSelect);
00725 instance.SetDeleteArray(&deleteArray_TGedSelect);
00726 instance.SetDestructor(&destruct_TGedSelect);
00727 instance.SetStreamerFunc(&streamer_TGedSelect);
00728 return &instance;
00729 }
00730 TGenericClassInfo *GenerateInitInstance(const ::TGedSelect*)
00731 {
00732 return GenerateInitInstanceLocal((::TGedSelect*)0);
00733 }
00734
00735 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedSelect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00736 }
00737
00738 namespace ROOT {
00739 void TGedMarkerPopup_ShowMembers(void *obj, TMemberInspector &R__insp);
00740 static void delete_TGedMarkerPopup(void *p);
00741 static void deleteArray_TGedMarkerPopup(void *p);
00742 static void destruct_TGedMarkerPopup(void *p);
00743 static void streamer_TGedMarkerPopup(TBuffer &buf, void *obj);
00744
00745
00746 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGedMarkerPopup*)
00747 {
00748 ::TGedMarkerPopup *ptr = 0;
00749 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGedMarkerPopup >(0);
00750 static ::ROOT::TGenericClassInfo
00751 instance("TGedMarkerPopup", ::TGedMarkerPopup::Class_Version(), "include/TGedMarkerSelect.h", 41,
00752 typeid(::TGedMarkerPopup), DefineBehavior(ptr, ptr),
00753 &::TGedMarkerPopup::Dictionary, isa_proxy, 0,
00754 sizeof(::TGedMarkerPopup) );
00755 instance.SetDelete(&delete_TGedMarkerPopup);
00756 instance.SetDeleteArray(&deleteArray_TGedMarkerPopup);
00757 instance.SetDestructor(&destruct_TGedMarkerPopup);
00758 instance.SetStreamerFunc(&streamer_TGedMarkerPopup);
00759 return &instance;
00760 }
00761 TGenericClassInfo *GenerateInitInstance(const ::TGedMarkerPopup*)
00762 {
00763 return GenerateInitInstanceLocal((::TGedMarkerPopup*)0);
00764 }
00765
00766 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGedMarkerPopup*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00767 }
00768
00769 namespace ROOT {
00770 void TGraphEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00771 static void *new_TGraphEditor(void *p = 0);
00772 static void *newArray_TGraphEditor(Long_t size, void *p);
00773 static void delete_TGraphEditor(void *p);
00774 static void deleteArray_TGraphEditor(void *p);
00775 static void destruct_TGraphEditor(void *p);
00776 static void streamer_TGraphEditor(TBuffer &buf, void *obj);
00777
00778
00779 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TGraphEditor*)
00780 {
00781 ::TGraphEditor *ptr = 0;
00782 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TGraphEditor >(0);
00783 static ::ROOT::TGenericClassInfo
00784 instance("TGraphEditor", ::TGraphEditor::Class_Version(), "include/TGraphEditor.h", 34,
00785 typeid(::TGraphEditor), DefineBehavior(ptr, ptr),
00786 &::TGraphEditor::Dictionary, isa_proxy, 0,
00787 sizeof(::TGraphEditor) );
00788 instance.SetNew(&new_TGraphEditor);
00789 instance.SetNewArray(&newArray_TGraphEditor);
00790 instance.SetDelete(&delete_TGraphEditor);
00791 instance.SetDeleteArray(&deleteArray_TGraphEditor);
00792 instance.SetDestructor(&destruct_TGraphEditor);
00793 instance.SetStreamerFunc(&streamer_TGraphEditor);
00794 return &instance;
00795 }
00796 TGenericClassInfo *GenerateInitInstance(const ::TGraphEditor*)
00797 {
00798 return GenerateInitInstanceLocal((::TGraphEditor*)0);
00799 }
00800
00801 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TGraphEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00802 }
00803
00804 namespace ROOT {
00805 void TH1Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
00806 static void *new_TH1Editor(void *p = 0);
00807 static void *newArray_TH1Editor(Long_t size, void *p);
00808 static void delete_TH1Editor(void *p);
00809 static void deleteArray_TH1Editor(void *p);
00810 static void destruct_TH1Editor(void *p);
00811 static void streamer_TH1Editor(TBuffer &buf, void *obj);
00812
00813
00814 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH1Editor*)
00815 {
00816 ::TH1Editor *ptr = 0;
00817 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH1Editor >(0);
00818 static ::ROOT::TGenericClassInfo
00819 instance("TH1Editor", ::TH1Editor::Class_Version(), "include/TH1Editor.h", 42,
00820 typeid(::TH1Editor), DefineBehavior(ptr, ptr),
00821 &::TH1Editor::Dictionary, isa_proxy, 0,
00822 sizeof(::TH1Editor) );
00823 instance.SetNew(&new_TH1Editor);
00824 instance.SetNewArray(&newArray_TH1Editor);
00825 instance.SetDelete(&delete_TH1Editor);
00826 instance.SetDeleteArray(&deleteArray_TH1Editor);
00827 instance.SetDestructor(&destruct_TH1Editor);
00828 instance.SetStreamerFunc(&streamer_TH1Editor);
00829 return &instance;
00830 }
00831 TGenericClassInfo *GenerateInitInstance(const ::TH1Editor*)
00832 {
00833 return GenerateInitInstanceLocal((::TH1Editor*)0);
00834 }
00835
00836 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH1Editor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00837 }
00838
00839 namespace ROOT {
00840 void TH2Editor_ShowMembers(void *obj, TMemberInspector &R__insp);
00841 static void *new_TH2Editor(void *p = 0);
00842 static void *newArray_TH2Editor(Long_t size, void *p);
00843 static void delete_TH2Editor(void *p);
00844 static void deleteArray_TH2Editor(void *p);
00845 static void destruct_TH2Editor(void *p);
00846 static void streamer_TH2Editor(TBuffer &buf, void *obj);
00847
00848
00849 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TH2Editor*)
00850 {
00851 ::TH2Editor *ptr = 0;
00852 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TH2Editor >(0);
00853 static ::ROOT::TGenericClassInfo
00854 instance("TH2Editor", ::TH2Editor::Class_Version(), "include/TH2Editor.h", 43,
00855 typeid(::TH2Editor), DefineBehavior(ptr, ptr),
00856 &::TH2Editor::Dictionary, isa_proxy, 0,
00857 sizeof(::TH2Editor) );
00858 instance.SetNew(&new_TH2Editor);
00859 instance.SetNewArray(&newArray_TH2Editor);
00860 instance.SetDelete(&delete_TH2Editor);
00861 instance.SetDeleteArray(&deleteArray_TH2Editor);
00862 instance.SetDestructor(&destruct_TH2Editor);
00863 instance.SetStreamerFunc(&streamer_TH2Editor);
00864 return &instance;
00865 }
00866 TGenericClassInfo *GenerateInitInstance(const ::TH2Editor*)
00867 {
00868 return GenerateInitInstanceLocal((::TH2Editor*)0);
00869 }
00870
00871 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TH2Editor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00872 }
00873
00874 namespace ROOT {
00875 void TLineEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00876 static void *new_TLineEditor(void *p = 0);
00877 static void *newArray_TLineEditor(Long_t size, void *p);
00878 static void delete_TLineEditor(void *p);
00879 static void deleteArray_TLineEditor(void *p);
00880 static void destruct_TLineEditor(void *p);
00881 static void streamer_TLineEditor(TBuffer &buf, void *obj);
00882
00883
00884 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TLineEditor*)
00885 {
00886 ::TLineEditor *ptr = 0;
00887 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TLineEditor >(0);
00888 static ::ROOT::TGenericClassInfo
00889 instance("TLineEditor", ::TLineEditor::Class_Version(), "include/TLineEditor.h", 31,
00890 typeid(::TLineEditor), DefineBehavior(ptr, ptr),
00891 &::TLineEditor::Dictionary, isa_proxy, 0,
00892 sizeof(::TLineEditor) );
00893 instance.SetNew(&new_TLineEditor);
00894 instance.SetNewArray(&newArray_TLineEditor);
00895 instance.SetDelete(&delete_TLineEditor);
00896 instance.SetDeleteArray(&deleteArray_TLineEditor);
00897 instance.SetDestructor(&destruct_TLineEditor);
00898 instance.SetStreamerFunc(&streamer_TLineEditor);
00899 return &instance;
00900 }
00901 TGenericClassInfo *GenerateInitInstance(const ::TLineEditor*)
00902 {
00903 return GenerateInitInstanceLocal((::TLineEditor*)0);
00904 }
00905
00906 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TLineEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00907 }
00908
00909 namespace ROOT {
00910 void TPadEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00911 static void *new_TPadEditor(void *p = 0);
00912 static void *newArray_TPadEditor(Long_t size, void *p);
00913 static void delete_TPadEditor(void *p);
00914 static void deleteArray_TPadEditor(void *p);
00915 static void destruct_TPadEditor(void *p);
00916 static void streamer_TPadEditor(TBuffer &buf, void *obj);
00917
00918
00919 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPadEditor*)
00920 {
00921 ::TPadEditor *ptr = 0;
00922 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPadEditor >(0);
00923 static ::ROOT::TGenericClassInfo
00924 instance("TPadEditor", ::TPadEditor::Class_Version(), "include/TPadEditor.h", 34,
00925 typeid(::TPadEditor), DefineBehavior(ptr, ptr),
00926 &::TPadEditor::Dictionary, isa_proxy, 0,
00927 sizeof(::TPadEditor) );
00928 instance.SetNew(&new_TPadEditor);
00929 instance.SetNewArray(&newArray_TPadEditor);
00930 instance.SetDelete(&delete_TPadEditor);
00931 instance.SetDeleteArray(&deleteArray_TPadEditor);
00932 instance.SetDestructor(&destruct_TPadEditor);
00933 instance.SetStreamerFunc(&streamer_TPadEditor);
00934 return &instance;
00935 }
00936 TGenericClassInfo *GenerateInitInstance(const ::TPadEditor*)
00937 {
00938 return GenerateInitInstanceLocal((::TPadEditor*)0);
00939 }
00940
00941 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPadEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00942 }
00943
00944 namespace ROOT {
00945 void TPaveStatsEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00946 static void *new_TPaveStatsEditor(void *p = 0);
00947 static void *newArray_TPaveStatsEditor(Long_t size, void *p);
00948 static void delete_TPaveStatsEditor(void *p);
00949 static void deleteArray_TPaveStatsEditor(void *p);
00950 static void destruct_TPaveStatsEditor(void *p);
00951 static void streamer_TPaveStatsEditor(TBuffer &buf, void *obj);
00952
00953
00954 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPaveStatsEditor*)
00955 {
00956 ::TPaveStatsEditor *ptr = 0;
00957 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPaveStatsEditor >(0);
00958 static ::ROOT::TGenericClassInfo
00959 instance("TPaveStatsEditor", ::TPaveStatsEditor::Class_Version(), "include/TPaveStatsEditor.h", 30,
00960 typeid(::TPaveStatsEditor), DefineBehavior(ptr, ptr),
00961 &::TPaveStatsEditor::Dictionary, isa_proxy, 0,
00962 sizeof(::TPaveStatsEditor) );
00963 instance.SetNew(&new_TPaveStatsEditor);
00964 instance.SetNewArray(&newArray_TPaveStatsEditor);
00965 instance.SetDelete(&delete_TPaveStatsEditor);
00966 instance.SetDeleteArray(&deleteArray_TPaveStatsEditor);
00967 instance.SetDestructor(&destruct_TPaveStatsEditor);
00968 instance.SetStreamerFunc(&streamer_TPaveStatsEditor);
00969 return &instance;
00970 }
00971 TGenericClassInfo *GenerateInitInstance(const ::TPaveStatsEditor*)
00972 {
00973 return GenerateInitInstanceLocal((::TPaveStatsEditor*)0);
00974 }
00975
00976 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPaveStatsEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00977 }
00978
00979 namespace ROOT {
00980 void TPieEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
00981 static void *new_TPieEditor(void *p = 0);
00982 static void *newArray_TPieEditor(Long_t size, void *p);
00983 static void delete_TPieEditor(void *p);
00984 static void deleteArray_TPieEditor(void *p);
00985 static void destruct_TPieEditor(void *p);
00986 static void streamer_TPieEditor(TBuffer &buf, void *obj);
00987
00988
00989 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPieEditor*)
00990 {
00991 ::TPieEditor *ptr = 0;
00992 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPieEditor >(0);
00993 static ::ROOT::TGenericClassInfo
00994 instance("TPieEditor", ::TPieEditor::Class_Version(), "include/TPieEditor.h", 37,
00995 typeid(::TPieEditor), DefineBehavior(ptr, ptr),
00996 &::TPieEditor::Dictionary, isa_proxy, 0,
00997 sizeof(::TPieEditor) );
00998 instance.SetNew(&new_TPieEditor);
00999 instance.SetNewArray(&newArray_TPieEditor);
01000 instance.SetDelete(&delete_TPieEditor);
01001 instance.SetDeleteArray(&deleteArray_TPieEditor);
01002 instance.SetDestructor(&destruct_TPieEditor);
01003 instance.SetStreamerFunc(&streamer_TPieEditor);
01004 return &instance;
01005 }
01006 TGenericClassInfo *GenerateInitInstance(const ::TPieEditor*)
01007 {
01008 return GenerateInitInstanceLocal((::TPieEditor*)0);
01009 }
01010
01011 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPieEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01012 }
01013
01014 namespace ROOT {
01015 void TPieSliceEditor_ShowMembers(void *obj, TMemberInspector &R__insp);
01016 static void *new_TPieSliceEditor(void *p = 0);
01017 static void *newArray_TPieSliceEditor(Long_t size, void *p);
01018 static void delete_TPieSliceEditor(void *p);
01019 static void deleteArray_TPieSliceEditor(void *p);
01020 static void destruct_TPieSliceEditor(void *p);
01021 static void streamer_TPieSliceEditor(TBuffer &buf, void *obj);
01022
01023
01024 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPieSliceEditor*)
01025 {
01026 ::TPieSliceEditor *ptr = 0;
01027 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPieSliceEditor >(0);
01028 static ::ROOT::TGenericClassInfo
01029 instance("TPieSliceEditor", ::TPieSliceEditor::Class_Version(), "include/TPieSliceEditor.h", 30,
01030 typeid(::TPieSliceEditor), DefineBehavior(ptr, ptr),
01031 &::TPieSliceEditor::Dictionary, isa_proxy, 0,
01032 sizeof(::TPieSliceEditor) );
01033 instance.SetNew(&new_TPieSliceEditor);
01034 instance.SetNewArray(&newArray_TPieSliceEditor);
01035 instance.SetDelete(&delete_TPieSliceEditor);
01036 instance.SetDeleteArray(&deleteArray_TPieSliceEditor);
01037 instance.SetDestructor(&destruct_TPieSliceEditor);
01038 instance.SetStreamerFunc(&streamer_TPieSliceEditor);
01039 return &instance;
01040 }
01041 TGenericClassInfo *GenerateInitInstance(const ::TPieSliceEditor*)
01042 {
01043 return GenerateInitInstanceLocal((::TPieSliceEditor*)0);
01044 }
01045
01046 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPieSliceEditor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01047 }
01048
01049 namespace ROOT {
01050 void TStyleManager_ShowMembers(void *obj, TMemberInspector &R__insp);
01051 static void delete_TStyleManager(void *p);
01052 static void deleteArray_TStyleManager(void *p);
01053 static void destruct_TStyleManager(void *p);
01054 static void streamer_TStyleManager(TBuffer &buf, void *obj);
01055
01056
01057 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStyleManager*)
01058 {
01059 ::TStyleManager *ptr = 0;
01060 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStyleManager >(0);
01061 static ::ROOT::TGenericClassInfo
01062 instance("TStyleManager", ::TStyleManager::Class_Version(), "include/TStyleManager.h", 68,
01063 typeid(::TStyleManager), DefineBehavior(ptr, ptr),
01064 &::TStyleManager::Dictionary, isa_proxy, 0,
01065 sizeof(::TStyleManager) );
01066 instance.SetDelete(&delete_TStyleManager);
01067 instance.SetDeleteArray(&deleteArray_TStyleManager);
01068 instance.SetDestructor(&destruct_TStyleManager);
01069 instance.SetStreamerFunc(&streamer_TStyleManager);
01070 return &instance;
01071 }
01072 TGenericClassInfo *GenerateInitInstance(const ::TStyleManager*)
01073 {
01074 return GenerateInitInstanceLocal((::TStyleManager*)0);
01075 }
01076
01077 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStyleManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01078 }
01079
01080 namespace ROOT {
01081 void TStyleDialog_ShowMembers(void *obj, TMemberInspector &R__insp);
01082 static void delete_TStyleDialog(void *p);
01083 static void deleteArray_TStyleDialog(void *p);
01084 static void destruct_TStyleDialog(void *p);
01085 static void streamer_TStyleDialog(TBuffer &buf, void *obj);
01086
01087
01088 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStyleDialog*)
01089 {
01090 ::TStyleDialog *ptr = 0;
01091 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStyleDialog >(0);
01092 static ::ROOT::TGenericClassInfo
01093 instance("TStyleDialog", ::TStyleDialog::Class_Version(), "include/TStyleDialog.h", 38,
01094 typeid(::TStyleDialog), DefineBehavior(ptr, ptr),
01095 &::TStyleDialog::Dictionary, isa_proxy, 0,
01096 sizeof(::TStyleDialog) );
01097 instance.SetDelete(&delete_TStyleDialog);
01098 instance.SetDeleteArray(&deleteArray_TStyleDialog);
01099 instance.SetDestructor(&destruct_TStyleDialog);
01100 instance.SetStreamerFunc(&streamer_TStyleDialog);
01101 return &instance;
01102 }
01103 TGenericClassInfo *GenerateInitInstance(const ::TStyleDialog*)
01104 {
01105 return GenerateInitInstanceLocal((::TStyleDialog*)0);
01106 }
01107
01108 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStyleDialog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01109 }
01110
01111 namespace ROOT {
01112 void TStylePreview_ShowMembers(void *obj, TMemberInspector &R__insp);
01113 static void delete_TStylePreview(void *p);
01114 static void deleteArray_TStylePreview(void *p);
01115 static void destruct_TStylePreview(void *p);
01116 static void streamer_TStylePreview(TBuffer &buf, void *obj);
01117
01118
01119 static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStylePreview*)
01120 {
01121 ::TStylePreview *ptr = 0;
01122 static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStylePreview >(0);
01123 static ::ROOT::TGenericClassInfo
01124 instance("TStylePreview", ::TStylePreview::Class_Version(), "include/TStylePreview.h", 35,
01125 typeid(::TStylePreview), DefineBehavior(ptr, ptr),
01126 &::TStylePreview::Dictionary, isa_proxy, 0,
01127 sizeof(::TStylePreview) );
01128 instance.SetDelete(&delete_TStylePreview);
01129 instance.SetDeleteArray(&deleteArray_TStylePreview);
01130 instance.SetDestructor(&destruct_TStylePreview);
01131 instance.SetStreamerFunc(&streamer_TStylePreview);
01132 return &instance;
01133 }
01134 TGenericClassInfo *GenerateInitInstance(const ::TStylePreview*)
01135 {
01136 return GenerateInitInstanceLocal((::TStylePreview*)0);
01137 }
01138
01139 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStylePreview*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01140 }
01141
01142
01143 TClass *TGedEditor::fgIsA = 0;
01144
01145
01146 const char *TGedEditor::Class_Name()
01147 {
01148 return "TGedEditor";
01149 }
01150
01151
01152 const char *TGedEditor::ImplFileName()
01153 {
01154 return ::ROOT::GenerateInitInstanceLocal((const ::TGedEditor*)0x0)->GetImplFileName();
01155 }
01156
01157
01158 int TGedEditor::ImplFileLine()
01159 {
01160 return ::ROOT::GenerateInitInstanceLocal((const ::TGedEditor*)0x0)->GetImplFileLine();
01161 }
01162
01163
01164 void TGedEditor::Dictionary()
01165 {
01166 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedEditor*)0x0)->GetClass();
01167 }
01168
01169
01170 TClass *TGedEditor::Class()
01171 {
01172 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedEditor*)0x0)->GetClass();
01173 return fgIsA;
01174 }
01175
01176
01177 TClass *TGedFrame::fgIsA = 0;
01178
01179
01180 const char *TGedFrame::Class_Name()
01181 {
01182 return "TGedFrame";
01183 }
01184
01185
01186 const char *TGedFrame::ImplFileName()
01187 {
01188 return ::ROOT::GenerateInitInstanceLocal((const ::TGedFrame*)0x0)->GetImplFileName();
01189 }
01190
01191
01192 int TGedFrame::ImplFileLine()
01193 {
01194 return ::ROOT::GenerateInitInstanceLocal((const ::TGedFrame*)0x0)->GetImplFileLine();
01195 }
01196
01197
01198 void TGedFrame::Dictionary()
01199 {
01200 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedFrame*)0x0)->GetClass();
01201 }
01202
01203
01204 TClass *TGedFrame::Class()
01205 {
01206 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedFrame*)0x0)->GetClass();
01207 return fgIsA;
01208 }
01209
01210
01211 TClass *TGedNameFrame::fgIsA = 0;
01212
01213
01214 const char *TGedNameFrame::Class_Name()
01215 {
01216 return "TGedNameFrame";
01217 }
01218
01219
01220 const char *TGedNameFrame::ImplFileName()
01221 {
01222 return ::ROOT::GenerateInitInstanceLocal((const ::TGedNameFrame*)0x0)->GetImplFileName();
01223 }
01224
01225
01226 int TGedNameFrame::ImplFileLine()
01227 {
01228 return ::ROOT::GenerateInitInstanceLocal((const ::TGedNameFrame*)0x0)->GetImplFileLine();
01229 }
01230
01231
01232 void TGedNameFrame::Dictionary()
01233 {
01234 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedNameFrame*)0x0)->GetClass();
01235 }
01236
01237
01238 TClass *TGedNameFrame::Class()
01239 {
01240 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedNameFrame*)0x0)->GetClass();
01241 return fgIsA;
01242 }
01243
01244
01245 TClass *TArrowEditor::fgIsA = 0;
01246
01247
01248 const char *TArrowEditor::Class_Name()
01249 {
01250 return "TArrowEditor";
01251 }
01252
01253
01254 const char *TArrowEditor::ImplFileName()
01255 {
01256 return ::ROOT::GenerateInitInstanceLocal((const ::TArrowEditor*)0x0)->GetImplFileName();
01257 }
01258
01259
01260 int TArrowEditor::ImplFileLine()
01261 {
01262 return ::ROOT::GenerateInitInstanceLocal((const ::TArrowEditor*)0x0)->GetImplFileLine();
01263 }
01264
01265
01266 void TArrowEditor::Dictionary()
01267 {
01268 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TArrowEditor*)0x0)->GetClass();
01269 }
01270
01271
01272 TClass *TArrowEditor::Class()
01273 {
01274 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TArrowEditor*)0x0)->GetClass();
01275 return fgIsA;
01276 }
01277
01278
01279 TClass *TGedPatternSelect::fgIsA = 0;
01280
01281
01282 const char *TGedPatternSelect::Class_Name()
01283 {
01284 return "TGedPatternSelect";
01285 }
01286
01287
01288 const char *TGedPatternSelect::ImplFileName()
01289 {
01290 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternSelect*)0x0)->GetImplFileName();
01291 }
01292
01293
01294 int TGedPatternSelect::ImplFileLine()
01295 {
01296 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternSelect*)0x0)->GetImplFileLine();
01297 }
01298
01299
01300 void TGedPatternSelect::Dictionary()
01301 {
01302 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternSelect*)0x0)->GetClass();
01303 }
01304
01305
01306 TClass *TGedPatternSelect::Class()
01307 {
01308 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternSelect*)0x0)->GetClass();
01309 return fgIsA;
01310 }
01311
01312
01313 TClass *TAttFillEditor::fgIsA = 0;
01314
01315
01316 const char *TAttFillEditor::Class_Name()
01317 {
01318 return "TAttFillEditor";
01319 }
01320
01321
01322 const char *TAttFillEditor::ImplFileName()
01323 {
01324 return ::ROOT::GenerateInitInstanceLocal((const ::TAttFillEditor*)0x0)->GetImplFileName();
01325 }
01326
01327
01328 int TAttFillEditor::ImplFileLine()
01329 {
01330 return ::ROOT::GenerateInitInstanceLocal((const ::TAttFillEditor*)0x0)->GetImplFileLine();
01331 }
01332
01333
01334 void TAttFillEditor::Dictionary()
01335 {
01336 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAttFillEditor*)0x0)->GetClass();
01337 }
01338
01339
01340 TClass *TAttFillEditor::Class()
01341 {
01342 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAttFillEditor*)0x0)->GetClass();
01343 return fgIsA;
01344 }
01345
01346
01347 TClass *TAttLineEditor::fgIsA = 0;
01348
01349
01350 const char *TAttLineEditor::Class_Name()
01351 {
01352 return "TAttLineEditor";
01353 }
01354
01355
01356 const char *TAttLineEditor::ImplFileName()
01357 {
01358 return ::ROOT::GenerateInitInstanceLocal((const ::TAttLineEditor*)0x0)->GetImplFileName();
01359 }
01360
01361
01362 int TAttLineEditor::ImplFileLine()
01363 {
01364 return ::ROOT::GenerateInitInstanceLocal((const ::TAttLineEditor*)0x0)->GetImplFileLine();
01365 }
01366
01367
01368 void TAttLineEditor::Dictionary()
01369 {
01370 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAttLineEditor*)0x0)->GetClass();
01371 }
01372
01373
01374 TClass *TAttLineEditor::Class()
01375 {
01376 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAttLineEditor*)0x0)->GetClass();
01377 return fgIsA;
01378 }
01379
01380
01381 TClass *TGedMarkerSelect::fgIsA = 0;
01382
01383
01384 const char *TGedMarkerSelect::Class_Name()
01385 {
01386 return "TGedMarkerSelect";
01387 }
01388
01389
01390 const char *TGedMarkerSelect::ImplFileName()
01391 {
01392 return ::ROOT::GenerateInitInstanceLocal((const ::TGedMarkerSelect*)0x0)->GetImplFileName();
01393 }
01394
01395
01396 int TGedMarkerSelect::ImplFileLine()
01397 {
01398 return ::ROOT::GenerateInitInstanceLocal((const ::TGedMarkerSelect*)0x0)->GetImplFileLine();
01399 }
01400
01401
01402 void TGedMarkerSelect::Dictionary()
01403 {
01404 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedMarkerSelect*)0x0)->GetClass();
01405 }
01406
01407
01408 TClass *TGedMarkerSelect::Class()
01409 {
01410 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedMarkerSelect*)0x0)->GetClass();
01411 return fgIsA;
01412 }
01413
01414
01415 TClass *TAttMarkerEditor::fgIsA = 0;
01416
01417
01418 const char *TAttMarkerEditor::Class_Name()
01419 {
01420 return "TAttMarkerEditor";
01421 }
01422
01423
01424 const char *TAttMarkerEditor::ImplFileName()
01425 {
01426 return ::ROOT::GenerateInitInstanceLocal((const ::TAttMarkerEditor*)0x0)->GetImplFileName();
01427 }
01428
01429
01430 int TAttMarkerEditor::ImplFileLine()
01431 {
01432 return ::ROOT::GenerateInitInstanceLocal((const ::TAttMarkerEditor*)0x0)->GetImplFileLine();
01433 }
01434
01435
01436 void TAttMarkerEditor::Dictionary()
01437 {
01438 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAttMarkerEditor*)0x0)->GetClass();
01439 }
01440
01441
01442 TClass *TAttMarkerEditor::Class()
01443 {
01444 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAttMarkerEditor*)0x0)->GetClass();
01445 return fgIsA;
01446 }
01447
01448
01449 TClass *TAttTextEditor::fgIsA = 0;
01450
01451
01452 const char *TAttTextEditor::Class_Name()
01453 {
01454 return "TAttTextEditor";
01455 }
01456
01457
01458 const char *TAttTextEditor::ImplFileName()
01459 {
01460 return ::ROOT::GenerateInitInstanceLocal((const ::TAttTextEditor*)0x0)->GetImplFileName();
01461 }
01462
01463
01464 int TAttTextEditor::ImplFileLine()
01465 {
01466 return ::ROOT::GenerateInitInstanceLocal((const ::TAttTextEditor*)0x0)->GetImplFileLine();
01467 }
01468
01469
01470 void TAttTextEditor::Dictionary()
01471 {
01472 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAttTextEditor*)0x0)->GetClass();
01473 }
01474
01475
01476 TClass *TAttTextEditor::Class()
01477 {
01478 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAttTextEditor*)0x0)->GetClass();
01479 return fgIsA;
01480 }
01481
01482
01483 TClass *TAxisEditor::fgIsA = 0;
01484
01485
01486 const char *TAxisEditor::Class_Name()
01487 {
01488 return "TAxisEditor";
01489 }
01490
01491
01492 const char *TAxisEditor::ImplFileName()
01493 {
01494 return ::ROOT::GenerateInitInstanceLocal((const ::TAxisEditor*)0x0)->GetImplFileName();
01495 }
01496
01497
01498 int TAxisEditor::ImplFileLine()
01499 {
01500 return ::ROOT::GenerateInitInstanceLocal((const ::TAxisEditor*)0x0)->GetImplFileLine();
01501 }
01502
01503
01504 void TAxisEditor::Dictionary()
01505 {
01506 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAxisEditor*)0x0)->GetClass();
01507 }
01508
01509
01510 TClass *TAxisEditor::Class()
01511 {
01512 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TAxisEditor*)0x0)->GetClass();
01513 return fgIsA;
01514 }
01515
01516
01517 TClass *TCurlyArcEditor::fgIsA = 0;
01518
01519
01520 const char *TCurlyArcEditor::Class_Name()
01521 {
01522 return "TCurlyArcEditor";
01523 }
01524
01525
01526 const char *TCurlyArcEditor::ImplFileName()
01527 {
01528 return ::ROOT::GenerateInitInstanceLocal((const ::TCurlyArcEditor*)0x0)->GetImplFileName();
01529 }
01530
01531
01532 int TCurlyArcEditor::ImplFileLine()
01533 {
01534 return ::ROOT::GenerateInitInstanceLocal((const ::TCurlyArcEditor*)0x0)->GetImplFileLine();
01535 }
01536
01537
01538 void TCurlyArcEditor::Dictionary()
01539 {
01540 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCurlyArcEditor*)0x0)->GetClass();
01541 }
01542
01543
01544 TClass *TCurlyArcEditor::Class()
01545 {
01546 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCurlyArcEditor*)0x0)->GetClass();
01547 return fgIsA;
01548 }
01549
01550
01551 TClass *TCurlyLineEditor::fgIsA = 0;
01552
01553
01554 const char *TCurlyLineEditor::Class_Name()
01555 {
01556 return "TCurlyLineEditor";
01557 }
01558
01559
01560 const char *TCurlyLineEditor::ImplFileName()
01561 {
01562 return ::ROOT::GenerateInitInstanceLocal((const ::TCurlyLineEditor*)0x0)->GetImplFileName();
01563 }
01564
01565
01566 int TCurlyLineEditor::ImplFileLine()
01567 {
01568 return ::ROOT::GenerateInitInstanceLocal((const ::TCurlyLineEditor*)0x0)->GetImplFileLine();
01569 }
01570
01571
01572 void TCurlyLineEditor::Dictionary()
01573 {
01574 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCurlyLineEditor*)0x0)->GetClass();
01575 }
01576
01577
01578 TClass *TCurlyLineEditor::Class()
01579 {
01580 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCurlyLineEditor*)0x0)->GetClass();
01581 return fgIsA;
01582 }
01583
01584
01585 TClass *TF1Editor::fgIsA = 0;
01586
01587
01588 const char *TF1Editor::Class_Name()
01589 {
01590 return "TF1Editor";
01591 }
01592
01593
01594 const char *TF1Editor::ImplFileName()
01595 {
01596 return ::ROOT::GenerateInitInstanceLocal((const ::TF1Editor*)0x0)->GetImplFileName();
01597 }
01598
01599
01600 int TF1Editor::ImplFileLine()
01601 {
01602 return ::ROOT::GenerateInitInstanceLocal((const ::TF1Editor*)0x0)->GetImplFileLine();
01603 }
01604
01605
01606 void TF1Editor::Dictionary()
01607 {
01608 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TF1Editor*)0x0)->GetClass();
01609 }
01610
01611
01612 TClass *TF1Editor::Class()
01613 {
01614 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TF1Editor*)0x0)->GetClass();
01615 return fgIsA;
01616 }
01617
01618
01619 TClass *TFrameEditor::fgIsA = 0;
01620
01621
01622 const char *TFrameEditor::Class_Name()
01623 {
01624 return "TFrameEditor";
01625 }
01626
01627
01628 const char *TFrameEditor::ImplFileName()
01629 {
01630 return ::ROOT::GenerateInitInstanceLocal((const ::TFrameEditor*)0x0)->GetImplFileName();
01631 }
01632
01633
01634 int TFrameEditor::ImplFileLine()
01635 {
01636 return ::ROOT::GenerateInitInstanceLocal((const ::TFrameEditor*)0x0)->GetImplFileLine();
01637 }
01638
01639
01640 void TFrameEditor::Dictionary()
01641 {
01642 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFrameEditor*)0x0)->GetClass();
01643 }
01644
01645
01646 TClass *TFrameEditor::Class()
01647 {
01648 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFrameEditor*)0x0)->GetClass();
01649 return fgIsA;
01650 }
01651
01652
01653 TClass *TFunctionParametersDialog::fgIsA = 0;
01654
01655
01656 const char *TFunctionParametersDialog::Class_Name()
01657 {
01658 return "TFunctionParametersDialog";
01659 }
01660
01661
01662 const char *TFunctionParametersDialog::ImplFileName()
01663 {
01664 return ::ROOT::GenerateInitInstanceLocal((const ::TFunctionParametersDialog*)0x0)->GetImplFileName();
01665 }
01666
01667
01668 int TFunctionParametersDialog::ImplFileLine()
01669 {
01670 return ::ROOT::GenerateInitInstanceLocal((const ::TFunctionParametersDialog*)0x0)->GetImplFileLine();
01671 }
01672
01673
01674 void TFunctionParametersDialog::Dictionary()
01675 {
01676 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFunctionParametersDialog*)0x0)->GetClass();
01677 }
01678
01679
01680 TClass *TFunctionParametersDialog::Class()
01681 {
01682 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFunctionParametersDialog*)0x0)->GetClass();
01683 return fgIsA;
01684 }
01685
01686
01687 TClass *TGedPopup::fgIsA = 0;
01688
01689
01690 const char *TGedPopup::Class_Name()
01691 {
01692 return "TGedPopup";
01693 }
01694
01695
01696 const char *TGedPopup::ImplFileName()
01697 {
01698 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPopup*)0x0)->GetImplFileName();
01699 }
01700
01701
01702 int TGedPopup::ImplFileLine()
01703 {
01704 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPopup*)0x0)->GetImplFileLine();
01705 }
01706
01707
01708 void TGedPopup::Dictionary()
01709 {
01710 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPopup*)0x0)->GetClass();
01711 }
01712
01713
01714 TClass *TGedPopup::Class()
01715 {
01716 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPopup*)0x0)->GetClass();
01717 return fgIsA;
01718 }
01719
01720
01721 TClass *TGedPatternFrame::fgIsA = 0;
01722
01723
01724 const char *TGedPatternFrame::Class_Name()
01725 {
01726 return "TGedPatternFrame";
01727 }
01728
01729
01730 const char *TGedPatternFrame::ImplFileName()
01731 {
01732 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternFrame*)0x0)->GetImplFileName();
01733 }
01734
01735
01736 int TGedPatternFrame::ImplFileLine()
01737 {
01738 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternFrame*)0x0)->GetImplFileLine();
01739 }
01740
01741
01742 void TGedPatternFrame::Dictionary()
01743 {
01744 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternFrame*)0x0)->GetClass();
01745 }
01746
01747
01748 TClass *TGedPatternFrame::Class()
01749 {
01750 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternFrame*)0x0)->GetClass();
01751 return fgIsA;
01752 }
01753
01754
01755 TClass *TGedPatternSelector::fgIsA = 0;
01756
01757
01758 const char *TGedPatternSelector::Class_Name()
01759 {
01760 return "TGedPatternSelector";
01761 }
01762
01763
01764 const char *TGedPatternSelector::ImplFileName()
01765 {
01766 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternSelector*)0x0)->GetImplFileName();
01767 }
01768
01769
01770 int TGedPatternSelector::ImplFileLine()
01771 {
01772 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternSelector*)0x0)->GetImplFileLine();
01773 }
01774
01775
01776 void TGedPatternSelector::Dictionary()
01777 {
01778 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternSelector*)0x0)->GetClass();
01779 }
01780
01781
01782 TClass *TGedPatternSelector::Class()
01783 {
01784 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternSelector*)0x0)->GetClass();
01785 return fgIsA;
01786 }
01787
01788
01789 TClass *TGedPatternPopup::fgIsA = 0;
01790
01791
01792 const char *TGedPatternPopup::Class_Name()
01793 {
01794 return "TGedPatternPopup";
01795 }
01796
01797
01798 const char *TGedPatternPopup::ImplFileName()
01799 {
01800 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternPopup*)0x0)->GetImplFileName();
01801 }
01802
01803
01804 int TGedPatternPopup::ImplFileLine()
01805 {
01806 return ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternPopup*)0x0)->GetImplFileLine();
01807 }
01808
01809
01810 void TGedPatternPopup::Dictionary()
01811 {
01812 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternPopup*)0x0)->GetClass();
01813 }
01814
01815
01816 TClass *TGedPatternPopup::Class()
01817 {
01818 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedPatternPopup*)0x0)->GetClass();
01819 return fgIsA;
01820 }
01821
01822
01823 TClass *TGedSelect::fgIsA = 0;
01824
01825
01826 const char *TGedSelect::Class_Name()
01827 {
01828 return "TGedSelect";
01829 }
01830
01831
01832 const char *TGedSelect::ImplFileName()
01833 {
01834 return ::ROOT::GenerateInitInstanceLocal((const ::TGedSelect*)0x0)->GetImplFileName();
01835 }
01836
01837
01838 int TGedSelect::ImplFileLine()
01839 {
01840 return ::ROOT::GenerateInitInstanceLocal((const ::TGedSelect*)0x0)->GetImplFileLine();
01841 }
01842
01843
01844 void TGedSelect::Dictionary()
01845 {
01846 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedSelect*)0x0)->GetClass();
01847 }
01848
01849
01850 TClass *TGedSelect::Class()
01851 {
01852 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedSelect*)0x0)->GetClass();
01853 return fgIsA;
01854 }
01855
01856
01857 TClass *TGedMarkerPopup::fgIsA = 0;
01858
01859
01860 const char *TGedMarkerPopup::Class_Name()
01861 {
01862 return "TGedMarkerPopup";
01863 }
01864
01865
01866 const char *TGedMarkerPopup::ImplFileName()
01867 {
01868 return ::ROOT::GenerateInitInstanceLocal((const ::TGedMarkerPopup*)0x0)->GetImplFileName();
01869 }
01870
01871
01872 int TGedMarkerPopup::ImplFileLine()
01873 {
01874 return ::ROOT::GenerateInitInstanceLocal((const ::TGedMarkerPopup*)0x0)->GetImplFileLine();
01875 }
01876
01877
01878 void TGedMarkerPopup::Dictionary()
01879 {
01880 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedMarkerPopup*)0x0)->GetClass();
01881 }
01882
01883
01884 TClass *TGedMarkerPopup::Class()
01885 {
01886 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGedMarkerPopup*)0x0)->GetClass();
01887 return fgIsA;
01888 }
01889
01890
01891 TClass *TGraphEditor::fgIsA = 0;
01892
01893
01894 const char *TGraphEditor::Class_Name()
01895 {
01896 return "TGraphEditor";
01897 }
01898
01899
01900 const char *TGraphEditor::ImplFileName()
01901 {
01902 return ::ROOT::GenerateInitInstanceLocal((const ::TGraphEditor*)0x0)->GetImplFileName();
01903 }
01904
01905
01906 int TGraphEditor::ImplFileLine()
01907 {
01908 return ::ROOT::GenerateInitInstanceLocal((const ::TGraphEditor*)0x0)->GetImplFileLine();
01909 }
01910
01911
01912 void TGraphEditor::Dictionary()
01913 {
01914 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGraphEditor*)0x0)->GetClass();
01915 }
01916
01917
01918 TClass *TGraphEditor::Class()
01919 {
01920 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TGraphEditor*)0x0)->GetClass();
01921 return fgIsA;
01922 }
01923
01924
01925 TClass *TH1Editor::fgIsA = 0;
01926
01927
01928 const char *TH1Editor::Class_Name()
01929 {
01930 return "TH1Editor";
01931 }
01932
01933
01934 const char *TH1Editor::ImplFileName()
01935 {
01936 return ::ROOT::GenerateInitInstanceLocal((const ::TH1Editor*)0x0)->GetImplFileName();
01937 }
01938
01939
01940 int TH1Editor::ImplFileLine()
01941 {
01942 return ::ROOT::GenerateInitInstanceLocal((const ::TH1Editor*)0x0)->GetImplFileLine();
01943 }
01944
01945
01946 void TH1Editor::Dictionary()
01947 {
01948 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TH1Editor*)0x0)->GetClass();
01949 }
01950
01951
01952 TClass *TH1Editor::Class()
01953 {
01954 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TH1Editor*)0x0)->GetClass();
01955 return fgIsA;
01956 }
01957
01958
01959 TClass *TH2Editor::fgIsA = 0;
01960
01961
01962 const char *TH2Editor::Class_Name()
01963 {
01964 return "TH2Editor";
01965 }
01966
01967
01968 const char *TH2Editor::ImplFileName()
01969 {
01970 return ::ROOT::GenerateInitInstanceLocal((const ::TH2Editor*)0x0)->GetImplFileName();
01971 }
01972
01973
01974 int TH2Editor::ImplFileLine()
01975 {
01976 return ::ROOT::GenerateInitInstanceLocal((const ::TH2Editor*)0x0)->GetImplFileLine();
01977 }
01978
01979
01980 void TH2Editor::Dictionary()
01981 {
01982 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TH2Editor*)0x0)->GetClass();
01983 }
01984
01985
01986 TClass *TH2Editor::Class()
01987 {
01988 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TH2Editor*)0x0)->GetClass();
01989 return fgIsA;
01990 }
01991
01992
01993 TClass *TLineEditor::fgIsA = 0;
01994
01995
01996 const char *TLineEditor::Class_Name()
01997 {
01998 return "TLineEditor";
01999 }
02000
02001
02002 const char *TLineEditor::ImplFileName()
02003 {
02004 return ::ROOT::GenerateInitInstanceLocal((const ::TLineEditor*)0x0)->GetImplFileName();
02005 }
02006
02007
02008 int TLineEditor::ImplFileLine()
02009 {
02010 return ::ROOT::GenerateInitInstanceLocal((const ::TLineEditor*)0x0)->GetImplFileLine();
02011 }
02012
02013
02014 void TLineEditor::Dictionary()
02015 {
02016 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TLineEditor*)0x0)->GetClass();
02017 }
02018
02019
02020 TClass *TLineEditor::Class()
02021 {
02022 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TLineEditor*)0x0)->GetClass();
02023 return fgIsA;
02024 }
02025
02026
02027 TClass *TPadEditor::fgIsA = 0;
02028
02029
02030 const char *TPadEditor::Class_Name()
02031 {
02032 return "TPadEditor";
02033 }
02034
02035
02036 const char *TPadEditor::ImplFileName()
02037 {
02038 return ::ROOT::GenerateInitInstanceLocal((const ::TPadEditor*)0x0)->GetImplFileName();
02039 }
02040
02041
02042 int TPadEditor::ImplFileLine()
02043 {
02044 return ::ROOT::GenerateInitInstanceLocal((const ::TPadEditor*)0x0)->GetImplFileLine();
02045 }
02046
02047
02048 void TPadEditor::Dictionary()
02049 {
02050 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPadEditor*)0x0)->GetClass();
02051 }
02052
02053
02054 TClass *TPadEditor::Class()
02055 {
02056 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPadEditor*)0x0)->GetClass();
02057 return fgIsA;
02058 }
02059
02060
02061 TClass *TPaveStatsEditor::fgIsA = 0;
02062
02063
02064 const char *TPaveStatsEditor::Class_Name()
02065 {
02066 return "TPaveStatsEditor";
02067 }
02068
02069
02070 const char *TPaveStatsEditor::ImplFileName()
02071 {
02072 return ::ROOT::GenerateInitInstanceLocal((const ::TPaveStatsEditor*)0x0)->GetImplFileName();
02073 }
02074
02075
02076 int TPaveStatsEditor::ImplFileLine()
02077 {
02078 return ::ROOT::GenerateInitInstanceLocal((const ::TPaveStatsEditor*)0x0)->GetImplFileLine();
02079 }
02080
02081
02082 void TPaveStatsEditor::Dictionary()
02083 {
02084 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPaveStatsEditor*)0x0)->GetClass();
02085 }
02086
02087
02088 TClass *TPaveStatsEditor::Class()
02089 {
02090 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPaveStatsEditor*)0x0)->GetClass();
02091 return fgIsA;
02092 }
02093
02094
02095 TClass *TPieEditor::fgIsA = 0;
02096
02097
02098 const char *TPieEditor::Class_Name()
02099 {
02100 return "TPieEditor";
02101 }
02102
02103
02104 const char *TPieEditor::ImplFileName()
02105 {
02106 return ::ROOT::GenerateInitInstanceLocal((const ::TPieEditor*)0x0)->GetImplFileName();
02107 }
02108
02109
02110 int TPieEditor::ImplFileLine()
02111 {
02112 return ::ROOT::GenerateInitInstanceLocal((const ::TPieEditor*)0x0)->GetImplFileLine();
02113 }
02114
02115
02116 void TPieEditor::Dictionary()
02117 {
02118 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPieEditor*)0x0)->GetClass();
02119 }
02120
02121
02122 TClass *TPieEditor::Class()
02123 {
02124 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPieEditor*)0x0)->GetClass();
02125 return fgIsA;
02126 }
02127
02128
02129 TClass *TPieSliceEditor::fgIsA = 0;
02130
02131
02132 const char *TPieSliceEditor::Class_Name()
02133 {
02134 return "TPieSliceEditor";
02135 }
02136
02137
02138 const char *TPieSliceEditor::ImplFileName()
02139 {
02140 return ::ROOT::GenerateInitInstanceLocal((const ::TPieSliceEditor*)0x0)->GetImplFileName();
02141 }
02142
02143
02144 int TPieSliceEditor::ImplFileLine()
02145 {
02146 return ::ROOT::GenerateInitInstanceLocal((const ::TPieSliceEditor*)0x0)->GetImplFileLine();
02147 }
02148
02149
02150 void TPieSliceEditor::Dictionary()
02151 {
02152 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPieSliceEditor*)0x0)->GetClass();
02153 }
02154
02155
02156 TClass *TPieSliceEditor::Class()
02157 {
02158 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPieSliceEditor*)0x0)->GetClass();
02159 return fgIsA;
02160 }
02161
02162
02163 TClass *TStyleManager::fgIsA = 0;
02164
02165
02166 const char *TStyleManager::Class_Name()
02167 {
02168 return "TStyleManager";
02169 }
02170
02171
02172 const char *TStyleManager::ImplFileName()
02173 {
02174 return ::ROOT::GenerateInitInstanceLocal((const ::TStyleManager*)0x0)->GetImplFileName();
02175 }
02176
02177
02178 int TStyleManager::ImplFileLine()
02179 {
02180 return ::ROOT::GenerateInitInstanceLocal((const ::TStyleManager*)0x0)->GetImplFileLine();
02181 }
02182
02183
02184 void TStyleManager::Dictionary()
02185 {
02186 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStyleManager*)0x0)->GetClass();
02187 }
02188
02189
02190 TClass *TStyleManager::Class()
02191 {
02192 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStyleManager*)0x0)->GetClass();
02193 return fgIsA;
02194 }
02195
02196
02197 TClass *TStyleDialog::fgIsA = 0;
02198
02199
02200 const char *TStyleDialog::Class_Name()
02201 {
02202 return "TStyleDialog";
02203 }
02204
02205
02206 const char *TStyleDialog::ImplFileName()
02207 {
02208 return ::ROOT::GenerateInitInstanceLocal((const ::TStyleDialog*)0x0)->GetImplFileName();
02209 }
02210
02211
02212 int TStyleDialog::ImplFileLine()
02213 {
02214 return ::ROOT::GenerateInitInstanceLocal((const ::TStyleDialog*)0x0)->GetImplFileLine();
02215 }
02216
02217
02218 void TStyleDialog::Dictionary()
02219 {
02220 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStyleDialog*)0x0)->GetClass();
02221 }
02222
02223
02224 TClass *TStyleDialog::Class()
02225 {
02226 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStyleDialog*)0x0)->GetClass();
02227 return fgIsA;
02228 }
02229
02230
02231 TClass *TStylePreview::fgIsA = 0;
02232
02233
02234 const char *TStylePreview::Class_Name()
02235 {
02236 return "TStylePreview";
02237 }
02238
02239
02240 const char *TStylePreview::ImplFileName()
02241 {
02242 return ::ROOT::GenerateInitInstanceLocal((const ::TStylePreview*)0x0)->GetImplFileName();
02243 }
02244
02245
02246 int TStylePreview::ImplFileLine()
02247 {
02248 return ::ROOT::GenerateInitInstanceLocal((const ::TStylePreview*)0x0)->GetImplFileLine();
02249 }
02250
02251
02252 void TStylePreview::Dictionary()
02253 {
02254 fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStylePreview*)0x0)->GetClass();
02255 }
02256
02257
02258 TClass *TStylePreview::Class()
02259 {
02260 if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStylePreview*)0x0)->GetClass();
02261 return fgIsA;
02262 }
02263
02264
02265 void TGedFrame::Streamer(TBuffer &R__b)
02266 {
02267
02268
02269 TGCompositeFrame::Streamer(R__b);
02270 }
02271
02272
02273 void TGedFrame::ShowMembers(TMemberInspector &R__insp)
02274 {
02275
02276 TClass *R__cl = ::TGedFrame::IsA();
02277 if (R__cl || R__insp.IsA()) { }
02278 R__insp.Inspect(R__cl, R__insp.GetParent(), "fInit", &fInit);
02279 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGedEditor", &fGedEditor);
02280 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModelClass", &fModelClass);
02281 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAvoidSignal", &fAvoidSignal);
02282 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtraTabs", &fExtraTabs);
02283 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPriority", &fPriority);
02284 TGCompositeFrame::ShowMembers(R__insp);
02285 }
02286
02287 namespace ROOT {
02288
02289 static void delete_TGedFrame(void *p) {
02290 delete ((::TGedFrame*)p);
02291 }
02292 static void deleteArray_TGedFrame(void *p) {
02293 delete [] ((::TGedFrame*)p);
02294 }
02295 static void destruct_TGedFrame(void *p) {
02296 typedef ::TGedFrame current_t;
02297 ((current_t*)p)->~current_t();
02298 }
02299
02300 static void streamer_TGedFrame(TBuffer &buf, void *obj) {
02301 ((::TGedFrame*)obj)->::TGedFrame::Streamer(buf);
02302 }
02303 }
02304
02305
02306 void TGedNameFrame::Streamer(TBuffer &R__b)
02307 {
02308
02309
02310 TGedFrame::Streamer(R__b);
02311 }
02312
02313
02314 void TGedNameFrame::ShowMembers(TMemberInspector &R__insp)
02315 {
02316
02317 TClass *R__cl = ::TGedNameFrame::IsA();
02318 if (R__cl || R__insp.IsA()) { }
02319 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabel", &fLabel);
02320 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f1", &f1);
02321 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f2", &f2);
02322 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
02323 TGedFrame::ShowMembers(R__insp);
02324 }
02325
02326 namespace ROOT {
02327
02328 static void *new_TGedNameFrame(void *p) {
02329 return p ? new(p) ::TGedNameFrame : new ::TGedNameFrame;
02330 }
02331 static void *newArray_TGedNameFrame(Long_t nElements, void *p) {
02332 return p ? new(p) ::TGedNameFrame[nElements] : new ::TGedNameFrame[nElements];
02333 }
02334
02335 static void delete_TGedNameFrame(void *p) {
02336 delete ((::TGedNameFrame*)p);
02337 }
02338 static void deleteArray_TGedNameFrame(void *p) {
02339 delete [] ((::TGedNameFrame*)p);
02340 }
02341 static void destruct_TGedNameFrame(void *p) {
02342 typedef ::TGedNameFrame current_t;
02343 ((current_t*)p)->~current_t();
02344 }
02345
02346 static void streamer_TGedNameFrame(TBuffer &buf, void *obj) {
02347 ((::TGedNameFrame*)obj)->::TGedNameFrame::Streamer(buf);
02348 }
02349 }
02350
02351
02352 void TArrowEditor::Streamer(TBuffer &R__b)
02353 {
02354
02355
02356 TGedFrame::Streamer(R__b);
02357 }
02358
02359
02360 void TArrowEditor::ShowMembers(TMemberInspector &R__insp)
02361 {
02362
02363 TClass *R__cl = ::TArrowEditor::IsA();
02364 if (R__cl || R__insp.IsA()) { }
02365 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fArrow", &fArrow);
02366 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptionCombo", &fOptionCombo);
02367 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAngleEntry", &fAngleEntry);
02368 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSizeEntry", &fSizeEntry);
02369 TGedFrame::ShowMembers(R__insp);
02370 }
02371
02372 namespace ROOT {
02373
02374 static void *new_TArrowEditor(void *p) {
02375 return p ? new(p) ::TArrowEditor : new ::TArrowEditor;
02376 }
02377 static void *newArray_TArrowEditor(Long_t nElements, void *p) {
02378 return p ? new(p) ::TArrowEditor[nElements] : new ::TArrowEditor[nElements];
02379 }
02380
02381 static void delete_TArrowEditor(void *p) {
02382 delete ((::TArrowEditor*)p);
02383 }
02384 static void deleteArray_TArrowEditor(void *p) {
02385 delete [] ((::TArrowEditor*)p);
02386 }
02387 static void destruct_TArrowEditor(void *p) {
02388 typedef ::TArrowEditor current_t;
02389 ((current_t*)p)->~current_t();
02390 }
02391
02392 static void streamer_TArrowEditor(TBuffer &buf, void *obj) {
02393 ((::TArrowEditor*)obj)->::TArrowEditor::Streamer(buf);
02394 }
02395 }
02396
02397
02398 void TLineEditor::Streamer(TBuffer &R__b)
02399 {
02400
02401
02402 TGedFrame::Streamer(R__b);
02403 }
02404
02405
02406 void TLineEditor::ShowMembers(TMemberInspector &R__insp)
02407 {
02408
02409 TClass *R__cl = ::TLineEditor::IsA();
02410 if (R__cl || R__insp.IsA()) { }
02411 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLine", &fLine);
02412 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartPointX", &fStartPointX);
02413 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartPointY", &fStartPointY);
02414 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndPointX", &fEndPointX);
02415 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndPointY", &fEndPointY);
02416 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVertical", &fVertical);
02417 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHorizontal", &fHorizontal);
02418 TGedFrame::ShowMembers(R__insp);
02419 }
02420
02421 namespace ROOT {
02422
02423 static void *new_TLineEditor(void *p) {
02424 return p ? new(p) ::TLineEditor : new ::TLineEditor;
02425 }
02426 static void *newArray_TLineEditor(Long_t nElements, void *p) {
02427 return p ? new(p) ::TLineEditor[nElements] : new ::TLineEditor[nElements];
02428 }
02429
02430 static void delete_TLineEditor(void *p) {
02431 delete ((::TLineEditor*)p);
02432 }
02433 static void deleteArray_TLineEditor(void *p) {
02434 delete [] ((::TLineEditor*)p);
02435 }
02436 static void destruct_TLineEditor(void *p) {
02437 typedef ::TLineEditor current_t;
02438 ((current_t*)p)->~current_t();
02439 }
02440
02441 static void streamer_TLineEditor(TBuffer &buf, void *obj) {
02442 ((::TLineEditor*)obj)->::TLineEditor::Streamer(buf);
02443 }
02444 }
02445
02446
02447 void TAttFillEditor::Streamer(TBuffer &R__b)
02448 {
02449
02450
02451 TGedFrame::Streamer(R__b);
02452 }
02453
02454
02455 void TAttFillEditor::ShowMembers(TMemberInspector &R__insp)
02456 {
02457
02458 TClass *R__cl = ::TAttFillEditor::IsA();
02459 if (R__cl || R__insp.IsA()) { }
02460 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttFill", &fAttFill);
02461 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
02462 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPatternSelect", &fPatternSelect);
02463 TGedFrame::ShowMembers(R__insp);
02464 }
02465
02466 namespace ROOT {
02467
02468 static void *new_TAttFillEditor(void *p) {
02469 return p ? new(p) ::TAttFillEditor : new ::TAttFillEditor;
02470 }
02471 static void *newArray_TAttFillEditor(Long_t nElements, void *p) {
02472 return p ? new(p) ::TAttFillEditor[nElements] : new ::TAttFillEditor[nElements];
02473 }
02474
02475 static void delete_TAttFillEditor(void *p) {
02476 delete ((::TAttFillEditor*)p);
02477 }
02478 static void deleteArray_TAttFillEditor(void *p) {
02479 delete [] ((::TAttFillEditor*)p);
02480 }
02481 static void destruct_TAttFillEditor(void *p) {
02482 typedef ::TAttFillEditor current_t;
02483 ((current_t*)p)->~current_t();
02484 }
02485
02486 static void streamer_TAttFillEditor(TBuffer &buf, void *obj) {
02487 ((::TAttFillEditor*)obj)->::TAttFillEditor::Streamer(buf);
02488 }
02489 }
02490
02491
02492 void TAttLineEditor::Streamer(TBuffer &R__b)
02493 {
02494
02495
02496 TGedFrame::Streamer(R__b);
02497 }
02498
02499
02500 void TAttLineEditor::ShowMembers(TMemberInspector &R__insp)
02501 {
02502
02503 TClass *R__cl = ::TAttLineEditor::IsA();
02504 if (R__cl || R__insp.IsA()) { }
02505 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttLine", &fAttLine);
02506 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStyleCombo", &fStyleCombo);
02507 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWidthCombo", &fWidthCombo);
02508 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
02509 TGedFrame::ShowMembers(R__insp);
02510 }
02511
02512 namespace ROOT {
02513
02514 static void *new_TAttLineEditor(void *p) {
02515 return p ? new(p) ::TAttLineEditor : new ::TAttLineEditor;
02516 }
02517 static void *newArray_TAttLineEditor(Long_t nElements, void *p) {
02518 return p ? new(p) ::TAttLineEditor[nElements] : new ::TAttLineEditor[nElements];
02519 }
02520
02521 static void delete_TAttLineEditor(void *p) {
02522 delete ((::TAttLineEditor*)p);
02523 }
02524 static void deleteArray_TAttLineEditor(void *p) {
02525 delete [] ((::TAttLineEditor*)p);
02526 }
02527 static void destruct_TAttLineEditor(void *p) {
02528 typedef ::TAttLineEditor current_t;
02529 ((current_t*)p)->~current_t();
02530 }
02531
02532 static void streamer_TAttLineEditor(TBuffer &buf, void *obj) {
02533 ((::TAttLineEditor*)obj)->::TAttLineEditor::Streamer(buf);
02534 }
02535 }
02536
02537
02538 void TAttMarkerEditor::Streamer(TBuffer &R__b)
02539 {
02540
02541
02542 TGedFrame::Streamer(R__b);
02543 }
02544
02545
02546 void TAttMarkerEditor::ShowMembers(TMemberInspector &R__insp)
02547 {
02548
02549 TClass *R__cl = ::TAttMarkerEditor::IsA();
02550 if (R__cl || R__insp.IsA()) { }
02551 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttMarker", &fAttMarker);
02552 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerSize", &fMarkerSize);
02553 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
02554 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerType", &fMarkerType);
02555 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSizeForText", &fSizeForText);
02556 TGedFrame::ShowMembers(R__insp);
02557 }
02558
02559 namespace ROOT {
02560
02561 static void *new_TAttMarkerEditor(void *p) {
02562 return p ? new(p) ::TAttMarkerEditor : new ::TAttMarkerEditor;
02563 }
02564 static void *newArray_TAttMarkerEditor(Long_t nElements, void *p) {
02565 return p ? new(p) ::TAttMarkerEditor[nElements] : new ::TAttMarkerEditor[nElements];
02566 }
02567
02568 static void delete_TAttMarkerEditor(void *p) {
02569 delete ((::TAttMarkerEditor*)p);
02570 }
02571 static void deleteArray_TAttMarkerEditor(void *p) {
02572 delete [] ((::TAttMarkerEditor*)p);
02573 }
02574 static void destruct_TAttMarkerEditor(void *p) {
02575 typedef ::TAttMarkerEditor current_t;
02576 ((current_t*)p)->~current_t();
02577 }
02578
02579 static void streamer_TAttMarkerEditor(TBuffer &buf, void *obj) {
02580 ((::TAttMarkerEditor*)obj)->::TAttMarkerEditor::Streamer(buf);
02581 }
02582 }
02583
02584
02585 void TAttTextEditor::Streamer(TBuffer &R__b)
02586 {
02587
02588
02589 TGedFrame::Streamer(R__b);
02590 }
02591
02592
02593 void TAttTextEditor::ShowMembers(TMemberInspector &R__insp)
02594 {
02595
02596 TClass *R__cl = ::TAttTextEditor::IsA();
02597 if (R__cl || R__insp.IsA()) { }
02598 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttText", &fAttText);
02599 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeCombo", &fTypeCombo);
02600 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSizeCombo", &fSizeCombo);
02601 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlignCombo", &fAlignCombo);
02602 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
02603 TGedFrame::ShowMembers(R__insp);
02604 }
02605
02606 namespace ROOT {
02607
02608 static void *new_TAttTextEditor(void *p) {
02609 return p ? new(p) ::TAttTextEditor : new ::TAttTextEditor;
02610 }
02611 static void *newArray_TAttTextEditor(Long_t nElements, void *p) {
02612 return p ? new(p) ::TAttTextEditor[nElements] : new ::TAttTextEditor[nElements];
02613 }
02614
02615 static void delete_TAttTextEditor(void *p) {
02616 delete ((::TAttTextEditor*)p);
02617 }
02618 static void deleteArray_TAttTextEditor(void *p) {
02619 delete [] ((::TAttTextEditor*)p);
02620 }
02621 static void destruct_TAttTextEditor(void *p) {
02622 typedef ::TAttTextEditor current_t;
02623 ((current_t*)p)->~current_t();
02624 }
02625
02626 static void streamer_TAttTextEditor(TBuffer &buf, void *obj) {
02627 ((::TAttTextEditor*)obj)->::TAttTextEditor::Streamer(buf);
02628 }
02629 }
02630
02631
02632 void TAxisEditor::Streamer(TBuffer &R__b)
02633 {
02634
02635
02636 TGedFrame::Streamer(R__b);
02637 }
02638
02639
02640 void TAxisEditor::ShowMembers(TMemberInspector &R__insp)
02641 {
02642
02643 TClass *R__cl = ::TAxisEditor::IsA();
02644 if (R__cl || R__insp.IsA()) { }
02645 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxis", &fAxis);
02646 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxisColor", &fAxisColor);
02647 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogAxis", &fLogAxis);
02648 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTickLength", &fTickLength);
02649 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDiv1", &fDiv1);
02650 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDiv2", &fDiv2);
02651 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDiv3", &fDiv3);
02652 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptimize", &fOptimize);
02653 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTicksBoth", &fTicksBoth);
02654 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMoreLog", &fMoreLog);
02655 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTicksFlag", &fTicksFlag);
02656 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
02657 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleColor", &fTitleColor);
02658 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleFont", &fTitleFont);
02659 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
02660 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleSize", &fTitleSize);
02661 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleOffset", &fTitleOffset);
02662 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCentered", &fCentered);
02663 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRotated", &fRotated);
02664 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelColor", &fLabelColor);
02665 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelFont", &fLabelFont);
02666 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLabelPrec", &fLabelPrec);
02667 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelSize", &fLabelSize);
02668 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLabelOffset", &fLabelOffset);
02669 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNoExponent", &fNoExponent);
02670 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDecimal", &fDecimal);
02671 TGedFrame::ShowMembers(R__insp);
02672 }
02673
02674 namespace ROOT {
02675
02676 static void *new_TAxisEditor(void *p) {
02677 return p ? new(p) ::TAxisEditor : new ::TAxisEditor;
02678 }
02679 static void *newArray_TAxisEditor(Long_t nElements, void *p) {
02680 return p ? new(p) ::TAxisEditor[nElements] : new ::TAxisEditor[nElements];
02681 }
02682
02683 static void delete_TAxisEditor(void *p) {
02684 delete ((::TAxisEditor*)p);
02685 }
02686 static void deleteArray_TAxisEditor(void *p) {
02687 delete [] ((::TAxisEditor*)p);
02688 }
02689 static void destruct_TAxisEditor(void *p) {
02690 typedef ::TAxisEditor current_t;
02691 ((current_t*)p)->~current_t();
02692 }
02693
02694 static void streamer_TAxisEditor(TBuffer &buf, void *obj) {
02695 ((::TAxisEditor*)obj)->::TAxisEditor::Streamer(buf);
02696 }
02697 }
02698
02699
02700 void TFrameEditor::Streamer(TBuffer &R__b)
02701 {
02702
02703
02704 TGedFrame::Streamer(R__b);
02705 }
02706
02707
02708 void TFrameEditor::ShowMembers(TMemberInspector &R__insp)
02709 {
02710
02711 TClass *R__cl = ::TFrameEditor::IsA();
02712 if (R__cl || R__insp.IsA()) { }
02713 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrame", &fFrame);
02714 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode", &fBmode);
02715 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode0", &fBmode0);
02716 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode1", &fBmode1);
02717 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmodelh", &fBmodelh);
02718 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBsize", &fBsize);
02719 TGedFrame::ShowMembers(R__insp);
02720 }
02721
02722 namespace ROOT {
02723
02724 static void *new_TFrameEditor(void *p) {
02725 return p ? new(p) ::TFrameEditor : new ::TFrameEditor;
02726 }
02727 static void *newArray_TFrameEditor(Long_t nElements, void *p) {
02728 return p ? new(p) ::TFrameEditor[nElements] : new ::TFrameEditor[nElements];
02729 }
02730
02731 static void delete_TFrameEditor(void *p) {
02732 delete ((::TFrameEditor*)p);
02733 }
02734 static void deleteArray_TFrameEditor(void *p) {
02735 delete [] ((::TFrameEditor*)p);
02736 }
02737 static void destruct_TFrameEditor(void *p) {
02738 typedef ::TFrameEditor current_t;
02739 ((current_t*)p)->~current_t();
02740 }
02741
02742 static void streamer_TFrameEditor(TBuffer &buf, void *obj) {
02743 ((::TFrameEditor*)obj)->::TFrameEditor::Streamer(buf);
02744 }
02745 }
02746
02747
02748 void TGraphEditor::Streamer(TBuffer &R__b)
02749 {
02750
02751
02752 TGedFrame::Streamer(R__b);
02753 }
02754
02755
02756 void TGraphEditor::ShowMembers(TMemberInspector &R__insp)
02757 {
02758
02759 TClass *R__cl = ::TGraphEditor::IsA();
02760 if (R__cl || R__insp.IsA()) { }
02761 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawShape", &fDrawShape);
02762 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
02763 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
02764 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGraph", &fGraph);
02765 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fgr", &fgr);
02766 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape", &fShape);
02767 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape0", &fShape0);
02768 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape1", &fShape1);
02769 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape2", &fShape2);
02770 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape3", &fShape3);
02771 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape1lh", &fShape1lh);
02772 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerOnOff", &fMarkerOnOff);
02773 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWidthCombo", &fWidthCombo);
02774 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExSide", &fExSide);
02775 TGedFrame::ShowMembers(R__insp);
02776 }
02777
02778 namespace ROOT {
02779
02780 static void *new_TGraphEditor(void *p) {
02781 return p ? new(p) ::TGraphEditor : new ::TGraphEditor;
02782 }
02783 static void *newArray_TGraphEditor(Long_t nElements, void *p) {
02784 return p ? new(p) ::TGraphEditor[nElements] : new ::TGraphEditor[nElements];
02785 }
02786
02787 static void delete_TGraphEditor(void *p) {
02788 delete ((::TGraphEditor*)p);
02789 }
02790 static void deleteArray_TGraphEditor(void *p) {
02791 delete [] ((::TGraphEditor*)p);
02792 }
02793 static void destruct_TGraphEditor(void *p) {
02794 typedef ::TGraphEditor current_t;
02795 ((current_t*)p)->~current_t();
02796 }
02797
02798 static void streamer_TGraphEditor(TBuffer &buf, void *obj) {
02799 ((::TGraphEditor*)obj)->::TGraphEditor::Streamer(buf);
02800 }
02801 }
02802
02803
02804 void TPieEditor::Streamer(TBuffer &R__b)
02805 {
02806
02807
02808 TGedFrame::Streamer(R__b);
02809 }
02810
02811
02812 void TPieEditor::ShowMembers(TMemberInspector &R__insp)
02813 {
02814
02815 TClass *R__cl = ::TPieEditor::IsA();
02816 if (R__cl || R__insp.IsA()) { }
02817 R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawShape", &fDrawShape);
02818 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
02819 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
02820 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPie", &fPie);
02821 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fgr", &fgr);
02822 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLblDirH", &fLblDirH);
02823 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLblDirR", &fLblDirR);
02824 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLblDirT", &fLblDirT);
02825 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShape1lh", &fShape1lh);
02826 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutlineOnOff", &fOutlineOnOff);
02827 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIs3D", &fIs3D);
02828 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3DHeight", &f3DHeight);
02829 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3DAngle", &f3DAngle);
02830 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSelect", &fColorSelect);
02831 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeCombo", &fTypeCombo);
02832 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSizeCombo", &fSizeCombo);
02833 TGedFrame::ShowMembers(R__insp);
02834 }
02835
02836 namespace ROOT {
02837
02838 static void *new_TPieEditor(void *p) {
02839 return p ? new(p) ::TPieEditor : new ::TPieEditor;
02840 }
02841 static void *newArray_TPieEditor(Long_t nElements, void *p) {
02842 return p ? new(p) ::TPieEditor[nElements] : new ::TPieEditor[nElements];
02843 }
02844
02845 static void delete_TPieEditor(void *p) {
02846 delete ((::TPieEditor*)p);
02847 }
02848 static void deleteArray_TPieEditor(void *p) {
02849 delete [] ((::TPieEditor*)p);
02850 }
02851 static void destruct_TPieEditor(void *p) {
02852 typedef ::TPieEditor current_t;
02853 ((current_t*)p)->~current_t();
02854 }
02855
02856 static void streamer_TPieEditor(TBuffer &buf, void *obj) {
02857 ((::TPieEditor*)obj)->::TPieEditor::Streamer(buf);
02858 }
02859 }
02860
02861
02862 void TPieSliceEditor::Streamer(TBuffer &R__b)
02863 {
02864
02865
02866 TGedFrame::Streamer(R__b);
02867 }
02868
02869
02870 void TPieSliceEditor::ShowMembers(TMemberInspector &R__insp)
02871 {
02872
02873 TClass *R__cl = ::TPieSliceEditor::IsA();
02874 if (R__cl || R__insp.IsA()) { }
02875 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPieSlice", &fPieSlice);
02876 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
02877 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValue", &fValue);
02878 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOffset", &fOffset);
02879 TGedFrame::ShowMembers(R__insp);
02880 }
02881
02882 namespace ROOT {
02883
02884 static void *new_TPieSliceEditor(void *p) {
02885 return p ? new(p) ::TPieSliceEditor : new ::TPieSliceEditor;
02886 }
02887 static void *newArray_TPieSliceEditor(Long_t nElements, void *p) {
02888 return p ? new(p) ::TPieSliceEditor[nElements] : new ::TPieSliceEditor[nElements];
02889 }
02890
02891 static void delete_TPieSliceEditor(void *p) {
02892 delete ((::TPieSliceEditor*)p);
02893 }
02894 static void deleteArray_TPieSliceEditor(void *p) {
02895 delete [] ((::TPieSliceEditor*)p);
02896 }
02897 static void destruct_TPieSliceEditor(void *p) {
02898 typedef ::TPieSliceEditor current_t;
02899 ((current_t*)p)->~current_t();
02900 }
02901
02902 static void streamer_TPieSliceEditor(TBuffer &buf, void *obj) {
02903 ((::TPieSliceEditor*)obj)->::TPieSliceEditor::Streamer(buf);
02904 }
02905 }
02906
02907
02908 void TH1Editor::Streamer(TBuffer &R__b)
02909 {
02910
02911
02912 TGedFrame::Streamer(R__b);
02913 }
02914
02915
02916 void TH1Editor::ShowMembers(TMemberInspector &R__insp)
02917 {
02918
02919 TClass *R__cl = ::TH1Editor::IsA();
02920 if (R__cl || R__insp.IsA()) { }
02921 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
02922 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSameOpt", &fSameOpt);
02923 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBin", &fBin);
02924 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
02925 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
02926 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDimGroup", &fDimGroup);
02927 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim", &fDim);
02928 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim0", &fDim0);
02929 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDimlh", &fDimlh);
02930 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim0lh", &fDim0lh);
02931 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeCombo", &fTypeCombo);
02932 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoordsCombo", &fCoordsCombo);
02933 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fErrorCombo", &fErrorCombo);
02934 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistOnOff", &fHistOnOff);
02935 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddMarker", &fAddMarker);
02936 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddB", &fAddB);
02937 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddBar", &fAddBar);
02938 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAdd", &fAdd);
02939 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMakeHBar", &fMakeHBar);
02940 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddSimple", &fAddSimple);
02941 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarWidth", &fBarWidth);
02942 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarOffset", &fBarOffset);
02943 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddCombo", &fAddCombo);
02944 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPercentCombo", &fPercentCombo);
02945 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f3", &f3);
02946 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f6", &f6);
02947 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f7", &f7);
02948 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f8", &f8);
02949 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f9", &f9);
02950 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f10", &f10);
02951 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f11", &f11);
02952 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f12", &f12);
02953 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f15", &f15);
02954 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinCont", &fBinCont);
02955 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinCont1", &fBinCont1);
02956 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinSlider", &fBinSlider);
02957 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinSlider1", &fBinSlider1);
02958 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinNumberEntry", &fBinNumberEntry);
02959 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinNumberEntry1", &fBinNumberEntry1);
02960 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinOffsetSld", &fBinOffsetSld);
02961 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOffsetNumberEntry", &fOffsetNumberEntry);
02962 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlider", &fSlider);
02963 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldMin", &fSldMin);
02964 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldMax", &fSldMax);
02965 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelaydraw", &fDelaydraw);
02966 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
02967 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
02968 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMake", &fMake);
02969 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMakeB", &fMakeB);
02970 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx1old", &fPx1old);
02971 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy1old", &fPy1old);
02972 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx2old", &fPx2old);
02973 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy2old", &fPy2old);
02974 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP1NDCold[3]", fP1NDCold);
02975 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP2NDCold[3]", fP2NDCold);
02976 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP3NDCold[3]", fP3NDCold);
02977 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP4NDCold[3]", fP4NDCold);
02978 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP1old[3]", fP1old);
02979 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP2old[3]", fP2old);
02980 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP3old[3]", fP3old);
02981 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP4old[3]", fP4old);
02982 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP5old[3]", fP5old);
02983 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP6old[3]", fP6old);
02984 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP7old[3]", fP7old);
02985 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP8old[3]", fP8old);
02986 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinHist", &fBinHist);
02987 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldOffset", &fOldOffset);
02988 TGedFrame::ShowMembers(R__insp);
02989 }
02990
02991 namespace ROOT {
02992
02993 static void *new_TH1Editor(void *p) {
02994 return p ? new(p) ::TH1Editor : new ::TH1Editor;
02995 }
02996 static void *newArray_TH1Editor(Long_t nElements, void *p) {
02997 return p ? new(p) ::TH1Editor[nElements] : new ::TH1Editor[nElements];
02998 }
02999
03000 static void delete_TH1Editor(void *p) {
03001 delete ((::TH1Editor*)p);
03002 }
03003 static void deleteArray_TH1Editor(void *p) {
03004 delete [] ((::TH1Editor*)p);
03005 }
03006 static void destruct_TH1Editor(void *p) {
03007 typedef ::TH1Editor current_t;
03008 ((current_t*)p)->~current_t();
03009 }
03010
03011 static void streamer_TH1Editor(TBuffer &buf, void *obj) {
03012 ((::TH1Editor*)obj)->::TH1Editor::Streamer(buf);
03013 }
03014 }
03015
03016
03017 void TH2Editor::Streamer(TBuffer &R__b)
03018 {
03019
03020
03021 TGedFrame::Streamer(R__b);
03022 }
03023
03024
03025 void TH2Editor::ShowMembers(TMemberInspector &R__insp)
03026 {
03027
03028 TClass *R__cl = ::TH2Editor::IsA();
03029 if (R__cl || R__insp.IsA()) { }
03030 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
03031 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBin", &fBin);
03032 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFit", &fFit);
03033 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
03034 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTypeCombo", &fTypeCombo);
03035 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoordsCombo", &fCoordsCombo);
03036 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContCombo", &fContCombo);
03037 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColContLbl", &fColContLbl);
03038 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColContLbl1", &fColContLbl1);
03039 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTitlePrec", &fTitlePrec);
03040 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDimGroup", &fDimGroup);
03041 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim", &fDim);
03042 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim0", &fDim0);
03043 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDimlh", &fDimlh);
03044 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDim0lh", &fDim0lh);
03045 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f6", &f6);
03046 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f9", &f9);
03047 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f12", &f12);
03048 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f13", &f13);
03049 R__insp.Inspect(R__cl, R__insp.GetParent(), "*f38", &f38);
03050 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddError", &fAddError);
03051 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddPalette", &fAddPalette);
03052 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddPalette1", &fAddPalette1);
03053 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddArr", &fAddArr);
03054 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddBox", &fAddBox);
03055 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddScat", &fAddScat);
03056 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddCol", &fAddCol);
03057 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddFB", &fAddFB);
03058 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddBB", &fAddBB);
03059 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAddText", &fAddText);
03060 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContLevels", &fContLevels);
03061 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContLevels1", &fContLevels1);
03062 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarWidth", &fBarWidth);
03063 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarOffset", &fBarOffset);
03064 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXCont", &fBinXCont);
03065 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXSlider", &fBinXSlider);
03066 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXNumberEntry", &fBinXNumberEntry);
03067 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYSlider", &fBinYSlider);
03068 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYNumberEntry", &fBinYNumberEntry);
03069 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03070 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
03071 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXCont1", &fBinXCont1);
03072 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXSlider1", &fBinXSlider1);
03073 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinXNumberEntry1", &fBinXNumberEntry1);
03074 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXOffsetNumberEntry", &fXOffsetNumberEntry);
03075 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXBinOffsetSld", &fXBinOffsetSld);
03076 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYCont1", &fBinYCont1);
03077 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYSlider1", &fBinYSlider1);
03078 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinYNumberEntry1", &fBinYNumberEntry1);
03079 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYOffsetNumberEntry", &fYOffsetNumberEntry);
03080 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYBinOffsetSld", &fYBinOffsetSld);
03081 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliderX", &fSliderX);
03082 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldXMin", &fSldXMin);
03083 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldXMax", &fSldXMax);
03084 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliderY", &fSliderY);
03085 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldYMin", &fSldYMin);
03086 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldYMax", &fSldYMax);
03087 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelaydraw", &fDelaydraw);
03088 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameColor", &fFrameColor);
03089 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFramePattern", &fFramePattern);
03090 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutString", &fCutString);
03091 R__insp.InspectMember(fCutString, "fCutString.");
03092 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx1old", &fPx1old);
03093 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy1old", &fPy1old);
03094 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPx2old", &fPx2old);
03095 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPy2old", &fPy2old);
03096 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP1oldx[3]", fP1oldx);
03097 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP2oldx[3]", fP2oldx);
03098 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP3oldx[3]", fP3oldx);
03099 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP4oldx[3]", fP4oldx);
03100 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP5oldx[3]", fP5oldx);
03101 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP6oldx[3]", fP6oldx);
03102 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP7oldx[3]", fP7oldx);
03103 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP8oldx[3]", fP8oldx);
03104 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP1oldy[3]", fP1oldy);
03105 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP2oldy[3]", fP2oldy);
03106 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP3oldy[3]", fP3oldy);
03107 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP4oldy[3]", fP4oldy);
03108 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP5oldy[3]", fP5oldy);
03109 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP6oldy[3]", fP6oldy);
03110 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP7oldy[3]", fP7oldy);
03111 R__insp.Inspect(R__cl, R__insp.GetParent(), "fP8oldy[3]", fP8oldy);
03112 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinHist", &fBinHist);
03113 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldXOffset", &fOldXOffset);
03114 R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldYOffset", &fOldYOffset);
03115 TGedFrame::ShowMembers(R__insp);
03116 }
03117
03118 namespace ROOT {
03119
03120 static void *new_TH2Editor(void *p) {
03121 return p ? new(p) ::TH2Editor : new ::TH2Editor;
03122 }
03123 static void *newArray_TH2Editor(Long_t nElements, void *p) {
03124 return p ? new(p) ::TH2Editor[nElements] : new ::TH2Editor[nElements];
03125 }
03126
03127 static void delete_TH2Editor(void *p) {
03128 delete ((::TH2Editor*)p);
03129 }
03130 static void deleteArray_TH2Editor(void *p) {
03131 delete [] ((::TH2Editor*)p);
03132 }
03133 static void destruct_TH2Editor(void *p) {
03134 typedef ::TH2Editor current_t;
03135 ((current_t*)p)->~current_t();
03136 }
03137
03138 static void streamer_TH2Editor(TBuffer &buf, void *obj) {
03139 ((::TH2Editor*)obj)->::TH2Editor::Streamer(buf);
03140 }
03141 }
03142
03143
03144 void TF1Editor::Streamer(TBuffer &R__b)
03145 {
03146
03147
03148 TGedFrame::Streamer(R__b);
03149 }
03150
03151
03152 void TF1Editor::ShowMembers(TMemberInspector &R__insp)
03153 {
03154
03155 TClass *R__cl = ::TF1Editor::IsA();
03156 if (R__cl || R__insp.IsA()) { }
03157 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fF1", &fF1);
03158 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
03159 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNP", &fNP);
03160 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParLabel", &fParLabel);
03161 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawMode", &fDrawMode);
03162 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSetPars", &fSetPars);
03163 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNXpoints", &fNXpoints);
03164 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSliderX", &fSliderX);
03165 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldMinX", &fSldMinX);
03166 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSldMaxX", &fSldMaxX);
03167 TGedFrame::ShowMembers(R__insp);
03168 }
03169
03170 namespace ROOT {
03171
03172 static void *new_TF1Editor(void *p) {
03173 return p ? new(p) ::TF1Editor : new ::TF1Editor;
03174 }
03175 static void *newArray_TF1Editor(Long_t nElements, void *p) {
03176 return p ? new(p) ::TF1Editor[nElements] : new ::TF1Editor[nElements];
03177 }
03178
03179 static void delete_TF1Editor(void *p) {
03180 delete ((::TF1Editor*)p);
03181 }
03182 static void deleteArray_TF1Editor(void *p) {
03183 delete [] ((::TF1Editor*)p);
03184 }
03185 static void destruct_TF1Editor(void *p) {
03186 typedef ::TF1Editor current_t;
03187 ((current_t*)p)->~current_t();
03188 }
03189
03190 static void streamer_TF1Editor(TBuffer &buf, void *obj) {
03191 ((::TF1Editor*)obj)->::TF1Editor::Streamer(buf);
03192 }
03193 }
03194
03195
03196 void TFunctionParametersDialog::Streamer(TBuffer &R__b)
03197 {
03198
03199
03200 TGTransientFrame::Streamer(R__b);
03201 }
03202
03203
03204 void TFunctionParametersDialog::ShowMembers(TMemberInspector &R__insp)
03205 {
03206
03207 TClass *R__cl = ::TFunctionParametersDialog::IsA();
03208 if (R__cl || R__insp.IsA()) { }
03209 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunc", &fFunc);
03210 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFpad", &fFpad);
03211 R__insp.Inspect(R__cl, R__insp.GetParent(), "fNP", &fNP);
03212 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPmin", &fPmin);
03213 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPmax", &fPmax);
03214 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPval", &fPval);
03215 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPerr", &fPerr);
03216 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRangexmin", &fRangexmin);
03217 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRangexmax", &fRangexmax);
03218 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRXmin", &fRXmin);
03219 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRXmax", &fRXmax);
03220 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContNam", &fContNam);
03221 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContVal", &fContVal);
03222 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContFix", &fContFix);
03223 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContSld", &fContSld);
03224 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContMin", &fContMin);
03225 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fContMax", &fContMax);
03226 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParNam", &fParNam);
03227 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParFix", &fParFix);
03228 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParVal", &fParVal);
03229 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParMin", &fParMin);
03230 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParMax", &fParMax);
03231 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParSld", &fParSld);
03232 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUpdate", &fUpdate);
03233 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApply", &fApply);
03234 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReset", &fReset);
03235 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOK", &fOK);
03236 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
03237 R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasChanges", &fHasChanges);
03238 R__insp.Inspect(R__cl, R__insp.GetParent(), "fImmediateDraw", &fImmediateDraw);
03239 TGTransientFrame::ShowMembers(R__insp);
03240 }
03241
03242 namespace ROOT {
03243
03244 static void delete_TFunctionParametersDialog(void *p) {
03245 delete ((::TFunctionParametersDialog*)p);
03246 }
03247 static void deleteArray_TFunctionParametersDialog(void *p) {
03248 delete [] ((::TFunctionParametersDialog*)p);
03249 }
03250 static void destruct_TFunctionParametersDialog(void *p) {
03251 typedef ::TFunctionParametersDialog current_t;
03252 ((current_t*)p)->~current_t();
03253 }
03254
03255 static void streamer_TFunctionParametersDialog(TBuffer &buf, void *obj) {
03256 ((::TFunctionParametersDialog*)obj)->::TFunctionParametersDialog::Streamer(buf);
03257 }
03258 }
03259
03260
03261 void TPaveStatsEditor::Streamer(TBuffer &R__b)
03262 {
03263
03264
03265 TGedFrame::Streamer(R__b);
03266 }
03267
03268
03269 void TPaveStatsEditor::ShowMembers(TMemberInspector &R__insp)
03270 {
03271
03272 TClass *R__cl = ::TPaveStatsEditor::IsA();
03273 if (R__cl || R__insp.IsA()) { }
03274 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaveStats", &fPaveStats);
03275 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistoName", &fHistoName);
03276 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntries", &fEntries);
03277 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMean", &fMean);
03278 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRMS", &fRMS);
03279 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnderflow", &fUnderflow);
03280 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOverflow", &fOverflow);
03281 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntegral", &fIntegral);
03282 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSkewness", &fSkewness);
03283 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKurtosis", &fKurtosis);
03284 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatsErrors", &fStatsErrors);
03285 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNameValues", &fNameValues);
03286 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fErrors", &fErrors);
03287 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChisquare", &fChisquare);
03288 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProbability", &fProbability);
03289 TGedFrame::ShowMembers(R__insp);
03290 }
03291
03292 namespace ROOT {
03293
03294 static void *new_TPaveStatsEditor(void *p) {
03295 return p ? new(p) ::TPaveStatsEditor : new ::TPaveStatsEditor;
03296 }
03297 static void *newArray_TPaveStatsEditor(Long_t nElements, void *p) {
03298 return p ? new(p) ::TPaveStatsEditor[nElements] : new ::TPaveStatsEditor[nElements];
03299 }
03300
03301 static void delete_TPaveStatsEditor(void *p) {
03302 delete ((::TPaveStatsEditor*)p);
03303 }
03304 static void deleteArray_TPaveStatsEditor(void *p) {
03305 delete [] ((::TPaveStatsEditor*)p);
03306 }
03307 static void destruct_TPaveStatsEditor(void *p) {
03308 typedef ::TPaveStatsEditor current_t;
03309 ((current_t*)p)->~current_t();
03310 }
03311
03312 static void streamer_TPaveStatsEditor(TBuffer &buf, void *obj) {
03313 ((::TPaveStatsEditor*)obj)->::TPaveStatsEditor::Streamer(buf);
03314 }
03315 }
03316
03317
03318 void TPadEditor::Streamer(TBuffer &R__b)
03319 {
03320
03321
03322 TGedFrame::Streamer(R__b);
03323 }
03324
03325
03326 void TPadEditor::ShowMembers(TMemberInspector &R__insp)
03327 {
03328
03329 TClass *R__cl = ::TPadEditor::IsA();
03330 if (R__cl || R__insp.IsA()) { }
03331 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadPointer", &fPadPointer);
03332 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditable", &fEditable);
03333 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCrosshair", &fCrosshair);
03334 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFixedAR", &fFixedAR);
03335 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridX", &fGridX);
03336 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridY", &fGridY);
03337 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogX", &fLogX);
03338 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogY", &fLogY);
03339 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogZ", &fLogZ);
03340 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTickX", &fTickX);
03341 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTickY", &fTickY);
03342 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode", &fBmode);
03343 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode0", &fBmode0);
03344 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmode1", &fBmode1);
03345 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBmodelh", &fBmodelh);
03346 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBsize", &fBsize);
03347 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBgroup", &fBgroup);
03348 TGedFrame::ShowMembers(R__insp);
03349 }
03350
03351 namespace ROOT {
03352
03353 static void *new_TPadEditor(void *p) {
03354 return p ? new(p) ::TPadEditor : new ::TPadEditor;
03355 }
03356 static void *newArray_TPadEditor(Long_t nElements, void *p) {
03357 return p ? new(p) ::TPadEditor[nElements] : new ::TPadEditor[nElements];
03358 }
03359
03360 static void delete_TPadEditor(void *p) {
03361 delete ((::TPadEditor*)p);
03362 }
03363 static void deleteArray_TPadEditor(void *p) {
03364 delete [] ((::TPadEditor*)p);
03365 }
03366 static void destruct_TPadEditor(void *p) {
03367 typedef ::TPadEditor current_t;
03368 ((current_t*)p)->~current_t();
03369 }
03370
03371 static void streamer_TPadEditor(TBuffer &buf, void *obj) {
03372 ((::TPadEditor*)obj)->::TPadEditor::Streamer(buf);
03373 }
03374 }
03375
03376
03377 void TGedEditor::Streamer(TBuffer &R__b)
03378 {
03379
03380
03381 TVirtualPadEditor::Streamer(R__b);
03382 TGMainFrame::Streamer(R__b);
03383 }
03384
03385
03386 void TGedEditor::ShowMembers(TMemberInspector &R__insp)
03387 {
03388
03389 TClass *R__cl = ::TGedEditor::IsA();
03390 if (R__cl || R__insp.IsA()) { }
03391 R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrameMap", &fFrameMap);
03392 R__insp.InspectMember(fFrameMap, "fFrameMap.");
03393 R__insp.Inspect(R__cl, R__insp.GetParent(), "fExclMap", &fExclMap);
03394 R__insp.InspectMember(fExclMap, "fExclMap.");
03395 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGedFrames", &fGedFrames);
03396 R__insp.InspectMember(fGedFrames, "fGedFrames.");
03397 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCan", &fCan);
03398 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTab", &fTab);
03399 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreatedTabs", &fCreatedTabs);
03400 R__insp.InspectMember(fCreatedTabs, "fCreatedTabs.");
03401 R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisibleTabs", &fVisibleTabs);
03402 R__insp.InspectMember(fVisibleTabs, "fVisibleTabs.");
03403 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTabContainer", &fTabContainer);
03404 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModel", &fModel);
03405 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
03406 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvas", &fCanvas);
03407 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
03408 R__insp.Inspect(R__cl, R__insp.GetParent(), "fGlobal", &fGlobal);
03409 TVirtualPadEditor::ShowMembers(R__insp);
03410 TGMainFrame::ShowMembers(R__insp);
03411 }
03412
03413 namespace ROOT {
03414
03415 static void *new_TGedEditor(void *p) {
03416 return p ? new(p) ::TGedEditor : new ::TGedEditor;
03417 }
03418 static void *newArray_TGedEditor(Long_t nElements, void *p) {
03419 return p ? new(p) ::TGedEditor[nElements] : new ::TGedEditor[nElements];
03420 }
03421
03422 static void delete_TGedEditor(void *p) {
03423 delete ((::TGedEditor*)p);
03424 }
03425 static void deleteArray_TGedEditor(void *p) {
03426 delete [] ((::TGedEditor*)p);
03427 }
03428 static void destruct_TGedEditor(void *p) {
03429 typedef ::TGedEditor current_t;
03430 ((current_t*)p)->~current_t();
03431 }
03432
03433 static void streamer_TGedEditor(TBuffer &buf, void *obj) {
03434 ((::TGedEditor*)obj)->::TGedEditor::Streamer(buf);
03435 }
03436 }
03437
03438
03439 void TCurlyArcEditor::Streamer(TBuffer &R__b)
03440 {
03441
03442
03443 TGedFrame::Streamer(R__b);
03444 }
03445
03446
03447 void TCurlyArcEditor::ShowMembers(TMemberInspector &R__insp)
03448 {
03449
03450 TClass *R__cl = ::TCurlyArcEditor::IsA();
03451 if (R__cl || R__insp.IsA()) { }
03452 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurlyArc", &fCurlyArc);
03453 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRadiusEntry", &fRadiusEntry);
03454 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhiminEntry", &fPhiminEntry);
03455 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPhimaxEntry", &fPhimaxEntry);
03456 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterXEntry", &fCenterXEntry);
03457 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCenterYEntry", &fCenterYEntry);
03458 TGedFrame::ShowMembers(R__insp);
03459 }
03460
03461 namespace ROOT {
03462
03463 static void *new_TCurlyArcEditor(void *p) {
03464 return p ? new(p) ::TCurlyArcEditor : new ::TCurlyArcEditor;
03465 }
03466 static void *newArray_TCurlyArcEditor(Long_t nElements, void *p) {
03467 return p ? new(p) ::TCurlyArcEditor[nElements] : new ::TCurlyArcEditor[nElements];
03468 }
03469
03470 static void delete_TCurlyArcEditor(void *p) {
03471 delete ((::TCurlyArcEditor*)p);
03472 }
03473 static void deleteArray_TCurlyArcEditor(void *p) {
03474 delete [] ((::TCurlyArcEditor*)p);
03475 }
03476 static void destruct_TCurlyArcEditor(void *p) {
03477 typedef ::TCurlyArcEditor current_t;
03478 ((current_t*)p)->~current_t();
03479 }
03480
03481 static void streamer_TCurlyArcEditor(TBuffer &buf, void *obj) {
03482 ((::TCurlyArcEditor*)obj)->::TCurlyArcEditor::Streamer(buf);
03483 }
03484 }
03485
03486
03487 void TCurlyLineEditor::Streamer(TBuffer &R__b)
03488 {
03489
03490
03491 TGedFrame::Streamer(R__b);
03492 }
03493
03494
03495 void TCurlyLineEditor::ShowMembers(TMemberInspector &R__insp)
03496 {
03497
03498 TClass *R__cl = ::TCurlyLineEditor::IsA();
03499 if (R__cl || R__insp.IsA()) { }
03500 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurlyLine", &fCurlyLine);
03501 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartXEntry", &fStartXEntry);
03502 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndXEntry", &fEndXEntry);
03503 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartYEntry", &fStartYEntry);
03504 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndYEntry", &fEndYEntry);
03505 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAmplitudeEntry", &fAmplitudeEntry);
03506 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWaveLengthEntry", &fWaveLengthEntry);
03507 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIsWavy", &fIsWavy);
03508 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStartXFrame", &fStartXFrame);
03509 TGedFrame::ShowMembers(R__insp);
03510 }
03511
03512 namespace ROOT {
03513
03514 static void *new_TCurlyLineEditor(void *p) {
03515 return p ? new(p) ::TCurlyLineEditor : new ::TCurlyLineEditor;
03516 }
03517 static void *newArray_TCurlyLineEditor(Long_t nElements, void *p) {
03518 return p ? new(p) ::TCurlyLineEditor[nElements] : new ::TCurlyLineEditor[nElements];
03519 }
03520
03521 static void delete_TCurlyLineEditor(void *p) {
03522 delete ((::TCurlyLineEditor*)p);
03523 }
03524 static void deleteArray_TCurlyLineEditor(void *p) {
03525 delete [] ((::TCurlyLineEditor*)p);
03526 }
03527 static void destruct_TCurlyLineEditor(void *p) {
03528 typedef ::TCurlyLineEditor current_t;
03529 ((current_t*)p)->~current_t();
03530 }
03531
03532 static void streamer_TCurlyLineEditor(TBuffer &buf, void *obj) {
03533 ((::TCurlyLineEditor*)obj)->::TCurlyLineEditor::Streamer(buf);
03534 }
03535 }
03536
03537
03538 void TGedPopup::Streamer(TBuffer &R__b)
03539 {
03540
03541
03542 TGCompositeFrame::Streamer(R__b);
03543 }
03544
03545
03546 void TGedPopup::ShowMembers(TMemberInspector &R__insp)
03547 {
03548
03549 TClass *R__cl = ::TGedPopup::IsA();
03550 if (R__cl || R__insp.IsA()) { }
03551 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgWindow", &fMsgWindow);
03552 TGCompositeFrame::ShowMembers(R__insp);
03553 }
03554
03555 namespace ROOT {
03556
03557 static void delete_TGedPopup(void *p) {
03558 delete ((::TGedPopup*)p);
03559 }
03560 static void deleteArray_TGedPopup(void *p) {
03561 delete [] ((::TGedPopup*)p);
03562 }
03563 static void destruct_TGedPopup(void *p) {
03564 typedef ::TGedPopup current_t;
03565 ((current_t*)p)->~current_t();
03566 }
03567
03568 static void streamer_TGedPopup(TBuffer &buf, void *obj) {
03569 ((::TGedPopup*)obj)->::TGedPopup::Streamer(buf);
03570 }
03571 }
03572
03573
03574 void TGedSelect::Streamer(TBuffer &R__b)
03575 {
03576
03577
03578 TGCheckButton::Streamer(R__b);
03579 }
03580
03581
03582 void TGedSelect::ShowMembers(TMemberInspector &R__insp)
03583 {
03584
03585 TClass *R__cl = ::TGedSelect::IsA();
03586 if (R__cl || R__insp.IsA()) { }
03587 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawGC", &fDrawGC);
03588 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPopup", &fPopup);
03589 TGCheckButton::ShowMembers(R__insp);
03590 }
03591
03592 namespace ROOT {
03593
03594 static void delete_TGedSelect(void *p) {
03595 delete ((::TGedSelect*)p);
03596 }
03597 static void deleteArray_TGedSelect(void *p) {
03598 delete [] ((::TGedSelect*)p);
03599 }
03600 static void destruct_TGedSelect(void *p) {
03601 typedef ::TGedSelect current_t;
03602 ((current_t*)p)->~current_t();
03603 }
03604
03605 static void streamer_TGedSelect(TBuffer &buf, void *obj) {
03606 ((::TGedSelect*)obj)->::TGedSelect::Streamer(buf);
03607 }
03608 }
03609
03610
03611 void TGedPatternFrame::Streamer(TBuffer &R__b)
03612 {
03613
03614
03615 TGFrame::Streamer(R__b);
03616 }
03617
03618
03619 void TGedPatternFrame::ShowMembers(TMemberInspector &R__insp)
03620 {
03621
03622 TClass *R__cl = ::TGedPatternFrame::IsA();
03623 if (R__cl || R__insp.IsA()) { }
03624 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgWindow", &fMsgWindow);
03625 R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
03626 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPattern", &fPattern);
03627 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTip", &fTip);
03628 R__insp.Inspect(R__cl, R__insp.GetParent(), "fTipText[5]", fTipText);
03629 TGFrame::ShowMembers(R__insp);
03630 }
03631
03632 namespace ROOT {
03633
03634 static void delete_TGedPatternFrame(void *p) {
03635 delete ((::TGedPatternFrame*)p);
03636 }
03637 static void deleteArray_TGedPatternFrame(void *p) {
03638 delete [] ((::TGedPatternFrame*)p);
03639 }
03640 static void destruct_TGedPatternFrame(void *p) {
03641 typedef ::TGedPatternFrame current_t;
03642 ((current_t*)p)->~current_t();
03643 }
03644
03645 static void streamer_TGedPatternFrame(TBuffer &buf, void *obj) {
03646 ((::TGedPatternFrame*)obj)->::TGedPatternFrame::Streamer(buf);
03647 }
03648 }
03649
03650
03651 void TGedPatternSelector::Streamer(TBuffer &R__b)
03652 {
03653
03654
03655 TGCompositeFrame::Streamer(R__b);
03656 }
03657
03658
03659 void TGedPatternSelector::ShowMembers(TMemberInspector &R__insp)
03660 {
03661
03662 TClass *R__cl = ::TGedPatternSelector::IsA();
03663 if (R__cl || R__insp.IsA()) { }
03664 R__insp.Inspect(R__cl, R__insp.GetParent(), "fActive", &fActive);
03665 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMsgWindow", &fMsgWindow);
03666 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCe[27]", &fCe);
03667 TGCompositeFrame::ShowMembers(R__insp);
03668 }
03669
03670 namespace ROOT {
03671
03672 static void delete_TGedPatternSelector(void *p) {
03673 delete ((::TGedPatternSelector*)p);
03674 }
03675 static void deleteArray_TGedPatternSelector(void *p) {
03676 delete [] ((::TGedPatternSelector*)p);
03677 }
03678 static void destruct_TGedPatternSelector(void *p) {
03679 typedef ::TGedPatternSelector current_t;
03680 ((current_t*)p)->~current_t();
03681 }
03682
03683 static void streamer_TGedPatternSelector(TBuffer &buf, void *obj) {
03684 ((::TGedPatternSelector*)obj)->::TGedPatternSelector::Streamer(buf);
03685 }
03686 }
03687
03688
03689 void TGedPatternPopup::Streamer(TBuffer &R__b)
03690 {
03691
03692
03693 TGedPopup::Streamer(R__b);
03694 }
03695
03696
03697 void TGedPatternPopup::ShowMembers(TMemberInspector &R__insp)
03698 {
03699
03700 TClass *R__cl = ::TGedPatternPopup::IsA();
03701 if (R__cl || R__insp.IsA()) { }
03702 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentPattern", &fCurrentPattern);
03703 TGedPopup::ShowMembers(R__insp);
03704 }
03705
03706 namespace ROOT {
03707
03708 static void delete_TGedPatternPopup(void *p) {
03709 delete ((::TGedPatternPopup*)p);
03710 }
03711 static void deleteArray_TGedPatternPopup(void *p) {
03712 delete [] ((::TGedPatternPopup*)p);
03713 }
03714 static void destruct_TGedPatternPopup(void *p) {
03715 typedef ::TGedPatternPopup current_t;
03716 ((current_t*)p)->~current_t();
03717 }
03718
03719 static void streamer_TGedPatternPopup(TBuffer &buf, void *obj) {
03720 ((::TGedPatternPopup*)obj)->::TGedPatternPopup::Streamer(buf);
03721 }
03722 }
03723
03724
03725 void TGedPatternSelect::Streamer(TBuffer &R__b)
03726 {
03727
03728
03729 TGedSelect::Streamer(R__b);
03730 }
03731
03732
03733 void TGedPatternSelect::ShowMembers(TMemberInspector &R__insp)
03734 {
03735
03736 TClass *R__cl = ::TGedPatternSelect::IsA();
03737 if (R__cl || R__insp.IsA()) { }
03738 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPattern", &fPattern);
03739 TGedSelect::ShowMembers(R__insp);
03740 }
03741
03742 namespace ROOT {
03743
03744 static void delete_TGedPatternSelect(void *p) {
03745 delete ((::TGedPatternSelect*)p);
03746 }
03747 static void deleteArray_TGedPatternSelect(void *p) {
03748 delete [] ((::TGedPatternSelect*)p);
03749 }
03750 static void destruct_TGedPatternSelect(void *p) {
03751 typedef ::TGedPatternSelect current_t;
03752 ((current_t*)p)->~current_t();
03753 }
03754
03755 static void streamer_TGedPatternSelect(TBuffer &buf, void *obj) {
03756 ((::TGedPatternSelect*)obj)->::TGedPatternSelect::Streamer(buf);
03757 }
03758 }
03759
03760
03761 void TGedMarkerSelect::Streamer(TBuffer &R__b)
03762 {
03763
03764
03765 TGedSelect::Streamer(R__b);
03766 }
03767
03768
03769 void TGedMarkerSelect::ShowMembers(TMemberInspector &R__insp)
03770 {
03771
03772 TClass *R__cl = ::TGedMarkerSelect::IsA();
03773 if (R__cl || R__insp.IsA()) { }
03774 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMarkerStyle", &fMarkerStyle);
03775 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPicture", &fPicture);
03776 TGedSelect::ShowMembers(R__insp);
03777 }
03778
03779 namespace ROOT {
03780
03781 static void delete_TGedMarkerSelect(void *p) {
03782 delete ((::TGedMarkerSelect*)p);
03783 }
03784 static void deleteArray_TGedMarkerSelect(void *p) {
03785 delete [] ((::TGedMarkerSelect*)p);
03786 }
03787 static void destruct_TGedMarkerSelect(void *p) {
03788 typedef ::TGedMarkerSelect current_t;
03789 ((current_t*)p)->~current_t();
03790 }
03791
03792 static void streamer_TGedMarkerSelect(TBuffer &buf, void *obj) {
03793 ((::TGedMarkerSelect*)obj)->::TGedMarkerSelect::Streamer(buf);
03794 }
03795 }
03796
03797
03798 void TGedMarkerPopup::Streamer(TBuffer &R__b)
03799 {
03800
03801
03802 TGedPopup::Streamer(R__b);
03803 }
03804
03805
03806 void TGedMarkerPopup::ShowMembers(TMemberInspector &R__insp)
03807 {
03808
03809 TClass *R__cl = ::TGedMarkerPopup::IsA();
03810 if (R__cl || R__insp.IsA()) { }
03811 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentStyle", &fCurrentStyle);
03812 TGedPopup::ShowMembers(R__insp);
03813 }
03814
03815 namespace ROOT {
03816
03817 static void delete_TGedMarkerPopup(void *p) {
03818 delete ((::TGedMarkerPopup*)p);
03819 }
03820 static void deleteArray_TGedMarkerPopup(void *p) {
03821 delete [] ((::TGedMarkerPopup*)p);
03822 }
03823 static void destruct_TGedMarkerPopup(void *p) {
03824 typedef ::TGedMarkerPopup current_t;
03825 ((current_t*)p)->~current_t();
03826 }
03827
03828 static void streamer_TGedMarkerPopup(TBuffer &buf, void *obj) {
03829 ((::TGedMarkerPopup*)obj)->::TGedMarkerPopup::Streamer(buf);
03830 }
03831 }
03832
03833
03834 void TStyleManager::Streamer(TBuffer &R__b)
03835 {
03836
03837
03838 TGMainFrame::Streamer(R__b);
03839 }
03840
03841
03842 void TStyleManager::ShowMembers(TMemberInspector &R__insp)
03843 {
03844
03845 TClass *R__cl = ::TStyleManager::IsA();
03846 if (R__cl || R__insp.IsA()) { }
03847 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurSelStyle", &fCurSelStyle);
03848 R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastChoice", &fLastChoice);
03849 R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealTimePreview", &fRealTimePreview);
03850 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurTabNum", &fCurTabNum);
03851 R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurTabAxisNum", &fCurTabAxisNum);
03852 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSMWidth", &fSMWidth);
03853 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSMHeight", &fSMHeight);
03854 R__insp.Inspect(R__cl, R__insp.GetParent(), "fStyleChanged", &fStyleChanged);
03855 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMoreAndNotLess", &fMoreAndNotLess);
03856 R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigSlotConnected", &fSigSlotConnected);
03857 R__insp.Inspect(R__cl, R__insp.GetParent(), "fAllAndNotCurrent", &fAllAndNotCurrent);
03858 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListFrame", &fTrashListFrame);
03859 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListLayout", &fTrashListLayout);
03860 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar);
03861 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuStyle", &fMenuStyle);
03862 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fImportCascade", &fImportCascade);
03863 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuHelp", &fMenuHelp);
03864 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBar", &fToolBar);
03865 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarNew", &fToolBarNew);
03866 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarDelete", &fToolBarDelete);
03867 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarImportCanvas", &fToolBarImportCanvas);
03868 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarImportMacro", &fToolBarImportMacro);
03869 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarExport", &fToolBarExport);
03870 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarHelp", &fToolBarHelp);
03871 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarNewPic", &fToolBarNewPic);
03872 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarDeletePic", &fToolBarDeletePic);
03873 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarImportCanvasPic", &fToolBarImportCanvasPic);
03874 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarImportMacroPic", &fToolBarImportMacroPic);
03875 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarExportPic", &fToolBarExportPic);
03876 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fToolBarHelpPic", &fToolBarHelpPic);
03877 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHorizontal3DLine", &fHorizontal3DLine);
03878 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListLabel", &fListLabel);
03879 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fListComboBox", &fListComboBox);
03880 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurMacro", &fCurMacro);
03881 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurStylabel", &fCurStylabel);
03882 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurStyle", &fCurStyle);
03883 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurPadLabel", &fCurPadLabel);
03884 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurPadTextEntry", &fCurPadTextEntry);
03885 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurPad", &fCurPad);
03886 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurObjLabel", &fCurObjLabel);
03887 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurObjTextEntry", &fCurObjTextEntry);
03888 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurObj", &fCurObj);
03889 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviewButton", &fPreviewButton);
03890 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviewRealTime", &fPreviewRealTime);
03891 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviewWindow", &fPreviewWindow);
03892 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMakeDefault", &fMakeDefault);
03893 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMakeDefaultPic", &fMakeDefaultPic);
03894 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnGroup", &fApplyOnGroup);
03895 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnAll", &fApplyOnAll);
03896 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnSel", &fApplyOnSel);
03897 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnButton", &fApplyOnButton);
03898 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMoreLess", &fMoreLess);
03899 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatusBar", &fStatusBar);
03900 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionFrame", &fEditionFrame);
03901 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionTab", &fEditionTab);
03902 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistosTab", &fHistosTab);
03903 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAxisTab", &fAxisTab);
03904 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionButtonFrame", &fEditionButtonFrame);
03905 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionHelp", &fEditionHelp);
03906 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionUpdatePreview", &fEditionUpdatePreview);
03907 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEditionReset", &fEditionReset);
03908 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFillColor", &fFillColor);
03909 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFillStyle", &fFillStyle);
03910 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHatchesLineWidth", &fHatchesLineWidth);
03911 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHatchesSpacing", &fHatchesSpacing);
03912 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextColor", &fTextColor);
03913 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextSize", &fTextSize);
03914 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextSizeInPixels", &fTextSizeInPixels);
03915 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextFont", &fTextFont);
03916 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextAlign", &fTextAlign);
03917 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTextAngle", &fTextAngle);
03918 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineColor", &fLineColor);
03919 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineWidth", &fLineWidth);
03920 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineStyle", &fLineStyle);
03921 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineStyleEdit", &fLineStyleEdit);
03922 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerColor", &fMarkerColor);
03923 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerStyle", &fMarkerStyle);
03924 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMarkerSize", &fMarkerSize);
03925 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fScreenFactor", &fScreenFactor);
03926 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasColor", &fCanvasColor);
03927 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasDefX", &fCanvasDefX);
03928 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasDefY", &fCanvasDefY);
03929 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasDefW", &fCanvasDefW);
03930 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasDefH", &fCanvasDefH);
03931 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasBorderMode", &fCanvasBorderMode);
03932 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCanvasBorderSize", &fCanvasBorderSize);
03933 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptDateBool", &fOptDateBool);
03934 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextColor", &fAttDateTextColor);
03935 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextSize", &fAttDateTextSize);
03936 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextSizeInPixels", &fAttDateTextSizeInPixels);
03937 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptDateFormat", &fOptDateFormat);
03938 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextFont", &fAttDateTextFont);
03939 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextAngle", &fAttDateTextAngle);
03940 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAttDateTextAlign", &fAttDateTextAlign);
03941 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDateX", &fDateX);
03942 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDateY", &fDateY);
03943 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadLeftMargin", &fPadLeftMargin);
03944 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadRightMargin", &fPadRightMargin);
03945 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadTopMargin", &fPadTopMargin);
03946 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadBottomMargin", &fPadBottomMargin);
03947 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadBorderMode", &fPadBorderMode);
03948 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadBorderSize", &fPadBorderSize);
03949 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadColor", &fPadColor);
03950 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadTickX", &fPadTickX);
03951 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadTickY", &fPadTickY);
03952 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadGridX", &fPadGridX);
03953 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPadGridY", &fPadGridY);
03954 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridColor", &fGridColor);
03955 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridWidth", &fGridWidth);
03956 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGridStyle", &fGridStyle);
03957 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistFillColor", &fHistFillColor);
03958 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistFillStyle", &fHistFillStyle);
03959 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistLineColor", &fHistLineColor);
03960 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistLineWidth", &fHistLineWidth);
03961 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistLineStyle", &fHistLineStyle);
03962 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarWidth", &fBarWidth);
03963 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBarOffset", &fBarOffset);
03964 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistMinimumZero", &fHistMinimumZero);
03965 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaintTextFormat", &fPaintTextFormat);
03966 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNumberContours", &fNumberContours);
03967 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegoInnerR", &fLegoInnerR);
03968 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameFillColor", &fFrameFillColor);
03969 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameFillStyle", &fFrameFillStyle);
03970 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameLineColor", &fFrameLineColor);
03971 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameLineWidth", &fFrameLineWidth);
03972 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameLineStyle", &fFrameLineStyle);
03973 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaletteEdit", &fPaletteEdit);
03974 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameBorderMode", &fFrameBorderMode);
03975 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFrameBorderSize", &fFrameBorderSize);
03976 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncColor", &fFuncColor);
03977 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncWidth", &fFuncWidth);
03978 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFuncStyle", &fFuncStyle);
03979 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawBorder", &fDrawBorder);
03980 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEndErrorSize", &fEndErrorSize);
03981 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fErrorX", &fErrorX);
03982 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimeOffsetDate", &fTimeOffsetDate);
03983 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimeOffsetTime", &fTimeOffsetTime);
03984 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStripDecimals", &fStripDecimals);
03985 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fApplyOnXYZ", &fApplyOnXYZ);
03986 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleSize", &fXTitleSize);
03987 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleSizeInPixels", &fXTitleSizeInPixels);
03988 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleColor", &fXTitleColor);
03989 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleOffset", &fXTitleOffset);
03990 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTitleFont", &fXTitleFont);
03991 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelSize", &fXLabelSize);
03992 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelSizeInPixels", &fXLabelSizeInPixels);
03993 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelColor", &fXLabelColor);
03994 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelOffset", &fXLabelOffset);
03995 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXLabelFont", &fXLabelFont);
03996 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXAxisColor", &fXAxisColor);
03997 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXTickLength", &fXTickLength);
03998 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptLogx", &fOptLogx);
03999 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXNdivMain", &fXNdivMain);
04000 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXNdivSub", &fXNdivSub);
04001 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXNdivSubSub", &fXNdivSubSub);
04002 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXNdivisionsOptimize", &fXNdivisionsOptimize);
04003 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleSize", &fYTitleSize);
04004 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleSizeInPixels", &fYTitleSizeInPixels);
04005 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleColor", &fYTitleColor);
04006 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleOffset", &fYTitleOffset);
04007 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTitleFont", &fYTitleFont);
04008 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelSize", &fYLabelSize);
04009 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelSizeInPixels", &fYLabelSizeInPixels);
04010 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelColor", &fYLabelColor);
04011 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelOffset", &fYLabelOffset);
04012 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYLabelFont", &fYLabelFont);
04013 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYAxisColor", &fYAxisColor);
04014 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYTickLength", &fYTickLength);
04015 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptLogy", &fOptLogy);
04016 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNdivMain", &fYNdivMain);
04017 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNdivSub", &fYNdivSub);
04018 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNdivSubSub", &fYNdivSubSub);
04019 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNdivisionsOptimize", &fYNdivisionsOptimize);
04020 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleSize", &fZTitleSize);
04021 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleSizeInPixels", &fZTitleSizeInPixels);
04022 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleColor", &fZTitleColor);
04023 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleOffset", &fZTitleOffset);
04024 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTitleFont", &fZTitleFont);
04025 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelSize", &fZLabelSize);
04026 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelSizeInPixels", &fZLabelSizeInPixels);
04027 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelColor", &fZLabelColor);
04028 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelOffset", &fZLabelOffset);
04029 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZLabelFont", &fZLabelFont);
04030 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZAxisColor", &fZAxisColor);
04031 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZTickLength", &fZTickLength);
04032 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptLogz", &fOptLogz);
04033 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZNdivMain", &fZNdivMain);
04034 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZNdivSub", &fZNdivSub);
04035 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZNdivSubSub", &fZNdivSubSub);
04036 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fZNdivisionsOptimize", &fZNdivisionsOptimize);
04037 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptTitle", &fOptTitle);
04038 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleColor", &fTitleColor);
04039 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleStyle", &fTitleStyle);
04040 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleTextColor", &fTitleTextColor);
04041 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleFontSize", &fTitleFontSize);
04042 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleFontSizeInPixels", &fTitleFontSizeInPixels);
04043 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleFont", &fTitleFont);
04044 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleAlign", &fTitleAlign);
04045 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleBorderSizeLabel", &fTitleBorderSizeLabel);
04046 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleBorderSize", &fTitleBorderSize);
04047 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleX", &fTitleX);
04048 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleY", &fTitleY);
04049 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleW", &fTitleW);
04050 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleH", &fTitleH);
04051 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegendBorderSizeLabel", &fLegendBorderSizeLabel);
04052 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLegendBorderSize", &fLegendBorderSize);
04053 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatColor", &fStatColor);
04054 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatStyle", &fStatStyle);
04055 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatTextColor", &fStatTextColor);
04056 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFontSize", &fStatFontSize);
04057 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFontSizeInPixels", &fStatFontSizeInPixels);
04058 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFont", &fStatFont);
04059 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatX", &fStatX);
04060 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatY", &fStatY);
04061 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatW", &fStatW);
04062 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatH", &fStatH);
04063 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatBorderSizeLabel", &fStatBorderSizeLabel);
04064 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatBorderSize", &fStatBorderSize);
04065 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatName", &fOptStatName);
04066 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatEntries", &fOptStatEntries);
04067 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatOverflow", &fOptStatOverflow);
04068 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatMean", &fOptStatMean);
04069 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatUnderflow", &fOptStatUnderflow);
04070 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatRMS", &fOptStatRMS);
04071 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatSkewness", &fOptStatSkewness);
04072 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatIntegral", &fOptStatIntegral);
04073 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatKurtosis", &fOptStatKurtosis);
04074 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptStatErrors", &fOptStatErrors);
04075 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFormatLabel", &fStatFormatLabel);
04076 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStatFormat", &fStatFormat);
04077 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptFitValues", &fOptFitValues);
04078 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptFitErrors", &fOptFitErrors);
04079 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptFitProbability", &fOptFitProbability);
04080 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOptFitChi", &fOptFitChi);
04081 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitFormatLabel", &fFitFormatLabel);
04082 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitFormat", &fFitFormat);
04083 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHeaderPS", &fHeaderPS);
04084 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitlePS", &fTitlePS);
04085 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorModelPS", &fColorModelPS);
04086 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorModelPSRGB", &fColorModelPSRGB);
04087 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorModelPSCMYK", &fColorModelPSCMYK);
04088 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLineScalePS", &fLineScalePS);
04089 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaperSizePredef", &fPaperSizePredef);
04090 R__insp.Inspect(R__cl, R__insp.GetParent(), "fPaperSizeEnCm", &fPaperSizeEnCm);
04091 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaperSizeX", &fPaperSizeX);
04092 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPaperSizeY", &fPaperSizeY);
04093 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandX", &fLayoutExpandX);
04094 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandXMargin", &fLayoutExpandXMargin);
04095 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandXY", &fLayoutExpandXY);
04096 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandXYMargin", &fLayoutExpandXYMargin);
04097 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLayoutExpandXCenterYMargin", &fLayoutExpandXCenterYMargin);
04098 TGMainFrame::ShowMembers(R__insp);
04099 }
04100
04101 namespace ROOT {
04102
04103 static void delete_TStyleManager(void *p) {
04104 delete ((::TStyleManager*)p);
04105 }
04106 static void deleteArray_TStyleManager(void *p) {
04107 delete [] ((::TStyleManager*)p);
04108 }
04109 static void destruct_TStyleManager(void *p) {
04110 typedef ::TStyleManager current_t;
04111 ((current_t*)p)->~current_t();
04112 }
04113
04114 static void streamer_TStyleManager(TBuffer &buf, void *obj) {
04115 ((::TStyleManager*)obj)->::TStyleManager::Streamer(buf);
04116 }
04117 }
04118
04119
04120 void TStylePreview::Streamer(TBuffer &R__b)
04121 {
04122
04123
04124 TGTransientFrame::Streamer(R__b);
04125 }
04126
04127
04128 void TStylePreview::ShowMembers(TMemberInspector &R__insp)
04129 {
04130
04131 TClass *R__cl = ::TStylePreview::IsA();
04132 if (R__cl || R__insp.IsA()) { }
04133 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEcan", &fEcan);
04134 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPad", &fPad);
04135 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListLayout", &fTrashListLayout);
04136 TGTransientFrame::ShowMembers(R__insp);
04137 }
04138
04139 namespace ROOT {
04140
04141 static void delete_TStylePreview(void *p) {
04142 delete ((::TStylePreview*)p);
04143 }
04144 static void deleteArray_TStylePreview(void *p) {
04145 delete [] ((::TStylePreview*)p);
04146 }
04147 static void destruct_TStylePreview(void *p) {
04148 typedef ::TStylePreview current_t;
04149 ((current_t*)p)->~current_t();
04150 }
04151
04152 static void streamer_TStylePreview(TBuffer &buf, void *obj) {
04153 ((::TStylePreview*)obj)->::TStylePreview::Streamer(buf);
04154 }
04155 }
04156
04157
04158 void TStyleDialog::Streamer(TBuffer &R__b)
04159 {
04160
04161
04162 TGTransientFrame::Streamer(R__b);
04163 }
04164
04165
04166 void TStyleDialog::ShowMembers(TMemberInspector &R__insp)
04167 {
04168
04169 TClass *R__cl = ::TStyleDialog::IsA();
04170 if (R__cl || R__insp.IsA()) { }
04171 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStyleManager", &fStyleManager);
04172 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fName", &fName);
04173 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNameLabel", &fNameLabel);
04174 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitle", &fTitle);
04175 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTitleLabel", &fTitleLabel);
04176 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWarnLabel", &fWarnLabel);
04177 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOK", &fOK);
04178 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCancel", &fCancel);
04179 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurStyle", &fCurStyle);
04180 R__insp.Inspect(R__cl, R__insp.GetParent(), "fMode", &fMode);
04181 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurPad", &fCurPad);
04182 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListFrame", &fTrashListFrame);
04183 R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrashListLayout", &fTrashListLayout);
04184 TGTransientFrame::ShowMembers(R__insp);
04185 }
04186
04187 namespace ROOT {
04188
04189 static void delete_TStyleDialog(void *p) {
04190 delete ((::TStyleDialog*)p);
04191 }
04192 static void deleteArray_TStyleDialog(void *p) {
04193 delete [] ((::TStyleDialog*)p);
04194 }
04195 static void destruct_TStyleDialog(void *p) {
04196 typedef ::TStyleDialog current_t;
04197 ((current_t*)p)->~current_t();
04198 }
04199
04200 static void streamer_TStyleDialog(TBuffer &buf, void *obj) {
04201 ((::TStyleDialog*)obj)->::TStyleDialog::Streamer(buf);
04202 }
04203 }
04204
04205
04206
04207
04208
04209
04210
04211
04212 #ifdef G__MEMTEST
04213 #undef malloc
04214 #undef free
04215 #endif
04216
04217 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
04218 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
04219 #endif
04220
04221 extern "C" void G__cpp_reset_tagtableG__Ged();
04222
04223 extern "C" void G__set_cpp_environmentG__Ged() {
04224 G__add_compiledheader("TObject.h");
04225 G__add_compiledheader("TMemberInspector.h");
04226 G__add_compiledheader("HelpSMText.h");
04227 G__add_compiledheader("TArrowEditor.h");
04228 G__add_compiledheader("TAttFillEditor.h");
04229 G__add_compiledheader("TAttLineEditor.h");
04230 G__add_compiledheader("TAttMarkerEditor.h");
04231 G__add_compiledheader("TAttTextEditor.h");
04232 G__add_compiledheader("TAxisEditor.h");
04233 G__add_compiledheader("TCurlyArcEditor.h");
04234 G__add_compiledheader("TCurlyLineEditor.h");
04235 G__add_compiledheader("TF1Editor.h");
04236 G__add_compiledheader("TFrameEditor.h");
04237 G__add_compiledheader("TFunctionParametersDialog.h");
04238 G__add_compiledheader("TGedEditor.h");
04239 G__add_compiledheader("TGedFrame.h");
04240 G__add_compiledheader("TGedMarkerSelect.h");
04241 G__add_compiledheader("TGedPatternSelect.h");
04242 G__add_compiledheader("TGraphEditor.h");
04243 G__add_compiledheader("TH1Editor.h");
04244 G__add_compiledheader("TH2Editor.h");
04245 G__add_compiledheader("TLineEditor.h");
04246 G__add_compiledheader("TPadEditor.h");
04247 G__add_compiledheader("TPaveStatsEditor.h");
04248 G__add_compiledheader("TPieEditor.h");
04249 G__add_compiledheader("TPieSliceEditor.h");
04250 G__add_compiledheader("TStyleDialog.h");
04251 G__add_compiledheader("TStyleManager.h");
04252 G__add_compiledheader("TStylePreview.h");
04253 G__cpp_reset_tagtableG__Ged();
04254 }
04255 #include <new>
04256 extern "C" int G__cpp_dllrevG__Ged() { return(30051515); }
04257
04258
04259
04260
04261
04262
04263 static int G__G__Ged_225_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04264 {
04265 TGedEditor* p = NULL;
04266 char* gvp = (char*) G__getgvp();
04267 switch (libp->paran) {
04268 case 3:
04269
04270 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04271 p = new TGedEditor(
04272 (TCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
04273 , (UInt_t) G__int(libp->para[2]));
04274 } else {
04275 p = new((void*) gvp) TGedEditor(
04276 (TCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
04277 , (UInt_t) G__int(libp->para[2]));
04278 }
04279 break;
04280 case 2:
04281
04282 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04283 p = new TGedEditor((TCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
04284 } else {
04285 p = new((void*) gvp) TGedEditor((TCanvas*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
04286 }
04287 break;
04288 case 1:
04289
04290 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04291 p = new TGedEditor((TCanvas*) G__int(libp->para[0]));
04292 } else {
04293 p = new((void*) gvp) TGedEditor((TCanvas*) G__int(libp->para[0]));
04294 }
04295 break;
04296 case 0:
04297 int n = G__getaryconstruct();
04298 if (n) {
04299 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04300 p = new TGedEditor[n];
04301 } else {
04302 p = new((void*) gvp) TGedEditor[n];
04303 }
04304 } else {
04305 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04306 p = new TGedEditor;
04307 } else {
04308 p = new((void*) gvp) TGedEditor;
04309 }
04310 }
04311 break;
04312 }
04313 result7->obj.i = (long) p;
04314 result7->ref = (long) p;
04315 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedEditor));
04316 return(1 || funcname || hash || result7 || libp) ;
04317 }
04318
04319 static int G__G__Ged_225_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04320 {
04321 ((TGedEditor*) G__getstructoffset())->PrintFrameStat();
04322 G__setnull(result7);
04323 return(1 || funcname || hash || result7 || libp) ;
04324 }
04325
04326 static int G__G__Ged_225_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04327 {
04328 switch (libp->paran) {
04329 case 1:
04330 ((TGedEditor*) G__getstructoffset())->Update((TGedFrame*) G__int(libp->para[0]));
04331 G__setnull(result7);
04332 break;
04333 case 0:
04334 ((TGedEditor*) G__getstructoffset())->Update();
04335 G__setnull(result7);
04336 break;
04337 }
04338 return(1 || funcname || hash || result7 || libp) ;
04339 }
04340
04341 static int G__G__Ged_225_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04342 {
04343 ((TGedEditor*) G__getstructoffset())->ReinitWorkspace();
04344 G__setnull(result7);
04345 return(1 || funcname || hash || result7 || libp) ;
04346 }
04347
04348 static int G__G__Ged_225_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04349 {
04350 ((TGedEditor*) G__getstructoffset())->ActivateEditor((TClass*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
04351 G__setnull(result7);
04352 return(1 || funcname || hash || result7 || libp) ;
04353 }
04354
04355 static int G__G__Ged_225_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04356 {
04357 ((TGedEditor*) G__getstructoffset())->ActivateEditors((TList*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
04358 G__setnull(result7);
04359 return(1 || funcname || hash || result7 || libp) ;
04360 }
04361
04362 static int G__G__Ged_225_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04363 {
04364 switch (libp->paran) {
04365 case 2:
04366 ((TGedEditor*) G__getstructoffset())->ExcludeClassEditor((TClass*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
04367 G__setnull(result7);
04368 break;
04369 case 1:
04370 ((TGedEditor*) G__getstructoffset())->ExcludeClassEditor((TClass*) G__int(libp->para[0]));
04371 G__setnull(result7);
04372 break;
04373 }
04374 return(1 || funcname || hash || result7 || libp) ;
04375 }
04376
04377 static int G__G__Ged_225_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04378 {
04379 ((TGedEditor*) G__getstructoffset())->InsertGedFrame((TGedFrame*) G__int(libp->para[0]));
04380 G__setnull(result7);
04381 return(1 || funcname || hash || result7 || libp) ;
04382 }
04383
04384 static int G__G__Ged_225_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04385 {
04386 G__letint(result7, 85, (long) ((const TGedEditor*) G__getstructoffset())->GetTGCanvas());
04387 return(1 || funcname || hash || result7 || libp) ;
04388 }
04389
04390 static int G__G__Ged_225_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04391 {
04392 G__letint(result7, 85, (long) ((const TGedEditor*) G__getstructoffset())->GetTab());
04393 return(1 || funcname || hash || result7 || libp) ;
04394 }
04395
04396 static int G__G__Ged_225_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04397 {
04398 G__letint(result7, 85, (long) ((TGedEditor*) G__getstructoffset())->GetEditorTab((const char*) G__int(libp->para[0])));
04399 return(1 || funcname || hash || result7 || libp) ;
04400 }
04401
04402 static int G__G__Ged_225_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04403 {
04404 G__letint(result7, 85, (long) ((TGedEditor*) G__getstructoffset())->GetEditorTabInfo((const char*) G__int(libp->para[0])));
04405 return(1 || funcname || hash || result7 || libp) ;
04406 }
04407
04408 static int G__G__Ged_225_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04409 {
04410 G__letint(result7, 85, (long) ((const TGedEditor*) G__getstructoffset())->GetPad());
04411 return(1 || funcname || hash || result7 || libp) ;
04412 }
04413
04414 static int G__G__Ged_225_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04415 {
04416 G__letint(result7, 85, (long) ((const TGedEditor*) G__getstructoffset())->GetModel());
04417 return(1 || funcname || hash || result7 || libp) ;
04418 }
04419
04420 static int G__G__Ged_225_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04421 {
04422 ((TGedEditor*) G__getstructoffset())->ConnectToCanvas((TCanvas*) G__int(libp->para[0]));
04423 G__setnull(result7);
04424 return(1 || funcname || hash || result7 || libp) ;
04425 }
04426
04427 static int G__G__Ged_225_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04428 {
04429 ((TGedEditor*) G__getstructoffset())->DisconnectFromCanvas();
04430 G__setnull(result7);
04431 return(1 || funcname || hash || result7 || libp) ;
04432 }
04433
04434 static int G__G__Ged_225_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04435 {
04436 ((TGedEditor*) G__getstructoffset())->GlobalClosed();
04437 G__setnull(result7);
04438 return(1 || funcname || hash || result7 || libp) ;
04439 }
04440
04441 static int G__G__Ged_225_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04442 {
04443 ((TGedEditor*) G__getstructoffset())->SetCanvas((TCanvas*) G__int(libp->para[0]));
04444 G__setnull(result7);
04445 return(1 || funcname || hash || result7 || libp) ;
04446 }
04447
04448 static int G__G__Ged_225_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04449 {
04450 ((TGedEditor*) G__getstructoffset())->GlobalSetModel((TVirtualPad*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
04451 , (Int_t) G__int(libp->para[2]));
04452 G__setnull(result7);
04453 return(1 || funcname || hash || result7 || libp) ;
04454 }
04455
04456 static int G__G__Ged_225_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04457 {
04458 ((TGedEditor*) G__getstructoffset())->SetModel((TVirtualPad*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
04459 , (Int_t) G__int(libp->para[2]));
04460 G__setnull(result7);
04461 return(1 || funcname || hash || result7 || libp) ;
04462 }
04463
04464 static int G__G__Ged_225_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04465 {
04466 G__letint(result7, 85, (long) TGedEditor::GetFrameCreator());
04467 return(1 || funcname || hash || result7 || libp) ;
04468 }
04469
04470 static int G__G__Ged_225_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04471 {
04472 TGedEditor::SetFrameCreator((TGedEditor*) G__int(libp->para[0]));
04473 G__setnull(result7);
04474 return(1 || funcname || hash || result7 || libp) ;
04475 }
04476
04477 static int G__G__Ged_225_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04478 {
04479 G__letint(result7, 85, (long) TGedEditor::Class());
04480 return(1 || funcname || hash || result7 || libp) ;
04481 }
04482
04483 static int G__G__Ged_225_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04484 {
04485 G__letint(result7, 67, (long) TGedEditor::Class_Name());
04486 return(1 || funcname || hash || result7 || libp) ;
04487 }
04488
04489 static int G__G__Ged_225_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04490 {
04491 G__letint(result7, 115, (long) TGedEditor::Class_Version());
04492 return(1 || funcname || hash || result7 || libp) ;
04493 }
04494
04495 static int G__G__Ged_225_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04496 {
04497 TGedEditor::Dictionary();
04498 G__setnull(result7);
04499 return(1 || funcname || hash || result7 || libp) ;
04500 }
04501
04502 static int G__G__Ged_225_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04503 {
04504 ((TGedEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04505 G__setnull(result7);
04506 return(1 || funcname || hash || result7 || libp) ;
04507 }
04508
04509 static int G__G__Ged_225_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04510 {
04511 G__letint(result7, 67, (long) TGedEditor::DeclFileName());
04512 return(1 || funcname || hash || result7 || libp) ;
04513 }
04514
04515 static int G__G__Ged_225_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04516 {
04517 G__letint(result7, 105, (long) TGedEditor::ImplFileLine());
04518 return(1 || funcname || hash || result7 || libp) ;
04519 }
04520
04521 static int G__G__Ged_225_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04522 {
04523 G__letint(result7, 67, (long) TGedEditor::ImplFileName());
04524 return(1 || funcname || hash || result7 || libp) ;
04525 }
04526
04527 static int G__G__Ged_225_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04528 {
04529 G__letint(result7, 105, (long) TGedEditor::DeclFileLine());
04530 return(1 || funcname || hash || result7 || libp) ;
04531 }
04532
04533
04534 typedef TGedEditor G__TTGedEditor;
04535 static int G__G__Ged_225_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04536 {
04537 char* gvp = (char*) G__getgvp();
04538 long soff = G__getstructoffset();
04539 int n = G__getaryconstruct();
04540
04541
04542
04543
04544
04545 if (!soff) {
04546 return(1);
04547 }
04548 if (n) {
04549 if (gvp == (char*)G__PVOID) {
04550 delete[] (TGedEditor*) soff;
04551 } else {
04552 G__setgvp((long) G__PVOID);
04553 for (int i = n - 1; i >= 0; --i) {
04554 ((TGedEditor*) (soff+(sizeof(TGedEditor)*i)))->~G__TTGedEditor();
04555 }
04556 G__setgvp((long)gvp);
04557 }
04558 } else {
04559 if (gvp == (char*)G__PVOID) {
04560 delete (TGedEditor*) soff;
04561 } else {
04562 G__setgvp((long) G__PVOID);
04563 ((TGedEditor*) (soff))->~G__TTGedEditor();
04564 G__setgvp((long)gvp);
04565 }
04566 }
04567 G__setnull(result7);
04568 return(1 || funcname || hash || result7 || libp) ;
04569 }
04570
04571
04572
04573 static int G__G__Ged_226_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04574 {
04575 ((TGedFrame*) G__getstructoffset())->Update();
04576 G__setnull(result7);
04577 return(1 || funcname || hash || result7 || libp) ;
04578 }
04579
04580 static int G__G__Ged_226_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04581 {
04582 G__letint(result7, 85, (long) ((TGedFrame*) G__getstructoffset())->GetModelClass());
04583 return(1 || funcname || hash || result7 || libp) ;
04584 }
04585
04586 static int G__G__Ged_226_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04587 {
04588 G__letint(result7, 105, (long) ((TGedFrame*) G__getstructoffset())->GetPriority());
04589 return(1 || funcname || hash || result7 || libp) ;
04590 }
04591
04592 static int G__G__Ged_226_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04593 {
04594 G__letint(result7, 85, (long) ((TGedFrame*) G__getstructoffset())->GetExtraTabs());
04595 return(1 || funcname || hash || result7 || libp) ;
04596 }
04597
04598 static int G__G__Ged_226_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04599 {
04600 G__letint(result7, 85, (long) ((TGedFrame*) G__getstructoffset())->GetGedEditor());
04601 return(1 || funcname || hash || result7 || libp) ;
04602 }
04603
04604 static int G__G__Ged_226_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04605 {
04606 ((TGedFrame*) G__getstructoffset())->AddExtraTab((TGedFrame::TGedSubFrame*) G__int(libp->para[0]));
04607 G__setnull(result7);
04608 return(1 || funcname || hash || result7 || libp) ;
04609 }
04610
04611 static int G__G__Ged_226_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04612 {
04613 G__letint(result7, 85, (long) ((TGedFrame*) G__getstructoffset())->CreateEditorTabSubFrame((const char*) G__int(libp->para[0])));
04614 return(1 || funcname || hash || result7 || libp) ;
04615 }
04616
04617 static int G__G__Ged_226_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04618 {
04619 ((TGedFrame*) G__getstructoffset())->Refresh((TObject*) G__int(libp->para[0]));
04620 G__setnull(result7);
04621 return(1 || funcname || hash || result7 || libp) ;
04622 }
04623
04624 static int G__G__Ged_226_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04625 {
04626 G__letint(result7, 103, (long) ((TGedFrame*) G__getstructoffset())->AcceptModel((TObject*) G__int(libp->para[0])));
04627 return(1 || funcname || hash || result7 || libp) ;
04628 }
04629
04630 static int G__G__Ged_226_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04631 {
04632 ((TGedFrame*) G__getstructoffset())->SetModelClass((TClass*) G__int(libp->para[0]));
04633 G__setnull(result7);
04634 return(1 || funcname || hash || result7 || libp) ;
04635 }
04636
04637 static int G__G__Ged_226_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04638 {
04639 ((TGedFrame*) G__getstructoffset())->SetModel((TObject*) G__int(libp->para[0]));
04640 G__setnull(result7);
04641 return(1 || funcname || hash || result7 || libp) ;
04642 }
04643
04644 static int G__G__Ged_226_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04645 {
04646 ((TGedFrame*) G__getstructoffset())->SetGedEditor((TGedEditor*) G__int(libp->para[0]));
04647 G__setnull(result7);
04648 return(1 || funcname || hash || result7 || libp) ;
04649 }
04650
04651 static int G__G__Ged_226_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04652 {
04653 ((TGedFrame*) G__getstructoffset())->ActivateBaseClassEditors((TClass*) G__int(libp->para[0]));
04654 G__setnull(result7);
04655 return(1 || funcname || hash || result7 || libp) ;
04656 }
04657
04658 static int G__G__Ged_226_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04659 {
04660 G__letint(result7, 85, (long) TGedFrame::Class());
04661 return(1 || funcname || hash || result7 || libp) ;
04662 }
04663
04664 static int G__G__Ged_226_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04665 {
04666 G__letint(result7, 67, (long) TGedFrame::Class_Name());
04667 return(1 || funcname || hash || result7 || libp) ;
04668 }
04669
04670 static int G__G__Ged_226_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04671 {
04672 G__letint(result7, 115, (long) TGedFrame::Class_Version());
04673 return(1 || funcname || hash || result7 || libp) ;
04674 }
04675
04676 static int G__G__Ged_226_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04677 {
04678 TGedFrame::Dictionary();
04679 G__setnull(result7);
04680 return(1 || funcname || hash || result7 || libp) ;
04681 }
04682
04683 static int G__G__Ged_226_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04684 {
04685 ((TGedFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04686 G__setnull(result7);
04687 return(1 || funcname || hash || result7 || libp) ;
04688 }
04689
04690 static int G__G__Ged_226_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04691 {
04692 G__letint(result7, 67, (long) TGedFrame::DeclFileName());
04693 return(1 || funcname || hash || result7 || libp) ;
04694 }
04695
04696 static int G__G__Ged_226_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04697 {
04698 G__letint(result7, 105, (long) TGedFrame::ImplFileLine());
04699 return(1 || funcname || hash || result7 || libp) ;
04700 }
04701
04702 static int G__G__Ged_226_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04703 {
04704 G__letint(result7, 67, (long) TGedFrame::ImplFileName());
04705 return(1 || funcname || hash || result7 || libp) ;
04706 }
04707
04708 static int G__G__Ged_226_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04709 {
04710 G__letint(result7, 105, (long) TGedFrame::DeclFileLine());
04711 return(1 || funcname || hash || result7 || libp) ;
04712 }
04713
04714
04715 typedef TGedFrame G__TTGedFrame;
04716 static int G__G__Ged_226_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04717 {
04718 char* gvp = (char*) G__getgvp();
04719 long soff = G__getstructoffset();
04720 int n = G__getaryconstruct();
04721
04722
04723
04724
04725
04726 if (!soff) {
04727 return(1);
04728 }
04729 if (n) {
04730 if (gvp == (char*)G__PVOID) {
04731 delete[] (TGedFrame*) soff;
04732 } else {
04733 G__setgvp((long) G__PVOID);
04734 for (int i = n - 1; i >= 0; --i) {
04735 ((TGedFrame*) (soff+(sizeof(TGedFrame)*i)))->~G__TTGedFrame();
04736 }
04737 G__setgvp((long)gvp);
04738 }
04739 } else {
04740 if (gvp == (char*)G__PVOID) {
04741 delete (TGedFrame*) soff;
04742 } else {
04743 G__setgvp((long) G__PVOID);
04744 ((TGedFrame*) (soff))->~G__TTGedFrame();
04745 G__setgvp((long)gvp);
04746 }
04747 }
04748 G__setnull(result7);
04749 return(1 || funcname || hash || result7 || libp) ;
04750 }
04751
04752
04753
04754 static int G__G__Ged_228_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04755 {
04756 TGedNameFrame* p = NULL;
04757 char* gvp = (char*) G__getgvp();
04758 switch (libp->paran) {
04759 case 5:
04760
04761 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04762 p = new TGedNameFrame(
04763 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04764 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
04765 , (Pixel_t) G__int(libp->para[4]));
04766 } else {
04767 p = new((void*) gvp) TGedNameFrame(
04768 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04769 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
04770 , (Pixel_t) G__int(libp->para[4]));
04771 }
04772 break;
04773 case 4:
04774
04775 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04776 p = new TGedNameFrame(
04777 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04778 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
04779 } else {
04780 p = new((void*) gvp) TGedNameFrame(
04781 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04782 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
04783 }
04784 break;
04785 case 3:
04786
04787 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04788 p = new TGedNameFrame(
04789 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04790 , (Int_t) G__int(libp->para[2]));
04791 } else {
04792 p = new((void*) gvp) TGedNameFrame(
04793 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04794 , (Int_t) G__int(libp->para[2]));
04795 }
04796 break;
04797 case 2:
04798
04799 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04800 p = new TGedNameFrame((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04801 } else {
04802 p = new((void*) gvp) TGedNameFrame((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04803 }
04804 break;
04805 case 1:
04806
04807 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04808 p = new TGedNameFrame((TGWindow*) G__int(libp->para[0]));
04809 } else {
04810 p = new((void*) gvp) TGedNameFrame((TGWindow*) G__int(libp->para[0]));
04811 }
04812 break;
04813 case 0:
04814 int n = G__getaryconstruct();
04815 if (n) {
04816 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04817 p = new TGedNameFrame[n];
04818 } else {
04819 p = new((void*) gvp) TGedNameFrame[n];
04820 }
04821 } else {
04822 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04823 p = new TGedNameFrame;
04824 } else {
04825 p = new((void*) gvp) TGedNameFrame;
04826 }
04827 }
04828 break;
04829 }
04830 result7->obj.i = (long) p;
04831 result7->ref = (long) p;
04832 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame));
04833 return(1 || funcname || hash || result7 || libp) ;
04834 }
04835
04836 static int G__G__Ged_228_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04837 {
04838 G__letint(result7, 85, (long) TGedNameFrame::Class());
04839 return(1 || funcname || hash || result7 || libp) ;
04840 }
04841
04842 static int G__G__Ged_228_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04843 {
04844 G__letint(result7, 67, (long) TGedNameFrame::Class_Name());
04845 return(1 || funcname || hash || result7 || libp) ;
04846 }
04847
04848 static int G__G__Ged_228_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04849 {
04850 G__letint(result7, 115, (long) TGedNameFrame::Class_Version());
04851 return(1 || funcname || hash || result7 || libp) ;
04852 }
04853
04854 static int G__G__Ged_228_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04855 {
04856 TGedNameFrame::Dictionary();
04857 G__setnull(result7);
04858 return(1 || funcname || hash || result7 || libp) ;
04859 }
04860
04861 static int G__G__Ged_228_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04862 {
04863 ((TGedNameFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04864 G__setnull(result7);
04865 return(1 || funcname || hash || result7 || libp) ;
04866 }
04867
04868 static int G__G__Ged_228_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04869 {
04870 G__letint(result7, 67, (long) TGedNameFrame::DeclFileName());
04871 return(1 || funcname || hash || result7 || libp) ;
04872 }
04873
04874 static int G__G__Ged_228_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04875 {
04876 G__letint(result7, 105, (long) TGedNameFrame::ImplFileLine());
04877 return(1 || funcname || hash || result7 || libp) ;
04878 }
04879
04880 static int G__G__Ged_228_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04881 {
04882 G__letint(result7, 67, (long) TGedNameFrame::ImplFileName());
04883 return(1 || funcname || hash || result7 || libp) ;
04884 }
04885
04886 static int G__G__Ged_228_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04887 {
04888 G__letint(result7, 105, (long) TGedNameFrame::DeclFileLine());
04889 return(1 || funcname || hash || result7 || libp) ;
04890 }
04891
04892
04893 typedef TGedNameFrame G__TTGedNameFrame;
04894 static int G__G__Ged_228_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04895 {
04896 char* gvp = (char*) G__getgvp();
04897 long soff = G__getstructoffset();
04898 int n = G__getaryconstruct();
04899
04900
04901
04902
04903
04904 if (!soff) {
04905 return(1);
04906 }
04907 if (n) {
04908 if (gvp == (char*)G__PVOID) {
04909 delete[] (TGedNameFrame*) soff;
04910 } else {
04911 G__setgvp((long) G__PVOID);
04912 for (int i = n - 1; i >= 0; --i) {
04913 ((TGedNameFrame*) (soff+(sizeof(TGedNameFrame)*i)))->~G__TTGedNameFrame();
04914 }
04915 G__setgvp((long)gvp);
04916 }
04917 } else {
04918 if (gvp == (char*)G__PVOID) {
04919 delete (TGedNameFrame*) soff;
04920 } else {
04921 G__setgvp((long) G__PVOID);
04922 ((TGedNameFrame*) (soff))->~G__TTGedNameFrame();
04923 G__setgvp((long)gvp);
04924 }
04925 }
04926 G__setnull(result7);
04927 return(1 || funcname || hash || result7 || libp) ;
04928 }
04929
04930
04931
04932 static int G__G__Ged_232_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04933 {
04934 TArrowEditor* p = NULL;
04935 char* gvp = (char*) G__getgvp();
04936 switch (libp->paran) {
04937 case 5:
04938
04939 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04940 p = new TArrowEditor(
04941 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04942 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
04943 , (Pixel_t) G__int(libp->para[4]));
04944 } else {
04945 p = new((void*) gvp) TArrowEditor(
04946 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04947 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
04948 , (Pixel_t) G__int(libp->para[4]));
04949 }
04950 break;
04951 case 4:
04952
04953 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04954 p = new TArrowEditor(
04955 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04956 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
04957 } else {
04958 p = new((void*) gvp) TArrowEditor(
04959 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04960 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
04961 }
04962 break;
04963 case 3:
04964
04965 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04966 p = new TArrowEditor(
04967 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04968 , (Int_t) G__int(libp->para[2]));
04969 } else {
04970 p = new((void*) gvp) TArrowEditor(
04971 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04972 , (Int_t) G__int(libp->para[2]));
04973 }
04974 break;
04975 case 2:
04976
04977 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04978 p = new TArrowEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04979 } else {
04980 p = new((void*) gvp) TArrowEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04981 }
04982 break;
04983 case 1:
04984
04985 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04986 p = new TArrowEditor((TGWindow*) G__int(libp->para[0]));
04987 } else {
04988 p = new((void*) gvp) TArrowEditor((TGWindow*) G__int(libp->para[0]));
04989 }
04990 break;
04991 case 0:
04992 int n = G__getaryconstruct();
04993 if (n) {
04994 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04995 p = new TArrowEditor[n];
04996 } else {
04997 p = new((void*) gvp) TArrowEditor[n];
04998 }
04999 } else {
05000 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05001 p = new TArrowEditor;
05002 } else {
05003 p = new((void*) gvp) TArrowEditor;
05004 }
05005 }
05006 break;
05007 }
05008 result7->obj.i = (long) p;
05009 result7->ref = (long) p;
05010 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TArrowEditor));
05011 return(1 || funcname || hash || result7 || libp) ;
05012 }
05013
05014 static int G__G__Ged_232_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05015 {
05016 ((TArrowEditor*) G__getstructoffset())->DoAngle();
05017 G__setnull(result7);
05018 return(1 || funcname || hash || result7 || libp) ;
05019 }
05020
05021 static int G__G__Ged_232_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05022 {
05023 ((TArrowEditor*) G__getstructoffset())->DoOption((Int_t) G__int(libp->para[0]));
05024 G__setnull(result7);
05025 return(1 || funcname || hash || result7 || libp) ;
05026 }
05027
05028 static int G__G__Ged_232_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05029 {
05030 ((TArrowEditor*) G__getstructoffset())->DoSize();
05031 G__setnull(result7);
05032 return(1 || funcname || hash || result7 || libp) ;
05033 }
05034
05035 static int G__G__Ged_232_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05036 {
05037 G__letint(result7, 85, (long) TArrowEditor::Class());
05038 return(1 || funcname || hash || result7 || libp) ;
05039 }
05040
05041 static int G__G__Ged_232_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05042 {
05043 G__letint(result7, 67, (long) TArrowEditor::Class_Name());
05044 return(1 || funcname || hash || result7 || libp) ;
05045 }
05046
05047 static int G__G__Ged_232_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05048 {
05049 G__letint(result7, 115, (long) TArrowEditor::Class_Version());
05050 return(1 || funcname || hash || result7 || libp) ;
05051 }
05052
05053 static int G__G__Ged_232_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05054 {
05055 TArrowEditor::Dictionary();
05056 G__setnull(result7);
05057 return(1 || funcname || hash || result7 || libp) ;
05058 }
05059
05060 static int G__G__Ged_232_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05061 {
05062 ((TArrowEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05063 G__setnull(result7);
05064 return(1 || funcname || hash || result7 || libp) ;
05065 }
05066
05067 static int G__G__Ged_232_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05068 {
05069 G__letint(result7, 67, (long) TArrowEditor::DeclFileName());
05070 return(1 || funcname || hash || result7 || libp) ;
05071 }
05072
05073 static int G__G__Ged_232_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05074 {
05075 G__letint(result7, 105, (long) TArrowEditor::ImplFileLine());
05076 return(1 || funcname || hash || result7 || libp) ;
05077 }
05078
05079 static int G__G__Ged_232_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05080 {
05081 G__letint(result7, 67, (long) TArrowEditor::ImplFileName());
05082 return(1 || funcname || hash || result7 || libp) ;
05083 }
05084
05085 static int G__G__Ged_232_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05086 {
05087 G__letint(result7, 105, (long) TArrowEditor::DeclFileLine());
05088 return(1 || funcname || hash || result7 || libp) ;
05089 }
05090
05091
05092 typedef TArrowEditor G__TTArrowEditor;
05093 static int G__G__Ged_232_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05094 {
05095 char* gvp = (char*) G__getgvp();
05096 long soff = G__getstructoffset();
05097 int n = G__getaryconstruct();
05098
05099
05100
05101
05102
05103 if (!soff) {
05104 return(1);
05105 }
05106 if (n) {
05107 if (gvp == (char*)G__PVOID) {
05108 delete[] (TArrowEditor*) soff;
05109 } else {
05110 G__setgvp((long) G__PVOID);
05111 for (int i = n - 1; i >= 0; --i) {
05112 ((TArrowEditor*) (soff+(sizeof(TArrowEditor)*i)))->~G__TTArrowEditor();
05113 }
05114 G__setgvp((long)gvp);
05115 }
05116 } else {
05117 if (gvp == (char*)G__PVOID) {
05118 delete (TArrowEditor*) soff;
05119 } else {
05120 G__setgvp((long) G__PVOID);
05121 ((TArrowEditor*) (soff))->~G__TTArrowEditor();
05122 G__setgvp((long)gvp);
05123 }
05124 }
05125 G__setnull(result7);
05126 return(1 || funcname || hash || result7 || libp) ;
05127 }
05128
05129
05130
05131 static int G__G__Ged_234_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05132 {
05133 TGedPatternSelect* p = NULL;
05134 char* gvp = (char*) G__getgvp();
05135
05136 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05137 p = new TGedPatternSelect(
05138 (TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
05139 , (Int_t) G__int(libp->para[2]));
05140 } else {
05141 p = new((void*) gvp) TGedPatternSelect(
05142 (TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
05143 , (Int_t) G__int(libp->para[2]));
05144 }
05145 result7->obj.i = (long) p;
05146 result7->ref = (long) p;
05147 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect));
05148 return(1 || funcname || hash || result7 || libp) ;
05149 }
05150
05151 static int G__G__Ged_234_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05152 {
05153 switch (libp->paran) {
05154 case 2:
05155 ((TGedPatternSelect*) G__getstructoffset())->SetPattern((Style_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05156 G__setnull(result7);
05157 break;
05158 case 1:
05159 ((TGedPatternSelect*) G__getstructoffset())->SetPattern((Style_t) G__int(libp->para[0]));
05160 G__setnull(result7);
05161 break;
05162 }
05163 return(1 || funcname || hash || result7 || libp) ;
05164 }
05165
05166 static int G__G__Ged_234_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05167 {
05168 G__letint(result7, 115, (long) ((const TGedPatternSelect*) G__getstructoffset())->GetPattern());
05169 return(1 || funcname || hash || result7 || libp) ;
05170 }
05171
05172 static int G__G__Ged_234_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05173 {
05174 switch (libp->paran) {
05175 case 1:
05176 ((TGedPatternSelect*) G__getstructoffset())->PatternSelected((Style_t) G__int(libp->para[0]));
05177 G__setnull(result7);
05178 break;
05179 case 0:
05180 ((TGedPatternSelect*) G__getstructoffset())->PatternSelected();
05181 G__setnull(result7);
05182 break;
05183 }
05184 return(1 || funcname || hash || result7 || libp) ;
05185 }
05186
05187 static int G__G__Ged_234_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05188 {
05189 G__letint(result7, 85, (long) TGedPatternSelect::Class());
05190 return(1 || funcname || hash || result7 || libp) ;
05191 }
05192
05193 static int G__G__Ged_234_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05194 {
05195 G__letint(result7, 67, (long) TGedPatternSelect::Class_Name());
05196 return(1 || funcname || hash || result7 || libp) ;
05197 }
05198
05199 static int G__G__Ged_234_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05200 {
05201 G__letint(result7, 115, (long) TGedPatternSelect::Class_Version());
05202 return(1 || funcname || hash || result7 || libp) ;
05203 }
05204
05205 static int G__G__Ged_234_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05206 {
05207 TGedPatternSelect::Dictionary();
05208 G__setnull(result7);
05209 return(1 || funcname || hash || result7 || libp) ;
05210 }
05211
05212 static int G__G__Ged_234_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05213 {
05214 ((TGedPatternSelect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05215 G__setnull(result7);
05216 return(1 || funcname || hash || result7 || libp) ;
05217 }
05218
05219 static int G__G__Ged_234_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05220 {
05221 G__letint(result7, 67, (long) TGedPatternSelect::DeclFileName());
05222 return(1 || funcname || hash || result7 || libp) ;
05223 }
05224
05225 static int G__G__Ged_234_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05226 {
05227 G__letint(result7, 105, (long) TGedPatternSelect::ImplFileLine());
05228 return(1 || funcname || hash || result7 || libp) ;
05229 }
05230
05231 static int G__G__Ged_234_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05232 {
05233 G__letint(result7, 67, (long) TGedPatternSelect::ImplFileName());
05234 return(1 || funcname || hash || result7 || libp) ;
05235 }
05236
05237 static int G__G__Ged_234_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05238 {
05239 G__letint(result7, 105, (long) TGedPatternSelect::DeclFileLine());
05240 return(1 || funcname || hash || result7 || libp) ;
05241 }
05242
05243
05244 typedef TGedPatternSelect G__TTGedPatternSelect;
05245 static int G__G__Ged_234_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05246 {
05247 char* gvp = (char*) G__getgvp();
05248 long soff = G__getstructoffset();
05249 int n = G__getaryconstruct();
05250
05251
05252
05253
05254
05255 if (!soff) {
05256 return(1);
05257 }
05258 if (n) {
05259 if (gvp == (char*)G__PVOID) {
05260 delete[] (TGedPatternSelect*) soff;
05261 } else {
05262 G__setgvp((long) G__PVOID);
05263 for (int i = n - 1; i >= 0; --i) {
05264 ((TGedPatternSelect*) (soff+(sizeof(TGedPatternSelect)*i)))->~G__TTGedPatternSelect();
05265 }
05266 G__setgvp((long)gvp);
05267 }
05268 } else {
05269 if (gvp == (char*)G__PVOID) {
05270 delete (TGedPatternSelect*) soff;
05271 } else {
05272 G__setgvp((long) G__PVOID);
05273 ((TGedPatternSelect*) (soff))->~G__TTGedPatternSelect();
05274 G__setgvp((long)gvp);
05275 }
05276 }
05277 G__setnull(result7);
05278 return(1 || funcname || hash || result7 || libp) ;
05279 }
05280
05281
05282
05283 static int G__G__Ged_235_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05284 {
05285 TAttFillEditor* p = NULL;
05286 char* gvp = (char*) G__getgvp();
05287 switch (libp->paran) {
05288 case 5:
05289
05290 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05291 p = new TAttFillEditor(
05292 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05293 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05294 , (Pixel_t) G__int(libp->para[4]));
05295 } else {
05296 p = new((void*) gvp) TAttFillEditor(
05297 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05298 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05299 , (Pixel_t) G__int(libp->para[4]));
05300 }
05301 break;
05302 case 4:
05303
05304 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05305 p = new TAttFillEditor(
05306 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05307 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05308 } else {
05309 p = new((void*) gvp) TAttFillEditor(
05310 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05311 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05312 }
05313 break;
05314 case 3:
05315
05316 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05317 p = new TAttFillEditor(
05318 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05319 , (Int_t) G__int(libp->para[2]));
05320 } else {
05321 p = new((void*) gvp) TAttFillEditor(
05322 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05323 , (Int_t) G__int(libp->para[2]));
05324 }
05325 break;
05326 case 2:
05327
05328 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05329 p = new TAttFillEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05330 } else {
05331 p = new((void*) gvp) TAttFillEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05332 }
05333 break;
05334 case 1:
05335
05336 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05337 p = new TAttFillEditor((TGWindow*) G__int(libp->para[0]));
05338 } else {
05339 p = new((void*) gvp) TAttFillEditor((TGWindow*) G__int(libp->para[0]));
05340 }
05341 break;
05342 case 0:
05343 int n = G__getaryconstruct();
05344 if (n) {
05345 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05346 p = new TAttFillEditor[n];
05347 } else {
05348 p = new((void*) gvp) TAttFillEditor[n];
05349 }
05350 } else {
05351 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05352 p = new TAttFillEditor;
05353 } else {
05354 p = new((void*) gvp) TAttFillEditor;
05355 }
05356 }
05357 break;
05358 }
05359 result7->obj.i = (long) p;
05360 result7->ref = (long) p;
05361 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor));
05362 return(1 || funcname || hash || result7 || libp) ;
05363 }
05364
05365 static int G__G__Ged_235_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05366 {
05367 ((TAttFillEditor*) G__getstructoffset())->DoFillColor((Pixel_t) G__int(libp->para[0]));
05368 G__setnull(result7);
05369 return(1 || funcname || hash || result7 || libp) ;
05370 }
05371
05372 static int G__G__Ged_235_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05373 {
05374 ((TAttFillEditor*) G__getstructoffset())->DoFillPattern((Style_t) G__int(libp->para[0]));
05375 G__setnull(result7);
05376 return(1 || funcname || hash || result7 || libp) ;
05377 }
05378
05379 static int G__G__Ged_235_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05380 {
05381 G__letint(result7, 85, (long) TAttFillEditor::Class());
05382 return(1 || funcname || hash || result7 || libp) ;
05383 }
05384
05385 static int G__G__Ged_235_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05386 {
05387 G__letint(result7, 67, (long) TAttFillEditor::Class_Name());
05388 return(1 || funcname || hash || result7 || libp) ;
05389 }
05390
05391 static int G__G__Ged_235_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05392 {
05393 G__letint(result7, 115, (long) TAttFillEditor::Class_Version());
05394 return(1 || funcname || hash || result7 || libp) ;
05395 }
05396
05397 static int G__G__Ged_235_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05398 {
05399 TAttFillEditor::Dictionary();
05400 G__setnull(result7);
05401 return(1 || funcname || hash || result7 || libp) ;
05402 }
05403
05404 static int G__G__Ged_235_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05405 {
05406 ((TAttFillEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05407 G__setnull(result7);
05408 return(1 || funcname || hash || result7 || libp) ;
05409 }
05410
05411 static int G__G__Ged_235_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05412 {
05413 G__letint(result7, 67, (long) TAttFillEditor::DeclFileName());
05414 return(1 || funcname || hash || result7 || libp) ;
05415 }
05416
05417 static int G__G__Ged_235_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05418 {
05419 G__letint(result7, 105, (long) TAttFillEditor::ImplFileLine());
05420 return(1 || funcname || hash || result7 || libp) ;
05421 }
05422
05423 static int G__G__Ged_235_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05424 {
05425 G__letint(result7, 67, (long) TAttFillEditor::ImplFileName());
05426 return(1 || funcname || hash || result7 || libp) ;
05427 }
05428
05429 static int G__G__Ged_235_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05430 {
05431 G__letint(result7, 105, (long) TAttFillEditor::DeclFileLine());
05432 return(1 || funcname || hash || result7 || libp) ;
05433 }
05434
05435
05436 typedef TAttFillEditor G__TTAttFillEditor;
05437 static int G__G__Ged_235_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05438 {
05439 char* gvp = (char*) G__getgvp();
05440 long soff = G__getstructoffset();
05441 int n = G__getaryconstruct();
05442
05443
05444
05445
05446
05447 if (!soff) {
05448 return(1);
05449 }
05450 if (n) {
05451 if (gvp == (char*)G__PVOID) {
05452 delete[] (TAttFillEditor*) soff;
05453 } else {
05454 G__setgvp((long) G__PVOID);
05455 for (int i = n - 1; i >= 0; --i) {
05456 ((TAttFillEditor*) (soff+(sizeof(TAttFillEditor)*i)))->~G__TTAttFillEditor();
05457 }
05458 G__setgvp((long)gvp);
05459 }
05460 } else {
05461 if (gvp == (char*)G__PVOID) {
05462 delete (TAttFillEditor*) soff;
05463 } else {
05464 G__setgvp((long) G__PVOID);
05465 ((TAttFillEditor*) (soff))->~G__TTAttFillEditor();
05466 G__setgvp((long)gvp);
05467 }
05468 }
05469 G__setnull(result7);
05470 return(1 || funcname || hash || result7 || libp) ;
05471 }
05472
05473
05474
05475 static int G__G__Ged_238_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05476 {
05477 TAttLineEditor* p = NULL;
05478 char* gvp = (char*) G__getgvp();
05479 switch (libp->paran) {
05480 case 5:
05481
05482 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05483 p = new TAttLineEditor(
05484 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05485 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05486 , (Pixel_t) G__int(libp->para[4]));
05487 } else {
05488 p = new((void*) gvp) TAttLineEditor(
05489 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05490 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05491 , (Pixel_t) G__int(libp->para[4]));
05492 }
05493 break;
05494 case 4:
05495
05496 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05497 p = new TAttLineEditor(
05498 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05499 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05500 } else {
05501 p = new((void*) gvp) TAttLineEditor(
05502 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05503 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05504 }
05505 break;
05506 case 3:
05507
05508 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05509 p = new TAttLineEditor(
05510 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05511 , (Int_t) G__int(libp->para[2]));
05512 } else {
05513 p = new((void*) gvp) TAttLineEditor(
05514 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05515 , (Int_t) G__int(libp->para[2]));
05516 }
05517 break;
05518 case 2:
05519
05520 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05521 p = new TAttLineEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05522 } else {
05523 p = new((void*) gvp) TAttLineEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05524 }
05525 break;
05526 case 1:
05527
05528 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05529 p = new TAttLineEditor((TGWindow*) G__int(libp->para[0]));
05530 } else {
05531 p = new((void*) gvp) TAttLineEditor((TGWindow*) G__int(libp->para[0]));
05532 }
05533 break;
05534 case 0:
05535 int n = G__getaryconstruct();
05536 if (n) {
05537 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05538 p = new TAttLineEditor[n];
05539 } else {
05540 p = new((void*) gvp) TAttLineEditor[n];
05541 }
05542 } else {
05543 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05544 p = new TAttLineEditor;
05545 } else {
05546 p = new((void*) gvp) TAttLineEditor;
05547 }
05548 }
05549 break;
05550 }
05551 result7->obj.i = (long) p;
05552 result7->ref = (long) p;
05553 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor));
05554 return(1 || funcname || hash || result7 || libp) ;
05555 }
05556
05557 static int G__G__Ged_238_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05558 {
05559 ((TAttLineEditor*) G__getstructoffset())->DoLineColor((Pixel_t) G__int(libp->para[0]));
05560 G__setnull(result7);
05561 return(1 || funcname || hash || result7 || libp) ;
05562 }
05563
05564 static int G__G__Ged_238_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05565 {
05566 ((TAttLineEditor*) G__getstructoffset())->DoLineStyle((Int_t) G__int(libp->para[0]));
05567 G__setnull(result7);
05568 return(1 || funcname || hash || result7 || libp) ;
05569 }
05570
05571 static int G__G__Ged_238_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05572 {
05573 ((TAttLineEditor*) G__getstructoffset())->DoLineWidth((Int_t) G__int(libp->para[0]));
05574 G__setnull(result7);
05575 return(1 || funcname || hash || result7 || libp) ;
05576 }
05577
05578 static int G__G__Ged_238_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05579 {
05580 G__letint(result7, 85, (long) TAttLineEditor::Class());
05581 return(1 || funcname || hash || result7 || libp) ;
05582 }
05583
05584 static int G__G__Ged_238_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05585 {
05586 G__letint(result7, 67, (long) TAttLineEditor::Class_Name());
05587 return(1 || funcname || hash || result7 || libp) ;
05588 }
05589
05590 static int G__G__Ged_238_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05591 {
05592 G__letint(result7, 115, (long) TAttLineEditor::Class_Version());
05593 return(1 || funcname || hash || result7 || libp) ;
05594 }
05595
05596 static int G__G__Ged_238_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05597 {
05598 TAttLineEditor::Dictionary();
05599 G__setnull(result7);
05600 return(1 || funcname || hash || result7 || libp) ;
05601 }
05602
05603 static int G__G__Ged_238_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05604 {
05605 ((TAttLineEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05606 G__setnull(result7);
05607 return(1 || funcname || hash || result7 || libp) ;
05608 }
05609
05610 static int G__G__Ged_238_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05611 {
05612 G__letint(result7, 67, (long) TAttLineEditor::DeclFileName());
05613 return(1 || funcname || hash || result7 || libp) ;
05614 }
05615
05616 static int G__G__Ged_238_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05617 {
05618 G__letint(result7, 105, (long) TAttLineEditor::ImplFileLine());
05619 return(1 || funcname || hash || result7 || libp) ;
05620 }
05621
05622 static int G__G__Ged_238_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05623 {
05624 G__letint(result7, 67, (long) TAttLineEditor::ImplFileName());
05625 return(1 || funcname || hash || result7 || libp) ;
05626 }
05627
05628 static int G__G__Ged_238_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05629 {
05630 G__letint(result7, 105, (long) TAttLineEditor::DeclFileLine());
05631 return(1 || funcname || hash || result7 || libp) ;
05632 }
05633
05634
05635 typedef TAttLineEditor G__TTAttLineEditor;
05636 static int G__G__Ged_238_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05637 {
05638 char* gvp = (char*) G__getgvp();
05639 long soff = G__getstructoffset();
05640 int n = G__getaryconstruct();
05641
05642
05643
05644
05645
05646 if (!soff) {
05647 return(1);
05648 }
05649 if (n) {
05650 if (gvp == (char*)G__PVOID) {
05651 delete[] (TAttLineEditor*) soff;
05652 } else {
05653 G__setgvp((long) G__PVOID);
05654 for (int i = n - 1; i >= 0; --i) {
05655 ((TAttLineEditor*) (soff+(sizeof(TAttLineEditor)*i)))->~G__TTAttLineEditor();
05656 }
05657 G__setgvp((long)gvp);
05658 }
05659 } else {
05660 if (gvp == (char*)G__PVOID) {
05661 delete (TAttLineEditor*) soff;
05662 } else {
05663 G__setgvp((long) G__PVOID);
05664 ((TAttLineEditor*) (soff))->~G__TTAttLineEditor();
05665 G__setgvp((long)gvp);
05666 }
05667 }
05668 G__setnull(result7);
05669 return(1 || funcname || hash || result7 || libp) ;
05670 }
05671
05672
05673
05674 static int G__G__Ged_239_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05675 {
05676 TGedMarkerSelect* p = NULL;
05677 char* gvp = (char*) G__getgvp();
05678
05679 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05680 p = new TGedMarkerSelect(
05681 (TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
05682 , (Int_t) G__int(libp->para[2]));
05683 } else {
05684 p = new((void*) gvp) TGedMarkerSelect(
05685 (TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
05686 , (Int_t) G__int(libp->para[2]));
05687 }
05688 result7->obj.i = (long) p;
05689 result7->ref = (long) p;
05690 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect));
05691 return(1 || funcname || hash || result7 || libp) ;
05692 }
05693
05694 static int G__G__Ged_239_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05695 {
05696 G__letint(result7, 115, (long) ((const TGedMarkerSelect*) G__getstructoffset())->GetMarkerStyle());
05697 return(1 || funcname || hash || result7 || libp) ;
05698 }
05699
05700 static int G__G__Ged_239_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05701 {
05702 ((TGedMarkerSelect*) G__getstructoffset())->SetMarkerStyle((Style_t) G__int(libp->para[0]));
05703 G__setnull(result7);
05704 return(1 || funcname || hash || result7 || libp) ;
05705 }
05706
05707 static int G__G__Ged_239_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05708 {
05709 switch (libp->paran) {
05710 case 1:
05711 ((TGedMarkerSelect*) G__getstructoffset())->MarkerSelected((Style_t) G__int(libp->para[0]));
05712 G__setnull(result7);
05713 break;
05714 case 0:
05715 ((TGedMarkerSelect*) G__getstructoffset())->MarkerSelected();
05716 G__setnull(result7);
05717 break;
05718 }
05719 return(1 || funcname || hash || result7 || libp) ;
05720 }
05721
05722 static int G__G__Ged_239_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05723 {
05724 G__letint(result7, 85, (long) TGedMarkerSelect::Class());
05725 return(1 || funcname || hash || result7 || libp) ;
05726 }
05727
05728 static int G__G__Ged_239_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05729 {
05730 G__letint(result7, 67, (long) TGedMarkerSelect::Class_Name());
05731 return(1 || funcname || hash || result7 || libp) ;
05732 }
05733
05734 static int G__G__Ged_239_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05735 {
05736 G__letint(result7, 115, (long) TGedMarkerSelect::Class_Version());
05737 return(1 || funcname || hash || result7 || libp) ;
05738 }
05739
05740 static int G__G__Ged_239_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05741 {
05742 TGedMarkerSelect::Dictionary();
05743 G__setnull(result7);
05744 return(1 || funcname || hash || result7 || libp) ;
05745 }
05746
05747 static int G__G__Ged_239_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05748 {
05749 ((TGedMarkerSelect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05750 G__setnull(result7);
05751 return(1 || funcname || hash || result7 || libp) ;
05752 }
05753
05754 static int G__G__Ged_239_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05755 {
05756 G__letint(result7, 67, (long) TGedMarkerSelect::DeclFileName());
05757 return(1 || funcname || hash || result7 || libp) ;
05758 }
05759
05760 static int G__G__Ged_239_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05761 {
05762 G__letint(result7, 105, (long) TGedMarkerSelect::ImplFileLine());
05763 return(1 || funcname || hash || result7 || libp) ;
05764 }
05765
05766 static int G__G__Ged_239_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05767 {
05768 G__letint(result7, 67, (long) TGedMarkerSelect::ImplFileName());
05769 return(1 || funcname || hash || result7 || libp) ;
05770 }
05771
05772 static int G__G__Ged_239_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05773 {
05774 G__letint(result7, 105, (long) TGedMarkerSelect::DeclFileLine());
05775 return(1 || funcname || hash || result7 || libp) ;
05776 }
05777
05778
05779 typedef TGedMarkerSelect G__TTGedMarkerSelect;
05780 static int G__G__Ged_239_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05781 {
05782 char* gvp = (char*) G__getgvp();
05783 long soff = G__getstructoffset();
05784 int n = G__getaryconstruct();
05785
05786
05787
05788
05789
05790 if (!soff) {
05791 return(1);
05792 }
05793 if (n) {
05794 if (gvp == (char*)G__PVOID) {
05795 delete[] (TGedMarkerSelect*) soff;
05796 } else {
05797 G__setgvp((long) G__PVOID);
05798 for (int i = n - 1; i >= 0; --i) {
05799 ((TGedMarkerSelect*) (soff+(sizeof(TGedMarkerSelect)*i)))->~G__TTGedMarkerSelect();
05800 }
05801 G__setgvp((long)gvp);
05802 }
05803 } else {
05804 if (gvp == (char*)G__PVOID) {
05805 delete (TGedMarkerSelect*) soff;
05806 } else {
05807 G__setgvp((long) G__PVOID);
05808 ((TGedMarkerSelect*) (soff))->~G__TTGedMarkerSelect();
05809 G__setgvp((long)gvp);
05810 }
05811 }
05812 G__setnull(result7);
05813 return(1 || funcname || hash || result7 || libp) ;
05814 }
05815
05816
05817
05818 static int G__G__Ged_240_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05819 {
05820 TAttMarkerEditor* p = NULL;
05821 char* gvp = (char*) G__getgvp();
05822 switch (libp->paran) {
05823 case 5:
05824
05825 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05826 p = new TAttMarkerEditor(
05827 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05828 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05829 , (Pixel_t) G__int(libp->para[4]));
05830 } else {
05831 p = new((void*) gvp) TAttMarkerEditor(
05832 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05833 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05834 , (Pixel_t) G__int(libp->para[4]));
05835 }
05836 break;
05837 case 4:
05838
05839 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05840 p = new TAttMarkerEditor(
05841 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05842 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05843 } else {
05844 p = new((void*) gvp) TAttMarkerEditor(
05845 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05846 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
05847 }
05848 break;
05849 case 3:
05850
05851 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05852 p = new TAttMarkerEditor(
05853 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05854 , (Int_t) G__int(libp->para[2]));
05855 } else {
05856 p = new((void*) gvp) TAttMarkerEditor(
05857 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05858 , (Int_t) G__int(libp->para[2]));
05859 }
05860 break;
05861 case 2:
05862
05863 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05864 p = new TAttMarkerEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05865 } else {
05866 p = new((void*) gvp) TAttMarkerEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05867 }
05868 break;
05869 case 1:
05870
05871 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05872 p = new TAttMarkerEditor((TGWindow*) G__int(libp->para[0]));
05873 } else {
05874 p = new((void*) gvp) TAttMarkerEditor((TGWindow*) G__int(libp->para[0]));
05875 }
05876 break;
05877 case 0:
05878 int n = G__getaryconstruct();
05879 if (n) {
05880 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05881 p = new TAttMarkerEditor[n];
05882 } else {
05883 p = new((void*) gvp) TAttMarkerEditor[n];
05884 }
05885 } else {
05886 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05887 p = new TAttMarkerEditor;
05888 } else {
05889 p = new((void*) gvp) TAttMarkerEditor;
05890 }
05891 }
05892 break;
05893 }
05894 result7->obj.i = (long) p;
05895 result7->ref = (long) p;
05896 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor));
05897 return(1 || funcname || hash || result7 || libp) ;
05898 }
05899
05900 static int G__G__Ged_240_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05901 {
05902 ((TAttMarkerEditor*) G__getstructoffset())->DoMarkerColor((Pixel_t) G__int(libp->para[0]));
05903 G__setnull(result7);
05904 return(1 || funcname || hash || result7 || libp) ;
05905 }
05906
05907 static int G__G__Ged_240_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05908 {
05909 ((TAttMarkerEditor*) G__getstructoffset())->DoMarkerSize();
05910 G__setnull(result7);
05911 return(1 || funcname || hash || result7 || libp) ;
05912 }
05913
05914 static int G__G__Ged_240_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05915 {
05916 ((TAttMarkerEditor*) G__getstructoffset())->DoMarkerStyle((Style_t) G__int(libp->para[0]));
05917 G__setnull(result7);
05918 return(1 || funcname || hash || result7 || libp) ;
05919 }
05920
05921 static int G__G__Ged_240_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05922 {
05923 G__letint(result7, 85, (long) TAttMarkerEditor::Class());
05924 return(1 || funcname || hash || result7 || libp) ;
05925 }
05926
05927 static int G__G__Ged_240_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05928 {
05929 G__letint(result7, 67, (long) TAttMarkerEditor::Class_Name());
05930 return(1 || funcname || hash || result7 || libp) ;
05931 }
05932
05933 static int G__G__Ged_240_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05934 {
05935 G__letint(result7, 115, (long) TAttMarkerEditor::Class_Version());
05936 return(1 || funcname || hash || result7 || libp) ;
05937 }
05938
05939 static int G__G__Ged_240_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05940 {
05941 TAttMarkerEditor::Dictionary();
05942 G__setnull(result7);
05943 return(1 || funcname || hash || result7 || libp) ;
05944 }
05945
05946 static int G__G__Ged_240_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05947 {
05948 ((TAttMarkerEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05949 G__setnull(result7);
05950 return(1 || funcname || hash || result7 || libp) ;
05951 }
05952
05953 static int G__G__Ged_240_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05954 {
05955 G__letint(result7, 67, (long) TAttMarkerEditor::DeclFileName());
05956 return(1 || funcname || hash || result7 || libp) ;
05957 }
05958
05959 static int G__G__Ged_240_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05960 {
05961 G__letint(result7, 105, (long) TAttMarkerEditor::ImplFileLine());
05962 return(1 || funcname || hash || result7 || libp) ;
05963 }
05964
05965 static int G__G__Ged_240_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05966 {
05967 G__letint(result7, 67, (long) TAttMarkerEditor::ImplFileName());
05968 return(1 || funcname || hash || result7 || libp) ;
05969 }
05970
05971 static int G__G__Ged_240_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05972 {
05973 G__letint(result7, 105, (long) TAttMarkerEditor::DeclFileLine());
05974 return(1 || funcname || hash || result7 || libp) ;
05975 }
05976
05977
05978 typedef TAttMarkerEditor G__TTAttMarkerEditor;
05979 static int G__G__Ged_240_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05980 {
05981 char* gvp = (char*) G__getgvp();
05982 long soff = G__getstructoffset();
05983 int n = G__getaryconstruct();
05984
05985
05986
05987
05988
05989 if (!soff) {
05990 return(1);
05991 }
05992 if (n) {
05993 if (gvp == (char*)G__PVOID) {
05994 delete[] (TAttMarkerEditor*) soff;
05995 } else {
05996 G__setgvp((long) G__PVOID);
05997 for (int i = n - 1; i >= 0; --i) {
05998 ((TAttMarkerEditor*) (soff+(sizeof(TAttMarkerEditor)*i)))->~G__TTAttMarkerEditor();
05999 }
06000 G__setgvp((long)gvp);
06001 }
06002 } else {
06003 if (gvp == (char*)G__PVOID) {
06004 delete (TAttMarkerEditor*) soff;
06005 } else {
06006 G__setgvp((long) G__PVOID);
06007 ((TAttMarkerEditor*) (soff))->~G__TTAttMarkerEditor();
06008 G__setgvp((long)gvp);
06009 }
06010 }
06011 G__setnull(result7);
06012 return(1 || funcname || hash || result7 || libp) ;
06013 }
06014
06015
06016
06017 static int G__G__Ged_242_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06018 {
06019 TAttTextEditor* p = NULL;
06020 char* gvp = (char*) G__getgvp();
06021 switch (libp->paran) {
06022 case 5:
06023
06024 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06025 p = new TAttTextEditor(
06026 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06027 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06028 , (Pixel_t) G__int(libp->para[4]));
06029 } else {
06030 p = new((void*) gvp) TAttTextEditor(
06031 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06032 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06033 , (Pixel_t) G__int(libp->para[4]));
06034 }
06035 break;
06036 case 4:
06037
06038 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06039 p = new TAttTextEditor(
06040 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06041 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06042 } else {
06043 p = new((void*) gvp) TAttTextEditor(
06044 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06045 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06046 }
06047 break;
06048 case 3:
06049
06050 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06051 p = new TAttTextEditor(
06052 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06053 , (Int_t) G__int(libp->para[2]));
06054 } else {
06055 p = new((void*) gvp) TAttTextEditor(
06056 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06057 , (Int_t) G__int(libp->para[2]));
06058 }
06059 break;
06060 case 2:
06061
06062 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06063 p = new TAttTextEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06064 } else {
06065 p = new((void*) gvp) TAttTextEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06066 }
06067 break;
06068 case 1:
06069
06070 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06071 p = new TAttTextEditor((TGWindow*) G__int(libp->para[0]));
06072 } else {
06073 p = new((void*) gvp) TAttTextEditor((TGWindow*) G__int(libp->para[0]));
06074 }
06075 break;
06076 case 0:
06077 int n = G__getaryconstruct();
06078 if (n) {
06079 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06080 p = new TAttTextEditor[n];
06081 } else {
06082 p = new((void*) gvp) TAttTextEditor[n];
06083 }
06084 } else {
06085 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06086 p = new TAttTextEditor;
06087 } else {
06088 p = new((void*) gvp) TAttTextEditor;
06089 }
06090 }
06091 break;
06092 }
06093 result7->obj.i = (long) p;
06094 result7->ref = (long) p;
06095 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor));
06096 return(1 || funcname || hash || result7 || libp) ;
06097 }
06098
06099 static int G__G__Ged_242_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06100 {
06101 G__letint(result7, 85, (long) TAttTextEditor::Class());
06102 return(1 || funcname || hash || result7 || libp) ;
06103 }
06104
06105 static int G__G__Ged_242_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06106 {
06107 G__letint(result7, 67, (long) TAttTextEditor::Class_Name());
06108 return(1 || funcname || hash || result7 || libp) ;
06109 }
06110
06111 static int G__G__Ged_242_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06112 {
06113 G__letint(result7, 115, (long) TAttTextEditor::Class_Version());
06114 return(1 || funcname || hash || result7 || libp) ;
06115 }
06116
06117 static int G__G__Ged_242_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06118 {
06119 TAttTextEditor::Dictionary();
06120 G__setnull(result7);
06121 return(1 || funcname || hash || result7 || libp) ;
06122 }
06123
06124 static int G__G__Ged_242_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06125 {
06126 ((TAttTextEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06127 G__setnull(result7);
06128 return(1 || funcname || hash || result7 || libp) ;
06129 }
06130
06131 static int G__G__Ged_242_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06132 {
06133 G__letint(result7, 67, (long) TAttTextEditor::DeclFileName());
06134 return(1 || funcname || hash || result7 || libp) ;
06135 }
06136
06137 static int G__G__Ged_242_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06138 {
06139 G__letint(result7, 105, (long) TAttTextEditor::ImplFileLine());
06140 return(1 || funcname || hash || result7 || libp) ;
06141 }
06142
06143 static int G__G__Ged_242_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06144 {
06145 G__letint(result7, 67, (long) TAttTextEditor::ImplFileName());
06146 return(1 || funcname || hash || result7 || libp) ;
06147 }
06148
06149 static int G__G__Ged_242_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06150 {
06151 G__letint(result7, 105, (long) TAttTextEditor::DeclFileLine());
06152 return(1 || funcname || hash || result7 || libp) ;
06153 }
06154
06155
06156 typedef TAttTextEditor G__TTAttTextEditor;
06157 static int G__G__Ged_242_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06158 {
06159 char* gvp = (char*) G__getgvp();
06160 long soff = G__getstructoffset();
06161 int n = G__getaryconstruct();
06162
06163
06164
06165
06166
06167 if (!soff) {
06168 return(1);
06169 }
06170 if (n) {
06171 if (gvp == (char*)G__PVOID) {
06172 delete[] (TAttTextEditor*) soff;
06173 } else {
06174 G__setgvp((long) G__PVOID);
06175 for (int i = n - 1; i >= 0; --i) {
06176 ((TAttTextEditor*) (soff+(sizeof(TAttTextEditor)*i)))->~G__TTAttTextEditor();
06177 }
06178 G__setgvp((long)gvp);
06179 }
06180 } else {
06181 if (gvp == (char*)G__PVOID) {
06182 delete (TAttTextEditor*) soff;
06183 } else {
06184 G__setgvp((long) G__PVOID);
06185 ((TAttTextEditor*) (soff))->~G__TTAttTextEditor();
06186 G__setgvp((long)gvp);
06187 }
06188 }
06189 G__setnull(result7);
06190 return(1 || funcname || hash || result7 || libp) ;
06191 }
06192
06193
06194
06195 static int G__G__Ged_246_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06196 {
06197 TAxisEditor* p = NULL;
06198 char* gvp = (char*) G__getgvp();
06199 switch (libp->paran) {
06200 case 5:
06201
06202 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06203 p = new TAxisEditor(
06204 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06205 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06206 , (Pixel_t) G__int(libp->para[4]));
06207 } else {
06208 p = new((void*) gvp) TAxisEditor(
06209 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06210 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06211 , (Pixel_t) G__int(libp->para[4]));
06212 }
06213 break;
06214 case 4:
06215
06216 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06217 p = new TAxisEditor(
06218 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06219 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06220 } else {
06221 p = new((void*) gvp) TAxisEditor(
06222 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06223 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06224 }
06225 break;
06226 case 3:
06227
06228 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06229 p = new TAxisEditor(
06230 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06231 , (Int_t) G__int(libp->para[2]));
06232 } else {
06233 p = new((void*) gvp) TAxisEditor(
06234 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06235 , (Int_t) G__int(libp->para[2]));
06236 }
06237 break;
06238 case 2:
06239
06240 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06241 p = new TAxisEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06242 } else {
06243 p = new((void*) gvp) TAxisEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06244 }
06245 break;
06246 case 1:
06247
06248 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06249 p = new TAxisEditor((TGWindow*) G__int(libp->para[0]));
06250 } else {
06251 p = new((void*) gvp) TAxisEditor((TGWindow*) G__int(libp->para[0]));
06252 }
06253 break;
06254 case 0:
06255 int n = G__getaryconstruct();
06256 if (n) {
06257 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06258 p = new TAxisEditor[n];
06259 } else {
06260 p = new((void*) gvp) TAxisEditor[n];
06261 }
06262 } else {
06263 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06264 p = new TAxisEditor;
06265 } else {
06266 p = new((void*) gvp) TAxisEditor;
06267 }
06268 }
06269 break;
06270 }
06271 result7->obj.i = (long) p;
06272 result7->ref = (long) p;
06273 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TAxisEditor));
06274 return(1 || funcname || hash || result7 || libp) ;
06275 }
06276
06277 static int G__G__Ged_246_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06278 {
06279 ((TAxisEditor*) G__getstructoffset())->DoTickLength();
06280 G__setnull(result7);
06281 return(1 || funcname || hash || result7 || libp) ;
06282 }
06283
06284 static int G__G__Ged_246_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06285 {
06286 ((TAxisEditor*) G__getstructoffset())->DoAxisColor((Pixel_t) G__int(libp->para[0]));
06287 G__setnull(result7);
06288 return(1 || funcname || hash || result7 || libp) ;
06289 }
06290
06291 static int G__G__Ged_246_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06292 {
06293 ((TAxisEditor*) G__getstructoffset())->DoTicks();
06294 G__setnull(result7);
06295 return(1 || funcname || hash || result7 || libp) ;
06296 }
06297
06298 static int G__G__Ged_246_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06299 {
06300 ((TAxisEditor*) G__getstructoffset())->DoDivisions();
06301 G__setnull(result7);
06302 return(1 || funcname || hash || result7 || libp) ;
06303 }
06304
06305 static int G__G__Ged_246_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06306 {
06307 ((TAxisEditor*) G__getstructoffset())->DoLogAxis();
06308 G__setnull(result7);
06309 return(1 || funcname || hash || result7 || libp) ;
06310 }
06311
06312 static int G__G__Ged_246_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06313 {
06314 ((TAxisEditor*) G__getstructoffset())->DoMoreLog();
06315 G__setnull(result7);
06316 return(1 || funcname || hash || result7 || libp) ;
06317 }
06318
06319 static int G__G__Ged_246_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06320 {
06321 ((TAxisEditor*) G__getstructoffset())->DoTitleColor((Pixel_t) G__int(libp->para[0]));
06322 G__setnull(result7);
06323 return(1 || funcname || hash || result7 || libp) ;
06324 }
06325
06326 static int G__G__Ged_246_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06327 {
06328 ((TAxisEditor*) G__getstructoffset())->DoTitle((const char*) G__int(libp->para[0]));
06329 G__setnull(result7);
06330 return(1 || funcname || hash || result7 || libp) ;
06331 }
06332
06333 static int G__G__Ged_246_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06334 {
06335 ((TAxisEditor*) G__getstructoffset())->DoTitleSize();
06336 G__setnull(result7);
06337 return(1 || funcname || hash || result7 || libp) ;
06338 }
06339
06340 static int G__G__Ged_246_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06341 {
06342 ((TAxisEditor*) G__getstructoffset())->DoTitleFont((Int_t) G__int(libp->para[0]));
06343 G__setnull(result7);
06344 return(1 || funcname || hash || result7 || libp) ;
06345 }
06346
06347 static int G__G__Ged_246_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06348 {
06349 ((TAxisEditor*) G__getstructoffset())->DoTitleOffset();
06350 G__setnull(result7);
06351 return(1 || funcname || hash || result7 || libp) ;
06352 }
06353
06354 static int G__G__Ged_246_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06355 {
06356 ((TAxisEditor*) G__getstructoffset())->DoTitleCentered();
06357 G__setnull(result7);
06358 return(1 || funcname || hash || result7 || libp) ;
06359 }
06360
06361 static int G__G__Ged_246_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06362 {
06363 ((TAxisEditor*) G__getstructoffset())->DoTitleRotated();
06364 G__setnull(result7);
06365 return(1 || funcname || hash || result7 || libp) ;
06366 }
06367
06368 static int G__G__Ged_246_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06369 {
06370 ((TAxisEditor*) G__getstructoffset())->DoLabelColor((Pixel_t) G__int(libp->para[0]));
06371 G__setnull(result7);
06372 return(1 || funcname || hash || result7 || libp) ;
06373 }
06374
06375 static int G__G__Ged_246_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06376 {
06377 ((TAxisEditor*) G__getstructoffset())->DoLabelSize();
06378 G__setnull(result7);
06379 return(1 || funcname || hash || result7 || libp) ;
06380 }
06381
06382 static int G__G__Ged_246_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06383 {
06384 ((TAxisEditor*) G__getstructoffset())->DoLabelFont((Int_t) G__int(libp->para[0]));
06385 G__setnull(result7);
06386 return(1 || funcname || hash || result7 || libp) ;
06387 }
06388
06389 static int G__G__Ged_246_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06390 {
06391 ((TAxisEditor*) G__getstructoffset())->DoLabelOffset();
06392 G__setnull(result7);
06393 return(1 || funcname || hash || result7 || libp) ;
06394 }
06395
06396 static int G__G__Ged_246_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06397 {
06398 ((TAxisEditor*) G__getstructoffset())->DoNoExponent();
06399 G__setnull(result7);
06400 return(1 || funcname || hash || result7 || libp) ;
06401 }
06402
06403 static int G__G__Ged_246_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06404 {
06405 ((TAxisEditor*) G__getstructoffset())->DoDecimal((Bool_t) G__int(libp->para[0]));
06406 G__setnull(result7);
06407 return(1 || funcname || hash || result7 || libp) ;
06408 }
06409
06410 static int G__G__Ged_246_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06411 {
06412 G__letint(result7, 85, (long) TAxisEditor::Class());
06413 return(1 || funcname || hash || result7 || libp) ;
06414 }
06415
06416 static int G__G__Ged_246_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06417 {
06418 G__letint(result7, 67, (long) TAxisEditor::Class_Name());
06419 return(1 || funcname || hash || result7 || libp) ;
06420 }
06421
06422 static int G__G__Ged_246_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06423 {
06424 G__letint(result7, 115, (long) TAxisEditor::Class_Version());
06425 return(1 || funcname || hash || result7 || libp) ;
06426 }
06427
06428 static int G__G__Ged_246_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06429 {
06430 TAxisEditor::Dictionary();
06431 G__setnull(result7);
06432 return(1 || funcname || hash || result7 || libp) ;
06433 }
06434
06435 static int G__G__Ged_246_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06436 {
06437 ((TAxisEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06438 G__setnull(result7);
06439 return(1 || funcname || hash || result7 || libp) ;
06440 }
06441
06442 static int G__G__Ged_246_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06443 {
06444 G__letint(result7, 67, (long) TAxisEditor::DeclFileName());
06445 return(1 || funcname || hash || result7 || libp) ;
06446 }
06447
06448 static int G__G__Ged_246_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06449 {
06450 G__letint(result7, 105, (long) TAxisEditor::ImplFileLine());
06451 return(1 || funcname || hash || result7 || libp) ;
06452 }
06453
06454 static int G__G__Ged_246_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06455 {
06456 G__letint(result7, 67, (long) TAxisEditor::ImplFileName());
06457 return(1 || funcname || hash || result7 || libp) ;
06458 }
06459
06460 static int G__G__Ged_246_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06461 {
06462 G__letint(result7, 105, (long) TAxisEditor::DeclFileLine());
06463 return(1 || funcname || hash || result7 || libp) ;
06464 }
06465
06466
06467 typedef TAxisEditor G__TTAxisEditor;
06468 static int G__G__Ged_246_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06469 {
06470 char* gvp = (char*) G__getgvp();
06471 long soff = G__getstructoffset();
06472 int n = G__getaryconstruct();
06473
06474
06475
06476
06477
06478 if (!soff) {
06479 return(1);
06480 }
06481 if (n) {
06482 if (gvp == (char*)G__PVOID) {
06483 delete[] (TAxisEditor*) soff;
06484 } else {
06485 G__setgvp((long) G__PVOID);
06486 for (int i = n - 1; i >= 0; --i) {
06487 ((TAxisEditor*) (soff+(sizeof(TAxisEditor)*i)))->~G__TTAxisEditor();
06488 }
06489 G__setgvp((long)gvp);
06490 }
06491 } else {
06492 if (gvp == (char*)G__PVOID) {
06493 delete (TAxisEditor*) soff;
06494 } else {
06495 G__setgvp((long) G__PVOID);
06496 ((TAxisEditor*) (soff))->~G__TTAxisEditor();
06497 G__setgvp((long)gvp);
06498 }
06499 }
06500 G__setnull(result7);
06501 return(1 || funcname || hash || result7 || libp) ;
06502 }
06503
06504
06505
06506 static int G__G__Ged_248_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06507 {
06508 TCurlyArcEditor* p = NULL;
06509 char* gvp = (char*) G__getgvp();
06510 switch (libp->paran) {
06511 case 5:
06512
06513 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06514 p = new TCurlyArcEditor(
06515 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06516 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06517 , (Pixel_t) G__int(libp->para[4]));
06518 } else {
06519 p = new((void*) gvp) TCurlyArcEditor(
06520 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06521 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06522 , (Pixel_t) G__int(libp->para[4]));
06523 }
06524 break;
06525 case 4:
06526
06527 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06528 p = new TCurlyArcEditor(
06529 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06530 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06531 } else {
06532 p = new((void*) gvp) TCurlyArcEditor(
06533 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06534 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06535 }
06536 break;
06537 case 3:
06538
06539 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06540 p = new TCurlyArcEditor(
06541 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06542 , (Int_t) G__int(libp->para[2]));
06543 } else {
06544 p = new((void*) gvp) TCurlyArcEditor(
06545 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06546 , (Int_t) G__int(libp->para[2]));
06547 }
06548 break;
06549 case 2:
06550
06551 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06552 p = new TCurlyArcEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06553 } else {
06554 p = new((void*) gvp) TCurlyArcEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06555 }
06556 break;
06557 case 1:
06558
06559 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06560 p = new TCurlyArcEditor((TGWindow*) G__int(libp->para[0]));
06561 } else {
06562 p = new((void*) gvp) TCurlyArcEditor((TGWindow*) G__int(libp->para[0]));
06563 }
06564 break;
06565 case 0:
06566 int n = G__getaryconstruct();
06567 if (n) {
06568 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06569 p = new TCurlyArcEditor[n];
06570 } else {
06571 p = new((void*) gvp) TCurlyArcEditor[n];
06572 }
06573 } else {
06574 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06575 p = new TCurlyArcEditor;
06576 } else {
06577 p = new((void*) gvp) TCurlyArcEditor;
06578 }
06579 }
06580 break;
06581 }
06582 result7->obj.i = (long) p;
06583 result7->ref = (long) p;
06584 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor));
06585 return(1 || funcname || hash || result7 || libp) ;
06586 }
06587
06588 static int G__G__Ged_248_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06589 {
06590 ((TCurlyArcEditor*) G__getstructoffset())->DoRadius();
06591 G__setnull(result7);
06592 return(1 || funcname || hash || result7 || libp) ;
06593 }
06594
06595 static int G__G__Ged_248_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06596 {
06597 ((TCurlyArcEditor*) G__getstructoffset())->DoPhimin();
06598 G__setnull(result7);
06599 return(1 || funcname || hash || result7 || libp) ;
06600 }
06601
06602 static int G__G__Ged_248_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06603 {
06604 ((TCurlyArcEditor*) G__getstructoffset())->DoPhimax();
06605 G__setnull(result7);
06606 return(1 || funcname || hash || result7 || libp) ;
06607 }
06608
06609 static int G__G__Ged_248_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06610 {
06611 ((TCurlyArcEditor*) G__getstructoffset())->DoCenterXY();
06612 G__setnull(result7);
06613 return(1 || funcname || hash || result7 || libp) ;
06614 }
06615
06616 static int G__G__Ged_248_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06617 {
06618 G__letint(result7, 85, (long) TCurlyArcEditor::Class());
06619 return(1 || funcname || hash || result7 || libp) ;
06620 }
06621
06622 static int G__G__Ged_248_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06623 {
06624 G__letint(result7, 67, (long) TCurlyArcEditor::Class_Name());
06625 return(1 || funcname || hash || result7 || libp) ;
06626 }
06627
06628 static int G__G__Ged_248_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06629 {
06630 G__letint(result7, 115, (long) TCurlyArcEditor::Class_Version());
06631 return(1 || funcname || hash || result7 || libp) ;
06632 }
06633
06634 static int G__G__Ged_248_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06635 {
06636 TCurlyArcEditor::Dictionary();
06637 G__setnull(result7);
06638 return(1 || funcname || hash || result7 || libp) ;
06639 }
06640
06641 static int G__G__Ged_248_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06642 {
06643 ((TCurlyArcEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06644 G__setnull(result7);
06645 return(1 || funcname || hash || result7 || libp) ;
06646 }
06647
06648 static int G__G__Ged_248_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06649 {
06650 G__letint(result7, 67, (long) TCurlyArcEditor::DeclFileName());
06651 return(1 || funcname || hash || result7 || libp) ;
06652 }
06653
06654 static int G__G__Ged_248_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06655 {
06656 G__letint(result7, 105, (long) TCurlyArcEditor::ImplFileLine());
06657 return(1 || funcname || hash || result7 || libp) ;
06658 }
06659
06660 static int G__G__Ged_248_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06661 {
06662 G__letint(result7, 67, (long) TCurlyArcEditor::ImplFileName());
06663 return(1 || funcname || hash || result7 || libp) ;
06664 }
06665
06666 static int G__G__Ged_248_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06667 {
06668 G__letint(result7, 105, (long) TCurlyArcEditor::DeclFileLine());
06669 return(1 || funcname || hash || result7 || libp) ;
06670 }
06671
06672
06673 typedef TCurlyArcEditor G__TTCurlyArcEditor;
06674 static int G__G__Ged_248_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06675 {
06676 char* gvp = (char*) G__getgvp();
06677 long soff = G__getstructoffset();
06678 int n = G__getaryconstruct();
06679
06680
06681
06682
06683
06684 if (!soff) {
06685 return(1);
06686 }
06687 if (n) {
06688 if (gvp == (char*)G__PVOID) {
06689 delete[] (TCurlyArcEditor*) soff;
06690 } else {
06691 G__setgvp((long) G__PVOID);
06692 for (int i = n - 1; i >= 0; --i) {
06693 ((TCurlyArcEditor*) (soff+(sizeof(TCurlyArcEditor)*i)))->~G__TTCurlyArcEditor();
06694 }
06695 G__setgvp((long)gvp);
06696 }
06697 } else {
06698 if (gvp == (char*)G__PVOID) {
06699 delete (TCurlyArcEditor*) soff;
06700 } else {
06701 G__setgvp((long) G__PVOID);
06702 ((TCurlyArcEditor*) (soff))->~G__TTCurlyArcEditor();
06703 G__setgvp((long)gvp);
06704 }
06705 }
06706 G__setnull(result7);
06707 return(1 || funcname || hash || result7 || libp) ;
06708 }
06709
06710
06711
06712 static int G__G__Ged_250_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06713 {
06714 TCurlyLineEditor* p = NULL;
06715 char* gvp = (char*) G__getgvp();
06716 switch (libp->paran) {
06717 case 5:
06718
06719 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06720 p = new TCurlyLineEditor(
06721 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06722 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06723 , (Pixel_t) G__int(libp->para[4]));
06724 } else {
06725 p = new((void*) gvp) TCurlyLineEditor(
06726 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06727 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06728 , (Pixel_t) G__int(libp->para[4]));
06729 }
06730 break;
06731 case 4:
06732
06733 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06734 p = new TCurlyLineEditor(
06735 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06736 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06737 } else {
06738 p = new((void*) gvp) TCurlyLineEditor(
06739 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06740 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06741 }
06742 break;
06743 case 3:
06744
06745 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06746 p = new TCurlyLineEditor(
06747 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06748 , (Int_t) G__int(libp->para[2]));
06749 } else {
06750 p = new((void*) gvp) TCurlyLineEditor(
06751 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06752 , (Int_t) G__int(libp->para[2]));
06753 }
06754 break;
06755 case 2:
06756
06757 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06758 p = new TCurlyLineEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06759 } else {
06760 p = new((void*) gvp) TCurlyLineEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06761 }
06762 break;
06763 case 1:
06764
06765 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06766 p = new TCurlyLineEditor((TGWindow*) G__int(libp->para[0]));
06767 } else {
06768 p = new((void*) gvp) TCurlyLineEditor((TGWindow*) G__int(libp->para[0]));
06769 }
06770 break;
06771 case 0:
06772 int n = G__getaryconstruct();
06773 if (n) {
06774 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06775 p = new TCurlyLineEditor[n];
06776 } else {
06777 p = new((void*) gvp) TCurlyLineEditor[n];
06778 }
06779 } else {
06780 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06781 p = new TCurlyLineEditor;
06782 } else {
06783 p = new((void*) gvp) TCurlyLineEditor;
06784 }
06785 }
06786 break;
06787 }
06788 result7->obj.i = (long) p;
06789 result7->ref = (long) p;
06790 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor));
06791 return(1 || funcname || hash || result7 || libp) ;
06792 }
06793
06794 static int G__G__Ged_250_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06795 {
06796 ((TCurlyLineEditor*) G__getstructoffset())->DoStartXY();
06797 G__setnull(result7);
06798 return(1 || funcname || hash || result7 || libp) ;
06799 }
06800
06801 static int G__G__Ged_250_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06802 {
06803 ((TCurlyLineEditor*) G__getstructoffset())->DoEndXY();
06804 G__setnull(result7);
06805 return(1 || funcname || hash || result7 || libp) ;
06806 }
06807
06808 static int G__G__Ged_250_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06809 {
06810 ((TCurlyLineEditor*) G__getstructoffset())->DoAmplitude();
06811 G__setnull(result7);
06812 return(1 || funcname || hash || result7 || libp) ;
06813 }
06814
06815 static int G__G__Ged_250_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06816 {
06817 ((TCurlyLineEditor*) G__getstructoffset())->DoWaveLength();
06818 G__setnull(result7);
06819 return(1 || funcname || hash || result7 || libp) ;
06820 }
06821
06822 static int G__G__Ged_250_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06823 {
06824 ((TCurlyLineEditor*) G__getstructoffset())->DoWavy();
06825 G__setnull(result7);
06826 return(1 || funcname || hash || result7 || libp) ;
06827 }
06828
06829 static int G__G__Ged_250_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06830 {
06831 G__letint(result7, 85, (long) TCurlyLineEditor::Class());
06832 return(1 || funcname || hash || result7 || libp) ;
06833 }
06834
06835 static int G__G__Ged_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06836 {
06837 G__letint(result7, 67, (long) TCurlyLineEditor::Class_Name());
06838 return(1 || funcname || hash || result7 || libp) ;
06839 }
06840
06841 static int G__G__Ged_250_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06842 {
06843 G__letint(result7, 115, (long) TCurlyLineEditor::Class_Version());
06844 return(1 || funcname || hash || result7 || libp) ;
06845 }
06846
06847 static int G__G__Ged_250_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06848 {
06849 TCurlyLineEditor::Dictionary();
06850 G__setnull(result7);
06851 return(1 || funcname || hash || result7 || libp) ;
06852 }
06853
06854 static int G__G__Ged_250_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06855 {
06856 ((TCurlyLineEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06857 G__setnull(result7);
06858 return(1 || funcname || hash || result7 || libp) ;
06859 }
06860
06861 static int G__G__Ged_250_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06862 {
06863 G__letint(result7, 67, (long) TCurlyLineEditor::DeclFileName());
06864 return(1 || funcname || hash || result7 || libp) ;
06865 }
06866
06867 static int G__G__Ged_250_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06868 {
06869 G__letint(result7, 105, (long) TCurlyLineEditor::ImplFileLine());
06870 return(1 || funcname || hash || result7 || libp) ;
06871 }
06872
06873 static int G__G__Ged_250_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06874 {
06875 G__letint(result7, 67, (long) TCurlyLineEditor::ImplFileName());
06876 return(1 || funcname || hash || result7 || libp) ;
06877 }
06878
06879 static int G__G__Ged_250_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06880 {
06881 G__letint(result7, 105, (long) TCurlyLineEditor::DeclFileLine());
06882 return(1 || funcname || hash || result7 || libp) ;
06883 }
06884
06885
06886 typedef TCurlyLineEditor G__TTCurlyLineEditor;
06887 static int G__G__Ged_250_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06888 {
06889 char* gvp = (char*) G__getgvp();
06890 long soff = G__getstructoffset();
06891 int n = G__getaryconstruct();
06892
06893
06894
06895
06896
06897 if (!soff) {
06898 return(1);
06899 }
06900 if (n) {
06901 if (gvp == (char*)G__PVOID) {
06902 delete[] (TCurlyLineEditor*) soff;
06903 } else {
06904 G__setgvp((long) G__PVOID);
06905 for (int i = n - 1; i >= 0; --i) {
06906 ((TCurlyLineEditor*) (soff+(sizeof(TCurlyLineEditor)*i)))->~G__TTCurlyLineEditor();
06907 }
06908 G__setgvp((long)gvp);
06909 }
06910 } else {
06911 if (gvp == (char*)G__PVOID) {
06912 delete (TCurlyLineEditor*) soff;
06913 } else {
06914 G__setgvp((long) G__PVOID);
06915 ((TCurlyLineEditor*) (soff))->~G__TTCurlyLineEditor();
06916 G__setgvp((long)gvp);
06917 }
06918 }
06919 G__setnull(result7);
06920 return(1 || funcname || hash || result7 || libp) ;
06921 }
06922
06923
06924
06925 static int G__G__Ged_254_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06926 {
06927 TF1Editor* p = NULL;
06928 char* gvp = (char*) G__getgvp();
06929 switch (libp->paran) {
06930 case 5:
06931
06932 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06933 p = new TF1Editor(
06934 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06935 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06936 , (Pixel_t) G__int(libp->para[4]));
06937 } else {
06938 p = new((void*) gvp) TF1Editor(
06939 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06940 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
06941 , (Pixel_t) G__int(libp->para[4]));
06942 }
06943 break;
06944 case 4:
06945
06946 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06947 p = new TF1Editor(
06948 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06949 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06950 } else {
06951 p = new((void*) gvp) TF1Editor(
06952 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06953 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06954 }
06955 break;
06956 case 3:
06957
06958 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06959 p = new TF1Editor(
06960 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06961 , (Int_t) G__int(libp->para[2]));
06962 } else {
06963 p = new((void*) gvp) TF1Editor(
06964 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
06965 , (Int_t) G__int(libp->para[2]));
06966 }
06967 break;
06968 case 2:
06969
06970 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06971 p = new TF1Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06972 } else {
06973 p = new((void*) gvp) TF1Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06974 }
06975 break;
06976 case 1:
06977
06978 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06979 p = new TF1Editor((TGWindow*) G__int(libp->para[0]));
06980 } else {
06981 p = new((void*) gvp) TF1Editor((TGWindow*) G__int(libp->para[0]));
06982 }
06983 break;
06984 case 0:
06985 int n = G__getaryconstruct();
06986 if (n) {
06987 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06988 p = new TF1Editor[n];
06989 } else {
06990 p = new((void*) gvp) TF1Editor[n];
06991 }
06992 } else {
06993 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06994 p = new TF1Editor;
06995 } else {
06996 p = new((void*) gvp) TF1Editor;
06997 }
06998 }
06999 break;
07000 }
07001 result7->obj.i = (long) p;
07002 result7->ref = (long) p;
07003 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TF1Editor));
07004 return(1 || funcname || hash || result7 || libp) ;
07005 }
07006
07007 static int G__G__Ged_254_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07008 {
07009 ((TF1Editor*) G__getstructoffset())->DoParameterSettings();
07010 G__setnull(result7);
07011 return(1 || funcname || hash || result7 || libp) ;
07012 }
07013
07014 static int G__G__Ged_254_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07015 {
07016 ((TF1Editor*) G__getstructoffset())->DoXPoints();
07017 G__setnull(result7);
07018 return(1 || funcname || hash || result7 || libp) ;
07019 }
07020
07021 static int G__G__Ged_254_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07022 {
07023 ((TF1Editor*) G__getstructoffset())->DoSliderXMoved();
07024 G__setnull(result7);
07025 return(1 || funcname || hash || result7 || libp) ;
07026 }
07027
07028 static int G__G__Ged_254_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07029 {
07030 ((TF1Editor*) G__getstructoffset())->DoSliderXPressed();
07031 G__setnull(result7);
07032 return(1 || funcname || hash || result7 || libp) ;
07033 }
07034
07035 static int G__G__Ged_254_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07036 {
07037 ((TF1Editor*) G__getstructoffset())->DoSliderXReleased();
07038 G__setnull(result7);
07039 return(1 || funcname || hash || result7 || libp) ;
07040 }
07041
07042 static int G__G__Ged_254_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07043 {
07044 ((TF1Editor*) G__getstructoffset())->DoXRange();
07045 G__setnull(result7);
07046 return(1 || funcname || hash || result7 || libp) ;
07047 }
07048
07049 static int G__G__Ged_254_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07050 {
07051 G__letint(result7, 85, (long) TF1Editor::Class());
07052 return(1 || funcname || hash || result7 || libp) ;
07053 }
07054
07055 static int G__G__Ged_254_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07056 {
07057 G__letint(result7, 67, (long) TF1Editor::Class_Name());
07058 return(1 || funcname || hash || result7 || libp) ;
07059 }
07060
07061 static int G__G__Ged_254_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07062 {
07063 G__letint(result7, 115, (long) TF1Editor::Class_Version());
07064 return(1 || funcname || hash || result7 || libp) ;
07065 }
07066
07067 static int G__G__Ged_254_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07068 {
07069 TF1Editor::Dictionary();
07070 G__setnull(result7);
07071 return(1 || funcname || hash || result7 || libp) ;
07072 }
07073
07074 static int G__G__Ged_254_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07075 {
07076 ((TF1Editor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07077 G__setnull(result7);
07078 return(1 || funcname || hash || result7 || libp) ;
07079 }
07080
07081 static int G__G__Ged_254_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07082 {
07083 G__letint(result7, 67, (long) TF1Editor::DeclFileName());
07084 return(1 || funcname || hash || result7 || libp) ;
07085 }
07086
07087 static int G__G__Ged_254_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07088 {
07089 G__letint(result7, 105, (long) TF1Editor::ImplFileLine());
07090 return(1 || funcname || hash || result7 || libp) ;
07091 }
07092
07093 static int G__G__Ged_254_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07094 {
07095 G__letint(result7, 67, (long) TF1Editor::ImplFileName());
07096 return(1 || funcname || hash || result7 || libp) ;
07097 }
07098
07099 static int G__G__Ged_254_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07100 {
07101 G__letint(result7, 105, (long) TF1Editor::DeclFileLine());
07102 return(1 || funcname || hash || result7 || libp) ;
07103 }
07104
07105
07106 typedef TF1Editor G__TTF1Editor;
07107 static int G__G__Ged_254_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07108 {
07109 char* gvp = (char*) G__getgvp();
07110 long soff = G__getstructoffset();
07111 int n = G__getaryconstruct();
07112
07113
07114
07115
07116
07117 if (!soff) {
07118 return(1);
07119 }
07120 if (n) {
07121 if (gvp == (char*)G__PVOID) {
07122 delete[] (TF1Editor*) soff;
07123 } else {
07124 G__setgvp((long) G__PVOID);
07125 for (int i = n - 1; i >= 0; --i) {
07126 ((TF1Editor*) (soff+(sizeof(TF1Editor)*i)))->~G__TTF1Editor();
07127 }
07128 G__setgvp((long)gvp);
07129 }
07130 } else {
07131 if (gvp == (char*)G__PVOID) {
07132 delete (TF1Editor*) soff;
07133 } else {
07134 G__setgvp((long) G__PVOID);
07135 ((TF1Editor*) (soff))->~G__TTF1Editor();
07136 G__setgvp((long)gvp);
07137 }
07138 }
07139 G__setnull(result7);
07140 return(1 || funcname || hash || result7 || libp) ;
07141 }
07142
07143
07144
07145 static int G__G__Ged_257_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07146 {
07147 TFrameEditor* p = NULL;
07148 char* gvp = (char*) G__getgvp();
07149 switch (libp->paran) {
07150 case 5:
07151
07152 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07153 p = new TFrameEditor(
07154 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07155 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07156 , (Pixel_t) G__int(libp->para[4]));
07157 } else {
07158 p = new((void*) gvp) TFrameEditor(
07159 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07160 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07161 , (Pixel_t) G__int(libp->para[4]));
07162 }
07163 break;
07164 case 4:
07165
07166 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07167 p = new TFrameEditor(
07168 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07169 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07170 } else {
07171 p = new((void*) gvp) TFrameEditor(
07172 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07173 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07174 }
07175 break;
07176 case 3:
07177
07178 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07179 p = new TFrameEditor(
07180 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07181 , (Int_t) G__int(libp->para[2]));
07182 } else {
07183 p = new((void*) gvp) TFrameEditor(
07184 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07185 , (Int_t) G__int(libp->para[2]));
07186 }
07187 break;
07188 case 2:
07189
07190 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07191 p = new TFrameEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07192 } else {
07193 p = new((void*) gvp) TFrameEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07194 }
07195 break;
07196 case 1:
07197
07198 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07199 p = new TFrameEditor((TGWindow*) G__int(libp->para[0]));
07200 } else {
07201 p = new((void*) gvp) TFrameEditor((TGWindow*) G__int(libp->para[0]));
07202 }
07203 break;
07204 case 0:
07205 int n = G__getaryconstruct();
07206 if (n) {
07207 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07208 p = new TFrameEditor[n];
07209 } else {
07210 p = new((void*) gvp) TFrameEditor[n];
07211 }
07212 } else {
07213 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07214 p = new TFrameEditor;
07215 } else {
07216 p = new((void*) gvp) TFrameEditor;
07217 }
07218 }
07219 break;
07220 }
07221 result7->obj.i = (long) p;
07222 result7->ref = (long) p;
07223 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TFrameEditor));
07224 return(1 || funcname || hash || result7 || libp) ;
07225 }
07226
07227 static int G__G__Ged_257_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07228 {
07229 ((TFrameEditor*) G__getstructoffset())->DoBorderMode();
07230 G__setnull(result7);
07231 return(1 || funcname || hash || result7 || libp) ;
07232 }
07233
07234 static int G__G__Ged_257_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07235 {
07236 ((TFrameEditor*) G__getstructoffset())->DoBorderSize((Int_t) G__int(libp->para[0]));
07237 G__setnull(result7);
07238 return(1 || funcname || hash || result7 || libp) ;
07239 }
07240
07241 static int G__G__Ged_257_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07242 {
07243 G__letint(result7, 85, (long) TFrameEditor::Class());
07244 return(1 || funcname || hash || result7 || libp) ;
07245 }
07246
07247 static int G__G__Ged_257_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07248 {
07249 G__letint(result7, 67, (long) TFrameEditor::Class_Name());
07250 return(1 || funcname || hash || result7 || libp) ;
07251 }
07252
07253 static int G__G__Ged_257_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07254 {
07255 G__letint(result7, 115, (long) TFrameEditor::Class_Version());
07256 return(1 || funcname || hash || result7 || libp) ;
07257 }
07258
07259 static int G__G__Ged_257_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07260 {
07261 TFrameEditor::Dictionary();
07262 G__setnull(result7);
07263 return(1 || funcname || hash || result7 || libp) ;
07264 }
07265
07266 static int G__G__Ged_257_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07267 {
07268 ((TFrameEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07269 G__setnull(result7);
07270 return(1 || funcname || hash || result7 || libp) ;
07271 }
07272
07273 static int G__G__Ged_257_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07274 {
07275 G__letint(result7, 67, (long) TFrameEditor::DeclFileName());
07276 return(1 || funcname || hash || result7 || libp) ;
07277 }
07278
07279 static int G__G__Ged_257_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07280 {
07281 G__letint(result7, 105, (long) TFrameEditor::ImplFileLine());
07282 return(1 || funcname || hash || result7 || libp) ;
07283 }
07284
07285 static int G__G__Ged_257_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07286 {
07287 G__letint(result7, 67, (long) TFrameEditor::ImplFileName());
07288 return(1 || funcname || hash || result7 || libp) ;
07289 }
07290
07291 static int G__G__Ged_257_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07292 {
07293 G__letint(result7, 105, (long) TFrameEditor::DeclFileLine());
07294 return(1 || funcname || hash || result7 || libp) ;
07295 }
07296
07297
07298 typedef TFrameEditor G__TTFrameEditor;
07299 static int G__G__Ged_257_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07300 {
07301 char* gvp = (char*) G__getgvp();
07302 long soff = G__getstructoffset();
07303 int n = G__getaryconstruct();
07304
07305
07306
07307
07308
07309 if (!soff) {
07310 return(1);
07311 }
07312 if (n) {
07313 if (gvp == (char*)G__PVOID) {
07314 delete[] (TFrameEditor*) soff;
07315 } else {
07316 G__setgvp((long) G__PVOID);
07317 for (int i = n - 1; i >= 0; --i) {
07318 ((TFrameEditor*) (soff+(sizeof(TFrameEditor)*i)))->~G__TTFrameEditor();
07319 }
07320 G__setgvp((long)gvp);
07321 }
07322 } else {
07323 if (gvp == (char*)G__PVOID) {
07324 delete (TFrameEditor*) soff;
07325 } else {
07326 G__setgvp((long) G__PVOID);
07327 ((TFrameEditor*) (soff))->~G__TTFrameEditor();
07328 G__setgvp((long)gvp);
07329 }
07330 }
07331 G__setnull(result7);
07332 return(1 || funcname || hash || result7 || libp) ;
07333 }
07334
07335
07336
07337 static int G__G__Ged_259_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07338 {
07339 TFunctionParametersDialog* p = NULL;
07340 char* gvp = (char*) G__getgvp();
07341
07342 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07343 p = new TFunctionParametersDialog(
07344 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07345 , (TF1*) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3])
07346 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
07347 } else {
07348 p = new((void*) gvp) TFunctionParametersDialog(
07349 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07350 , (TF1*) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3])
07351 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
07352 }
07353 result7->obj.i = (long) p;
07354 result7->ref = (long) p;
07355 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog));
07356 return(1 || funcname || hash || result7 || libp) ;
07357 }
07358
07359 static int G__G__Ged_259_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07360 {
07361 ((TFunctionParametersDialog*) G__getstructoffset())->DoApply();
07362 G__setnull(result7);
07363 return(1 || funcname || hash || result7 || libp) ;
07364 }
07365
07366 static int G__G__Ged_259_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07367 {
07368 ((TFunctionParametersDialog*) G__getstructoffset())->DoCancel();
07369 G__setnull(result7);
07370 return(1 || funcname || hash || result7 || libp) ;
07371 }
07372
07373 static int G__G__Ged_259_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07374 {
07375 ((TFunctionParametersDialog*) G__getstructoffset())->DoFix((Bool_t) G__int(libp->para[0]));
07376 G__setnull(result7);
07377 return(1 || funcname || hash || result7 || libp) ;
07378 }
07379
07380 static int G__G__Ged_259_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07381 {
07382 ((TFunctionParametersDialog*) G__getstructoffset())->DoOK();
07383 G__setnull(result7);
07384 return(1 || funcname || hash || result7 || libp) ;
07385 }
07386
07387 static int G__G__Ged_259_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07388 {
07389 ((TFunctionParametersDialog*) G__getstructoffset())->DoParMaxLimit();
07390 G__setnull(result7);
07391 return(1 || funcname || hash || result7 || libp) ;
07392 }
07393
07394 static int G__G__Ged_259_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07395 {
07396 ((TFunctionParametersDialog*) G__getstructoffset())->DoParMinLimit();
07397 G__setnull(result7);
07398 return(1 || funcname || hash || result7 || libp) ;
07399 }
07400
07401 static int G__G__Ged_259_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07402 {
07403 ((TFunctionParametersDialog*) G__getstructoffset())->DoParValue();
07404 G__setnull(result7);
07405 return(1 || funcname || hash || result7 || libp) ;
07406 }
07407
07408 static int G__G__Ged_259_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07409 {
07410 ((TFunctionParametersDialog*) G__getstructoffset())->DoReset();
07411 G__setnull(result7);
07412 return(1 || funcname || hash || result7 || libp) ;
07413 }
07414
07415 static int G__G__Ged_259_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07416 {
07417 ((TFunctionParametersDialog*) G__getstructoffset())->DoSlider();
07418 G__setnull(result7);
07419 return(1 || funcname || hash || result7 || libp) ;
07420 }
07421
07422 static int G__G__Ged_259_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07423 {
07424 ((TFunctionParametersDialog*) G__getstructoffset())->HandleButtons((Bool_t) G__int(libp->para[0]));
07425 G__setnull(result7);
07426 return(1 || funcname || hash || result7 || libp) ;
07427 }
07428
07429 static int G__G__Ged_259_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07430 {
07431 ((TFunctionParametersDialog*) G__getstructoffset())->RedrawFunction();
07432 G__setnull(result7);
07433 return(1 || funcname || hash || result7 || libp) ;
07434 }
07435
07436 static int G__G__Ged_259_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07437 {
07438 G__letint(result7, 85, (long) TFunctionParametersDialog::Class());
07439 return(1 || funcname || hash || result7 || libp) ;
07440 }
07441
07442 static int G__G__Ged_259_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07443 {
07444 G__letint(result7, 67, (long) TFunctionParametersDialog::Class_Name());
07445 return(1 || funcname || hash || result7 || libp) ;
07446 }
07447
07448 static int G__G__Ged_259_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07449 {
07450 G__letint(result7, 115, (long) TFunctionParametersDialog::Class_Version());
07451 return(1 || funcname || hash || result7 || libp) ;
07452 }
07453
07454 static int G__G__Ged_259_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07455 {
07456 TFunctionParametersDialog::Dictionary();
07457 G__setnull(result7);
07458 return(1 || funcname || hash || result7 || libp) ;
07459 }
07460
07461 static int G__G__Ged_259_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07462 {
07463 ((TFunctionParametersDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07464 G__setnull(result7);
07465 return(1 || funcname || hash || result7 || libp) ;
07466 }
07467
07468 static int G__G__Ged_259_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07469 {
07470 G__letint(result7, 67, (long) TFunctionParametersDialog::DeclFileName());
07471 return(1 || funcname || hash || result7 || libp) ;
07472 }
07473
07474 static int G__G__Ged_259_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07475 {
07476 G__letint(result7, 105, (long) TFunctionParametersDialog::ImplFileLine());
07477 return(1 || funcname || hash || result7 || libp) ;
07478 }
07479
07480 static int G__G__Ged_259_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07481 {
07482 G__letint(result7, 67, (long) TFunctionParametersDialog::ImplFileName());
07483 return(1 || funcname || hash || result7 || libp) ;
07484 }
07485
07486 static int G__G__Ged_259_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07487 {
07488 G__letint(result7, 105, (long) TFunctionParametersDialog::DeclFileLine());
07489 return(1 || funcname || hash || result7 || libp) ;
07490 }
07491
07492
07493 typedef TFunctionParametersDialog G__TTFunctionParametersDialog;
07494 static int G__G__Ged_259_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07495 {
07496 char* gvp = (char*) G__getgvp();
07497 long soff = G__getstructoffset();
07498 int n = G__getaryconstruct();
07499
07500
07501
07502
07503
07504 if (!soff) {
07505 return(1);
07506 }
07507 if (n) {
07508 if (gvp == (char*)G__PVOID) {
07509 delete[] (TFunctionParametersDialog*) soff;
07510 } else {
07511 G__setgvp((long) G__PVOID);
07512 for (int i = n - 1; i >= 0; --i) {
07513 ((TFunctionParametersDialog*) (soff+(sizeof(TFunctionParametersDialog)*i)))->~G__TTFunctionParametersDialog();
07514 }
07515 G__setgvp((long)gvp);
07516 }
07517 } else {
07518 if (gvp == (char*)G__PVOID) {
07519 delete (TFunctionParametersDialog*) soff;
07520 } else {
07521 G__setgvp((long) G__PVOID);
07522 ((TFunctionParametersDialog*) (soff))->~G__TTFunctionParametersDialog();
07523 G__setgvp((long)gvp);
07524 }
07525 }
07526 G__setnull(result7);
07527 return(1 || funcname || hash || result7 || libp) ;
07528 }
07529
07530
07531
07532 static int G__G__Ged_280_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07533 {
07534 TGedPopup* p = NULL;
07535 char* gvp = (char*) G__getgvp();
07536 switch (libp->paran) {
07537 case 6:
07538
07539 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07540 p = new TGedPopup(
07541 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07542 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07543 , (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
07544 } else {
07545 p = new((void*) gvp) TGedPopup(
07546 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07547 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07548 , (UInt_t) G__int(libp->para[4]), (Pixel_t) G__int(libp->para[5]));
07549 }
07550 break;
07551 case 5:
07552
07553 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07554 p = new TGedPopup(
07555 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07556 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07557 , (UInt_t) G__int(libp->para[4]));
07558 } else {
07559 p = new((void*) gvp) TGedPopup(
07560 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07561 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
07562 , (UInt_t) G__int(libp->para[4]));
07563 }
07564 break;
07565 case 4:
07566
07567 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07568 p = new TGedPopup(
07569 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07570 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07571 } else {
07572 p = new((void*) gvp) TGedPopup(
07573 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07574 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07575 }
07576 break;
07577 }
07578 result7->obj.i = (long) p;
07579 result7->ref = (long) p;
07580 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedPopup));
07581 return(1 || funcname || hash || result7 || libp) ;
07582 }
07583
07584 static int G__G__Ged_280_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07585 {
07586 ((TGedPopup*) G__getstructoffset())->PlacePopup((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07587 , (UInt_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
07588 G__setnull(result7);
07589 return(1 || funcname || hash || result7 || libp) ;
07590 }
07591
07592 static int G__G__Ged_280_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07593 {
07594 ((TGedPopup*) G__getstructoffset())->EndPopup();
07595 G__setnull(result7);
07596 return(1 || funcname || hash || result7 || libp) ;
07597 }
07598
07599 static int G__G__Ged_280_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07600 {
07601 G__letint(result7, 85, (long) TGedPopup::Class());
07602 return(1 || funcname || hash || result7 || libp) ;
07603 }
07604
07605 static int G__G__Ged_280_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07606 {
07607 G__letint(result7, 67, (long) TGedPopup::Class_Name());
07608 return(1 || funcname || hash || result7 || libp) ;
07609 }
07610
07611 static int G__G__Ged_280_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07612 {
07613 G__letint(result7, 115, (long) TGedPopup::Class_Version());
07614 return(1 || funcname || hash || result7 || libp) ;
07615 }
07616
07617 static int G__G__Ged_280_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07618 {
07619 TGedPopup::Dictionary();
07620 G__setnull(result7);
07621 return(1 || funcname || hash || result7 || libp) ;
07622 }
07623
07624 static int G__G__Ged_280_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07625 {
07626 ((TGedPopup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07627 G__setnull(result7);
07628 return(1 || funcname || hash || result7 || libp) ;
07629 }
07630
07631 static int G__G__Ged_280_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07632 {
07633 G__letint(result7, 67, (long) TGedPopup::DeclFileName());
07634 return(1 || funcname || hash || result7 || libp) ;
07635 }
07636
07637 static int G__G__Ged_280_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07638 {
07639 G__letint(result7, 105, (long) TGedPopup::ImplFileLine());
07640 return(1 || funcname || hash || result7 || libp) ;
07641 }
07642
07643 static int G__G__Ged_280_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07644 {
07645 G__letint(result7, 67, (long) TGedPopup::ImplFileName());
07646 return(1 || funcname || hash || result7 || libp) ;
07647 }
07648
07649 static int G__G__Ged_280_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07650 {
07651 G__letint(result7, 105, (long) TGedPopup::DeclFileLine());
07652 return(1 || funcname || hash || result7 || libp) ;
07653 }
07654
07655
07656 typedef TGedPopup G__TTGedPopup;
07657 static int G__G__Ged_280_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07658 {
07659 char* gvp = (char*) G__getgvp();
07660 long soff = G__getstructoffset();
07661 int n = G__getaryconstruct();
07662
07663
07664
07665
07666
07667 if (!soff) {
07668 return(1);
07669 }
07670 if (n) {
07671 if (gvp == (char*)G__PVOID) {
07672 delete[] (TGedPopup*) soff;
07673 } else {
07674 G__setgvp((long) G__PVOID);
07675 for (int i = n - 1; i >= 0; --i) {
07676 ((TGedPopup*) (soff+(sizeof(TGedPopup)*i)))->~G__TTGedPopup();
07677 }
07678 G__setgvp((long)gvp);
07679 }
07680 } else {
07681 if (gvp == (char*)G__PVOID) {
07682 delete (TGedPopup*) soff;
07683 } else {
07684 G__setgvp((long) G__PVOID);
07685 ((TGedPopup*) (soff))->~G__TTGedPopup();
07686 G__setgvp((long)gvp);
07687 }
07688 }
07689 G__setnull(result7);
07690 return(1 || funcname || hash || result7 || libp) ;
07691 }
07692
07693
07694
07695 static int G__G__Ged_281_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07696 {
07697 TGedPatternFrame* p = NULL;
07698 char* gvp = (char*) G__getgvp();
07699 switch (libp->paran) {
07700 case 4:
07701
07702 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07703 p = new TGedPatternFrame(
07704 (TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
07705 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
07706 } else {
07707 p = new((void*) gvp) TGedPatternFrame(
07708 (TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
07709 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
07710 }
07711 break;
07712 case 3:
07713
07714 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07715 p = new TGedPatternFrame(
07716 (TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
07717 , (Int_t) G__int(libp->para[2]));
07718 } else {
07719 p = new((void*) gvp) TGedPatternFrame(
07720 (TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1])
07721 , (Int_t) G__int(libp->para[2]));
07722 }
07723 break;
07724 case 2:
07725
07726 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07727 p = new TGedPatternFrame((TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1]));
07728 } else {
07729 p = new((void*) gvp) TGedPatternFrame((TGWindow*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1]));
07730 }
07731 break;
07732 }
07733 result7->obj.i = (long) p;
07734 result7->ref = (long) p;
07735 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame));
07736 return(1 || funcname || hash || result7 || libp) ;
07737 }
07738
07739 static int G__G__Ged_281_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07740 {
07741 ((TGedPatternFrame*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
07742 G__setnull(result7);
07743 return(1 || funcname || hash || result7 || libp) ;
07744 }
07745
07746 static int G__G__Ged_281_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07747 {
07748 G__letint(result7, 115, (long) ((const TGedPatternFrame*) G__getstructoffset())->GetPattern());
07749 return(1 || funcname || hash || result7 || libp) ;
07750 }
07751
07752 static int G__G__Ged_281_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07753 {
07754 TGedPatternFrame::SetFillStyle((TGGC*) G__int(libp->para[0]), (Style_t) G__int(libp->para[1]));
07755 G__setnull(result7);
07756 return(1 || funcname || hash || result7 || libp) ;
07757 }
07758
07759 static int G__G__Ged_281_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07760 {
07761 G__letint(result7, 85, (long) TGedPatternFrame::Class());
07762 return(1 || funcname || hash || result7 || libp) ;
07763 }
07764
07765 static int G__G__Ged_281_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07766 {
07767 G__letint(result7, 67, (long) TGedPatternFrame::Class_Name());
07768 return(1 || funcname || hash || result7 || libp) ;
07769 }
07770
07771 static int G__G__Ged_281_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07772 {
07773 G__letint(result7, 115, (long) TGedPatternFrame::Class_Version());
07774 return(1 || funcname || hash || result7 || libp) ;
07775 }
07776
07777 static int G__G__Ged_281_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07778 {
07779 TGedPatternFrame::Dictionary();
07780 G__setnull(result7);
07781 return(1 || funcname || hash || result7 || libp) ;
07782 }
07783
07784 static int G__G__Ged_281_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07785 {
07786 ((TGedPatternFrame*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07787 G__setnull(result7);
07788 return(1 || funcname || hash || result7 || libp) ;
07789 }
07790
07791 static int G__G__Ged_281_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07792 {
07793 G__letint(result7, 67, (long) TGedPatternFrame::DeclFileName());
07794 return(1 || funcname || hash || result7 || libp) ;
07795 }
07796
07797 static int G__G__Ged_281_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07798 {
07799 G__letint(result7, 105, (long) TGedPatternFrame::ImplFileLine());
07800 return(1 || funcname || hash || result7 || libp) ;
07801 }
07802
07803 static int G__G__Ged_281_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07804 {
07805 G__letint(result7, 67, (long) TGedPatternFrame::ImplFileName());
07806 return(1 || funcname || hash || result7 || libp) ;
07807 }
07808
07809 static int G__G__Ged_281_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07810 {
07811 G__letint(result7, 105, (long) TGedPatternFrame::DeclFileLine());
07812 return(1 || funcname || hash || result7 || libp) ;
07813 }
07814
07815
07816 typedef TGedPatternFrame G__TTGedPatternFrame;
07817 static int G__G__Ged_281_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07818 {
07819 char* gvp = (char*) G__getgvp();
07820 long soff = G__getstructoffset();
07821 int n = G__getaryconstruct();
07822
07823
07824
07825
07826
07827 if (!soff) {
07828 return(1);
07829 }
07830 if (n) {
07831 if (gvp == (char*)G__PVOID) {
07832 delete[] (TGedPatternFrame*) soff;
07833 } else {
07834 G__setgvp((long) G__PVOID);
07835 for (int i = n - 1; i >= 0; --i) {
07836 ((TGedPatternFrame*) (soff+(sizeof(TGedPatternFrame)*i)))->~G__TTGedPatternFrame();
07837 }
07838 G__setgvp((long)gvp);
07839 }
07840 } else {
07841 if (gvp == (char*)G__PVOID) {
07842 delete (TGedPatternFrame*) soff;
07843 } else {
07844 G__setgvp((long) G__PVOID);
07845 ((TGedPatternFrame*) (soff))->~G__TTGedPatternFrame();
07846 G__setgvp((long)gvp);
07847 }
07848 }
07849 G__setnull(result7);
07850 return(1 || funcname || hash || result7 || libp) ;
07851 }
07852
07853
07854
07855 static int G__G__Ged_282_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07856 {
07857 TGedPatternSelector* p = NULL;
07858 char* gvp = (char*) G__getgvp();
07859
07860 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07861 p = new TGedPatternSelector((TGWindow*) G__int(libp->para[0]));
07862 } else {
07863 p = new((void*) gvp) TGedPatternSelector((TGWindow*) G__int(libp->para[0]));
07864 }
07865 result7->obj.i = (long) p;
07866 result7->ref = (long) p;
07867 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector));
07868 return(1 || funcname || hash || result7 || libp) ;
07869 }
07870
07871 static int G__G__Ged_282_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07872 {
07873 ((TGedPatternSelector*) G__getstructoffset())->SetActive((Int_t) G__int(libp->para[0]));
07874 G__setnull(result7);
07875 return(1 || funcname || hash || result7 || libp) ;
07876 }
07877
07878 static int G__G__Ged_282_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07879 {
07880 G__letint(result7, 105, (long) ((const TGedPatternSelector*) G__getstructoffset())->GetActive());
07881 return(1 || funcname || hash || result7 || libp) ;
07882 }
07883
07884 static int G__G__Ged_282_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07885 {
07886 G__letint(result7, 85, (long) TGedPatternSelector::Class());
07887 return(1 || funcname || hash || result7 || libp) ;
07888 }
07889
07890 static int G__G__Ged_282_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07891 {
07892 G__letint(result7, 67, (long) TGedPatternSelector::Class_Name());
07893 return(1 || funcname || hash || result7 || libp) ;
07894 }
07895
07896 static int G__G__Ged_282_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07897 {
07898 G__letint(result7, 115, (long) TGedPatternSelector::Class_Version());
07899 return(1 || funcname || hash || result7 || libp) ;
07900 }
07901
07902 static int G__G__Ged_282_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07903 {
07904 TGedPatternSelector::Dictionary();
07905 G__setnull(result7);
07906 return(1 || funcname || hash || result7 || libp) ;
07907 }
07908
07909 static int G__G__Ged_282_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07910 {
07911 ((TGedPatternSelector*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07912 G__setnull(result7);
07913 return(1 || funcname || hash || result7 || libp) ;
07914 }
07915
07916 static int G__G__Ged_282_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07917 {
07918 G__letint(result7, 67, (long) TGedPatternSelector::DeclFileName());
07919 return(1 || funcname || hash || result7 || libp) ;
07920 }
07921
07922 static int G__G__Ged_282_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07923 {
07924 G__letint(result7, 105, (long) TGedPatternSelector::ImplFileLine());
07925 return(1 || funcname || hash || result7 || libp) ;
07926 }
07927
07928 static int G__G__Ged_282_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07929 {
07930 G__letint(result7, 67, (long) TGedPatternSelector::ImplFileName());
07931 return(1 || funcname || hash || result7 || libp) ;
07932 }
07933
07934 static int G__G__Ged_282_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07935 {
07936 G__letint(result7, 105, (long) TGedPatternSelector::DeclFileLine());
07937 return(1 || funcname || hash || result7 || libp) ;
07938 }
07939
07940
07941 typedef TGedPatternSelector G__TTGedPatternSelector;
07942 static int G__G__Ged_282_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07943 {
07944 char* gvp = (char*) G__getgvp();
07945 long soff = G__getstructoffset();
07946 int n = G__getaryconstruct();
07947
07948
07949
07950
07951
07952 if (!soff) {
07953 return(1);
07954 }
07955 if (n) {
07956 if (gvp == (char*)G__PVOID) {
07957 delete[] (TGedPatternSelector*) soff;
07958 } else {
07959 G__setgvp((long) G__PVOID);
07960 for (int i = n - 1; i >= 0; --i) {
07961 ((TGedPatternSelector*) (soff+(sizeof(TGedPatternSelector)*i)))->~G__TTGedPatternSelector();
07962 }
07963 G__setgvp((long)gvp);
07964 }
07965 } else {
07966 if (gvp == (char*)G__PVOID) {
07967 delete (TGedPatternSelector*) soff;
07968 } else {
07969 G__setgvp((long) G__PVOID);
07970 ((TGedPatternSelector*) (soff))->~G__TTGedPatternSelector();
07971 G__setgvp((long)gvp);
07972 }
07973 }
07974 G__setnull(result7);
07975 return(1 || funcname || hash || result7 || libp) ;
07976 }
07977
07978
07979
07980 static int G__G__Ged_283_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07981 {
07982 TGedPatternPopup* p = NULL;
07983 char* gvp = (char*) G__getgvp();
07984
07985 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07986 p = new TGedPatternPopup(
07987 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07988 , (Style_t) G__int(libp->para[2]));
07989 } else {
07990 p = new((void*) gvp) TGedPatternPopup(
07991 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
07992 , (Style_t) G__int(libp->para[2]));
07993 }
07994 result7->obj.i = (long) p;
07995 result7->ref = (long) p;
07996 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup));
07997 return(1 || funcname || hash || result7 || libp) ;
07998 }
07999
08000 static int G__G__Ged_283_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08001 {
08002 G__letint(result7, 85, (long) TGedPatternPopup::Class());
08003 return(1 || funcname || hash || result7 || libp) ;
08004 }
08005
08006 static int G__G__Ged_283_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08007 {
08008 G__letint(result7, 67, (long) TGedPatternPopup::Class_Name());
08009 return(1 || funcname || hash || result7 || libp) ;
08010 }
08011
08012 static int G__G__Ged_283_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08013 {
08014 G__letint(result7, 115, (long) TGedPatternPopup::Class_Version());
08015 return(1 || funcname || hash || result7 || libp) ;
08016 }
08017
08018 static int G__G__Ged_283_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08019 {
08020 TGedPatternPopup::Dictionary();
08021 G__setnull(result7);
08022 return(1 || funcname || hash || result7 || libp) ;
08023 }
08024
08025 static int G__G__Ged_283_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08026 {
08027 ((TGedPatternPopup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08028 G__setnull(result7);
08029 return(1 || funcname || hash || result7 || libp) ;
08030 }
08031
08032 static int G__G__Ged_283_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08033 {
08034 G__letint(result7, 67, (long) TGedPatternPopup::DeclFileName());
08035 return(1 || funcname || hash || result7 || libp) ;
08036 }
08037
08038 static int G__G__Ged_283_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08039 {
08040 G__letint(result7, 105, (long) TGedPatternPopup::ImplFileLine());
08041 return(1 || funcname || hash || result7 || libp) ;
08042 }
08043
08044 static int G__G__Ged_283_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08045 {
08046 G__letint(result7, 67, (long) TGedPatternPopup::ImplFileName());
08047 return(1 || funcname || hash || result7 || libp) ;
08048 }
08049
08050 static int G__G__Ged_283_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08051 {
08052 G__letint(result7, 105, (long) TGedPatternPopup::DeclFileLine());
08053 return(1 || funcname || hash || result7 || libp) ;
08054 }
08055
08056
08057 typedef TGedPatternPopup G__TTGedPatternPopup;
08058 static int G__G__Ged_283_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08059 {
08060 char* gvp = (char*) G__getgvp();
08061 long soff = G__getstructoffset();
08062 int n = G__getaryconstruct();
08063
08064
08065
08066
08067
08068 if (!soff) {
08069 return(1);
08070 }
08071 if (n) {
08072 if (gvp == (char*)G__PVOID) {
08073 delete[] (TGedPatternPopup*) soff;
08074 } else {
08075 G__setgvp((long) G__PVOID);
08076 for (int i = n - 1; i >= 0; --i) {
08077 ((TGedPatternPopup*) (soff+(sizeof(TGedPatternPopup)*i)))->~G__TTGedPatternPopup();
08078 }
08079 G__setgvp((long)gvp);
08080 }
08081 } else {
08082 if (gvp == (char*)G__PVOID) {
08083 delete (TGedPatternPopup*) soff;
08084 } else {
08085 G__setgvp((long) G__PVOID);
08086 ((TGedPatternPopup*) (soff))->~G__TTGedPatternPopup();
08087 G__setgvp((long)gvp);
08088 }
08089 }
08090 G__setnull(result7);
08091 return(1 || funcname || hash || result7 || libp) ;
08092 }
08093
08094
08095
08096 static int G__G__Ged_284_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08097 {
08098 TGedSelect* p = NULL;
08099 char* gvp = (char*) G__getgvp();
08100
08101 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08102 p = new TGedSelect((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08103 } else {
08104 p = new((void*) gvp) TGedSelect((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08105 }
08106 result7->obj.i = (long) p;
08107 result7->ref = (long) p;
08108 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedSelect));
08109 return(1 || funcname || hash || result7 || libp) ;
08110 }
08111
08112 static int G__G__Ged_284_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08113 {
08114 ((TGedSelect*) G__getstructoffset())->Enable();
08115 G__setnull(result7);
08116 return(1 || funcname || hash || result7 || libp) ;
08117 }
08118
08119 static int G__G__Ged_284_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08120 {
08121 ((TGedSelect*) G__getstructoffset())->Disable();
08122 G__setnull(result7);
08123 return(1 || funcname || hash || result7 || libp) ;
08124 }
08125
08126 static int G__G__Ged_284_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08127 {
08128 ((TGedSelect*) G__getstructoffset())->SetPopup((TGedPopup*) G__int(libp->para[0]));
08129 G__setnull(result7);
08130 return(1 || funcname || hash || result7 || libp) ;
08131 }
08132
08133 static int G__G__Ged_284_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08134 {
08135 G__letint(result7, 85, (long) TGedSelect::Class());
08136 return(1 || funcname || hash || result7 || libp) ;
08137 }
08138
08139 static int G__G__Ged_284_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08140 {
08141 G__letint(result7, 67, (long) TGedSelect::Class_Name());
08142 return(1 || funcname || hash || result7 || libp) ;
08143 }
08144
08145 static int G__G__Ged_284_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08146 {
08147 G__letint(result7, 115, (long) TGedSelect::Class_Version());
08148 return(1 || funcname || hash || result7 || libp) ;
08149 }
08150
08151 static int G__G__Ged_284_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08152 {
08153 TGedSelect::Dictionary();
08154 G__setnull(result7);
08155 return(1 || funcname || hash || result7 || libp) ;
08156 }
08157
08158 static int G__G__Ged_284_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08159 {
08160 ((TGedSelect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08161 G__setnull(result7);
08162 return(1 || funcname || hash || result7 || libp) ;
08163 }
08164
08165 static int G__G__Ged_284_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08166 {
08167 G__letint(result7, 67, (long) TGedSelect::DeclFileName());
08168 return(1 || funcname || hash || result7 || libp) ;
08169 }
08170
08171 static int G__G__Ged_284_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08172 {
08173 G__letint(result7, 105, (long) TGedSelect::ImplFileLine());
08174 return(1 || funcname || hash || result7 || libp) ;
08175 }
08176
08177 static int G__G__Ged_284_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08178 {
08179 G__letint(result7, 67, (long) TGedSelect::ImplFileName());
08180 return(1 || funcname || hash || result7 || libp) ;
08181 }
08182
08183 static int G__G__Ged_284_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08184 {
08185 G__letint(result7, 105, (long) TGedSelect::DeclFileLine());
08186 return(1 || funcname || hash || result7 || libp) ;
08187 }
08188
08189
08190 typedef TGedSelect G__TTGedSelect;
08191 static int G__G__Ged_284_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08192 {
08193 char* gvp = (char*) G__getgvp();
08194 long soff = G__getstructoffset();
08195 int n = G__getaryconstruct();
08196
08197
08198
08199
08200
08201 if (!soff) {
08202 return(1);
08203 }
08204 if (n) {
08205 if (gvp == (char*)G__PVOID) {
08206 delete[] (TGedSelect*) soff;
08207 } else {
08208 G__setgvp((long) G__PVOID);
08209 for (int i = n - 1; i >= 0; --i) {
08210 ((TGedSelect*) (soff+(sizeof(TGedSelect)*i)))->~G__TTGedSelect();
08211 }
08212 G__setgvp((long)gvp);
08213 }
08214 } else {
08215 if (gvp == (char*)G__PVOID) {
08216 delete (TGedSelect*) soff;
08217 } else {
08218 G__setgvp((long) G__PVOID);
08219 ((TGedSelect*) (soff))->~G__TTGedSelect();
08220 G__setgvp((long)gvp);
08221 }
08222 }
08223 G__setnull(result7);
08224 return(1 || funcname || hash || result7 || libp) ;
08225 }
08226
08227
08228
08229 static int G__G__Ged_285_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08230 {
08231 TGedMarkerPopup* p = NULL;
08232 char* gvp = (char*) G__getgvp();
08233
08234 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08235 p = new TGedMarkerPopup(
08236 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
08237 , (Style_t) G__int(libp->para[2]));
08238 } else {
08239 p = new((void*) gvp) TGedMarkerPopup(
08240 (TGWindow*) G__int(libp->para[0]), (TGWindow*) G__int(libp->para[1])
08241 , (Style_t) G__int(libp->para[2]));
08242 }
08243 result7->obj.i = (long) p;
08244 result7->ref = (long) p;
08245 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup));
08246 return(1 || funcname || hash || result7 || libp) ;
08247 }
08248
08249 static int G__G__Ged_285_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08250 {
08251 G__letint(result7, 85, (long) TGedMarkerPopup::Class());
08252 return(1 || funcname || hash || result7 || libp) ;
08253 }
08254
08255 static int G__G__Ged_285_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08256 {
08257 G__letint(result7, 67, (long) TGedMarkerPopup::Class_Name());
08258 return(1 || funcname || hash || result7 || libp) ;
08259 }
08260
08261 static int G__G__Ged_285_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08262 {
08263 G__letint(result7, 115, (long) TGedMarkerPopup::Class_Version());
08264 return(1 || funcname || hash || result7 || libp) ;
08265 }
08266
08267 static int G__G__Ged_285_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08268 {
08269 TGedMarkerPopup::Dictionary();
08270 G__setnull(result7);
08271 return(1 || funcname || hash || result7 || libp) ;
08272 }
08273
08274 static int G__G__Ged_285_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08275 {
08276 ((TGedMarkerPopup*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08277 G__setnull(result7);
08278 return(1 || funcname || hash || result7 || libp) ;
08279 }
08280
08281 static int G__G__Ged_285_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08282 {
08283 G__letint(result7, 67, (long) TGedMarkerPopup::DeclFileName());
08284 return(1 || funcname || hash || result7 || libp) ;
08285 }
08286
08287 static int G__G__Ged_285_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08288 {
08289 G__letint(result7, 105, (long) TGedMarkerPopup::ImplFileLine());
08290 return(1 || funcname || hash || result7 || libp) ;
08291 }
08292
08293 static int G__G__Ged_285_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08294 {
08295 G__letint(result7, 67, (long) TGedMarkerPopup::ImplFileName());
08296 return(1 || funcname || hash || result7 || libp) ;
08297 }
08298
08299 static int G__G__Ged_285_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08300 {
08301 G__letint(result7, 105, (long) TGedMarkerPopup::DeclFileLine());
08302 return(1 || funcname || hash || result7 || libp) ;
08303 }
08304
08305
08306 typedef TGedMarkerPopup G__TTGedMarkerPopup;
08307 static int G__G__Ged_285_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08308 {
08309 char* gvp = (char*) G__getgvp();
08310 long soff = G__getstructoffset();
08311 int n = G__getaryconstruct();
08312
08313
08314
08315
08316
08317 if (!soff) {
08318 return(1);
08319 }
08320 if (n) {
08321 if (gvp == (char*)G__PVOID) {
08322 delete[] (TGedMarkerPopup*) soff;
08323 } else {
08324 G__setgvp((long) G__PVOID);
08325 for (int i = n - 1; i >= 0; --i) {
08326 ((TGedMarkerPopup*) (soff+(sizeof(TGedMarkerPopup)*i)))->~G__TTGedMarkerPopup();
08327 }
08328 G__setgvp((long)gvp);
08329 }
08330 } else {
08331 if (gvp == (char*)G__PVOID) {
08332 delete (TGedMarkerPopup*) soff;
08333 } else {
08334 G__setgvp((long) G__PVOID);
08335 ((TGedMarkerPopup*) (soff))->~G__TTGedMarkerPopup();
08336 G__setgvp((long)gvp);
08337 }
08338 }
08339 G__setnull(result7);
08340 return(1 || funcname || hash || result7 || libp) ;
08341 }
08342
08343
08344
08345 static int G__G__Ged_287_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08346 {
08347 TGraphEditor* p = NULL;
08348 char* gvp = (char*) G__getgvp();
08349 switch (libp->paran) {
08350 case 5:
08351
08352 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08353 p = new TGraphEditor(
08354 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08355 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08356 , (Pixel_t) G__int(libp->para[4]));
08357 } else {
08358 p = new((void*) gvp) TGraphEditor(
08359 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08360 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08361 , (Pixel_t) G__int(libp->para[4]));
08362 }
08363 break;
08364 case 4:
08365
08366 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08367 p = new TGraphEditor(
08368 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08369 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08370 } else {
08371 p = new((void*) gvp) TGraphEditor(
08372 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08373 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08374 }
08375 break;
08376 case 3:
08377
08378 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08379 p = new TGraphEditor(
08380 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08381 , (Int_t) G__int(libp->para[2]));
08382 } else {
08383 p = new((void*) gvp) TGraphEditor(
08384 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08385 , (Int_t) G__int(libp->para[2]));
08386 }
08387 break;
08388 case 2:
08389
08390 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08391 p = new TGraphEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08392 } else {
08393 p = new((void*) gvp) TGraphEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08394 }
08395 break;
08396 case 1:
08397
08398 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08399 p = new TGraphEditor((TGWindow*) G__int(libp->para[0]));
08400 } else {
08401 p = new((void*) gvp) TGraphEditor((TGWindow*) G__int(libp->para[0]));
08402 }
08403 break;
08404 case 0:
08405 int n = G__getaryconstruct();
08406 if (n) {
08407 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08408 p = new TGraphEditor[n];
08409 } else {
08410 p = new((void*) gvp) TGraphEditor[n];
08411 }
08412 } else {
08413 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08414 p = new TGraphEditor;
08415 } else {
08416 p = new((void*) gvp) TGraphEditor;
08417 }
08418 }
08419 break;
08420 }
08421 result7->obj.i = (long) p;
08422 result7->ref = (long) p;
08423 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TGraphEditor));
08424 return(1 || funcname || hash || result7 || libp) ;
08425 }
08426
08427 static int G__G__Ged_287_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08428 {
08429 ((TGraphEditor*) G__getstructoffset())->DoShape();
08430 G__setnull(result7);
08431 return(1 || funcname || hash || result7 || libp) ;
08432 }
08433
08434 static int G__G__Ged_287_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08435 {
08436 ((TGraphEditor*) G__getstructoffset())->DoMarkerOnOff((Bool_t) G__int(libp->para[0]));
08437 G__setnull(result7);
08438 return(1 || funcname || hash || result7 || libp) ;
08439 }
08440
08441 static int G__G__Ged_287_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08442 {
08443 ((TGraphEditor*) G__getstructoffset())->DoTitle((const char*) G__int(libp->para[0]));
08444 G__setnull(result7);
08445 return(1 || funcname || hash || result7 || libp) ;
08446 }
08447
08448 static int G__G__Ged_287_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08449 {
08450 ((TGraphEditor*) G__getstructoffset())->DoGraphLineWidth();
08451 G__setnull(result7);
08452 return(1 || funcname || hash || result7 || libp) ;
08453 }
08454
08455 static int G__G__Ged_287_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08456 {
08457 G__letint(result7, 85, (long) TGraphEditor::Class());
08458 return(1 || funcname || hash || result7 || libp) ;
08459 }
08460
08461 static int G__G__Ged_287_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08462 {
08463 G__letint(result7, 67, (long) TGraphEditor::Class_Name());
08464 return(1 || funcname || hash || result7 || libp) ;
08465 }
08466
08467 static int G__G__Ged_287_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08468 {
08469 G__letint(result7, 115, (long) TGraphEditor::Class_Version());
08470 return(1 || funcname || hash || result7 || libp) ;
08471 }
08472
08473 static int G__G__Ged_287_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08474 {
08475 TGraphEditor::Dictionary();
08476 G__setnull(result7);
08477 return(1 || funcname || hash || result7 || libp) ;
08478 }
08479
08480 static int G__G__Ged_287_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08481 {
08482 ((TGraphEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08483 G__setnull(result7);
08484 return(1 || funcname || hash || result7 || libp) ;
08485 }
08486
08487 static int G__G__Ged_287_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08488 {
08489 G__letint(result7, 67, (long) TGraphEditor::DeclFileName());
08490 return(1 || funcname || hash || result7 || libp) ;
08491 }
08492
08493 static int G__G__Ged_287_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08494 {
08495 G__letint(result7, 105, (long) TGraphEditor::ImplFileLine());
08496 return(1 || funcname || hash || result7 || libp) ;
08497 }
08498
08499 static int G__G__Ged_287_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08500 {
08501 G__letint(result7, 67, (long) TGraphEditor::ImplFileName());
08502 return(1 || funcname || hash || result7 || libp) ;
08503 }
08504
08505 static int G__G__Ged_287_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08506 {
08507 G__letint(result7, 105, (long) TGraphEditor::DeclFileLine());
08508 return(1 || funcname || hash || result7 || libp) ;
08509 }
08510
08511
08512 typedef TGraphEditor G__TTGraphEditor;
08513 static int G__G__Ged_287_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08514 {
08515 char* gvp = (char*) G__getgvp();
08516 long soff = G__getstructoffset();
08517 int n = G__getaryconstruct();
08518
08519
08520
08521
08522
08523 if (!soff) {
08524 return(1);
08525 }
08526 if (n) {
08527 if (gvp == (char*)G__PVOID) {
08528 delete[] (TGraphEditor*) soff;
08529 } else {
08530 G__setgvp((long) G__PVOID);
08531 for (int i = n - 1; i >= 0; --i) {
08532 ((TGraphEditor*) (soff+(sizeof(TGraphEditor)*i)))->~G__TTGraphEditor();
08533 }
08534 G__setgvp((long)gvp);
08535 }
08536 } else {
08537 if (gvp == (char*)G__PVOID) {
08538 delete (TGraphEditor*) soff;
08539 } else {
08540 G__setgvp((long) G__PVOID);
08541 ((TGraphEditor*) (soff))->~G__TTGraphEditor();
08542 G__setgvp((long)gvp);
08543 }
08544 }
08545 G__setnull(result7);
08546 return(1 || funcname || hash || result7 || libp) ;
08547 }
08548
08549
08550
08551 static int G__G__Ged_291_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08552 {
08553 TH1Editor* p = NULL;
08554 char* gvp = (char*) G__getgvp();
08555 switch (libp->paran) {
08556 case 5:
08557
08558 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08559 p = new TH1Editor(
08560 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08561 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08562 , (Pixel_t) G__int(libp->para[4]));
08563 } else {
08564 p = new((void*) gvp) TH1Editor(
08565 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08566 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08567 , (Pixel_t) G__int(libp->para[4]));
08568 }
08569 break;
08570 case 4:
08571
08572 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08573 p = new TH1Editor(
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 } else {
08577 p = new((void*) gvp) TH1Editor(
08578 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08579 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08580 }
08581 break;
08582 case 3:
08583
08584 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08585 p = new TH1Editor(
08586 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08587 , (Int_t) G__int(libp->para[2]));
08588 } else {
08589 p = new((void*) gvp) TH1Editor(
08590 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08591 , (Int_t) G__int(libp->para[2]));
08592 }
08593 break;
08594 case 2:
08595
08596 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08597 p = new TH1Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08598 } else {
08599 p = new((void*) gvp) TH1Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
08600 }
08601 break;
08602 case 1:
08603
08604 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08605 p = new TH1Editor((TGWindow*) G__int(libp->para[0]));
08606 } else {
08607 p = new((void*) gvp) TH1Editor((TGWindow*) G__int(libp->para[0]));
08608 }
08609 break;
08610 case 0:
08611 int n = G__getaryconstruct();
08612 if (n) {
08613 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08614 p = new TH1Editor[n];
08615 } else {
08616 p = new((void*) gvp) TH1Editor[n];
08617 }
08618 } else {
08619 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08620 p = new TH1Editor;
08621 } else {
08622 p = new((void*) gvp) TH1Editor;
08623 }
08624 }
08625 break;
08626 }
08627 result7->obj.i = (long) p;
08628 result7->ref = (long) p;
08629 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TH1Editor));
08630 return(1 || funcname || hash || result7 || libp) ;
08631 }
08632
08633 static int G__G__Ged_291_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08634 {
08635 ((TH1Editor*) G__getstructoffset())->DoTitle((const char*) G__int(libp->para[0]));
08636 G__setnull(result7);
08637 return(1 || funcname || hash || result7 || libp) ;
08638 }
08639
08640 static int G__G__Ged_291_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08641 {
08642 ((TH1Editor*) G__getstructoffset())->DoAddMarker((Bool_t) G__int(libp->para[0]));
08643 G__setnull(result7);
08644 return(1 || funcname || hash || result7 || libp) ;
08645 }
08646
08647 static int G__G__Ged_291_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08648 {
08649 ((TH1Editor*) G__getstructoffset())->DoAddBar((Bool_t) G__int(libp->para[0]));
08650 G__setnull(result7);
08651 return(1 || funcname || hash || result7 || libp) ;
08652 }
08653
08654 static int G__G__Ged_291_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08655 {
08656 ((TH1Editor*) G__getstructoffset())->DoAddB((Bool_t) G__int(libp->para[0]));
08657 G__setnull(result7);
08658 return(1 || funcname || hash || result7 || libp) ;
08659 }
08660
08661 static int G__G__Ged_291_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08662 {
08663 ((TH1Editor*) G__getstructoffset())->DoAddSimple((Bool_t) G__int(libp->para[0]));
08664 G__setnull(result7);
08665 return(1 || funcname || hash || result7 || libp) ;
08666 }
08667
08668 static int G__G__Ged_291_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08669 {
08670 ((TH1Editor*) G__getstructoffset())->DoHistSimple();
08671 G__setnull(result7);
08672 return(1 || funcname || hash || result7 || libp) ;
08673 }
08674
08675 static int G__G__Ged_291_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08676 {
08677 ((TH1Editor*) G__getstructoffset())->DoHistComplex();
08678 G__setnull(result7);
08679 return(1 || funcname || hash || result7 || libp) ;
08680 }
08681
08682 static int G__G__Ged_291_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08683 {
08684 ((TH1Editor*) G__getstructoffset())->DoHistChanges();
08685 G__setnull(result7);
08686 return(1 || funcname || hash || result7 || libp) ;
08687 }
08688
08689 static int G__G__Ged_291_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08690 {
08691 ((TH1Editor*) G__getstructoffset())->DoHistView();
08692 G__setnull(result7);
08693 return(1 || funcname || hash || result7 || libp) ;
08694 }
08695
08696 static int G__G__Ged_291_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08697 {
08698 ((TH1Editor*) G__getstructoffset())->DoBarOffset();
08699 G__setnull(result7);
08700 return(1 || funcname || hash || result7 || libp) ;
08701 }
08702
08703 static int G__G__Ged_291_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08704 {
08705 ((TH1Editor*) G__getstructoffset())->DoBarWidth();
08706 G__setnull(result7);
08707 return(1 || funcname || hash || result7 || libp) ;
08708 }
08709
08710 static int G__G__Ged_291_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08711 {
08712 ((TH1Editor*) G__getstructoffset())->DoPercent();
08713 G__setnull(result7);
08714 return(1 || funcname || hash || result7 || libp) ;
08715 }
08716
08717 static int G__G__Ged_291_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08718 {
08719 ((TH1Editor*) G__getstructoffset())->DoHBar((Bool_t) G__int(libp->para[0]));
08720 G__setnull(result7);
08721 return(1 || funcname || hash || result7 || libp) ;
08722 }
08723
08724 static int G__G__Ged_291_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08725 {
08726 ((TH1Editor*) G__getstructoffset())->DoSliderMoved();
08727 G__setnull(result7);
08728 return(1 || funcname || hash || result7 || libp) ;
08729 }
08730
08731 static int G__G__Ged_291_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08732 {
08733 ((TH1Editor*) G__getstructoffset())->DoSliderPressed();
08734 G__setnull(result7);
08735 return(1 || funcname || hash || result7 || libp) ;
08736 }
08737
08738 static int G__G__Ged_291_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08739 {
08740 ((TH1Editor*) G__getstructoffset())->DoSliderReleased();
08741 G__setnull(result7);
08742 return(1 || funcname || hash || result7 || libp) ;
08743 }
08744
08745 static int G__G__Ged_291_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08746 {
08747 ((TH1Editor*) G__getstructoffset())->DoAxisRange();
08748 G__setnull(result7);
08749 return(1 || funcname || hash || result7 || libp) ;
08750 }
08751
08752 static int G__G__Ged_291_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08753 {
08754 ((TH1Editor*) G__getstructoffset())->DoBinMoved((Int_t) G__int(libp->para[0]));
08755 G__setnull(result7);
08756 return(1 || funcname || hash || result7 || libp) ;
08757 }
08758
08759 static int G__G__Ged_291_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08760 {
08761 ((TH1Editor*) G__getstructoffset())->DoBinReleased();
08762 G__setnull(result7);
08763 return(1 || funcname || hash || result7 || libp) ;
08764 }
08765
08766 static int G__G__Ged_291_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08767 {
08768 ((TH1Editor*) G__getstructoffset())->DoBinPressed();
08769 G__setnull(result7);
08770 return(1 || funcname || hash || result7 || libp) ;
08771 }
08772
08773 static int G__G__Ged_291_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08774 {
08775 ((TH1Editor*) G__getstructoffset())->DoBinLabel();
08776 G__setnull(result7);
08777 return(1 || funcname || hash || result7 || libp) ;
08778 }
08779
08780 static int G__G__Ged_291_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08781 {
08782 ((TH1Editor*) G__getstructoffset())->DoBinReleased1();
08783 G__setnull(result7);
08784 return(1 || funcname || hash || result7 || libp) ;
08785 }
08786
08787 static int G__G__Ged_291_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08788 {
08789 ((TH1Editor*) G__getstructoffset())->DoBinMoved1();
08790 G__setnull(result7);
08791 return(1 || funcname || hash || result7 || libp) ;
08792 }
08793
08794 static int G__G__Ged_291_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08795 {
08796 ((TH1Editor*) G__getstructoffset())->DoBinLabel1();
08797 G__setnull(result7);
08798 return(1 || funcname || hash || result7 || libp) ;
08799 }
08800
08801 static int G__G__Ged_291_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08802 {
08803 ((TH1Editor*) G__getstructoffset())->DoOffsetMoved((Int_t) G__int(libp->para[0]));
08804 G__setnull(result7);
08805 return(1 || funcname || hash || result7 || libp) ;
08806 }
08807
08808 static int G__G__Ged_291_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08809 {
08810 ((TH1Editor*) G__getstructoffset())->DoOffsetReleased();
08811 G__setnull(result7);
08812 return(1 || funcname || hash || result7 || libp) ;
08813 }
08814
08815 static int G__G__Ged_291_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08816 {
08817 ((TH1Editor*) G__getstructoffset())->DoOffsetPressed();
08818 G__setnull(result7);
08819 return(1 || funcname || hash || result7 || libp) ;
08820 }
08821
08822 static int G__G__Ged_291_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08823 {
08824 ((TH1Editor*) G__getstructoffset())->DoBinOffset();
08825 G__setnull(result7);
08826 return(1 || funcname || hash || result7 || libp) ;
08827 }
08828
08829 static int G__G__Ged_291_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08830 {
08831 ((TH1Editor*) G__getstructoffset())->DoApply();
08832 G__setnull(result7);
08833 return(1 || funcname || hash || result7 || libp) ;
08834 }
08835
08836 static int G__G__Ged_291_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08837 {
08838 ((TH1Editor*) G__getstructoffset())->DoCancel();
08839 G__setnull(result7);
08840 return(1 || funcname || hash || result7 || libp) ;
08841 }
08842
08843 static int G__G__Ged_291_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08844 {
08845 ((TH1Editor*) G__getstructoffset())->PaintBox3D((Float_t*) G__int(libp->para[0]), (Float_t*) G__int(libp->para[1])
08846 , (Float_t*) G__int(libp->para[2]), (Float_t*) G__int(libp->para[3]));
08847 G__setnull(result7);
08848 return(1 || funcname || hash || result7 || libp) ;
08849 }
08850
08851 static int G__G__Ged_291_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08852 {
08853 G__letint(result7, 73, (long) ((TH1Editor*) G__getstructoffset())->Dividers((Int_t) G__int(libp->para[0])));
08854 return(1 || funcname || hash || result7 || libp) ;
08855 }
08856
08857 static int G__G__Ged_291_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08858 {
08859 G__letint(result7, 85, (long) TH1Editor::Class());
08860 return(1 || funcname || hash || result7 || libp) ;
08861 }
08862
08863 static int G__G__Ged_291_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08864 {
08865 G__letint(result7, 67, (long) TH1Editor::Class_Name());
08866 return(1 || funcname || hash || result7 || libp) ;
08867 }
08868
08869 static int G__G__Ged_291_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08870 {
08871 G__letint(result7, 115, (long) TH1Editor::Class_Version());
08872 return(1 || funcname || hash || result7 || libp) ;
08873 }
08874
08875 static int G__G__Ged_291_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08876 {
08877 TH1Editor::Dictionary();
08878 G__setnull(result7);
08879 return(1 || funcname || hash || result7 || libp) ;
08880 }
08881
08882 static int G__G__Ged_291_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08883 {
08884 ((TH1Editor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08885 G__setnull(result7);
08886 return(1 || funcname || hash || result7 || libp) ;
08887 }
08888
08889 static int G__G__Ged_291_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08890 {
08891 G__letint(result7, 67, (long) TH1Editor::DeclFileName());
08892 return(1 || funcname || hash || result7 || libp) ;
08893 }
08894
08895 static int G__G__Ged_291_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08896 {
08897 G__letint(result7, 105, (long) TH1Editor::ImplFileLine());
08898 return(1 || funcname || hash || result7 || libp) ;
08899 }
08900
08901 static int G__G__Ged_291_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08902 {
08903 G__letint(result7, 67, (long) TH1Editor::ImplFileName());
08904 return(1 || funcname || hash || result7 || libp) ;
08905 }
08906
08907 static int G__G__Ged_291_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08908 {
08909 G__letint(result7, 105, (long) TH1Editor::DeclFileLine());
08910 return(1 || funcname || hash || result7 || libp) ;
08911 }
08912
08913
08914 typedef TH1Editor G__TTH1Editor;
08915 static int G__G__Ged_291_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08916 {
08917 char* gvp = (char*) G__getgvp();
08918 long soff = G__getstructoffset();
08919 int n = G__getaryconstruct();
08920
08921
08922
08923
08924
08925 if (!soff) {
08926 return(1);
08927 }
08928 if (n) {
08929 if (gvp == (char*)G__PVOID) {
08930 delete[] (TH1Editor*) soff;
08931 } else {
08932 G__setgvp((long) G__PVOID);
08933 for (int i = n - 1; i >= 0; --i) {
08934 ((TH1Editor*) (soff+(sizeof(TH1Editor)*i)))->~G__TTH1Editor();
08935 }
08936 G__setgvp((long)gvp);
08937 }
08938 } else {
08939 if (gvp == (char*)G__PVOID) {
08940 delete (TH1Editor*) soff;
08941 } else {
08942 G__setgvp((long) G__PVOID);
08943 ((TH1Editor*) (soff))->~G__TTH1Editor();
08944 G__setgvp((long)gvp);
08945 }
08946 }
08947 G__setnull(result7);
08948 return(1 || funcname || hash || result7 || libp) ;
08949 }
08950
08951
08952
08953 static int G__G__Ged_293_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08954 {
08955 TH2Editor* p = NULL;
08956 char* gvp = (char*) G__getgvp();
08957 switch (libp->paran) {
08958 case 5:
08959
08960 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08961 p = new TH2Editor(
08962 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08963 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08964 , (Pixel_t) G__int(libp->para[4]));
08965 } else {
08966 p = new((void*) gvp) TH2Editor(
08967 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08968 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
08969 , (Pixel_t) G__int(libp->para[4]));
08970 }
08971 break;
08972 case 4:
08973
08974 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08975 p = new TH2Editor(
08976 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08977 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08978 } else {
08979 p = new((void*) gvp) TH2Editor(
08980 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08981 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
08982 }
08983 break;
08984 case 3:
08985
08986 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08987 p = new TH2Editor(
08988 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08989 , (Int_t) G__int(libp->para[2]));
08990 } else {
08991 p = new((void*) gvp) TH2Editor(
08992 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
08993 , (Int_t) G__int(libp->para[2]));
08994 }
08995 break;
08996 case 2:
08997
08998 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08999 p = new TH2Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09000 } else {
09001 p = new((void*) gvp) TH2Editor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09002 }
09003 break;
09004 case 1:
09005
09006 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09007 p = new TH2Editor((TGWindow*) G__int(libp->para[0]));
09008 } else {
09009 p = new((void*) gvp) TH2Editor((TGWindow*) G__int(libp->para[0]));
09010 }
09011 break;
09012 case 0:
09013 int n = G__getaryconstruct();
09014 if (n) {
09015 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09016 p = new TH2Editor[n];
09017 } else {
09018 p = new((void*) gvp) TH2Editor[n];
09019 }
09020 } else {
09021 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09022 p = new TH2Editor;
09023 } else {
09024 p = new((void*) gvp) TH2Editor;
09025 }
09026 }
09027 break;
09028 }
09029 result7->obj.i = (long) p;
09030 result7->ref = (long) p;
09031 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TH2Editor));
09032 return(1 || funcname || hash || result7 || libp) ;
09033 }
09034
09035 static int G__G__Ged_293_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09036 {
09037 ((TH2Editor*) G__getstructoffset())->DoTitle((const char*) G__int(libp->para[0]));
09038 G__setnull(result7);
09039 return(1 || funcname || hash || result7 || libp) ;
09040 }
09041
09042 static int G__G__Ged_293_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09043 {
09044 ((TH2Editor*) G__getstructoffset())->DoHistView();
09045 G__setnull(result7);
09046 return(1 || funcname || hash || result7 || libp) ;
09047 }
09048
09049 static int G__G__Ged_293_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09050 {
09051 ((TH2Editor*) G__getstructoffset())->DoHistSimple();
09052 G__setnull(result7);
09053 return(1 || funcname || hash || result7 || libp) ;
09054 }
09055
09056 static int G__G__Ged_293_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09057 {
09058 ((TH2Editor*) G__getstructoffset())->DoHistComplex();
09059 G__setnull(result7);
09060 return(1 || funcname || hash || result7 || libp) ;
09061 }
09062
09063 static int G__G__Ged_293_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09064 {
09065 ((TH2Editor*) G__getstructoffset())->DoHistChanges();
09066 G__setnull(result7);
09067 return(1 || funcname || hash || result7 || libp) ;
09068 }
09069
09070 static int G__G__Ged_293_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09071 {
09072 ((TH2Editor*) G__getstructoffset())->DoAddArr((Bool_t) G__int(libp->para[0]));
09073 G__setnull(result7);
09074 return(1 || funcname || hash || result7 || libp) ;
09075 }
09076
09077 static int G__G__Ged_293_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09078 {
09079 ((TH2Editor*) G__getstructoffset())->DoAddBox((Bool_t) G__int(libp->para[0]));
09080 G__setnull(result7);
09081 return(1 || funcname || hash || result7 || libp) ;
09082 }
09083
09084 static int G__G__Ged_293_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09085 {
09086 ((TH2Editor*) G__getstructoffset())->DoAddCol((Bool_t) G__int(libp->para[0]));
09087 G__setnull(result7);
09088 return(1 || funcname || hash || result7 || libp) ;
09089 }
09090
09091 static int G__G__Ged_293_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09092 {
09093 ((TH2Editor*) G__getstructoffset())->DoAddScat((Bool_t) G__int(libp->para[0]));
09094 G__setnull(result7);
09095 return(1 || funcname || hash || result7 || libp) ;
09096 }
09097
09098 static int G__G__Ged_293_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09099 {
09100 ((TH2Editor*) G__getstructoffset())->DoAddText((Bool_t) G__int(libp->para[0]));
09101 G__setnull(result7);
09102 return(1 || funcname || hash || result7 || libp) ;
09103 }
09104
09105 static int G__G__Ged_293_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09106 {
09107 ((TH2Editor*) G__getstructoffset())->DoAddError((Bool_t) G__int(libp->para[0]));
09108 G__setnull(result7);
09109 return(1 || funcname || hash || result7 || libp) ;
09110 }
09111
09112 static int G__G__Ged_293_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09113 {
09114 ((TH2Editor*) G__getstructoffset())->DoAddPalette((Bool_t) G__int(libp->para[0]));
09115 G__setnull(result7);
09116 return(1 || funcname || hash || result7 || libp) ;
09117 }
09118
09119 static int G__G__Ged_293_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09120 {
09121 ((TH2Editor*) G__getstructoffset())->DoAddFB();
09122 G__setnull(result7);
09123 return(1 || funcname || hash || result7 || libp) ;
09124 }
09125
09126 static int G__G__Ged_293_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09127 {
09128 ((TH2Editor*) G__getstructoffset())->DoAddBB();
09129 G__setnull(result7);
09130 return(1 || funcname || hash || result7 || libp) ;
09131 }
09132
09133 static int G__G__Ged_293_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09134 {
09135 ((TH2Editor*) G__getstructoffset())->DoContLevel();
09136 G__setnull(result7);
09137 return(1 || funcname || hash || result7 || libp) ;
09138 }
09139
09140 static int G__G__Ged_293_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09141 {
09142 ((TH2Editor*) G__getstructoffset())->DoContLevel1();
09143 G__setnull(result7);
09144 return(1 || funcname || hash || result7 || libp) ;
09145 }
09146
09147 static int G__G__Ged_293_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09148 {
09149 ((TH2Editor*) G__getstructoffset())->DoBarWidth();
09150 G__setnull(result7);
09151 return(1 || funcname || hash || result7 || libp) ;
09152 }
09153
09154 static int G__G__Ged_293_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09155 {
09156 ((TH2Editor*) G__getstructoffset())->DoBarOffset();
09157 G__setnull(result7);
09158 return(1 || funcname || hash || result7 || libp) ;
09159 }
09160
09161 static int G__G__Ged_293_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09162 {
09163 ((TH2Editor*) G__getstructoffset())->DoBinPressed();
09164 G__setnull(result7);
09165 return(1 || funcname || hash || result7 || libp) ;
09166 }
09167
09168 static int G__G__Ged_293_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09169 {
09170 ((TH2Editor*) G__getstructoffset())->DoBinMoved();
09171 G__setnull(result7);
09172 return(1 || funcname || hash || result7 || libp) ;
09173 }
09174
09175 static int G__G__Ged_293_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09176 {
09177 ((TH2Editor*) G__getstructoffset())->DoBinReleased();
09178 G__setnull(result7);
09179 return(1 || funcname || hash || result7 || libp) ;
09180 }
09181
09182 static int G__G__Ged_293_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09183 {
09184 ((TH2Editor*) G__getstructoffset())->DoBinLabel();
09185 G__setnull(result7);
09186 return(1 || funcname || hash || result7 || libp) ;
09187 }
09188
09189 static int G__G__Ged_293_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09190 {
09191 ((TH2Editor*) G__getstructoffset())->DoApply();
09192 G__setnull(result7);
09193 return(1 || funcname || hash || result7 || libp) ;
09194 }
09195
09196 static int G__G__Ged_293_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09197 {
09198 ((TH2Editor*) G__getstructoffset())->DoCancel();
09199 G__setnull(result7);
09200 return(1 || funcname || hash || result7 || libp) ;
09201 }
09202
09203 static int G__G__Ged_293_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09204 {
09205 ((TH2Editor*) G__getstructoffset())->DoBinReleased1();
09206 G__setnull(result7);
09207 return(1 || funcname || hash || result7 || libp) ;
09208 }
09209
09210 static int G__G__Ged_293_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09211 {
09212 ((TH2Editor*) G__getstructoffset())->DoBinMoved1();
09213 G__setnull(result7);
09214 return(1 || funcname || hash || result7 || libp) ;
09215 }
09216
09217 static int G__G__Ged_293_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09218 {
09219 ((TH2Editor*) G__getstructoffset())->DoBinLabel1();
09220 G__setnull(result7);
09221 return(1 || funcname || hash || result7 || libp) ;
09222 }
09223
09224 static int G__G__Ged_293_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09225 {
09226 ((TH2Editor*) G__getstructoffset())->DoOffsetMoved();
09227 G__setnull(result7);
09228 return(1 || funcname || hash || result7 || libp) ;
09229 }
09230
09231 static int G__G__Ged_293_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09232 {
09233 ((TH2Editor*) G__getstructoffset())->DoOffsetReleased();
09234 G__setnull(result7);
09235 return(1 || funcname || hash || result7 || libp) ;
09236 }
09237
09238 static int G__G__Ged_293_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09239 {
09240 ((TH2Editor*) G__getstructoffset())->DoOffsetPressed();
09241 G__setnull(result7);
09242 return(1 || funcname || hash || result7 || libp) ;
09243 }
09244
09245 static int G__G__Ged_293_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09246 {
09247 ((TH2Editor*) G__getstructoffset())->DoBinOffset();
09248 G__setnull(result7);
09249 return(1 || funcname || hash || result7 || libp) ;
09250 }
09251
09252 static int G__G__Ged_293_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09253 {
09254 ((TH2Editor*) G__getstructoffset())->DoSliderXMoved();
09255 G__setnull(result7);
09256 return(1 || funcname || hash || result7 || libp) ;
09257 }
09258
09259 static int G__G__Ged_293_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09260 {
09261 ((TH2Editor*) G__getstructoffset())->DoSliderXPressed();
09262 G__setnull(result7);
09263 return(1 || funcname || hash || result7 || libp) ;
09264 }
09265
09266 static int G__G__Ged_293_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09267 {
09268 ((TH2Editor*) G__getstructoffset())->DoSliderXReleased();
09269 G__setnull(result7);
09270 return(1 || funcname || hash || result7 || libp) ;
09271 }
09272
09273 static int G__G__Ged_293_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09274 {
09275 ((TH2Editor*) G__getstructoffset())->DoXAxisRange();
09276 G__setnull(result7);
09277 return(1 || funcname || hash || result7 || libp) ;
09278 }
09279
09280 static int G__G__Ged_293_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09281 {
09282 ((TH2Editor*) G__getstructoffset())->DoSliderYMoved();
09283 G__setnull(result7);
09284 return(1 || funcname || hash || result7 || libp) ;
09285 }
09286
09287 static int G__G__Ged_293_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09288 {
09289 ((TH2Editor*) G__getstructoffset())->DoSliderYPressed();
09290 G__setnull(result7);
09291 return(1 || funcname || hash || result7 || libp) ;
09292 }
09293
09294 static int G__G__Ged_293_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09295 {
09296 ((TH2Editor*) G__getstructoffset())->DoSliderYReleased();
09297 G__setnull(result7);
09298 return(1 || funcname || hash || result7 || libp) ;
09299 }
09300
09301 static int G__G__Ged_293_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09302 {
09303 ((TH2Editor*) G__getstructoffset())->DoYAxisRange();
09304 G__setnull(result7);
09305 return(1 || funcname || hash || result7 || libp) ;
09306 }
09307
09308 static int G__G__Ged_293_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09309 {
09310 ((TH2Editor*) G__getstructoffset())->DoFillColor((Pixel_t) G__int(libp->para[0]));
09311 G__setnull(result7);
09312 return(1 || funcname || hash || result7 || libp) ;
09313 }
09314
09315 static int G__G__Ged_293_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09316 {
09317 ((TH2Editor*) G__getstructoffset())->DoFillPattern((Style_t) G__int(libp->para[0]));
09318 G__setnull(result7);
09319 return(1 || funcname || hash || result7 || libp) ;
09320 }
09321
09322 static int G__G__Ged_293_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09323 {
09324 G__letint(result7, 73, (long) ((TH2Editor*) G__getstructoffset())->Dividers((Int_t) G__int(libp->para[0])));
09325 return(1 || funcname || hash || result7 || libp) ;
09326 }
09327
09328 static int G__G__Ged_293_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09329 {
09330 G__letint(result7, 85, (long) TH2Editor::Class());
09331 return(1 || funcname || hash || result7 || libp) ;
09332 }
09333
09334 static int G__G__Ged_293_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09335 {
09336 G__letint(result7, 67, (long) TH2Editor::Class_Name());
09337 return(1 || funcname || hash || result7 || libp) ;
09338 }
09339
09340 static int G__G__Ged_293_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09341 {
09342 G__letint(result7, 115, (long) TH2Editor::Class_Version());
09343 return(1 || funcname || hash || result7 || libp) ;
09344 }
09345
09346 static int G__G__Ged_293_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09347 {
09348 TH2Editor::Dictionary();
09349 G__setnull(result7);
09350 return(1 || funcname || hash || result7 || libp) ;
09351 }
09352
09353 static int G__G__Ged_293_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09354 {
09355 ((TH2Editor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09356 G__setnull(result7);
09357 return(1 || funcname || hash || result7 || libp) ;
09358 }
09359
09360 static int G__G__Ged_293_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09361 {
09362 G__letint(result7, 67, (long) TH2Editor::DeclFileName());
09363 return(1 || funcname || hash || result7 || libp) ;
09364 }
09365
09366 static int G__G__Ged_293_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09367 {
09368 G__letint(result7, 105, (long) TH2Editor::ImplFileLine());
09369 return(1 || funcname || hash || result7 || libp) ;
09370 }
09371
09372 static int G__G__Ged_293_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09373 {
09374 G__letint(result7, 67, (long) TH2Editor::ImplFileName());
09375 return(1 || funcname || hash || result7 || libp) ;
09376 }
09377
09378 static int G__G__Ged_293_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09379 {
09380 G__letint(result7, 105, (long) TH2Editor::DeclFileLine());
09381 return(1 || funcname || hash || result7 || libp) ;
09382 }
09383
09384
09385 typedef TH2Editor G__TTH2Editor;
09386 static int G__G__Ged_293_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09387 {
09388 char* gvp = (char*) G__getgvp();
09389 long soff = G__getstructoffset();
09390 int n = G__getaryconstruct();
09391
09392
09393
09394
09395
09396 if (!soff) {
09397 return(1);
09398 }
09399 if (n) {
09400 if (gvp == (char*)G__PVOID) {
09401 delete[] (TH2Editor*) soff;
09402 } else {
09403 G__setgvp((long) G__PVOID);
09404 for (int i = n - 1; i >= 0; --i) {
09405 ((TH2Editor*) (soff+(sizeof(TH2Editor)*i)))->~G__TTH2Editor();
09406 }
09407 G__setgvp((long)gvp);
09408 }
09409 } else {
09410 if (gvp == (char*)G__PVOID) {
09411 delete (TH2Editor*) soff;
09412 } else {
09413 G__setgvp((long) G__PVOID);
09414 ((TH2Editor*) (soff))->~G__TTH2Editor();
09415 G__setgvp((long)gvp);
09416 }
09417 }
09418 G__setnull(result7);
09419 return(1 || funcname || hash || result7 || libp) ;
09420 }
09421
09422
09423
09424 static int G__G__Ged_295_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09425 {
09426 TLineEditor* p = NULL;
09427 char* gvp = (char*) G__getgvp();
09428 switch (libp->paran) {
09429 case 5:
09430
09431 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09432 p = new TLineEditor(
09433 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09434 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
09435 , (Pixel_t) G__int(libp->para[4]));
09436 } else {
09437 p = new((void*) gvp) TLineEditor(
09438 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09439 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
09440 , (Pixel_t) G__int(libp->para[4]));
09441 }
09442 break;
09443 case 4:
09444
09445 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09446 p = new TLineEditor(
09447 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09448 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09449 } else {
09450 p = new((void*) gvp) TLineEditor(
09451 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09452 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09453 }
09454 break;
09455 case 3:
09456
09457 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09458 p = new TLineEditor(
09459 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09460 , (Int_t) G__int(libp->para[2]));
09461 } else {
09462 p = new((void*) gvp) TLineEditor(
09463 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09464 , (Int_t) G__int(libp->para[2]));
09465 }
09466 break;
09467 case 2:
09468
09469 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09470 p = new TLineEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09471 } else {
09472 p = new((void*) gvp) TLineEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09473 }
09474 break;
09475 case 1:
09476
09477 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09478 p = new TLineEditor((TGWindow*) G__int(libp->para[0]));
09479 } else {
09480 p = new((void*) gvp) TLineEditor((TGWindow*) G__int(libp->para[0]));
09481 }
09482 break;
09483 case 0:
09484 int n = G__getaryconstruct();
09485 if (n) {
09486 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09487 p = new TLineEditor[n];
09488 } else {
09489 p = new((void*) gvp) TLineEditor[n];
09490 }
09491 } else {
09492 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09493 p = new TLineEditor;
09494 } else {
09495 p = new((void*) gvp) TLineEditor;
09496 }
09497 }
09498 break;
09499 }
09500 result7->obj.i = (long) p;
09501 result7->ref = (long) p;
09502 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TLineEditor));
09503 return(1 || funcname || hash || result7 || libp) ;
09504 }
09505
09506 static int G__G__Ged_295_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09507 {
09508 ((TLineEditor*) G__getstructoffset())->DoStartPoint();
09509 G__setnull(result7);
09510 return(1 || funcname || hash || result7 || libp) ;
09511 }
09512
09513 static int G__G__Ged_295_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09514 {
09515 ((TLineEditor*) G__getstructoffset())->DoEndPoint();
09516 G__setnull(result7);
09517 return(1 || funcname || hash || result7 || libp) ;
09518 }
09519
09520 static int G__G__Ged_295_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09521 {
09522 ((TLineEditor*) G__getstructoffset())->DoLineVertical();
09523 G__setnull(result7);
09524 return(1 || funcname || hash || result7 || libp) ;
09525 }
09526
09527 static int G__G__Ged_295_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09528 {
09529 ((TLineEditor*) G__getstructoffset())->DoLineHorizontal();
09530 G__setnull(result7);
09531 return(1 || funcname || hash || result7 || libp) ;
09532 }
09533
09534 static int G__G__Ged_295_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09535 {
09536 G__letint(result7, 85, (long) TLineEditor::Class());
09537 return(1 || funcname || hash || result7 || libp) ;
09538 }
09539
09540 static int G__G__Ged_295_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09541 {
09542 G__letint(result7, 67, (long) TLineEditor::Class_Name());
09543 return(1 || funcname || hash || result7 || libp) ;
09544 }
09545
09546 static int G__G__Ged_295_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09547 {
09548 G__letint(result7, 115, (long) TLineEditor::Class_Version());
09549 return(1 || funcname || hash || result7 || libp) ;
09550 }
09551
09552 static int G__G__Ged_295_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09553 {
09554 TLineEditor::Dictionary();
09555 G__setnull(result7);
09556 return(1 || funcname || hash || result7 || libp) ;
09557 }
09558
09559 static int G__G__Ged_295_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09560 {
09561 ((TLineEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09562 G__setnull(result7);
09563 return(1 || funcname || hash || result7 || libp) ;
09564 }
09565
09566 static int G__G__Ged_295_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09567 {
09568 G__letint(result7, 67, (long) TLineEditor::DeclFileName());
09569 return(1 || funcname || hash || result7 || libp) ;
09570 }
09571
09572 static int G__G__Ged_295_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09573 {
09574 G__letint(result7, 105, (long) TLineEditor::ImplFileLine());
09575 return(1 || funcname || hash || result7 || libp) ;
09576 }
09577
09578 static int G__G__Ged_295_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09579 {
09580 G__letint(result7, 67, (long) TLineEditor::ImplFileName());
09581 return(1 || funcname || hash || result7 || libp) ;
09582 }
09583
09584 static int G__G__Ged_295_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09585 {
09586 G__letint(result7, 105, (long) TLineEditor::DeclFileLine());
09587 return(1 || funcname || hash || result7 || libp) ;
09588 }
09589
09590
09591 typedef TLineEditor G__TTLineEditor;
09592 static int G__G__Ged_295_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09593 {
09594 char* gvp = (char*) G__getgvp();
09595 long soff = G__getstructoffset();
09596 int n = G__getaryconstruct();
09597
09598
09599
09600
09601
09602 if (!soff) {
09603 return(1);
09604 }
09605 if (n) {
09606 if (gvp == (char*)G__PVOID) {
09607 delete[] (TLineEditor*) soff;
09608 } else {
09609 G__setgvp((long) G__PVOID);
09610 for (int i = n - 1; i >= 0; --i) {
09611 ((TLineEditor*) (soff+(sizeof(TLineEditor)*i)))->~G__TTLineEditor();
09612 }
09613 G__setgvp((long)gvp);
09614 }
09615 } else {
09616 if (gvp == (char*)G__PVOID) {
09617 delete (TLineEditor*) soff;
09618 } else {
09619 G__setgvp((long) G__PVOID);
09620 ((TLineEditor*) (soff))->~G__TTLineEditor();
09621 G__setgvp((long)gvp);
09622 }
09623 }
09624 G__setnull(result7);
09625 return(1 || funcname || hash || result7 || libp) ;
09626 }
09627
09628
09629
09630 static int G__G__Ged_297_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09631 {
09632 TPadEditor* p = NULL;
09633 char* gvp = (char*) G__getgvp();
09634 switch (libp->paran) {
09635 case 5:
09636
09637 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09638 p = new TPadEditor(
09639 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09640 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
09641 , (Pixel_t) G__int(libp->para[4]));
09642 } else {
09643 p = new((void*) gvp) TPadEditor(
09644 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09645 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
09646 , (Pixel_t) G__int(libp->para[4]));
09647 }
09648 break;
09649 case 4:
09650
09651 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09652 p = new TPadEditor(
09653 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09654 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09655 } else {
09656 p = new((void*) gvp) TPadEditor(
09657 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09658 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09659 }
09660 break;
09661 case 3:
09662
09663 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09664 p = new TPadEditor(
09665 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09666 , (Int_t) G__int(libp->para[2]));
09667 } else {
09668 p = new((void*) gvp) TPadEditor(
09669 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09670 , (Int_t) G__int(libp->para[2]));
09671 }
09672 break;
09673 case 2:
09674
09675 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09676 p = new TPadEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09677 } else {
09678 p = new((void*) gvp) TPadEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09679 }
09680 break;
09681 case 1:
09682
09683 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09684 p = new TPadEditor((TGWindow*) G__int(libp->para[0]));
09685 } else {
09686 p = new((void*) gvp) TPadEditor((TGWindow*) G__int(libp->para[0]));
09687 }
09688 break;
09689 case 0:
09690 int n = G__getaryconstruct();
09691 if (n) {
09692 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09693 p = new TPadEditor[n];
09694 } else {
09695 p = new((void*) gvp) TPadEditor[n];
09696 }
09697 } else {
09698 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09699 p = new TPadEditor;
09700 } else {
09701 p = new((void*) gvp) TPadEditor;
09702 }
09703 }
09704 break;
09705 }
09706 result7->obj.i = (long) p;
09707 result7->ref = (long) p;
09708 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TPadEditor));
09709 return(1 || funcname || hash || result7 || libp) ;
09710 }
09711
09712 static int G__G__Ged_297_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09713 {
09714 ((TPadEditor*) G__getstructoffset())->DoEditable((Bool_t) G__int(libp->para[0]));
09715 G__setnull(result7);
09716 return(1 || funcname || hash || result7 || libp) ;
09717 }
09718
09719 static int G__G__Ged_297_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09720 {
09721 ((TPadEditor*) G__getstructoffset())->DoCrosshair((Bool_t) G__int(libp->para[0]));
09722 G__setnull(result7);
09723 return(1 || funcname || hash || result7 || libp) ;
09724 }
09725
09726 static int G__G__Ged_297_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09727 {
09728 ((TPadEditor*) G__getstructoffset())->DoFixedAspectRatio((Bool_t) G__int(libp->para[0]));
09729 G__setnull(result7);
09730 return(1 || funcname || hash || result7 || libp) ;
09731 }
09732
09733 static int G__G__Ged_297_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09734 {
09735 ((TPadEditor*) G__getstructoffset())->DoGridX((Bool_t) G__int(libp->para[0]));
09736 G__setnull(result7);
09737 return(1 || funcname || hash || result7 || libp) ;
09738 }
09739
09740 static int G__G__Ged_297_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09741 {
09742 ((TPadEditor*) G__getstructoffset())->DoGridY((Bool_t) G__int(libp->para[0]));
09743 G__setnull(result7);
09744 return(1 || funcname || hash || result7 || libp) ;
09745 }
09746
09747 static int G__G__Ged_297_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09748 {
09749 ((TPadEditor*) G__getstructoffset())->DoLogX((Bool_t) G__int(libp->para[0]));
09750 G__setnull(result7);
09751 return(1 || funcname || hash || result7 || libp) ;
09752 }
09753
09754 static int G__G__Ged_297_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09755 {
09756 ((TPadEditor*) G__getstructoffset())->DoLogY((Bool_t) G__int(libp->para[0]));
09757 G__setnull(result7);
09758 return(1 || funcname || hash || result7 || libp) ;
09759 }
09760
09761 static int G__G__Ged_297_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09762 {
09763 ((TPadEditor*) G__getstructoffset())->DoLogZ((Bool_t) G__int(libp->para[0]));
09764 G__setnull(result7);
09765 return(1 || funcname || hash || result7 || libp) ;
09766 }
09767
09768 static int G__G__Ged_297_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09769 {
09770 ((TPadEditor*) G__getstructoffset())->DoTickX((Bool_t) G__int(libp->para[0]));
09771 G__setnull(result7);
09772 return(1 || funcname || hash || result7 || libp) ;
09773 }
09774
09775 static int G__G__Ged_297_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09776 {
09777 ((TPadEditor*) G__getstructoffset())->DoTickY((Bool_t) G__int(libp->para[0]));
09778 G__setnull(result7);
09779 return(1 || funcname || hash || result7 || libp) ;
09780 }
09781
09782 static int G__G__Ged_297_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09783 {
09784 ((TPadEditor*) G__getstructoffset())->DoBorderMode();
09785 G__setnull(result7);
09786 return(1 || funcname || hash || result7 || libp) ;
09787 }
09788
09789 static int G__G__Ged_297_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09790 {
09791 ((TPadEditor*) G__getstructoffset())->DoBorderSize((Int_t) G__int(libp->para[0]));
09792 G__setnull(result7);
09793 return(1 || funcname || hash || result7 || libp) ;
09794 }
09795
09796 static int G__G__Ged_297_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09797 {
09798 G__letint(result7, 85, (long) TPadEditor::Class());
09799 return(1 || funcname || hash || result7 || libp) ;
09800 }
09801
09802 static int G__G__Ged_297_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09803 {
09804 G__letint(result7, 67, (long) TPadEditor::Class_Name());
09805 return(1 || funcname || hash || result7 || libp) ;
09806 }
09807
09808 static int G__G__Ged_297_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09809 {
09810 G__letint(result7, 115, (long) TPadEditor::Class_Version());
09811 return(1 || funcname || hash || result7 || libp) ;
09812 }
09813
09814 static int G__G__Ged_297_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09815 {
09816 TPadEditor::Dictionary();
09817 G__setnull(result7);
09818 return(1 || funcname || hash || result7 || libp) ;
09819 }
09820
09821 static int G__G__Ged_297_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09822 {
09823 ((TPadEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09824 G__setnull(result7);
09825 return(1 || funcname || hash || result7 || libp) ;
09826 }
09827
09828 static int G__G__Ged_297_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09829 {
09830 G__letint(result7, 67, (long) TPadEditor::DeclFileName());
09831 return(1 || funcname || hash || result7 || libp) ;
09832 }
09833
09834 static int G__G__Ged_297_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09835 {
09836 G__letint(result7, 105, (long) TPadEditor::ImplFileLine());
09837 return(1 || funcname || hash || result7 || libp) ;
09838 }
09839
09840 static int G__G__Ged_297_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09841 {
09842 G__letint(result7, 67, (long) TPadEditor::ImplFileName());
09843 return(1 || funcname || hash || result7 || libp) ;
09844 }
09845
09846 static int G__G__Ged_297_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09847 {
09848 G__letint(result7, 105, (long) TPadEditor::DeclFileLine());
09849 return(1 || funcname || hash || result7 || libp) ;
09850 }
09851
09852
09853 typedef TPadEditor G__TTPadEditor;
09854 static int G__G__Ged_297_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09855 {
09856 char* gvp = (char*) G__getgvp();
09857 long soff = G__getstructoffset();
09858 int n = G__getaryconstruct();
09859
09860
09861
09862
09863
09864 if (!soff) {
09865 return(1);
09866 }
09867 if (n) {
09868 if (gvp == (char*)G__PVOID) {
09869 delete[] (TPadEditor*) soff;
09870 } else {
09871 G__setgvp((long) G__PVOID);
09872 for (int i = n - 1; i >= 0; --i) {
09873 ((TPadEditor*) (soff+(sizeof(TPadEditor)*i)))->~G__TTPadEditor();
09874 }
09875 G__setgvp((long)gvp);
09876 }
09877 } else {
09878 if (gvp == (char*)G__PVOID) {
09879 delete (TPadEditor*) soff;
09880 } else {
09881 G__setgvp((long) G__PVOID);
09882 ((TPadEditor*) (soff))->~G__TTPadEditor();
09883 G__setgvp((long)gvp);
09884 }
09885 }
09886 G__setnull(result7);
09887 return(1 || funcname || hash || result7 || libp) ;
09888 }
09889
09890
09891
09892 static int G__G__Ged_299_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09893 {
09894 TPaveStatsEditor* p = NULL;
09895 char* gvp = (char*) G__getgvp();
09896 switch (libp->paran) {
09897 case 5:
09898
09899 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09900 p = new TPaveStatsEditor(
09901 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09902 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
09903 , (Pixel_t) G__int(libp->para[4]));
09904 } else {
09905 p = new((void*) gvp) TPaveStatsEditor(
09906 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09907 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
09908 , (Pixel_t) G__int(libp->para[4]));
09909 }
09910 break;
09911 case 4:
09912
09913 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09914 p = new TPaveStatsEditor(
09915 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09916 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09917 } else {
09918 p = new((void*) gvp) TPaveStatsEditor(
09919 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09920 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
09921 }
09922 break;
09923 case 3:
09924
09925 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09926 p = new TPaveStatsEditor(
09927 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09928 , (Int_t) G__int(libp->para[2]));
09929 } else {
09930 p = new((void*) gvp) TPaveStatsEditor(
09931 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09932 , (Int_t) G__int(libp->para[2]));
09933 }
09934 break;
09935 case 2:
09936
09937 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09938 p = new TPaveStatsEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09939 } else {
09940 p = new((void*) gvp) TPaveStatsEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09941 }
09942 break;
09943 case 1:
09944
09945 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09946 p = new TPaveStatsEditor((TGWindow*) G__int(libp->para[0]));
09947 } else {
09948 p = new((void*) gvp) TPaveStatsEditor((TGWindow*) G__int(libp->para[0]));
09949 }
09950 break;
09951 case 0:
09952 int n = G__getaryconstruct();
09953 if (n) {
09954 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09955 p = new TPaveStatsEditor[n];
09956 } else {
09957 p = new((void*) gvp) TPaveStatsEditor[n];
09958 }
09959 } else {
09960 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09961 p = new TPaveStatsEditor;
09962 } else {
09963 p = new((void*) gvp) TPaveStatsEditor;
09964 }
09965 }
09966 break;
09967 }
09968 result7->obj.i = (long) p;
09969 result7->ref = (long) p;
09970 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor));
09971 return(1 || funcname || hash || result7 || libp) ;
09972 }
09973
09974 static int G__G__Ged_299_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09975 {
09976 ((TPaveStatsEditor*) G__getstructoffset())->DoStatOptions();
09977 G__setnull(result7);
09978 return(1 || funcname || hash || result7 || libp) ;
09979 }
09980
09981 static int G__G__Ged_299_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09982 {
09983 ((TPaveStatsEditor*) G__getstructoffset())->DoFitOptions();
09984 G__setnull(result7);
09985 return(1 || funcname || hash || result7 || libp) ;
09986 }
09987
09988 static int G__G__Ged_299_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09989 {
09990 ((TPaveStatsEditor*) G__getstructoffset())->SetValuesON((Bool_t) G__int(libp->para[0]));
09991 G__setnull(result7);
09992 return(1 || funcname || hash || result7 || libp) ;
09993 }
09994
09995 static int G__G__Ged_299_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09996 {
09997 G__letint(result7, 85, (long) TPaveStatsEditor::Class());
09998 return(1 || funcname || hash || result7 || libp) ;
09999 }
10000
10001 static int G__G__Ged_299_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10002 {
10003 G__letint(result7, 67, (long) TPaveStatsEditor::Class_Name());
10004 return(1 || funcname || hash || result7 || libp) ;
10005 }
10006
10007 static int G__G__Ged_299_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10008 {
10009 G__letint(result7, 115, (long) TPaveStatsEditor::Class_Version());
10010 return(1 || funcname || hash || result7 || libp) ;
10011 }
10012
10013 static int G__G__Ged_299_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10014 {
10015 TPaveStatsEditor::Dictionary();
10016 G__setnull(result7);
10017 return(1 || funcname || hash || result7 || libp) ;
10018 }
10019
10020 static int G__G__Ged_299_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10021 {
10022 ((TPaveStatsEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10023 G__setnull(result7);
10024 return(1 || funcname || hash || result7 || libp) ;
10025 }
10026
10027 static int G__G__Ged_299_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10028 {
10029 G__letint(result7, 67, (long) TPaveStatsEditor::DeclFileName());
10030 return(1 || funcname || hash || result7 || libp) ;
10031 }
10032
10033 static int G__G__Ged_299_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10034 {
10035 G__letint(result7, 105, (long) TPaveStatsEditor::ImplFileLine());
10036 return(1 || funcname || hash || result7 || libp) ;
10037 }
10038
10039 static int G__G__Ged_299_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10040 {
10041 G__letint(result7, 67, (long) TPaveStatsEditor::ImplFileName());
10042 return(1 || funcname || hash || result7 || libp) ;
10043 }
10044
10045 static int G__G__Ged_299_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10046 {
10047 G__letint(result7, 105, (long) TPaveStatsEditor::DeclFileLine());
10048 return(1 || funcname || hash || result7 || libp) ;
10049 }
10050
10051
10052 typedef TPaveStatsEditor G__TTPaveStatsEditor;
10053 static int G__G__Ged_299_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10054 {
10055 char* gvp = (char*) G__getgvp();
10056 long soff = G__getstructoffset();
10057 int n = G__getaryconstruct();
10058
10059
10060
10061
10062
10063 if (!soff) {
10064 return(1);
10065 }
10066 if (n) {
10067 if (gvp == (char*)G__PVOID) {
10068 delete[] (TPaveStatsEditor*) soff;
10069 } else {
10070 G__setgvp((long) G__PVOID);
10071 for (int i = n - 1; i >= 0; --i) {
10072 ((TPaveStatsEditor*) (soff+(sizeof(TPaveStatsEditor)*i)))->~G__TTPaveStatsEditor();
10073 }
10074 G__setgvp((long)gvp);
10075 }
10076 } else {
10077 if (gvp == (char*)G__PVOID) {
10078 delete (TPaveStatsEditor*) soff;
10079 } else {
10080 G__setgvp((long) G__PVOID);
10081 ((TPaveStatsEditor*) (soff))->~G__TTPaveStatsEditor();
10082 G__setgvp((long)gvp);
10083 }
10084 }
10085 G__setnull(result7);
10086 return(1 || funcname || hash || result7 || libp) ;
10087 }
10088
10089
10090
10091 static int G__G__Ged_301_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10092 {
10093 TPieEditor* p = NULL;
10094 char* gvp = (char*) G__getgvp();
10095 switch (libp->paran) {
10096 case 5:
10097
10098 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10099 p = new TPieEditor(
10100 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10101 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10102 , (Pixel_t) G__int(libp->para[4]));
10103 } else {
10104 p = new((void*) gvp) TPieEditor(
10105 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10106 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10107 , (Pixel_t) G__int(libp->para[4]));
10108 }
10109 break;
10110 case 4:
10111
10112 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10113 p = new TPieEditor(
10114 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10115 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10116 } else {
10117 p = new((void*) gvp) TPieEditor(
10118 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10119 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10120 }
10121 break;
10122 case 3:
10123
10124 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10125 p = new TPieEditor(
10126 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10127 , (Int_t) G__int(libp->para[2]));
10128 } else {
10129 p = new((void*) gvp) TPieEditor(
10130 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10131 , (Int_t) G__int(libp->para[2]));
10132 }
10133 break;
10134 case 2:
10135
10136 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10137 p = new TPieEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10138 } else {
10139 p = new((void*) gvp) TPieEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10140 }
10141 break;
10142 case 1:
10143
10144 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10145 p = new TPieEditor((TGWindow*) G__int(libp->para[0]));
10146 } else {
10147 p = new((void*) gvp) TPieEditor((TGWindow*) G__int(libp->para[0]));
10148 }
10149 break;
10150 case 0:
10151 int n = G__getaryconstruct();
10152 if (n) {
10153 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10154 p = new TPieEditor[n];
10155 } else {
10156 p = new((void*) gvp) TPieEditor[n];
10157 }
10158 } else {
10159 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10160 p = new TPieEditor;
10161 } else {
10162 p = new((void*) gvp) TPieEditor;
10163 }
10164 }
10165 break;
10166 }
10167 result7->obj.i = (long) p;
10168 result7->ref = (long) p;
10169 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TPieEditor));
10170 return(1 || funcname || hash || result7 || libp) ;
10171 }
10172
10173 static int G__G__Ged_301_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10174 {
10175 ((TPieEditor*) G__getstructoffset())->DoShape();
10176 G__setnull(result7);
10177 return(1 || funcname || hash || result7 || libp) ;
10178 }
10179
10180 static int G__G__Ged_301_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10181 {
10182 ((TPieEditor*) G__getstructoffset())->DoMarkerOnOff((Bool_t) G__int(libp->para[0]));
10183 G__setnull(result7);
10184 return(1 || funcname || hash || result7 || libp) ;
10185 }
10186
10187 static int G__G__Ged_301_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10188 {
10189 ((TPieEditor*) G__getstructoffset())->DoTitle((const char*) G__int(libp->para[0]));
10190 G__setnull(result7);
10191 return(1 || funcname || hash || result7 || libp) ;
10192 }
10193
10194 static int G__G__Ged_301_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10195 {
10196 ((TPieEditor*) G__getstructoffset())->DoGraphLineWidth();
10197 G__setnull(result7);
10198 return(1 || funcname || hash || result7 || libp) ;
10199 }
10200
10201 static int G__G__Ged_301_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10202 {
10203 ((TPieEditor*) G__getstructoffset())->DoChange3DAngle();
10204 G__setnull(result7);
10205 return(1 || funcname || hash || result7 || libp) ;
10206 }
10207
10208 static int G__G__Ged_301_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10209 {
10210 ((TPieEditor*) G__getstructoffset())->DoTextChange();
10211 G__setnull(result7);
10212 return(1 || funcname || hash || result7 || libp) ;
10213 }
10214
10215 static int G__G__Ged_301_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10216 {
10217 G__letint(result7, 85, (long) TPieEditor::Class());
10218 return(1 || funcname || hash || result7 || libp) ;
10219 }
10220
10221 static int G__G__Ged_301_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10222 {
10223 G__letint(result7, 67, (long) TPieEditor::Class_Name());
10224 return(1 || funcname || hash || result7 || libp) ;
10225 }
10226
10227 static int G__G__Ged_301_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10228 {
10229 G__letint(result7, 115, (long) TPieEditor::Class_Version());
10230 return(1 || funcname || hash || result7 || libp) ;
10231 }
10232
10233 static int G__G__Ged_301_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10234 {
10235 TPieEditor::Dictionary();
10236 G__setnull(result7);
10237 return(1 || funcname || hash || result7 || libp) ;
10238 }
10239
10240 static int G__G__Ged_301_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10241 {
10242 ((TPieEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10243 G__setnull(result7);
10244 return(1 || funcname || hash || result7 || libp) ;
10245 }
10246
10247 static int G__G__Ged_301_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10248 {
10249 G__letint(result7, 67, (long) TPieEditor::DeclFileName());
10250 return(1 || funcname || hash || result7 || libp) ;
10251 }
10252
10253 static int G__G__Ged_301_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10254 {
10255 G__letint(result7, 105, (long) TPieEditor::ImplFileLine());
10256 return(1 || funcname || hash || result7 || libp) ;
10257 }
10258
10259 static int G__G__Ged_301_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10260 {
10261 G__letint(result7, 67, (long) TPieEditor::ImplFileName());
10262 return(1 || funcname || hash || result7 || libp) ;
10263 }
10264
10265 static int G__G__Ged_301_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10266 {
10267 G__letint(result7, 105, (long) TPieEditor::DeclFileLine());
10268 return(1 || funcname || hash || result7 || libp) ;
10269 }
10270
10271
10272 typedef TPieEditor G__TTPieEditor;
10273 static int G__G__Ged_301_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10274 {
10275 char* gvp = (char*) G__getgvp();
10276 long soff = G__getstructoffset();
10277 int n = G__getaryconstruct();
10278
10279
10280
10281
10282
10283 if (!soff) {
10284 return(1);
10285 }
10286 if (n) {
10287 if (gvp == (char*)G__PVOID) {
10288 delete[] (TPieEditor*) soff;
10289 } else {
10290 G__setgvp((long) G__PVOID);
10291 for (int i = n - 1; i >= 0; --i) {
10292 ((TPieEditor*) (soff+(sizeof(TPieEditor)*i)))->~G__TTPieEditor();
10293 }
10294 G__setgvp((long)gvp);
10295 }
10296 } else {
10297 if (gvp == (char*)G__PVOID) {
10298 delete (TPieEditor*) soff;
10299 } else {
10300 G__setgvp((long) G__PVOID);
10301 ((TPieEditor*) (soff))->~G__TTPieEditor();
10302 G__setgvp((long)gvp);
10303 }
10304 }
10305 G__setnull(result7);
10306 return(1 || funcname || hash || result7 || libp) ;
10307 }
10308
10309
10310
10311 static int G__G__Ged_303_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10312 {
10313 TPieSliceEditor* p = NULL;
10314 char* gvp = (char*) G__getgvp();
10315 switch (libp->paran) {
10316 case 5:
10317
10318 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10319 p = new TPieSliceEditor(
10320 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10321 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10322 , (Pixel_t) G__int(libp->para[4]));
10323 } else {
10324 p = new((void*) gvp) TPieSliceEditor(
10325 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10326 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
10327 , (Pixel_t) G__int(libp->para[4]));
10328 }
10329 break;
10330 case 4:
10331
10332 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10333 p = new TPieSliceEditor(
10334 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10335 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10336 } else {
10337 p = new((void*) gvp) TPieSliceEditor(
10338 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10339 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
10340 }
10341 break;
10342 case 3:
10343
10344 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10345 p = new TPieSliceEditor(
10346 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10347 , (Int_t) G__int(libp->para[2]));
10348 } else {
10349 p = new((void*) gvp) TPieSliceEditor(
10350 (TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10351 , (Int_t) G__int(libp->para[2]));
10352 }
10353 break;
10354 case 2:
10355
10356 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10357 p = new TPieSliceEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10358 } else {
10359 p = new((void*) gvp) TPieSliceEditor((TGWindow*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10360 }
10361 break;
10362 case 1:
10363
10364 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10365 p = new TPieSliceEditor((TGWindow*) G__int(libp->para[0]));
10366 } else {
10367 p = new((void*) gvp) TPieSliceEditor((TGWindow*) G__int(libp->para[0]));
10368 }
10369 break;
10370 case 0:
10371 int n = G__getaryconstruct();
10372 if (n) {
10373 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10374 p = new TPieSliceEditor[n];
10375 } else {
10376 p = new((void*) gvp) TPieSliceEditor[n];
10377 }
10378 } else {
10379 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10380 p = new TPieSliceEditor;
10381 } else {
10382 p = new((void*) gvp) TPieSliceEditor;
10383 }
10384 }
10385 break;
10386 }
10387 result7->obj.i = (long) p;
10388 result7->ref = (long) p;
10389 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor));
10390 return(1 || funcname || hash || result7 || libp) ;
10391 }
10392
10393 static int G__G__Ged_303_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10394 {
10395 ((TPieSliceEditor*) G__getstructoffset())->DoTitle((const char*) G__int(libp->para[0]));
10396 G__setnull(result7);
10397 return(1 || funcname || hash || result7 || libp) ;
10398 }
10399
10400 static int G__G__Ged_303_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10401 {
10402 ((TPieSliceEditor*) G__getstructoffset())->DoValue();
10403 G__setnull(result7);
10404 return(1 || funcname || hash || result7 || libp) ;
10405 }
10406
10407 static int G__G__Ged_303_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10408 {
10409 ((TPieSliceEditor*) G__getstructoffset())->DoOffset();
10410 G__setnull(result7);
10411 return(1 || funcname || hash || result7 || libp) ;
10412 }
10413
10414 static int G__G__Ged_303_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10415 {
10416 G__letint(result7, 85, (long) TPieSliceEditor::Class());
10417 return(1 || funcname || hash || result7 || libp) ;
10418 }
10419
10420 static int G__G__Ged_303_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10421 {
10422 G__letint(result7, 67, (long) TPieSliceEditor::Class_Name());
10423 return(1 || funcname || hash || result7 || libp) ;
10424 }
10425
10426 static int G__G__Ged_303_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10427 {
10428 G__letint(result7, 115, (long) TPieSliceEditor::Class_Version());
10429 return(1 || funcname || hash || result7 || libp) ;
10430 }
10431
10432 static int G__G__Ged_303_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10433 {
10434 TPieSliceEditor::Dictionary();
10435 G__setnull(result7);
10436 return(1 || funcname || hash || result7 || libp) ;
10437 }
10438
10439 static int G__G__Ged_303_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10440 {
10441 ((TPieSliceEditor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10442 G__setnull(result7);
10443 return(1 || funcname || hash || result7 || libp) ;
10444 }
10445
10446 static int G__G__Ged_303_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10447 {
10448 G__letint(result7, 67, (long) TPieSliceEditor::DeclFileName());
10449 return(1 || funcname || hash || result7 || libp) ;
10450 }
10451
10452 static int G__G__Ged_303_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10453 {
10454 G__letint(result7, 105, (long) TPieSliceEditor::ImplFileLine());
10455 return(1 || funcname || hash || result7 || libp) ;
10456 }
10457
10458 static int G__G__Ged_303_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10459 {
10460 G__letint(result7, 67, (long) TPieSliceEditor::ImplFileName());
10461 return(1 || funcname || hash || result7 || libp) ;
10462 }
10463
10464 static int G__G__Ged_303_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10465 {
10466 G__letint(result7, 105, (long) TPieSliceEditor::DeclFileLine());
10467 return(1 || funcname || hash || result7 || libp) ;
10468 }
10469
10470
10471 typedef TPieSliceEditor G__TTPieSliceEditor;
10472 static int G__G__Ged_303_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10473 {
10474 char* gvp = (char*) G__getgvp();
10475 long soff = G__getstructoffset();
10476 int n = G__getaryconstruct();
10477
10478
10479
10480
10481
10482 if (!soff) {
10483 return(1);
10484 }
10485 if (n) {
10486 if (gvp == (char*)G__PVOID) {
10487 delete[] (TPieSliceEditor*) soff;
10488 } else {
10489 G__setgvp((long) G__PVOID);
10490 for (int i = n - 1; i >= 0; --i) {
10491 ((TPieSliceEditor*) (soff+(sizeof(TPieSliceEditor)*i)))->~G__TTPieSliceEditor();
10492 }
10493 G__setgvp((long)gvp);
10494 }
10495 } else {
10496 if (gvp == (char*)G__PVOID) {
10497 delete (TPieSliceEditor*) soff;
10498 } else {
10499 G__setgvp((long) G__PVOID);
10500 ((TPieSliceEditor*) (soff))->~G__TTPieSliceEditor();
10501 G__setgvp((long)gvp);
10502 }
10503 }
10504 G__setnull(result7);
10505 return(1 || funcname || hash || result7 || libp) ;
10506 }
10507
10508
10509
10510 static int G__G__Ged_305_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10511 {
10512 TStyleManager* p = NULL;
10513 char* gvp = (char*) G__getgvp();
10514
10515 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10516 p = new TStyleManager((TGWindow*) G__int(libp->para[0]));
10517 } else {
10518 p = new((void*) gvp) TStyleManager((TGWindow*) G__int(libp->para[0]));
10519 }
10520 result7->obj.i = (long) p;
10521 result7->ref = (long) p;
10522 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TStyleManager));
10523 return(1 || funcname || hash || result7 || libp) ;
10524 }
10525
10526 static int G__G__Ged_305_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10527 {
10528 TStyleManager::Show();
10529 G__setnull(result7);
10530 return(1 || funcname || hash || result7 || libp) ;
10531 }
10532
10533 static int G__G__Ged_305_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10534 {
10535 TStyleManager::Terminate();
10536 G__setnull(result7);
10537 return(1 || funcname || hash || result7 || libp) ;
10538 }
10539
10540 static int G__G__Ged_305_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10541 {
10542 {
10543 TStyleManager*& obj = TStyleManager::GetSM();
10544 result7->ref = (long) (&obj);
10545 G__letint(result7, 'U', (long)obj);
10546 }
10547 return(1 || funcname || hash || result7 || libp) ;
10548 }
10549
10550 static int G__G__Ged_305_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10551 {
10552 ((TStyleManager*) G__getstructoffset())->Init();
10553 G__setnull(result7);
10554 return(1 || funcname || hash || result7 || libp) ;
10555 }
10556
10557 static int G__G__Ged_305_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10558 {
10559 ((TStyleManager*) G__getstructoffset())->Hide();
10560 G__setnull(result7);
10561 return(1 || funcname || hash || result7 || libp) ;
10562 }
10563
10564 static int G__G__Ged_305_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10565 {
10566 ((TStyleManager*) G__getstructoffset())->SetCurSelStyle((TStyle*) G__int(libp->para[0]));
10567 G__setnull(result7);
10568 return(1 || funcname || hash || result7 || libp) ;
10569 }
10570
10571 static int G__G__Ged_305_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10572 {
10573 ((TStyleManager*) G__getstructoffset())->SetLastChoice((Bool_t) G__int(libp->para[0]));
10574 G__setnull(result7);
10575 return(1 || funcname || hash || result7 || libp) ;
10576 }
10577
10578 static int G__G__Ged_305_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10579 {
10580 ((TStyleManager*) G__getstructoffset())->DoMenu((Int_t) G__int(libp->para[0]));
10581 G__setnull(result7);
10582 return(1 || funcname || hash || result7 || libp) ;
10583 }
10584
10585 static int G__G__Ged_305_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10586 {
10587 ((TStyleManager*) G__getstructoffset())->DoImportMacro((Bool_t) G__int(libp->para[0]));
10588 G__setnull(result7);
10589 return(1 || funcname || hash || result7 || libp) ;
10590 }
10591
10592 static int G__G__Ged_305_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10593 {
10594 ((TStyleManager*) G__getstructoffset())->DoListSelect();
10595 G__setnull(result7);
10596 return(1 || funcname || hash || result7 || libp) ;
10597 }
10598
10599 static int G__G__Ged_305_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10600 {
10601 ((TStyleManager*) G__getstructoffset())->DoRealTime((Bool_t) G__int(libp->para[0]));
10602 G__setnull(result7);
10603 return(1 || funcname || hash || result7 || libp) ;
10604 }
10605
10606 static int G__G__Ged_305_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10607 {
10608 ((TStyleManager*) G__getstructoffset())->DoPreview((Bool_t) G__int(libp->para[0]));
10609 G__setnull(result7);
10610 return(1 || funcname || hash || result7 || libp) ;
10611 }
10612
10613 static int G__G__Ged_305_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10614 {
10615 ((TStyleManager*) G__getstructoffset())->DoPreviewClosed();
10616 G__setnull(result7);
10617 return(1 || funcname || hash || result7 || libp) ;
10618 }
10619
10620 static int G__G__Ged_305_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10621 {
10622 ((TStyleManager*) G__getstructoffset())->DoMakeDefault();
10623 G__setnull(result7);
10624 return(1 || funcname || hash || result7 || libp) ;
10625 }
10626
10627 static int G__G__Ged_305_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10628 {
10629 ((TStyleManager*) G__getstructoffset())->DoApplyOnSelect((Int_t) G__int(libp->para[0]));
10630 G__setnull(result7);
10631 return(1 || funcname || hash || result7 || libp) ;
10632 }
10633
10634 static int G__G__Ged_305_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10635 {
10636 ((TStyleManager*) G__getstructoffset())->DoApplyOn();
10637 G__setnull(result7);
10638 return(1 || funcname || hash || result7 || libp) ;
10639 }
10640
10641 static int G__G__Ged_305_0_118(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10642 {
10643 ((TStyleManager*) G__getstructoffset())->DoMoreLess();
10644 G__setnull(result7);
10645 return(1 || funcname || hash || result7 || libp) ;
10646 }
10647
10648 static int G__G__Ged_305_0_119(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10649 {
10650 ((TStyleManager*) G__getstructoffset())->DoEditionUpdatePreview();
10651 G__setnull(result7);
10652 return(1 || funcname || hash || result7 || libp) ;
10653 }
10654
10655 static int G__G__Ged_305_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10656 {
10657 ((TStyleManager*) G__getstructoffset())->DoChangeTab((Int_t) G__int(libp->para[0]));
10658 G__setnull(result7);
10659 return(1 || funcname || hash || result7 || libp) ;
10660 }
10661
10662 static int G__G__Ged_305_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10663 {
10664 ((TStyleManager*) G__getstructoffset())->DoChangeAxisTab((Int_t) G__int(libp->para[0]));
10665 G__setnull(result7);
10666 return(1 || funcname || hash || result7 || libp) ;
10667 }
10668
10669 static int G__G__Ged_305_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10670 {
10671 switch (libp->paran) {
10672 case 1:
10673 ((TStyleManager*) G__getstructoffset())->BuildList((TStyle*) G__int(libp->para[0]));
10674 G__setnull(result7);
10675 break;
10676 case 0:
10677 ((TStyleManager*) G__getstructoffset())->BuildList();
10678 G__setnull(result7);
10679 break;
10680 }
10681 return(1 || funcname || hash || result7 || libp) ;
10682 }
10683
10684 static int G__G__Ged_305_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10685 {
10686 ((TStyleManager*) G__getstructoffset())->DoSelectNoCanvas();
10687 G__setnull(result7);
10688 return(1 || funcname || hash || result7 || libp) ;
10689 }
10690
10691 static int G__G__Ged_305_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10692 {
10693 ((TStyleManager*) G__getstructoffset())->DoSelectCanvas((TVirtualPad*) G__int(libp->para[0]), (TObject*) G__int(libp->para[1])
10694 , (Int_t) G__int(libp->para[2]));
10695 G__setnull(result7);
10696 return(1 || funcname || hash || result7 || libp) ;
10697 }
10698
10699 static int G__G__Ged_305_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10700 {
10701 ((TStyleManager*) G__getstructoffset())->ModFillColor();
10702 G__setnull(result7);
10703 return(1 || funcname || hash || result7 || libp) ;
10704 }
10705
10706 static int G__G__Ged_305_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10707 {
10708 ((TStyleManager*) G__getstructoffset())->ModFillStyle();
10709 G__setnull(result7);
10710 return(1 || funcname || hash || result7 || libp) ;
10711 }
10712
10713 static int G__G__Ged_305_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10714 {
10715 ((TStyleManager*) G__getstructoffset())->ModHatchesLineWidth();
10716 G__setnull(result7);
10717 return(1 || funcname || hash || result7 || libp) ;
10718 }
10719
10720 static int G__G__Ged_305_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10721 {
10722 ((TStyleManager*) G__getstructoffset())->ModHatchesSpacing();
10723 G__setnull(result7);
10724 return(1 || funcname || hash || result7 || libp) ;
10725 }
10726
10727 static int G__G__Ged_305_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10728 {
10729 ((TStyleManager*) G__getstructoffset())->ModMarkerColor();
10730 G__setnull(result7);
10731 return(1 || funcname || hash || result7 || libp) ;
10732 }
10733
10734 static int G__G__Ged_305_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10735 {
10736 ((TStyleManager*) G__getstructoffset())->ModMarkerStyle();
10737 G__setnull(result7);
10738 return(1 || funcname || hash || result7 || libp) ;
10739 }
10740
10741 static int G__G__Ged_305_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10742 {
10743 ((TStyleManager*) G__getstructoffset())->ModMarkerSize();
10744 G__setnull(result7);
10745 return(1 || funcname || hash || result7 || libp) ;
10746 }
10747
10748 static int G__G__Ged_305_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10749 {
10750 ((TStyleManager*) G__getstructoffset())->ModScreenFactor();
10751 G__setnull(result7);
10752 return(1 || funcname || hash || result7 || libp) ;
10753 }
10754
10755 static int G__G__Ged_305_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10756 {
10757 ((TStyleManager*) G__getstructoffset())->ModLineColor();
10758 G__setnull(result7);
10759 return(1 || funcname || hash || result7 || libp) ;
10760 }
10761
10762 static int G__G__Ged_305_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10763 {
10764 ((TStyleManager*) G__getstructoffset())->ModLineWidth();
10765 G__setnull(result7);
10766 return(1 || funcname || hash || result7 || libp) ;
10767 }
10768
10769 static int G__G__Ged_305_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10770 {
10771 ((TStyleManager*) G__getstructoffset())->ModLineStyle();
10772 G__setnull(result7);
10773 return(1 || funcname || hash || result7 || libp) ;
10774 }
10775
10776 static int G__G__Ged_305_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10777 {
10778 ((TStyleManager*) G__getstructoffset())->ModLineStyleEdit();
10779 G__setnull(result7);
10780 return(1 || funcname || hash || result7 || libp) ;
10781 }
10782
10783 static int G__G__Ged_305_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10784 {
10785 ((TStyleManager*) G__getstructoffset())->ModTextColor();
10786 G__setnull(result7);
10787 return(1 || funcname || hash || result7 || libp) ;
10788 }
10789
10790 static int G__G__Ged_305_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10791 {
10792 ((TStyleManager*) G__getstructoffset())->ModTextSize();
10793 G__setnull(result7);
10794 return(1 || funcname || hash || result7 || libp) ;
10795 }
10796
10797 static int G__G__Ged_305_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10798 {
10799 ((TStyleManager*) G__getstructoffset())->ModTextSizeInPixels((Bool_t) G__int(libp->para[0]));
10800 G__setnull(result7);
10801 return(1 || funcname || hash || result7 || libp) ;
10802 }
10803
10804 static int G__G__Ged_305_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10805 {
10806 ((TStyleManager*) G__getstructoffset())->ModTextFont();
10807 G__setnull(result7);
10808 return(1 || funcname || hash || result7 || libp) ;
10809 }
10810
10811 static int G__G__Ged_305_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10812 {
10813 ((TStyleManager*) G__getstructoffset())->ModTextAlign();
10814 G__setnull(result7);
10815 return(1 || funcname || hash || result7 || libp) ;
10816 }
10817
10818 static int G__G__Ged_305_0_143(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10819 {
10820 ((TStyleManager*) G__getstructoffset())->ModTextAngle();
10821 G__setnull(result7);
10822 return(1 || funcname || hash || result7 || libp) ;
10823 }
10824
10825 static int G__G__Ged_305_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10826 {
10827 ((TStyleManager*) G__getstructoffset())->ModCanvasColor();
10828 G__setnull(result7);
10829 return(1 || funcname || hash || result7 || libp) ;
10830 }
10831
10832 static int G__G__Ged_305_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10833 {
10834 ((TStyleManager*) G__getstructoffset())->ModCanvasDefX();
10835 G__setnull(result7);
10836 return(1 || funcname || hash || result7 || libp) ;
10837 }
10838
10839 static int G__G__Ged_305_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10840 {
10841 ((TStyleManager*) G__getstructoffset())->ModCanvasDefY();
10842 G__setnull(result7);
10843 return(1 || funcname || hash || result7 || libp) ;
10844 }
10845
10846 static int G__G__Ged_305_0_147(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10847 {
10848 ((TStyleManager*) G__getstructoffset())->ModCanvasDefW();
10849 G__setnull(result7);
10850 return(1 || funcname || hash || result7 || libp) ;
10851 }
10852
10853 static int G__G__Ged_305_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10854 {
10855 ((TStyleManager*) G__getstructoffset())->ModCanvasDefH();
10856 G__setnull(result7);
10857 return(1 || funcname || hash || result7 || libp) ;
10858 }
10859
10860 static int G__G__Ged_305_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10861 {
10862 ((TStyleManager*) G__getstructoffset())->ModCanvasBorderMode();
10863 G__setnull(result7);
10864 return(1 || funcname || hash || result7 || libp) ;
10865 }
10866
10867 static int G__G__Ged_305_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10868 {
10869 ((TStyleManager*) G__getstructoffset())->ModCanvasBorderSize();
10870 G__setnull(result7);
10871 return(1 || funcname || hash || result7 || libp) ;
10872 }
10873
10874 static int G__G__Ged_305_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10875 {
10876 ((TStyleManager*) G__getstructoffset())->ModOptDateBool();
10877 G__setnull(result7);
10878 return(1 || funcname || hash || result7 || libp) ;
10879 }
10880
10881 static int G__G__Ged_305_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10882 {
10883 ((TStyleManager*) G__getstructoffset())->ModAttDateTextColor();
10884 G__setnull(result7);
10885 return(1 || funcname || hash || result7 || libp) ;
10886 }
10887
10888 static int G__G__Ged_305_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10889 {
10890 ((TStyleManager*) G__getstructoffset())->ModAttDateTextSize();
10891 G__setnull(result7);
10892 return(1 || funcname || hash || result7 || libp) ;
10893 }
10894
10895 static int G__G__Ged_305_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10896 {
10897 ((TStyleManager*) G__getstructoffset())->ModAttDateTextSizeInPixels((Bool_t) G__int(libp->para[0]));
10898 G__setnull(result7);
10899 return(1 || funcname || hash || result7 || libp) ;
10900 }
10901
10902 static int G__G__Ged_305_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10903 {
10904 ((TStyleManager*) G__getstructoffset())->ModOptDateFormat();
10905 G__setnull(result7);
10906 return(1 || funcname || hash || result7 || libp) ;
10907 }
10908
10909 static int G__G__Ged_305_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10910 {
10911 ((TStyleManager*) G__getstructoffset())->ModAttDateTextFont();
10912 G__setnull(result7);
10913 return(1 || funcname || hash || result7 || libp) ;
10914 }
10915
10916 static int G__G__Ged_305_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10917 {
10918 ((TStyleManager*) G__getstructoffset())->ModAttDateTextAngle();
10919 G__setnull(result7);
10920 return(1 || funcname || hash || result7 || libp) ;
10921 }
10922
10923 static int G__G__Ged_305_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10924 {
10925 ((TStyleManager*) G__getstructoffset())->ModAttDateTextAlign();
10926 G__setnull(result7);
10927 return(1 || funcname || hash || result7 || libp) ;
10928 }
10929
10930 static int G__G__Ged_305_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10931 {
10932 ((TStyleManager*) G__getstructoffset())->ModDateX();
10933 G__setnull(result7);
10934 return(1 || funcname || hash || result7 || libp) ;
10935 }
10936
10937 static int G__G__Ged_305_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10938 {
10939 ((TStyleManager*) G__getstructoffset())->ModDateY();
10940 G__setnull(result7);
10941 return(1 || funcname || hash || result7 || libp) ;
10942 }
10943
10944 static int G__G__Ged_305_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10945 {
10946 ((TStyleManager*) G__getstructoffset())->ModPadTopMargin();
10947 G__setnull(result7);
10948 return(1 || funcname || hash || result7 || libp) ;
10949 }
10950
10951 static int G__G__Ged_305_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10952 {
10953 ((TStyleManager*) G__getstructoffset())->ModPadBottomMargin();
10954 G__setnull(result7);
10955 return(1 || funcname || hash || result7 || libp) ;
10956 }
10957
10958 static int G__G__Ged_305_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10959 {
10960 ((TStyleManager*) G__getstructoffset())->ModPadLeftMargin();
10961 G__setnull(result7);
10962 return(1 || funcname || hash || result7 || libp) ;
10963 }
10964
10965 static int G__G__Ged_305_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10966 {
10967 ((TStyleManager*) G__getstructoffset())->ModPadRightMargin();
10968 G__setnull(result7);
10969 return(1 || funcname || hash || result7 || libp) ;
10970 }
10971
10972 static int G__G__Ged_305_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10973 {
10974 ((TStyleManager*) G__getstructoffset())->ModPadBorderMode();
10975 G__setnull(result7);
10976 return(1 || funcname || hash || result7 || libp) ;
10977 }
10978
10979 static int G__G__Ged_305_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10980 {
10981 ((TStyleManager*) G__getstructoffset())->ModPadBorderSize();
10982 G__setnull(result7);
10983 return(1 || funcname || hash || result7 || libp) ;
10984 }
10985
10986 static int G__G__Ged_305_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10987 {
10988 ((TStyleManager*) G__getstructoffset())->ModPadColor();
10989 G__setnull(result7);
10990 return(1 || funcname || hash || result7 || libp) ;
10991 }
10992
10993 static int G__G__Ged_305_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10994 {
10995 ((TStyleManager*) G__getstructoffset())->ModPadTickX();
10996 G__setnull(result7);
10997 return(1 || funcname || hash || result7 || libp) ;
10998 }
10999
11000 static int G__G__Ged_305_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11001 {
11002 ((TStyleManager*) G__getstructoffset())->ModPadTickY();
11003 G__setnull(result7);
11004 return(1 || funcname || hash || result7 || libp) ;
11005 }
11006
11007 static int G__G__Ged_305_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11008 {
11009 ((TStyleManager*) G__getstructoffset())->ModPadGridX();
11010 G__setnull(result7);
11011 return(1 || funcname || hash || result7 || libp) ;
11012 }
11013
11014 static int G__G__Ged_305_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11015 {
11016 ((TStyleManager*) G__getstructoffset())->ModPadGridY();
11017 G__setnull(result7);
11018 return(1 || funcname || hash || result7 || libp) ;
11019 }
11020
11021 static int G__G__Ged_305_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11022 {
11023 ((TStyleManager*) G__getstructoffset())->ModGridColor();
11024 G__setnull(result7);
11025 return(1 || funcname || hash || result7 || libp) ;
11026 }
11027
11028 static int G__G__Ged_305_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11029 {
11030 ((TStyleManager*) G__getstructoffset())->ModGridWidth();
11031 G__setnull(result7);
11032 return(1 || funcname || hash || result7 || libp) ;
11033 }
11034
11035 static int G__G__Ged_305_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11036 {
11037 ((TStyleManager*) G__getstructoffset())->ModGridStyle();
11038 G__setnull(result7);
11039 return(1 || funcname || hash || result7 || libp) ;
11040 }
11041
11042 static int G__G__Ged_305_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11043 {
11044 ((TStyleManager*) G__getstructoffset())->ModHistFillColor();
11045 G__setnull(result7);
11046 return(1 || funcname || hash || result7 || libp) ;
11047 }
11048
11049 static int G__G__Ged_305_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11050 {
11051 ((TStyleManager*) G__getstructoffset())->ModHistFillStyle();
11052 G__setnull(result7);
11053 return(1 || funcname || hash || result7 || libp) ;
11054 }
11055
11056 static int G__G__Ged_305_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11057 {
11058 ((TStyleManager*) G__getstructoffset())->ModHistLineColor();
11059 G__setnull(result7);
11060 return(1 || funcname || hash || result7 || libp) ;
11061 }
11062
11063 static int G__G__Ged_305_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11064 {
11065 ((TStyleManager*) G__getstructoffset())->ModHistLineWidth();
11066 G__setnull(result7);
11067 return(1 || funcname || hash || result7 || libp) ;
11068 }
11069
11070 static int G__G__Ged_305_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11071 {
11072 ((TStyleManager*) G__getstructoffset())->ModHistLineStyle();
11073 G__setnull(result7);
11074 return(1 || funcname || hash || result7 || libp) ;
11075 }
11076
11077 static int G__G__Ged_305_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11078 {
11079 ((TStyleManager*) G__getstructoffset())->ModBarWidth();
11080 G__setnull(result7);
11081 return(1 || funcname || hash || result7 || libp) ;
11082 }
11083
11084 static int G__G__Ged_305_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11085 {
11086 ((TStyleManager*) G__getstructoffset())->ModBarOffset();
11087 G__setnull(result7);
11088 return(1 || funcname || hash || result7 || libp) ;
11089 }
11090
11091 static int G__G__Ged_305_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11092 {
11093 ((TStyleManager*) G__getstructoffset())->ModHistMinimumZero();
11094 G__setnull(result7);
11095 return(1 || funcname || hash || result7 || libp) ;
11096 }
11097
11098 static int G__G__Ged_305_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11099 {
11100 ((TStyleManager*) G__getstructoffset())->ModPaintTextFormat();
11101 G__setnull(result7);
11102 return(1 || funcname || hash || result7 || libp) ;
11103 }
11104
11105 static int G__G__Ged_305_0_184(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11106 {
11107 ((TStyleManager*) G__getstructoffset())->ModNumberContours();
11108 G__setnull(result7);
11109 return(1 || funcname || hash || result7 || libp) ;
11110 }
11111
11112 static int G__G__Ged_305_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11113 {
11114 ((TStyleManager*) G__getstructoffset())->ModLegoInnerR();
11115 G__setnull(result7);
11116 return(1 || funcname || hash || result7 || libp) ;
11117 }
11118
11119 static int G__G__Ged_305_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11120 {
11121 ((TStyleManager*) G__getstructoffset())->ModFrameFillColor();
11122 G__setnull(result7);
11123 return(1 || funcname || hash || result7 || libp) ;
11124 }
11125
11126 static int G__G__Ged_305_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11127 {
11128 ((TStyleManager*) G__getstructoffset())->ModFrameFillStyle();
11129 G__setnull(result7);
11130 return(1 || funcname || hash || result7 || libp) ;
11131 }
11132
11133 static int G__G__Ged_305_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11134 {
11135 ((TStyleManager*) G__getstructoffset())->ModFrameLineColor();
11136 G__setnull(result7);
11137 return(1 || funcname || hash || result7 || libp) ;
11138 }
11139
11140 static int G__G__Ged_305_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11141 {
11142 ((TStyleManager*) G__getstructoffset())->ModFrameLineWidth();
11143 G__setnull(result7);
11144 return(1 || funcname || hash || result7 || libp) ;
11145 }
11146
11147 static int G__G__Ged_305_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11148 {
11149 ((TStyleManager*) G__getstructoffset())->ModFrameLineStyle();
11150 G__setnull(result7);
11151 return(1 || funcname || hash || result7 || libp) ;
11152 }
11153
11154 static int G__G__Ged_305_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11155 {
11156 ((TStyleManager*) G__getstructoffset())->ModPaletteEdit();
11157 G__setnull(result7);
11158 return(1 || funcname || hash || result7 || libp) ;
11159 }
11160
11161 static int G__G__Ged_305_0_192(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11162 {
11163 ((TStyleManager*) G__getstructoffset())->ModFrameBorderMode();
11164 G__setnull(result7);
11165 return(1 || funcname || hash || result7 || libp) ;
11166 }
11167
11168 static int G__G__Ged_305_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11169 {
11170 ((TStyleManager*) G__getstructoffset())->ModFrameBorderSize();
11171 G__setnull(result7);
11172 return(1 || funcname || hash || result7 || libp) ;
11173 }
11174
11175 static int G__G__Ged_305_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11176 {
11177 ((TStyleManager*) G__getstructoffset())->ModFuncColor();
11178 G__setnull(result7);
11179 return(1 || funcname || hash || result7 || libp) ;
11180 }
11181
11182 static int G__G__Ged_305_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11183 {
11184 ((TStyleManager*) G__getstructoffset())->ModFuncWidth();
11185 G__setnull(result7);
11186 return(1 || funcname || hash || result7 || libp) ;
11187 }
11188
11189 static int G__G__Ged_305_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11190 {
11191 ((TStyleManager*) G__getstructoffset())->ModFuncStyle();
11192 G__setnull(result7);
11193 return(1 || funcname || hash || result7 || libp) ;
11194 }
11195
11196 static int G__G__Ged_305_0_197(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11197 {
11198 ((TStyleManager*) G__getstructoffset())->ModDrawBorder();
11199 G__setnull(result7);
11200 return(1 || funcname || hash || result7 || libp) ;
11201 }
11202
11203 static int G__G__Ged_305_0_198(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11204 {
11205 ((TStyleManager*) G__getstructoffset())->ModEndErrorSize();
11206 G__setnull(result7);
11207 return(1 || funcname || hash || result7 || libp) ;
11208 }
11209
11210 static int G__G__Ged_305_0_199(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11211 {
11212 ((TStyleManager*) G__getstructoffset())->ModErrorX();
11213 G__setnull(result7);
11214 return(1 || funcname || hash || result7 || libp) ;
11215 }
11216
11217 static int G__G__Ged_305_0_200(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11218 {
11219 ((TStyleManager*) G__getstructoffset())->ModTimeOffset();
11220 G__setnull(result7);
11221 return(1 || funcname || hash || result7 || libp) ;
11222 }
11223
11224 static int G__G__Ged_305_0_201(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11225 {
11226 ((TStyleManager*) G__getstructoffset())->ModStripDecimals();
11227 G__setnull(result7);
11228 return(1 || funcname || hash || result7 || libp) ;
11229 }
11230
11231 static int G__G__Ged_305_0_202(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11232 {
11233 ((TStyleManager*) G__getstructoffset())->ModApplyOnXYZ();
11234 G__setnull(result7);
11235 return(1 || funcname || hash || result7 || libp) ;
11236 }
11237
11238 static int G__G__Ged_305_0_203(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11239 {
11240 ((TStyleManager*) G__getstructoffset())->ModXTitleSize();
11241 G__setnull(result7);
11242 return(1 || funcname || hash || result7 || libp) ;
11243 }
11244
11245 static int G__G__Ged_305_0_204(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11246 {
11247 ((TStyleManager*) G__getstructoffset())->ModXTitleSizeInPixels((Bool_t) G__int(libp->para[0]));
11248 G__setnull(result7);
11249 return(1 || funcname || hash || result7 || libp) ;
11250 }
11251
11252 static int G__G__Ged_305_0_205(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11253 {
11254 ((TStyleManager*) G__getstructoffset())->ModXTitleColor();
11255 G__setnull(result7);
11256 return(1 || funcname || hash || result7 || libp) ;
11257 }
11258
11259 static int G__G__Ged_305_0_206(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11260 {
11261 ((TStyleManager*) G__getstructoffset())->ModXTitleOffset();
11262 G__setnull(result7);
11263 return(1 || funcname || hash || result7 || libp) ;
11264 }
11265
11266 static int G__G__Ged_305_0_207(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11267 {
11268 ((TStyleManager*) G__getstructoffset())->ModXTitleFont();
11269 G__setnull(result7);
11270 return(1 || funcname || hash || result7 || libp) ;
11271 }
11272
11273 static int G__G__Ged_305_0_208(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11274 {
11275 ((TStyleManager*) G__getstructoffset())->ModXLabelSize();
11276 G__setnull(result7);
11277 return(1 || funcname || hash || result7 || libp) ;
11278 }
11279
11280 static int G__G__Ged_305_0_209(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11281 {
11282 ((TStyleManager*) G__getstructoffset())->ModXLabelSizeInPixels((Bool_t) G__int(libp->para[0]));
11283 G__setnull(result7);
11284 return(1 || funcname || hash || result7 || libp) ;
11285 }
11286
11287 static int G__G__Ged_305_0_210(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11288 {
11289 ((TStyleManager*) G__getstructoffset())->ModXLabelColor();
11290 G__setnull(result7);
11291 return(1 || funcname || hash || result7 || libp) ;
11292 }
11293
11294 static int G__G__Ged_305_0_211(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11295 {
11296 ((TStyleManager*) G__getstructoffset())->ModXLabelOffset();
11297 G__setnull(result7);
11298 return(1 || funcname || hash || result7 || libp) ;
11299 }
11300
11301 static int G__G__Ged_305_0_212(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11302 {
11303 ((TStyleManager*) G__getstructoffset())->ModXLabelFont();
11304 G__setnull(result7);
11305 return(1 || funcname || hash || result7 || libp) ;
11306 }
11307
11308 static int G__G__Ged_305_0_213(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11309 {
11310 ((TStyleManager*) G__getstructoffset())->ModXAxisColor();
11311 G__setnull(result7);
11312 return(1 || funcname || hash || result7 || libp) ;
11313 }
11314
11315 static int G__G__Ged_305_0_214(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11316 {
11317 ((TStyleManager*) G__getstructoffset())->ModXTickLength();
11318 G__setnull(result7);
11319 return(1 || funcname || hash || result7 || libp) ;
11320 }
11321
11322 static int G__G__Ged_305_0_215(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11323 {
11324 ((TStyleManager*) G__getstructoffset())->ModOptLogx();
11325 G__setnull(result7);
11326 return(1 || funcname || hash || result7 || libp) ;
11327 }
11328
11329 static int G__G__Ged_305_0_216(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11330 {
11331 ((TStyleManager*) G__getstructoffset())->ModXNdivisions();
11332 G__setnull(result7);
11333 return(1 || funcname || hash || result7 || libp) ;
11334 }
11335
11336 static int G__G__Ged_305_0_217(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11337 {
11338 ((TStyleManager*) G__getstructoffset())->ModYTitleSize();
11339 G__setnull(result7);
11340 return(1 || funcname || hash || result7 || libp) ;
11341 }
11342
11343 static int G__G__Ged_305_0_218(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11344 {
11345 ((TStyleManager*) G__getstructoffset())->ModYTitleSizeInPixels((Bool_t) G__int(libp->para[0]));
11346 G__setnull(result7);
11347 return(1 || funcname || hash || result7 || libp) ;
11348 }
11349
11350 static int G__G__Ged_305_0_219(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11351 {
11352 ((TStyleManager*) G__getstructoffset())->ModYTitleColor();
11353 G__setnull(result7);
11354 return(1 || funcname || hash || result7 || libp) ;
11355 }
11356
11357 static int G__G__Ged_305_0_220(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11358 {
11359 ((TStyleManager*) G__getstructoffset())->ModYTitleOffset();
11360 G__setnull(result7);
11361 return(1 || funcname || hash || result7 || libp) ;
11362 }
11363
11364 static int G__G__Ged_305_0_221(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11365 {
11366 ((TStyleManager*) G__getstructoffset())->ModYTitleFont();
11367 G__setnull(result7);
11368 return(1 || funcname || hash || result7 || libp) ;
11369 }
11370
11371 static int G__G__Ged_305_0_222(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11372 {
11373 ((TStyleManager*) G__getstructoffset())->ModYLabelSize();
11374 G__setnull(result7);
11375 return(1 || funcname || hash || result7 || libp) ;
11376 }
11377
11378 static int G__G__Ged_305_0_223(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11379 {
11380 ((TStyleManager*) G__getstructoffset())->ModYLabelSizeInPixels((Bool_t) G__int(libp->para[0]));
11381 G__setnull(result7);
11382 return(1 || funcname || hash || result7 || libp) ;
11383 }
11384
11385 static int G__G__Ged_305_0_224(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11386 {
11387 ((TStyleManager*) G__getstructoffset())->ModYLabelColor();
11388 G__setnull(result7);
11389 return(1 || funcname || hash || result7 || libp) ;
11390 }
11391
11392 static int G__G__Ged_305_0_225(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11393 {
11394 ((TStyleManager*) G__getstructoffset())->ModYLabelOffset();
11395 G__setnull(result7);
11396 return(1 || funcname || hash || result7 || libp) ;
11397 }
11398
11399 static int G__G__Ged_305_0_226(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11400 {
11401 ((TStyleManager*) G__getstructoffset())->ModYLabelFont();
11402 G__setnull(result7);
11403 return(1 || funcname || hash || result7 || libp) ;
11404 }
11405
11406 static int G__G__Ged_305_0_227(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11407 {
11408 ((TStyleManager*) G__getstructoffset())->ModYAxisColor();
11409 G__setnull(result7);
11410 return(1 || funcname || hash || result7 || libp) ;
11411 }
11412
11413 static int G__G__Ged_305_0_228(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11414 {
11415 ((TStyleManager*) G__getstructoffset())->ModYTickLength();
11416 G__setnull(result7);
11417 return(1 || funcname || hash || result7 || libp) ;
11418 }
11419
11420 static int G__G__Ged_305_0_229(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11421 {
11422 ((TStyleManager*) G__getstructoffset())->ModOptLogy();
11423 G__setnull(result7);
11424 return(1 || funcname || hash || result7 || libp) ;
11425 }
11426
11427 static int G__G__Ged_305_0_230(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11428 {
11429 ((TStyleManager*) G__getstructoffset())->ModYNdivisions();
11430 G__setnull(result7);
11431 return(1 || funcname || hash || result7 || libp) ;
11432 }
11433
11434 static int G__G__Ged_305_0_231(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11435 {
11436 ((TStyleManager*) G__getstructoffset())->ModZTitleSize();
11437 G__setnull(result7);
11438 return(1 || funcname || hash || result7 || libp) ;
11439 }
11440
11441 static int G__G__Ged_305_0_232(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11442 {
11443 ((TStyleManager*) G__getstructoffset())->ModZTitleSizeInPixels((Bool_t) G__int(libp->para[0]));
11444 G__setnull(result7);
11445 return(1 || funcname || hash || result7 || libp) ;
11446 }
11447
11448 static int G__G__Ged_305_0_233(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11449 {
11450 ((TStyleManager*) G__getstructoffset())->ModZTitleColor();
11451 G__setnull(result7);
11452 return(1 || funcname || hash || result7 || libp) ;
11453 }
11454
11455 static int G__G__Ged_305_0_234(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11456 {
11457 ((TStyleManager*) G__getstructoffset())->ModZTitleOffset();
11458 G__setnull(result7);
11459 return(1 || funcname || hash || result7 || libp) ;
11460 }
11461
11462 static int G__G__Ged_305_0_235(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11463 {
11464 ((TStyleManager*) G__getstructoffset())->ModZTitleFont();
11465 G__setnull(result7);
11466 return(1 || funcname || hash || result7 || libp) ;
11467 }
11468
11469 static int G__G__Ged_305_0_236(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11470 {
11471 ((TStyleManager*) G__getstructoffset())->ModZLabelSize();
11472 G__setnull(result7);
11473 return(1 || funcname || hash || result7 || libp) ;
11474 }
11475
11476 static int G__G__Ged_305_0_237(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11477 {
11478 ((TStyleManager*) G__getstructoffset())->ModZLabelSizeInPixels((Bool_t) G__int(libp->para[0]));
11479 G__setnull(result7);
11480 return(1 || funcname || hash || result7 || libp) ;
11481 }
11482
11483 static int G__G__Ged_305_0_238(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11484 {
11485 ((TStyleManager*) G__getstructoffset())->ModZLabelColor();
11486 G__setnull(result7);
11487 return(1 || funcname || hash || result7 || libp) ;
11488 }
11489
11490 static int G__G__Ged_305_0_239(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11491 {
11492 ((TStyleManager*) G__getstructoffset())->ModZLabelOffset();
11493 G__setnull(result7);
11494 return(1 || funcname || hash || result7 || libp) ;
11495 }
11496
11497 static int G__G__Ged_305_0_240(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11498 {
11499 ((TStyleManager*) G__getstructoffset())->ModZLabelFont();
11500 G__setnull(result7);
11501 return(1 || funcname || hash || result7 || libp) ;
11502 }
11503
11504 static int G__G__Ged_305_0_241(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11505 {
11506 ((TStyleManager*) G__getstructoffset())->ModZAxisColor();
11507 G__setnull(result7);
11508 return(1 || funcname || hash || result7 || libp) ;
11509 }
11510
11511 static int G__G__Ged_305_0_242(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11512 {
11513 ((TStyleManager*) G__getstructoffset())->ModZTickLength();
11514 G__setnull(result7);
11515 return(1 || funcname || hash || result7 || libp) ;
11516 }
11517
11518 static int G__G__Ged_305_0_243(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11519 {
11520 ((TStyleManager*) G__getstructoffset())->ModOptLogz();
11521 G__setnull(result7);
11522 return(1 || funcname || hash || result7 || libp) ;
11523 }
11524
11525 static int G__G__Ged_305_0_244(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11526 {
11527 ((TStyleManager*) G__getstructoffset())->ModZNdivisions();
11528 G__setnull(result7);
11529 return(1 || funcname || hash || result7 || libp) ;
11530 }
11531
11532 static int G__G__Ged_305_0_245(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11533 {
11534 ((TStyleManager*) G__getstructoffset())->ModOptTitle();
11535 G__setnull(result7);
11536 return(1 || funcname || hash || result7 || libp) ;
11537 }
11538
11539 static int G__G__Ged_305_0_246(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11540 {
11541 ((TStyleManager*) G__getstructoffset())->ModTitleFillColor();
11542 G__setnull(result7);
11543 return(1 || funcname || hash || result7 || libp) ;
11544 }
11545
11546 static int G__G__Ged_305_0_247(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11547 {
11548 ((TStyleManager*) G__getstructoffset())->ModTitleStyle();
11549 G__setnull(result7);
11550 return(1 || funcname || hash || result7 || libp) ;
11551 }
11552
11553 static int G__G__Ged_305_0_248(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11554 {
11555 ((TStyleManager*) G__getstructoffset())->ModTitleTextColor();
11556 G__setnull(result7);
11557 return(1 || funcname || hash || result7 || libp) ;
11558 }
11559
11560 static int G__G__Ged_305_0_249(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11561 {
11562 ((TStyleManager*) G__getstructoffset())->ModTitleFontSize();
11563 G__setnull(result7);
11564 return(1 || funcname || hash || result7 || libp) ;
11565 }
11566
11567 static int G__G__Ged_305_0_250(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11568 {
11569 ((TStyleManager*) G__getstructoffset())->ModTitleFontSizeInPixels((Bool_t) G__int(libp->para[0]));
11570 G__setnull(result7);
11571 return(1 || funcname || hash || result7 || libp) ;
11572 }
11573
11574 static int G__G__Ged_305_0_251(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11575 {
11576 ((TStyleManager*) G__getstructoffset())->ModTitleFont();
11577 G__setnull(result7);
11578 return(1 || funcname || hash || result7 || libp) ;
11579 }
11580
11581 static int G__G__Ged_305_0_252(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11582 {
11583 ((TStyleManager*) G__getstructoffset())->ModTitleAlign();
11584 G__setnull(result7);
11585 return(1 || funcname || hash || result7 || libp) ;
11586 }
11587
11588 static int G__G__Ged_305_0_253(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11589 {
11590 ((TStyleManager*) G__getstructoffset())->ModTitleBorderSize();
11591 G__setnull(result7);
11592 return(1 || funcname || hash || result7 || libp) ;
11593 }
11594
11595 static int G__G__Ged_305_0_254(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11596 {
11597 ((TStyleManager*) G__getstructoffset())->ModTitleX();
11598 G__setnull(result7);
11599 return(1 || funcname || hash || result7 || libp) ;
11600 }
11601
11602 static int G__G__Ged_305_0_255(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11603 {
11604 ((TStyleManager*) G__getstructoffset())->ModTitleY();
11605 G__setnull(result7);
11606 return(1 || funcname || hash || result7 || libp) ;
11607 }
11608
11609 static int G__G__Ged_305_0_256(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11610 {
11611 ((TStyleManager*) G__getstructoffset())->ModTitleW();
11612 G__setnull(result7);
11613 return(1 || funcname || hash || result7 || libp) ;
11614 }
11615
11616 static int G__G__Ged_305_0_257(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11617 {
11618 ((TStyleManager*) G__getstructoffset())->ModTitleH();
11619 G__setnull(result7);
11620 return(1 || funcname || hash || result7 || libp) ;
11621 }
11622
11623 static int G__G__Ged_305_0_258(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11624 {
11625 ((TStyleManager*) G__getstructoffset())->ModLegendBorderSize();
11626 G__setnull(result7);
11627 return(1 || funcname || hash || result7 || libp) ;
11628 }
11629
11630 static int G__G__Ged_305_0_259(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11631 {
11632 ((TStyleManager*) G__getstructoffset())->ModStatColor((Pixel_t) G__int(libp->para[0]));
11633 G__setnull(result7);
11634 return(1 || funcname || hash || result7 || libp) ;
11635 }
11636
11637 static int G__G__Ged_305_0_260(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11638 {
11639 ((TStyleManager*) G__getstructoffset())->ModStatStyle((Style_t) G__int(libp->para[0]));
11640 G__setnull(result7);
11641 return(1 || funcname || hash || result7 || libp) ;
11642 }
11643
11644 static int G__G__Ged_305_0_261(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11645 {
11646 ((TStyleManager*) G__getstructoffset())->ModStatTextColor((Pixel_t) G__int(libp->para[0]));
11647 G__setnull(result7);
11648 return(1 || funcname || hash || result7 || libp) ;
11649 }
11650
11651 static int G__G__Ged_305_0_262(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11652 {
11653 ((TStyleManager*) G__getstructoffset())->ModStatFontSize();
11654 G__setnull(result7);
11655 return(1 || funcname || hash || result7 || libp) ;
11656 }
11657
11658 static int G__G__Ged_305_0_263(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11659 {
11660 ((TStyleManager*) G__getstructoffset())->ModStatFontSizeInPixels((Bool_t) G__int(libp->para[0]));
11661 G__setnull(result7);
11662 return(1 || funcname || hash || result7 || libp) ;
11663 }
11664
11665 static int G__G__Ged_305_0_264(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11666 {
11667 ((TStyleManager*) G__getstructoffset())->ModStatFont();
11668 G__setnull(result7);
11669 return(1 || funcname || hash || result7 || libp) ;
11670 }
11671
11672 static int G__G__Ged_305_0_265(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11673 {
11674 ((TStyleManager*) G__getstructoffset())->ModStatX();
11675 G__setnull(result7);
11676 return(1 || funcname || hash || result7 || libp) ;
11677 }
11678
11679 static int G__G__Ged_305_0_266(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11680 {
11681 ((TStyleManager*) G__getstructoffset())->ModStatY();
11682 G__setnull(result7);
11683 return(1 || funcname || hash || result7 || libp) ;
11684 }
11685
11686 static int G__G__Ged_305_0_267(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11687 {
11688 ((TStyleManager*) G__getstructoffset())->ModStatW();
11689 G__setnull(result7);
11690 return(1 || funcname || hash || result7 || libp) ;
11691 }
11692
11693 static int G__G__Ged_305_0_268(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11694 {
11695 ((TStyleManager*) G__getstructoffset())->ModStatH();
11696 G__setnull(result7);
11697 return(1 || funcname || hash || result7 || libp) ;
11698 }
11699
11700 static int G__G__Ged_305_0_269(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11701 {
11702 ((TStyleManager*) G__getstructoffset())->ModStatBorderSize();
11703 G__setnull(result7);
11704 return(1 || funcname || hash || result7 || libp) ;
11705 }
11706
11707 static int G__G__Ged_305_0_270(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11708 {
11709 ((TStyleManager*) G__getstructoffset())->ModOptStat();
11710 G__setnull(result7);
11711 return(1 || funcname || hash || result7 || libp) ;
11712 }
11713
11714 static int G__G__Ged_305_0_271(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11715 {
11716 ((TStyleManager*) G__getstructoffset())->ModStatFormat((const char*) G__int(libp->para[0]));
11717 G__setnull(result7);
11718 return(1 || funcname || hash || result7 || libp) ;
11719 }
11720
11721 static int G__G__Ged_305_0_272(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11722 {
11723 ((TStyleManager*) G__getstructoffset())->ModOptFit();
11724 G__setnull(result7);
11725 return(1 || funcname || hash || result7 || libp) ;
11726 }
11727
11728 static int G__G__Ged_305_0_273(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11729 {
11730 ((TStyleManager*) G__getstructoffset())->ModFitFormat((const char*) G__int(libp->para[0]));
11731 G__setnull(result7);
11732 return(1 || funcname || hash || result7 || libp) ;
11733 }
11734
11735 static int G__G__Ged_305_0_274(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11736 {
11737 ((TStyleManager*) G__getstructoffset())->ModHeaderPS();
11738 G__setnull(result7);
11739 return(1 || funcname || hash || result7 || libp) ;
11740 }
11741
11742 static int G__G__Ged_305_0_275(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11743 {
11744 ((TStyleManager*) G__getstructoffset())->ModTitlePS();
11745 G__setnull(result7);
11746 return(1 || funcname || hash || result7 || libp) ;
11747 }
11748
11749 static int G__G__Ged_305_0_276(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11750 {
11751 ((TStyleManager*) G__getstructoffset())->ModColorModelPS();
11752 G__setnull(result7);
11753 return(1 || funcname || hash || result7 || libp) ;
11754 }
11755
11756 static int G__G__Ged_305_0_277(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11757 {
11758 ((TStyleManager*) G__getstructoffset())->ModLineScalePS();
11759 G__setnull(result7);
11760 return(1 || funcname || hash || result7 || libp) ;
11761 }
11762
11763 static int G__G__Ged_305_0_278(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11764 {
11765 ((TStyleManager*) G__getstructoffset())->ModPaperSizePredef();
11766 G__setnull(result7);
11767 return(1 || funcname || hash || result7 || libp) ;
11768 }
11769
11770 static int G__G__Ged_305_0_279(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11771 {
11772 ((TStyleManager*) G__getstructoffset())->ModPaperSizeXY();
11773 G__setnull(result7);
11774 return(1 || funcname || hash || result7 || libp) ;
11775 }
11776
11777 static int G__G__Ged_305_0_280(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11778 {
11779 G__letint(result7, 85, (long) TStyleManager::Class());
11780 return(1 || funcname || hash || result7 || libp) ;
11781 }
11782
11783 static int G__G__Ged_305_0_281(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11784 {
11785 G__letint(result7, 67, (long) TStyleManager::Class_Name());
11786 return(1 || funcname || hash || result7 || libp) ;
11787 }
11788
11789 static int G__G__Ged_305_0_282(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11790 {
11791 G__letint(result7, 115, (long) TStyleManager::Class_Version());
11792 return(1 || funcname || hash || result7 || libp) ;
11793 }
11794
11795 static int G__G__Ged_305_0_283(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11796 {
11797 TStyleManager::Dictionary();
11798 G__setnull(result7);
11799 return(1 || funcname || hash || result7 || libp) ;
11800 }
11801
11802 static int G__G__Ged_305_0_287(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11803 {
11804 ((TStyleManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11805 G__setnull(result7);
11806 return(1 || funcname || hash || result7 || libp) ;
11807 }
11808
11809 static int G__G__Ged_305_0_288(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11810 {
11811 G__letint(result7, 67, (long) TStyleManager::DeclFileName());
11812 return(1 || funcname || hash || result7 || libp) ;
11813 }
11814
11815 static int G__G__Ged_305_0_289(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11816 {
11817 G__letint(result7, 105, (long) TStyleManager::ImplFileLine());
11818 return(1 || funcname || hash || result7 || libp) ;
11819 }
11820
11821 static int G__G__Ged_305_0_290(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11822 {
11823 G__letint(result7, 67, (long) TStyleManager::ImplFileName());
11824 return(1 || funcname || hash || result7 || libp) ;
11825 }
11826
11827 static int G__G__Ged_305_0_291(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11828 {
11829 G__letint(result7, 105, (long) TStyleManager::DeclFileLine());
11830 return(1 || funcname || hash || result7 || libp) ;
11831 }
11832
11833
11834 typedef TStyleManager G__TTStyleManager;
11835 static int G__G__Ged_305_0_292(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11836 {
11837 char* gvp = (char*) G__getgvp();
11838 long soff = G__getstructoffset();
11839 int n = G__getaryconstruct();
11840
11841
11842
11843
11844
11845 if (!soff) {
11846 return(1);
11847 }
11848 if (n) {
11849 if (gvp == (char*)G__PVOID) {
11850 delete[] (TStyleManager*) soff;
11851 } else {
11852 G__setgvp((long) G__PVOID);
11853 for (int i = n - 1; i >= 0; --i) {
11854 ((TStyleManager*) (soff+(sizeof(TStyleManager)*i)))->~G__TTStyleManager();
11855 }
11856 G__setgvp((long)gvp);
11857 }
11858 } else {
11859 if (gvp == (char*)G__PVOID) {
11860 delete (TStyleManager*) soff;
11861 } else {
11862 G__setgvp((long) G__PVOID);
11863 ((TStyleManager*) (soff))->~G__TTStyleManager();
11864 G__setgvp((long)gvp);
11865 }
11866 }
11867 G__setnull(result7);
11868 return(1 || funcname || hash || result7 || libp) ;
11869 }
11870
11871
11872
11873 static int G__G__Ged_306_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11874 {
11875 TStyleDialog* p = NULL;
11876 char* gvp = (char*) G__getgvp();
11877 switch (libp->paran) {
11878 case 4:
11879
11880 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11881 p = new TStyleDialog(
11882 (TStyleManager*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
11883 , (Int_t) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3]));
11884 } else {
11885 p = new((void*) gvp) TStyleDialog(
11886 (TStyleManager*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
11887 , (Int_t) G__int(libp->para[2]), (TVirtualPad*) G__int(libp->para[3]));
11888 }
11889 break;
11890 case 3:
11891
11892 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11893 p = new TStyleDialog(
11894 (TStyleManager*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
11895 , (Int_t) G__int(libp->para[2]));
11896 } else {
11897 p = new((void*) gvp) TStyleDialog(
11898 (TStyleManager*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
11899 , (Int_t) G__int(libp->para[2]));
11900 }
11901 break;
11902 }
11903 result7->obj.i = (long) p;
11904 result7->ref = (long) p;
11905 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TStyleDialog));
11906 return(1 || funcname || hash || result7 || libp) ;
11907 }
11908
11909 static int G__G__Ged_306_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11910 {
11911 ((TStyleDialog*) G__getstructoffset())->DoCloseWindow();
11912 G__setnull(result7);
11913 return(1 || funcname || hash || result7 || libp) ;
11914 }
11915
11916 static int G__G__Ged_306_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11917 {
11918 ((TStyleDialog*) G__getstructoffset())->DoCancel();
11919 G__setnull(result7);
11920 return(1 || funcname || hash || result7 || libp) ;
11921 }
11922
11923 static int G__G__Ged_306_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11924 {
11925 ((TStyleDialog*) G__getstructoffset())->DoOK();
11926 G__setnull(result7);
11927 return(1 || funcname || hash || result7 || libp) ;
11928 }
11929
11930 static int G__G__Ged_306_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11931 {
11932 ((TStyleDialog*) G__getstructoffset())->DoUpdate();
11933 G__setnull(result7);
11934 return(1 || funcname || hash || result7 || libp) ;
11935 }
11936
11937 static int G__G__Ged_306_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11938 {
11939 G__letint(result7, 85, (long) TStyleDialog::Class());
11940 return(1 || funcname || hash || result7 || libp) ;
11941 }
11942
11943 static int G__G__Ged_306_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11944 {
11945 G__letint(result7, 67, (long) TStyleDialog::Class_Name());
11946 return(1 || funcname || hash || result7 || libp) ;
11947 }
11948
11949 static int G__G__Ged_306_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11950 {
11951 G__letint(result7, 115, (long) TStyleDialog::Class_Version());
11952 return(1 || funcname || hash || result7 || libp) ;
11953 }
11954
11955 static int G__G__Ged_306_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11956 {
11957 TStyleDialog::Dictionary();
11958 G__setnull(result7);
11959 return(1 || funcname || hash || result7 || libp) ;
11960 }
11961
11962 static int G__G__Ged_306_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11963 {
11964 ((TStyleDialog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11965 G__setnull(result7);
11966 return(1 || funcname || hash || result7 || libp) ;
11967 }
11968
11969 static int G__G__Ged_306_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11970 {
11971 G__letint(result7, 67, (long) TStyleDialog::DeclFileName());
11972 return(1 || funcname || hash || result7 || libp) ;
11973 }
11974
11975 static int G__G__Ged_306_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11976 {
11977 G__letint(result7, 105, (long) TStyleDialog::ImplFileLine());
11978 return(1 || funcname || hash || result7 || libp) ;
11979 }
11980
11981 static int G__G__Ged_306_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11982 {
11983 G__letint(result7, 67, (long) TStyleDialog::ImplFileName());
11984 return(1 || funcname || hash || result7 || libp) ;
11985 }
11986
11987 static int G__G__Ged_306_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11988 {
11989 G__letint(result7, 105, (long) TStyleDialog::DeclFileLine());
11990 return(1 || funcname || hash || result7 || libp) ;
11991 }
11992
11993
11994 typedef TStyleDialog G__TTStyleDialog;
11995 static int G__G__Ged_306_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11996 {
11997 char* gvp = (char*) G__getgvp();
11998 long soff = G__getstructoffset();
11999 int n = G__getaryconstruct();
12000
12001
12002
12003
12004
12005 if (!soff) {
12006 return(1);
12007 }
12008 if (n) {
12009 if (gvp == (char*)G__PVOID) {
12010 delete[] (TStyleDialog*) soff;
12011 } else {
12012 G__setgvp((long) G__PVOID);
12013 for (int i = n - 1; i >= 0; --i) {
12014 ((TStyleDialog*) (soff+(sizeof(TStyleDialog)*i)))->~G__TTStyleDialog();
12015 }
12016 G__setgvp((long)gvp);
12017 }
12018 } else {
12019 if (gvp == (char*)G__PVOID) {
12020 delete (TStyleDialog*) soff;
12021 } else {
12022 G__setgvp((long) G__PVOID);
12023 ((TStyleDialog*) (soff))->~G__TTStyleDialog();
12024 G__setgvp((long)gvp);
12025 }
12026 }
12027 G__setnull(result7);
12028 return(1 || funcname || hash || result7 || libp) ;
12029 }
12030
12031
12032
12033 static int G__G__Ged_323_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12034 {
12035 TStylePreview* p = NULL;
12036 char* gvp = (char*) G__getgvp();
12037
12038 if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12039 p = new TStylePreview(
12040 (TGWindow*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
12041 , (TVirtualPad*) G__int(libp->para[2]));
12042 } else {
12043 p = new((void*) gvp) TStylePreview(
12044 (TGWindow*) G__int(libp->para[0]), (TStyle*) G__int(libp->para[1])
12045 , (TVirtualPad*) G__int(libp->para[2]));
12046 }
12047 result7->obj.i = (long) p;
12048 result7->ref = (long) p;
12049 G__set_tagnum(result7,G__get_linked_tagnum(&G__G__GedLN_TStylePreview));
12050 return(1 || funcname || hash || result7 || libp) ;
12051 }
12052
12053 static int G__G__Ged_323_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12054 {
12055 ((TStylePreview*) G__getstructoffset())->Update((TStyle*) G__int(libp->para[0]), (TVirtualPad*) G__int(libp->para[1]));
12056 G__setnull(result7);
12057 return(1 || funcname || hash || result7 || libp) ;
12058 }
12059
12060 static int G__G__Ged_323_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12061 {
12062 ((TStylePreview*) G__getstructoffset())->MapTheWindow();
12063 G__setnull(result7);
12064 return(1 || funcname || hash || result7 || libp) ;
12065 }
12066
12067 static int G__G__Ged_323_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12068 {
12069 G__letint(result7, 85, (long) ((TStylePreview*) G__getstructoffset())->GetMainCanvas());
12070 return(1 || funcname || hash || result7 || libp) ;
12071 }
12072
12073 static int G__G__Ged_323_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12074 {
12075 G__letint(result7, 85, (long) TStylePreview::Class());
12076 return(1 || funcname || hash || result7 || libp) ;
12077 }
12078
12079 static int G__G__Ged_323_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12080 {
12081 G__letint(result7, 67, (long) TStylePreview::Class_Name());
12082 return(1 || funcname || hash || result7 || libp) ;
12083 }
12084
12085 static int G__G__Ged_323_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12086 {
12087 G__letint(result7, 115, (long) TStylePreview::Class_Version());
12088 return(1 || funcname || hash || result7 || libp) ;
12089 }
12090
12091 static int G__G__Ged_323_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12092 {
12093 TStylePreview::Dictionary();
12094 G__setnull(result7);
12095 return(1 || funcname || hash || result7 || libp) ;
12096 }
12097
12098 static int G__G__Ged_323_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12099 {
12100 ((TStylePreview*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12101 G__setnull(result7);
12102 return(1 || funcname || hash || result7 || libp) ;
12103 }
12104
12105 static int G__G__Ged_323_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12106 {
12107 G__letint(result7, 67, (long) TStylePreview::DeclFileName());
12108 return(1 || funcname || hash || result7 || libp) ;
12109 }
12110
12111 static int G__G__Ged_323_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12112 {
12113 G__letint(result7, 105, (long) TStylePreview::ImplFileLine());
12114 return(1 || funcname || hash || result7 || libp) ;
12115 }
12116
12117 static int G__G__Ged_323_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12118 {
12119 G__letint(result7, 67, (long) TStylePreview::ImplFileName());
12120 return(1 || funcname || hash || result7 || libp) ;
12121 }
12122
12123 static int G__G__Ged_323_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12124 {
12125 G__letint(result7, 105, (long) TStylePreview::DeclFileLine());
12126 return(1 || funcname || hash || result7 || libp) ;
12127 }
12128
12129
12130 typedef TStylePreview G__TTStylePreview;
12131 static int G__G__Ged_323_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12132 {
12133 char* gvp = (char*) G__getgvp();
12134 long soff = G__getstructoffset();
12135 int n = G__getaryconstruct();
12136
12137
12138
12139
12140
12141 if (!soff) {
12142 return(1);
12143 }
12144 if (n) {
12145 if (gvp == (char*)G__PVOID) {
12146 delete[] (TStylePreview*) soff;
12147 } else {
12148 G__setgvp((long) G__PVOID);
12149 for (int i = n - 1; i >= 0; --i) {
12150 ((TStylePreview*) (soff+(sizeof(TStylePreview)*i)))->~G__TTStylePreview();
12151 }
12152 G__setgvp((long)gvp);
12153 }
12154 } else {
12155 if (gvp == (char*)G__PVOID) {
12156 delete (TStylePreview*) soff;
12157 } else {
12158 G__setgvp((long) G__PVOID);
12159 ((TStylePreview*) (soff))->~G__TTStylePreview();
12160 G__setgvp((long)gvp);
12161 }
12162 }
12163 G__setnull(result7);
12164 return(1 || funcname || hash || result7 || libp) ;
12165 }
12166
12167
12168
12169
12170
12171
12172
12173
12174
12175
12176
12177
12178
12179
12180
12181
12182
12183
12184
12185
12186
12187
12188
12189
12190
12191
12192
12193
12194
12195
12196
12197
12198
12199
12200
12201
12202
12203
12204
12205
12206
12207
12208
12209
12210
12211
12212
12213
12214
12215
12216
12217
12218
12219
12220
12221
12222
12223
12224
12225
12226
12227
12228
12229
12230
12231
12232
12233
12234
12235
12236
12237
12238
12239
12240
12241
12242
12243
12244
12245
12246
12247 class G__Sizep2memfuncG__Ged {
12248 public:
12249 G__Sizep2memfuncG__Ged(): p(&G__Sizep2memfuncG__Ged::sizep2memfunc) {}
12250 size_t sizep2memfunc() { return(sizeof(p)); }
12251 private:
12252 size_t (G__Sizep2memfuncG__Ged::*p)();
12253 };
12254
12255 size_t G__get_sizep2memfuncG__Ged()
12256 {
12257 G__Sizep2memfuncG__Ged a;
12258 G__setsizep2memfunc((int)a.sizep2memfunc());
12259 return((size_t)a.sizep2memfunc());
12260 }
12261
12262
12263
12264
12265
12266
12267
12268
12269
12270
12271
12272 extern "C" void G__cpp_setup_inheritanceG__Ged() {
12273
12274
12275 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedEditor))) {
12276 TGedEditor *G__Lderived;
12277 G__Lderived=(TGedEditor*)0x1000;
12278 {
12279 TVirtualPadEditor *G__Lpbase=(TVirtualPadEditor*)G__Lderived;
12280 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TVirtualPadEditor),(long)G__Lpbase-(long)G__Lderived,1,1);
12281 }
12282 {
12283 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
12284 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12285 }
12286 {
12287 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12288 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12289 }
12290 {
12291 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12292 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12293 }
12294 {
12295 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12296 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12297 }
12298 {
12299 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12300 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12301 }
12302 {
12303 TObject *G__Lpbase=(TObject*)G__Lderived;
12304 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12305 }
12306 {
12307 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12308 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12309 }
12310 }
12311 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedFrame))) {
12312 TGedFrame *G__Lderived;
12313 G__Lderived=(TGedFrame*)0x1000;
12314 {
12315 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12316 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12317 }
12318 {
12319 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12320 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12321 }
12322 {
12323 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12324 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12325 }
12326 {
12327 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12328 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12329 }
12330 {
12331 TObject *G__Lpbase=(TObject*)G__Lderived;
12332 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12333 }
12334 {
12335 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12336 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12337 }
12338 }
12339 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame))) {
12340 TGedNameFrame *G__Lderived;
12341 G__Lderived=(TGedNameFrame*)0x1000;
12342 {
12343 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12344 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12345 }
12346 {
12347 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12348 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12349 }
12350 {
12351 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12352 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12353 }
12354 {
12355 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12356 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12357 }
12358 {
12359 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12360 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12361 }
12362 {
12363 TObject *G__Lpbase=(TObject*)G__Lderived;
12364 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12365 }
12366 {
12367 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12368 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12369 }
12370 }
12371 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor))) {
12372 TArrowEditor *G__Lderived;
12373 G__Lderived=(TArrowEditor*)0x1000;
12374 {
12375 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12376 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12377 }
12378 {
12379 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12380 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12381 }
12382 {
12383 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12384 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12385 }
12386 {
12387 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12388 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12389 }
12390 {
12391 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12392 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12393 }
12394 {
12395 TObject *G__Lpbase=(TObject*)G__Lderived;
12396 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12397 }
12398 {
12399 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12400 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12401 }
12402 }
12403 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect))) {
12404 TGedPatternSelect *G__Lderived;
12405 G__Lderived=(TGedPatternSelect*)0x1000;
12406 {
12407 TGedSelect *G__Lpbase=(TGedSelect*)G__Lderived;
12408 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGedSelect),(long)G__Lpbase-(long)G__Lderived,1,1);
12409 }
12410 {
12411 TGCheckButton *G__Lpbase=(TGCheckButton*)G__Lderived;
12412 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),(long)G__Lpbase-(long)G__Lderived,1,0);
12413 }
12414 {
12415 TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
12416 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,0);
12417 }
12418 {
12419 TGButton *G__Lpbase=(TGButton*)G__Lderived;
12420 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
12421 }
12422 {
12423 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12424 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12425 }
12426 {
12427 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12428 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12429 }
12430 {
12431 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12432 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12433 }
12434 {
12435 TObject *G__Lpbase=(TObject*)G__Lderived;
12436 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12437 }
12438 {
12439 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12440 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12441 }
12442 {
12443 TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
12444 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
12445 }
12446 }
12447 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor))) {
12448 TAttFillEditor *G__Lderived;
12449 G__Lderived=(TAttFillEditor*)0x1000;
12450 {
12451 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12452 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12453 }
12454 {
12455 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12456 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12457 }
12458 {
12459 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12460 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12461 }
12462 {
12463 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12464 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12465 }
12466 {
12467 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12468 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12469 }
12470 {
12471 TObject *G__Lpbase=(TObject*)G__Lderived;
12472 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12473 }
12474 {
12475 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12476 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12477 }
12478 }
12479 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor))) {
12480 TAttLineEditor *G__Lderived;
12481 G__Lderived=(TAttLineEditor*)0x1000;
12482 {
12483 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12484 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12485 }
12486 {
12487 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12488 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12489 }
12490 {
12491 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12492 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12493 }
12494 {
12495 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12496 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12497 }
12498 {
12499 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12500 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12501 }
12502 {
12503 TObject *G__Lpbase=(TObject*)G__Lderived;
12504 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12505 }
12506 {
12507 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12508 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12509 }
12510 }
12511 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect))) {
12512 TGedMarkerSelect *G__Lderived;
12513 G__Lderived=(TGedMarkerSelect*)0x1000;
12514 {
12515 TGedSelect *G__Lpbase=(TGedSelect*)G__Lderived;
12516 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGedSelect),(long)G__Lpbase-(long)G__Lderived,1,1);
12517 }
12518 {
12519 TGCheckButton *G__Lpbase=(TGCheckButton*)G__Lderived;
12520 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),(long)G__Lpbase-(long)G__Lderived,1,0);
12521 }
12522 {
12523 TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
12524 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,0);
12525 }
12526 {
12527 TGButton *G__Lpbase=(TGButton*)G__Lderived;
12528 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
12529 }
12530 {
12531 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12532 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12533 }
12534 {
12535 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12536 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12537 }
12538 {
12539 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12540 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12541 }
12542 {
12543 TObject *G__Lpbase=(TObject*)G__Lderived;
12544 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12545 }
12546 {
12547 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12548 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12549 }
12550 {
12551 TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
12552 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
12553 }
12554 }
12555 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor))) {
12556 TAttMarkerEditor *G__Lderived;
12557 G__Lderived=(TAttMarkerEditor*)0x1000;
12558 {
12559 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12560 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12561 }
12562 {
12563 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12564 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12565 }
12566 {
12567 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12568 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12569 }
12570 {
12571 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12572 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12573 }
12574 {
12575 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12576 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12577 }
12578 {
12579 TObject *G__Lpbase=(TObject*)G__Lderived;
12580 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12581 }
12582 {
12583 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12584 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12585 }
12586 }
12587 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor))) {
12588 TAttTextEditor *G__Lderived;
12589 G__Lderived=(TAttTextEditor*)0x1000;
12590 {
12591 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12592 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12593 }
12594 {
12595 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12596 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12597 }
12598 {
12599 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12600 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12601 }
12602 {
12603 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12604 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12605 }
12606 {
12607 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12608 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12609 }
12610 {
12611 TObject *G__Lpbase=(TObject*)G__Lderived;
12612 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12613 }
12614 {
12615 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12616 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12617 }
12618 }
12619 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton))) {
12620 TGCheckButton *G__Lderived;
12621 G__Lderived=(TGCheckButton*)0x1000;
12622 {
12623 TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
12624 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,1);
12625 }
12626 {
12627 TGButton *G__Lpbase=(TGButton*)G__Lderived;
12628 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
12629 }
12630 {
12631 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12632 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12633 }
12634 {
12635 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12636 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12637 }
12638 {
12639 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12640 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12641 }
12642 {
12643 TObject *G__Lpbase=(TObject*)G__Lderived;
12644 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12645 }
12646 {
12647 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12648 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12649 }
12650 {
12651 TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
12652 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
12653 }
12654 }
12655 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor))) {
12656 TAxisEditor *G__Lderived;
12657 G__Lderived=(TAxisEditor*)0x1000;
12658 {
12659 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12660 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12661 }
12662 {
12663 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12664 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12665 }
12666 {
12667 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12668 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12669 }
12670 {
12671 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12672 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12673 }
12674 {
12675 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12676 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12677 }
12678 {
12679 TObject *G__Lpbase=(TObject*)G__Lderived;
12680 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12681 }
12682 {
12683 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12684 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12685 }
12686 }
12687 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor))) {
12688 TCurlyArcEditor *G__Lderived;
12689 G__Lderived=(TCurlyArcEditor*)0x1000;
12690 {
12691 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12692 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12693 }
12694 {
12695 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12696 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12697 }
12698 {
12699 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12700 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12701 }
12702 {
12703 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12704 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12705 }
12706 {
12707 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12708 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12709 }
12710 {
12711 TObject *G__Lpbase=(TObject*)G__Lderived;
12712 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12713 }
12714 {
12715 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12716 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12717 }
12718 }
12719 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor))) {
12720 TCurlyLineEditor *G__Lderived;
12721 G__Lderived=(TCurlyLineEditor*)0x1000;
12722 {
12723 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12724 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12725 }
12726 {
12727 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12728 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12729 }
12730 {
12731 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12732 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12733 }
12734 {
12735 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12736 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12737 }
12738 {
12739 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12740 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12741 }
12742 {
12743 TObject *G__Lpbase=(TObject*)G__Lderived;
12744 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12745 }
12746 {
12747 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12748 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12749 }
12750 }
12751 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TF1Editor))) {
12752 TF1Editor *G__Lderived;
12753 G__Lderived=(TF1Editor*)0x1000;
12754 {
12755 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12756 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12757 }
12758 {
12759 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12760 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12761 }
12762 {
12763 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12764 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12765 }
12766 {
12767 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12768 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12769 }
12770 {
12771 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12772 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12773 }
12774 {
12775 TObject *G__Lpbase=(TObject*)G__Lderived;
12776 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12777 }
12778 {
12779 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12780 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12781 }
12782 }
12783 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor))) {
12784 TFrameEditor *G__Lderived;
12785 G__Lderived=(TFrameEditor*)0x1000;
12786 {
12787 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
12788 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12789 }
12790 {
12791 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12792 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12793 }
12794 {
12795 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12796 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12797 }
12798 {
12799 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12800 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12801 }
12802 {
12803 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12804 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12805 }
12806 {
12807 TObject *G__Lpbase=(TObject*)G__Lderived;
12808 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12809 }
12810 {
12811 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12812 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12813 }
12814 }
12815 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog))) {
12816 TFunctionParametersDialog *G__Lderived;
12817 G__Lderived=(TFunctionParametersDialog*)0x1000;
12818 {
12819 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
12820 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12821 }
12822 {
12823 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
12824 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12825 }
12826 {
12827 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12828 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12829 }
12830 {
12831 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12832 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12833 }
12834 {
12835 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12836 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12837 }
12838 {
12839 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12840 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12841 }
12842 {
12843 TObject *G__Lpbase=(TObject*)G__Lderived;
12844 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12845 }
12846 {
12847 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12848 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12849 }
12850 }
12851 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGButton))) {
12852 TGButton *G__Lderived;
12853 G__Lderived=(TGButton*)0x1000;
12854 {
12855 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12856 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12857 }
12858 {
12859 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12860 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12861 }
12862 {
12863 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12864 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12865 }
12866 {
12867 TObject *G__Lpbase=(TObject*)G__Lderived;
12868 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12869 }
12870 {
12871 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12872 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12873 }
12874 {
12875 TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
12876 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGButton),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,1);
12877 }
12878 }
12879 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPopup))) {
12880 TGedPopup *G__Lderived;
12881 G__Lderived=(TGedPopup*)0x1000;
12882 {
12883 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12884 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12885 }
12886 {
12887 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12888 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12889 }
12890 {
12891 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12892 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12893 }
12894 {
12895 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12896 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12897 }
12898 {
12899 TObject *G__Lpbase=(TObject*)G__Lderived;
12900 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12901 }
12902 {
12903 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12904 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12905 }
12906 }
12907 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame))) {
12908 TGedPatternFrame *G__Lderived;
12909 G__Lderived=(TGedPatternFrame*)0x1000;
12910 {
12911 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12912 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12913 }
12914 {
12915 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12916 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12917 }
12918 {
12919 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12920 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12921 }
12922 {
12923 TObject *G__Lpbase=(TObject*)G__Lderived;
12924 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12925 }
12926 {
12927 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12928 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12929 }
12930 }
12931 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector))) {
12932 TGedPatternSelector *G__Lderived;
12933 G__Lderived=(TGedPatternSelector*)0x1000;
12934 {
12935 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12936 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
12937 }
12938 {
12939 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12940 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12941 }
12942 {
12943 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12944 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12945 }
12946 {
12947 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12948 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12949 }
12950 {
12951 TObject *G__Lpbase=(TObject*)G__Lderived;
12952 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12953 }
12954 {
12955 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12956 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12957 }
12958 }
12959 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup))) {
12960 TGedPatternPopup *G__Lderived;
12961 G__Lderived=(TGedPatternPopup*)0x1000;
12962 {
12963 TGedPopup *G__Lpbase=(TGedPopup*)G__Lderived;
12964 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGedPopup),(long)G__Lpbase-(long)G__Lderived,1,1);
12965 }
12966 {
12967 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
12968 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12969 }
12970 {
12971 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
12972 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
12973 }
12974 {
12975 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
12976 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
12977 }
12978 {
12979 TGObject *G__Lpbase=(TGObject*)G__Lderived;
12980 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12981 }
12982 {
12983 TObject *G__Lpbase=(TObject*)G__Lderived;
12984 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12985 }
12986 {
12987 TQObject *G__Lpbase=(TQObject*)G__Lderived;
12988 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
12989 }
12990 }
12991 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedSelect))) {
12992 TGedSelect *G__Lderived;
12993 G__Lderived=(TGedSelect*)0x1000;
12994 {
12995 TGCheckButton *G__Lpbase=(TGCheckButton*)G__Lderived;
12996 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),(long)G__Lpbase-(long)G__Lderived,1,1);
12997 }
12998 {
12999 TGTextButton *G__Lpbase=(TGTextButton*)G__Lderived;
13000 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGTextButton),(long)G__Lpbase-(long)G__Lderived,1,0);
13001 }
13002 {
13003 TGButton *G__Lpbase=(TGButton*)G__Lderived;
13004 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGButton),(long)G__Lpbase-(long)G__Lderived,1,0);
13005 }
13006 {
13007 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13008 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13009 }
13010 {
13011 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13012 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13013 }
13014 {
13015 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13016 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13017 }
13018 {
13019 TObject *G__Lpbase=(TObject*)G__Lderived;
13020 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13021 }
13022 {
13023 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13024 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13025 }
13026 {
13027 TGWidget *G__Lpbase=(TGWidget*)G__Lderived;
13028 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect),G__get_linked_tagnum(&G__G__GedLN_TGWidget),(long)G__Lpbase-(long)G__Lderived,1,0);
13029 }
13030 }
13031 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup))) {
13032 TGedMarkerPopup *G__Lderived;
13033 G__Lderived=(TGedMarkerPopup*)0x1000;
13034 {
13035 TGedPopup *G__Lpbase=(TGedPopup*)G__Lderived;
13036 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGedPopup),(long)G__Lpbase-(long)G__Lderived,1,1);
13037 }
13038 {
13039 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13040 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13041 }
13042 {
13043 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13044 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13045 }
13046 {
13047 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13048 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13049 }
13050 {
13051 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13052 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13053 }
13054 {
13055 TObject *G__Lpbase=(TObject*)G__Lderived;
13056 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13057 }
13058 {
13059 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13060 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13061 }
13062 }
13063 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor))) {
13064 TGraphEditor *G__Lderived;
13065 G__Lderived=(TGraphEditor*)0x1000;
13066 {
13067 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13068 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13069 }
13070 {
13071 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13072 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13073 }
13074 {
13075 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13076 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13077 }
13078 {
13079 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13080 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13081 }
13082 {
13083 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13084 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13085 }
13086 {
13087 TObject *G__Lpbase=(TObject*)G__Lderived;
13088 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13089 }
13090 {
13091 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13092 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13093 }
13094 }
13095 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TH1Editor))) {
13096 TH1Editor *G__Lderived;
13097 G__Lderived=(TH1Editor*)0x1000;
13098 {
13099 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13100 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13101 }
13102 {
13103 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13104 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13105 }
13106 {
13107 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13108 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13109 }
13110 {
13111 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13112 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13113 }
13114 {
13115 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13116 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13117 }
13118 {
13119 TObject *G__Lpbase=(TObject*)G__Lderived;
13120 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13121 }
13122 {
13123 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13124 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13125 }
13126 }
13127 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TH2Editor))) {
13128 TH2Editor *G__Lderived;
13129 G__Lderived=(TH2Editor*)0x1000;
13130 {
13131 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13132 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13133 }
13134 {
13135 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13136 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13137 }
13138 {
13139 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13140 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13141 }
13142 {
13143 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13144 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13145 }
13146 {
13147 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13148 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13149 }
13150 {
13151 TObject *G__Lpbase=(TObject*)G__Lderived;
13152 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13153 }
13154 {
13155 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13156 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13157 }
13158 }
13159 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TLineEditor))) {
13160 TLineEditor *G__Lderived;
13161 G__Lderived=(TLineEditor*)0x1000;
13162 {
13163 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13164 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13165 }
13166 {
13167 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13168 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13169 }
13170 {
13171 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13172 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13173 }
13174 {
13175 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13176 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13177 }
13178 {
13179 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13180 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13181 }
13182 {
13183 TObject *G__Lpbase=(TObject*)G__Lderived;
13184 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13185 }
13186 {
13187 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13188 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13189 }
13190 }
13191 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TPadEditor))) {
13192 TPadEditor *G__Lderived;
13193 G__Lderived=(TPadEditor*)0x1000;
13194 {
13195 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13196 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13197 }
13198 {
13199 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13200 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13201 }
13202 {
13203 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13204 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13205 }
13206 {
13207 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13208 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13209 }
13210 {
13211 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13212 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13213 }
13214 {
13215 TObject *G__Lpbase=(TObject*)G__Lderived;
13216 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13217 }
13218 {
13219 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13220 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13221 }
13222 }
13223 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor))) {
13224 TPaveStatsEditor *G__Lderived;
13225 G__Lderived=(TPaveStatsEditor*)0x1000;
13226 {
13227 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13228 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13229 }
13230 {
13231 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13232 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13233 }
13234 {
13235 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13236 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13237 }
13238 {
13239 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13240 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13241 }
13242 {
13243 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13244 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13245 }
13246 {
13247 TObject *G__Lpbase=(TObject*)G__Lderived;
13248 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13249 }
13250 {
13251 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13252 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13253 }
13254 }
13255 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TPieEditor))) {
13256 TPieEditor *G__Lderived;
13257 G__Lderived=(TPieEditor*)0x1000;
13258 {
13259 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13260 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13261 }
13262 {
13263 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13264 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13265 }
13266 {
13267 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13268 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13269 }
13270 {
13271 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13272 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13273 }
13274 {
13275 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13276 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13277 }
13278 {
13279 TObject *G__Lpbase=(TObject*)G__Lderived;
13280 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13281 }
13282 {
13283 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13284 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13285 }
13286 }
13287 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor))) {
13288 TPieSliceEditor *G__Lderived;
13289 G__Lderived=(TPieSliceEditor*)0x1000;
13290 {
13291 TGedFrame *G__Lpbase=(TGedFrame*)G__Lderived;
13292 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGedFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13293 }
13294 {
13295 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13296 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13297 }
13298 {
13299 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13300 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13301 }
13302 {
13303 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13304 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13305 }
13306 {
13307 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13308 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13309 }
13310 {
13311 TObject *G__Lpbase=(TObject*)G__Lderived;
13312 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13313 }
13314 {
13315 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13316 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13317 }
13318 }
13319 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TStyleManager))) {
13320 TStyleManager *G__Lderived;
13321 G__Lderived=(TStyleManager*)0x1000;
13322 {
13323 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13324 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13325 }
13326 {
13327 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13328 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13329 }
13330 {
13331 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13332 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13333 }
13334 {
13335 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13336 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13337 }
13338 {
13339 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13340 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13341 }
13342 {
13343 TObject *G__Lpbase=(TObject*)G__Lderived;
13344 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13345 }
13346 {
13347 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13348 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13349 }
13350 }
13351 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog))) {
13352 TStyleDialog *G__Lderived;
13353 G__Lderived=(TStyleDialog*)0x1000;
13354 {
13355 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
13356 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13357 }
13358 {
13359 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13360 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13361 }
13362 {
13363 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13364 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13365 }
13366 {
13367 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13368 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13369 }
13370 {
13371 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13372 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13373 }
13374 {
13375 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13376 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13377 }
13378 {
13379 TObject *G__Lpbase=(TObject*)G__Lderived;
13380 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13381 }
13382 {
13383 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13384 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13385 }
13386 }
13387 if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__GedLN_TStylePreview))) {
13388 TStylePreview *G__Lderived;
13389 G__Lderived=(TStylePreview*)0x1000;
13390 {
13391 TGTransientFrame *G__Lpbase=(TGTransientFrame*)G__Lderived;
13392 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGTransientFrame),(long)G__Lpbase-(long)G__Lderived,1,1);
13393 }
13394 {
13395 TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived;
13396 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13397 }
13398 {
13399 TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived;
13400 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13401 }
13402 {
13403 TGFrame *G__Lpbase=(TGFrame*)G__Lderived;
13404 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0);
13405 }
13406 {
13407 TGWindow *G__Lpbase=(TGWindow*)G__Lderived;
13408 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0);
13409 }
13410 {
13411 TGObject *G__Lpbase=(TGObject*)G__Lderived;
13412 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13413 }
13414 {
13415 TObject *G__Lpbase=(TObject*)G__Lderived;
13416 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13417 }
13418 {
13419 TQObject *G__Lpbase=(TQObject*)G__Lderived;
13420 G__inheritance_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview),G__get_linked_tagnum(&G__G__GedLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
13421 }
13422 }
13423 }
13424
13425
13426
13427
13428 extern "C" void G__cpp_setup_typetableG__Ged() {
13429
13430
13431 G__search_typename2("Int_t",105,-1,0,-1);
13432 G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
13433 G__search_typename2("UInt_t",104,-1,0,-1);
13434 G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
13435 G__search_typename2("Float_t",102,-1,0,-1);
13436 G__setnewtype(-1,"Float 4 bytes (float)",0);
13437 G__search_typename2("Double_t",100,-1,0,-1);
13438 G__setnewtype(-1,"Double 8 bytes",0);
13439 G__search_typename2("Bool_t",103,-1,0,-1);
13440 G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
13441 G__search_typename2("Version_t",115,-1,0,-1);
13442 G__setnewtype(-1,"Class version identifier (short)",0);
13443 G__search_typename2("Style_t",115,-1,0,-1);
13444 G__setnewtype(-1,"Style number (short)",0);
13445 G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
13446 G__setnewtype(-1,NULL,0);
13447 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
13448 G__setnewtype(-1,NULL,0);
13449 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
13450 G__setnewtype(-1,NULL,0);
13451 G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
13452 G__setnewtype(-1,NULL,0);
13453 G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
13454 G__setnewtype(-1,NULL,0);
13455 G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
13456 G__setnewtype(-1,NULL,0);
13457 G__search_typename2("Pixel_t",107,-1,0,-1);
13458 G__setnewtype(-1,"Pixel value",0);
13459 G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13460 G__setnewtype(-1,NULL,0);
13461 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13462 G__setnewtype(-1,NULL,0);
13463 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13464 G__setnewtype(-1,NULL,0);
13465 G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
13466 G__setnewtype(-1,NULL,0);
13467 }
13468
13469
13470
13471
13472
13473
13474
13475
13476 static void G__setup_memvarTGedEditor(void) {
13477 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor));
13478 { TGedEditor *p; p=(TGedEditor*)0x1000; if (p) { }
13479 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TMap),-1,-1,2,"fFrameMap=",0,"global map of available frames");
13480 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TMap),-1,-1,2,"fExclMap=",0,"map of excluded editors for selected model");
13481 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,2,"fGedFrames=",0,"list visible of frames ");
13482 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCanvas),-1,-1,2,"fCan=",0,"provides scroll bars");
13483 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTab),-1,-1,2,"fTab=",0,"tab widget holding the editor");
13484 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,2,"fCreatedTabs=",0,"list of created tabs");
13485 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,2,"fVisibleTabs=",0,"list ofcurrently used tabs");
13486 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fTabContainer=",0,"main tab container");
13487 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TObject),-1,-1,2,"fModel=",0,"selected object");
13488 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,2,"fPad=",0,"selected pad");
13489 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TCanvas),-1,-1,2,"fCanvas=",0,"canvas related to the editor");
13490 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-1,2,"fClass=",0,"class of the selected object");
13491 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fGlobal=",0,"true if editor is global");
13492 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedEditor),-1,-2,2,"fgFrameCreator=",0,(char*)NULL);
13493 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13494 }
13495 G__tag_memvar_reset();
13496 }
13497
13498
13499
13500 static void G__setup_memvarTGedFrame(void) {
13501 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame));
13502 { TGedFrame *p; p=(TGedFrame*)0x1000; if (p) { }
13503 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fInit=",0,"init flag for setting signals/slots");
13504 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedEditor),-1,-1,2,"fGedEditor=",0,"manager of this frame");
13505 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-1,2,"fModelClass=",0,"class corresponding to instantiated GedFrame");
13506 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAvoidSignal=",0,"flag for executing slots");
13507 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,2,"fExtraTabs=",0,"addtional tabs in ged editor");
13508 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPriority=",0,"location in GedEditor");
13509 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13510 }
13511 G__tag_memvar_reset();
13512 }
13513
13514
13515
13516 static void G__setup_memvarTGedNameFrame(void) {
13517 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame));
13518 { TGedNameFrame *p; p=(TGedNameFrame*)0x1000; if (p) { }
13519 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,2,"fLabel=",0,"label of attribute frame");
13520 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f1=",0,(char*)NULL);
13521 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f2=",0,"container frames");
13522 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGToolTip),-1,-1,2,"fTip=",0,"tool tip associated with button");
13523 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13524 }
13525 G__tag_memvar_reset();
13526 }
13527
13528
13529
13530 static void G__setup_memvarTArrowEditor(void) {
13531 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor));
13532 { TArrowEditor *p; p=(TArrowEditor*)0x1000; if (p) { }
13533 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TArrow),-1,-1,2,"fArrow=",0,"arrow object");
13534 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fOptionCombo=",0,"arrow shapes combo box");
13535 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fAngleEntry=",0,"opening angle entry");
13536 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fSizeEntry=",0,"size entry");
13537 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13538 }
13539 G__tag_memvar_reset();
13540 }
13541
13542
13543
13544 static void G__setup_memvarTGedPatternSelect(void) {
13545 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect));
13546 { TGedPatternSelect *p; p=(TGedPatternSelect*)0x1000; if (p) { }
13547 G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fPattern=",0,(char*)NULL);
13548 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13549 }
13550 G__tag_memvar_reset();
13551 }
13552
13553
13554
13555 static void G__setup_memvarTAttFillEditor(void) {
13556 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor));
13557 { TAttFillEditor *p; p=(TAttFillEditor*)0x1000; if (p) { }
13558 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAttFill),-1,-1,2,"fAttFill=",0,"fill attribute object");
13559 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"fill color widget");
13560 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,2,"fPatternSelect=",0,"fill pattern widget");
13561 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13562 }
13563 G__tag_memvar_reset();
13564 }
13565
13566
13567
13568 static void G__setup_memvarTAttLineEditor(void) {
13569 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor));
13570 { TAttLineEditor *p; p=(TAttLineEditor*)0x1000; if (p) { }
13571 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAttLine),-1,-1,2,"fAttLine=",0,"line attribute object");
13572 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,2,"fStyleCombo=",0,"line style combo box");
13573 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,2,"fWidthCombo=",0,"line width combo box");
13574 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"line color widget");
13575 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13576 }
13577 G__tag_memvar_reset();
13578 }
13579
13580
13581
13582 static void G__setup_memvarTGedMarkerSelect(void) {
13583 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect));
13584 { TGedMarkerSelect *p; p=(TGedMarkerSelect*)0x1000; if (p) { }
13585 G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fMarkerStyle=",0,"marker style");
13586 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,2,"fPicture=",0,"image used for popup window");
13587 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13588 }
13589 G__tag_memvar_reset();
13590 }
13591
13592
13593
13594 static void G__setup_memvarTAttMarkerEditor(void) {
13595 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor));
13596 { TAttMarkerEditor *p; p=(TAttMarkerEditor*)0x1000; if (p) { }
13597 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAttMarker),-1,-1,2,"fAttMarker=",0,"marker attribute object");
13598 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fMarkerSize=",0,"marker size combo box");
13599 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"marker color");
13600 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),-1,-1,2,"fMarkerType=",0,"marker type");
13601 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSizeForText=",0,"true if \"text\" draw option uses marker size");
13602 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13603 }
13604 G__tag_memvar_reset();
13605 }
13606
13607
13608
13609 static void G__setup_memvarTAttTextEditor(void) {
13610 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor));
13611 { TAttTextEditor *p; p=(TAttTextEditor*)0x1000; if (p) { }
13612 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAttText),-1,-1,2,"fAttText=",0,"text attribute object");
13613 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,2,"fTypeCombo=",0,"font style combo box");
13614 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fSizeCombo=",0,"font size combo box");
13615 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fAlignCombo=",0,"font aligh combo box");
13616 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"color selection widget");
13617 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13618 }
13619 G__tag_memvar_reset();
13620 }
13621
13622
13623
13624 static void G__setup_memvarTAxisEditor(void) {
13625 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor));
13626 { TAxisEditor *p; p=(TAxisEditor*)0x1000; if (p) { }
13627 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TAxis),-1,-1,2,"fAxis=",0,"axis object");
13628 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fAxisColor=",0,"color selection widget");
13629 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fLogAxis=",0,"logarithmic check box ");
13630 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fTickLength=",0,"tick length number entry");
13631 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fDiv1=",0,"primary axis division number entry");
13632 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fDiv2=",0,"secondary axis division number entry");
13633 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fDiv3=",0,"tertiary axis division number entry");
13634 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fOptimize=",0,"tick optimization check box");
13635 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fTicksBoth=",0,"check box setting ticks on both axis sides");
13636 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fMoreLog=",0,"more logarithmic labels check box");
13637 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTicksFlag=",0,"positive/negative ticks' flag");
13638 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"axis title input field");
13639 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fTitleColor=",0,"color selection widget");
13640 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,2,"fTitleFont=",0,"title font combo box");
13641 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
13642 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fTitleSize=",0,"title size number entry");
13643 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fTitleOffset=",0,"title offset number entry");
13644 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fCentered=",0,"check button for centered title");
13645 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fRotated=",0,"check button for rotated title");
13646 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fLabelColor=",0,"color selection widget");
13647 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,2,"fLabelFont=",0,"label font combo box");
13648 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLabelPrec=",0,"font precision level");
13649 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fLabelSize=",0,"label size number entry");
13650 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fLabelOffset=",0,"label offset number entry");
13651 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fNoExponent=",0,"check box for No exponent choice");
13652 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fDecimal=",0,"decimal part check box ");
13653 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13654 }
13655 G__tag_memvar_reset();
13656 }
13657
13658
13659
13660 static void G__setup_memvarTCurlyArcEditor(void) {
13661 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor));
13662 { TCurlyArcEditor *p; p=(TCurlyArcEditor*)0x1000; if (p) { }
13663 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TCurlyArc),-1,-1,2,"fCurlyArc=",0,"CurlyArc object");
13664 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fRadiusEntry=",0,"radius entry");
13665 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fPhiminEntry=",0,"Phimin entry");
13666 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fPhimaxEntry=",0,"Phimax entry");
13667 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fCenterXEntry=",0,"center x entry");
13668 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fCenterYEntry=",0,"center y entry");
13669 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13670 }
13671 G__tag_memvar_reset();
13672 }
13673
13674
13675
13676 static void G__setup_memvarTCurlyLineEditor(void) {
13677 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor));
13678 { TCurlyLineEditor *p; p=(TCurlyLineEditor*)0x1000; if (p) { }
13679 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TCurlyLine),-1,-1,2,"fCurlyLine=",0,"CurlyLineobject");
13680 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fStartXEntry=",0,"start x entry");
13681 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fEndXEntry=",0,"end x entry");
13682 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fStartYEntry=",0,"start y entry");
13683 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fEndYEntry=",0,"end y entry");
13684 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fAmplitudeEntry=",0,"ampl entry");
13685 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fWaveLengthEntry=",0,"wavelength entry");
13686 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fIsWavy=",0,"toggle wavy / curly");
13687 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fStartXFrame=",0,(char*)NULL);
13688 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13689 }
13690 G__tag_memvar_reset();
13691 }
13692
13693
13694
13695 static void G__setup_memvarTF1Editor(void) {
13696 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor));
13697 { TF1Editor *p; p=(TF1Editor*)0x1000; if (p) { }
13698 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TF1),-1,-1,2,"fF1=",0,"selected TF1 object");
13699 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"function title");
13700 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNP=",0,"number of function parameters");
13701 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,2,"fParLabel=",0,"label for number of parameters");
13702 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fDrawMode=",0,"immediate function redraw (if selected)");
13703 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fSetPars=",0,"open 'Set Parameters' dialog");
13704 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fNXpoints=",0,"number of points along x-axis");
13705 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGDoubleHSlider),-1,-1,2,"fSliderX=",0,"slider to set x-axis range");
13706 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldMinX=",0,"contains minimum value of x-axis");
13707 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldMaxX=",0,"contains maximum value of x-axis");
13708 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13709 }
13710 G__tag_memvar_reset();
13711 }
13712
13713
13714
13715 static void G__setup_memvarTFrameEditor(void) {
13716 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor));
13717 { TFrameEditor *p; p=(TFrameEditor*)0x1000; if (p) { }
13718 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TFrame),-1,-1,2,"fFrame=",0,(char*)NULL);
13719 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode=",0,"set sinken frame border mode");
13720 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode0=",0,"set no border");
13721 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode1=",0,"set raised frame border mode");
13722 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fBmodelh=",0,"layout hints for border mode buttons");
13723 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,2,"fBsize=",0,"set frame border size");
13724 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13725 }
13726 G__tag_memvar_reset();
13727 }
13728
13729
13730
13731 static void G__setup_memvarTFunctionParametersDialog(void) {
13732 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog));
13733 { TFunctionParametersDialog *p; p=(TFunctionParametersDialog*)0x1000; if (p) { }
13734 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TF1),-1,-1,2,"fFunc=",0,"function passed to this dialog");
13735 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,2,"fFpad=",0,"pad where the function is drawn");
13736 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNP=",0,"number of function parameters");
13737 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmin=",0,"min limits of patameters range");
13738 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPmax=",0,"max limits of patameters range");
13739 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPval=",0,"original patameters' values");
13740 G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPerr=",0,"original patameters' errors");
13741 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRangexmin=",0,"min limits of patameters range");
13742 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRangexmax=",0,"max limits of patameters range");
13743 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRXmin=",0,"original min range");
13744 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRXmax=",0,"original max range");
13745 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContNam=",0,"container of parameter names");
13746 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContVal=",0,"container of parameter values");
13747 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContFix=",0,"container of fix settings");
13748 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContSld=",0,"container of sliders");
13749 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContMin=",0,"container of min range values");
13750 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fContMax=",0,"container of max range values");
13751 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fParNam=",0,"parameter names");
13752 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fParFix=",0,"fix setting check buttons");
13753 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fParVal=",0,"parameter values");
13754 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fParMin=",0,"min range values");
13755 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fParMax=",0,"max range values");
13756 G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__GedLN_TGTripleHSlider),-1,-1,2,"fParSld=",0,"triple sliders");
13757 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fUpdate=",0,"Immediate update check button");
13758 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply button");
13759 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fReset=",0,"Reset button");
13760 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fOK=",0,"Cancel button");
13761 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel button");
13762 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHasChanges=",0,"kTRUE if function was redrawn;");
13763 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fImmediateDraw=",0,"kTRUE if function is updated on run-time");
13764 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13765 }
13766 G__tag_memvar_reset();
13767 }
13768
13769
13770
13771 static void G__setup_memvarTGedPopup(void) {
13772 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup));
13773 { TGedPopup *p; p=(TGedPopup*)0x1000; if (p) { }
13774 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGWindow),-1,-1,2,"fMsgWindow=",0,(char*)NULL);
13775 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13776 }
13777 G__tag_memvar_reset();
13778 }
13779
13780
13781
13782 static void G__setup_memvarTGedPatternFrame(void) {
13783 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame));
13784 { TGedPatternFrame *p; p=(TGedPatternFrame*)0x1000; if (p) { }
13785 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGWindow),-1,-1,2,"fMsgWindow=",0,(char*)NULL);
13786 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fActive=",0,(char*)NULL);
13787 G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fPattern=",0,(char*)NULL);
13788 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGGC),-1,-2,2,"fgGC=",0,(char*)NULL);
13789 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGToolTip),-1,-1,2,"fTip=",0,"tool tip associated with a button");
13790 G__memvar_setup((void*)0,99,0,0,-1,-1,-1,2,"fTipText[5]=",0,(char*)NULL);
13791 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13792 }
13793 G__tag_memvar_reset();
13794 }
13795
13796
13797
13798 static void G__setup_memvarTGedPatternSelector(void) {
13799 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector));
13800 { TGedPatternSelector *p; p=(TGedPatternSelector*)0x1000; if (p) { }
13801 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fActive=",0,(char*)NULL);
13802 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGWindow),-1,-1,2,"fMsgWindow=",0,(char*)NULL);
13803 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame),-1,-1,2,"fCe[27]=",0,(char*)NULL);
13804 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13805 }
13806 G__tag_memvar_reset();
13807 }
13808
13809
13810
13811 static void G__setup_memvarTGedPatternPopup(void) {
13812 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup));
13813 { TGedPatternPopup *p; p=(TGedPatternPopup*)0x1000; if (p) { }
13814 G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fCurrentPattern=",0,(char*)NULL);
13815 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13816 }
13817 G__tag_memvar_reset();
13818 }
13819
13820
13821
13822 static void G__setup_memvarTGedSelect(void) {
13823 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect));
13824 { TGedSelect *p; p=(TGedSelect*)0x1000; if (p) { }
13825 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGGC),-1,-1,2,"fDrawGC=",0,(char*)NULL);
13826 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPopup),-1,-1,2,"fPopup=",0,(char*)NULL);
13827 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13828 }
13829 G__tag_memvar_reset();
13830 }
13831
13832
13833
13834 static void G__setup_memvarTGedMarkerPopup(void) {
13835 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup));
13836 { TGedMarkerPopup *p; p=(TGedMarkerPopup*)0x1000; if (p) { }
13837 G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Style_t"),-1,2,"fCurrentStyle=",0,"currently selected style");
13838 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13839 }
13840 G__tag_memvar_reset();
13841 }
13842
13843
13844
13845 static void G__setup_memvarTGraphEditor(void) {
13846 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor));
13847 { TGraphEditor *p; p=(TGraphEditor*)0x1000; if (p) { }
13848 G__memvar_setup((void*)0,99,0,0,-1,-1,-1,2,"fDrawShape=",0,"Shape of the Graph (simple, smooth, bar)");
13849 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"Contains the title of the graph");
13850 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
13851 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGraph),-1,-1,2,"fGraph=",0,"Graph object");
13852 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,2,"fgr=",0,"Group the Radiobuttons:");
13853 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape=",0,"just draw unconnected points");
13854 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape0=",0,"set smooth graph curve");
13855 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape1=",0,"set simple poly-line between every graph point");
13856 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape2=",0,"set graph draw mode to bar chart");
13857 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fShape3=",0,"set graph draw mode to fill area");
13858 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fShape1lh=",0,"layout-hints for fShape1");
13859 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fMarkerOnOff=",0,"set Marker visible/unvisible");
13860 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,2,"fWidthCombo=",0,"Exclusion zone width ");
13861 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fExSide=",0,"set the exclusion zone side");
13862 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13863 }
13864 G__tag_memvar_reset();
13865 }
13866
13867
13868
13869 static void G__setup_memvarTH1Editor(void) {
13870 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor));
13871 { TH1Editor *p; p=(TH1Editor*)0x1000; if (p) { }
13872 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TH1),-1,-1,2,"fHist=",0,"histogram object");
13873 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fSameOpt=",0,"flag for option \"same\"");
13874 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBin=",0,"Contains the Binning Widgets");
13875 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
13876 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"histogram title input field");
13877 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHButtonGroup),-1,-1,2,"fDimGroup=",0,"Radiobuttongroup to change 2D <-> 3D-Plot");
13878 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fDim=",0,"2D-Plot RadioButton");
13879 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fDim0=",0,"3D-Plot RadioButton");
13880 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fDimlh=",0,"layout hints for 2D-Plot RadioButton");
13881 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fDim0lh=",0,"layout hints for 3D-Plot RadioButton");
13882 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fTypeCombo=",0,"histogram type combo box");
13883 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fCoordsCombo=",0,"Coordinate System combo box");
13884 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fErrorCombo=",0,"Error combo box");
13885 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fHistOnOff=",0,"Draw a simple histogram with default options");
13886 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddMarker=",0,"Draw a Marker on top of each bin");
13887 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddB=",0,"Draw a Bar Chart");
13888 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddBar=",0,"Bar Option");
13889 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAdd=",0,"Activate more Options");
13890 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fMakeHBar=",0,"Draw Horizontal Bar Chart");
13891 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddSimple=",0,"Draw a simple histogram (==HIST draw option)");
13892 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fBarWidth=",0,"Change the Bar Width");
13893 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fBarOffset=",0,"Change the Bar Offset");
13894 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fAddCombo=",0,"Add Lines, Bars, Fill");
13895 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fPercentCombo=",0,"Percentage of the Bar which is drawn in a different color");
13896 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f3=",0,"Contains Histogram Type");
13897 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f6=",0,"Contains the Add-ComboBox (Style)");
13898 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f7=",0,"Contains the Marker OnOff CheckBox");
13899 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f8=",0,"Contains the Bar Chart CheckBox");
13900 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f9=",0,"Contains the Bar Option CheckBox");
13901 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f10=",0,"Contains the Bar Option Title");
13902 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f11=",0,"Contains the Bar Width/Offset NumberEntries");
13903 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f12=",0,"Contains fPercentCombo, fMakeHBar");
13904 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f15=",0,"Contains outer line CheckBox");
13905 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinCont=",0,"Contains the Rebin Widgets for case 1");
13906 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinCont1=",0,"Contains the Rebin Widgets for case 2");
13907 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinSlider=",0,"Slider to set rebinning integer value");
13908 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinSlider1=",0,"Slider to set rebinning integer value for ntuple histogram");
13909 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinNumberEntry=",0,"Label which shows the rebinned bin number");
13910 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinNumberEntry1=",0,"Label which shows the rebinned bin number for ntuple histogram");
13911 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinOffsetSld=",0,"Add an offset to the origin of the histogram");
13912 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fOffsetNumberEntry=",0,"Shows the offset to the origin of the histogram");
13913 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGDoubleHSlider),-1,-1,2,"fSlider=",0,"Slider to set x-axis range");
13914 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldMin=",0,"Contains the minimum value of the x-Axis");
13915 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldMax=",0,"Contains the maximum value of the x-Axis");
13916 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fDelaydraw=",0,"Delayed drawing of the new axis range");
13917 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept the rebinned histogram");
13918 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button to reprobate the rebinned histogram");
13919 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMake=",0,"Veto Variable");
13920 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMakeB=",0,"avoid execution of Bar Slots");
13921 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPx1old=",0,(char*)NULL);
13922 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPy1old=",0,(char*)NULL);
13923 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPx2old=",0,(char*)NULL);
13924 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPy2old=",0,(char*)NULL);
13925 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP1NDCold[3]=",0,(char*)NULL);
13926 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP2NDCold[3]=",0,(char*)NULL);
13927 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP3NDCold[3]=",0,(char*)NULL);
13928 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP4NDCold[3]=",0,(char*)NULL);
13929 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP1old[3]=",0,(char*)NULL);
13930 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP2old[3]=",0,(char*)NULL);
13931 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP3old[3]=",0,(char*)NULL);
13932 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP4old[3]=",0,(char*)NULL);
13933 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP5old[3]=",0,(char*)NULL);
13934 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP6old[3]=",0,(char*)NULL);
13935 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP7old[3]=",0,(char*)NULL);
13936 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP8old[3]=",0,(char*)NULL);
13937 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TH1),-1,-1,4,"fBinHist=",0,"Cloned histogram for rebin");
13938 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOldOffset=",0,"save the old offset of the histogram");
13939 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
13940 }
13941 G__tag_memvar_reset();
13942 }
13943
13944
13945
13946 static void G__setup_memvarTH2Editor(void) {
13947 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor));
13948 { TH2Editor *p; p=(TH2Editor*)0x1000; if (p) { }
13949 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TH2),-1,-1,2,"fHist=",0,"histogram object");
13950 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBin=",0,"Contains the Binning Widgets");
13951 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fFit=",0,"Contains the Fitting Widgets");
13952 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"histogram title input field");
13953 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fTypeCombo=",0,"histogram type combo box");
13954 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fCoordsCombo=",0,"Coordinate System combo box");
13955 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fContCombo=",0,"Contour selecting combo box");
13956 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,2,"fColContLbl=",0,"No. of Contours Label 1");
13957 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,2,"fColContLbl1=",0,"No. of Contours Label 2");
13958 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
13959 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHButtonGroup),-1,-1,2,"fDimGroup=",0,"Radiobuttongroup to change 2D <-> 3D-Plot");
13960 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fDim=",0,"2D-Plot RadioButton");
13961 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fDim0=",0,"3D-Plot RadioButton");
13962 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fDimlh=",0,"layout hints for 2D-Plot RadioButton");
13963 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fDim0lh=",0,"layout hints for 3D-Plot RadioButton");
13964 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f6=",0,"Frame that contains the 2D CheckBox DrawOptions");
13965 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f9=",0,"Frame that contains the 3D CheckBox DrawOptions");
13966 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f12=",0,"Frame that contains the Bar-Title");
13967 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f13=",0,"Frame that contains the Bar Width/Offset NumberEntries");
13968 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"f38=",0,"Frame that contains the Frame Fill widgets");
13969 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddError=",0,"CheckBox connected to error bars");
13970 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddPalette=",0,"CheckBox connected to Z option (2D)");
13971 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddPalette1=",0,"CheckBox connected to Z option (3D)");
13972 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddArr=",0,"CheckBox connected to Arr-Option");
13973 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddBox=",0,"CheckBox connected to Box-Option");
13974 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddScat=",0,"CheckBox connected to Scat-Option");
13975 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddCol=",0,"CheckBox connected to Col-Option");
13976 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddFB=",0,"Draw front box (or not)");
13977 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddBB=",0,"Draw back box (or not)");
13978 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fAddText=",0,"Draw bin contents as text");
13979 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fContLevels=",0,"Set number of contour levels");
13980 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fContLevels1=",0,"Set number of contour levels");
13981 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fBarWidth=",0,"Set bar width of histogram");
13982 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fBarOffset=",0,"Set bar offset of histogram");
13983 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinXCont=",0,"Contains the rebin widgets for case 1");
13984 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinXSlider=",0,"Slider to set rebinning x integer value");
13985 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinXNumberEntry=",0,"Label which shows the rebinned bin number");
13986 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinYSlider=",0,"Slider to set rebinning y integer value");
13987 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinYNumberEntry=",0,"Label which shows the rebinned bin number");
13988 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fApply=",0,"Apply-Button to accept the rebinned histogram");
13989 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,2,"fCancel=",0,"Cancel-Button to reprobate the rebinned histogram");
13990 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinXCont1=",0,"Contains the X Rebin Widgets for case 2");
13991 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinXSlider1=",0,"Slider to set x rebinning integer value");
13992 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinXNumberEntry1=",0,"Label which shows the rebinned x bin number");
13993 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fXOffsetNumberEntry=",0,"Shows the offset to the x origin of the histogram");
13994 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fXBinOffsetSld=",0,"Add an x-offset to the origin of the histogram");
13995 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame),-1,-1,2,"fBinYCont1=",0,"Contains the Y Rebin Widgets for case 2");
13996 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fBinYSlider1=",0,"Slider to set y rebinning integer value");
13997 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fBinYNumberEntry1=",0,"Label which shows the rebinned y bin number");
13998 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fYOffsetNumberEntry=",0,"Shows the offset to the y origin of the histogram");
13999 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHSlider),-1,-1,2,"fYBinOffsetSld=",0,"Add an y-offset to the origin of the histogram");
14000 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGDoubleHSlider),-1,-1,2,"fSliderX=",0,"Slider to set x-axis range");
14001 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldXMin=",0,"Contains the minimum value of the x-Axis");
14002 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldXMax=",0,"Contains the maximum value of the x-Axis");
14003 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGDoubleHSlider),-1,-1,2,"fSliderY=",0,"Slider to set y-axis range");
14004 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldYMin=",0,"Contains the minimum value of the y-Axis");
14005 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntryField),-1,-1,2,"fSldYMax=",0,"Contains the maximum value of the y-Axis");
14006 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fDelaydraw=",0,"Delayed drawing of the new axis range");
14007 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fFrameColor=",0,"Select the Frame Color");
14008 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,2,"fFramePattern=",0,"Select the Frame Pattern Style");
14009 G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__GedLN_TString),-1,-1,2,"fCutString=",0,"Contais info about graphical cuts (if any)");
14010 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPx1old=",0,(char*)NULL);
14011 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPy1old=",0,(char*)NULL);
14012 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPx2old=",0,(char*)NULL);
14013 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPy2old=",0,(char*)NULL);
14014 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP1oldx[3]=",0,(char*)NULL);
14015 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP2oldx[3]=",0,(char*)NULL);
14016 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP3oldx[3]=",0,(char*)NULL);
14017 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP4oldx[3]=",0,(char*)NULL);
14018 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP5oldx[3]=",0,(char*)NULL);
14019 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP6oldx[3]=",0,(char*)NULL);
14020 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP7oldx[3]=",0,(char*)NULL);
14021 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP8oldx[3]=",0,(char*)NULL);
14022 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP1oldy[3]=",0,(char*)NULL);
14023 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP2oldy[3]=",0,(char*)NULL);
14024 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP3oldy[3]=",0,(char*)NULL);
14025 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP4oldy[3]=",0,(char*)NULL);
14026 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP5oldy[3]=",0,(char*)NULL);
14027 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP6oldy[3]=",0,(char*)NULL);
14028 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP7oldy[3]=",0,(char*)NULL);
14029 G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fP8oldy[3]=",0,(char*)NULL);
14030 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TH2),-1,-1,4,"fBinHist=",0,"Cloned histogram for rebin");
14031 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOldXOffset=",0,"saves the old x offset of the histogram");
14032 G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOldYOffset=",0,"saves the old y offset of the histogram");
14033 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14034 }
14035 G__tag_memvar_reset();
14036 }
14037
14038
14039
14040 static void G__setup_memvarTLineEditor(void) {
14041 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor));
14042 { TLineEditor *p; p=(TLineEditor*)0x1000; if (p) { }
14043 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TLine),-1,-1,2,"fLine=",0,"line object");
14044 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fStartPointX=",0,"start point x coordinate");
14045 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fStartPointY=",0,"start point y coordinate");
14046 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fEndPointX=",0,"end point x coordinate");
14047 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fEndPointY=",0,"end point y coordinate");
14048 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fVertical=",0,"set the line vertical");
14049 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fHorizontal=",0,"set the line horizontal");
14050 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14051 }
14052 G__tag_memvar_reset();
14053 }
14054
14055
14056
14057 static void G__setup_memvarTPadEditor(void) {
14058 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor));
14059 { TPadEditor *p; p=(TPadEditor*)0x1000; if (p) { }
14060 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TPad),-1,-1,2,"fPadPointer=",0,"TPad object");
14061 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fEditable=",0,"set pad editable");
14062 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fCrosshair=",0,"set crosshair ");
14063 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fFixedAR=",0,"set fixed aspect ratio");
14064 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fGridX=",0,"set grid on X");
14065 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fGridY=",0,"set grid on Y");
14066 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fLogX=",0,"set log scale on X");
14067 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fLogY=",0,"set log scale on Y");
14068 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fLogZ=",0,"set log scale on Z");
14069 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fTickX=",0,"set ticks on X");
14070 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fTickY=",0,"set ticks on Y");
14071 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode=",0,"set sinken pad border mode");
14072 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode0=",0,"set no pad border");
14073 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fBmode1=",0,"set raised pad border mode");
14074 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fBmodelh=",0,"layout hints for border mode buttons");
14075 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,2,"fBsize=",0,"set pad border size");
14076 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,2,"fBgroup=",0,"button group of border mode");
14077 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14078 }
14079 G__tag_memvar_reset();
14080 }
14081
14082
14083
14084 static void G__setup_memvarTPaveStatsEditor(void) {
14085 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor));
14086 { TPaveStatsEditor *p; p=(TPaveStatsEditor*)0x1000; if (p) { }
14087 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TPaveStats),-1,-1,2,"fPaveStats=",0,"TPaveStats object");
14088 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fHistoName=",0,"histo name check box");
14089 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fEntries=",0,"entries' number check box");
14090 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fMean=",0,"mean value check box");
14091 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fRMS=",0,"RMS check box");
14092 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fUnderflow=",0,"underflow number check box");
14093 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fOverflow=",0,"overflow number check box");
14094 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fIntegral=",0,"integral of bins check box");
14095 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fSkewness=",0,"skewness check box");
14096 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fKurtosis=",0,"kurtosis check box");
14097 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fStatsErrors=",0,"statistics error check box");
14098 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fNameValues=",0,"parameters' name/values check box");
14099 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fErrors=",0,"error check box");
14100 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fChisquare=",0,"Chisquare check box");
14101 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fProbability=",0,"probability check box");
14102 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14103 }
14104 G__tag_memvar_reset();
14105 }
14106
14107
14108
14109 static void G__setup_memvarTPieEditor(void) {
14110 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor));
14111 { TPieEditor *p; p=(TPieEditor*)0x1000; if (p) { }
14112 G__memvar_setup((void*)0,99,0,0,-1,-1,-1,2,"fDrawShape=",0,"Shape of the Graph (simple, smooth, bar)");
14113 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"Contains the title of the graph");
14114 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fTitlePrec=",0,"font precision level");
14115 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TPie),-1,-1,2,"fPie=",0,"Pie object");
14116 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,2,"fgr=",0,"Group the Radiobuttons:");
14117 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fLblDirH=",0,"Draw slice's labels horizontal");
14118 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fLblDirR=",0,"Draw slice's labels radial to the piechart");
14119 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,2,"fLblDirT=",0,"Draw slice's labels tangential to the piechart's circle");
14120 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,2,"fShape1lh=",0,"layout-hints for fShape1");
14121 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fOutlineOnOff=",0,"set piechart outline visible/unvisible");
14122 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,2,"fIs3D=",0,"set if is enabled the pseudo-3d mode");
14123 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"f3DHeight=",0,"set the 3D tickness");
14124 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"f3DAngle=",0,"set the pseudo 3D angle");
14125 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,2,"fColorSelect=",0,"font color selector");
14126 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,2,"fTypeCombo=",0,"font style");
14127 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,2,"fSizeCombo=",0,"font size");
14128 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14129 }
14130 G__tag_memvar_reset();
14131 }
14132
14133
14134
14135 static void G__setup_memvarTPieSliceEditor(void) {
14136 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor));
14137 { TPieSliceEditor *p; p=(TPieSliceEditor*)0x1000; if (p) { }
14138 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TPieSlice),-1,-1,4,"fPieSlice=",0,(char*)NULL);
14139 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,2,"fTitle=",0,"Slice label");
14140 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fValue=",0,"Value of the slice");
14141 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,2,"fOffset=",0,"Grafical offset in the radial direction");
14142 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14143 }
14144 G__tag_memvar_reset();
14145 }
14146
14147
14148
14149 static void G__setup_memvarTStyleManager(void) {
14150 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager));
14151 { TStyleManager *p; p=(TStyleManager*)0x1000; if (p) { }
14152 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStyleManager),-1,-2,4,"fgStyleManager=",0,"singleton style manager");
14153 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStyle),-1,-1,4,"fCurSelStyle=",0,"current selected style");
14154 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLastChoice=",0,"=kTRUE if the user choose OK in the last TStyleDialog");
14155 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRealTimePreview=",0,"=kTRUE if auto refreshed preview");
14156 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurTabNum=",0,"current opened tab number");
14157 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurTabAxisNum=",0,"current opened axis tab number");
14158 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSMWidth=",0,"style manager's width");
14159 G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSMHeight=",0,"style manager's height");
14160 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStyleChanged=",0,"=kTRUE if the style has been modified");
14161 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMoreAndNotLess=",0,"=kTRUE when editor is open");
14162 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSigSlotConnected=",0,"=kTRUE when signal/slots connected");
14163 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAllAndNotCurrent=",0,"=kTRUE when apply on 'All canvases'");
14164 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListFrame=",0,"to avoid memory leak");
14165 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListLayout=",0,"to avoid memory leak");
14166 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGMenuBar),-1,-1,4,"fMenuBar=",0,"the main window menu bar");
14167 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPopupMenu),-1,-1,4,"fMenuStyle=",0,"the 'Style' popup menu");
14168 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPopupMenu),-1,-1,4,"fImportCascade=",0,"Cascaded menu 'Import'");
14169 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPopupMenu),-1,-1,4,"fMenuHelp=",0,"the 'Help' popup menu");
14170 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGToolBar),-1,-1,4,"fToolBar=",0,"the tool bar");
14171 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarNew=",0,"tool bar 'New' button");
14172 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarDelete=",0,"tool bar 'Delete' button");
14173 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarImportCanvas=",0,"tool bar 'Import from canvas' button");
14174 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarImportMacro=",0,"tool bar 'Import from macro' button");
14175 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarExport=",0,"tool bar 'Export' button");
14176 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fToolBarHelp=",0,"tool bar 'Help' button");
14177 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarNewPic=",0,"tool bar 'New' picture");
14178 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarDeletePic=",0,"tool bar 'Delete' picture");
14179 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarImportCanvasPic=",0,"tool bar 'Import from canvas' picture");
14180 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarImportMacroPic=",0,"tool bar 'Import from macro' picture");
14181 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarExportPic=",0,"tool bar 'Export' picture");
14182 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fToolBarHelpPic=",0,"tool bar 'Help' picture");
14183 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHorizontal3DLine),-1,-1,4,"fHorizontal3DLine=",0,"a line under the tool bar");
14184 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fListLabel=",0,"label 'Available Styles:'");
14185 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fListComboBox=",0,"list of available styles");
14186 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFileInfo),-1,-1,4,"fCurMacro=",0,"current macro");
14187 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fCurStylabel=",0,"label 'gStyle is set to:'");
14188 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fCurStyle=",0,"label showing gStyle's name");
14189 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fCurPadLabel=",0,"label 'Canvas:'");
14190 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fCurPadTextEntry=",0,"label showing current pad's name");
14191 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,4,"fCurPad=",0,"current pad");
14192 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fCurObjLabel=",0,"label 'Object:'");
14193 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fCurObjTextEntry=",0,"label showing current object's name");
14194 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TObject),-1,-1,4,"fCurObj=",0,"current object");
14195 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPreviewButton=",0,"if checked, preview is visible");
14196 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPreviewRealTime=",0,"if checked, real time preview");
14197 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStylePreview),-1,-1,4,"fPreviewWindow=",0,"preview");
14198 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGPictureButton),-1,-1,4,"fMakeDefault=",0,"selected style becom gStyle");
14199 G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__GedLN_TGPicture),-1,-1,4,"fMakeDefaultPic=",0,"button picture");
14200 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHButtonGroup),-1,-1,4,"fApplyOnGroup=",0,"'Apply on' button group");
14201 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,4,"fApplyOnAll=",0,"'Apply on' button group");
14202 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,4,"fApplyOnSel=",0,"'Apply on' button group");
14203 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fApplyOnButton=",0,"apply style on object(s)");
14204 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fMoreLess=",0,"open/close the editor");
14205 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGStatusBar),-1,-1,4,"fStatusBar=",0,"status bar");
14206 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGVerticalFrame),-1,-1,4,"fEditionFrame=",0,"editor");
14207 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTab),-1,-1,4,"fEditionTab=",0,"editor's tabs");
14208 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTab),-1,-1,4,"fHistosTab=",0,"histos' tabs");
14209 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTab),-1,-1,4,"fAxisTab=",0,"axis' tabs");
14210 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGHorizontalFrame),-1,-1,4,"fEditionButtonFrame=",0,"editor's buttons");
14211 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fEditionHelp=",0,"help button");
14212 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fEditionUpdatePreview=",0,"update preview button");
14213 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fEditionReset=",0,"reset button");
14214 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fFillColor=",0,"general fill color selection widget");
14215 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fFillStyle=",0,"general fill pattern selection widget");
14216 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fHatchesLineWidth=",0,"general hatches width combo box");
14217 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fHatchesSpacing=",0,"general hatches spacing number entry");
14218 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fTextColor=",0,"general text color selection widget");
14219 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTextSize=",0,"general text size number entry");
14220 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fTextSizeInPixels=",0,"general text size check box");
14221 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fTextFont=",0,"general text font combo box");
14222 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fTextAlign=",0,"general text align combo box");
14223 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTextAngle=",0,"general text angle number entry");
14224 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fLineColor=",0,"general line color selection widget");
14225 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fLineWidth=",0,"general line width combo box");
14226 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fLineStyle=",0,"general line style combo box");
14227 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fLineStyleEdit=",0,"general line style editor open button");
14228 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fMarkerColor=",0,"general marker color selection widget");
14229 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect),-1,-1,4,"fMarkerStyle=",0,"general marker style entry");
14230 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fMarkerSize=",0,"general marker size combo box");
14231 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fScreenFactor=",0,"general screen factor number entry");
14232 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fCanvasColor=",0,"canvas fill color selection widget");
14233 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fCanvasDefX=",0,"canvas abscissa number entry");
14234 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fCanvasDefY=",0,"canvas ordinate number entry");
14235 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fCanvasDefW=",0,"canvas width number entry");
14236 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fCanvasDefH=",0,"canvas height number entry");
14237 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,4,"fCanvasBorderMode=",0,"canvas border mode button group");
14238 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fCanvasBorderSize=",0,"canvas border size combo box");
14239 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptDateBool=",0,"canvas date show/hide check box");
14240 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fAttDateTextColor=",0,"canvas date color selection widget");
14241 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fAttDateTextSize=",0,"canvas date size number entry");
14242 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fAttDateTextSizeInPixels=",0,"canvas date size check box");
14243 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fOptDateFormat=",0,"canvas date format text entry");
14244 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fAttDateTextFont=",0,"canvas date font combo box");
14245 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fAttDateTextAngle=",0,"canvas date angle number entry");
14246 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fAttDateTextAlign=",0,"canvas date align combo box");
14247 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fDateX=",0,"canvas date abscissa number entry");
14248 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fDateY=",0,"canvas date ordinate number entry");
14249 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPadLeftMargin=",0,"pad left margin number entry");
14250 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPadRightMargin=",0,"pad right margin number entry");
14251 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPadTopMargin=",0,"pad top margin number entry");
14252 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPadBottomMargin=",0,"pad bottom margin number entry");
14253 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,4,"fPadBorderMode=",0,"pad border mode button group");
14254 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fPadBorderSize=",0,"pad border size combo box");
14255 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fPadColor=",0,"pad fill color selection widget");
14256 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPadTickX=",0,"pad ticks along X show/hide check box");
14257 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPadTickY=",0,"pad ticks along Y show/hide check box");
14258 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPadGridX=",0,"pad grid along X show/hide check box");
14259 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fPadGridY=",0,"pad grid along Y show/hide check box");
14260 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fGridColor=",0,"pad grid line color selection widget");
14261 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fGridWidth=",0,"pad grid line width combo box");
14262 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fGridStyle=",0,"pad grid line style combo box");
14263 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fHistFillColor=",0,"histograms fill color selection widget");
14264 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fHistFillStyle=",0,"histograms fill pattern selection widget");
14265 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fHistLineColor=",0,"histograms fill color selection widget");
14266 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fHistLineWidth=",0,"histograms line width combo box");
14267 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fHistLineStyle=",0,"histograms line style combo box");
14268 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fBarWidth=",0,"histograms bar width number entry");
14269 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fBarOffset=",0,"histograms bar offset number entry");
14270 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fHistMinimumZero=",0,"histograms minimum zero check box");
14271 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fPaintTextFormat=",0,"histograms format text entry");
14272 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fNumberContours=",0,"histograms number of contours number entry");
14273 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fLegoInnerR=",0,"histograms lego inner radius number entry");
14274 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fFrameFillColor=",0,"frame fill color selection widget");
14275 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fFrameFillStyle=",0,"frame fill pattern selection widget");
14276 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fFrameLineColor=",0,"frame line color selection widget");
14277 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fFrameLineWidth=",0,"frame line width combo box");
14278 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fFrameLineStyle=",0,"frame line style combo box");
14279 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fPaletteEdit=",0,"palette editor open button");
14280 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,4,"fFrameBorderMode=",0,"frame border mode button group");
14281 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fFrameBorderSize=",0,"frame border size combo box");
14282 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fFuncColor=",0,"function color selection widget");
14283 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fFuncWidth=",0,"function width number entry");
14284 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox),-1,-1,4,"fFuncStyle=",0,"function line style combo box");
14285 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fDrawBorder=",0,"function border show/hide check box");
14286 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fEndErrorSize=",0,"end error size number entry");
14287 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fErrorX=",0,"error along abscissa number entry");
14288 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTimeOffsetDate=",0,"axis time offset (mm/dd/yyyy) number entry");
14289 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTimeOffsetTime=",0,"axis time offset (hh:mm:ss) number entry");
14290 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fStripDecimals=",0,"axis label's decimal part show/hide check box");
14291 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fApplyOnXYZ=",0,"axis apply on XYZ text button");
14292 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXTitleSize=",0,"X axis title size number entry");
14293 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fXTitleSizeInPixels=",0,"X axis title size check box");
14294 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fXTitleColor=",0,"X axis title color selection widget");
14295 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXTitleOffset=",0,"X axis title offset number entry");
14296 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fXTitleFont=",0,"X axis title font combo box");
14297 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXLabelSize=",0,"X axis label size number entry");
14298 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fXLabelSizeInPixels=",0,"X axis label size check box");
14299 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fXLabelColor=",0,"X axis label color selection widget");
14300 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXLabelOffset=",0,"X axis label offset number entry");
14301 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fXLabelFont=",0,"X axis label font combo box");
14302 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fXAxisColor=",0,"X axis color selection widget");
14303 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXTickLength=",0,"X axis tick length number entry");
14304 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptLogx=",0,"X axis logarithmic scale check box");
14305 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXNdivMain=",0,"X axis primary division number entry");
14306 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXNdivSub=",0,"X axis secondary division number entry");
14307 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fXNdivSubSub=",0,"X axis tertiary division number entry");
14308 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fXNdivisionsOptimize=",0,"X axis division optimization check box");
14309 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYTitleSize=",0,"Y axis title size number entry");
14310 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fYTitleSizeInPixels=",0,"Y axis title size check box");
14311 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fYTitleColor=",0,"Y axis title color selection widget");
14312 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYTitleOffset=",0,"Y axis title offset number entry");
14313 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fYTitleFont=",0,"Y axis title font combo box");
14314 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYLabelSize=",0,"Y axis label size number entry");
14315 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fYLabelSizeInPixels=",0,"Y axis label size check box");
14316 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fYLabelColor=",0,"Y axis label color selection widget");
14317 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYLabelOffset=",0,"Y axis label offset number entry");
14318 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fYLabelFont=",0,"Y axis label font combo box");
14319 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fYAxisColor=",0,"Y axis color selection widget");
14320 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYTickLength=",0,"Y axis tick length number entry");
14321 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptLogy=",0,"Y axis logarithmic scale check box");
14322 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYNdivMain=",0,"Y axis primary division number entry");
14323 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYNdivSub=",0,"Y axis secondary division number entry");
14324 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fYNdivSubSub=",0,"Y axis tertiary division number entry");
14325 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fYNdivisionsOptimize=",0,"Y axis division optimization check box");
14326 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZTitleSize=",0,"Z axis title size number entry");
14327 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fZTitleSizeInPixels=",0,"Z axis title size check box");
14328 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fZTitleColor=",0,"Z axis title color selection widget");
14329 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZTitleOffset=",0,"Z axis title offset number entry");
14330 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fZTitleFont=",0,"Z axis title font combo box");
14331 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZLabelSize=",0,"Z axis label size number entry");
14332 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fZLabelSizeInPixels=",0,"Z axis label size check box");
14333 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fZLabelColor=",0,"Z axis label color selection widget");
14334 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZLabelOffset=",0,"Z axis label offset number entry");
14335 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fZLabelFont=",0,"Z axis label font combo box");
14336 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fZAxisColor=",0,"Z axis color selection widget");
14337 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZTickLength=",0,"Z axis tick length number entry");
14338 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptLogz=",0,"Z axis logarithmic scale check box");
14339 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZNdivMain=",0,"Z axis primary division number entry");
14340 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZNdivSub=",0,"Z axis secondary division number entry");
14341 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fZNdivSubSub=",0,"Z axis tertiary division number entry");
14342 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fZNdivisionsOptimize=",0,"Z axis division optimization check box");
14343 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptTitle=",0,"title show/hide check box");
14344 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fTitleColor=",0,"title fill color selection widget");
14345 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fTitleStyle=",0,"title fill pattern selection widget");
14346 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fTitleTextColor=",0,"title text color selection widget");
14347 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleFontSize=",0,"title font size number entry");
14348 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fTitleFontSizeInPixels=",0,"title font size check box");
14349 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fTitleFont=",0,"title font combo box");
14350 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fTitleAlign=",0,"title align combo box");
14351 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fTitleBorderSizeLabel=",0,"label 'Title's'");
14352 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fTitleBorderSize=",0,"title border size combo box");
14353 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleX=",0,"title abscissa number entry");
14354 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleY=",0,"title ordinate number entry");
14355 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleW=",0,"title width number entry");
14356 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fTitleH=",0,"title height number entry");
14357 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fLegendBorderSizeLabel=",0,"label 'Legend's'");
14358 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fLegendBorderSize=",0,"legend border size combo box");
14359 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fStatColor=",0,"stats fill color selection widget");
14360 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect),-1,-1,4,"fStatStyle=",0,"stats fill pattern selection widget");
14361 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGColorSelect),-1,-1,4,"fStatTextColor=",0,"stats text color selection widget");
14362 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatFontSize=",0,"stats font size number entry");
14363 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fStatFontSizeInPixels=",0,"stats font size check box");
14364 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox),-1,-1,4,"fStatFont=",0,"stats font type combo box");
14365 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatX=",0,"stats abscissa number entry");
14366 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatY=",0,"stats ordinate number entry");
14367 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatW=",0,"stats width number entry");
14368 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fStatH=",0,"stats height number entry");
14369 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fStatBorderSizeLabel=",0,"label 'stats' shadow");
14370 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox),-1,-1,4,"fStatBorderSize=",0,"stats border size combo box");
14371 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatName=",0,"stats name show/hide check box");
14372 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatEntries=",0,"stats entries show/hide check box");
14373 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatOverflow=",0,"stats overflow show/hide check box");
14374 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatMean=",0,"stats mean show/hide check box");
14375 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatUnderflow=",0,"stats underflow show/hide check box");
14376 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatRMS=",0,"stats RMS show/hide check box");
14377 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatSkewness=",0,"stats Skewness show/hide check box");
14378 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatIntegral=",0,"stats integral show/hide check box");
14379 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatKurtosis=",0,"stats kurtosis show/hide check box");
14380 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptStatErrors=",0,"stats errors check box");
14381 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fStatFormatLabel=",0,"label 'stats format'");
14382 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fStatFormat=",0,"stats format text entry");
14383 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptFitValues=",0,"fit values show/hide check box");
14384 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptFitErrors=",0,"fit errors check box");
14385 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptFitProbability=",0,"fit probability show/hide check box");
14386 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGCheckButton),-1,-1,4,"fOptFitChi=",0,"fit Chi show/hide check box");
14387 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fFitFormatLabel=",0,"label 'fit format'");
14388 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fFitFormat=",0,"fit format text entry");
14389 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fHeaderPS=",0,"ps/pdf header text entry");
14390 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fTitlePS=",0,"ps/pdf title text entry");
14391 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup),-1,-1,4,"fColorModelPS=",0,"ps/pdf color model button group");
14392 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,4,"fColorModelPSRGB=",0,"RGB radio button");
14393 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGRadioButton),-1,-1,4,"fColorModelPSCMYK=",0,"CMYB radio button");
14394 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fLineScalePS=",0,"ps/pdf line scale number entry");
14395 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGComboBox),-1,-1,4,"fPaperSizePredef=",0,"ps/pdf paper size combo box");
14396 G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPaperSizeEnCm=",0,"=kTRUE if the paper size is in cm");
14397 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPaperSizeX=",0,"ps/pdf paper size width number entry");
14398 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry),-1,-1,4,"fPaperSizeY=",0,"ps/pdf paper size height number entry");
14399 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandX=",0,"often used layout");
14400 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandXMargin=",0,"often used layout");
14401 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandXY=",0,"often used layout");
14402 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandXYMargin=",0,"often used layout");
14403 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLayoutHints),-1,-1,4,"fLayoutExpandXCenterYMargin=",0,"often used layout");
14404 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14405 }
14406 G__tag_memvar_reset();
14407 }
14408
14409
14410
14411 static void G__setup_memvarTStyleDialog(void) {
14412 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog));
14413 { TStyleDialog *p; p=(TStyleDialog*)0x1000; if (p) { }
14414 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStyleManager),-1,-1,4,"fStyleManager=",0,"parent style manager");
14415 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fName=",0,"TStyle name text entry");
14416 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fNameLabel=",0,"name label");
14417 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextEntry),-1,-1,4,"fTitle=",0,"TStyle title text entry");
14418 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fTitleLabel=",0,"title label");
14419 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGLabel),-1,-1,4,"fWarnLabel=",0,"label for warnings");
14420 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fOK=",0,"save button");
14421 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TGTextButton),-1,-1,4,"fCancel=",0,"cancel button");
14422 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TStyle),-1,-1,4,"fCurStyle=",0,"style to copy or to rename");
14423 G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMode=",0,"1=new, 2=rename, 3=import");
14424 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,4,"fCurPad=",0,"current pad from which to import");
14425 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListFrame=",0,"to avoid memory leak");
14426 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListLayout=",0,"to avoid memory leak");
14427 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14428 }
14429 G__tag_memvar_reset();
14430 }
14431
14432
14433
14434 static void G__setup_memvarTStylePreview(void) {
14435 G__tag_memvar_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview));
14436 { TStylePreview *p; p=(TStylePreview*)0x1000; if (p) { }
14437 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TRootEmbeddedCanvas),-1,-1,4,"fEcan=",0,"canvas for preview");
14438 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TVirtualPad),-1,-1,4,"fPad=",0,"original pad previewed");
14439 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TList),-1,-1,4,"fTrashListLayout=",0,"to avoid memory leak");
14440 G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__GedLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
14441 }
14442 G__tag_memvar_reset();
14443 }
14444
14445 extern "C" void G__cpp_setup_memvarG__Ged() {
14446 }
14447
14448
14449
14450
14451
14452
14453
14454
14455
14456
14457
14458
14459 static void G__setup_memfuncTGedEditor(void) {
14460
14461 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedEditor));
14462 G__memfunc_setup("TGedEditor",971,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 0, 1, 1, 4, 0, "u 'TGedEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
14463 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 1, 1, 1, 4, 0, "u 'TGedEditor' - 11 - -", "Not implemented", (void*) NULL, 0);
14464 G__memfunc_setup("ConfigureGedFrames",1808,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - objChaged", (char*)NULL, (void*) NULL, 0);
14465 G__memfunc_setup("CreateNameFrame",1472,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGedFrame), -1, 0, 2, 1, 2, 0,
14466 "U 'TGWindow' - 10 - parent C - - 10 - tab_name", (char*)NULL, (void*) NULL, 1);
14467 G__memfunc_setup("TGedEditor",971,G__G__Ged_225_0_5, 105, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 0, 3, 1, 1, 0,
14468 "U 'TCanvas' - 0 '0' canvas h - 'UInt_t' 0 '175' width "
14469 "h - 'UInt_t' 0 '20' height", (char*)NULL, (void*) NULL, 0);
14470 G__memfunc_setup("PrintFrameStat",1428,G__G__Ged_225_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14471 G__memfunc_setup("Update",611,G__G__Ged_225_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedFrame' - 0 '0' frame", (char*)NULL, (void*) NULL, 1);
14472 G__memfunc_setup("ReinitWorkspace",1562,G__G__Ged_225_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14473 G__memfunc_setup("ActivateEditor",1432,G__G__Ged_225_0_9, 121, -1, -1, 0, 2, 1, 1, 0,
14474 "U 'TClass' - 0 - cl g - 'Bool_t' 0 - recurse", (char*)NULL, (void*) NULL, 0);
14475 G__memfunc_setup("ActivateEditors",1547,G__G__Ged_225_0_10, 121, -1, -1, 0, 2, 1, 1, 0,
14476 "U 'TList' - 0 - bcl g - 'Bool_t' 0 - recurse", (char*)NULL, (void*) NULL, 0);
14477 G__memfunc_setup("ExcludeClassEditor",1831,G__G__Ged_225_0_11, 121, -1, -1, 0, 2, 1, 1, 0,
14478 "U 'TClass' - 0 - cl g - 'Bool_t' 0 'kFALSE' recurse", (char*)NULL, (void*) NULL, 0);
14479 G__memfunc_setup("InsertGedFrame",1392,G__G__Ged_225_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
14480 G__memfunc_setup("GetTGCanvas",1047,G__G__Ged_225_0_13, 85, G__get_linked_tagnum(&G__G__GedLN_TGCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14481 G__memfunc_setup("GetTab",567,G__G__Ged_225_0_14, 85, G__get_linked_tagnum(&G__G__GedLN_TGTab), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14482 G__memfunc_setup("GetEditorTab",1182,G__G__Ged_225_0_15, 85, G__get_linked_tagnum(&G__G__GedLN_TGCompositeFrame), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
14483 G__memfunc_setup("GetEditorTabInfo",1578,G__G__Ged_225_0_16, 85, G__get_linked_tagnum(&G__G__GedLN_TGedTabInfo), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
14484 G__memfunc_setup("GetCanvas",892,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TCanvas), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14485 G__memfunc_setup("GetPad",565,G__G__Ged_225_0_18, 85, G__get_linked_tagnum(&G__G__GedLN_TVirtualPad), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14486 G__memfunc_setup("GetModel",785,G__G__Ged_225_0_19, 85, G__get_linked_tagnum(&G__G__GedLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14487 G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14488 G__memfunc_setup("ConnectToCanvas",1513,G__G__Ged_225_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 - c", (char*)NULL, (void*) NULL, 1);
14489 G__memfunc_setup("DisconnectFromCanvas",2042,G__G__Ged_225_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14490 G__memfunc_setup("IsGlobal",781,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14491 G__memfunc_setup("Hide",378,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14492 G__memfunc_setup("GlobalClosed",1195,G__G__Ged_225_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14493 G__memfunc_setup("SetCanvas",904,G__G__Ged_225_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TCanvas' - 0 - c", (char*)NULL, (void*) NULL, 1);
14494 G__memfunc_setup("SetGlobal",893,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - global", (char*)NULL, (void*) NULL, 1);
14495 G__memfunc_setup("GlobalSetModel",1390,G__G__Ged_225_0_28, 121, -1, -1, 0, 3, 1, 1, 0,
14496 "U 'TVirtualPad' - 0 - - U 'TObject' - 0 - - "
14497 "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
14498 G__memfunc_setup("SetModel",797,G__G__Ged_225_0_29, 121, -1, -1, 0, 3, 1, 1, 0,
14499 "U 'TVirtualPad' - 0 - pad U 'TObject' - 0 - obj "
14500 "i - 'Int_t' 0 - event", (char*)NULL, (void*) NULL, 1);
14501 G__memfunc_setup("Show",417,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14502 G__memfunc_setup("RecursiveRemove",1574,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
14503 G__memfunc_setup("GetFrameCreator",1499,G__G__Ged_225_0_32, 85, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TGedEditor* (*)())(&TGedEditor::GetFrameCreator) ), 0);
14504 G__memfunc_setup("SetFrameCreator",1511,G__G__Ged_225_0_33, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TGedEditor' - 0 - e", (char*)NULL, (void*) G__func2void( (void (*)(TGedEditor*))(&TGedEditor::SetFrameCreator) ), 0);
14505 G__memfunc_setup("Class",502,G__G__Ged_225_0_34, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedEditor::Class) ), 0);
14506 G__memfunc_setup("Class_Name",982,G__G__Ged_225_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedEditor::Class_Name) ), 0);
14507 G__memfunc_setup("Class_Version",1339,G__G__Ged_225_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedEditor::Class_Version) ), 0);
14508 G__memfunc_setup("Dictionary",1046,G__G__Ged_225_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedEditor::Dictionary) ), 0);
14509 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14510 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);
14511 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);
14512 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_225_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14513 G__memfunc_setup("DeclFileName",1145,G__G__Ged_225_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedEditor::DeclFileName) ), 0);
14514 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_225_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedEditor::ImplFileLine) ), 0);
14515 G__memfunc_setup("ImplFileName",1171,G__G__Ged_225_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedEditor::ImplFileName) ), 0);
14516 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_225_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedEditor::DeclFileLine) ), 0);
14517
14518 G__memfunc_setup("~TGedEditor", 1097, G__G__Ged_225_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14519 G__tag_memfunc_reset();
14520 }
14521
14522 static void G__setup_memfuncTGedFrame(void) {
14523
14524 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedFrame));
14525 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TGedFrame), -1, 1, 1, 1, 4, 0, "u 'TGedFrame' - 11 - -", "Not implemented", (void*) NULL, 0);
14526 G__memfunc_setup("MakeTitle",896,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - title", (char*)NULL, (void*) NULL, 1);
14527 G__memfunc_setup("Update",611,G__G__Ged_226_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14528 G__memfunc_setup("GetDrawOption",1319,(G__InterfaceMethod) NULL,67, -1, G__defined_typename("Option_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14529 G__memfunc_setup("GetModelClass",1287,G__G__Ged_226_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14530 G__memfunc_setup("GetPriority",1154,G__G__Ged_226_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14531 G__memfunc_setup("GetExtraTabs",1198,G__G__Ged_226_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14532 G__memfunc_setup("GetGedEditor",1175,G__G__Ged_226_0_10, 85, G__get_linked_tagnum(&G__G__GedLN_TGedEditor), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
14533 G__memfunc_setup("AddExtraTab",1060,G__G__Ged_226_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedFrame::TGedSubFrame' - 0 - sf", (char*)NULL, (void*) NULL, 1);
14534 G__memfunc_setup("CreateEditorTabSubFrame",2279,G__G__Ged_226_0_12, 85, G__get_linked_tagnum(&G__G__GedLN_TGVerticalFrame), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
14535 G__memfunc_setup("Refresh",719,G__G__Ged_226_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 1);
14536 G__memfunc_setup("SetDrawOption",1331,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
14537 G__memfunc_setup("AcceptModel",1089,G__G__Ged_226_0_15, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
14538 G__memfunc_setup("SetModelClass",1299,G__G__Ged_226_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - mcl", (char*)NULL, (void*) NULL, 0);
14539 G__memfunc_setup("SetModel",797,G__G__Ged_226_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
14540 G__memfunc_setup("SetGedEditor",1187,G__G__Ged_226_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedEditor' - 0 - ed", (char*)NULL, (void*) NULL, 1);
14541 G__memfunc_setup("ActivateBaseClassEditors",2428,G__G__Ged_226_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - cl", (char*)NULL, (void*) NULL, 1);
14542 G__memfunc_setup("Class",502,G__G__Ged_226_0_20, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedFrame::Class) ), 0);
14543 G__memfunc_setup("Class_Name",982,G__G__Ged_226_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedFrame::Class_Name) ), 0);
14544 G__memfunc_setup("Class_Version",1339,G__G__Ged_226_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedFrame::Class_Version) ), 0);
14545 G__memfunc_setup("Dictionary",1046,G__G__Ged_226_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedFrame::Dictionary) ), 0);
14546 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14547 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);
14548 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);
14549 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_226_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14550 G__memfunc_setup("DeclFileName",1145,G__G__Ged_226_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedFrame::DeclFileName) ), 0);
14551 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_226_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedFrame::ImplFileLine) ), 0);
14552 G__memfunc_setup("ImplFileName",1171,G__G__Ged_226_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedFrame::ImplFileName) ), 0);
14553 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_226_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedFrame::DeclFileLine) ), 0);
14554
14555 G__memfunc_setup("~TGedFrame", 973, G__G__Ged_226_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14556 G__tag_memfunc_reset();
14557 }
14558
14559 static void G__setup_memfuncTGedNameFrame(void) {
14560
14561 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame));
14562 G__memfunc_setup("TGedNameFrame",1232,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame), -1, 0, 1, 1, 4, 0, "u 'TGedNameFrame' - 11 - -", "not implemented", (void*) NULL, 0);
14563 G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame), -1, 1, 1, 1, 4, 0, "u 'TGedNameFrame' - 11 - -", "not implemented", (void*) NULL, 0);
14564 G__memfunc_setup("TGedNameFrame",1232,G__G__Ged_228_0_3, 105, G__get_linked_tagnum(&G__G__GedLN_TGedNameFrame), -1, 0, 5, 1, 1, 0,
14565 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '170' width "
14566 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14567 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14568 G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
14569 G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
14570 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);
14571 G__memfunc_setup("Class",502,G__G__Ged_228_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedNameFrame::Class) ), 0);
14572 G__memfunc_setup("Class_Name",982,G__G__Ged_228_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedNameFrame::Class_Name) ), 0);
14573 G__memfunc_setup("Class_Version",1339,G__G__Ged_228_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedNameFrame::Class_Version) ), 0);
14574 G__memfunc_setup("Dictionary",1046,G__G__Ged_228_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedNameFrame::Dictionary) ), 0);
14575 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14576 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);
14577 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);
14578 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_228_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14579 G__memfunc_setup("DeclFileName",1145,G__G__Ged_228_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedNameFrame::DeclFileName) ), 0);
14580 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_228_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedNameFrame::ImplFileLine) ), 0);
14581 G__memfunc_setup("ImplFileName",1171,G__G__Ged_228_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedNameFrame::ImplFileName) ), 0);
14582 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_228_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedNameFrame::DeclFileLine) ), 0);
14583
14584 G__memfunc_setup("~TGedNameFrame", 1358, G__G__Ged_228_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14585 G__tag_memfunc_reset();
14586 }
14587
14588 static void G__setup_memfuncTArrowEditor(void) {
14589
14590 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TArrowEditor));
14591 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14592 G__memfunc_setup("BuildOptionComboBox",1922,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 2, 0,
14593 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
14594 G__memfunc_setup("GetShapeEntry",1315,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 0);
14595 G__memfunc_setup("TArrowEditor",1222,G__G__Ged_232_0_4, 105, G__get_linked_tagnum(&G__G__GedLN_TArrowEditor), -1, 0, 5, 1, 1, 0,
14596 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14597 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14598 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14599 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);
14600 G__memfunc_setup("DoAngle",666,G__G__Ged_232_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14601 G__memfunc_setup("DoOption",812,G__G__Ged_232_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
14602 G__memfunc_setup("DoSize",590,G__G__Ged_232_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14603 G__memfunc_setup("Class",502,G__G__Ged_232_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TArrowEditor::Class) ), 0);
14604 G__memfunc_setup("Class_Name",982,G__G__Ged_232_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrowEditor::Class_Name) ), 0);
14605 G__memfunc_setup("Class_Version",1339,G__G__Ged_232_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TArrowEditor::Class_Version) ), 0);
14606 G__memfunc_setup("Dictionary",1046,G__G__Ged_232_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TArrowEditor::Dictionary) ), 0);
14607 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14608 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);
14609 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);
14610 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_232_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14611 G__memfunc_setup("DeclFileName",1145,G__G__Ged_232_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrowEditor::DeclFileName) ), 0);
14612 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_232_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrowEditor::ImplFileLine) ), 0);
14613 G__memfunc_setup("ImplFileName",1171,G__G__Ged_232_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TArrowEditor::ImplFileName) ), 0);
14614 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_232_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TArrowEditor::DeclFileLine) ), 0);
14615
14616 G__memfunc_setup("~TArrowEditor", 1348, G__G__Ged_232_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14617 G__tag_memfunc_reset();
14618 }
14619
14620 static void G__setup_memfuncTGedPatternSelect(void) {
14621
14622 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect));
14623 G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14624 G__memfunc_setup("TGedPatternSelect",1698,G__G__Ged_234_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect), -1, 0, 3, 1, 1, 0,
14625 "U 'TGWindow' - 10 - p s - 'Style_t' 0 - pattern "
14626 "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
14627 G__memfunc_setup("SetPattern",1034,G__G__Ged_234_0_3, 121, -1, -1, 0, 2, 1, 1, 0,
14628 "s - 'Style_t' 0 - pattern g - 'Bool_t' 0 'kTRUE' emit", (char*)NULL, (void*) NULL, 0);
14629 G__memfunc_setup("GetPattern",1022,G__G__Ged_234_0_4, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14630 G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__GedLN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14631 G__memfunc_setup("PatternSelected",1543,G__G__Ged_234_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' pattern", "*SIGNAL*", (void*) NULL, 1);
14632 G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
14633 "l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
14634 "l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
14635 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14636 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
14637 G__memfunc_setup("Class",502,G__G__Ged_234_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPatternSelect::Class) ), 0);
14638 G__memfunc_setup("Class_Name",982,G__G__Ged_234_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelect::Class_Name) ), 0);
14639 G__memfunc_setup("Class_Version",1339,G__G__Ged_234_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPatternSelect::Class_Version) ), 0);
14640 G__memfunc_setup("Dictionary",1046,G__G__Ged_234_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPatternSelect::Dictionary) ), 0);
14641 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14642 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);
14643 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);
14644 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_234_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14645 G__memfunc_setup("DeclFileName",1145,G__G__Ged_234_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelect::DeclFileName) ), 0);
14646 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_234_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternSelect::ImplFileLine) ), 0);
14647 G__memfunc_setup("ImplFileName",1171,G__G__Ged_234_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelect::ImplFileName) ), 0);
14648 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_234_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternSelect::DeclFileLine) ), 0);
14649
14650 G__memfunc_setup("~TGedPatternSelect", 1824, G__G__Ged_234_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14651 G__tag_memfunc_reset();
14652 }
14653
14654 static void G__setup_memfuncTAttFillEditor(void) {
14655
14656 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor));
14657 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14658 G__memfunc_setup("TAttFillEditor",1387,G__G__Ged_235_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TAttFillEditor), -1, 0, 5, 1, 1, 0,
14659 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14660 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14661 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14662 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);
14663 G__memfunc_setup("DoFillColor",1081,G__G__Ged_235_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
14664 G__memfunc_setup("DoFillPattern",1304,G__G__Ged_235_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - color", (char*)NULL, (void*) NULL, 1);
14665 G__memfunc_setup("Class",502,G__G__Ged_235_0_6, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttFillEditor::Class) ), 0);
14666 G__memfunc_setup("Class_Name",982,G__G__Ged_235_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFillEditor::Class_Name) ), 0);
14667 G__memfunc_setup("Class_Version",1339,G__G__Ged_235_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttFillEditor::Class_Version) ), 0);
14668 G__memfunc_setup("Dictionary",1046,G__G__Ged_235_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttFillEditor::Dictionary) ), 0);
14669 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14670 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);
14671 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);
14672 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_235_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14673 G__memfunc_setup("DeclFileName",1145,G__G__Ged_235_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFillEditor::DeclFileName) ), 0);
14674 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_235_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttFillEditor::ImplFileLine) ), 0);
14675 G__memfunc_setup("ImplFileName",1171,G__G__Ged_235_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttFillEditor::ImplFileName) ), 0);
14676 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_235_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttFillEditor::DeclFileLine) ), 0);
14677
14678 G__memfunc_setup("~TAttFillEditor", 1513, G__G__Ged_235_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14679 G__tag_memfunc_reset();
14680 }
14681
14682 static void G__setup_memfuncTAttLineEditor(void) {
14683
14684 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor));
14685 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14686 G__memfunc_setup("TAttLineEditor",1388,G__G__Ged_238_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TAttLineEditor), -1, 0, 5, 1, 1, 0,
14687 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14688 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14689 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14690 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);
14691 G__memfunc_setup("DoLineColor",1082,G__G__Ged_238_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
14692 G__memfunc_setup("DoLineStyle",1100,G__G__Ged_238_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - style", (char*)NULL, (void*) NULL, 1);
14693 G__memfunc_setup("DoLineWidth",1083,G__G__Ged_238_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - width", (char*)NULL, (void*) NULL, 1);
14694 G__memfunc_setup("Class",502,G__G__Ged_238_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttLineEditor::Class) ), 0);
14695 G__memfunc_setup("Class_Name",982,G__G__Ged_238_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLineEditor::Class_Name) ), 0);
14696 G__memfunc_setup("Class_Version",1339,G__G__Ged_238_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttLineEditor::Class_Version) ), 0);
14697 G__memfunc_setup("Dictionary",1046,G__G__Ged_238_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttLineEditor::Dictionary) ), 0);
14698 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14699 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);
14700 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);
14701 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_238_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14702 G__memfunc_setup("DeclFileName",1145,G__G__Ged_238_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLineEditor::DeclFileName) ), 0);
14703 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_238_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttLineEditor::ImplFileLine) ), 0);
14704 G__memfunc_setup("ImplFileName",1171,G__G__Ged_238_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttLineEditor::ImplFileName) ), 0);
14705 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_238_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttLineEditor::DeclFileLine) ), 0);
14706
14707 G__memfunc_setup("~TAttLineEditor", 1514, G__G__Ged_238_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14708 G__tag_memfunc_reset();
14709 }
14710
14711 static void G__setup_memfuncTGedMarkerSelect(void) {
14712
14713 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect));
14714 G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14715 G__memfunc_setup("TGedMarkerSelect",1574,G__G__Ged_239_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect), -1, 0, 3, 1, 1, 0,
14716 "U 'TGWindow' - 10 - p s - 'Style_t' 0 - markerStyle "
14717 "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
14718 G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
14719 "l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
14720 "l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
14721 G__memfunc_setup("GetMarkerStyle",1427,G__G__Ged_239_0_4, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
14722 G__memfunc_setup("SetMarkerStyle",1439,G__G__Ged_239_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - pattern", (char*)NULL, (void*) NULL, 0);
14723 G__memfunc_setup("MarkerSelected",1419,G__G__Ged_239_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 '0' marker", "*SIGNAL*", (void*) NULL, 1);
14724 G__memfunc_setup("SavePrimitive",1352,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0,
14725 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
14726 G__memfunc_setup("GetDefaultSize",1408,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__GedLN_TGDimension), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14727 G__memfunc_setup("Class",502,G__G__Ged_239_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedMarkerSelect::Class) ), 0);
14728 G__memfunc_setup("Class_Name",982,G__G__Ged_239_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerSelect::Class_Name) ), 0);
14729 G__memfunc_setup("Class_Version",1339,G__G__Ged_239_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedMarkerSelect::Class_Version) ), 0);
14730 G__memfunc_setup("Dictionary",1046,G__G__Ged_239_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedMarkerSelect::Dictionary) ), 0);
14731 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14732 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);
14733 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);
14734 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_239_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14735 G__memfunc_setup("DeclFileName",1145,G__G__Ged_239_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerSelect::DeclFileName) ), 0);
14736 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_239_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedMarkerSelect::ImplFileLine) ), 0);
14737 G__memfunc_setup("ImplFileName",1171,G__G__Ged_239_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerSelect::ImplFileName) ), 0);
14738 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_239_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedMarkerSelect::DeclFileLine) ), 0);
14739
14740 G__memfunc_setup("~TGedMarkerSelect", 1700, G__G__Ged_239_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14741 G__tag_memfunc_reset();
14742 }
14743
14744 static void G__setup_memfuncTAttMarkerEditor(void) {
14745
14746 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor));
14747 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14748 G__memfunc_setup("TAttMarkerEditor",1606,G__G__Ged_240_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TAttMarkerEditor), -1, 0, 5, 1, 1, 0,
14749 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14750 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14751 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14752 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);
14753 G__memfunc_setup("DoMarkerColor",1300,G__G__Ged_240_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
14754 G__memfunc_setup("DoMarkerSize",1200,G__G__Ged_240_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14755 G__memfunc_setup("DoMarkerStyle",1318,G__G__Ged_240_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - style", (char*)NULL, (void*) NULL, 1);
14756 G__memfunc_setup("Class",502,G__G__Ged_240_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttMarkerEditor::Class) ), 0);
14757 G__memfunc_setup("Class_Name",982,G__G__Ged_240_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarkerEditor::Class_Name) ), 0);
14758 G__memfunc_setup("Class_Version",1339,G__G__Ged_240_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttMarkerEditor::Class_Version) ), 0);
14759 G__memfunc_setup("Dictionary",1046,G__G__Ged_240_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttMarkerEditor::Dictionary) ), 0);
14760 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14761 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);
14762 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);
14763 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_240_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14764 G__memfunc_setup("DeclFileName",1145,G__G__Ged_240_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarkerEditor::DeclFileName) ), 0);
14765 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_240_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttMarkerEditor::ImplFileLine) ), 0);
14766 G__memfunc_setup("ImplFileName",1171,G__G__Ged_240_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttMarkerEditor::ImplFileName) ), 0);
14767 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_240_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttMarkerEditor::DeclFileLine) ), 0);
14768
14769 G__memfunc_setup("~TAttMarkerEditor", 1732, G__G__Ged_240_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14770 G__tag_memfunc_reset();
14771 }
14772
14773 static void G__setup_memfuncTAttTextEditor(void) {
14774
14775 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor));
14776 G__memfunc_setup("BuildFontSizeComboBox",2107,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
14777 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
14778 G__memfunc_setup("BuildTextAlignComboBox",2201,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
14779 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
14780 G__memfunc_setup("TAttTextEditor",1417,G__G__Ged_242_0_3, 105, G__get_linked_tagnum(&G__G__GedLN_TAttTextEditor), -1, 0, 5, 1, 1, 0,
14781 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14782 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14783 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14784 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);
14785 G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
14786 "l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
14787 "l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
14788 G__memfunc_setup("Class",502,G__G__Ged_242_0_6, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAttTextEditor::Class) ), 0);
14789 G__memfunc_setup("Class_Name",982,G__G__Ged_242_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttTextEditor::Class_Name) ), 0);
14790 G__memfunc_setup("Class_Version",1339,G__G__Ged_242_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAttTextEditor::Class_Version) ), 0);
14791 G__memfunc_setup("Dictionary",1046,G__G__Ged_242_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAttTextEditor::Dictionary) ), 0);
14792 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14793 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);
14794 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);
14795 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_242_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14796 G__memfunc_setup("DeclFileName",1145,G__G__Ged_242_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttTextEditor::DeclFileName) ), 0);
14797 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_242_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttTextEditor::ImplFileLine) ), 0);
14798 G__memfunc_setup("ImplFileName",1171,G__G__Ged_242_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAttTextEditor::ImplFileName) ), 0);
14799 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_242_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAttTextEditor::DeclFileLine) ), 0);
14800
14801 G__memfunc_setup("~TAttTextEditor", 1543, G__G__Ged_242_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14802 G__tag_memfunc_reset();
14803 }
14804
14805 static void G__setup_memfuncTAxisEditor(void) {
14806
14807 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TAxisEditor));
14808 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14809 G__memfunc_setup("TAxisEditor",1104,G__G__Ged_246_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TAxisEditor), -1, 0, 5, 1, 1, 0,
14810 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14811 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14812 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14813 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);
14814 G__memfunc_setup("DoTickLength",1184,G__G__Ged_246_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14815 G__memfunc_setup("DoAxisColor",1095,G__G__Ged_246_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
14816 G__memfunc_setup("DoTicks",689,G__G__Ged_246_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14817 G__memfunc_setup("DoDivisions",1131,G__G__Ged_246_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14818 G__memfunc_setup("DoLogAxis",874,G__G__Ged_246_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14819 G__memfunc_setup("DoMoreLog",872,G__G__Ged_246_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14820 G__memfunc_setup("DoTitleColor",1204,G__G__Ged_246_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
14821 G__memfunc_setup("DoTitle",693,G__G__Ged_246_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
14822 G__memfunc_setup("DoTitleSize",1104,G__G__Ged_246_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14823 G__memfunc_setup("DoTitleFont",1100,G__G__Ged_246_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - font", (char*)NULL, (void*) NULL, 1);
14824 G__memfunc_setup("DoTitleOffset",1308,G__G__Ged_246_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14825 G__memfunc_setup("DoTitleCentered",1503,G__G__Ged_246_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14826 G__memfunc_setup("DoTitleRotated",1416,G__G__Ged_246_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14827 G__memfunc_setup("DoLabelColor",1170,G__G__Ged_246_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", (char*)NULL, (void*) NULL, 1);
14828 G__memfunc_setup("DoLabelSize",1070,G__G__Ged_246_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14829 G__memfunc_setup("DoLabelFont",1066,G__G__Ged_246_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - font", (char*)NULL, (void*) NULL, 1);
14830 G__memfunc_setup("DoLabelOffset",1274,G__G__Ged_246_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14831 G__memfunc_setup("DoNoExponent",1217,G__G__Ged_246_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14832 G__memfunc_setup("DoDecimal",866,G__G__Ged_246_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
14833 G__memfunc_setup("Class",502,G__G__Ged_246_0_23, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TAxisEditor::Class) ), 0);
14834 G__memfunc_setup("Class_Name",982,G__G__Ged_246_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxisEditor::Class_Name) ), 0);
14835 G__memfunc_setup("Class_Version",1339,G__G__Ged_246_0_25, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TAxisEditor::Class_Version) ), 0);
14836 G__memfunc_setup("Dictionary",1046,G__G__Ged_246_0_26, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TAxisEditor::Dictionary) ), 0);
14837 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14838 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);
14839 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);
14840 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_246_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14841 G__memfunc_setup("DeclFileName",1145,G__G__Ged_246_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxisEditor::DeclFileName) ), 0);
14842 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_246_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAxisEditor::ImplFileLine) ), 0);
14843 G__memfunc_setup("ImplFileName",1171,G__G__Ged_246_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TAxisEditor::ImplFileName) ), 0);
14844 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_246_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TAxisEditor::DeclFileLine) ), 0);
14845
14846 G__memfunc_setup("~TAxisEditor", 1230, G__G__Ged_246_0_35, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14847 G__tag_memfunc_reset();
14848 }
14849
14850 static void G__setup_memfuncTCurlyArcEditor(void) {
14851
14852 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor));
14853 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14854 G__memfunc_setup("TCurlyArcEditor",1504,G__G__Ged_248_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TCurlyArcEditor), -1, 0, 5, 1, 1, 0,
14855 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14856 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14857 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14858 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);
14859 G__memfunc_setup("DoRadius",795,G__G__Ged_248_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14860 G__memfunc_setup("DoPhimin",792,G__G__Ged_248_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14861 G__memfunc_setup("DoPhimax",794,G__G__Ged_248_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14862 G__memfunc_setup("DoCenterXY",965,G__G__Ged_248_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14863 G__memfunc_setup("Class",502,G__G__Ged_248_0_8, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCurlyArcEditor::Class) ), 0);
14864 G__memfunc_setup("Class_Name",982,G__G__Ged_248_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArcEditor::Class_Name) ), 0);
14865 G__memfunc_setup("Class_Version",1339,G__G__Ged_248_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCurlyArcEditor::Class_Version) ), 0);
14866 G__memfunc_setup("Dictionary",1046,G__G__Ged_248_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCurlyArcEditor::Dictionary) ), 0);
14867 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14868 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);
14869 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);
14870 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_248_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14871 G__memfunc_setup("DeclFileName",1145,G__G__Ged_248_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArcEditor::DeclFileName) ), 0);
14872 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_248_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyArcEditor::ImplFileLine) ), 0);
14873 G__memfunc_setup("ImplFileName",1171,G__G__Ged_248_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyArcEditor::ImplFileName) ), 0);
14874 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_248_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyArcEditor::DeclFileLine) ), 0);
14875
14876 G__memfunc_setup("~TCurlyArcEditor", 1630, G__G__Ged_248_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14877 G__tag_memfunc_reset();
14878 }
14879
14880 static void G__setup_memfuncTCurlyLineEditor(void) {
14881
14882 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor));
14883 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14884 G__memfunc_setup("TCurlyLineEditor",1618,G__G__Ged_250_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TCurlyLineEditor), -1, 0, 5, 1, 1, 0,
14885 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14886 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14887 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14888 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);
14889 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);
14890 G__memfunc_setup("DoStartXY",882,G__G__Ged_250_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14891 G__memfunc_setup("DoEndXY",635,G__G__Ged_250_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14892 G__memfunc_setup("DoAmplitude",1112,G__G__Ged_250_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14893 G__memfunc_setup("DoWaveLength",1192,G__G__Ged_250_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14894 G__memfunc_setup("DoWavy",602,G__G__Ged_250_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14895 G__memfunc_setup("Class",502,G__G__Ged_250_0_10, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCurlyLineEditor::Class) ), 0);
14896 G__memfunc_setup("Class_Name",982,G__G__Ged_250_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLineEditor::Class_Name) ), 0);
14897 G__memfunc_setup("Class_Version",1339,G__G__Ged_250_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCurlyLineEditor::Class_Version) ), 0);
14898 G__memfunc_setup("Dictionary",1046,G__G__Ged_250_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCurlyLineEditor::Dictionary) ), 0);
14899 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14900 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);
14901 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);
14902 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_250_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14903 G__memfunc_setup("DeclFileName",1145,G__G__Ged_250_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLineEditor::DeclFileName) ), 0);
14904 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_250_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyLineEditor::ImplFileLine) ), 0);
14905 G__memfunc_setup("ImplFileName",1171,G__G__Ged_250_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCurlyLineEditor::ImplFileName) ), 0);
14906 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_250_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCurlyLineEditor::DeclFileLine) ), 0);
14907
14908 G__memfunc_setup("~TCurlyLineEditor", 1744, G__G__Ged_250_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14909 G__tag_memfunc_reset();
14910 }
14911
14912 static void G__setup_memfuncTF1Editor(void) {
14913
14914 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TF1Editor));
14915 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "connect signals to slots", (void*) NULL, 1);
14916 G__memfunc_setup("TF1Editor",818,G__G__Ged_254_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TF1Editor), -1, 0, 5, 1, 1, 0,
14917 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14918 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14919 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14920 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);
14921 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);
14922 G__memfunc_setup("DoParameterSettings",1957,G__G__Ged_254_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14923 G__memfunc_setup("DoXPoints",904,G__G__Ged_254_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14924 G__memfunc_setup("DoSliderXMoved",1385,G__G__Ged_254_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14925 G__memfunc_setup("DoSliderXPressed",1604,G__G__Ged_254_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14926 G__memfunc_setup("DoSliderXReleased",1683,G__G__Ged_254_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14927 G__memfunc_setup("DoXRange",760,G__G__Ged_254_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14928 G__memfunc_setup("Class",502,G__G__Ged_254_0_11, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TF1Editor::Class) ), 0);
14929 G__memfunc_setup("Class_Name",982,G__G__Ged_254_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1Editor::Class_Name) ), 0);
14930 G__memfunc_setup("Class_Version",1339,G__G__Ged_254_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TF1Editor::Class_Version) ), 0);
14931 G__memfunc_setup("Dictionary",1046,G__G__Ged_254_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TF1Editor::Dictionary) ), 0);
14932 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14933 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);
14934 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);
14935 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_254_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14936 G__memfunc_setup("DeclFileName",1145,G__G__Ged_254_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1Editor::DeclFileName) ), 0);
14937 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_254_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF1Editor::ImplFileLine) ), 0);
14938 G__memfunc_setup("ImplFileName",1171,G__G__Ged_254_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TF1Editor::ImplFileName) ), 0);
14939 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_254_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TF1Editor::DeclFileLine) ), 0);
14940
14941 G__memfunc_setup("~TF1Editor", 944, G__G__Ged_254_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14942 G__tag_memfunc_reset();
14943 }
14944
14945 static void G__setup_memfuncTFrameEditor(void) {
14946
14947 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TFrameEditor));
14948 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
14949 G__memfunc_setup("TFrameEditor",1190,G__G__Ged_257_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TFrameEditor), -1, 0, 5, 1, 1, 0,
14950 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
14951 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
14952 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
14953 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);
14954 G__memfunc_setup("DoBorderMode",1174,G__G__Ged_257_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14955 G__memfunc_setup("DoBorderSize",1196,G__G__Ged_257_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
14956 G__memfunc_setup("Class",502,G__G__Ged_257_0_6, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFrameEditor::Class) ), 0);
14957 G__memfunc_setup("Class_Name",982,G__G__Ged_257_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrameEditor::Class_Name) ), 0);
14958 G__memfunc_setup("Class_Version",1339,G__G__Ged_257_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFrameEditor::Class_Version) ), 0);
14959 G__memfunc_setup("Dictionary",1046,G__G__Ged_257_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFrameEditor::Dictionary) ), 0);
14960 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14961 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);
14962 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);
14963 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_257_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
14964 G__memfunc_setup("DeclFileName",1145,G__G__Ged_257_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrameEditor::DeclFileName) ), 0);
14965 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_257_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFrameEditor::ImplFileLine) ), 0);
14966 G__memfunc_setup("ImplFileName",1171,G__G__Ged_257_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFrameEditor::ImplFileName) ), 0);
14967 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_257_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFrameEditor::DeclFileLine) ), 0);
14968
14969 G__memfunc_setup("~TFrameEditor", 1316, G__G__Ged_257_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
14970 G__tag_memfunc_reset();
14971 }
14972
14973 static void G__setup_memfuncTFunctionParametersDialog(void) {
14974
14975 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog));
14976 G__memfunc_setup("TFunctionParametersDialog",2558,G__G__Ged_259_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TFunctionParametersDialog), -1, 0, 6, 1, 1, 0,
14977 "U 'TGWindow' - 10 - p U 'TGWindow' - 10 - main "
14978 "U 'TF1' - 0 - func U 'TVirtualPad' - 0 - pad "
14979 "d - 'Double_t' 0 - rmin d - 'Double_t' 0 - rmax", (char*)NULL, (void*) NULL, 0);
14980 G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14981 G__memfunc_setup("DoApply",697,G__G__Ged_259_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14982 G__memfunc_setup("DoCancel",761,G__G__Ged_259_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14983 G__memfunc_setup("DoFix",474,G__G__Ged_259_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
14984 G__memfunc_setup("DoOK",333,G__G__Ged_259_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14985 G__memfunc_setup("DoParMaxLimit",1275,G__G__Ged_259_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14986 G__memfunc_setup("DoParMinLimit",1273,G__G__Ged_259_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14987 G__memfunc_setup("DoParValue",979,G__G__Ged_259_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14988 G__memfunc_setup("DoReset",694,G__G__Ged_259_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14989 G__memfunc_setup("DoSlider",790,G__G__Ged_259_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14990 G__memfunc_setup("HandleButtons",1339,G__G__Ged_259_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - update", (char*)NULL, (void*) NULL, 1);
14991 G__memfunc_setup("RedrawFunction",1451,G__G__Ged_259_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
14992 G__memfunc_setup("Class",502,G__G__Ged_259_0_14, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFunctionParametersDialog::Class) ), 0);
14993 G__memfunc_setup("Class_Name",982,G__G__Ged_259_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunctionParametersDialog::Class_Name) ), 0);
14994 G__memfunc_setup("Class_Version",1339,G__G__Ged_259_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFunctionParametersDialog::Class_Version) ), 0);
14995 G__memfunc_setup("Dictionary",1046,G__G__Ged_259_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFunctionParametersDialog::Dictionary) ), 0);
14996 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
14997 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);
14998 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);
14999 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_259_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15000 G__memfunc_setup("DeclFileName",1145,G__G__Ged_259_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunctionParametersDialog::DeclFileName) ), 0);
15001 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_259_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFunctionParametersDialog::ImplFileLine) ), 0);
15002 G__memfunc_setup("ImplFileName",1171,G__G__Ged_259_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFunctionParametersDialog::ImplFileName) ), 0);
15003 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_259_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFunctionParametersDialog::DeclFileLine) ), 0);
15004
15005 G__memfunc_setup("~TFunctionParametersDialog", 2684, G__G__Ged_259_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15006 G__tag_memfunc_reset();
15007 }
15008
15009 static void G__setup_memfuncTGedPopup(void) {
15010
15011 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPopup));
15012 G__memfunc_setup("TGedPopup",888,G__G__Ged_280_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPopup), -1, 0, 6, 1, 1, 0,
15013 "U 'TGWindow' - 10 - p U 'TGWindow' - 10 - m "
15014 "h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h "
15015 "h - 'UInt_t' 0 '0' options k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15016 G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
15017 G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
15018 "l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
15019 "l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
15020 G__memfunc_setup("PlacePopup",1017,G__G__Ged_280_0_4, 121, -1, -1, 0, 4, 1, 1, 0,
15021 "i - 'Int_t' 0 - x i - 'Int_t' 0 - y "
15022 "h - 'UInt_t' 0 - w h - 'UInt_t' 0 - h", (char*)NULL, (void*) NULL, 0);
15023 G__memfunc_setup("EndPopup",811,G__G__Ged_280_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15024 G__memfunc_setup("Class",502,G__G__Ged_280_0_6, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPopup::Class) ), 0);
15025 G__memfunc_setup("Class_Name",982,G__G__Ged_280_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPopup::Class_Name) ), 0);
15026 G__memfunc_setup("Class_Version",1339,G__G__Ged_280_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPopup::Class_Version) ), 0);
15027 G__memfunc_setup("Dictionary",1046,G__G__Ged_280_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPopup::Dictionary) ), 0);
15028 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15029 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);
15030 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);
15031 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_280_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15032 G__memfunc_setup("DeclFileName",1145,G__G__Ged_280_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPopup::DeclFileName) ), 0);
15033 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_280_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPopup::ImplFileLine) ), 0);
15034 G__memfunc_setup("ImplFileName",1171,G__G__Ged_280_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPopup::ImplFileName) ), 0);
15035 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_280_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPopup::DeclFileLine) ), 0);
15036
15037 G__memfunc_setup("~TGedPopup", 1014, G__G__Ged_280_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15038 G__tag_memfunc_reset();
15039 }
15040
15041 static void G__setup_memfuncTGedPatternFrame(void) {
15042
15043 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame));
15044 G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15045 G__memfunc_setup("TGedPatternFrame",1581,G__G__Ged_281_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPatternFrame), -1, 0, 4, 1, 1, 0,
15046 "U 'TGWindow' - 10 - p s - 'Style_t' 0 - pattern "
15047 "i - 'Int_t' 0 '40' width i - 'Int_t' 0 '20' height", (char*)NULL, (void*) NULL, 0);
15048 G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
15049 G__memfunc_setup("HandleCrossing",1428,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
15050 G__memfunc_setup("DrawBorder",1004,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15051 G__memfunc_setup("SetActive",904,G__G__Ged_281_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - in", (char*)NULL, (void*) NULL, 0);
15052 G__memfunc_setup("GetPattern",1022,G__G__Ged_281_0_7, 115, -1, G__defined_typename("Style_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15053 G__memfunc_setup("SetFillStyle",1220,G__G__Ged_281_0_8, 121, -1, -1, 0, 2, 3, 1, 0,
15054 "U 'TGGC' - 0 - gc s - 'Style_t' 0 - fstyle", "set fill style for given GC", (void*) G__func2void( (void (*)(TGGC*, Style_t))(&TGedPatternFrame::SetFillStyle) ), 0);
15055 G__memfunc_setup("Class",502,G__G__Ged_281_0_9, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPatternFrame::Class) ), 0);
15056 G__memfunc_setup("Class_Name",982,G__G__Ged_281_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternFrame::Class_Name) ), 0);
15057 G__memfunc_setup("Class_Version",1339,G__G__Ged_281_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPatternFrame::Class_Version) ), 0);
15058 G__memfunc_setup("Dictionary",1046,G__G__Ged_281_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPatternFrame::Dictionary) ), 0);
15059 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15060 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);
15061 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);
15062 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_281_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15063 G__memfunc_setup("DeclFileName",1145,G__G__Ged_281_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternFrame::DeclFileName) ), 0);
15064 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_281_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternFrame::ImplFileLine) ), 0);
15065 G__memfunc_setup("ImplFileName",1171,G__G__Ged_281_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternFrame::ImplFileName) ), 0);
15066 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_281_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternFrame::DeclFileLine) ), 0);
15067
15068 G__memfunc_setup("~TGedPatternFrame", 1707, G__G__Ged_281_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15069 G__tag_memfunc_reset();
15070 }
15071
15072 static void G__setup_memfuncTGedPatternSelector(void) {
15073
15074 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector));
15075 G__memfunc_setup("TGedPatternSelector",1923,G__G__Ged_282_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelector), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - p", (char*)NULL, (void*) NULL, 0);
15076 G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
15077 "l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
15078 "l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
15079 G__memfunc_setup("SetActive",904,G__G__Ged_282_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - newat", (char*)NULL, (void*) NULL, 0);
15080 G__memfunc_setup("GetActive",892,G__G__Ged_282_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15081 G__memfunc_setup("Class",502,G__G__Ged_282_0_5, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPatternSelector::Class) ), 0);
15082 G__memfunc_setup("Class_Name",982,G__G__Ged_282_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelector::Class_Name) ), 0);
15083 G__memfunc_setup("Class_Version",1339,G__G__Ged_282_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPatternSelector::Class_Version) ), 0);
15084 G__memfunc_setup("Dictionary",1046,G__G__Ged_282_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPatternSelector::Dictionary) ), 0);
15085 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15086 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);
15087 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);
15088 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_282_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15089 G__memfunc_setup("DeclFileName",1145,G__G__Ged_282_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelector::DeclFileName) ), 0);
15090 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_282_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternSelector::ImplFileLine) ), 0);
15091 G__memfunc_setup("ImplFileName",1171,G__G__Ged_282_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternSelector::ImplFileName) ), 0);
15092 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_282_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternSelector::DeclFileLine) ), 0);
15093
15094 G__memfunc_setup("~TGedPatternSelector", 2049, G__G__Ged_282_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15095 G__tag_memfunc_reset();
15096 }
15097
15098 static void G__setup_memfuncTGedPatternPopup(void) {
15099
15100 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup));
15101 G__memfunc_setup("TGedPatternPopup",1622,G__G__Ged_283_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TGedPatternPopup), -1, 0, 3, 1, 1, 0,
15102 "U 'TGWindow' - 10 - p U 'TGWindow' - 10 - m "
15103 "s - 'Style_t' 0 - pattern", (char*)NULL, (void*) NULL, 0);
15104 G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
15105 "l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
15106 "l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
15107 G__memfunc_setup("Class",502,G__G__Ged_283_0_3, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedPatternPopup::Class) ), 0);
15108 G__memfunc_setup("Class_Name",982,G__G__Ged_283_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternPopup::Class_Name) ), 0);
15109 G__memfunc_setup("Class_Version",1339,G__G__Ged_283_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedPatternPopup::Class_Version) ), 0);
15110 G__memfunc_setup("Dictionary",1046,G__G__Ged_283_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedPatternPopup::Dictionary) ), 0);
15111 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15112 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);
15113 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);
15114 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_283_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15115 G__memfunc_setup("DeclFileName",1145,G__G__Ged_283_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternPopup::DeclFileName) ), 0);
15116 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_283_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternPopup::ImplFileLine) ), 0);
15117 G__memfunc_setup("ImplFileName",1171,G__G__Ged_283_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedPatternPopup::ImplFileName) ), 0);
15118 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_283_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedPatternPopup::DeclFileLine) ), 0);
15119
15120 G__memfunc_setup("~TGedPatternPopup", 1748, G__G__Ged_283_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15121 G__tag_memfunc_reset();
15122 }
15123
15124 static void G__setup_memfuncTGedSelect(void) {
15125
15126 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedSelect));
15127 G__memfunc_setup("DoRedraw",792,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15128 G__memfunc_setup("DrawTriangle",1220,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0,
15129 "k - 'GContext_t' 0 - gc i - 'Int_t' 0 - x "
15130 "i - 'Int_t' 0 - y", (char*)NULL, (void*) NULL, 0);
15131 G__memfunc_setup("TGedSelect",964,G__G__Ged_284_0_3, 105, G__get_linked_tagnum(&G__G__GedLN_TGedSelect), -1, 0, 2, 1, 1, 0,
15132 "U 'TGWindow' - 10 - p i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15133 G__memfunc_setup("HandleButton",1224,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'Event_t' - 0 - event", (char*)NULL, (void*) NULL, 1);
15134 G__memfunc_setup("Enable",583,G__G__Ged_284_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15135 G__memfunc_setup("Disable",692,G__G__Ged_284_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15136 G__memfunc_setup("SetPopup",832,G__G__Ged_284_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TGedPopup' - 0 - p", "popup will be deleted in destructor.", (void*) NULL, 1);
15137 G__memfunc_setup("Class",502,G__G__Ged_284_0_8, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedSelect::Class) ), 0);
15138 G__memfunc_setup("Class_Name",982,G__G__Ged_284_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedSelect::Class_Name) ), 0);
15139 G__memfunc_setup("Class_Version",1339,G__G__Ged_284_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedSelect::Class_Version) ), 0);
15140 G__memfunc_setup("Dictionary",1046,G__G__Ged_284_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedSelect::Dictionary) ), 0);
15141 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15142 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);
15143 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);
15144 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_284_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15145 G__memfunc_setup("DeclFileName",1145,G__G__Ged_284_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedSelect::DeclFileName) ), 0);
15146 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_284_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedSelect::ImplFileLine) ), 0);
15147 G__memfunc_setup("ImplFileName",1171,G__G__Ged_284_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedSelect::ImplFileName) ), 0);
15148 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_284_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedSelect::DeclFileLine) ), 0);
15149
15150 G__memfunc_setup("~TGedSelect", 1090, G__G__Ged_284_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15151 G__tag_memfunc_reset();
15152 }
15153
15154 static void G__setup_memfuncTGedMarkerPopup(void) {
15155
15156 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup));
15157 G__memfunc_setup("TGedMarkerPopup",1498,G__G__Ged_285_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TGedMarkerPopup), -1, 0, 3, 1, 1, 0,
15158 "U 'TGWindow' - 10 - p U 'TGWindow' - 10 - m "
15159 "s - 'Style_t' 0 - markerStyle", (char*)NULL, (void*) NULL, 0);
15160 G__memfunc_setup("ProcessMessage",1444,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0,
15161 "l - 'Long_t' 0 - msg l - 'Long_t' 0 - parm1 "
15162 "l - 'Long_t' 0 - parm2", (char*)NULL, (void*) NULL, 1);
15163 G__memfunc_setup("Class",502,G__G__Ged_285_0_3, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGedMarkerPopup::Class) ), 0);
15164 G__memfunc_setup("Class_Name",982,G__G__Ged_285_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerPopup::Class_Name) ), 0);
15165 G__memfunc_setup("Class_Version",1339,G__G__Ged_285_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGedMarkerPopup::Class_Version) ), 0);
15166 G__memfunc_setup("Dictionary",1046,G__G__Ged_285_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGedMarkerPopup::Dictionary) ), 0);
15167 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15168 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);
15169 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);
15170 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_285_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15171 G__memfunc_setup("DeclFileName",1145,G__G__Ged_285_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerPopup::DeclFileName) ), 0);
15172 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_285_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedMarkerPopup::ImplFileLine) ), 0);
15173 G__memfunc_setup("ImplFileName",1171,G__G__Ged_285_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGedMarkerPopup::ImplFileName) ), 0);
15174 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_285_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGedMarkerPopup::DeclFileLine) ), 0);
15175
15176 G__memfunc_setup("~TGedMarkerPopup", 1624, G__G__Ged_285_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15177 G__tag_memfunc_reset();
15178 }
15179
15180 static void G__setup_memfuncTGraphEditor(void) {
15181
15182 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TGraphEditor));
15183 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15184 G__memfunc_setup("TGraphEditor",1197,G__G__Ged_287_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TGraphEditor), -1, 0, 5, 1, 1, 0,
15185 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15186 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15187 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15188 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);
15189 G__memfunc_setup("DoShape",676,G__G__Ged_287_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15190 G__memfunc_setup("DoMarkerOnOff",1261,G__G__Ged_287_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15191 G__memfunc_setup("DoTitle",693,G__G__Ged_287_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
15192 G__memfunc_setup("DoGraphLineWidth",1581,G__G__Ged_287_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15193 G__memfunc_setup("Class",502,G__G__Ged_287_0_8, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TGraphEditor::Class) ), 0);
15194 G__memfunc_setup("Class_Name",982,G__G__Ged_287_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphEditor::Class_Name) ), 0);
15195 G__memfunc_setup("Class_Version",1339,G__G__Ged_287_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TGraphEditor::Class_Version) ), 0);
15196 G__memfunc_setup("Dictionary",1046,G__G__Ged_287_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TGraphEditor::Dictionary) ), 0);
15197 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15198 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);
15199 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);
15200 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_287_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15201 G__memfunc_setup("DeclFileName",1145,G__G__Ged_287_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphEditor::DeclFileName) ), 0);
15202 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_287_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphEditor::ImplFileLine) ), 0);
15203 G__memfunc_setup("ImplFileName",1171,G__G__Ged_287_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TGraphEditor::ImplFileName) ), 0);
15204 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_287_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TGraphEditor::DeclFileLine) ), 0);
15205
15206 G__memfunc_setup("~TGraphEditor", 1323, G__G__Ged_287_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15207 G__tag_memfunc_reset();
15208 }
15209
15210 static void G__setup_memfuncTH1Editor(void) {
15211
15212 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TH1Editor));
15213 G__memfunc_setup("BuildHistTypeComboBox",2115,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15214 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the Type ComboBox", (void*) NULL, 0);
15215 G__memfunc_setup("BuildHistCoordsComboBox",2315,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15216 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the Coordinate ComboBox", (void*) NULL, 0);
15217 G__memfunc_setup("BuildHistErrorComboBox",2219,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15218 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the Error ComboBox", (void*) NULL, 0);
15219 G__memfunc_setup("BuildHistAddComboBox",1962,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15220 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the Add ComboBox", (void*) NULL, 0);
15221 G__memfunc_setup("BuildPercentComboBox",2010,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15222 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", "builts the ComboBox for setting the Bar options bar1,..., bar4", (void*) NULL, 0);
15223 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);
15224 G__memfunc_setup("CreateBinTab",1156,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Creates the Bin Tab (part of the SetGedEditor)", (void*) NULL, 0);
15225 G__memfunc_setup("GetHistTypeLabel",1594,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", "Get the Histogram Type = String which contains the Histogram Draw Option", (void*) NULL, 0);
15226 G__memfunc_setup("GetHistCoordsLabel",1794,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", "Get the histogram coordinate system (CYL, SPH, PSR, ..)", (void*) NULL, 0);
15227 G__memfunc_setup("GetHistErrorLabel",1698,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", "Get the histogram Error type (E1, .., E4)", (void*) NULL, 0);
15228 G__memfunc_setup("GetHistAddLabel",1441,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", "Get the histogram addon (smooth line, simple line, ..)", (void*) NULL, 0);
15229 G__memfunc_setup("ChangeErrorCombo",1600,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
15230 G__memfunc_setup("TH1Editor",820,G__G__Ged_291_0_13, 105, G__get_linked_tagnum(&G__G__GedLN_TH1Editor), -1, 0, 5, 1, 1, 0,
15231 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15232 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15233 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15234 G__memfunc_setup("AcceptModel",1089,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 1);
15235 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);
15236 G__memfunc_setup("DoTitle",693,G__G__Ged_291_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
15237 G__memfunc_setup("DoAddMarker",1054,G__G__Ged_291_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15238 G__memfunc_setup("DoAddBar",721,G__G__Ged_291_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
15239 G__memfunc_setup("DoAddB",510,G__G__Ged_291_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
15240 G__memfunc_setup("DoAddSimple",1062,G__G__Ged_291_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15241 G__memfunc_setup("DoHistSimple",1205,G__G__Ged_291_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15242 G__memfunc_setup("DoHistComplex",1315,G__G__Ged_291_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15243 G__memfunc_setup("DoHistChanges",1284,G__G__Ged_291_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15244 G__memfunc_setup("DoHistView",998,G__G__Ged_291_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15245 G__memfunc_setup("DoBarOffset",1071,G__G__Ged_291_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15246 G__memfunc_setup("DoBarWidth",968,G__G__Ged_291_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15247 G__memfunc_setup("DoPercent",900,G__G__Ged_291_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15248 G__memfunc_setup("DoHBar",528,G__G__Ged_291_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15249 G__memfunc_setup("DoSliderMoved",1297,G__G__Ged_291_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15250 G__memfunc_setup("DoSliderPressed",1516,G__G__Ged_291_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15251 G__memfunc_setup("DoSliderReleased",1595,G__G__Ged_291_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15252 G__memfunc_setup("DoAxisRange",1077,G__G__Ged_291_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15253 G__memfunc_setup("DoBinMoved",967,G__G__Ged_291_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - number", (char*)NULL, (void*) NULL, 1);
15254 G__memfunc_setup("DoBinReleased",1265,G__G__Ged_291_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15255 G__memfunc_setup("DoBinPressed",1186,G__G__Ged_291_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15256 G__memfunc_setup("DoBinLabel",940,G__G__Ged_291_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15257 G__memfunc_setup("DoBinReleased1",1314,G__G__Ged_291_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15258 G__memfunc_setup("DoBinMoved1",1016,G__G__Ged_291_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15259 G__memfunc_setup("DoBinLabel1",989,G__G__Ged_291_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15260 G__memfunc_setup("DoOffsetMoved",1301,G__G__Ged_291_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - num", (char*)NULL, (void*) NULL, 1);
15261 G__memfunc_setup("DoOffsetReleased",1599,G__G__Ged_291_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15262 G__memfunc_setup("DoOffsetPressed",1520,G__G__Ged_291_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15263 G__memfunc_setup("DoBinOffset",1075,G__G__Ged_291_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15264 G__memfunc_setup("DoApply",697,G__G__Ged_291_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15265 G__memfunc_setup("DoCancel",761,G__G__Ged_291_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15266 G__memfunc_setup("PaintBox3D",924,G__G__Ged_291_0_46, 121, -1, -1, 0, 4, 1, 1, 0,
15267 "F - 'Float_t' 0 - p1 F - 'Float_t' 0 - p2 "
15268 "F - 'Float_t' 0 - p3 F - 'Float_t' 0 - p4", (char*)NULL, (void*) NULL, 1);
15269 G__memfunc_setup("Dividers",826,G__G__Ged_291_0_47, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
15270 G__memfunc_setup("Class",502,G__G__Ged_291_0_48, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH1Editor::Class) ), 0);
15271 G__memfunc_setup("Class_Name",982,G__G__Ged_291_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1Editor::Class_Name) ), 0);
15272 G__memfunc_setup("Class_Version",1339,G__G__Ged_291_0_50, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH1Editor::Class_Version) ), 0);
15273 G__memfunc_setup("Dictionary",1046,G__G__Ged_291_0_51, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH1Editor::Dictionary) ), 0);
15274 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15275 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);
15276 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);
15277 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_291_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15278 G__memfunc_setup("DeclFileName",1145,G__G__Ged_291_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1Editor::DeclFileName) ), 0);
15279 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_291_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1Editor::ImplFileLine) ), 0);
15280 G__memfunc_setup("ImplFileName",1171,G__G__Ged_291_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH1Editor::ImplFileName) ), 0);
15281 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_291_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH1Editor::DeclFileLine) ), 0);
15282
15283 G__memfunc_setup("~TH1Editor", 946, G__G__Ged_291_0_60, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15284 G__tag_memfunc_reset();
15285 }
15286
15287 static void G__setup_memfuncTH2Editor(void) {
15288
15289 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TH2Editor));
15290 G__memfunc_setup("BuildHistTypeComboBox",2115,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15291 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15292 G__memfunc_setup("BuildHistCoordsComboBox",2315,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15293 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15294 G__memfunc_setup("BuildHistContComboBox",2101,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15295 "U 'TGFrame' - 0 - parent i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15296 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15297 G__memfunc_setup("CreateBinTab",1156,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Creates the Bin Tab (part of the SetGedEditor)", (void*) NULL, 0);
15298 G__memfunc_setup("PaintBox3D",924,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0,
15299 "F - 'Float_t' 0 - p1 F - 'Float_t' 0 - p2 "
15300 "F - 'Float_t' 0 - p3 F - 'Float_t' 0 - p4", (char*)NULL, (void*) NULL, 0);
15301 G__memfunc_setup("GetHistTypeLabel",1594,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15302 G__memfunc_setup("GetHistCoordsLabel",1794,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15303 G__memfunc_setup("GetHistContLabel",1580,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15304 G__memfunc_setup("GetHistAdditiveLabel",1986,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15305 G__memfunc_setup("GetCutOptionString",1852,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__GedLN_TString), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15306 G__memfunc_setup("TH2Editor",821,G__G__Ged_293_0_12, 105, G__get_linked_tagnum(&G__G__GedLN_TH2Editor), -1, 0, 5, 1, 1, 0,
15307 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15308 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15309 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15310 G__memfunc_setup("AcceptModel",1089,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - model", (char*)NULL, (void*) NULL, 1);
15311 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);
15312 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);
15313 G__memfunc_setup("DoTitle",693,G__G__Ged_293_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
15314 G__memfunc_setup("DoHistView",998,G__G__Ged_293_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15315 G__memfunc_setup("DoHistSimple",1205,G__G__Ged_293_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15316 G__memfunc_setup("DoHistComplex",1315,G__G__Ged_293_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15317 G__memfunc_setup("DoHistChanges",1284,G__G__Ged_293_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15318 G__memfunc_setup("DoAddArr",737,G__G__Ged_293_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15319 G__memfunc_setup("DoAddBox",741,G__G__Ged_293_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15320 G__memfunc_setup("DoAddCol",730,G__G__Ged_293_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15321 G__memfunc_setup("DoAddScat",839,G__G__Ged_293_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15322 G__memfunc_setup("DoAddText",865,G__G__Ged_293_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15323 G__memfunc_setup("DoAddError",966,G__G__Ged_293_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15324 G__memfunc_setup("DoAddPalette",1163,G__G__Ged_293_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15325 G__memfunc_setup("DoAddFB",580,G__G__Ged_293_0_28, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15326 G__memfunc_setup("DoAddBB",576,G__G__Ged_293_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15327 G__memfunc_setup("DoContLevel",1087,G__G__Ged_293_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15328 G__memfunc_setup("DoContLevel1",1136,G__G__Ged_293_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15329 G__memfunc_setup("DoBarWidth",968,G__G__Ged_293_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15330 G__memfunc_setup("DoBarOffset",1071,G__G__Ged_293_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15331 G__memfunc_setup("DoBinPressed",1186,G__G__Ged_293_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15332 G__memfunc_setup("DoBinMoved",967,G__G__Ged_293_0_35, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15333 G__memfunc_setup("DoBinReleased",1265,G__G__Ged_293_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15334 G__memfunc_setup("DoBinLabel",940,G__G__Ged_293_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15335 G__memfunc_setup("DoApply",697,G__G__Ged_293_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15336 G__memfunc_setup("DoCancel",761,G__G__Ged_293_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15337 G__memfunc_setup("DoBinReleased1",1314,G__G__Ged_293_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15338 G__memfunc_setup("DoBinMoved1",1016,G__G__Ged_293_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15339 G__memfunc_setup("DoBinLabel1",989,G__G__Ged_293_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15340 G__memfunc_setup("DoOffsetMoved",1301,G__G__Ged_293_0_43, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15341 G__memfunc_setup("DoOffsetReleased",1599,G__G__Ged_293_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15342 G__memfunc_setup("DoOffsetPressed",1520,G__G__Ged_293_0_45, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15343 G__memfunc_setup("DoBinOffset",1075,G__G__Ged_293_0_46, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15344 G__memfunc_setup("DoSliderXMoved",1385,G__G__Ged_293_0_47, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15345 G__memfunc_setup("DoSliderXPressed",1604,G__G__Ged_293_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15346 G__memfunc_setup("DoSliderXReleased",1683,G__G__Ged_293_0_49, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15347 G__memfunc_setup("DoXAxisRange",1165,G__G__Ged_293_0_50, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15348 G__memfunc_setup("DoSliderYMoved",1386,G__G__Ged_293_0_51, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15349 G__memfunc_setup("DoSliderYPressed",1605,G__G__Ged_293_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15350 G__memfunc_setup("DoSliderYReleased",1684,G__G__Ged_293_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15351 G__memfunc_setup("DoYAxisRange",1166,G__G__Ged_293_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15352 G__memfunc_setup("DoFillColor",1081,G__G__Ged_293_0_55, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - -", (char*)NULL, (void*) NULL, 1);
15353 G__memfunc_setup("DoFillPattern",1304,G__G__Ged_293_0_56, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - -", (char*)NULL, (void*) NULL, 1);
15354 G__memfunc_setup("Dividers",826,G__G__Ged_293_0_57, 73, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
15355 G__memfunc_setup("Class",502,G__G__Ged_293_0_58, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TH2Editor::Class) ), 0);
15356 G__memfunc_setup("Class_Name",982,G__G__Ged_293_0_59, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Editor::Class_Name) ), 0);
15357 G__memfunc_setup("Class_Version",1339,G__G__Ged_293_0_60, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TH2Editor::Class_Version) ), 0);
15358 G__memfunc_setup("Dictionary",1046,G__G__Ged_293_0_61, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TH2Editor::Dictionary) ), 0);
15359 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15360 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);
15361 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);
15362 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_293_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15363 G__memfunc_setup("DeclFileName",1145,G__G__Ged_293_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Editor::DeclFileName) ), 0);
15364 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_293_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2Editor::ImplFileLine) ), 0);
15365 G__memfunc_setup("ImplFileName",1171,G__G__Ged_293_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TH2Editor::ImplFileName) ), 0);
15366 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_293_0_69, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TH2Editor::DeclFileLine) ), 0);
15367
15368 G__memfunc_setup("~TH2Editor", 947, G__G__Ged_293_0_70, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15369 G__tag_memfunc_reset();
15370 }
15371
15372 static void G__setup_memfuncTLineEditor(void) {
15373
15374 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TLineEditor));
15375 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15376 G__memfunc_setup("TLineEditor",1091,G__G__Ged_295_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TLineEditor), -1, 0, 5, 1, 1, 0,
15377 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15378 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15379 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15380 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);
15381 G__memfunc_setup("DoStartPoint",1227,G__G__Ged_295_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15382 G__memfunc_setup("DoEndPoint",980,G__G__Ged_295_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15383 G__memfunc_setup("DoLineVertical",1397,G__G__Ged_295_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15384 G__memfunc_setup("DoLineHorizontal",1637,G__G__Ged_295_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15385 G__memfunc_setup("Class",502,G__G__Ged_295_0_8, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TLineEditor::Class) ), 0);
15386 G__memfunc_setup("Class_Name",982,G__G__Ged_295_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLineEditor::Class_Name) ), 0);
15387 G__memfunc_setup("Class_Version",1339,G__G__Ged_295_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TLineEditor::Class_Version) ), 0);
15388 G__memfunc_setup("Dictionary",1046,G__G__Ged_295_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TLineEditor::Dictionary) ), 0);
15389 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15390 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);
15391 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);
15392 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_295_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15393 G__memfunc_setup("DeclFileName",1145,G__G__Ged_295_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLineEditor::DeclFileName) ), 0);
15394 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_295_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLineEditor::ImplFileLine) ), 0);
15395 G__memfunc_setup("ImplFileName",1171,G__G__Ged_295_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TLineEditor::ImplFileName) ), 0);
15396 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_295_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TLineEditor::DeclFileLine) ), 0);
15397
15398 G__memfunc_setup("~TLineEditor", 1217, G__G__Ged_295_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15399 G__tag_memfunc_reset();
15400 }
15401
15402 static void G__setup_memfuncTPadEditor(void) {
15403
15404 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TPadEditor));
15405 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15406 G__memfunc_setup("TPadEditor",976,G__G__Ged_297_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TPadEditor), -1, 0, 5, 1, 1, 0,
15407 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15408 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15409 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15410 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);
15411 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);
15412 G__memfunc_setup("DoEditable",973,G__G__Ged_297_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15413 G__memfunc_setup("DoCrosshair",1121,G__G__Ged_297_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15414 G__memfunc_setup("DoFixedAspectRatio",1794,G__G__Ged_297_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15415 G__memfunc_setup("DoGridX",657,G__G__Ged_297_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15416 G__memfunc_setup("DoGridY",658,G__G__Ged_297_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15417 G__memfunc_setup("DoLogX",557,G__G__Ged_297_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15418 G__memfunc_setup("DoLogY",558,G__G__Ged_297_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15419 G__memfunc_setup("DoLogZ",559,G__G__Ged_297_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15420 G__memfunc_setup("DoTickX",662,G__G__Ged_297_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15421 G__memfunc_setup("DoTickY",663,G__G__Ged_297_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15422 G__memfunc_setup("DoBorderMode",1174,G__G__Ged_297_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15423 G__memfunc_setup("DoBorderSize",1196,G__G__Ged_297_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 1);
15424 G__memfunc_setup("Class",502,G__G__Ged_297_0_17, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPadEditor::Class) ), 0);
15425 G__memfunc_setup("Class_Name",982,G__G__Ged_297_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPadEditor::Class_Name) ), 0);
15426 G__memfunc_setup("Class_Version",1339,G__G__Ged_297_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPadEditor::Class_Version) ), 0);
15427 G__memfunc_setup("Dictionary",1046,G__G__Ged_297_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPadEditor::Dictionary) ), 0);
15428 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15429 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);
15430 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);
15431 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_297_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15432 G__memfunc_setup("DeclFileName",1145,G__G__Ged_297_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPadEditor::DeclFileName) ), 0);
15433 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_297_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPadEditor::ImplFileLine) ), 0);
15434 G__memfunc_setup("ImplFileName",1171,G__G__Ged_297_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPadEditor::ImplFileName) ), 0);
15435 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_297_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPadEditor::DeclFileLine) ), 0);
15436
15437 G__memfunc_setup("~TPadEditor", 1102, G__G__Ged_297_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15438 G__tag_memfunc_reset();
15439 }
15440
15441 static void G__setup_memfuncTPaveStatsEditor(void) {
15442
15443 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor));
15444 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15445 G__memfunc_setup("TPaveStatsEditor",1622,G__G__Ged_299_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TPaveStatsEditor), -1, 0, 5, 1, 1, 0,
15446 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15447 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15448 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15449 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);
15450 G__memfunc_setup("DoStatOptions",1339,G__G__Ged_299_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15451 G__memfunc_setup("DoFitOptions",1218,G__G__Ged_299_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15452 G__memfunc_setup("SetValuesON",1081,G__G__Ged_299_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15453 G__memfunc_setup("Class",502,G__G__Ged_299_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPaveStatsEditor::Class) ), 0);
15454 G__memfunc_setup("Class_Name",982,G__G__Ged_299_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStatsEditor::Class_Name) ), 0);
15455 G__memfunc_setup("Class_Version",1339,G__G__Ged_299_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPaveStatsEditor::Class_Version) ), 0);
15456 G__memfunc_setup("Dictionary",1046,G__G__Ged_299_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPaveStatsEditor::Dictionary) ), 0);
15457 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15458 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);
15459 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);
15460 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_299_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15461 G__memfunc_setup("DeclFileName",1145,G__G__Ged_299_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStatsEditor::DeclFileName) ), 0);
15462 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_299_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveStatsEditor::ImplFileLine) ), 0);
15463 G__memfunc_setup("ImplFileName",1171,G__G__Ged_299_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPaveStatsEditor::ImplFileName) ), 0);
15464 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_299_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPaveStatsEditor::DeclFileLine) ), 0);
15465
15466 G__memfunc_setup("~TPaveStatsEditor", 1748, G__G__Ged_299_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15467 G__tag_memfunc_reset();
15468 }
15469
15470 static void G__setup_memfuncTPieEditor(void) {
15471
15472 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TPieEditor));
15473 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
15474 G__memfunc_setup("BuildFontSizeComboBox",2107,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 3, 2, 0,
15475 "U 'TGFrame' - 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
15476 G__memfunc_setup("TPieEditor",985,G__G__Ged_301_0_3, 105, G__get_linked_tagnum(&G__G__GedLN_TPieEditor), -1, 0, 5, 1, 1, 0,
15477 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15478 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15479 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15480 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
15481 G__memfunc_setup("ActivateBaseClassEditors",2428,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TClass' - 0 - -", (char*)NULL, (void*) NULL, 1);
15482 G__memfunc_setup("DoShape",676,G__G__Ged_301_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15483 G__memfunc_setup("DoMarkerOnOff",1261,G__G__Ged_301_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - on", (char*)NULL, (void*) NULL, 1);
15484 G__memfunc_setup("DoTitle",693,G__G__Ged_301_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - text", (char*)NULL, (void*) NULL, 1);
15485 G__memfunc_setup("DoGraphLineWidth",1581,G__G__Ged_301_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15486 G__memfunc_setup("DoChange3DAngle",1367,G__G__Ged_301_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15487 G__memfunc_setup("DoTextChange",1182,G__G__Ged_301_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15488 G__memfunc_setup("Class",502,G__G__Ged_301_0_12, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPieEditor::Class) ), 0);
15489 G__memfunc_setup("Class_Name",982,G__G__Ged_301_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieEditor::Class_Name) ), 0);
15490 G__memfunc_setup("Class_Version",1339,G__G__Ged_301_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPieEditor::Class_Version) ), 0);
15491 G__memfunc_setup("Dictionary",1046,G__G__Ged_301_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPieEditor::Dictionary) ), 0);
15492 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15493 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);
15494 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);
15495 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_301_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15496 G__memfunc_setup("DeclFileName",1145,G__G__Ged_301_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieEditor::DeclFileName) ), 0);
15497 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_301_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieEditor::ImplFileLine) ), 0);
15498 G__memfunc_setup("ImplFileName",1171,G__G__Ged_301_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieEditor::ImplFileName) ), 0);
15499 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_301_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieEditor::DeclFileLine) ), 0);
15500
15501 G__memfunc_setup("~TPieEditor", 1111, G__G__Ged_301_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15502 G__tag_memfunc_reset();
15503 }
15504
15505 static void G__setup_memfuncTPieSliceEditor(void) {
15506
15507 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor));
15508 G__memfunc_setup("ConnectSignals2Slots",2018,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
15509 G__memfunc_setup("TPieSliceEditor",1481,G__G__Ged_303_0_2, 105, G__get_linked_tagnum(&G__G__GedLN_TPieSliceEditor), -1, 0, 5, 1, 1, 0,
15510 "U 'TGWindow' - 10 '0' p i - 'Int_t' 0 '140' width "
15511 "i - 'Int_t' 0 '30' height h - 'UInt_t' 0 'kChildFrame' options "
15512 "k - 'Pixel_t' 0 'GetDefaultFrameBackground()' back", (char*)NULL, (void*) NULL, 0);
15513 G__memfunc_setup("SetModel",797,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - -", (char*)NULL, (void*) NULL, 1);
15514 G__memfunc_setup("DoTitle",693,G__G__Ged_303_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
15515 G__memfunc_setup("DoValue",688,G__G__Ged_303_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15516 G__memfunc_setup("DoOffset",794,G__G__Ged_303_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15517 G__memfunc_setup("Class",502,G__G__Ged_303_0_7, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPieSliceEditor::Class) ), 0);
15518 G__memfunc_setup("Class_Name",982,G__G__Ged_303_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSliceEditor::Class_Name) ), 0);
15519 G__memfunc_setup("Class_Version",1339,G__G__Ged_303_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPieSliceEditor::Class_Version) ), 0);
15520 G__memfunc_setup("Dictionary",1046,G__G__Ged_303_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPieSliceEditor::Dictionary) ), 0);
15521 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15522 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);
15523 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);
15524 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_303_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15525 G__memfunc_setup("DeclFileName",1145,G__G__Ged_303_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSliceEditor::DeclFileName) ), 0);
15526 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_303_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieSliceEditor::ImplFileLine) ), 0);
15527 G__memfunc_setup("ImplFileName",1171,G__G__Ged_303_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPieSliceEditor::ImplFileName) ), 0);
15528 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_303_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPieSliceEditor::DeclFileLine) ), 0);
15529
15530 G__memfunc_setup("~TPieSliceEditor", 1607, G__G__Ged_303_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15531 G__tag_memfunc_reset();
15532 }
15533
15534 static void G__setup_memfuncTStyleManager(void) {
15535
15536 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleManager));
15537 G__memfunc_setup("AddMenus",785,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - p", (char*)NULL, (void*) NULL, 0);
15538 G__memfunc_setup("DoNew",477,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15539 G__memfunc_setup("DoDelete",774,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15540 G__memfunc_setup("DoRename",779,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15541 G__memfunc_setup("DoExport",821,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15542 G__memfunc_setup("DoExit",589,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15543 G__memfunc_setup("DoHelp",572,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
15544 G__memfunc_setup("DoImportCanvas",1418,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15545 G__memfunc_setup("CreateMacro",1094,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15546 G__memfunc_setup("AddToolbar",988,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - p", (char*)NULL, (void*) NULL, 0);
15547 G__memfunc_setup("AddTopLevelInterface",1989,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - cf", (char*)NULL, (void*) NULL, 0);
15548 G__memfunc_setup("UpdateStatusBar",1532,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15549 G__memfunc_setup("UpdateEditor",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - tabNum", (char*)NULL, (void*) NULL, 0);
15550 G__memfunc_setup("ConnectAll",995,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15551 G__memfunc_setup("DisconnectAll",1315,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15552 G__memfunc_setup("ConnectEditor",1329,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - tabNum", (char*)NULL, (void*) NULL, 0);
15553 G__memfunc_setup("DisconnectEditor",1649,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - tabNum", (char*)NULL, (void*) NULL, 0);
15554 G__memfunc_setup("DoEditor",794,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
15555 G__memfunc_setup("AddEdition",981,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - p", (char*)NULL, (void*) NULL, 0);
15556 G__memfunc_setup("CreateTabGeneral",1577,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15557 G__memfunc_setup("AddGeneralLine",1359,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15558 G__memfunc_setup("AddGeneralFill",1358,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15559 G__memfunc_setup("AddGeneralText",1388,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15560 G__memfunc_setup("AddGeneralMarker",1577,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15561 G__memfunc_setup("CreateTabCanvas",1479,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15562 G__memfunc_setup("AddCanvasFill",1260,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15563 G__memfunc_setup("AddCanvasGeometry",1713,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15564 G__memfunc_setup("AddCanvasBorder",1475,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15565 G__memfunc_setup("AddCanvasDate",1251,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15566 G__memfunc_setup("CreateTabPad",1152,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15567 G__memfunc_setup("AddPadMargin",1148,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15568 G__memfunc_setup("AddPadBorder",1148,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15569 G__memfunc_setup("AddPadFill",933,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15570 G__memfunc_setup("AddPadTicks",1052,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15571 G__memfunc_setup("AddPadGrid",932,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15572 G__memfunc_setup("CreateTabHistos",1509,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15573 G__memfunc_setup("CreateTabHistosHistos",2143,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15574 G__memfunc_setup("AddHistosHistosFill",1924,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15575 G__memfunc_setup("AddHistosHistosLine",1925,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15576 G__memfunc_setup("AddHistosHistosBar",1810,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15577 G__memfunc_setup("AddHistosHistosContours",2394,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15578 G__memfunc_setup("AddHistosHistosAxis",1938,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15579 G__memfunc_setup("AddHistosHistosLegoInnerR",2514,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15580 G__memfunc_setup("CreateTabHistosFrames",2115,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15581 G__memfunc_setup("AddHistosFramesFill",1896,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15582 G__memfunc_setup("AddHistosFramesLine",1897,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15583 G__memfunc_setup("AddHistosFramesBorder",2111,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15584 G__memfunc_setup("CreateTabHistosGraphs",2122,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15585 G__memfunc_setup("AddHistosGraphsLine",1904,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15586 G__memfunc_setup("AddHistosGraphsBorder",2118,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15587 G__memfunc_setup("AddHistosGraphsErrors",2149,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15588 G__memfunc_setup("CreateTabAxis",1280,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15589 G__memfunc_setup("CreateTabAxisX",1368,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15590 G__memfunc_setup("AddAxisXTitle",1272,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15591 G__memfunc_setup("AddAxisXLine",1150,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15592 G__memfunc_setup("AddAxisXLabels",1353,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15593 G__memfunc_setup("AddAxisXDivisions",1710,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15594 G__memfunc_setup("CreateTabAxisY",1369,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15595 G__memfunc_setup("AddAxisYTitle",1273,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15596 G__memfunc_setup("AddAxisYLine",1151,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15597 G__memfunc_setup("AddAxisYLabels",1354,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15598 G__memfunc_setup("AddAxisYDivisions",1711,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15599 G__memfunc_setup("CreateTabAxisZ",1370,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15600 G__memfunc_setup("AddAxisZTitle",1274,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15601 G__memfunc_setup("AddAxisZLine",1152,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15602 G__memfunc_setup("AddAxisZLabels",1355,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15603 G__memfunc_setup("AddAxisZDivisions",1712,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15604 G__memfunc_setup("CreateTabTitle",1389,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15605 G__memfunc_setup("AddTitleFill",1170,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15606 G__memfunc_setup("AddTitleBorderSize",1796,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15607 G__memfunc_setup("AddTitleText",1200,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15608 G__memfunc_setup("AddTitleGeometry",1623,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15609 G__memfunc_setup("CreateTabStats",1402,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15610 G__memfunc_setup("AddStatsFill",1183,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15611 G__memfunc_setup("AddStatsText",1213,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15612 G__memfunc_setup("AddStatsGeometry",1636,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15613 G__memfunc_setup("AddStatsStats",1319,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15614 G__memfunc_setup("AddStatsFit",1083,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15615 G__memfunc_setup("CreateTabPsPdf",1352,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - tab", (char*)NULL, (void*) NULL, 0);
15616 G__memfunc_setup("AddPsPdfHeader",1327,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15617 G__memfunc_setup("AddPsPdfTitle",1256,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15618 G__memfunc_setup("AddPsPdfColorModel",1750,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15619 G__memfunc_setup("AddPsPdfPaperSize",1657,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15620 G__memfunc_setup("AddPsPdfLineScale",1622,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TGCompositeFrame' - 0 - f", (char*)NULL, (void*) NULL, 0);
15621 G__memfunc_setup("AddTitle",779,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0,
15622 "U 'TGCompositeFrame' - 0 - f C - - 10 - s", (char*)NULL, (void*) NULL, 0);
15623 G__memfunc_setup("AddColorEntry",1306,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGColorSelect), -1, 0, 2, 1, 4, 0,
15624 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15625 G__memfunc_setup("AddFillStyleEntry",1715,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGedPatternSelect), -1, 0, 2, 1, 4, 0,
15626 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15627 G__memfunc_setup("AddMarkerStyleEntry",1934,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGedMarkerSelect), -1, 0, 2, 1, 4, 0,
15628 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15629 G__memfunc_setup("AddMarkerSizeEntry",1816,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 4, 0,
15630 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15631 G__memfunc_setup("AddNumberEntry",1412,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGNumberEntry), -1, 0, 13, 1, 4, 0,
15632 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - e1 "
15633 "i - 'Int_t' 0 - e2 i - 'Int_t' 0 - e3 "
15634 "i - 'Int_t' 0 - id C - - 10 - s "
15635 "d - 'Double_t' 0 - init i - 'Int_t' 0 - digits "
15636 "i 'TGNumberFormat::EStyle' - 0 - nfS i 'TGNumberFormat::EAttribute' - 0 - nfA "
15637 "i 'TGNumberFormat::ELimit' - 0 - nfL d - 'Double_t' 0 - min "
15638 "d - 'Double_t' 0 - max", (char*)NULL, (void*) NULL, 0);
15639 G__memfunc_setup("AddLineWidthEntry",1699,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGLineWidthComboBox), -1, 0, 2, 1, 4, 0,
15640 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15641 G__memfunc_setup("AddLineStyleEntry",1716,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGLineStyleComboBox), -1, 0, 2, 1, 4, 0,
15642 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15643 G__memfunc_setup("AddTextButton",1322,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGTextButton), -1, 0, 3, 1, 4, 0,
15644 "U 'TGCompositeFrame' - 0 - f C - - 10 - s "
15645 "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15646 G__memfunc_setup("AddFontTypeEntry",1620,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGFontTypeComboBox), -1, 0, 2, 1, 4, 0,
15647 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15648 G__memfunc_setup("AddTextAlignEntry",1707,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 4, 0,
15649 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15650 G__memfunc_setup("AddBorderModeEntry",1790,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGButtonGroup), -1, 0, 4, 1, 4, 0,
15651 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id1 "
15652 "i - 'Int_t' 0 - id2 i - 'Int_t' 0 - id3", (char*)NULL, (void*) NULL, 0);
15653 G__memfunc_setup("AddDateFormatEntry",1794,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 4, 0,
15654 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15655 G__memfunc_setup("AddCheckButton",1379,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGCheckButton), -1, 0, 5, 1, 4, 0,
15656 "U 'TGCompositeFrame' - 0 - f C - - 10 - s "
15657 "i - 'Int_t' 0 - id i - 'Int_t' 0 '0' e1 "
15658 "i - 'Int_t' 0 '2' e2", (char*)NULL, (void*) NULL, 0);
15659 G__memfunc_setup("AddTextEntry",1216,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGTextEntry), -1, 0, 3, 1, 4, 0,
15660 "U 'TGCompositeFrame' - 0 - f C - - 10 - s "
15661 "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15662 G__memfunc_setup("AddPaperSizeEntry",1710,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__GedLN_TGComboBox), -1, 0, 2, 1, 4, 0,
15663 "U 'TGCompositeFrame' - 0 - f i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
15664 G__memfunc_setup("TStyleManager",1312,G__G__Ged_305_0_101, 105, G__get_linked_tagnum(&G__G__GedLN_TStyleManager), -1, 0, 1, 1, 1, 0, "U 'TGWindow' - 10 - -", (char*)NULL, (void*) NULL, 0);
15665 G__memfunc_setup("Show",417,G__G__Ged_305_0_102, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyleManager::Show) ), 0);
15666 G__memfunc_setup("Terminate",937,G__G__Ged_305_0_103, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyleManager::Terminate) ), 0);
15667 G__memfunc_setup("GetSM",448,G__G__Ged_305_0_104, 85, G__get_linked_tagnum(&G__G__GedLN_TStyleManager), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TStyleManager*& (*)())(&TStyleManager::GetSM) ), 0);
15668 G__memfunc_setup("Init",404,G__G__Ged_305_0_105, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15669 G__memfunc_setup("Hide",378,G__G__Ged_305_0_106, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15670 G__memfunc_setup("SetCurSelStyle",1419,G__G__Ged_305_0_107, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TStyle' - 0 - style", (char*)NULL, (void*) NULL, 0);
15671 G__memfunc_setup("SetLastChoice",1291,G__G__Ged_305_0_108, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - choice", (char*)NULL, (void*) NULL, 0);
15672 G__memfunc_setup("DoMenu",584,G__G__Ged_305_0_109, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - menuID", "SLOT", (void*) NULL, 0);
15673 G__memfunc_setup("DoImportMacro",1312,G__G__Ged_305_0_110, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - create", "SLOT", (void*) NULL, 0);
15674 G__memfunc_setup("DoListSelect",1199,G__G__Ged_305_0_111, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15675 G__memfunc_setup("DoRealTime",966,G__G__Ged_305_0_112, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15676 G__memfunc_setup("DoPreview",917,G__G__Ged_305_0_113, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15677 G__memfunc_setup("DoPreviewClosed",1519,G__G__Ged_305_0_114, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15678 G__memfunc_setup("DoMakeDefault",1270,G__G__Ged_305_0_115, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15679 G__memfunc_setup("DoApplyOnSelect",1494,G__G__Ged_305_0_116, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", "SLOT", (void*) NULL, 0);
15680 G__memfunc_setup("DoApplyOn",886,G__G__Ged_305_0_117, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15681 G__memfunc_setup("DoMoreLess",989,G__G__Ged_305_0_118, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15682 G__memfunc_setup("DoEditionUpdatePreview",2244,G__G__Ged_305_0_119, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15683 G__memfunc_setup("DoChangeTab",1040,G__G__Ged_305_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", "SLOT", (void*) NULL, 0);
15684 G__memfunc_setup("DoChangeAxisTab",1445,G__G__Ged_305_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", "SLOT", (void*) NULL, 0);
15685 G__memfunc_setup("BuildList",908,G__G__Ged_305_0_122, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TStyle' - 0 '0' style", (char*)NULL, (void*) NULL, 0);
15686 G__memfunc_setup("DoSelectNoCanvas",1580,G__G__Ged_305_0_123, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15687 G__memfunc_setup("DoSelectCanvas",1391,G__G__Ged_305_0_124, 121, -1, -1, 0, 3, 1, 1, 0,
15688 "U 'TVirtualPad' - 0 - pad U 'TObject' - 0 - obj "
15689 "i - 'Int_t' 0 - mouseButton", "SLOT", (void*) NULL, 0);
15690 G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 1);
15691 G__memfunc_setup("ModFillColor",1190,G__G__Ged_305_0_126, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15692 G__memfunc_setup("ModFillStyle",1208,G__G__Ged_305_0_127, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15693 G__memfunc_setup("ModHatchesLineWidth",1896,G__G__Ged_305_0_128, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15694 G__memfunc_setup("ModHatchesSpacing",1701,G__G__Ged_305_0_129, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15695 G__memfunc_setup("ModMarkerColor",1409,G__G__Ged_305_0_130, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15696 G__memfunc_setup("ModMarkerStyle",1427,G__G__Ged_305_0_131, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15697 G__memfunc_setup("ModMarkerSize",1309,G__G__Ged_305_0_132, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15698 G__memfunc_setup("ModScreenFactor",1503,G__G__Ged_305_0_133, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15699 G__memfunc_setup("ModLineColor",1191,G__G__Ged_305_0_134, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15700 G__memfunc_setup("ModLineWidth",1192,G__G__Ged_305_0_135, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15701 G__memfunc_setup("ModLineStyle",1209,G__G__Ged_305_0_136, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15702 G__memfunc_setup("ModLineStyleEdit",1599,G__G__Ged_305_0_137, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15703 G__memfunc_setup("ModTextColor",1220,G__G__Ged_305_0_138, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15704 G__memfunc_setup("ModTextSize",1120,G__G__Ged_305_0_139, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15705 G__memfunc_setup("ModTextSizeInPixels",1932,G__G__Ged_305_0_140, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15706 G__memfunc_setup("ModTextFont",1116,G__G__Ged_305_0_141, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15707 G__memfunc_setup("ModTextAlign",1200,G__G__Ged_305_0_142, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15708 G__memfunc_setup("ModTextAngle",1196,G__G__Ged_305_0_143, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15709 G__memfunc_setup("ModCanvasColor",1403,G__G__Ged_305_0_144, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15710 G__memfunc_setup("ModCanvasDefX",1251,G__G__Ged_305_0_145, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15711 G__memfunc_setup("ModCanvasDefY",1252,G__G__Ged_305_0_146, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15712 G__memfunc_setup("ModCanvasDefW",1250,G__G__Ged_305_0_147, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15713 G__memfunc_setup("ModCanvasDefH",1235,G__G__Ged_305_0_148, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15714 G__memfunc_setup("ModCanvasBorderMode",1887,G__G__Ged_305_0_149, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15715 G__memfunc_setup("ModCanvasBorderSize",1909,G__G__Ged_305_0_150, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15716 G__memfunc_setup("ModOptDateBool",1373,G__G__Ged_305_0_151, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15717 G__memfunc_setup("ModAttDateTextColor",1899,G__G__Ged_305_0_152, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15718 G__memfunc_setup("ModAttDateTextSize",1799,G__G__Ged_305_0_153, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15719 G__memfunc_setup("ModAttDateTextSizeInPixels",2611,G__G__Ged_305_0_154, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15720 G__memfunc_setup("ModOptDateFormat",1594,G__G__Ged_305_0_155, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15721 G__memfunc_setup("ModAttDateTextFont",1795,G__G__Ged_305_0_156, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15722 G__memfunc_setup("ModAttDateTextAngle",1875,G__G__Ged_305_0_157, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15723 G__memfunc_setup("ModAttDateTextAlign",1879,G__G__Ged_305_0_158, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15724 G__memfunc_setup("ModDateX",758,G__G__Ged_305_0_159, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15725 G__memfunc_setup("ModDateY",759,G__G__Ged_305_0_160, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15726 G__memfunc_setup("ModPadTopMargin",1478,G__G__Ged_305_0_161, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15727 G__memfunc_setup("ModPadBottomMargin",1800,G__G__Ged_305_0_162, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15728 G__memfunc_setup("ModPadLeftMargin",1566,G__G__Ged_305_0_163, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15729 G__memfunc_setup("ModPadRightMargin",1681,G__G__Ged_305_0_164, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15730 G__memfunc_setup("ModPadBorderMode",1560,G__G__Ged_305_0_165, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15731 G__memfunc_setup("ModPadBorderSize",1582,G__G__Ged_305_0_166, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15732 G__memfunc_setup("ModPadColor",1076,G__G__Ged_305_0_167, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15733 G__memfunc_setup("ModPadTickX",1048,G__G__Ged_305_0_168, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15734 G__memfunc_setup("ModPadTickY",1049,G__G__Ged_305_0_169, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15735 G__memfunc_setup("ModPadGridX",1043,G__G__Ged_305_0_170, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15736 G__memfunc_setup("ModPadGridY",1044,G__G__Ged_305_0_171, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15737 G__memfunc_setup("ModGridColor",1189,G__G__Ged_305_0_172, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15738 G__memfunc_setup("ModGridWidth",1190,G__G__Ged_305_0_173, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15739 G__memfunc_setup("ModGridStyle",1207,G__G__Ged_305_0_174, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15740 G__memfunc_setup("ModHistFillColor",1598,G__G__Ged_305_0_175, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15741 G__memfunc_setup("ModHistFillStyle",1616,G__G__Ged_305_0_176, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15742 G__memfunc_setup("ModHistLineColor",1599,G__G__Ged_305_0_177, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15743 G__memfunc_setup("ModHistLineWidth",1600,G__G__Ged_305_0_178, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15744 G__memfunc_setup("ModHistLineStyle",1617,G__G__Ged_305_0_179, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15745 G__memfunc_setup("ModBarWidth",1077,G__G__Ged_305_0_180, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15746 G__memfunc_setup("ModBarOffset",1180,G__G__Ged_305_0_181, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15747 G__memfunc_setup("ModHistMinimumZero",1844,G__G__Ged_305_0_182, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15748 G__memfunc_setup("ModPaintTextFormat",1834,G__G__Ged_305_0_183, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15749 G__memfunc_setup("ModNumberContours",1766,G__G__Ged_305_0_184, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15750 G__memfunc_setup("ModLegoInnerR",1269,G__G__Ged_305_0_185, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15751 G__memfunc_setup("ModFrameFillColor",1681,G__G__Ged_305_0_186, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15752 G__memfunc_setup("ModFrameFillStyle",1699,G__G__Ged_305_0_187, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15753 G__memfunc_setup("ModFrameLineColor",1682,G__G__Ged_305_0_188, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15754 G__memfunc_setup("ModFrameLineWidth",1683,G__G__Ged_305_0_189, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15755 G__memfunc_setup("ModFrameLineStyle",1700,G__G__Ged_305_0_190, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15756 G__memfunc_setup("ModPaletteEdit",1397,G__G__Ged_305_0_191, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15757 G__memfunc_setup("ModFrameBorderMode",1774,G__G__Ged_305_0_192, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15758 G__memfunc_setup("ModFrameBorderSize",1796,G__G__Ged_305_0_193, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15759 G__memfunc_setup("ModFuncColor",1195,G__G__Ged_305_0_194, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15760 G__memfunc_setup("ModFuncWidth",1196,G__G__Ged_305_0_195, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15761 G__memfunc_setup("ModFuncStyle",1213,G__G__Ged_305_0_196, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15762 G__memfunc_setup("ModDrawBorder",1292,G__G__Ged_305_0_197, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15763 G__memfunc_setup("ModEndErrorSize",1500,G__G__Ged_305_0_198, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15764 G__memfunc_setup("ModErrorX",898,G__G__Ged_305_0_199, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15765 G__memfunc_setup("ModTimeOffset",1302,G__G__Ged_305_0_200, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15766 G__memfunc_setup("ModStripDecimals",1620,G__G__Ged_305_0_201, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15767 G__memfunc_setup("ModApplyOnXYZ",1262,G__G__Ged_305_0_202, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15768 G__memfunc_setup("ModXTitleSize",1301,G__G__Ged_305_0_203, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15769 G__memfunc_setup("ModXTitleSizeInPixels",2113,G__G__Ged_305_0_204, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15770 G__memfunc_setup("ModXTitleColor",1401,G__G__Ged_305_0_205, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15771 G__memfunc_setup("ModXTitleOffset",1505,G__G__Ged_305_0_206, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15772 G__memfunc_setup("ModXTitleFont",1297,G__G__Ged_305_0_207, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15773 G__memfunc_setup("ModXLabelSize",1267,G__G__Ged_305_0_208, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15774 G__memfunc_setup("ModXLabelSizeInPixels",2079,G__G__Ged_305_0_209, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15775 G__memfunc_setup("ModXLabelColor",1367,G__G__Ged_305_0_210, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15776 G__memfunc_setup("ModXLabelOffset",1471,G__G__Ged_305_0_211, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15777 G__memfunc_setup("ModXLabelFont",1263,G__G__Ged_305_0_212, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15778 G__memfunc_setup("ModXAxisColor",1292,G__G__Ged_305_0_213, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15779 G__memfunc_setup("ModXTickLength",1381,G__G__Ged_305_0_214, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15780 G__memfunc_setup("ModOptLogx",1005,G__G__Ged_305_0_215, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15781 G__memfunc_setup("ModXNdivisions",1438,G__G__Ged_305_0_216, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15782 G__memfunc_setup("ModYTitleSize",1302,G__G__Ged_305_0_217, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15783 G__memfunc_setup("ModYTitleSizeInPixels",2114,G__G__Ged_305_0_218, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15784 G__memfunc_setup("ModYTitleColor",1402,G__G__Ged_305_0_219, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15785 G__memfunc_setup("ModYTitleOffset",1506,G__G__Ged_305_0_220, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15786 G__memfunc_setup("ModYTitleFont",1298,G__G__Ged_305_0_221, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15787 G__memfunc_setup("ModYLabelSize",1268,G__G__Ged_305_0_222, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15788 G__memfunc_setup("ModYLabelSizeInPixels",2080,G__G__Ged_305_0_223, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15789 G__memfunc_setup("ModYLabelColor",1368,G__G__Ged_305_0_224, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15790 G__memfunc_setup("ModYLabelOffset",1472,G__G__Ged_305_0_225, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15791 G__memfunc_setup("ModYLabelFont",1264,G__G__Ged_305_0_226, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15792 G__memfunc_setup("ModYAxisColor",1293,G__G__Ged_305_0_227, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15793 G__memfunc_setup("ModYTickLength",1382,G__G__Ged_305_0_228, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15794 G__memfunc_setup("ModOptLogy",1006,G__G__Ged_305_0_229, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15795 G__memfunc_setup("ModYNdivisions",1439,G__G__Ged_305_0_230, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15796 G__memfunc_setup("ModZTitleSize",1303,G__G__Ged_305_0_231, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15797 G__memfunc_setup("ModZTitleSizeInPixels",2115,G__G__Ged_305_0_232, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15798 G__memfunc_setup("ModZTitleColor",1403,G__G__Ged_305_0_233, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15799 G__memfunc_setup("ModZTitleOffset",1507,G__G__Ged_305_0_234, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15800 G__memfunc_setup("ModZTitleFont",1299,G__G__Ged_305_0_235, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15801 G__memfunc_setup("ModZLabelSize",1269,G__G__Ged_305_0_236, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15802 G__memfunc_setup("ModZLabelSizeInPixels",2081,G__G__Ged_305_0_237, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15803 G__memfunc_setup("ModZLabelColor",1369,G__G__Ged_305_0_238, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15804 G__memfunc_setup("ModZLabelOffset",1473,G__G__Ged_305_0_239, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15805 G__memfunc_setup("ModZLabelFont",1265,G__G__Ged_305_0_240, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15806 G__memfunc_setup("ModZAxisColor",1294,G__G__Ged_305_0_241, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15807 G__memfunc_setup("ModZTickLength",1383,G__G__Ged_305_0_242, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15808 G__memfunc_setup("ModOptLogz",1007,G__G__Ged_305_0_243, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15809 G__memfunc_setup("ModZNdivisions",1440,G__G__Ged_305_0_244, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15810 G__memfunc_setup("ModOptTitle",1109,G__G__Ged_305_0_245, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15811 G__memfunc_setup("ModTitleFillColor",1704,G__G__Ged_305_0_246, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15812 G__memfunc_setup("ModTitleStyle",1331,G__G__Ged_305_0_247, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15813 G__memfunc_setup("ModTitleTextColor",1734,G__G__Ged_305_0_248, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15814 G__memfunc_setup("ModTitleFontSize",1620,G__G__Ged_305_0_249, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15815 G__memfunc_setup("ModTitleFontSizeInPixels",2432,G__G__Ged_305_0_250, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15816 G__memfunc_setup("ModTitleFont",1209,G__G__Ged_305_0_251, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15817 G__memfunc_setup("ModTitleAlign",1293,G__G__Ged_305_0_252, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15818 G__memfunc_setup("ModTitleBorderSize",1819,G__G__Ged_305_0_253, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15819 G__memfunc_setup("ModTitleX",890,G__G__Ged_305_0_254, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15820 G__memfunc_setup("ModTitleY",891,G__G__Ged_305_0_255, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15821 G__memfunc_setup("ModTitleW",889,G__G__Ged_305_0_256, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15822 G__memfunc_setup("ModTitleH",874,G__G__Ged_305_0_257, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15823 G__memfunc_setup("ModLegendBorderSize",1896,G__G__Ged_305_0_258, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15824 G__memfunc_setup("ModStatColor",1211,G__G__Ged_305_0_259, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", "SLOT", (void*) NULL, 0);
15825 G__memfunc_setup("ModStatStyle",1229,G__G__Ged_305_0_260, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Style_t' 0 - pattern", "SLOT", (void*) NULL, 0);
15826 G__memfunc_setup("ModStatTextColor",1632,G__G__Ged_305_0_261, 121, -1, -1, 0, 1, 1, 1, 0, "k - 'Pixel_t' 0 - color", "SLOT", (void*) NULL, 0);
15827 G__memfunc_setup("ModStatFontSize",1518,G__G__Ged_305_0_262, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15828 G__memfunc_setup("ModStatFontSizeInPixels",2330,G__G__Ged_305_0_263, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", "SLOT", (void*) NULL, 0);
15829 G__memfunc_setup("ModStatFont",1107,G__G__Ged_305_0_264, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15830 G__memfunc_setup("ModStatX",788,G__G__Ged_305_0_265, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15831 G__memfunc_setup("ModStatY",789,G__G__Ged_305_0_266, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15832 G__memfunc_setup("ModStatW",787,G__G__Ged_305_0_267, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15833 G__memfunc_setup("ModStatH",772,G__G__Ged_305_0_268, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15834 G__memfunc_setup("ModStatBorderSize",1717,G__G__Ged_305_0_269, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15835 G__memfunc_setup("ModOptStat",1007,G__G__Ged_305_0_270, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15836 G__memfunc_setup("ModStatFormat",1317,G__G__Ged_305_0_271, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - sformat", "SLOT", (void*) NULL, 0);
15837 G__memfunc_setup("ModOptFit",886,G__G__Ged_305_0_272, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15838 G__memfunc_setup("ModFitFormat",1196,G__G__Ged_305_0_273, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - fitformat", "SLOT", (void*) NULL, 0);
15839 G__memfunc_setup("ModHeaderPS",1036,G__G__Ged_305_0_274, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15840 G__memfunc_setup("ModTitlePS",965,G__G__Ged_305_0_275, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15841 G__memfunc_setup("ModColorModelPS",1459,G__G__Ged_305_0_276, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15842 G__memfunc_setup("ModLineScalePS",1331,G__G__Ged_305_0_277, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15843 G__memfunc_setup("ModPaperSizePredef",1801,G__G__Ged_305_0_278, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15844 G__memfunc_setup("ModPaperSizeXY",1380,G__G__Ged_305_0_279, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15845 G__memfunc_setup("Class",502,G__G__Ged_305_0_280, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStyleManager::Class) ), 0);
15846 G__memfunc_setup("Class_Name",982,G__G__Ged_305_0_281, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleManager::Class_Name) ), 0);
15847 G__memfunc_setup("Class_Version",1339,G__G__Ged_305_0_282, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStyleManager::Class_Version) ), 0);
15848 G__memfunc_setup("Dictionary",1046,G__G__Ged_305_0_283, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyleManager::Dictionary) ), 0);
15849 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15850 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);
15851 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);
15852 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_305_0_287, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15853 G__memfunc_setup("DeclFileName",1145,G__G__Ged_305_0_288, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleManager::DeclFileName) ), 0);
15854 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_305_0_289, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyleManager::ImplFileLine) ), 0);
15855 G__memfunc_setup("ImplFileName",1171,G__G__Ged_305_0_290, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleManager::ImplFileName) ), 0);
15856 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_305_0_291, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyleManager::DeclFileLine) ), 0);
15857
15858 G__memfunc_setup("~TStyleManager", 1438, G__G__Ged_305_0_292, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15859 G__tag_memfunc_reset();
15860 }
15861
15862 static void G__setup_memfuncTStyleDialog(void) {
15863
15864 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TStyleDialog));
15865 G__memfunc_setup("TStyleDialog",1205,G__G__Ged_306_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TStyleDialog), -1, 0, 4, 1, 1, 0,
15866 "U 'TStyleManager' - 0 - sm U 'TStyle' - 0 - cur "
15867 "i - 'Int_t' 0 - mode U 'TVirtualPad' - 0 '0' currentPad", (char*)NULL, (void*) NULL, 0);
15868 G__memfunc_setup("DoCloseWindow",1313,G__G__Ged_306_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15869 G__memfunc_setup("DoCancel",761,G__G__Ged_306_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15870 G__memfunc_setup("DoOK",333,G__G__Ged_306_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15871 G__memfunc_setup("DoUpdate",790,G__G__Ged_306_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "SLOT", (void*) NULL, 0);
15872 G__memfunc_setup("Class",502,G__G__Ged_306_0_6, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStyleDialog::Class) ), 0);
15873 G__memfunc_setup("Class_Name",982,G__G__Ged_306_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleDialog::Class_Name) ), 0);
15874 G__memfunc_setup("Class_Version",1339,G__G__Ged_306_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStyleDialog::Class_Version) ), 0);
15875 G__memfunc_setup("Dictionary",1046,G__G__Ged_306_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStyleDialog::Dictionary) ), 0);
15876 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15877 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);
15878 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);
15879 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_306_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15880 G__memfunc_setup("DeclFileName",1145,G__G__Ged_306_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleDialog::DeclFileName) ), 0);
15881 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_306_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyleDialog::ImplFileLine) ), 0);
15882 G__memfunc_setup("ImplFileName",1171,G__G__Ged_306_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStyleDialog::ImplFileName) ), 0);
15883 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_306_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStyleDialog::DeclFileLine) ), 0);
15884
15885 G__memfunc_setup("~TStyleDialog", 1331, G__G__Ged_306_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15886 G__tag_memfunc_reset();
15887 }
15888
15889 static void G__setup_memfuncTStylePreview(void) {
15890
15891 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__GedLN_TStylePreview));
15892 G__memfunc_setup("TStylePreview",1351,G__G__Ged_323_0_1, 105, G__get_linked_tagnum(&G__G__GedLN_TStylePreview), -1, 0, 3, 1, 1, 0,
15893 "U 'TGWindow' - 10 - p U 'TStyle' - 0 - style "
15894 "U 'TVirtualPad' - 0 - currentPad", (char*)NULL, (void*) NULL, 0);
15895 G__memfunc_setup("Update",611,G__G__Ged_323_0_2, 121, -1, -1, 0, 2, 1, 1, 0,
15896 "U 'TStyle' - 0 - style U 'TVirtualPad' - 0 - pad", (char*)NULL, (void*) NULL, 0);
15897 G__memfunc_setup("MapTheWindow",1207,G__G__Ged_323_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15898 G__memfunc_setup("GetMainCanvas",1281,G__G__Ged_323_0_4, 85, G__get_linked_tagnum(&G__G__GedLN_TCanvas), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15899 G__memfunc_setup("Class",502,G__G__Ged_323_0_5, 85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStylePreview::Class) ), 0);
15900 G__memfunc_setup("Class_Name",982,G__G__Ged_323_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStylePreview::Class_Name) ), 0);
15901 G__memfunc_setup("Class_Version",1339,G__G__Ged_323_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStylePreview::Class_Version) ), 0);
15902 G__memfunc_setup("Dictionary",1046,G__G__Ged_323_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStylePreview::Dictionary) ), 0);
15903 G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__GedLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15904 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);
15905 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);
15906 G__memfunc_setup("StreamerNVirtual",1656,G__G__Ged_323_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
15907 G__memfunc_setup("DeclFileName",1145,G__G__Ged_323_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStylePreview::DeclFileName) ), 0);
15908 G__memfunc_setup("ImplFileLine",1178,G__G__Ged_323_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStylePreview::ImplFileLine) ), 0);
15909 G__memfunc_setup("ImplFileName",1171,G__G__Ged_323_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStylePreview::ImplFileName) ), 0);
15910 G__memfunc_setup("DeclFileLine",1152,G__G__Ged_323_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStylePreview::DeclFileLine) ), 0);
15911
15912 G__memfunc_setup("~TStylePreview", 1477, G__G__Ged_323_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15913 G__tag_memfunc_reset();
15914 }
15915
15916
15917
15918
15919
15920 extern "C" void G__cpp_setup_memfuncG__Ged() {
15921 }
15922
15923
15924
15925
15926 static void G__cpp_setup_global0() {
15927
15928
15929 G__resetplocal();
15930
15931 }
15932
15933 static void G__cpp_setup_global1() {
15934 }
15935
15936 static void G__cpp_setup_global2() {
15937 }
15938
15939 static void G__cpp_setup_global3() {
15940 }
15941
15942 static void G__cpp_setup_global4() {
15943 }
15944
15945 static void G__cpp_setup_global5() {
15946
15947 G__resetglobalenv();
15948 }
15949 extern "C" void G__cpp_setup_globalG__Ged() {
15950 G__cpp_setup_global0();
15951 G__cpp_setup_global1();
15952 G__cpp_setup_global2();
15953 G__cpp_setup_global3();
15954 G__cpp_setup_global4();
15955 G__cpp_setup_global5();
15956 }
15957
15958
15959
15960
15961 static void G__cpp_setup_func0() {
15962 G__lastifuncposition();
15963
15964 }
15965
15966 static void G__cpp_setup_func1() {
15967 }
15968
15969 static void G__cpp_setup_func2() {
15970 }
15971
15972 static void G__cpp_setup_func3() {
15973
15974 G__resetifuncposition();
15975 }
15976
15977 extern "C" void G__cpp_setup_funcG__Ged() {
15978 G__cpp_setup_func0();
15979 G__cpp_setup_func1();
15980 G__cpp_setup_func2();
15981 G__cpp_setup_func3();
15982 }
15983
15984
15985
15986
15987
15988 G__linked_taginfo G__G__GedLN_TClass = { "TClass" , 99 , -1 };
15989 G__linked_taginfo G__G__GedLN_TBuffer = { "TBuffer" , 99 , -1 };
15990 G__linked_taginfo G__G__GedLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
15991 G__linked_taginfo G__G__GedLN_TObject = { "TObject" , 99 , -1 };
15992 G__linked_taginfo G__G__GedLN_TString = { "TString" , 99 , -1 };
15993 G__linked_taginfo G__G__GedLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
15994 G__linked_taginfo G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
15995 G__linked_taginfo G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
15996 G__linked_taginfo G__G__GedLN_TList = { "TList" , 99 , -1 };
15997 G__linked_taginfo G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
15998 G__linked_taginfo G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
15999 G__linked_taginfo G__G__GedLN_Event_t = { "Event_t" , 115 , -1 };
16000 G__linked_taginfo G__G__GedLN_TGObject = { "TGObject" , 99 , -1 };
16001 G__linked_taginfo G__G__GedLN_TQObject = { "TQObject" , 99 , -1 };
16002 G__linked_taginfo G__G__GedLN_TGWindow = { "TGWindow" , 99 , -1 };
16003 G__linked_taginfo G__G__GedLN_TGPicture = { "TGPicture" , 99 , -1 };
16004 G__linked_taginfo G__G__GedLN_TGGC = { "TGGC" , 99 , -1 };
16005 G__linked_taginfo G__G__GedLN_TAttLine = { "TAttLine" , 99 , -1 };
16006 G__linked_taginfo G__G__GedLN_TAttFill = { "TAttFill" , 99 , -1 };
16007 G__linked_taginfo G__G__GedLN_TAttText = { "TAttText" , 99 , -1 };
16008 G__linked_taginfo G__G__GedLN_TAttMarker = { "TAttMarker" , 99 , -1 };
16009 G__linked_taginfo G__G__GedLN_TGDimension = { "TGDimension" , 99 , -1 };
16010 G__linked_taginfo G__G__GedLN_TGFrame = { "TGFrame" , 99 , -1 };
16011 G__linked_taginfo G__G__GedLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 };
16012 G__linked_taginfo G__G__GedLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 };
16013 G__linked_taginfo G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
16014 G__linked_taginfo G__G__GedLN_TGTextButton = { "TGTextButton" , 99 , -1 };
16015 G__linked_taginfo G__G__GedLN_TGVerticalFrame = { "TGVerticalFrame" , 99 , -1 };
16016 G__linked_taginfo G__G__GedLN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 };
16017 G__linked_taginfo G__G__GedLN_TGMainFrame = { "TGMainFrame" , 99 , -1 };
16018 G__linked_taginfo G__G__GedLN_TGTransientFrame = { "TGTransientFrame" , 99 , -1 };
16019 G__linked_taginfo G__G__GedLN_TVirtualPad = { "TVirtualPad" , 99 , -1 };
16020 G__linked_taginfo G__G__GedLN_TCanvas = { "TCanvas" , 99 , -1 };
16021 G__linked_taginfo G__G__GedLN_TGLabel = { "TGLabel" , 99 , -1 };
16022 G__linked_taginfo G__G__GedLN_TGToolTip = { "TGToolTip" , 99 , -1 };
16023 G__linked_taginfo G__G__GedLN_TGTab = { "TGTab" , 99 , -1 };
16024 G__linked_taginfo G__G__GedLN_TGedEditor = { "TGedEditor" , 99 , -1 };
16025 G__linked_taginfo G__G__GedLN_TGedFrame = { "TGedFrame" , 99 , -1 };
16026 G__linked_taginfo G__G__GedLN_TGedFramecLcLTGedSubFrame = { "TGedFrame::TGedSubFrame" , 99 , -1 };
16027 G__linked_taginfo G__G__GedLN_TGedNameFrame = { "TGedNameFrame" , 99 , -1 };
16028 G__linked_taginfo G__G__GedLN_TGComboBox = { "TGComboBox" , 99 , -1 };
16029 G__linked_taginfo G__G__GedLN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 };
16030 G__linked_taginfo G__G__GedLN_TArrow = { "TArrow" , 99 , -1 };
16031 G__linked_taginfo G__G__GedLN_TArrowEditor = { "TArrowEditor" , 99 , -1 };
16032 G__linked_taginfo G__G__GedLN_TGColorSelect = { "TGColorSelect" , 99 , -1 };
16033 G__linked_taginfo G__G__GedLN_TGedPatternSelect = { "TGedPatternSelect" , 99 , -1 };
16034 G__linked_taginfo G__G__GedLN_TAttFillEditor = { "TAttFillEditor" , 99 , -1 };
16035 G__linked_taginfo G__G__GedLN_TGLineStyleComboBox = { "TGLineStyleComboBox" , 99 , -1 };
16036 G__linked_taginfo G__G__GedLN_TGLineWidthComboBox = { "TGLineWidthComboBox" , 99 , -1 };
16037 G__linked_taginfo G__G__GedLN_TAttLineEditor = { "TAttLineEditor" , 99 , -1 };
16038 G__linked_taginfo G__G__GedLN_TGedMarkerSelect = { "TGedMarkerSelect" , 99 , -1 };
16039 G__linked_taginfo G__G__GedLN_TAttMarkerEditor = { "TAttMarkerEditor" , 99 , -1 };
16040 G__linked_taginfo G__G__GedLN_TGFontTypeComboBox = { "TGFontTypeComboBox" , 99 , -1 };
16041 G__linked_taginfo G__G__GedLN_TAttTextEditor = { "TAttTextEditor" , 99 , -1 };
16042 G__linked_taginfo G__G__GedLN_TAxis = { "TAxis" , 99 , -1 };
16043 G__linked_taginfo G__G__GedLN_TGTextEntry = { "TGTextEntry" , 99 , -1 };
16044 G__linked_taginfo G__G__GedLN_TGCheckButton = { "TGCheckButton" , 99 , -1 };
16045 G__linked_taginfo G__G__GedLN_TAxisEditor = { "TAxisEditor" , 99 , -1 };
16046 G__linked_taginfo G__G__GedLN_TCurlyArc = { "TCurlyArc" , 99 , -1 };
16047 G__linked_taginfo G__G__GedLN_TCurlyArcEditor = { "TCurlyArcEditor" , 99 , -1 };
16048 G__linked_taginfo G__G__GedLN_TCurlyLine = { "TCurlyLine" , 99 , -1 };
16049 G__linked_taginfo G__G__GedLN_TCurlyLineEditor = { "TCurlyLineEditor" , 99 , -1 };
16050 G__linked_taginfo G__G__GedLN_TGDoubleHSlider = { "TGDoubleHSlider" , 99 , -1 };
16051 G__linked_taginfo G__G__GedLN_TGNumberEntryField = { "TGNumberEntryField" , 99 , -1 };
16052 G__linked_taginfo G__G__GedLN_TF1 = { "TF1" , 99 , -1 };
16053 G__linked_taginfo G__G__GedLN_TF1Editor = { "TF1Editor" , 99 , -1 };
16054 G__linked_taginfo G__G__GedLN_TGRadioButton = { "TGRadioButton" , 99 , -1 };
16055 G__linked_taginfo G__G__GedLN_TFrame = { "TFrame" , 99 , -1 };
16056 G__linked_taginfo G__G__GedLN_TFrameEditor = { "TFrameEditor" , 99 , -1 };
16057 G__linked_taginfo G__G__GedLN_TGTripleHSlider = { "TGTripleHSlider" , 99 , -1 };
16058 G__linked_taginfo G__G__GedLN_TFunctionParametersDialog = { "TFunctionParametersDialog" , 99 , -1 };
16059 G__linked_taginfo G__G__GedLN_TVirtualPadEditor = { "TVirtualPadEditor" , 99 , -1 };
16060 G__linked_taginfo G__G__GedLN_TMap = { "TMap" , 99 , -1 };
16061 G__linked_taginfo G__G__GedLN_TGCanvas = { "TGCanvas" , 99 , -1 };
16062 G__linked_taginfo G__G__GedLN_TGedTabInfo = { "TGedTabInfo" , 99 , -1 };
16063 G__linked_taginfo G__G__GedLN_TGWidget = { "TGWidget" , 99 , -1 };
16064 G__linked_taginfo G__G__GedLN_TGButtonGroup = { "TGButtonGroup" , 99 , -1 };
16065 G__linked_taginfo G__G__GedLN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 };
16066 G__linked_taginfo G__G__GedLN_TGButton = { "TGButton" , 99 , -1 };
16067 G__linked_taginfo G__G__GedLN_TGPictureButton = { "TGPictureButton" , 99 , -1 };
16068 G__linked_taginfo G__G__GedLN_TGedPopup = { "TGedPopup" , 99 , -1 };
16069 G__linked_taginfo G__G__GedLN_TGedPatternFrame = { "TGedPatternFrame" , 99 , -1 };
16070 G__linked_taginfo G__G__GedLN_TGedPatternSelector = { "TGedPatternSelector" , 99 , -1 };
16071 G__linked_taginfo G__G__GedLN_TGedPatternPopup = { "TGedPatternPopup" , 99 , -1 };
16072 G__linked_taginfo G__G__GedLN_TGedSelect = { "TGedSelect" , 99 , -1 };
16073 G__linked_taginfo G__G__GedLN_TGedMarkerPopup = { "TGedMarkerPopup" , 99 , -1 };
16074 G__linked_taginfo G__G__GedLN_TGraph = { "TGraph" , 99 , -1 };
16075 G__linked_taginfo G__G__GedLN_TGraphEditor = { "TGraphEditor" , 99 , -1 };
16076 G__linked_taginfo G__G__GedLN_TH1 = { "TH1" , 99 , -1 };
16077 G__linked_taginfo G__G__GedLN_TGHButtonGroup = { "TGHButtonGroup" , 99 , -1 };
16078 G__linked_taginfo G__G__GedLN_TGHSlider = { "TGHSlider" , 99 , -1 };
16079 G__linked_taginfo G__G__GedLN_TH1Editor = { "TH1Editor" , 99 , -1 };
16080 G__linked_taginfo G__G__GedLN_TH2 = { "TH2" , 99 , -1 };
16081 G__linked_taginfo G__G__GedLN_TH2Editor = { "TH2Editor" , 99 , -1 };
16082 G__linked_taginfo G__G__GedLN_TLine = { "TLine" , 99 , -1 };
16083 G__linked_taginfo G__G__GedLN_TLineEditor = { "TLineEditor" , 99 , -1 };
16084 G__linked_taginfo G__G__GedLN_TPad = { "TPad" , 99 , -1 };
16085 G__linked_taginfo G__G__GedLN_TPadEditor = { "TPadEditor" , 99 , -1 };
16086 G__linked_taginfo G__G__GedLN_TPaveStats = { "TPaveStats" , 99 , -1 };
16087 G__linked_taginfo G__G__GedLN_TPaveStatsEditor = { "TPaveStatsEditor" , 99 , -1 };
16088 G__linked_taginfo G__G__GedLN_TPie = { "TPie" , 99 , -1 };
16089 G__linked_taginfo G__G__GedLN_TPieEditor = { "TPieEditor" , 99 , -1 };
16090 G__linked_taginfo G__G__GedLN_TPieSlice = { "TPieSlice" , 99 , -1 };
16091 G__linked_taginfo G__G__GedLN_TPieSliceEditor = { "TPieSliceEditor" , 99 , -1 };
16092 G__linked_taginfo G__G__GedLN_TStyle = { "TStyle" , 99 , -1 };
16093 G__linked_taginfo G__G__GedLN_TStyleManager = { "TStyleManager" , 99 , -1 };
16094 G__linked_taginfo G__G__GedLN_TStyleDialog = { "TStyleDialog" , 99 , -1 };
16095 G__linked_taginfo G__G__GedLN_TGNumberFormat = { "TGNumberFormat" , 99 , -1 };
16096 G__linked_taginfo G__G__GedLN_TGNumberFormatcLcLEStyle = { "TGNumberFormat::EStyle" , 101 , -1 };
16097 G__linked_taginfo G__G__GedLN_TGNumberFormatcLcLEAttribute = { "TGNumberFormat::EAttribute" , 101 , -1 };
16098 G__linked_taginfo G__G__GedLN_TGNumberFormatcLcLELimit = { "TGNumberFormat::ELimit" , 101 , -1 };
16099 G__linked_taginfo G__G__GedLN_TGFileInfo = { "TGFileInfo" , 99 , -1 };
16100 G__linked_taginfo G__G__GedLN_TGHorizontal3DLine = { "TGHorizontal3DLine" , 99 , -1 };
16101 G__linked_taginfo G__G__GedLN_TGMenuBar = { "TGMenuBar" , 99 , -1 };
16102 G__linked_taginfo G__G__GedLN_TGStatusBar = { "TGStatusBar" , 99 , -1 };
16103 G__linked_taginfo G__G__GedLN_TGToolBar = { "TGToolBar" , 99 , -1 };
16104 G__linked_taginfo G__G__GedLN_TStylePreview = { "TStylePreview" , 99 , -1 };
16105 G__linked_taginfo G__G__GedLN_TRootEmbeddedCanvas = { "TRootEmbeddedCanvas" , 99 , -1 };
16106
16107
16108 extern "C" void G__cpp_reset_tagtableG__Ged() {
16109 G__G__GedLN_TClass.tagnum = -1 ;
16110 G__G__GedLN_TBuffer.tagnum = -1 ;
16111 G__G__GedLN_TMemberInspector.tagnum = -1 ;
16112 G__G__GedLN_TObject.tagnum = -1 ;
16113 G__G__GedLN_TString.tagnum = -1 ;
16114 G__G__GedLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
16115 G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
16116 G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
16117 G__G__GedLN_TList.tagnum = -1 ;
16118 G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
16119 G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
16120 G__G__GedLN_Event_t.tagnum = -1 ;
16121 G__G__GedLN_TGObject.tagnum = -1 ;
16122 G__G__GedLN_TQObject.tagnum = -1 ;
16123 G__G__GedLN_TGWindow.tagnum = -1 ;
16124 G__G__GedLN_TGPicture.tagnum = -1 ;
16125 G__G__GedLN_TGGC.tagnum = -1 ;
16126 G__G__GedLN_TAttLine.tagnum = -1 ;
16127 G__G__GedLN_TAttFill.tagnum = -1 ;
16128 G__G__GedLN_TAttText.tagnum = -1 ;
16129 G__G__GedLN_TAttMarker.tagnum = -1 ;
16130 G__G__GedLN_TGDimension.tagnum = -1 ;
16131 G__G__GedLN_TGFrame.tagnum = -1 ;
16132 G__G__GedLN_TGCompositeFrame.tagnum = -1 ;
16133 G__G__GedLN_TGLayoutHints.tagnum = -1 ;
16134 G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
16135 G__G__GedLN_TGTextButton.tagnum = -1 ;
16136 G__G__GedLN_TGVerticalFrame.tagnum = -1 ;
16137 G__G__GedLN_TGHorizontalFrame.tagnum = -1 ;
16138 G__G__GedLN_TGMainFrame.tagnum = -1 ;
16139 G__G__GedLN_TGTransientFrame.tagnum = -1 ;
16140 G__G__GedLN_TVirtualPad.tagnum = -1 ;
16141 G__G__GedLN_TCanvas.tagnum = -1 ;
16142 G__G__GedLN_TGLabel.tagnum = -1 ;
16143 G__G__GedLN_TGToolTip.tagnum = -1 ;
16144 G__G__GedLN_TGTab.tagnum = -1 ;
16145 G__G__GedLN_TGedEditor.tagnum = -1 ;
16146 G__G__GedLN_TGedFrame.tagnum = -1 ;
16147 G__G__GedLN_TGedFramecLcLTGedSubFrame.tagnum = -1 ;
16148 G__G__GedLN_TGedNameFrame.tagnum = -1 ;
16149 G__G__GedLN_TGComboBox.tagnum = -1 ;
16150 G__G__GedLN_TGNumberEntry.tagnum = -1 ;
16151 G__G__GedLN_TArrow.tagnum = -1 ;
16152 G__G__GedLN_TArrowEditor.tagnum = -1 ;
16153 G__G__GedLN_TGColorSelect.tagnum = -1 ;
16154 G__G__GedLN_TGedPatternSelect.tagnum = -1 ;
16155 G__G__GedLN_TAttFillEditor.tagnum = -1 ;
16156 G__G__GedLN_TGLineStyleComboBox.tagnum = -1 ;
16157 G__G__GedLN_TGLineWidthComboBox.tagnum = -1 ;
16158 G__G__GedLN_TAttLineEditor.tagnum = -1 ;
16159 G__G__GedLN_TGedMarkerSelect.tagnum = -1 ;
16160 G__G__GedLN_TAttMarkerEditor.tagnum = -1 ;
16161 G__G__GedLN_TGFontTypeComboBox.tagnum = -1 ;
16162 G__G__GedLN_TAttTextEditor.tagnum = -1 ;
16163 G__G__GedLN_TAxis.tagnum = -1 ;
16164 G__G__GedLN_TGTextEntry.tagnum = -1 ;
16165 G__G__GedLN_TGCheckButton.tagnum = -1 ;
16166 G__G__GedLN_TAxisEditor.tagnum = -1 ;
16167 G__G__GedLN_TCurlyArc.tagnum = -1 ;
16168 G__G__GedLN_TCurlyArcEditor.tagnum = -1 ;
16169 G__G__GedLN_TCurlyLine.tagnum = -1 ;
16170 G__G__GedLN_TCurlyLineEditor.tagnum = -1 ;
16171 G__G__GedLN_TGDoubleHSlider.tagnum = -1 ;
16172 G__G__GedLN_TGNumberEntryField.tagnum = -1 ;
16173 G__G__GedLN_TF1.tagnum = -1 ;
16174 G__G__GedLN_TF1Editor.tagnum = -1 ;
16175 G__G__GedLN_TGRadioButton.tagnum = -1 ;
16176 G__G__GedLN_TFrame.tagnum = -1 ;
16177 G__G__GedLN_TFrameEditor.tagnum = -1 ;
16178 G__G__GedLN_TGTripleHSlider.tagnum = -1 ;
16179 G__G__GedLN_TFunctionParametersDialog.tagnum = -1 ;
16180 G__G__GedLN_TVirtualPadEditor.tagnum = -1 ;
16181 G__G__GedLN_TMap.tagnum = -1 ;
16182 G__G__GedLN_TGCanvas.tagnum = -1 ;
16183 G__G__GedLN_TGedTabInfo.tagnum = -1 ;
16184 G__G__GedLN_TGWidget.tagnum = -1 ;
16185 G__G__GedLN_TGButtonGroup.tagnum = -1 ;
16186 G__G__GedLN_TGPopupMenu.tagnum = -1 ;
16187 G__G__GedLN_TGButton.tagnum = -1 ;
16188 G__G__GedLN_TGPictureButton.tagnum = -1 ;
16189 G__G__GedLN_TGedPopup.tagnum = -1 ;
16190 G__G__GedLN_TGedPatternFrame.tagnum = -1 ;
16191 G__G__GedLN_TGedPatternSelector.tagnum = -1 ;
16192 G__G__GedLN_TGedPatternPopup.tagnum = -1 ;
16193 G__G__GedLN_TGedSelect.tagnum = -1 ;
16194 G__G__GedLN_TGedMarkerPopup.tagnum = -1 ;
16195 G__G__GedLN_TGraph.tagnum = -1 ;
16196 G__G__GedLN_TGraphEditor.tagnum = -1 ;
16197 G__G__GedLN_TH1.tagnum = -1 ;
16198 G__G__GedLN_TGHButtonGroup.tagnum = -1 ;
16199 G__G__GedLN_TGHSlider.tagnum = -1 ;
16200 G__G__GedLN_TH1Editor.tagnum = -1 ;
16201 G__G__GedLN_TH2.tagnum = -1 ;
16202 G__G__GedLN_TH2Editor.tagnum = -1 ;
16203 G__G__GedLN_TLine.tagnum = -1 ;
16204 G__G__GedLN_TLineEditor.tagnum = -1 ;
16205 G__G__GedLN_TPad.tagnum = -1 ;
16206 G__G__GedLN_TPadEditor.tagnum = -1 ;
16207 G__G__GedLN_TPaveStats.tagnum = -1 ;
16208 G__G__GedLN_TPaveStatsEditor.tagnum = -1 ;
16209 G__G__GedLN_TPie.tagnum = -1 ;
16210 G__G__GedLN_TPieEditor.tagnum = -1 ;
16211 G__G__GedLN_TPieSlice.tagnum = -1 ;
16212 G__G__GedLN_TPieSliceEditor.tagnum = -1 ;
16213 G__G__GedLN_TStyle.tagnum = -1 ;
16214 G__G__GedLN_TStyleManager.tagnum = -1 ;
16215 G__G__GedLN_TStyleDialog.tagnum = -1 ;
16216 G__G__GedLN_TGNumberFormat.tagnum = -1 ;
16217 G__G__GedLN_TGNumberFormatcLcLEStyle.tagnum = -1 ;
16218 G__G__GedLN_TGNumberFormatcLcLEAttribute.tagnum = -1 ;
16219 G__G__GedLN_TGNumberFormatcLcLELimit.tagnum = -1 ;
16220 G__G__GedLN_TGFileInfo.tagnum = -1 ;
16221 G__G__GedLN_TGHorizontal3DLine.tagnum = -1 ;
16222 G__G__GedLN_TGMenuBar.tagnum = -1 ;
16223 G__G__GedLN_TGStatusBar.tagnum = -1 ;
16224 G__G__GedLN_TGToolBar.tagnum = -1 ;
16225 G__G__GedLN_TStylePreview.tagnum = -1 ;
16226 G__G__GedLN_TRootEmbeddedCanvas.tagnum = -1 ;
16227 }
16228
16229
16230 extern "C" void G__cpp_setup_tagtableG__Ged() {
16231
16232
16233 G__get_linked_tagnum_fwd(&G__G__GedLN_TClass);
16234 G__get_linked_tagnum_fwd(&G__G__GedLN_TBuffer);
16235 G__get_linked_tagnum_fwd(&G__G__GedLN_TMemberInspector);
16236 G__get_linked_tagnum_fwd(&G__G__GedLN_TObject);
16237 G__get_linked_tagnum_fwd(&G__G__GedLN_TString);
16238 G__get_linked_tagnum_fwd(&G__G__GedLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
16239 G__get_linked_tagnum_fwd(&G__G__GedLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
16240 G__get_linked_tagnum_fwd(&G__G__GedLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
16241 G__get_linked_tagnum_fwd(&G__G__GedLN_TList);
16242 G__get_linked_tagnum_fwd(&G__G__GedLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
16243 G__get_linked_tagnum_fwd(&G__G__GedLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
16244 G__get_linked_tagnum_fwd(&G__G__GedLN_Event_t);
16245 G__get_linked_tagnum_fwd(&G__G__GedLN_TGObject);
16246 G__get_linked_tagnum_fwd(&G__G__GedLN_TQObject);
16247 G__get_linked_tagnum_fwd(&G__G__GedLN_TGWindow);
16248 G__get_linked_tagnum_fwd(&G__G__GedLN_TGPicture);
16249 G__get_linked_tagnum_fwd(&G__G__GedLN_TGGC);
16250 G__get_linked_tagnum_fwd(&G__G__GedLN_TAttLine);
16251 G__get_linked_tagnum_fwd(&G__G__GedLN_TAttFill);
16252 G__get_linked_tagnum_fwd(&G__G__GedLN_TAttText);
16253 G__get_linked_tagnum_fwd(&G__G__GedLN_TAttMarker);
16254 G__get_linked_tagnum_fwd(&G__G__GedLN_TGDimension);
16255 G__get_linked_tagnum_fwd(&G__G__GedLN_TGFrame);
16256 G__get_linked_tagnum_fwd(&G__G__GedLN_TGCompositeFrame);
16257 G__get_linked_tagnum_fwd(&G__G__GedLN_TGLayoutHints);
16258 G__get_linked_tagnum_fwd(&G__G__GedLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
16259 G__get_linked_tagnum_fwd(&G__G__GedLN_TGTextButton);
16260 G__get_linked_tagnum_fwd(&G__G__GedLN_TGVerticalFrame);
16261 G__get_linked_tagnum_fwd(&G__G__GedLN_TGHorizontalFrame);
16262 G__get_linked_tagnum_fwd(&G__G__GedLN_TGMainFrame);
16263 G__get_linked_tagnum_fwd(&G__G__GedLN_TGTransientFrame);
16264 G__get_linked_tagnum_fwd(&G__G__GedLN_TVirtualPad);
16265 G__get_linked_tagnum_fwd(&G__G__GedLN_TCanvas);
16266 G__get_linked_tagnum_fwd(&G__G__GedLN_TGLabel);
16267 G__get_linked_tagnum_fwd(&G__G__GedLN_TGToolTip);
16268 G__get_linked_tagnum_fwd(&G__G__GedLN_TGTab);
16269 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedEditor),sizeof(TGedEditor),-1,65280,"ROOT graphics editor",G__setup_memvarTGedEditor,G__setup_memfuncTGedEditor);
16270 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedFrame),sizeof(TGedFrame),-1,65281,"base editor's frame",G__setup_memvarTGedFrame,G__setup_memfuncTGedFrame);
16271 G__get_linked_tagnum_fwd(&G__G__GedLN_TGedFramecLcLTGedSubFrame);
16272 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedNameFrame),sizeof(TGedNameFrame),-1,65280,"frame showing the selected object name",G__setup_memvarTGedNameFrame,G__setup_memfuncTGedNameFrame);
16273 G__get_linked_tagnum_fwd(&G__G__GedLN_TGComboBox);
16274 G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberEntry);
16275 G__get_linked_tagnum_fwd(&G__G__GedLN_TArrow);
16276 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TArrowEditor),sizeof(TArrowEditor),-1,62720,"GUI for editing arrow attributes",G__setup_memvarTArrowEditor,G__setup_memfuncTArrowEditor);
16277 G__get_linked_tagnum_fwd(&G__G__GedLN_TGColorSelect);
16278 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPatternSelect),sizeof(TGedPatternSelect),-1,62464,"pattern selection check-button",G__setup_memvarTGedPatternSelect,G__setup_memfuncTGedPatternSelect);
16279 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAttFillEditor),sizeof(TAttFillEditor),-1,62720,"GUI for editing fill attributes",G__setup_memvarTAttFillEditor,G__setup_memfuncTAttFillEditor);
16280 G__get_linked_tagnum_fwd(&G__G__GedLN_TGLineStyleComboBox);
16281 G__get_linked_tagnum_fwd(&G__G__GedLN_TGLineWidthComboBox);
16282 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAttLineEditor),sizeof(TAttLineEditor),-1,62720,"GUI for editing line attributes",G__setup_memvarTAttLineEditor,G__setup_memfuncTAttLineEditor);
16283 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedMarkerSelect),sizeof(TGedMarkerSelect),-1,62464,"Marker selection button",G__setup_memvarTGedMarkerSelect,G__setup_memfuncTGedMarkerSelect);
16284 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAttMarkerEditor),sizeof(TAttMarkerEditor),-1,62720,"GUI for editing marker attributes",G__setup_memvarTAttMarkerEditor,G__setup_memfuncTAttMarkerEditor);
16285 G__get_linked_tagnum_fwd(&G__G__GedLN_TGFontTypeComboBox);
16286 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAttTextEditor),sizeof(TAttTextEditor),-1,62720,"GUI for editing text attributes",G__setup_memvarTAttTextEditor,G__setup_memfuncTAttTextEditor);
16287 G__get_linked_tagnum_fwd(&G__G__GedLN_TAxis);
16288 G__get_linked_tagnum_fwd(&G__G__GedLN_TGTextEntry);
16289 G__get_linked_tagnum_fwd(&G__G__GedLN_TGCheckButton);
16290 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TAxisEditor),sizeof(TAxisEditor),-1,62720,"axis editor",G__setup_memvarTAxisEditor,G__setup_memfuncTAxisEditor);
16291 G__get_linked_tagnum_fwd(&G__G__GedLN_TCurlyArc);
16292 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TCurlyArcEditor),sizeof(TCurlyArcEditor),-1,62720,"GUI for editing arrow attributes",G__setup_memvarTCurlyArcEditor,G__setup_memfuncTCurlyArcEditor);
16293 G__get_linked_tagnum_fwd(&G__G__GedLN_TCurlyLine);
16294 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TCurlyLineEditor),sizeof(TCurlyLineEditor),-1,62720,"GUI for editing arrow attributes",G__setup_memvarTCurlyLineEditor,G__setup_memfuncTCurlyLineEditor);
16295 G__get_linked_tagnum_fwd(&G__G__GedLN_TGDoubleHSlider);
16296 G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberEntryField);
16297 G__get_linked_tagnum_fwd(&G__G__GedLN_TF1);
16298 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TF1Editor),sizeof(TF1Editor),-1,62720,"user interface for TF1 objects",G__setup_memvarTF1Editor,G__setup_memfuncTF1Editor);
16299 G__get_linked_tagnum_fwd(&G__G__GedLN_TGRadioButton);
16300 G__get_linked_tagnum_fwd(&G__G__GedLN_TFrame);
16301 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TFrameEditor),sizeof(TFrameEditor),-1,62720,"editor of TFrame objects",G__setup_memvarTFrameEditor,G__setup_memfuncTFrameEditor);
16302 G__get_linked_tagnum_fwd(&G__G__GedLN_TGTripleHSlider);
16303 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TFunctionParametersDialog),sizeof(TFunctionParametersDialog),-1,62464,"Function parameters dialog",G__setup_memvarTFunctionParametersDialog,G__setup_memfuncTFunctionParametersDialog);
16304 G__get_linked_tagnum_fwd(&G__G__GedLN_TVirtualPadEditor);
16305 G__get_linked_tagnum_fwd(&G__G__GedLN_TMap);
16306 G__get_linked_tagnum_fwd(&G__G__GedLN_TGCanvas);
16307 G__get_linked_tagnum_fwd(&G__G__GedLN_TGedTabInfo);
16308 G__get_linked_tagnum_fwd(&G__G__GedLN_TGWidget);
16309 G__get_linked_tagnum_fwd(&G__G__GedLN_TGButtonGroup);
16310 G__get_linked_tagnum_fwd(&G__G__GedLN_TGPopupMenu);
16311 G__get_linked_tagnum_fwd(&G__G__GedLN_TGButton);
16312 G__get_linked_tagnum_fwd(&G__G__GedLN_TGPictureButton);
16313 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPopup),sizeof(TGedPopup),-1,62464,"popup window",G__setup_memvarTGedPopup,G__setup_memfuncTGedPopup);
16314 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPatternFrame),sizeof(TGedPatternFrame),-1,62464,"pattern frame",G__setup_memvarTGedPatternFrame,G__setup_memfuncTGedPatternFrame);
16315 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPatternSelector),sizeof(TGedPatternSelector),-1,62464,"select pattern frame",G__setup_memvarTGedPatternSelector,G__setup_memfuncTGedPatternSelector);
16316 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedPatternPopup),sizeof(TGedPatternPopup),-1,62464,"Color selector popup",G__setup_memvarTGedPatternPopup,G__setup_memfuncTGedPatternPopup);
16317 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedSelect),sizeof(TGedSelect),-1,62464,"selection check-button",G__setup_memvarTGedSelect,G__setup_memfuncTGedSelect);
16318 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGedMarkerPopup),sizeof(TGedMarkerPopup),-1,62464,"marker select popup",G__setup_memvarTGedMarkerPopup,G__setup_memfuncTGedMarkerPopup);
16319 G__get_linked_tagnum_fwd(&G__G__GedLN_TGraph);
16320 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TGraphEditor),sizeof(TGraphEditor),-1,62720,"graph editor",G__setup_memvarTGraphEditor,G__setup_memfuncTGraphEditor);
16321 G__get_linked_tagnum_fwd(&G__G__GedLN_TH1);
16322 G__get_linked_tagnum_fwd(&G__G__GedLN_TGHButtonGroup);
16323 G__get_linked_tagnum_fwd(&G__G__GedLN_TGHSlider);
16324 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TH1Editor),sizeof(TH1Editor),-1,62720,"TH1 editor",G__setup_memvarTH1Editor,G__setup_memfuncTH1Editor);
16325 G__get_linked_tagnum_fwd(&G__G__GedLN_TH2);
16326 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TH2Editor),sizeof(TH2Editor),-1,62720,"TH2 editor",G__setup_memvarTH2Editor,G__setup_memfuncTH2Editor);
16327 G__get_linked_tagnum_fwd(&G__G__GedLN_TLine);
16328 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TLineEditor),sizeof(TLineEditor),-1,62720,"GUI for editing Line attributes",G__setup_memvarTLineEditor,G__setup_memfuncTLineEditor);
16329 G__get_linked_tagnum_fwd(&G__G__GedLN_TPad);
16330 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TPadEditor),sizeof(TPadEditor),-1,62720,"editor of TPad objects",G__setup_memvarTPadEditor,G__setup_memfuncTPadEditor);
16331 G__get_linked_tagnum_fwd(&G__G__GedLN_TPaveStats);
16332 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TPaveStatsEditor),sizeof(TPaveStatsEditor),-1,62720,"GUI for editing TPaveStats",G__setup_memvarTPaveStatsEditor,G__setup_memfuncTPaveStatsEditor);
16333 G__get_linked_tagnum_fwd(&G__G__GedLN_TPie);
16334 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TPieEditor),sizeof(TPieEditor),-1,62720,"piechart editor",G__setup_memvarTPieEditor,G__setup_memfuncTPieEditor);
16335 G__get_linked_tagnum_fwd(&G__G__GedLN_TPieSlice);
16336 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TPieSliceEditor),sizeof(TPieSliceEditor),-1,62720,"piechart' slice editor",G__setup_memvarTPieSliceEditor,G__setup_memfuncTPieSliceEditor);
16337 G__get_linked_tagnum_fwd(&G__G__GedLN_TStyle);
16338 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TStyleManager),sizeof(TStyleManager),-1,62464,"Graphical User Interface for managing styles",G__setup_memvarTStyleManager,G__setup_memfuncTStyleManager);
16339 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TStyleDialog),sizeof(TStyleDialog),-1,62464,"Dialog box used by the TStyleManager class",G__setup_memvarTStyleDialog,G__setup_memfuncTStyleDialog);
16340 G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberFormat);
16341 G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberFormatcLcLEStyle);
16342 G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberFormatcLcLEAttribute);
16343 G__get_linked_tagnum_fwd(&G__G__GedLN_TGNumberFormatcLcLELimit);
16344 G__get_linked_tagnum_fwd(&G__G__GedLN_TGFileInfo);
16345 G__get_linked_tagnum_fwd(&G__G__GedLN_TGHorizontal3DLine);
16346 G__get_linked_tagnum_fwd(&G__G__GedLN_TGMenuBar);
16347 G__get_linked_tagnum_fwd(&G__G__GedLN_TGStatusBar);
16348 G__get_linked_tagnum_fwd(&G__G__GedLN_TGToolBar);
16349 G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__GedLN_TStylePreview),sizeof(TStylePreview),-1,62464,"Preview window used by the TStyleManager class",G__setup_memvarTStylePreview,G__setup_memfuncTStylePreview);
16350 G__get_linked_tagnum_fwd(&G__G__GedLN_TRootEmbeddedCanvas);
16351 }
16352 extern "C" void G__cpp_setupG__Ged(void) {
16353 G__check_setup_version(30051515,"G__cpp_setupG__Ged()");
16354 G__set_cpp_environmentG__Ged();
16355 G__cpp_setup_tagtableG__Ged();
16356
16357 G__cpp_setup_inheritanceG__Ged();
16358
16359 G__cpp_setup_typetableG__Ged();
16360
16361 G__cpp_setup_memvarG__Ged();
16362
16363 G__cpp_setup_memfuncG__Ged();
16364 G__cpp_setup_globalG__Ged();
16365 G__cpp_setup_funcG__Ged();
16366
16367 if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Ged();
16368 return;
16369 }
16370 class G__cpp_setup_initG__Ged {
16371 public:
16372 G__cpp_setup_initG__Ged() { G__add_setup_func("G__Ged",(G__incsetup)(&G__cpp_setupG__Ged)); G__call_setup_funcs(); }
16373 ~G__cpp_setup_initG__Ged() { G__remove_setup_func("G__Ged"); }
16374 };
16375 G__cpp_setup_initG__Ged G__cpp_setup_initializerG__Ged;
16376
