#include <TApplication.h>
#include <TGClient.h>
#include <TCanvas.h>
#include <TF1.h>
#include <TRandom.h>
#include <TRootEmbeddedCanvas.h>
#include <TGTableContainer.h>
#include <TGFileDialog.h>

#include "boardSetting.h"

TString boardSettingName[NUM_BOARD_INFO] = { "Model",
                                             "DPP Type",
                                             "Link Type",
                                             "Serial Number",
                                             "Number of channels",
                                             "Sampling rate",
                                             "ADC bit",
                                             "ROC version",
                                             "AMC version"
                                          }; 

Pixel_t BoardSetting::red = 0;
Pixel_t BoardSetting::blue = 0;
TGNumberEntry * BoardSetting::boardIDEntry = NULL;
Digitizer ** BoardSetting::digi = NULL;
DigitizerPHA * BoardSetting::pha = NULL;
DigitizerPSD * BoardSetting::psd = NULL;

TGTextEntry * BoardSetting::txtACQStatus = NULL;
TGTextEntry * BoardSetting::txtACQEventReady = NULL;
TGTextEntry * BoardSetting::txtACQEventFull = NULL;
TGTextEntry * BoardSetting::txtACQClockSource = NULL;
TGTextEntry * BoardSetting::txtACQPLLLock = NULL;
TGTextEntry * BoardSetting::txtACQChDown = NULL;
TGTextEntry * BoardSetting::txtACQSIN = NULL;
TGTextEntry * BoardSetting::txtACQTRIGIN = NULL;
TGTextEntry * BoardSetting::txtACQBoardReady = NULL;
TGTextEntry * BoardSetting::txtACQTemp0 = NULL;
TGTextEntry * BoardSetting::txtACQTemp1 = NULL;
TGTextEntry * BoardSetting::txtACQTemp2 = NULL;
TGTextEntry * BoardSetting::txtACQTemp3 = NULL;

TGTextEntry *  BoardSetting::txtEventReady = NULL;
TGTextEntry *  BoardSetting::txtBusError = NULL;
TGTextEntry *  BoardSetting::txtVMEFIFO = NULL;

