DiagramDesigner/diagramCavas/source/diagramCavas.cpp

#include <QMdiSubWindow>
#include <QMessageBox>
#include <QJsonObject>
#include <QStandardItem>
#include <QLibrary>
#include <QMetaMethod>
#include <QApplication>
#include "monitorPanel.h"
#include "diagramCavas.h"
#include "dataBase.h"
#include "graphicsItem/graphicsBaseItem.h"
#include "projectModelManager.h"
#include "topologyManager.h"
#include "powerEntity.h"
#include "cornerMonitorLauncher.h"
#include "loadMonitorPageDlg.h"
#include "diagramConnectSetting.h"
#include "diagramCommunication/include/communicationManager.h"
#include "diagramCommunication/include/configManager.h"
#include "instance/dataAccessor.h"
#include "uiCommunicationBus.h"
#include "itemPropertyDlg.h"
#include "monitorConfigDlg.h"
#include "structDataPreviewDlg.h"
#include "extraPropertyManager.h"
#include "createHMIdlg.h"
#include "pluginManager.h"
#include "graphicsItem/pluginItemFactory.h"

#include "QQuickDetailsViewMananger.h"
#include "propertyType/propertyTypeCustomization_DataSourceType.h"
#include "propertyType/dataSourceType.h"

#include "basePannelPropertyProxy.h"

DiagramCavas::DiagramCavas(QWidget *parent)
    : QMdiArea(parent)
    ,_cornerButton(nullptr)
    ,_loadMonitorPageDlg(nullptr)
    ,_connectSetting(nullptr)
    ,_dataAccessor(nullptr)
    ,_structDataPreviewDlg(nullptr)
    ,_extraPropertyManager(nullptr)
    ,_createHMIDlg(nullptr)
    ,m_pluginManager(nullptr)
    ,m_itemFactory(nullptr)
{
    _pageIndex = 0;
}

DiagramCavas::~DiagramCavas()
{
    disconnect();       //断开连接避免动态库释放时信号问题
}

MonitorPanel* DiagramCavas::getMonitorPanel(QString sPage)
{
    if(m_mapMonitorPanel.contains(sPage))
        return m_mapMonitorPanel[sPage].first;
    return nullptr;
}

void DiagramCavas::updateSubPos()
{
    if(_cornerButton)
        _cornerButton->positionAtCorner();
}

void DiagramCavas::passRecommmandHttpData(HttpRecommandInfo info)
{
    if(_structDataPreviewDlg){      //数据预览dlg
        QStringList lst;
        for(auto &str:info.lstRecommand){
            QString sCompleteName = info.sInput+str;
            if(!lst.contains(sCompleteName))
                lst.append(sCompleteName);
        }
        _structDataPreviewDlg->updateRecommandLst(lst);
    }
    //===============================================
    QMdiSubWindow* pSub = currentSubWindow();
    if(!pSub)
        return;
    QWidget* pWindow= pSub->widget();
    BaseDrawingPanel* pPanel = dynamic_cast<BaseDrawingPanel*>(pWindow);
    if(pPanel)
    {
        if(pPanel->getMode() == DM_run)
        {
            auto pMonitor = dynamic_cast<MonitorPanel*>(pPanel);
            if(pMonitor){
                auto pDlg = pMonitor->getMonitorConfigDlg();
                if(pDlg){

                    QStringList lst;
                    for(auto &str:info.lstRecommand){
                        QString sCompleteName = info.sInput+str;
                        if(!lst.contains(sCompleteName))
                            lst.append(sCompleteName);
                    }
                    pDlg->updateRecommandLst(lst);
                }
                //FixedPortsModel* pModel = pMonitor->getModelController();
            }
        }
    }
}

