Shamusworld >> Repos - architektonas/blob - src/arc.cpp

   1 // arc.cpp: Arc object
   2 //
   3 // Part of the Architektonas Project
   4 // (C) 2011 Underground Software
   5 // See the README and GPLv3 files for licensing and warranty information
   6 //
   7 // JLH = James Hammons <jlhamm@acm.org>
   8 //
   9 // WHO  WHEN        WHAT
  10 // ---  ----------  ------------------------------------------------------------
  11 // JLH  03/30/2011  Created this file
  12 // JLH  04/03/2011  Added information panel (angles) rendering
  13 // JLH  08/16/2013  Added continuous user feedack like for Line and Circle
  14 //
  15
  16 #include "arc.h"
  17
  18 #include <QtGui>
  19 #include "geometry.h"
  20 #include "mathconstants.h"
  21 #include "painter.h"
  22
  23
  24 Arc::Arc(Vector p1, double r, double a1, double a2, Object * p/*= NULL*/):
  25         Object(p1, p), /*type(OTArc),*/ radius(r), startAngle(a1), angleSpan(a2),
  26         draggingCenter(false), draggingEdge(false), draggingRotate(false),
  27         draggingSpan(false),
  28         hitCenter(false), hitArc(false), hitRotate(false), hitSpan(false)
  29 {
  30         // This is in the base class, why can't we use the contructor to fill it???
  31         type = OTArc;
  32         state = OSInactive;
  33 }
  34
  35
  36 Arc::~Arc()
  37 {
  38 }
  39
  40
  41 /*virtual*/ void Arc::Draw(Painter * painter)
  42 {
  43         QPen pen;
  44         painter->SetPen(QPen(Qt::red, 2.0, Qt::DotLine));
  45
  46         Point p1(cos(startAngle), sin(startAngle));
  47         Point p2(cos(startAngle + angleSpan), sin(startAngle + angleSpan));
  48         Vector handle2 = (p1 * radius) + position;
  49         Vector handle3 = (p2 * radius) + position;
  50
  51         if ((state == OSSelected) || ((state == OSInactive) && hitRotate))
  52                 painter->DrawHandle(handle2);
  53
  54         if ((state == OSSelected) || ((state == OSInactive) && hitSpan))
  55                 painter->DrawHandle(handle3);
  56
  57         if ((state == OSSelected) || ((state == OSInactive) && hitCenter))
  58                 painter->DrawHandle(position);
  59
  60         if ((state == OSInactive) && !hitArc)
  61                 painter->SetPen(QPen(Qt::black, 1.0, Qt::SolidLine));
  62
  63         painter->DrawArc(position, radius, startAngle, angleSpan);
  64
  65         if (draggingRotate || draggingSpan)
  66         {
  67                 if (draggingRotate)
  68                 {
  69                         // If we rotating, we draw a guideline showing the angle we're
  70                         // moving it from.
  71                         Point p3(cos(oldAngle), sin(oldAngle));
  72                         Vector oldLine = (p3 * (radius * 1.25)) + position;
  73                         pen = QPen(QColor(0x80, 0x80, 0x80), 1.0, Qt::DashLine);
  74                         painter->SetPen(pen);
  75 //                      painter->DrawLine((int)position.x, (int)position.y, (int)oldLine.x, (int)oldLine.y);
  76                         painter->DrawLine(position, oldLine);
  77                 }
  78
  79                 // In rotating and setting the span, we draw a line showing where
  80                 // we angle/span is that we're setting.
  81                 pen = QPen(QColor(0x00, 0xC0, 0x80), 1.0, Qt::DashLine);
  82                 painter->SetPen(pen);
  83                 painter->DrawLine((int)position.x, (int)position.y, (int)oldPoint.x, (int)oldPoint.y);
  84         }
  85
  86         // If we're rotating or setting the span, draw an information panel
  87         // showing both absolute and relative angles being set.
  88         if (draggingRotate || draggingSpan || draggingEdge)
  89         {
  90                 double absAngle = (Vector(oldPoint - position).Angle()) * RADIANS_TO_DEGREES;
  91                 double relAngle = (startAngle >= oldAngle ? startAngle - oldAngle :
  92                         startAngle - oldAngle + (2.0 * PI)) * RADIANS_TO_DEGREES;
  93
  94                 QString text;
  95
  96                 if (draggingRotate)
  97                 {
  98                         text = QObject::tr("Abs ") + QChar(0x2221) + ": %1" + QChar(0x00B0)
  99                                 + QObject::tr("\nRel ") + QChar(0x2221) + ": %2" + QChar(0x00B0);
 100                         text = text.arg(absAngle, 0, 'd', 4).arg(relAngle, 0, 'd', 4);
 101                 }
 102                 else if (draggingSpan)
 103                 {
 104                         text = QObject::tr("Abs ") + QChar(0x2221) + ": %1" + QChar(0x00B0)
 105                                 + QObject::tr("\nSpan: %2") + QChar(0x00B0);
 106                         text = text.arg(absAngle, 0, 'd', 4).arg(angleSpan * RADIANS_TO_DEGREES, 0, 'd', 4);
 107                 }
 108                 else if (draggingEdge)
 109                 {
 110                         text = QObject::tr("Radius: %1\nScale: %2%");
 111                         text = text.arg(radius, 0, 'd', 4).arg(radius / oldRadius * 100.0, 0, 'd', 0);
 112                 }
 113
 114 #if 0
 115                 pen = QPen(QColor(0x00, 0xFF, 0x00), 1.0, Qt::SolidLine);
 116                 painter->SetPen(pen);
 117                 painter->SetBrush(QBrush(QColor(0x40, 0xFF, 0x40, 0x9F)));
 118                 QRectF textRect(10.0, 10.0, 270.0, 70.0);       // x, y, w, h
 119                 painter->DrawRoundedRect(textRect, 7.0, 7.0);
 120
 121                 textRect.setLeft(textRect.left() + 14);
 122                 painter->SetFont(*Object::font);
 123                 pen = QPen(QColor(0x00, 0x5F, 0xDF));
 124                 painter->SetPen(pen);
 125                 painter->DrawText(textRect, Qt::AlignVCenter, text);
 126 #else
 127                 painter->DrawInformativeText(text);
 128 #endif
 129         }
 130 }
 131
 132
 133 /*virtual*/ Vector Arc::Center(void)
 134 {
 135         return position;
 136 }
 137
 138
 139 /*
 140  We need at least *four* handles for this object:
 141  - one for moving
 142  - one for resizing
 143  - one for rotation
 144  - one for setting the span of the arc
 145
 146 We need to think about the intuitive way (if there is any) to grab and
 147 manipulate a complex object like this... Need to think, "What should happen when
 148 I click here and drag there?"
 149
 150 Also: should put the snap logic into the Object base class (as a static method)...
 151 */
 152
 153 /*virtual*/ bool Arc::Collided(Vector point)
 154 {
 155         // Someone told us to fuck off, so we'll fuck off. :-)
 156         if (ignoreClicks)
 157                 return false;
 158
 159         objectWasDragged = false;
 160         bool hitSomething = HitTest(point);
 161         draggingCenter = hitCenter;
 162         draggingEdge   = hitArc;
 163         draggingRotate = hitRotate;
 164         draggingSpan   = hitSpan;
 165
 166         // Now that we've done our hit testing on the non-snapped point, snap it if
 167         // necessary...
 168         if (snapToGrid)
 169                 point = SnapPointToGrid(point);
 170
 171         if (snapPointIsValid)
 172                 point = snapPoint;
 173
 174 /*
 175 State Management:
 176 We want the arc to go into OSSelected mode if we click on it but don't drag.
 177 If we don't click anywhere on the arc, then we want it to go into OSInactive mode.
 178 Otherwise, we hit a handle and we want to modify the object whether it's in
 179 OSSelected mode or not.
 180
 181 If I, go to S. Can drag, but only handles 2, 3, & 4 (since the center is not highlighted
 182 until we select it.
 183         However, if dragging, revert to I once finished.
 184
 185 If S, stay in S. Can drag all.
 186
 187 So, we know this. If wasDragged is true, then there's a chance we need to revert to I.
 188 How can we be sure?
 189
 190 So. We have a matrix that looks like this:
 191
 192         |Was I|Was S
 193 --------+-----+-----
 194 Inactive|     |
 195 --------+-----+-----
 196 Selected|     |
 197
 198         |h1|h2|h3|h4
 199 --------+--+--+--+--
 200 Inactive|  |  |  |
 201 --------+--+--+--+--
 202 Selected|  |  |  |
 203
 204 so let's do like this:
 205 */
 206         if (hitSomething)
 207         {
 208                 oldState = state;
 209                 state = OSSelected;
 210 //              oldPoint = point;
 211                 oldPoint = position;
 212                 oldAngle = startAngle;
 213                 oldRadius = radius;
 214                 return true;
 215         }
 216
 217         state = OSInactive;
 218         return false;
 219 }
 220
 221
 222 /*virtual*/ bool Arc::PointerMoved(Vector point)
 223 {
 224 // one other thing to check here for is if a modifier key is being held as well,
 225 // to allow for multi-selection
 226         if (selectionInProgress)
 227         {
 228                 // Check for whether or not the rect contains this circle
 229 //              if (selection.normalized().contains(Extents()))
 230                 if (selection.contains(Extents()))
 231                         state = OSSelected;
 232                 else
 233                         state = OSInactive;
 234
 235                 return false;
 236         }
 237
 238         // The TLC will send these messages if the object is selected but not clicked on.
 239         // So we have to be careful with our assumptions here.
 240         // This is actually untrue in that case, we need to come up with something better
 241         // here...
 242 //      objectWasDragged = true;
 243 //      needUpdate = false;
 244         SaveHitState();
 245         bool hovered = HitTest(point);
 246         needUpdate = HitStateChanged();
 247
 248         if (snapToGrid)
 249                 point = SnapPointToGrid(point);
 250
 251         if (snapPointIsValid)
 252                 point = snapPoint;
 253
 254         objectWasDragged = (draggingCenter | draggingEdge | draggingRotate | draggingSpan);
 255
 256         if (objectWasDragged)
 257                 needUpdate = true;
 258 //      if (!(hitHandle1 || hitHandle2 || hitHandle3 || hitHandle4))
 259 //              return;
 260
 261 //      Vector delta = point - oldPoint;
 262
 263         if (draggingCenter)
 264                 position = point;
 265         else if (draggingEdge)
 266                 radius = Vector::Magnitude(point, position);
 267         else if (draggingRotate)
 268         {
 269                 startAngle = Vector(point - position).Angle();
 270         }
 271         else if (draggingSpan)
 272         {
 273                 double angle = Vector(point - position).Angle();
 274
 275                 if (angle < startAngle)
 276                         angle += 2.0 * PI;
 277
 278                 angleSpan = angle - startAngle;
 279         }
 280
 281         // Why save this? For rendering code?
 282         oldPoint = point;
 283 //      needUpdate = true;
 284         return hovered;
 285 }
 286
 287
 288 /*virtual*/ void Arc::PointerReleased(void)
 289 {
 290         // Mouse went up, so our dragging is done (if any *was* done, that is)
 291 //      hitHandle1 = hitHandle2 = hitHandle3 = hitHandle4 = false;
 292         draggingCenter = draggingEdge = draggingRotate = draggingSpan = false;
 293         hitCenter = hitArc = hitRotate = hitSpan = false;
 294
 295         // If the object was dragged, then revert to the old state.
 296         // Otherwise, we were probably just clicked, and want to stay in the selected state.
 297         if (objectWasDragged)
 298                 state = oldState;
 299 }
 300
 301
 302 /*virtual*/ bool Arc::HitTest(Point point)
 303 {
 304         hitCenter = hitArc = hitRotate = hitSpan = false;
 305
 306 /*
 307 What we have:
 308 the center of the arc
 309 the starting angle
 310 the span of the arc
 311 The point on a unit circle given an angle a is x = cos(a), y = sin(a)
 312 This vector is already unitized, so all we need to do to get our point is to
 313 multiply it by radius (to get the length correct) and add it to the center
 314 point (to get the correct position).
 315 */
 316 //      Vector v1(point, position);     // Head minus tail (vector points at "point")
 317         Vector v1(position, point);     // Head minus tail (vector points at "point")
 318         Point p1(cos(startAngle), sin(startAngle));
 319         Point p2(cos(startAngle + angleSpan), sin(startAngle + angleSpan));
 320         Vector handle2 = (p1 * radius) + position;
 321         Vector handle3 = (p2 * radius) + position;
 322         double pointerAngle = v1.Angle();
 323         double length = v1.Magnitude();
 324
 325 #if 0
 326         if (v1.Magnitude() < 10.0)
 327                 hitCenter = true;
 328         else if (Vector(handle3 - point).Magnitude() < 10.0)
 329                 hitSpan = true;
 330         else if (Vector(handle2 - point).Magnitude() < 10.0)
 331                 hitRotate = true;
 332         else if ((v1.Magnitude() < radius + 3.0) && (v1.Magnitude() > radius - 3.0)
 333                 && AngleInArcSpan(pointerAngle))
 334                 hitArc = true;
 335 #else
 336         if ((length * Painter::zoom) < 8.0)
 337         {
 338                 hitCenter = true;
 339                 snapPoint = position;
 340                 snapPointIsValid = true;
 341         }
 342         else if (((fabs(length - radius) * Painter::zoom) < 2.0)
 343                 && AngleInArcSpan(pointerAngle))
 344                 hitArc = true;
 345         else if ((Vector::Magnitude(handle2, point) * Painter::zoom) < 8.0)
 346         {
 347                 hitRotate = true;
 348                 snapPoint = handle2;
 349                 snapPointIsValid = true;
 350         }
 351         else if ((Vector::Magnitude(handle3, point) * Painter::zoom) < 8.0)
 352         {
 353                 hitSpan = true;
 354                 snapPoint = handle3;
 355                 snapPointIsValid = true;
 356         }
 357 #endif
 358
 359         return (hitCenter || hitArc || hitRotate || hitSpan ? true : false);
 360 }
 361
 362
 363 /*virtual*/ QRectF Arc::Extents(void)
 364 {
 365         double start = startAngle;
 366         double end = start + angleSpan;
 367         QPointF p1(cos(start), sin(start));
 368         QPointF p2(cos(end), sin(end));
 369         QRectF bounds(p1, p2);
 370
 371         // Swap X/Y coordinates if they're backwards...
 372         if (bounds.left() > bounds.right())
 373         {
 374                 double temp = bounds.left();
 375                 bounds.setLeft(bounds.right());
 376                 bounds.setRight(temp);
 377         }
 378
 379         if (bounds.bottom() > bounds.top())
 380         {
 381                 double temp = bounds.bottom();
 382                 bounds.setBottom(bounds.top());
 383                 bounds.setTop(temp);
 384         }
 385
 386         // If the end of the arc is before the beginning, add 360 degrees to it
 387         if (end < start)
 388                 end += 2.0 * PI;
 389
 390         // Adjust the bounds depending on which axes are crossed
 391         if ((start < PI_OVER_2) && (end > PI_OVER_2))
 392                 bounds.setTop(1.0);
 393
 394         if ((start < PI) && (end > PI))
 395                 bounds.setLeft(-1.0);
 396
 397         if ((start < (PI + PI_OVER_2)) && (end > (PI + PI_OVER_2)))
 398                 bounds.setBottom(-1.0);
 399
 400         if ((start < (2.0 * PI)) && (end > (2.0 * PI)))
 401                 bounds.setRight(1.0);
 402
 403         if ((start < ((2.0 * PI) + PI_OVER_2)) && (end > ((2.0 * PI) + PI_OVER_2)))
 404                 bounds.setTop(1.0);
 405
 406         if ((start < (3.0 * PI)) && (end > (3.0 * PI)))
 407                 bounds.setLeft(-1.0);
 408
 409         if ((start < ((3.0 * PI) + PI_OVER_2)) && (end > ((3.0 * PI) + PI_OVER_2)))
 410                 bounds.setBottom(-1.0);
 411
 412         bounds.setTopLeft(QPointF(bounds.left() * radius, bounds.top() * radius));
 413         bounds.setBottomRight(QPointF(bounds.right() * radius, bounds.bottom() * radius));
 414         bounds.translate(position.x, position.y);
 415         return bounds;
 416 }
 417
 418
 419 /*
 420 start = 350, span = 20, end = 10, angle = 5
 421 angle < start, so angle = 365
 422 */
 423 bool Arc::AngleInArcSpan(double angle)
 424 {
 425         // This should be simple except for a small complication: The start angle plus
 426         // the angle span can end up being less than the start angle! So, to check
 427         // for this possibility, we check to see if the angle passed in is less than
 428         // the start angle and if so, add 2PI to the angle passed in. Then we take the
 429         // difference between our start angle and this adjusted angle and see if it
 430         // falls within our span.
 431         if (angle < startAngle)
 432                 angle += 2.0 * PI;
 433
 434         double passedInSpan = angle - startAngle;
 435
 436         return (passedInSpan <= angleSpan ?  true : false);
 437 }
 438
 439
 440 void Arc::SaveHitState(void)
 441 {
 442         oldHitCenter = hitCenter;
 443         oldHitArc    = hitArc;
 444         oldHitRotate = hitRotate;
 445         oldHitSpan   = hitSpan;
 446 }
 447
 448
 449 bool Arc::HitStateChanged(void)
 450 {
 451         if ((hitCenter != oldHitCenter)
 452                 || (hitArc != oldHitArc)
 453                 || (hitRotate != oldHitRotate)
 454                 || (hitSpan != oldHitSpan))
 455                 return true;
 456
 457         return false;
 458 }
 459
 460
 461 /*virtual*/ void Arc::Enumerate(FILE * file)
 462 {
 463         fprintf(file, "ARC %i (%lf,%lf) %lf, %lf, %lf\n", layer, position.x, position.y, radius, startAngle, angleSpan);
 464 }
 465
 466
 467 /*virtual*/ Object * Arc::Copy(void)
 468 {
 469 #warning "!!! This doesn't take care of attached Dimensions !!!"
 470 /*
 471 This is a real problem. While having a pointer in the Dimension to this line's points
 472 is fast & easy, it creates a huge problem when trying to replicate an object like this.
 473
 474 Maybe a way to fix that then, is to have reference numbers instead of pointers. That
 475 way, if you copy them, ... you might still have problems. Because you can't be sure if
 476 a copy will be persistant or not, you then *definitely* do not want them to have the
 477 same reference number.
 478 */
 479         return new Arc(position, radius, startAngle, angleSpan, parent);
 480 }
 481
 482
 483 /*virtual*/ void Arc::Rotate(Point point, double angle)
 484 {
 485         Point c1 = Geometry::RotatePointAroundPoint(position, point, angle);
 486         Point ap1(cos(startAngle), sin(startAngle));
 487         Point angleStartPoint = (ap1 * radius) + position;
 488         Point c2 = Geometry::RotatePointAroundPoint(angleStartPoint, point, angle);
 489
 490         position = c1;
 491         startAngle = Vector(c1, c2).Angle();
 492 }
 493
 494
 495 /*virtual*/ void Arc::Mirror(Point p1, Point p2)
 496 {
 497         Point c1 = Geometry::MirrorPointAroundLine(position, p1, p2);
 498         Point ap1(cos(startAngle + angleSpan), sin(startAngle + angleSpan));
 499         Point angleEndPoint = (ap1 * radius) + position;
 500         Point c2 = Geometry::MirrorPointAroundLine(angleEndPoint, p1, p2);
 501
 502         position = c1;
 503         startAngle = Vector(c2, c1).Angle();
 504 }
 505
 506
 507 /*virtual*/ void Arc::Save(void)
 508 {
 509         Object::Save();
 510         oldRadius2 = radius;
 511         oldStartAngle = startAngle;
 512         oldAngleSpan = angleSpan;
 513 }
 514
 515
 516 /*virtual*/ void Arc::Restore(void)
 517 {
 518         Object::Restore();
 519         radius = oldRadius2;
 520         startAngle = oldStartAngle;
 521         angleSpan = oldAngleSpan;
 522 }
 523