ObjectLine.h

Go to the documentation of this file.

#ifndef _OBJECTLINE_H_
#define _OBJECTLINE_H_

#include "AbstractObjectStock.h"
// to see how to integrate better, own definition in ObjectLine as well
#include "EditorObjStock.h"

#include "TypeObjectLine.h"

// could be in implementation if really needed
#include <iostream>
// declare ROOT types UInt_t, should suppress as more as possible
//#include <Rtypes.h>
#include <TLine.h>

class ObjectLine : public AbstractObjectStock, public TAttLine
{
    protected :

        std::string name_line;

        // Line [-inf,+inf], kHalfLine1 [point,+inf], kHalfLine2 [-inf, point], kSegment[point,point]
        // could be in EditorObject, takes memory here ! or in TypeLine.h, no
        // no memory, just better encapsulation if not needed form outside, here only used by the ObjectLine
        enum ModeLine { kLine = 0, kHalfLine1 = 1, kHalfLine2 = 2, kSegment = 3 };

        ModeLine fModeLine;
        TypeLine fTypeLine;

        TLine *fline;

        // protected function used by the constructor,
        // simple wrapper to construct the line
        void InitLine( double x0, double y0, double x1, double y1 );

        virtual std::vector<float> GetValues( int px, int py, time_t &date ) const;

      public :
          // default constructor, not used yet
          ObjectLine();
          // miss something to get the reference ??
          //ObjectLine ( TypeLine & tline, double valuey0 );
          ObjectLine ( TypeLine tline, double valuey0 );
          // should replace mode as well, not clear which one in this function
          ObjectLine( double x0, double y0, double x1, double y1 ); // Int_t kMode );
          virtual ~ObjectLine() {
#ifdef DEBUG_OBJSTOCK
                  std::cout << "Destructor ObjectLine" << std::endl;
#endif
                  delete fline; fline = 0;
          }

          // as for indicator not present in abstract base
          virtual std::string GetNameObject() const { return name_line; }
          // new added not used yet
          virtual void SetNameObject ( std::string & name ) { name_line = name; }

          // to define, maybe override in derived
          /*
          virtual std::vector<std::string> MakeStringForStatusBar( int px, int py ) const {
              std::vector<std::string> vec_string;
              vec_string.push_back("toto1");
              vec_string.push_back("toto2");
              return vec_string;
          }*/

          // should not be public, but protected ??
          double GetX0() const { return fline->GetX1();}
          double GetX1() const { return fline->GetX2();}
          double GetY0() const { return fline->GetY1();}
          double GetY1() const { return fline->GetY2();}
          // could receive double and translate to double for ROOT
          void SetX0(double x0) { fline->SetX1(x0);}
          void SetX1(double x1) { fline->SetX2(x1);}
          void SetY0(double y0) { fline->SetY1(y0);}
          void SetY1(double y1) { fline->SetY2(y1);}

          // pure virtual in AbstractObjectStock, but never used here !
          // maybe can implement it  ??
          virtual void SetValues( unsigned int, std::vector<double>, double, double, time_t, UInt_t=0)  {}

          // graphical function, need to redirect now, needed for interation with graphical editor
          virtual Width_t GetLineWidth() const { return fline->GetLineWidth(); }
          virtual Color_t GetLineColor() const { return fline->GetLineColor(); }
          virtual Style_t GetLineStyle() const { return fline->GetLineStyle(); }
          virtual void SetLineWidth(Width_t lwidth) { fline->SetLineWidth(lwidth); }
          virtual void SetLineColor(Color_t color)  { fline->SetLineColor(color); }
          virtual void SetLineStyle(Style_t lstyle) { fline->SetLineStyle( lstyle ); }

          // deal with Modeline
          virtual Int_t GetModeLine() const {return fModeLine;}
          virtual bool IsLine()      { if (fModeLine==kLine) return true; else return false;}
          virtual bool IsHalfLine1() { if (fModeLine==kHalfLine1) return true; else return false;}
          virtual bool IsHalfLine2() { if (fModeLine==kHalfLine2) return true; else return false;}
          virtual bool IsSegment()   { if (fModeLine==kSegment) return true; else return false;}

          //virtual void GetModekLine()  { return fModeLine; std::cout << "Get kLine" << endl; }
          // *TOGGLE* not working
          virtual void SetModekLine()      { fModeLine= kLine; std::cout << "Set kLine" << std::endl; } // *MENU*
          virtual void SetModekHalfLine1() { fModeLine= kHalfLine1; std::cout << "Set kHalfLine1" << std::endl; } // *MENU*
          virtual void SetModekHalfLine2() { fModeLine= kHalfLine2; std::cout << "Set kHalfLine2" << std::endl; } // *MENU*
          virtual void SetModekSegment()   { fModeLine= kSegment; std::cout << "Set kSegment" << std::endl; } // *MENU*

          //deal with TypeLine
          virtual TypeLine GetTypeLine() const {return fTypeLine;}
          virtual bool IsSupport() const { return (fTypeLine==TypeLine::kSupport) ? true : false;}
          virtual bool IsTendance() const  { return (fTypeLine==TypeLine::kTendance) ? true : false;}

          // default for all GetExtrama do nothing
          virtual void GetExtrema( double & /*min*/, double & /*max*/ ) const {
          //    //min = max = GetY0();
          /*   std::cout << "ObjectLine::GetExtrema do nothing " << std::endl; */}

          virtual void Resize( unsigned int /*new_size*/ ) {
#ifdef DEBUG_OBJSTOCK
                  std::cout << "ObjectLine::Resize to nothing" << std::endl;
#endif
          }