void DiagramCavas::initial()
{
    //todo:读取数据并初始化
    QList<PageInfo> lst = DataBase::GetInstance()->getAllPage();
    for(auto &info:lst)
    {
        TopologyManager::instance().createDiagram(QString::number(info.id),info.name);
    }
    _cornerButton = new CornerMonitorLauncher(this);
    _cornerButton->showDlg();
    _loadMonitorPageDlg = new LoadMonitorPageDlg(this);
    connect(_cornerButton,&CornerMonitorLauncher::openLoadMonitorDlg,this,[&](){
        if(_loadMonitorPageDlg){
            updateMonitorListFromDB(1);
            _loadMonitorPageDlg->show();
        }
    });
    connect(_loadMonitorPageDlg,&LoadMonitorPageDlg::monitorSelected,this,&DiagramCavas::onSignal_monitorSelected);
    _connectSetting = new DiagramConnectSetting(this);

    // 初始化通信管理器
    CommunicationManager* comm = CommunicationManager::instance();
    comm->initialize();

    // 加载配置
    ConfigManager* config = ConfigManager::instance();
    config->loadConfig("config.json");

    _extraPropertyManager = new ExtraPropertyManager(this);
    _extraPropertyManager->initial();

    // 应用配置
    comm->updateHttpConfig(config->getHttpConfig());
    comm->updateWebSocketConfig(config->getWebSocketConfig());

    _dataAccessor = new DataAccessor(this);
    _dataAccessor->setParent(this);
    connect(UiCommunicationBus::instance(),
            SIGNAL(httpDataProcessed(QString,QVariant)),
            _dataAccessor,
            SLOT(onReceiveHttpData(QString,QVariant)),
            Qt::AutoConnection);
    connect(UiCommunicationBus::instance(),
            SIGNAL(websocketDataProcessed(QVariant)),
            _dataAccessor,
            SLOT(onReceiveWebsocketData(QVariant)),
            Qt::AutoConnection);
    _structDataPreviewDlg = new StructDataPreviewDlg(this);
    _structDataPreviewDlg->setExtraPropertyManager(_extraPropertyManager);
    _structDataPreviewDlg->loadData();

    QQuickDetailsViewManager::Get()->registerPropertyTypeCustomization<DataSourceType, PropertyTypeCustomization_DataSourceType>();

    _createHMIDlg = new CreateHMIdlg(this);
    connect(_createHMIDlg,&CreateHMIdlg::createHMI,this,&DiagramCavas::onSignal_createHMIClicked);
    updateHMIlstFromDB();

    loadPluginConfig(QCoreApplication::applicationDirPath()+"/pluginConfig.json");      //加载plugin关联信息

    m_pluginManager = PluginManager::instance();
    //创建Canvas项工厂
    m_itemFactory = PluginItemFactory::instance();
    m_itemFactory->setPluginManager(m_pluginManager);
    //加载插件
    QString pluginsDir = QApplication::applicationDirPath() + "/plugins";
    m_pluginManager->addPluginDirectory(pluginsDir);
    m_pluginManager->loadAllPlugins(pluginsDir);
}

void DiagramCavas::onSignal_addDrawingPanel(PowerEntity* pItem,DiagramMode mode,QString parent)
{
    if(mode == DM_run){
        MonitorPanel* pPanel = new MonitorPanel(pItem,this,mode);
        _curPage = pItem->name();
        pPanel->setPageName(_curPage);
        pPanel->setWindowTitle(_curPage);
        pPanel->setParentPage(parent);
        QMdiSubWindow* pSub = this->addSubWindow(pPanel);
        m_mapMonitorPanel.insert(_curPage,qMakePair(pPanel,pSub));
        pPanel->show();

        FixedPortsModel* pModel = pPanel->getModelController();
        pModel->setCavas(QPointer<DiagramCavas>(this));
        connect(pModel,&FixedPortsModel::activatePage,this,&DiagramCavas::onSignal_activatePage);
        connect(pPanel,&MonitorPanel::panelDelete,this,&DiagramCavas::onSignal_panelDelete);
        connect(pModel,&FixedPortsModel::monitorCreated,this,&DiagramCavas::onSignal_monitorCreated);
        connect(pModel,&FixedPortsModel::monitorItems,this,&DiagramCavas::onSignal_monitorItemCreated);
        //connect(pModel,&FixedPortsModel::notifyUpdateMonitorTopology,this,&DiagramCavas::onSignal_updateMonitorTopology);     ***使用属性构建拓扑层级，暂不使用260317 by
        connect(pModel,&FixedPortsModel::updateTopologyItems,this,&DiagramCavas::onSignal_updateTopology);

        connect(pModel,&FixedPortsModel::HMIUpdated,this,&DiagramCavas::onSignal_updateHMI);
    }
    calculateLauncherVisible();
}

