ObjectLine.cxx

Go to the documentation of this file.

#include <iostream>

#include <TPad.h>
// only for ObjectLine
#include <KeySymbols.h>

#include "ObjectLine.h"

#include "ListObjectStock.h"
#include "THStock.h"
#include "../CommonXAxis.h"

// for ROOT dictionary
ClassImp ( ObjectLine )
ClassImp ( ObjectLineIndicator )
ClassImp ( ObjectLineTendance )


// protected function, should be able to call constructor from another constructor
// C++ 11 possible no ??
// now much more class, specificity done by the sub-class
// can still use default ?
void ObjectLine::InitLine( double x0, double y0, double x1, double y1)
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "ObjectLine::InitLine " << std::endl;
#endif

  // first check x0<x1, need for bin and date
  // correct automatically
  if ( x0 > x1 ) {
      double t_x1 = x1;
      double t_y1 = y1;
      x1 = x0;
      x0 = t_x1;
      y1 = y0;
      y0 = t_y1;
  }
  // construct the line
  fline = new TLine ( x0, y0, x1, y1 );
  //std::cout << " x0 x1 y0, y1 " << x0 << " " << x1 << " " << y0 << " " << y1 << std::endl;
  // use as default
  fline->SetLineWidth( 2 );
  fline->SetLineColor ( 4 );
}

// maybe need a clean constructor here, used by derived class now
ObjectLine::ObjectLine() : AbstractObjectStock(), fline( nullptr )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry Constructor default Base ObjectLine " << std::endl;
#endif
}

// used by ObjectStockIndicator, fits well
ObjectLine::ObjectLine( TypeLine tline, double valuey0 ) : AbstractObjectStock()
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "ObjectLine::ObjectLine( Int_t typeline, valueY ) " << " valuey0 " << valuey0 << std::endl;
#endif

  // set the type, kSupp, kTendance..
  fTypeLine = tline;
  InitLine ( 0., valuey0, 1.0, valuey0);
}

// used ?? not sure
//should use init now
ObjectLine::ObjectLine ( double x0, double y0, double x1, double y1) : //, Int_t kMode ) :
AbstractObjectStock()
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Constructor ObjectLine with 4 arguments call InitLine " << std::endl;
#endif
  InitLine ( x0, y0, x1, y1 );
  // no use of kMode
}

// extrapolate should be Tendance, here ObjectLine only for date, bin maybe
std::vector<float> ObjectLine::GetValues(int px, int py, time_t &date ) const
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry  ObjectLine::GetValues px/py where used to move ?? px/py " << px << " " << py << std::endl;
#endif

  std::vector<float> values;
  Int_t bin;
  Int_t bin2 = -1; //need because ref not work with default ??

  // to make clear
  // bin send as reference, no use of bin, but keep existing function,
  // -1 do not look for bin2 closer (Only PStockLine)
  date = fParentTHStock->GetDateBinFromPixel( px, py, bin, bin2 );
#ifdef DEBUG_OBJSTOCK
  std::cout << "ObjectLine::GetValues, need to extrapolate " << std::endl;
  std::cout << "date " << date << " " << Utils::Time_tToString( date )<< " bin " << bin << std::endl;
#endif

  //Here want to exprapolateY
  //Float_t value_pt = (Float_t) ExtrapolateYPad ( gPad->AbsPixeltoX( px ) );
  // extrapolate should be Tendance, here ObjectLine only for date, bin maybe
  // cannot use from ObjectLine, Extrapolate need coeff_d, origin
  //double value_pt = ExtrapolateYPad ( gPad->AbsPixeltoX( px ) );
  //std::cout << "value extrapolated " << value_pt << std::endl;
  //values.push_back ( value_pt );
  values.push_back ( 0. );
  return values;
}

// ok works, but should be overriden, do not want object point to Base !
Int_t ObjectLine::DistancetoPrimitive(Int_t px, Int_t py, AbstractObjectStock** object )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "ObjectLine::DistancetoPrimitive return dist " << fline->DistancetoPrimitive( px, py ) << std::endl;
    std::cout << "fline->ClassName() " << fline->ClassName() << std::endl;
#endif

    *object = this;
    return fline->DistancetoPrimitive( px, py );
}

// Take over TLine::Paint, could make better ??, not really need to SetValues
// no need of TParam here, SetValues or individual set up should work
// or if kLine, need to set Y0,Y1, X0=0,X1=1

