TGo4Condition.h

Go to the documentation of this file.

// $Id$
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
//                     Planckstr. 1, 64291 Darmstadt, Germany
// Contact:            http://go4.gsi.de
//-----------------------------------------------------------------------
// This software can be used under the license agreements as stated
// in Go4License.txt file which is part of the distribution.
//-----------------------------------------------------------------------

#ifndef TGO4CONDITION_H
#define TGO4CONDITION_H

#include "TNamed.h"
#include "TAttLine.h"
#include "TAttFill.h"
#include <iostream>

class TH1;
class TVirtualPad;
class TCutG;
class TObjArray;

class TGo4HistogramEntry;
class TGo4EventElement;
class TGo4ConditionPainter;

enum ConditionsKind {
   kGO4CONDWINDOW  = 1,
   kGO4CONDPOLYGON = 2
};

class TGo4Condition : public TNamed, public TAttLine, public TAttFill {

  friend class TGo4CondArray;

  public:
    TGo4Condition();

    TGo4Condition(const char *name, const char *title = "Go4 Condition");

    virtual ~TGo4Condition();

    void Paint(Option_t *opt = "") override;

    void Draw(Option_t *opt = "") override;

    virtual void UnDraw(Option_t *opt = "");

    void Pop() override;

    virtual TGo4ConditionPainter *CreatePainter();

    virtual Int_t Counts();

    virtual Int_t TrueCounts();

    virtual void ResetCounts();

    virtual void SetCounts(Int_t truecounts, Int_t counts);

    virtual void Disable(Bool_t result);

    virtual void Enable();

    Bool_t IsEnabled() const { return fbEnabled; }

    virtual Bool_t Test();
    virtual Bool_t Test(Double_t x, Double_t y) { return true; }
    virtual Bool_t Test(Double_t x) { return true; }
    //virtual Bool_t Test(Bool_t result) { return true; }

    virtual void SetValues() {}
    virtual void SetValues(Double_t low1, Double_t up1) {}
    virtual void SetValues(Double_t low1, Double_t up1, Double_t low2, Double_t up2) {}
    virtual void SetValues(TCutG * newcut) {}
    virtual void SetValues(Double_t * x, Double_t * y, Int_t len) {}

    virtual void AddCondition(TGo4Condition *next);

    void IncCounts();

    void IncTrueCounts();

    Bool_t IsTrue() const { return fbTrue; }

    Bool_t IsFalse() const { return fbFalse; }

    Bool_t FixedResult() const { return fbResult; }

    virtual void Invert(Bool_t on);

    virtual void PrintCondition(Bool_t full=kTRUE);

    virtual void PrintBar();

    void Print(Option_t *opt = "") const override;

    void SetLast(Bool_t value) { fbLastResult=value; }

    Bool_t GetLast() const { return fbLastResult; }

    virtual Bool_t UpdateFrom(TGo4Condition *cond, Bool_t counts);

    virtual Bool_t UpdateFromUrl(const char *rest_url_opt);

    virtual void GetValues(Int_t &dim, Double_t &x1, Double_t &y1, Double_t &x2, Double_t &y2);
    virtual Double_t GetXLow() const { return 0.; }
    virtual Double_t GetXUp() const { return 0.; }
    virtual Double_t GetYLow() const { return 0.; }
    virtual Double_t GetYUp() const { return 0.; }
    virtual TCutG *GetCut(Bool_t owner) { return nullptr; }

    virtual Double_t GetIntegral(TH1 *, Option_t * = "") { return 0.; }

    virtual Double_t GetMean(TH1 *, Int_t = 1)  { return 0.; }

    virtual Double_t GetRMS(TH1 *, Int_t = 1)  { return 0.; }

    virtual Double_t GetSkewness(TH1 *, Int_t = 1)  { return 0.; }

    virtual Double_t GetCurtosis(TH1 *, Int_t = 1)  { return 0.; }

    virtual Double_t GetXMax(TH1 *) { return 0.; }

    virtual Double_t GetYMax(TH1 *) { return 0.; }

    virtual Double_t GetCMax(TH1 *) { return 0.; }

    virtual const TGo4Condition *GetActiveCondition() const { return this; }

    virtual void MarkReset(Bool_t on);

    void Clear(Option_t *opt = "") override;

    virtual void SetFlags(Bool_t enabled, Bool_t lastresult, Bool_t markreset,
                   Bool_t result, Bool_t truevalue, Bool_t falsevalue);