void DiagramCavas::onSignal_addGraphicsItem(ModelStateInfo& info)
{
    QMdiSubWindow* actWindow = activeSubWindow();
    if(!actWindow)
        return;
    QWidget* pWindow= currentSubWindow()->widget();
    /*DrawingPanel* pPanel = dynamic_cast<DrawingPanel*>(pWindow);

    if(pPanel)
        pPanel->onSignal_addGraphicsItem(info);*/
}

void DiagramCavas::onSignal_addPage()
{
    //onSignal_addDrawingPanel(QString("Page_")+QString::number(++_pageIndex));
}

void DiagramCavas::onSignal_savePage()
{
    QWidget* pWindow= currentSubWindow()->widget();
    BaseDrawingPanel* pPanel = dynamic_cast<BaseDrawingPanel*>(pWindow);
    if(pPanel)
    {
        if(pPanel->getMode() == DM_run)
        {
            auto pMonitor = dynamic_cast<MonitorPanel*>(pPanel);
            if(pMonitor){
                auto pEntity = pMonitor->getEntity();
                if(pEntity){
                    QMap<QByteArray,HMIImageInfo>& mapResource = ProjectModelManager::instance().getHMIimageMap();
                    DataBase::GetInstance()->insertHMIimagesWithCheck(mapResource.values());    //智能查重插入HMIsource

                    QList<HMIImageRef>& imgRefLst = pMonitor->getModelController()->getHMIimageRef();       //获取当前HMI所有img引用
                    if(imgRefLst.size()){
                        auto lstRef = DataBase::GetInstance()->getHMIRefAll(imgRefLst.first().hmiId);       //检测HMI是否存储过，删除旧img引用
                        if(lstRef.size())
                            DataBase::GetInstance()->removeHMIRefAll(imgRefLst.first().hmiId);
                        DataBase::GetInstance()->insertHMIimageRefBatch(imgRefLst);     //全部重新插入
                    }

                    QList<HMICustomImageRef>& imgCustomRefLst = pMonitor->getModelController()->getHMICustomImageRef();       //获取当前HMI所有custom引用
                    if(imgCustomRefLst.size()){
                        auto lstRef = DataBase::GetInstance()->getHMICustomRefAll(imgCustomRefLst.first().hmiId);
                        if(lstRef.size())
                            DataBase::GetInstance()->removeHMICustomRefAll(imgCustomRefLst.first().hmiId);
                        DataBase::GetInstance()->insertHMICustomRefBatch(imgCustomRefLst);
                    }

                    if(DataBase::GetInstance()->getHMIdByName(pEntity->name()).isNull())        //不存在，创建
                        DataBase::GetInstance()->insertHMI(QUuid(pEntity->id()),pEntity->name(),pEntity->name(),pMonitor->getDiagramInfo());
                    else
                        DataBase::GetInstance()->updateHMI(pEntity->name(),pMonitor->getDiagramInfo());
                    auto pControl = pMonitor->getModelController();
                    if(pControl)
                        emit pControl->HMIUpdated(pEntity->name(),QUuid(pEntity->id()),1,QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm"));
                    QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"保存成功"));
                }
            }
        }
    }
}

void DiagramCavas::onSignal_loadMonitor(PowerEntity* p)
{
    if(!m_mapMonitorPanel.contains(p->name()))
    {
        onSignal_addDrawingPanel(p,DiagramMode::DM_run);
        QJsonObject context = DataBase::GetInstance()->getHMIContextByTag(p->name());
        m_mapMonitorPanel[p->name()].first->loadNodes(context);
    }
    else        //已存在
    {
        m_mapMonitorPanel[p->name()].first->show();
    }
    onTargetSelected(m_mapMonitorPanel[p->name()].first->getPropertyProxy());
}

