#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"
                                          }; 

bool BoardSetting::isOpened = false;

///======== declared at FSUDAQ.cpp
extern Pixel_t red, blue, green;
extern unsigned short nDigi;
extern Digitizer ** digi;

BoardSetting::BoardSetting(const TGWindow *p, UInt_t w, UInt_t h){

  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, nDigi-1);
  boardIDEntry->Connect("Modified()", "BoardSetting", this, "ChangeBoard()"); 
  if( nDigi <= 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 Settings to default"); hframe0->AddFrame(bSoftwareReset, layoutHints);
  bSoftwareReset->Connect("Clicked()", "BoardSetting", this, "ResetSettingToDefault()");
  
  TGTextButton * bSoftwareClear = new TGTextButton(hframe0, "Clear Buffer"); hframe0->AddFrame(bSoftwareClear, layoutHints);
  bSoftwareClear->Connect("Clicked()", "BoardSetting", this, "ClearBuffer()");
  
  {///=========== Setting file
    TGHorizontalFrame *hframe1 = new TGHorizontalFrame(vframe); vframe->AddFrame(hframe1, new TGLayoutHints(kLHintsLeft, 5, 5, 0, 0));

    TGTextButton * bProgramBoardFromFile = new TGTextButton(hframe1, "Load File"); hframe1->AddFrame(bProgramBoardFromFile, new TGLayoutHints( kLHintsLeft | kLHintsCenterY, 5,5,3,3));
    bProgramBoardFromFile->Connect("Clicked()", "BoardSetting", this, "ProgramBoardFromFile()");
    if( nDigi == 1 && digi[0]->IsDummy() ) bProgramBoardFromFile->SetEnabled(false);
    
    TGTextButton * bSaveFile = new TGTextButton(hframe1, "Save As"); hframe1->AddFrame(bSaveFile, new TGLayoutHints( kLHintsLeft | kLHintsCenterY, 5,5,3,3));
    bSaveFile->Connect("Clicked()", "BoardSetting", this, "SaveSettingFile()");
    
    TGLabel * lbSettingFile = new TGLabel(hframe1, "Setting file :"); hframe1->AddFrame(lbSettingFile, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5,5,4,2));
    txtSettingFile = new TGTextEntry(hframe1, ""); hframe1->AddFrame(txtSettingFile, new TGLayoutHints(kLHintsLeft | kLHintsCenterY, 5,5,3,3));
    txtSettingFile->SetEnabled(false);
    txtSettingFile->Resize(550, 20);
    if( digi != NULL ) txtSettingFile->SetText( digi[boardID]->GetSettingFileName().c_str());    

  }
  
  {///============ fixed info
    TGGroupFrame * gInfo = new TGGroupFrame(vframe, "Board Info", kHorizontalFrame); vframe->AddFrame(gInfo, new TGLayoutHints(kLHintsExpandX, 5, 0, 0, 0));  
    TGHorizontalFrame * hframeInfo = new TGHorizontalFrame(gInfo); gInfo->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);
    }
  }
  
  TGHorizontalFrame * hRow3 = new TGHorizontalFrame(vframe); vframe->AddFrame(hRow3, new TGLayoutHints(kLHintsExpandX));

  {///========= ACD Status
    TGGroupFrame * gAcqStatus = new TGGroupFrame(hRow3, "ACQ Status", kHorizontalFrame); hRow3->AddFrame(gAcqStatus, new TGLayoutHints(kLHintsExpandX, 5, 5, 0, 0));  
    TGHorizontalFrame * hfAcqStatus = new TGHorizontalFrame(gAcqStatus); gAcqStatus->AddFrame(hfAcqStatus, new TGLayoutHints(kLHintsExpandX));
    
    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" );
  
    txtACQClockSource = new TGTextEntry(vAcqStatus1, new TGTextBuffer(1)); vAcqStatus1->AddFrame(txtACQClockSource, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQClockSource->SetEnabled(false);
    txtACQClockSource->SetText( "Internal Clock" );

    TGVerticalFrame * vAcqStatus2 = new TGVerticalFrame(hfAcqStatus); hfAcqStatus->AddFrame(vAcqStatus2);
    
    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" );
    
    txtACQSIN = new TGTextEntry(vAcqStatus2, new TGTextBuffer(1)); vAcqStatus2->AddFrame(txtACQSIN, new TGLayoutHints(kLHintsRight, 5,5,0,0));
    txtACQSIN->SetEnabled(false);
    txtACQSIN->SetText( "S-IN = 0" );
    
    txtACQTRIGIN = new TGTextEntry(vAcqStatus2, new TGTextBuffer(1)); vAcqStatus2->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);
    
  }

  {///==========="Readout Status"
    TGGroupFrame * gReadoutStatus = new TGGroupFrame(hRow3, "Readout Status", kHorizontalFrame); hRow3->AddFrame(gReadoutStatus, new TGLayoutHints( kLHintsExpandY, 0, 0, 0, 0) ); 

    TGVerticalFrame * vReadoutStatus = new TGVerticalFrame(gReadoutStatus); gReadoutStatus->AddFrame(vReadoutStatus, new TGLayoutHints(kLHintsCenterY | kLHintsExpandY, 5, 5, 10, 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->Resize(150,20);
    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->Resize(150,20);
    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->Resize(150,20);
    txtVMEFIFO->SetTextColor(blue);
  }

  TGHorizontalFrame * hRow1 = new TGHorizontalFrame(vframe); vframe->AddFrame(hRow1, new TGLayoutHints( kLHintsExpandX));
  
  {///========= Board Configure
    TGGroupFrame * gBdCfg = new TGGroupFrame(hRow1, "Board Configure", kHorizontalFrame); hRow1->AddFrame(gBdCfg, new TGLayoutHints( kLHintsLeft, 5, 5, 0, 0));  
    
    TGVerticalFrame * vBdCfg0 = new TGVerticalFrame(gBdCfg); gBdCfg->AddFrame(vBdCfg0 );
    
    TGHorizontalFrame * hBdCfg = new TGHorizontalFrame(vBdCfg0); vBdCfg0->AddFrame(hBdCfg, new TGLayoutHints( kLHintsLeft));
    
    TGVerticalFrame * vBdCfg1 = new TGVerticalFrame(hBdCfg); hBdCfg->AddFrame(vBdCfg1, new TGLayoutHints( kLHintsLeft, 5, 5, 10, 0) );
    
    TGLayoutHints * haha = new TGLayoutHints( kLHintsLeft, 5, 5, 3, 0);
    
    bAutoDataFlush = new TGCheckButton(vBdCfg1, "Auto Data Flush", 1); vBdCfg1->AddFrame(bAutoDataFlush, haha);
    bAutoDataFlush->SetState(kButtonUp);
    bAutoDataFlush->Connect("Clicked()", "BoardSetting", this, "SetBoardConfiguration()");
    
    bDecimateWF = new TGCheckButton(vBdCfg1, "Decimate WaveForm", 1); vBdCfg1->AddFrame(bDecimateWF, haha);
    bDecimateWF->SetState(kButtonUp);
    bDecimateWF->Connect("Clicked()", "BoardSetting", this, "SetBoardConfiguration()");

    bWFRecord = new TGCheckButton(vBdCfg1, "Record WaveFrom", 1); vBdCfg1->AddFrame(bWFRecord, haha);
    bWFRecord->SetState(kButtonUp);
    bWFRecord->Connect("Clicked()", "BoardSetting", this, "SetBoardConfiguration()");

    bTrigPropa = new TGCheckButton(vBdCfg1, "Trigger Propagation (coincidence) ", 1); vBdCfg1->AddFrame(bTrigPropa, haha);
    bTrigPropa->SetState(kButtonUp);
    bTrigPropa->Connect("Clicked()", "BoardSetting", this, "SetBoardConfiguration()");
    
    bExtrac2 = new TGCheckButton(vBdCfg1, "Enable Extra2 word", 1); vBdCfg1->AddFrame(bExtrac2, haha);
    bExtrac2->SetState(kButtonUp);
    bExtrac2->Connect("Clicked()", "BoardSetting", this, "SetBoardConfiguration()");
    
    
    TGVerticalFrame * vBdCfg2 = new TGVerticalFrame(hBdCfg); hBdCfg->AddFrame(vBdCfg2, new TGLayoutHints( kLHintsLeft, 5, 5, 10, 0));
    
    bDualTrace = new TGCheckButton(vBdCfg2, "Dual Trace", 1); vBdCfg2->AddFrame(bDualTrace);
    bDualTrace->SetState(kButtonUp);
    bDualTrace->Connect("Clicked()", "BoardSetting", this, "SetBoardConfiguration()");
    
    TGHorizontalFrame * hBdCfg_Probe = new TGHorizontalFrame(vBdCfg2); vBdCfg2->AddFrame(hBdCfg_Probe);
    
    TGVerticalFrame * vBdCfg_Probe_Label = new TGVerticalFrame(hBdCfg_Probe); hBdCfg_Probe->AddFrame(vBdCfg_Probe_Label);
    
    TGVerticalFrame * vBdCfg_Probe_CBox = new TGVerticalFrame(hBdCfg_Probe); hBdCfg_Probe->AddFrame(vBdCfg_Probe_CBox);
    
    TGLayoutHints * kaka = new TGLayoutHints( kLHintsRight, 5, 5, 3, 2);
    
    TGLabel * lbAP1 = new TGLabel(vBdCfg_Probe_Label, "Ana. Prb. 1"); vBdCfg_Probe_Label->AddFrame(lbAP1, kaka);
    cbAP1 = new TGComboBox(vBdCfg_Probe_CBox, "Ana. Pb. 1", 1); vBdCfg_Probe_CBox->AddFrame(cbAP1);  
    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->Connect("Changed()", "BoardSetting", this, "SetBoardConfiguration()");
    
    TGLabel * lbAP2 = new TGLabel(vBdCfg_Probe_Label, "Ana. Prb. 2"); vBdCfg_Probe_Label->AddFrame(lbAP2, kaka);
    cbAP2 = new TGComboBox(vBdCfg_Probe_CBox, "Ana. Pb. 2", 1); vBdCfg_Probe_CBox->AddFrame(cbAP2);  
    cbAP2->EnableTextInput(false);
    cbAP2->AddEntry("N/A", -3);
    cbAP2->AddEntry("Input", 0);
    cbAP2->AddEntry("Threshold", 1);
    cbAP2->AddEntry("Trapezoid - Baseline", 2);
    cbAP2->AddEntry("Baseline", 3);
    cbAP2->Resize(150, 20);
    cbAP2->SetEnabled(false);
    cbAP2->Connect("Changed()", "BoardSetting", this, "SetBoardConfiguration()");  
    
    TGLabel * lbDP1 = new TGLabel(vBdCfg_Probe_Label, "Digi. Prb. 1"); vBdCfg_Probe_Label->AddFrame(lbDP1, kaka);
    cbDP1 = new TGComboBox(vBdCfg_Probe_CBox, "Digital. Pb.", 1); vBdCfg_Probe_CBox->AddFrame(cbDP1); 
    cbDP1->EnableTextInput(false);
    cbDP1->AddEntry("Peaking", 0);
    cbDP1->AddEntry("Armed (Triggered)", 1);
    cbDP1->AddEntry("Peak Run", 2);
    cbDP1->AddEntry("Pile-Up", 3);
    cbDP1->AddEntry("Peaking", 4);
    cbDP1->AddEntry("TRG Validation Win.", 5);
    cbDP1->AddEntry("Baseline freeze", 6);
    cbDP1->AddEntry("TRG holdoff", 7);
    cbDP1->AddEntry("TRG Validation", 8);
    cbDP1->AddEntry("ACQ busy", 9);
    cbDP1->AddEntry("Zero Cross", 10);
    cbDP1->AddEntry("Ext. TRG", 11);
    cbDP1->AddEntry("Memory full", 12);
    cbDP1->Resize(150, 20);
    cbDP1->Connect("Changed()", "BoardSetting", this, "SetBoardConfiguration()");
    
    TGLabel * lbDP2 = new TGLabel(vBdCfg_Probe_Label, "Digi. Prb. 2"); vBdCfg_Probe_Label->AddFrame(lbDP2, kaka);
    cbDP2 = new TGComboBox(vBdCfg_Probe_CBox, "Digital. Pb.", 1); vBdCfg_Probe_CBox->AddFrame(cbDP2); 
    cbDP2->EnableTextInput(false);
    cbDP2->AddEntry("N/A", -3);
    cbDP2->AddEntry("Trigger", 0);  
    cbDP2->Resize(150, 20);
    cbDP2->Connect("Changed()", "BoardSetting", this, "SetBoardConfiguration()");
    
    TGHorizontalFrame * hframeBdCfg3 = new TGHorizontalFrame(vBdCfg0); vBdCfg0->AddFrame(hframeBdCfg3, new TGLayoutHints( kLHintsCenterX, 5, 5, 5, 5));
    
    TGVerticalFrame * vBdCfga_label = new TGVerticalFrame(hframeBdCfg3); hframeBdCfg3->AddFrame(vBdCfga_label, new TGLayoutHints( kLHintsLeft, 5, 5, 10, 0) );
    TGVerticalFrame * vBdCfga_CBox = new TGVerticalFrame(hframeBdCfg3); hframeBdCfg3->AddFrame(vBdCfga_CBox, new TGLayoutHints( kLHintsLeft, 5, 5, 10, 0) );

    TGLabel * lbAggOrg = new TGLabel(vBdCfga_label, "Aggregate Organization"); vBdCfga_label->AddFrame(lbAggOrg, kaka);
    cbAggOrg = new TGComboBox(vBdCfga_CBox, "Aggregate Organization", 1); vBdCfga_CBox->AddFrame(cbAggOrg); 
    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(100, 20);
    cbAggOrg->Connect("Changed()", "BoardSetting", this, "SetAggregateOrganization()");
  
    TGLabel * lbAggBLT = new TGLabel(vBdCfga_label, "MAx. Aggregate pre Readout"); vBdCfga_label->AddFrame(lbAggBLT, kaka);
    numAggBLT = new TGNumberEntry(vBdCfga_CBox, 50, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  vBdCfga_CBox->AddFrame(numAggBLT); 
    numAggBLT->SetWidth(100);
    numAggBLT->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 0x3FF);
    numAggBLT->Connect("Modified()", "BoardSetting", this, "SetReadOutAggregate()"); 
    
      ///"FanSpeed Control",
    TGLabel * lbFanCtrl = new TGLabel(vBdCfga_label, "Fan Speed Control", kHorizontalFrame); vBdCfga_label->AddFrame(lbFanCtrl, kaka); 
    cbFanCtrl = new TGComboBox(vBdCfga_CBox, "",1); vBdCfga_CBox->AddFrame(cbFanCtrl); 
    cbFanCtrl->EnableTextInput(false);
    cbFanCtrl->AddEntry("N/A",0);
    cbFanCtrl->AddEntry("Slow/Auto",0x30);
    cbFanCtrl->AddEntry("Fast", 0x38); 
    cbFanCtrl->Resize(100, 20);
    cbFanCtrl->Connect("Changed()", "BoardSetting", this, "SetFanSpeedControl()");

    TGVerticalFrame * vBdCfga_haha = new TGVerticalFrame(hframeBdCfg3); hframeBdCfg3->AddFrame(vBdCfga_haha, new TGLayoutHints( kLHintsLeft, 5, 5, 10, 0) );
    
    TGLabel * lbBufferSize = new TGLabel(vBdCfga_haha, "Buffer Size [MByte]", kHorizontalFrame); vBdCfga_haha->AddFrame(lbBufferSize, kaka); 
    txtBufferSize = new TGTextEntry(vBdCfga_haha, ""); vBdCfga_haha->AddFrame(txtBufferSize);
    txtBufferSize->SetEnabled(false);
    txtBufferSize->Resize(100, 20);

  }
    
  {///========== ACQ control
    TGGroupFrame * gAcqCtrl = new TGGroupFrame(hRow1, "ACQ Control", kHorizontalFrame); hRow1->AddFrame(gAcqCtrl , new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));  
    
    TGVerticalFrame * vAcqCtrl1 = new TGVerticalFrame(gAcqCtrl); gAcqCtrl->AddFrame(vAcqCtrl1, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 5, 5, 10, 10));
    
    TGHorizontalFrame * hAcqCtrl_a = new TGHorizontalFrame(vAcqCtrl1); vAcqCtrl1->AddFrame(hAcqCtrl_a);
    
    TGVerticalFrame * vAcqCtrl_label = new TGVerticalFrame(hAcqCtrl_a); hAcqCtrl_a->AddFrame(vAcqCtrl_label );
    TGVerticalFrame * vAcqCtrl_CBox = new TGVerticalFrame(hAcqCtrl_a); hAcqCtrl_a->AddFrame(vAcqCtrl_CBox);
    
    TGLayoutHints * haha = new TGLayoutHints( kLHintsRight, 5, 5, 6, 5);
    TGLayoutHints * kaka = new TGLayoutHints( kLHintsLeft,  5, 5, 3, 2);
    
    TGLabel * lbAcqMode = new TGLabel(vAcqCtrl_label, "ACQ Mode"); vAcqCtrl_label->AddFrame(lbAcqMode, haha);
    cbAcqMode = new TGComboBox(vAcqCtrl_CBox, "ACQ Mode", 1); vAcqCtrl_CBox->AddFrame(cbAcqMode, kaka); 
    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->Resize(100, 20);
    cbAcqMode->Connect("Changed()", "BoardSetting", this, "SetACQControl()");
    
    TGLabel * lbPLLref = new TGLabel(vAcqCtrl_label, "PLL Ref."); vAcqCtrl_label->AddFrame(lbPLLref, haha);
    cbPLLref = new TGComboBox(vAcqCtrl_CBox, "PLL Ref.", 1); vAcqCtrl_CBox->AddFrame(cbPLLref, kaka); 
    cbPLLref->EnableTextInput(false);
    cbPLLref->AddEntry("internal", 0);
    cbPLLref->AddEntry("external", 1);
    cbPLLref->Resize(100, 20);
    cbPLLref->Connect("Changed()", "BoardSetting", this, "SetACQControl()");
    
    TGLabel * lbRunStartStopDelay = new TGLabel(vAcqCtrl_label, "Run/Start/Stop Delay [ns]"); vAcqCtrl_label->AddFrame(lbRunStartStopDelay, haha);
    numRunStartStopDelay = new TGNumberEntry(vAcqCtrl_CBox, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  vAcqCtrl_CBox->AddFrame(numRunStartStopDelay, kaka); 
    numRunStartStopDelay->SetWidth(100);
    numRunStartStopDelay->SetLimits(TGNumberFormat::kNELLimitMinMax, 0, 0x0FF); 
    numRunStartStopDelay->Connect("Modified()", "BoardSetting", this, "SetRunStartStopDelay()");
   
    bAcqArm = new TGCheckButton(vAcqCtrl_CBox, "ACQ Start/Arm", 1); vAcqCtrl_CBox->AddFrame(bAcqArm, kaka);
    bAcqArm->SetState(kButtonUp);
    bAcqArm->Connect("Clicked()", "BoardSetting", this, "SetACQControl()");
    
    TGHorizontalFrame * hAcqCtrl_b = new TGHorizontalFrame(vAcqCtrl1); vAcqCtrl1->AddFrame(hAcqCtrl_b, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 10, 0));
    bSWTrigger = new TGTextButton(hAcqCtrl_b, "Send Software Trigger Signal"); hAcqCtrl_b->AddFrame(bSWTrigger, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
    bSWTrigger->Connect("Clicked()", "BoardSetting", this, "SendSoftwareTriggerSignal()");
    bSWTrigger->SetWidth(250);
    
    TGHorizontalFrame * hAcqCtrl_c = new TGHorizontalFrame(vAcqCtrl1); vAcqCtrl1->AddFrame(hAcqCtrl_c, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 0, 0, 10, 0));
    bSWClockSync = new TGTextButton(hAcqCtrl_c, "Send Software Clock Sync Signal"); hAcqCtrl_c->AddFrame(bSWClockSync, new TGLayoutHints(kLHintsExpandX | kLHintsExpandY));
    bSWClockSync->Connect("Clicked()", "BoardSetting", this, "SendSoftwareClockSyncSignal()");
    bSWClockSync->Resize(250, 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));

    ///"Disable External Trigger",
    bEnableExtTRG = new TGCheckButton(vTRGType, "Enable Ext. Trigger", 1); vTRGType->AddFrame(bEnableExtTRG);
    bEnableExtTRG->Connect("Clicked()", "BoardSetting", this, "SetEnableExternalTrigger()");
    

    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));  

    TGLayoutHints * haha = new TGLayoutHints(kLHintsCenterX , 2, 2, 3, 3);

    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], haha);  
      lbTRGMskCh0[i] = new TGLabel(vTRGMsk[i], Form("%d", 2*i)); vTRGMsk[i]->AddFrame(lbTRGMskCh0[i], haha);
      lbTRGMskCh1[i] = new TGLabel(vTRGMsk[i], Form("%d", 2*i+1)); vTRGMsk[i]->AddFrame(lbTRGMskCh1[i], haha);
    }

    ///"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], haha);
      cbGbTRGMskCh[i]->Connect("Clicked()", "BoardSetting", this, "SetGlobalTriggerMask()");
    }

    ///"TRG-OUT 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++){
      cbTRGOUTMsk[i]  = new TGCheckButton(vTRGMsk[i], ""); vTRGMsk[i]->AddFrame(cbTRGOUTMsk[i], haha);
      cbTRGOUTMsk[i]->Connect("Clicked()", "BoardSetting", this, "SetTRGOUTMask()");
    }
  
    TGVerticalFrame * vTRGMsk1 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk1, haha);
    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 * lbTRGOUTMode_haha = new TGLabel(vTRGMsk1, "TRG-OUT MODE"); vTRGMsk1->AddFrame(lbTRGOUTMode_haha, new TGLayoutHints(kLHintsRight | kLHintsCenterY , 5, 5, 3, 4));  
    
    TGVerticalFrame * vTRGMsk2 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk2, haha);
    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);
    numMajorCoinWin->Connect("Modified()", "BoardSetting", this, "SetGlobalTriggerMask()");

    cbTRGOUTMode = new TGComboBox(vTRGMsk2, "OR",0); vTRGMsk2->AddFrame(cbTRGOUTMode); 
    cbTRGOUTMode->EnableTextInput(false);
    cbTRGOUTMode->AddEntry("OR", 0);
    cbTRGOUTMode->AddEntry("AND", 1);
    cbTRGOUTMode->AddEntry("Majority", 2);
    cbTRGOUTMode->Resize(70, 20);
    cbTRGOUTMode->Connect("Changed()", "BoardSetting", this, "SetTRGOUTMask()");
    
    TGVerticalFrame * vTRGMsk3 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk3, haha);
    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);
    GlbMajorLevel->Connect("Modified()", "BoardSetting", this, "SetGlobalTriggerMask()");
    
    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);
    TRGOUTMajorLevel->Connect("Modified()", "BoardSetting", this, "SetTRGOUTMask()");
    
    TGVerticalFrame * vTRGMsk5 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk5, haha);
    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);
    bGLBExtTrigger->Connect("Clicked()", "BoardSetting", this, "SetGlobalTriggerMask()");
    
    bTRGOUTExtTrigger = new TGCheckButton(vTRGMsk5, "", 1); vTRGMsk5->AddFrame(bTRGOUTExtTrigger,  layoutHints);
    bTRGOUTExtTrigger->SetState(kButtonUp);
    bTRGOUTExtTrigger->Connect("Clicked()", "BoardSetting", this, "SetTRGOUTMask()");
    
    TGVerticalFrame * vTRGMsk6 = new TGVerticalFrame(hframeTRGCfg); hframeTRGCfg->AddFrame(vTRGMsk6, haha);
    TGLabel * lbSWTrigger = new TGLabel(vTRGMsk6, "SW"); 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);
    bGLBSoftwareTrigger->Connect("Clicked()", "BoardSetting", this, "SetGlobalTriggerMask()");
    
    bTRGOUTSoftwareTrigger = new TGCheckButton(vTRGMsk6, "", 1); vTRGMsk6->AddFrame(bTRGOUTSoftwareTrigger,  layoutHints); 
    bTRGOUTSoftwareTrigger->SetState(kButtonDown);
    bTRGOUTSoftwareTrigger->Connect("Clicked()", "BoardSetting", this, "SetTRGOUTMask()");

    TGHorizontalFrame * hframeTRGCfg2 = new TGHorizontalFrame(vTRGCfg); vTRGCfg->AddFrame(hframeTRGCfg2, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 2,2,2,2));

    ///"Extended Veto Delay", only when bit[9] of 0x8100 = 1
    ///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);
    ///numExtendVetoDelay->Connect("Modified()", "BoardSetting", this, "SetExtendedVetoDelay()");
  }
  
  TGHorizontalFrame * hRow0 = new TGHorizontalFrame(vframe); vframe->AddFrame(hRow0, new TGLayoutHints( kLHintsExpandX));
  
  {///================= ///"Trigger Validation Mask",
    TGGroupFrame * gTRGValMsk = new TGGroupFrame(hRow0, "Trigger Validation Mask", kHorizontalFrame); hRow0->AddFrame(gTRGValMsk, new TGLayoutHints(kLHintsExpandX, 0, 5, 5, 5));  
    TGVerticalFrame * vTRGValMsk = new TGVerticalFrame(gTRGValMsk); gTRGValMsk->AddFrame(vTRGValMsk, new TGLayoutHints(kLHintsExpandX));
    TGHorizontalFrame * hfTRGValMsk = new TGHorizontalFrame(vTRGValMsk); vTRGValMsk->AddFrame(hfTRGValMsk, new TGLayoutHints(kLHintsCenterY, 2,2,2,2));  
 
    TGLayoutHints * haha = new TGLayoutHints(kLHintsCenterX , 2, 2, 3, 3);
    
    TGVerticalFrame * vTRGch = new TGVerticalFrame(hfTRGValMsk); hfTRGValMsk->AddFrame(vTRGch, new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));

    TGLabel * lbdummy0 = new TGLabel(vTRGch, ""); 
    vTRGch->AddFrame(lbdummy0);  
    vTRGch->AddFrame(lbdummy0);  
    TGLabel * lbTRGValMsk[8];
    for( int i = 0; i < 8 ; i++){
      lbTRGValMsk[i] = new TGLabel(vTRGch, Form("ch %2d - %2d", 2*i, 2*i+1)); vTRGch->AddFrame(lbTRGValMsk[i], new TGLayoutHints(kLHintsRight | kLHintsCenterY , 5, 5, 3, 4));  
    }

    TGVerticalFrame * vTRGMsk[8];
    for( int i = 0; i < 8; i++){vTRGMsk[i] = new TGVerticalFrame(hfTRGValMsk); hfTRGValMsk->AddFrame(vTRGMsk[i], new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4)); }
    for( int i = 0; i < 8; i++){TGLabel * lbdummy0 = new TGLabel(vTRGMsk[i], Form("%d", 2*i  )); vTRGMsk[i]->AddFrame(lbdummy0); }
    for( int i = 0; i < 8; i++){TGLabel * lbdummy0 = new TGLabel(vTRGMsk[i], Form("%d", 2*i+1)); vTRGMsk[i]->AddFrame(lbdummy0); }
    
    for( int i = 0; i < 8; i++){
      for( int j = 0; j < 8 ; j++){
        cbTRGValMskCh[i][j]  = new TGCheckButton(vTRGMsk[j], ""); vTRGMsk[j]->AddFrame(cbTRGValMskCh[i][j], haha);
        cbTRGValMskCh[i][j]->Connect("Clicked()", "BoardSetting", this, "SetTriggerValidMask()");
      }
    }
    
    TGVerticalFrame * vTRGValMode = new TGVerticalFrame(hfTRGValMsk); hfTRGValMsk->AddFrame(vTRGValMode,new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    
    vTRGValMode->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 0));  
    TGLabel * lbTRGValMODE = new TGLabel(vTRGValMode, "MODE"); vTRGValMode->AddFrame(lbTRGValMODE, haha);  
    for( int i = 0; i < 8; i++){
      cbTRGValMODE[i] = new TGComboBox(vTRGValMode, "OR",0); vTRGValMode->AddFrame(cbTRGValMODE[i]); 
      cbTRGValMODE[i]->EnableTextInput(false);
      cbTRGValMODE[i]->AddEntry("OR", 0);
      cbTRGValMODE[i]->AddEntry("AND", 1);
      cbTRGValMODE[i]->AddEntry("Majority", 2);
      cbTRGValMODE[i]->Resize(70, 20);
      cbTRGValMODE[i]->Connect("Changed()", "BoardSetting", this, "SetTriggerValidMask()");
    }
    
    TGVerticalFrame * vTRGValMajor = new TGVerticalFrame(hfTRGValMsk); hfTRGValMsk->AddFrame(vTRGValMajor,new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    
    vTRGValMajor->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 0));  
    TGLabel * lbMajorLevel = new TGLabel(vTRGValMajor, "Majority Level"); vTRGValMajor->AddFrame(lbMajorLevel, haha); 
    for( int i =0 ; i < 8; i++){
      TRGValMajorLevel[i] = new TGNumberEntry(vTRGValMajor, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  vTRGValMajor->AddFrame(TRGValMajorLevel[i]); 
      TRGValMajorLevel[i]->Resize(70, 20);
      TRGValMajorLevel[i]->Connect("Modified()", "BoardSetting", this, "SetTriggerValidMask()");
    }
    
    TGVerticalFrame * vTRGValExtTrg = new TGVerticalFrame(hfTRGValMsk); hfTRGValMsk->AddFrame(vTRGValExtTrg,new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    
    vTRGValExtTrg->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 0));  
    TGLabel * lbExtTrigger = new TGLabel(vTRGValExtTrg, "Ext."); vTRGValExtTrg->AddFrame(lbExtTrigger, haha);
    for( int i =0 ; i < 8; i++){
      bTRGValExtTrigger[i] = new TGCheckButton(vTRGValExtTrg, "", 1); vTRGValExtTrg->AddFrame(bTRGValExtTrigger[i], haha);
      bTRGValExtTrigger[i]->SetState(kButtonUp);
      bTRGValExtTrigger[i]->Connect("Clicked()", "BoardSetting", this, "SetTriggerValidMask()");
    }
    
    TGVerticalFrame * vTRGOUTSWTrg = new TGVerticalFrame(hfTRGValMsk); hfTRGValMsk->AddFrame(vTRGOUTSWTrg,new TGLayoutHints(kLHintsCenterX , 5, 5, 3, 4));
    
    vTRGOUTSWTrg->AddFrame(lbdummy0, new TGLayoutHints(kLHintsLeft | kLHintsCenterY , 5, 5, 3, 0));  
    TGLabel * lbSWTrigger = new TGLabel(vTRGOUTSWTrg, "SW"); vTRGOUTSWTrg->AddFrame(lbSWTrigger, haha);
    for( int i = 0; i < 8; i++){
      bTRGValSoftwareTrigger[i] = new TGCheckButton(vTRGOUTSWTrg, "", 1); vTRGOUTSWTrg->AddFrame(bTRGValSoftwareTrigger[i], haha); 
      bTRGValSoftwareTrigger[i]->SetState(kButtonDown);
      bTRGValSoftwareTrigger[i]->Connect("Clicked()", "BoardSetting", this, "SetTriggerValidMask()");
    }
  }
  
  {///================== Button
    TGGroupFrame * gButton = new TGGroupFrame(hRow0, "Others Buttons", kHorizontalFrame); hRow0->AddFrame(gButton, new TGLayoutHints(kLHintsExpandY, 0, 0, 5, 5));  
    TGVerticalFrame * vfButton = new TGVerticalFrame(gButton); gButton->AddFrame(vfButton, new TGLayoutHints(kLHintsExpandX));
    
    TGTextButton * bProgramDefaultBoard = new TGTextButton(vfButton, "Program Default Board"); vfButton->AddFrame(bProgramDefaultBoard, new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 5, 0, 5, 0));
    bProgramDefaultBoard->Connect("Clicked()", "BoardSetting", this, "ProgramDefaultBoard()");

    TGTextButton * bProgramBoard = new TGTextButton(vfButton, "Program Board from File"); vfButton->AddFrame(bProgramBoard, new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 5, 0, 5, 0));
    bProgramBoard->Connect("Clicked()", "BoardSetting", this, "ProgramBoardFromLoadedFile()");

    TGTextButton * bUpdateStatus = new TGTextButton(vfButton, "Update Status and Settings"); vfButton->AddFrame(bUpdateStatus, new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 5, 0, 5, 0));
    bUpdateStatus->Connect("Clicked()", "BoardSetting", this, "ChangeBoard()");

    TGTextButton * bOpenChannelSetting = new TGTextButton(vfButton, "Open Channel Setting"); vfButton->AddFrame(bOpenChannelSetting, new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 5, 0, 5, 0));
    bOpenChannelSetting->Connect("Clicked()", "BoardSetting", this, "OpenChannelSetting()");

    TGTextButton * bReadData = new TGTextButton(vfButton, "Read Data"); vfButton->AddFrame(bReadData, new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 5, 0, 5, 0));
    bReadData->Connect("Clicked()", "BoardSetting", this, "ReadData()");
    
    TGTextButton * bCaliADC = new TGTextButton(vfButton, "Calibrate ADC"); vfButton->AddFrame(bCaliADC, new TGLayoutHints( kLHintsExpandX | kLHintsExpandY, 5, 0, 5, 0));
    bCaliADC->Connect("Clicked()", "BoardSetting", this, "CaliADC()");
    
  }
  
  TGHorizontalFrame * hRow2 = new TGHorizontalFrame(vframe); vframe->AddFrame(hRow2, new TGLayoutHints(kLHintsExpandX));
  
  {///=================="Front Panel IO Control",
    TGGroupFrame * gFrontIOCtrl = new TGGroupFrame(hRow2, "Front Panel IO Control", kHorizontalFrame); hRow2->AddFrame(gFrontIOCtrl, new TGLayoutHints( kLHintsExpandX, 5, 5, 0, 0) ); 

    TGHorizontalFrame * hFrontIOCtrl = new TGHorizontalFrame(gFrontIOCtrl); gFrontIOCtrl->AddFrame(hFrontIOCtrl);
    
    TGVerticalFrame * vFrontIOCtrl_label = new TGVerticalFrame(hFrontIOCtrl); hFrontIOCtrl->AddFrame(vFrontIOCtrl_label);
    TGVerticalFrame * vFrontIOCtrl_CBox = new TGVerticalFrame(hFrontIOCtrl); hFrontIOCtrl->AddFrame(vFrontIOCtrl_CBox);
    
    TGLayoutHints * haha = new TGLayoutHints( kLHintsRight, 5, 5, 3, 2);
    
    TGLabel * lbLEMOIO = new TGLabel(vFrontIOCtrl_label, "LEMO I/O"); vFrontIOCtrl_label->AddFrame(lbLEMOIO, haha); 
    cbLEMOIO = new TGComboBox(vFrontIOCtrl_CBox, "",1); vFrontIOCtrl_CBox->AddFrame(cbLEMOIO); 
    cbLEMOIO->EnableTextInput(false);
    cbLEMOIO->AddEntry("NIM", 0);
    cbLEMOIO->AddEntry("TTL", 1);
    cbLEMOIO->Resize(50, 20);
    cbLEMOIO->Connect("Changed()", "BoardSetting", this, "SetFrontPanelIO()");
    
    ///use 0x811C, bit:[14:19], 6bits
    TGLabel * lbTRGOUTMODE2 = new TGLabel(vFrontIOCtrl_label, "TRG-OUT Mode"); vFrontIOCtrl_label->AddFrame(lbTRGOUTMODE2, haha); 
    cbTRGOUTMODE2 = new TGComboBox(vFrontIOCtrl_CBox, "",1); vFrontIOCtrl_CBox->AddFrame(cbTRGOUTMODE2); 
    cbTRGOUTMODE2->EnableTextInput(false);
    cbTRGOUTMODE2->AddEntry("Disable",            0x00002); /// this is TRG_OUT high  imped. 0x811C bit[1]
    cbTRGOUTMODE2->AddEntry("force TRG-OUT is 0", 0x08000);  
    cbTRGOUTMODE2->AddEntry("force TRG-OUT is 1", 0x0C000); 
    cbTRGOUTMODE2->AddEntry("Trigger",            0x00000);  
    cbTRGOUTMODE2->AddEntry("Channel Probe",      0x20000); 
    cbTRGOUTMODE2->AddEntry("S-IN",               0x30000);  
    cbTRGOUTMODE2->AddEntry("RUN",                0x10000); 
    cbTRGOUTMODE2->AddEntry("Sync Clock",         0x50000); 
    cbTRGOUTMODE2->AddEntry("Clock Phase",        0x90000);
    cbTRGOUTMODE2->AddEntry("BUSY/UNLOCK",        0xD0000);
    cbTRGOUTMODE2->Resize(160, 20);
    cbTRGOUTMODE2->Connect("Changed()", "BoardSetting", this, "SetFrontPanelIO()");

    TGLabel * lbTRGINCtrl = new TGLabel(vFrontIOCtrl_label, "TRG-IN control"); vFrontIOCtrl_label->AddFrame(lbTRGINCtrl, haha); 
    cbTRGINCtrl = new TGComboBox(vFrontIOCtrl_CBox, "",1); vFrontIOCtrl_CBox->AddFrame(cbTRGINCtrl); 
    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->Resize(250, 20);
    cbTRGINCtrl->Connect("Changed()", "BoardSetting", this, "SetFrontPanelIO()");
    
    TGLabel * lbTRGINMezzanines = new TGLabel(vFrontIOCtrl_label, "TRG-IN to Mezzanines"); vFrontIOCtrl_label->AddFrame(lbTRGINMezzanines, haha); 
    cbTRGINMezzanines = new TGComboBox(vFrontIOCtrl_CBox, "",1); vFrontIOCtrl_CBox->AddFrame(cbTRGINMezzanines); 
    cbTRGINMezzanines->EnableTextInput(false);
    cbTRGINMezzanines->AddEntry("Trigger local is sync with TRG-IN", 0);
    cbTRGINMezzanines->AddEntry("TRG-IN send to mezzanines (no delay)", 1);
    cbTRGINMezzanines->Resize(200, 20);
    cbTRGINMezzanines->Connect("Changed()", "BoardSetting", this, "SetFrontPanelIO()");

    ///"Front Panel LVDS IO New Features",
    ///"LVDS IO Data",
    
    ///"Analog Monitor Mode
    TGLabel * lbAnaMonitor = new TGLabel(vFrontIOCtrl_label, "Analog Monitor Mode (MON/Sigma)"); vFrontIOCtrl_label->AddFrame(lbAnaMonitor, haha); 
    cbAnaMonitor = new TGComboBox(vFrontIOCtrl_CBox, "",1); vFrontIOCtrl_CBox->AddFrame(cbAnaMonitor); 
    cbAnaMonitor->EnableTextInput(false);
    cbAnaMonitor->AddEntry("Trigger Majority", 0);
    cbAnaMonitor->AddEntry("Test", 1); 
    cbAnaMonitor->AddEntry("Buffer Occupancy", 3);
    cbAnaMonitor->AddEntry("Voltage Level", 4); 
    cbAnaMonitor->Resize(150, 20);
    cbAnaMonitor->Connect("Changed()", "BoardSetting", this, "SetAnalogMonitorMode()");
    //cbAnaMonitor->Connect("Changed()", "ChannelSettingPHA", this, "ChangePolarity()"); //Example to call other class
    
    ///"Buffer Occupancy Gain
    TGLabel * lbBufferOccpGain = new TGLabel(vFrontIOCtrl_label, "Buffer Occupancy Gain"); vFrontIOCtrl_label->AddFrame(lbBufferOccpGain, haha); 
    numBufferOccpGain = new TGNumberEntry(vFrontIOCtrl_CBox, 0, 0, 0, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative);  vFrontIOCtrl_CBox->AddFrame(numBufferOccpGain); 
    numBufferOccpGain->SetState(false);
    numBufferOccpGain->Resize(70, 17);
    numBufferOccpGain->Connect("Modified()", "BoardSetting", this, "SetAnalogMonitorMode()");
    
  }
  
  
  //TODO check is VME model
  {///"Readout Control",
    TGGroupFrame * gReadoutCtrl = new TGGroupFrame(hRow2, "ReadOut Control", kHorizontalFrame); hRow2->AddFrame(gReadoutCtrl, new TGLayoutHints( kLHintsExpandY)); 
    TGVerticalFrame * vReadoutCtrl = new TGVerticalFrame(gReadoutCtrl); gReadoutCtrl->AddFrame(vReadoutCtrl);
    
    TGHorizontalFrame * hReadoutCtrl = new TGHorizontalFrame(vReadoutCtrl); vReadoutCtrl->AddFrame(hReadoutCtrl, new TGLayoutHints( kLHintsLeft, 5, 5, 5, 5));
    
    TGLabel * lbVMEInterruptLevel = new TGLabel(hReadoutCtrl, "VME Interrupt Level"); hReadoutCtrl->AddFrame(lbVMEInterruptLevel,new TGLayoutHints( kLHintsLeft, 5, 5, 3, 3)); 
    cbVMEInterrupLevel = new TGComboBox(hReadoutCtrl, "", 1); hReadoutCtrl->AddFrame(cbVMEInterrupLevel); 
    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->Resize(80, 20);
    cbVMEInterrupLevel->Connect("Changed()", "BoardSetting", this, "SetReadOutControl()");

    bOpticalLinkInterrupt = new TGCheckButton(vReadoutCtrl, "Optical Link Interrupt", 1); vReadoutCtrl->AddFrame(bOpticalLinkInterrupt); 
    bOpticalLinkInterrupt->SetState(kButtonUp);
    bOpticalLinkInterrupt->Connect("Clicked()", "BoardSetting", this, "SetReadOutControl()");

    bEventAligned = new TGCheckButton(vReadoutCtrl, "Event Aligned Enabled", 1); vReadoutCtrl->AddFrame(bEventAligned); 
    bEventAligned->SetState(kButtonUp);
    bEventAligned->Connect("Clicked()", "BoardSetting", this, "SetReadOutControl()");

    bVMEAlogn64Mode = new TGCheckButton(vReadoutCtrl, "64-bit aligned", 1); vReadoutCtrl->AddFrame(bVMEAlogn64Mode); 
    bVMEAlogn64Mode->SetState(kButtonUp);
    bVMEAlogn64Mode->Connect("Clicked()", "BoardSetting", this, "SetReadOutControl()");
    
    bInteruptReleaseMode = new TGCheckButton(vReadoutCtrl, "Interrupt Release on Acknowldge", 1); vReadoutCtrl->AddFrame(bInteruptReleaseMode); 
    bInteruptReleaseMode->SetState(kButtonUp);
    bInteruptReleaseMode->Connect("Clicked()", "BoardSetting", this, "SetReadOutControl()");

    bEnableExtendedBlockTransfer = new TGCheckButton(vReadoutCtrl, "Enable Extended Block Transfer", 1); vReadoutCtrl->AddFrame(bEnableExtendedBlockTransfer); 
    bEnableExtendedBlockTransfer->SetState(kButtonUp);
    bEnableExtendedBlockTransfer->Connect("Clicked()", "BoardSetting", this, "SetReadOutControl()");
  }

  
  ///===== LVSD
  TGHorizontalFrame * hframeNote1 = new TGHorizontalFrame(vframe); vframe->AddFrame(hframeNote1, new TGLayoutHints(kLHintsCenterY , 5,5,0,0));
  TGLabel * lbNote1 = new TGLabel(hframeNote1, "LVSD Control is not impletmented."); hframeNote1->AddFrame(lbNote1, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 5, 5, 0, 0)); 

  TGHorizontalFrame * hframeNote2 = new TGHorizontalFrame(vframe); vframe->AddFrame(hframeNote2, new TGLayoutHints(kLHintsCenterY , 5,5,0,0));
  TGLabel * lbNote2 = new TGLabel(hframeNote2, "Trigger Validation Mask only for 0x8180."); hframeNote2->AddFrame(lbNote2, new TGLayoutHints(kLHintsCenterY | kLHintsLeft, 5, 5, 0, 0)); 

  ///==================== Read digitizer Setting
  ChangeBoard();
  
  fMain->MapSubwindows();
  fMain->Resize(fMain->GetDefaultSize());
  fMain->MapWindow();
  
  isOpened = true;
  
  ///Setup thread
  ///readStatusThread = new TThread("readStatus", ReadStatus, (void *) 1);
  ///if( digi != NULL ) readStatusThread->Run();
}

