265 lines
10 KiB
C++
265 lines
10 KiB
C++
#include "component_display.h"
|
|
#include "schema_display.h"
|
|
|
|
#include <QDrag>
|
|
#include <QDragEnterEvent>
|
|
#include <QMimeData>
|
|
|
|
namespace display {
|
|
|
|
Schema::Schema()
|
|
{
|
|
this->selectedBrush.setColor(QColor::fromRgb(20,20,125));
|
|
this->selectedPen.setColor(QColor::fromRgb(20, 20, 125));
|
|
|
|
this->setScene(&scene);
|
|
this->setAcceptDrops(true);
|
|
}
|
|
|
|
|
|
void Schema::setSchema(domain::Schema* _schema, domain::Library* _library)
|
|
{
|
|
components.clear();
|
|
buses.clear();
|
|
|
|
scene.clear();
|
|
busConnections.clear();
|
|
this->schema = _schema;
|
|
this->library = _library;
|
|
if(schema != nullptr) {
|
|
for(auto &instance: schema->componentInstances) {
|
|
auto group = new display::ComponentGroup(instance);
|
|
for(auto pin: group->getPins()) {
|
|
display::Pin* p = pin;
|
|
domain::ConnectionComponent connection{instance->name, p->getPin().getName()};
|
|
pins.insert(std::make_pair(connection, p));
|
|
}
|
|
components.insert(std::make_pair(instance->name, group));
|
|
scene.addItem(group);
|
|
}
|
|
for(auto &instance: schema->busInstances) {
|
|
if(instance->bus.getDisplay().has_value()) {
|
|
auto group = new display::BusGroup(instance);
|
|
buses.insert(std::make_pair(instance->name, group));
|
|
scene.addItem(group);
|
|
}
|
|
}
|
|
for(auto &connection: schema->connections) {
|
|
auto busInstance = dynamic_cast<domain::BusConnectionInstance*>(connection.get());
|
|
if(busInstance != nullptr) {
|
|
auto con = new display::BusConnection(busInstance, components[busInstance->instance->name], buses[busInstance->bus->name]);
|
|
busConnections.push_back(con);
|
|
scene.addItem(con);
|
|
}
|
|
auto directInstance = dynamic_cast<domain::DirectConnectionInstance*>(connection.get());
|
|
if(directInstance != nullptr) {
|
|
auto con = new display::DirectConnection(directInstance, components[directInstance->instance->name], components[directInstance->secondInstance->name]);
|
|
directConnections.push_back(con);
|
|
scene.addItem(con);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Schema::updateConnections() {
|
|
if(schema != nullptr) {
|
|
for(auto conn: busConnections) {
|
|
conn->updateConnection();
|
|
}
|
|
for(auto conn: directConnections) {
|
|
conn->updateConnection();
|
|
}
|
|
}
|
|
}
|
|
|
|
void Schema::dragEnterEvent(QDragEnterEvent *event) {
|
|
if(event->mimeData()->hasFormat("comdel/component") ||
|
|
event->mimeData()->hasFormat("comdel/bus")) {
|
|
event->acceptProposedAction();
|
|
}
|
|
}
|
|
|
|
void Schema::dropEvent(QDropEvent *event) {
|
|
if(event->mimeData()->hasFormat("comdel/component")) {
|
|
auto component = library->getComponent(event->mimeData()->data("comdel/component").toStdString());
|
|
|
|
auto attributes = std::vector<domain::InstanceAttribute>();
|
|
for(auto attr: component.getAttributes()) {
|
|
attributes.emplace_back(attr.getName(), attr.getDefault(), attr);
|
|
}
|
|
|
|
auto currentPos = this->mapToScene(event->pos());
|
|
|
|
auto instance = std::make_shared<domain::ComponentInstance>(component.getInstanceName(), attributes, std::make_pair(currentPos.x(), currentPos.y()), component);
|
|
schema->componentInstances.push_back(instance);
|
|
|
|
auto group = new display::ComponentGroup(instance);
|
|
scene.addItem(group);
|
|
for(auto pin: group->getPins()) {
|
|
display::Pin* p = pin;
|
|
domain::ConnectionComponent connection{instance->name, p->getPin().getName()};
|
|
pins.insert(std::make_pair(connection, p));
|
|
}
|
|
|
|
components[instance->name] = group;
|
|
|
|
event->acceptProposedAction();
|
|
}
|
|
if(event->mimeData()->hasFormat("comdel/bus")) {
|
|
auto bus = library->getBus(event->mimeData()->data("comdel/bus").toStdString());
|
|
|
|
auto currentPos = this->mapToScene(event->pos());
|
|
|
|
auto instance = std::make_shared<domain::BusInstance>(bus.getName(), std::make_pair(currentPos.x(), currentPos.y()), bus, 50);
|
|
schema->busInstances.push_back(instance);
|
|
|
|
auto group = new display::BusGroup(instance);
|
|
scene.addItem(group);
|
|
buses[instance->name] = group;
|
|
|
|
event->acceptProposedAction();
|
|
}
|
|
}
|
|
|
|
void Schema::dragMoveEvent(QDragMoveEvent *event) {
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
void Schema::removeConnectable(QPointF endPoint) {
|
|
auto instance = context.pin->getComponentInstance();
|
|
auto& pin = context.pin->getPin();
|
|
|
|
auto busInstances = getAvailableConnectionBusses(instance, pin);
|
|
|
|
for(auto &bus: busInstances) {
|
|
auto rect = buses[bus->name]->boundingRect();
|
|
rect = QRectF(buses[bus->name]->x(), buses[bus->name]->y(), rect.width(), rect.height());
|
|
|
|
if(rect.contains(endPoint)) {
|
|
auto con = library->getConnection({instance->component.getName(), pin.getName()}, bus->bus.getName());
|
|
if(con.has_value()) {
|
|
std::vector<domain::InstanceAttribute> attributes;
|
|
for(auto attr: con->getAttributes()) {
|
|
attributes.emplace_back(attr.getName(), attr.getDefault(), attr);
|
|
}
|
|
|
|
auto conInstance = std::make_shared<domain::BusConnectionInstance>(instance, attributes, bus, *con);
|
|
schema->connections.push_back(conInstance);
|
|
|
|
if (conInstance != nullptr) {
|
|
auto c = new display::BusConnection(conInstance.get(), components[conInstance->instance->name],
|
|
buses[conInstance->bus->name]);
|
|
busConnections.push_back(c);
|
|
scene.addItem(c);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
auto pinInstances = getAvailableConnectionPins(instance, pin);
|
|
|
|
for(auto &pinInstance: pinInstances) {
|
|
auto rect = pins[pinInstance]->boundingRect();
|
|
rect.setX(pins[pinInstance]->scenePos().x());
|
|
rect.setY(pins[pinInstance]->scenePos().y());
|
|
|
|
if(rect.contains(endPoint)) {
|
|
auto name = components[pinInstance.component]->getComponentInstance()->component.getName();
|
|
auto con = library->getConnection({instance->component.getName(), pin.getName()}, {name, pinInstance.pin});
|
|
if(con.has_value()) {
|
|
auto bus = library->getBus(con->getBus());
|
|
auto busInstance = std::make_shared<domain::BusInstance>(bus.getName(), bus);
|
|
schema->busInstances.push_back(busInstance);
|
|
|
|
std::vector<domain::InstanceAttribute> attributes;
|
|
for(auto attr: con->getAttributes()) {
|
|
attributes.emplace_back(attr.getName(), attr.getDefault(), attr);
|
|
}
|
|
|
|
auto conInstance = std::make_shared<domain::DirectConnectionInstance>(instance, components[pinInstance.component]->getComponentInstance().get(), attributes, busInstance.get(), *con);
|
|
schema->connections.push_back(conInstance);
|
|
|
|
if (conInstance != nullptr) {
|
|
auto c = new display::DirectConnection(conInstance.get(), components[conInstance->instance->name], components[conInstance->secondInstance->name]);
|
|
directConnections.push_back(c);
|
|
scene.addItem(c);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
updateConnections();
|
|
|
|
|
|
for(auto& item: this->context.selectable) {
|
|
this->scene.removeItem(item);
|
|
delete item;
|
|
}
|
|
this->context.selectable.clear();
|
|
}
|
|
|
|
void Schema::showConnectable(Pin *domainPin) {
|
|
auto& pin = domainPin->getPin();
|
|
|
|
auto busInstances = getAvailableConnectionBusses(domainPin->getComponentInstance(), domainPin->getPin());
|
|
|
|
for(auto bus: busInstances) {
|
|
auto& group = buses[bus->name];
|
|
auto rect = new QGraphicsRectItem(group->boundingRect());
|
|
rect->setPen(selectedPen);
|
|
rect->setPos(group->scenePos());
|
|
|
|
auto _rect = rect->rect();
|
|
_rect.setWidth(_rect.width() + 1);
|
|
_rect.setHeight(_rect.height() + 1);
|
|
rect->setRect(_rect);
|
|
|
|
context.selectable.push_back(rect);
|
|
scene.addItem(rect);
|
|
}
|
|
|
|
std::vector<domain::ConnectionComponent> pinInstances = getAvailableConnectionPins(domainPin->getComponentInstance(), domainPin->getPin());
|
|
|
|
for(auto& pinInstance: pinInstances) {
|
|
auto& instance = pins[pinInstance];
|
|
auto rect = new QGraphicsRectItem(instance->boundingRect());
|
|
rect->setPen(selectedPen);
|
|
rect->setPos(instance->scenePos());
|
|
|
|
auto _rect = rect->rect();
|
|
_rect.setWidth(_rect.width() + 1);
|
|
_rect.setHeight(_rect.height() + 1);
|
|
rect->setRect(_rect);
|
|
|
|
context.selectable.push_back(rect);
|
|
scene.addItem(rect);
|
|
}
|
|
|
|
}
|
|
|
|
std::vector<domain::BusInstance*> Schema::getAvailableConnectionBusses(domain::ComponentInstance *instance, domain::Pin &pin) {
|
|
std::vector<domain::BusInstance*> instances;
|
|
for(const auto& bus: schema->busInstances) {
|
|
if(library->hasConnection(domain::ConnectionComponent{instance->component.getName(), pin.getName()}, bus->bus.getName())) {
|
|
instances.push_back(bus.get());
|
|
}
|
|
}
|
|
return instances;
|
|
}
|
|
|
|
std::vector<domain::ConnectionComponent> Schema::getAvailableConnectionPins(domain::ComponentInstance *instance, domain::Pin &pin) {
|
|
std::vector<domain::ConnectionComponent> instances;
|
|
domain::ConnectionComponent source{instance->component.getName(), pin.getName()};
|
|
for(const auto& entry: pins) {
|
|
std::string name = components[entry.first.component]->getComponentInstance()->component.getName();
|
|
if(library->hasConnection(source, domain::ConnectionComponent{name, entry.first.pin})) {
|
|
instances.push_back(entry.first);
|
|
}
|
|
}
|
|
return instances;
|
|
}
|
|
|
|
} // namespace display
|