Subversion Repositories f9daq

// Simple macro showing capabilities of triple slider
//Authors: Bertrand Bellenot, Ilka Antcheva

#include "TGButton.h"
#include "TRootEmbeddedCanvas.h"
#include "TGLayout.h"
#include "TF1.h"
#include "TMath.h"
#include "TCanvas.h"
#include "TGTextEntry.h"
#include "TGNumberEntry.h"
#include "TGLabel.h"
#include "TGTripleSlider.h"
#include "TGFrame.h"
#include "TGTab.h"
#include "TGButton.h"
#include "TGSlider.h"
#include "TGComboBox.h"
#include <TGFileDialog.h>
#include "DrsChannel.h"
#include "drs.h"

enum ETestCommandIdentifiers {
        HId1,
        HId2,
        HId3,

        VId1,
        VId2,
        VId3,

        CFId1,

        HCId1,
        HCId2,


        HSId1,

        VSId1,
        StartId
};

const char *filetypesdat[] = {
        "data files",    "*.dat",
        "Text files",    "*.[tT][xX][tT]",
        0,               0
};

const char *filetypesini[] = {
        "configuration files",    "*.ini",
        0,               0
};

TRootEmbeddedCanvas *fCanvas;

class TChannel {
private:


        TGTripleHSlider     *fTimingSlider;
        TGTripleHSlider     *fThresholdSlider;

        TGLayoutHints       *fBly, *fBfly1, *fBfly2, *fBfly3;
public:
        TChannel( TGCompositeFrame *p, int ch);
        ~TChannel();

        TGTextEntry         *fTeh[7];
        TGTextBuffer        *fTbh[7];
        TGCheckButton       *fEdge;

        void DoText(const char *text);
        void DoSlider();
        void HandleButtons();

        ClassDef(TChannel, 0)

};



TChannel::~TChannel(){



}