void DiagramCavas::runPage(const QString sName)
{
    QString pageName = sName+QString("_run");
    if(!m_mapMonitorPanel.contains(pageName))
    {
        //onSignal_addDrawingPanel(pageName,DM_run);
        QJsonObject context = DataBase::GetInstance()->getPageContextByName(sName);
        //m_mapDrawPanel[pageName]->loadNodes(context);
    }
    else        //已存在
    {
        //m_mapDrawPanel[pageName]->show();
    }
}

void DiagramCavas::onSignal_runPage()
{
    runPage(_curPage);
}

void DiagramCavas::onSignal_deletePage()
{

}

void DiagramCavas::onSignal_activatePage(const QString& name)
{
    _curPage = name;
}

void DiagramCavas::onSignal_panelDelete(const QString& name,int nType)
{
    if(nType == 2){
        MonitorPanel* pPanel = m_mapMonitorPanel.take(name).first;
        this->removeSubWindow(pPanel);
        delete pPanel;
    }
    calculateLauncherVisible();
}

void DiagramCavas::onSignal_createEntity(EntityInfo info)
{
    PowerEntity* pEntity;
    pEntity = TopologyManager::instance().findEntity(info.sUuid);
    if(!pEntity)        //不存在创建
    {
        pEntity = TopologyManager::instance().createEntity(info.eType,info.sUuid,info.sName);
        PowerEntity* pParent = TopologyManager::instance().findEntity(info.sParentId);
        if(pParent)         //构建父子关系
        {
            pParent->addChild(pEntity);
        }

        switch (info.eType){
        case EntityType::Grid:
        case EntityType::Zone:
        case EntityType::Station:
            break;
        case EntityType::ConfigurationDiagram:
            onSignal_addDrawingPanel(pEntity);
            break;
        default:
            break;
        }
    }

}

void DiagramCavas::onSignal_changeEntity(EntityInfo info)
{

}

void DiagramCavas::onSignal_deleteEntity(EntityInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findEntity(info.sUuid);
    if(pEntity)
    {
        switch (info.eType){
        case EntityType::Grid:
        case EntityType::Zone:
        case EntityType::Station:
            TopologyManager::instance().deleteEntity(info.sUuid);
            break;
        case EntityType::ConfigurationDiagram:
            removePanel(pEntity);
            TopologyManager::instance().deleteEntity(info.sUuid);
            break;
        default:
            break;
        }
    }
}

void DiagramCavas::onSignal_selectEntity(EntityInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findEntity(info.sUuid);
    if(pEntity)
    {
        switch (info.eType){
        case EntityType::Grid:
        case EntityType::Zone:
        case EntityType::Station:
            break;
        default:
            break;
        }
    }
    else            //不存在,从数据库中load
    {

    }
}

void DiagramCavas::onSignal_createDiagram(DiagramInfo info,DiagramMode mode)
{
    PowerEntity* pEntity;
    ModelFunctionType type;
    if(mode == DM_run)
        type = ModelFunctionType::RuntimeModel;
    else if(mode == DM_edit)
        type = ModelFunctionType::ProjectModel;
    pEntity = TopologyManager::instance().findDiagram(info.id.toString(),type);
    if(!pEntity)        //不存在创建
    {
        pEntity = TopologyManager::instance().createDiagram(info.id.toString(),info.sName,type);
        /*PowerEntity* pParent = TopologyManager::instance().findDiagram(info.parentId.toString());
        if(pParent)         //构建父子关系
        {
            pParent->addChild(pEntity);
        }*/

        onSignal_addDrawingPanel(pEntity,mode);
    }
}

void DiagramCavas::onSignal_changeDiagram(DiagramInfo info)
{

}

void DiagramCavas::onSignal_deleteDiagram(DiagramInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findDiagram(info.id.toString());
    if(pEntity)
    {
        removePanel(pEntity);
        TopologyManager::instance().deleteEntity(info.id.toString());
    }
}

void DiagramCavas::onSignal_selectDiagram(DiagramInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findDiagram(QString::number(info.id.toInt()));
    if(pEntity)
    {
        //onSignal_loadPage(pEntity);
    }
    else            //不存在,从数据库中load
    {

    }
}

void DiagramCavas::onSignal_openNetSetting()
{
    if(_connectSetting){
        _connectSetting->showDlg();
    }
}