// very simple, all work done by thstock, could move a part ??
// here some extrapolation, easier for other, acess to bin ?? with parent
// anchor ?? with parent can call function DistancetoPoint of THStock ?? and gPad accessible from here !!
void ObjectLine::Paint( const Option_t* ) //option
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "\tObjectLine::Paint" << std::endl;
#endif
  //keep for test
  //std::cout << "X0 " << fline->GetX1() << " XtoPad " << gPad->XtoPad(fline->GetX1()) << std::endl;
  //std::cout << "X1 " << fline->GetX2() << " XtoPad " << gPad->XtoPad(fline->GetX2()) << std::endl;
  //std::cout << "Y0 " << fline->GetY1() << " XtoPad " << gPad->XtoPad(fline->GetY1()) << std::endl;
  //std::cout << "Y1 " << fline->GetY2() << " XtoPad " << gPad->XtoPad(fline->GetY2()) << std::endl;
  // X's already setup to correct in Pad coordinates from THStock::Paint
  fline->PaintLine( fline->GetX1(), fline->GetY1(),
                    fline->GetX2(), fline->GetY2() );
  // or use GetX0/X1 internal, more computation for nothing
  //fline->PaintLine( GetX0(), GetY0(), GetX1(), GetY1() );
}


// Constructor
ObjectLineIndicator::ObjectLineIndicator ( std::string name, double value ) :
    ObjectLine( TypeLine::kSupport, (double)value ) {//, name_line( name ) {
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry Constructor ObjectLineIndicator name " << name << " value " << value << std::endl;
    //std::
#endif
    name_line = name;
    // fixed here, no default for this value
    fModeLine = kLine;

    //std::cout << " Before SetY " << std::endl;
    /* crash
    SetY0( value );
    SetY1( value );
    */
    // why valueY0/Y1 certianly not here, but for Tendance
    //std::cout << " End Constructor ObjectLineIndicator " << std::endl;
}

std::vector<std::string> ObjectLineIndicator::MakeStringForStatusBar( int px, int /*py*/ ) const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry ObjectLineIndicator::MakeStringForStatusBar " << std::endl;
    std::cout << "px " << px << std::endl;
    std::cout << "NameObject " << GetNameObject() << std::endl;
    std::cout << "fParentTHStock " << fParentTHStock << std::endl;
#endif
    std::vector<std::string> vec_string;
    std::string str1;

    int bin2;
    int bin = fParentTHStock->GetBinFromPixel( px, bin2 );
#ifdef DEBUG_OBJSTOCK
    std::cout << "bin " << bin << "bin2 " << bin2 << std::endl;
#endif

    time_t date = fParentTHStock->GetDateFromBin( bin );
    vec_string.push_back( Utils::Time_tToString( date, true ) );

    str1 = GetNameObject() + " " + Utils::toString<float>( GetY0() );
    vec_string.push_back( str1 );
    return vec_string;
}

void ObjectLineIndicator::SetObjectStock( ListDataStockBase * /*ldata*/, CommonXAxis */*fcommon_xaxis_th*/, Hparam_stock_t & Hparam_stock )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "ObjectLineIndicator::SetObjectStock easy than general function " << std::endl;
    std::cout << "Hparam.xmin/xmax " << Hparam_stock.xmin << " Hparam_stock.xmax " << Hparam_stock.xmax << std::endl;
#endif
    SetX0 ( Hparam_stock.xmin );
    SetX1 ( Hparam_stock.xmax );
}


// Constructor used when manual drawing, cannot set up all data
// need to call FinalizeDrawableLine to complete
ObjectLineTendance::ObjectLineTendance( TypeLine & tline, double valueX, double valueY) :
        ObjectLine(), coeff_d ( 0. ), origin ( 0 ), valueY0(0.), valueY1(0.),
        ftbegin(0), ftend(0),fbin_begin(0),fbin_end(0)
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Const ObjectLineTendance::ObjectLineTendance( int mode_line, doubleX, doubleY ) " << std::endl;
    std::cout << "test X " << valueX << std::endl;
    std::cout << "test Y " << valueY << std::endl;
    //std::cout << "int modeline " << modeline << std::endl;
#endif
    // Set the type support/tendance
    fTypeLine = tline;
    // use kSegment for Tendance by default
    fModeLine = kSegment;

    InitLine ( valueX, valueY,  valueX, valueY );
    // set up all other member, later
    // after finishing drawing in Finalise
}

// need to recalculate in Pad axis, everytime it is paint
// reclaculated coeff_d in the axis of Pad Y is fine ( user ),
// x0/1 is modified ( can come from bin or time or Hparam_stock.xmin/max)
void ObjectLineTendance::RecalcCoeff_origin( double x0, double x1)
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "ObjectLineTendance::RecalcCoeff_origin" << std::endl;
  std::cout << "x0 " << x0 << " x1 " << x1 << std::endl;