BoardSetting::~BoardSetting(){
  printf("----- %s \n", __func__);
  isOpened = false;
  
  printf("close BoardSetting window\n"); 

  /// this is essential to delete any TGNumberEntry, when the focu on it and close the windows --> crash.
  delete numAggBLT; 
  delete numRunStartStopDelay;
  delete numMajorCoinWin;
  delete numBufferOccpGain;
  //delete numExtendVetoDelay;
  for( int i = 0; i < 8; i++) delete TRGValMajorLevel[i];
  delete TRGOUTMajorLevel;
  delete GlbMajorLevel;
  
  delete boardIDEntry;
  for( int i = 0;  i < NUM_BOARD_INFO; i++ ) delete entry[i];
  delete txtSettingFile;
  
  delete enPLLStatus;
  delete enTempStatus;
  delete enADCPwrStatus;
  
  delete txtBufferSize;
  
  fMain->Cleanup(); 
  delete fMain;

}

void BoardSetting::LogMsg(TString msg){
  Emit("LogMsg(char*)", msg.Data());
}

void BoardSetting::DisableEdit(){ // When ACQ is running, disable all control
  
}

void BoardSetting::EnableEdit(){ // When ACQ is running, disable all control
  
}

void BoardSetting::ReadStatus(){
  if( digi == NULL) return;
  
  int boardID = boardIDEntry->GetNumber();
  if( digi[boardID]->IsDummy() ) {
    txtACQBoardReady->SetText("No Digitizer is opened!");
    txtACQBoardReady->SetTextColor(red);
    return;
  }
  
  /// ACQ Status
  ///digi[boardID]->PrintRegister(Register::DPP::AcquisitionStatus, "ACQ Status");
  uint32_t temp = digi[boardID]->ReadRegister(Register::DPP::AcquisitionStatus_R);
  
  txtACQStatus     ->SetText( ((temp >> 2) & 0x1) == 0 ? "ACQ is stopped" : "ACQ is Running", false);  txtACQStatus->SetTextColor( ((temp >> 2) & 0x1) == 0 ? 1 : blue); 
  txtACQEventReady ->SetText( ((temp >> 3) & 0x1) == 0 ? "no Event" : "Has Events", false);            txtACQEventReady->SetTextColor( ((temp >> 3) & 0x1) == 0 ? 1 : blue); 
  txtACQEventFull  ->SetText( ((temp >> 4) & 0x1) == 0 ? "no channel FULL" : "a channel FULL", false); txtACQEventFull->SetTextColor( ((temp >> 4) & 0x1) == 0 ? 1 : red); 
  txtACQClockSource->SetText( ((temp >> 5) & 0x1) == 0 ? "Internal Clock" : "External Clock", false);  txtACQClockSource->SetTextColor( ((temp >> 5) & 0x1) == 0 ? 1 : blue); 
  txtACQPLLLock    ->SetText( ((temp >> 7) & 0x1) == 0 ? "PLL no lock" : "PLL locked", false);         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)", false);         
        txtACQBoardReady->SetTextColor( ((temp >> 8) & 0x1) == 0 ? red : 1);
  txtACQChDown     ->SetText( ((temp >> 19) & 0x1) == 0 ? "Channels are ON" : "Channels ShutDown", false);
        txtACQChDown->SetTextColor( ((temp >> 19) & 0x1) == 0 ? 1 : red); 
  txtACQSIN    ->SetText( ((temp >> 15) & 0x1) == 0 ? "S-IN = 0" : "S-IN = 1", false);       txtACQSIN->SetTextColor( ((temp >> 15) & 0x1) == 0 ? 1 : blue); 
  txtACQTRIGIN  ->SetText( ((temp >> 16) & 0x1) == 0 ? "TRG-IN = 0" : "TRG-IN = 1", false);  txtACQTRIGIN->SetTextColor( ((temp >> 16) & 0x1) == 0 ? 1 : blue); 
  
  txtACQTemp0->SetText( ((temp >> 20) & 0x1) == 0 ? "< 70" : "> 70", false);       txtACQTemp0->SetTextColor( ((temp >> 20) & 0x1) == 0 ? 1 : red); 
  txtACQTemp1->SetText( ((temp >> 21) & 0x1) == 0 ? "< 70" : "> 70", false);       txtACQTemp1->SetTextColor( ((temp >> 21) & 0x1) == 0 ? 1 : red); 
  txtACQTemp2->SetText( ((temp >> 22) & 0x1) == 0 ? "< 70" : "> 70", false);       txtACQTemp2->SetTextColor( ((temp >> 22) & 0x1) == 0 ? 1 : red); 
  txtACQTemp3->SetText( ((temp >> 23) & 0x1) == 0 ? "< 70" : "> 70", false);       txtACQTemp3->SetTextColor( ((temp >> 23) & 0x1) == 0 ? 1 : red); 
  
  /// Redaout Status
  ///digi[boardID]->PrintRegister(Register::DPP::ReadoutStatus, "Readout Status");
  temp = digi[boardID]->ReadRegister(Register::DPP::ReadoutStatus_R);
  if( (temp & 0x1) == 1 ){
    txtEventReady->SetText( "Event Ready" , false); txtEventReady->SetTextColor(blue);
  }else{
    txtEventReady->SetText( "No Data Ready" , false); txtEventReady->SetTextColor(red);
  }
  
  if( (( temp >> 2 ) & 0x1 ) == 0 ){
    txtBusError->SetText( "no Bus Error", false ); txtBusError->SetTextColor(blue);
  }else{
    txtBusError->SetText( "Bus Error", false ); txtBusError->SetTextColor(red);
  }

  if( (( temp >> 3 ) & 0x1 ) == 0 ){
    txtVMEFIFO->SetText( "VME FIFO NOT EMPTY", false ); txtVMEFIFO->SetTextColor(blue);
  }else{
    txtVMEFIFO->SetText( "VME FIFO EMPTY", false ); txtVMEFIFO->SetTextColor(red);
  }
  
  ///================ Board Failure Status
  ///digi[boardID]->PrintRegister(Register::DPP::BoardFailureStatus, "Board Fail");
  temp = digi[boardID]->ReadRegister(Register::DPP::BoardFailureStatus_R);
  if( ((temp >> 4) & 0x1) == 0 ) {
    enPLLStatus->SetText( "OK" , false); enPLLStatus->SetTextColor(1);
  }else{
    enPLLStatus->SetText( "Lost Lock" , false); enPLLStatus->SetTextColor(red);
  }
  
  if( ((temp >> 5) & 0x1) == 0 ) {
    enTempStatus->SetText( "OK" , false); enTempStatus->SetTextColor(1);
  }else{
    enTempStatus->SetText( "Failure" , false); enTempStatus->SetTextColor(red);
  }
  
  if( ((temp >> 6) & 0x1) == 0 ) {
    enADCPwrStatus->SetText( "OK", false); enADCPwrStatus->SetTextColor(1);
  }else{
    enADCPwrStatus->SetText( "Failure", false); enADCPwrStatus->SetTextColor(red);
  }
  
}