TChannel::TChannel( TGCompositeFrame *p, int ch){

        //--- layout for the frame: place at bottom, right aligned
        fBfly1 = new TGLayoutHints(kLHintsTop | kLHintsCenterX, 5, 5, 5, 5);
        fBfly2 = new TGLayoutHints(kLHintsTop | kLHintsLeft,    5, 5, 5, 5);
        fBfly3 = new TGLayoutHints(kLHintsTop | kLHintsRight,   5, 5, 5, 5);
        fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5);


        TGVerticalFrame *fHframe1 = new TGVerticalFrame(p, 0, 0, 0);



        TGHorizontalFrame * fThresholdFrame = new TGHorizontalFrame(fHframe1, 0, 0, 0);

        //TGLabel *fLChannel = new TGLabel(fThresholdFrame, tmp);
        TGLabel *fLThreshold = new TGLabel(fThresholdFrame, "Threshold:");

        fThresholdSlider = new TGTripleHSlider(fThresholdFrame, 190, kDoubleScaleBoth, VSId1,
                                               kHorizontalFrame,
                                               p->GetDefaultFrameBackground(),
                                               kFALSE, kFALSE, kFALSE, kFALSE);
        fThresholdSlider->Connect("PointerPositionChanged()", "TChannel",  this, "DoSlider()");
        fThresholdSlider->Connect("PositionChanged()", "TChannel", this, "DoSlider()");
        fThresholdSlider->SetRange(-1,1);

        //fThresholdFrame->AddFrame(fLChannel, fBfly2);
        fThresholdFrame->AddFrame(fLThreshold, fBfly2);
        fThresholdFrame->AddFrame(fThresholdSlider, fBly);

        TGHorizontalFrame * fTimeWinFrame = new TGHorizontalFrame(fHframe1, 0, 0, 0);
        fEdge = new TGCheckButton(fTimeWinFrame, "&Positive Edge", HCId2);
        fEdge->SetState(kButtonUp);
        fEdge->SetToolTipText("Pointer position relative to slider position");

        TGLabel *fLTiming = new TGLabel(fTimeWinFrame, "Time Window:");

        fTimingSlider = new TGTripleHSlider(fTimeWinFrame, 190, kDoubleScaleBoth, HSId1,
                                            kHorizontalFrame,
                                            p->GetDefaultFrameBackground(),
                                            kFALSE, kFALSE, kFALSE, kFALSE);
        fTimingSlider->Connect("PointerPositionChanged()", "TChannel",  this, "DoSlider()");
        fTimingSlider->Connect("PositionChanged()", "TChannel", this, "DoSlider()");
        fTimingSlider->SetRange(0,200);



        fHframe1->Resize(200, 25);

        fEdge->Connect("Clicked()", "TChannel", this,
                       "HandleButtons()");

        fTimeWinFrame->AddFrame(fEdge, fBfly2);
        fTimeWinFrame->AddFrame(fLTiming, fBfly2);
        fTimeWinFrame->AddFrame(fTimingSlider, fBly);

        fHframe1->AddFrame(fThresholdFrame, fBly);
        fHframe1->AddFrame(fTimeWinFrame, fBly);




        TGHorizontalFrame *fNumbersFrame = new TGHorizontalFrame(fHframe1, 0, 0, 0);

        for (int i=0; i<7; i++)
                fTeh[i] = new TGTextEntry(fNumbersFrame, fTbh[i] = new TGTextBuffer(5), HId1+i);

        fTeh[0]->SetToolTipText("Minimum (left) Value of Slider");
        fTeh[1]->SetToolTipText("Pointer Position Value");
        fTeh[2]->SetToolTipText("Maximum (right) Value of Slider");
        fTeh[3]->SetToolTipText("Signal Cut 0");
        fTeh[4]->SetToolTipText("Signal Threshold");
        fTeh[5]->SetToolTipText("Signal Cut 1");

        fTeh[6]->SetToolTipText("Constant Fraction Ratio");

        for (int i=0; i<7; i++) {
                fTbh[i]->AddText(0, "0.0");
                fTeh[i]->Connect("TextChanged(char*)", "TChannel", this,
                                 "DoText(char*)");
        }

        fNumbersFrame->Resize(100, 25);



        for (int i=0; i<7; i++) { fNumbersFrame->AddFrame(fTeh[i], fBfly2); }


        fHframe1->AddFrame(fNumbersFrame, fBly);
        p->AddFrame(fHframe1, fBly);




        fTimingSlider->SetPosition(60,120);
        fTimingSlider->SetPointerPosition(65);
        fThresholdSlider->SetPosition(-0.5,0.5);
        fThresholdSlider->SetPointerPosition(0.25);

        char buf[32];
        sprintf(buf, "%.3f", fTimingSlider->GetMinPosition());
        fTbh[0]->Clear();
        fTbh[0]->AddText(0, buf);
        sprintf(buf, "%.3f", fTimingSlider->GetPointerPosition());
        fTbh[1]->Clear();
        fTbh[1]->AddText(0, buf);
        sprintf(buf, "%.3f", fTimingSlider->GetMaxPosition());
        fTbh[2]->Clear();
        fTbh[2]->AddText(0, buf);
        sprintf(buf, "%.3f", fThresholdSlider->GetMinPosition());
        fTbh[3]->Clear();
        fTbh[3]->AddText(0, buf);
        sprintf(buf, "%.3f", fThresholdSlider->GetPointerPosition());
        fTbh[4]->Clear();
        fTbh[4]->AddText(0, buf);
        sprintf(buf, "%.3f", fThresholdSlider->GetMaxPosition());
        fTbh[5]->Clear();
        fTbh[5]->AddText(0, buf);

        sprintf(buf, "0.25");
        fTbh[6]->Clear();
        fTbh[6]->AddText(0, buf);


}


class TDrsGui: public TGMainFrame {

private:

        TGLayoutHints       *fLcan;
        TGComboBox *fTrgch;
        TGVerticalFrame   *fHframe0;
        TGTextButton *fStart;
        TGTextButton *fSelect;
        TGTextEntry *fFile;
        TGNumberEntry *fFirst;
        TGNumberEntry *fNeve;
        TGNumberEntry *fUpdFrq;
        TGTextBuffer        *fFileText;