#endif

  double y0, y1;

  // use initial values, set up when first drawn : should correspond to bin and date
  y0 = valueY0; y1 = valueY1;
  // try with normal one, not they may be overwriten by extrapolation !
  //y0 = GetY0(); //y1 = GetY1();

  //check y1 - yo sign, use Abs, no can keep negative
  coeff_d = ( y1 - y0 ) / ( x1 - x0 );
  origin = y0 - coeff_d * x0; // == y1 - coeff_d * x1

#ifdef DEBUG_OBJSTOCK
  std::cout << "y0 " << y0 << " y1 " << y1 << std::endl;
  std:: cout << " coeff origin " << coeff_d << " " << origin << std::endl;
  // just for test, origin should be equal
  std:: cout << " should be equal coeff origin " << coeff_d << " " << y1 - coeff_d * x1 << std::endl;
#endif
}

// cannot access intern data member ? to check
void ObjectLineTendance::InitCoeff_origin( double x0, double x1, double y0, double y1 )
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "ObjectLineTendance::InitCoeff_origin" << std::endl;
  //std::cout << "x0 " << x0 << " x1 " << x1 << std::endl;
#endif

  //check y1 - yo sign, use Abs
  coeff_d = ( y1 - y0 ) / ( x1 - x0 );
  origin = y0 - coeff_d * x0; // == y1 - coeff_d * x1

#ifdef DEBUG_OBJSTOCK
  std:: cout << " coeff origin " << coeff_d << " " << origin << std::endl;
#endif
  // just for test, origin should be equal
  //std:: cout << " coeff origin " << coeff_d << " " << y1 - coeff_d * x1 << std::endl;
}


double ObjectLineTendance::GetXBorder( double y ) const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "GetXBorder y " << y << std::endl;
#endif
  double x_cross;

  x_cross = ( y - origin ) / coeff_d;
  //std::cout << "ObjectLine::GetXBorder x return " << x_cross << std::endl;
  return x_cross;
}

double ObjectLineTendance::ExtrapolateYPad ( double x ) const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "ExtrapolateYPad coeff_d origin " << coeff_d << " " << origin << std::endl;
#endif
  double y_extra;
  //std::cout << "ExtrapolateYPad coeff_d origin " << coeff_d << " " << origin << std::endl;
  y_extra = coeff_d * x + origin;
  //std::cout << "ExtrapolateYPad x= " << x << " y_extra= " << y_extra << std::endl;
  return y_extra;
}

void ObjectLineTendance::FinaliseDrawableLine( CommonXAxis *fcommon_xaxis_th )
{
#ifdef DEBUG_OBJSTOCK
        std::cout << "\n\tEntry ObjectLineTendance::FinaliseDrawableLine()" << std::endl;
        std::cout << "fcommon_axis " << fcommon_xaxis_th << std::endl;
#endif


        //get closer bin / can get from obj_stock
        Int_t bin_x0 = fcommon_xaxis_th->GetXAxis()->FindBin( GetX0() );
        Int_t bin_x1 = fcommon_xaxis_th->GetXAxis()->FindBin( GetX1() );
        SetBins ( bin_x0, bin_x1 );

#ifdef DEBUG_OBJSTOCK
        std::cout << "set bins " << bin_x0 << " " << bin_x1 << std::endl;
        std::cout << "set bins ok " << std::endl;
    std::cout << "test fParentTHStock " << fParentTHStock << std::endl;
#endif

        // need to use the parent THStock here, or could use fcommon_xaxis ?
        time_t t0 = fParentTHStock->GetDateFromBin ( bin_x0 );
        //std::cout << "after GetDateFromBin " << std::endl;
        time_t t1 = fParentTHStock->GetDateFromBin ( bin_x1 );
        //Set the ObjectLine, time or bin ?? make both
        SetTimes( t0, t1 );
        //std::cout << "Set Times t0/t1 " << t0 << " " << t1 << std::endl;

        InitCoeff_origin ( GetX0(), GetX1(), GetY0(), GetY1() );

        //keep final initial data in data member, keep Yvalues after extrapolation
        // could keep the values centered in the bin, make it easier ??
        SetInitValuesY();
#ifdef DEBUG_OBJSTOCK
        std::cout << "InitValuesY Y0/Y1 " << valueY0 << " " << valueY1 << std::endl;
#endif
        // aprroximate X to middle of the bin, common for all ??
        SetX0( fcommon_xaxis_th->GetXAxis()->GetBinCenter( bin_x0 ) );
        SetX1( fcommon_xaxis_th->GetXAxis()->GetBinCenter( bin_x1 ) );
#ifdef DEBUG_OBJSTOCK
        std::cout << "new X0 X1 " << GetX0() << " " << GetX1() << std::endl;
#endif

        // Extrapolate with previous Yvalues, fine like this
        SetY0( ExtrapolateYPad( GetX0() ));
        SetY1( ExtrapolateYPad( GetX1() ));
#ifdef DEBUG_OBJSTOCK
        std::cout << "GetY0/Y1 after extrapolate " << GetY0() << " " << GetY1() << std::endl;
#endif
}

