Subversion Repositories Code-Repo

#include "Canvas.h"

Canvas::Canvas(QWidget *parent) : QGraphicsView(parent)

{

    // Set some drawing options to improve performance

    setBackgroundRole(QPalette::Base);

    setAutoFillBackground(true);

    setFrameStyle(Sunken | StyledPanel);

    setRenderHint(QPainter::Antialiasing, true);

    setDragMode(QGraphicsView::RubberBandDrag);

    setOptimizationFlags(QGraphicsView::DontSavePainterState);

    setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);

    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);

    scene = new QGraphicsScene;

    setScene(scene);

    zoomLevel = 100;

    _pan = false;

    circuit = NULL;

    // Draw axis lines when running in debug mode

#ifdef _DEBUG

    QGraphicsLineItem *xAxis = new QGraphicsLineItem(-1000, 0, 1000, 0);

    QGraphicsLineItem *yAxis = new QGraphicsLineItem(0, -800, 0, 800);

    scene->addItem(xAxis);

    scene->addItem(yAxis);

    debugPen = QPen(QColor(COLOR_WIRE_REGION_OUTLINE), 1, Qt::DashDotLine);

#endif

/*

    Gate_BASE *g;

    for (int i = 1; i < 6; i++) {

        g = new Gate_INPUT(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 000);

        g = new Gate_OUTPUT(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 150);

        g = new Gate_BUFFER(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 300);

        g = new Gate_AND(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 500);

        g = new Gate_NAND(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 700);

        g = new Gate_OR(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 900);

        g = new Gate_NOR(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 1100);

        g = new Gate_XOR(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 1300);

        g = new Gate_XNOR(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 1500);

        g = new Gate_NOT(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 1700);

        g = new Gate_DFF(0, gate_INPUT, i, 0);

        scene->addItem(g);

        g->setCanvasPosition(BASE_GATE_SIZE_X + i * 2 * (BASE_GATE_SIZE_X + 20), 1900);

    }*/

}

QSize Canvas::minimumSizeHint() const

{

    return QSize(400,400);

}

QSize Canvas::sizeHint() const

{

    return QSize(800,600);

}

void Canvas::drawCircuit(Circuit *circuit)

{

    this->circuit = circuit;

    // Calculate the maximum distance between gates including spacing

    int largestLevelCount = 0; int largestYSize = 0;

    for (int i = 0; i < circuit->gatesPerLevel.keys().size(); i++) {

        int level = circuit->gatesPerLevel.keys()[i];

        QList<Gate_BASE*> gates = circuit->gatesPerLevel[level];

        // We want center to center distance of top and bottom gate

        int levelYSize = (gates[0]->ySize / 2) + (gates[gates.size() - 1]->ySize / 2);

        levelYSize += CANVAS_GATE_Y_SPACING * (gates.size() - 1);

        for (int j = 1; j < gates.size() - 1; j++) {

            levelYSize += gates[j]->ySize;

        }

        if (levelYSize > largestYSize) {

            largestLevelCount = gates.size();

            largestYSize = levelYSize;

        }

    }

    // Iterate through each level of the circuit and draw the gates

    int xOffset = 0, yOffset = 0, ySpacing = 0;

    int xSize = (circuit->gatesPerLevel.keys().size() - 1) * CANVAS_GATE_X_SPACING;

    xOffset = - xSize / 2;

    for (int i = 0; i < circuit->gatesPerLevel.keys().size(); i++) {

        int level = circuit->gatesPerLevel.keys()[i];

        QList<Gate_BASE*> gates = circuit->gatesPerLevel[level];

        // Calculate offsets and spacing between gates

        if (gates.size() == largestLevelCount) {

            ySpacing = largestYSize / (gates.size() - 1);

            yOffset = - largestYSize / 2;

        } else {

            ySpacing = largestYSize / (gates.size());

            yOffset = - largestYSize / 2 + ySpacing / 2;

        }

        // Draw gates onto canvas

        for (int j = 0; j < gates.size(); j++) {

            scene->addItem(gates[j]);

            connect(gates[j], SIGNAL(updateStatus(QString)), this, SIGNAL(updateStatus(QString)));

            gates[j]->setCanvasPosition(xOffset, yOffset);

            yOffset += ySpacing;

        }

        xOffset += CANVAS_GATE_X_SPACING;

    }

    /*

    // Go through and calculate wiring region between gate objects

    wireSpace *vSpacing;

    for (int i = 1; i < circuit->gatesPerLevel.keys().size() - 1; i++) {

        int level = circuit->gatesPerLevel.keys()[i];

        QList<Gate_BASE*> gates = circuit->gatesPerLevel[level];

        // Compute and save top region

        QRectF topSpace = QRectF(gates[0]->x(), -largestYSize / 2, gates[0]->xSize, gates[0]->y() + largestYSize / 2);

        vSpacing = new wireSpace;

        vSpacing->region = topSpace;

        circuit->wireVSpacing[level].append(vSpacing);

        // Compute and save intermediate regions

        for (int j = 0; j < gates.size() - 1; j++) {

            QRectF midSpace;

            if (gates[j]->xSize >= gates[j+1]->xSize) {

                midSpace = QRectF(gates[j]->x(), gates[j]->y() + gates[j]->ySize, gates[j]->xSize, gates[j+1]->y() - (gates[j]->y() + gates[j]->ySize));

            } else {

                midSpace = QRectF(gates[j+1]->x(), gates[j]->y() + gates[j]->ySize, gates[j+1]->xSize, gates[j+1]->y() - (gates[j]->y() + gates[j]->ySize));

            }

            vSpacing = new wireSpace;

            vSpacing->region = midSpace;

            circuit->wireVSpacing[level].append(vSpacing);

        }

        // Compute and save bottom region

        Gate_BASE *lastGate = gates[gates.size() - 1];

        QRectF botSpace = QRectF(lastGate->x(), lastGate->y() + lastGate->ySize, lastGate->xSize, largestYSize / 2 - (lastGate->y() + lastGate->ySize));

        vSpacing = new wireSpace;

        vSpacing->region = botSpace;

        circuit->wireVSpacing[level].append(vSpacing);

        // Draw regions in debug mode

#ifdef _DEBUG

        for (int j = 0; j < circuit->wireVSpacing[level].size(); j++)

            scene->addRect(circuit->wireVSpacing[level][j]->region, debugPen, QBrush(QColor(COLOR_WIRE_REGION_V)));

#endif

    }*/

    /*

    // Go through and calculate wiring region between levels

    wireSpace *hSpacing;

    for (int i = 0; i < circuit->gatesPerLevel.keys().size() - 1; i++) {

        int level = circuit->gatesPerLevel.keys()[i];

        QList<Gate_BASE*> gates = circuit->gatesPerLevel[level];

        // Compute the max X position for this level and min X position for next level

    }*/

    // Instantiate wires for each output->input connection on each gate

    QList<int> gateIDs = circuit->gateIndex.keys();

    for (int i = 0; i < gateIDs.size(); i++) {

        Gate_BASE *tmp = circuit->gateIndex[gateIDs[i]];

        // Connect each gate's input to other gate's output

        for (int j = 0; j < tmp->fanInGates.size(); j++) {

            Wire *wire = new Wire();

            wire->setPoints(tmp->fanInGates[j], tmp, j);

            // Store wires in gates on both ends

            tmp->gateInputWires.append(wire);

            tmp->fanInGates[j]->gateOutputWires.append(wire);

            // Save wire information into circuit

            circuit->wires.append(wire);

            connect(wire, SIGNAL(updateStatus(QString)), this, SIGNAL(updateStatus(QString)));

            connect(circuit, SIGNAL(toggleShowWireValues()), wire, SLOT(toggleShowValues()));

            scene->addItem(wire);

        }

    }

    scene->update();

    emit updateStatus("Circuit file successfully loaded");

}

