From 9ad65bc374265c1c7d84e65dcb7d52ebd80bb7ff Mon Sep 17 00:00:00 2001 From: Anna Bergamaschi Date: Thu, 27 Nov 2014 09:30:14 +0100 Subject: [PATCH] First commit --- JCTBGui/JCTBGui.cpp | 157 ++ JCTBGui/Makefile | 29 + JCTBGui/example.alias | 176 ++ JCTBGui/jctbAcquisition.cpp | 228 ++ JCTBGui/jctbAcquisition.h | 60 + JCTBGui/jctbAdcs.cpp | 215 ++ JCTBGui/jctbAdcs.h | 83 + JCTBGui/jctbDac.cpp | 122 + JCTBGui/jctbDac.h | 44 + JCTBGui/jctbDacs.cpp | 88 + JCTBGui/jctbDacs.h | 40 + JCTBGui/jctbDict.cpp | 4274 +++++++++++++++++++++++++++++++++++ JCTBGui/jctbDict.h | 98 + JCTBGui/jctbLinkDef.h | 11 + JCTBGui/jctbMain.cpp | 665 ++++++ JCTBGui/jctbMain.h | 94 + JCTBGui/jctbPattern.cpp | 532 +++++ JCTBGui/jctbPattern.h | 124 + JCTBGui/jctbSignal.cpp | 186 ++ JCTBGui/jctbSignal.h | 71 + JCTBGui/jctbSignals.cpp | 257 +++ JCTBGui/jctbSignals.h | 44 + 22 files changed, 7598 insertions(+) create mode 100755 JCTBGui/JCTBGui.cpp create mode 100755 JCTBGui/Makefile create mode 100755 JCTBGui/example.alias create mode 100755 JCTBGui/jctbAcquisition.cpp create mode 100755 JCTBGui/jctbAcquisition.h create mode 100755 JCTBGui/jctbAdcs.cpp create mode 100755 JCTBGui/jctbAdcs.h create mode 100755 JCTBGui/jctbDac.cpp create mode 100755 JCTBGui/jctbDac.h create mode 100755 JCTBGui/jctbDacs.cpp create mode 100755 JCTBGui/jctbDacs.h create mode 100755 JCTBGui/jctbDict.cpp create mode 100755 JCTBGui/jctbDict.h create mode 100755 JCTBGui/jctbLinkDef.h create mode 100755 JCTBGui/jctbMain.cpp create mode 100755 JCTBGui/jctbMain.h create mode 100755 JCTBGui/jctbPattern.cpp create mode 100755 JCTBGui/jctbPattern.h create mode 100755 JCTBGui/jctbSignal.cpp create mode 100755 JCTBGui/jctbSignal.h create mode 100755 JCTBGui/jctbSignals.cpp create mode 100755 JCTBGui/jctbSignals.h diff --git a/JCTBGui/JCTBGui.cpp b/JCTBGui/JCTBGui.cpp new file mode 100755 index 000000000..bc1b042a8 --- /dev/null +++ b/JCTBGui/JCTBGui.cpp @@ -0,0 +1,157 @@ +#include +#include + +#include +#include + +#include +#include +#include +#include + + +#include "multiSlsDetector.h" +#include "sls_detector_defs.h" +#include "sls_receiver_defs.h" +#include "jctbMain.h" +using namespace std; + + +int main(int argc, char **argv) { + + + string afname, cfname, pfname; + int id=0; + + int af=0, cf=0, pf=0; + + + cout << " *** " << argc << endl; + for (int ia=0; iasetOnline(slsDetectorDefs::ONLINE_FLAG); + + + if (cf) { + myDet->readConfigurationFile(cfname); + } else + cout << "No config file specified" << endl; + + + cout << "Created multi detector id " << id << " hostname " << myDet->getHostname() << endl; + + if (pf) { + myDet->retrieveDetectorSetup(pfname); + } else + cout << "No parameter file specified" << endl; + + + + + + /***********Create GUI stuff *******************/ + TApplication theApp("App",&argc,argv); + + + gStyle->SetDrawBorder(0); + gStyle->SetCanvasColor(kWhite); + gStyle->SetCanvasDefH(800); + gStyle->SetCanvasDefW(800); + gStyle->SetCanvasBorderMode(0); + gStyle->SetPadBorderMode(0); + gStyle->SetPaintTextFormat("5.2f"); + gStyle->SetLineWidth(2); + gStyle->SetTextSize(1.1); + gStyle->SetLabelSize(0.04,"xy"); + gStyle->SetTitleSize(0.05,"xy"); + gStyle->SetTitleOffset(1.0,"x"); + gStyle->SetTitleOffset(1.1,"y"); + gStyle->SetPadTopMargin(0.15); + gStyle->SetPadRightMargin(0.15); + gStyle->SetPadBottomMargin(0.15); + gStyle->SetPadLeftMargin(0.15); + gStyle->SetLegendBorderSize(1); + gStyle->SetFrameBorderMode(0); + gStyle->SetFrameFillColor(kWhite); + // gStyle->SetLegendFillColor(kWhite); + gStyle->SetTitleFillColor(kWhite); + gStyle->SetFillColor(kWhite); + gStyle->SetStatFontSize(0.03); + gStyle->SetStatBorderSize(1); + gStyle->SetStatFormat("6.4g"); + gStyle->SetStatX(0.95); + gStyle->SetStatY(0.95); + gStyle->SetStatW(0.2); + gStyle->SetStatH(0.2); + gStyle->SetTitleX(0.1); + gStyle->SetTitleY(0.95); + gStyle->SetTitleBorderSize(0); + gStyle->SetTitleFontSize(0.05); + gROOT->SetStyle("Default"); + + + TColor::InitializeColors(); + const Int_t NRGBs = 5; + const Int_t NCont = 90; + + Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 }; + Double_t red[NRGBs] = { 0.00, 0.00, 0.87, 1.00, 0.51 }; + Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 }; + Double_t blue[NRGBs] = { 0.51, 1.00, 0.12, 0.00, 0.00 }; + TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont); + gStyle->SetNumberContours(NCont); + + + gROOT->ForceStyle(); + jctbMain *mf=new jctbMain(gClient->GetRoot(),myDet); + + cout << " *** " << argc << endl; + for (int ia=0; ialoadAlias(afname); + else + cout << "no alias specified" << endl; + + theApp.Run(); + return 0; +} diff --git a/JCTBGui/Makefile b/JCTBGui/Makefile new file mode 100755 index 000000000..f8115db0b --- /dev/null +++ b/JCTBGui/Makefile @@ -0,0 +1,29 @@ + +SRC=jctbDict.cpp jctbMain.cpp jctbDacs.cpp jctbDac.cpp jctbPattern.cpp jctbSignals.cpp jctbSignal.cpp jctbAdcs.cpp jctbAcquisition.cpp +INCS=jctbSignals.h jctbSignal.h jctbPattern.h jctbDacs.h jctbDac.h jctbMain.h jctbAdcs.h jctbAcquisition.h +LINKDEF=jctbLinkDef.h + +INCDIR=-I../slsReceiverSoftware/include/ -I../slsDetectorSoftware/multiSlsDetector/ -I../slsDetectorSoftware/slsDetector -I../slsDetectorSoftware/commonFiles -I../slsDetectorSoftware/slsDetectorAnalysis -I../slsDetectorSoftware/slsDetectorUsers -I../slsDetectorSoftware/usersFunctions +LDFLAG=-L../bin -lSlsDetector -L/usr/lib64/ -lpthread + +MAIN=JCTBGui.cpp + +DESTDIR?=../bin + +all: $(DESTDIR)/JCTBGui + +doc: + cd manual && make DESTDIR=$(DESTDIR) + +htmldoc: + cd manual && make html DESTDIR=$(DESTDIR) + +jctbDict.cpp: $(INCS) $(LINKDEF) + rootcint -f jctbDict.cpp -c $(INCS) $(LINKDEF) + +$(DESTDIR)/JCTBGui: $(SRC) $(MAIN) $(LINKDEF) $(INCS) + g++ -DMYROOT `root-config --cflags --glibs` -lMinuit $(LDFLAG) -o JCTBGui $(INCDIR) $(SRC) $(MAIN) + mv JCTBGui $(DESTDIR) + +clean: + rm -f JCTBGui *.o jctbDict.* diff --git a/JCTBGui/example.alias b/JCTBGui/example.alias new file mode 100755 index 000000000..761b25d61 --- /dev/null +++ b/JCTBGui/example.alias @@ -0,0 +1,176 @@ +# this is a comment (every line starting with no keyword is such) + +# space in label not allowed (tbf) + +#BITX bitName plotFlag plotColorRGB (from 0!) + + +#BIT1 compTestOUT 1 2 #you can put comments also here (leave a space bef. #) + +BIT1 compTestIN + +BIT32 curON + +BIT2 side_clk + +BIT3 side_din + +BIT4 clear_shr + +BIT5 bottom_din + +BIT6 bottom_clk + +BIT7 gHF + +BIT31 bypassCDS + +BIT8 ENprechPRE + +BIT9 res + +BIT30 pulseOFF + +BIT27 connCDS #INVERTED NAME to match logical behaviour, chipname disconnCDS + +BIT24 Dsg_1 + +BIT25 Dsg_2 + +BIT23 Dsg_3 + +BIT10 sto0 + +BIT11 sto1 + +BIT12 sto2 + +BIT13 resCDS + +BIT14 prechargeConnect + +BIT15 pulse + +BIT21 PCT_mode + +BIT16 res_DGS + +#BIT26 dbit1 + +#BIT27 dbit0 + +#CMOS_IN + +#CMOS_IN1 out_DGS + +#LVDS_IN + +# now the names of ADC channels (lt. 12 characters) + +ADC1 T_boa.(C) + +ADC2 Va+ + +ADC3 Vdd_ps + +ADC4 Vsh + +ADC5 Vcc_int + +ADC6 Vcc_iochip + +ADC7 Vcc1.8A + +ADC8 Vcc1.8D + +ADC9 T_chip + +ADC10 _nc + +ADC11 _nc + +ADC12 _Vcc_io # 0.068 ohm resistor + +ADC13 _nc # 0.068 ohm resistor + +ADC14 _Va # 0.068 ohm resistor + +ADC15 _nc + +ADC16 _vdd_ana + +I1 _I_va(mA) # this values are computed as spec. + +I1a 2 #by the following lines ((ADCa-ADCb)/R) + +I1b 14 # all the values comes mainly from the adapter board + +I1r 0.068 + +I2 _I_vdd(mA) # + +I2a 3 + +I2b 16 + +I2r 0.068 # + +I3 _nn + +I3a 14 + +I3b 2 + +I3r 0.068 + +I4 _I_io(mA) + +I4a 6 + +I4b 12 + +I4r 0.068 #shuld be 5000000 for mA readout + +# now the names of DAC channels (lt. 12 characters) + +DAC7 vbp_colbuf + +DAC8 vIpreCDS + +DAC9 vIpre + +DAC10 VprechPre + +DAC11 prechargeV + +DAC12 ibias_SFP + +DAC1 vcasc_SFP + +DAC3 VPH + +DAC4 VPL + +DAC2 ibias_CS + +DAC5 vrefDGS + +DAC6 vIpreDGS + +DAC1 vcascSFP + +DAC13 s2d_vcascp + +#POT1 s2d_vcascn + +DAC14 vin_com + +DAC15 vout_com + +DAC16 vb_sda + +# number (1-16) of the adc "reading" the pot controlled VR. (should be always 2) + +DACFORPOTVR 2 + +#SCHEMATIC jungfrau01_ADP.pdf #those files are located in doc/ folder diff --git a/JCTBGui/jctbAcquisition.cpp b/JCTBGui/jctbAcquisition.cpp new file mode 100755 index 000000000..cc727610b --- /dev/null +++ b/JCTBGui/jctbAcquisition.cpp @@ -0,0 +1,228 @@ + +#include +#include +#include +#include +#include + + +#include +#include +#include + +#include "jctbAcquisition.h" +#include "multiSlsDetector.h" +#include "sls_detector_defs.h" + +using namespace std; + + + + +jctbAcquisition::jctbAcquisition(TGVerticalFrame *page, multiSlsDetector *det) : TGGroupFrame(page,"Acquisition",kVerticalFrame), myDet(det) { + + page->AddFrame(this,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 10,10,10,10)); + MapWindow(); + + TGHorizontalFrame *hframe=new TGHorizontalFrame(this, 800,50); + AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 10,10,10,10)); + hframe->MapWindow(); + + char tit[100]; + + + cFileSave= new TGCheckButton(hframe, "Output file: "); + hframe->AddFrame(cFileSave,new TGLayoutHints(kLHintsTop | kLHintsLeft | kLHintsExpandX, 5, 5, 5, 5)); + cFileSave->MapWindow(); + cFileSave->SetTextJustify(kTextRight); + cFileSave->Connect("Toggled(Bool_t)","jctbAcquisition",this,"setFsave(Bool_t)"); + + + eFname = new TGTextEntry(hframe, (myDet->getFileName()).c_str()); + + hframe->AddFrame(eFname,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5)); + eFname->MapWindow(); + eFname->Resize(150,30); + + eFname->Connect("ReturnPressed()","jctbAcquisition",this,"setFname()"); + + + TGLabel *label=new TGLabel(hframe,"index: "); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5)); + label->MapWindow(); + label->SetTextJustify(kTextRight); + + + eFindex = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELNoLimits); + hframe->AddFrame( eFindex,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eFindex->MapWindow(); + eFindex->Resize(150,30); + TGTextEntry *e= eFindex->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbAcquisition",this,"setFindex()"); + + + hframe=new TGHorizontalFrame(this, 800,50); + AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 10,10,10,10)); + hframe->MapWindow(); + + label=new TGLabel(hframe,"Output directory: "); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5)); + label->MapWindow(); + label->SetTextJustify(kTextRight); + + + + eOutdir = new TGTextEntry(hframe, (myDet->getFilePath()).c_str()); + + hframe->AddFrame(eOutdir,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5)); + eOutdir->MapWindow(); + eOutdir->Resize(150,30); + + + eOutdir->Connect("ReturnPressed()","jctbAcquisition",this,"setOutdir()"); + + hframe=new TGHorizontalFrame(this, 800,50); + AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 10,10,10,10)); + hframe->MapWindow(); + + bStatus=new TGTextButton(hframe, "Start"); + hframe->AddFrame(bStatus,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5)); + bStatus->MapWindow(); + bStatus->Connect("Clicked()","jctbAcquisition",this,"toggleAcquisition()"); + + + acqThread = new TThread("acqThread", + jctbAcquisition::ThreadHandle,(void*)this); + // acqThread->Run(); + + myDet->registerProgressCallback(&progressCallback,(void*)this); + + + myDet->registerDataCallback(&dataCallback, (void*)this); + +} + +int jctbAcquisition::dataCallback(detectorData *data, int index, void* pArgs) { + + + cout <<"------"<< index << " " << data->npoints << " "<< data->npy << endl; + + + + +} + + + + +void jctbAcquisition::setOutdir() { + + myDet->setFilePath(eOutdir->GetText()); + +// // cout << "setting dac! "<< id << endl; + +// myDet->setDAC(dacsEntry->GetIntNumber(), (slsDetectorDefs::dacIndex)id, dacsUnit->IsOn()); + +// getValue(); + +} + +void jctbAcquisition::setFname() { + myDet->setFileName(eFname->GetText()); +// int val=myDet->setDAC(-1, (slsDetectorDefs::dacIndex)id, dacsUnit->IsOn()); +// char s[100]; + +// sprintf(s,"%d",val); + +// dacsValue->SetText(s); + + +// return val; + +} + +void jctbAcquisition::setFindex() { + myDet->setFileIndex(eFindex->GetNumber()); + +} + + +void jctbAcquisition::setFsave(Bool_t b) { + myDet->enableWriteToFile(b); + eFname->SetState(b); + eOutdir->SetState(b); + +} + +void jctbAcquisition::update() { + + + eFname->SetText((myDet->getFileName()).c_str()); + eOutdir->SetText((myDet->getFilePath()).c_str()); + eFindex->SetNumber(myDet->getFileIndex()); + cFileSave->SetOn(myDet->enableWriteToFile()); + eFname->SetState(cFileSave->IsOn()); + eOutdir->SetState(cFileSave->IsOn()); + eFindex->SetState(cFileSave->IsOn()); + +} + + + +void jctbAcquisition::toggleAcquisition() { + + + + if (acqThread->GetState()==1 || acqThread->GetState()==6) { + bStatus->SetText("Stop"); + acqThread->Run(); + //myDet->startAcquisition(); + StopFlag=0; + } else { + StopFlag=1; + myDet->stopAcquisition(); + bStatus->SetText("Start"); + // acqThread->Kill(); + } +} + +void jctbAcquisition::acquisitionFinished() { + bStatus->SetText("Start"); +} + +void jctbAcquisition::startAcquisition(){ + cout << "Detector started " << endl; + myDet->acquire(); +} + +void* jctbAcquisition::ThreadHandle(void *arg) +{ + jctbAcquisition *acq = static_cast(arg); + int i=0; + + acq->startAcquisition(); + acq->acquisitionFinished(); + + // while(!(classInstance->StopFlag)) + // { + // cout << "thread " << i++ << endl; + // usleep(100000); + // } + //myDet->readFrame(); + +} + + int jctbAcquisition::progressCallback(double f,void* arg) { + + + // jctbAcquisition *acq = static_cast(arg); + + + cout << "*********" << f << "*******" << endl; + + + + + } diff --git a/JCTBGui/jctbAcquisition.h b/JCTBGui/jctbAcquisition.h new file mode 100755 index 000000000..c0758cb4b --- /dev/null +++ b/JCTBGui/jctbAcquisition.h @@ -0,0 +1,60 @@ +#ifndef JCTBACQUISITION_H +#define JCTBACQUISITION_H +#include + + + +class TGTextEntry; +class TGLabel; +class TGNumberEntry; +class TGCheckButton; +class TThread; + +class TGTextButton; + +class multiSlsDetector; +class detectorData; + +#include +using namespace std; + +class jctbAcquisition : public TGGroupFrame { + + + private: + TGTextEntry *eOutdir; + TGTextEntry *eFname; + TGNumberEntry *eFindex; + TGCheckButton *cFileSave; + TGTextButton *bStatus; + // TGTextButton + + TThread *acqThread; + + multiSlsDetector* myDet; + + + + + + public: + jctbAcquisition(TGVerticalFrame*, multiSlsDetector*); + void setOutdir(); + void setFname(); + void setFsave(Bool_t); + void setFindex(); + void toggleAcquisition(); + static void* ThreadHandle(void *arg); + void update(); + void acquisitionFinished(); + + void startAcquisition(); + static int progressCallback(double,void*); + static int dataCallback(detectorData*, int, void*); + int StopFlag; + + ClassDef(jctbAcquisition,0) +}; + + +#endif diff --git a/JCTBGui/jctbAdcs.cpp b/JCTBGui/jctbAdcs.cpp new file mode 100755 index 000000000..77f38f7e0 --- /dev/null +++ b/JCTBGui/jctbAdcs.cpp @@ -0,0 +1,215 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "jctbAdcs.h" +#include "multiSlsDetector.h" + +using namespace std; + + + +jctbAdc::jctbAdc(TGVerticalFrame *page, int i, multiSlsDetector *det) + : TGHorizontalFrame(page, 800,800), id(i), myDet(det) { + + TGHorizontalFrame *hframe=this; + char tit[100]; + + page->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hframe->MapWindow(); + + + + + + sprintf(tit, "ADC%d", id); + + sAdcLabel= new TGLabel(hframe, tit); + hframe->AddFrame(sAdcLabel,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + sAdcLabel->MapWindow(); + sAdcLabel->SetTextJustify(kTextLeft); + + + + + + sAdcEnable= new TGCheckButton(hframe, "Enable"); + hframe->AddFrame( sAdcEnable,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + sAdcEnable->MapWindow(); + sAdcEnable->SetOn(kTRUE); + sAdcEnable->SetEnabled(kFALSE); + + + + sAdcPlot= new TGCheckButton(hframe, "Plot"); + hframe->AddFrame( sAdcPlot,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + sAdcPlot->MapWindow(); + + + sAdcPlot->Connect("Toggled(Bool_t)","jctbAdc",this,"ToggledPlot(Bool_t)"); + + + + fColorSel = new TGColorSelect(hframe, id+1, 0); + hframe->AddFrame(fColorSel, new TGLayoutHints(kLHintsTop | + kLHintsLeft, 2, 0, 2, 2)); + + + fColorSel->SetColor(TColor::Number2Pixel(id+1)); + + +}; + +void jctbAdc::setAdcAlias(char *tit, int plot, int color) { + if (tit) + sAdcLabel->SetText(tit); + if (plot) + sAdcPlot->SetOn(kTRUE,kTRUE); + else + sAdcPlot->SetOn(kFALSE,kTRUE); + if (color>=0) + fColorSel->SetColor(color); + fColorSel->SetEnabled(sAdcPlot->IsOn()); +} + + +string jctbAdc::getAdcAlias() { + + char line[1000]; + sprintf(line,"ADC%d %s %d %x\n",id,sAdcLabel->GetText()->Data(),sAdcPlot->IsOn(),fColorSel->GetColor()); + return string(line); +} + +void jctbAdc::update() { + +} + + +void jctbAdc::ToggledPlot(Bool_t b){ + + Long_t mask=b<SetEnabled(b); + +} + +void jctbAdc::ToggledAdcPlot(Int_t b){ + + + Emit("ToggledAdcPlot(Int_t)", id); + +} + + + + + + + + +jctbAdcs::jctbAdcs(TGVerticalFrame *page, multiSlsDetector *det) + : TGGroupFrame(page,"Adcs",kVerticalFrame), myDet(det) { + + + SetTitlePos(TGGroupFrame::kLeft); + page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10)); + MapWindow(); + + char tit[100]; + + + TGHorizontalFrame* hframe=new TGHorizontalFrame(this, 800,800); + AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hframe->MapWindow(); + + + + + int idac=0; + + + + + + TGHorizontalFrame* hhframe=new TGHorizontalFrame(this, 800,800); + AddFrame(hhframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hhframe->MapWindow(); + + TGVerticalFrame *vframe; + + + + + for (idac=0; idacAddFrame(vframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + vframe->MapWindow(); + + + + } + + sAdc[idac]=new jctbAdc(vframe,idac,myDet); + } + + +} + +void jctbAdcs::update() { + + + ; + + + +} + +int jctbAdcs::setAdcAlias(string line) { + + int is=-1, plot=0, color=-1; + char tit[100]; + int narg=sscanf(line.c_str(),"ADC%d %s %d %x",&is,tit,&plot, &color); + if (narg<2) + return -1; + if (narg!=3) + color=-1; + if (is>=0 && issetAdcAlias(tit,plot,color); + } + return is; + +} + +string jctbAdcs::getAdcAlias() { + + ostringstream line; + + for (int is=0; isgetAdcAlias(); + + return line.str(); +} diff --git a/JCTBGui/jctbAdcs.h b/JCTBGui/jctbAdcs.h new file mode 100755 index 000000000..cc243547c --- /dev/null +++ b/JCTBGui/jctbAdcs.h @@ -0,0 +1,83 @@ +#ifndef JCTBADCS_H +#define JCTBADCS_H +#include + + +#define NADCS 32 + +class TRootEmbeddedCanvas; +class TGButtonGroup; +class TGVerticalFrame; +class TGHorizontalFrame; +class TGTextEntry; +class TGLabel; +class TGNumberEntry; +class TH2F; +class TGComboBox; +class TGCheckButton; +class TGColorSelect; + +class THStack; +class TGraphErrors; +class TGTextButton; +class TGTab; + +class TGraph; + +class multiSlsDetector; + +#include +using namespace std; + +class jctbAdc : public TGHorizontalFrame { + + + private: + + + TGLabel *sAdcLabel; + TGCheckButton *sAdcEnable; + TGCheckButton *sAdcPlot; + + TGColorSelect *fColorSel; + + TGraph *gADC; + + int id; + multiSlsDetector *myDet; + + public: + jctbAdc(TGVerticalFrame *page, int i, multiSlsDetector *det); + + + void setAdcAlias(char *tit, int plot, int color); + string getAdcAlias(); + void ToggledAdcPlot(Int_t b); + void ToggledPlot(Bool_t b); + + void update(); + + ClassDef(jctbAdc,0) + }; + + + +class jctbAdcs : public TGGroupFrame { +private: + + jctbAdc *sAdc[NADCS]; + + multiSlsDetector *myDet; + +public: + + jctbAdcs(TGVerticalFrame *page, multiSlsDetector *det); + int setAdcAlias(string line); + string getAdcAlias(); + + void update(); + + ClassDef(jctbAdcs,0) +}; + +#endif diff --git a/JCTBGui/jctbDac.cpp b/JCTBGui/jctbDac.cpp new file mode 100755 index 000000000..738c92ec8 --- /dev/null +++ b/JCTBGui/jctbDac.cpp @@ -0,0 +1,122 @@ + +#include +#include +#include +#include + +#include +#include +#include + +#include "jctbDac.h" +#include "multiSlsDetector.h" +#include "sls_detector_defs.h" + +using namespace std; + + + + +jctbDac::jctbDac(TGGroupFrame *page, int idac, multiSlsDetector *det) : TGHorizontalFrame(page, 800,50) , id(idac), myDet(det) { + + + TGHorizontalFrame *hframe=this; + + page->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 10,10,10,10)); + MapWindow(); + + char tit[100]; + + + sprintf(tit, "DAC %d:",idac); + + dacsLabel= new TGLabel(hframe, tit); + + hframe->AddFrame(dacsLabel,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5)); + dacsLabel->MapWindow(); + dacsLabel->SetTextJustify(kTextLeft); + + + dacsEntry = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 65535); + + hframe->AddFrame(dacsEntry,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5)); + dacsEntry->MapWindow(); + dacsEntry->Resize(150,30); + + + dacsUnit= new TGCheckButton(hframe, "mV"); + hframe->AddFrame( dacsUnit,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5)); + dacsUnit->MapWindow(); + + + + sprintf(tit, "xxx"); + dacsValue= new TGLabel(hframe, tit); + hframe->AddFrame( dacsValue,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 5, 5, 5, 5)); + dacsValue->MapWindow(); + dacsValue->SetTextJustify(kTextLeft); + + TGTextEntry *e=dacsEntry->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbDac",this,"setValue()"); + // cout << "(((((((((((((((((((((((((((((((" << dacsEntry->GetListOfSignals()->At(0)->IsA() << endl; + + +} + + + +int jctbDac::setLabel(char *tit, int mv) { + if(tit) + dacsLabel->SetText(tit); + if (mv>0) + dacsUnit->SetOn(kTRUE,kTRUE); + else if (mv==0) + dacsUnit->SetOn(kFALSE,kTRUE); + + + return id; + +} + +string jctbDac::getLabel() { + + ostringstream line; + + line << "DAC" << dec << id << " " << dacsUnit->IsOn() << endl; + + return line.str(); + +} + + +void jctbDac::setValue() { + + + + // cout << "setting dac! "<< id << endl; + + myDet->setDAC(dacsEntry->GetIntNumber(), (slsDetectorDefs::dacIndex)id, dacsUnit->IsOn()); + + getValue(); + +} + +int jctbDac::getValue() { + + int val=myDet->setDAC(-1, (slsDetectorDefs::dacIndex)id, dacsUnit->IsOn()); + char s[100]; + cout << "dac " << id << " " << val << endl; + sprintf(s,"%d",val); + + dacsValue->SetText(s); + + + return val; + +} + + + diff --git a/JCTBGui/jctbDac.h b/JCTBGui/jctbDac.h new file mode 100755 index 000000000..63c51a9e1 --- /dev/null +++ b/JCTBGui/jctbDac.h @@ -0,0 +1,44 @@ +#ifndef JCTBDAC_H +#define JCTBDAC_H +#include + + + +class TGTextEntry; +class TGLabel; +class TGNumberEntry; +class TGCheckButton; + + +class multiSlsDetector; + +#include +using namespace std; + +class jctbDac : public TGHorizontalFrame { + + + private: + TGLabel *dacsLabel; + TGNumberEntry *dacsEntry; + TGCheckButton *dacsUnit; + TGLabel *dacsValue; + int id; + + multiSlsDetector* myDet; + public: + jctbDac(TGGroupFrame*, int , multiSlsDetector*); + void setValue(); + int getValue(); + + + int setLabel(char *tit, int mv); + string getLabel(); + + + + ClassDef(jctbDac,0) +}; + + +#endif diff --git a/JCTBGui/jctbDacs.cpp b/JCTBGui/jctbDacs.cpp new file mode 100755 index 000000000..e8b32077b --- /dev/null +++ b/JCTBGui/jctbDacs.cpp @@ -0,0 +1,88 @@ + +#include +#include +#include + +#include "jctbDac.h" +#include "jctbDacs.h" +#include "multiSlsDetector.h" +#include "sls_detector_defs.h" + +using namespace std; + + + + + + +jctbDacs::jctbDacs(TGVerticalFrame *page, multiSlsDetector *det) : TGGroupFrame(page,"DACs",kVerticalFrame) , myDet(det){ + + + SetTitlePos(TGGroupFrame::kLeft); + page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10)); + MapWindow(); + + // cout << "window mapped " << endl; + + for (int idac=0; idac=0 && issetLabel(tit,mv); + return is; + +} + +string jctbDacs::getDacAlias() { + + ostringstream line; + + for (int i=0; igetLabel() << endl; + return line.str(); + +} + + + + +string jctbDacs::getDacParameters() { + + + ostringstream line; + + for (int i=0; igetValue << endl; + line << "dac:" << i << " " << dacs[i]->getValue() << endl; + } + return line.str(); + + +} + + + +void jctbDacs::update() { + + for (int idac=0; idacgetValue(); + + } + + +} diff --git a/JCTBGui/jctbDacs.h b/JCTBGui/jctbDacs.h new file mode 100755 index 000000000..5288bdbef --- /dev/null +++ b/JCTBGui/jctbDacs.h @@ -0,0 +1,40 @@ +#ifndef JCTBDACS_H +#define JCTBDACS_H +#include + + +#define NDACS 16 + + + + + +class multiSlsDetector; +class jctbDac; + +#include +using namespace std; + + +class jctbDacs : public TGGroupFrame { +private: + + + + jctbDac *dacs[NDACS]; + + multiSlsDetector* myDet; + +public: + jctbDacs(TGVerticalFrame *page, multiSlsDetector*); + + int setDacAlias(string line); + string getDacAlias(); + string getDacParameters(); + + void update(); + + ClassDef(jctbDacs,0) +}; + +#endif diff --git a/JCTBGui/jctbDict.cpp b/JCTBGui/jctbDict.cpp new file mode 100755 index 000000000..4be84fb37 --- /dev/null +++ b/JCTBGui/jctbDict.cpp @@ -0,0 +1,4274 @@ +// +// File generated by rootcint at Wed Nov 26 13:04:39 2014 + +// Do NOT change. Changes will be lost next time file is generated +// + +#define R__DICTIONARY_FILENAME jctbDict +#include "RConfig.h" //rootcint 4834 +#if !defined(R__ACCESS_IN_SYMBOL) +//Break the privacy of classes -- Disabled for the moment +#define private public +#define protected public +#endif + +// Since CINT ignores the std namespace, we need to do so in this file. +namespace std {} using namespace std; +#include "jctbDict.h" + +#include "TClass.h" +#include "TBuffer.h" +#include "TMemberInspector.h" +#include "TError.h" + +#ifndef G__ROOT +#define G__ROOT +#endif + +#include "RtypesImp.h" +#include "TIsAProxy.h" +#include "TFileMergeInfo.h" + +// START OF SHADOWS + +namespace ROOT { + namespace Shadow { + } // of namespace Shadow +} // of namespace ROOT +// END OF SHADOWS + +namespace ROOT { + void jctbSignal_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbSignal(void *p); + static void deleteArray_jctbSignal(void *p); + static void destruct_jctbSignal(void *p); + static void streamer_jctbSignal(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbSignal*) + { + ::jctbSignal *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbSignal >(0); + static ::ROOT::TGenericClassInfo + instance("jctbSignal", ::jctbSignal::Class_Version(), "./jctbSignal.h", 24, + typeid(::jctbSignal), DefineBehavior(ptr, ptr), + &::jctbSignal::Dictionary, isa_proxy, 0, + sizeof(::jctbSignal) ); + instance.SetDelete(&delete_jctbSignal); + instance.SetDeleteArray(&deleteArray_jctbSignal); + instance.SetDestructor(&destruct_jctbSignal); + instance.SetStreamerFunc(&streamer_jctbSignal); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbSignal*) + { + return GenerateInitInstanceLocal((::jctbSignal*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbSignal*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbSignals_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbSignals(void *p); + static void deleteArray_jctbSignals(void *p); + static void destruct_jctbSignals(void *p); + static void streamer_jctbSignals(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbSignals*) + { + ::jctbSignals *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbSignals >(0); + static ::ROOT::TGenericClassInfo + instance("jctbSignals", ::jctbSignals::Class_Version(), "./jctbSignals.h", 20, + typeid(::jctbSignals), DefineBehavior(ptr, ptr), + &::jctbSignals::Dictionary, isa_proxy, 0, + sizeof(::jctbSignals) ); + instance.SetDelete(&delete_jctbSignals); + instance.SetDeleteArray(&deleteArray_jctbSignals); + instance.SetDestructor(&destruct_jctbSignals); + instance.SetStreamerFunc(&streamer_jctbSignals); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbSignals*) + { + return GenerateInitInstanceLocal((::jctbSignals*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbSignals*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbLoop_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbLoop(void *p); + static void deleteArray_jctbLoop(void *p); + static void destruct_jctbLoop(void *p); + static void streamer_jctbLoop(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbLoop*) + { + ::jctbLoop *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbLoop >(0); + static ::ROOT::TGenericClassInfo + instance("jctbLoop", ::jctbLoop::Class_Version(), "./jctbPattern.h", 36, + typeid(::jctbLoop), DefineBehavior(ptr, ptr), + &::jctbLoop::Dictionary, isa_proxy, 0, + sizeof(::jctbLoop) ); + instance.SetDelete(&delete_jctbLoop); + instance.SetDeleteArray(&deleteArray_jctbLoop); + instance.SetDestructor(&destruct_jctbLoop); + instance.SetStreamerFunc(&streamer_jctbLoop); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbLoop*) + { + return GenerateInitInstanceLocal((::jctbLoop*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbLoop*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbWait_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbWait(void *p); + static void deleteArray_jctbWait(void *p); + static void destruct_jctbWait(void *p); + static void streamer_jctbWait(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbWait*) + { + ::jctbWait *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbWait >(0); + static ::ROOT::TGenericClassInfo + instance("jctbWait", ::jctbWait::Class_Version(), "./jctbPattern.h", 58, + typeid(::jctbWait), DefineBehavior(ptr, ptr), + &::jctbWait::Dictionary, isa_proxy, 0, + sizeof(::jctbWait) ); + instance.SetDelete(&delete_jctbWait); + instance.SetDeleteArray(&deleteArray_jctbWait); + instance.SetDestructor(&destruct_jctbWait); + instance.SetStreamerFunc(&streamer_jctbWait); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbWait*) + { + return GenerateInitInstanceLocal((::jctbWait*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbWait*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbPattern_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbPattern(void *p); + static void deleteArray_jctbPattern(void *p); + static void destruct_jctbPattern(void *p); + static void streamer_jctbPattern(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbPattern*) + { + ::jctbPattern *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbPattern >(0); + static ::ROOT::TGenericClassInfo + instance("jctbPattern", ::jctbPattern::Class_Version(), "./jctbPattern.h", 85, + typeid(::jctbPattern), DefineBehavior(ptr, ptr), + &::jctbPattern::Dictionary, isa_proxy, 0, + sizeof(::jctbPattern) ); + instance.SetDelete(&delete_jctbPattern); + instance.SetDeleteArray(&deleteArray_jctbPattern); + instance.SetDestructor(&destruct_jctbPattern); + instance.SetStreamerFunc(&streamer_jctbPattern); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbPattern*) + { + return GenerateInitInstanceLocal((::jctbPattern*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbPattern*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbDac_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbDac(void *p); + static void deleteArray_jctbDac(void *p); + static void destruct_jctbDac(void *p); + static void streamer_jctbDac(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbDac*) + { + ::jctbDac *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbDac >(0); + static ::ROOT::TGenericClassInfo + instance("jctbDac", ::jctbDac::Class_Version(), "./jctbDac.h", 18, + typeid(::jctbDac), DefineBehavior(ptr, ptr), + &::jctbDac::Dictionary, isa_proxy, 0, + sizeof(::jctbDac) ); + instance.SetDelete(&delete_jctbDac); + instance.SetDeleteArray(&deleteArray_jctbDac); + instance.SetDestructor(&destruct_jctbDac); + instance.SetStreamerFunc(&streamer_jctbDac); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbDac*) + { + return GenerateInitInstanceLocal((::jctbDac*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbDac*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbDacs_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbDacs(void *p); + static void deleteArray_jctbDacs(void *p); + static void destruct_jctbDacs(void *p); + static void streamer_jctbDacs(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbDacs*) + { + ::jctbDacs *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbDacs >(0); + static ::ROOT::TGenericClassInfo + instance("jctbDacs", ::jctbDacs::Class_Version(), "./jctbDacs.h", 19, + typeid(::jctbDacs), DefineBehavior(ptr, ptr), + &::jctbDacs::Dictionary, isa_proxy, 0, + sizeof(::jctbDacs) ); + instance.SetDelete(&delete_jctbDacs); + instance.SetDeleteArray(&deleteArray_jctbDacs); + instance.SetDestructor(&destruct_jctbDacs); + instance.SetStreamerFunc(&streamer_jctbDacs); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbDacs*) + { + return GenerateInitInstanceLocal((::jctbDacs*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbDacs*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbAdcs_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbAdcs(void *p); + static void deleteArray_jctbAdcs(void *p); + static void destruct_jctbAdcs(void *p); + static void streamer_jctbAdcs(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbAdcs*) + { + ::jctbAdcs *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbAdcs >(0); + static ::ROOT::TGenericClassInfo + instance("jctbAdcs", ::jctbAdcs::Class_Version(), "./jctbAdcs.h", 65, + typeid(::jctbAdcs), DefineBehavior(ptr, ptr), + &::jctbAdcs::Dictionary, isa_proxy, 0, + sizeof(::jctbAdcs) ); + instance.SetDelete(&delete_jctbAdcs); + instance.SetDeleteArray(&deleteArray_jctbAdcs); + instance.SetDestructor(&destruct_jctbAdcs); + instance.SetStreamerFunc(&streamer_jctbAdcs); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbAdcs*) + { + return GenerateInitInstanceLocal((::jctbAdcs*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbAdcs*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbAcquisition_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbAcquisition(void *p); + static void deleteArray_jctbAcquisition(void *p); + static void destruct_jctbAcquisition(void *p); + static void streamer_jctbAcquisition(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbAcquisition*) + { + ::jctbAcquisition *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbAcquisition >(0); + static ::ROOT::TGenericClassInfo + instance("jctbAcquisition", ::jctbAcquisition::Class_Version(), "./jctbAcquisition.h", 21, + typeid(::jctbAcquisition), DefineBehavior(ptr, ptr), + &::jctbAcquisition::Dictionary, isa_proxy, 0, + sizeof(::jctbAcquisition) ); + instance.SetDelete(&delete_jctbAcquisition); + instance.SetDeleteArray(&deleteArray_jctbAcquisition); + instance.SetDestructor(&destruct_jctbAcquisition); + instance.SetStreamerFunc(&streamer_jctbAcquisition); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbAcquisition*) + { + return GenerateInitInstanceLocal((::jctbAcquisition*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbAcquisition*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbMain_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbMain(void *p); + static void deleteArray_jctbMain(void *p); + static void destruct_jctbMain(void *p); + static void streamer_jctbMain(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbMain*) + { + ::jctbMain *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbMain >(0); + static ::ROOT::TGenericClassInfo + instance("jctbMain", ::jctbMain::Class_Version(), "./jctbMain.h", 41, + typeid(::jctbMain), DefineBehavior(ptr, ptr), + &::jctbMain::Dictionary, isa_proxy, 0, + sizeof(::jctbMain) ); + instance.SetDelete(&delete_jctbMain); + instance.SetDeleteArray(&deleteArray_jctbMain); + instance.SetDestructor(&destruct_jctbMain); + instance.SetStreamerFunc(&streamer_jctbMain); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbMain*) + { + return GenerateInitInstanceLocal((::jctbMain*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbMain*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +namespace ROOT { + void jctbAdc_ShowMembers(void *obj, TMemberInspector &R__insp); + static void delete_jctbAdc(void *p); + static void deleteArray_jctbAdc(void *p); + static void destruct_jctbAdc(void *p); + static void streamer_jctbAdc(TBuffer &buf, void *obj); + + // Function generating the singleton type initializer + static TGenericClassInfo *GenerateInitInstanceLocal(const ::jctbAdc*) + { + ::jctbAdc *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::jctbAdc >(0); + static ::ROOT::TGenericClassInfo + instance("jctbAdc", ::jctbAdc::Class_Version(), "./jctbAdcs.h", 32, + typeid(::jctbAdc), DefineBehavior(ptr, ptr), + &::jctbAdc::Dictionary, isa_proxy, 0, + sizeof(::jctbAdc) ); + instance.SetDelete(&delete_jctbAdc); + instance.SetDeleteArray(&deleteArray_jctbAdc); + instance.SetDestructor(&destruct_jctbAdc); + instance.SetStreamerFunc(&streamer_jctbAdc); + return &instance; + } + TGenericClassInfo *GenerateInitInstance(const ::jctbAdc*) + { + return GenerateInitInstanceLocal((::jctbAdc*)0); + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::jctbAdc*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} // end of namespace ROOT + +//______________________________________________________________________________ +TClass *jctbSignal::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbSignal::Class_Name() +{ + return "jctbSignal"; +} + +//______________________________________________________________________________ +const char *jctbSignal::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbSignal*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbSignal::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbSignal*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbSignal::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbSignal*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbSignal::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbSignal*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbSignals::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbSignals::Class_Name() +{ + return "jctbSignals"; +} + +//______________________________________________________________________________ +const char *jctbSignals::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbSignals*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbSignals::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbSignals*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbSignals::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbSignals*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbSignals::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbSignals*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbLoop::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbLoop::Class_Name() +{ + return "jctbLoop"; +} + +//______________________________________________________________________________ +const char *jctbLoop::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbLoop*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbLoop::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbLoop*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbLoop::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbLoop*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbLoop::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbLoop*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbWait::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbWait::Class_Name() +{ + return "jctbWait"; +} + +//______________________________________________________________________________ +const char *jctbWait::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbWait*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbWait::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbWait*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbWait::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbWait*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbWait::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbWait*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbPattern::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbPattern::Class_Name() +{ + return "jctbPattern"; +} + +//______________________________________________________________________________ +const char *jctbPattern::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbPattern*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbPattern::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbPattern*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbPattern::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbPattern*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbPattern::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbPattern*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbDac::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbDac::Class_Name() +{ + return "jctbDac"; +} + +//______________________________________________________________________________ +const char *jctbDac::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbDac*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbDac::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbDac*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbDac::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbDac*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbDac::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbDac*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbDacs::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbDacs::Class_Name() +{ + return "jctbDacs"; +} + +//______________________________________________________________________________ +const char *jctbDacs::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbDacs*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbDacs::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbDacs*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbDacs::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbDacs*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbDacs::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbDacs*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbAdcs::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbAdcs::Class_Name() +{ + return "jctbAdcs"; +} + +//______________________________________________________________________________ +const char *jctbAdcs::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbAdcs*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbAdcs::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbAdcs*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbAdcs::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbAdcs*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbAdcs::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbAdcs*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbAcquisition::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbAcquisition::Class_Name() +{ + return "jctbAcquisition"; +} + +//______________________________________________________________________________ +const char *jctbAcquisition::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbAcquisition*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbAcquisition::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbAcquisition*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbAcquisition::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbAcquisition*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbAcquisition::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbAcquisition*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbMain::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbMain::Class_Name() +{ + return "jctbMain"; +} + +//______________________________________________________________________________ +const char *jctbMain::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbMain*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbMain::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbMain*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbMain::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbMain*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbMain::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbMain*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *jctbAdc::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *jctbAdc::Class_Name() +{ + return "jctbAdc"; +} + +//______________________________________________________________________________ +const char *jctbAdc::ImplFileName() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbAdc*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int jctbAdc::ImplFileLine() +{ + return ::ROOT::GenerateInitInstanceLocal((const ::jctbAdc*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void jctbAdc::Dictionary() +{ + fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbAdc*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *jctbAdc::Class() +{ + if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::jctbAdc*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +void jctbMain::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbMain. + + TGMainFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbMain::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbMain. + TClass *R__cl = ::jctbMain::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEcanvas", &fEcanvas); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModulecanvas", &fModulecanvas); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*br", &br); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*mtab", &mtab); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*dacs", &dacs); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sig", &sig); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*adcs", &adcs); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*pat", &pat); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*acq", &acq); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuDock", &fMenuDock); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBar", &fMenuBar); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuFile", &fMenuFile); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuTest", &fMenuTest); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuView", &fMenuView); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuHelp", &fMenuHelp); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCascadeMenu", &fCascadeMenu); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCascade1Menu", &fCascade1Menu); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCascade2Menu", &fCascade2Menu); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuNew1", &fMenuNew1); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuNew2", &fMenuNew2); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarLayout", &fMenuBarLayout); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarItemLayout", &fMenuBarItemLayout); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMenuBarHelpLayout", &fMenuBarHelpLayout); + TGMainFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbMain(void *p) { + delete ((::jctbMain*)p); + } + static void deleteArray_jctbMain(void *p) { + delete [] ((::jctbMain*)p); + } + static void destruct_jctbMain(void *p) { + typedef ::jctbMain current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbMain(TBuffer &buf, void *obj) { + ((::jctbMain*)obj)->::jctbMain::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbMain + +//______________________________________________________________________________ +void jctbDacs::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbDacs. + + TGGroupFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbDacs::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbDacs. + TClass *R__cl = ::jctbDacs::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*dacs[16]", &dacs); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + TGGroupFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbDacs(void *p) { + delete ((::jctbDacs*)p); + } + static void deleteArray_jctbDacs(void *p) { + delete [] ((::jctbDacs*)p); + } + static void destruct_jctbDacs(void *p) { + typedef ::jctbDacs current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbDacs(TBuffer &buf, void *obj) { + ((::jctbDacs*)obj)->::jctbDacs::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbDacs + +//______________________________________________________________________________ +void jctbDac::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbDac. + + TGHorizontalFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbDac::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbDac. + TClass *R__cl = ::jctbDac::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*dacsLabel", &dacsLabel); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*dacsEntry", &dacsEntry); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*dacsUnit", &dacsUnit); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*dacsValue", &dacsValue); + R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &id); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + TGHorizontalFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbDac(void *p) { + delete ((::jctbDac*)p); + } + static void deleteArray_jctbDac(void *p) { + delete [] ((::jctbDac*)p); + } + static void destruct_jctbDac(void *p) { + typedef ::jctbDac current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbDac(TBuffer &buf, void *obj) { + ((::jctbDac*)obj)->::jctbDac::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbDac + +//______________________________________________________________________________ +void jctbSignals::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbSignals. + + TGGroupFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbSignals::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbSignals. + TClass *R__cl = ::jctbSignals::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*signals[64]", &signals); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eIOCntrlRegister", &eIOCntrlRegister); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eClkCntrlRegister", &eClkCntrlRegister); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + TGGroupFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbSignals(void *p) { + delete ((::jctbSignals*)p); + } + static void deleteArray_jctbSignals(void *p) { + delete [] ((::jctbSignals*)p); + } + static void destruct_jctbSignals(void *p) { + typedef ::jctbSignals current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbSignals(TBuffer &buf, void *obj) { + ((::jctbSignals*)obj)->::jctbSignals::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbSignals + +//______________________________________________________________________________ +void jctbSignal::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbSignal. + + TGHorizontalFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbSignal::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbSignal. + TClass *R__cl = ::jctbSignal::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sLabel", &sLabel); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sOutput", &sOutput); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sClock", &sClock); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sPlot", &sPlot); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sValue", &sValue); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sEntry", &sEntry); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSel", &fColorSel); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &id); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*hsig", &hsig); + TGHorizontalFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbSignal(void *p) { + delete ((::jctbSignal*)p); + } + static void deleteArray_jctbSignal(void *p) { + delete [] ((::jctbSignal*)p); + } + static void destruct_jctbSignal(void *p) { + typedef ::jctbSignal current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbSignal(TBuffer &buf, void *obj) { + ((::jctbSignal*)obj)->::jctbSignal::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbSignal + +//______________________________________________________________________________ +void jctbAdc::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbAdc. + + TGHorizontalFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbAdc::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbAdc. + TClass *R__cl = ::jctbAdc::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sAdcLabel", &sAdcLabel); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sAdcEnable", &sAdcEnable); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sAdcPlot", &sAdcPlot); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*fColorSel", &fColorSel); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*gADC", &gADC); + R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &id); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + TGHorizontalFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbAdc(void *p) { + delete ((::jctbAdc*)p); + } + static void deleteArray_jctbAdc(void *p) { + delete [] ((::jctbAdc*)p); + } + static void destruct_jctbAdc(void *p) { + typedef ::jctbAdc current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbAdc(TBuffer &buf, void *obj) { + ((::jctbAdc*)obj)->::jctbAdc::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbAdc + +//______________________________________________________________________________ +void jctbAdcs::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbAdcs. + + TGGroupFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbAdcs::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbAdcs. + TClass *R__cl = ::jctbAdcs::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*sAdc[32]", &sAdc); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + TGGroupFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbAdcs(void *p) { + delete ((::jctbAdcs*)p); + } + static void deleteArray_jctbAdcs(void *p) { + delete [] ((::jctbAdcs*)p); + } + static void destruct_jctbAdcs(void *p) { + typedef ::jctbAdcs current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbAdcs(TBuffer &buf, void *obj) { + ((::jctbAdcs*)obj)->::jctbAdcs::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbAdcs + +//______________________________________________________________________________ +void jctbLoop::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbLoop. + + TGHorizontalFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbLoop::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbLoop. + TClass *R__cl = ::jctbLoop::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eLoopStartAddr", &eLoopStartAddr); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eLoopStopAddr", &eLoopStopAddr); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eLoopNumber", &eLoopNumber); + R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &id); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + TGHorizontalFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbLoop(void *p) { + delete ((::jctbLoop*)p); + } + static void deleteArray_jctbLoop(void *p) { + delete [] ((::jctbLoop*)p); + } + static void destruct_jctbLoop(void *p) { + typedef ::jctbLoop current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbLoop(TBuffer &buf, void *obj) { + ((::jctbLoop*)obj)->::jctbLoop::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbLoop + +//______________________________________________________________________________ +void jctbWait::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbWait. + + TGHorizontalFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbWait::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbWait. + TClass *R__cl = ::jctbWait::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eWaitAddr", &eWaitAddr); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eWaitTime", &eWaitTime); + R__insp.Inspect(R__cl, R__insp.GetParent(), "id", &id); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + TGHorizontalFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbWait(void *p) { + delete ((::jctbWait*)p); + } + static void deleteArray_jctbWait(void *p) { + delete [] ((::jctbWait*)p); + } + static void destruct_jctbWait(void *p) { + typedef ::jctbWait current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbWait(TBuffer &buf, void *obj) { + ((::jctbWait*)obj)->::jctbWait::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbWait + +//______________________________________________________________________________ +void jctbPattern::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbPattern. + + TGGroupFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbPattern::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbPattern. + TClass *R__cl = ::jctbPattern::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eAdcClkFreq", &eAdcClkFreq); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eRunClkFreq", &eRunClkFreq); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eAdcClkPhase", &eAdcClkPhase); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eRunClkPhase", &eRunClkPhase); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eStartAddr", &eStartAddr); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eStopAddr", &eStopAddr); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eFrames", &eFrames); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*ePeriod", &ePeriod); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eLoop[3]", &eLoop); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eWait[3]", &eWait); + R__insp.Inspect(R__cl, R__insp.GetParent(), "pat[8192]", pat); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + TGGroupFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbPattern(void *p) { + delete ((::jctbPattern*)p); + } + static void deleteArray_jctbPattern(void *p) { + delete [] ((::jctbPattern*)p); + } + static void destruct_jctbPattern(void *p) { + typedef ::jctbPattern current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbPattern(TBuffer &buf, void *obj) { + ((::jctbPattern*)obj)->::jctbPattern::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbPattern + +//______________________________________________________________________________ +void jctbAcquisition::Streamer(TBuffer &R__b) +{ + // Stream an object of class jctbAcquisition. + + TGGroupFrame::Streamer(R__b); +} + +//______________________________________________________________________________ +void jctbAcquisition::ShowMembers(TMemberInspector &R__insp) +{ + // Inspect the data members of an object of class jctbAcquisition. + TClass *R__cl = ::jctbAcquisition::IsA(); + if (R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eOutdir", &eOutdir); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eFname", &eFname); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*eFindex", &eFindex); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*cFileSave", &cFileSave); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*bStatus", &bStatus); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*acqThread", &acqThread); + R__insp.Inspect(R__cl, R__insp.GetParent(), "*myDet", &myDet); + R__insp.Inspect(R__cl, R__insp.GetParent(), "StopFlag", &StopFlag); + TGGroupFrame::ShowMembers(R__insp); +} + +namespace ROOT { + // Wrapper around operator delete + static void delete_jctbAcquisition(void *p) { + delete ((::jctbAcquisition*)p); + } + static void deleteArray_jctbAcquisition(void *p) { + delete [] ((::jctbAcquisition*)p); + } + static void destruct_jctbAcquisition(void *p) { + typedef ::jctbAcquisition current_t; + ((current_t*)p)->~current_t(); + } + // Wrapper around a custom streamer member function. + static void streamer_jctbAcquisition(TBuffer &buf, void *obj) { + ((::jctbAcquisition*)obj)->::jctbAcquisition::Streamer(buf); + } +} // end of namespace ROOT for class ::jctbAcquisition + +/******************************************************** +* jctbDict.cpp +* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED +* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX(). +* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE. +********************************************************/ + +#ifdef G__MEMTEST +#undef malloc +#undef free +#endif + +#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3)) +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif + +extern "C" void G__cpp_reset_tagtablejctbDict(); + +extern "C" void G__set_cpp_environmentjctbDict() { + G__add_compiledheader("TObject.h"); + G__add_compiledheader("TMemberInspector.h"); + G__add_compiledheader("jctbSignals.h"); + G__add_compiledheader("jctbSignal.h"); + G__add_compiledheader("jctbPattern.h"); + G__add_compiledheader("jctbDacs.h"); + G__add_compiledheader("jctbDac.h"); + G__add_compiledheader("jctbMain.h"); + G__add_compiledheader("jctbAdcs.h"); + G__add_compiledheader("jctbAcquisition.h"); + G__cpp_reset_tagtablejctbDict(); +} +#include +extern "C" int G__cpp_dllrevjctbDict() { return(30051515); } + +/********************************************************* +* Member function Interface Method +*********************************************************/ + +/* jctbSignal */ +static int G__jctbDict_290_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbSignal* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 3 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbSignal( +(TGFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } else { + p = new((void*) gvp) jctbSignal( +(TGFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbSignal)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbSignal*) G__getstructoffset())->setSignalAlias((char*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (int) G__int(libp->para[2]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + string* pobj; + string xobj = ((jctbSignal*) G__getstructoffset())->getSignalAlias(); + pobj = new string(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) ((jctbSignal*) G__getstructoffset())->getPlot()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbSignal*) G__getstructoffset())->setOutput((Long64_t) G__Longlong(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbSignal*) G__getstructoffset())->setClock((Long64_t) G__Longlong(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignal*) G__getstructoffset())->ToggledOutput((Bool_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignal*) G__getstructoffset())->ToggledClock((Bool_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignal*) G__getstructoffset())->ToggledPlot((Bool_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbSignal*) G__getstructoffset())->isClock()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbSignal*) G__getstructoffset())->isOutput()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbSignal*) G__getstructoffset())->isPlot()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignal*) G__getstructoffset())->ToggledSignalOutput((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignal*) G__getstructoffset())->ToggledSignalClock((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignal*) G__getstructoffset())->ToggledSignalPlot((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbSignal::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbSignal::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbSignal::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbSignal::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbSignal::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbSignal::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbSignal::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_290_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbSignal::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbSignal G__TjctbSignal; +static int G__jctbDict_290_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbSignal*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbSignal*) (soff+(sizeof(jctbSignal)*i)))->~G__TjctbSignal(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbSignal*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbSignal*) (soff))->~G__TjctbSignal(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbSignals */ +static int G__jctbDict_291_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbSignals* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 2 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbSignals((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } else { + p = new((void*) gvp) jctbSignals((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbSignals)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbSignals*) G__getstructoffset())->setSignalAlias(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + string* pobj; + string xobj = ((jctbSignals*) G__getstructoffset())->getSignalAlias(); + pobj = new string(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignals*) G__getstructoffset())->update(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignals*) G__getstructoffset())->ToggledOutReg((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignals*) G__getstructoffset())->ToggledClockReg((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignals*) G__getstructoffset())->ToggledPlot((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbSignals::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbSignals::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbSignals::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbSignals::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbSignals*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbSignals::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbSignals::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbSignals::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_291_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbSignals::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbSignals G__TjctbSignals; +static int G__jctbDict_291_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbSignals*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbSignals*) (soff+(sizeof(jctbSignals)*i)))->~G__TjctbSignals(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbSignals*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbSignals*) (soff))->~G__TjctbSignals(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbLoop */ +static int G__jctbDict_305_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbLoop* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 3 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbLoop( +(TGGroupFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } else { + p = new((void*) gvp) jctbLoop( +(TGGroupFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbLoop)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbLoop*) G__getstructoffset())->setNLoops(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbLoop*) G__getstructoffset())->update(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbLoop::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbLoop::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbLoop::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbLoop::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbLoop*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbLoop::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbLoop::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbLoop::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_305_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbLoop::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbLoop G__TjctbLoop; +static int G__jctbDict_305_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbLoop*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbLoop*) (soff+(sizeof(jctbLoop)*i)))->~G__TjctbLoop(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbLoop*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbLoop*) (soff))->~G__TjctbLoop(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbWait */ +static int G__jctbDict_306_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbWait* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 3 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbWait( +(TGGroupFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } else { + p = new((void*) gvp) jctbWait( +(TGGroupFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbWait)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbWait*) G__getstructoffset())->setWaitTime(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbWait*) G__getstructoffset())->update(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbWait::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbWait::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbWait::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbWait::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbWait*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbWait::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbWait::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbWait::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_306_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbWait::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbWait G__TjctbWait; +static int G__jctbDict_306_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbWait*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbWait*) (soff+(sizeof(jctbWait)*i)))->~G__TjctbWait(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbWait*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbWait*) (soff))->~G__TjctbWait(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbPattern */ +static int G__jctbDict_307_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbPattern* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 2 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbPattern((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } else { + p = new((void*) gvp) jctbPattern((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbPattern)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbPattern*) G__getstructoffset())->update(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbPattern*) G__getstructoffset())->setAdcFreq(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbPattern*) G__getstructoffset())->setRunFreq(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbPattern*) G__getstructoffset())->setAdcPhase(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbPattern*) G__getstructoffset())->setRunPhase(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbPattern*) G__getstructoffset())->setFrames(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbPattern*) G__getstructoffset())->setPeriod(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbPattern::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbPattern::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbPattern::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbPattern::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbPattern*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbPattern::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbPattern::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbPattern::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_307_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbPattern::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbPattern G__TjctbPattern; +static int G__jctbDict_307_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbPattern*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbPattern*) (soff+(sizeof(jctbPattern)*i)))->~G__TjctbPattern(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbPattern*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbPattern*) (soff))->~G__TjctbPattern(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbDac */ +static int G__jctbDict_308_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbDac* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 3 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbDac( +(TGGroupFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } else { + p = new((void*) gvp) jctbDac( +(TGGroupFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbDac)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbDac*) G__getstructoffset())->setValue(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbDac*) G__getstructoffset())->getValue()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbDac*) G__getstructoffset())->setLabel((char*) G__int(libp->para[0]), (int) G__int(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + string* pobj; + string xobj = ((jctbDac*) G__getstructoffset())->getLabel(); + pobj = new string(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbDac::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbDac::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbDac::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbDac::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbDac*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbDac::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbDac::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbDac::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_308_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbDac::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbDac G__TjctbDac; +static int G__jctbDict_308_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbDac*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbDac*) (soff+(sizeof(jctbDac)*i)))->~G__TjctbDac(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbDac*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbDac*) (soff))->~G__TjctbDac(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbDacs */ +static int G__jctbDict_309_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbDacs* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 2 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbDacs((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } else { + p = new((void*) gvp) jctbDacs((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbDacs)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbDacs*) G__getstructoffset())->setDacAlias(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + string* pobj; + string xobj = ((jctbDacs*) G__getstructoffset())->getDacAlias(); + pobj = new string(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + string* pobj; + string xobj = ((jctbDacs*) G__getstructoffset())->getDacParameters(); + pobj = new string(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbDacs*) G__getstructoffset())->update(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbDacs::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbDacs::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbDacs::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbDacs::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbDacs*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbDacs::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbDacs::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbDacs::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_309_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbDacs::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbDacs G__TjctbDacs; +static int G__jctbDict_309_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbDacs*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbDacs*) (soff+(sizeof(jctbDacs)*i)))->~G__TjctbDacs(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbDacs*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbDacs*) (soff))->~G__TjctbDacs(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbAdcs */ +static int G__jctbDict_313_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbAdcs* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 2 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbAdcs((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } else { + p = new((void*) gvp) jctbAdcs((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbAdcs*) G__getstructoffset())->setAdcAlias(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + string* pobj; + string xobj = ((jctbAdcs*) G__getstructoffset())->getAdcAlias(); + pobj = new string(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAdcs*) G__getstructoffset())->update(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbAdcs::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAdcs::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbAdcs::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbAdcs::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAdcs*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAdcs::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbAdcs::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAdcs::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_313_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbAdcs::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbAdcs G__TjctbAdcs; +static int G__jctbDict_313_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbAdcs*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbAdcs*) (soff+(sizeof(jctbAdcs)*i)))->~G__TjctbAdcs(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbAdcs*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbAdcs*) (soff))->~G__TjctbAdcs(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbAcquisition */ +static int G__jctbDict_314_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbAcquisition* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 2 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbAcquisition((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } else { + p = new((void*) gvp) jctbAcquisition((TGVerticalFrame*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->setOutdir(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->setFname(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->setFsave((Bool_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->setFindex(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->toggleAcquisition(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 89, (long) jctbAcquisition::ThreadHandle((void*) G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->update(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->acquisitionFinished(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->startAcquisition(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbAcquisition::progressCallback((double) G__double(libp->para[0]), (void*) G__int(libp->para[1]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbAcquisition::dataCallback((detectorData*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (void*) G__int(libp->para[2]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbAcquisition::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAcquisition::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbAcquisition::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbAcquisition::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAcquisition*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAcquisition::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbAcquisition::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAcquisition::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_314_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbAcquisition::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbAcquisition G__TjctbAcquisition; +static int G__jctbDict_314_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbAcquisition*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbAcquisition*) (soff+(sizeof(jctbAcquisition)*i)))->~G__TjctbAcquisition(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbAcquisition*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbAcquisition*) (soff))->~G__TjctbAcquisition(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbMain */ +static int G__jctbDict_315_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbMain* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 2 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbMain((TGWindow*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } else { + p = new((void*) gvp) jctbMain((TGWindow*) G__int(libp->para[0]), (multiSlsDetector*) G__int(libp->para[1])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbMain)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbMain*) G__getstructoffset())->loadAlias(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbMain*) G__getstructoffset())->saveAlias(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbMain*) G__getstructoffset())->loadParameters(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbMain*) G__getstructoffset())->saveParameters(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbMain*) G__getstructoffset())->loadConfiguration(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) ((jctbMain*) G__getstructoffset())->saveConfiguration(*((string*) G__int(libp->para[0])))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbMain*) G__getstructoffset())->tabSelected((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbMain*) G__getstructoffset())->HandleMenu((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbMain::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbMain::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbMain::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbMain::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbMain*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbMain::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbMain::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbMain::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_315_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbMain::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbMain G__TjctbMain; +static int G__jctbDict_315_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbMain*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbMain*) (soff+(sizeof(jctbMain)*i)))->~G__TjctbMain(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbMain*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbMain*) (soff))->~G__TjctbMain(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* jctbAdc */ +static int G__jctbDict_317_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbAdc* p = NULL; + char* gvp = (char*) G__getgvp(); + //m: 3 + if ((gvp == (char*)G__PVOID) || (gvp == 0)) { + p = new jctbAdc( +(TGVerticalFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } else { + p = new((void*) gvp) jctbAdc( +(TGVerticalFrame*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (multiSlsDetector*) G__int(libp->para[2])); + } + result7->obj.i = (long) p; + result7->ref = (long) p; + G__set_tagnum(result7,G__get_linked_tagnum(&G__jctbDictLN_jctbAdc)); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAdc*) G__getstructoffset())->setAdcAlias((char*) G__int(libp->para[0]), (int) G__int(libp->para[1]) +, (int) G__int(libp->para[2])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + { + string* pobj; + string xobj = ((jctbAdc*) G__getstructoffset())->getAdcAlias(); + pobj = new string(xobj); + result7->obj.i = (long) ((void*) pobj); + result7->ref = result7->obj.i; + G__store_tempobject(*result7); + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAdc*) G__getstructoffset())->ToggledAdcPlot((Int_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAdc*) G__getstructoffset())->ToggledPlot((Bool_t) G__int(libp->para[0])); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAdc*) G__getstructoffset())->update(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 85, (long) jctbAdc::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAdc::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 115, (long) jctbAdc::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + jctbAdc::Dictionary(); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + ((jctbAdc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAdc::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbAdc::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 67, (long) jctbAdc::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__jctbDict_317_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + G__letint(result7, 105, (long) jctbAdc::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef jctbAdc G__TjctbAdc; +static int G__jctbDict_317_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash) +{ + char* gvp = (char*) G__getgvp(); + long soff = G__getstructoffset(); + int n = G__getaryconstruct(); + // + //has_a_delete: 1 + //has_own_delete1arg: 0 + //has_own_delete2arg: 0 + // + if (!soff) { + return(1); + } + if (n) { + if (gvp == (char*)G__PVOID) { + delete[] (jctbAdc*) soff; + } else { + G__setgvp((long) G__PVOID); + for (int i = n - 1; i >= 0; --i) { + ((jctbAdc*) (soff+(sizeof(jctbAdc)*i)))->~G__TjctbAdc(); + } + G__setgvp((long)gvp); + } + } else { + if (gvp == (char*)G__PVOID) { + delete (jctbAdc*) soff; + } else { + G__setgvp((long) G__PVOID); + ((jctbAdc*) (soff))->~G__TjctbAdc(); + G__setgvp((long)gvp); + } + } + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* Setting up global function */ + +/********************************************************* +* Member function Stub +*********************************************************/ + +/* jctbSignal */ + +/* jctbSignals */ + +/* jctbLoop */ + +/* jctbWait */ + +/* jctbPattern */ + +/* jctbDac */ + +/* jctbDacs */ + +/* jctbAdcs */ + +/* jctbAcquisition */ + +/* jctbMain */ + +/* jctbAdc */ + +/********************************************************* +* Global function Stub +*********************************************************/ + +/********************************************************* +* Get size of pointer to member function +*********************************************************/ +class G__Sizep2memfuncjctbDict { + public: + G__Sizep2memfuncjctbDict(): p(&G__Sizep2memfuncjctbDict::sizep2memfunc) {} + size_t sizep2memfunc() { return(sizeof(p)); } + private: + size_t (G__Sizep2memfuncjctbDict::*p)(); +}; + +size_t G__get_sizep2memfuncjctbDict() +{ + G__Sizep2memfuncjctbDict a; + G__setsizep2memfunc((int)a.sizep2memfunc()); + return((size_t)a.sizep2memfunc()); +} + + +/********************************************************* +* virtual base class offset calculation interface +*********************************************************/ + + /* Setting up class inheritance */ + +/********************************************************* +* Inheritance information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_inheritancejctbDict() { + + /* Setting up class inheritance */ + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal))) { + jctbSignal *G__Lderived; + G__Lderived=(jctbSignal*)0x1000; + { + TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal),G__get_linked_tagnum(&G__jctbDictLN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals))) { + jctbSignals *G__Lderived; + G__Lderived=(jctbSignals*)0x1000; + { + TGGroupFrame *G__Lpbase=(TGGroupFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals),G__get_linked_tagnum(&G__jctbDictLN_TGGroupFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop))) { + jctbLoop *G__Lderived; + G__Lderived=(jctbLoop*)0x1000; + { + TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop),G__get_linked_tagnum(&G__jctbDictLN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbWait))) { + jctbWait *G__Lderived; + G__Lderived=(jctbWait*)0x1000; + { + TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait),G__get_linked_tagnum(&G__jctbDictLN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern))) { + jctbPattern *G__Lderived; + G__Lderived=(jctbPattern*)0x1000; + { + TGGroupFrame *G__Lpbase=(TGGroupFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern),G__get_linked_tagnum(&G__jctbDictLN_TGGroupFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbDac))) { + jctbDac *G__Lderived; + G__Lderived=(jctbDac*)0x1000; + { + TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac),G__get_linked_tagnum(&G__jctbDictLN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs))) { + jctbDacs *G__Lderived; + G__Lderived=(jctbDacs*)0x1000; + { + TGGroupFrame *G__Lpbase=(TGGroupFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs),G__get_linked_tagnum(&G__jctbDictLN_TGGroupFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs))) { + jctbAdcs *G__Lderived; + G__Lderived=(jctbAdcs*)0x1000; + { + TGGroupFrame *G__Lpbase=(TGGroupFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs),G__get_linked_tagnum(&G__jctbDictLN_TGGroupFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition))) { + jctbAcquisition *G__Lderived; + G__Lderived=(jctbAcquisition*)0x1000; + { + TGGroupFrame *G__Lpbase=(TGGroupFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition),G__get_linked_tagnum(&G__jctbDictLN_TGGroupFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbMain))) { + jctbMain *G__Lderived; + G__Lderived=(jctbMain*)0x1000; + { + TGMainFrame *G__Lpbase=(TGMainFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain),G__get_linked_tagnum(&G__jctbDictLN_TGMainFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc))) { + jctbAdc *G__Lderived; + G__Lderived=(jctbAdc*)0x1000; + { + TGHorizontalFrame *G__Lpbase=(TGHorizontalFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc),G__get_linked_tagnum(&G__jctbDictLN_TGHorizontalFrame),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TGCompositeFrame *G__Lpbase=(TGCompositeFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc),G__get_linked_tagnum(&G__jctbDictLN_TGCompositeFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGFrame *G__Lpbase=(TGFrame*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc),G__get_linked_tagnum(&G__jctbDictLN_TGFrame),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGWindow *G__Lpbase=(TGWindow*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc),G__get_linked_tagnum(&G__jctbDictLN_TGWindow),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TGObject *G__Lpbase=(TGObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc),G__get_linked_tagnum(&G__jctbDictLN_TGObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc),G__get_linked_tagnum(&G__jctbDictLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + TQObject *G__Lpbase=(TQObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc),G__get_linked_tagnum(&G__jctbDictLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + } +} + +/********************************************************* +* typedef information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_typetablejctbDict() { + + /* Setting up typedef entry */ + G__search_typename2("Int_t",105,-1,0,-1); + G__setnewtype(-1,"Signed integer 4 bytes (int)",0); + G__search_typename2("Bool_t",103,-1,0,-1); + G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0); + G__search_typename2("Version_t",115,-1,0,-1); + G__setnewtype(-1,"Class version identifier (short)",0); + G__search_typename2("Long64_t",110,-1,0,-1); + G__setnewtype(-1,"Portable signed long integer 8 bytes",0); + G__search_typename2("vector",117,G__get_linked_tagnum(&G__jctbDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__jctbDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__jctbDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__jctbDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__jctbDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("vector",117,G__get_linked_tagnum(&G__jctbDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__jctbDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__jctbDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__jctbDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__jctbDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR)); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__jctbDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__jctbDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__jctbDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__jctbDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); +} + +/********************************************************* +* Data Member information setup/ +*********************************************************/ + + /* Setting up class,struct,union tag member variable */ + + /* jctbSignal */ +static void G__setup_memvarjctbSignal(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal)); + { jctbSignal *p; p=(jctbSignal*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGLabel),-1,-1,4,"sLabel=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGCheckButton),-1,-1,4,"sOutput=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGCheckButton),-1,-1,4,"sClock=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGCheckButton),-1,-1,4,"sPlot=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGLabel),-1,-1,4,"sValue=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"sEntry=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGColorSelect),-1,-1,4,"fColorSel=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"id=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TH1I),-1,-1,4,"hsig=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbSignals */ +static void G__setup_memvarjctbSignals(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals)); + { jctbSignals *p; p=(jctbSignals*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbSignal),-1,-1,4,"signals[64]=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eIOCntrlRegister=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eClkCntrlRegister=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbLoop */ +static void G__setup_memvarjctbLoop(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop)); + { jctbLoop *p; p=(jctbLoop*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eLoopStartAddr=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eLoopStopAddr=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eLoopNumber=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"id=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbWait */ +static void G__setup_memvarjctbWait(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait)); + { jctbWait *p; p=(jctbWait*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eWaitAddr=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eWaitTime=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"id=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbPattern */ +static void G__setup_memvarjctbPattern(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern)); + { jctbPattern *p; p=(jctbPattern*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eAdcClkFreq=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eRunClkFreq=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eAdcClkPhase=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eRunClkPhase=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eStartAddr=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eStopAddr=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eFrames=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"ePeriod=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbLoop),-1,-1,4,"eLoop[3]=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbWait),-1,-1,4,"eWait[3]=",0,(char*)NULL); + G__memvar_setup((void*)0,99,0,0,-1,-1,-1,4,"pat[8192]=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbDac */ +static void G__setup_memvarjctbDac(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac)); + { jctbDac *p; p=(jctbDac*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGLabel),-1,-1,4,"dacsLabel=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"dacsEntry=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGCheckButton),-1,-1,4,"dacsUnit=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGLabel),-1,-1,4,"dacsValue=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"id=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbDacs */ +static void G__setup_memvarjctbDacs(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs)); + { jctbDacs *p; p=(jctbDacs*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbDac),-1,-1,4,"dacs[16]=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbAdcs */ +static void G__setup_memvarjctbAdcs(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs)); + { jctbAdcs *p; p=(jctbAdcs*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbAdc),-1,-1,4,"sAdc[32]=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbAcquisition */ +static void G__setup_memvarjctbAcquisition(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition)); + { jctbAcquisition *p; p=(jctbAcquisition*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGTextEntry),-1,-1,4,"eOutdir=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGTextEntry),-1,-1,4,"eFname=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGNumberEntry),-1,-1,4,"eFindex=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGCheckButton),-1,-1,4,"cFileSave=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGTextButton),-1,-1,4,"bStatus=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TThread),-1,-1,4,"acqThread=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)((long)(&p->StopFlag)-(long)(p)),105,0,0,-1,-1,-1,1,"StopFlag=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbMain */ +static void G__setup_memvarjctbMain(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain)); + { jctbMain *p; p=(jctbMain*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TRootEmbeddedCanvas),-1,-1,4,"fEcanvas=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TRootEmbeddedCanvas),-1,-1,4,"fModulecanvas=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGButtonGroup),-1,-1,4,"br=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGTab),-1,-1,4,"mtab=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbDacs),-1,-1,4,"dacs=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbSignals),-1,-1,4,"sig=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs),-1,-1,4,"adcs=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbPattern),-1,-1,4,"pat=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition),-1,-1,4,"acq=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGDockableFrame),-1,-1,4,"fMenuDock=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGMenuBar),-1,-1,4,"fMenuBar=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fMenuFile=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fMenuTest=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fMenuView=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fMenuHelp=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fCascadeMenu=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fCascade1Menu=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fCascade2Menu=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fMenuNew1=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGPopupMenu),-1,-1,4,"fMenuNew2=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGLayoutHints),-1,-1,4,"fMenuBarLayout=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGLayoutHints),-1,-1,4,"fMenuBarItemLayout=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGLayoutHints),-1,-1,4,"fMenuBarHelpLayout=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* jctbAdc */ +static void G__setup_memvarjctbAdc(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc)); + { jctbAdc *p; p=(jctbAdc*)0x1000; if (p) { } + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGLabel),-1,-1,4,"sAdcLabel=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGCheckButton),-1,-1,4,"sAdcEnable=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGCheckButton),-1,-1,4,"sAdcPlot=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGColorSelect),-1,-1,4,"fColorSel=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TGraph),-1,-1,4,"gADC=",0,(char*)NULL); + G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"id=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_multiSlsDetector),-1,-1,4,"myDet=",0,(char*)NULL); + G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__jctbDictLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + +extern "C" void G__cpp_setup_memvarjctbDict() { +} +/*********************************************************** +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +***********************************************************/ + +/********************************************************* +* Member function information setup for each class +*********************************************************/ +static void G__setup_memfuncjctbSignal(void) { + /* jctbSignal */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignal)); + G__memfunc_setup("jctbSignal",1025,G__jctbDict_290_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbSignal), -1, 0, 3, 1, 1, 0, +"U 'TGFrame' - 0 - page i - - 0 - i " +"U 'multiSlsDetector' - 0 - det", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setSignalAlias",1428,G__jctbDict_290_0_2, 105, -1, -1, 0, 3, 1, 1, 0, +"C - - 0 - tit i - - 0 - plot " +"i - - 0 - col", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getSignalAlias",1416,G__jctbDict_290_0_3, 117, G__get_linked_tagnum(&G__jctbDictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getPlot",735,G__jctbDict_290_0_4, 85, G__get_linked_tagnum(&G__jctbDictLN_TH1I), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setOutput",989,G__jctbDict_290_0_5, 105, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setClock",824,G__jctbDict_290_0_6, 105, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledOutput",1367,G__jctbDict_290_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledClock",1202,G__jctbDict_290_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledPlot",1125,G__jctbDict_290_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("isClock",712,G__jctbDict_290_0_10, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("isOutput",877,G__jctbDict_290_0_11, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("isPlot",635,G__jctbDict_290_0_12, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledSignalOutput",1973,G__jctbDict_290_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "*SIGNAL*", (void*) NULL, 0); + G__memfunc_setup("ToggledSignalClock",1808,G__jctbDict_290_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "*SIGNAL*", (void*) NULL, 0); + G__memfunc_setup("ToggledSignalPlot",1731,G__jctbDict_290_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "*SIGNAL*", (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_290_0_16, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbSignal::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_290_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbSignal::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_290_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbSignal::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_290_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbSignal::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_290_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_290_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbSignal::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_290_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbSignal::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_290_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbSignal::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_290_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbSignal::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbSignal", 1151, G__jctbDict_290_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbSignals(void) { + /* jctbSignals */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbSignals)); + G__memfunc_setup("jctbSignals",1140,G__jctbDict_291_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbSignals), -1, 0, 2, 1, 1, 0, +"U 'TGVerticalFrame' - 0 - page U 'multiSlsDetector' - 0 - det", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setSignalAlias",1428,G__jctbDict_291_0_2, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - line", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getSignalAlias",1416,G__jctbDict_291_0_3, 117, G__get_linked_tagnum(&G__jctbDictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("update",643,G__jctbDict_291_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledOutReg",1308,G__jctbDict_291_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledClockReg",1488,G__jctbDict_291_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledPlot",1125,G__jctbDict_291_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_291_0_8, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbSignals::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_291_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbSignals::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_291_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbSignals::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_291_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbSignals::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_291_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_291_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbSignals::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_291_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbSignals::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_291_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbSignals::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_291_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbSignals::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbSignals", 1266, G__jctbDict_291_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbLoop(void) { + /* jctbLoop */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbLoop)); + G__memfunc_setup("jctbLoop",829,G__jctbDict_305_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbLoop), -1, 0, 3, 1, 1, 0, +"U 'TGGroupFrame' - 0 - page i - - 0 - i " +"U 'multiSlsDetector' - 0 - det", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setNLoops",935,G__jctbDict_305_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("update",643,G__jctbDict_305_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_305_0_4, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbLoop::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_305_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbLoop::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_305_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbLoop::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_305_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbLoop::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_305_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_305_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbLoop::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_305_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbLoop::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_305_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbLoop::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_305_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbLoop::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbLoop", 955, G__jctbDict_305_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbWait(void) { + /* jctbWait */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbWait)); + G__memfunc_setup("jctbWait",824,G__jctbDict_306_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbWait), -1, 0, 3, 1, 1, 0, +"U 'TGGroupFrame' - 0 - page i - - 0 - i " +"U 'multiSlsDetector' - 0 - det", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setWaitTime",1136,G__jctbDict_306_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("update",643,G__jctbDict_306_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_306_0_4, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbWait::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_306_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbWait::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_306_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbWait::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_306_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbWait::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_306_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_306_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbWait::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_306_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbWait::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_306_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbWait::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_306_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbWait::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbWait", 950, G__jctbDict_306_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbPattern(void) { + /* jctbPattern */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbPattern)); + G__memfunc_setup("jctbPattern",1153,G__jctbDict_307_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbPattern), -1, 0, 2, 1, 1, 0, +"U 'TGVerticalFrame' - 0 - page U 'multiSlsDetector' - 0 - det", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("update",643,G__jctbDict_307_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setAdcFreq",994,G__jctbDict_307_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setRunFreq",1039,G__jctbDict_307_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setAdcPhase",1093,G__jctbDict_307_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setRunPhase",1138,G__jctbDict_307_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setFrames",938,G__jctbDict_307_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setPeriod",943,G__jctbDict_307_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_307_0_9, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbPattern::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_307_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbPattern::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_307_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbPattern::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_307_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbPattern::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_307_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_307_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbPattern::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_307_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbPattern::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_307_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbPattern::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_307_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbPattern::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbPattern", 1279, G__jctbDict_307_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbDac(void) { + /* jctbDac */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDac)); + G__memfunc_setup("jctbDac",683,G__jctbDict_308_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbDac), -1, 0, 3, 1, 1, 0, +"U 'TGGroupFrame' - 0 - - i - - 0 - - " +"U 'multiSlsDetector' - 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setValue",841,G__jctbDict_308_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getValue",829,G__jctbDict_308_0_3, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setLabel",812,G__jctbDict_308_0_4, 105, -1, -1, 0, 2, 1, 1, 0, +"C - - 0 - tit i - - 0 - mv", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getLabel",800,G__jctbDict_308_0_5, 117, G__get_linked_tagnum(&G__jctbDictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_308_0_6, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbDac::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_308_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbDac::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_308_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbDac::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_308_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbDac::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_308_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_308_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbDac::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_308_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbDac::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_308_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbDac::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_308_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbDac::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbDac", 809, G__jctbDict_308_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbDacs(void) { + /* jctbDacs */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbDacs)); + G__memfunc_setup("jctbDacs",798,G__jctbDict_309_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbDacs), -1, 0, 2, 1, 1, 0, +"U 'TGVerticalFrame' - 0 - page U 'multiSlsDetector' - 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setDacAlias",1086,G__jctbDict_309_0_2, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - line", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getDacAlias",1074,G__jctbDict_309_0_3, 117, G__get_linked_tagnum(&G__jctbDictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getDacParameters",1628,G__jctbDict_309_0_4, 117, G__get_linked_tagnum(&G__jctbDictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("update",643,G__jctbDict_309_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_309_0_6, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbDacs::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_309_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbDacs::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_309_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbDacs::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_309_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbDacs::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_309_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_309_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbDacs::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_309_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbDacs::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_309_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbDacs::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_309_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbDacs::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbDacs", 924, G__jctbDict_309_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbAdcs(void) { + /* jctbAdcs */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs)); + G__memfunc_setup("jctbAdcs",798,G__jctbDict_313_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbAdcs), -1, 0, 2, 1, 1, 0, +"U 'TGVerticalFrame' - 0 - page U 'multiSlsDetector' - 0 - det", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setAdcAlias",1086,G__jctbDict_313_0_2, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - line", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getAdcAlias",1074,G__jctbDict_313_0_3, 117, G__get_linked_tagnum(&G__jctbDictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("update",643,G__jctbDict_313_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_313_0_5, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbAdcs::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_313_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAdcs::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_313_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbAdcs::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_313_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbAdcs::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_313_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_313_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAdcs::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_313_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbAdcs::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_313_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAdcs::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_313_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbAdcs::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbAdcs", 924, G__jctbDict_313_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbAcquisition(void) { + /* jctbAcquisition */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition)); + G__memfunc_setup("jctbAcquisition",1580,G__jctbDict_314_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbAcquisition), -1, 0, 2, 1, 1, 0, +"U 'TGVerticalFrame' - 0 - - U 'multiSlsDetector' - 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setOutdir",963,G__jctbDict_314_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setFname",819,G__jctbDict_314_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setFsave",833,G__jctbDict_314_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setFindex",938,G__jctbDict_314_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("toggleAcquisition",1803,G__jctbDict_314_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ThreadHandle",1188,G__jctbDict_314_0_7, 89, -1, -1, 0, 1, 3, 1, 0, "Y - - 0 - arg", (char*)NULL, (void*) G__func2void( (void* (*)(void*))(&jctbAcquisition::ThreadHandle) ), 0); + G__memfunc_setup("update",643,G__jctbDict_314_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("acquisitionFinished",2003,G__jctbDict_314_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("startAcquisition",1719,G__jctbDict_314_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("progressCallback",1666,G__jctbDict_314_0_11, 105, -1, -1, 0, 2, 3, 1, 0, +"d - - 0 - - Y - - 0 - -", (char*)NULL, (void*) G__func2void( (int (*)(double, void*))(&jctbAcquisition::progressCallback) ), 0); + G__memfunc_setup("dataCallback",1191,G__jctbDict_314_0_12, 105, -1, -1, 0, 3, 3, 1, 0, +"U 'detectorData' - 0 - - i - - 0 - - " +"Y - - 0 - -", (char*)NULL, (void*) G__func2void( (int (*)(detectorData*, int, void*))(&jctbAcquisition::dataCallback) ), 0); + G__memfunc_setup("Class",502,G__jctbDict_314_0_13, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbAcquisition::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_314_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAcquisition::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_314_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbAcquisition::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_314_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbAcquisition::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_314_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_314_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAcquisition::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_314_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbAcquisition::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_314_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAcquisition::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_314_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbAcquisition::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbAcquisition", 1706, G__jctbDict_314_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbMain(void) { + /* jctbMain */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbMain)); + G__memfunc_setup("jctbMain",808,G__jctbDict_315_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbMain), -1, 0, 2, 1, 1, 0, +"U 'TGWindow' - 10 - p U 'multiSlsDetector' - 0 - det", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("loadAlias",906,G__jctbDict_315_0_2, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - fname", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("saveAlias",921,G__jctbDict_315_0_3, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - fname", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("loadParameters",1460,G__jctbDict_315_0_4, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - fname", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("saveParameters",1475,G__jctbDict_315_0_5, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - fname", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("loadConfiguration",1784,G__jctbDict_315_0_6, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - fname", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("saveConfiguration",1799,G__jctbDict_315_0_7, 105, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - fname", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("tabSelected",1120,G__jctbDict_315_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("CloseWindow",1134,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1); + G__memfunc_setup("HandleMenu",993,G__jctbDict_315_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_315_0_11, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbMain::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_315_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbMain::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_315_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbMain::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_315_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbMain::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_315_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_315_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbMain::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_315_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbMain::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_315_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbMain::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_315_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbMain::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbMain", 934, G__jctbDict_315_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncjctbAdc(void) { + /* jctbAdc */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__jctbDictLN_jctbAdc)); + G__memfunc_setup("jctbAdc",683,G__jctbDict_317_0_1, 105, G__get_linked_tagnum(&G__jctbDictLN_jctbAdc), -1, 0, 3, 1, 1, 0, +"U 'TGVerticalFrame' - 0 - page i - - 0 - i " +"U 'multiSlsDetector' - 0 - det", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("setAdcAlias",1086,G__jctbDict_317_0_2, 121, -1, -1, 0, 3, 1, 1, 0, +"C - - 0 - tit i - - 0 - plot " +"i - - 0 - color", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("getAdcAlias",1074,G__jctbDict_317_0_3, 117, G__get_linked_tagnum(&G__jctbDictLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledAdcPlot",1389,G__jctbDict_317_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("ToggledPlot",1125,G__jctbDict_317_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("update",643,G__jctbDict_317_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("Class",502,G__jctbDict_317_0_7, 85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&jctbAdc::Class) ), 0); + G__memfunc_setup("Class_Name",982,G__jctbDict_317_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAdc::Class_Name) ), 0); + G__memfunc_setup("Class_Version",1339,G__jctbDict_317_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&jctbAdc::Class_Version) ), 0); + G__memfunc_setup("Dictionary",1046,G__jctbDict_317_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&jctbAdc::Dictionary) ), 0); + G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__jctbDictLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1); + 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); + 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); + G__memfunc_setup("StreamerNVirtual",1656,G__jctbDict_317_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0); + G__memfunc_setup("DeclFileName",1145,G__jctbDict_317_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAdc::DeclFileName) ), 0); + G__memfunc_setup("ImplFileLine",1178,G__jctbDict_317_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbAdc::ImplFileLine) ), 0); + G__memfunc_setup("ImplFileName",1171,G__jctbDict_317_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&jctbAdc::ImplFileName) ), 0); + G__memfunc_setup("DeclFileLine",1152,G__jctbDict_317_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&jctbAdc::DeclFileLine) ), 0); + // automatic destructor + G__memfunc_setup("~jctbAdc", 809, G__jctbDict_317_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0); + G__tag_memfunc_reset(); +} + + +/********************************************************* +* Member function information setup +*********************************************************/ +extern "C" void G__cpp_setup_memfuncjctbDict() { +} + +/********************************************************* +* Global variable information setup for each class +*********************************************************/ +static void G__cpp_setup_global0() { + + /* Setting up global variables */ + G__resetplocal(); + +} + +static void G__cpp_setup_global1() { +} + +static void G__cpp_setup_global2() { +} + +static void G__cpp_setup_global3() { +} + +static void G__cpp_setup_global4() { + + G__resetglobalenv(); +} +extern "C" void G__cpp_setup_globaljctbDict() { + G__cpp_setup_global0(); + G__cpp_setup_global1(); + G__cpp_setup_global2(); + G__cpp_setup_global3(); + G__cpp_setup_global4(); +} + +/********************************************************* +* Global function information setup for each class +*********************************************************/ +static void G__cpp_setup_func0() { + G__lastifuncposition(); + +} + +static void G__cpp_setup_func1() { +} + +static void G__cpp_setup_func2() { +} + +static void G__cpp_setup_func3() { +} + +static void G__cpp_setup_func4() { +} + +static void G__cpp_setup_func5() { +} + +static void G__cpp_setup_func6() { +} + +static void G__cpp_setup_func7() { +} + +static void G__cpp_setup_func8() { +} + +static void G__cpp_setup_func9() { +} + +static void G__cpp_setup_func10() { +} + +static void G__cpp_setup_func11() { +} + +static void G__cpp_setup_func12() { +} + +static void G__cpp_setup_func13() { + + G__resetifuncposition(); +} + +extern "C" void G__cpp_setup_funcjctbDict() { + G__cpp_setup_func0(); + G__cpp_setup_func1(); + G__cpp_setup_func2(); + G__cpp_setup_func3(); + G__cpp_setup_func4(); + G__cpp_setup_func5(); + G__cpp_setup_func6(); + G__cpp_setup_func7(); + G__cpp_setup_func8(); + G__cpp_setup_func9(); + G__cpp_setup_func10(); + G__cpp_setup_func11(); + G__cpp_setup_func12(); + G__cpp_setup_func13(); +} + +/********************************************************* +* Class,struct,union,enum tag information setup +*********************************************************/ +/* Setup class/struct taginfo */ +G__linked_taginfo G__jctbDictLN_TClass = { "TClass" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TBuffer = { "TBuffer" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TMemberInspector = { "TMemberInspector" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TObject = { "TObject" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_string = { "string" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector >" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator >::iterator>" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector >" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator >::iterator>" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGObject = { "TGObject" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TQObject = { "TQObject" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGWindow = { "TGWindow" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGFrame = { "TGFrame" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGCompositeFrame = { "TGCompositeFrame" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGLayoutHints = { "TGLayoutHints" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator" , 115 , -1 }; +G__linked_taginfo G__jctbDictLN_TGTextButton = { "TGTextButton" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGVerticalFrame = { "TGVerticalFrame" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGHorizontalFrame = { "TGHorizontalFrame" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGMainFrame = { "TGMainFrame" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGGroupFrame = { "TGGroupFrame" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGNumberEntry = { "TGNumberEntry" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_multiSlsDetector = { "multiSlsDetector" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbSignal = { "jctbSignal" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbSignals = { "jctbSignals" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGTextEntry = { "TGTextEntry" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGLabel = { "TGLabel" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGCheckButton = { "TGCheckButton" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TH1I = { "TH1I" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGColorSelect = { "TGColorSelect" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TRootEmbeddedCanvas = { "TRootEmbeddedCanvas" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGButtonGroup = { "TGButtonGroup" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGTab = { "TGTab" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbLoop = { "jctbLoop" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbWait = { "jctbWait" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbPattern = { "jctbPattern" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbDac = { "jctbDac" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbDacs = { "jctbDacs" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGMenuBar = { "TGMenuBar" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGPopupMenu = { "TGPopupMenu" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGDockableFrame = { "TGDockableFrame" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbAdcs = { "jctbAdcs" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbAcquisition = { "jctbAcquisition" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbMain = { "jctbMain" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TGraph = { "TGraph" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_jctbAdc = { "jctbAdc" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_TThread = { "TThread" , 99 , -1 }; +G__linked_taginfo G__jctbDictLN_detectorData = { "detectorData" , 99 , -1 }; + +/* Reset class/struct taginfo */ +extern "C" void G__cpp_reset_tagtablejctbDict() { + G__jctbDictLN_TClass.tagnum = -1 ; + G__jctbDictLN_TBuffer.tagnum = -1 ; + G__jctbDictLN_TMemberInspector.tagnum = -1 ; + G__jctbDictLN_TObject.tagnum = -1 ; + G__jctbDictLN_string.tagnum = -1 ; + G__jctbDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ; + G__jctbDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ; + G__jctbDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ; + G__jctbDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ; + G__jctbDictLN_TGObject.tagnum = -1 ; + G__jctbDictLN_TQObject.tagnum = -1 ; + G__jctbDictLN_TGWindow.tagnum = -1 ; + G__jctbDictLN_TGFrame.tagnum = -1 ; + G__jctbDictLN_TGCompositeFrame.tagnum = -1 ; + G__jctbDictLN_TGLayoutHints.tagnum = -1 ; + G__jctbDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ; + G__jctbDictLN_TGTextButton.tagnum = -1 ; + G__jctbDictLN_TGVerticalFrame.tagnum = -1 ; + G__jctbDictLN_TGHorizontalFrame.tagnum = -1 ; + G__jctbDictLN_TGMainFrame.tagnum = -1 ; + G__jctbDictLN_TGGroupFrame.tagnum = -1 ; + G__jctbDictLN_TGNumberEntry.tagnum = -1 ; + G__jctbDictLN_multiSlsDetector.tagnum = -1 ; + G__jctbDictLN_jctbSignal.tagnum = -1 ; + G__jctbDictLN_jctbSignals.tagnum = -1 ; + G__jctbDictLN_TGTextEntry.tagnum = -1 ; + G__jctbDictLN_TGLabel.tagnum = -1 ; + G__jctbDictLN_TGCheckButton.tagnum = -1 ; + G__jctbDictLN_TH1I.tagnum = -1 ; + G__jctbDictLN_TGColorSelect.tagnum = -1 ; + G__jctbDictLN_TRootEmbeddedCanvas.tagnum = -1 ; + G__jctbDictLN_TGButtonGroup.tagnum = -1 ; + G__jctbDictLN_TGTab.tagnum = -1 ; + G__jctbDictLN_jctbLoop.tagnum = -1 ; + G__jctbDictLN_jctbWait.tagnum = -1 ; + G__jctbDictLN_jctbPattern.tagnum = -1 ; + G__jctbDictLN_jctbDac.tagnum = -1 ; + G__jctbDictLN_jctbDacs.tagnum = -1 ; + G__jctbDictLN_TGMenuBar.tagnum = -1 ; + G__jctbDictLN_TGPopupMenu.tagnum = -1 ; + G__jctbDictLN_TGDockableFrame.tagnum = -1 ; + G__jctbDictLN_jctbAdcs.tagnum = -1 ; + G__jctbDictLN_jctbAcquisition.tagnum = -1 ; + G__jctbDictLN_jctbMain.tagnum = -1 ; + G__jctbDictLN_TGraph.tagnum = -1 ; + G__jctbDictLN_jctbAdc.tagnum = -1 ; + G__jctbDictLN_TThread.tagnum = -1 ; + G__jctbDictLN_detectorData.tagnum = -1 ; +} + + +extern "C" void G__cpp_setup_tagtablejctbDict() { + + /* Setting up class,struct,union tag entry */ + G__get_linked_tagnum_fwd(&G__jctbDictLN_TClass); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TBuffer); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TMemberInspector); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TObject); + G__get_linked_tagnum_fwd(&G__jctbDictLN_string); + G__get_linked_tagnum_fwd(&G__jctbDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR); + G__get_linked_tagnum_fwd(&G__jctbDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR); + G__get_linked_tagnum_fwd(&G__jctbDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR); + G__get_linked_tagnum_fwd(&G__jctbDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGObject); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TQObject); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGWindow); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGFrame); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGCompositeFrame); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGLayoutHints); + G__get_linked_tagnum_fwd(&G__jctbDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGTextButton); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGVerticalFrame); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGHorizontalFrame); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGMainFrame); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGGroupFrame); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGNumberEntry); + G__get_linked_tagnum_fwd(&G__jctbDictLN_multiSlsDetector); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbSignal),sizeof(jctbSignal),-1,61440,(char*)NULL,G__setup_memvarjctbSignal,G__setup_memfuncjctbSignal); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbSignals),sizeof(jctbSignals),-1,61440,(char*)NULL,G__setup_memvarjctbSignals,G__setup_memfuncjctbSignals); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGTextEntry); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGLabel); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGCheckButton); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TH1I); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGColorSelect); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TRootEmbeddedCanvas); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGButtonGroup); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGTab); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbLoop),sizeof(jctbLoop),-1,61440,(char*)NULL,G__setup_memvarjctbLoop,G__setup_memfuncjctbLoop); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbWait),sizeof(jctbWait),-1,61440,(char*)NULL,G__setup_memvarjctbWait,G__setup_memfuncjctbWait); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbPattern),sizeof(jctbPattern),-1,61440,(char*)NULL,G__setup_memvarjctbPattern,G__setup_memfuncjctbPattern); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbDac),sizeof(jctbDac),-1,61440,(char*)NULL,G__setup_memvarjctbDac,G__setup_memfuncjctbDac); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbDacs),sizeof(jctbDacs),-1,61440,(char*)NULL,G__setup_memvarjctbDacs,G__setup_memfuncjctbDacs); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGMenuBar); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGPopupMenu); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGDockableFrame); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbAdcs),sizeof(jctbAdcs),-1,61440,(char*)NULL,G__setup_memvarjctbAdcs,G__setup_memfuncjctbAdcs); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbAcquisition),sizeof(jctbAcquisition),-1,61440,(char*)NULL,G__setup_memvarjctbAcquisition,G__setup_memfuncjctbAcquisition); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbMain),sizeof(jctbMain),-1,61440,(char*)NULL,G__setup_memvarjctbMain,G__setup_memfuncjctbMain); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TGraph); + G__tagtable_setup(G__get_linked_tagnum_fwd(&G__jctbDictLN_jctbAdc),sizeof(jctbAdc),-1,61440,(char*)NULL,G__setup_memvarjctbAdc,G__setup_memfuncjctbAdc); + G__get_linked_tagnum_fwd(&G__jctbDictLN_TThread); + G__get_linked_tagnum_fwd(&G__jctbDictLN_detectorData); +} +extern "C" void G__cpp_setupjctbDict(void) { + G__check_setup_version(30051515,"G__cpp_setupjctbDict()"); + G__set_cpp_environmentjctbDict(); + G__cpp_setup_tagtablejctbDict(); + + G__cpp_setup_inheritancejctbDict(); + + G__cpp_setup_typetablejctbDict(); + + G__cpp_setup_memvarjctbDict(); + + G__cpp_setup_memfuncjctbDict(); + G__cpp_setup_globaljctbDict(); + G__cpp_setup_funcjctbDict(); + + if(0==G__getsizep2memfunc()) G__get_sizep2memfuncjctbDict(); + return; +} +class G__cpp_setup_initjctbDict { + public: + G__cpp_setup_initjctbDict() { G__add_setup_func("jctbDict",(G__incsetup)(&G__cpp_setupjctbDict)); G__call_setup_funcs(); } + ~G__cpp_setup_initjctbDict() { G__remove_setup_func("jctbDict"); } +}; +G__cpp_setup_initjctbDict G__cpp_setup_initializerjctbDict; + diff --git a/JCTBGui/jctbDict.h b/JCTBGui/jctbDict.h new file mode 100755 index 000000000..dcb6e1dd4 --- /dev/null +++ b/JCTBGui/jctbDict.h @@ -0,0 +1,98 @@ +/******************************************************************** +* jctbDict.h +* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED +* FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX(). +* CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE. +********************************************************************/ +#ifdef __CINT__ +#error jctbDict.h/C is only for compilation. Abort cint. +#endif +#include +#include +#include +#include +#include +#define G__ANSIHEADER +#define G__DICTIONARY +#define G__PRIVATE_GVALUE +#include "G__ci.h" +#include "FastAllocString.h" +extern "C" { +extern void G__cpp_setup_tagtablejctbDict(); +extern void G__cpp_setup_inheritancejctbDict(); +extern void G__cpp_setup_typetablejctbDict(); +extern void G__cpp_setup_memvarjctbDict(); +extern void G__cpp_setup_globaljctbDict(); +extern void G__cpp_setup_memfuncjctbDict(); +extern void G__cpp_setup_funcjctbDict(); +extern void G__set_cpp_environmentjctbDict(); +} + + +#include "TObject.h" +#include "TMemberInspector.h" +#include "jctbSignals.h" +#include "jctbSignal.h" +#include "jctbPattern.h" +#include "jctbDacs.h" +#include "jctbDac.h" +#include "jctbMain.h" +#include "jctbAdcs.h" +#include "jctbAcquisition.h" +#include +namespace std { } +using namespace std; + +#ifndef G__MEMFUNCBODY +#endif + +extern G__linked_taginfo G__jctbDictLN_TClass; +extern G__linked_taginfo G__jctbDictLN_TBuffer; +extern G__linked_taginfo G__jctbDictLN_TMemberInspector; +extern G__linked_taginfo G__jctbDictLN_TObject; +extern G__linked_taginfo G__jctbDictLN_string; +extern G__linked_taginfo G__jctbDictLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR; +extern G__linked_taginfo G__jctbDictLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR; +extern G__linked_taginfo G__jctbDictLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR; +extern G__linked_taginfo G__jctbDictLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR; +extern G__linked_taginfo G__jctbDictLN_TGObject; +extern G__linked_taginfo G__jctbDictLN_TQObject; +extern G__linked_taginfo G__jctbDictLN_TGWindow; +extern G__linked_taginfo G__jctbDictLN_TGFrame; +extern G__linked_taginfo G__jctbDictLN_TGCompositeFrame; +extern G__linked_taginfo G__jctbDictLN_TGLayoutHints; +extern G__linked_taginfo G__jctbDictLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR; +extern G__linked_taginfo G__jctbDictLN_TGTextButton; +extern G__linked_taginfo G__jctbDictLN_TGVerticalFrame; +extern G__linked_taginfo G__jctbDictLN_TGHorizontalFrame; +extern G__linked_taginfo G__jctbDictLN_TGMainFrame; +extern G__linked_taginfo G__jctbDictLN_TGGroupFrame; +extern G__linked_taginfo G__jctbDictLN_TGNumberEntry; +extern G__linked_taginfo G__jctbDictLN_multiSlsDetector; +extern G__linked_taginfo G__jctbDictLN_jctbSignal; +extern G__linked_taginfo G__jctbDictLN_jctbSignals; +extern G__linked_taginfo G__jctbDictLN_TGTextEntry; +extern G__linked_taginfo G__jctbDictLN_TGLabel; +extern G__linked_taginfo G__jctbDictLN_TGCheckButton; +extern G__linked_taginfo G__jctbDictLN_TH1I; +extern G__linked_taginfo G__jctbDictLN_TGColorSelect; +extern G__linked_taginfo G__jctbDictLN_TRootEmbeddedCanvas; +extern G__linked_taginfo G__jctbDictLN_TGButtonGroup; +extern G__linked_taginfo G__jctbDictLN_TGTab; +extern G__linked_taginfo G__jctbDictLN_jctbLoop; +extern G__linked_taginfo G__jctbDictLN_jctbWait; +extern G__linked_taginfo G__jctbDictLN_jctbPattern; +extern G__linked_taginfo G__jctbDictLN_jctbDac; +extern G__linked_taginfo G__jctbDictLN_jctbDacs; +extern G__linked_taginfo G__jctbDictLN_TGMenuBar; +extern G__linked_taginfo G__jctbDictLN_TGPopupMenu; +extern G__linked_taginfo G__jctbDictLN_TGDockableFrame; +extern G__linked_taginfo G__jctbDictLN_jctbAdcs; +extern G__linked_taginfo G__jctbDictLN_jctbAcquisition; +extern G__linked_taginfo G__jctbDictLN_jctbMain; +extern G__linked_taginfo G__jctbDictLN_TGraph; +extern G__linked_taginfo G__jctbDictLN_jctbAdc; +extern G__linked_taginfo G__jctbDictLN_TThread; +extern G__linked_taginfo G__jctbDictLN_detectorData; + +/* STUB derived class for protected member access */ diff --git a/JCTBGui/jctbLinkDef.h b/JCTBGui/jctbLinkDef.h new file mode 100755 index 000000000..150c9c3d8 --- /dev/null +++ b/JCTBGui/jctbLinkDef.h @@ -0,0 +1,11 @@ +#pragma link C++ class jctbMain; +#pragma link C++ class jctbDacs; +#pragma link C++ class jctbDac; +#pragma link C++ class jctbSignals; +#pragma link C++ class jctbSignal; +#pragma link C++ class jctbAdc; +#pragma link C++ class jctbAdcs; +#pragma link C++ class jctbLoop; +#pragma link C++ class jctbWait; +#pragma link C++ class jctbPattern; +#pragma link C++ class jctbAcquisition; diff --git a/JCTBGui/jctbMain.cpp b/JCTBGui/jctbMain.cpp new file mode 100755 index 000000000..3d419f111 --- /dev/null +++ b/JCTBGui/jctbMain.cpp @@ -0,0 +1,665 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +#include +#include +//#include +//#include + + + + + + + +#include +#include +#include +#include + +#include "multiSlsDetector.h" +#include "jctbMain.h" +#include "jctbDacs.h" +#include "jctbSignals.h" +#include "jctbPattern.h" +#include "jctbAdcs.h" +#include "jctbAcquisition.h" + +using namespace std; + + + +jctbMain::jctbMain(const TGWindow *p, multiSlsDetector *det) + : TGMainFrame(p,800,800) { + + myDet=det; + + Connect("CloseWindow()", "jctbMain", this, "CloseWindow()"); + + + + + +// fMenuDock = new TGDockableFrame(this); +// AddFrame(fMenuDock, new TGLayoutHints(kLHintsExpandX, 0, 0, 1, 0)); +// fMenuDock->SetWindowName("GuiTest Menu"); + + fMenuBarLayout = new TGLayoutHints(kLHintsTop | kLHintsExpandX); + fMenuBarItemLayout = new TGLayoutHints(kLHintsTop | kLHintsLeft, 0, 4, 0, 0); + fMenuBarHelpLayout = new TGLayoutHints(kLHintsTop | kLHintsRight); + + fMenuFile = new TGPopupMenu(gClient->GetRoot()); + int im=0; + + fMenuFile->AddEntry("Open Alias", im++); + fMenuFile->AddEntry("Save Alias", im++); + fMenuFile->AddSeparator(); + fMenuFile->AddEntry("Open Parameters", im++); + fMenuFile->AddEntry("Save Parameters", im++); + fMenuFile->AddSeparator(); + fMenuFile->AddEntry("Open Configuration", im++); + fMenuFile->AddEntry("Save Configuration", im++); + fMenuFile->AddSeparator(); + fMenuFile->AddEntry("Open Pattern", im++); + fMenuFile->AddEntry("Save Pattern", im++); + fMenuFile->AddSeparator(); + fMenuFile->AddEntry("Exit", im++); + + fMenuFile->Connect("Activated(Int_t)", "jctbMain", this, + "HandleMenu(Int_t)"); + // fMenuFile->Connect("PoppedUp()", "TestMainFrame", this, "HandlePopup()"); +// fMenuFile->Connect("PoppedDown()", "TestMainFrame", this, "HandlePopdown()"); + + + + +// fCascade2Menu = new TGPopupMenu(gClient->GetRoot()); +// fCascade2Menu->AddEntry("ID = 2&3", im++); +// fCascade2Menu->AddEntry("ID = 2&4", im++); +// fCascade2Menu->AddEntry("ID = 2&5", im++); + +// fCascade1Menu = new TGPopupMenu(gClient->GetRoot()); +// fCascade1Menu->AddEntry("ID = 4&1", 41); +// fCascade1Menu->AddEntry("ID = 4&2", 42); +// fCascade1Menu->AddEntry("ID = 4&3", 43); +// fCascade1Menu->AddSeparator(); +// fCascade1Menu->AddPopup("Cascade&d 2", fCascade2Menu); + +// fCascadeMenu = new TGPopupMenu(gClient->GetRoot()); +// fCascadeMenu->AddEntry("ID = 5&1", 51); +// fCascadeMenu->AddEntry("ID = 5&2", 52); +// fCascadeMenu->AddEntry("ID = 5&3", 53); +// fCascadeMenu->AddSeparator(); +// fCascadeMenu->AddPopup("&Cascaded 1", fCascade1Menu); + +// fMenuTest = new TGPopupMenu(gClient->GetRoot()); +// fMenuTest->AddLabel("Test different features..."); +// fMenuTest->AddSeparator(); +// fMenuTest->AddEntry("&Dialog...", im++); +// fMenuTest->AddEntry("&Message Box...", im++); +// fMenuTest->AddEntry("&Sliders...", im++); +// fMenuTest->AddEntry("Sh&utter...", im++); +// fMenuTest->AddEntry("&List Directory...", im++); +// fMenuTest->AddEntry("&File List...", im++); +// fMenuTest->AddEntry("&Progress...", im++); +// fMenuTest->AddEntry("&Number Entry...", im++); +// fMenuTest->AddEntry("F&ont Dialog...", im++); +// fMenuTest->AddSeparator(); +// fMenuTest->AddEntry("Add New Menus", im++); +// fMenuTest->AddSeparator(); +// fMenuTest->AddPopup("&Cascaded menus", fCascadeMenu); + +// fMenuView = new TGPopupMenu(gClient->GetRoot()); +// fMenuView->AddEntry("&Dock", im++); +// fMenuView->AddEntry("&Undock", im++); +// fMenuView->AddSeparator(); +// fMenuView->AddEntry("Enable U&ndock", im++); +// fMenuView->AddEntry("Enable &Hide", im++); +// fMenuView->DisableEntry(im); + +// fMenuDock->EnableUndock(kTRUE); +// fMenuDock->EnableHide(kTRUE); +// fMenuView->CheckEntry(im); +// fMenuView->CheckEntry(im); + +// // When using the DockButton of the MenuDock, +// // the states 'enable' and 'disable' of menus have to be updated. +// fMenuDock->Connect("Undocked()", "TestMainFrame", this, "HandleMenu(=M_VIEW_UNDOCK)"); + +// fMenuHelp = new TGPopupMenu(gClient->GetRoot()); +// fMenuHelp->AddEntry("&Contents", im++); +// fMenuHelp->AddEntry("&Search...", im++); +// fMenuHelp->AddSeparator(); +// fMenuHelp->AddEntry("&About", im++); + +// fMenuNew1 = new TGPopupMenu(); +// fMenuNew1->AddEntry("Remove New Menus", im++); + +// fMenuNew2 = new TGPopupMenu(); +// fMenuNew2->AddEntry("Remove New Menus", im++); + + // Menu button messages are handled by the main frame (i.e. "this") + // HandleMenu() method. +// fMenuFile->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); +// fMenuFile->Connect("PoppedUp()", "TestMainFrame", this, "HandlePopup()"); +// fMenuFile->Connect("PoppedDown()", "TestMainFrame", this, "HandlePopdown()"); +// fMenuTest->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); +// fMenuView->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); +// fMenuHelp->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); +// fCascadeMenu->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); +// fCascade1Menu->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); +// fCascade2Menu->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); +// fMenuNew1->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); +// fMenuNew2->Connect("Activated(Int_t)", "TestMainFrame", this, +// "HandleMenu(Int_t)"); + + + + + + + + + + + + + + + + + + + + + TGVerticalFrame *vframe=new TGVerticalFrame(this, 800,1200); //main frame + + + + fMenuBar = new TGMenuBar(vframe, 1, 1, kHorizontalFrame); + fMenuBar->AddPopup("&File", fMenuFile, fMenuBarItemLayout); +// fMenuBar->AddPopup("&Test", fMenuTest, fMenuBarItemLayout); +// fMenuBar->AddPopup("&View", fMenuView, fMenuBarItemLayout); +// fMenuBar->AddPopup("&Help", fMenuHelp, fMenuBarHelpLayout); + + vframe->AddFrame(fMenuBar, fMenuBarLayout); + + + + + + + + + + TGHorizontalFrame* hpage=new TGHorizontalFrame(vframe, 800,1200); //horizontal frame. Inside there should be the tab and the canvas + mtab=new TGTab(hpage, 1500, 1200); //tab! + // page=new TGVerticalFrame(mtab, 1500,1200); + + TGCompositeFrame *tf = mtab->AddTab("DACs"); + TGVerticalFrame *page=new TGVerticalFrame(tf, 1500,1200); + tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1)); + dacs=new jctbDacs(page, myDet); + + + tf = mtab->AddTab("Signals"); + page=new TGVerticalFrame(tf, 1500,1200); + tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1)); + sig=new jctbSignals(page, myDet); + + + tf = mtab->AddTab("ADCs"); + page=new TGVerticalFrame(tf, 1500,1200); + tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1)); + adcs=new jctbAdcs(page, myDet); + + + + + tf = mtab->AddTab("Pattern"); + page=new TGVerticalFrame(tf, 1500,1200); + tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1)); + pat=new jctbPattern(page, myDet); + + + + tf = mtab->AddTab("Acquisition"); + page=new TGVerticalFrame(tf, 1500,1200); + tf->AddFrame(page, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1)); + acq=new jctbAcquisition(page, myDet); + + + + + + hpage->AddFrame(mtab,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1)); + + vframe->AddFrame(hpage,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1)); + + AddFrame(vframe,new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10,10,10,1)); + vframe->MapWindow(); + hpage->MapWindow(); + mtab->MapWindow(); + page->MapWindow(); + + // Sets window name and shows the main frame + SetWindowName("JCTB Gui"); + MapSubwindows(); + MapWindow(); + Resize(1500,1200); + + +// // Creates widgets of the example + fEcanvas = new TRootEmbeddedCanvas ("Ecanvas",hpage,800,800); + fEcanvas->Resize(); + fEcanvas->GetCanvas()->Update(); + + hpage->AddFrame(fEcanvas, new TGLayoutHints(kLHintsBottom | kLHintsCenterX | kLHintsExpandX | kLHintsExpandY, 10,10,10,10)); + + + fEcanvas->MapWindow(); + hpage->MapSubwindows(); + mtab->Connect("Selected(Int_t)","jctbMain",this,"tabSelected(Int_t)"); + + + tabSelected(0); +} + +void jctbMain::CloseWindow() { + gApplication->Terminate(); +} + + + + + +void jctbMain::HandleMenu(Int_t id) +{ + // Handle menu items. + + + + + switch (id) { + + case 0: // fMenuFile->AddEntry("Open Alias", im++); + cout << "Open Alias" << endl; + { + static TString dir("."); + TGFileInfo fi; + //fi.fFileTypes = filetypes; + fi.fIniDir = StrDup(dir); + printf("fIniDir = %s\n", fi.fIniDir); + new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi); + printf("Open file: %s (dir: %s)\n", fi.fFilename); + // dir = fi.fIniDir; + loadAlias(fi.fFilename); + } + break; + + case 1: // fMenuFile->AddEntry("Save Alias", im++); + cout << "Save Alias" << endl; + { + static TString dir("."); + TGFileInfo fi; + //fi.fFileTypes = filetypes; + fi.fIniDir = StrDup(dir); + printf("fIniDir = %s\n", fi.fIniDir); + new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi); + printf("Save file: %s (dir: %s)\n", fi.fFilename); + // dir = fi.fIniDir; + saveAlias(fi.fFilename); + } + break; + + case 2: //fMenuFile->AddEntry("Open Parameters", im++); + cout << "Open Parameters" << endl; + { + static TString dir("."); + TGFileInfo fi; + //fi.fFileTypes = filetypes; + fi.fIniDir = StrDup(dir); + printf("fIniDir = %s\n", fi.fIniDir); + new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi); + printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir); + // dir = fi.fIniDir; + loadParameters(fi.fFilename); + } + break; + + case 3: //fMenuFile->AddEntry("Save Parameters", im++); + cout << "Save Parameters" << endl; + { + static TString dir("."); + TGFileInfo fi; + //fi.fFileTypes = filetypes; + fi.fIniDir = StrDup(dir); + printf("fIniDir = %s\n", fi.fIniDir); + new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi); + printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir); + // dir = fi.fIniDir; + saveParameters(fi.fFilename); + } + break; + + case 4: // fMenuFile->AddEntry("Open Configuration", im++); + cout << "Open configuration" << endl; + { + static TString dir("."); + TGFileInfo fi; + //fi.fFileTypes = filetypes; + fi.fIniDir = StrDup(dir); + printf("fIniDir = %s\n", fi.fIniDir); + new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi); + printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir); + // dir = fi.fIniDir; + } + break; + + case 5: // fMenuFile->AddEntry("Save Configuration", im++); + cout << "Save configuration" << endl; + { + static TString dir("."); + TGFileInfo fi; + //fi.fFileTypes = filetypes; + fi.fIniDir = StrDup(dir); + printf("fIniDir = %s\n", fi.fIniDir); + new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi); + printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir); + // dir = fi.fIniDir; + } + break; + + case 6: //fMenuFile->AddEntry("Open Pattern", im++); + cout << "Open pattern" << endl; + { + static TString dir("."); + TGFileInfo fi; + //fi.fFileTypes = filetypes; + fi.fIniDir = StrDup(dir); + printf("fIniDir = %s\n", fi.fIniDir); + new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi); + printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir); + // dir = fi.fIniDir; + } + break; + + case 7: //fMenuFile->AddEntry("Save Pattern", im++); + cout << "Save pattern" << endl; + { + static TString dir("."); + TGFileInfo fi; + //fi.fFileTypes = filetypes; + fi.fIniDir = StrDup(dir); + printf("fIniDir = %s\n", fi.fIniDir); + new TGFileDialog(gClient->GetRoot(), this, kFDSave, &fi); + printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir); + // dir = fi.fIniDir; + } + break; + + case 8: // fMenuFile->AddEntry("Exit", im++); + CloseWindow(); + + default: + printf("Menu item %d selected\n", id); + break; + } +} + + + + + + + +int jctbMain::loadConfiguration(string fname) { + + myDet->readConfigurationFile(fname); + +// string line; +// int i; +// ifstream myfile (fname.c_str()); +// if (myfile.is_open()) +// { +// while ( getline (myfile,line) ) +// { + + + +// } +// myfile.close(); +// } + +// else cout << "Unable to open file"; + + return 0; + +} + + + + + +int jctbMain::saveConfiguration(string fname) { + + + string line; + int i; + ofstream myfile (fname.c_str()); + if (myfile.is_open()) + { + + + myfile.close(); + } + + else cout << "Unable to open file"; + + return 0; + +} + + + + + + + +int jctbMain::loadParameters(string fname) { + + myDet->retrieveDetectorSetup(fname); + +// string line; +// int i; +// ifstream myfile (fname.c_str()); +// if (myfile.is_open()) +// { +// while ( getline (myfile,line) ) +// { + + + +// } +// myfile.close(); +// } + +// else cout << "Unable to open file"; + + return 0; + +} + + + + + +int jctbMain::saveParameters(string fname) { + + + string line; + int i; + ofstream myfile (fname.c_str()); + if (myfile.is_open()) + { + + myfile << dacs->getDacParameters(); + myfile.close(); + } + + else cout << "Unable to open file"; + + return 0; + +} + + + + + +int jctbMain::loadAlias(string fname) { + + + string line; + int i; + ifstream myfile (fname.c_str()); + if (myfile.is_open()) + { + while ( getline (myfile,line) ) + { + // cout << line ; + if (sscanf(line.c_str(),"BIT%d",&i)>0) { + //cout << "*******" << line<< endl; + sig->setSignalAlias(line); + // cout << line ; + } else if (sscanf(line.c_str(),"DAC%d",&i)>0) { + dacs->setDacAlias(line); + // cout << "+++++++++" << line<< endl; + } else if (sscanf(line.c_str(),"ADC%d",&i)>0) { + adcs->setAdcAlias(line); + // cout << "---------" << line<< endl; + } // else + // cout << "<<<<<<<" << line << endl; + + + } + myfile.close(); + } + + else cout << "Unable to open file"; + + return 0; + +} + + + + + +int jctbMain::saveAlias(string fname) { + + + string line; + int i; + ofstream myfile (fname.c_str()); + if (myfile.is_open()) + { + //while ( getline (myfile,line) ) + // { + // cout << line ; + //if (sscanf(line.c_str(),"BIT%d",&i)>0) { + //cout << "*******" << line<< endl; + myfile << sig->getSignalAlias(); + // cout << line ; + // } else if (sscanf(line.c_str(),"DAC%d",&i)>0) { + myfile << dacs->getDacAlias(); + // cout << "+++++++++" << line<< endl; + // } else if (sscanf(line.c_str(),"ADC%d",&i)>0) { + myfile << adcs->getAdcAlias(); + // cout << "---------" << line<< endl; + // } // else + // cout << "<<<<<<<" << line << endl; + + + //} + myfile.close(); + } + + else cout << "Unable to open file"; + + return 0; + +} + + + + + + + + + + + +void jctbMain::tabSelected(Int_t i) { + + // cout << "Selected tab " << i << endl; + // cout << "Current tab is " << mtab->GetCurrent() << endl; + + switch (i) { + + case 0: //dacs + dacs->update(); + break; + case 1: //signals + sig->update(); + break; + + case 2: //adcs + adcs->update(); + break; + + case 3: //pattern + pat->update(); + break; + + case 4: //acq + acq->update(); + break; + + default: + ; + + + } + + +} diff --git a/JCTBGui/jctbMain.h b/JCTBGui/jctbMain.h new file mode 100755 index 000000000..25b398184 --- /dev/null +++ b/JCTBGui/jctbMain.h @@ -0,0 +1,94 @@ +#ifndef JCTBMAIN_H +#define JCTBMAIN_H +#include + + +class TRootEmbeddedCanvas; +class TGButtonGroup; +class TGVerticalFrame; +class TGHorizontalFrame; +class TGTextEntry; +class TGLabel; +class TGNumberEntry; +class TH2F; +class TGComboBox; +class TGCheckButton; + +class THStack; +class TGraphErrors; +class TGTextButton; +class TGTab; + +class TGMenuBar; +class TGPopupMenu; +class TGDockableFrame; +class TGLayoutHints; + +class jctbDacs; + + +class jctbSignals; + +class multiSlsDetector; + +class jctbPattern; +class jctbAdcs; +class jctbAcquisition; + +#include +using namespace std; + +class jctbMain : public TGMainFrame { +private: + + + multiSlsDetector *myDet; + + + + TRootEmbeddedCanvas *fEcanvas; + TRootEmbeddedCanvas *fModulecanvas; + TGButtonGroup *br; + + TGTab *mtab; + + + jctbDacs *dacs; + + + jctbSignals *sig; + jctbAdcs *adcs; + + + + jctbPattern *pat; + jctbAcquisition *acq; + + TGDockableFrame *fMenuDock; + + TGMenuBar *fMenuBar; + TGPopupMenu *fMenuFile, *fMenuTest, *fMenuView, *fMenuHelp; + TGPopupMenu *fCascadeMenu, *fCascade1Menu, *fCascade2Menu; + TGPopupMenu *fMenuNew1, *fMenuNew2; + TGLayoutHints *fMenuBarLayout, *fMenuBarItemLayout, *fMenuBarHelpLayout; + +public: + jctbMain(const TGWindow *p, multiSlsDetector *det); + + + int loadAlias(string fname); + int saveAlias(string fname); + int loadParameters(string fname); + int saveParameters(string fname); + int loadConfiguration(string fname); + int saveConfiguration(string fname); + void tabSelected(Int_t); + + void CloseWindow(); + + void HandleMenu(Int_t); + + ClassDef(jctbMain,0) +}; + +#endif diff --git a/JCTBGui/jctbPattern.cpp b/JCTBGui/jctbPattern.cpp new file mode 100755 index 000000000..950fafdc8 --- /dev/null +++ b/JCTBGui/jctbPattern.cpp @@ -0,0 +1,532 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "jctbPattern.h" +#include "multiSlsDetector.h" + +using namespace std; + + + + + +jctbLoop::jctbLoop(TGGroupFrame *page, int i, multiSlsDetector *det) : TGHorizontalFrame(page, 800,800), id(i), myDet(det) { + + TGHorizontalFrame *hframe=this; + + char tit[100]; + + page->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + MapWindow(); + + + + + + sprintf(tit, "Loop %d Repetitions: ", id); + + TGLabel *label= new TGLabel(hframe, tit); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + eLoopNumber = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELNoLimits); + hframe->AddFrame( eLoopNumber,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eLoopNumber->MapWindow(); + eLoopNumber->Resize(150,30); + TGTextEntry *e= eLoopNumber->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbLoop",this,"setNLoops()"); + + + + + sprintf(tit, "Start Address: "); + + label= new TGLabel(hframe, tit); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + eLoopStartAddr = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESHex, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 1024); + hframe->AddFrame( eLoopStartAddr,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eLoopStartAddr->MapWindow(); + eLoopStartAddr->Resize(150,30); + + eLoopStartAddr->SetState(kFALSE); + + label= new TGLabel(hframe, "Stop Address: "); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + + eLoopStopAddr = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESHex, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 1024); + hframe->AddFrame( eLoopStopAddr,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eLoopStopAddr->MapWindow(); + eLoopStopAddr->Resize(150,30); + + + + eLoopStopAddr->SetState(kFALSE); +} + +void jctbLoop::setNLoops() { + + int start, stop, n; + + + start=-1; + stop=-1; + n=eLoopNumber->GetNumber(); + myDet->setCTBPatLoops(id,start, stop,n); + + +} + + + +void jctbLoop::update() { + + int start, stop, n; + + + start=-1; + stop=-1; + n=-1; + myDet->setCTBPatLoops(id,start, stop,n); + eLoopStartAddr->SetHexNumber(start); + eLoopStopAddr->SetHexNumber(stop); + eLoopNumber->SetNumber(n); + +} + + + +jctbWait::jctbWait(TGGroupFrame *page, int i, multiSlsDetector *det) : TGHorizontalFrame(page, 800,800), id(i), myDet(det) { + + char tit[100]; + TGHorizontalFrame *hframe=this; + page->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + MapWindow(); + + + + sprintf(tit, "Wait %d (run clk): ", id); + + TGLabel *label= new TGLabel(hframe, tit); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + eWaitTime = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELNoLimits); + hframe->AddFrame( eWaitTime,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eWaitTime->MapWindow(); + eWaitTime->Resize(150,30); + TGTextEntry *e= eWaitTime->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbWait",this,"setWaitTime()"); + + + + sprintf(tit, "Wait Address: "); + + label= new TGLabel(hframe, tit); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + eWaitAddr = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESHex, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 1024); + hframe->AddFrame( eWaitAddr,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eWaitAddr->MapWindow(); + eWaitAddr->Resize(150,30); + + eWaitAddr->SetState(kFALSE); + +} + + + +void jctbWait::setWaitTime() { + + + Long64_t t=eWaitTime->GetNumber(); + + t=myDet->setCTBPatWaitTime(id,t); +} + + + +void jctbWait::update() { + + int start, stop, n, addr; + + Long64_t t=-1; + + + t=myDet->setCTBPatWaitTime(id,t); + addr=myDet->setCTBPatWaitAddr(id,-1); + eWaitAddr->SetHexNumber(addr); + eWaitTime->SetNumber(t); + +} + + + + + + + + + +jctbPattern::jctbPattern(TGVerticalFrame *page, multiSlsDetector *det) + : TGGroupFrame(page,"Pattern",kVerticalFrame), myDet(det) { + + + SetTitlePos(TGGroupFrame::kLeft); + page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10)); + MapWindow(); + + + char tit[100]; + + + TGHorizontalFrame* hframe=new TGHorizontalFrame(this, 800,800); + AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hframe->MapWindow(); + + + sprintf(tit, "ADC Clock Frequency (MHz): "); + + TGLabel *label= new TGLabel(hframe, tit); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + eAdcClkFreq = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 40); + hframe->AddFrame( eAdcClkFreq,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eAdcClkFreq->MapWindow(); + eAdcClkFreq->Resize(150,30); + TGTextEntry *e= eAdcClkFreq->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbPattern",this,"setAdcFreq()"); + + + label= new TGLabel(hframe, " Phase (0.15ns step): "); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + + eAdcClkPhase = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 200); + hframe->AddFrame( eAdcClkPhase,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eAdcClkPhase->MapWindow(); + eAdcClkPhase->Resize(150,30); + e= eAdcClkPhase->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbPattern",this,"setAdcPhase()"); + + + + hframe=new TGHorizontalFrame(this, 800,800); + AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hframe->MapWindow(); + + + sprintf(tit, "Run Clock Frequency (MHz): "); + + label= new TGLabel(hframe, tit); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + eRunClkFreq = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 160); + hframe->AddFrame( eRunClkFreq,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eRunClkFreq->MapWindow(); + eRunClkFreq->Resize(150,30); + e= eRunClkFreq->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbPattern",this,"setRunFreq()"); + + + + label= new TGLabel(hframe, " Phase (0.15ns step): "); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + + eRunClkPhase = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 200); + hframe->AddFrame( eRunClkPhase,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eRunClkPhase->MapWindow(); + eRunClkPhase->Resize(150,30); + e= eRunClkPhase->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbPattern",this,"setRunPhase()"); + + + + + + + + hframe=new TGHorizontalFrame(this, 800,800); + AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hframe->MapWindow(); + + + sprintf(tit, "Number of frames: "); + + label= new TGLabel(hframe, tit); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + eFrames = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELNoLimits); + hframe->AddFrame( eFrames,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eFrames->MapWindow(); + eFrames->Resize(150,30); + e= eFrames->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbPattern",this,"setFrames()"); + + + label= new TGLabel(hframe, " Period (s): "); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + + ePeriod = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESInteger, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELNoLimits); + hframe->AddFrame( ePeriod,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + ePeriod->MapWindow(); + ePeriod->Resize(150,30); + e= ePeriod->TGNumberEntry::GetNumberEntry(); + e->Connect("ReturnPressed()","jctbPattern",this,"setPeriod()"); + + + + + + + hframe=new TGHorizontalFrame(this, 800,800); + AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hframe->MapWindow(); + + + sprintf(tit, "Start Address: "); + + label= new TGLabel(hframe, tit); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + eStartAddr = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESHex, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 1024); + hframe->AddFrame( eStartAddr,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eStartAddr->MapWindow(); + eStartAddr->Resize(150,30); + + eStartAddr->SetState(kFALSE); + + label= new TGLabel(hframe, "Stop Address: "); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + + + + eStopAddr = new TGNumberEntry(hframe, 0, 9,999, TGNumberFormat::kNESHex, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELLimitMinMax, + 0, 1024); + hframe->AddFrame( eStopAddr,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eStopAddr->MapWindow(); + eStopAddr->Resize(150,30); + + + + + eStopAddr->SetState(kFALSE); + + + + + + + int idac=0; + for (idac=0; idacSetNumber(myDet->setSpeed(slsDetectorDefs::ADC_CLOCK,-1)); + eRunClkFreq->SetNumber(myDet->setSpeed(slsDetectorDefs::CLOCK_DIVIDER,-1)); + //ADC_PHASE + //PHASE_SHIFT + eFrames->SetNumber(myDet->setTimer(slsDetectorDefs::FRAME_NUMBER,-1)); + ePeriod->SetNumber(((Double_t)myDet->setTimer(slsDetectorDefs::FRAME_PERIOD,-1))*1E-9); + + start=-1; + stop=-1; + n=-1; + myDet->setCTBPatLoops(-1,start, stop,n); + eStartAddr->SetHexNumber(start); + eStopAddr->SetHexNumber(stop); + + for (int iloop=0; iloopupdate(); + + } + + for (int iwait=0; iwaitupdate(); + } + + + +} + +void jctbPattern::setFrames() { + myDet->setTimer(slsDetectorDefs::FRAME_NUMBER,eFrames->GetNumber()); +} + +void jctbPattern::setPeriod() { + myDet->setTimer(slsDetectorDefs::FRAME_PERIOD,eFrames->GetNumber()*1E9); +} + + + + +void jctbPattern::setAdcFreq() { + myDet->setSpeed(slsDetectorDefs::ADC_CLOCK,eAdcClkFreq->GetNumber()); +} +void jctbPattern::setRunFreq() { + myDet->setSpeed(slsDetectorDefs::CLOCK_DIVIDER,eRunClkFreq->GetNumber()); + +} +void jctbPattern::setAdcPhase() { + myDet->setSpeed(slsDetectorDefs::ADC_PHASE,eAdcClkPhase->GetNumber()); + +} + + +void jctbPattern::setRunPhase() { + myDet->setSpeed(slsDetectorDefs::PHASE_SHIFT,eRunClkPhase->GetNumber()); + +} + diff --git a/JCTBGui/jctbPattern.h b/JCTBGui/jctbPattern.h new file mode 100755 index 000000000..75c3a51aa --- /dev/null +++ b/JCTBGui/jctbPattern.h @@ -0,0 +1,124 @@ +#ifndef JCTBPATTERN_H +#define JCTBPATTERN_H +#include + + +#define NLOOPS 3 +#define NWAITS 3 +#define NADCS 32 +#define PATLEN 1024 + +class TRootEmbeddedCanvas; +class TGButtonGroup; +class TGVerticalFrame; +class TGHorizontalFrame; +class TGTextEntry; +class TGLabel; +class TGNumberEntry; +class TH2F; +class TGComboBox; +class TGCheckButton; + +class THStack; +class TGraphErrors; +class energyCalibration; +class TGTextButton; +class TGTab; + +class multiSlsDetector; + + +#include +using namespace std; + + + +class jctbLoop : public TGHorizontalFrame { + + + private: + + TGNumberEntry *eLoopStartAddr; + TGNumberEntry *eLoopStopAddr; + TGNumberEntry *eLoopNumber; + + int id; + + multiSlsDetector *myDet; + + public: + jctbLoop(TGGroupFrame *page, int i,multiSlsDetector *det); + + void setNLoops(); + void update(); + + ClassDef(jctbLoop,0) + }; + +class jctbWait : public TGHorizontalFrame { + + + private: + + TGNumberEntry *eWaitAddr; + TGNumberEntry *eWaitTime; + + int id; + + multiSlsDetector *myDet; + + public: + jctbWait(TGGroupFrame *page, int i,multiSlsDetector *det); + + void setWaitTime(); + void update(); + + ClassDef(jctbWait,0) + }; + + + + + + + +class jctbPattern : public TGGroupFrame { +private: + + + TGNumberEntry *eAdcClkFreq; + TGNumberEntry *eRunClkFreq; + TGNumberEntry *eAdcClkPhase; + TGNumberEntry *eRunClkPhase; + + TGNumberEntry *eStartAddr; + TGNumberEntry *eStopAddr; + TGNumberEntry *eFrames; + TGNumberEntry *ePeriod; + + jctbLoop *eLoop[NLOOPS]; + jctbWait *eWait[NWAITS]; + + + char pat[PATLEN*8]; + + multiSlsDetector *myDet; + +public: + + jctbPattern(TGVerticalFrame *page, multiSlsDetector *det); + + void update(); + void setAdcFreq(); + void setRunFreq(); + void setAdcPhase(); + void setRunPhase(); + void setFrames(); + void setPeriod(); + + + + ClassDef(jctbPattern,0) +}; + +#endif diff --git a/JCTBGui/jctbSignal.cpp b/JCTBGui/jctbSignal.cpp new file mode 100755 index 000000000..4967f59be --- /dev/null +++ b/JCTBGui/jctbSignal.cpp @@ -0,0 +1,186 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include "jctbSignal.h" +#include "multiSlsDetector.h" + +using namespace std; + + + +jctbSignal::jctbSignal(TGFrame *page, int i, multiSlsDetector *det) + : TGHorizontalFrame(page, 800,50), myDet(det), id(i), hsig(NULL) { + + + TGHorizontalFrame *hframe=this; + char tit[100]; + + + + sprintf(tit, "BIT%d ",id); + + sLabel= new TGLabel(hframe, tit); + hframe->AddFrame( sLabel,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + sLabel->MapWindow(); + sLabel->SetTextJustify(kTextLeft); + + + + sOutput= new TGCheckButton(hframe, "Out"); + hframe->AddFrame( sOutput,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + sOutput->MapWindow(); + + + sOutput->Connect("Toggled(Bool_t)","jctbSignal",this,"ToggledOutput(Bool_t)"); + + sClock= new TGCheckButton(hframe, "Clk"); + hframe->AddFrame( sClock,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + sClock->MapWindow(); + + sClock->Connect("Toggled(Bool_t)","jctbSignal",this,"ToggledClock(Bool_t)"); + + + sPlot= new TGCheckButton(hframe, "Plot"); + hframe->AddFrame( sPlot,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + sPlot->MapWindow(); + + sPlot->Connect("Toggled(Bool_t)","jctbSignal",this,"ToggledPlot(Bool_t)"); + + fColorSel = new TGColorSelect(hframe, id+1, 0); + hframe->AddFrame(fColorSel, new TGLayoutHints(kLHintsTop | + kLHintsLeft, 2, 0, 2, 2)); + + + fColorSel->SetColor(TColor::Number2Pixel(id+1)); + + + ToggledOutput(kFALSE); + + if (id==63) { + sOutput->SetOn(kTRUE); + sClock->SetOn(kFALSE); + sOutput->SetEnabled(kFALSE); + sClock->SetEnabled(kFALSE); + } + + +} +int jctbSignal::setSignalAlias(char *tit, int plot, int col) { + + if (tit) + sLabel->SetText(tit); + + if (plot>0) { + sPlot->SetOn(kTRUE,kTRUE); + } else if (plot==0) + sPlot->SetOn(kFALSE,kTRUE); + + if (col>=0) + fColorSel->SetColor(col);//TColor::Number2Pixel(col+1)); + + fColorSel->SetEnabled(sPlot->IsOn()); + return 0; + +} + +string jctbSignal::getSignalAlias() { + + + ostringstream oss; + oss << "BIT" << dec << id << " " << sLabel->GetText()->Data() << " " << sPlot->IsOn() << hex << " " << fColorSel->GetColor() << endl; + return oss.str(); + + + + +} +int jctbSignal::setOutput(Long64_t r) { + + + // cout << hex << r << dec <SetOn(kTRUE,kTRUE); + else + sOutput->SetOn(kFALSE,kTRUE); + + return sOutput->IsOn(); + +} + +int jctbSignal::setClock(Long64_t r) { + + Long64_t mask=((Long64_t)1<SetOn(kTRUE,kTRUE); + else + sClock->SetOn(kFALSE,kTRUE); + + return sClock->IsOn(); + +} + +int jctbSignal::isClock() { sClock->IsOn();} +int jctbSignal::isOutput() { sOutput->IsOn();} +int jctbSignal::isPlot() { sPlot->IsOn();} + + +void jctbSignal::ToggledOutput(Bool_t b) { + Long_t mask=b<SetEnabled(kTRUE); + sPlot->SetEnabled(kTRUE); + if ( sPlot->IsOn()) + fColorSel->SetEnabled(kTRUE); + else + fColorSel->SetEnabled(kFALSE); + } else { + sClock->SetEnabled(kFALSE); + sPlot->SetEnabled(kFALSE); + fColorSel->SetEnabled(kFALSE); + } + + +} +void jctbSignal::ToggledClock(Bool_t b){ + Long_t mask=b<SetEnabled(b); + +} + + +void jctbSignal::ToggledSignalOutput(Int_t b) { + Emit("ToggledSignalOutput(Int_t)", id); + +} +void jctbSignal::ToggledSignalClock(Int_t b){ + Emit("ToggledSignalClock(Int_t)", id); + + +} +void jctbSignal::ToggledSignalPlot(Int_t b){ + Emit("ToggledSignalPlot(Int_t)", id); + +} diff --git a/JCTBGui/jctbSignal.h b/JCTBGui/jctbSignal.h new file mode 100755 index 000000000..a77ec39db --- /dev/null +++ b/JCTBGui/jctbSignal.h @@ -0,0 +1,71 @@ +#ifndef JCTBSIGNAL_H +#define JCTBSIGNAL_H +#include + + + + + +class TGTextEntry; +class TGLabel; +class TGNumberEntry; +class TGCheckButton; +class TH1I; +class TGTextButton; +class TGColorSelect; + + + +class multiSlsDetector; + +#include +using namespace std; + +class jctbSignal : public TGHorizontalFrame { + + // RQ_OBJECT("jctbSignal") + +private: + + TGLabel *sLabel; + TGCheckButton *sOutput; + TGCheckButton *sClock; + TGCheckButton *sPlot; + TGLabel *sValue; + TGNumberEntry *sEntry; + TGColorSelect *fColorSel; + + multiSlsDetector *myDet; + Int_t id; + + TH1I *hsig; + +public: + + jctbSignal(TGFrame *page, int i, multiSlsDetector *det); + int setSignalAlias(char *tit, int plot, int col); + string getSignalAlias(); + + TH1I *getPlot() {return hsig;}; + int setOutput(Long64_t); + int setClock(Long64_t); + + void ToggledOutput(Bool_t); + void ToggledClock(Bool_t); + void ToggledPlot(Bool_t); + + int isClock(); + int isOutput(); + int isPlot(); + + + void ToggledSignalOutput(Int_t); //*SIGNAL* + void ToggledSignalClock(Int_t); //*SIGNAL* + void ToggledSignalPlot(Int_t); //*SIGNAL* + + + + ClassDef(jctbSignal,0) +}; + +#endif diff --git a/JCTBGui/jctbSignals.cpp b/JCTBGui/jctbSignals.cpp new file mode 100755 index 000000000..9acb69451 --- /dev/null +++ b/JCTBGui/jctbSignals.cpp @@ -0,0 +1,257 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "jctbSignals.h" +#include "jctbSignal.h" +#include "multiSlsDetector.h" + +using namespace std; + + + +#define DEFAULTFN "run_0.encal" + + +jctbSignals::jctbSignals(TGVerticalFrame *page, multiSlsDetector *det) + : TGGroupFrame(page,"IO Signals",kVerticalFrame), myDet(det) { + + + SetTitlePos(TGGroupFrame::kLeft); + page->AddFrame(this,new TGLayoutHints( kLHintsTop | kLHintsExpandX , 10,10,10,10)); + MapWindow(); + + cout << "window mapped " << endl; + + TGHorizontalFrame *hframe; + char tit[100]; + + TGHorizontalFrame* hhframe=new TGHorizontalFrame(this, 800,800); + AddFrame(hhframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hhframe->MapWindow(); + + TGVerticalFrame *vframe; + + + + + int idac=0; + for (idac=0; idacAddFrame(vframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + vframe->MapWindow(); + + + + } + + + signals[idac]=new jctbSignal(vframe,idac,myDet); + signals[idac]->Connect(" ToggledSignalOutput(Int_t)","jctbSignals",this,"ToggledOutReg(Int_t)"); + signals[idac]->Connect(" ToggledSignalClock(Int_t)","jctbSignals",this,"ToggledClockReg(Int_t)"); + signals[idac]->Connect(" ToggledSignalPlot(Int_t)","jctbSignals",this,"ToggledPlot(Int_t)"); + + vframe->AddFrame(signals[idac],new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + signals[idac]->MapWindow(); + + } + idac=63; + signals[idac]=new jctbSignal(vframe,idac,myDet); + vframe->AddFrame(signals[idac],new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + signals[idac]->MapWindow(); + sprintf(tit,"ADC Latch"); + + signals[idac]->setSignalAlias(tit,-1,-1); + + signals[idac]->Connect(" ToggledSignalOutput(Int_t)","jctbSignals",this,"ToggledOutReg(Int_t)"); + signals[idac]->Connect(" ToggledSignalClock(Int_t)","jctbSignals",this,"ToggledClockReg(Int_t)"); + signals[idac]->Connect(" ToggledSignalPlot(Int_t)","jctbSignals",this,"ToggledPlot(Int_t)"); + + + + hframe=new TGHorizontalFrame(vframe, 800,50); + vframe->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hframe->MapWindow(); + + + TGLabel *label= new TGLabel(hframe, "IO Control Register"); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + eIOCntrlRegister = new TGNumberEntry(hframe, 0, 16,999, TGNumberFormat::kNESHex, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELNoLimits); + + hframe->AddFrame(eIOCntrlRegister,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eIOCntrlRegister->MapWindow(); + eIOCntrlRegister->Resize(150,30); + + + + + hframe=new TGHorizontalFrame(vframe, 800,50); + vframe->AddFrame(hframe,new TGLayoutHints(kLHintsTop | kLHintsExpandX , 1,1,1,1)); + hframe->MapWindow(); + + + label= new TGLabel(hframe, "Clock Control Register"); + hframe->AddFrame(label,new TGLayoutHints(kLHintsTop | kLHintsLeft| kLHintsExpandX, 1, 1, 1, 1)); + label->MapWindow(); + label->SetTextJustify(kTextLeft); + + + eClkCntrlRegister = new TGNumberEntry(hframe, 0, 16,999, TGNumberFormat::kNESHex, + TGNumberFormat::kNEANonNegative, + TGNumberFormat::kNELNoLimits); + + hframe->AddFrame(eClkCntrlRegister,new TGLayoutHints(kLHintsTop | kLHintsExpandX, 1, 1, 1, 1)); + eClkCntrlRegister->MapWindow(); + eClkCntrlRegister->Resize(150,30); + + eIOCntrlRegister->SetState(kFALSE); + eClkCntrlRegister->SetState(kFALSE); + +} + + + + +int jctbSignals::setSignalAlias(string line) { + + int is=-1, plot=0, col=-1; + char tit[100]; + int narg=sscanf(line.c_str(),"BIT%d %s %d %d",&is,tit,&plot,&col); + if (narg<2) + return -1; + if (is>=0 && issetSignalAlias(tit,plot,col); + } + return is; + +} + +string jctbSignals::getSignalAlias() { + + ostringstream oss; + for (int is=0; isgetSignalAlias() << endl; + + + return oss.str(); + +} + + +void jctbSignals::update() { + Long64_t oreg=myDet->setCTBWord(-1,-1); + Long64_t creg=myDet->setCTBWord(-2,-1); + + + char val[1000]; + cout << hex << oreg << dec << endl; + cout << hex << creg << dec << endl; + + sprintf(val,"%llX",oreg); + // eIOCntrlRegister->SetHexNumber(oreg); + eIOCntrlRegister->SetText(val); + sprintf(val,"%llX",creg); + // eClkCntrlRegister->SetHexNumber(creg); + eClkCntrlRegister->SetText(val); + + for (int idac=0; idacsetOutput(oreg); + signals[idac]->setClock(creg); + } + + + +} + +void jctbSignals::ToggledOutReg(Int_t mask) { + + char val[1000]; + Long64_t oreg=myDet->setCTBWord(-1,-1); + Long64_t m=((Long64_t)1)<isOutput()) + oreg|=m; + else + oreg&=~m; + + cout << dec << sizeof(Long64_t) << " " << mask << " " << hex << m << " ioreg " << oreg << endl; + + myDet->setCTBWord(-1,oreg); + oreg=myDet->setCTBWord(-1,-1); + + cout << dec << sizeof(Long64_t) << " " << mask << " " << hex << m << " ioreg " << oreg << endl; + + sprintf(val,"%llX",oreg); + // eIOCntrlRegister->SetHexNumber(oreg); + eIOCntrlRegister->SetText(val); + // eIOCntrlRegister->SetNumber(oreg); + +} + + + +void jctbSignals::ToggledClockReg(Int_t mask){ + + char val[1000]; + Long64_t oreg=myDet->setCTBWord(-2,-1); + Long64_t m=((Long64_t)1)<isClock()) + oreg|=m; + else + oreg&=~m; + + cout << hex << "clkreg " << oreg << endl; + + myDet->setCTBWord(-2,oreg); + oreg=myDet->setCTBWord(-2,-1); + sprintf(val,"%llX",oreg); + // eIOCntrlRegister->SetHexNumber(oreg); + + eClkCntrlRegister->SetText(val); + +} + + + + +void jctbSignals::ToggledPlot(Int_t mask) { + + if (signals[mask]->isPlot()) + cout << "plot signal " << mask << endl; + else + cout << "unplot signal " << mask << endl; + +} diff --git a/JCTBGui/jctbSignals.h b/JCTBGui/jctbSignals.h new file mode 100755 index 000000000..2f8b4873a --- /dev/null +++ b/JCTBGui/jctbSignals.h @@ -0,0 +1,44 @@ +#ifndef JCTBSIGNALS_H +#define JCTBSIGNALS_H +#include + + +#define NSIGNALS 64 +#define NIOSIGNALS 52 +#define ADCLATCH 63 + + + + +class TGNumberEntry; +class multiSlsDetector; +class jctbSignal; + +#include +using namespace std; + +class jctbSignals : public TGGroupFrame { +private: + + jctbSignal *signals[NSIGNALS]; + + TGNumberEntry *eIOCntrlRegister; + TGNumberEntry *eClkCntrlRegister; + + multiSlsDetector *myDet; + +public: + jctbSignals(TGVerticalFrame *page, multiSlsDetector *det); + int setSignalAlias(string line); + string getSignalAlias(); + + void update(); + + + void ToggledOutReg(Int_t); + void ToggledClockReg(Int_t); + void ToggledPlot(Int_t); + ClassDef(jctbSignals,0) +}; + +#endif