//set the origin after a rotation, assure than actual position x,y is kept
void ObjectLineTendance::SetOrigin ( double & x, double & y )
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Set origin " << x << " " << y << " " << origin << std::endl;
#endif
  origin = y - coeff_d * x;
#ifdef DEBUG_OBJSTOCK
  std::cout << "new origin " << origin << std::endl;
#endif
}

std::vector<std::string> ObjectLineTendance::MakeStringForStatusBar( int px, int py ) const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry ObjectLineTendance::MakeStringForStatusBar px/py " << std::endl;
#endif
    std::string text_str0, text_str1;
    std::vector<std::string> vec_string;

    std::vector<float> values;
    double fvalues;
    time_t date;

    if ( IsSupport() ) {
        values.push_back ( GetY0() );
        text_str0= "";
        text_str1 = "Support = " + Utils::toString(values[0]);
    } else {
#ifdef DEBUG_OBJSTOCK
        std::cout << "ObjectLineTendance::MakeStringForStatusBar, call get value to extrapolate " << std::endl;
#endif
        // values not used, only want the date from px
        values = GetValues( px, py, date );
        text_str0 = Utils::Time_tToString( date, true );
        // overwrite values
        fvalues = ExtrapolateYPad( gPad->AbsPixeltoX( px ) );
        //std::cout << "new value " << std::endl;
        text_str1 = "Tendance = "+ Utils::toString<double>(fvalues);
    }

    vec_string.push_back(text_str0);
    vec_string.push_back(text_str1);
    return vec_string;
}

// to reoptimise, to use ToPaint()
// 2 main case, Support or Tendance, but can use same logic ??
void ObjectLineTendance::SetObjectStock( ListDataStockBase * /*ldata*/, CommonXAxis *fcommon_xaxis_th, Hparam_stock_t & Hparam_stock )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry ObjectLineTendance::SetObjectStock " << std::endl;
    std::cout << "Hparam_stock.xfirst/xlast " << Hparam_stock.xfirst << " " << Hparam_stock.xlast << std::endl;