BoardSetting::BoardSetting(const TGWindow *p, UInt_t w, UInt_t h, Digitizer ** digi, int nBoard){
  
  this->nDigi = nBoard;
  this->digi = digi; 
  
  gClient->GetColorByName("red", red);  
  gClient->GetColorByName("blue", blue);  
  
  fMain = new TGMainFrame(p,w,h);
  fMain->SetWindowName("Board Settings & Status");
  fMain->Connect("CloseWindow()", "BoardSetting", this, "CloseWindow()");
  
  TGLayoutHints * layoutHints = new TGLayoutHints(kLHintsCenterX | kLHintsCenterY, 5,5,3,3); /// left, right, top, bottom
  TGVerticalFrame * vframe = new TGVerticalFrame(fMain); fMain->AddFrame(vframe, layoutHints); 
  
  ///==========Module choose
  TGHorizontalFrame *hframe0 = new TGHorizontalFrame(vframe, w, 50 ); vframe->AddFrame(hframe0, layoutHints);
  
  TGLabel * lb0 = new TGLabel(hframe0, "Board ID :"); hframe0->AddFrame(lb0, layoutHints);
  boardIDEntry = new TGNumberEntry(hframe0, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative); hframe0->AddFrame(boardIDEntry, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
  
  boardIDEntry->SetWidth(50);
  boardIDEntry->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, nBoard-1);
  boardIDEntry->Connect("Modified()", "BoardSetting", this, "ChangeBoard()"); 
  if( nBoard <= 1 ) boardIDEntry->SetState(false);

  int boardID = boardIDEntry->GetNumber();
  
  /// Board Failure status
  TGLabel * lbPLLStatus = new TGLabel(hframe0, "PLL status :"); hframe0->AddFrame(lbPLLStatus, layoutHints);
  enPLLStatus = new TGTextEntry(hframe0, ""); hframe0->AddFrame(enPLLStatus, layoutHints);
  enPLLStatus->SetEnabled(false);
  enPLLStatus->Resize(50, 20);
  
  TGLabel * lbTempStatus = new TGLabel(hframe0, "Temp status :"); hframe0->AddFrame(lbTempStatus, layoutHints);
  enTempStatus = new TGTextEntry(hframe0, ""); hframe0->AddFrame(enTempStatus, layoutHints);
  enTempStatus->SetEnabled(false);
  enTempStatus->Resize(50, 20);
  
  TGLabel * lbADCPwrStatus = new TGLabel(hframe0, "ADC Power :"); hframe0->AddFrame(lbADCPwrStatus, layoutHints);
  enADCPwrStatus = new TGTextEntry(hframe0, ""); hframe0->AddFrame(enADCPwrStatus, layoutHints);
  enADCPwrStatus->SetEnabled(false);
  enADCPwrStatus->Resize(50, 20);
  
  TGTextButton * bSoftwareReset = new TGTextButton(hframe0, "Reset default Settings"); hframe0->AddFrame(bSoftwareReset, layoutHints);
  TGTextButton * bSoftwareClear = new TGTextButton(hframe0, "Clear Buffer"); hframe0->AddFrame(bSoftwareClear, layoutHints);
  
  
  {///============ fixed info
    TGHorizontalFrame * hframeInfo = new TGHorizontalFrame(vframe); vframe->AddFrame(hframeInfo, new TGLayoutHints(kLHintsExpandX));
    
    int numCol = 3;
    TGVerticalFrame * vframeInfo[numCol];
    for( int i = 0; i < numCol ; i++) {
      vframeInfo[i] = new TGVerticalFrame(hframeInfo);  hframeInfo->AddFrame(vframeInfo[i],new TGLayoutHints(kLHintsExpandX));
    }
      
    TGHorizontalFrame *hframe[NUM_BOARD_INFO];
    TGLabel * lb[NUM_BOARD_INFO];
    for( int i = 0 ; i < NUM_BOARD_INFO; i++){
      hframe[i] = new TGHorizontalFrame(vframeInfo[i%3], 50, 50 ); vframeInfo[i%3]->AddFrame(hframe[i], new TGLayoutHints(kLHintsRight, 2,2,0,0));
    
      lb[i] = new TGLabel(hframe[i], boardSettingName[i]); hframe[i]->AddFrame(lb[i], new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5, 5, 0, 0));
    
      entry[i] = new TGTextEntry(hframe[i], new TGTextBuffer(1)); hframe[i]->AddFrame(entry[i], new TGLayoutHints(kLHintsRight, 5,5,0,0));
      entry[i]->SetEnabled(false);
    }
  }
  
  {///========= Board Configure
    TGGroupFrame * gBdCfg = new TGGroupFrame(vframe, "Board Configure", kHorizontalFrame); vframe->AddFrame(gBdCfg , new TGLayoutHints(kLHintsExpandX));  
    TGVerticalFrame * vBdCfg = new TGVerticalFrame(gBdCfg); gBdCfg->AddFrame(vBdCfg);
    TGHorizontalFrame * hframeBdCfg1 = new TGHorizontalFrame(vBdCfg); vBdCfg->AddFrame(hframeBdCfg1, layoutHints);
    
    bAutoDataFlush = new TGCheckButton(hframeBdCfg1, "Auto Data Flush", 1); hframeBdCfg1->AddFrame(bAutoDataFlush, layoutHints);
    bAutoDataFlush->SetState(kButtonUp);
    bAutoDataFlush->Connect("Clicked()", "BoardSetting", this, "SetAutoDataFlush()");
    
    bDecimateWF = new TGCheckButton(hframeBdCfg1, "Decimate WaveForm", 1); hframeBdCfg1->AddFrame(bDecimateWF, layoutHints);
    bDecimateWF->SetState(kButtonUp);
    bDecimateWF->Connect("Clicked()", "BoardSetting", this, "SetDecimateWF()");
    
    bWFRecord = new TGCheckButton(hframeBdCfg1, "Record WaveFrom", 1); hframeBdCfg1->AddFrame(bWFRecord, layoutHints);
    bWFRecord->SetState(kButtonUp);
    bWFRecord->Connect("Clicked()", "BoardSetting", this, "SetWaveFormRecord()");

    bTrigPropa = new TGCheckButton(hframeBdCfg1, "Trigger Propagation (coincidence) ", 1); hframeBdCfg1->AddFrame(bTrigPropa, layoutHints);
    bTrigPropa->SetState(kButtonUp);
    bTrigPropa->Connect("Clicked()", "BoardSetting", this, "SetTriggerPropagation()");
    
    bExtrac2 = new TGCheckButton(hframeBdCfg1, "Enable Extra2 word", 1); hframeBdCfg1->AddFrame(bExtrac2, layoutHints);
    bExtrac2->SetState(kButtonUp);
    bExtrac2->Connect("Clicked()", "BoardSetting", this, "SetEnableExtra2()");

    TGHorizontalFrame * hframeBdCfg2 = new TGHorizontalFrame(vBdCfg); vBdCfg->AddFrame(hframeBdCfg2, layoutHints);  
    bDualTrace = new TGCheckButton(hframeBdCfg2, "Dual Trace", 1); hframeBdCfg2->AddFrame(bDualTrace, layoutHints);
    bDualTrace->SetState(kButtonUp);
    bDualTrace->Connect("Clicked()", "BoardSetting", this, "SetDualTrace()");

    TGLabel * lbAP1 = new TGLabel(hframeBdCfg2, "Ana. Prb. 1"); hframeBdCfg2->AddFrame(lbAP1, layoutHints);
    cbAP1 = new TGComboBox(hframeBdCfg2, "Ana. Pb. 1", 1); hframeBdCfg2->AddFrame(cbAP1, layoutHints);  
    cbAP1->EnableTextInput(false);
    cbAP1->AddEntry("Input", 0);
    cbAP1->AddEntry("RC-CR (1st derivative)", 1);
    cbAP1->AddEntry("RC-CR2 (2st derivative)", 2);
    cbAP1->AddEntry("Trapezoid", 3);
    cbAP1->Resize(150, 20);
    cbAP1->Select(0);
    cbAP1->Connect("Changed()", "BoardSetting", this, "SetAnalogProbe1()");
    

    TGLabel * lbAP2 = new TGLabel(hframeBdCfg2, "Ana. Prb. 2"); hframeBdCfg2->AddFrame(lbAP2, layoutHints);
    cbAP2 = new TGComboBox(hframeBdCfg2, "Ana. Pb. 2", 1); hframeBdCfg2->AddFrame(cbAP2, layoutHints);  
    cbAP2->EnableTextInput(false);
    cbAP2->AddEntry("Input", 0);
    cbAP2->AddEntry("Threshold", 1);
    cbAP2->AddEntry("Trapezoid - Baseline", 2);
    cbAP2->AddEntry("Baseline", 3);
    cbAP2->Resize(150, 20);
    cbAP2->Select(0);
    cbAP2->SetEnabled(false);
    cbAP2->Connect("Changed()", "BoardSetting", this, "SetAnalogProbe2()");  
    
    TGLabel * lbDP = new TGLabel(hframeBdCfg2, "Digi. Prb. "); hframeBdCfg2->AddFrame(lbDP, layoutHints);
    cbDP = new TGComboBox(hframeBdCfg2, "Digital. Pb.", 1); hframeBdCfg2->AddFrame(cbDP, layoutHints); 
    cbDP->EnableTextInput(false);
    cbDP->AddEntry("Peaking", 0);
    cbDP->AddEntry("Armed (Triggered)", 1);
    cbDP->AddEntry("Peak Run", 2);
    cbDP->AddEntry("Pile-Up", 3);
    cbDP->AddEntry("Peaking", 4);
    cbDP->AddEntry("TRG Validation Win.", 5);
    cbDP->AddEntry("Baseline freeze", 6);
    cbDP->AddEntry("TRG holdoff", 7);
    cbDP->AddEntry("TRG Validation", 8);
    cbDP->AddEntry("ACQ busy", 9);
    cbDP->AddEntry("Zero Cross", 10);
    cbDP->AddEntry("Ext. TRG", 11);
    cbDP->AddEntry("Memory full", 12);
    cbDP->Resize(150, 20);
    cbDP->Select(0);
    cbDP->Connect("Changed()", "BoardSetting", this, "SetDigitalProbe()");
    
    TGHorizontalFrame * hframeBdCfg3 = new TGHorizontalFrame(vBdCfg); vBdCfg->AddFrame(hframeBdCfg3, layoutHints);
    TGLabel * lbAggOrg = new TGLabel(hframeBdCfg3, "Aggregate Organization"); hframeBdCfg3->AddFrame(lbAggOrg, layoutHints);
    cbAggOrg = new TGComboBox(hframeBdCfg3, "Aggregate Organization", 1); hframeBdCfg3->AddFrame(cbAggOrg, layoutHints); 
    cbAggOrg->EnableTextInput(false);
    cbAggOrg->AddEntry("Not used", 0);
    cbAggOrg->AddEntry("4", 2);
    cbAggOrg->AddEntry("8", 3);
    cbAggOrg->AddEntry("16", 4);
    cbAggOrg->AddEntry("32", 5);
    cbAggOrg->AddEntry("64", 6);
    cbAggOrg->AddEntry("128", 7);
    cbAggOrg->AddEntry("256", 8);
    cbAggOrg->AddEntry("512", 9);
    cbAggOrg->AddEntry("1024", 10);
    cbAggOrg->Resize(150, 20);
    cbAggOrg->Select(0);
    cbAggOrg->Connect("Changed()", "BoardSetting", this, "SetAggregateOrganization()");
    
    TGLabel * lbAggBLT = new TGLabel(hframeBdCfg3, "MAx. Aggregate pre Readout"); hframeBdCfg3->AddFrame(lbAggBLT, layoutHints);
    numAggBLT = new TGNumberEntry(hframeBdCfg3, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  hframeBdCfg3->AddFrame(numAggBLT, layoutHints); 
    numAggBLT->SetWidth(60);
    numAggBLT->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 0x3FF);
    numAggBLT->Connect("Modified()", "BoardSetting", this, "SetReadOutAggregate()"); 
    
      ///"FanSpeed Control",
    TGLabel * lbFanCtrl = new TGLabel(hframeBdCfg3, "Fan Speed Control", kHorizontalFrame); hframeBdCfg3->AddFrame(lbFanCtrl, layoutHints ); 
    cbFanCtrl = new TGComboBox(hframeBdCfg3, "",1); hframeBdCfg3->AddFrame(cbFanCtrl, layoutHints); 
    cbFanCtrl->EnableTextInput(false);
    cbFanCtrl->AddEntry("Slow/Auto",0x30);
    cbFanCtrl->AddEntry("Fast", 0x38); 
    cbFanCtrl->Select(0x30);
    cbFanCtrl->Resize(100, 20);
    }
    
  {///========== ACQ control
    TGGroupFrame * gAcqCtrl = new TGGroupFrame(vframe, "ACQ Control", kHorizontalFrame); vframe->AddFrame(gAcqCtrl , new TGLayoutHints(kLHintsExpandX));  
    TGVerticalFrame * vAcqCtrl = new TGVerticalFrame(gAcqCtrl); gAcqCtrl->AddFrame(vAcqCtrl);
    
    TGHorizontalFrame * hfAcqCtrl = new TGHorizontalFrame(vAcqCtrl); vAcqCtrl->AddFrame(hfAcqCtrl, layoutHints);

    TGLabel * lbAcqMode = new TGLabel(hfAcqCtrl, "ACQ Mode"); hfAcqCtrl->AddFrame(lbAcqMode, layoutHints);
    cbAcqMode = new TGComboBox(hfAcqCtrl, "ACQ Mode", 1); hfAcqCtrl->AddFrame(cbAcqMode, layoutHints); 
    cbAcqMode->EnableTextInput(false);
    cbAcqMode->AddEntry("Software", 0);
    cbAcqMode->AddEntry("S-IN / GPI", 1);
    cbAcqMode->AddEntry("1st Trig. Ctrl.", 2);
    cbAcqMode->AddEntry("LVSD Ctrl.", 3);
    cbAcqMode->Select(0);
    cbAcqMode->Resize(100, 20);

    bAcqArm = new TGCheckButton(hfAcqCtrl, "ACQ Start/Arm", 1); hfAcqCtrl->AddFrame(bAcqArm, layoutHints);
    bAcqArm->SetState(kButtonUp);
    //bAcqArm->Connect("Clicked()", "BoardSetting", this, "SetAutoDataFlush()");
    
    TGLabel * lbPLLref = new TGLabel(hfAcqCtrl, "PLL Ref."); hfAcqCtrl->AddFrame(lbPLLref, layoutHints);
    cbPLLref = new TGComboBox(hfAcqCtrl, "PLL Ref.", 1); hfAcqCtrl->AddFrame(cbPLLref, layoutHints); 
    cbPLLref->EnableTextInput(false);
    cbPLLref->AddEntry("internal", 0);
    cbPLLref->AddEntry("external", 1);
    cbPLLref->Select(0);
    cbPLLref->Resize(100, 20);
    
    TGHorizontalFrame * hfAcqCtrl2 = new TGHorizontalFrame(vAcqCtrl); vAcqCtrl->AddFrame(hfAcqCtrl2, layoutHints);
    
    bSWTrigger = new TGTextButton(hfAcqCtrl2, "Send Software Trigger"); hfAcqCtrl2->AddFrame(bSWTrigger, layoutHints);
    //bSWTrigger->Connect("Clicked()", "BoardSetting", this, "SetAutoDataFlush()");
    
    bSWClockSync = new TGTextButton(hfAcqCtrl2, "Send Software Clock Sync"); hfAcqCtrl2->AddFrame(bSWClockSync, layoutHints);
    //bSWClockSync->Connect("Clicked()", "BoardSetting", this, "SetAutoDataFlush()");
    
    TGLabel * lbRunStartStopDelay = new TGLabel(hfAcqCtrl2, "Run/Start/Stop Delay [ns]"); hfAcqCtrl2->AddFrame(lbRunStartStopDelay, layoutHints);
    numRunStartStopDelay = new TGNumberEntry(hfAcqCtrl2, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  hfAcqCtrl2->AddFrame(numRunStartStopDelay, layoutHints); 
    numRunStartStopDelay->SetWidth(60);
    numRunStartStopDelay->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 0x0FF); 
  }

  {///========= ACD Status
    TGGroupFrame * gAcqStatus = new TGGroupFrame(vframe, "ACQ Status", kHorizontalFrame); vframe->AddFrame(gAcqStatus , new TGLayoutHints(kLHintsExpandX));  
    TGHorizontalFrame * hfAcqStatus = new TGHorizontalFrame(gAcqStatus); gAcqStatus->AddFrame(hfAcqStatus, new TGLayoutHints(kLHintsExpandY , 5, 5, 3, 0));
    
    TGVerticalFrame * vAcqStatus1 = new TGVerticalFrame(hfAcqStatus); hfAcqStatus->AddFrame(vAcqStatus1);
  
    txtACQStatus = new TGTextEntry(vAcqStatus1, new TGTextBuffer(1)); vAcqStatus1->AddFrame(txtACQStatus, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQStatus->SetEnabled(false);
    txtACQStatus->SetText( "ACQ is stopped" );
    
    txtACQEventReady = new TGTextEntry(vAcqStatus1, new TGTextBuffer(1)); vAcqStatus1->AddFrame(txtACQEventReady, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQEventReady->SetEnabled(false);
    txtACQEventReady->SetText( "no Event" );

    txtACQEventFull = new TGTextEntry(vAcqStatus1, new TGTextBuffer(1)); vAcqStatus1->AddFrame(txtACQEventFull, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQEventFull->SetEnabled(false);
    txtACQEventFull->SetText( "no channel FULL" );

    TGVerticalFrame * vAcqStatus2 = new TGVerticalFrame(hfAcqStatus); hfAcqStatus->AddFrame(vAcqStatus2);
  
    txtACQClockSource = new TGTextEntry(vAcqStatus2, new TGTextBuffer(1)); vAcqStatus2->AddFrame(txtACQClockSource, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQClockSource->SetEnabled(false);
    txtACQClockSource->SetText( "Internal Clock" );

    txtACQPLLLock = new TGTextEntry(vAcqStatus2, new TGTextBuffer(1)); vAcqStatus2->AddFrame(txtACQPLLLock, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQPLLLock->SetEnabled(false);
    txtACQPLLLock->SetText( "PLL unlock" );

    txtACQChDown = new TGTextEntry(vAcqStatus2, new TGTextBuffer(1)); vAcqStatus2->AddFrame(txtACQChDown, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQChDown->SetEnabled(false);
    txtACQChDown->SetText( "Channels are ON" );

    TGVerticalFrame * vAcqStatus3 = new TGVerticalFrame(hfAcqStatus); hfAcqStatus->AddFrame(vAcqStatus3);
    
    txtACQSIN = new TGTextEntry(vAcqStatus3, new TGTextBuffer(1)); vAcqStatus3->AddFrame(txtACQSIN, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQSIN->SetEnabled(false);
    txtACQSIN->SetText( "S-IN = 0" );
    
    txtACQTRIGIN = new TGTextEntry(vAcqStatus3, new TGTextBuffer(1)); vAcqStatus3->AddFrame(txtACQTRIGIN, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQTRIGIN->SetEnabled(false);
    txtACQTRIGIN->SetText( "TRG-IN = 0" );
    
    TGVerticalFrame * vAcqStatus4 = new TGVerticalFrame(hfAcqStatus); hfAcqStatus->AddFrame(vAcqStatus4);
    
    txtACQBoardReady = new TGTextEntry(vAcqStatus4, new TGTextBuffer(1)); vAcqStatus4->AddFrame(txtACQBoardReady, new TGLayoutHints(kLHintsLeft, 5,5,0,0));
    txtACQBoardReady->SetEnabled(false);
    txtACQBoardReady->SetText( "Board NOT Ready (PLL & ADCs are NOT sync)" );
    txtACQBoardReady->Resize(280, 20);
    
    TGHorizontalFrame * hfAcqTemp = new TGHorizontalFrame(vAcqStatus4); vAcqStatus4->AddFrame(hfAcqTemp, new TGLayoutHints(kLHintsExpandY , 5, 5, 3, 0));
    
    TGVerticalFrame * vAcqTemp1 = new TGVerticalFrame(hfAcqTemp); hfAcqTemp->AddFrame(vAcqTemp1);
    TGLabel * lbdummy0 = new TGLabel(vAcqTemp1, "                ch :"); vAcqTemp1->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 0, 2));  
    lbdummy0->Resize(60, 20);
    TGLabel * lbACQTemp = new TGLabel(vAcqTemp1, "Temp. Stat.:"); vAcqTemp1->AddFrame(lbACQTemp, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 2, 2));  
    lbACQTemp->Resize(60, 20);
    
    TGVerticalFrame * vAcqTemp2 = new TGVerticalFrame(hfAcqTemp); hfAcqTemp->AddFrame(vAcqTemp2);
    TGLabel * lbch0 = new TGLabel(vAcqTemp2, "0-3"); vAcqTemp2->AddFrame(lbch0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 0, 0));  
    lbch0->Resize(40, 20);
    txtACQTemp0 = new TGTextEntry(vAcqTemp2, new TGTextBuffer(1)); vAcqTemp2->AddFrame(txtACQTemp0, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQTemp0->SetEnabled(false);
    txtACQTemp0->SetText( "<70" );
    txtACQTemp0->Resize(40, 20);
    
    TGVerticalFrame * vAcqTemp3 = new TGVerticalFrame(hfAcqTemp); hfAcqTemp->AddFrame(vAcqTemp3);
    TGLabel * lbch1 = new TGLabel(vAcqTemp3, "4-7"); vAcqTemp3->AddFrame(lbch1, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 0, 0));  
    lbch1->Resize(40,20);
    txtACQTemp1 = new TGTextEntry(vAcqTemp3, new TGTextBuffer(1)); vAcqTemp3->AddFrame(txtACQTemp1, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQTemp1->SetEnabled(false);
    txtACQTemp1->SetText( "<70" );
    txtACQTemp1->Resize(40,20);
    
    TGVerticalFrame * vAcqTemp4 = new TGVerticalFrame(hfAcqTemp); hfAcqTemp->AddFrame(vAcqTemp4);
    TGLabel * lbch2 = new TGLabel(vAcqTemp4, "8-11"); vAcqTemp4->AddFrame(lbch2, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 0, 0));  
    lbch2->Resize(40, 20);
    txtACQTemp2 = new TGTextEntry(vAcqTemp4, new TGTextBuffer(1)); vAcqTemp4->AddFrame(txtACQTemp2, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQTemp2->SetEnabled(false);
    txtACQTemp2->SetText( "<70" );
    txtACQTemp2->Resize(40,20);
    
    TGVerticalFrame * vAcqTemp5 = new TGVerticalFrame(hfAcqTemp); hfAcqTemp->AddFrame(vAcqTemp5);
    TGLabel * lbch3 = new TGLabel(vAcqTemp5, "12-15"); vAcqTemp5->AddFrame(lbch3, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 0, 0));  
    lbch3->Resize(40, 20);
    txtACQTemp3 = new TGTextEntry(vAcqTemp5, new TGTextBuffer(1)); vAcqTemp5->AddFrame(txtACQTemp3, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQTemp3->SetEnabled(false);
    txtACQTemp3->SetText( "<70" );
    txtACQTemp3->Resize(40,20);
    
  }

  {///========= Trigger Configure
    TGGroupFrame * gTRGCfg = new TGGroupFrame(vframe, "Trigger Configure", kHorizontalFrame); vframe->AddFrame(gTRGCfg, new TGLayoutHints(kLHintsExpandX));  
    TGVerticalFrame * vTRGCfg = new TGVerticalFrame(gTRGCfg); gTRGCfg->AddFrame(vTRGCfg, new TGLayoutHints(kLHintsExpandX));
    
    ///--- various type of triggers
    TGHorizontalFrame * hframeTRGCfg = new TGHorizontalFrame(vTRGCfg); vTRGCfg->AddFrame(hframeTRGCfg, new TGLayoutHints(kLHintsCenterY, 2,2,2,2));  
    TGVerticalFrame * vTRGType = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGType, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));

    TGLabel * lbdummy0 = new TGLabel(vTRGType, ""); 
    vTRGType->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 4));  
    vTRGType->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 4));  

    TGVerticalFrame * vTRGMsk[8];
    TGLabel * lbTRGMskCh0[8];
    TGLabel * lbTRGMskCh1[8];
    for( int i = 0; i < 8; i++){
      vTRGMsk[i] = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk[i], new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));  
      lbTRGMskCh0[i] = new TGLabel(vTRGMsk[i], Form("%d", 2*i)); vTRGMsk[i]->AddFrame(lbTRGMskCh0[i], new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
      lbTRGMskCh1[i] = new TGLabel(vTRGMsk[i], Form("%d", 2*i+1)); vTRGMsk[i]->AddFrame(lbTRGMskCh1[i], new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    }

    ///"Global Trigger Mask",
    TGLabel * lbGbTRGMsk = new TGLabel(vTRGType, "Global Trigger Mask"); vTRGType->AddFrame(lbGbTRGMsk, new TGLayoutHints(kLHintsRight | kLHintsCenterY , 5, 5, 3, 4));    
    for( int i = 0; i < 8; i++){
      cbGbTRGMskCh[i]  = new TGCheckButton(vTRGMsk[i], ""); vTRGMsk[i]->AddFrame(cbGbTRGMskCh[i], new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    }

    ///"Trigger Validation Mask",
    TGLabel * lbTRGValMsk = new TGLabel(vTRGType, "Trigger Validation Mask"); vTRGType->AddFrame(lbTRGValMsk, new TGLayoutHints(kLHintsRight | kLHintsCenterY , 5, 5, 3, 4));  
    for( int i = 0; i < 8; i++){
      cbTRGValMskCh[i]  = new TGCheckButton(vTRGMsk[i], ""); vTRGMsk[i]->AddFrame(cbTRGValMskCh[i], new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    }
    
    ///"Front Panel TRG-OUT Enable Mask",
    TGLabel * lbTRGOUTMsk = new TGLabel(vTRGType, "TRG-OUT Mask"); vTRGType->AddFrame(lbTRGOUTMsk, new TGLayoutHints(kLHintsRight | kLHintsCenterY , 5, 5, 3, 4));  
    for( int i = 0; i < 8; i++){
      cbTRGOUTMskCh[i]  = new TGCheckButton(vTRGMsk[i], ""); vTRGMsk[i]->AddFrame(cbTRGOUTMskCh[i], new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    }
    
    TGVerticalFrame * vTRGMsk1 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk1, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    vTRGMsk1->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 4));  
    vTRGMsk1->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 4));  
    TGLabel * lbMajorCoinWin = new TGLabel(vTRGMsk1, "Maj. Coin. Win."); vTRGMsk1->AddFrame(lbMajorCoinWin, new TGLayoutHints(kLHintsRight | kLHintsCenterY , 5, 5, 3, 4)); 
    TGLabel * lbTRGMODE = new TGLabel(vTRGMsk1, "TRG MODE"); vTRGMsk1->AddFrame(lbTRGMODE, new TGLayoutHints(kLHintsRight | kLHintsCenterY , 5, 5, 3, 4));  
    TGLabel * lbTRGOUTMODE = new TGLabel(vTRGMsk1, "TRG-OUT MODE"); vTRGMsk1->AddFrame(lbTRGOUTMODE, new TGLayoutHints(kLHintsRight | kLHintsCenterY , 5, 5, 3, 4));  
    
    TGVerticalFrame * vTRGMsk2 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk2, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    vTRGMsk2->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 4));  
    vTRGMsk2->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 4));  
    
    numMajorCoinWin = new TGNumberEntry(vTRGMsk2, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  vTRGMsk2->AddFrame(numMajorCoinWin); 
    numMajorCoinWin->Resize(70, 20);

    cbTRGMODE = new TGComboBox(vTRGMsk2, "TRG MODE",1); vTRGMsk2->AddFrame(cbTRGMODE); 
    cbTRGMODE->EnableTextInput(false);
    cbTRGMODE->AddEntry("OR", 0);
    cbTRGMODE->AddEntry("AND", 1);
    cbTRGMODE->AddEntry("Majority", 2);
    cbTRGMODE->Resize(70, 20);
    cbTRGMODE->Select(0);
    cbTRGOUTMODE = new TGComboBox(vTRGMsk2, "TRG MODE",1); vTRGMsk2->AddFrame(cbTRGOUTMODE); 
    cbTRGOUTMODE->EnableTextInput(false);
    cbTRGOUTMODE->AddEntry("OR", 0);
    cbTRGOUTMODE->AddEntry("AND", 1);
    cbTRGOUTMODE->AddEntry("Majority", 2);
    cbTRGOUTMODE->Resize(70, 20);
    cbTRGOUTMODE->Select(0);
    
    TGVerticalFrame * vTRGMsk3 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk3, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    vTRGMsk3->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 4));  
    TGLabel * lbMajorLevel = new TGLabel(vTRGMsk3, "Majority Level"); vTRGMsk3->AddFrame(lbMajorLevel, layoutHints); 
    GlbMajorLevel = new TGNumberEntry(vTRGMsk3, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  vTRGMsk3->AddFrame(GlbMajorLevel, new TGLayoutHints(kLHintsCenterY, 2,2,2,2)); 
    GlbMajorLevel->Resize(70, 17);
    TRGMajorLevel = new TGNumberEntry(vTRGMsk3, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  vTRGMsk3->AddFrame(TRGMajorLevel, new TGLayoutHints(kLHintsCenterY, 2,2,2,2)); 
    TRGMajorLevel->Resize(70, 17);
    TRGOUTMajorLevel = new TGNumberEntry(vTRGMsk3, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  vTRGMsk3->AddFrame(TRGOUTMajorLevel, new TGLayoutHints(kLHintsCenterY, 2,2,2,2)); 
    TRGOUTMajorLevel->Resize(70, 17);
      
    //TGVerticalFrame * vTRGMsk4 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk4, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    //TGLabel * lbLVDSTrigger = new TGLabel(vTRGMsk4, "LVDS"); vTRGMsk4->AddFrame(lbLVDSTrigger, layoutHints); 
    //TGLabel * lbdummy1 = new TGLabel(vTRGMsk4, "Trg.");  vTRGMsk4->AddFrame(lbdummy1, layoutHints);    
    //bGLBLVDSTrigger = new TGCheckButton(vTRGMsk4, "", 1); vTRGMsk4->AddFrame(bGLBLVDSTrigger, layoutHints);
    //bGLBLVDSTrigger->SetState(kButtonUp);
    //vTRGMsk4->AddFrame(lbdummy0, layoutHints);    
    //bTRGOUTLVDSTrigger = new TGCheckButton(vTRGMsk4, "", 1); vTRGMsk4->AddFrame(bTRGOUTLVDSTrigger, layoutHints);
    //bTRGOUTLVDSTrigger->SetState(kButtonUp);

    TGVerticalFrame * vTRGMsk5 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk5, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    TGLabel * lbExtTrigger = new TGLabel(vTRGMsk5, "Ext."); vTRGMsk5->AddFrame(lbExtTrigger, layoutHints); 
    TGLabel * lbdummy2 = new TGLabel(vTRGMsk5, "Trg.");  vTRGMsk5->AddFrame(lbdummy2, layoutHints);     

    bGLBExtTrigger = new TGCheckButton(vTRGMsk5, "", 1); vTRGMsk5->AddFrame(bGLBExtTrigger,  layoutHints);
    bGLBExtTrigger->SetState(kButtonUp);
    bTRGExtTrigger = new TGCheckButton(vTRGMsk5, "", 1); vTRGMsk5->AddFrame(bTRGExtTrigger,  layoutHints);
    bTRGExtTrigger->SetState(kButtonUp);
    bTRGOUTExtTrigger = new TGCheckButton(vTRGMsk5, "", 1); vTRGMsk5->AddFrame(bTRGOUTExtTrigger,  layoutHints);
    bTRGOUTExtTrigger->SetState(kButtonUp);

    TGVerticalFrame * vTRGMsk6 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk6, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    TGLabel * lbSWTrigger = new TGLabel(vTRGMsk6, "Software"); vTRGMsk6->AddFrame(lbSWTrigger, layoutHints); 
    TGLabel * lbdummy3 = new TGLabel(vTRGMsk6, "Trg.");  vTRGMsk6->AddFrame(lbdummy3, layoutHints);    
    
    bGLBSoftwareTrigger = new TGCheckButton(vTRGMsk6, "", 1); vTRGMsk6->AddFrame(bGLBSoftwareTrigger,  layoutHints); 
    bGLBSoftwareTrigger->SetState(kButtonDown);
    bTRGSoftwareTrigger = new TGCheckButton(vTRGMsk6, "", 1); vTRGMsk6->AddFrame(bTRGSoftwareTrigger,  layoutHints); 
    bTRGSoftwareTrigger->SetState(kButtonDown);
    bTRGOUTSoftwareTrigger = new TGCheckButton(vTRGMsk6, "", 1); vTRGMsk6->AddFrame(bTRGOUTSoftwareTrigger,  layoutHints); 
    bTRGOUTSoftwareTrigger->SetState(kButtonDown);

    TGHorizontalFrame * hframeTRGCfg2 = new TGHorizontalFrame(vTRGCfg); vTRGCfg->AddFrame(hframeTRGCfg2, new TGLayoutHints(kLHintsCenterY | kLHintsRight, 2,2,2,2));
    //bTRGValMskLVSDGLB = new TGCheckButton(hframeTRGCfg2, "LVSD Global Trg. Valid", 1); hframeTRGCfg2->AddFrame(bTRGValMskLVSDGLB,  new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4));
    //bTRGValMskLVSDLCL = new TGCheckButton(hframeTRGCfg2, "LVSD Local Trg. Valid", 1); hframeTRGCfg2->AddFrame(bTRGValMskLVSDLCL,  new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4));
    
    ///"Disable External Trigger",
    bEnableExtTRG = new TGCheckButton(hframeTRGCfg2, "Enable Ext. Trigger", 1); hframeTRGCfg2->AddFrame(bEnableExtTRG,  new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4));
    
    ///"Extended Veto Delay",
    TGLabel * lbExtendVetoDelay = new TGLabel(hframeTRGCfg2, "Extended Veto Delay"); hframeTRGCfg2->AddFrame(lbExtendVetoDelay, new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4)); 
    numExtendVetoDelay = new TGNumberEntry(hframeTRGCfg2, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  hframeTRGCfg2->AddFrame(numExtendVetoDelay,  new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4)); 
    numExtendVetoDelay->Resize(70, 17);
  }
  
  {///=================="Front Panel IO Control",
    TGGroupFrame * gFrontIOCtrl = new TGGroupFrame(vframe, "Front Panel IO Control", kHorizontalFrame); vframe->AddFrame(gFrontIOCtrl, new TGLayoutHints(kLHintsExpandX)); 
    TGVerticalFrame * vFrontIOCtrl = new TGVerticalFrame(gFrontIOCtrl); gFrontIOCtrl->AddFrame(vFrontIOCtrl, new TGLayoutHints(kLHintsLeft, 5, 5, 3, 4));
    TGHorizontalFrame * hframeFrontIOCtrl = new TGHorizontalFrame(vFrontIOCtrl); vFrontIOCtrl->AddFrame(hframeFrontIOCtrl, new TGLayoutHints(kLHintsCenterY, 5,5,3,4));

    TGLabel * lbLEMOIO = new TGLabel(hframeFrontIOCtrl, "LEMO I/O"); hframeFrontIOCtrl->AddFrame(lbLEMOIO, new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4)); 
    cbLEMOIO = new TGComboBox(hframeFrontIOCtrl, "",1); hframeFrontIOCtrl->AddFrame(cbLEMOIO, new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4)); 
    cbLEMOIO->EnableTextInput(false);
    cbLEMOIO->AddEntry("NIM", 0);
    cbLEMOIO->AddEntry("TTL", 1);
    cbLEMOIO->Select(0);
    cbLEMOIO->Resize(50, 20);
    
    ///use 0x811C, bit:[14:19], 6bits
    TGLabel * lbTRGOUTMODE2 = new TGLabel(hframeFrontIOCtrl, "TRG-OUT Mode"); hframeFrontIOCtrl->AddFrame(lbTRGOUTMODE2, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 5, 5, 3, 4)); 
    cbTRGOUTmode = new TGComboBox(hframeFrontIOCtrl, "",1); hframeFrontIOCtrl->AddFrame(cbTRGOUTmode, new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4)); 
    cbTRGOUTmode->EnableTextInput(false);
    cbTRGOUTmode->AddEntry("force TRG-OUT is 0", 0x08000);  
    cbTRGOUTmode->AddEntry("force TRG-OUT is 1", 0x0C000); 
    cbTRGOUTmode->AddEntry("Trigger",            0x00000);  
    cbTRGOUTmode->AddEntry("Channel Probe",      0x20000); 
    cbTRGOUTmode->AddEntry("S-IN",               0x30000);  
    cbTRGOUTmode->AddEntry("RUN",                0x10000); 
    cbTRGOUTmode->AddEntry("Sync Clock",         0x50000); 
    cbTRGOUTmode->AddEntry("Clock Phase",        0x90000);
    cbTRGOUTmode->AddEntry("BUSY/UNLOCK",        0xD0000);
    cbTRGOUTmode->Select(0);
    cbTRGOUTmode->Resize(160, 20);
    
    bTRGOUTImp = new TGCheckButton(hframeFrontIOCtrl, "TRG-OUT high impe.(off)", 1); hframeFrontIOCtrl->AddFrame(bTRGOUTImp,  layoutHints); 
    bTRGOUTImp->SetState(kButtonUp);

    TGHorizontalFrame * hframeFrontIOCtrl1 = new TGHorizontalFrame(vFrontIOCtrl); vFrontIOCtrl->AddFrame(hframeFrontIOCtrl1, new TGLayoutHints(kLHintsCenterY , 5,5,3,4));
    TGLabel * lbTRGINCtrl = new TGLabel(hframeFrontIOCtrl1, "TRG-IN control"); hframeFrontIOCtrl1->AddFrame(lbTRGINCtrl, new TGLayoutHints(kLHintsCenterY | kLHintsLeft , 5, 5, 3, 4)); 
    cbTRGINCtrl = new TGComboBox(hframeFrontIOCtrl1, "",1); hframeFrontIOCtrl1->AddFrame(cbTRGINCtrl, new TGLayoutHints(kLHintsCenterY | kLHintsCenterX, 5, 5, 3, 4)); 
    cbTRGINCtrl->EnableTextInput(false);
    cbTRGINCtrl->AddEntry("trigger sync with the edge of the TRIG-IN", 0);
    cbTRGINCtrl->AddEntry("trigger sync with the whole TRIG-IN", 1);
    cbTRGINCtrl->Select(0);
    cbTRGINCtrl->Resize(250, 20);
    
    TGLabel * lbTRGINMezzanines = new TGLabel(hframeFrontIOCtrl1, "TRG-IN to Mezzanines"); hframeFrontIOCtrl1->AddFrame(lbTRGINMezzanines, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 5, 5, 3, 4)); 
    cbTRGINMezzanines = new TGComboBox(hframeFrontIOCtrl1, "",1); hframeFrontIOCtrl1->AddFrame(cbTRGINMezzanines, new TGLayoutHints(kLHintsCenterY | kLHintsCenterX, 5, 5, 3, 4)); 
    cbTRGINMezzanines->EnableTextInput(false);
    cbTRGINMezzanines->AddEntry("Trigger local is sync with TRG-IN", 0);
    cbTRGINMezzanines->AddEntry("TRG-IN send to mezzanines (no delay)", 1);
    cbTRGINMezzanines->Select(0);
    cbTRGINMezzanines->Resize(200, 20);

    ///"Front Panel LVDS IO New Features",
    ///"LVDS IO Data",
    
    ///"Analog Monitor Mode
    TGHorizontalFrame * hframeFrontIOCtrl2 = new TGHorizontalFrame(vFrontIOCtrl); vFrontIOCtrl->AddFrame(hframeFrontIOCtrl2, new TGLayoutHints(kLHintsCenterY, 5,5,3,2));
    TGLabel * lbAnaMonitor = new TGLabel(hframeFrontIOCtrl2, "Analog Monitor Mode (MON/Sigma)"); hframeFrontIOCtrl2->AddFrame(lbAnaMonitor, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 5, 5, 3, 2)); 
    cbAnaMonitor = new TGComboBox(hframeFrontIOCtrl2, "",1); hframeFrontIOCtrl2->AddFrame(cbAnaMonitor, new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 2)); 
    cbAnaMonitor->EnableTextInput(false);
    cbAnaMonitor->AddEntry("Trigger Majority", 0);
    cbAnaMonitor->AddEntry("Test", 1); 
    cbAnaMonitor->AddEntry("Buffer Occupancy", 3);
    cbAnaMonitor->AddEntry("Voltage Level", 4); 
    cbAnaMonitor->Select(0);
    cbAnaMonitor->Resize(150, 20);
    cbAnaMonitor->Connect("Changed()", "BoardSetting", this, "SetAnalogMonitorMode()");
    cbAnaMonitor->Connect("Changed()", "ChannelSetting", this, "ChangePolarity()"); //Example to call other class
    
    ///"Buffer Occupancy Gain
    TGLabel * lbBufferOccpGain = new TGLabel(hframeFrontIOCtrl2, "Buffer Occupancy Gain"); hframeFrontIOCtrl2->AddFrame(lbBufferOccpGain, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 5, 5, 3, 2)); 
    numBufferOccpGain = new TGNumberEntry(hframeFrontIOCtrl2, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  hframeFrontIOCtrl2->AddFrame(numBufferOccpGain,  new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 2)); 
    numBufferOccpGain->SetState(false);
    numBufferOccpGain->Resize(70, 17);
  }
  
  TGHorizontalFrame * hRow = new TGHorizontalFrame(vframe); vframe->AddFrame(hRow, new TGLayoutHints(kLHintsExpandX));
  
  //TODO check is VME model
  {///"Readout Control",
    TGGroupFrame * gReadoutCtrl = new TGGroupFrame(hRow, "ReadOut Control", kHorizontalFrame); hRow->AddFrame(gReadoutCtrl); 
    TGVerticalFrame * vReadoutCtrl = new TGVerticalFrame(gReadoutCtrl); gReadoutCtrl->AddFrame(vReadoutCtrl);
    
    TGHorizontalFrame * hReadoutCtrl = new TGHorizontalFrame(vReadoutCtrl); vReadoutCtrl->AddFrame(hReadoutCtrl, new TGLayoutHints(kLHintsCenterY, 5,5,3,4));
    
    TGLabel * lbVMEInterruptLevel = new TGLabel(hReadoutCtrl, "VME Interrupt Level"); hReadoutCtrl->AddFrame(lbVMEInterruptLevel, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 5, 5, 3, 4)); 
    
    cbVMEInterrupLevel = new TGComboBox(hReadoutCtrl, "", 1); hReadoutCtrl->AddFrame(cbVMEInterrupLevel,  new TGLayoutHints(kLHintsCenterY , 5, 5, 3, 4)); 
    cbVMEInterrupLevel->EnableTextInput(false);
    cbVMEInterrupLevel->AddEntry("Disabled", 0);
    cbVMEInterrupLevel->AddEntry("1", 1);
    cbVMEInterrupLevel->AddEntry("2", 2);
    cbVMEInterrupLevel->AddEntry("3", 3);
    cbVMEInterrupLevel->AddEntry("4", 4);
    cbVMEInterrupLevel->AddEntry("5", 5);
    cbVMEInterrupLevel->AddEntry("6", 6);
    cbVMEInterrupLevel->AddEntry("7", 7);
    cbVMEInterrupLevel->Select(0);
    cbVMEInterrupLevel->Resize(70, 20);

    bOpticalLinkInterrupt = new TGCheckButton(hReadoutCtrl, "Optical Link Interrupt", 1); hReadoutCtrl->AddFrame(bOpticalLinkInterrupt,  layoutHints); 
    bOpticalLinkInterrupt->SetState(kButtonUp);

    bEventAligned = new TGCheckButton(hReadoutCtrl, "Event Aligned Enabled", 1); hReadoutCtrl->AddFrame(bEventAligned,  layoutHints); 
    bEventAligned->SetState(kButtonUp);

    bVMEAlogn64Mode = new TGCheckButton(hReadoutCtrl, "64-bit aligned", 1); hReadoutCtrl->AddFrame(bVMEAlogn64Mode,  layoutHints); 
    bVMEAlogn64Mode->SetState(kButtonUp);

    TGHorizontalFrame * hReadoutCtrl2 = new TGHorizontalFrame(vReadoutCtrl); vReadoutCtrl->AddFrame(hReadoutCtrl2, new TGLayoutHints(kLHintsCenterY, 5,5,3,4));
    
    //TGCheckButton * bVMEBaseAddRelocation= new TGCheckButton(hReadoutCtrl, "VME baase addr. relocation", 1); hReadoutCtrl->AddFrame(bVMEBaseAddRelocation,  layoutHints); 
    //bVMEBaseAddRelocation->SetState(kButtonUp);
    //Need Relocation address
    
    bInteruptReleaseMode = new TGCheckButton(hReadoutCtrl2, "Interrupt Release on Acknowldge", 1); hReadoutCtrl2->AddFrame(bInteruptReleaseMode,  layoutHints); 
    bInteruptReleaseMode->SetState(kButtonUp);

    bEnableExtendedBlockTransfer = new TGCheckButton(hReadoutCtrl2, "Enable Extended Block Transfer", 1); hReadoutCtrl2->AddFrame(bEnableExtendedBlockTransfer,  layoutHints); 
    bEnableExtendedBlockTransfer->SetState(kButtonUp);
  }
  
  {///==========="Readout Status"
    TGGroupFrame * gReadoutStatus = new TGGroupFrame(hRow, "Readout Status", kHorizontalFrame); hRow->AddFrame(gReadoutStatus, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 5, 5, 0, 0) ); 
    TGVerticalFrame * vReadoutStatus = new TGVerticalFrame(gReadoutStatus); gReadoutStatus->AddFrame(vReadoutStatus, new TGLayoutHints(kLHintsExpandY , 5, 5, 3, 0));
    
    txtEventReady = new TGTextEntry(vReadoutStatus, new TGTextBuffer(1)); vReadoutStatus->AddFrame(txtEventReady, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtEventReady->SetEnabled(false);
    txtEventReady->SetText( "Event Ready" );
    txtEventReady->SetTextColor(blue);
    
    txtBusError = new TGTextEntry(vReadoutStatus, new TGTextBuffer(1)); vReadoutStatus->AddFrame(txtBusError, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtBusError->SetEnabled(false);
    txtBusError->SetText( "no Bus Error" );
    txtBusError->SetTextColor(blue);
    
    txtVMEFIFO = new TGTextEntry(vReadoutStatus, new TGTextBuffer(1)); vReadoutStatus->AddFrame(txtVMEFIFO, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtVMEFIFO->SetEnabled(false);
    txtVMEFIFO->SetText( "VME FIFO EMPTY" );
    txtVMEFIFO->SetTextColor(blue);
  }
  
  ///===== LVSD
  TGHorizontalFrame * hframeLVSD = new TGHorizontalFrame(vframe); vframe->AddFrame(hframeLVSD, new TGLayoutHints(kLHintsCenterY , 5,5,3,4));
  TGLabel * lbLVSD = new TGLabel(hframeLVSD, "LVSD Control is not impletmented."); hframeLVSD->AddFrame(lbLVSD, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 5, 5, 3, 2)); 

  ///==================== Read digitizer Setting
  ChangeBoard();
  
  fMain->MapSubwindows();
  fMain->Resize(fMain->GetDefaultSize());
  fMain->MapWindow();
  
  
  ///Setup thread
  readStatusThread = new TThread("hahaha", ReadStatus, (void *) 1);
  if( digi != NULL ) {
    readStatusThread->Run();
  }
  
  isOpened = true;
}
BoardSetting::~BoardSetting(){
  
  isOpened = false;
  
  for( int i = 0; i < nDigi; i++) digi[i] = 0;
  
  pha = 0;
  psd = 0;
  
  delete readStatusThread;
  
  fMain->Cleanup();
  delete fMain;

}

