~vbursian/research-assistant/intervers

////////////////////////////////////////////////////////////////////////////////

/*! @file Marks.cpp   Базовые классы разметки.

- Part of RANet - Research Assistant Net Library (based on ANSI C++).

- Copyright(C) 2000-2015, Viktor E. Bursian, St.Petersburg, Russia.

                          Viktor_dot_Bursian_at_mail_dot_ioffe_dot_ru

*///////////////////////////////////////////////////////////////////////////////

#include "Marks.h"

#include "Symbols.h"

#include "Log.h"

//#include "Excepts.h"

//#include <math.h>

//#include <limits>

namespace RA {

//------------------------------------------------------------------------------

//-------------------------------------------------------------------- sMark ---

sMark::sMark  (std::istream & a_stream ,rcsVersion  version)

    :sStorable(a_stream,version)

    ,sGraphObject(a_stream,version)

{

}

void  sMark::Store (std::ostream & a_stream) const

{

  sGraphObject::Store(a_stream);

}

//------------------------------------------------------------ sPositionMark ---

sPositionMark::sPositionMark  (std::istream & a_stream ,rcsVersion  version)

    :sStorable(a_stream,version)

    ,sPhysValueNode(a_stream,version)

    ,sMark(a_stream,version)

{

  if( version < sVersion(1,1) ){

    int Mode;

    a_stream.READ_INTO(Mode);

  }

}

void  sPositionMark::Store (std::ostream & a_stream) const

{

  sPhysValueNode::Store(a_stream);

  sMark::Store(a_stream);

}

void  sPositionMark::SetAppearance (psAppearance  appearance)

{

  QMutexLocker                BodyLocker(&BodyMutex);

  sMark::SetAppearance(appearance);

  MarkAsEdited();

}

sString  sPositionMark::Text (eTextFormat        F

                             ,eTextDetalization  D)

{

  sString                     T;

  if( F == HTML ){

    T = Symbol::MarkIcon;

    if( psLineAppearance  A = dynamic_cast<psLineAppearance>(TheAppearance) ){

      T = sString("<font color=") + A->LineColor.HexARGB() + ">"

          + T

          + "</font>";

    };

  };

  return T + sPhysValueNode::Text(F,D);

}

void  sPositionMark::CopyFrom (psNode  other)

{

  sPhysValueNode::CopyFrom(other);

  psPositionMark              Other = dynamic_cast<psPositionMark>(other);

  if( Other ){

    //!@todo{Net} Копирование Appearance

//    if( Appearance ){

//      delete Appearance;  Appearance = NULL;

//    }

//    if( Other->Appearance )

//      Appearance = Other->Appearance->Replica();

    MarkAsEdited();

  }

}

//-------------------------------------------------- sPositionMarkAppearance ---

sPositionMarkAppearance::~sPositionMarkAppearance ()

{

}

sPositionMarkAppearance::sPositionMarkAppearance ()

    :sAppearance()

    ,sLineAppearance()

    ,Mode(cInfiniteLine)

    ,MarkLength(10)

{

}

sPositionMarkAppearance::sPositionMarkAppearance (std::istream &  a_stream

                                                 ,rcsVersion      version)

    :sAppearance(a_stream,version)

    ,sLineAppearance(a_stream,version)

{

  a_stream.READ_INTO(Mode);

  a_stream.READ_INTO(MarkLength);

}

void  sPositionMarkAppearance::Store (std::ostream &  a_stream) const

{

  sLineAppearance::Store(a_stream);

  a_stream.WRITE_FROM(Mode);

  a_stream.WRITE_FROM(MarkLength);

}

//------------------------------------------------------------------- sXMark ---

sXMark::sXMark  (std::istream & a_stream ,rcsVersion  version)

    :sPositionMark(a_stream,version)

{

}

void  sXMark::Store (std::ostream &  a_stream) const

{

  sPositionMark::Store(a_stream);

}

sBoundaries  sXMark::Boundaries ()

{

  sBoundaries                 B (sPhysRange((sPhysValue)(*this)

                                           ,(sPhysValue)(*this))

                                ,sPhysRange(real_nan,real_nan,_Unitsless_)

                                );

//  RANet::Log.Put(sLog::Debug,"Graph"

//      ,sString("sXMark::Boundaries: ")+B.X.From().Text()+" "+B.X.To().Text());

  return B;

}

int  sXMark::Distance (rcsIntPoint  position

                      ,rcsScales    scales  )

{

  try{

    return std::abs( position.X - scales.X.T((sPhysValue)(*this)) );

  }catch(rxRAlgebra){

    return std::numeric_limits<int>::max();

  }

}

//------------------------------------------------------------------- sYMark ---

sYMark::sYMark  (std::istream & a_stream ,rcsVersion  version)