#endif

    double tmp_x;
    // not used by kLine ?? but still exists ?? to check
    int bin_x0 = GetBinBegin();
    int bin_x1 = GetBinEnd();

    // default xvalues of the reference bin in pad coordinate
    double tmp_x0 = gPad->XtoPad( fcommon_xaxis_th->GetXAxis()->GetBinCenter( bin_x0 ) );
    double tmp_x1 = gPad->XtoPad( fcommon_xaxis_th->GetXAxis()->GetBinCenter( bin_x1 ) );

    // best, always true coeff in Pad coordinate, after just need to modify X and extrapolate
    // dependent of the Pad ?? or can store it ?? to check
    RecalcCoeff_origin( tmp_x0, tmp_x1 );

    // comment for compilation test without Hparam_stock
    // introduce different cases, can generalise ?
    // kLine [-inf, +inf]
    if ( IsLine() ) {
#ifdef DEBUG_OBJSTOCK
        std::cout << "IsLine true" << std::endl;
#endif
        // all case line extends to the full pad
        SetX0 ( Hparam_stock.xmin );
        SetX1 ( Hparam_stock.xmax );

        // simpler case it is a straight horizontal line
        /*
        if ( IsSupport() ) {
            // just check if need to be printed
            //std::cout << "PaintLine because object_line->IsSupport true continue " << std::endl;
            //paint only if inside the pad, can use only y0 == y1

            // to cjheck why this test
            // original version, not sure what was GetValueY0 ??
            //if ( ( GetValueY0() > Hparam_stock.ymin) && ( GetValueY0() < Hparam_stock.ymax) )
                //Paint();
                //continue;
                // now can exit after paint
                //return;
        }
        */
        // else a compelte line
        // extrapolate the Y value to the border limit
        SetY0 ( ExtrapolateYPad ( Hparam_stock.xmin ) );
        SetY1 ( ExtrapolateYPad ( Hparam_stock.xmax ) );
    }

    else {
    //else not Line, HalfLine or Segment (Segment = 2 HalfLine), complexe but less code
    // HalfLine1 [point, inf], check position of X0, apply to Segment as well
    if ( IsHalfLine1() || IsSegment() ) {
        //std::cout << "kHalfLine1 or Segment " << std::endl;

        if ( bin_x0 < Hparam_stock.xfirst ) {
            bin_x0 = Hparam_stock.xfirst;
            // recompute tmp_x0, otherwise use default
            // could get lowedge here
            tmp_x0 = gPad->XtoPad( fcommon_xaxis_th->GetXAxis()->GetBinCenter( bin_x0 ) );
            //std::cout << "modified bin_x0 " << Hparam_stock.xfirst << " and tmp_x0 " << tmp_x0 << std::endl; // modify tmp_x0
        }
        //std::cout <<"SetX0/Y0 to "<< tmp_x0 << " " << object_line->ExtrapolateYPad ( tmp_x0 ) << std::endl;
        // SetX0 and Y0 coeff_d is correct
        SetX0 ( tmp_x0 );
        SetY0 ( ExtrapolateYPad ( tmp_x0 ) );

        // needed is HalfLine extrapolate for X1
        if ( IsHalfLine1() ) {
             //std::cout << "kHalfLine1 only" << std::endl;
             //SetX1 and Y1 for the half line
             SetX1 ( Hparam_stock.xmax );
             SetY1 ( ExtrapolateYPad ( Hparam_stock.xmax ) );

             //test bad effect
             if ( bin_x0 == Hparam_stock.xlast) {
#ifdef DEBUG_OBJSTOCK
                 std::cout << "bad effect " << std::endl;
                 // could exit here
#endif
                 //doNotDraw = true;
             }
        }
    }
    // HalfLine2 [-inf, point]
    if ( IsHalfLine2() || IsSegment() ) {
        //std::cout << "kHalfLine2 or Segment " << std::endl;
        if ( bin_x1 > Hparam_stock.xlast ) {
            bin_x1 = Hparam_stock.xlast;
            //recompute tmp_x1
            tmp_x1 = gPad->XtoPad( fcommon_xaxis_th->GetXAxis()->GetBinCenter( bin_x1 ) );
            //std::cout << "modified bin_x1 " << Hparam_stock.xlast << " and tmp_x1 " << tmp_x1 << std::endl;
        }
        //Should set X1, for both half line and segment
        //std::cout << "SetX1/Y1 to tmp_x1 " << tmp_x1 << " " << object_line->ExtrapolateYPad ( tmp_x1 ) << std::endl;
        SetX1 ( tmp_x1 );
        SetY1 ( ExtrapolateYPad ( tmp_x1 ) );
        // finalize HalfLine2
        if ( IsHalfLine2() ) {
            //SetX0 and Y0 for the half line
            SetX0 ( Hparam_stock.xmin );
            SetY0 ( ExtrapolateYPad ( Hparam_stock.xmin ) );
            //test bad effect
            if ( bin_x1 == Hparam_stock.xfirst) {
#ifdef DEBUG_OBJSTOCK
                std::cout << " bad effect kHalfLine2 " << std::endl;
                // could exit here
#endif
                //doNotDraw = true;
            }
        }
    }
    } //else not kLine, miss the indentation

    //test Y outside border, apply for all even segment
    //here group all cases, could make a function, not needed now but later..
#ifdef DEBUG_OBJSTOCK
    std::cout << "Pad Ymin/max " << Hparam_stock.ymin << " " << Hparam_stock.ymax << std::endl;
#endif
    // check Y1
    if ( ( GetY1() < Hparam_stock.ymin) || ( GetY1() > Hparam_stock.ymax) ) {
        //std::cout << "out of Y1 border !!! " << std::endl;
        //cannot been both so case
        if ( GetY1() < Hparam_stock.ymin ) {
            //Extrapolate coeff_d is good here
            tmp_x = GetXBorder ( Hparam_stock.ymin );
        } else {
            tmp_x = GetXBorder ( Hparam_stock.ymax );
        }
        //ok get correct X in Pad, apply both cases
        SetX1( tmp_x );
        SetY1( ExtrapolateYPad ( tmp_x ) );
    }
    //same for Y0
    if ( ( GetY0() < Hparam_stock.ymin) || ( GetY0() > Hparam_stock.ymax) ) {
        //std::cout << "out of Y0 border !!! " << std::endl;
        if ( GetY0() < Hparam_stock.ymin ) {
            tmp_x = GetXBorder ( Hparam_stock.ymin );
        } else {
            tmp_x = GetXBorder ( Hparam_stock.ymax );
        }
        SetX0( tmp_x );
        SetY0( ExtrapolateYPad ( tmp_x ) );
    }
}

