Added Mirror tool

diff --git a/src/applicationwindow.cpp b/src/applicationwindow.cpp
index 825eb6dd30d451cf4cefd37438aa8c34d4558c37..a1fd4f1fe0c8abc12bf19a6d66e3fb964fcd4506 100644 (file)
--- a/src/applicationwindow.cpp
+++ b/src/applicationwindow.cpp
@@ -262,6 +262,11 @@ void ApplicationWindow::RotateTool(void)
 void ApplicationWindow::MirrorTool(void)
 {
        ClearUIToolStatesExcept(mirrorAct);
+
+       // Do tear-down if Rotate tool has been turned off
+       if (!mirrorAct->isChecked())
+               drawing->MirrorHandler(ToolCleanup, Point(0, 0));
+
        SetInternalToolStates();
 }
 

diff --git a/src/drawingview.cpp b/src/drawingview.cpp
index 7b493234ce2550531f7986e744d2115b599cf042..fff56da8ef77bbd2e78a0f28a0278d82339fad4e 100644 (file)
--- a/src/drawingview.cpp
+++ b/src/drawingview.cpp
@@ -585,6 +585,8 @@ void DrawingView::ToolHandler(int mode, Point p)
                ArcHandler(mode, p);
        else if (Global::tool == TTRotate)
                RotateHandler(mode, p);
+       else if (Global::tool == TTMirror)
+               MirrorHandler(mode, p);
 }
 
 
@@ -708,8 +710,39 @@ void DrawingView::ToolDraw(Painter * painter)
 
                        if (ctrlDown)
                                informativeText += " (Copy)";
+               }
+       }
+       else if (Global::tool == TTMirror)
+       {
+               if ((Global::toolState == TSNone) || (Global::toolState == TSPoint1))
+                       painter->DrawHandle(toolPoint[0]);
+               else if ((Global::toolState == TSPoint2) && shiftDown)
+                       painter->DrawHandle(toolPoint[1]);
+               else
+               {
+                       if (toolPoint[0] == toolPoint[1])
+                               return;
+                       
+                       painter->DrawLine(toolPoint[0], toolPoint[1]);
+                       // Likely we need a tool container for this... (now we do!)
+#if 0
+                       if (ctrlDown)
+                       {
+                               painter->SetPen(0x00FF00, 2.0, LSSolid);
+                               overrideColor = true;
+                       }
+
+                       RenderObjects(painter, toolObjects);
+                       overrideColor = false;
+#endif
+
+                       double absAngle = (Vector(toolPoint[1] - toolPoint[0]).Angle()) * RADIANS_TO_DEGREES;
+
+                       QString text = QChar(0x2221) + QObject::tr(": %1");
+                       informativeText = text.arg(absAngle);
 
-//                     painter->DrawInformativeText(text);
+                       if (ctrlDown)
+                               informativeText += " (Copy)";
                }
        }
 }
@@ -970,6 +1003,112 @@ void DrawingView::RotateHandler(int mode, Point p)
 }
 
 
+void DrawingView::MirrorHandler(int mode, Point p)
+{
+       switch (mode)
+       {
+       case ToolMouseDown:
+               if (Global::toolState == TSNone)
+               {
+                       toolPoint[0] = p;
+                       SavePointsFrom(select, toolScratch);
+                       Global::toolState = TSPoint1;
+               }
+               else if (Global::toolState == TSPoint1)
+                       toolPoint[0] = p;
+               else
+                       toolPoint[1] = p;
+
+               break;
+       case ToolMouseMove:
+               if ((Global::toolState == TSPoint1) || (Global::toolState == TSNone))
+                       toolPoint[0] = p;
+               else if (Global::toolState == TSPoint2)
+               {
+                       toolPoint[1] = p;
+
+                       if (shiftDown)
+                               return;
+
+                       double angle = Vector(toolPoint[0], toolPoint[1]).Angle();
+                       std::vector<void *>::iterator j = select.begin();
+                       std::vector<Object>::iterator i = toolScratch.begin();
+
+                       for(; i!=toolScratch.end(); i++, j++)
+                       {
+                               Object obj = *i;
+                               Point p1 = Geometry::MirrorPointAroundLine(obj.p[0], toolPoint[0], toolPoint[1]);
+                               Point p2 = Geometry::MirrorPointAroundLine(obj.p[1], toolPoint[0], toolPoint[1]);
+                               Object * obj2 = (Object *)(*j);
+                               obj2->p[0] = p1;
+                               obj2->p[1] = p2;
+
+                               if (obj.type == OTArc)
+                               {
+#if 0
+                                       // This is WRONG for mirroring...
+                                       obj2->angle[0] = obj.angle[0] + angle;
+#endif
+                                       obj2->angle[0] = (2.0 * angle) - obj.angle[0] - obj.angle[1];
+
+                                       if (obj2->angle[0] > PI_TIMES_2)
+                                               obj2->angle[0] -= PI_TIMES_2;
+                               }
+                       }
+               }
+
+               break;
+       case ToolMouseUp:
+               if (Global::toolState == TSPoint1)
+               {
+                       Global::toolState = TSPoint2;
+                       // Prevent spurious line from drawing...
+                       toolPoint[1] = toolPoint[0];
+               }
+               else if ((Global::toolState == TSPoint2) && shiftDown)
+               {
+                       // Key override is telling us to make a new line, not continue the
+                       // previous one.
+                       toolPoint[0] = toolPoint[1];
+               }
+               else
+               {
+                       // Either we're finished with our rotate, or we're stamping a copy.
+                       if (ctrlDown)
+                       {
+                               // Stamp a copy of the selection at the current rotation & bail
+                               std::vector<void *> temp;
+                               CopyObjects(select, temp);
+                               ClearSelected(temp);
+                               AddObjectsTo(document.objects, temp);
+                               RestorePointsTo(select, toolScratch);
+                               return;
+                       }
+
+                       toolPoint[0] = p;
+                       Global::toolState = TSPoint1;
+                       SavePointsFrom(select, toolScratch);
+               }
+
+               break;
+       case ToolKeyDown:
+               // Reset the selection if shift held down...
+               if (shiftDown)
+                       RestorePointsTo(select, toolScratch);
+
+               break;
+       case ToolKeyUp:
+               // Reset selection when key is let up
+               if (!shiftDown)
+                       MirrorHandler(ToolMouseMove, toolPoint[1]);
+
+               break;
+       case ToolCleanup:
+               RestorePointsTo(select, toolScratch);
+       }
+}
+
+
 void DrawingView::mousePressEvent(QMouseEvent * event)
 {
        if (event->button() == Qt::LeftButton)

diff --git a/src/drawingview.h b/src/drawingview.h
index e22634c00d936eda7afd7ad2a87752f611e8d5b0..849ce76b2c943a1d2a07070d1585c54107434b60 100644 (file)
--- a/src/drawingview.h
+++ b/src/drawingview.h
@@ -30,6 +30,7 @@ class DrawingView: public QWidget
                void CircleHandler(int, Point);
                void ArcHandler(int, Point);
                void RotateHandler(int, Point);
+               void MirrorHandler(int, Point);
                void CheckObjectBounds(void);
                bool HitTestObjects(Point);
                void HandleObjectMovement(Point);