Subversion Repositories Code-Repo

#include "Wire.h"

Wire::Wire(QGraphicsItem *parent) :

    QGraphicsObject(parent)

{

    setFlags(ItemIsSelectable);

    createActions();

    this->auxSelected = false;

    this->showValues = true;

    // Create the default pens to draw with

    this->defaultPen = QPen(QColor(COLOR_MAIN), DEFAULT_LINE_WIDTH, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);

    this->defaultBrush = QBrush(Qt::NoBrush);

    this->selectedPen = QPen(QColor(COLOR_MAIN_SELECTED), DEFAULT_LINE_WIDTH, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);

    this->highlightedPen = QPen(QColor(COLOR_MAIN_SELECTED), DEFAULT_LINE_WIDTH, Qt::SolidLine, Qt::RoundCap, Qt::RoundJoin);

    this->defaultFont = QFont("Consolas", 20);

    this->wireValue = logicValue_X;

    this->wireFaultyValue = logicValue_X;

    this->valueString = "X/X";

#ifdef _DEBUG

    this->debugPen = QPen(QColor(COLOR_DEBUG), 1, Qt::DashLine);

    this->debugBrush = QBrush(Qt::NoBrush);

    this->debugSelectedPen = QPen(QColor(COLOR_DEBUG_SELECTED), 1, Qt::DashLine);

    this->debugErrorPen = QPen(QColor(COLOR_DEBUG_ERROR), 2, Qt::DashLine);

#endif

}

Wire::~Wire()

{

}

QRectF Wire::boundingRect() const

{

    QMargins margin(SELECTION_WIDTH, SELECTION_WIDTH, SELECTION_WIDTH, SELECTION_WIDTH);

    return bRect + margin;

}

QPainterPath Wire::shape() const

{

    return shapeArea;

}

void Wire::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

{

    Q_UNUSED(widget);

    Q_UNUSED(option);

#ifdef _DEBUG

    painter->save();

    painter->setPen((auxSelected) ? debugSelectedPen : debugPen);

    painter->setBrush(debugBrush);

    painter->drawRect(this->boundingRect());

    painter->drawPath(shapeArea);

    painter->restore();

#endif

    // Set line color accordingly

    if (auxSelected) painter->setPen(highlightedPen);

    else painter->setPen(defaultPen);

    painter->setBrush(defaultBrush);

    // Draw the line

    painter->drawPath(line);

    QPainterPath textBox;

    textBox.addText(0, 0, defaultFont, valueString);

    // Draw the text (wire value)

    if (showValues) {

        QPainterPath text;

        text.addText(bRect.center().x() - (textBox.boundingRect().width() / 2),

                     bRect.center().y() + (textBox.boundingRect().height() / 2) - 2,

                     defaultFont, valueString);

        QPainterPathStroker stroker;

        stroker.setCapStyle(Qt::RoundCap);

        stroker.setJoinStyle(Qt::RoundJoin);

        stroker.setWidth(10);

        QPainterPath textOutline = stroker.createStroke(text);

        painter->save();

        painter->setPen(QPen(Qt::white));

        painter->setBrush(QBrush(Qt::white));

        painter->drawPath(textOutline);

        painter->restore();

        painter->drawPath(text);

    }

}

/**

 * Draw line from given point to point

 */

void Wire::setPoints(Gate_BASE *source, Gate_BASE *sink, int sinkID)

{

    this->gateOutput = source;

    this->gateInput = sink;

    this->gateInputID = sinkID;

    // Calculate the bounding box of this line (normalized)

    bRect = QRectF(gateOutput->gateOutputPoint, gateInput->gateInputPoints[gateInputID]).normalized();

    // Move box to center of object

    QPointF center = bRect.center();

    bRect.translate(- center.x(), - center.y());

    // Calculate new I/O points in local coordinates

    QPointF tOutput = gateOutput->gateOutputPoint - center;

    QPointF tInput = gateInput->gateInputPoints[gateInputID] - center;

    // Draw the line

    linePoints.append(tOutput);

    linePoints.append(QPointF(bRect.center().x(), tOutput.y()));

    linePoints.append(QPointF(bRect.center().x(), tInput.y()));

    linePoints.append(tInput);

    line.moveTo(linePoints[0]);

    for (int i = 1; i < linePoints.size(); i++) {

        line.lineTo(linePoints[i]);

    }

    // Stroke the line to allow for selection

    QPainterPathStroker stroke;

    stroke.setWidth(SELECTION_WIDTH);

    shapeArea = stroke.createStroke(line);

    // Move wire on canvas to proper location

    this->setPos(center.x(), center.y());

    prepareGeometryChange();

}

