editor/plc.cpp

#include "plc.h"
#include "ui_plc.h"
#include "item.h"

#include <QListWidgetItem>
#include <QMimeData>
#include <QDrag>
#include <QPainter>
#include <QMouseEvent>
#include <QDropEvent>
#include <QGraphicsView>
#include <QMessageBox>
#include "creatitem.h"

PLC::PLC(RegisterManager *regManager, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::PLC),
    registerManager(regManager)
{
    ui->setupUi(this);
//    modbusManager = new ModbusManager(registerManager, this);
    /* 1. 场景 */
    plc_scene_ = new QGraphicsScene(this);
    ui->graphicsView->setScene(plc_scene_);
    ui->graphicsView->setSceneRect(0, 0, 800, 600);
    ui->graphicsView->setDragMode(QGraphicsView::RubberBandDrag);

    /* 2. 列表 */
    ui->listWidget->setViewMode(QListView::IconMode);
    ui->listWidget->setIconSize(QSize(60, 30));
    ui->listWidget->setDragEnabled(false);
    ui->listWidget->viewport()->installEventFilter(this);

    /* 3. 填充列表 */
    createComponents();
    connect(ui->listWidget,&QListWidget::currentTextChanged,this,&PLC::onListwidgetCurrenttextchanged);
    connect(ui->btn_insert,&QPushButton::clicked,this,&PLC::btnInsertClicked);
//    connect(modbusManager, &ModbusManager::connectionStatusChanged,
//            this, &PLC::updateConnectionStatus);
//    connect(modbusManager, &ModbusManager::errorOccurred,
//            this, &PLC::handleModbusError);
    connect(ui->graphicsView, &MyGraphicsView::itemBoundToRegister,
            registerManager, &RegisterManager::bindItem);
    connect(ui->graphicsView, &MyGraphicsView::itemResetRegister,
            registerManager, &RegisterManager::unbindItem);
//    connect(this, &PLC::requestWriteRegister,
//            modbusManager, &ModbusManager::writeRegister);
}

PLC::~PLC()
{
    delete ui;
}

bool PLC::eventFilter(QObject *obj, QEvent *event)
{
    if (obj == ui->listWidget->viewport()) {
        static QListWidgetItem *dragItem = nullptr;
        static QPoint startPos;

        if (event->type() == QEvent::MouseButtonPress) {
            auto *me = static_cast<QMouseEvent*>(event);
            if (me->button() == Qt::LeftButton) {
                dragItem  = ui->listWidget->itemAt(me->pos());
                startPos  = me->pos();
            }
        } else if (event->type() == QEvent::MouseMove && dragItem) {
            auto *me = static_cast<QMouseEvent*>(event);
            if ((me->pos() - startPos).manhattanLength()
                    >= QApplication::startDragDistance()) {

                QString type = dragItem->data(Qt::UserRole).toString();

                QMimeData *mime = new QMimeData;
                mime->setData("application/x-component", type.toUtf8());

                QDrag *drag = new QDrag(this);
                drag->setMimeData(mime);
                drag->setPixmap(dragItem->icon().pixmap(ui->listWidget->iconSize()));
                drag->setHotSpot(drag->pixmap().rect().center());
                drag->exec(Qt::CopyAction);

                dragItem = nullptr;
            }
        } else if (event->type() == QEvent::MouseButtonRelease) {
            dragItem = nullptr;
        }
    }
    return QWidget::eventFilter(obj, event);
}

void PLC::createComponents()
{
    struct Comp { QString name; QColor color; };
    const QVector<Comp> comps = {
        {"常开",     Qt::blue},
        {"常闭",     Qt::red},
        {"比较", Qt::green},
        {"线圈",     Qt::darkYellow}
    };

    for (const Comp &c : comps) {
        QListWidgetItem *it = new QListWidgetItem(c.name, ui->listWidget);

        QPixmap pix(60, 30);
        pix.fill(Qt::white);
        QPainter p(&pix);
        p.setRenderHint(QPainter::Antialiasing);
        p.setBrush(c.color.lighter(150));
        p.setPen(QPen(c.color, 2));
        p.drawRoundedRect(QRect(5, 5, 50, 20), 3, 3);
        p.setPen(Qt::black);
        p.drawText(QRect(5, 5, 50, 20), Qt::AlignCenter, c.name);

        it->setIcon(QIcon(pix));
        it->setData(Qt::UserRole, c.name);
    }
}

void PLC::clearScene()
{
    plc_scene_->clear();
}

