Added visual feedback to switch side handle.

diff --git a/src/dimension.cpp b/src/dimension.cpp
index 2d37eeaed366815b282f70034ce78dfb3b838281..9c9e15c8dd5af0ed3824c7926775caab700c8ec8 100644 (file)
--- a/src/dimension.cpp
+++ b/src/dimension.cpp
@@ -27,6 +27,7 @@ Dimension::Dimension(Vector p1, Vector p2, DimensionType dt/*= DTLinear*/, Objec
 {
        // We set the size to 1/4 base unit. Could be anything.
        type = OTDimension;
+//     dimensionType = DTLinearHorz;
 }
 
 
@@ -62,31 +63,71 @@ all objects move as a unified whole.
        // Draw an aligned dimension line
        Vector v(position, endpoint);
        double angle = v.Angle();
-       Vector orthogonal = Vector::Normal(position, endpoint);
+//     Vector orthogonal = Vector::Normal(position, endpoint);
        Vector unit = v.Unit();
        linePt1 = position, linePt2 = endpoint;
 
 // Horizontally aligned display
 #if 1
-       Vector /*pos = position, endp = endpoint,*/ ortho;
-       double y1;
+       Vector ortho;
+       double x1, y1, length;
 
-       if ((angle < PI_OVER_2) || (angle > PI3_OVER_2))
+       if (dimensionType == DTLinearVert)
        {
-               y1 = (position.y > endpoint.y ? position.y : endpoint.y);
-               ortho = Vector(0, 1.0);
-               angle = 0;
+               if ((angle < 0) || (angle > PI))
+       //      if ((angle < PI_OVER_2) || (angle > PI3_OVER_2))
+               {
+                       x1 = (position.x > endpoint.x ? position.x : endpoint.x);
+                       y1 = (position.y > endpoint.y ? position.y : endpoint.y);
+                       ortho = Vector(1.0, 0);
+       //              ortho = Vector(0, 1.0);
+                       angle = PI3_OVER_2;
+       //              angle = 0;
+               }
+               else
+               {
+                       x1 = (position.x > endpoint.x ? endpoint.x : position.x);
+                       y1 = (position.y > endpoint.y ? endpoint.y : position.y);
+                       ortho = Vector(-1.0, 0);
+       //              ortho = Vector(0, -1.0);
+                       angle = PI_OVER_2;
+       //              angle = PI;
+               }
+
+               linePt1.x = linePt2.x = x1;
+               length = fabs(position.y - endpoint.y);
        }
-       else
+       else if (dimensionType == DTLinearHorz)
+       {
+               if ((angle < PI_OVER_2) || (angle > PI3_OVER_2))
+               {
+                       x1 = (position.x > endpoint.x ? position.x : endpoint.x);
+                       y1 = (position.y > endpoint.y ? position.y : endpoint.y);
+                       ortho = Vector(0, 1.0);
+                       angle = 0;
+               }
+               else
+               {
+                       x1 = (position.x > endpoint.x ? endpoint.x : position.x);
+                       y1 = (position.y > endpoint.y ? endpoint.y : position.y);
+                       ortho = Vector(0, -1.0);
+                       angle = PI;
+               }
+
+               linePt1.y = linePt2.y = y1;
+               length = fabs(position.x - endpoint.x);
+       }
+       else if (dimensionType == DTLinear)
        {
-               y1 = (position.y > endpoint.y ? endpoint.y : position.y);
-               ortho = Vector(0, -1.0);
-               angle = PI;
+               angle = Vector(linePt1, linePt2).Angle();
+               ortho = Vector::Normal(linePt1, linePt2);
+               length = v.Magnitude();
        }
 
-//     pos.y = endp.y = y1;
-       linePt1.y = linePt2.y = y1;
        unit = Vector(linePt1, linePt2).Unit();
+//     angle = Vector(linePt1, linePt2).Angle();
+//     ortho = Vector::Normal(linePt1, linePt2);
+
        Point p1 = linePt1 + (ortho * 10.0 * size);
        Point p2 = linePt2 + (ortho * 10.0 * size);
        Point p3 = linePt1 + (ortho * 16.0 * size);
@@ -141,19 +182,12 @@ I believe they are pixels.
 
        // Draw length of dimension line...
        painter->SetFont(QFont("Arial", 8.0 * Painter::zoom * size));
-#if 0
-       Vector v1((p1.x - p2.x) / 2.0, (p1.y - p2.y) / 2.0);
-       Point ctr = p2 + v1;
-#else
        Point ctr = p2 + (Vector(p2, p1) / 2.0);
-#endif
 
 #if 0
        QString dimText = QString("%1\"").arg(Vector(endpoint - position).Magnitude());
 #else
        QString dimText;
-//     double length = v.Magnitude();
-       double length = fabs(position.x - endpoint.x);
 
        if (length < 12.0)
                dimText = QString("%1\"").arg(length);
@@ -171,28 +205,19 @@ I believe they are pixels.
 
        painter->DrawAngledText(ctr, angle, dimText, size);
 
-// need to make another handle drawing function in Painter, instead of this
        if (hitLine)
        {
-#if 0
-               Point p9 = ((position + endpoint) / 2.0) + (orthogonal * 14.0)
-                + (unit * 7.0);
-
-               Point p10 = p9 + (orthogonal * -7.0);
-               Point p11 = p10 + (unit * 7.0);
-               Point p12 = p11 + (orthogonal * 7.0);
-               Point p13 = p12 + (unit * -7.0);
-               painter->DrawLine(p10, p11);
-               painter->DrawLine(p11, p12);
-               painter->DrawLine(p12, p13);
-               painter->DrawLine(p13, p10);
-#else
+               Point hp1 = (p1 + p2) / 2.0;
+
                if (hitFlipSwitch)
+               {
+                       painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+                       painter->SetBrush(QBrush(QColor(Qt::magenta)));
+                       painter->DrawArrowHandle(hp1, ortho.Angle() + PI);
                        painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+               }
 
-               Point hp1 = (p1 + p2) / 2.0;
                painter->DrawHandle(hp1);
-#endif
        }
 }
 

