← Back to branch summary

~vbursian/research-assistant/intervers

« back to all changes in this revision

Viewing changes to RANet/Marks.cpp

  • Committer: Viktor Bursian
  • Date: 2013-06-06 15:10:08 UTC
  • Revision ID: vbursian@gmail.com-20130606151008-6641eh62f0lgx8jt
Tags: version_0.3.0
version 0.3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
RANet/Marks.cpp
5
5
                     Viktor.Bursian@mail.ioffe.ru
6
6
*///////////////////////////////////////////////////////////////////////////////
7
7
#include "Marks.h"
 
8
#include "Symbols.h"
 
9
#include "Log.h"
8
10
//#include "Excepts.h"
9
11
//#include <math.h>
10
12
//#include <limits>
15
17
DEFINE_CLASS_TAG(sPositionMark)
16
18
DEFINE_CLASS_TAG(sXMark)
17
19
DEFINE_CLASS_TAG(sYMark)
18
 
DEFINE_CLASS_TAG(sIntervalMark)
19
 
DEFINE_CLASS_TAG(sXIntervalMark)
20
 
DEFINE_CLASS_TAG(sYIntervalMark)
21
 
DEFINE_CLASS_TAG(sBaselineMark)
22
 
 
23
 
//------------------------------------------------------------------------------
24
 
 
25
 
sString  sMark::Hint ()
26
 
{
27
 
  return Text();
28
 
};
29
 
 
30
 
//------------------------------------------------------------------------------
 
20
//DEFINE_CLASS_TAG(sIntervalMark)
 
21
//DEFINE_CLASS_TAG(sXIntervalMark)
 
22
//DEFINE_CLASS_TAG(sYIntervalMark)
 
23
//DEFINE_CLASS_TAG(sBaselineMark)
 
24
 
 
25
//-------------------------------------------------------------------- sMark ---
 
26
 
 
27
sMark::sMark  (rsObjectStream S)
 
28
    :sGraphObject(S)
 
29
{
 
30
};
 
31
 
 
32
 
 
33
void  sMark::Store (rsObjectStream S)
 
34
{
 
35
  sGraphObject::Store(S);
 
36
};
 
37
 
 
38
//------------------------------------------------------------ sPositionMark ---
31
39
 
32
40
sPositionMark::sPositionMark  (rsObjectStream S)
33
41
    :sMark(S)
 
42
    ,sPhysValueNode(S)
34
43
{
35
44
  S.READ_INTO(Mode);
36
 
  S.READ_INTO(FValue);
37
45
};
38
46
 
39
47
 
40
48
void  sPositionMark::Store (rsObjectStream S)
41
49
{
42
50
  sMark::Store(S);
 
51
  sPhysValueNode::Store(S);
43
52
  S.WRITE_FROM(Mode);
44
 
  S.WRITE_FROM(FValue);
45
53
};
46
54
 
47
55
 
48
 
void  sPositionMark::AssignIntrinsicContent (sNode::sPtr   NP)
 
56
void  sPositionMark::AssignIntrinsicContent (sNodePtr   NP)
49
57
{
50
 
  sMark::AssignIntrinsicContent(NP);
51
 
  if( NP->OwnType() <= sPositionMark::Type ){
 
58
  sPhysValueNode::AssignIntrinsicContent(NP);
 
59
  sPositionMark::sPtr         Ptr(NP);
 
60
  if( Ptr.IsCorrect() ){
52
61
    //! @todo{Undo} sNetUndoAssignValue2nInt(sPtr(this),Value)
53
62
    Mode=rsPositionMark(*NP).Mode;
54
 
    FValue=rsPositionMark(*NP).FValue;
55
 
  };
56
 
};
57
 
 
58
 
 
59
 
sString  sPositionMark::Text () const
60
 
{
61
 
  return sLongString(AnsiString(FValue).c_str());
62
 
};
63
 
 
64
 
//------------------------------------------------------------------------------
65
 
 
66
 
sNode::sPtr  sXMark::Copy () const
67
 
{
68
 
  psXMark                     NewNode = new sXMark(Value());
69
 
  return sPtr(NewNode);
 
63
  };
 
64
};
 
65
 
 
66
 
 
67
sString  sPositionMark::Text (eTextFormat        F
 
68
                           ,eTextDetalization  D) const
 