          //virtual Int_t DistancetoPrimitive(Int_t px, Int_t py); //, TObject** obj );
          virtual Int_t DistancetoPrimitive(Int_t px, Int_t py, AbstractObjectStock ** obj );
          // cannot anchor to an ObjectLine
          virtual int DistancetoPoint(int /*px*/, int /*py*/, double &/*yvalue*/, int /*bin*/ = -1) const
          { /*std::cout << "CollectionObjectStock::DistancetoPoint " << std::endl;*/ return 9999; }

          // ldata, not used here, done for compilation
          virtual void SetObjectStock( ListDataStockBase * /*ldata*/, CommonXAxis */*fcommon_xaxis_th*/, Hparam_stock_t & /*Hparam_stock*/ ) {
             /*std::cout << "ObjectLine::SetObjectStock to override or make a default " << std::endl;*/
          }
          virtual void Paint( const Option_t* ="");

          // slot, neeeded for interaction here or in Tendance ?
          virtual void ExecuteEvent(Int_t /*event*/, Int_t /*px*/, Int_t /*py*/) {}

  ClassDef ( ObjectLine, 1);
};

class ObjectLineIndicator : public ObjectLine
{
    public :
        ObjectLineIndicator() : ObjectLine() {}
        // from a user point of view, name is good to extend base
        // here assign directly the name, maybe better way ?? will see
        ObjectLineIndicator ( std::string name, double value );
        virtual ~ObjectLineIndicator() {}

        virtual std::vector<std::string> MakeStringForStatusBar( int px, int py ) const;

        virtual void GetExtrema( double & min, double & max ) const { min = max = GetY0();
             /*std::cout << "ObjectLineIndicator::GetExtrema " << GetY0() << std::endl;*/}

        virtual void ClearObjectStock() {
#ifdef DEBUG_OBJSTOCK
                std::cout << "ObjectLineIndicator::ClearObjectStock, do nothing " << std::endl;
#endif
        } //=0
        virtual void SetObjectStock( ListDataStockBase * /*ldata*/, CommonXAxis */*fcommon_xaxis_th*/, Hparam_stock_t & /*Hparam_stock*/ );

        // no interaction with them, cannot move it
        virtual void ExecuteEvent(Int_t /*event*/, Int_t /*px*/, Int_t /*py*/) {
#ifdef DEBUG_OBJSTOCK
                std::cout << "ObjectLineIndicator::ExecuteEvent, do nothing " << std::endl;
#endif
        }

        // except for printing name in status bar
        // but can use the base class for this...
        //virtual Int_t DistancetoPrimitive(Int_t px, Int_t py); //, TObject** obj );
        //virtual Int_t DistancetoPrimitive(Int_t px, Int_t py, AbstractObjectStock ** obj );

  ClassDef ( ObjectLineIndicator, 1 );
};

class ObjectLineTendance : public ObjectLine
{
    protected :
        double coeff_d, origin;

        double valueY0, valueY1;

        time_t ftbegin, ftend;
        int fbin_begin, fbin_end;

        void RecalcCoeff_origin ( double x0, double x1);
        virtual double GetXBorder( double y ) const;
        virtual double ExtrapolateYPad ( double ) const;

    public :
        ObjectLineTendance() : ObjectLine(), coeff_d(0.), origin(0.),
            valueY0(0.), valueY1(0.), ftbegin(0), ftend(0),fbin_begin(0),fbin_end(0) {}
        ObjectLineTendance ( TypeLine & tline, double valueX, double valueY );
        virtual ~ObjectLineTendance() {}

        void FinaliseDrawableLine( CommonXAxis *fcommon_xaxis_th );

        double  GetCoeffD() const { return coeff_d; }
        void SetCoeffD ( double & new_coeff ) { coeff_d = new_coeff; }
        double GetOrigin() const { return origin; }
        void SetOrigin ( double & x, double & y );
        // a lot called by THStock.cxx, could be in Object, in Set for instance
        //needed because ftime and fline are private, should check the order x1 < x2
        time_t GetTimeBegin() const {return ftbegin;}
        time_t GetTimeEnd()   const {return ftend;}
        Int_t GetBinBegin()   const {return fbin_begin;}
        Int_t GetBinEnd()     const {return fbin_end;}

        void SetTimeT0 ( time_t begin ) { ftbegin = begin; }
        void SetTimeT1 ( time_t end )   { ftend = end; }
        virtual void SetTimes ( time_t begin, time_t end ) { ftbegin = begin; ftend = end; }
        void SetBinBegin( Int_t bin_x0 ) { fbin_begin = bin_x0; }
        void SetBinEnd  ( Int_t bin_x1 ) { fbin_end   = bin_x1; }
        void SetBins ( Int_t bin_x0, Int_t bin_x1 ) { fbin_begin = bin_x0; fbin_end = bin_x1; }
        void SetInitValuesY() { valueY0 = fline->GetY1(); valueY1 = fline->GetY2(); }

        // used only when creating the line, was used in TCreateObject only at this time
        // and when MoveObjectStock is called, maybe public ?? not if Factory
        void InitCoeff_origin( double x0, double x1, double y0, double y1 );

        // Should provide simple function, for moving

        virtual std::vector<std::string> MakeStringForStatusBar( int px, int py ) const;
        virtual void ClearObjectStock() {
#ifdef DEBUG_OBJSTOCK
                std::cout << "ObjectLineTendance::ClearObjectStock" << std::endl;
#endif
        }
        virtual void SetObjectStock( ListDataStockBase * /*ldata*/, CommonXAxis */*fcommon_xaxis_th*/, Hparam_stock_t & /*Hparam_stock*/ );
        void virtual Paint( const Option_t* ="");

        // here want interaction with the line, only class to be drawable, movable
        virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
        virtual void MoveObjectLine( bool kdir ); //, kModeMove kmove );

  ClassDef ( ObjectLineTendance, 1 );
};

#endif //_OBJECTLINE_H_