Added automagically resizing grid. :-D

[architektonas] / src / drawingview.cpp

diff --git a/src/drawingview.cpp b/src/drawingview.cpp
index dc6853203769404357e2ac7ca05c5e57f9c7329f..ca352c2cb7c8de575b6a59b2e3f250d609f89f27 100644 (file)
--- a/src/drawingview.cpp
+++ b/src/drawingview.cpp
@@ -120,16 +120,84 @@ need a thickness parameter similar to the "size" param for dimensions. (And now
 we do! :-)
 
 */
-       SetGridSize(12);        // This is in pixels
+       gridPixels = 12; //tmp
+       SetGridSize(12.0);      // This is in pixels
+}
+
+
+void DrawingView::DrawBackground(Painter * painter)
+{
+       Point ul = Painter::QtToCartesianCoords(Vector(0, 0));
+       Point br = Painter::QtToCartesianCoords(Vector(Global::screenSize.x, Global::screenSize.y));
+
+       painter->SetBrush(0xF0F0F0);
+       painter->SetPen(0xF0F0F0, 1, 1);
+       painter->DrawRect(QRectF(QPointF(ul.x, ul.y), QPointF(br.x, br.y)));
+
+       double spacing = Global::gridSpacing;
+
+       if (spacing < 1.0)
+               spacing = 1.0;
+
+       double leftx = floor(ul.x / spacing) * spacing;
+       double bottomy = floor(br.y / spacing) * spacing;
+
+       double w = (br.x - ul.x) + Global::gridSpacing + 1.0;
+       double h = (ul.y - br.y) + Global::gridSpacing + 1.0;
+
+       Vector start(leftx, bottomy), size(w, h);
+
+       if (Global::gridSpacing <= 0.015625)
+               DrawSubGrid(painter, 0xFFD2D2, 0.015625, start, size);
+
+       if (Global::gridSpacing <= 0.03125)
+               DrawSubGrid(painter, 0xFFD2D2, 0.03125, start, size);
+
+       if (Global::gridSpacing <= 0.0625)
+               DrawSubGrid(painter, 0xB8ECFF, 0.0625, start, size);
+
+       if (Global::gridSpacing <= 0.125)
+               DrawSubGrid(painter, 0xB8ECFF, 0.125, start, size);
+
+       if (Global::gridSpacing <= 0.25)
+               DrawSubGrid(painter, 0xDBDBFF, 0.25, start, size);
+
+       if (Global::gridSpacing <= 0.5)
+               DrawSubGrid(painter, 0xDBDBFF, 0.5, start, size);
+
+       painter->SetPen(QPen(QColor(0xD2, 0xD2, 0xFF), 2.0, Qt::SolidLine));
+
+       for(double i=0; i<=w; i+=spacing)
+               painter->DrawVLine(leftx + i);
+
+       for(double i=0; i<=h; i+=spacing)
+               painter->DrawHLine(bottomy + i);
+}
+
+
+void DrawingView::DrawSubGrid(Painter * painter, uint32_t color, double step, Vector start, Vector size)
+{
+       painter->SetPen(color, 1, 1);
+
+       for(double i=-step; i<=size.x; i+=step*2.0)
+               painter->DrawVLine(start.x + i);
+
+       for(double i=-step; i<=size.y; i+=step*2.0)
+               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);
@@ -148,11 +216,13 @@ void DrawingView::SetGridSize(uint32_t size)
 // 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;
@@ -227,6 +297,70 @@ zero; so we do another modulus operation on the result to achieve this.
        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
 }
 
 
@@ -381,6 +515,8 @@ void DrawingView::paintEvent(QPaintEvent * /*event*/)
 
        Global::viewportHeight = size().height();
 
+       DrawBackground(&painter);
+
        // Draw coordinate axes
        painter.SetPen(QPen(Qt::blue, 1.0, Qt::DotLine));
        painter.DrawLine(0, -16384, 0, 16384);
@@ -1996,35 +2132,28 @@ void DrawingView::mouseReleaseEvent(QMouseEvent * event)
 
 void DrawingView::wheelEvent(QWheelEvent * event)
 {
-       double zoomFactor = 1.25;
+       double zoomFactor = 1.20;
        scrollWheelSeen = true;
 
-       if (event->delta() < 0)
+       if (event->angleDelta().y() < 0)
        {
-               if (Global::zoom > 20.0)
+               if (Global::zoom > 400.0)
                        return;
 
                Global::zoom *= zoomFactor;
-//             Point np = Painter::QtToCartesianCoords(oldScrollPoint);
-//             Global::origin += (oldPoint - np);
        }
        else
        {
-               if (Global::zoom < 0.25)
+               if (Global::zoom < 0.125)
                        return;
 
                Global::zoom /= zoomFactor;
-//             Point np = Painter::QtToCartesianCoords(oldScrollPoint);
-//             Global::origin += (oldPoint - np);
        }
 
        Point np = Painter::QtToCartesianCoords(oldScrollPoint);
        Global::origin += (oldPoint - np);
 
-//     Global::gridSpacing = gridPixels / Painter::zoom;
-       SetGridSize(Global::gridSpacing * Global::zoom);
-       update();
-//     zoomIndicator->setText(QString("Grid: %1\", BU: Inch").arg(Global::gridSpacing));
+       emit(NeedZoomUpdate());
 }