jiayulong/logplus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
dea304ce1d
logplus/ModuleConsole/src/WorkflowSceneManager.cpp
zhaolei 404d38fd1d 添加算法调用功能
2026-01-16 17:18:41 +08:00

3069 lines
108 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* @file WorkflowSceneManager.cpp
*/
#include <cassert>
#include <QtAlgorithms>
#include <QGraphicsSceneDragDropEvent>
#include <QMimeData>
#include <QtDebug>
#include <QDir>
#include <QKeyEvent>
#include <QGraphicsView>
#include <QApplication>
#include <QClipboard>
#include <QScrollBar>
#include <QStandardItemModel>
#include <QtDebug>
#include <iostream>
#include <QAction>
#include <QPainterPath>
#include <QDesktopWidget>
#include <QMenu>
#include <QDockWidget>
// #include "VecWindowDocument.h"
#include "WorkflowSceneManager.h"
// #include "ModuleGraphicsItem.h"
#include "ModuleInformation.h"
#include "ModuleConnectGraphicsItem.h"
// #include "PaiWorkflowDataModel.h"
// #include "ModuleParameterFillEngine.h"
#include "ModuleParameter.h"
#include "ModuleConnection.h"
#include "ModuleManager.h"
// #include "QtWellSceneManager.h"
// #include "PaiModuleStyle.h"
#include "ModuleToolBarGraphicsItem.h"
#include "ModuleCheckResult.h"
// #include "ModulePortInfoGraphicsItem.h"
// #include "ModuleParameterUtil.h"
// #include "PaiGeoObject.h"
// #include "PaiSeisData.h"
// #include "PaiDataMaster.h"
// #include "ParameterValidateThread.h"
// #include "PaiThreadPoolManager.h"
// #include "PaiJob.h"
// #include "PaiLineEdit.h"
#include "WorkflowConst.h"
#include "PaiModuleTree.h"
#include "GlobalModuleBackup.h"
// #include "Utils.h"
// #include "PAIConst.h"
// #include "PaiMessageBox.h"
// #include "Log.h"
#include "ParameterEditor.h"
#include "ParameterEditorModel.h"
// #include "PaiSurvey.h"
#include "GlobalUtility.h"
// #include "PaiTypes.h"
#include "PaiPushButton.h"
// #include "ConsoleGUIService.h"
// #include "PluginManager.h"
// #include "WorkflowPlugin.h"
#include "WorkflowWidget.h"
// #include "WorkflowPluginControl.h"
#include "WorkFlowFile.h"
// #include "CopyModuleCmd.h"
#include "DeleteModuleCmd.h"
#include "CutModuleCmd.h"
#include "PasteModuleCmd.h"
#include "CopyModuleCmd.h"
#include "AddLineCmd.h"
#include "AddModuleCmd.h"
#include "BreakLineCmd.h"
#include "LayoutModuleCmd.h"
#include "RenameModuleCmd.h"
#include "GlobalWorkflowItems.h"
#include "SaveHelper.h"
#include "SelectAllCmd.h"
#include "ZoomInCmd.h"
#include "ZoomOutCmd.h"
// #include "ParameterCmd.h"
// #include "PaiDropEventAnalyser.h"
#include "MoveModuleCmd.h"
#include "PaiTreeItemDelegate.h"
#include "PaiWorkflowTemplateTree.h"
#include "PaiJobSummaryItem.h"
#include "PaiJobParameterItem.h"
#include "PaiJobErrorInfoItem.h"
#include "WorkflowWidget.h"
// #include "TimeStampLogger.h"
#include "PaiJobErrorInfoWidget.h"
// #include "PaiPermissionChecker.h"
#include "PaiMenuToolBar.h"
#include "ModuleInformation.h"
#include "LogModuleConsole.h"
#include <PELibraryModule.h>
#include "LogModuleParamers.h"
// #include "WellSectionWindowDocument.h"
#include "PaiWorkflowDataModel.h"
using namespace pai;
using namespace pai::graphics2d;
using namespace pai::objectmodel;
using namespace pai::gui;
using namespace pai::workflow;
const QString TOOLBAR_DELETE_DISABLED_ITEMS = "Delete disabled items";
WorkflowSceneManager::WorkflowSceneManager(qreal x, qreal y, qreal width, qreal height, QObject *pParent) :
GeneralWorkflowScene(x,y,width,height,pParent),
m_pStartItem(NULL),
m_pEndItem(NULL),
m_pTmpLine(NULL),
m_bModuleMoved(false),
m_bLeftButtonDown(false),
m_bKeyPressed(false),
m_bMousePressPoint(0, 0),
m_SubmitThreadCount(0),
// m_pUndoStack(new PaiUndoStack()),
// m_pThreadPool(NULL),
m_zoomCount(0),
m_pParameterEditor(NULL),
m_bEnableMultiSelect(true),
m_bIsSingleMethod(true)
{
//初始化ModuleNameList
InitModuleNameList();
connect(this, SIGNAL(selectionChanged()), this, SLOT(slotOnSelectionChanged()));
// connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent,
// SIGNAL(PortSelectionChanged (pai::graphics2d::ModuleGraphicsItem*,bool)), this,
// SLOT(slotOnPortSelectionChanged(pai::graphics2d::ModuleGraphicsItem*,bool)));
// connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent,
// SIGNAL(PortHoveringChanged (pai::graphics2d::ModuleGraphicsItem*,bool)), this,
// SLOT(slotOnPortHoveringChanged(pai::graphics2d::ModuleGraphicsItem*,bool)));
// connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent,
// SIGNAL(DeleteModule(pai::graphics2d::GeneralWorkflowScene *, pai::graphics2d::ModuleGraphicsItem*)), this,
// SLOT(slotDeleteModule(pai::graphics2d::GeneralWorkflowScene *, pai::graphics2d::ModuleGraphicsItem*)));
// connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent, SIGNAL(DoubleClick(pai::workflow::CModuleInformation*, bool)), this, SIGNAL(
// doubleClickModule(pai::workflow::CModuleInformation*, bool)));
// //connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent, SIGNAL(signalUpdateModule(pai::graphics2d::ModuleGraphicsItem*)), this,
// //SLOT(slotUpdataModule(pai::graphics2d::ModuleGraphicsItem*)));
// connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent, SIGNAL(SetEnalbed(pai::graphics2d::ModuleGraphicsItem *, bool)), this,
// SLOT(slotOnDisableOrEnable(pai::graphics2d::ModuleGraphicsItem *, bool)));
// //connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent, SIGNAL(signalSetName(pai::graphics2d::ModuleGraphicsItem *)), this,
// //SLOT(slotOnSetName(pai::graphics2d::ModuleGraphicsItem *)));
// connect(&pai::graphics2d::PaiModuleStyle::m_EventAgent, SIGNAL(ChangePosition(QPointF, pai::graphics2d::ModuleGraphicsItem*)),
// this, SLOT(SetModulePosition(QPointF, pai::graphics2d::ModuleGraphicsItem*)));
// // connect(this, SIGNAL(signalSelectModule(CModuleInformation*)),
// // this, SLOT(slotSelectModule(CModuleInformation*)));
// //connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent, SIGNAL(signalEditingFinished()),
// // this, SLOT(slotSetSelectedModuleName()));
// connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent, SIGNAL(ClickSelectedItem(pai::workflow::CModuleInformation*)),
// this, SIGNAL(signalSelectModule(pai::workflow::CModuleInformation*)));
}
WorkflowSceneManager::~WorkflowSceneManager()
{
//等待所有的线程都结束
WaitThreadForDone();
//这里每必要调用Clear()函数，因为在场景析构的时候，会自动把所有的item析构
// if(m_pUndoStack != NULL)
// {
// m_pUndoStack->clear();
// delete m_pUndoStack;
// }
ReleaseThreadPool();
RemoveModulesInBackup();
}
void WorkflowSceneManager::ReleaseThreadPool()
{
// if(m_ScenceReadOnly == false && m_pWorkflow != NULL && m_pThreadPool != NULL)
// {
// PaiThreadPoolManager::GetInstance()->ReleaseThreadPool(m_pWorkflow->GetID());
// m_pThreadPool = NULL;
// }
}
int WorkflowSceneManager::GetSubmitThreadCount()
{
return m_SubmitThreadCount;
}
// PaiUndoStack* WorkflowSceneManager::GetUndoStack()
// {
// return m_pUndoStack;
// }
void WorkflowSceneManager::SetSubmitting(bool bSubmit)
{
// bool isSubmitting = bSubmit == true ? true : m_pWorkflow->IsSubmitting();
// if(NULL != m_pWorkflow && IsActiveWorkflow(m_pWorkflow) == true)
// {
// PageService* pPageService =
// ::GetConsoleGUIService()->GetViewTabService()->GetPageService(QUuid(g_szWorkflowPluginID));
// assert(pPageService != NULL);
// QAction* pSubmitAction = pPageService->GetAction(tr(g_szSubmit));
// if(pSubmitAction != NULL)
// {
// pSubmitAction->setEnabled(!isSubmitting);
// }
// m_pWorkflow->SetCanSubmit(!isSubmitting); //设置是否可以sumbit
// }
}
void WorkflowSceneManager::AddWorkflow(pai::objectmodel::PaiWorkflowDataModel* pWorkflow, bool bJobRelated)
{
// if(!pWorkflow)
// {
// return;
// }
// m_pWorkflow = pWorkflow;
// if(m_ScenceReadOnly == false)
// {
// assert(m_pThreadPool == NULL);
// m_pThreadPool = PaiThreadPoolManager::GetInstance()->CreateThreadPool(m_pWorkflow->GetID());
// }
// //添加模块图元
// int nModuleCount = pWorkflow->GetModuleCount();
// for(int i = 0; i < nModuleCount; ++i)
// {
// workflow::CModuleInformation* pModule = pWorkflow->GetModule(i);
// if (!pModule)
// {
// continue;
// }
// pai::graphics2d::ModuleGraphicsItem *pModuleItem = AddModule(pModule,pWorkflow->GetModuleStyle(pModule->GetStepID()),bJobRelated);
// if(!pModuleItem)
// {
// continue;
// }
// pModuleItem->SetWorkflow(m_pWorkflow);
// pModuleItem->SetInitialValidated(true);
// }
// //添加模块之间的连线
// int nConnectionCount = pWorkflow->GetConnectionCount();
// for(int i = 0; i < nConnectionCount; ++i)
// {
// AddConnection(pWorkflow->GetConnection(i));
// }
// if(nModuleCount > 0 && m_ScenceReadOnly == false)
// {
// if(!bJobRelated) //JobManager Tab 页上的 Related workflow不需要验证
// {
// ValidateModulesAcceptDropData(QUuid(), QString());
// StartSubmitValidateThread();
// }
// }
}
void WorkflowSceneManager::StartSubmitValidateThread()
{
//测井不需要
}
void WorkflowSceneManager::SetParameterEditor(CParameterEditor * pParamEditor)
{
m_pParameterEditor = pParamEditor;
}
void WorkflowSceneManager::EnableMultiSelect(QGraphicsView *pWorkflowView, bool enable)
{
pWorkflowView->setDragMode(QGraphicsView::NoDrag);
m_bEnableMultiSelect = enable;
}
pai::graphics2d::ModuleGraphicsItem* WorkflowSceneManager::AddModule(pai::workflow::CModuleInformation* pModule,
pai::graphics2d::PaiModuleStyle* pStyle,bool bJobRelated)
{
return NULL;
// if((NULL == pModule) || (NULL == pStyle))
// {
// return NULL;
// }
// ModuleGraphicsItem* pItem = new ModuleGraphicsItem(pModule, pStyle, bJobRelated);
// pItem->SetToolBarItem(m_pModuleToolBarItem);
// pItem->SetModuleNamePopup(m_pMouduleNameList.keys());
// addItem(pItem);
// if(m_pThreadPool && !pModule->IsBlankModule() && !bJobRelated)
// {
// CParameterValidateThread *pValidateThread = new CParameterValidateThread(pModule);
// connect(pValidateThread, SIGNAL(finished()), this, SLOT(slotOnParameterValidated()));
// m_pThreadPool->start(pValidateThread);
// }
// GlobalModuleBackup *moduleBack = ::GetGlobalModuleBackup();
// moduleBack->InsertBackupModule(m_pWorkflow->GetID(), pItem->GetModule());
// return pItem;
}
void WorkflowSceneManager::AddConnection(pai::workflow::CModuleConnection* pConnect)
{
// ModuleGraphicsItem* pStartItem = FindModule(pConnect->GetSourceId());
// ModuleGraphicsItem* pEndItem = FindModule(pConnect->GetDestId());
// int nStartSelectedPortIndex = QString::fromStdString(pConnect->GetOutPort()).toInt();
// int nEndSelectedPortIndex = QString::fromStdString(pConnect->GetInPort()).toInt();
// QGraphicsItem* pLineItem = new ModuleConnectGraphicsItem(pStartItem, nStartSelectedPortIndex, pEndItem,
// nEndSelectedPortIndex);
// addItem(pLineItem);
// update();
}
void WorkflowSceneManager::dragEnterEvent(QGraphicsSceneDragDropEvent *pEvent)
{
// PaiDropEventAnalyser dropAna(pEvent->mimeData());
// if(!dropAna.IsAvailable())
// {
// return;
// }
// //数据来源自模块树或者模板树
// if(dropAna.GetDataSource() == DRAG_MODULETREE || dropAna.GetDataSource() == DRAG_TEMPLATETREE)
// {
// pEvent->acceptProposedAction();
// }
// else
// {
// //获取拖拽数据
// QList<DraggedData>dataLst = dropAna.GetDraggedData();
// bool bHasValidType = false;
// foreach(DraggedData draggedData, dataLst)
// {
// //如果是工作流或者地震数据
// if(QUuid(draggedData.dataType) == QUuid(PaiWorkflowDataModel::GetTypeIDString()))
// {
// bHasValidType = true;
// break;
// }
// }
// if(bHasValidType)
// {
// pEvent->acceptProposedAction();
// }
// else
// {
// QGraphicsScene::dragEnterEvent(pEvent);
// }
// }
}
void WorkflowSceneManager::dragMoveEvent(QGraphicsSceneDragDropEvent *pEvent)
{
// PaiDropEventAnalyser dropAna(pEvent->mimeData());
// if(!dropAna.IsAvailable())
// {
// return;
// }
// //数据来源自模块树或者模板树
// if(dropAna.GetDataSource() == DRAG_MODULETREE || dropAna.GetDataSource() == DRAG_TEMPLATETREE)
// {
// pEvent->acceptProposedAction();
// }
// else
// {
// //获取拖拽数据
// QList<DraggedData>dataLst = dropAna.GetDraggedData();
// bool bHasValidType = false;
// foreach(DraggedData draggedData, dataLst)
// {
// //如果是工作流或者地震数据
// if(QUuid(draggedData.dataType) == QUuid(PaiWorkflowDataModel::GetTypeIDString()))
// {
// bHasValidType = true;
// break;
// }
// }
// if(bHasValidType)
// {
// pEvent->acceptProposedAction();
// }
// else
// {
// QGraphicsScene::dragMoveEvent(pEvent);
// }
// }
}
void WorkflowSceneManager::dropEvent(QGraphicsSceneDragDropEvent *pEvent)
{
// QGraphicsScene::dropEvent(pEvent);
// PaiDropEventAnalyser dropAna(pEvent->mimeData());
// if(!dropAna.IsAvailable())
// {
// return;
// }
// //数据来自于模块树
// if(dropAna.GetDataSource() == DRAG_MODULETREE)
// {
// try
// {
// if(m_pWorkflow)
// {
// QList<DraggedData>dataLst = dropAna.GetDraggedData();
// QUndoCommand *pAddModuleCommond = new AddModuleCmd(this, m_pWorkflow, dataLst.at(0).id,
// pEvent->scenePos());
// m_pUndoStack->push(pAddModuleCommond);
// pEvent->acceptProposedAction();
// }
// }
// catch(pai::error::generic_error &exeption)
// {
// pai::gui::PaiMessageBox::Critical(NULL, PAI_NAME,
// QString(g_szPasteLine).append(exeption.what()));
// pai::log::Info(_FLF(g_szPasteLine + exeption.what()));
// }
// }
// else if(dropAna.GetDataSource() == DRAG_TEMPLATETREE)//数据来自于模板树
// {
// QList<DraggedData>dataLst = dropAna.GetDraggedData();
// PaiObject* pObject =
// GetWorkflowPlugin()->GetWorkflowPluginCtr()->GetTemplateTree()->GetChildByName(dataLst.at(0).dataName);
// if(pObject)
// {
// slotApplyTemplate(pObject);
// }
// }
// else
// {
// QList<DraggedData>dataLst = dropAna.GetDraggedData();
// //获取工作流插件
// pai::IPlugin* pWorkflowPlugin = ::GetConsoleGUIService()->GetPluginManager()->GetPlugin(QUuid(g_szWorkflowPluginID));
// if(!pWorkflowPlugin)
// {
// return;
// }
// pai::CPaiWorkflowPlugin* pWorkflowView = dynamic_cast< pai::CPaiWorkflowPlugin* > (pWorkflowPlugin);
// if(!pWorkflowView)
// {
// return;
// }
// WorkflowPluginControl *pCtrl = pWorkflowView->GetWorkflowPluginCtr();
// if(!pCtrl)
// {
// return;
// }
// //打开被托入工作流
// foreach(DraggedData draggedData, dataLst)
// {
// if(QUuid(draggedData.dataType) == QUuid(PaiWorkflowDataModel::GetTypeIDString()))
// {
// bool ok;
// long long dbid = (draggedData.id).toLongLong(&ok);
// if(ok)
// {
// //打开工作流
// pCtrl->OpenWorkflowView(dbid);
// }
// }
// }
// }
// pEvent->setDropAction(Qt::CopyAction);
}
void WorkflowSceneManager::keyReleaseEvent(QKeyEvent * keyEvent)
{
// QGraphicsScene::keyReleaseEvent(keyEvent);
// if(!(keyEvent->key() == Qt::Key_Left || keyEvent->key() == Qt::Key_Right || keyEvent->key() == Qt::Key_Up
// || keyEvent->key() == Qt::Key_Down))
// {
// m_bKeyPressed = false;
// }
// QList< ModuleMovedInfo > moduleMovedInfoList;
// switch(keyEvent->key())
// {
// case Qt::Key_Escape:
// {
// clearSelection();
// break;
// }
// case Qt::Key_Delete:
// {
// slotDeleteModule();
// break;
// }
// case Qt::Key_Home:
// {
// foreach(QGraphicsView* pView, views())
// {
// pView->horizontalScrollBar()->setValue(pView->horizontalScrollBar()->minimum());
// }
// break;
// }
// case Qt::Key_End:
// {
// foreach(QGraphicsView* pView, views())
// {
// pView->horizontalScrollBar()->setValue(pView->horizontalScrollBar()->maximum());
// }
// break;
// }
// case Qt::Key_Left:
// {
// if(!IsEditingModuleName())
// {
// foreach(QGraphicsItem* pItem, selectedItems())
// {
// if (pItem->type() != pai::graphics2d::ModuleConnectGraphicsItem::Type)
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (!pModule)
// {
// continue;
// }
// if (!m_bKeyPressed)
// {
// pModule->GetModuleStyle()->SetMousePressPos(pModule->pos());
// }
// pModule->setPos(pItem->pos().x() - 10, pItem->pos().y());
// pModule->GetModuleStyle()->SetMouseReleasePos(pItem->pos());
// ModuleMovedInfo moveInfo;
// moveInfo.stepId = pModule->GetModule()->GetStepID();
// moveInfo.mousePressPos = pModule->GetModuleStyle()->GetMousePressPos();
// moveInfo.mouseReleasePos = pModule->GetModuleStyle()->GetMouseReleasePos();
// moduleMovedInfoList << moveInfo;
// }
// }
// QUndoCommand *pMoveModuleCmd = new MoveModuleCmd(this, moduleMovedInfoList, true);
// m_pUndoStack->push(pMoveModuleCmd);
// }
// m_bKeyPressed = true;
// break;
// }
// case Qt::Key_Up:
// {
// if(!IsEditingModuleName())
// {
// foreach(QGraphicsItem* pItem, selectedItems())
// {
// if (pItem->type() != pai::graphics2d::ModuleConnectGraphicsItem::Type)
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (!pModule)
// {
// continue;
// }
// if (!m_bKeyPressed)
// {
// pModule->GetModuleStyle()->SetMousePressPos(pModule->pos());
// }
// pItem->setPos(pItem->pos().x(), pItem->pos().y() - 10);
// pModule->GetModuleStyle()->SetMouseReleasePos(pItem->pos());
// ModuleMovedInfo moveInfo;
// moveInfo.stepId = pModule->GetModule()->GetStepID();
// moveInfo.mousePressPos = pModule->GetModuleStyle()->GetMousePressPos();
// moveInfo.mouseReleasePos = pModule->GetModuleStyle()->GetMouseReleasePos();
// moduleMovedInfoList << moveInfo;
// }
// }
// QUndoCommand *pMoveModuleCmd = new MoveModuleCmd(this, moduleMovedInfoList, true);
// m_pUndoStack->push(pMoveModuleCmd);
// }
// m_bKeyPressed = true;
// break;
// }
// case Qt::Key_Right:
// {
// if(!IsEditingModuleName())
// {
// foreach(QGraphicsItem* pItem, selectedItems())
// {
// if (pItem->type() != pai::graphics2d::ModuleConnectGraphicsItem::Type)
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (!pModule)
// {
// continue;
// }
// if (!m_bKeyPressed)
// {
// pModule->GetModuleStyle()->SetMousePressPos(pModule->pos());
// }
// pItem->setPos(pItem->pos().x() + 10, pItem->pos().y());
// pModule->GetModuleStyle()->SetMouseReleasePos(pItem->pos());
// ModuleMovedInfo moveInfo;
// moveInfo.stepId = pModule->GetModule()->GetStepID();
// moveInfo.mousePressPos = pModule->GetModuleStyle()->GetMousePressPos();
// moveInfo.mouseReleasePos = pModule->GetModuleStyle()->GetMouseReleasePos();
// moduleMovedInfoList << moveInfo;
// }
// }
// QUndoCommand *pMoveModuleCmd = new MoveModuleCmd(this, moduleMovedInfoList, true);
// m_pUndoStack->push(pMoveModuleCmd);
// }
// m_bKeyPressed = true;
// break;
// }
// case Qt::Key_Down:
// {
// if(!IsEditingModuleName())
// {
// foreach(QGraphicsItem* pItem, selectedItems())
// {
// if (pItem->type() != pai::graphics2d::ModuleConnectGraphicsItem::Type)
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (!pModule)
// {
// continue;
// }
// if (!m_bKeyPressed)
// {
// pModule->GetModuleStyle()->SetMousePressPos(pModule->pos());
// }
// pItem->setPos(pItem->pos().x(), pItem->pos().y() + 10);
// pModule->GetModuleStyle()->SetMouseReleasePos(pItem->pos());
// ModuleMovedInfo moveInfo;
// moveInfo.stepId = pModule->GetModule()->GetStepID();
// moveInfo.mousePressPos = pModule->GetModuleStyle()->GetMousePressPos();
// moveInfo.mouseReleasePos = pModule->GetModuleStyle()->GetMouseReleasePos();
// moduleMovedInfoList << moveInfo;
// }
// }
// QUndoCommand *pMoveModuleCmd = new MoveModuleCmd(this, moduleMovedInfoList, true);
// m_pUndoStack->push(pMoveModuleCmd);
// }
// m_bKeyPressed = true;
// break;
// }
// case Qt::Key_PageUp:
// {
// foreach(QGraphicsView* pView, views())
// {
// pView->verticalScrollBar()->setValue(pView->verticalScrollBar()->value()
// - pView->verticalScrollBar()->pageStep());
// }
// break;
// }
// case Qt::Key_PageDown:
// {
// foreach(QGraphicsView* pView, views())
// {
// pView->verticalScrollBar()->setValue(pView->verticalScrollBar()->value()
// + pView->verticalScrollBar()->pageStep());
// }
// break;
// }
// default:
// break;
// }
}
void WorkflowSceneManager::keyPressEvent(QKeyEvent * keyEvent)
{
QGraphicsScene::keyPressEvent(keyEvent);
// 处理组合键输入
if(Qt::Key_C == keyEvent->key() && (Qt::ControlModifier & keyEvent->modifiers()))
{
slotCopy();
}
else if(Qt::Key_V == keyEvent->key() && (Qt::ControlModifier & keyEvent->modifiers()))
{
slotPaste();
}
else if(Qt::Key_X == keyEvent->key() && (Qt::ControlModifier & keyEvent->modifiers()))
{
slotCutItem();
}
else if(Qt::Key_A == keyEvent->key() && (Qt::ControlModifier & keyEvent->modifiers()))
{
slotSelectAll();
}
else if(Qt::Key_Z == keyEvent->key() && (Qt::ControlModifier & keyEvent->modifiers()))
{
slotUndo();
}
else if(Qt::Key_Y == keyEvent->key() && (Qt::ControlModifier & keyEvent->modifiers()))
{
slotRedo();
}
}
void WorkflowSceneManager::slotPaste()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Paste workflow modules");
QPoint point(-1, -1);
//设置复制模块坐标
point.setX(m_PastePoint.x() + 10);
point.setY(m_PastePoint.y() + 10);
//粘贴后的间隔变大, 显示连接线
m_PastePoint.setX(m_PastePoint.x() + 120);
m_PastePoint.setY(m_PastePoint.y() + 10);
QRectF boundingRect;
// // get copy items from GlobalWorkflowItems class support paste the copied items between workflows
// foreach (QGraphicsItem *item, GlobalWorkflowItems::GetInstance()->GetCopyGraphicItems())
// boundingRect |= item->sceneBoundingRect();
// //场景中x和y方向上的默认扩展距离
// int nDefaultInterval = 60;
// ExpandSceneRectIfNeeded(boundingRect.bottomRight(), nDefaultInterval, nDefaultInterval);
// clearSelection();
// QList< QGraphicsItem* > copyItems = GlobalWorkflowItems::GetInstance()->GetCopyGraphicItems();
// QUndoCommand *pPasteModuleCmd = new PasteModuleCmd(this, m_pWorkflow, copyItems, point, boundingRect);
// m_pUndoStack->push(pPasteModuleCmd);
// HideAllModuleNameEdit();
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Paste workflow modules");
}
void WorkflowSceneManager::slotApplyTemplate(pai::objectmodel::PaiObject* pObject)
{
// if(!pObject)
// {
// return;
// }
// PaiWorkflowDataModel* pWorkflow = NULL;
// if(::GetWorkflowConsole() && GetWorkflowConsole()->GetWorkflowControl()
// && GetWorkflowConsole()->GetWorkflowWidget())
// {
// pWorkflow = GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow();
// }
// if(!m_pWorkflow || m_pWorkflow != pWorkflow)
// {
// return;
// }
// PaiWorkflowDataModel* pWorkflowSrc = dynamic_cast< PaiWorkflowDataModel* > (pObject);
// if(!pWorkflowSrc)
// {
// return;
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Apply workflow template");
// if(!pWorkflowSrc->HasFlag(PaiObject::DataLoaded))
// {
// pWorkflowSrc->ReloadDataModuel();
// }
// //Clear();
// QPoint point(0, 0);
// QRectF boundingRect(0, 0, 0, 0);
// QGraphicsItem* pMostRightItem = NULL;
// foreach(QGraphicsItem* pItem, items())
// {
// if (pItem->type() == pai::graphics2d::ModuleGraphicsItem::Type)
// {
// pai::graphics2d::ModuleGraphicsItem* pLoopModuleItem = dynamic_cast<pai::graphics2d::ModuleGraphicsItem*> (pItem);
// if (NULL != pLoopModuleItem)
// {
// if ((NULL == pMostRightItem) || (pItem->pos().x() > pMostRightItem->pos().x()))
// {
// pMostRightItem = pItem;
// }
// }
// }
// }
// if(pMostRightItem)
// {
// point.setX(pMostRightItem->pos().x() + pMostRightItem->boundingRect().width());
// }
// ClearItems();
// QUndoCommand *pPasteModuleCmd = new PasteModuleCmd(this, m_pWorkflow, pWorkflowSrc, point, boundingRect);
// m_pUndoStack->push(pPasteModuleCmd);
// SceneRectAutoAdaptive();
// if (!m_ScenceReadOnly)
// {
// UpdateActions();
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Apply workflow template");
}
void WorkflowSceneManager::mousePressEvent(QGraphicsSceneMouseEvent * mouseEvent)
{
// m_rubberBandPoint = mouseEvent->scenePos().toPoint();
// /////////////////////////////改
// if(mouseEvent->button() == Qt::LeftButton && QApplication::keyboardModifiers() ==Qt::AltModifier)
// {
// m_pTmpLine = new QGraphicsLineItem(QLineF(mouseEvent->scenePos(), mouseEvent->scenePos()));
// m_pTmpLine->setPen(QPen(QColor("#517284"), 1, Qt::DashLine));
// m_pTmpLine->setZValue(2);
// addItem(m_pTmpLine);
// }
// else if(mouseEvent->button() == Qt::LeftButton)
// {
// m_bLeftButtonDown = true;
// m_bMousePressPoint = mouseEvent->pos();
// if(selectedItems().isEmpty() && !items().isEmpty())
// {
// HideAllModuleNameEdit();
// }
// foreach(QGraphicsItem *pItem, selectedItems())
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (!pModule)
// {
// continue;
// }
// pModule->GetModuleStyle()->SetMousePressPos(pModule->pos());
// }
// }
// QGraphicsScene::mousePressEvent(mouseEvent);
}
void WorkflowSceneManager::mouseMoveEvent(QGraphicsSceneMouseEvent * mouseEvent)
{
// /////////////////////////////改
// //if(QApplication::keyboardModifiers() ==Qt::AltModifier)
// //if(NULL != m_pStartItem && NULL != m_pTmpLine && NULL == m_pEndItem)
// if(m_pTmpLine)
// {
// QLineF newLine(m_pTmpLine->line().p1(), mouseEvent->scenePos());
// m_pTmpLine->setLine(newLine);
// }
// else
// {
// QGraphicsScene::mouseMoveEvent(mouseEvent);
// foreach (QGraphicsItem* pItem, selectedItems())
// {
// if (dynamic_cast<ModuleGraphicsItem*>(pItem) && m_bLeftButtonDown)
// {
// if((mouseEvent->pos() - m_bMousePressPoint).manhattanLength() > QApplication::startDragDistance())
// {
// m_bModuleMoved = true;
// }
// break;
// }
// }
// //模块的透明度
// const float translucence = 0.5;
// const float opacity = 1;
// for(int i = 0; i < selectedItems().count(); i++)
// {
// //判断模块是否重合，如果重合，设置上层模块的透明度
// pai::graphics2d::ModuleGraphicsItem* pModuleItem =
// dynamic_cast< pai::graphics2d::ModuleGraphicsItem* > (selectedItems().at(i));
// if(NULL != pModuleItem && pModuleItem == mouseGrabberItem())
// {
// //设置选中的模块的Z value值
// pModuleItem->setZValue(1);
// pModuleItem->GetToolBar()->setZValue(1);
// //拖动了模块的位置，将工作流状态置为已修改
// m_pWorkflow->SetModify(true);
// }
// if(NULL != pModuleItem)
// {
// QList< QGraphicsItem* > lstModuleItems = pModuleItem->collidingItems(Qt::IntersectsItemShape);
// for(int j = 0; j < lstModuleItems.size(); j++)
// {
// pai::graphics2d::ModuleGraphicsItem* pCollidingModuleItem =
// dynamic_cast< pai::graphics2d::ModuleGraphicsItem* > (lstModuleItems[j]);
// if(NULL != pCollidingModuleItem)
// {
// pCollidingModuleItem->setZValue(0);
// if(qAbs(pCollidingModuleItem->pos().x() - pModuleItem->pos().x()) < 10
// && qAbs(pCollidingModuleItem->pos().y() - pModuleItem->pos().y()) < 10)
// {
// pModuleItem->setOpacity(translucence);
// }
// else
// {
// pModuleItem->setOpacity(opacity);
// //如果当前移动的模块的碰撞模块之前为半透明，那么在当前模块离开后，透明度设置为1
// if(translucence == pCollidingModuleItem->opacity())
// {
// pCollidingModuleItem->setOpacity(opacity);
// }
// }
// }
// }
// }
// update();
// }
// }
}
void WorkflowSceneManager::mouseReleaseEvent(QGraphicsSceneMouseEvent * mouseEvent)
{
// QGraphicsScene::mouseReleaseEvent(mouseEvent);
// m_bLeftButtonDown = false;
// if(NULL != m_pTmpLine)//模块直接连线的情况
// {
// QList<QGraphicsItem*> startItems = items(m_pTmpLine->line().p1());
// if (startItems.count() && startItems.first() == m_pTmpLine)
// startItems.removeFirst();
// QList<QGraphicsItem*> endItems = items(m_pTmpLine->line().p2());
// if (endItems.count() && endItems.first() == m_pTmpLine)
// endItems.removeFirst();
// ClearDashLine();
// //添加新的连线
// if (startItems.count() > 0 && endItems.count() > 0 &&
// startItems.first() != endItems.first())
// {
// m_pStartItem = ( ModuleGraphicsItem*)startItems.first();
// m_pEndItem = ( ModuleGraphicsItem*)endItems.first();
// }
// if(m_pStartItem != NULL && m_pEndItem != NULL)
// {
// if(m_pStartItem != m_pEndItem)
// {
// ModuleGraphicsItem* pItem = m_pEndItem;
// pai::graphics2d::PortDirection eStartPortDirection;
// pai::graphics2d::PortDirection eEndPortDirection;
// int nStartSelectedPortIndex =0;
// int nEndSelectedPortIndex =0;
// //////////////////改
// m_pStartItem->GetSelectedPort(eStartPortDirection, nStartSelectedPortIndex);
// if(nStartSelectedPortIndex == -1)
// {
// m_pStartItem = NULL;
// m_pEndItem = NULL;
// return;
// }
// m_pEndItem->GetHoveringPort(eEndPortDirection, nEndSelectedPortIndex);
// if(nEndSelectedPortIndex == -1)
// {
// m_pStartItem = NULL;
// m_pEndItem = NULL;
// return;
// }
// if(eStartPortDirection == eEndPortDirection)
// {
// //重置端口状态
// HilightOtherItems(m_pStartItem, false);
// HilightOtherItems(m_pEndItem, false);
// m_pStartItem->CancelPortSelect();
// m_pEndItem->CancelPortSelect();
// m_pStartItem = NULL;
// m_pEndItem = NULL;
// return;
// }
// if(eStartPortDirection == Top && eEndPortDirection == Bottom)
// {
// //交换两个模块的前后顺序
// m_pEndItem = m_pStartItem;
// m_pStartItem = pItem;
// qSwap(nStartSelectedPortIndex, nEndSelectedPortIndex);
// }
// //调整绘制顺序，防止箭头被覆盖
// m_pStartItem->stackBefore(m_pEndItem);
// QUndoCommand *pAddLineCommond = new AddLineCmd(this, m_pWorkflow, m_pStartItem, m_pEndItem,
// nStartSelectedPortIndex, nEndSelectedPortIndex);
// m_pUndoStack->push(pAddLineCommond);
// //重置端口状态
// HilightOtherItems(m_pEndItem == pItem ? m_pStartItem : m_pEndItem, false);
// m_pStartItem->CancelPortSelect();
// m_pEndItem->CancelPortSelect();
// m_pStartItem = NULL;
// m_pEndItem = NULL;
// }
// }
// }
// else if(m_bModuleMoved)//模块被拖动的情况
// {
// m_bModuleMoved = false;
// QList< ModuleMovedInfo > moduleMovedInfoList;
// foreach(QGraphicsItem *pItem, selectedItems())
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (!pModule)
// {
// continue;
// }
// pModule->GetModuleStyle()->SetMouseReleasePos(pModule->pos());
// ModuleMovedInfo moveInfo;
// moveInfo.stepId = pModule->GetModule()->GetStepID();
// moveInfo.mousePressPos = pModule->GetModuleStyle()->GetMousePressPos();
// moveInfo.mouseReleasePos = pModule->GetModuleStyle()->GetMouseReleasePos();
// moduleMovedInfoList << moveInfo;
// }
// QUndoCommand *pMoveModuleCmd = new MoveModuleCmd(this, moduleMovedInfoList, false);
// m_pUndoStack->push(pMoveModuleCmd);
// m_bKeyPressed = false;
// emit UpdateSceneRect();
// }
// else if(m_rubberBandPoint != mouseEvent->scenePos().toPoint() && !itemAt(m_rubberBandPoint))//模块被框选的情况
// {
// //是否框选所选区域
// if(!m_bEnableMultiSelect)
// {
// return;
// }
// QRectF rect(m_rubberBandPoint, mouseEvent->scenePos().toPoint());
// QPainterPath path;
// path.addRect(rect);
// setSelectionArea(path);
// }
}
void WorkflowSceneManager::UpdateActions()
{
//测井解释不需要，先删除
}
void WorkflowSceneManager::RestoreActions(bool bConnectAction)
{
// // 获得工具条上的菜单，并设置可用性
// ToolBarService* pStyleToolBarService = this->GetStyleToolBarService();
// if(pStyleToolBarService != NULL)
// {
// QAction* pAddLineAction = pStyleToolBarService->GetAction(tr(g_szConnect));
// if(pAddLineAction != NULL)
// {
// if(bConnectAction == true)
// {
// connect(pAddLineAction, SIGNAL(triggered()), this, SLOT(slotAddLine()), Qt::UniqueConnection);
// }
// else
// {
// disconnect(pAddLineAction, SIGNAL(triggered()), this, SLOT(slotAddLine()));
// }
// }
// QAction* pBreakAction = pStyleToolBarService->GetAction(tr(g_szBreak));
// if(pBreakAction != NULL)
// {
// if(bConnectAction == true)
// {
// connect(pBreakAction, SIGNAL(triggered()), this, SLOT(slotBreakLine()), Qt::UniqueConnection);
// }
// else
// {
// disconnect(pBreakAction, SIGNAL(triggered()), this, SLOT(slotBreakLine()));
// }
// }
// QAction* pDisableAction = pStyleToolBarService->GetAction(tr(g_szDisable));
// if(pDisableAction != NULL)
// {
// if(bConnectAction == true)
// {
// connect(pDisableAction, SIGNAL(triggered()), this, SLOT(slotToolBarEnable()), Qt::UniqueConnection);
// }
// else
// {
// disconnect(pDisableAction, SIGNAL(triggered()), this, SLOT(slotToolBarEnable()));
// }
// }
// QAction* pDeleteAction = pStyleToolBarService->GetAction(tr(g_szDeleteO));
// if(pDeleteAction != NULL)
// {
// if(bConnectAction == true)
// {
// connect(pDeleteAction, SIGNAL(triggered()), this, SLOT(slotDeleteModule()), Qt::UniqueConnection);
// }
// else
// {
// disconnect(pDeleteAction, SIGNAL(triggered()), this, SLOT(slotDeleteModule()));
// }
// }
// QAction* pLayoutAction = pStyleToolBarService->GetAction(tr(g_szAutoAlign));
// if(pLayoutAction != NULL)
// {
// if(bConnectAction == true)
// {
// connect(pLayoutAction, SIGNAL(triggered()), this, SLOT(slotAlign()), Qt::UniqueConnection);
// }
// else
// {
// disconnect(pLayoutAction, SIGNAL(triggered()), this, SLOT(slotAlign()));
// }
// }
// QAction* pEditAction = pStyleToolBarService->GetAction(tr(g_szEditDot));
// if(pEditAction != NULL)
// {
// if(bConnectAction == true)
// {
// connect(pEditAction, SIGNAL(triggered()), this, SLOT(slotToolBarEdit()), Qt::UniqueConnection);
// }
// else
// {
// disconnect(pEditAction, SIGNAL(triggered()), this, SLOT(slotToolBarEdit()));
// }
// }
// QAction* pDeleteDisabledItemsAction = pStyleToolBarService->GetAction(TOOLBAR_DELETE_DISABLED_ITEMS);
// if(pDeleteDisabledItemsAction)
// {
// if(bConnectAction == true)
// {
// connect(pDeleteDisabledItemsAction, SIGNAL(triggered()), this, SLOT(slotDeleteDisabledItems()),
// Qt::UniqueConnection);
// }
// else
// {
// disconnect(pDeleteDisabledItemsAction, SIGNAL(triggered()), this, SLOT(slotDeleteDisabledItems()));
// }
// }
// }
}
void WorkflowSceneManager::slotOnSelectionChanged()
{
// m_bKeyPressed = false;
// QGraphicsItem* pItem = focusItem();
// if(!pItem)
// {
// if(NULL != m_pStartItem)
// {
// HilightOtherItems(m_pStartItem, false);
// m_pStartItem->CancelPortSelect();
// m_pStartItem = NULL;
// }
// }
// else
// {
// if(pItem->type() == ModuleGraphicsItem::Type)
// {
// ModuleGraphicsItem* pModule = static_cast< ModuleGraphicsItem* > (pItem);
// if(m_pStartItem != NULL && pModule != m_pStartItem)
// {
// HilightOtherItems(m_pStartItem, false);
// m_pStartItem->CancelPortSelect();
// m_pStartItem = NULL;
// }
// }
// //隐藏模块名称编辑框
// HideAllModuleNameEdit();
// }
// //更新工具栏
// if(!m_ScenceReadOnly)
// {
// UpdateActions();
// }
// //更新B2区info信息
// UpdateHelpDoc();
}
void WorkflowSceneManager::slotSelectModule(pai::workflow::CModuleInformation *pInfo)
{
// if(pInfo == NULL)
// {
// return;
// }
// if(m_pWorkflow && !m_ScenceReadOnly)
// {
// pai::graphics2d::ModuleGraphicsItem* pModuleItem = FindModule(pInfo->GetStepID());
// if(pModuleItem) // 只有本场景的Item才进行相关操作。
// {
// //自动填充
// if(!pInfo->IsBlankModule())
// {
// ModuleParameterFillEngine smartFillEngine;
// if(smartFillEngine.SmartFill(pInfo, m_pWorkflow) == true)
// {
// m_pWorkflow->SetModify(true);
// pModuleItem->SetInitialValidated(false);
// }
// }
// //隐藏模块名称编辑框
// pModuleItem->HideModuleNameEditor();
// }
// }
}
void WorkflowSceneManager::ClearDashLine()
{
// if(NULL != m_pTmpLine)
// {
// QList< QGraphicsItem * > startItems = items(m_pTmpLine->line().p1());
// if(startItems.count() && startItems.first() == m_pTmpLine)
// {
// startItems.removeFirst();
// }
// QList< QGraphicsItem * > endItems = items(m_pTmpLine->line().p2());
// if(endItems.count() && endItems.first() == m_pTmpLine)
// {
// endItems.removeFirst();
// }
// removeItem(m_pTmpLine);
// delete m_pTmpLine;
// m_pTmpLine = NULL;
// SetSceneLineDrawing(false);
// }
}
void WorkflowSceneManager::slotOnPortHoveringChanged(pai::graphics2d::ModuleGraphicsItem* pItem, bool bHovering)
{
// if(pItem == NULL || pItem->scene() != this)
// {
// return;
// }
// if(m_pStartItem != NULL && bHovering && m_pStartItem != pItem)
// {
// m_pEndItem = pItem;
// }
}
void WorkflowSceneManager::slotOnPortSelectionChanged(pai::graphics2d::ModuleGraphicsItem* pItem, bool bSelected)
{
// if(pItem == NULL || pItem->scene() != this)
// {
// return;
// }
// if(m_pStartItem == NULL && bSelected)
// {
// m_pStartItem = pItem;
// HilightOtherItems(m_pStartItem, true);
// SetSceneLineDrawing(true);
// return;
// }
// if(m_pStartItem != NULL)
// {
// if(m_pEndItem == NULL && pItem != m_pStartItem)
// {
// pai::graphics2d::PortDirection eStartPortDirection;
// pai::graphics2d::PortDirection eEndPortDirection;
// int nStartSelectedPortIndex;
// int nEndSelectedPortIndex;
// m_pStartItem->GetSelectedPort(eStartPortDirection, nStartSelectedPortIndex);
// if(nStartSelectedPortIndex == -1)
// {
// m_pStartItem = NULL;
// return;
// }
// m_pEndItem = pItem;
// m_pEndItem->GetSelectedPort(eEndPortDirection, nEndSelectedPortIndex);
// if(nEndSelectedPortIndex == -1)
// {
// m_pEndItem = NULL;
// return;
// }
// if(eStartPortDirection == eEndPortDirection)
// {
// //重置端口状态
// HilightOtherItems(m_pStartItem, false);
// HilightOtherItems(m_pEndItem, false);
// m_pStartItem->CancelPortSelect();
// m_pEndItem->CancelPortSelect();
// m_pStartItem = NULL;
// m_pEndItem = NULL;
// return;
// }
// m_pStartItem->stackBefore(m_pEndItem);
// if(eStartPortDirection == Top && eEndPortDirection == Bottom)
// {
// //交换两个模块的前后顺序
// m_pEndItem = m_pStartItem;
// m_pStartItem = pItem;
// qSwap(nStartSelectedPortIndex, nEndSelectedPortIndex);
// }
// QUndoCommand *pAddLineCommond = new AddLineCmd(this, m_pWorkflow, m_pStartItem, m_pEndItem,
// nStartSelectedPortIndex, nEndSelectedPortIndex);
// m_pUndoStack->push(pAddLineCommond);
// //重置端口状态
// HilightOtherItems(m_pEndItem == pItem ? m_pStartItem : m_pEndItem, false);
// if(m_pStartItem)
// {
// m_pStartItem->CancelPortSelect();
// }
// if(m_pEndItem)
// {
// m_pEndItem->CancelPortSelect();
// }
// m_pStartItem = NULL;
// m_pEndItem = NULL;
// }
// else if(m_pEndItem == NULL)
// {
// SetSceneLineDrawing(true);
// }
// }
}
void WorkflowSceneManager::slotAddModule(const QString& moduleName)
{
pai::module::CModuleManager* pModuleManager = ::pai::module::GetModuleManager();
PELibraryModule* amodule2 = NULL;
CModule* amodule3 = NULL;
if (pModuleManager)
{
// amodule3 = dynamic_cast<PELibraryModule*>(pModuleManager->CreateModuleByClassName(moduleName.toStdString()));
amodule3 = (pModuleManager->CreateModuleByClassName(moduleName.toStdString()));
amodule2 = dynamic_cast<PELibraryModule*>(amodule3);
CModuleConsole* pModuleConsole = GetWorkflowConsole();
CModuleParamers *pModuleParamers = pModuleConsole->g_mModuleParamers;
PELibraryModule* amodule=amodule2;
// amodule->SetSlfFileName("D:/jiayl0909/logPlus/build/Logdata/JPH-307.slf");
amodule->SetSlfFileName(pModuleParamers->m_CurrentSLFFileName);
amodule->InitModule(m_pParameterEditor);
CWellLogWorkflowDataModel * pWorkflowDataModel =dynamic_cast<CWellLogWorkflowDataModel*>( ::GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow() );
if (pWorkflowDataModel)
{
pWorkflowDataModel->m_pModule = amodule;
// pModuleConsole->m_pWorkflowDataModel = new CWellLogWorkflowDataModel();
// pai::objectmodel::PaiWorkflowDataModel* pWorkflow = pModuleConsole->m_pWorkflowDataModel;
// ::GetWorkflowConsole()->GetWorkflowWidget()->SetWorkflow(pWorkflow);
}
if(amodule&&amodule->parDialog) {
QRect rt=amodule->parDialog->geometry();
pModuleParamers->m_pParameterEditor->setVisible(false);
pModuleParamers->m_pDialogLayout->setVisible(true);
amodule->parDialog->setMinimumHeight(rt.height());
pModuleParamers->m_pDialogLayout->setWidget(amodule->parDialog);
disconnect(pModuleParamers->m_pbtnRun,SIGNAL(clicked()),pModuleParamers,SLOT(slotRunCurrentZone()));
pModuleParamers->m_pbtnRun->setVisible(false);
pModuleParamers->m_pbtnRun->setEnabled(false);
}
else {
pModuleParamers->m_pParameterEditor->setVisible(true);
pModuleParamers->m_pDialogLayout->setVisible(false);
pModuleParamers->m_pbtnRun->setVisible(true);
pModuleParamers->m_pbtnRun->setEnabled(true);
disconnect(pModuleParamers->m_pbtnRun,SIGNAL(clicked()),pModuleParamers,SLOT(slotRunCurrentZone()));
connect(pModuleParamers->m_pbtnRun,SIGNAL(clicked()),pModuleParamers,SLOT(slotRunCurrentZone()));
}
pModuleParamers->m_pCurrentModuleInfo = new CModuleInformation(moduleName.toStdString());
pai::workflow::CModuleInformation * amoduleInfo = pModuleParamers->m_pCurrentModuleInfo;
// amoduleInfo->GetModule()->SetSlfFileName(pModuleParamers->m_CurrentSLFFileName)
amoduleInfo->SetModule(amodule);
pModuleParamers->InitCardParamSettings(amoduleInfo);
return;
// PELibraryModule* amodule=dynamic_cast<PELibraryModule*>(m_pWorkflow->GetModule(0)->GetModule());
}
// // double click module on module tree
// CModuleConsole* cn=GetWorkflowConsole();
// if(!cn||!cn->GetWorkflowWidget()) return;
// m_pWorkflow=cn->GetWorkflowWidget()->GetWorkflow();
// if(m_pWorkflow && !moduleName.isEmpty())
{
if (m_bIsSingleMethod)
{
DeleteAll();
}
//获取唯一被选中模块
pai::graphics2d::ModuleGraphicsItem* pSelectedItem = GetSingleSelectedItem();
if(pSelectedItem)
{
//如果只选中一个模块，则双击模块树，默认为在选中模块下面添加模块树上的模块
// QUndoCommand *pAddModuleCommond = new AddModuleCmd(this, m_pWorkflow, moduleName, pSelectedItem, false);
// m_pUndoStack->push(pAddModuleCommond);
return;
}
// QUndoCommand *pAddModuleCommond = new AddModuleCmd(this, m_pWorkflow, moduleName);
// m_pUndoStack->push(pAddModuleCommond);
if(m_bIsSingleMethod) {
CModuleParamers *pModuleParamers=GetWorkflowConsole()->g_mModuleParamers;
if(pModuleParamers&&pModuleParamers->m_TabWidget_Module) pModuleParamers->m_TabWidget_Module->setCurrentWidget(pModuleParamers->m_TablWiget_Para);
QSplitter * m_pVSplitter=dynamic_cast<QSplitter *>(pModuleParamers->parent());
if(m_pVSplitter) {
// CVecWindow *pMWOSGWindow =dynamic_cast<CVecWindow *>(m_pVSplitter->widget(0));
// if(pMWOSGWindow) {
// CWellSectionWindowDocument *pDoc=dynamic_cast<CWellSectionWindowDocument *>(pMWOSGWindow->GetWindowDocument());
// if(pDoc) {
if(/*m_pWorkflow->GetModule(0)*/amodule2)
{
// pDoc->pModule=m_pWorkflow->GetModule(0)->GetModule();
// PELibraryModule* amodule=dynamic_cast<PELibraryModule*>(pDoc->pModule);
PELibraryModule* amodule=amodule2;
if(amodule&&amodule->parDialog) {
QRect rt=amodule->parDialog->geometry();
pModuleParamers->m_pParameterEditor->setVisible(false);
pModuleParamers->m_pDialogLayout->setVisible(true);
amodule->parDialog->setMinimumHeight(rt.height());
pModuleParamers->m_pDialogLayout->setWidget(amodule->parDialog);
disconnect(pModuleParamers->m_pbtnRun,SIGNAL(clicked()),pModuleParamers,SLOT(slotRunCurrentZone()));
pModuleParamers->m_pbtnRun->setVisible(false);
pModuleParamers->m_pbtnRun->setEnabled(false);
}
else {
pModuleParamers->m_pParameterEditor->setVisible(true);
pModuleParamers->m_pDialogLayout->setVisible(false);
pModuleParamers->m_pbtnRun->setVisible(true);
pModuleParamers->m_pbtnRun->setEnabled(true);
disconnect(pModuleParamers->m_pbtnRun,SIGNAL(clicked()),pModuleParamers,SLOT(slotRunCurrentZone()));
connect(pModuleParamers->m_pbtnRun,SIGNAL(clicked()),pModuleParamers,SLOT(slotRunCurrentZone()));
}
}
// }
// }
}
}
}
}
CModuleInformation * WorkflowSceneManager::GetSingleSelectedModule()
{
// pai::graphics2d::ModuleGraphicsItem* pSelectedItem = GetSingleSelectedItem();
// if (pSelectedItem)
// {
// return pSelectedItem->GetModule();
// }
return NULL;
}
void WorkflowSceneManager::slotOnObjectRemoveChild(pai::objectmodel::PaiObject* /*pObject*/,
pai::objectmodel::PaiObject* pChild)
{
// if(m_pWorkflow == NULL || m_pWorkflow->HasFlag(PaiObject::Deleting))
// {
// return;
// }
// if(m_ScenceReadOnly == true)
// {
// return;
// }
// HandleOnObjectAddOrRemove(pChild, false);
}
void WorkflowSceneManager::HandleOnObjectAddOrRemove(pai::objectmodel::PaiObject* pChild, bool add)
{
// QMap < AcceptDropType, QUuid > mapAllConversions = pai::ModuleParameterUtil::GetAcceptDropTypesMap();
// if(mapAllConversions.values().contains(pChild->GetTypeID()) == true)
// {
// PaiGeoObject *pChildGeoObject = dynamic_cast< PaiGeoObject * > (pChild);
// if(pChildGeoObject != NULL)
// {
// // 如果新添加的数据对象与当前工作流在同一个工区时，启动工作流模块校验线程，处理数据变化对当前工作流模块的影响。
// if(add)
// {
// PaiSurvey* pSurvey = pChildGeoObject->GetForebear< PaiSurvey > ();
// //获取数据树上虚拟工作流
// PaiObject *pDataTreeWorkflow = GetObjectModelService()->GetObject(m_pWorkflow->GetDBID());
// if(!pDataTreeWorkflow)
// {
// return;
// }
// if(pSurvey && pSurvey == pDataTreeWorkflow->GetForebear< PaiSurvey > ())
// {
// ValidateModulesAcceptDropData(pChild->GetTypeID(), pChildGeoObject->GetPhysicalFile());
// }
// }
// else // 如果数据对象被删除，启动工作流模块校验线程，处理数据变化对当前工作流模块的影响。
// {
// ValidateModulesAcceptDropData(pChild->GetTypeID(), pChildGeoObject->GetPhysicalFile());
// }
// }
// }
}
// void WorkflowSceneManager::ValidateModulesAcceptDropData(QUuid typeID, QString logicFileName)
// {
// if(logicFileName.isEmpty())
// {
// return;
// }
// int nModuleCount = m_pWorkflow->GetModuleCount();
// if(nModuleCount > 0 && m_ScenceReadOnly == false)
// {
// for(int i = 0; i < nModuleCount; ++i)
// {
// workflow::CModuleInformation* pModule = m_pWorkflow->GetModule(i);
// if (!pModule)
// {
// continue;
// }
// pai::graphics2d::ModuleGraphicsItem *pModuleItem = FindModule(pModule->GetStepID());
// if(NULL == pModuleItem || NULL == pModule->GetModule())
// {
// continue;
// }
// pai::module::CModuleParameter* pModuleParam = pModule->GetModule()->GetModuleParameter();
// assert(pModuleParam != NULL);
// std::vector< CParameterItem* > vecLeafItems;
// pModuleParam->GetRootParameterItem()->GetParameterItemsWithValidInputType(vecLeafItems);
// std::vector< pai::module::CParameterItem* >::const_iterator it;
// for(it = vecLeafItems.begin(); it != vecLeafItems.end(); ++it)
// {
// pai::module::CParameterItem *pParameterItem = *it;
// QList < QUuid > acceptDropTypes(pai::ModuleParameterUtil::GetAcceptDropTypes(pParameterItem));
// if(logicFileName.toStdString() == pParameterItem->GetStringValue())
// {
// if(((acceptDropTypes.count() == 0) && (pParameterItem->GetInputType()
// == pai::module::HDFSFILEEDITOR) && (pParameterItem->GetInOut() == "OUT"))
// || ((acceptDropTypes.count() > 0) && acceptDropTypes.at(0) == typeID))
// {
// if(m_pThreadPool != NULL)
// {
// CParameterValidateThread *pValidateThread =
// new CParameterValidateThread(pModule, ValidateEventSource_FromBackgroundNoSubmit);
// connect(pValidateThread, SIGNAL(finished()), m_pParameterEditor->model(),
// SLOT(slotOnParameterValidated()));
// m_pThreadPool->start(pValidateThread);
// }
// break;
// }
// }
// }
// }
// }
// }
void WorkflowSceneManager::slotOnParameterValidated()
{
CParameterValidateThread* pValidateThread = dynamic_cast< CParameterValidateThread* > (sender());
if(pValidateThread == NULL)
{
return;
}
pai::module::CModuleCheckResult* pErrorInfo = pValidateThread->GetCheckResult();
if(pErrorInfo != NULL)
{
slotOnModuleParameterError(pValidateThread->GetModuleInfo(),pValidateThread->GetModuleCheckResult(),*pErrorInfo,
pValidateThread->GetValidateEventSource());
}
pValidateThread->deleteLater();
}
void WorkflowSceneManager::DeleteModule(int setpID)
{
// pai::graphics2d::ModuleGraphicsItem* pModuleItem = FindModule(setpID);
// if(pModuleItem != NULL)
// {
// if(pModuleItem == m_pStartItem)
// {
// m_pStartItem = NULL;
// }
// if(pModuleItem == m_pEndItem)
// {
// m_pEndItem = NULL;
// }
// removeItem(pModuleItem);
// //在移除模块以后模块参数列表清空
// if(m_pParameterEditor)
// {
// m_pParameterEditor->Clear();
// }
// m_pModuleToolBarItem->DetachModuleItem();
// m_pModuleToolBarItem->SetToolBarVisible(false);
// delete pModuleItem;
// pModuleItem = NULL;
// //场景删除模块时，更新场景rect
// emit UpdateSceneRect();
// }
// else
// {
// pai::log::Debug(_FLF("not find module item."));
// }
}
void WorkflowSceneManager::DeleteConnection(pai::workflow::CModuleConnection *pConnection)
{
// QGraphicsItem* pConnectionItem = FindConnection(pConnection);
// if(pConnectionItem != NULL)
// {
// removeItem(pConnectionItem);
// delete pConnectionItem;
// pConnectionItem = NULL;
// }
// else
// {
// // pai::log::Debug(_FLF("not find connection item."));
// }
}
void WorkflowSceneManager::slotDeleteModule(pai::graphics2d::GeneralWorkflowScene * pScene,
pai::graphics2d::ModuleGraphicsItem* pModuleItem)
{
// if(NULL == this->m_pWorkflow || pModuleItem == NULL || pScene != this)
// {
// return;
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Delete module form workflow");
// QList< QGraphicsItem* > list;
// list.clear();
// list.push_back(pModuleItem);
// QUndoCommand *pDeleteModuleCommond = new DeleteModuleCmd(this, m_pWorkflow, list);
// m_pUndoStack->push(pDeleteModuleCommond);
// //refresh action after delete modules
// if(m_pWorkflow != NULL )
// {
// UpdateActions();
// }
// //更新B2区info信息
// UpdateHelpDoc();
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Delete module form workflow");
}
void WorkflowSceneManager::SelectModuleItem(int stepID)
{
// ModuleGraphicsItem *pModuleItem = FindModule(stepID);
// if(pModuleItem)
// {
// if(!pModuleItem->isSelected())
// {
// pModuleItem->setSelected(true);
// }
// emit signalOpenModuleParam(pModuleItem->GetModule());
// }
// //更新B2区info信息
// UpdateHelpDoc();
}
void WorkflowSceneManager::slotCopy()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Copy workflow modules");
// //获取要复制模块的坐标
// foreach(QGraphicsItem* pItem, selectedItems())
// {
// if (pItem->type() != pai::graphics2d::ModuleConnectGraphicsItem::Type)
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (!pModule)
// {
// continue;
// }
// if (!m_bKeyPressed)
// {
// pModule->GetModuleStyle()->SetMousePressPos(pModule->pos());
// }
// m_PastePoint.setX(pItem->pos().x());
// m_PastePoint.setY(pItem->pos().y());
// }
// }
// CopyModuleCmd copyModuleCmd(m_pWorkflow, selectedItems());
// copyModuleCmd.redo();
// PageService* pPageService =
// ::GetConsoleGUIService()->GetViewTabService()->GetPageService(QUuid(g_szWorkflowPluginID));
// if(pPageService == NULL)
// {
// return;
// }
// QAction* pPasteAction = pPageService->GetAction(tr(g_szPaste));
// if(pPasteAction != NULL)
// {
// pPasteAction->setEnabled(true);
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Copy workflow modules");
}
void WorkflowSceneManager::DeleteAll()
{
slotSelectAll();
slotDeleteModule();
}
// select all slot added by Pangshiming (2012.6.11)
void WorkflowSceneManager::slotSelectAll()
{
// disconnect(this, SIGNAL(selectionChanged()), this, SLOT(slotOnSelectionChanged()));
// SelectAllCmd selectAllCmd(this);
// selectAllCmd.redo();
// connect(this, SIGNAL(selectionChanged()), this, SLOT(slotOnSelectionChanged()));
// UpdateActions();
// //更新B2区info信息
// UpdateHelpDoc();
}
// copy all slot added by Pangshiming (2012.6.11)
void WorkflowSceneManager::slotCopyAll()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Copy all modules");
// CopyModuleCmd copyModuleCmd(m_pWorkflow, items());
// copyModuleCmd.redo();
// PageService* pPageService =
// ::GetConsoleGUIService()->GetViewTabService()->GetPageService(QUuid(g_szWorkflowPluginID));
// if(pPageService == NULL)
// {
// return;
// }
// QAction* pPasteAction = pPageService->GetAction(tr(g_szPaste));
// if(pPasteAction != NULL)
// {
// pPasteAction->setEnabled(true);
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Copy all modules");
}
QMenu* WorkflowSceneManager::WorkflowSenceMenu(QGraphicsSceneContextMenuEvent* pContextMenuEvent)
{
QMenu* pSenceMenu = new QMenu;
bool existing = IsModuleExisting();
// QAction *pSelectAllAction = pSenceMenu->addAction(tr(g_szSelectAll), this, SLOT(slotSelectAll()));
// //场景中存在模块或者连线selectAll使能
// pSelectAllAction->setEnabled(existing);
//添加分割线
pSenceMenu->addSeparator();
// QAction *pUndoAction = pSenceMenu->addAction(tr(g_szUndo), this, SLOT(slotUndo()));
// pUndoAction->setEnabled(m_pUndoStack->canUndo());
// QAction *pRedoAction = pSenceMenu->addAction(tr(g_szRedo), this, SLOT(slotRedo()));
// pRedoAction->setEnabled(m_pUndoStack->canRedo());
// //添加分割线
// pSenceMenu->addSeparator();
// QAction *pAlignAction = pSenceMenu->addAction(tr(g_szAutoAlign), this, SLOT(slotAlign()));
// // if selected items great then 2,user can do Auto-Align action (PSM add 2012.6.11)
// int selectedModuleCount = 0;
// for(int j = 0; j < selectedItems().count(); j++)
// {
// if(this->selectedItems().at(j)->type() == ModuleGraphicsItem::Type)
// {
// selectedModuleCount += 1;
// }
// }
// pAlignAction->setEnabled(selectedModuleCount >= 2 && CheckConnection());
//添加分割线
pSenceMenu->addSeparator();
//添加分割线
pSenceMenu->addSeparator();
QAction *pZoominAction = pSenceMenu->addAction(tr(g_szZoomIn), this, SLOT(slotZoomin()));
QAction *pZoomoutAction = pSenceMenu->addAction(tr(g_szZoomOut), this, SLOT(slotZoomout()));
//场景中存在模块并且放大次数小于最大放大次数时，zoomIn按钮使能
pZoominAction->setEnabled(existing &&(m_zoomCount < ZOOM_MAXCOUNT));
//场景中存在模块并且缩小次数大于最小缩小次数时，zoomOut按钮使能
pZoomoutAction->setEnabled(existing && (m_zoomCount > ZOOM_MINCOUNT));
return pSenceMenu;
}
QMenu* WorkflowSceneManager::WorkflowConnectLineMenu(QGraphicsSceneContextMenuEvent* /*contextMenuEvent*/)
{
QMenu* connectLineMenu = new QMenu;
QAction *delAction = connectLineMenu->addAction(tr(g_szDeleteO), this, SLOT(slotDeleteConnection()));
delAction->setEnabled(true);
connectLineMenu->addSeparator();
QAction *addCommentAction = connectLineMenu->addAction(tr(g_szAddAnnotODot));
addCommentAction->setEnabled(false);
return connectLineMenu;
}
QMenu* WorkflowSceneManager::WorkflowPortMenu(QGraphicsSceneContextMenuEvent* /*contextMenuEvent*/)
{
QMenu* portMenu = new QMenu;
QAction *connectToAction = portMenu->addAction(tr(g_szConnectTo));
connectToAction->setEnabled(false);
QMenu* connectToMenu = new QMenu;
connectToAction->setMenu(connectToMenu);
portMenu->addSeparator();
QAction *disconnectFromAction = portMenu->addAction(tr(g_szDisconnetFrom));
disconnectFromAction->setEnabled(false);
QMenu* disconnectFromMenu = new QMenu;
disconnectFromAction->setMenu(disconnectFromMenu);
return portMenu;
}
QMenu *WorkflowSceneManager::WorkflowModuleMenu(pai::workflow::CModuleInformation *moduleInfo)
{
QMenu *moduleMenu = new QMenu;
// QAction *parametersAction = moduleMenu->addAction(tr(g_szParameterODot), this, SLOT(slotModuleParameter()));
// parametersAction->setEnabled(false);
// pai::graphics2d::ModuleGraphicsItem *pSelectedItem = GetSingleSelectedItem();
// if(pSelectedItem != NULL)
// {
// parametersAction->setEnabled(true);
// }
// moduleMenu->addSeparator();
// int selectedModuleCount = 0;
// for(int j = 0; j < selectedItems().count(); j++)
// {
// // if(this->selectedItems().at(j)->type() == ModuleGraphicsItem::Type)
// {
// selectedModuleCount += 1;
// }
// }
// QAction *delAction = moduleMenu->addAction(tr(g_szDeleteO), this, SLOT(slotDeleteModule()));
// delAction->setData(moduleInfo->GetStepID());
// moduleMenu->addSeparator();
// QAction *alignAction = moduleMenu->addAction(tr(g_szAutoAlign), this, SLOT(slotAlign()));
// alignAction->setEnabled(false);
// // if stected items great then 2,user can do Auto-Align action (PSM add 2012.6.11)
// if(selectedModuleCount >= 2 /*&& CheckConnection()*/)
// {
// alignAction->setEnabled(true);
// }
return moduleMenu;
}
void WorkflowSceneManager::slotDeleteModule()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Delete modules on workflow");
// QUndoCommand *pDeleteModuleCommond = new DeleteModuleCmd(this, m_pWorkflow, selectedItems());
// m_pUndoStack->push(pDeleteModuleCommond);
// //reset submit action after delete modules
// if(m_pWorkflow != NULL)
// {
// UpdateActions();
// }
// //更新B2区的info信息
// UpdateHelpDoc();
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Delete modules on workflow");
}
void WorkflowSceneManager::slotUndo()
{
// m_pUndoStack->undo();
// HideAllModuleNameEdit();
}
void WorkflowSceneManager::slotRedo()
{
// m_pUndoStack->redo();
// HideAllModuleNameEdit();
}
// align the selected items (Pangshiming add 2012.5.31)
void WorkflowSceneManager::slotAlign()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Align modules on workflow");
// if(!m_pWorkflow)
// {
// return;
// }
// QUndoCommand *pLayoutModuleCommond = new LayoutModuleCmd(this, m_pWorkflow, selectedItems());
// // m_pUndoStack->push(pLayoutModuleCommond);
// SceneRectAutoAdaptive();
//自动排序以后，模块的位置发生变化，设置模块被修改标志为真
// m_pWorkflow->SetModify(true);
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Align modules on workflow");
}
///////////////////////////////////////////////////////////////////////////////
void WorkflowSceneManager::slotZoomin()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Zoom in");
// QList< QGraphicsView* > list = views();
// if(list.count() != 0 && (m_zoomCount < ZOOM_MAXCOUNT))
// {
// QUndoCommand *pZoomInCmd = new ZoomInCmd(list.at(0));
// m_pUndoStack->push(pZoomInCmd);
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Zoom in");
}
void WorkflowSceneManager::slotZoomout()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Zoom out");
// QList< QGraphicsView* > list = views();
// if(list.count() != 0 && (m_zoomCount > ZOOM_MINCOUNT))
// {
// QUndoCommand *pZoomInCmd = new ZoomOutCmd(list.at(0));
// m_pUndoStack->push(pZoomInCmd);
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Zoom out");
}
void WorkflowSceneManager::slotPasteHere()
{
// // pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Paste workflow modules");
// QAction* pAction = dynamic_cast< QAction* > (sender());
// QPoint point = pAction->data().toPoint();
// QRectF boundingRect;
// // get copy items from GlobalWorkflowItems class support paste the copied items between workflows
// foreach (QGraphicsItem *item, GlobalWorkflowItems::GetInstance()->GetCopyGraphicItems())
// boundingRect |= item->sceneBoundingRect();
// ExpandSceneRectIfNeeded(point, boundingRect.width(), boundingRect.height());
// QList< QGraphicsItem* > copyItems = GlobalWorkflowItems::GetInstance()->GetCopyGraphicItems();
// QUndoCommand *pPasteModuleCmd = new PasteModuleCmd(this, m_pWorkflow, copyItems, point, boundingRect);
// // m_pUndoStack->push(pPasteModuleCmd);
// clearSelection();
// // pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Paste workflow modules");
}
void WorkflowSceneManager::slotOnModuleParameterError(pai::workflow::CModuleInformation * pModuleInfo,bool checkresult,
const CModuleCheckResult& errorInfo,
ValidateEventSource /*eventSource*/)
{
if(pModuleInfo == NULL || pModuleInfo->IsBlankModule())
{
return;
}
// if(!m_pWorkflow->HasModule(pModuleInfo))
// {
// return;
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Show parameter error on Module");
// std::vector < std::string > vecParameterItemIDs;
// errorInfo.GetErroInfoParameterIDs(vecParameterItemIDs);
// //设置模块的错误提示信息
// QAction *pAction = ::GetGlobalCommand().GetAction(GetViewCmdID_RunWorkflow());
// QString errorString("");
// if(vecParameterItemIDs.size() > 0)
// {
// errorString.append("Parameters Error Information");
// for(unsigned int j = 0; j < vecParameterItemIDs.size(); j++)
// {
// errorString.append("\n");
// errorString.append(QString::number(j + 1) + ". " + QString::fromStdString(vecParameterItemIDs.at(j)) + "\n"
// + QString::fromStdString(errorInfo.GetErrorMessage(vecParameterItemIDs.at(j))));
// if(j < vecParameterItemIDs.size() - 1)
// {
// errorString.append("\n");
// }
// }
// }
// if(pAction) {
// QString name;
// if(pModuleInfo->GetModule()&&pModuleInfo->GetModule()->GetMetaData()) name=pModuleInfo->GetModule()->GetMetaData()->GetName().c_str();
// pAction->setToolTip("Run_"+name);
// pAction->setEnabled(checkresult);
// }
// ModuleGraphicsItem * pGraphicsItem = FindModule(pModuleInfo->GetStepID());
// if(!pGraphicsItem)
// {
// return;
// }
// pGraphicsItem->SetErrorString(errorString);
// PaiModuleStyle* pErrorModuleStyle = m_pWorkflow->GetModuleStyle(pModuleInfo->GetStepID());
// bool bFindError = true;
// if(pErrorModuleStyle != NULL)
// {
// pai::module::ParameterCompleteIndex completeIndex = pai::module::ParamPerfect;
// pModuleInfo->GetModule()->GetModuleParameter()->IsReady(completeIndex);
// if(completeIndex == pai::module::ParamWarning)
// {
// pErrorModuleStyle->SetWarningFlag(true);
// }
// else
// {
// if(completeIndex == pai::module::ParamPerfect && errorInfo.IsEmpty())
// {
// //无错误时需要把警告和错误两种标志都取消
// pErrorModuleStyle->SetWarningFlag(false);
// pErrorModuleStyle->SetErrorFlag(false);
// }
// else
// {
// pErrorModuleStyle->SetErrorFlag(true);
// }
// }
// pGraphicsItem->update();
// bFindError = (pErrorModuleStyle->IsError() || pErrorModuleStyle->IsWarning());
// }
// if(!bFindError)
// {
// int nModuleCount = m_pWorkflow->GetModuleCount();
// for(int i = 0; i < nModuleCount; ++i)
// {
// workflow::CModuleInformation* pModule = m_pWorkflow->GetModule(i);
// if(NULL == pModule)
// {
// continue;
// }
// PaiModuleStyle* pModuleStyle = m_pWorkflow->GetModuleStyle(pModule->GetStepID());
// if(pModuleStyle != NULL && (pModuleStyle->IsError() || pModuleStyle->IsWarning()))
// {
// bFindError = true;
// break;
// }
// }
// }
//if(bFindError)
//{
// m_pWorkflow->SetCanSubmit(false);
// PageService* pPageService =
// ::GetConsoleGUIService()->GetViewTabService()->GetPageService(QUuid(g_szWorkflowPluginID));
// assert(pPageService != NULL);
// QAction* pSubmitAction = pPageService->GetAction(tr(g_szSubmit));
// if(pSubmitAction != NULL)
// {
// pSubmitAction->setEnabled(false);
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false,
// "Show parameter error on Module");
// return;
//}
//pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Show parameter error on Module");
//StartSubmitValidateThread();
}
bool WorkflowSceneManager::IsActiveWorkflow(pai::objectmodel::PaiWorkflowDataModel* pWorkflow)
{
if(!pWorkflow)
{
return false;
}
PaiWorkflowDataModel* pTmpWorkflow = NULL;
// if(GetWorkflowPlugin() && GetWorkflowPlugin()->GetWorkflowPluginCtr()
// && GetWorkflowPlugin()->GetWorkflowPluginCtr()->GetActiveWorkflowView())
// {
// pTmpWorkflow = GetWorkflowPlugin()->GetWorkflowPluginCtr()->GetActiveWorkflowView()->GetWorkflow();
// }
return (pTmpWorkflow == pWorkflow);
}
void WorkflowSceneManager::slotOnCanSubmitThreadFinished()
{
SubmitValidateThread* pValidateThread = dynamic_cast< SubmitValidateThread* > (sender());
//如果验证线程的顺序号小于启动的线程数，则直接返回，不设置按钮状态。
if(pValidateThread == NULL || pValidateThread->GetOrderNumber() < m_SubmitThreadCount)
{
return;
}
//无论本视图对应的tab页是否处于被选中状态，bLastSubmitStatus状态值都应该被更新。
bool bLastSubmitStatus = pValidateThread->GetPermitSubmit();
//只有本视图对应的tab页是处于被选中状态，按钮状态才应该根据bLastSubmitStatus被更新。
// if(NULL != m_pWorkflow && IsActiveWorkflow(m_pWorkflow) == true)
// {
// m_pWorkflow->SetCanSubmit(bLastSubmitStatus && !(m_pWorkflow->IsSubmitting()));
// PageService* pPageService =
// ::GetConsoleGUIService()->GetViewTabService()->GetPageService(QUuid(g_szWorkflowPluginID));
// assert(pPageService != NULL);
// QAction* pSubmitAction = pPageService->GetAction(tr(g_szSubmit));
// if(pSubmitAction != NULL)
// {
// try
// {
// //获取数据树上虚拟工作流
// PaiObject *pDataTreeWorkflow = GetObjectModelService()->GetObject(m_pWorkflow->GetDBID());
// if(!pDataTreeWorkflow)
// {
// return;
// }
// pSubmitAction->setEnabled(bLastSubmitStatus && !(m_pWorkflow->IsSubmitting())
// && (PaiPermissionChecker::HasPermission(pDataTreeWorkflow,PaiAction::PaiPermissionTypes(PaiAction::UPDATE))));
// }
// catch(pai::error::generic_error & e)
// {
// pSubmitAction->setEnabled(false);
// }
// catch(...)
// {
// pSubmitAction->setEnabled(false);
// }
// }
// }
pValidateThread->deleteLater();
}
// CPaiWorkflowPlugin * WorkflowSceneManager::GetWorkflowPlugin()
// {
// return dynamic_cast< CPaiWorkflowPlugin * >
// (::GetConsoleGUIService()->GetPluginManager()->GetPlugin(QUuid(QString("1e511b0b-02a6-4eec-af57-613f489d4b49"))));
// }
void WorkflowSceneManager::contextMenuEvent(QGraphicsSceneContextMenuEvent* contextMenuEvent)
{
ModuleGraphicsItem* pModule = NULL;
ClearDashLine();
// pai::log::Debug(_FLF(tr("selected items %1").arg(selectedItems().count()).toStdString()));
// ModuleConnectGraphicsItem* pConnectLine = NULL;
// foreach(QGraphicsItem* pItem, selectedItems())
// {
// if(ModuleGraphicsItem::Type == pItem->type() && pItem->mapToScene(pItem->boundingRect())
// .containsPoint(contextMenuEvent->scenePos(), Qt::OddEvenFill))
// {
// pModule = static_cast<ModuleGraphicsItem*>(pItem);
// break;
// }
// if(ModuleConnectGraphicsItem::Type == pItem->type() && pItem->mapToScene(pItem->boundingRect())
// .containsPoint(contextMenuEvent->scenePos(), Qt::OddEvenFill))
// {
// pConnectLine = static_cast<ModuleConnectGraphicsItem*>(pItem);
// break;
// }
// }
// if((NULL == pModule) && (NULL == pConnectLine))
// {
// clearSelection();
// foreach(QGraphicsItem* pItem, items())
// {
// if(ModuleGraphicsItem::Type == pItem->type() && pItem->mapToScene(pItem->boundingRect())
// .containsPoint(contextMenuEvent->scenePos(), Qt::OddEvenFill))
// {
// pModule = static_cast<ModuleGraphicsItem*>(pItem);
// pItem->setSelected(true); //set the item that mouse pointer on it be selected item(module)
// break;
// }
// if(ModuleConnectGraphicsItem::Type == pItem->type() && pItem->mapToScene(pItem->boundingRect())
// .containsPoint(contextMenuEvent->scenePos(), Qt::OddEvenFill))
// {
// pConnectLine = static_cast<ModuleConnectGraphicsItem*>(pItem);
// pItem->setSelected(true); // set the item that mouse pointer on it be selected item(connected line)
// break;
// }
// }
// if((NULL == pModule) && (NULL == pConnectLine)) // no item selected (situation of blank scenes)
// {
// slotSelectModule(NULL); // clear selection before popup menu, avoid crash
// QMenu* pMenu = WorkflowSenceMenu(contextMenuEvent); // popup WorkflowSenceMenu
// if(NULL != pMenu)
// {
// pMenu->exec(contextMenuEvent->screenPos());
// delete pMenu;
// }
// }
// }
// if(NULL != pModule)
// {
// if(pModule->HasPortSelected())
// {
// int selectedPortIndex = -1;
// PortDirection selectedPortDirection = Top;
// pModule->GetSelectedPort(selectedPortDirection, selectedPortIndex);
// assert(selectedPortIndex >= 0);
// QPolygonF portRect = pModule->mapToScene(pModule->GetPortBoundingRect(selectedPortDirection,
// selectedPortIndex));
// if(portRect.boundingRect().contains(contextMenuEvent->scenePos()))
// {
// QMenu* pMenu = WorkflowPortMenu(contextMenuEvent);
// if(NULL != pMenu)
// {
// pMenu->exec(contextMenuEvent->screenPos());
// delete pMenu;
// }
// return;
// }
// }
// QMenu* pMenu = WorkflowModuleMenu(pModule->GetModule());
// if(NULL != pMenu)
// {
// pMenu->exec(contextMenuEvent->screenPos());
// delete pMenu;
// }
// }
// if(NULL != pConnectLine)
// {
// QMenu* pMenu = WorkflowConnectLineMenu(contextMenuEvent);
// if(NULL != pMenu)
// {
// pMenu->exec(contextMenuEvent->screenPos());
// delete pMenu;
// }
// }
}
void WorkflowSceneManager::slotOnModuleParamDataChanged()
{
// for(int i = 0; i < m_pWorkflow->GetModuleCount(); ++i)
// {
// if(::GetGlobalModuleBackup()->HasModified(m_pWorkflow->GetID(), m_pWorkflow->GetModule(i)))
// {
// m_pWorkflow->SetModify(true);
// break;
// }
// }
}
void WorkflowSceneManager::slotOnDisableOrEnable(pai::graphics2d::ModuleGraphicsItem *item, bool enable)
{
// if(item == NULL || item->scene() != this)
// {
// return;
// }
// item->SetDisable(enable);
UpdateActions();
update();
}
void WorkflowSceneManager::slotOnSetName(pai::graphics2d::ModuleGraphicsItem *pItem)
{
// if(pItem == NULL || pItem->scene() != this)
// {
// return;
// }
// HideAllModuleNameEdit();
// pItem->setSelected(true);
// pItem->ShowModuleNameEditor();
}
void WorkflowSceneManager::RemoveModulesInBackup()
{
//清空模块的备份信息
// if(m_pWorkflow != NULL)
// {
// GlobalModuleBackup *moduleBack = ::GetGlobalModuleBackup();
// moduleBack->RemoveBackupModulesInWorkflow(m_pWorkflow->GetID());
// }
}
void WorkflowSceneManager::Clear()
{
//在移除模块以后模块参数列表清空
if(m_pParameterEditor)
{
m_pParameterEditor->Clear();
}
// m_pUndoStack->clear();
ReleaseThreadPool();
RemoveModulesInBackup();
//解除item间的父子关系，因为在清空场景时，delete父item时，子item也会一起析构
//虽然子item析构了，但是它的对象指针并没有从场景中移除，如果再次调用机会导致程序崩溃，defect31416
//解除了父子关系以后，再清理场景这个问题就不会存在
foreach(QGraphicsItem* pItem, items())
{
if (pItem->type() != pai::graphics2d::ModuleToolBarGraphicsItem::Type)
{
pItem->setParentItem(NULL);
}
}
//清空场景
foreach(QGraphicsItem* pItem, items())
{
if (pItem->type() != pai::graphics2d::ModuleToolBarGraphicsItem::Type)
{
removeItem(pItem);
delete pItem;
pItem = NULL;
}
}
//m_pWorkflow表示Job Manager插件B1区对应的工作流，或者日志插件A1区对应的工作流，或者工作流插件对应的工作流
//Job Manager插件B1区对应的工作流和日志插件A1区对应的工作流，工作流对象的管理由场景对应的View或者View的父亲管理
//对于工作流插件对应的编辑区工作流，目前由数据树管理，因此清理场景时m_pWorkflow直接置空即可
m_pWorkflow = NULL;
}
void WorkflowSceneManager::ClearItems()
{
foreach(QGraphicsItem* pItem, items())
{
if (pItem->type() != pai::graphics2d::ModuleToolBarGraphicsItem::Type)
{
pItem->setParentItem(NULL);
}
}
//清空场景
foreach(QGraphicsItem* pItem, items())
{
if (pItem->type() != pai::graphics2d::ModuleToolBarGraphicsItem::Type)
{
removeItem(pItem);
delete pItem;
pItem = NULL;
}
}
}
void WorkflowSceneManager::slotUpdateModule(pai::graphics2d::ModuleGraphicsItem* pItem)
{
// if(pItem == NULL || pItem->scene() != this)
// {
// return;
// }
// if(m_pWorkflow)
// {
// m_pWorkflow->SetModify(true);
// }
// if(pItem->GetModule())
// {
// SelectModuleItem(pItem->GetModule()->GetStepID());
// }
// if(m_pThreadPool != NULL)
// {
// CParameterValidateThread *pValidateThread =
// new CParameterValidateThread(pItem->GetModule(), ValidateEventSource_FromParameterItemChanged);
// connect(pValidateThread, SIGNAL(finished()), this, SLOT(slotOnParameterValidated()));
// m_pThreadPool->start(pValidateThread);
// }
}
void WorkflowSceneManager::slotDeleteConnection()
{
slotBreakLine();
}
void WorkflowSceneManager::slotCutItem()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Cut modules on workflow");
// QUndoCommand *pCutModuleCmd = new CutModuleCmd(this, m_pWorkflow, selectedItems());
// m_pUndoStack->push(pCutModuleCmd);
// PageService* pPageService =
// ::GetConsoleGUIService()->GetViewTabService()->GetPageService(QUuid(g_szWorkflowPluginID));
// if(pPageService == NULL)
// {
// return;
// }
// QAction* pPasteAction = pPageService->GetAction(tr(g_szPaste));
// if(pPasteAction != NULL)
// {
// pPasteAction->setEnabled(true);
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Cut modules on workflow");
}
void WorkflowSceneManager::slotAddLine()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Add line");
// ModuleGraphicsItem* pFirstItem = dynamic_cast< ModuleGraphicsItem* > (selectedItems().at(0));
// ModuleGraphicsItem* pSecondItem = dynamic_cast< ModuleGraphicsItem* > (selectedItems().at(1));
// //被选中的两个item，y坐标小的默认为startItem
// if(pFirstItem->y() > pSecondItem->y())
// {
// ModuleGraphicsItem *pTmpItem = pFirstItem;
// pFirstItem = pSecondItem;
// pSecondItem = pTmpItem;
// }
// QUndoCommand *pAddLineCommond = new AddLineCmd(this, m_pWorkflow, pFirstItem, pSecondItem);
// m_pUndoStack->push(pAddLineCommond);
// clearSelection();
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Add line");
}
void WorkflowSceneManager::slotBreakLine()
{
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Break line");
// QList<workflow::CModuleConnection*> connectionList = GlobalWorkflowItems::GetInstance()->GetConnectLineList(selectedItems());
// QUndoCommand *pBreakLineCommond = new BreakLineCmd(m_pWorkflow, this, connectionList);
// // m_pUndoStack->push(pBreakLineCommond);
// clearSelection();
// //更新B2区info信息
// UpdateHelpDoc();
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Break line");
}
void WorkflowSceneManager::slotOnModuleMenuClick(const QString& menuname, const QString& moduleInfo)
{
// //判断WorkflowSceneManager是否时选中场景
// if(!SaveHelper::GetActiveWorkflowView() || SaveHelper::GetActiveWorkflowView()->GetScene() != this)
// {
// return;
// }
// if(menuname == QString(tr(g_szAdd)))
// {
// slotAddModule(moduleInfo); // same to add a module on the end of workflow
// }
// else if(menuname == QString(tr(g_szAddUp)))
// {
// addBeforeOrAfter(moduleInfo, true);
// }
// else if(menuname == QString(tr(g_szAddDown)))
// {
// addBeforeOrAfter(moduleInfo, false);
// }
}
bool WorkflowSceneManager::AddLineCondition()
{
if(selectedItems().count() < 2)
{
return false;
}
int moduleCount = 0;
int moduleHasOutputCount = 0;
int moduleHasInputCount = 0;
// foreach (QGraphicsItem *pItem, selectedItems())
// {
// ModuleGraphicsItem *pModuleItem = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if(pModuleItem)
// {
// moduleCount += 1;
// if (pModuleItem->GetOutputPortCount() > 0)
// {
// ++moduleHasOutputCount;
// }
// if (pModuleItem->GetInputPortCount() > 0)
// {
// ++moduleHasInputCount;
// }
// }
// }
return (moduleCount == selectedItems().count() && moduleCount == 2 && moduleHasOutputCount && moduleHasInputCount);
}
bool WorkflowSceneManager::BreakLineCondition()
{
int moduleCount = 0;
foreach (QGraphicsItem *pItem, selectedItems())
{
if(pItem->type() == ModuleConnectGraphicsItem::Type)
{
++moduleCount;
}
}
return (moduleCount > 0);
}
bool WorkflowSceneManager::DeleteModuleCondition()
{
int moduleCount = 0;
foreach (QGraphicsItem *pItem, selectedItems())
{
// if(pItem->type() == ModuleGraphicsItem::Type)
// {
// ++moduleCount;
// }
}
return (moduleCount > 0);
}
bool WorkflowSceneManager::IsModuleExisting()
{
bool flag = false;
// foreach (QGraphicsItem *pItem, items())
// {
// if(pItem->type() == ModuleGraphicsItem::Type
// || pItem->type() == ModuleConnectGraphicsItem::Type)
// {
// flag = true;
// break;
// }
// }
return flag;
}
bool WorkflowSceneManager::DisableAndEditCondition()
{
int moduleCount = 0;
foreach (QGraphicsItem *pItem, selectedItems())
{
// ModuleGraphicsItem *pModuleItem = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if(pModuleItem)
// {
// ++moduleCount;
// }
}
return (moduleCount == 1);
}
void WorkflowSceneManager::slotToolBarEnable()
{
// ModuleGraphicsItem *pSelectedItem = GetSingleSelectedItem();
// if(!pSelectedItem)
// {
// return;
// }
// if(!pSelectedItem->IsDisable())
// {
// slotOnDisableOrEnable(pSelectedItem, true);
// }
// else
// {
// slotOnDisableOrEnable(pSelectedItem, false);
// }
UpdateActions();
}
void WorkflowSceneManager::slotToolBarEdit()
{
// ModuleGraphicsItem *pSelectedItem = GetSingleSelectedItem();
// if(pSelectedItem == NULL)
// {
// return;
// }
// SetFocusViewport();
// slotOnSetName(pSelectedItem);
}
// 在选定模块前或后加入一模块
void WorkflowSceneManager::addBeforeOrAfter(const QString& moduleName, bool isBefore)
{
// ModuleGraphicsItem *pSelectedItem = GetSingleSelectedItem();
// if(pSelectedItem == NULL)
// {
// return;
// }
// QUndoCommand *pAddModuleCommond = new AddModuleCmd(this, m_pWorkflow, moduleName, pSelectedItem, isBefore);
// // m_pUndoStack->push(pAddModuleCommond);
}
void WorkflowSceneManager::SetSubToolBarName(const QString &name)
{
m_strSubToolBarName = name;
}
// pai::ToolBarService* WorkflowSceneManager::GetStyleToolBarService() const
// {
// if(m_pWorkflow == NULL)
// {
// return NULL;
// }
// PageService* pPageService = NULL;
// if(::GetConsoleGUIService() && ::GetConsoleGUIService()->GetViewTabService())
// {
// pPageService = ::GetConsoleGUIService()->GetViewTabService()->GetPageService(QUuid(g_szWorkflowPluginID));
// }
// if(!pPageService)
// {
// return NULL;
// }
// return pPageService->GetToolBarService(m_strSubToolBarName.toStdString());
// }
void WorkflowSceneManager::slotModuleParameter()
{
// ModuleGraphicsItem *pSelectedItem = GetSingleSelectedItem();
// if(!pSelectedItem)
// {
// return;
// }
// ParameterCmd parameterCmd(pSelectedItem);
// parameterCmd.redo();
}
void WorkflowSceneManager::slotDeleteDisabledItems()
{
// QUndoCommand *pDeleteModuleCommond = new DeleteModuleCmd(this, m_pWorkflow, GetDisabledItems());
// m_pUndoStack->push(pDeleteModuleCommond);
}
void WorkflowSceneManager::mouseDoubleClickEvent(QGraphicsSceneMouseEvent * mouseEvent)
{
QGraphicsScene::mouseDoubleClickEvent(mouseEvent);
/*
QPointF point = mouseEvent->scenePos();
foreach (QGraphicsItem *pItem, items())
{
ModuleGraphicsItem* pModuleItem = dynamic_cast<ModuleGraphicsItem*>(pItem);
if(pModuleItem && pModuleItem->sceneBoundingRect().contains(point))
{
return;
}
}
QUndoCommand *pAddModuleCommand = new AddModuleCmd(this, m_pWorkflow, "", point);
m_pUndoStack->push(pAddModuleCommand);
PageService* pPageService = ::GetConsoleGUIService()->GetViewTabService()->GetPageService(g_szWorkflowPluginID);
if(NULL == pPageService)
{
return;
}
QAction* pSubmitAction = pPageService->GetAction(tr(g_szSubmit));
if(pSubmitAction != NULL)
{
pSubmitAction->setEnabled(false); //When a blank module is added, make submit button disabled
}
m_pWorkflow->SetCanSubmit(false); //设置是否可以sumbit
*/
}
bool WorkflowSceneManager::CheckConnection()
{
// //获取所有的module
// QList<QGraphicsItem*> allItems = items();
// //只获取module和它的step
// QList<ModuleGraphicsItem*> modules;
// QList<int> stepID;
// for (int j = 0; j < allItems.size(); j++)
// {
// if (allItems.at(j)->type() == ModuleGraphicsItem::Type) // module item
// {
// ModuleGraphicsItem *moduleItem = dynamic_cast<ModuleGraphicsItem *> (allItems.at(j));
// if (moduleItem && moduleItem->GetModule())
// {
// modules.push_back(moduleItem);
// stepID.push_back(moduleItem->GetModule()->GetStepID());
// }
// }
// }
// //遍历modules，查看是否存在没有连线的item。存在就返回false
// if(m_pWorkflow)
// {
// CWorkFlowFile* pWorkflowFile = m_pWorkflow->GetWorkflowFile();
// if(pWorkflowFile)
// {
// bool flag = false;
// bool destFlag = false;
// for(int i = 0; i < stepID.size(); ++i)
// {
// flag = false;
// destFlag = false;
// //获取输入端口数量
// int inPortCount = modules.at(i)->GetInputPortCount();
// if(inPortCount == 0)
// {
// //输入模块时连线检查
// for (unsigned int j = 0; j < pWorkflowFile->GetModuleConnections()->size(); j++)
// {
// if (pWorkflowFile->GetModuleConnections()->at(j)->GetSourceId() == stepID.at(i))
// {
// flag = true;
// break;
// }
// }
// if(!flag)
// {
// return false;
// }
// }
// else
// {
// int outPortCount = modules.at(i)->GetOutputPortCount();
// if(outPortCount == 0)
// {
// //输出模块时连线检查
// for (unsigned int j = 0; j < pWorkflowFile->GetModuleConnections()->size(); j++)
// {
// if(pWorkflowFile->GetModuleConnections()->at(j)->GetDestId() == stepID.at(i))
// {
// flag = true;
// break;
// }
// }
// if(!flag)
// {
// return false;
// }
// }
// else
// {
// //中间模块连线检查
// for (unsigned int j = 0; j < pWorkflowFile->GetModuleConnections()->size(); j++)
// {
// if(!destFlag && pWorkflowFile->GetModuleConnections()->at(j)->GetSourceId() == stepID.at(i))
// {
// destFlag = true;
// }
// if(!flag &&pWorkflowFile->GetModuleConnections()->at(j)->GetDestId() == stepID.at(i))
// {
// flag = true;
// }
// }
// if(!destFlag || !flag)
// {
// return false;
// }
// }
// }
// }
// }
// }
return true;
}
// void WorkflowSceneManager::slotSetSelectedModuleName()
// {
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Module Rename");
// //获取被编辑的Item
// ModuleGraphicsItem *pEditedItem = NULL;
// foreach(QGraphicsItem* pItem, selectedItems())
// {
// if (pItem->type() == pai::graphics2d::ModuleGraphicsItem::Type)
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (pModule && pModule->IsEditingModuleName())
// {
// pEditedItem = pModule;
// break;
// }
// }
// }
// try
// {
// if(pEditedItem && pEditedItem->IsEditingModuleName() && NULL != m_pWorkflow && !(pEditedItem->GetModuleNameEditorText().isEmpty()))
// {
// if(m_pMouduleNameList.keys().contains(pEditedItem->GetModuleNameEditorText()))
// {
// QUndoCommand *pRenameModuleCommond =
// new RenameModuleCmd(this, m_pWorkflow, items(), pEditedItem,
// m_pMouduleNameList.value(pEditedItem->GetModuleNameEditorText()));
// m_pUndoStack->push(pRenameModuleCommond);
// //更新B2区info信息
// UpdateHelpDoc();
// }
// }
// }
// catch(pai::error::generic_error & e)
// {
// pai::gui::PaiMessageBox::Critical(NULL, PAI_NAME,
// QString(g_szRenameModle).append(e.what()));
// pai::log::Info(_FLF(g_szRenameModle + e.what()));
// }
// if(pEditedItem)
// {
// pEditedItem->HideModuleNameEditor();
// }
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Module Rename");
// }
// bool WorkflowSceneManager::IsEditingModuleName()
// {
// foreach(QGraphicsItem* pItem, selectedItems())
// {
// if (pItem->type() == pai::graphics2d::ModuleGraphicsItem::Type)
// {
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(pItem);
// if (pModule && pModule->IsEditingModuleName())
// {
// return true;
// }
// }
// }
// return false;
// }
// void WorkflowSceneManager::HideAllModuleNameEdit()
// {
// //隐藏场景中模块名称编辑Edit
// foreach (QGraphicsItem *item, items())
// {
// ModuleGraphicsItem * tmpItem = dynamic_cast<ModuleGraphicsItem*>(item);
// if(tmpItem)
// {
// tmpItem->HideModuleNameEditor();
// }
// }
// }
void WorkflowSceneManager::InitModuleNameList()
{
//获取下拉框中的内容
CModuleManager* modManager = ::GetModuleManager();
std::vector< CModule* > vecModules;
modManager->ListAllModules(vecModules);
std::vector< CModule * >::const_iterator it = vecModules.begin();
while(it != vecModules.end())
{
QString name = QString::fromStdString((*it)->GetMetaData()->GetName());
QString className = QString::fromStdString((*it)->GetClassName());
m_pMouduleNameList.insert(name, className);
++it;
}
}
void WorkflowSceneManager::slotOnObjectAddChildren(pai::objectmodel::PaiObject* /*pWorkflow */, QList<
pai::objectmodel::PaiObject* >& children)
{
if(m_ScenceReadOnly == true || m_pWorkflow == NULL)
{
return;
}
foreach(pai::objectmodel::PaiObject *pChild, children)
{
HandleOnObjectAddOrRemove(pChild, true);
}
}
int WorkflowSceneManager::GetZoomCount()
{
return m_zoomCount;
}
void WorkflowSceneManager::SetZoomCount(int zoomCount)
{
m_zoomCount = zoomCount;
}
void WorkflowSceneManager::OpenModuleParam(pai::workflow::CModuleInformation *pModuleInfo)
{
// CVecWindowDocument* pDoc=GetWorkflowConsole()->g_mModuleParamers->GetWindowDocument();
// CWellLogWorkflowDataModel * pwellWorkflowDataModel =dynamic_cast<CWellLogWorkflowDataModel*>(m_pWorkflow);
// CQtWellSceneManager*m_pWellSceneManager = dynamic_cast<CQtWellSceneManager*>(pDoc->GetVecWindow()->GetSceneManager());
// if(!m_pWellSceneManager) return;
// if(!pModuleInfo)
// {
// if(GetWorkflowConsole()->g_mModuleParamers) GetWorkflowConsole()->g_mModuleParamers->InitCardParamSettings(pModuleInfo);//初始化参数设置页
// return;
// }
// PELibraryModule * amodule=dynamic_cast<PELibraryModule *>(pModuleInfo->GetModule());
// if(amodule) {
// CBaseObject* subtree=CPaiObjectHelper::GetSubtree(::GetProject(),pwellWorkflowDataModel->GetCurrentWellRoundPath());
// if(!subtree) {
// CBaseObject*subtree1=dynamic_cast<CBaseObject*>(::GetProject()->GetCurrentObject());
// CObjWelllogRound* pObjWelllogRound=dynamic_cast<CObjWelllogRound*>(subtree1);
// if(subtree1&&!pObjWelllogRound)
// {
// while(subtree1)
// {
// subtree1=dynamic_cast<CBaseObject*>(subtree1->GetPaiObject()->GetParent());
// pObjWelllogRound=dynamic_cast<CObjWelllogRound*>(subtree1);
// if(pObjWelllogRound) break;
// }
// }
// if(pObjWelllogRound) {
// CModuleConsole * pWorkflowConsole=::GetWorkflowConsole();
// pWorkflowConsole->wellRoundpath=pObjWelllogRound->GetWellRoundPath();
// pwellWorkflowDataModel->SetCurrentWellRoundPath(pWorkflowConsole->wellRoundpath);
// subtree=subtree1;
// }
// }
// QString slf="";
// if(subtree)
// {
// if(subtree->GetPaiObject()->GetTypeID()==GetClassID_WellLogRound()&&GetWorkflowConsole()->g_mModuleParamers){
// CObjWelllogRound* currentwr=(CObjWelllogRound*)(subtree->GetPaiObject());
// slf=currentwr->GetSlfFileName();
// amodule->SetSlfFileName(slf);
// GetWorkflowConsole()->g_mModuleParamers->InitCardParamSettings(pModuleInfo);//初始化参数设置页
// }
// }
// QString temname=pDoc->GetTemplateFileName();
// if(!temname.isEmpty()&&pDoc->GetVecWindow()->GetWindowType()!=GetWindowTypeID_QtMultiWellSection()) {
// QString fun=QString::fromStdString(pModuleInfo->GetModule()->GetMetaData()->GetID());
// int i=fun.indexOf("_");
// if(i>-1) fun=fun.mid(i+1);
// QString cid=fun;
// int i0=cid.lastIndexOf("_");
// if(i0>-1) cid=cid.mid(i0+1);
// if(temname.indexOf(cid,0,Qt::CaseInsensitive)==-1)
// {
// if(QMessageBox::warning(NULL,QString::fromUtf8("提示"),QString::fromUtf8("是否替换为处理模块配套的显示图？"),QMessageBox::Yes,QMessageBox::No)==QMessageBox::Yes)
// {
// QString wellname;
// QString path;
// if(!slf.isEmpty())
// {
// GetWellNameAndPath(slf,wellname,path);
// }
// QString strValue;
// if(!amodule->strDLLFun.isEmpty()) {
// if(!amodule->strPlot.isEmpty()) strValue=amodule->strPlot;
// else if(amodule->Hd) {
// strValue=amodule->Hd->Plot;
// if(strValue.isEmpty()) strValue=amodule->strDLLFun+".tpl";
// }
// else strValue=amodule->strDLLFun+".tpl";
// }
// QString defaultTempleteFile;
// QString strTempPath=::GetTemplatePath();
// QString sourceDir=strTempPath+"well"+QDir::separator();
// QString Templetename;
// if(!strValue.isEmpty()) Templetename=strValue;
// else Templetename=cid+".tpl";
// defaultTempleteFile=sourceDir+Templetename;
// QString TempleteFile=path+QDir::separator()+wellname+Templetename;
// if(!TempleteFile.endsWith(".tpl")) TempleteFile+=".tpl";
// QDir ss;
// if(!ss.exists(TempleteFile))
// {
// QFile::copy(defaultTempleteFile,TempleteFile);
// }
// defaultTempleteFile=TempleteFile;
// QString windowname;
// windowname=pDoc->GetName();
// QFileInfo afile(defaultTempleteFile);
// windowname=windowname+"_"+afile.completeBaseName()+"_";
// //qDebug()<<QString::fromStdString(GenTimeStamp())<<"模板开始刷新："+defaultTempleteFile;
// pDoc->ApplyTemplate(defaultTempleteFile);
// pDoc->GetVecWindow()->GetSceneManager()->UpdateAll();
// }
// }
// }
// }
emit signalOpenModuleParam(pModuleInfo);
}
QList<pai::graphics2d::ModuleGraphicsItem*> WorkflowSceneManager::GetOutputModules(pai::graphics2d::ModuleGraphicsItem *pModuleItem)
{
//获取pEndItem模块输出端口对应的所有连线
QList<ModuleConnectGraphicsItem*> lstConnections;
// foreach (QGraphicsItem* pItem, items())
// {
// if (pItem && pItem->type() == ModuleConnectGraphicsItem::Type)
// {
// ModuleConnectGraphicsItem* pConnectionItem = dynamic_cast<ModuleConnectGraphicsItem*>(pItem);
// if (pConnectionItem && pConnectionItem->GetStartItem() == pModuleItem)
// {
// lstConnections.append(pConnectionItem);
// }
// }
// }
// //获取连线对应的结束模块
QList<ModuleGraphicsItem*> lstModule;
// foreach (ModuleConnectGraphicsItem* pConItem, lstConnections)
// {
// lstModule.append(pConItem->GetEndItem());
// }
return lstModule;
}
bool WorkflowSceneManager::CheckConnection(pai::graphics2d::ModuleGraphicsItem *pBeginModule, pai::graphics2d::ModuleGraphicsItem *pEndModule)
{
bool result = false;
// foreach(QGraphicsItem *pItem,items())
// {
// if(pItem &&pItem->type() == ModuleConnectGraphicsItem::Type)
// {
// ModuleConnectGraphicsItem *pConnection = dynamic_cast<ModuleConnectGraphicsItem*>(pItem);
// if(pConnection && pConnection->GetEndItem() == pEndModule && pConnection->GetStartItem() == pBeginModule)
// {
// result = true;
// }
// }
// }
return result;
}
void WorkflowSceneManager::WaitThreadForDone()
{
// if(m_pThreadPool != NULL)
// {
// m_pThreadPool->waitForDone();
// }
}
void WorkflowSceneManager::UpdateHelpDoc()
{
//如果做完鼠标或者键盘操作，场景中的选中模块数量不等于1，更新B2区info信息
if(1 != selectedItems().count())
{
emit signalSelectModule((workflow::CModuleInformation*)NULL);
emit moduleSelectedSignal(false);
}
else
{
// //选中模块数量等于1,显示选中模块的帮助信息
// ModuleGraphicsItem *pModule = dynamic_cast<ModuleGraphicsItem*>(selectedItems().at(0));
// if(pModule && pModule->GetModule())
// {
// emit signalSelectModule(pModule->GetModule());
// emit moduleSelectedSignal(true);
// }
}
}
Reference in New Issue View Git Blame Copy Permalink