| /* |
| |
| Permission is hereby granted, free of charge, to any person |
| obtaining a copy of this software and associated documentation |
| files (the "Software"), to deal in the Software without |
| restriction, including without limitation the rights to use, |
| copy, modify, merge, publish, distribute, sublicense, and/or sell |
| copies of the Software, and to permit persons to whom the |
| Software is furnished to do so, subject to the following |
| conditions: |
| |
| The above copyright notice and this permission notice shall be |
| included in all copies or substantial portions of the Software. |
| |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES |
| OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
| HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| #include "logicunit.h" |
| #include "wire.h" |
| |
| |
| |
| |
| LogicUnit::LogicUnit(QString name, UnitType unitType, QMenu *contextMenu, |
| QGraphicsItem *parent, QGraphicsScene * /* scene */ ) |
| : QGraphicsPolygonItem(parent) |
| { |
| myUnitType = unitType; |
| myContextMenu = contextMenu; |
| myName=name; |
| myIncount = 0; |
| myLayer = 0; |
| QList<int> list; |
| myOutVal.append(list); |
| myOutVal[0].append(0); |
| hasOdinNode = false; |
| highlighted = false; |
| hasModule = false; |
| myCurrentCycle = 0; |
| |
| //different types and shapes are possible here. |
| // if the shape includes a graphic it can be added in function image() |
| switch (myUnitType) { |
| case Input: |
| myPolygon << QPointF(-50, 0) << QPointF(0, 50) |
| << QPointF(50, 0) << QPointF(0, -50) |
| << QPointF(-50, 0); |
| break; |
| case Latch: |
| myPolygon << QPointF(-50, -50) << QPointF(50, -50) |
| << QPointF(50, 50) << QPointF(-50, 50) |
| << QPointF(-50, -50) << QPointF(-50, 24) |
| << QPointF(-43, 17)<< QPointF(-50, 10); |
| |
| break; |
| case Output: |
| myPolygon << QPointF(-50, -50) << QPointF(50, -50) |
| << QPointF(0, 10) << QPointF(50, 0) |
| << QPointF(-50, -50); |
| |
| break; |
| case Clock: |
| myPolygon << QPointF(-50, 0) << QPointF(0, 50) |
| << QPointF(50, 0) << QPointF(0, -50) |
| << QPointF(-50, 0)<< QPointF(-50, 30) << QPointF(-30, 50) |
| << QPointF(30, 50) << QPointF(50, 30) |
| << QPointF(50, -30)<< QPointF(30, -50) |
| << QPointF(-30, -50)<< QPointF(-50, -30) |
| << QPointF(-50, 30); |
| break; |
| case And: |
| case Or: |
| case Nor: |
| case Not: |
| case Nand: |
| case Xor: |
| case Xnor: |
| case ADDER_FUNC: |
| case MUX: |
| case CARRY_FUNC: |
| case ADD: |
| case MINUS: |
| case MULTIPLY: |
| case MEMORY: |
| case Module: |
| myPolygon << QPointF(-50, -50) << QPointF(50, -50) |
| << QPointF(50, 50) << QPointF(-50, 50) |
| << QPointF(-50, -50); |
| break; |
| default: |
| myPolygon << QPointF(-50, 30) << QPointF(-30, 50) |
| << QPointF(30, 50) << QPointF(50, 30) |
| << QPointF(50, -30)<< QPointF(30, -50) |
| << QPointF(-30, -50)<< QPointF(-50, -30) |
| << QPointF(-50, 30); |
| break; |
| |
| } |
| setPolygon(myPolygon); |
| |
| //Object properties |
| setFlag(QGraphicsItem::ItemIsMovable, true); |
| setFlag(QGraphicsItem::ItemIsSelectable, true); |
| setFlag(QGraphicsItem::ItemSendsGeometryChanges, true); |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: removeConnection) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::removeConnection(Wire *wire) |
| { |
| int index = wires.indexOf(wire); |
| |
| if (index != -1) |
| wires.removeAt(index); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: removeConnections) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::removeConnections() |
| { |
| foreach (Wire *wire, wires) { |
| wire->startUnit()->removeConnection(wire); |
| wire->endUnit()->removeConnection(wire); |
| scene()->removeItem(wire); |
| delete wire; |
| } |
| myIncount=0; |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: addConnection) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::addConnection(Wire *wire) |
| { |
| if(myUnitType != LogicUnit::Module){ |
| //increase the input count if this instance is the ending point |
| if(wire->endUnit()->getName().compare(myName) == 0){ |
| myIncount++; |
| foreach (Wire *oldwire, wires) { |
| oldwire->setMaxNumber(myIncount); |
| } |
| wire->setNumber(myIncount); |
| wire->setMaxNumber(myIncount); |
| } |
| wires.append(wire); |
| itemChange(QGraphicsPolygonItem::ItemPositionChange,QVariant(0)); |
| }else{//I am a Module |
| if(wire->startUnit()->hasModule){ |
| //I am the start module |
| if(wire->startUnit()->getModule()->getName().compare(myName)==0){ |
| LogicUnit* startNode = wire->startUnit(); |
| if(!outNodes.contains(startNode)){ |
| outNodes.append(startNode); |
| } |
| wires.append(wire); |
| wire->setMyOutputPinNumberModule(outNodes.indexOf(startNode)+1); |
| } |
| }else if(wire->endUnit()->hasModule){ |
| //I am the end Module |
| if(wire->endUnit()->getModule()->getName().compare(myName)==0){ |
| myIncount++; |
| wires.append(wire); |
| wire->setNumberModule(myIncount); |
| } |
| } |
| } |
| |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: image) |
| *-------------------------------------------------------------------------------------------*/ |
| QPixmap* LogicUnit::image() const |
| { |
| QSize size(250,250); |
| QPixmap* pixmap = new QPixmap(size); |
| switch (myUnitType) { |
| case And: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/AND.png")); |
| pixmap->scaled(size); |
| break; |
| case Nand: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/NAND.png")); |
| pixmap->scaled(size); |
| break; |
| case Or: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/OR.png")); |
| pixmap->scaled(size); |
| break; |
| case Nor: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/NOR.png")); |
| pixmap->scaled(size); |
| break; |
| case Xor: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/XOR.png")); |
| pixmap->scaled(size); |
| break; |
| case Xnor: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/XNOR.png")); |
| pixmap->scaled(size); |
| break; |
| case Not: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/NOT.png")); |
| pixmap->scaled(size); |
| break; |
| case MUX: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/MUX.png")); |
| pixmap->scaled(size); |
| break; |
| case ADDER_FUNC: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/ADDER_FUNC.png")); |
| pixmap->scaled(size); |
| break; |
| case CARRY_FUNC: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/CARRY_FUNC.png")); |
| pixmap->scaled(size); |
| break; |
| case MULTIPLY: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/Hmult.png")); |
| pixmap->scaled(size); |
| break; |
| case ADD: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/Hadd.png")); |
| pixmap->scaled(size); |
| break; |
| case MINUS: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/Hminus.png")); |
| pixmap->scaled(size); |
| break; |
| case MEMORY: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/Hmemory.png")); |
| pixmap->scaled(size); |
| break; |
| case Module: |
| pixmap->convertFromImage(QImage(":/images/nodeTypes/module.png")); |
| pixmap->scaled(size); |
| break; |
| default: |
| pixmap->fill(Qt::transparent); |
| QPainter painter(pixmap); |
| painter.setPen(QPen(Qt::black, 8)); |
| painter.translate(125, 125); |
| painter.drawPolyline(myPolygon); |
| } |
| |
| |
| |
| return pixmap; |
| } |
| |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: contextMenuEvent) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) |
| { |
| scene()->clearSelection(); |
| setSelected(true); |
| myContextMenu->exec(event->screenPos()); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: itemChange) |
| *-------------------------------------------------------------------------------------------*/ |
| QVariant LogicUnit::itemChange(GraphicsItemChange change, |
| const QVariant &value) |
| { |
| int i = 0; |
| if (change == QGraphicsItem::ItemPositionChange) { |
| foreach (Wire *wire, wires) { |
| wire->updatePosition(); |
| i++; |
| } |
| } |
| |
| return value; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: paint) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget){ |
| QGraphicsPolygonItem::paint(painter,option,widget); |
| QImage image; |
| |
| //If a picture defines the shape, use the fullrect and draw invisible borders |
| |
| switch (myUnitType) { |
| case And: |
| image.load(":/images/nodeTypes/AND.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case Nand: |
| image.load(":/images/nodeTypes/NAND.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case Or: |
| image.load(":/images/nodeTypes/OR.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case Nor: |
| image.load(":/images/nodeTypes/NOR.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case Xor: |
| image.load(":/images/nodeTypes/XOR.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case Xnor: |
| image.load(":/images/nodeTypes/XNOR.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case Not: |
| image.load(":/images/nodeTypes/NOT.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case MUX: |
| image.load(":/images/nodeTypes/MUX.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case ADDER_FUNC: |
| image.load(":/images/nodeTypes/ADDER_FUNC.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case CARRY_FUNC: |
| image.load(":/images/nodeTypes/CARRY_FUNC.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case MEMORY: |
| image.load(":/images/nodeTypes/Hmemory.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case Module: |
| image.load(":/images/nodeTypes/module.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case MINUS: |
| image.load(":/images/nodeTypes/Hminus.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case ADD: |
| image.load(":/images/nodeTypes/Hadd.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case MULTIPLY: |
| image.load(":/images/nodeTypes/Hmult.png"); |
| painter->drawImage(boundingRect(),image); |
| break; |
| case LogicGate: |
| case Input: |
| case Output: |
| case Latch: |
| case Clock: |
| default: |
| break; |
| } |
| |
| |
| painter->setFont(QFont("Times", 9)); |
| |
| painter->setPen(QPen(Qt::red)); |
| painter->drawText(boundingRect(), |
| Qt::TextWrapAnywhere | |
| Qt::AlignVCenter | |
| Qt::AlignCenter, |
| myName); |
| painter->setPen(QPen(Qt::black)); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getName) |
| *-------------------------------------------------------------------------------------------*/ |
| QString LogicUnit::getName(){ |
| return myName; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getOutCons) |
| *-------------------------------------------------------------------------------------------*/ |
| QList<Wire *> LogicUnit::getOutCons() |
| { |
| QList<Wire *> outgoing; |
| //An outgoing connection has THIS as startUnit |
| foreach (Wire *wire,wires) { |
| if(wire->startUnit()->getName().compare(myName)==0) |
| outgoing.append(wire); |
| } |
| return outgoing; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getOutConsHash) |
| *-------------------------------------------------------------------------------------------*/ |
| QHash<QString, Wire *> LogicUnit::getOutConsHash() |
| { |
| QHash <QString, Wire *> outgoing; |
| //An outgoing connection has THIS as startUnit |
| foreach (Wire *wire,wires) { |
| if(wire->startUnit()->getName().compare(myName)==0) |
| outgoing.insert(wire->endUnit()->getName(), wire); |
| } |
| return outgoing; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: setLayer) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::setLayer(int layer) |
| { |
| myLayer = layer; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getLayer) |
| *-------------------------------------------------------------------------------------------*/ |
| int LogicUnit::getLayer() |
| { |
| return myLayer; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: updateWires) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::updateWires() |
| { |
| foreach(Wire *wire, wires){ |
| wire->updateWireStatus(); |
| wire->updatePosition(); |
| } |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: setName) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::setName(QString name) |
| { |
| myName = name; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getAllCons) |
| *-------------------------------------------------------------------------------------------*/ |
| QList<Wire *> LogicUnit::getAllCons() |
| { |
| return wires; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getOutValue) |
| *-------------------------------------------------------------------------------------------*/ |
| /** |
| *returns the value of pinNumber. pinNumber starts with 1. |
| */ |
| int LogicUnit::getOutValue(int pinNumber) |
| { |
| /*During the creation of the node the |
| Output count might be unknown. Connections |
| know their output pin. If the connection requests a higher number |
| than numbers available, add zeros.*/ |
| //FIXME read above |
| while(pinNumber>myOutVal.size()){ |
| //add zeros until size is big enough in |
| //case the list was not expanded yet. |
| QList<int> list; |
| myOutVal.append(list); |
| myOutVal[myOutVal.size()-1].append(0); |
| } |
| |
| //append cycles if required |
| while(myCurrentCycle>=myOutVal[pinNumber-1].size()){ |
| //add zeros until size is big enough in |
| //case the list was not expanded yet. |
| myOutVal[pinNumber].append(0); |
| } |
| |
| //pinNumber-1 as wire objects start numbering with 1 instead of 0 |
| return myOutVal[pinNumber-1].at(myCurrentCycle); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: setOutValue) |
| *-------------------------------------------------------------------------------------------*/ |
| /*Sets the output value(starts with 0) of the logic block. Only 1 and 0 can be set. |
| If the variable 'value' is greater that 1 it is set to 1. If its smaller than 0 it is 0*/ |
| int LogicUnit::setOutValue(int pinNumber, int value, int cycle) |
| { |
| int result = -1; |
| |
| //append outputs if needed |
| while(pinNumber>=myOutVal.size()){ |
| //add zeros until size is big enough in |
| //case the list was not expanded yet. |
| QList<int> list; |
| myOutVal.append(list); |
| myOutVal[myOutVal.size()-1].append(0); |
| } |
| |
| //append cycles if required |
| while(cycle>=myOutVal[pinNumber].size()){ |
| //add zeros until size is big enough in |
| //case the list was not expanded yet. |
| myOutVal[pinNumber].append(0); |
| } |
| |
| //make sure only 1, 0 and -1 are legal |
| //all illegal values are made -1 |
| if(value == 1){ |
| myOutVal[pinNumber].replace(cycle, value); |
| result = 1; |
| }else if(value == 0){ |
| myOutVal[pinNumber].replace(cycle, value); |
| result = 1; |
| }else{ |
| myOutVal[pinNumber].replace(cycle, -1); |
| result = 1; |
| } |
| return result; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: setOdinRef) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::setOdinRef(nnode_t *odinNode) |
| { |
| myOdinNode = odinNode; |
| hasOdinNode = true; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getOdinRef) |
| *-------------------------------------------------------------------------------------------*/ |
| nnode_t * LogicUnit::getOdinRef() |
| { |
| return myOdinNode; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: hasOdinReference) |
| *-------------------------------------------------------------------------------------------*/ |
| bool LogicUnit::hasOdinReference() |
| { |
| return hasOdinNode; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getParents) |
| *-------------------------------------------------------------------------------------------*/ |
| QList<LogicUnit*> LogicUnit::getParents() |
| { |
| QList<LogicUnit*> result; |
| foreach(Wire* wire, wires){ |
| if(wire->endUnit()->getName().compare(myName) == 0){ |
| result.append(wire->startUnit()); |
| } |
| } |
| return result; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: isHighlighted) |
| *-------------------------------------------------------------------------------------------*/ |
| bool LogicUnit::isHighlighted() |
| { |
| return highlighted; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: setHighlighted) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::setHighlighted(bool value) |
| { |
| highlighted = value; |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: setCurrentCycle) |
| *-------------------------------------------------------------------------------------------*/ |
| void LogicUnit::setCurrentCycle(int cycle) |
| { |
| myCurrentCycle = cycle; |
| updateWires(); |
| } |
| |
| bool LogicUnit::isShown() |
| { |
| return shown; |
| } |
| |
| void LogicUnit::setShown(bool value) |
| { |
| shown = value; |
| setVisible(value); |
| } |
| |
| /*--------------------------------------------------------------------------------------------- |
| * (function: getChildren) |
| *-------------------------------------------------------------------------------------------*/ |
| QList<LogicUnit*> LogicUnit::getChildren(){ |
| QList<LogicUnit*> children; |
| //An outgoing connection has THIS as startUnit |
| foreach (Wire *wire,wires) { |
| if(wire->startUnit()->getName().compare(myName)==0) |
| children.append(wire->endUnit()); |
| } |
| |
| return children; |
| } |
| |
| /* |
| Connects modules with nodes and the other way round |
| */ |
| void LogicUnit::addPartner(LogicUnit *partner) |
| { |
| moduleViewPartners.append(partner); |
| if(myUnitType != LogicUnit::Module) |
| hasModule = true; |
| } |
| |
| LogicUnit * LogicUnit::getModule() |
| { |
| return moduleViewPartners.at(0); |
| } |
| |
| int LogicUnit::getMaxOutNumber() |
| { |
| return outNodes.count(); |
| } |
| |
| int LogicUnit::getMaxNumber() |
| { |
| return myIncount; |
| } |
| |
| void LogicUnit::showActivity() |
| { |
| int activity = 0; |
| |
| if(wires.count()>0){ |
| foreach(Wire* wire, wires){ |
| activity += wire->getActivity(); |
| } |
| activity = activity / wires.count(); |
| setBrush(QColor(activity,255-activity,0)); |
| } |
| |
| |
| } |
| |