void PLC::applyProjectToScene(const Project& proj)
{
    clearScene();
    QVector<Item*> itemObjs;
    for (const auto& d : proj.items_) {
        Item* item = creatItem(d.type);
        if (!item) continue;
        item->setPos(d.x, d.y);
        item->setRegisterId(d.registerId);
        connect(item, &Item::requestCopy, ui->graphicsView, &MyGraphicsView::onItemRequestCopy);
        connect(item, &Item::requestDelete, ui->graphicsView, &MyGraphicsView::onItemRequestDelete);
        connect(item, &Item::requestBindRegister, ui->graphicsView, &MyGraphicsView::onItemRequestBindRegister);
        plc_scene_->addItem(item);
        registerManager->bindItem(item,d.registerId);
        itemObjs.append(item);
    }
    for (const auto& c : proj.connections_) {
        if (c.from >= 0 && c.from < itemObjs.size() && c.to >= 0 && c.to < itemObjs.size()) {
            Connection* conn = new Connection(
                itemObjs[c.from], static_cast<Item::AnchorType>(c.fromType),
                itemObjs[c.to], static_cast<Item::AnchorType>(c.toType));
            plc_scene_->addItem(conn);
        }
    }
}

void PLC::extractSceneToProject(Project& proj)
{
    proj.clear();
    QList<Item*> items;
    // (1) 先收集所有Item
    for (QGraphicsItem* gi : plc_scene_->items()) {
        if (Item* it = dynamic_cast<Item*>(gi)) {
            items.append(it);
        }
    }
    // (2) 存Item数据
    for (Item* it : items) {
        Project::ItemData d;
        d.type = it->itemType();
        d.x = it->pos().x();
        d.y = it->pos().y();
        d.registerId = it->registerId();
        proj.items_.append(d);
    }
    // (3) 存连线数据
    for (QGraphicsItem* gi : plc_scene_->items()) {
        if (Connection* conn = dynamic_cast<Connection*>(gi)) {
            int fromIdx = items.indexOf(conn->from_);
            int toIdx = items.indexOf(conn->to_);
            if (fromIdx >= 0 && toIdx >= 0) {
                Project::ConnectionData c;
                c.from = fromIdx;
                c.to = toIdx;
                c.fromType = static_cast<int>(conn->fromType_);
                c.toType = static_cast<int>(conn->toType_);
                proj.connections_.append(c);
            }
        }
    }
}

void PLC::onListwidgetCurrenttextchanged(const QString &text)
{
    selectedComponentType = text;
}

void PLC::btnInsertClicked()
{
    // 1. 找场景中被选中的连线
       QList<QGraphicsItem*> selectedItems = ui->graphicsView->scene()->selectedItems();
       Connection* selectedConn = nullptr;
       for (QGraphicsItem* item : selectedItems) {
           selectedConn = dynamic_cast<Connection*>(item);
           if (selectedConn) break;
       }
       if (!selectedConn) {
           QMessageBox::warning(this, "提示", "请先选中一条连线");
           return;
       }
       if (selectedComponentType.isEmpty()) {
           QMessageBox::warning(this, "提示", "请先在列表中选择要插入的组件");
           return;
       }

       // 2. 计算插入点（中点）
       QLineF lf = selectedConn->line();
       QPointF insertPos = (lf.p1() + lf.p2()) / 2;

       // 3. 删除原连线
       Item* from = selectedConn->from_;
       Item* to = selectedConn->to_;
       Item::AnchorType fromType = selectedConn->fromType_;
       Item::AnchorType toType = selectedConn->toType_;

       from->removeConnection(selectedConn);
       to->removeConnection(selectedConn);
       ui->graphicsView->scene()->removeItem(selectedConn);
       delete selectedConn;

       // 4. 插入新元件
       Item* newItem = creatItem(selectedComponentType);
       newItem->setPos(insertPos);
       connect(newItem, &Item::requestCopy, ui->graphicsView, &MyGraphicsView::onItemRequestCopy);
       connect(newItem, &Item::requestDelete, ui->graphicsView, &MyGraphicsView::onItemRequestDelete);
       connect(newItem, &Item::requestBindRegister, ui->graphicsView, &MyGraphicsView::onItemRequestBindRegister);
       ui->graphicsView->scene()->addItem(newItem);

       // 5. 新建两条连线
       Connection* c1 = new Connection(from, fromType, newItem, Item::Left);
       ui->graphicsView->scene()->addItem(c1);
       Connection* c2 = new Connection(newItem, Item::Right, to, toType);
       ui->graphicsView->scene()->addItem(c2);
}

void PLC::updateConnectionStatus(bool connection)
{
    if (connection)
    {
        ui->textEdit->append("连接");
    }
    else
    {
        ui->textEdit->append("断开");
    }
}