#include "global.h"
#include "mathconstants.h"
#include "painter.h"
+#include "penwidget.h"
#include "structs.h"
#include "utils.h"
-
#define BACKGROUND_MAX_SIZE 512
-
DrawingView::DrawingView(QWidget * parent/*= NULL*/): QWidget(parent),
// The value in the settings file will override this.
useAntialiasing(true), numHovered(0), shiftDown(false),
ctrlDown(false), altDown(false),
gridBackground(BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE),
- scale(1.0), offsetX(-10), offsetY(-10), document(true),
+ scale(1.0), offsetX(-10), offsetY(-10), supressSelected(false),
+ document(true),
gridPixels(0), collided(false), scrollDrag(false), hoverPointValid(false),
hoveringIntersection(false), dragged(NULL), draggingObject(false),
angleSnap(false), dirty(false)
setBackgroundRole(QPalette::Base);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+ curMarker = QCursor(QPixmap(":/res/cursor-marker.png"), 1, 18);
+ curDropper = QCursor(QPixmap(":/res/cursor-dropper.png"), 1, 20);
+
Global::gridSpacing = 12.0; // In base units (inch is default)
Line * line = new Line(Vector(5, 5), Vector(50, 40), 2.0, 0xFF7F00, LSDash);
Need a way to scale line widths as well. :-/ Shouldn't be too difficult, just
need a thickness parameter similar to the "size" param for dimensions. (And now
we do! :-)
-
*/
- gridPixels = 12; //tmp
- SetGridSize(12.0); // This is in pixels
}
-
void DrawingView::DrawBackground(Painter * painter)
{
Point ul = Painter::QtToCartesianCoords(Vector(0, 0));
painter->DrawHLine(bottomy + i);
}
-
void DrawingView::DrawSubGrid(Painter * painter, uint32_t color, double step, Vector start, Vector size)
{
painter->SetPen(color, 1, 1);
painter->DrawHLine(start.y + i);
}
-
-void DrawingView::SetGridSize(uint32_t size)
-{
-#if 0
- // Sanity check
- if (size == gridPixels)
- return;
-
- // tmp...
- if (size <= 1)
- return;
-
- // Recreate the background bitmap
- gridPixels = size;
- QPainter pmp(&gridBackground);
- pmp.fillRect(0, 0, BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE, QColor(240, 240, 240));
- pmp.setPen(QPen(QColor(210, 210, 255), 2.0, Qt::SolidLine));
-
- for(int i=0; i<(BACKGROUND_MAX_SIZE-1); i+=gridPixels)
- {
- pmp.drawLine(i, 0, i, BACKGROUND_MAX_SIZE - 1);
- pmp.drawLine(0, i, BACKGROUND_MAX_SIZE - 1, i);
- }
-
- pmp.end();
-
- // Set up new BG brush & zoom level (pixels per base unit)
-// This shouldn't be done here, because it fucks up the scrollwheel zooming...
-// Global::zoom = gridPixels / Global::gridSpacing;
- UpdateGridBackground();
-#endif
-}
-
-
-void DrawingView::UpdateGridBackground(void)
-{
-#if 0
- // Transform the origin to Qt coordinates
- Vector pixmapOrigin = Painter::CartesianToQtCoords(Vector());
- int x = (int)pixmapOrigin.x;
- int y = (int)pixmapOrigin.y;
- // Use mod arithmetic to grab the correct swatch of background
-/*
-Negative numbers still screw it up... Need to think about what we're
-trying to do here. The fact that it worked with 72 seems to have been pure luck.
-It seems the problem is negative numbers: We can't let that happen.
-When taking away the zero, it pops over 1 px at zero, then goes about 1/2 a
-grid at x<0.
-
-The bitmap looks like this:
-
-+---+---+---+---+---
-| | | | |
-| | | | |
-+---+---+---+---+---
-| | | | |
-| | | | |
-| | | | |
-
-@ x = 1, we want it to look like:
-
--+---+---+---+---+---
- | | | | |
- | | | | |
--+---+---+---+---+---
- | | | | |
- | | | | |
- | | | | |
-
-Which means we need to grab the sample from x = 3. @ x = -1:
-
----+---+---+---+---
- | | | |
- | | | |
----+---+---+---+---
- | | | |
- | | | |
- | | | |
-
-Which means we need to grab the sample from x = 1. Which means we have to take
-the mirror of the modulus of gridPixels.
-
-Doing a mod of a negative number is problematic: 1st, the compiler converts the
-negative number to an unsigned int, then it does the mod. Gets you wrong answers
-most of the time, unless you use a power of 2. :-P So what we do here is just
-take the modulus of the negation, which means we don't have to worry about
-mirroring it later.
-
-The positive case looks gruesome (and it is) but it boils down to this: We take
-the modulus of the X coordinate, then mirror it by subtraction from the
-maximum (in this case, gridPixels). This gives us a number in the range of 1 to
-gridPixels. But we need the case where the result equalling gridPixels to be
-zero; so we do another modulus operation on the result to achieve this.
-*/
- if (x < 0)
- x = -x % gridPixels;
- else
- x = (gridPixels - (x % gridPixels)) % gridPixels;
-
- if (y < 0)
- y = -y % gridPixels;
- else
- y = (gridPixels - (y % gridPixels)) % gridPixels;
-
- // Here we grab a section of the bigger pixmap, so that the background
- // *looks* like it's scrolling...
- QPixmap pm = gridBackground.copy(x, y, gridPixels, gridPixels);
- QPalette pal = palette();
- pal.setBrush(backgroundRole(), QBrush(pm));
- setAutoFillBackground(true);
- setPalette(pal);
-#endif
-}
-
-
-void DrawingView::SetGridSize(double size)
-{
-#if 0
- // Sanity check
- if (size == gridPixelsF)
- return;
-
- // tmp...
- if (size <= 1)
- return;
-
- // Recreate the background bitmap
- gridPixelsF = size;
- QPainter pmp(&gridBackground);
- pmp.fillRect(0, 0, BACKGROUND_MAX_SIZE, BACKGROUND_MAX_SIZE, QColor(240, 240, 240));
- pmp.setPen(QPen(QColor(210, 210, 255), 2.0, Qt::SolidLine));
-
- for(double i=0; i<(BACKGROUND_MAX_SIZE-1); i+=gridPixelsF)
- {
- pmp.drawLine(i, 0, i, (double)(BACKGROUND_MAX_SIZE - 1));
- pmp.drawLine(0, i, (double)(BACKGROUND_MAX_SIZE - 1), i);
- }
-
- pmp.end();
-
- // Set up new BG brush & zoom level (pixels per base unit)
-// This shouldn't be done here, because it fucks up the scrollwheel zooming...
-// Global::zoom = gridPixels / Global::gridSpacing;
- UpdateGridBackgroundF();
-#endif
-}
-
-
-void DrawingView::UpdateGridBackgroundF(void)
-{
-#if 0
- // Transform the origin to Qt coordinates
- Vector pixmapOrigin = Painter::CartesianToQtCoords(Vector());
- int x = 0;// (int)pixmapOrigin.x;
- int y = 0;// (int)pixmapOrigin.y;
- // Use mod arithmetic to grab the correct swatch of background
-
-/* if (x < 0)
- x = -x % gridPixels;
- else
- x = (gridPixels - (x % gridPixels)) % gridPixels;
-
- if (y < 0)
- y = -y % gridPixels;
- else
- y = (gridPixels - (y % gridPixels)) % gridPixels;*/
-
- // Here we grab a section of the bigger pixmap, so that the background
- // *looks* like it's scrolling...
- QPixmap pm = gridBackground.copy(x, y, gridPixelsF, gridPixelsF);
- QPalette pal = palette();
- pal.setBrush(backgroundRole(), QBrush(pm));
- setAutoFillBackground(true);
- setPalette(pal);
-#endif
-}
-
-
//
// Basically, we just make a single pass through the Container. If the layer #
// is less than the layer # being deleted, then do nothing. If the layer # is
update();
}
-
void DrawingView::HandleLayerToggle(void)
{
// A layer's visibility was toggled, so update the screen...
update();
}
-
//
// A layer was moved up or down in the layer list, so we have to swap the
// document's object's layer numbers in the layers that were swapped.
//
void DrawingView::HandleLayerSwap(int layer1, int layer2)
{
-// !!! FIX !!! This doesn't properly handle container contents...
//printf("DrawingView: Swapping layers %i and %i.\n", layer1, layer2);
- for(VPVectorIter i=document.objects.begin(); i!=document.objects.end(); i++)
+ HandleLayerSwap(layer1, layer2, document.objects);
+}
+
+/*
+We can roll this into the main one above, by having the LayerWidget's emit() call sending NULL for the VPVector, which we can test for and set to document.objects to grab the top layer. Or, keep it a top level call and a recursive call. Which is worse? :-P
+*/
+void DrawingView::HandleLayerSwap(int layer1, int layer2, VPVector & v)
+{
+ for(VPVectorIter i=v.begin(); i!=v.end(); i++)
{
Object * obj = (Object *)(*i);
obj->layer = layer2;
else if (obj->layer == layer2)
obj->layer = layer1;
+
+ if (obj->type == OTContainer)
+ HandleLayerSwap(layer1, layer2, ((Container *)obj)->objects);
}
}
-
void DrawingView::HandlePenWidth(float width)
{
for(VPVectorIter i=select.begin(); i!=select.end(); i++)
Object * obj = (Object *)(*i);
obj->thickness = width;
}
-}
+ supressSelected = true;
+ update();
+}
void DrawingView::HandlePenStyle(int style)
{
Object * obj = (Object *)(*i);
obj->style = style;
}
-}
+ supressSelected = true;
+ update();
+}
void DrawingView::HandlePenColor(uint32_t color)
{
Object * obj = (Object *)(*i);
obj->color = color;
}
-}
+ supressSelected = true;
+ update();
+}
-void DrawingView::HandlePenStamp(void)
+void DrawingView::HandlePenStamp(QAction * action)
{
- VPVector flat = Flatten(select);
+ PenWidget * pw = (PenWidget *)action->parentWidget();
+ pw->dropperAction->setChecked(false);
+ Global::penDropper = false;
+ Global::penStamp = action->isChecked();
- for(VPVectorIter i=flat.begin(); i!=flat.end(); i++)
- {
- Object * obj = (Object *)(*i);
-
- if (obj->type != OTText)
- obj->thickness = Global::penWidth;
+ if (Global::penStamp)
+ setCursor(curMarker);
+ else
+ setCursor(Qt::ArrowCursor);
- obj->style = Global::penStyle;
- obj->color = Global::penColor;
- }
+ if (Global::penStamp == false)
+ ClearSelected(document.objects);
update();
}
+void DrawingView::HandlePenDropper(QAction * action)
+{
+ PenWidget * pw = (PenWidget *)action->parentWidget();
+ pw->stampAction->setChecked(false);
+ Global::penStamp = false;
+ Global::penDropper = action->isChecked();
+
+ if (Global::penDropper)
+ setCursor(curDropper);
+ else
+ setCursor(Qt::ArrowCursor);
+
+ update();
+}
QPoint DrawingView::GetAdjustedMousePosition(QMouseEvent * event)
{
return QPoint(offsetX + event->x(), offsetY + (size().height() - event->y()));
}
-
QPoint DrawingView::GetAdjustedClientPosition(int x, int y)
{
// VOODOO ALERT (ON Y COMPONENT!!!!) (eh?)
return QPoint(-offsetX + x, (size().height() - (-offsetY + y)) * +1.0);
}
-
void DrawingView::focusOutEvent(QFocusEvent * /*event*/)
{
// printf("DrawingView::focusOutEvent()...\n");
setCursor(Qt::ArrowCursor);
}
+void DrawingView::focusInEvent(QFocusEvent * /*event*/)
+{
+ if (Global::penStamp)
+ setCursor(curMarker);
+ else if (Global::penDropper)
+ setCursor(curDropper);
+//FocusOut already set this...
+// else
+// setCursor(Qt::ArrowCursor);
+}
void DrawingView::paintEvent(QPaintEvent * /*event*/)
{
painter.DrawInformativeText(informativeText);
}
-
//
// Renders objects in the passed in vector
//
painter->SetPen(obj->color, Global::zoom * scaledThickness, obj->style);
painter->SetBrush(obj->color);
- if (obj->selected || obj->hitObject)
+ // penStamp supresses object highlighting, so that changes can be seen.
+ if (supressSelected || Global::penStamp)
+ {
+ if (obj->hitObject)
+ {
+ painter->SetPen(Global::penColor, Global::zoom * Global::scale * Global::penWidth, Global::penStyle);
+ painter->SetBrush(Global::penColor);
+ }
+ }
+ else if (obj->selected || obj->hitObject)
painter->SetPen(0xFF0000, Global::zoom * scaledThickness, LSDash);
}
break;
}
+ case OTPolyline:
+ {
+ break;
+ }
+
case OTContainer:
{
// Containers require recursive rendering...
Container * c = (Container *)obj;
-printf("About to render container: # objs=%i, layer=%i\n", (*c).objects.size(), layer);
+//printf("About to render container: # objs=%i, layer=%i\n", (*c).objects.size(), layer);
RenderObjects(painter, (*c).objects, layer, ignoreLayer);
//printf("Container extents: <%lf, %lf>, <%lf, %lf>\nsize: %i\n", r.l, r.t, r.r, r.b, c->objects.size());
break;
}
}
-}
+ supressSelected = false;
+}
//
// This toggles the selection being hovered (typically, only 1 object)
}
}
-
VPVector DrawingView::GetSelection(void)
{
VPVector v;
return v;
}
-
-VPVector DrawingView::GetHovered(void)
+//
+// When testing for hovered intersections, we need to be able to exclude some
+// objects which have funky characteristics or handles; so we allow for that
+// here.
+//
+VPVector DrawingView::GetHovered(bool exclude/*= false*/)
{
VPVector v;
for(VPVectorIter i=document.objects.begin(); i!=document.objects.end(); i++)
{
- if (((Object *)(*i))->hovered)
+ Object * obj = (Object *)(*i);
+
+ if (obj->hovered)
+ {
+ if (exclude
+ && ((obj->type == OTDimension)
+ || ((obj->type == OTCircle) && (obj->hitPoint[0] == true))
+ || ((obj->type == OTArc) && (obj->hitPoint[0] == true))
+ || (draggingObject && (obj == dragged))))
+ continue;
+
v.push_back(*i);
+ }
}
return v;
}
-
void DrawingView::resizeEvent(QResizeEvent * /*event*/)
{
Global::screenSize = Vector(size().width(), size().height());
- UpdateGridBackground();
}
-
void DrawingView::ToolHandler(int mode, Point p)
{
// Drop angle snap until it's needed
ParallelHandler(mode, p);
}
-
void DrawingView::ToolDraw(Painter * painter)
{
if (Global::tool == TTLine)
}
}
-
void DrawingView::LineHandler(int mode, Point p)
{
switch (mode)
{
case ToolMouseDown:
+/* toolObj[0] = NULL;
+
+ // Check to see if we can do a circle tangent snap
+ if (numHovered == 1)
+ {
+ VPVector hover = GetHovered();
+ Object * obj = (Object *)hover[0];
+
+ // Save for later if the object clicked was a circle (need to check that it wasn't the center clicked on, because that will fuck up connecting centers of circles with lines... and now we do! :-)
+ if ((obj->type == OTCircle) && (obj->hitPoint[0] == false))
+ toolObj[0] = obj;
+ }*/
+
if (Global::toolState == TSNone)
toolPoint[0] = p;
else
if (Global::toolState == TSNone)
toolPoint[0] = p;
else
+ {
toolPoint[1] = p;
+/* bool isCircle = false;
+
+ if (numHovered == 1)
+ {
+ VPVector hover = GetHovered();
+ Object * obj = (Object *)hover[0];
+
+ if ((obj->type == OTCircle) && (obj->hitPoint[0] == false))
+ {
+ isCircle = true;
+ toolObj[1] = obj;
+ }
+ }
+
+ // Adjust initial point if it's on a circle (tangent point)
+ if (toolObj[0] != NULL)
+ {
+ if (isCircle)
+ {
+ Geometry::FindTangents(toolObj[0], toolObj[1]);
+
+ if (Global::numIntersectPoints > 0)
+ {
+ toolPoint[0] = Global::intersectPoint[0];
+ toolPoint[1] = Global::intersectPoint[1];
+ }
+ }
+ else
+ {
+ Geometry::FindTangents(toolObj[0], p);
+
+ if (Global::numIntersectPoints > 0)
+ toolPoint[0] = Global::intersectPoint[0];
+ }
+ }
+ else
+ {
+ if (isCircle)
+ {
+ Geometry::FindTangents(toolObj[1], toolPoint[0]);
+
+ if (Global::numIntersectPoints > 0)
+ toolPoint[1] = Global::intersectPoint[0];
+ }
+ }*/
+ }
break;
}
}
-
void DrawingView::CircleHandler(int mode, Point p)
{
switch (mode)
}
}
-
void DrawingView::ArcHandler(int mode, Point p)
{
switch (mode)
}
}
-
void DrawingView::RotateHandler(int mode, Point p)
{
switch (mode)
}
}
-
void DrawingView::MirrorHandler(int mode, Point p)
{
switch (mode)
}
}
-
void DrawingView::DimensionHandler(int mode, Point p)
{
switch (mode)
}
}
-
void DrawingView::TriangulateHandler(int mode, Point/*p*/)
{
switch (mode)
}
}
-
void DrawingView::TrimHandler(int mode, Point p)
{
/*
-n.b.: this code is lifted straight out of the old oo code. needs to be updated.
+N.B.: this code is lifted straight out of the old oo code. needs to be updated.
+ Also: trim tool should ignore snap.
*/
switch (mode)
{
}
}
-
void DrawingView::ParallelHandler(int mode, Point /*p*/)
{
switch (mode)
}
}
-
void DrawingView::mousePressEvent(QMouseEvent * event)
{
if (event->button() == Qt::LeftButton)
//printf("mousePressEvent::numHovered > 0 (hover2[0]=$%llx, type=%s)\n", dragged, objName[dragged->type]);
// Alert the pen widget
- emit ObjectSelected(dragged);
+// Maybe do this with an eyedropper tool on the pen bar? [YES]
+// emit ObjectSelected(dragged);
+ if (Global::penDropper)
+ {
+ Global::penColor = dragged->color;
+ Global::penWidth = dragged->thickness;
+ Global::penStyle = dragged->style;
+ emit ObjectSelected(dragged);
+ ClearSelected(document.objects);
+ return;
+ }
+
+ if (Global::penStamp)
+ {
+ dragged->color = Global::penColor;
+ dragged->thickness = Global::penWidth;
+ dragged->style = Global::penStyle;
+ return;
+ }
// See if anything is using just a straight click on a handle
if (HandleObjectClicked())
}
}
-
void DrawingView::mouseMoveEvent(QMouseEvent * event)
{
// It seems that wheelEvent() triggers this for some reason...
delta.y = -delta.y;
Global::origin -= delta;
- UpdateGridBackground();
+// UpdateGridBackground();
update();
oldPoint = point;
return;
// Make sure previously selected objects stay selected (CTRL held)
for(VPVectorIter i=select.begin(); i!=select.end(); i++)
- ((Object *)(*i))->selected = true;
+ {
+ // Make sure *not* to select items on hidden layers
+ if (Global::layerHidden[((Object *)(*i))->layer] == false)
+ ((Object *)(*i))->selected = true;
+ }
update();
return;
// Do object hit testing...
bool needUpdate = HitTestObjects(point);
- VPVector hover2 = GetHovered();
+ VPVector hover2 = GetHovered(true); // Exclude dimension objects and circle centers (probably need to add arc centers too) from hover (also dragged objects...)
#if 0
{
if (needUpdate)
#endif
// Check for multi-hover...
- if (numHovered > 1)
+ if (hover2.size() > 1)
{
-//need to check for case where hover is over 2 circles and a 3rd's center...
+//need to check for case where hover is over 2 circles and a 3rd's center (no longer a problem, I think)...
Object * obj1 = (Object *)hover2[0], * obj2 = (Object *)hover2[1];
Geometry::Intersects(obj1, obj2);
intersectionPoint = v1;
}
}
- else if (numHovered == 1)
+ else if (hover2.size() == 1)
{
Object * obj = (Object *)hover2[0];
{
/*
Not sure that this is the best way to handle this, but it works(TM)...
-Except when lines are overlapping, then it doesn't work... !!! FIX !!!
*/
Point midpoint = Geometry::Midpoint((Line *)obj);
Vector v1 = Vector::Magnitude(midpoint, point);
needUpdate = true;
}
}
+ else if (obj->type == OTCircle)
+ {
+ if ((draggingObject && (dragged->type == OTLine)) && (dragged->hitPoint[0] || dragged->hitPoint[1]))
+ {
+ Point p = (dragged->hitPoint[0] ? dragged->p[1] : dragged->p[0]);
+ Geometry::FindTangents(obj, p);
+
+ if (Global::numIntersectPoints > 0)
+ {
+ hoveringIntersection = true;
+ intersectionPoint = Geometry::NearestTo(point, Global::intersectPoint[0], Global::intersectPoint[1]);
+ }
+ }
+ else if ((Global::tool == TTLine) && (Global::toolState == TSPoint2))
+ {
+ Geometry::FindTangents(obj, toolPoint[0]);
+
+ if (Global::numIntersectPoints > 0)
+ {
+ hoveringIntersection = true;
+ intersectionPoint = Geometry::NearestTo(point, Global::intersectPoint[0], Global::intersectPoint[1]);
+ }
+ }
+ }
}
// Handle object movement (left button down & over an object)
update();
}
-
void DrawingView::mouseReleaseEvent(QMouseEvent * event)
{
if (event->button() == Qt::LeftButton)
else if (event->button() == Qt::MiddleButton)
{
scrollDrag = false;
- setCursor(Qt::ArrowCursor);
+
+ if (Global::penStamp)
+ setCursor(curMarker);
+ else if (Global::penDropper)
+ setCursor(curDropper);
+ else
+ setCursor(Qt::ArrowCursor);
+
+ // Need to convert this, since it's in Qt coordinates (for wheelEvent)
+ oldPoint = Painter::QtToCartesianCoords(oldPoint);
}
}
-
void DrawingView::wheelEvent(QWheelEvent * event)
{
double zoomFactor = 1.20;
emit(NeedZoomUpdate());
}
-
void DrawingView::keyPressEvent(QKeyEvent * event)
{
bool oldShift = shiftDown;
}
}
-
void DrawingView::keyReleaseEvent(QKeyEvent * event)
{
bool oldShift = shiftDown;
if (oldAlt != altDown)
{
scrollDrag = false;
- setCursor(Qt::ArrowCursor);
+
+ if (Global::penStamp)
+ setCursor(curMarker);
+ else if (Global::penDropper)
+ setCursor(curDropper);
+ else
+ setCursor(Qt::ArrowCursor);
}
}
-
//
// 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
return point;
}
-
Point DrawingView::SnapPointToAngle(Point point)
{
// Snap to a single digit angle (using toolpoint #1 as the center)
return point;
}
-
Rect DrawingView::GetObjectExtents(Object * obj)
{
// Default to empty rect, if object checks below fail for some reason
return rect;
}
-
void DrawingView::CheckObjectBounds(void)
{
VPVectorIter i;
switch (obj->type)
{
case OTLine:
- case OTDimension:
+ case OTDimension: // N.B.: We don't check this properly...
{
Line * l = (Line *)obj;
}
}
-
bool DrawingView::HitTestObjects(Point point)
{
VPVectorIter i;
return needUpdate;
}
-
bool DrawingView::HitTest(Object * obj, Point point)
{
bool needUpdate = false;
return needUpdate;
}
-
bool DrawingView::HandleObjectClicked(void)
{
if (dragged->type == OTDimension)
return false;
}
-
void DrawingView::HandleObjectMovement(Point point)
{
Point delta = point - oldPoint;
}
}
-
void DrawingView::AddDimensionTo(void * o)
{
Object * obj = (Object *)o;
break;
}
}
-
projects / architektonas / blobdiff