]> Shamusworld >> Repos - architektonas/blob - src/base/rs_point.cpp
Initial import
[architektonas] / src / base / rs_point.cpp
1 /****************************************************************************
2 ** $Id: rs_point.cpp 1907 2004-09-04 19:56:42Z andrew $
3 **
4 ** Copyright (C) 2001-2003 RibbonSoft. All rights reserved.
5 **
6 ** This file is part of the qcadlib Library project.
7 **
8 ** This file may be distributed and/or modified under the terms of the
9 ** GNU General Public License version 2 as published by the Free Software
10 ** Foundation and appearing in the file LICENSE.GPL included in the
11 ** packaging of this file.
12 **
13 ** Licensees holding valid qcadlib Professional Edition licenses may use
14 ** this file in accordance with the qcadlib Commercial License
15 ** Agreement provided with the Software.
16 **
17 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
18 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19 **
20 ** See http://www.ribbonsoft.com for further details.
21 **
22 ** Contact info@ribbonsoft.com if any conditions of this licensing are
23 ** not clear to you.
24 **
25 **********************************************************************/
26
27 #include "rs_point.h"
28
29 #include "rs_graphicview.h"
30 //#include "rs_painter.h"
31 #include "paintintf.h"
32
33 /**
34  * Default constructor.
35  */
36 RS_Point::RS_Point(RS_EntityContainer * parent, const RS_PointData & d):
37         RS_AtomicEntity(parent), data(d)
38 {
39         calculateBorders();
40 }
41
42 /*virtual*/ RS_Entity * RS_Point::clone()
43 {
44         RS_Point * p = new RS_Point(*this);
45         p->initId();
46         return p;
47 }
48
49 /**     @return RS_ENTITY_POINT */
50 /*virtual*/ RS2::EntityType RS_Point::rtti() const
51 {
52         return RS2::EntityPoint;
53 }
54
55 /**
56  * @return Start point of the entity.
57  */
58 /*virtual*/ Vector RS_Point::getStartpoint() const
59 {
60         return data.pos;
61 }
62
63 /**
64  * @return End point of the entity.
65  */
66 /*virtual*/ Vector RS_Point::getEndpoint() const
67 {
68         return data.pos;
69 }
70
71 /** @return Copy of data that defines the point. */
72 RS_PointData RS_Point::getData() const
73 {
74         return data;
75 }
76
77 /** @return Position of the point */
78 Vector RS_Point::getPos()
79 {
80         return data.pos;
81 }
82
83 /** Sets a new position for this point. */
84 void RS_Point::setPos(const Vector & pos)
85 {
86         data.pos = pos;
87 }
88
89 void RS_Point::calculateBorders()
90 {
91         minV = maxV = data.pos;
92 }
93
94 VectorSolutions RS_Point::getRefPoints()
95 {
96         VectorSolutions ret(data.pos);
97         return ret;
98 }
99
100 Vector RS_Point::getNearestEndpoint(const Vector & coord, double * dist)
101 {
102         if (dist != NULL)
103                 *dist = data.pos.distanceTo(coord);
104
105         return data.pos;
106 }
107
108 Vector RS_Point::getNearestPointOnEntity(const Vector & coord,
109         bool /*onEntity*/, double * dist, RS_Entity ** entity)
110 {
111         if (dist != NULL)
112                 *dist = data.pos.distanceTo(coord);
113
114         if (entity != NULL)
115                 *entity = this;
116
117         return data.pos;
118 }
119
120 Vector RS_Point::getNearestCenter(const Vector & coord, double * dist)
121 {
122         if (dist != NULL)
123                 *dist = data.pos.distanceTo(coord);
124
125         return data.pos;
126 }
127
128 Vector RS_Point::getNearestMiddle(const Vector & coord, double * dist)
129 {
130         if (dist != NULL)
131                 *dist = data.pos.distanceTo(coord);
132
133         return data.pos;
134 }
135
136 Vector RS_Point::getNearestDist(double /*distance*/, const Vector & /*coord*/, double * dist)
137 {
138         if (dist != NULL)
139                 *dist = RS_MAXDOUBLE;
140
141         return Vector(false);
142 }
143
144 double RS_Point::getDistanceToPoint(const Vector & coord, RS_Entity ** entity,
145         RS2::ResolveLevel /*level*/, double /*solidDist*/)
146 {
147         if (entity != NULL)
148                 *entity = this;
149
150         return data.pos.distanceTo(coord);
151 }
152
153 void RS_Point::moveStartpoint(const Vector & pos)
154 {
155         data.pos = pos;
156         calculateBorders();
157 }
158
159 void RS_Point::move(Vector offset)
160 {
161         data.pos.move(offset);
162         calculateBorders();
163 }
164
165 void RS_Point::rotate(Vector center, double angle)
166 {
167         data.pos.rotate(center, angle);
168         calculateBorders();
169 }
170
171 void RS_Point::scale(Vector center, Vector factor)
172 {
173         data.pos.scale(center, factor);
174         calculateBorders();
175 }
176
177 void RS_Point::mirror(Vector axisPoint1, Vector axisPoint2)
178 {
179         data.pos.mirror(axisPoint1, axisPoint2);
180         calculateBorders();
181 }
182
183 //void RS_Point::draw(RS_Painter * painter, RS_GraphicView * view, double /*patternOffset*/)
184 void RS_Point::draw(PaintInterface * painter, RS_GraphicView * view, double /*patternOffset*/)
185 {
186         if (painter == NULL || view == NULL)
187                 return;
188
189         painter->drawPoint(view->toGui(getPos()));
190 }
191
192 /**
193  * Dumps the point's data to stdout.
194  */
195 std::ostream & operator<<(std::ostream & os, const RS_Point & p)
196 {
197     os << " Point: " << p.getData() << "\n";
198     return os;
199 }