void DiagramCavas::onSignal_openStructDataPreview()
{
    if(_structDataPreviewDlg)
        _structDataPreviewDlg->showDlg();
}

void DiagramCavas::onSignal_createHMI(QString sName,QUuid id)
{
    emit createHMI(sName,id);
}

void DiagramCavas::onSignal_updateHMI(QString sName,QUuid id,int nState,QString sTime)
{
    emit updateHMI(sName,id,nState,sTime);
}

void DiagramCavas::removePanel(PowerEntity* pEntity)
{
    QMap<QString,QPair<MonitorPanel*,QMdiSubWindow*>>::Iterator iter;
    for(iter = m_mapMonitorPanel.begin(); iter != m_mapMonitorPanel.end();++iter)
    {
        if(pEntity->name() == iter.value().first->pageName())
        {
            MonitorPanel* pPanel = m_mapMonitorPanel.take(iter.key()).first;

            QWidget* pWindow = static_cast<QWidget*>(pPanel);
            setActiveSubWindow(iter->second);
            closeActiveSubWindow();
            //removeSubWindow(pPanel);
            //todo：记录删除组态图，从数据库中删除
            delete pPanel;
            break;
        }
    }
}

void DiagramCavas::calculateLauncherVisible()
{
    if(_cornerButton){
        if (m_mapMonitorPanel.isEmpty()) {
            _cornerButton->setVisible(true);
        } else {
            _cornerButton->setVisible(false);
        }
    }
}

bool DiagramCavas::loadPluginConfig(const QString& configPath)
{
    QFile file(configPath);
    if (!file.open(QIODevice::ReadOnly)) {
        qWarning() << "Cannot open config file:" << configPath;
        return false;
    }

    QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
    if (doc.isNull() || !doc.isObject()) {
        qWarning() << "Invalid JSON config";
        return false;
    }

    return parsePluginConfig(doc.object());
}

bool DiagramCavas::parsePluginConfig(const QJsonObject& root)
{
    if (!root.contains("shapes")) {
        qWarning() << "Missing 'shapes' key";
        return false;
    }

    QJsonArray items = root["shapes"].toArray();

    for (const QJsonValue& itemVal : items) {
        QJsonObject itemObj = itemVal.toObject();

        int type = itemObj["type"].toInt();
        QString shapeName = itemObj["shapeName"].toString();
        QString modelName = itemObj["modelName"].toString();

        // 解析枚举类型
        PluginTypeInfo info;
        info.baseType = type;
        info.shapeName = shapeName;
        info.modelName = modelName;
        m_pluginInfo[shapeName] = info;
    }

    qDebug() << "Loaded" << m_pluginInfo.size() << "shapes types from config";
    return true;
}

void DiagramCavas::resizeEvent(QResizeEvent* event)
{
    if(_cornerButton)
        _cornerButton->positionAtCorner();
}

void DiagramCavas::onTargetSelected(QObject* obj)
{
    if(obj)
        emit selectTarget(obj);
}
/****************************************************/

void DiagramCavas::onSignal_updateTopology(QList<HierarchyItem> lst,bool refresh,bool showFull)
{
    emit prepareUpdateTopology(lst,refresh,showFull);
}

/*******************bay************************/
void DiagramCavas::onSignl_openCurrentBay()
{
    /*QWidget* pWindow= currentSubWindow()->widget();
    if(pWindow == nullptr){
        QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"当前无打开的工程模"));
    }
    MonitorPanel* pPanel = dynamic_cast<MonitorPanel*>(pWindow);
    if(pPanel)
    {
        if(pPanel->getMode() == DM_run)
        {
            pPanel->getModelController()->onSignal_openBayManager();
        }
    }*/
}
/*********************monitor**************************/

void DiagramCavas::onCreateHMIClicked()
{
    if(_createHMIDlg)
        _createHMIDlg->showDlg();
}