        TChannel * fChannel[4];
        TGLayoutHints       *fBly;
public:
        TDrsGui();
        virtual ~TDrsGui();

        void CloseWindow();
        void StartAnalysis();
        void HandleAction();
        void LoadIni();
        ClassDef(TDrsGui, 0)
};

void TDrsGui::StartAnalysis(){
        const int nch=4;
        DrsChannel c[nch];

        for (int i=0; i<nch; i++) {


                c[i].cfrac = atof(fChannel[i]->fTbh[6]->GetString());
                c[i].threshold = atof( fChannel[i]->fTbh[4]->GetString());
                c[i].twin[0] = atof( fChannel[i]->fTbh[0]->GetString());
                c[i].twin[1] = atof( fChannel[i]->fTbh[2]->GetString());

                c[i].adcgate[0] = atof( fChannel[i]->fTbh[1]->GetString());;
                c[i].adcgate[1] = c[i].adcgate[0] + c[i].twin[1]-c[i].twin[0];

                c[i].vcut[0] = atof( fChannel[i]->fTbh[3]->GetString());
                c[i].vcut[1] = atof( fChannel[i]->fTbh[5]->GetString());

                c[i].edge = fChannel[i]->fEdge->GetState();



                printf("Ch.%d :",i);
                for (int j=0; j<7; j++) printf("\t%f", atof( fChannel[i]->fTbh[j]->GetString()));
                printf("%d\n", fChannel[i]->fEdge->GetState() );

        }
        printf("File: %s\n", fFileText->GetString()  );





        int nev=fNeve->GetIntNumber();
                int first=fFirst->GetIntNumber();
        int updfrq=fUpdFrq->GetIntNumber();;

        int trgch=fTrgch->GetSelected();
        drs * d = new drs(fFileText->GetString(), nch, c, trgch,first, nev, updfrq  );


}
void TDrsGui::LoadIni(){
        static TString dir(".");
        TGFileInfo fi;
        fi.fFileTypes = filetypesini;
        fi.fIniDir    = StrDup(dir);
        printf("fIniDir = %s\n", fi.fIniDir);
        new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
        printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
        dir = fi.fIniDir;
        FILE *fp= fopen(fi.fFilename,"r");
        float f[10];
        int j=0;
        const int ndim=400;
        char line[ndim];
        int edge=0;
        int ch=0;
        float cfrac=1;
        while (fgets(line,ndim,fp)!=NULL) {
                if (line[0]=='#' ) continue;
                printf("%d***********\n",j++);
                sscanf(line,"%d%d%f%f%f%f%f%f%f",&ch,&edge,&f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6]);
                printf("%d\t%d\t",ch, edge);
                for (int i=0; i<7; i++) {

                        char buf[20];
                        sprintf(buf, "%.3f", f[i]);
                        fChannel[ch]->fTbh[i]->Clear();
                        fChannel[ch]->fTbh[i]->AddText(0, buf);
                        fChannel[ch]->fTeh[i]->SetCursorPosition(fChannel[ch]->fTeh[i]->GetCursorPosition());
                        fChannel[ch]->fTeh[i]->Deselect();
                        gClient->NeedRedraw(fChannel[ch]->fTeh[i]);
                        printf("%2.2f\t",f[i]);

                }
                if (!edge) fChannel[ch]->fEdge->SetState(kButtonUp);
                else fChannel[ch]->fEdge->SetState(kButtonDown);

                printf("\n");
        }

        fclose(fp);


}