    virtual void GetFlags(Bool_t *enabled, Bool_t *lastresult, Bool_t *markreset,
                   Bool_t *result, Bool_t *truevalue, Bool_t *falsevalue);

    virtual void SetVisible(Bool_t on) { fbVisible = on; }

    virtual Bool_t IsVisible() const { return fbVisible; }

    void SetHistogramLink(Bool_t on) { fbHistogramLink = on; }

    Bool_t IsHistogramLink() const { return fbHistogramLink; }

    void SetHistogram(const char *name);

    const char *GetLinkedHistogram() const;

    virtual void SetWorkHistogram(TH1 *histo) { fxHisto = histo; }

    TH1 *GetWorkHistogram() const { return fxHisto; }

    virtual void SetPainter(TGo4ConditionPainter *painter);

    void SetUpdateEpsilon(Double_t val){fdUpdateEpsilon=val;}

    Double_t GetUpdateEpsilon() const { return fdUpdateEpsilon; }

    static const Double_t fgdUPDATEEPSILON;

    void SaveLabelStyle();

    void InitLabelStyle();

    void ResetLabel(Option_t *opt = "reset");

    virtual void SetLabelDraw(Bool_t on) { fbLabelDraw = on; } // *TOGGLE* *GETTER=IsLabelDraw
    virtual Bool_t IsLabelDraw() const { return fbLabelDraw; }

    virtual void SetLimitsDraw(Bool_t on) { fbLimitsDraw = on; } // *TOGGLE* *GETTER=IsLimitsDraw
    virtual Bool_t IsLimitsDraw() const { return fbLimitsDraw; }

    virtual void SetIntDraw(Bool_t on) { fbIntDraw = on; } // *TOGGLE* *GETTER=IsIntDraw
    virtual Bool_t IsIntDraw() const { return fbIntDraw; }

    virtual void SetXMeanDraw(Bool_t on) { fbXMeanDraw = on; } // *TOGGLE* *GETTER=IsXMeanDraw
    virtual Bool_t IsXMeanDraw() const { return fbXMeanDraw; }

    virtual void SetXRMSDraw(Bool_t on) { fbXRMSDraw = on; } // *TOGGLE* *GETTER=IsXRMSDraw
    virtual Bool_t IsXRMSDraw() const { return fbXRMSDraw; }

    virtual void SetYMeanDraw(Bool_t on) { fbYMeanDraw = on; } // *TOGGLE* *GETTER=IsYMeanDraw
    virtual Bool_t IsYMeanDraw() const { return fbYMeanDraw; }

    virtual void SetYRMSDraw(Bool_t on) { fbYRMSDraw = on; } // *TOGGLE* *GETTER=IsYRMSDraw
    virtual Bool_t IsYRMSDraw() const { return fbYRMSDraw; }

    virtual void SetXMaxDraw(Bool_t on) { fbXMaxDraw = on; } // *TOGGLE* *GETTER=IsXMaxDraw
    virtual Bool_t IsXMaxDraw() const { return fbXMaxDraw; }

    virtual void SetYMaxDraw(Bool_t on) { fbYMaxDraw = on; } // *TOGGLE* *GETTER=IsYMaxDraw
    virtual Bool_t IsYMaxDraw() const { return fbYMaxDraw; }

    virtual void SetCMaxDraw(Bool_t on) { fbCMaxDraw = on; } // *TOGGLE* *GETTER=IsCMaxDraw
    virtual Bool_t IsCMaxDraw() const { return fbCMaxDraw; }

    virtual void SetLabelNumFormat(const char *fmt) { fxNumFormat = fmt; }
    virtual const char *GetLabelNumFormat() const { return fxNumFormat.Data(); }

    virtual void SetChanged(Bool_t on = kTRUE)
    {
       if (on)
          fiIsChanged++;
       else
          fiIsChanged = 0;
    }
    virtual Int_t IsChanged() const { return fiIsChanged; }

    void SetMultiEdit(Bool_t on) { fbMultiEdit = on; }
    virtual Bool_t IsMultiEdit() const { return fbMultiEdit; }

    void SetDimension(Int_t d) { fiDim = d; }
    Int_t GetDimension() const { return fiDim; }

    void SetOwnedByEditor(Bool_t on) { fbOwnedByEditor = on; }
    Bool_t IsOwnedByEditor() const { return fbOwnedByEditor; }

    virtual void SetCurrentIndex(Int_t) {}

    virtual Int_t GetCurrentIndex() const { return 0; }

    virtual Int_t GetNumberOfConditions() const { return 1; }

    virtual Int_t GetMemorySize() const;