/**

 * Zooms the canvas using matrix scaling

 */

void Canvas::zoomCanvas(int level)

{

    zoomLevel = level;

    qreal scale = qPow(qreal(2), (zoomLevel - 160) / qreal(40));

    QMatrix matrix;

    matrix.scale(scale,scale);

    setMatrix(matrix);

}

#ifndef QT_NO_WHEELEVENT

void Canvas::wheelEvent(QWheelEvent *event)

{

    // Zoom canvas on scroll wheel

    if (event->delta() > 0) {

        zoomCanvas(zoomLevel + 5);

        emit updateZoomSlider(zoomLevel + 5);

    } else {

        zoomCanvas(zoomLevel - 5);

        emit updateZoomSlider(zoomLevel - 5);

    }

    event->accept();

}

#endif

void Canvas::mousePressEvent(QMouseEvent *event)

{

    // If CTRL is held down, pan the canvas

    if (event->modifiers() & Qt::ControlModifier) {

        _pan = true;

        _panStartX = event->x();

        _panStartY = event->y();

        setCursor(Qt::ClosedHandCursor);

        event->accept();

        return;

    }

    if (circuit != NULL && circuit->circuitLoaded) {

        // Clear any previously selected gates and wires

        for (int i = 0; i < circuit->gatesPerLevel.size(); i++) {

            QList<Gate_BASE*> gates = circuit->gatesPerLevel[i];

            for (int j = 0; j < gates.size(); j++) {

                gates[j]->setHighlight(false, QColor(0,0,0,255));

            }

        }

        for (int i = 0; i < circuit->wires.size(); i++) {

            circuit->wires[i]->setHighlight(false, QColor(0,0,0,255));

        }

        updateStatus("");

    }

    // If not panning, propogate event to child objects

    QGraphicsView::mousePressEvent(event);

}

void Canvas::mouseMoveEvent(QMouseEvent *event)

{

    // Process panning if active

    if (_pan) {

        horizontalScrollBar()->setValue(horizontalScrollBar()->value() - (event->x() - _panStartX));

        verticalScrollBar()->setValue(verticalScrollBar()->value() - (event->y() - _panStartY));

        _panStartX = event->x();

        _panStartY = event->y();

        event->accept();

        return;

    }

    // Otherwise propogate event to child objects

    QGraphicsView::mouseMoveEvent(event);

}

void Canvas::mouseReleaseEvent(QMouseEvent *event)

{

    // Stop panning if active

    _pan = false;

    setCursor(Qt::ArrowCursor);

    event->accept();

    // Propogate event to child objects

    QGraphicsView::mouseReleaseEvent(event);

}