Added more visual feedback to Dimension type changing buttons.

diff --git a/src/dimension.cpp b/src/dimension.cpp
index 9c9e15c8dd5af0ed3824c7926775caab700c8ec8..8729b1cce27862a7842b1175dee87c1ec0f92fe9 100644 (file)
--- a/src/dimension.cpp
+++ b/src/dimension.cpp
@@ -208,6 +208,8 @@ I believe they are pixels.
        if (hitLine)
        {
                Point hp1 = (p1 + p2) / 2.0;
+               Point hp2 = (p1 + hp1) / 2.0;
+               Point hp3 = (hp1 + p2) / 2.0;
 
                if (hitFlipSwitch)
                {
@@ -218,6 +220,28 @@ I believe they are pixels.
                }
 
                painter->DrawHandle(hp1);
+               painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));
+
+               if (hitChangeSwitch1)
+               {
+                       painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+                       painter->SetBrush(QBrush(QColor(Qt::magenta)));
+                       painter->DrawArrowToLineHandle(hp2, (dimensionType == DTLinearVert ? ortho.Angle() : 0));
+                       painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+               }
+
+               painter->DrawHandle(hp2);
+               painter->SetPen(QPen(Qt::blue, 1.0 * Painter::zoom * size, Qt::SolidLine));
+
+               if (hitChangeSwitch2)
+               {
+                       painter->SetPen(QPen(Qt::magenta, 1.0, Qt::SolidLine));
+                       painter->SetBrush(QBrush(QColor(Qt::magenta)));
+                       painter->DrawArrowToLineHandle(hp3, PI_OVER_2);
+                       painter->SetPen(QPen(Qt::magenta, 2.0, Qt::DotLine));
+               }
+
+               painter->DrawHandle(hp3);
        }
 }
 
@@ -268,6 +292,28 @@ I believe they are pixels.
 //             state = OSInactive;
 //             return true;
        }
+       else if (hitChangeSwitch1)
+       {
+               // There are three cases here: aligned, horizontal, & vertical. Aligned
+               // and horizontal do the same thing, vertical goes back to linear.
+               if (dimensionType == DTLinearVert)
+                       dimensionType = DTLinear;
+               else
+                       dimensionType = DTLinearVert;
+
+               hitFlipSwitch = hitLine = false;
+       }
+       else if (hitChangeSwitch2)
+       {
+               // There are three cases here: aligned, horizontal, & vertical. Aligned
+               // and vertical do the same thing, horizontal goes back to linear.
+               if (dimensionType == DTLinearHorz)
+                       dimensionType = DTLinear;
+               else
+                       dimensionType = DTLinearHorz;
+
+               hitFlipSwitch = hitLine = false;
+       }
 
        state = OSInactive;
        return false;
@@ -370,7 +416,8 @@ about keeping track of old states...
 #endif
        Point p3(p1, point);
 
-       hitPoint1 = hitPoint2 = hitLine = hitFlipSwitch = false;
+       hitPoint1 = hitPoint2 = hitLine = hitFlipSwitch = hitChangeSwitch1
+               = hitChangeSwitch2 = false;
        Vector v1(position, point);
        Vector v2(endpoint, point);
 //     Vector lineSegment(position, endpoint);
@@ -378,7 +425,10 @@ about keeping track of old states...
 //     double t = Geometry::ParameterOfLineAndPoint(position, endpoint, point);
        double t = Geometry::ParameterOfLineAndPoint(p1, p2, point);
        double distance;
-       Point hFSPoint = Point((p1 + p2) / 2.0, point);
+       Point midpoint = (p1 + p2) / 2.0;
+       Point hFSPoint = Point(midpoint, point);
+       Point hCS1Point = Point((p1 + midpoint) / 2.0, point);
+       Point hCS2Point = Point((midpoint + p2) / 2.0, point);
 
        if (t < 0.0)
                distance = v1.Magnitude();
@@ -399,8 +449,12 @@ about keeping track of old states...
 
        if ((hFSPoint.Magnitude() * Painter::zoom) < 8.0)
                hitFlipSwitch = true;
+       else if ((hCS1Point.Magnitude() * Painter::zoom) < 8.0)
+               hitChangeSwitch1 = true;
+       else if ((hCS2Point.Magnitude() * Painter::zoom) < 8.0)
+               hitChangeSwitch2 = true;
 
-       return (hitPoint1 || hitPoint2 || hitLine || hitFlipSwitch ? true : false);
+       return (hitPoint1 || hitPoint2 || hitLine || hitFlipSwitch || hitChangeSwitch1 || hitChangeSwitch2 ? true : false);
 }
 
 
@@ -410,12 +464,17 @@ void Dimension::SaveHitState(void)
        oldHitPoint2 = hitPoint2;
        oldHitLine = hitLine;
        oldHitFlipSwitch = hitFlipSwitch;
+       oldHitChangeSwitch1 = hitChangeSwitch1;
+       oldHitChangeSwitch2 = hitChangeSwitch2;
 }
 
 
 bool Dimension::HitStateChanged(void)
 {
-       if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2) || (hitLine != oldHitLine) || (hitFlipSwitch != oldHitFlipSwitch))
+       if ((hitPoint1 != oldHitPoint1) || (hitPoint2 != oldHitPoint2)
+               || (hitLine != oldHitLine) || (hitFlipSwitch != oldHitFlipSwitch)
+               || (hitChangeSwitch1 != oldHitChangeSwitch1)
+               || (hitChangeSwitch2 != oldHitChangeSwitch2))
                return true;
 
        return false;

diff --git a/src/dimension.h b/src/dimension.h
index dfbfd1d95dc3fa978cf0781bfe4c4ccc8faa34f8..fbc2896a21735573983e69d477ae98d06f716e4d 100644 (file)
--- a/src/dimension.h
+++ b/src/dimension.h
@@ -50,7 +50,9 @@ class Dimension: public Object
                bool hitPoint2;
                bool hitLine;
                bool hitFlipSwitch;
-               bool oldHitPoint1, oldHitPoint2, oldHitLine, oldHitFlipSwitch;
+               bool hitChangeSwitch1;
+               bool hitChangeSwitch2;
+               bool oldHitPoint1, oldHitPoint2, oldHitLine, oldHitFlipSwitch, oldHitChangeSwitch1, oldHitChangeSwitch2;
        public:
                double size;                                            // Size of arrows/text in base units
 };

diff --git a/src/painter.cpp b/src/painter.cpp
index 046dd2a7d92fa0c608c1370a57c4d3d1a4700392..4213261315b7aacb66a4e9420a98061cd6f350e1 100644 (file)
--- a/src/painter.cpp
+++ b/src/painter.cpp
@@ -203,6 +203,27 @@ void Painter::DrawArrowHandle(Vector center, double angle)
 }
 
 
+// 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::DrawArrowToLineHandle(Vector center, double angle)
+{
+       DrawArrowHandle(center, angle);
+       center = CartesianToQtCoords(center);
+
+       // 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 p1 = center + (unit * 21.0);
+       Point p2 = p1 + (orthogonal * 7.0);
+       Point p3 = p1 - (orthogonal * 7.0);
+
+       painter->drawLine(p2.x, p2.y, p3.x, p3.y);
+}
+
+
 void Painter::DrawLine(int x1, int y1, int x2, int y2)
 {
        if (!painter)

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