void TDrsGui::HandleAction(){
        static TString dir(".");
        TGFileInfo fi;
        fi.fFileTypes = filetypesdat;
        fi.fIniDir    = StrDup(dir);
        printf("fIniDir = %s\n", fi.fIniDir);
        new TGFileDialog(gClient->GetRoot(), this, kFDOpen, &fi);
        printf("Open file: %s (dir: %s)\n", fi.fFilename, fi.fIniDir);
        dir = fi.fIniDir;
        //char buf[32];
        //sprintf(buf, "%.3f", fTimingSlider->GetMinPosition());
        fFileText->Clear();
        fFileText->AddText(0,fi.fFilename);
        /*
           fCanvas->GetCanvas()->Modified();
              fCanvas->GetCanvas()->Update();
         */
        fFile->SetCursorPosition(fFile->GetCursorPosition());
        fFile->Deselect();
        gClient->NeedRedraw(fFile);
}
//______________________________________________________________________________
TDrsGui::TDrsGui() : TGMainFrame(gClient->GetRoot(), 100, 100)
{
        SetCleanup(kDeepCleanup);
        // Create an embedded canvas and add to the main frame, centered in x and y
        // and with 30 pixel margins all around
        /*
           fCanvas = new TRootEmbeddedCanvas("Canvas", this, 600, 400);
           fLcan = new TGLayoutHints(kLHintsExpandX | kLHintsExpandY, 10, 10, 10, 10);
           //AddFrame(fCanvas, fLcan);
           fCanvas->GetCanvas()->SetFillColor(33);
           fCanvas->GetCanvas()->SetFrameFillColor(41);
           fCanvas->GetCanvas()->SetBorderMode(0);
           fCanvas->GetCanvas()->SetGrid();
           fCanvas->GetCanvas()->SetLogy();
         */
        fHframe0 = new TGVerticalFrame(this, 0, 0, 0);
        fHframe0->Resize(200, 50);
        //--- layout for buttons: top align, equally expand horizontally
        fBly = new TGLayoutHints(kLHintsTop | kLHintsExpandX, 5, 5, 5, 5);

        TGHorizontalFrame *fStartFrame = new TGHorizontalFrame(fHframe0, 0, 0, 0);

        char tmp[20];
        // combo box widget
        fTrgch = new TGComboBox(fStartFrame,50);
        for (int i = 0; i < 4; i++) {
                sprintf(tmp, "Ch %i", i);
                fTrgch->AddEntry(tmp, i);
        }
        fTrgch->Resize(50, 20);
        fTrgch->Select(0);
        TGLabel *fLTrgch = new TGLabel(fStartFrame, "Trg Chan:");
        fNeve = new TGNumberEntry(fStartFrame,  5000, 5,999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative );
        TGLabel *fLNeve = new TGLabel(fStartFrame, "Number of ev.:");
                
                fFirst = new TGNumberEntry(fStartFrame,  0, 5,999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative );
        TGLabel *fLFirst = new TGLabel(fStartFrame, "First ev.:");

        fUpdFrq = new TGNumberEntry(fStartFrame,  50, 5,999, TGNumberFormat::kNESInteger, TGNumberFormat::kNEANonNegative );
        TGLabel *fLUpdFrq = new TGLabel(fStartFrame, "Update Freq.:");

        fStartFrame->AddFrame(fLTrgch, fBly);
        fStartFrame->AddFrame(fTrgch, fBly);
        fStartFrame->AddFrame(fLNeve, fBly);
        fStartFrame->AddFrame(fNeve, fBly);
                fStartFrame->AddFrame(fLFirst, fBly);
        fStartFrame->AddFrame(fFirst, fBly);
        fStartFrame->AddFrame(fLUpdFrq, fBly);
        fStartFrame->AddFrame(fUpdFrq, fBly);

        fHframe0->AddFrame(fStartFrame, fBly);


        TGHorizontalFrame *fH = new TGHorizontalFrame(fHframe0, 0, 0, 0);


        fStart =  new TGTextButton(fH, "Start");
        fStart->Connect("Clicked()", "TDrsGui", this, "StartAnalysis()");

        fSelect =  new TGTextButton(fH, "Select Analysis File");
        fSelect->Connect("Clicked()", "TDrsGui", this, "HandleAction()");

        fFile = new TGTextEntry(fH, fFileText = new TGTextBuffer(5), 1);

        TGTextButton * fLoadIni =  new TGTextButton(fH, "Load Ini File");
        fLoadIni->Connect("Clicked()", "TDrsGui", this, "LoadIni()");


        fH->AddFrame(fSelect, fBly);
        fH->AddFrame(fFile, fBly);
        fH->AddFrame(fLoadIni, fBly);
        fH->AddFrame(fStart, fBly);

        fHframe0->AddFrame(fH, fBly);
        AddFrame(fHframe0, fBly);

        //--------- create the Tab widget
        TGTab *fTab = new TGTab(fHframe0, 300, 300);
        TGLayoutHints *fL3 = new TGLayoutHints(kLHintsTop | kLHintsLeft, 5, 5, 5, 5);

        for (int ich=0; ich<4; ich++) {
                char tmp[255];
                sprintf(tmp,"Channel %d:",ich);
                TGCompositeFrame *tf = fTab->AddTab(tmp);
                fChannel[ich]= new TChannel( tf, ich);

        }
        fHframe0->AddFrame(fTab, fBly);

        // Set main frame name, map sub windows (buttons), initialize layout
        // algorithm via Resize() and map main frame
        SetWindowName("DRS Analysis");
        MapSubwindows();
        Resize(GetDefaultSize());
        MapWindow();

}

