~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