diff --git a/src/painter.cpp b/src/painter.cpp
index 6145638c8a022080a30aab44122498ff0fcd9eb1..046dd2a7d92fa0c608c1370a57c4d3d1a4700392 100644 (file)
--- a/src/painter.cpp
+++ b/src/painter.cpp
@@ -177,6 +177,32 @@ void Painter::DrawHandle(Vector center)
 }
 
 
+// This function is for drawing object handles without regard for zoom level;
+// we don't want our object handle size to depend on the zoom level!
+void Painter::DrawArrowHandle(Vector center, double angle)
+{
+       center = CartesianToQtCoords(center);
+       QPolygonF arrow;
+
+       // Since we're drawing directly on the screen, the Y is inverted. So we use
+       // the mirror of the angle.
+       double orthoAngle = -angle + (PI / 2.0);
+       Vector orthogonal = Vector(cos(orthoAngle), sin(orthoAngle));
+       Vector unit = Vector(cos(-angle), sin(-angle));
+
+       Point p0 = center + (unit * 6.0);
+       Point p1 = center + (unit * 21.0);
+       Point p1b = center + (unit * 11.0);
+       Point p2 = p1b + (orthogonal * 5.0);
+       Point p3 = p1b - (orthogonal * 5.0);
+
+       painter->drawLine(p0.x, p0.y, p1.x, p1.y);
+       arrow << QPointF(p1.x, p1.y) << QPointF(p2.x, p2.y) << QPointF(p3.x, p3.y);
+
+       painter->drawPolygon(arrow);
+}
+
+
 void Painter::DrawLine(int x1, int y1, int x2, int y2)
 {
        if (!painter)

diff --git a/src/painter.h b/src/painter.h
index 1bc261b0eab5cbd198467e5d8e38688db3939a09..50c79a429f8747fbe73303c8d99c2f2da080f31b 100644 (file)
--- a/src/painter.h
+++ b/src/painter.h
@@ -22,6 +22,7 @@ class Painter
                void DrawArc(Vector, double, double, double);
                void DrawEllipse(Vector, double, double);
                void DrawHandle(Vector);
+               void DrawArrowHandle(Vector, double);
                void DrawLine(int, int, int, int);
                void DrawLine(Vector, Vector);
                void DrawPoint(int, int);