← Back to branch summary

~vbursian/research-assistant/intervers

« back to all changes in this revision

Viewing changes to RANet/TwoDimensional.h

  • 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/TwoDimensional.h
1
 
////////////////////////////////////////////////////////////////////////////////
2
 
/*! @file TwoDimensional.h   Двумерные графические объекты.
3
 
- Part of RANet - Research Assistant Net Library (based on ANSI C++).
4
 
- Copyright(C) 2000-2010, Viktor E. Bursian, St.Petersburg, Russia.
5
 
                     Viktor.Bursian@mail.ioffe.ru
6
 
*///////////////////////////////////////////////////////////////////////////////
7
 
#ifndef TwoDimensional_H
8
 
#define TwoDimensional_H
9
 
#include "Storable.h"
10
 
#include "Color.h"
11
 
#include "PhysValue.h"
12
 
#include "Ranges.h"
13
 
namespace RA {
14
 
//------------------------------------------------------------------------------
15
 
 
16
 
ANNOUNCE_CLASS(sPoint)
17
 
ANNOUNCE_CLASS(sLineSegment)
18
 
ANNOUNCE_CLASS(sBoundaries)
19
 
 
20
 
ANNOUNCE_CLASS(sAppearance)
21
 
ANNOUNCE_CLASS(sPointAppearance)
22
 
ANNOUNCE_CLASS(sLineAppearance)
23
 
 
24
 
ANNOUNCE_ABSTRACT_CLASS(s2DVisibleObject)
25
 
 
26
 
//------------------------------------------------------------------- sPoint ---
27
 
 
28
 
class RANet_EXPORT  sPoint
29
 
{
30
 
  public:
31
 
                              sPoint ()
32
 
                                  :X(0.0),Y(0.0)
33
 
                                {};
34
 
                              sPoint (real  x ,real  y)
35
 
                                  :X(x),Y(y)
36
 
                                {};
37
 
                              sPoint (rcsPoint P)
38
 
                                  :X(P.X),Y(P.Y)
39
 
                                {};
40
 
    rsPoint                   operator = (rcsPoint P)
41
 
                                { X=P.X;  Y=P.Y; return *this; };
42
 
//    bool                      operator == (rcsPoint P)
43
 
//                                { return (X==P.X)&&(Y==P.Y); };
44
 
//    bool                      operator < (rcsPoint P)
45
 
//                                { return (X<P.X)&&(Y<P.Y); };
46
 
    rsPoint                   operator += (rcsPoint P)
47
 
                                { X+=P.X;  Y+=P.Y; return *this; };
48
 
    rsPoint                   operator -= (rcsPoint P)
49
 
                                { X-=P.X;  Y-=P.Y; return *this; };
50
 
    sPoint                    operator + (rcsPoint P)
51
 
                                { return sPoint( X+P.X , Y+P.Y ); };
52
 
    sPoint                    operator - (rcsPoint P)
53
 
                                { return sPoint( X-P.X , Y-P.Y ); };
54
 
 
55
 
  public: //fields
56
 
    real                      X;
57
 
    real                      Y;
58
 
};
59
 
 
60
 
//------------------------------------------------------------- sLineSegment ---
61
 
 
62
 
class RANet_EXPORT  sLineSegment
63
 
{
64
 
  public:
65
 
//                              sLineSegment () {};
66
 
 
67
 
  public: //fields
68
 
    sPoint                    Start;
69
 
    sPoint                    End;
70
 
};
71
 
 
72
 
//-------------------------------------------------------------- sBoundaries ---
73
 
 
74
 
class RANet_EXPORT  sBoundaries
75
 
{
76
 
  public:
77
 
                              sBoundaries ()
78
 
                                {};
79
 
                              sBoundaries (sRange x ,sRange y)
80
 
                                  :X(x),Y(y)
81
 
                                {};
82
 
                              sBoundaries (rcsBoundaries B)
83
 
                                  :X(B.X),Y(B.Y)
84
 
                                {};
85
 
    rsBoundaries              operator = (rcsBoundaries B)
86
 
                                { X=B.X; Y=B.Y; return *this; };
87
 
    bool                      operator == (rcsBoundaries B)
88
 
                                { return (X==B.X) && (Y==B.Y); };
89
 
//    rsBoundaries              operator |= (rcsBoundaries);
90
 
//    rsBoundaries              operator |= (rcsPoint);
91
 
 
92
 
  public: //fields
93
 
    sRange                    X;
94
 
    sRange                    Y;
95
 
};
96
 
 
97
 
//-------------------------------------------------------------- sAppearance ---
98
 
/*! Базовый класс для атрибутов внешнего вида узлов сети (цвета кривых и т.п.).
99
 
 
100
 
 
101
 
*/
102
 
class RANet_EXPORT  sAppearance : virtual public sStorable
103
 
{
104
 
  STORABLE(sAppearance)
105
 
  public:
106
 
                              sAppearance ();
107
 
  public: //fields
108
 
    sColor                    Color;
109
 
    bool                      Hidden;
110
 
};
111
 
 
112
 
//--------------------------------------------------------- sPointAppearance ---
113
 
 
114
 
class RANet_EXPORT  sPointAppearance : public sAppearance
115
 
{
116
 
  STORABLE(sPointAppearance)
117
 
  public:
118
 
    enum                      eStyle
119
 
                                {PointSolidCircle,PointOpenCircle};
120
 
    static const eStyle       DefaultStyle;
121
 
    static const int          DefaultSize;
122
 
  public:
123
 
                              sPointAppearance ();
124
 
  public: //fields
125
 
    int                       Size;
126
 
    eStyle                    Style;
127
 
};
128
 
 
129
 
//---------------------------------------------------------- sLineAppearance ---
130
 
 
131
 
class RANet_EXPORT  sLineAppearance : public sAppearance
132
 
{
133
 
  STORABLE(sLineAppearance)
134
 
  public:
135
 
    enum                      eStyle
136
 
                                {LineSolid,LineDotted,LineDashed};
137
 
    static const eStyle       DefaultStyle;
138
 
    static const int          DefaultThickness;
139
 
  public:
140
 
                              sLineAppearance ();
141
 
  public: //fields
142
 
    int                       Thickness;
143
 
    eStyle                    Style;
144
 
};
145
 
 
146
 
 
147
 
//--------------------------------------------------------- s2DVisibleObject ---
148
 
 
149
 
class RANet_EXPORT  s2DVisibleObject : virtual public sStorable
150
 
{
151
 
//  ADAM(s2DVisibleObject)
152
 
  ABSTRACT_STORABLE(s2DVisibleObject)
153
 
  public:
154
 
    virtual sBoundaries       Boundaries ();
155
 
    virtual int               Distance (sPoint P
156
 
                                       ,real   XPixelValue
157
 
                                       ,real   YPixelValue);
158
 
    virtual sString           Hint () =0;
159
 
    virtual void              SetColor (rcsColor);
160
 
 
161
 
  protected:
162
 
    explicit                  s2DVisibleObject ()
163
 
                                  :sAdam(),sStorable(),Appearance(NULL)
164
 
                                {};
165
 
 
166
 
  public: //fields
167
 
    psAppearance              Appearance;
168
 
};
169
 
 
170
 
//------------------------------------------------------------------------------
171
 
}; //namespace RA
172
 
#endif
173