void BoardSetting::ChangeBoard(){
  printf("=== %s\n", __func__);
  
  if( digi == NULL ) {
    printf("no didgitizers\n");
    return;
  }

  int boardID = boardIDEntry->GetNumber();

  txtSettingFile->SetText( digi[boardID]->GetSettingFileName().c_str() );

  digi[boardID]->ReadAllSettingsFromBoard(true);

  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", false); break;
          case V1720_DPP_CI_CODE : entry[i]->SetText("DPP-CI ", false); break;
          case V1720_DPP_PSD_CODE: entry[i]->SetText("DPP-PSD", false); break;
          case V1751_DPP_PSD_CODE: entry[i]->SetText("DPP-PSD", false); break;
          case V1751_DPP_ZLE_CODE: entry[i]->SetText("DPP-ZLE", false); break;
          case V1743_DPP_CI_CODE:  entry[i]->SetText("DPP-PSD", false); break;
          case V1740_DPP_QDC_CODE: entry[i]->SetText("DPP-QDC", false); break;
          case V1730_DPP_PSD_CODE: entry[i]->SetText("DPP-PSD", false); break;
          case V1730_DPP_PHA_CODE: entry[i]->SetText("DPP-PHA", false); break;
          case V1730_DPP_ZLE_CODE: entry[i]->SetText("DPP-ZLE", false); break;
          case V1730_DPP_DAW_CODE: entry[i]->SetText("DPP-DAW", false); break;
        }
        
        break;
      case 2 : entry[i]->SetText( Form("%s", digi[boardID]->GetLinkType() ==  CAEN_DGTZ_USB ? "USB" : "Optical Link"), false ); break;
      case 3 : entry[i]->SetText( Form("%d", digi[boardID]->GetSerialNumber() ), false ); break;
      case 4 : entry[i]->SetText( Form("%d", digi[boardID]->GetNChannel() ), false ); break;
      case 5 : entry[i]->SetText( Form("%0.f MHz = %.1f ns", 1000/digi[boardID]->GetCh2ns(), digi[boardID]->GetCh2ns()), false ); break;
      case 6 : entry[i]->SetText( Form("%d", digi[boardID]->GetADCBits() ), false ); break;
      case 7 : entry[i]->SetText( Form("%s", (digi[boardID]->GetROCVersion()).c_str() ), false ); break;
      case 8 : entry[i]->SetText( Form("%s", (digi[boardID]->GetAMCVersion()).c_str() ), false ); break;
    }
  }
  
  cbAggOrg->Select( digi[boardID]->GetSettingFromMemory(Register::DPP::AggregateOrganization) , false);
  numAggBLT->SetNumber( digi[boardID]->GetSettingFromMemory(Register::DPP::MaxAggregatePerBlockTransfer) , false);
  
  FillBufferSizeTextBox();
  
  if( digi[boardID]->GetNChannel() == 8 ){
    ///FAN Speed control only for desktop version
    cbFanCtrl->SetEnabled(true);
    cbFanCtrl->Select( digi[boardID]->GetSettingFromMemory(Register::DPP::FanSpeedControl) , false);  
  }else{
    cbFanCtrl->SetEnabled(false);
    cbFanCtrl->Select( 0 , false);  
  }

  numRunStartStopDelay->SetNumber( digi[boardID]->GetSettingFromMemory(Register::DPP::RunStartStopDelay), false);
  bEnableExtTRG->SetState( (digi[boardID]->GetSettingFromMemory(Register::DPP::DisableExternalTrigger) & 0x1) ? kButtonDown : kButtonUp, false);
  ///numExtendVetoDelay->SetNumber( digi[boardID]->GetSettingFromMemory(Register::DPP::ExtendedVetoDelay) , false);
  
  cbAnaMonitor->Select( digi[boardID]->GetSettingFromMemory(Register::DPP::AnalogMonitorMode) & 0x7 , false);
  numBufferOccpGain->SetNumber( digi[boardID]->GetSettingFromMemory(Register::DPP::BufferOccupancyGain) & 0xf, false);
  
  ReadStatus();
  
  /// ACQ Control      
  //digi[boardID]->PrintRegister(Register::DPP::AcquisitionControl, "AcquisitionControl");
  uint32_t tempBits = digi[boardID]->GetSettingFromMemory(Register::DPP::AcquisitionControl);   
  cbAcqMode->Select( tempBits & 0x3 , false);
  bAcqArm->SetState( ((tempBits >> 2) & 0x1) ? kButtonDown : kButtonUp, false);
  cbPLLref->Select(  ((tempBits >> 6) & 0x1), false);

  /// Global Trigger Mask
  tempBits = digi[boardID]->GetSettingFromMemory(Register::DPP::GlobalTriggerMask);
  for( int i = 0; i < 8; i++){
    cbGbTRGMskCh[i]->SetState( ((tempBits >> i ) & 0x1) == 0 ? kButtonUp : kButtonDown , false);
  }
  numMajorCoinWin->SetNumber( (tempBits >> 20 ) & 0x7 , false);
  GlbMajorLevel->SetNumber( ( tempBits >> 24) & 0x7 , false);
  bGLBExtTrigger->SetState( (( tempBits >> 30) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false);
  bGLBSoftwareTrigger->SetState( (( tempBits >> 31) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false);

  /// Front Panel TRG-OUT Enable Mask , PHA = PSD only for bit[19:0]
  tempBits = digi[boardID]->GetSettingFromMemory(Register::DPP::FrontPanelTRGOUTEnableMask);
  for( int i = 0; i < 8; i++){
    cbTRGOUTMsk[i]->SetState( ((tempBits >> i ) & 0x1) == 0 ? kButtonUp : kButtonDown, false );
  }
  cbTRGOUTMode->Select( ( tempBits >> 8 ) & 0x3, false) ;
  TRGOUTMajorLevel->SetNumber( ( tempBits >> 10 ) & 0x7, false);
  bTRGOUTExtTrigger->SetState( (( tempBits >> 30) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false);
  bTRGOUTSoftwareTrigger->SetState( (( tempBits >> 30) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false);

  /// Trigger Validation Mask
  for( int i = 0; i < 8; i++){
    tempBits = digi[boardID]->GetSettingFromMemory(Register::DPP::TriggerValidationMask_G, 2*i);
    for( int j = 0; j < 8; j++){
      cbTRGValMskCh[i][j]->SetState( ((tempBits >> j ) & 0x1) == 0 ? kButtonUp : kButtonDown , false);
    }
    cbTRGValMODE[i]->Select( ( tempBits >> 8 ) & 0x3, false) ;
    TRGValMajorLevel[i]->SetNumber( ( tempBits >> 10 ) & 0x3, false);
    bTRGValExtTrigger[i]->SetState( (( tempBits >> 30) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false);
    bTRGValSoftwareTrigger[i]->SetState( (( tempBits >> 31) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false);
  }

  
  /// Front Panel I/O Control, PHA = PSD only for bit[19:0]
  tempBits = digi[boardID]->GetSettingFromMemory(Register::DPP::FrontPanelIOControl);
  cbLEMOIO->Select( tempBits & 0x1 , false);
  if( ((tempBits >> 1) & 0x1 ) == 0 ) {
    cbTRGOUTMODE2->Select( 2 , false);
  }else{
    cbTRGOUTMODE2->Select( (tempBits) & 0x3F000 , false);
  }
  cbTRGINCtrl->Select( (tempBits >> 10) & 0x1 , false);
  cbTRGINMezzanines->Select( (tempBits >> 11) & 0x1 , false);
      
  /// Readout Control
  tempBits = digi[boardID]->GetSettingFromMemory(Register::DPP::ReadoutControl);
  cbVMEInterrupLevel->Select( tempBits & 0x3 , false); 
  bOpticalLinkInterrupt->SetState( (( tempBits >> 3 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false) ;
  bEventAligned->SetState( (( tempBits >> 4 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false) ;
  bVMEAlogn64Mode->SetState( (( tempBits >> 5 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false) ;
  bInteruptReleaseMode->SetState( (( tempBits >> 7 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false) ;
  bEnableExtendedBlockTransfer->SetState( (( tempBits >> 8 ) & 0x1 ) == 0 ? kButtonUp : kButtonDown, false) ;

  if( digi[boardID]->GetDPPType() == V1730_DPP_PHA_CODE ) {
    
    bDecimateWF->SetEnabled(true);
    
    cbAP1->RemoveAll();
    cbAP1->AddEntry("Input", 0);
    cbAP1->AddEntry("RC-CR (1st derivative)", 1);
    cbAP1->AddEntry("RC-CR2 (2st derivative)", 2);
    cbAP1->AddEntry("Trapezoid", 3);
    
    cbAP2->SetEnabled(true);
    cbAP2->RemoveAll();
    cbAP2->AddEntry("N/A", -3);
    cbAP2->AddEntry("Input", 0);
    cbAP2->AddEntry("Threshold", 1);
    cbAP2->AddEntry("Trapezoid - Baseline", 2);
    cbAP2->AddEntry("Baseline", 3);
    
    cbDP1->RemoveAll();
    cbDP1->AddEntry("Peaking", 0);
    cbDP1->AddEntry("Armed (Triggered)", 1);
    cbDP1->AddEntry("Peak Run", 2);
    cbDP1->AddEntry("Pile-Up", 3);
    cbDP1->AddEntry("Peaking", 4); ///Duplicated?
    cbDP1->AddEntry("TRG Validation Win.", 5);
    cbDP1->AddEntry("Baseline freeze", 6);
    cbDP1->AddEntry("TRG holdoff", 7);
    cbDP1->AddEntry("TRG Validation", 8);
    cbDP1->AddEntry("ACQ busy", 9);
    cbDP1->AddEntry("Zero Cross", 10);
    cbDP1->AddEntry("Ext. TRG", 11);
    cbDP1->AddEntry("Memory full", 12);
    
    cbDP2->RemoveAll();
    cbDP2->AddEntry("N/A", -3);
    cbDP2->AddEntry("Trigger", 0);  

    cbDP2->SetEnabled(false);
    cbDP2->Select(-3, false); 
    
    /// Board Configuration
    //digi[boardID]->PrintRegister(Register::DPP::BoardConfiguration, "BoardConfiguration");
    tempBits = digi[boardID]->GetSettingFromMemory(Register::DPP::BoardConfiguration);
    
    bAutoDataFlush->SetState( (tempBits & 0x1) ? kButtonDown : kButtonUp, false);
    bDecimateWF->SetState(    ((tempBits >>  1) & 0x1) ? kButtonDown : kButtonUp, false );
    bWFRecord->SetState(      ((tempBits >> 16) & 0x1) ? kButtonDown : kButtonUp, false );
    bTrigPropa->SetState(     ((tempBits >>  2) & 0x1) ? kButtonDown : kButtonUp, false );
    bExtrac2->SetState(       ((tempBits >> 17) & 0x1) ? kButtonDown : kButtonUp, false );
    
    //TODO remove bDualTrace, when cbAP2 is not -1, DualTrace is on
    
    if( (tempBits >> 11) & 0x1 ){
      bDualTrace->SetState( kButtonDown , false );
      cbAP2->SetEnabled(true);
      cbAP2->Select( ((tempBits >> 14) & 0x3) , false);
    }else{
      bDualTrace->SetState( kButtonUp , false );
      cbAP2->SetEnabled(false);
      cbAP2->Select(-3, false);
    }
    
    cbAP1->Select(            ((tempBits >> 12) & 0x3) , false);
    cbDP1->Select(            ((tempBits >> 20) & 0x7) , false);
    
  }else if( digi[boardID]->GetDPPType() == V1730_DPP_PSD_CODE ) {
    
    bDecimateWF->SetEnabled(false);
    cbDP2->SetEnabled(true);
    
    cbAP1->RemoveAll();
    cbAP1->AddEntry("Input", 0);
    cbAP1->AddEntry("CFD", 1);
    cbAP1->AddEntry("Input", 2);
    
    cbAP2->SetEnabled(false);
    cbAP2->RemoveAll();
    cbAP2->AddEntry("N/A", -3);
    cbAP2->AddEntry("Baseline", 0);
    cbAP2->AddEntry("CFD", 1);
    
    cbDP1->RemoveAll();
    cbDP1->AddEntry("Long Gate", 0);
    cbDP1->AddEntry("Over Threshold", 1);
    cbDP1->AddEntry("Shaped TRG", 2);
    cbDP1->AddEntry("TRG Val. Accep. Win.", 3);
    cbDP1->AddEntry("Pile Up", 4);
    cbDP1->AddEntry("Coincidence", 5);
    cbDP1->AddEntry("Trigger", 7);
    
    cbDP2->RemoveAll();
    cbDP2->AddEntry("Short Gate", 0);
    cbDP2->AddEntry("Over Threshold", 1);
    cbDP2->AddEntry("TRG Validation", 2);
    cbDP2->AddEntry("TRG Holdoff", 3);
    cbDP2->AddEntry("PileUp Trigger", 4);
    cbDP2->AddEntry("PSD Cut hight", 5);
    cbDP2->AddEntry("Baseline freeze", 6);
    cbDP2->AddEntry("Trigger", 7);
    
    tempBits = digi[boardID]->GetSettingFromMemory(Register::DPP::BoardConfiguration);
    
    bAutoDataFlush->SetState( (tempBits & 0x1) ? kButtonDown : kButtonUp, false);
    bTrigPropa->SetState(     ((tempBits >>  2) & 0x1) ? kButtonDown : kButtonUp, false );
    
    if( ((tempBits >> 11) & 0x1) == 1 ) { /// Dual Trace
      bDualTrace->SetState(kButtonDown , false );
      
      switch ((tempBits >> 12) & 0x3) {
        case 0 : {
          cbAP1->Select( 0, false); 
          cbAP2->Select( 0, false);   
        }; break;
        
        case 1 : {
          cbAP1->Select( 1, false); 
          cbAP2->Select( 0, false);   
        }; break;
        
        case 2 : {
          cbAP1->Select( 2, false); 
          cbAP2->Select( 1, false);   
        }; break;
      }
    }else{
      bDualTrace->SetState( kButtonUp, false );
      cbAP1->Select( ((tempBits >> 12) & 0x3) , false);
      cbAP2->Select(-1, false);
    }
    
    bWFRecord->SetState(      ((tempBits >> 16) & 0x1) ? kButtonDown : kButtonUp, false );
    bExtrac2->SetState(       ((tempBits >> 17) & 0x1) ? kButtonDown : kButtonUp, false );
    
    cbDP1->Select(            ((tempBits >> 23) & 0x7) , false);
    cbDP2->Select(            ((tempBits >> 26) & 0x7) , false);
    
  }
  
  return;
}

//################################################ Change Settings

void BoardSetting::OpenChannelSetting(){
  printf("=== %s\n", __func__);
  
  Int_t boardID = boardIDEntry->GetNumber();
  Haha(boardID);
}

void BoardSetting::Haha(Int_t boardID){ /// this is for sending signal to mainwindow to open channel setting for the board
  printf("=== %s\n", __func__);
  Emit("Haha(Int_t)", boardID);
}

void BoardSetting::TellChannelSettingtoUpdate(){
  Emit("TellChannelSettingtoUpdate()");
}

void BoardSetting::ResetSettingToDefault(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();

  digi[boardID]->Reset();
  digi[boardID]->WriteRegister(Register::DPP::SoftwareReset_W, 1);
  
  ChangeBoard();
  
}

void BoardSetting::ClearBuffer(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();
  digi[boardID]->WriteRegister(Register::DPP::SoftwareClear_W, 1);
  
  ReadStatus();
}

void BoardSetting::SetBoardConfiguration(){
  printf("=== %s\n", __func__);
  
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();
  uint32_t bit = (3 << 18); /// timestamp and energy recording
  if( digi[boardID]->GetDPPType() == V1730_DPP_PHA_CODE ) {
    
    bit += (34 << 3) ; /// Reserved must be 0010010 for bit[10:3]
    if( bAutoDataFlush->GetState() == kButtonDown ) { bit += 1;};
    if( bDecimateWF->GetState() == kButtonDown ) bit += (1 << 1);
    if( bWFRecord->GetState() == kButtonDown ) bit += ( 1 << 16);
    if( bTrigPropa->GetState() == kButtonDown ) bit += ( 1 << 2);
    if( bExtrac2->GetState() == kButtonDown ) bit += ( 1 << 17);
    if( bDualTrace->GetState() == kButtonDown ) {
      bit += ( 1 << 11);
      cbAP2->SetEnabled(true);
    }else{
      cbAP2->SetEnabled(false);
      cbAP2->Select(-3, false);
    }
    
    if( cbAP2->GetSelected() > 0 ) bit += (cbAP2->GetSelected() << 14);
    
    bit += (cbAP1->GetSelected() << 12);
    bit += (cbDP1->GetSelected() << 20);

  }
  
  if( digi[boardID]->GetDPPType() == V1730_DPP_PSD_CODE ) {

    bit += (18 << 3) ; /// Reserved must be 0010010 for bit[10:3]
    if( bAutoDataFlush->GetState() == kButtonDown ) bit += 1;
    if( bDecimateWF->GetState() == kButtonDown ) bit += (1 << 1);
    if( bWFRecord->GetState() == kButtonDown ) bit += ( 1 << 16);
    if( bTrigPropa->GetState() == kButtonDown ) bit += ( 1 << 2);
    if( bExtrac2->GetState() == kButtonDown ) bit += ( 1 << 17);
    
    if( bDualTrace->GetState() == kButtonDown ) bit += ( 1 << 11);
    bit += (cbAP1->GetSelected() << 12);
    bit += (cbDP1->GetSelected() << 23);
    bit += (cbDP2->GetSelected() << 26);
    
  }
  
  printf("bit : 0x%x \n", bit);
  digi[boardID]->WriteRegister(Register::DPP::BoardConfiguration, bit);
}

void BoardSetting::SetAggregateOrganization(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  digi[boardID]->WriteRegister(Register::DPP::AggregateOrganization, cbAggOrg->GetSelected());
  
  FillBufferSizeTextBox();
}

void BoardSetting::SetReadOutAggregate(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);

  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  digi[boardID]->WriteRegister(Register::DPP::MaxAggregatePerBlockTransfer, (unsigned int) numAggBLT->GetNumber());

  FillBufferSizeTextBox();
  
}

void BoardSetting::SetFanSpeedControl(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  digi[boardID]->WriteRegister(Register::DPP::FanSpeedControl, cbFanCtrl->GetSelected() );
}

void BoardSetting::SetACQControl(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  
  uint32_t bit = 0;
  bit += ( cbAcqMode->GetSelected() );
  bit += ( bAcqArm->GetState() == kButtonDown ? (1 << 2) : 0 );
  bit += ( cbPLLref->GetSelected() << 6 );
  
  printf("bit : 0x%x \n", bit);
  
  digi[boardID]->WriteRegister(Register::DPP::AcquisitionControl, bit );
  
  ReadStatus();
}


void BoardSetting::SendSoftwareTriggerSignal(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  digi[boardID]->WriteRegister(Register::DPP::SoftwareTrigger_W, 1 );
  
  ReadStatus();
  
}

void BoardSetting::SendSoftwareClockSyncSignal(){   /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  digi[boardID]->WriteRegister(Register::DPP::SoftwareClockSync_W, 1 );  
}

void BoardSetting::SetRunStartStopDelay(){   /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  
  digi[boardID]->WriteRegister(Register::DPP::RunStartStopDelay, (unsigned int) numRunStartStopDelay->GetNumber() );  
}

void BoardSetting::SetGlobalTriggerMask(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  

  uint32_t bit = 0;
  for( int i = 0; i < 8; i ++ ) bit += ( (cbGbTRGMskCh[i]->GetState() == kButtonDown) ? (1 << i ) : 0);
  bit += ( ((unsigned int) numMajorCoinWin->GetNumber() ) << 20 );
  bit += ( ((unsigned int) GlbMajorLevel->GetNumber() ) << 24 );
  bit += ( (bGLBExtTrigger->GetState() == kButtonDown) ? (1 << 30) : 0);
  bit += ( (bGLBSoftwareTrigger->GetState() == kButtonDown) ? (1 << 31) : 0 );
  
  printf("bit : 0x%x \n", bit);
  
  digi[boardID]->WriteRegister(Register::DPP::GlobalTriggerMask, bit ); 
}

void BoardSetting::SetTRGOUTMask(){   /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  

  uint32_t bit = 0;
  for( int i = 0; i < 8; i ++ ) bit += ( (cbTRGOUTMsk[i]->GetState() == kButtonDown) ? (1 << i ) :0 );
  bit += ( (cbTRGOUTMode->GetSelected() << 8) );
  bit += ( ((unsigned int) TRGOUTMajorLevel->GetNumber() ) << 24 );
  bit += ( (bTRGOUTExtTrigger->GetState() == kButtonDown) ? (1 << 30) : 0);
  bit += ( (bTRGOUTSoftwareTrigger->GetState() == kButtonDown) ? (1 << 31) : 0 );
  
  printf("bit : 0x%x \n", bit);

  digi[boardID]->WriteRegister(Register::DPP::FrontPanelTRGOUTEnableMask, bit ); 
}

void BoardSetting::SetTriggerValidMask(){   /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  

  uint32_t bit = 0;
  for( int i = 0; i < 8; i++){
    bit = 0;
    for( int j = 0; j < 8; j++) bit += ( (cbTRGValMskCh[i][j]->GetState() == kButtonDown) ? (1 << j ) : 0 );
    bit += ( (cbTRGValMODE[i]->GetSelected() << 8) );
    bit += ( ((unsigned int) TRGValMajorLevel[i]->GetNumber() ) << 24 );
    bit += ( (bTRGValExtTrigger[i]->GetState() == kButtonDown) ? (1 << 30) : 0 );
    bit += ( (bTRGValSoftwareTrigger[i]->GetState() == kButtonDown) ? (1 << 31) : 0 );
    printf("pch : %d, bit : 0x%x \n", i, bit);  
    digi[boardID]->WriteRegister(Register::DPP::TriggerValidationMask_G, bit , 2*i);  
  }
}
void BoardSetting::SetEnableExternalTrigger(){   /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  

  if (bEnableExtTRG->GetState() == kButtonDown) {
    digi[boardID]->WriteRegister(Register::DPP::DisableExternalTrigger, 0x1 ); 
  }else{
    digi[boardID]->WriteRegister(Register::DPP::DisableExternalTrigger, 0x0 ); 
  }
}

void BoardSetting::SetExtendedVetoDelay(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  
  ///digi[boardID]->WriteRegister(Register::DPP::ExtendedVetoDelay, (unsigned int) numExtendVetoDelay->GetNumber() ); 
}

void BoardSetting::SetFrontPanelIO(){  /// bit[20] different, bit[20] (PSD) not impletemented, PHA, bit[20] not use 
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  
  uint32_t bit = 0;
  bit += ( cbLEMOIO->GetSelected() );
  bit += cbTRGOUTMODE2->GetSelected()  ;
  bit += ( cbTRGINCtrl->GetSelected()  << 10 );
  bit += ( cbTRGINMezzanines->GetSelected()  << 11 );
  
  ///bit[20] = 0 by default. 
  printf("bit : 0x%x \n", bit);  
  
  digi[boardID]->WriteRegister(Register::DPP::FrontPanelIOControl, bit ); 
}

void BoardSetting::SetAnalogMonitorMode(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  
  digi[boardID]->WriteRegister(Register::DPP::AnalogMonitorMode, cbAnaMonitor->GetSelected() ); 
  
  if( cbAnaMonitor->GetSelected() == 3) {
    numBufferOccpGain->SetState(true);
    digi[boardID]->WriteRegister(Register::DPP::BufferOccupancyGain, (int) numBufferOccpGain->GetNumber() ); 
  }else{
    numBufferOccpGain->SetState(false);
  }
}

void BoardSetting::SetReadOutControl(){  /// same for PHA and PSD
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  uint32_t bit = 0;
  
  bit += cbVMEInterrupLevel->GetSelected();
  bit += ( (bOpticalLinkInterrupt->GetState() == kButtonDown) ? (1 << 3) : 0 );
  bit += ( (bEventAligned->GetState() == kButtonDown) ? (1 << 4) : 0 );
  bit += ( (bVMEAlogn64Mode->GetState() == kButtonDown) ? (1 << 5) : 0 );
  bit += ( (bInteruptReleaseMode->GetState() == kButtonDown) ? (1 << 7) : 0 );
  bit += ( (bEnableExtendedBlockTransfer->GetState() == kButtonDown) ? (1 << 8) : 0 );

  printf("bit : 0x%x \n", bit);  

  digi[boardID]->WriteRegister(Register::DPP::ReadoutControl, bit ); 
}

void BoardSetting::ReadData(){
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  
  uint32_t temp = digi[boardID]->GetSettingFromMemory(Register::DPP::ReadoutStatus_R);
  if( (temp & 0x1) == 0 ) {
    printf("No data. \n");
    return;
  }
  
  Data * data = digi[boardID]->GetData();
  data->Allocate80MBMemory();
  data->DPPType = digi[boardID]->GetDPPType();
  
  digi[boardID]->ReadData();
  
  //data->PrintBuffer();
  data->DecodeBuffer(false, 3);
  
  data->PrintStat();
  
  //Fill Histogram

  data->ClearData();
  
  ReadStatus();
  
}

void BoardSetting::ProgramDefaultBoard(){
  printf("=== %s\n", __func__);
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  
  if( digi[boardID]->GetDPPType() == V1730_DPP_PSD_CODE ){
    digi[boardID]->ProgramBoard();
  }
  if( digi[boardID]->GetDPPType() == V1730_DPP_PHA_CODE ){
    digi[boardID]->ProgramPHABoard();    
  }
  
  ChangeBoard();
}

void BoardSetting::ProgramBoardFromFile(){
  const char *filetypes[] = { "Setting File", "*.bin",
                              0,               0 };
  
  TGFileInfo fi;
  fi.fFileTypes = filetypes;
  fi.SetIniDir(".");
  printf("fIniDir = %s\n", fi.fIniDir);
  new TGFileDialog(gClient->GetRoot(), fMain, kFDOpen, &fi);
  printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
  
  if( fi.fFilename == NULL) return;
  
  txtSettingFile->SetText(fi.fFilename);
  
  int loadStatus = -1;
  if( digi == NULL ) {
    ///digi = new  Digitizer *[1];
    ///nDigi = 1;
    ///digi[0] = new Digitizer();
    ///loadStatus = digi[0]->LoadSettingBinaryToMemory( fi.fFilename );
    
  }else{
    int boardID = boardIDEntry->GetNumber();  
    LogMsg(Form("Program Board %03d From file %s. It may take ~ 10 sec.", digi[boardID]->GetSerialNumber(), fi.fFilename));
    loadStatus = digi[boardID]->LoadSettingBinaryToMemory( fi.fFilename );
    digi[boardID]->ProgramSettingsToBoard();
  }
  
  if( loadStatus == 0 ) {
    ChangeBoard();
  }else{
    LogMsg(Form("program board fail."));
  }

}

void BoardSetting::ProgramBoardFromLoadedFile(){
  if( digi == NULL ) return;

  int boardID = boardIDEntry->GetNumber();
  LogMsg(Form("Program Board %03d From file %s. It may take ~ 10 sec.", digi[boardID]->GetSerialNumber(), digi[boardID]->GetSettingFileName().c_str()));
  
  digi[boardID]->ProgramSettingsToBoard();
  ChangeBoard();
}

void BoardSetting::SaveSettingFile(){
  
  const char *filetypes[] = { "Setting File", "*.bin", 
                              "Text File", "*.txt", 
                              0, 0};
                              
  TGFileInfo fi;
  fi.fFileTypes = filetypes;
  fi.SetIniDir(".");
  printf("fIniDir = %s\n", fi.fIniDir);
  new TGFileDialog(gClient->GetRoot(), fMain, kFDSave, &fi);
  printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
 
  if( fi.fFilename == NULL) return; 
  
  TString temp = fi.fFilename;
  int len = temp.Length();
  temp.Remove(0, len-3);
  
  if( temp == "bin" ){      
    txtSettingFile->SetText(fi.fFilename);
    if( digi == NULL ) {
      
    }else{
      int boardID = boardIDEntry->GetNumber();  
      digi[boardID]->SaveAllSettingsAsBin( fi.fFilename );
    }
  }else if( temp == "txt") {
      int boardID = boardIDEntry->GetNumber();  
      digi[boardID]->SaveAllSettingsAsText( fi.fFilename );    
  }else{
    LogMsg("Invalid file extension.");
  }
  
}

void BoardSetting::FillBufferSizeTextBox(){
  if( digi == NULL ) return;
  int boardID = boardIDEntry->GetNumber();  
  uint32_t buffer = digi[boardID]->CalByteForBuffer();
  txtBufferSize->SetText(Form("%.2f", buffer/1024./1024.));
}

void BoardSetting::CaliADC(){
  if ( digi == NULL ) return;
  short boardID = boardIDEntry->GetNumber();
  if( digi != NULL ) digi[boardID]->WriteRegister(Register::DPP::ADCCalibration_W, 1);
}