    virtual Bool_t IsPolygonType() const { return kFALSE; }
    virtual Bool_t IsArrayType() const { return kFALSE; }

    void DeletePainter();

    static Bool_t fgbLABELDRAW;

    static Bool_t fgbLIMITSDRAW;

    static Bool_t fgbINTDRAW;

    static Bool_t fgbXMEANDRAW;

    static Bool_t fgbXRMSDRAW;

    static Bool_t fgbYMEANDRAW;

    static Bool_t fgbYRMSDRAW;

    static Bool_t fgbXMAXDRAW;

    static Bool_t fgbYMAXDRAW;

    static Bool_t fgbCMAXDRAW;

   static TString fgxNUMFORMAT;
   static TString fgxURL_RESET;
   static TString fgxURL_RESULT;
   static TString fgxURL_INVERT;
   static TString fgxURL_VISIBLE;
   static TString fgxURL_LABEL;
   static TString fgxURL_LIMITS;
   static TString fgxURL_INTEGRAL;
   static TString fgxURL_XMEAN;
   static TString fgxURL_XRMS;
   static TString fgxURL_YMEAN;
   static TString fgxURL_YRMS;
   static TString fgxURL_XMAX;
   static TString fgxURL_YMAX;
   static TString fgxURL_CMAX;

   static void SetGlobalStyle(Bool_t LABELDRAW, Bool_t LIMITSDRAW, Bool_t INTDRAW,
                              Bool_t XMEANDRAW, Bool_t YMEANDRAW, Bool_t XRMSDRAW, Bool_t YRMSDRAW,
                              Bool_t XMAXDRAW, Bool_t YMAXDRAW, Bool_t CMAXDRAW, const char *NUMFORMAT);

   static void GetGlobalStyle(Bool_t &LABELDRAW, Bool_t &LIMITSDRAW, Bool_t &INTDRAW,
                              Bool_t &XMEANDRAW, Bool_t &YMEANDRAW, Bool_t &XRMSDRAW, Bool_t &YRMSDRAW,
                              Bool_t &XMAXDRAW, Bool_t &YMAXDRAW, Bool_t &CMAXDRAW, TString &NUMFORMAT);

  protected:

    TGo4ConditionPainter *fxPainter{nullptr};

    TObjArray *fxUrlOptionArray{nullptr}; 

    void BuildUrlOptionArray(const char *rest_url_opt);

    Bool_t UrlOptionHasKey(const char *key);

    TString GetUrlOptionAsString(const char *key, TString def_value);

    Int_t GetUrlOptionAsInt(const char *key, Int_t def_value);

    Double_t GetUrlOptionAsDouble(const char *key, Double_t def_value);

    void SetPainted(Bool_t on) { fbIsPainted = on; }
    Bool_t IsPainted() const { return fbIsPainted; }

    const char *MakeScript(std::ostream &out, const char *varname, Option_t *opt = "", const char *arrextraargs = nullptr);

  private:

    Int_t fiDim{0};

    Bool_t fbMarkReset{kFALSE};

    Bool_t fbLastResult{kFALSE};

    Bool_t fbTrue{kTRUE};

    Bool_t fbFalse{kFALSE};

    Int_t fiTrueCounts{0};

    Int_t fiCounts{0};

    Bool_t fbEnabled{kFALSE};

    Bool_t fbResult{kFALSE};

    Bool_t fbMultiEdit{kFALSE};

    Bool_t fbVisible{kFALSE};

    Bool_t fbHistogramLink{kFALSE};

    TString fxHistoName;

    Double_t fdUpdateEpsilon{0};

    Bool_t fbLabelDraw{kFALSE};

    Bool_t fbLimitsDraw{kFALSE};

    Bool_t fbIntDraw{kFALSE};

    Bool_t fbXMeanDraw{kFALSE};

    Bool_t fbXRMSDraw{kFALSE};

    Bool_t fbYMeanDraw{kFALSE};

    Bool_t fbYRMSDraw{kFALSE};

    Bool_t fbXMaxDraw{kFALSE};

    Bool_t fbYMaxDraw{kFALSE};

    Bool_t fbCMaxDraw{kFALSE};

    TString fxNumFormat;

    TH1 *fxHisto{nullptr};   

    Int_t fiIsChanged{0}; 

    Bool_t fbIsPainted{kFALSE}; 

    Bool_t fbOwnedByEditor{kFALSE}; 

    Bool_t fbStreamedCondition{kFALSE}; 

   ClassDefOverride(TGo4Condition,8)
};

#endif //TGO4CONDITION_H