    :sPositionMark(a_stream,version)

{

}

void  sYMark::Store (std::ostream & a_stream) const

{

  sPositionMark::Store(a_stream);

}

sBoundaries  sYMark::Boundaries ()

{

  sBoundaries                 B (sPhysRange(real_nan,real_nan,_Unitsless_)

                                ,sPhysRange((sPhysValue)(*this)

                                           ,(sPhysValue)(*this))

                                );

//  RANet::Log.Put(sLog::Debug,"Graph"

//      ,sString("sYMark::Boundaries: ")+B.Y.From().Text()+" "+B.Y.To().Text());

  return B;

}

int  sYMark::Distance (rcsIntPoint  position

                      ,rcsScales    scales  )

{

  try{

    return std::abs( position.Y - scales.Y.T((sPhysValue)(*this)) );

  }catch(rxRAlgebra){

    return std::numeric_limits<int>::max();

  }

}

/*

//------------------------------------------------------------------------------

sIntervalMark::sIntervalMark (real AFrom ,real ATo)

    :FFrom(AFrom),FTo(ATo)

{

};

sIntervalMark::sIntervalMark  (std::istream & S)

    :sMark(S)

{

  S.READ_INTO(FFrom);

  S.READ_INTO(FTo);

};

void  sIntervalMark::Store (std::ostream & S) const

{

  sMark::Store(S);

  S.WRITE_FROM(FFrom);

  S.WRITE_FROM(FTo);

};

void  sIntervalMark::AssignIntrinsicContent (sNode::sPtr   NP)

{

  sMark::AssignIntrinsicContent(NP);

  if( NP->OwnType() <= sIntervalMark::Type ){

    //! @todo{Undo} sNetUndoAssignValue2nInt(sPtr(this),Value)

    FFrom=rsIntervalMark(*NP).FFrom;

    FTo=rsIntervalMark(*NP).FTo;

  };

};

sString  sIntervalMark::Text ()

{

  sLongString                 T;

  T=sLongString(AnsiString(FFrom).c_str());

  T+=" .. ";

  T+=sLongString(AnsiString(FTo).c_str());

  return T;

};

//------------------------------------------------------------------------------

sNode::sPtr  sXIntervalMark::Copy () const

{

  psXIntervalMark           NewNode = new sXIntervalMark(From(),To());

  return sPtr(NewNode);

};

sBoundaries  sXIntervalMark::Boundaries ()

{

  sBoundaries                 B ( sPhysRange(From(),To()) ,sPhysRange() );

  return B;

};

int  sXIntervalMark::Distance (sPoint P

                              ,real XPixelValue

                              ,real //YPixelValue

                              )

{

  if( P.X < From() ){

    return floor((From()-P.X)/XPixelValue+0.5);

  }else if( P.X > To() ){

    return floor((P.X-To())/XPixelValue+0.5);

  }else{

    return 0;

  };

};

//------------------------------------------------------------------------------

sNode::sPtr  sYIntervalMark::Copy () const

{

  psYIntervalMark           NewNode = new sYIntervalMark(From(),To());

  return sPtr(NewNode);

};

sBoundaries  sYIntervalMark::Boundaries ()

{

  sBoundaries                 B ( sPhysRange() ,sPhysRange(From(),To()) );

  return B;

};

int  sYIntervalMark::Distance (sPoint P

                              ,real //XPixelValue

                              ,real YPixelValue

                              )

{

  if( P.Y < From() ){

    return floor((From()-P.Y)/YPixelValue+0.5);

  }else if( P.Y > To() ){

    return floor((P.Y-To())/YPixelValue+0.5);

  }else{

    return 0;

  };

};

//------------------------------------------------------------------------------

sNode::sPtr  sBaselineMark::Copy () const

{

  psBaselineMark              NewNode = new sBaselineMark(From(),To());

  return sPtr(NewNode);

};

*/

//------------------------------------------------------------------------------

} //namespace RA