void * BoardSetting::ReadStatus(void * ptr){
  int boardID = boardIDEntry->GetNumber();
  
  if( digi == NULL ) {
    printf("no didgitizers\n");
    return 0;
  }
  
  int pauseTime = 1000; /// msec

  if( digi[boardID]->GetDPPType() == V1730_DPP_PHA_CODE ) {
  
    pha = dynamic_cast<DigitizerPHA*> (digi[boardID]);
    
    //while( digi[boardID]->isACQRunning() == false ){
    while( true ){
    
      /// ACQ Status
      uint32_t temp = pha->ReadRegister(Register::DPP::AcquisitionStatus);
      
      txtACQStatus     ->SetText( ((temp >> 2) & 0x1) == 0 ? "ACQ is stopped" : "ACQ is Running");  txtACQStatus->SetTextColor( ((temp >> 2) & 0x1) == 0 ? 1 : blue); 
      txtACQEventReady ->SetText( ((temp >> 3) & 0x1) == 0 ? "no Event" : "Has Events");            txtACQEventReady->SetTextColor( ((temp >> 3) & 0x1) == 0 ? 1 : blue); 
      txtACQEventFull  ->SetText( ((temp >> 4) & 0x1) == 0 ? "no channel FULL" : "a channel FULL"); txtACQEventFull->SetTextColor( ((temp >> 4) & 0x1) == 0 ? 1 : red); 
      txtACQClockSource->SetText( ((temp >> 5) & 0x1) == 0 ? "Internal Clock" : "External Clock");  txtACQClockSource->SetTextColor( ((temp >> 5) & 0x1) == 0 ? 1 : blue); 
      txtACQPLLLock    ->SetText( ((temp >> 7) & 0x1) == 0 ? "PLL no lock" : "PLL locked");         txtACQPLLLock->SetTextColor( ((temp >> 7) & 0x1) == 0 ? 1 : blue); 
      txtACQBoardReady ->SetText( ((temp >> 8) & 0x1) == 0 ? "Board NOT Ready (PLL & ADCs are NOT sync)" : "Board Ready (PLL & ADCs are sync)");         
            txtACQBoardReady->SetTextColor( ((temp >> 8) & 0x1) == 0 ? red : 1);
      txtACQChDown     ->SetText( ((temp >> 19) & 0x1) == 0 ? "Channels are ON" : "Channels ShutDown");
            txtACQChDown->SetTextColor( ((temp >> 19) & 0x1) == 0 ? 1 : red); 
      txtACQSIN    ->SetText( ((temp >> 15) & 0x1) == 0 ? "S-IN = 0" : "S-IN = 1");          txtACQSIN->SetTextColor( ((temp >> 15) & 0x1) == 0 ? 1 : blue); 
      txtACQTRIGIN  ->SetText( ((temp >> 16) & 0x1) == 0 ? "TRG-IN = 0" : "TRG-IN = 1");  txtACQTRIGIN->SetTextColor( ((temp >> 16) & 0x1) == 0 ? 1 : blue); 
      
      txtACQTemp0->SetText( ((temp >> 20) & 0x1) == 0 ? "< 70" : "> 70");       txtACQTemp0->SetTextColor( ((temp >> 20) & 0x1) == 0 ? 1 : red); 
      txtACQTemp1->SetText( ((temp >> 21) & 0x1) == 0 ? "< 70" : "> 70");       txtACQTemp1->SetTextColor( ((temp >> 21) & 0x1) == 0 ? 1 : red); 
      txtACQTemp2->SetText( ((temp >> 22) & 0x1) == 0 ? "< 70" : "> 70");       txtACQTemp2->SetTextColor( ((temp >> 22) & 0x1) == 0 ? 1 : red); 
      txtACQTemp3->SetText( ((temp >> 23) & 0x1) == 0 ? "< 70" : "> 70");       txtACQTemp3->SetTextColor( ((temp >> 23) & 0x1) == 0 ? 1 : red); 
      
      /// Redaout Status
      temp = pha->ReadRegister(Register::DPP::ReadoutStatus);
      if( (temp & 0x1) == 1 ){
        txtEventReady->SetText( "Event Ready" ); txtEventReady->SetTextColor(blue);
      }else{
        txtEventReady->SetText( "No Data Ready" ); txtEventReady->SetTextColor(red);
      }
      
      if( (( temp >> 2 ) & 0x1 ) == 0 ){
        txtBusError->SetText( "no Bus Error" ); txtBusError->SetTextColor(blue);
      }else{
        txtBusError->SetText( "Bus Error" ); txtBusError->SetTextColor(red);
      }

      if( (( temp >> 3 ) & 0x1 ) == 0 ){
        txtVMEFIFO->SetText( "VME FIFO NOT EMPTY" ); txtVMEFIFO->SetTextColor(red);
      }else{
        txtVMEFIFO->SetText( "VME FIFO EMPTY" ); txtVMEFIFO->SetTextColor(red);
      }
      
    }

    pha = 0;
  }
}