void ObjectLineTendance::Paint( const Option_t* )
{
#ifdef DEBUG_OBJSTOCK
        std::cout << "ObjectLineTendance::Paint " << std::endl;
        //std::cout << "fline " << fline << std::endl;
        //std::cout << "GetX0/X1 " << GetX0() << " " << GetX1() << std::endl;
        //std::cout << "GetY0/Y1 " << GetY0() << " " << GetY1() << std::endl;
#endif
        // should be as simple as, ok works !
        fline->Paint();
}

void ObjectLineTendance::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
    int kMaxDiff = 20; // default 20
    // all come from TLine, static ?? memo between call
    // all memorized between call, cannot be parallelized
    static bool p1, p2, pL;
    static int d1,d2,px1,px2,py1,py2;
    static int pxold, pyold, px1old, py1old, px2old, py2old;
    int dx, dy;

#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry ObjectLineTendance::ExecuteEvent " << std::endl;
    std::cout << "pxold/pyold " << pxold << " " << pyold << std::endl;
    std::cout << "px/py " << px << " " << py << std::endl;
#endif

    switch (event) {

        // no break, so always called first when button is stayed down, then call the appropriate event
        case kButton1Down:
    #ifdef DEBUG_OBJSTOCK
            std::cout << " kButton1Down no break , setLineColor(-1) " << std::endl;
    #endif

            gVirtualX->SetLineColor(-1);
            TAttLine::Modify();  //Change line attributes only if necessary
            // No break !!! so call kMouseMotion or other just after
            // really needed ??
            break;

        // select a part of the line : extremity or full line
        // always called even if not selected
        case kMouseMotion:
    #ifdef DEBUG_OBJSTOCK
            std::cout << "kMouseMotion " << std::endl;
    #endif
            px1 = gPad->XtoAbsPixel( GetX0() );
            py1 = gPad->YtoAbsPixel( GetY0() );
            px2 = gPad->XtoAbsPixel( GetX1() );
            py2 = gPad->YtoAbsPixel( GetY1() );
            //std::cout << "px1 / py1 " << px1 << " " << py1 << std::endl;
            //default false, need because static ??
            p1 = p2 = pL = kFALSE;

            d1  = abs(px1 - px) + abs(py1-py); //simply take sum of pixels differences
            if (d1 < kMaxDiff) { //*-*================>OK take point number 1
                px1old = px1; py1old = py1;
                p1 = kTRUE;
                gPad->SetCursor(kPointer);
                return;
            }
            d2  = abs(px2 - px) + abs(py2-py); //simply take sum of pixels differences
            if (d2 < kMaxDiff) { //*-*================>OK take point number 2
                px2old = px2; py2old = py2;
                p2 = kTRUE;
                gPad->SetCursor(kPointer);
                return;
            }
            // if end point not selected, more than kMaxDiff select the full line
            //std::cout << "no end point selected, set pL true " << std::endl;
            pL = kTRUE;
            pxold = px; pyold = py;
            gPad->SetCursor(kMove);
            break;

        // move one point of the line
        case kButton1Motion:
    #ifdef DEBUG_OBJSTOCK
            std::cout << "kButton1Motion " << std::endl;
    #endif
            if (p1) {
                // same trick here ?? redraw to delete the line !!
                gVirtualX->DrawLine(px1old, py1old, px2, py2);
                gVirtualX->DrawLine(px, py, px2, py2);
                px1old = px;
                py1old = py;
            }
            if (p2) {
                gVirtualX->DrawLine(px1, py1, px2old, py2old);
                gVirtualX->DrawLine(px1, py1, px, py);
                px2old = px;
                py2old = py;
            }
            if (pL) {
                gVirtualX->DrawLine(px1, py1, px2, py2);
                dx = px-pxold;  dy = py-pyold;
                px1 += dx; py1 += dy; px2 += dx; py2 += dy;
                gVirtualX->DrawLine(px1, py1, px2, py2);
                pxold = px;
                pyold = py;
            }
            break;

        // when release button, set value
        case kButton1Up:
    #ifdef DEBUG_OBJSTOCK
        std::cout << "kButton1Up " << std::endl;
    #endif
            //??
            //if (gROOT->IsEscaped()) {
            //    gROOT->SetEscape(kFALSE);
            //    break;
            //}
            //do not make test NDC

            //need to check if moved, otherwise just for selection
            //no good, called everytime..
            if ( ( px==pxold ) && ( py=pyold ) ) {
                std::cout << "px==pxold && py==pyold what to do !!!" << std::endl;
            }
#ifdef DEBUG_OBJSTOCK
            std::cout << "p1, p2, pL " << p1 << " " << p2 << " " << pL << std::endl;
#endif

            // good to do, replace with real value, avoid gPad !!
            // could use an intermadiate, and finally set the final values

            // move line if pl  is true
            // move extremity if p1/p2 is true
            // p1/p2 use only px, could be real value
            if (p1) {
                SetX0 ( gPad->PadtoX(gPad->AbsPixeltoX(px)) );
                SetY0 ( gPad->PadtoY(gPad->AbsPixeltoY(py)) );
            }
            if (p2) {
                SetX1 ( gPad->PadtoX(gPad->AbsPixeltoX(px)) );
                SetY1 ( gPad->PadtoY(gPad->AbsPixeltoY(py)) );
            }
            // set both extremity to new values
            if (pL) {
                SetX0 ( gPad->PadtoX(gPad->AbsPixeltoX(px1)) );
                SetY0 ( gPad->PadtoY(gPad->AbsPixeltoY(py1)) );
                SetX1 ( gPad->PadtoX(gPad->AbsPixeltoX(px2)) );
                SetY1 ( gPad->PadtoY(gPad->AbsPixeltoY(py2)) );
            }

            /* test support / fibo
             if (TestBit(kVertical)) {
                 if (p1) fX2 = fX1;
             if (p2) fX1 = fX2;
             }
             if (TestBit(kHorizontal)) {
                 if (p1) fY2 = fY1;
                 if (p2) fY1 = fY2;
            }*/
            // need same, test Support/tendance
#ifdef DEBUG_OBJSTOCK
            std::cout << " IsSupport ? " <<  IsSupport() << std::endl;
#endif
            if ( IsSupport() ) {
                 if ( p1 ) SetY1( GetY0() );
                 if ( p2 ) SetY0( GetY1() );
                 // pL should be ok for support, it is ok for support
            }

            // here particular code, need to change YValues
            // need check Anchor, all done in THStock, simpler to call THStock function ??

            // specificity of LineTendance,
            // ok move the line !!
            // but do make a support a tendance !!
            // Set InitValues, will set the real value for drawing
            SetInitValuesY();

            // reset pX ?? will be reset after anyway
            // reset when kMouseMotion, strange...
            // try with setup to FALSE here
            p1 = p2 = pL = kFALSE;

            // need to check if moved, otherwise just for selection
            // last commented
            // fParentTHStock->MoveObjectLine ( this ); //can check, Anchor, set bin if different
            // std::cout << "last commented MoveObjectLine " << std::endl;

            gPad->Modified(kTRUE);
            // why this ?? not change anything
            //gVirtualX->SetLineColor(-1);
            break;

        //try with keyboard, ok use px py
        case kKeyPress:
    #ifdef DEBUG_OBJSTOCK
            std::cout << "kKeyPress " << event << " px " << px << " py " << py << std::endl;
    #endif
            Int_t key, keysym;
            //if key pressed pixel changed to key value, no access to position anymore
            key = px;
            keysym = py;
            //printf("symbol = %c (%x)\n", key, keysym);

            // can send own function to deal with all possibilites, anyway need to call THStock ?? not sure
            switch ((EKeySym)keysym) {

                // translation T
                case kKey_t:
                    EditorObjStock::SetTranslate ();
//#ifdef DEBUG_OBJSTOCK
 //                  std::cout << "set Transalation" << std::endl;
                   std::cout << "get kTranslate " << EditorObjStock::GetTranslate() << std::endl;
//#endif
                    break;
                // rotation R
                case kKey_r:
                    EditorObjStock::SetRotate ();
//#ifdef DEBUG_OBJSTOCK
//                    std::cout << "set Rotation" << std::endl;
                    std::cout << "get kRotat " << EditorObjStock::GetRotate() << std::endl;
//#endif
                    break;

                // deal with move, left rigth no used yet
                case kKey_Left:
                    std::cout<<"left arrow"<<std::endl;
                    break;
                case kKey_Right:
                    std::cout<<"rightarrow"<<std::endl;
                    break;

                case kKey_Down:
                    std::cout<<"down arrow, last commented "<<std::endl; // down sense is down, or send key to function ?? better !
                    //if ( EditorObjStock::GetTranslate() ) fParentTHStock->TranslateObjStock( this, false, "transl", pxold, pyold );
                    //if ( EditorObjStock::GetRotate()    ) fParentTHStock->TranslateObjStock( this, false, "rotat", pxold, pyold );
                    MoveObjectLine( false );
                    break;

                case kKey_Up:
                    std::cout << "up arrow, last commented " << std::endl; // up sense is true
                    //std::cout << " gettranslate " << EditorObjStock::GetTranslate () << std::endl;
                    //if ( EditorObjStock::GetTranslate() ) fParentTHStock->TranslateObjStock( this, true, "transl", pxold, pyold );
                    //if ( EditorObjStock::GetRotate() ) fParentTHStock->TranslateObjStock( this, true, "rotat", pxold, pyold );
                    // pass only the direction ( positive/negative )
                    MoveObjectLine( true );
                    break;

                case kKey_Return:
                    std::cout << "kKey_Return " << std::endl;
                    break;

                default :
    //#ifdef DEBUG_OBJSTOCK
                    std::cout << "default case unset trans and rotat" << std::endl;
    //#endif
                    //need a graphic in GUIMainFrame, how to unset automatically ??
                    //EditorObjStock::SetTranslate ( false );
                    //EditorObjStock::SetRotate ( false );
                    break;
            }
            return;

        default :
//#ifdef DEBUG_OBJSTOCK
                std::cout << "default case no event associated, nothing to do " << std::endl;
//#endif
                break;
      } //end switch

}