void DiagramCavas::onSignal_createHMIClicked(QString sHMI,QString sStructPage,int modelType)
{
    QUuid id = QUuid::createUuid();
    auto *pEntity = TopologyManager::instance().createDiagram(id.toString(),sHMI,ModelFunctionType::RuntimeModel);
    onSignal_addDrawingPanel(pEntity,DiagramMode::DM_run);
    QJsonObject context = DataBase::GetInstance()->getMonitorContextByTag(sStructPage);
    m_mapMonitorPanel[sHMI].first->loadNodes(context);       //加载系统图结构
    onSignal_createHMI(sHMI,id);
    onTargetSelected(m_mapMonitorPanel[sHMI].first->getPropertyProxy());
}

void DiagramCavas::onSignal_updateCurItems(QList<HierarchyItem> lst,bool refresh)
{
    emit prepareUpdateItems(lst,refresh);
}

void DiagramCavas::onSignal_selectedItems(QList<HierarchyItem> lst)
{
    emit prepareSelectItems(lst);
}

void DiagramCavas::onSignal_monitorCreated(QString sProj,QPair<QString,QUuid> pair)
{
    emit updateMonitorList(sProj,pair);
}

void DiagramCavas::onSignal_monitorItemCreated(QList<HierarchyItem> lst)
{
    emit createdMonitorItems(lst);
}

void DiagramCavas::onSignal_monitorSelected(DiagramInfo info)
{
    PowerEntity* pEntity = TopologyManager::instance().findDiagram(info.id.toString(),ModelFunctionType::RuntimeModel);
    if(pEntity)
    {
        onSignal_loadMonitor(pEntity);
    }
}

void DiagramCavas::onSignal_saveMonitor(QList<QPair<QString,QUuid>> lst)
{
    for(auto &pair:lst){
        auto pMonitor = m_mapMonitorPanel.value(pair.first).first;
        if(pMonitor){
            if(DataBase::GetInstance()->getPageIdByName(pMonitor->getParentPage()) == -1){
                QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"请先保存工程模型"));
                return;
            }
        }
    }

    for(auto& pair:lst){
        auto pMonitor = m_mapMonitorPanel.value(pair.first).first;
        if(pMonitor){
            if(DataBase::GetInstance()->getMonitorIdByName(pair.first).isNull())        //不存在，创建
                DataBase::GetInstance()->insertMonitor(pair.second,pair.first,pair.first,pMonitor->getParentPage(),pMonitor->getDiagramInfo());
            else
                DataBase::GetInstance()->updateMonitor(pair.first,pMonitor->getDiagramInfo());
        }
    }
    QMessageBox::information(NULL, QString("提示"), QString::fromWCharArray(L"保存成功"));
}

void DiagramCavas::updateMonitorListFromDB(int dest)
{
    if(dest != 0)
        _loadMonitorPageDlg->clearItems();

    QList<MonitorPageInfo> lstMonitor = DataBase::GetInstance()->getAllMonitor();
    for(auto &info:lstMonitor)
    {
        auto p = TopologyManager::instance().findDiagram(info.uid.toString(),ModelFunctionType::RuntimeModel);
        if(!p){
            TopologyManager::instance().createDiagram(info.uid.toString(),info.name,ModelFunctionType::RuntimeModel);
            if(dest == 0)
                emit updateMonitorList(info.parent,qMakePair(info.name,info.uid));
            else{
                _loadMonitorPageDlg->updateItems(info.parent,qMakePair(info.name,info.uid));
            }
        }
        else{       //存在直接发送
            if(dest == 0)
                emit updateMonitorList(info.parent,qMakePair(info.name,info.uid));
            else{
                _loadMonitorPageDlg->updateItems(info.parent,qMakePair(info.name,info.uid));
            }
        }
    }
}

void DiagramCavas::onSignal_updateMonitorTopology(QList<QUuid> lst)
{
    emit updateMonitorTopology(lst);
}

void DiagramCavas::updateHMIlstFromDB()
{
    QList<HMIPageInfo> lstMonitor = DataBase::GetInstance()->getAllHMI();
    for(auto &info:lstMonitor)
    {
        auto p = TopologyManager::instance().findDiagram(info.uid.toString(),ModelFunctionType::RuntimeModel);
        if(!p){
            TopologyManager::instance().createDiagram(info.uid.toString(),info.name,ModelFunctionType::RuntimeModel);
        }
    }
}