69
{
 
70
  sString                     T;
 
71
  if( F == HTML ){
 
72
    T = Symbol::MarkIcon;
 
73
//    psCurveAppearance           A = dynamic_cast<psCurveAppearance>(Appearance);
 
74
//    if( A ){
 
75
//      T = sString("<font ") + A->/*Line.*/Color.TagForHTML() + ">";
 
76
//          + T
 
77
//          + "</font>";
 
78
//    };
 
79
  };
 
80
  return T + sPhysValueNode::Text(F,D);
 
81
};
 
82
 
 
83
//------------------------------------------------------------------- sXMark ---
 
84
 
 
85
sXMark::sXMark  (rsObjectStream S)
 
86
    :sPositionMark(S)
 
87
{
 
88
};
 
89
 
 
90
 
 
91
void  sXMark::Store (rsObjectStream S)
 
92
{
 
93
  sPositionMark::Store(S);
70
94
};
71
95
 
72
96
 
73
97
sBoundaries  sXMark::Boundaries ()
74
98
{
75
 
  sBoundaries                 B ( sPhysRange(Value(),Value()) ,sPhysRange() );
 
99
  sBoundaries                 B (sPhysRange((sPhysValue)(*this)
 
100
                                           ,(sPhysValue)(*this))
 
101
                                ,sPhysRange(real_nan,real_nan,_Unitsless_)
 
102
                                );
 
103
//  RANet::Log.Put(sLog::Debug,"Graph"
 
104
//      ,sString("sXMark::Boundaries: ")+B.X.From().Text()+" "+B.X.To().Text());
76
105
  return B;
77
106
};
78
107
 
79
108
 
80
 
int  sXMark::Distance (sPoint P
81
 
                      ,real XPixelValue
82
 
                      ,real //YPixelValue
83
 
                      )
84
 
{
85
 
  return floor(fabs(P.X-Value())/XPixelValue+0.5);
86
 
};
87
 
 
88
 
//------------------------------------------------------------------------------
89
 
 
90
 
sNode::sPtr  sYMark::Copy () const
91
 
{
92
 
  psYMark                     NewNode = new sYMark(Value());
93
 
  return sPtr(NewNode);
 
109
int  sXMark::Distance (rcsIntPoint  position
 
110
                      ,rcsScales    scales  )
 
111
{
 
112
  try{
 
113
    return abs( position.X - scales.X.Tr((sPhysValue)(*this)) );
 
114
  }catch(rxRAlgebra){
 
115
    return std::numeric_limits<int>::max();
 
116
  };
 
117
};
 
118
 
 
119
//------------------------------------------------------------------- sYMark ---
 
120
 
 
121
sYMark::sYMark  (rsObjectStream S)
 
122
    :sPositionMark(S)
 
123
{
 
124
};
 
125
 
 
126
 
 
127
void  sYMark::Store (rsObjectStream S)
 
128
{
 
129
  sPositionMark::Store(S);
94
130
};
95
131
 
96
132
 
97
133
sBoundaries  sYMark::Boundaries ()
98
134
{
99
 
  sBoundaries                 B ( sPhysRange() ,sPhysRange(Value(),Value()) );
 
135
  sBoundaries                 B (sPhysRange(real_nan,real_nan,_Unitsless_)
 
136
                                ,sPhysRange((sPhysValue)(*this)
 
137
                                           ,(sPhysValue)(*this))
 
138
                                );
 
139
//  RANet::Log.Put(sLog::Debug,"Graph"
 
140
//      ,sString("sYMark::Boundaries: ")+B.Y.From().Text()+" "+B.Y.To().Text());
100
141
  return B;
101
142
};
102
143
 
103
144
 
104
 
int  sYMark::Distance (sPoint P
105
 
                      ,real //XPixelValue
106
 
                      ,real YPixelValue
107
 
                      )
 
145
int  sYMark::Distance (rcsIntPoint  position
 
146
                      ,rcsScales    scales  )
108
147
{
109
 
  return floor(fabs(P.Y-Value())/YPixelValue+0.5);
 
148
  try{
 
149
    return abs( position.Y - scales.Y.Tr((sPhysValue)(*this)) );
 
150
  }catch(rxRAlgebra){
 
151
    return std::numeric_limits<int>::max();
 
152
  };
110
153
};
111
154
 
 
155
/*
112
156
//------------------------------------------------------------------------------
113
157
 
114
158
sIntervalMark::sIntervalMark (real AFrom ,real ATo)
220
264
  return sPtr(NewNode);
221
265
};
222
266
 
 
267
*/
223
268
//------------------------------------------------------------------------------
224
269
}; //namespace RA
225
270