/**

 * Sets the color of the pen drawing the line

 */

void Wire::setPenColor(QColor color)

{

    this->defaultPen.setColor(color);

}

/**

 * Sets the highlight color when wire is selected

 */

void Wire::setHighlight(bool state, QColor color)

{

    auxSelected = state;

    if (state) {

        highlightedPen.setColor(color);

        setZValue(SELECTED_Z);

    } else {

        setZValue(WIRE_DEFAULT_Z);

    }

    update();

}

/**

 * Resets the value of the wire to unknown 'X'

 */

void Wire::reset()

{

    setValue(logicValue_X, logicValue_X);

    update();

}

/**

 * Toggles if wire values should be shown

 */

void Wire::toggleShowValues()

{

    showValues = !showValues;

    update();

}

/**

 * Sets the value of the wire

 */

void Wire::setValue(logicValue value, logicValue faultyValue, bool recurse)

{

    wireValue = value;

    wireFaultyValue = faultyValue;

    // Compute the status string

    valueString = "";

    if (wireValue == logicValue_0) valueString += "0";

    else if (wireValue == logicValue_1) valueString += "1";

    else valueString += "X";

    valueString += "/";

    if (wireFaultyValue == logicValue_0) valueString += "0";

    else if (wireFaultyValue == logicValue_1) valueString += "1";

    else valueString += "X";

    // Propogate value to sink/source gates

    gateInput->setInputValue(gateInputID, wireValue, wireFaultyValue);

    gateInput->setOutputValue(wireValue, wireFaultyValue);

    // Propogate to gates if necessary

    if (recurse) {

        for (int i = 0; i < gateOutput->gateOutputWires.size(); i++) {

            gateOutput->gateOutputWires[i]->setValue(wireValue, wireFaultyValue, false);

        }

    }

    update();

}

void Wire::mousePressEvent(QGraphicsSceneMouseEvent *event)

{

    QString status = QString("Wire Source: Gate %1 | Sink: Gate %2 | Value: ").arg(gateOutput->gateID).arg(gateInput->gateID);

    status += valueString;

    emit updateStatus(status);

    // On selection, highlight sink and source gates

    setZValue(1);

    setHighlight(true, QColor(COLOR_MAIN_SELECTED));

    gateOutput->setHighlight(true, QColor(COLOR_OUTPUT_SELECTED));

    gateInput->setHighlight(true, QColor(COLOR_INPUT_SELECTED));

    event->accept();

}

void Wire::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)

{

    QMenu menu;

    menu.addAction(injectValueAction);

    menu.addAction(injectFaultAction);

    menu.addAction(resetValuesAction);

    menu.exec(event->screenPos());

    event->accept();

}

void Wire::createActions()

{

    injectValueAction = new QAction("&Set Value", this);

    connect(injectValueAction, SIGNAL(triggered()), this, SLOT(promptValue()));

    injectFaultAction = new QAction("&Inject Fault", this);

    connect(injectFaultAction, SIGNAL(triggered()), this, SLOT(promptFaultyValue()));

    resetValuesAction = new QAction("&Reset Values", this);

    connect(resetValuesAction, SIGNAL(triggered()), this, SLOT(reset()));

}

void Wire::promptValue()

{

    bool ok;

    QStringList options;

    options << "0" << "1";

    QString sel = QInputDialog::getItem(0, "Choose Value", "Enter Value:", options, 0, false, &ok);

    if (ok && !sel.isEmpty()) {

        if (sel == "0") setValue(logicValue_0, logicValue_0);

        else if (sel == "1") setValue(logicValue_1, logicValue_1);

        else setValue(logicValue_X, logicValue_X);

    }

}

void Wire::promptFaultyValue()

{

    bool ok;

    QStringList options;

    options << "0" << "1";

    QString sel = QInputDialog::getItem(0, "Choose Value", "Enter Faulty Value:", options, 0, false, &ok);

    if (ok && !sel.isEmpty()) {

        if (sel == "0") setValue(logicValue_1, logicValue_0);

        else if (sel == "1") setValue(logicValue_0, logicValue_1);

        else setValue(logicValue_X, logicValue_X);

    }

}