//______________________________________________________________________________
TDrsGui::~TDrsGui()
{
        // Clean up

        Cleanup();
}

//______________________________________________________________________________
void TDrsGui::CloseWindow()
{
        // Called when window is closed via the window manager.

        delete this;
}

//______________________________________________________________________________
void TChannel::DoText(const char * /*text*/)
{
        // Handle text entry widgets.

        TGTextEntry *te = (TGTextEntry *) gTQSender;
        Int_t id = te->WidgetId();

        switch (id) {
        case HId1:
                fTimingSlider->SetPosition(atof(fTbh[0]->GetString()),
                                           fTimingSlider->GetMaxPosition());
                break;
        case HId2:
                fTimingSlider->SetPointerPosition(atof(fTbh[1]->GetString()));
                break;
        case HId3:
                fTimingSlider->SetPosition(fTimingSlider->GetMinPosition(),
                                           atof(fTbh[2]->GetString()));
                break;

        case VId1:
                fThresholdSlider->SetPosition(atof(fTbh[3]->GetString()),
                                              fThresholdSlider->GetMaxPosition());
                break;
        case VId2:
                fThresholdSlider->SetPointerPosition(atof(fTbh[4]->GetString()));
                break;
        case VId3:
                fThresholdSlider->SetPosition(fThresholdSlider->GetMinPosition(),
                                              atof(fTbh[5]->GetString()));
                break;

        default:
                break;
        }
        /*


           fCanvas->GetCanvas()->Modified();
           fCanvas->GetCanvas()->Update();

         */
}

//______________________________________________________________________________
void TChannel::DoSlider()
{
        // Handle slider widgets.

        char buf[32];

        float values[6]={
                fTimingSlider->GetMinPosition(),fTimingSlider->GetPointerPosition(),fTimingSlider->GetMaxPosition(),
                fThresholdSlider->GetMinPosition(),fThresholdSlider->GetPointerPosition(),fThresholdSlider->GetMaxPosition()
        };

        for (int i=0; i<6; i++) {
                sprintf(buf, "%.3f", values[i]);
                fTbh[i]->Clear();
                fTbh[i]->AddText(0, buf);
                fTeh[i]->SetCursorPosition(fTeh[i]->GetCursorPosition());
                fTeh[i]->Deselect();
                gClient->NeedRedraw(fTeh[i]);
        }


        /*

           fCanvas->GetCanvas()->Modified();
           fCanvas->GetCanvas()->Update();
         */
}

//______________________________________________________________________________
void TChannel::HandleButtons()
{
        // Handle different buttons.

        TGButton *btn = (TGButton *) gTQSender;
        Int_t id = btn->WidgetId();

        switch (id) {
        case HCId1:
                // fTimingSlider->SetConstrained(fTrigger->GetState());
                break;
        case HCId2:
                fTimingSlider->SetRelative(fEdge->GetState());
                break;
        default:
                break;
        }
}


void drsgui()
{
        new TDrsGui();
}