void BoardSetting::ChangeBoard(){
  int boardID = boardIDEntry->GetNumber();
  
  if( digi == NULL ) {
    printf("no didgitizers\n");
    return;
  }else{
    digi[boardID]->PrintBoard();
  }
  
  for( int i = 0; i < NUM_BOARD_INFO;  i++){
    switch (i) {
      case 0 : entry[i]->SetText( Form("%s", (digi[boardID]->GetModelName()).c_str()) ); break;
      case 1 : 
      
        switch (digi[boardID]->GetDPPType()){
          case V1724_DPP_PHA_CODE: entry[i]->SetText("DPP-PHA "); break;
          case V1720_DPP_CI_CODE : entry[i]->SetText("DPP-CI"); break;
          case V1720_DPP_PSD_CODE: entry[i]->SetText("DPP-PSD "); break;
          case V1751_DPP_PSD_CODE: entry[i]->SetText("DPP-PSD "); break;
          case V1751_DPP_ZLE_CODE: entry[i]->SetText("DPP-ZLE "); break;
          case V1743_DPP_CI_CODE:  entry[i]->SetText("DPP-PSD "); break;
          case V1740_DPP_QDC_CODE: entry[i]->SetText("DPP-QDC "); break;
          case V1730_DPP_PSD_CODE: entry[i]->SetText("DPP-PSD "); break;
          case V1730_DPP_PHA_CODE: entry[i]->SetText("DPP-PHA "); break;
          case V1730_DPP_ZLE_CODE: entry[i]->SetText("DPP-ZLE "); break;
          case V1730_DPP_DAW_CODE: entry[i]->SetText("DPP-DAW "); break;
        }
        
        break;
      case 2 : entry[i]->SetText( Form("%s", digi[boardID]->GetLinkType() ==  CAEN_DGTZ_USB ? "USB" : "Optical Link") ); break;
      case 3 : entry[i]->SetText( Form("%d", digi[boardID]->GetSerialNumber() ) ); break;
      case 4 : entry[i]->SetText( Form("%d", digi[boardID]->GetNChannel() ) ); break;
      case 5 : entry[i]->SetText( Form("%0.f MHz = %.1f ns", 1000/digi[boardID]->GetCh2ns(), digi[boardID]->GetCh2ns()) ); break;
      case 6 : entry[i]->SetText( Form("%d", digi[boardID]->GetADCBits() ) ); break;
      case 7 : entry[i]->SetText( Form("%s", (digi[boardID]->GetROCVersion()).c_str() ) ); break;
      case 8 : entry[i]->SetText( Form("%s", (digi[boardID]->GetAMCVersion()).c_str() ) ); break;
    }
  }
  
  ///================ Board Failure Status
  if( digi[boardID]->GetDPPType() == V1730_DPP_PHA_CODE ) {
    
    pha = dynamic_cast<DigitizerPHA*> (digi[boardID]);
    
    unsigned int temp = pha->ReadRegister(Register::BoardFailureStatus);
    
    if( (temp & 0x10) == 0 ) {
      enPLLStatus->SetText( "OK" ); enPLLStatus->SetTextColor(1);
    }else{
      enPLLStatus->SetText( "Lost Lock" ); enPLLStatus->SetTextColor(red);
    }
    
    if( (temp & 0x20) == 0 ) {
      enTempStatus->SetText( "OK (<70)" ); enTempStatus->SetTextColor(1);
    }else{
      enTempStatus->SetText( "Failure" ); enTempStatus->SetTextColor(red);
    }
    
    if( (temp & 0x40) == 0 ) {
      enADCPwrStatus->SetText( "OK" ); enADCPwrStatus->SetTextColor(1);
    }else{
      enADCPwrStatus->SetText( "Failure" ); enADCPwrStatus->SetTextColor(red);
    }
    
    pha->PrintBoardConfiguration();
    
    bAutoDataFlush->SetState( pha->GetSetting(Setting::PHA::AutoDataFlush_board_bool) == 1.0 ? kButtonDown : kButtonUp );
    bDecimateWF->SetState(    pha->GetSetting(Setting::PHA::DecimateWaveForm_board_bool) == 1.0 ? kButtonDown : kButtonUp );
    bWFRecord->SetState(     pha->GetSetting(Setting::PHA::WavefromRecording_board_bool) == 1.0? kButtonDown : kButtonUp );
    bTrigPropa->SetState(  pha->GetSetting(Setting::PHA::TriggerPropapation_board_bool) == 1.0? kButtonDown : kButtonUp );
    bExtrac2->SetState(  pha->GetSetting(Setting::PHA::EnableExtra2Word_board_bool) == 1.0? kButtonDown : kButtonUp);
    bDualTrace->SetState( pha->GetSetting(Setting::PHA::DualTrace_board_bool) == 1.0? kButtonDown : kButtonUp);
    
    cbAP1->Select( pha->GetSetting(Setting::PHA::AnalogProbe1_board_2bit) );
    cbAP2->Select( pha->GetSetting(Setting::PHA::AnalogProbe2_board_2bit) );
    cbDP->Select( pha->GetSetting(Setting::PHA::VirtualProbe_board_4bit) );
    
    cbAggOrg->Select( pha->GetSetting(Setting::PHA::AggregateOrganization_board_3bit) );
    numAggBLT->SetNumber( pha->GetSetting(Setting::PHA::MaxAggregatePreBlockTransfer_board_10bit) );
    
    cbFanCtrl->Select( pha->GetSetting(Setting::PHA::FanSpeedControl_bool) );
    
    pha->PrintACQControl();
    
    cbAcqMode->Select( pha->GetSetting(Setting::PHA::StartStopMode_2bit));
    bAcqArm->SetState( pha->GetSetting(Setting::PHA::StartStopACQ_bool) == 1.0 ? kButtonDown : kButtonUp);
    cbPLLref->Select( pha->GetSetting(Setting::PHA::PLLClockSource_bool));
    
    numRunStartStopDelay->SetNumber( pha->GetSetting(Setting::PHA::RunStartStopDelay_8bit));
    
    /// Global Trigger Mask
    temp = pha->ReadRegister(Register::DPP::GlobalTriggerMask);
    for( int i = 0; i < 8; i++){
      cbGbTRGMskCh[i]->SetState( ((temp >> i ) & 0x1) == 0 ? kButtonUp : kButtonDown );
    }
    numMajorCoinWin->SetNumber( (temp >> 20 ) & 0x7 );
    GlbMajorLevel->SetNumber( ( temp >> 24) & 0x7 );
    //bGLBLVDSTrigger->SetState( (( temp >> 29) & 0x1 ) == 0 ? kButtonUp : kButtonDown);
    bGLBExtTrigger->SetState( (( temp >> 30) & 0x1 ) == 0 ? kButtonUp : kButtonDown);
    bGLBSoftwareTrigger->SetState( (( temp >> 31) & 0x1 ) == 0 ? kButtonUp : kButtonDown);

    /// Trigger Validation Mask
    temp = pha->ReadRegister(Register::DPP::TriggerValidationMask);
    for( int i = 0; i < 8; i++){
      cbTRGValMskCh[i]->SetState( ((temp >> i ) & 0x1) == 0 ? kButtonUp : kButtonDown );
    }
    cbTRGMODE->Select( ( temp >> 8 ) & 0x3) ;
    TRGMajorLevel->SetNumber( ( temp >> 10 ) & 0x3);
    bTRGExtTrigger->SetState( (( temp >> 30) & 0x1 ) == 0 ? kButtonUp : kButtonDown);
    bTRGSoftwareTrigger->SetState( (( temp >> 31) & 0x1 ) == 0 ? kButtonUp : kButtonDown);

    //bTRGValMskLVSDGLB->SetState( (( temp >> 28) & 0x1 ) == 0 ? kButtonUp : kButtonDown);
    //bTRGValMskLVSDLCL->SetState( (( temp >> 29) & 0x1 ) == 0 ? kButtonUp : kButtonDown);
    
    /// Front Panel TRG-OUT Enable Mask
    temp = pha->ReadRegister(Register::DPP::FrontPanelTRGOUTEnableMask);
    for( int i = 0; i < 8; i++){
      cbTRGOUTMskCh[i]->SetState( ((temp >> i ) & 0x1) == 0 ? kButtonUp : kButtonDown );
    }
    cbTRGOUTMODE->Select( ( temp >> 8 ) & 0x3) ;
    TRGOUTMajorLevel->SetNumber( ( temp >> 10 ) & 0x7);
    //bTRGOUTLVDSTrigger->SetState( (( temp >> 29) & 0x1 ) == 0 ? kButtonUp : kButtonDown);
    bTRGOUTExtTrigger->SetState( (( temp >> 30) & 0x1 ) == 0 ? kButtonUp : kButtonDown);
    bTRGOUTSoftwareTrigger->SetState( (( temp >> 30) & 0x1 ) == 0 ? kButtonUp : kButtonDown);
    
    bEnableExtTRG->SetState( pha->GetSetting(Setting::PHA::DisableExternalTrigger_bool) == 1.0 ? kButtonDown : kButtonUp);
    
    numExtendVetoDelay->SetNumber( pha->GetSetting(Setting::PHA::ExtendedVetoDelay_16bit) );
    
    /// Front Panel I/O Control
    temp = pha->ReadRegister(Register::DPP::FrontPanelIOControl);
    cbLEMOIO->Select( temp & 0x1 );
    cbTRGOUTmode->Select( (temp >> 14) & 0x3F );
    bTRGOUTImp->SetState( ((temp >> 1) & 0x1 ) == 0 ? kButtonUp : kButtonDown) ;
    cbTRGINCtrl->Select( (temp >> 10) & 0x1 );
    cbTRGINMezzanines->Select( (temp >> 11) & 0x1 );
    
    cbAnaMonitor->Select( pha->GetSetting(Setting::PHA::AnalogMonitorMode_3bit) );
    numBufferOccpGain->SetNumber( pha->GetSetting(Setting::PHA::BufferOccupancyGain_4bit));
    
    /// Readout Control
    temp = pha->ReadRegister(Register::DPP::ReadoutControl);
    cbVMEInterrupLevel->Select( temp & 0x3 ); 
    bOpticalLinkInterrupt->SetState( (( temp >> 3 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown) ;
    bEventAligned->SetState( (( temp >> 4 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown) ;
    bVMEAlogn64Mode->SetState( (( temp >> 5 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown) ;
    bInteruptReleaseMode->SetState( (( temp >> 7 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown) ;
    bEnableExtendedBlockTransfer->SetState( (( temp >> 8 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown) ;
    

    
    pha = NULL; ///unlink the pointer
  }else if( digi[boardID]->GetDPPType() == V1730_DPP_PSD_CODE ) {
    
    
  }else{ ///========== disable all others
    bAutoDataFlush->SetEditable(false);
    
    
    
  }
  
  
  

  return;
}

void BoardSetting::SetAutoDataFlush(){
  printf("========== Auto Data Flush \n");
}

void BoardSetting::SetDecimateWF(){
  printf("========== Decimate WF \n");
}

void BoardSetting::SetWaveFormRecord(){
  printf("========== WF Record \n");
}

void BoardSetting::SetDualTrace(){
  printf("========== Dual trace \n");
  cbAP2->SetEnabled(bDualTrace->IsDown());
}

void BoardSetting::SetTriggerPropagation(){
  printf("========== Trigger Propagation \n");
}

void BoardSetting::SetEnableExtra2(){
  printf("========== SetEnableExtra2 \n");
}

void BoardSetting::SetAnalogProbe1(){
  printf("========== SetAnalogProbe1, %d \n", cbAP1->GetSelected());
  
}

void BoardSetting::SetAnalogProbe2(){
  printf("========== SetAnalogProbe2, %d \n", cbAP2->GetSelected());
}

void BoardSetting::SetDigitalProbe(){
  printf("========== SetDigitalProbe, %d \n", cbDP->GetSelected());
}

void BoardSetting::SetAggregateOrganization(){
  printf("========== SetAggregateOrganization, %d \n", cbAggOrg->GetSelected());
}

void BoardSetting::SetReadOutAggregate(){
  printf("========== SetReadOutAggregate, %d \n", (int) numAggBLT->GetNumber());
}

void BoardSetting::SetAnalogMonitorMode(){
  printf("========== SetAnalogMonitorMode, %d \n", cbAnaMonitor->GetSelected());
  if( cbAnaMonitor->GetSelected() == 3) {
    numBufferOccpGain->SetState(true);
  }else{
    numBufferOccpGain->SetState(false);
  }
}

void BoardSetting::SoftwareReset(){
  
}