// new added, see later for polymorphisme,
// but here the only clas to be movable for the moment
// THStock::TranslateObjStock ( ObjectLine * obj_stock, bool sense, std::string mode, Int_t pxold, Int_t pyold )
void ObjectLineTendance::MoveObjectLine( bool kdir ) //kModeMove kmove )
{
#ifdef DEBUG_OBJSTOCK
        std::cout << "Entry ObjectLineTendance::MoveObjectLine " << std::endl;
        std::cout << "kdir " << kdir << std::endl; // " ,kmove " << kmove <<
#endif

        double new_coeff,old_coeff = 0.;

        // apply a translation, only along Y
        if ( EditorObjStock::GetTranslate() ) {
#ifdef DEBUG_OBJSTOCK
                std::cout << "mode translation " << std::endl;
#endif
                // increase positively
                if ( kdir == true ) {
                        SetY0 ( GetY0() + 5. ); SetY1 ( GetY1() + 5. );
                // negatively
                } else {
                        /*valueY0 -= 5.0; valueY1 -= 5.0;*/
                        SetY0 ( GetY0() - 5. ); SetY1 ( GetY1() - 5. );
                }

#ifdef DEBUG_OBJSTOCK
                std::cout << "new valueY0 " << valueY0 << std::endl;
                std::cout << "new valueY1 " << valueY1 << std::endl;
                std::cout << "new Y0/Y1 " << GetY0() << "/" << GetY1() << std::endl;
#endif

        // apply a rotation
        } else if ( EditorObjStock::GetRotate() ) {
#ifdef DEBUG_OBJSTOCK
                std::cout << "mode rotation " << std::endl;
#endif
                old_coeff = GetCoeffD();
#ifdef DEBUG_OBJSTOCK
                std::cout << "old_coeff " << old_coeff << std::endl;
#endif
                // increase positively
                if ( kdir == true ) {
                        new_coeff = old_coeff * 1.025;
                        //SetCoeffD ( new_coeff );

                } else {
                        new_coeff = old_coeff * 0.975;
                        //SetCoeffD ( old_coeff*0.975 );
                    //SetCoeffD ( new_coeff );

                }
                SetCoeffD ( new_coeff );
#ifdef DEBUG_OBJSTOCK
                std::cout << "new coeff " << GetCoeffD() << std::endl;
#endif
                // original call, from THStock
                /*
                //need to set origin, at which x ?? for all segment, halfline... current position is good
                obj_stock->SetOrigin( gPad->AbsPixeltoX(pxold), gPad->AbsPixeltoY(pyold) );
                //need to extrapolate Y, X not modified
                //work like this for all line, halflinem segment
                obj_stock->SetY0 ( obj_stock->ExtrapolateYPad ( GetXPadFromBin (obj_stock->GetBinBegin()) ) );
                obj_stock->SetY1 ( obj_stock->ExtrapolateYPad ( GetXPadFromBin (obj_stock->GetBinEnd  ()) ) );
                */
        }
        // any of tranlsate or rotate is set to true
#ifdef DEBUG_OBJSTOCK
        else {

                std::cout << "any transl or rotate selected " << std::endl;
        }
#endif
        // once common data have been set, finalize it
        // logic in Finalize, correct Y0/Y1 and then
        SetInitValuesY();

        // both are required for working, could be in a calling function
        gPad->Modified();
        gPad->Update();

        // could have something similar
        //Modified();
        //Update();
        // or
        //fParentTHStock->Modified();
        //fParentTHStock->Update();
}