#include <stdint.h>
#include "mathconstants.h"
-#include "arc.h"
-#include "circle.h"
-#include "dimension.h"
-#include "geometry.h"
-#include "line.h"
+//#include "arc.h"
+//#include "circle.h"
+//#include "dimension.h"
+//#include "geometry.h"
+//#include "line.h"
+#include "global.h"
#include "painter.h"
// The value in the settings file will override this.
useAntialiasing(true),
gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
- scale(1.0), offsetX(-10), offsetY(-10), document(Vector(0, 0)),
- gridPixels(0), collided(false), toolAction(NULL)
+ scale(1.0), offsetX(-10), offsetY(-10),// document(Vector(0, 0)),
+ gridPixels(0), collided(false)//, toolAction(NULL)
{
- document.isTopLevelContainer = true;
+// document.isTopLevelContainer = true;
+//wtf? doesn't work except in c++11??? document = { 0 };
setBackgroundRole(QPalette::Base);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
- Object::gridSpacing = 12.0; // In base units (inch is default)
+ Global::gridSpacing = 12.0; // In base units (inch is default)
+#if 0
Line * line = new Line(Vector(5, 5), Vector(50, 40), &document);
document.Add(line);
document.Add(new Line(Vector(50, 40), Vector(10, 83), &document));
// Alternate way to do the above...
line->SetDimensionOnLine();
#endif
+#endif
/*
Here we set the grid size in pixels--12 in this case. Initially, we have our
Really, the 100% zoom level can be set at *any* zoom level, it's more of a
convenience function than any measure of absolutes. Doing things that way we
could rid ourselves of the whole SCREEN_ZOOM parameter and all the attendant
-shittyness that comes with it.
+shittiness that comes with it.
However, it seems that SCREEN_ZOOM is used to make text and arrow sizes show up
a certain way, which means we should probably create something else in those
}
+#if 0
void DrawingView::SetToolActive(Action * action)
{
if (action != NULL)
connect(toolAction, SIGNAL(NeedRefresh()), this, SLOT(HandleActionUpdate()));
}
}
+#endif
void DrawingView::SetGridSize(uint32_t size)
// Set up new BG brush & zoom level (pixels per base unit)
// Painter::zoom = gridPixels / gridSpacing;
- Painter::zoom = gridPixels / Object::gridSpacing;
+ Painter::zoom = gridPixels / Global::gridSpacing;
UpdateGridBackground();
}
{
if (object)
{
- object->Reparent(&document);
- document.Add(object);
+// object->Reparent(&document);
+// document.Add(object);
update();
}
//printf("DrawingView::AddNewObjectToDocument(). object=%08X\n", object);
void DrawingView::SetCurrentLayer(int layer)
{
- Object::currentLayer = layer;
+ Global::currentLayer = layer;
//printf("DrawingView::CurrentLayer = %i\n", layer);
}
if (useAntialiasing)
qtPainter.setRenderHint(QPainter::Antialiasing);
- Object::SetViewportHeight(size().height());
+ Global::viewportHeight = size().height();
// Draw coordinate axes
painter.SetPen(QPen(Qt::blue, 1.0, Qt::DotLine));
painter.DrawLine(-16384, 0, 16384, 0);
// The top level document takes care of rendering for us...
- document.Draw(&painter);
+// document.Draw(&painter);
+#if 0
if (toolAction)
{
painter.SetPen(QPen(QColor(200, 100, 0, 255), 1.0, Qt::DashLine));
painter.DrawCrosshair(oldPoint);
toolAction->Draw(&painter);
}
+#endif
- if (Object::selectionInProgress)
+#if 1
+ if (Global::selectionInProgress)
{
painter.SetPen(QPen(QColor(255, 127, 0, 255)));
painter.SetBrush(QBrush(QColor(255, 127, 0, 100)));
- painter.DrawRect(Object::selection);
+ painter.DrawRect(Global::selection);
}
+#endif
}
if (event->button() == Qt::LeftButton)
{
Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
- collided = document.Collided(point);
+// collided = document.Collided(point);
+ collided = false;
// Do an update if collided with at least *one* object in the document
- if (collided)
- update();
+// if (collided)
+// update();
+#if 0
if (toolAction)
{
- if (Object::snapToGrid)
- point = Object::SnapPointToGrid(point);
+ if (Global::snapToGrid)
+ point = Global::SnapPointToGrid(point);
// We always snap to object points, and they take precendence over
// grid points...
- if (Object::snapPointIsValid)
- point = Object::snapPoint;
+ if (Global::snapPointIsValid)
+ point = Global::snapPoint;
toolAction->MouseDown(point);
}
+#endif
+#if 1
// Didn't hit any object and not using a tool, so do a selection rectangle
- if (!(collided || toolAction))
+ if (!(collided))// || toolAction))
{
- Object::selectionInProgress = true;
- Object::selection.setTopLeft(QPointF(point.x, point.y));
- Object::selection.setBottomRight(QPointF(point.x, point.y));
+ Global::selectionInProgress = true;
+ Global::selection.setTopLeft(QPointF(point.x, point.y));
+ Global::selection.setBottomRight(QPointF(point.x, point.y));
}
+#endif
}
else if (event->button() == Qt::MiddleButton)
{
void DrawingView::mouseMoveEvent(QMouseEvent * event)
{
Vector point = Painter::QtToCartesianCoords(Vector(event->x(), event->y()));
- Object::selection.setBottomRight(QPointF(point.x, point.y));
+ Global::selection.setBottomRight(QPointF(point.x, point.y));
// Only needs to be done here, as mouse down is always preceded by movement
- Object::snapPointIsValid = false;
+ Global::snapPointIsValid = false;
// Scrolling...
if (event->buttons() & Qt::MiddleButton)
return;
}
-#if 0
+#if 1
// Grid processing... (only snap here is left button is down)
- if ((event->buttons() & Qt::LeftButton) && Object::snapToGrid)
+ if ((event->buttons() & Qt::LeftButton) && Global::snapToGrid)
{
- point = Object::SnapPointToGrid(point);
+ point = SnapPointToGrid(point);
}
// Snap points on objects always take precedence over the grid, whether
// dragging an object or not...
//thisnowok
- if (Object::snapPointIsValid)
+ if (Global::snapPointIsValid)
{
// Uncommenting this causes the cursor to become unresponsive after the first
// object is added.
-// point = Object::snapPoint;
+// point = Global::snapPoint;
}
#endif
//we should keep track of the last point here and only pass this down *if* the point
//changed...
+#if 0
// This returns true if we've moved over an object...
if (document.PointerMoved(point))
{
if (n == 1)
{
- Object::snapPoint = document.lastObjectHovered->GetPointAtParameter(t);
- Object::snapPointIsValid = true;
+ Global::snapPoint = document.lastObjectHovered->GetPointAtParameter(t);
+ Global::snapPointIsValid = true;
}
}
else if ((document.lastObjectHovered->type == OTCircle) && (document.penultimateObjectHovered->type == OTCircle))
if (n == 1)
{
- Object::snapPoint = p1;
- Object::snapPointIsValid = true;
+ Global::snapPoint = p1;
+ Global::snapPointIsValid = true;
}
else if (n == 2)
{
double d2 = Vector(point, p2).Magnitude();
if (d1 < d2)
- Object::snapPoint = p1;
+ Global::snapPoint = p1;
else
- Object::snapPoint = p2;
+ Global::snapPoint = p2;
- Object::snapPointIsValid = true;
+ Global::snapPointIsValid = true;
}
}
}
if (toolAction)
{
- if (Object::snapToGrid)
- point = Object::SnapPointToGrid(point);
+ if (Global::snapToGrid)
+ point = Global::SnapPointToGrid(point);
// We always snap to object points, and they take precendence over
// grid points...
- if (Object::snapPointIsValid)
- point = Object::snapPoint;
+ if (Global::snapPointIsValid)
+ point = Global::snapPoint;
toolAction->MouseMoved(point);
}
+#endif
// This is used to draw the tool crosshair...
oldPoint = point;
- if (document.NeedsUpdate() || Object::selectionInProgress || toolAction)
+#if 1
+ if (/*document.NeedsUpdate() ||*/ Global::selectionInProgress /*|| toolAction*/)
update();
+#endif
}
{
if (event->button() == Qt::LeftButton)
{
+#if 0
document.PointerReleased();
+#endif
//We need to update especially if nothing collided and the state needs to change. !!! FIX !!!
//could set it up to use the document's update function (assumes that all object updates
// if (collided)
update(); // Do an update if collided with at least *one* object in the document
+#if 0
if (toolAction)
toolAction->MouseReleased();
+#endif
- if (Object::selectionInProgress)
+ if (Global::selectionInProgress)
{
// Select all the stuff inside of selection
- Object::selectionInProgress = false;
+ Global::selectionInProgress = false;
}
}
else if (event->button() == Qt::MiddleButton)
Painter::zoom /= zoomFactor;
}
-// Object::gridSpacing = gridPixels / Painter::zoom;
+#if 1
+// Global::gridSpacing = gridPixels / Painter::zoom;
// UpdateGridBackground();
- SetGridSize(Object::gridSpacing * Painter::zoom);
+ SetGridSize(Global::gridSpacing * Painter::zoom);
update();
-// zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Object::gridSpacing));
+// zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
+#endif
}
void DrawingView::keyPressEvent(QKeyEvent * event)
{
+#if 0
if (toolAction)
toolAction->KeyDown(event->key());
+#endif
}
void DrawingView::keyReleaseEvent(QKeyEvent * event)
{
+#if 0
if (toolAction)
toolAction->KeyReleased(event->key());
+#endif
+}
+
+//
+// This looks strange, but it's really quite simple: We want a point that's
+// more than half-way to the next grid point to snap there while conversely we
+// want a point that's less than half-way to to the next grid point then snap
+// to the one before it. So we add half of the grid spacing to the point, then
+// divide by it so that we can remove the fractional part, then multiply it
+// back to get back to the correct answer.
+//
+Point DrawingView::SnapPointToGrid(Point point)
+{
+ point += Global::gridSpacing / 2.0; // *This* adds to Z!!!
+ point /= Global::gridSpacing;
+ point.x = floor(point.x);//need to fix this for negative numbers...
+ point.y = floor(point.y);
+ point.z = 0; // Make *sure* Z doesn't go anywhere!!!
+ point *= Global::gridSpacing;
+ return point;
}
projects / architektonas / blobdiff