Shamusworld >> Repos - architektonas/blob - src/base/rs_leader.cpp

   1 /****************************************************************************
   2 ** $Id: rs_leader.cpp 1938 2004-12-09 23:09:53Z 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_leader.h"
  28
  29 #include "rs_debug.h"
  30 #include "rs_line.h"
  31 #include "rs_solid.h"
  32
  33 /**
  34  * Constructor.
  35  */
  36 RS_Leader::RS_Leader(RS_EntityContainer * parent): RS_EntityContainer(parent)
  37 {
  38     empty = true;
  39 }
  40
  41 /**
  42  * Constructor.
  43  * @param d Leader data
  44  */
  45 RS_Leader::RS_Leader(RS_EntityContainer * parent, const RS_LeaderData & d):
  46         RS_EntityContainer(parent), data(d)
  47 {
  48     empty = true;
  49 }
  50
  51 /**
  52  * Destructor
  53  */
  54 RS_Leader::~RS_Leader()
  55 {
  56 }
  57
  58 /*virtual*/ RS_Entity * RS_Leader::clone()
  59 {
  60         RS_Leader * p = new RS_Leader(*this);
  61 #warning "!!! Need to deal with setAutoDelete() Qt3->Qt4 !!!"
  62 //      p->entities.setAutoDelete(entities.autoDelete());
  63         p->initId();
  64         p->detach();
  65         return p;
  66 }
  67
  68 /**     @return RS2::EntityDimLeader */
  69 /*virtual*/ RS2::EntityType RS_Leader::rtti() const
  70 {
  71         return RS2::EntityDimLeader;
  72 }
  73
  74 /**
  75  * Implementation of update. Updates the arrow.
  76  */
  77 void RS_Leader::update()
  78 {
  79         // find and delete arrow:
  80         for(RS_Entity * e=firstEntity(); e!=NULL; e=nextEntity())
  81         {
  82                 if (e->rtti() == RS2::EntitySolid)
  83                 {
  84                         removeEntity(e);
  85                         break;
  86                 }
  87         }
  88
  89         if (isUndone())
  90         {
  91                 setVisible(false);
  92                 return;
  93         }
  94
  95         RS_Entity * fe = firstEntity();
  96
  97         if (fe != NULL && fe->isAtomic())
  98         {
  99                 Vector p1 = ((RS_AtomicEntity *)fe)->getStartpoint();
 100                 Vector p2 = ((RS_AtomicEntity *)fe)->getEndpoint();
 101
 102                 // first entity must be the line which gets the arrow:
 103                 if (hasArrowHead())
 104                 {
 105                         RS_Solid * s = new RS_Solid(this, RS_SolidData());
 106                         s->shapeArrow(p1, p2.angleTo(p1), getGraphicVariableDouble("$DIMASZ", 2.5));
 107                         s->setPen(RS_Pen(RS2::FlagInvalid));
 108                         s->setLayer(NULL);
 109                         RS_EntityContainer::addEntity(s);
 110                 }
 111         }
 112 }
 113
 114 /** @return Copy of data that defines the leader. */
 115 RS_LeaderData RS_Leader::getData() const
 116 {
 117         return data;
 118 }
 119
 120 /** @return true: if this leader has an arrow at the beginning. */
 121 bool RS_Leader::hasArrowHead()
 122 {
 123         return data.arrowHead;
 124 }
 125
 126 /**
 127  * Adds a vertex from the endpoint of the last element or
 128  * sets the startpoint to the point 'v'.
 129  *
 130  * The very first vertex added is the starting point.
 131  *
 132  * @param v vertex coordinate
 133  *
 134  * @return Pointer to the entity that was addded or NULL if this
 135  *         was the first vertex added.
 136  */
 137 RS_Entity * RS_Leader::addVertex(const Vector & v)
 138 {
 139         RS_Entity * entity = NULL;
 140         static Vector last = Vector(false);
 141
 142         if (empty)
 143         {
 144                 last = v;
 145                 empty = false;
 146         }
 147         else
 148         {
 149                 // add line to the leader:
 150                 entity = new RS_Line(this, RS_LineData(last, v));
 151                 entity->setPen(RS_Pen(RS2::FlagInvalid));
 152                 entity->setLayer(NULL);
 153                 RS_EntityContainer::addEntity(entity);
 154
 155                 if (count() == 1 && hasArrowHead())
 156                         update();
 157
 158                 last = v;
 159         }
 160
 161         return entity;
 162 }
 163
 164 /**
 165  * Reimplementation of the addEntity method for a normal container.
 166  * This reimplementation deletes the given entity!
 167  *
 168  * To add entities use addVertex() instead.
 169  */
 170 void RS_Leader::addEntity(RS_Entity * entity)
 171 {
 172         RS_DEBUG->print(RS_Debug::D_WARNING, "RS_Leader::addEntity: should never be called");
 173
 174         if (entity == NULL)
 175                 return;
 176
 177         delete entity;
 178 }
 179
 180 /*virtual*/ double RS_Leader::getLength()
 181 {
 182         return -1.0;
 183 }
 184
 185 void RS_Leader::move(Vector offset)
 186 {
 187         RS_EntityContainer::move(offset);
 188         update();
 189 }
 190
 191 void RS_Leader::rotate(Vector center, double angle)
 192 {
 193         RS_EntityContainer::rotate(center, angle);
 194         update();
 195 }
 196
 197 void RS_Leader::scale(Vector center, Vector factor)
 198 {
 199         RS_EntityContainer::scale(center, factor);
 200         update();
 201 }
 202
 203 void RS_Leader::mirror(Vector axisPoint1, Vector axisPoint2)
 204 {
 205         RS_EntityContainer::mirror(axisPoint1, axisPoint2);
 206         update();
 207 }
 208
 209 void RS_Leader::stretch(Vector firstCorner, Vector secondCorner, Vector offset)
 210 {
 211         RS_EntityContainer::stretch(firstCorner, secondCorner, offset);
 212         update();
 213 }
 214
 215 /**
 216  * Dumps the leader's data to stdout.
 217  */
 218 std::ostream & operator<<(std::ostream & os, const RS_Leader & l)
 219 {
 220         os << " Leader: " << l.getData() << " {\n";
 221         os << (RS_EntityContainer &)l;
 222         os << "\n}\n";
 223
 224         return os;
 225 }