2632 lines
99 KiB
C++
2632 lines
99 KiB
C++
/**
|
||
* @file WorkflowPluginControl.cpp
|
||
* @note 该文件是从WorkflowPlugin中提取出来的，如果查看之前的历史请查看WorkflowPlugin.cpp
|
||
* @date 3014-08-05
|
||
*/
|
||
#include <QApplication>
|
||
#include <QUndoGroup>
|
||
#include <QFileInfo>
|
||
#include <QDir>
|
||
#include <QMenu>
|
||
#include <QSettings>
|
||
#include <QDebug>
|
||
#include <limits>
|
||
#include "WorkFlowFile.h"
|
||
// #include "WellViewInfo.h"
|
||
// #include "DataImport.h"
|
||
// #include "PaiInputDialog.h"
|
||
// #include "PaiJobMaster.h"
|
||
#include "PaiSettings.h"
|
||
#include "WorkflowPluginControl.h"
|
||
// #include "ModuleGraphicsItem.h"
|
||
// #include "ConsoleGUIService.h"
|
||
// #include "ViewExtension.h"
|
||
#include "WorkflowWidget.h"
|
||
#include "PaiModuleTree.h"
|
||
#include "PaiTextEdit.h"
|
||
#include "PaiWorkflowDataModel.h"
|
||
#include "WorkflowSceneManager.h"
|
||
#include "PaiModuleToolBarView.h"
|
||
#include "ParameterEditor.h"
|
||
#include "WorkflowConst.h"
|
||
#include "GlobalUtility.h"
|
||
#include "ParameterEditorModel.h"
|
||
// #include "PluginManager.h"
|
||
// #include "PaiWorkflowMaster.h"
|
||
// #include "PaiObjectSelection.h"
|
||
#include "PAIConst.h"
|
||
#include "ModuleInformation.h"
|
||
// #include "PaiBalloonTip.h"
|
||
// #include "TimeStampLogger.h"
|
||
#include "Utils.h"
|
||
// #include "PaiBalloonTipSettings.h"
|
||
#include "DeleteTemplateCmd.h"
|
||
#include "DeleteWorkflowCmd.h"
|
||
#include "SaveHelper.h"
|
||
#include "SaveAsWorkflowCmd.h"
|
||
#include "SaveAsTemplateCmd.h"
|
||
// #include "SaveWorkflowCmd.h"
|
||
#include "SaveTemplateCmd.h"
|
||
#include "SaveWorkflowAsImageCmd.h"
|
||
#include "SaveAllWorkflowsCmd.h"
|
||
// #include "SubmitWorkflowCmd.h"
|
||
// #include "PaiAction.h"
|
||
#include "basefun.h"
|
||
#include "PaiWorkflowTemplateTree.h"
|
||
// #include "PaiFileDialog.h"
|
||
// #include "PaiSelectSurveyDialog.h"
|
||
#include "WorkflowPackage.h"
|
||
// #include "PaiCheckJobOutputThread.h"
|
||
// #include "WorkflowPlugin.h"
|
||
// #include "PaiPermissionChecker.h"
|
||
#include "PaiMenuToolBar.h"
|
||
#include "LogModuleConsole.h"
|
||
#include "WellLogWorkflowDataModel.h"
|
||
#include "WellLogWorkflowRunner.h"
|
||
#include "ObjectID.h"
|
||
// #include "ObjProject.h"
|
||
// #include "ObjectEvent.h"
|
||
#include "ObjWelllog.h"
|
||
// #include "VecDisplayObjectCommand.h"
|
||
// #include "VecWindow.h"
|
||
#include "RunTimeContext.h"
|
||
// #include "ObjWellRulerTrack.h"
|
||
// #include "VecSceneManager.h"
|
||
#include "BaseObject.h"
|
||
// #include "QtViewer.h"
|
||
// #include "VecWindowCommand.h"
|
||
#include "GeometryUtils.h"
|
||
// #include "ConsoleOutputWidget.h"
|
||
#include "ObjWell.h"
|
||
#include "PELibraryModule.h"
|
||
#include "PaiMessageBox.h"
|
||
// void OSGFRAMEWORK_EXPORT AppendConsole(pai::log::Priority priority,const QString &output);
|
||
using namespace pai;
|
||
using namespace pai::gui;
|
||
using namespace pai::graphics2d;
|
||
using namespace pai::objectmodel;
|
||
|
||
const QString LAST_EXPORT_WORKFLOW_PATH = "Export workflows path";
|
||
const QString LAST_IMPORT_WORKFLOW_PATH = "Import workflows path";
|
||
////////////////////////////////////// WorkflowPluginControl /////////////////////////////////////////
|
||
WorkflowPluginControl::WorkflowPluginControl(const QUuid& viewID, QObject* pParent) :
|
||
QObject(pParent),
|
||
ControlExtension(),
|
||
m_ViewID(viewID),
|
||
m_pTemplateTree(NULL),
|
||
m_pCheckJobOutputThread(NULL),
|
||
m_pWellLogWorkflowRunner(new CWellLogWorkflowRunner())
|
||
{
|
||
m_pUndoGroup = new QUndoGroup(this);
|
||
m_pUndoAction = m_pUndoGroup->createUndoAction(this, g_szUndo);
|
||
m_pUndoAction->setIcon(QIcon(g_szWUndo2Png));
|
||
m_pUndoAction->setShortcut(Qt::CTRL + Qt::Key_Z);
|
||
|
||
m_pRedoAction = m_pUndoGroup->createRedoAction(this, g_szRedo);
|
||
m_pRedoAction->setIcon(QIcon(g_szUndoPng));
|
||
m_pRedoAction->setShortcut(Qt::CTRL + Qt::Key_Y);
|
||
}
|
||
|
||
WorkflowPluginControl::~WorkflowPluginControl()
|
||
{
|
||
if(m_pUndoAction != NULL)
|
||
{
|
||
delete m_pUndoAction;
|
||
m_pUndoAction = NULL;
|
||
}
|
||
if(m_pRedoAction != NULL)
|
||
{
|
||
delete m_pRedoAction;
|
||
m_pRedoAction = NULL;
|
||
}
|
||
if(m_pUndoGroup != NULL)
|
||
{
|
||
delete m_pUndoGroup;
|
||
m_pUndoGroup = NULL;
|
||
}
|
||
|
||
// if(m_pCheckJobOutputThread && m_pCheckJobOutputThread->isRunning())
|
||
// {
|
||
// m_pCheckJobOutputThread->wait();
|
||
// delete m_pCheckJobOutputThread;
|
||
// m_pCheckJobOutputThread = NULL;
|
||
// }
|
||
delete m_pWellLogWorkflowRunner;
|
||
m_pWellLogWorkflowRunner = NULL;
|
||
|
||
}
|
||
|
||
QAction* WorkflowPluginControl::GetUndoAction()
|
||
{
|
||
return m_pUndoAction;
|
||
}
|
||
|
||
QAction* WorkflowPluginControl::GetRedoAction()
|
||
{
|
||
return m_pRedoAction;
|
||
}
|
||
|
||
QUndoGroup* WorkflowPluginControl::GetUndoGroup()
|
||
{
|
||
return m_pUndoGroup;
|
||
}
|
||
|
||
std::string WorkflowPluginControl::GetStringID() const
|
||
{
|
||
return g_szPluginControl;
|
||
}
|
||
|
||
QUuid WorkflowPluginControl::GetViewID() const
|
||
{
|
||
return m_ViewID;
|
||
}
|
||
|
||
bool WorkflowPluginControl::BuildTreeMenuActionsForObject(QList< PaiObject* > & contextObjs,
|
||
QList< PaiAction* > & lstMenuActions)
|
||
{
|
||
// if(contextObjs.count() == 1)
|
||
// {
|
||
// PaiObject *pContextObj = contextObjs.first();
|
||
// ////获取workflowMaster的DBID和类型
|
||
// long long workflowMasterID = pContextObj->GetDBID();
|
||
// QUuid typeID = pContextObj->GetTypeID();
|
||
|
||
// if(typeID == QUuid(PaiWorkflowMaster::GetTypeIDString()))
|
||
// {
|
||
// PaiAction* pNewWorkflowAction = new PaiAction(QIcon(":/f_new_workflow.png"), tr(g_szNewWorkflowDot), this);
|
||
// pNewWorkflowAction->SetActionFlags(pNewWorkflowAction->GetFlags() | PaiAction::TreeFloatingAct);
|
||
// pNewWorkflowAction->SetPermission(pai::gui::PaiAction::CREATE);
|
||
// pNewWorkflowAction->setData(QVariant(workflowMasterID));
|
||
// connect(pNewWorkflowAction, SIGNAL(triggered()), this, SLOT(slotNewWorkflow()));
|
||
// lstMenuActions.push_back(pNewWorkflowAction);
|
||
|
||
// PaiAction* pImportWorkflowAction = new PaiAction(QIcon(":/f_import_workflow.png"), tr(g_szImportWorkDot), this);
|
||
// pImportWorkflowAction->SetActionFlags(pImportWorkflowAction->GetFlags() | PaiAction::TreeFloatingAct);
|
||
// pImportWorkflowAction->SetObject(pContextObj);
|
||
// pImportWorkflowAction->SetPermission(pai::gui::PaiAction::CREATE);
|
||
// connect(pImportWorkflowAction, SIGNAL(triggered()), this, SLOT(slotImportWorkflows()));
|
||
// lstMenuActions.push_back(pImportWorkflowAction);
|
||
|
||
// QList< PaiObject* > childWorkflows;
|
||
// pContextObj->GetObjectByType(childWorkflows, QUuid(PaiWorkflowDataModel::GetTypeIDString()));
|
||
// if(!childWorkflows.empty())
|
||
// {
|
||
// PaiAction* pExportWorkflowAction = new PaiAction(QIcon(":/f_export_workflow.png"),
|
||
// tr(g_szExportAllWorkDot), this);
|
||
// pExportWorkflowAction->SetActionFlags(pExportWorkflowAction->GetFlags() | PaiAction::TreeFloatingAct);
|
||
|
||
// pExportWorkflowAction->SetObjects(childWorkflows);
|
||
// pExportWorkflowAction->SetPermission(pai::gui::PaiAction::CREATE);
|
||
// connect(pExportWorkflowAction, SIGNAL(triggered()), this, SLOT(slotExportWorkflows()));
|
||
// lstMenuActions.push_back(pExportWorkflowAction);
|
||
// }
|
||
|
||
// return true;
|
||
// }
|
||
// }
|
||
|
||
// // 检查是否所选中类型全为PaiWorkflowDataModel
|
||
// bool areWorkflowModel = true;
|
||
// QList<QVariant> wfIDs;
|
||
// foreach(PaiObject *pObj, contextObjs)
|
||
// {
|
||
// wfIDs << QVariant(pObj->GetDBID());
|
||
// if (pObj->GetTypeID() != QUuid(PaiWorkflowDataModel::GetTypeIDString()))
|
||
// {
|
||
// wfIDs.clear();
|
||
// areWorkflowModel = false;
|
||
// break;
|
||
// }
|
||
// }
|
||
|
||
// if(areWorkflowModel)
|
||
// {
|
||
// PaiAction* pEditWorkflowAction = new PaiAction(QIcon(":/f_edit_workflow.png"), tr(g_szWorkflowOpen), this);
|
||
// pEditWorkflowAction->SetActionFlags(pEditWorkflowAction->GetFlags() | PaiAction::TreeFloatingAct);
|
||
// pEditWorkflowAction->setData(QVariant(wfIDs));
|
||
// connect(pEditWorkflowAction, SIGNAL(triggered()), this, SLOT(slotEditItem()));
|
||
// lstMenuActions.push_back(pEditWorkflowAction);
|
||
|
||
// if(contextObjs.count() == 1)
|
||
// {
|
||
// PaiAction* pSubmitWorkflowAction = new PaiAction(QIcon(":/f_submit_job.png"), tr(g_szSubmitODot), this);
|
||
// pSubmitWorkflowAction->SetActionFlags(pSubmitWorkflowAction->GetFlags() | PaiAction::TreeFloatingAct);
|
||
// bool bPermitSubmit = true;
|
||
// bool permission = true;
|
||
// foreach(PaiObject *pObj, contextObjs)
|
||
// {
|
||
// PaiWorkflowDataModel* pWorkflow = dynamic_cast<PaiWorkflowDataModel*> (pObj);
|
||
// if(pWorkflow == NULL)
|
||
// {
|
||
// return false; //得到PaiWorkflowDataModel为空时退出
|
||
// }
|
||
// //如果当前工作流打开了，则需要判断打开的工作流中submit权限
|
||
// if(GetObjectModelService()->GetObjectLockManager()->IsObjectLocked(pWorkflow->GetDBID(),false))
|
||
// {
|
||
// QList< PaiWorkflowDataModel* > workflows = GetOpenedWorkflows();
|
||
// for(int i = 0; i < workflows.size(); i++)
|
||
// {
|
||
// if(workflows.at(i) && pWorkflow->GetDBID() == workflows.at(i)->GetDBID())
|
||
// {
|
||
// pWorkflow = workflows.at(i); //打开的工作流替换为编辑界面流
|
||
// break;
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// pWorkflow->ReloadDataModuel();
|
||
// }
|
||
// bPermitSubmit = pWorkflow->IsSubmitting() ? false : pWorkflow->CanSubmit(true);
|
||
// try
|
||
// {
|
||
// permission = PaiPermissionChecker::HasPermission(pObj,PaiAction::PaiPermissionTypes(PaiAction::UPDATE));
|
||
// }
|
||
// catch(pai::error::generic_error & e)
|
||
// {
|
||
// permission = false;
|
||
// }
|
||
// catch(...)
|
||
// {
|
||
// permission = false;
|
||
// }
|
||
// if(!bPermitSubmit || !permission)
|
||
// {
|
||
// break;
|
||
// }
|
||
// }
|
||
// pSubmitWorkflowAction->setEnabled(bPermitSubmit && permission);
|
||
// if(bPermitSubmit)
|
||
// {
|
||
// pSubmitWorkflowAction->SetObjects(contextObjs);
|
||
// connect(pSubmitWorkflowAction, SIGNAL(triggered()), this, SLOT(slotPreSubmitWorkflow()));
|
||
// }
|
||
// lstMenuActions.push_back(pSubmitWorkflowAction);
|
||
// }
|
||
|
||
// PaiAction* pExportWorkflowAction = new PaiAction(QIcon(":/f_export_workflow.png"), tr(g_szExportWorkflowDot),
|
||
// this);
|
||
// pExportWorkflowAction->SetActionFlags(pExportWorkflowAction->GetFlags() | PaiAction::TreeFloatingAct);
|
||
|
||
// pExportWorkflowAction->SetObjects(contextObjs);
|
||
// pExportWorkflowAction->SetPermission(pai::gui::PaiAction::CREATE);
|
||
// connect(pExportWorkflowAction, SIGNAL(triggered()), this, SLOT(slotExportWorkflows()));
|
||
// lstMenuActions.push_back(pExportWorkflowAction);
|
||
|
||
// return true;
|
||
// }
|
||
|
||
return false;
|
||
}
|
||
|
||
CPaiWorkflowTemplateTree* WorkflowPluginControl::GetTemplateTree()
|
||
{
|
||
return m_pTemplateTree;
|
||
}
|
||
|
||
void WorkflowPluginControl::slotSaveWorkflowAsImageFile()
|
||
{
|
||
//SaveWorkflowAsImageCmd saveWorkflowAsImageCmd(m_ViewID);
|
||
// saveWorkflowAsImageCmd.redo();
|
||
}
|
||
|
||
void WorkflowPluginControl::slotSaveAllWorkflows()
|
||
{
|
||
//SaveAllWorkflowsCmd saveAllWorkflowsCmd(m_ViewID, m_pTemplateTree);
|
||
//saveAllWorkflowsCmd.redo();
|
||
}
|
||
|
||
void WorkflowPluginControl::slotSaveAsWorkflow()
|
||
{
|
||
//SaveAsWorkflowCmd saveAsWorkflowCmd(m_ViewID, GetActiveWorkflow());
|
||
//saveAsWorkflowCmd.redo();
|
||
|
||
// if(!saveAsWorkflowCmd.GetSaveAsResult() && (SaveHelper::GetSaveExceptionWhich() == pai::error::ERR_DATA_CHANGED))
|
||
// {
|
||
// SaveHelper::SetSaveException("");
|
||
// QWidget* pMainWindow = NULL;
|
||
// QString title = "π-Frame Workflow";
|
||
// QString body = QObject::tr("The workflow has been modified. Do you want to reload it?");
|
||
// if(PaiMessageBox::Warning(pMainWindow, title, body, PaiMessageBox::Yes | PaiMessageBox::No, PaiMessageBox::Yes)
|
||
// == PaiMessageBox::Yes)
|
||
// {
|
||
// //需要更新工作流模型
|
||
// SaveHelper::GetActiveWorkflowView()->SetWorkflow(GetActiveWorkflow(), true);
|
||
// }
|
||
// }
|
||
// pai::graphics2d::CParameterEditor* pEditor = dynamic_cast< pai::graphics2d::CParameterEditor* > (GetParameterEditor());
|
||
// if(pEditor != NULL)
|
||
// {
|
||
// ParameterEditorModel *pEditorModel = dynamic_cast< ParameterEditorModel* > (pEditor->model());
|
||
// if(pEditorModel && GetActiveWorkflow())
|
||
// {
|
||
// pEditorModel->SetCurrentWorkflowID(QUuid(GetActiveWorkflow()->GetID()));
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotSaveAsTemplate()
|
||
{
|
||
// //PageService *pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetViewID());
|
||
// // if(pPageService)
|
||
// // {
|
||
// // pPageService->ActiveView(g_szTemplates);
|
||
// // }
|
||
|
||
// if(m_pTemplateTree &&GetActiveWorkflow())
|
||
// {
|
||
// SaveAsTemplateCmd saveAsTemplateCmd(m_pTemplateTree, GetActiveWorkflow());
|
||
// saveAsTemplateCmd.redo();
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotSaveWorkflow()
|
||
{
|
||
/*
|
||
if(GetActiveWorkflow())
|
||
{
|
||
if(GetActiveWorkflow()->IsTemplate())
|
||
{
|
||
SaveTemplateCmd saveTemplateCmd(m_pTemplateTree, GetActiveWorkflow());
|
||
saveTemplateCmd.redo();
|
||
}
|
||
else
|
||
{
|
||
SaveWorkflowCmd saveWorkflowCmd(m_ViewID, GetActiveWorkflow());
|
||
saveWorkflowCmd.redo();
|
||
if(!saveWorkflowCmd.GetSaveResult() && (SaveHelper::GetSaveExceptionWhich() == pai::error::ERR_DATA_CHANGED))
|
||
{
|
||
SaveHelper::SetSaveException("");
|
||
QWidget* pMainWindow = NULL;
|
||
QString title = "π-Frame Workflow";
|
||
QString body = QObject::tr("The workflow has been modified. Do you want to reload it?");
|
||
if(PaiMessageBox::Yes == PaiMessageBox::Warning(pMainWindow, title, body, PaiMessageBox::Yes
|
||
| PaiMessageBox::No, PaiMessageBox::Yes))
|
||
{
|
||
//需要更新工作流模型
|
||
SaveHelper::GetActiveWorkflowView()->SetWorkflow(GetActiveWorkflow(), true);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
|
||
bool WorkflowPluginControl::OpenNameJobDialog(QString& strJobName, QString strLabelText)
|
||
{
|
||
return false;
|
||
// PaiInputDialog dlg(NULL);
|
||
// dlg.SetOkButtonText("&Submit");
|
||
// dlg.SetText(strJobName);
|
||
// dlg.SetLabelText(strLabelText);
|
||
// dlg.setWindowTitle(PAI_NAME);
|
||
// dlg.UseValidateNameEdit(g_iMaxJobNameLength);
|
||
|
||
// if(dlg.exec() == QDialog::Accepted)
|
||
// {
|
||
// strJobName = dlg.TextValue();
|
||
// return true;
|
||
// }
|
||
// else
|
||
// {
|
||
// return false;
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotPreSubmitWorkflow()
|
||
{
|
||
//测井项目不需要，删除
|
||
}
|
||
|
||
void WorkflowPluginControl::slotSubmitWorkflow(pai::objectmodel::PaiWorkflowDataModel* pWorkflow,
|
||
const QString & jobName)
|
||
{
|
||
//测井项目不需要，删除
|
||
}
|
||
|
||
void WorkflowPluginControl::slotOnJobSubmitFinished(PaiWorkflowDataModel* pWorkflowObject, const QString& strNewJobName)
|
||
{
|
||
//测井项目不需要，删除
|
||
|
||
}
|
||
|
||
void WorkflowPluginControl::slotOnJobDataGenerated(pai::objectmodel::PaiObject* pJob,
|
||
const QString& strPropertyName,
|
||
const QVariant& varJobOutputDataID)
|
||
{
|
||
//测井项目不需要，删除
|
||
}
|
||
|
||
void WorkflowPluginControl::SubmitWorkflow()
|
||
{
|
||
|
||
//测井项目不需要，删除
|
||
|
||
}
|
||
|
||
void WorkflowPluginControl::NewWorkflow(pai::objectmodel::PaiObject *pSur)
|
||
{
|
||
//测井项目额外实现，不需要，删除
|
||
}
|
||
|
||
void WorkflowPluginControl::slotNewWorkflow()
|
||
{
|
||
//测井项目额外实现，不需要，删除
|
||
}
|
||
|
||
void WorkflowPluginControl::NewWorkflowByBrowse()
|
||
{
|
||
// pai::gui::PaiSelectSurveyDialog selDlg(NULL);
|
||
// if(QDialog::Accepted == selDlg.exec())
|
||
// {
|
||
// PaiObject *pObj = selDlg.GetSelectedSurvey();
|
||
// if(pObj)
|
||
// {
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "New workflow");
|
||
|
||
// PaiObject* pSelectObject = GetObjectModelService()->GetObject(pObj->GetID());
|
||
// NewWorkflow(pSelectObject);
|
||
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "New workflow");
|
||
// }
|
||
// else
|
||
// {
|
||
// PaiMessageBox::Information(NULL, tr("Notice"),
|
||
// "No survey has been seleted!", PaiMessageBox::Ok);
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::ParseError(QList< QPair< int, QString > > &importErrorLst, ImportType type)
|
||
{
|
||
// QString strErr;
|
||
// int errorCount = importErrorLst.count();
|
||
// for(int i = 0; i < errorCount; ++i)
|
||
// {
|
||
// QPair< int, QString > pair = importErrorLst.at(i);
|
||
// switch(pair.first)
|
||
// {
|
||
// case ImportErrorType_STYLE:
|
||
// strErr.append(tr(g_szWorkflowStyle).arg(pair.second));
|
||
// break;
|
||
// case ImportErrorType_DELETE:
|
||
// strErr.append(tr(g_szDeletFaile).arg(pair.second));
|
||
// break;
|
||
// case ImportErrorType_REMOVE:
|
||
// strErr.append(tr(g_szRemoveFailed).arg(pair.second));
|
||
// break;
|
||
// case ImportErrorType_PARSE:
|
||
// strErr.append(pair.second);
|
||
// break;
|
||
// case ImportErrorType_IMPORT:
|
||
// strErr.append(pair.second);
|
||
// break;
|
||
// default:
|
||
// strErr.append(tr(g_szImportFailed).arg(pair.second));
|
||
// break;
|
||
// }
|
||
// }
|
||
// const char *ErrorMsg = (type == WORKFLOW_TYPE) ? g_szImportFailed : g_szTemplateImportFailed;
|
||
// const char *importType = (type == WORKFLOW_TYPE) ? g_szWorkflowImpor : g_szTemplateImpor;
|
||
|
||
// QString strErrorMsg(ErrorMsg);
|
||
// if(!strErrorMsg.isEmpty() && ::GetConsoleGUIService())
|
||
// {
|
||
// PaiMessageBox box(PaiMessageBox::Icon_Critical, tr(importType), tr(ErrorMsg).arg(errorCount), strErr,
|
||
// PaiMessageBox::Ok, NULL);
|
||
// box.exec();
|
||
// }
|
||
|
||
// pai::log::Info(_FLF(QObject::tr(ErrorMsg).arg(errorCount).toStdString() + strErr.toStdString()));
|
||
|
||
}
|
||
|
||
bool WorkflowPluginControl::HasUnsupportedModule(PaiWorkflowDataModel* pWorkflow, QString &versionMsg)
|
||
{
|
||
if(!pWorkflow)
|
||
{
|
||
return false;
|
||
}
|
||
//处理新版本中已经不存在的模块
|
||
QStringList modulesNames = pWorkflow->GetMissingModuleNames();
|
||
if (!modulesNames.isEmpty())
|
||
{
|
||
//把要显示的模块名称组织成html格式的列表
|
||
QString missingModuleName =QString("<ul>");
|
||
foreach(QString str,modulesNames)
|
||
{
|
||
missingModuleName += (QString("<li>")+str+QString("</li>\n"));
|
||
}
|
||
//移除最后一个换行符
|
||
if(missingModuleName.endsWith("\n"))
|
||
{
|
||
missingModuleName.remove(missingModuleName.size()-1,1);
|
||
}
|
||
missingModuleName += QString("</ul>");
|
||
|
||
versionMsg = QString("The workflow contains one or more modules that do not exist in current system."
|
||
"Do you still want to import it? "
|
||
"Module names:%1").arg(missingModuleName);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
void WorkflowPluginControl::UpdateOpenedWorkflow(PaiWorkflowDataModel* pWorkflow, long long workflowdbid)
|
||
{
|
||
// if((SaveHelper::GetActiveWorkflowView()->GetWorkflow()) &&
|
||
// SaveHelper::GetActiveWorkflowView()->GetWorkflow()->GetDBID() == workflowdbid)
|
||
// {
|
||
// SaveHelper::GetActiveWorkflowView()->SetWorkflow(pWorkflow, false);
|
||
// }
|
||
// else
|
||
// {
|
||
// PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(m_ViewID);
|
||
// if(pPageService != NULL)
|
||
// {
|
||
// QWidget* pWorkflowTabs = pPageService->GetWidgetView("A");
|
||
// if(pWorkflowTabs != NULL)
|
||
// {
|
||
// QList< WorkflowWidget* > lstWorkflowWidgets = pWorkflowTabs->findChildren< WorkflowWidget* > ();
|
||
// foreach(WorkflowWidget* pWorkflowWidget, lstWorkflowWidgets)
|
||
// {
|
||
// if((pWorkflowWidget->GetWorkflow()) &&
|
||
// pWorkflowWidget->GetWorkflow()->GetDBID() == workflowdbid)
|
||
// {
|
||
// pWorkflowWidget->SetWorkflow(pWorkflow, false);
|
||
// break;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
bool WorkflowPluginControl::ImportWorkflow(const QString& JsonFilePath,
|
||
pai::objectmodel::PaiObject *pWorkflowMaster,
|
||
QList < QPair< int, QString > > &importErrorList,
|
||
pai::gui::PaiMessageBox::StandardButton &resultButton,
|
||
QStringList &strNames,
|
||
ImportType type,
|
||
QString outPutFile)
|
||
{
|
||
// QString strErrMsg;
|
||
// QString baseWorkflowName;
|
||
// bool workflowOpend = false;
|
||
|
||
// PaiObject* pOldWorkflow = NULL;
|
||
// QUuid workflowDataModelID;
|
||
// long long workflowdbid = 0;
|
||
// //获取去掉后缀的工作流名称
|
||
// QString suffix(g_szJson);
|
||
// QString strBaseName = GetWorkflowBaseName(JsonFilePath,suffix);
|
||
|
||
// if(strBaseName.endsWith(g_szStyle))
|
||
// {
|
||
// importErrorList << QPair<int, QString>(ImportErrorType_STYLE, JsonFilePath);
|
||
// return false;
|
||
// }
|
||
// //新建工作流
|
||
// PaiWorkflowDataModel* pNewWorkflow = new PaiWorkflowDataModel();
|
||
// std::string error;
|
||
// if(pNewWorkflow->Parse(JsonFilePath.toStdString(),"", error, outPutFile.toStdString()))
|
||
// {
|
||
// //检查工作流中是否存在当前版本已经不存在的模块
|
||
// QString versionMsg;
|
||
// if(HasUnsupportedModule(pNewWorkflow,versionMsg))
|
||
// {
|
||
// PaiMessageBox::StandardButton resultBtn = PaiMessageBox::Warning(NULL,
|
||
// tr("Warning"), versionMsg, PaiMessageBox::Yes | PaiMessageBox::Cancel);
|
||
// if(resultBtn == PaiMessageBox::Cancel)
|
||
// {
|
||
// delete pNewWorkflow;
|
||
// pNewWorkflow = NULL;
|
||
// return false;
|
||
// }
|
||
// }
|
||
|
||
// //处理老的的模块
|
||
// QString invalidModules;
|
||
// if (pNewWorkflow->IsValid(invalidModules) == false)
|
||
// {
|
||
// QString msg = QString("The workflow contains different version of modules.\nDo you still want to import it?\n") + invalidModules;
|
||
// PaiMessageBox::StandardButton resultBtn = PaiMessageBox::Warning(NULL, tr("Warning"),
|
||
// msg,PaiMessageBox::Yes | PaiMessageBox::Cancel);
|
||
|
||
// if(resultBtn == PaiMessageBox::Cancel)
|
||
// {
|
||
// delete pNewWorkflow;
|
||
// pNewWorkflow = NULL;
|
||
// return false;
|
||
// }
|
||
// }
|
||
|
||
// //检查同名，删除同名
|
||
// if(strNames.contains(strBaseName))
|
||
// {
|
||
// const char *deleteOldMsg = (type == WORKFLOW_TYPE)?g_szDeletOld:g_szDeletOldTempalte;
|
||
// if(resultButton != PaiMessageBox::YesToAll)
|
||
// {
|
||
// resultButton = PaiMessageBox::Question(NULL, tr(g_szQuestion),
|
||
// tr(deleteOldMsg).arg(strBaseName), PaiMessageBox::YesToAll | PaiMessageBox::Yes | PaiMessageBox::Cancel);
|
||
// }
|
||
// if(resultButton == PaiMessageBox::Cancel)
|
||
// {
|
||
// delete pNewWorkflow;
|
||
// pNewWorkflow = NULL;
|
||
// return false;
|
||
// }
|
||
// else
|
||
// {
|
||
// pOldWorkflow = (type == WORKFLOW_TYPE)?(pWorkflowMaster->GetObjectByName(strBaseName)):(m_pTemplateTree->GetChildByName(strBaseName));
|
||
|
||
// //如果这个工作流被打开状态，workflowOpend置真
|
||
// if(GetObjectModelService()->GetObjectLockManager()->IsObjectLocked(pOldWorkflow->GetDBID(),false))
|
||
// {
|
||
// workflowOpend = true;
|
||
// workflowDataModelID = pOldWorkflow->GetID();
|
||
// workflowdbid = pOldWorkflow->GetDBID();
|
||
// }
|
||
|
||
// if(type == WORKFLOW_TYPE && !pOldWorkflow->Erase(&strErrMsg))
|
||
// {
|
||
// importErrorList << QPair<int, QString>(ImportErrorType_DELETE, JsonFilePath);
|
||
// delete pNewWorkflow;
|
||
// return false;
|
||
// }
|
||
// if(type == WORKFLOW_TYPE && !pWorkflowMaster->RemoveChild(pOldWorkflow, true))
|
||
// {
|
||
// importErrorList << QPair<int, QString>(ImportErrorType_REMOVE, JsonFilePath);
|
||
// delete pNewWorkflow;
|
||
// return false;
|
||
// }
|
||
// if(type == TEMPLATE_TYPE)
|
||
// {
|
||
// DeleteTemplateCmd deleteTemplateCmd(m_pTemplateTree, pOldWorkflow);
|
||
// deleteTemplateCmd.redo();
|
||
|
||
// if(!deleteTemplateCmd.GetResult())
|
||
// {
|
||
// importErrorList << QPair<int, QString>(ImportErrorType_DELETE, JsonFilePath);
|
||
// delete pNewWorkflow;
|
||
// return false;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
|
||
// pNewWorkflow->SetName(strBaseName);
|
||
// if(workflowOpend)
|
||
// {
|
||
// pNewWorkflow->SetID(workflowDataModelID);
|
||
// }
|
||
|
||
// if(type == WORKFLOW_TYPE)
|
||
// {
|
||
// pWorkflowMaster->AddChild(pNewWorkflow);
|
||
// QString strJsonFileName("/tmp/");
|
||
// strJsonFileName += pNewWorkflow->GetName();
|
||
// QString strID = pNewWorkflow->GetID().toString();//这里取ID来保证/tmp/下的工作流文件名唯一
|
||
// strID.remove('{').remove('-').remove('}');
|
||
// strJsonFileName += strID;
|
||
// strJsonFileName += g_szJson;
|
||
|
||
// pNewWorkflow->Save(strJsonFileName.toStdString());
|
||
// }
|
||
|
||
// if(type == TEMPLATE_TYPE)
|
||
// {
|
||
// bool bResult = SaveHelper::SaveWorkflow(pNewWorkflow, true);
|
||
// if (!bResult)
|
||
// {
|
||
// importErrorList << QPair<int, QString>(ImportErrorType_IMPORT, SaveHelper::GetSaveExceptionWhat());
|
||
// delete pNewWorkflow;
|
||
// return false;
|
||
// }
|
||
// m_pTemplateTree->AddChild(pNewWorkflow);
|
||
// }
|
||
// if(type == WORKFLOW_TYPE && !pNewWorkflow->SaveToDB(&strErrMsg))
|
||
// {
|
||
// importErrorList << QPair<int, QString>(ImportErrorType_IMPORT, JsonFilePath);
|
||
// }
|
||
// else if(type == WORKFLOW_TYPE)
|
||
// {
|
||
// //导入成功则选中
|
||
// GetObjectModelService()->GetObjectSelection()->Select(pNewWorkflow->GetID());
|
||
// }
|
||
|
||
// //这里要做当老的工作流打开时的处理
|
||
// if(workflowOpend)
|
||
// {
|
||
// UpdateOpenedWorkflow(pNewWorkflow,workflowdbid);
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// QString importError;
|
||
// const char *parseFailed = (type == WORKFLOW_TYPE)?g_szParseFailed:g_szTemplateParseFailed;
|
||
// importError.append(tr(parseFailed).arg(JsonFilePath));
|
||
// importErrorList << QPair<int, QString>(ImportErrorType_PARSE, importError + QString::fromStdString(error));
|
||
// delete pNewWorkflow;
|
||
// return false;
|
||
// }
|
||
return true;
|
||
}
|
||
|
||
void WorkflowPluginControl::HandleImportedFiles(const QStringList & lstJsonFilePaths,
|
||
PaiObject *pWorkflowMaster,
|
||
QStringList & strNames,
|
||
ImportType type,
|
||
QString outPutFile)
|
||
{
|
||
// PaiMessageBox::StandardButton resultButton = PaiMessageBox::Yes;
|
||
// QList < QPair< int, QString > > importErrorList;
|
||
// QString fileNameList;
|
||
// foreach(QString strJsonFile, lstJsonFilePaths)
|
||
// {
|
||
// QString strBaseName;
|
||
// if(ImportWorkflow(strJsonFile,pWorkflowMaster,importErrorList,resultButton,strNames,type,outPutFile))
|
||
// {
|
||
// //获取去掉后缀的工作流名称
|
||
// QString suffix(g_szJson);
|
||
// strBaseName = GetWorkflowBaseName(strJsonFile,suffix);
|
||
// fileNameList += QString("\'"+strBaseName+"\' ");
|
||
// }
|
||
// else
|
||
// {
|
||
// continue;
|
||
// }
|
||
// }
|
||
|
||
// if(importErrorList.empty())
|
||
// {
|
||
// if(fileNameList.isEmpty())
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// if(1 != lstJsonFilePaths.count())
|
||
// {
|
||
// fileNameList += " files.";
|
||
// }
|
||
// else
|
||
// {
|
||
// fileNameList += " file.";
|
||
// }
|
||
// //全部导入成功则不选中parent
|
||
// if(type == WORKFLOW_TYPE)
|
||
// {
|
||
// GetObjectModelService()->GetObjectSelection()->Unselect(pWorkflowMaster->GetID());
|
||
// }
|
||
|
||
// const char *title = (type == WORKFLOW_TYPE) ? g_szWorkflowImpor : g_szTemplateImpor;
|
||
// if(::GetConsoleGUIService())
|
||
// {
|
||
// PaiMessageBox::Information(NULL, tr(title),
|
||
// tr(g_szImportWorkflowName).arg(fileNameList), PaiMessageBox::Ok);
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// //处理导入错误
|
||
// ParseError(importErrorList, type);
|
||
// }
|
||
}
|
||
void WorkflowPluginControl::ImportWorkflows(const QUuid& targetParentID,
|
||
const QStringList& lstJsonFilePaths,
|
||
ImportType type)
|
||
{
|
||
// //导入workflow时用的判断
|
||
// if(type == WORKFLOW_TYPE && targetParentID.isNull())
|
||
// {
|
||
// ShowMessage(PAI_NAME, g_szInvalidId);
|
||
// return;
|
||
// }
|
||
|
||
// PaiObject* pParentStage = NULL;
|
||
// PaiSurvey* pSurvey = NULL;
|
||
// QString outPutFile;
|
||
// QStringList names;
|
||
// if(type == WORKFLOW_TYPE)
|
||
// {
|
||
// pParentStage = GetObjectModelService()->GetObject(targetParentID);
|
||
// Q_ASSERT(NULL != pParentStage);
|
||
|
||
// pSurvey = pParentStage->GetForebear< PaiSurvey > ();
|
||
// if(!pSurvey)
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// outPutFile.append(pSurvey->GetPhysicalFile());
|
||
// outPutFile.append("/");
|
||
|
||
// QList< PaiObject* > workflows;
|
||
// pParentStage->GetChildren(workflows);
|
||
|
||
// foreach(PaiObject* pWorkflow, workflows)
|
||
// {
|
||
// names << pWorkflow->GetName();
|
||
// }
|
||
// }
|
||
// else if(type == TEMPLATE_TYPE)
|
||
// {
|
||
// outPutFile = QString();
|
||
|
||
// for(int i = 0; i < m_pTemplateTree->GetChildren().count(); ++i)
|
||
// {
|
||
// names << m_pTemplateTree->GetChildren().at(i)->GetName();
|
||
// }
|
||
// }
|
||
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Import workflows");
|
||
|
||
// try
|
||
// {
|
||
// //处理选中的工作流文件
|
||
// HandleImportedFiles(lstJsonFilePaths,pParentStage,names,type,outPutFile);
|
||
// }
|
||
// catch (pai::error::generic_error & e)
|
||
// {
|
||
// const char * exceptionMsg = (type == WORKFLOW_TYPE)?g_szImportCaught:g_szImportTemplateCaught;
|
||
// if (::GetConsoleGUIService())
|
||
// {
|
||
// pai::gui::PaiMessageBox::Critical(NULL, PAI_NAME, QString(
|
||
// exceptionMsg).append(e.what()));
|
||
// }
|
||
// pai::log::Info(_FLF(exceptionMsg + e.what()));
|
||
// }
|
||
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Import workflows");
|
||
}
|
||
|
||
void WorkflowPluginControl::Import(PaiAction *pSender, ImportType type)
|
||
{
|
||
// PaiSettings settings;
|
||
// QStringList filters;
|
||
// filters << "Workflow files (*.wfl)" << "All Files (*)";
|
||
// const QString importPath = (type == WORKFLOW_TYPE) ? LAST_IMPORT_WORKFLOW_PATH : LAST_IMPORT_TEMPLATES_PATH;
|
||
|
||
// //构造文件对话框
|
||
// PaiFileDialog importdlg(NULL, g_szWflFilesImp,
|
||
// settings.value(importPath, QDir::homePath()).toString());
|
||
// importdlg.SetNameFilters(filters);
|
||
// importdlg.SetFileMode(ExistingFiles);
|
||
|
||
// //进入事件循环，等待点ok
|
||
// if(QDialog::Accepted == importdlg.exec())
|
||
// {
|
||
// QStringList lstWflFiles = importdlg.SelectedFiles();
|
||
// if(!lstWflFiles.isEmpty())
|
||
// {
|
||
// QFileInfo fi(lstWflFiles.at(0));
|
||
|
||
// for(int i = 0; i < lstWflFiles.count(); i++)
|
||
// {
|
||
// QFileInfo tmp(lstWflFiles.at(i));
|
||
// if(!tmp.exists())
|
||
// {
|
||
// QString fileNotExistMsg = tmp.fileName() + " is not exist.";
|
||
// PaiMessageBox::Information(NULL, tr("Information"),
|
||
// fileNotExistMsg, PaiMessageBox::Ok, PaiMessageBox::Ok);
|
||
// lstWflFiles.removeAt(i);
|
||
// --i;
|
||
// }
|
||
// }
|
||
// if(lstWflFiles.isEmpty())
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// settings.setValue(importPath, fi.absoluteDir().absolutePath());
|
||
|
||
// // create temp path to save json files
|
||
// WorkflowPackage wflPacker;
|
||
// QString wflTemp = QDir::homePath() + "/" + g_szWorkflowDir;
|
||
// QString msg;
|
||
// if(!wflPacker.Exists(wflTemp))
|
||
// {
|
||
// QString msg;
|
||
// if(!wflPacker.Mkdirs(wflTemp, msg))
|
||
// {
|
||
// PaiMessageBox::Critical(NULL, tr("Error"), msg,
|
||
// PaiMessageBox::Ok, PaiMessageBox::Ok);
|
||
// return;
|
||
// }
|
||
// }
|
||
// else if(!wflPacker.IsDirectory(wflTemp))
|
||
// {
|
||
// QString msg;
|
||
// bool ret = wflPacker.Delete(wflTemp, msg);
|
||
// if(ret)
|
||
// {
|
||
// ret = wflPacker.Mkdirs(wflTemp, msg);
|
||
// }
|
||
// if(!ret)
|
||
// {
|
||
// PaiMessageBox::Critical(NULL, tr("Error"), msg,
|
||
// PaiMessageBox::Ok, PaiMessageBox::Ok);
|
||
// return;
|
||
// }
|
||
// }
|
||
|
||
// // unpack workflow files
|
||
// QStringList lstJsonFiles;
|
||
// foreach (QString wflpkg, lstWflFiles)
|
||
// {
|
||
// //获取去掉后缀的工作流名称
|
||
// QString suffix(g_szWfl);
|
||
// QString wflName = GetWorkflowBaseName(wflpkg,suffix);
|
||
|
||
// QString jsonDirTemp = wflTemp + "/" + QString::number(QDateTime::currentMSecsSinceEpoch()) + wflName;
|
||
// if(wflPacker.UnZipPackage(wflpkg, jsonDirTemp, msg))
|
||
// {
|
||
// QString jsonFile = jsonDirTemp + "/" + wflName + g_szJson;
|
||
// QString styleFile = jsonDirTemp + "/" + wflName + g_szStyle + g_szJson;
|
||
|
||
// // list all the json files inside the workflow package
|
||
// QStringList lstFiles;
|
||
// if (2 != wflPacker.ListFiles(jsonDirTemp, g_szJson, lstFiles)) // should only contains two json files
|
||
|
||
// {
|
||
// PaiMessageBox::Critical(NULL, tr("Error"),
|
||
// tr("It's a invalid workflow file!"),PaiMessageBox::Ok, PaiMessageBox::Ok);
|
||
// return;
|
||
// }
|
||
// // check whether the json file name equals to package file name
|
||
// // if not then rename the json file
|
||
// if (!lstFiles.contains(QString(wflName+g_szJson)))
|
||
// {
|
||
// foreach (QString name, lstFiles)
|
||
// {
|
||
// QString oldPath = jsonDirTemp + "/" + name;
|
||
// if (name.endsWith(QString(g_szStyle)+QString(g_szJson)))
|
||
// {
|
||
// wflPacker.Rename(oldPath, styleFile);
|
||
// }
|
||
// else if (name.endsWith(QString(g_szJson)))
|
||
// {
|
||
// wflPacker.Rename(oldPath, jsonFile);
|
||
// }
|
||
// }
|
||
// }
|
||
// lstJsonFiles.append(jsonFile);
|
||
// }
|
||
// }
|
||
// if(!lstJsonFiles.isEmpty())
|
||
// {
|
||
// if(type == WORKFLOW_TYPE)
|
||
// {
|
||
// //导入工作流
|
||
// PaiObject *pObj = pSender->GetFirstObject();
|
||
// ImportWorkflows(pObj ? pObj->GetID() : QUuid(), lstJsonFiles, WORKFLOW_TYPE);
|
||
// }
|
||
// else if(type == TEMPLATE_TYPE)
|
||
// {
|
||
// //导入模板
|
||
// ImportWorkflows(NULL, lstJsonFiles, TEMPLATE_TYPE);
|
||
// }
|
||
|
||
// // delete temp files and dirs
|
||
// foreach(QString jsonFile, lstJsonFiles)
|
||
// {
|
||
// QFileInfo info(jsonFile);
|
||
// //获取去掉后缀的工作流名称
|
||
// QString suffix(g_szJson);
|
||
// QString jsonName = GetWorkflowBaseName(jsonFile,suffix);
|
||
|
||
// QString jsonDirTemp = info.absolutePath();
|
||
// QString jsonFilePath = jsonDirTemp + "/" + jsonName + g_szJson;
|
||
// QString styleFilePath = jsonDirTemp + "/" + jsonName + g_szStyle + g_szJson;
|
||
// QString errorMsg;
|
||
// wflPacker.Delete(jsonFilePath, errorMsg);
|
||
// wflPacker.Delete(styleFilePath, errorMsg);
|
||
// wflPacker.Rmdir(jsonDirTemp);
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotImportWorkflows(ImportType type)
|
||
{
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Import workflows");
|
||
|
||
// PaiAction *pAction = NULL;
|
||
// if(type == WORKFLOW_TYPE)
|
||
// {
|
||
// pAction = dynamic_cast< PaiAction* > (sender());
|
||
// }
|
||
|
||
// Import(pAction, type);
|
||
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Import workflows");
|
||
}
|
||
|
||
QWidget* WorkflowPluginControl::GetParameterEditor() const
|
||
{
|
||
//测井项目额外实现，不需要，删除
|
||
return NULL;
|
||
}
|
||
|
||
// WorkflowWidget* WorkflowPluginControl::GetActiveWorkflowView()
|
||
// {
|
||
// return SaveHelper::GetActiveWorkflowView();
|
||
// }
|
||
|
||
void WorkflowPluginControl::slotRefreshProperties(const QUuid & id)
|
||
{
|
||
// QList < QUuid > objIDs;
|
||
// GetObjectModelService()->GetObjectSelection()->GetSelection(objIDs);
|
||
// foreach(QUuid objID, objIDs)
|
||
// {
|
||
// if(id == objID) // 判断当前要刷新的属性信息当前是否正在显示
|
||
|
||
// {
|
||
// pai::objectmodel::PaiObject *pObj = GetObjectModelService()->GetObject(id);
|
||
// if(pObj)
|
||
// {
|
||
// PaiTextEdit *pTEdit = SaveHelper::GetPropertiesTextEdit();
|
||
// if(pTEdit)
|
||
// {
|
||
// pTEdit->setHtml(pObj->GetProperties());
|
||
// }
|
||
// }
|
||
// return;
|
||
// }
|
||
// }
|
||
|
||
// if(GetObjectModelService()->GetProjectCount() == 0)
|
||
// {
|
||
// PaiTextEdit *pTEdit = SaveHelper::GetPropertiesTextEdit();
|
||
// if(pTEdit)
|
||
// {
|
||
// pTEdit->setHtml("");
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotActivateParameterEditor(pai::workflow::CModuleInformation* pInfo, bool IsModuleReadOnly)
|
||
{
|
||
if(IsModuleReadOnly)
|
||
{
|
||
return;
|
||
}
|
||
// PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetViewID());
|
||
// if(NULL != pPageService)
|
||
// {
|
||
// PaiMenuToolBar * pMenuToolBar = pPageService->GetMenuToolBar();
|
||
// if(NULL != pMenuToolBar)
|
||
// {
|
||
// PaiMenu* pMenu = pMenuToolBar->GetViewsMenu();
|
||
// if(NULL != pMenu)
|
||
// {
|
||
// QList< QAction * > viewActionList = pMenu->actions();
|
||
// foreach(QAction *pViewAction, viewActionList)
|
||
// {
|
||
// if(pViewAction->text() == g_szParameters && !pViewAction->isChecked())
|
||
// {
|
||
// if (pInfo && !pInfo->IsBlankModule())
|
||
// {
|
||
// pViewAction->trigger();
|
||
// }
|
||
// break;
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// pPageService->ActiveView(g_szParameters);
|
||
// }
|
||
}
|
||
void WorkflowPluginControl::slotActivateModuleTree(pai::workflow::CModuleInformation* pCurrentModule, bool IsModuleReadOnly)
|
||
{
|
||
// if(!IsModuleReadOnly || !m_bUnitTest)
|
||
// {
|
||
// PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetViewID());
|
||
// if(pPageService != NULL)
|
||
// {
|
||
// QWidget *pActiveWidget = pPageService->GetCurrentView(g_szB1);
|
||
// if(pActiveWidget != NULL)
|
||
// {
|
||
// QString strExtensionID = pActiveWidget->property(g_szExtensionID).toString();
|
||
// if(strExtensionID == g_szTemplates || (strExtensionID == g_szParameters && pCurrentModule == NULL))
|
||
// {
|
||
// if(strExtensionID == g_szParameters)
|
||
// {
|
||
// pai::graphics2d::CParameterEditor* pEditor = dynamic_cast< pai::graphics2d::CParameterEditor* > (GetParameterEditor());
|
||
// if(pEditor != NULL)
|
||
// {
|
||
// pEditor->Clear();
|
||
// }
|
||
// }
|
||
// pPageService->ActiveView(g_szModules);
|
||
// }
|
||
//
|
||
// ViewExtension *pModuleViewExtension =
|
||
// dynamic_cast< ViewExtension* > (pPageService->GetExtension(QString(tr(g_szModules)).toStdString()));
|
||
// if(pModuleViewExtension != NULL)
|
||
// {
|
||
// CPaiModuleToolBarView* moduleToolBar = dynamic_cast< CPaiModuleToolBarView* > (pModuleViewExtension->GetView());
|
||
// if(moduleToolBar != NULL)
|
||
// {
|
||
// if(pCurrentModule && !pCurrentModule->IsBlankModule())
|
||
// {
|
||
// moduleToolBar->GetModuleTree()->selectModules(QString::fromLocal8Bit(pCurrentModule->GetModule()->GetMetaData()->GetName().c_str()));
|
||
// }
|
||
// else
|
||
// {
|
||
// moduleToolBar->GetModuleTree()->selectModules("");
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::ShowMsg(QString strMsg)
|
||
{
|
||
// //状态栏提示置空
|
||
// if(GetConsoleGUIService() && GetConsoleGUIService()->GetStatusBarService())
|
||
// {
|
||
// GetConsoleGUIService()->GetStatusBarService()->EndProcessMessage("");
|
||
// }
|
||
// ShowMessage(PAI_NAME, strMsg);
|
||
}
|
||
|
||
void WorkflowPluginControl::slotCloseWorkflowPlugin(QString strAreaName) //syr
|
||
{
|
||
// if(strAreaName == g_szA)
|
||
// {
|
||
// if(PaiBalloonTipSettings::GetTipSetting("PaiBalloonTipType_HandleSaveAsTemplate") == false)
|
||
// {
|
||
// PaiBalloonTip::HideBalloon();
|
||
// }
|
||
// // GetConsoleGUIService()->GetViewTabService()->Unregister(GetViewID().toString().toStdString());
|
||
|
||
// SaveHelper::SetActiveWorkflowView( NULL);
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotActiveParameter()
|
||
{
|
||
// WorkflowWidget* pWorkflowWidget = this->GetActiveWorkflowView();
|
||
// if(pWorkflowWidget != NULL)
|
||
// {
|
||
// assert(GetActiveWorkflow() != NULL);
|
||
|
||
// if(m_pTemplateTree && GetActiveWorkflow()->IsTemplate())
|
||
// {
|
||
// m_pTemplateTree->ActiveItem(GetActiveWorkflow()->GetName());
|
||
// }
|
||
// //设置参数编辑区域的当前工作流
|
||
// pai::graphics2d::CParameterEditor* pEditor = dynamic_cast< pai::graphics2d::CParameterEditor* > (GetParameterEditor());
|
||
// if(pEditor != NULL)
|
||
// {
|
||
// ParameterEditorModel* editorModel = dynamic_cast< ParameterEditorModel * > (pEditor->model());
|
||
// if(editorModel != NULL)
|
||
// {
|
||
// editorModel->SetCurrentWorkflowID(QUuid(GetActiveWorkflow()->GetID()));
|
||
// }
|
||
// }
|
||
// WorkflowSceneManager* pScene = dynamic_cast<WorkflowSceneManager *>(pWorkflowWidget->GetScene());
|
||
// if(pScene != NULL && pScene->selectedItems().count() > 0)
|
||
// {
|
||
// if(pScene->selectedItems().at(0)->type() == pai::graphics2d::ModuleGraphicsItem::Type)
|
||
// {
|
||
// pai::graphics2d::ModuleGraphicsItem *pItem =
|
||
// dynamic_cast< pai::graphics2d::ModuleGraphicsItem * > (pScene->selectedItems().at(0));
|
||
// if(pItem && pItem->GetModule())
|
||
// {
|
||
// pScene->SelectModuleItem(pItem->GetModule()->GetStepID());
|
||
// }
|
||
// else
|
||
// {
|
||
// //这里传一个无效的id，只发送moduleSelectedSignal信号
|
||
// pScene->SelectModuleItem(-1);
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// if(pScene->selectedItems().at(0)->isSelected())
|
||
// {
|
||
// //这里传一个无效的id，只发送moduleSelectedSignal信号
|
||
// pScene->SelectModuleItem(-1);
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// // clear parameter editor if no item is selected
|
||
// if(pEditor != NULL)
|
||
// {
|
||
// pEditor->Clear();
|
||
// }
|
||
// //这里传一个无效的id，只发送moduleSelectedSignal信号
|
||
// pScene->SelectModuleItem(-1);
|
||
// }
|
||
// }
|
||
}
|
||
|
||
bool WorkflowPluginControl::CloseWorkflow(pai::objectmodel::PaiWorkflowDataModel* pWorkflowObject, QObject* pSender)
|
||
{
|
||
// PaiObject *pDataTreeWorkflow = NULL;
|
||
// PaiSurvey *pSurvey = NULL;
|
||
// PaiObject *pParentStage = NULL;
|
||
// if(!pWorkflowObject->IsTemplate())
|
||
// {
|
||
// //获取数据树上虚拟工作流
|
||
// pDataTreeWorkflow = GetObjectModelService()->GetObject(pWorkflowObject->GetDBID());
|
||
// if(!pDataTreeWorkflow)
|
||
// {
|
||
// return true;
|
||
// }
|
||
// //获取工作流所在工区
|
||
// pSurvey = pDataTreeWorkflow->GetForebear< PaiSurvey > ();
|
||
// if(pSurvey)
|
||
// {
|
||
// //获取工作流管理节点对象指针
|
||
// pParentStage = pSurvey->GetMaster(QUuid(PaiWorkflowMaster::GetTypeIDString()));
|
||
// }
|
||
// }
|
||
|
||
// if(pWorkflowObject == NULL
|
||
// || !pWorkflowObject->HasDataModified()
|
||
// || (!pWorkflowObject->IsTemplate() && !pSurvey))
|
||
// {
|
||
// return true;
|
||
// }
|
||
// else
|
||
// {
|
||
// // check survey update permission
|
||
// bool permission = true;
|
||
// try
|
||
// {
|
||
// if(pWorkflowObject->IsTemplate() == false)
|
||
// {
|
||
// permission = PaiPermissionChecker::HasPermission(dynamic_cast<PaiObject*>(pSurvey),PaiAction::PaiPermissionTypes(PaiAction::UPDATE));
|
||
// }
|
||
// }
|
||
// catch(pai::error::generic_error & e)
|
||
// {
|
||
// permission = false;
|
||
// }
|
||
// catch(...)
|
||
// {
|
||
// permission = false;
|
||
// }
|
||
|
||
// // do nothing if no permission
|
||
// if(!permission)
|
||
// {
|
||
// return true;
|
||
// }
|
||
// }
|
||
|
||
// // if no view extensions on "A" area, return directly
|
||
// PageService *pPageService = qobject_cast< PageService* > (pSender);
|
||
// if(pPageService)
|
||
// {
|
||
// QList< IExtension* > extensions;
|
||
// pPageService->GetAreaExtensions(g_szA, extensions);
|
||
// if(extensions.size() == 0)
|
||
// {
|
||
// return true;
|
||
// }
|
||
// }
|
||
|
||
// int r = PaiMessageBox::Question(NULL, g_szQuestion, tr(g_szSaveChanges) + pWorkflowObject->GetName() + "?",
|
||
// PaiMessageBox::Yes | PaiMessageBox::No | PaiMessageBox::Cancel, PaiMessageBox::Yes);
|
||
// switch(r)
|
||
// {
|
||
// case PaiMessageBox::Cancel:
|
||
// pSender->setProperty(g_szClose, false);
|
||
// return false;
|
||
// case PaiMessageBox::No:
|
||
// {
|
||
// if(!pWorkflowObject->HasFlag(PaiObject::Loaded))
|
||
// {
|
||
// if(pParentStage)
|
||
// {
|
||
// pWorkflowObject->SetModify(false);
|
||
// pParentStage->RemoveChild(pDataTreeWorkflow, true);
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// pWorkflowObject->ReloadDataModuel();
|
||
// }
|
||
// return true;
|
||
// }
|
||
// default: // PaiMessageBox::Yes
|
||
// {
|
||
// PaiWorkflowDataModel* pOldActiveWorkflow = GetActiveWorkflow();
|
||
// bool bIsCurrentWorkflow = pOldActiveWorkflow == pWorkflowObject ? true : false;
|
||
// SaveWorkflowCmd *pSaveWorkflowCmd = NULL;
|
||
// SaveTemplateCmd *pSaveTemplateCmd = NULL;
|
||
// if(pWorkflowObject->IsTemplate())
|
||
// {
|
||
// pSaveTemplateCmd = new SaveTemplateCmd(m_pTemplateTree, pWorkflowObject);
|
||
// pSaveTemplateCmd->redo();
|
||
// }
|
||
// else
|
||
// {
|
||
// pSaveWorkflowCmd = new SaveWorkflowCmd(m_ViewID, pWorkflowObject);
|
||
// pSaveWorkflowCmd->redo();
|
||
// }
|
||
|
||
// //如果要保存的工作流和当前工作流是同一个，则在保存之后，设置编辑界面的工作流为当前工作流。
|
||
// if(bIsCurrentWorkflow && (GetActiveWorkflowView() != NULL))
|
||
// {
|
||
// pOldActiveWorkflow = GetActiveWorkflowView()->GetWorkflow();
|
||
// pWorkflowObject = pOldActiveWorkflow;
|
||
// }
|
||
|
||
// if((pSaveWorkflowCmd && !pSaveWorkflowCmd->GetSaveResult()) || (pSaveTemplateCmd
|
||
// && !pSaveTemplateCmd->GetSaveResult()))
|
||
// {
|
||
// delete pSaveWorkflowCmd;
|
||
// delete pSaveTemplateCmd;
|
||
// pSender->setProperty(g_szClose, false);
|
||
// {
|
||
// return false;
|
||
// }
|
||
// }
|
||
// break;
|
||
// }
|
||
// }
|
||
// UpdateSaveActions(false, pWorkflowObject);
|
||
return true;
|
||
}
|
||
|
||
void WorkflowPluginControl::SetActiveTemplate(pai::CPaiWorkflowTemplateTree *pTemplateTree)
|
||
{
|
||
m_pTemplateTree = pTemplateTree;
|
||
}
|
||
|
||
void WorkflowPluginControl::slotOnClosePluginTabPage(const QString& strPageID)
|
||
{
|
||
/*
|
||
if(strPageID != m_ViewID.toString())
|
||
{
|
||
return;
|
||
}
|
||
|
||
QList< PaiWorkflowDataModel* > lstModifiedWorkflows = SaveHelper::GetModifiedWorkflows(m_ViewID);
|
||
int canceledCount = 0;
|
||
foreach(PaiWorkflowDataModel* pModifiedWorkflow, lstModifiedWorkflows)
|
||
{
|
||
canceledCount += CloseWorkflow(pModifiedWorkflow,sender()) == false ? 1:0;
|
||
}
|
||
if(canceledCount == 0)
|
||
{
|
||
SaveHelper::SetActiveWorkflowView( NULL);
|
||
// stop handle signal ObjectRefreshed if page was closed
|
||
disconnect(&pai::objectmodel::PaiObject::m_EventAgent,
|
||
SIGNAL(ObjectRefreshed(pai::objectmodel::PaiObject*)), 0, 0);
|
||
}
|
||
*/
|
||
}
|
||
|
||
void WorkflowPluginControl::slotCloseWorkflowWidget(const QString& strExtensionID)
|
||
{
|
||
/*
|
||
PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetViewID());
|
||
|
||
if(NULL == pPageService)
|
||
{
|
||
return;
|
||
}
|
||
ViewExtension* pViewExtension =
|
||
dynamic_cast< ViewExtension* > (pPageService->GetExtension(strExtensionID.toStdString()));
|
||
if(NULL == pViewExtension)
|
||
{
|
||
return;
|
||
}
|
||
WorkflowWidget* pClosingWorkflowWidget = GetFirstChildObject< WorkflowWidget > (pViewExtension->GetView());
|
||
if(NULL == pClosingWorkflowWidget)
|
||
{
|
||
return;
|
||
}
|
||
|
||
bool close = CloseWorkflow(pClosingWorkflowWidget->GetWorkflow(), sender());
|
||
|
||
if(close)
|
||
{
|
||
//如果关闭的工作流是活动的工作流，那么把活动工作流置空
|
||
if(pClosingWorkflowWidget == GetActiveWorkflowView())
|
||
{
|
||
SaveHelper::SetActiveWorkflowView(NULL);
|
||
}
|
||
//关闭前清理参数面板
|
||
CParameterEditor* pEditor = dynamic_cast<CParameterEditor*>(GetParameterEditor());
|
||
if (pEditor != NULL)
|
||
{
|
||
pEditor->Clear();
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
|
||
void WorkflowPluginControl::slotOnWorkflowPropertyChanged(pai::objectmodel::PaiObject* pObj,
|
||
const QString & strPropertyName, const QVariant & /*strNewPropertyValue*/)
|
||
{
|
||
// QString name = pObj->GetName();
|
||
// if(pObj->GetTypeID() == GetClassID_WorkflowDataModel())
|
||
// {
|
||
// ::GetObjectEvent().OnUpdateWorkflowWindow(pObj);
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::UpdateSaveActions(bool updateOrClose, pai::objectmodel::PaiObject* pObj)
|
||
{
|
||
/*
|
||
PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetViewID());
|
||
|
||
if(pPageService == NULL || pObj == NULL)
|
||
{
|
||
return;
|
||
}
|
||
|
||
QAction* pAction = pPageService->GetAction(tr(g_szSave));
|
||
QAction* pSaveAllAction = pPageService->GetAction(tr(g_szSaveAll));
|
||
|
||
if(pAction != NULL && pSaveAllAction != NULL)
|
||
{
|
||
bool permission = true;
|
||
try
|
||
{
|
||
//普通工作流需要获取权限，模板目前先按所有人都能修改处理
|
||
PaiWorkflowDataModel *pWorkflowDataModel = dynamic_cast< PaiWorkflowDataModel * > (pObj);
|
||
//数据树上的虚拟节点
|
||
PaiObject *pDataTreeWorkflow = GetObjectModelService()->GetObject(pObj->GetDBID());
|
||
|
||
if(!(pWorkflowDataModel->IsTemplate()) && pDataTreeWorkflow)
|
||
{
|
||
permission = pDataTreeWorkflow->GetForebear< PaiSurvey > ()
|
||
&& PaiPermissionChecker::HasPermission(pDataTreeWorkflow,PaiAction::PaiPermissionTypes(PaiAction::UPDATE));
|
||
}
|
||
else
|
||
{
|
||
permission = true;
|
||
}
|
||
}
|
||
catch(pai::error::generic_error & e)
|
||
{
|
||
permission = false;
|
||
}
|
||
catch(...)
|
||
{
|
||
permission = false;
|
||
}
|
||
|
||
//如果是pObj工作流的标志更新(updateOrClose应该为true),且pObj是当前工作流
|
||
if(updateOrClose)
|
||
{
|
||
if(pObj->HasDataModified())
|
||
{
|
||
//此时工作流有数据更新，则Save和SaveAll都应该可用
|
||
pAction->setEnabled(permission);
|
||
pSaveAllAction->setEnabled(permission);
|
||
}
|
||
else
|
||
{
|
||
//此时工作流没有数据更新，则Save应该不可用
|
||
pAction->setEnabled(false);
|
||
|
||
//查询所有打开的工作流，如果都没有数据更新SaveAll应该不可用
|
||
QList< PaiWorkflowDataModel* > lstModifiedWorkflows = SaveHelper::GetModifiedWorkflows(m_ViewID);
|
||
pSaveAllAction->setEnabled(lstModifiedWorkflows.size());
|
||
}
|
||
}
|
||
else
|
||
{
|
||
//以下是关闭某个工作流或者因删除而发生关闭某个工作流时(updateOrClose应该为false), 用来更新SaveAll的可用状态.
|
||
//若被关闭的工作流有数据更新，则查询所有打开的工作流，如果只有一个有数据更新即为要被关闭的工作流，则SaveAll应该不可用；
|
||
//此时被关闭的工作流如果没有数据更新，则查询所有打开的工作流，如果都没有数据更新SaveAll应该不可用；
|
||
QList< PaiWorkflowDataModel* > lstModifiedWorkflows = SaveHelper::GetModifiedWorkflows(m_ViewID);
|
||
|
||
int modified = pObj->HasDataModified() == true ? (lstModifiedWorkflows.size() - 1) : lstModifiedWorkflows.size();
|
||
pSaveAllAction->setEnabled(modified);
|
||
}
|
||
}
|
||
*/
|
||
}
|
||
|
||
void WorkflowPluginControl::CreateTempDir(const QString &tempPath)
|
||
{
|
||
// WorkflowPackage wflPacker;
|
||
// //如果临时文件加不存在
|
||
// if(!wflPacker.Exists(tempPath))
|
||
// {
|
||
// //创建临时文件夹
|
||
// QString msg;
|
||
// if(!wflPacker.Mkdirs(tempPath, msg))
|
||
// {
|
||
// PaiMessageBox::Critical(NULL, tr("Error"), msg, PaiMessageBox::Ok,
|
||
// PaiMessageBox::Ok);
|
||
// return;
|
||
// }
|
||
// }
|
||
// else if(!wflPacker.IsDirectory(tempPath))//如果存在同名的临时文件
|
||
// {
|
||
// //删除同名临时文件
|
||
// QString msg;
|
||
// bool ret = wflPacker.Delete(tempPath, msg);
|
||
// if(ret)
|
||
// {
|
||
// //创建临时文件夹
|
||
// ret = wflPacker.Mkdirs(tempPath, msg);
|
||
// }
|
||
// if(!ret)
|
||
// {
|
||
// PaiMessageBox::Critical(NULL, tr("Error"), msg, PaiMessageBox::Ok,
|
||
// PaiMessageBox::Ok);
|
||
// return;
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::DeleteTempDir(const QString &tempPath)
|
||
{
|
||
// WorkflowPackage wflPacker;
|
||
// //如果临时文件夹存在
|
||
// if(wflPacker.Exists(tempPath))
|
||
// {
|
||
// //删除临时文件夹
|
||
// if(!wflPacker.Rmdir(tempPath))
|
||
// {
|
||
// QString msg("Failed to delete temporary folder!");
|
||
// // PaiMessageBox::Critical(NULL, tr("Error"), msg, PaiMessageBox::Ok,
|
||
// // PaiMessageBox::Ok);
|
||
// return;
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::CheckExportedWorkflows(QList<pai::objectmodel::PaiObject*> &workflowList, const QString &targetPath)
|
||
{
|
||
// WorkflowPackage wflPacker;
|
||
// PaiMessageBox::StandardButton resultButton = PaiMessageBox::Yes;
|
||
// QList<pai::objectmodel::PaiObject*> exportedWorkflows = workflowList;
|
||
// //遍历被导出的工作流
|
||
// foreach(PaiObject* pSrcObject, exportedWorkflows)
|
||
// {
|
||
// //目标工作流的绝对路径
|
||
// QString strTargetWflFilePath = targetPath + "/" + pSrcObject->GetName() + g_szWfl;
|
||
// QFileInfo fi(strTargetWflFilePath);
|
||
// //如果已经存在
|
||
// if (fi.exists())
|
||
// {
|
||
// if(resultButton != PaiMessageBox::YesToAll)
|
||
// {
|
||
// resultButton = PaiMessageBox::Question(NULL, tr(g_szQuestion),
|
||
// tr(g_szOverOldOne).arg(pSrcObject->GetName() + g_szWfl),
|
||
// PaiMessageBox::YesToAll | PaiMessageBox::Yes | PaiMessageBox::Cancel, PaiMessageBox::Cancel);
|
||
// }
|
||
|
||
// if(resultButton == PaiMessageBox::Yes || resultButton == PaiMessageBox::YesToAll)
|
||
// {
|
||
// //删除当前存在的.wfl文件
|
||
// DeleteFile(strTargetWflFilePath);
|
||
// }
|
||
// if(resultButton == PaiMessageBox::Cancel)
|
||
// {
|
||
// //将当前工作流从导出列表中删除
|
||
// workflowList.removeOne(pSrcObject);
|
||
// continue;
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::OpenExportWorkflowsDialog(QString &targetPath, ImportType type)
|
||
{
|
||
// PaiSettings settings;
|
||
// const QString lastExportPath = (type == WORKFLOW_TYPE) ? LAST_EXPORT_WORKFLOW_PATH : LAST_EXPORT_TEMPLATES_PATH;
|
||
// //导出对话框初始化
|
||
// PaiFileDialog exportdlg(::GetWorkflowConsole());
|
||
// //exportdlg.SetLastDirSettingKey("1111111111111111");
|
||
// exportdlg.SetFileMode(Directory);
|
||
// exportdlg.SetAcceptMode(AcceptSave);
|
||
// exportdlg.SetDirectory(settings.value(lastExportPath, QDir::homePath()).toString());
|
||
// exportdlg.setWindowTitle(tr(g_szExportToDot));
|
||
// //导出对话框事件循环
|
||
// if(QDialog::Accepted == exportdlg.exec())
|
||
// {
|
||
// QStringList selectedFiles = exportdlg.SelectedFiles();
|
||
// if(!selectedFiles.isEmpty())
|
||
// {
|
||
// targetPath = selectedFiles.first();
|
||
// settings.setValue(lastExportPath, targetPath);
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::SaveExportedWorkflows(QList<pai::objectmodel::PaiObject*> &workflowList)
|
||
{
|
||
// PaiMessageBox::StandardButton resultButton = PaiMessageBox::Yes;
|
||
// //获取所有未保存的工作流
|
||
// QList<PaiWorkflowDataModel*> lstModifiedWorkflows = SaveHelper::GetModifiedWorkflows(m_ViewID);
|
||
|
||
// //遍历导出列表
|
||
// foreach(PaiObject *pObj,workflowList)
|
||
// {
|
||
// PaiWorkflowDataModel*pTmpWF = dynamic_cast<PaiWorkflowDataModel*>(pObj);
|
||
// if(pTmpWF)
|
||
// {
|
||
// //遍历被修改的工作流
|
||
// foreach(PaiWorkflowDataModel* pModifiedWorkflow, lstModifiedWorkflows)
|
||
// {
|
||
// if(pModifiedWorkflow->GetDBID() == pTmpWF->GetDBID())
|
||
// {
|
||
// if(resultButton != PaiMessageBox::YesToAll)
|
||
// {
|
||
// resultButton = PaiMessageBox::Question(NULL, tr(g_szQuestion),
|
||
// tr(g_szSaveChanges) + pTmpWF->GetName() + "?",
|
||
// PaiMessageBox::YesToAll | PaiMessageBox::Yes | PaiMessageBox::Cancel, PaiMessageBox::Cancel);
|
||
// }
|
||
// if (resultButton == PaiMessageBox::Cancel)
|
||
// {
|
||
// break;
|
||
// }
|
||
// //保存工作流
|
||
// SaveHelper::SaveWorkflow(pModifiedWorkflow, pModifiedWorkflow->IsTemplate());
|
||
// break;
|
||
// }
|
||
// }
|
||
// if(!pTmpWF->IsTemplate())
|
||
// {
|
||
// pTmpWF->ReloadDataModuel();
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
bool WorkflowPluginControl::DeleteFile(const QString& filePath)
|
||
{
|
||
// WorkflowPackage wflPacker;
|
||
// if(wflPacker.Exists(filePath))
|
||
// {
|
||
// QString errorMsg;
|
||
// wflPacker.Delete(filePath, errorMsg);
|
||
// if(!errorMsg.isEmpty())
|
||
// {
|
||
// PaiMessageBox::Critical(NULL, tr("Error"),errorMsg,
|
||
// PaiMessageBox::Ok, PaiMessageBox::Ok);
|
||
// return false;
|
||
// }
|
||
// }
|
||
return true;
|
||
}
|
||
|
||
void WorkflowPluginControl::slotExportWorkflows(ImportType type)
|
||
{
|
||
// PaiAction* pAction = NULL;
|
||
// QList< PaiObject* > objectList;
|
||
// objectList.clear();
|
||
|
||
// //获取被导出的工作流或者模板
|
||
// if(type == WORKFLOW_TYPE)
|
||
// {
|
||
// pAction = dynamic_cast< PaiAction* > (sender());
|
||
// if(!pAction)
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// objectList = pAction->GetObjects();
|
||
// }
|
||
// else if(type == TEMPLATE_TYPE)
|
||
// {
|
||
// objectList = m_pTemplateTree->GetSelectedChildren();
|
||
// }
|
||
|
||
// //处理不同项目或不同工区下的同名工作流同时导出情况
|
||
// for(int i = 0; i < objectList.count() - 1; ++i)
|
||
// {
|
||
// for(int j = i + 1; j < objectList.count(); ++j)
|
||
// {
|
||
// if(objectList.at(i)->GetName() == objectList.at(j)->GetName())
|
||
// {
|
||
// QString msg("Can't export the workflow of the same name !");
|
||
// PaiMessageBox::Critical(::GetWorkflowConsole(), tr("Error"), msg, PaiMessageBox::Ok,
|
||
// PaiMessageBox::Ok);
|
||
// return;
|
||
// }
|
||
// }
|
||
// }
|
||
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Export workflows");
|
||
// //保存导出链表中未保存的工作流
|
||
// //SaveExportedWorkflows(objectList);
|
||
|
||
// //如果被导出列表为空直接返回
|
||
// if(objectList.empty())
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// QString strTargetDirPath("");
|
||
// //打开导出工作流对话框
|
||
// OpenExportWorkflowsDialog(strTargetDirPath,type);
|
||
|
||
// if(strTargetDirPath.isEmpty())
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// //检查是否目标路径下已经存在当前将被导出的工作流
|
||
// // CheckExportedWorkflows(objectList,strTargetDirPath);
|
||
// //如果被导出列表为空直接返回
|
||
// if(objectList.empty())
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// WorkflowPackage wflPacker;
|
||
// int successCount = 0;
|
||
// int failCount = 0;
|
||
// QString saveStrings("");
|
||
// //存放工作流文件的临时名称和目标名称
|
||
// QMap<QString,QString> wflNameMap;
|
||
// //工作流临时文件夹
|
||
// QList<QString> wflTmpDir;
|
||
|
||
// foreach(PaiObject* pSrcObject, objectList)
|
||
// {
|
||
// // create temp path to save json files
|
||
// QString workflowTempName = QString::number(QDateTime::currentMSecsSinceEpoch());
|
||
// QString workflowTempPath = QDir::homePath() + "/" + g_szWorkflowDir + "/" + workflowTempName;
|
||
// CreateTempDir(workflowTempPath);
|
||
// wflTmpDir << workflowTempPath;
|
||
|
||
// //临时目录下的工作流*.json和*_style.json文件名
|
||
// QString strTargetJsonFilePath = workflowTempPath + "/" + pSrcObject->GetName() + g_szJson;
|
||
// QString strTargetStyleFilePath= workflowTempPath + "/" + pSrcObject->GetName() + g_szStyle + g_szJson;
|
||
// //将要产生的工作流文件*.wfl
|
||
// QString strTargetWflName = workflowTempName + g_szWfl;
|
||
// //将要产生的工作流文件的绝对路径
|
||
// QString strTargetWflFilePath = strTargetDirPath + "/" + strTargetWflName;
|
||
// //当前工作流
|
||
// pai::objectmodel::PaiWorkflowDataModel* pSrcWorkflow = dynamic_cast<pai::objectmodel::PaiWorkflowDataModel*>(pSrcObject);
|
||
// if(!pSrcWorkflow)
|
||
// {
|
||
// continue;
|
||
// }
|
||
// //在临时文件夹下生成*.json和*_style.json文件
|
||
// bool retSave = pSrcWorkflow->Save(strTargetJsonFilePath.toStdString(),true);
|
||
// QFileInfo jsonFileInfo(strTargetJsonFilePath);
|
||
// QFileInfo styleFileInfo(strTargetStyleFilePath);
|
||
// QString msg;
|
||
// //如果*.json和*_style.json文件在临时目录下存在
|
||
// if(jsonFileInfo.exists() && styleFileInfo.exists())
|
||
// {
|
||
// QStringList srcFiles;
|
||
// srcFiles.append(strTargetJsonFilePath);
|
||
// srcFiles.append(strTargetStyleFilePath);
|
||
// //生成工作流文件(*.wfl)
|
||
// // if (!wflPacker.ZipPackage(strTargetDirPath, strTargetWflName, srcFiles, msg))
|
||
// // {
|
||
// // retSave = false;
|
||
// // }
|
||
// // else
|
||
// // {
|
||
// // wflNameMap[strTargetDirPath +"/" + strTargetWflName]= strTargetDirPath + "/" + pSrcObject->GetName()+g_szWfl;
|
||
// // }
|
||
// }
|
||
// else
|
||
// {
|
||
// retSave = false;
|
||
// }
|
||
|
||
// if (retSave == true)
|
||
// {
|
||
// //记录导出成功的次数和信息
|
||
// const char *exportPath = (type == WORKFLOW_TYPE)?g_szExportPath:g_szExportTemplatePath;
|
||
// ++successCount;
|
||
// // saveStrings.append(tr(exportPath).arg(pSrcObject->GetName(), strTargetDirPath + "/" + pSrcObject->GetName() + g_szWfl));
|
||
// }
|
||
// else
|
||
// {
|
||
// //记录导出失败的信息和次数
|
||
// const char *exportFailedPath = (type == WORKFLOW_TYPE)?g_szExportFailed:g_szExportTemplatetFailed;
|
||
// ++failCount;
|
||
// // saveStrings.append(tr(exportFailedPath).arg(pSrcObject->GetName(), strTargetDirPath + "/" + pSrcObject->GetName() + g_szWfl));
|
||
// }
|
||
// }
|
||
// //重命名压缩成功的工作流文件
|
||
// PaiMessageBox::StandardButton resultButton = PaiMessageBox::Yes;
|
||
// QMap<QString, QString>::const_iterator it = wflNameMap.constBegin();
|
||
// while (it != wflNameMap.constEnd())
|
||
// {
|
||
// QFile wflTmpFile(it.key());
|
||
// QFile wflTargetFile(it.value());
|
||
// if(wflTargetFile.exists())
|
||
// {
|
||
// if(resultButton != PaiMessageBox::YesToAll)
|
||
// {
|
||
// resultButton = PaiMessageBox::Question(NULL, tr(g_szQuestion),
|
||
// tr(g_szOverOldOne).arg(it.value()),
|
||
// PaiMessageBox::YesToAll | PaiMessageBox::Yes | PaiMessageBox::Cancel, PaiMessageBox::Cancel);
|
||
// }
|
||
|
||
// if(resultButton == PaiMessageBox::Yes || resultButton == PaiMessageBox::YesToAll)
|
||
// {
|
||
// //删除当前存在的.wfl文件
|
||
// DeleteFile(it.value());
|
||
// wflTmpFile.rename(it.value());
|
||
// }
|
||
// if(resultButton == PaiMessageBox::Cancel)
|
||
// {
|
||
// DeleteFile(it.key());
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// wflTmpFile.rename(it.value());
|
||
// }
|
||
// ++it;
|
||
// }
|
||
|
||
// foreach(QString wflDir,wflTmpDir)
|
||
// {
|
||
// QDir tmpDir(wflDir);
|
||
// if(tmpDir.exists())
|
||
// {
|
||
// //删除工作流导出时产生的临时文件夹
|
||
// DeleteTempDir(wflDir);
|
||
// }
|
||
// }
|
||
|
||
// if(::GetConsoleGUIService())
|
||
// {
|
||
// //显示导出工作流成功的信息和导出失败的信息
|
||
// const char *title = (type == WORKFLOW_TYPE) ? g_szWorkflowExpor : g_szTemplateExpor;
|
||
// const char *allSucceedMsg = (type == WORKFLOW_TYPE) ? g_szExportAll : g_szExportAllTemplates;
|
||
// const char *msg = (type == WORKFLOW_TYPE) ? g_szExportSuccFai : g_szExportSuccFaiTemplate;
|
||
// PaiMessageBox
|
||
// box(PaiMessageBox::Icon_Information, tr(title),
|
||
// failCount == 0 ? tr(allSucceedMsg).arg(successCount) : tr(msg).arg(successCount).arg(failCount),
|
||
// saveStrings, PaiMessageBox::Ok, NULL);
|
||
// box.exec();
|
||
// }
|
||
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Export workflows");
|
||
}
|
||
|
||
void WorkflowPluginControl::slotDeleteItem()
|
||
{
|
||
// PaiAction* pAction = dynamic_cast< PaiAction* > (sender());
|
||
// if(!pAction)
|
||
// {
|
||
// return;
|
||
// }
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Delete workflow");
|
||
|
||
// QList< PaiObject* > objs = pAction->GetObjects();
|
||
// if(!objs.empty())
|
||
// {
|
||
// QStringList names;
|
||
// foreach(PaiObject *pObj, objs)
|
||
// {
|
||
// names.append(pObj->GetName());
|
||
// }
|
||
|
||
// if(PaiMessageBox::Warning(NULL, tr(g_szWarning),
|
||
// tr(g_szWantDelete).arg(names.join(" ")), PaiMessageBox::Yes | PaiMessageBox::No,
|
||
// PaiMessageBox::No) == PaiMessageBox::Yes)
|
||
// {
|
||
// foreach(PaiObject *pObject, objs)
|
||
// {
|
||
// DeleteWorkflowCmd deleteWorkflowCmd(pObject);
|
||
// deleteWorkflowCmd.redo();
|
||
// }
|
||
// }
|
||
// }
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Delete workflow");
|
||
}
|
||
|
||
void WorkflowPluginControl::OpenWorkflowView(long long dbid)
|
||
{
|
||
// //获取工作流插件
|
||
// pai::IPlugin* pWorkflowPlugin = ::GetConsoleGUIService()->GetPluginManager()->GetPlugin(m_ViewID);
|
||
// if(!pWorkflowPlugin)
|
||
// {
|
||
// return;
|
||
// }
|
||
// pai::CPaiWorkflowPlugin* pWorkflowView = dynamic_cast< pai::CPaiWorkflowPlugin* > (pWorkflowPlugin);
|
||
// if(!pWorkflowView)
|
||
// {
|
||
// return;
|
||
// }
|
||
// //获取数据树上工作流
|
||
// PaiObject *pDataTreeWorkflow = GetObjectModelService()->GetObject(dbid);
|
||
// if(!pDataTreeWorkflow)
|
||
// {
|
||
// return;
|
||
// }
|
||
// //dbid>0 说明是已经保存数据库的工作流
|
||
// if(dbid > 0)
|
||
// {
|
||
// //两种情况，1.已经打开的 2.没有打开的
|
||
// if(GetObjectModelService()->GetObjectLockManager()->IsObjectLocked(dbid,false))
|
||
// {
|
||
// pWorkflowView->Show(pDataTreeWorkflow);
|
||
// }
|
||
// else
|
||
// {
|
||
// PaiWorkflowDataModel *pWorkflow = new PaiWorkflowDataModel();
|
||
// //从数据库加载工作流
|
||
// pWorkflow->Load(dbid);
|
||
// pWorkflow->SetID(pDataTreeWorkflow->GetID());
|
||
|
||
// //可以发送事件
|
||
// pWorkflow->SetEventEnabled(true);
|
||
// pWorkflow->SetModify(false);
|
||
// bool bOpened = true;
|
||
// //将合理的工作流打开，不合理的给出提示。(老版本也可以打开)
|
||
// //把要显示的模块名称组织成html格式的列表
|
||
// QStringList modulesNames = pWorkflow->GetMissingModuleNames();
|
||
// if (!modulesNames.isEmpty())
|
||
// {
|
||
// QString missingModuleName =QString("<ul>");
|
||
// foreach(QString str,modulesNames)
|
||
// {
|
||
// missingModuleName += (QString("<li>")+str+QString("</li>\n"));
|
||
// }
|
||
// //移除最后一个换行符
|
||
// if(missingModuleName.endsWith("\n"))
|
||
// {
|
||
// missingModuleName.remove(missingModuleName.size()-1,1);
|
||
// }
|
||
// missingModuleName += QString("</ul>");
|
||
// //显示的消息
|
||
// QString msg = QString("The workflow contains one or more modules that do not exist in current system. "
|
||
// "Module names:%1").arg(missingModuleName);
|
||
// PaiMessageBox::Warning(NULL, tr("Warning"), msg, PaiMessageBox::Ok);
|
||
// }
|
||
// //检查模块版本
|
||
// QString invalidModules;
|
||
// if (pWorkflow->IsValid(invalidModules) == false)
|
||
// {
|
||
// QString msg = QString("The workflow contains different version of modules.\n") + invalidModules;
|
||
// PaiMessageBox::Warning(NULL, tr("Warning"), msg, PaiMessageBox::Ok);
|
||
// }
|
||
|
||
// if(NULL == GetConsoleGUIService()->GetViewTabService()->GetExtension(m_ViewID.toString().toStdString()))
|
||
// {
|
||
// //如果没有打开View，则先打开View
|
||
// bOpened = pWorkflowView->OpenView();
|
||
// }
|
||
// if(bOpened)
|
||
// {
|
||
// pWorkflowView->Show(pWorkflow);
|
||
// }
|
||
// }
|
||
// }
|
||
// else
|
||
// {
|
||
// pWorkflowView->Show(pDataTreeWorkflow);
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotEditItem()
|
||
{
|
||
// PaiAction* pAction = dynamic_cast< PaiAction* > (sender());
|
||
// if(!pAction)
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", true, "Edit workflow");
|
||
|
||
// QList< PaiObject* > objs;
|
||
// QList<QVariant> wfIDs = pAction->data().toList();
|
||
// foreach(QVariant wfID,wfIDs)
|
||
// {
|
||
// bool ok = false;
|
||
// long long dbid = wfID.toLongLong(&ok);
|
||
// if(ok)
|
||
// {
|
||
// OpenWorkflowView(dbid);
|
||
// }
|
||
// }
|
||
// pai::gui::TimeStampLogger::GetInstance().WriteGUIBenchMarkLog("Workflow", false, "Edit workflow");
|
||
}
|
||
|
||
void WorkflowPluginControl::slotOnActiveCurrentWorkflow(const QString& strExtensionID)
|
||
{
|
||
// ViewExtension *pViewExtension = dynamic_cast< ViewExtension * > (sender());
|
||
// if(pViewExtension != NULL)
|
||
// {
|
||
// WorkflowWidget* pWorkflowWidget =
|
||
// GetFirstChildWidget< WorkflowWidget > (dynamic_cast< QWidget* > (pViewExtension->GetView()));
|
||
// if(pWorkflowWidget != NULL)
|
||
// {
|
||
// if(GetActiveWorkflow() == pWorkflowWidget->GetWorkflow())
|
||
// {
|
||
// return;
|
||
// }
|
||
// SaveHelper::SetActiveWorkflowView(pWorkflowWidget);
|
||
// }
|
||
// }
|
||
// slotActiveParameter();
|
||
// QUuid currentWorkflowID(strExtensionID);
|
||
// if(!currentWorkflowID.isNull())
|
||
// {
|
||
// PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetViewID());
|
||
// if(pPageService != NULL)
|
||
// {
|
||
// HandleCurrentWorkEnvironment(HandleEnvironment_BeforeUnselect);
|
||
//
|
||
// QList< IExtension* > lstWorkflowExtensions;
|
||
// pPageService->GetAreaExtensions(g_szA, lstWorkflowExtensions);
|
||
// foreach(IExtension* pExtension,lstWorkflowExtensions)
|
||
// {
|
||
// QUuid otherWorkflowID(QString::fromStdString(pExtension->GetStringID()));
|
||
// if(!otherWorkflowID.isNull())
|
||
// {
|
||
// GetObjectModelService()->GetObjectSelection()->Unselect(otherWorkflowID);
|
||
// }
|
||
// }
|
||
// if(GetActiveWorkflow())
|
||
// {
|
||
// pPageService->SetFullPathName(GetActiveWorkflow()->GetFullPathName());
|
||
// }
|
||
// }
|
||
// // to fix 27548, 如果是工作流模板对象，则不试图在数据树上选中节点
|
||
// if(!GetActiveWorkflow()->IsTemplate())
|
||
// {
|
||
// GetObjectModelService()->GetObjectSelection()->Select(currentWorkflowID, true);
|
||
// }
|
||
//
|
||
// HandleCurrentWorkEnvironment(HandleEnvironment_AfterSelect);
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::HandleCurrentWorkEnvironment(HandleEnvironmentType type)
|
||
{
|
||
// PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetViewID());
|
||
// if(pPageService != NULL)
|
||
// {
|
||
// switch(type)
|
||
// {
|
||
// case HandleEnvironment_BeforeUnselect:
|
||
// {
|
||
// //获得当前工作流数据模型,因此本函数需要在设置新的工作流数据模型前使用
|
||
// PaiWorkflowDataModel* pCurrentActiveWorkflow = GetActiveWorkflow();
|
||
// if(pCurrentActiveWorkflow != NULL)
|
||
// {
|
||
// ViewExtension *pViewExtension =
|
||
// dynamic_cast< ViewExtension* > (pPageService->GetExtension(pCurrentActiveWorkflow->GetID().toString().toStdString()));
|
||
// if(pViewExtension != NULL)
|
||
// {
|
||
// //当前工作流对应的WorkflowWidget，即前一个WorkflowWidget.
|
||
// WorkflowWidget *pLastWorkflowWidget =
|
||
// GetFirstChildWidget< WorkflowWidget > (dynamic_cast< QWidget* > (pViewExtension->GetView()));
|
||
// if(pLastWorkflowWidget != NULL)
|
||
// {
|
||
// //清空map
|
||
// pLastWorkflowWidget->ClearSelectedExtensions();
|
||
//
|
||
// //为前一个WorkflowWidget保存B类页选择的ExtensionID
|
||
// //保存选择的ExtensionID.
|
||
// QWidget *pActiveWidget = pPageService->GetCurrentView(g_szB1);
|
||
// if(pActiveWidget != NULL)
|
||
// {
|
||
// QString strExtensionID = pActiveWidget->property(g_szExtensionID).toString();
|
||
// pLastWorkflowWidget->SetSelectedExtension(g_szB1, strExtensionID);
|
||
// }
|
||
//
|
||
// pActiveWidget = pPageService->GetCurrentView(g_szB2);
|
||
// if(pActiveWidget != NULL)
|
||
// {
|
||
// QString strExtensionID = pActiveWidget->property(g_szExtensionID).toString();
|
||
// pLastWorkflowWidget->SetSelectedExtension(g_szB2, strExtensionID);
|
||
// }
|
||
//
|
||
// //这里还要设置一下菜单项的可用情况
|
||
// WorkflowSceneManager* pScene = dynamic_cast<WorkflowSceneManager *>(pLastWorkflowWidget->GetScene());
|
||
// if(pScene != NULL)
|
||
// {
|
||
// pScene->RestoreActions(false);
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// break;
|
||
//
|
||
// case HandleEnvironment_AfterSelect:
|
||
// {
|
||
// //获得当前工作流数据模型,因此本函数需要在设置新的工作流数据模型前使用
|
||
// WorkflowWidget *pActiveWorkflowWidget = GetActiveWorkflowView();
|
||
//
|
||
// if(pActiveWorkflowWidget != NULL)//如果用户拖拽了一个别的页面到工作流的A区且激活该页则可能为空
|
||
// {
|
||
// //这里还要设置一下菜单项的可用情况
|
||
// WorkflowSceneManager* pScene = dynamic_cast<WorkflowSceneManager *>(pActiveWorkflowWidget->GetScene());
|
||
// if(pScene != NULL)
|
||
// {
|
||
// //if all command undo redo ok, this line can be opened.
|
||
// m_pUndoGroup->setActiveStack(pScene->GetUndoStack());
|
||
// pScene->RestoreActions(true);
|
||
// pScene->UpdateActions();
|
||
// }
|
||
// //在切换页签时，更新工作流插件的工具栏
|
||
// UpdateSaveActions(true,GetActiveWorkflow());
|
||
//
|
||
// //读取当前WorkflowWidget的B类页选择的ExtensionID, 执行ActiveView。
|
||
// QMap< QString, QString > selectedMap;
|
||
// pActiveWorkflowWidget->GetSelectedExtensions(selectedMap);
|
||
//
|
||
// QMapIterator< QString, QString > i(selectedMap);
|
||
// while(i.hasNext())
|
||
// {
|
||
// i.next();
|
||
// pPageService->ActiveView(i.value().toStdString());
|
||
// }
|
||
// }
|
||
// }
|
||
// break;
|
||
//
|
||
// default:
|
||
// break;
|
||
// }
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotPasteItems()
|
||
{
|
||
|
||
// WorkflowWidget *wfView = GetActiveWorkflowView();
|
||
// if(wfView == NULL)
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// WorkflowSceneManager* wfScene = dynamic_cast<WorkflowSceneManager *>(wfView->GetScene());
|
||
// if(wfScene != NULL)
|
||
// {
|
||
// wfScene->slotPaste();
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotCutItems()
|
||
{
|
||
// WorkflowWidget *wfView = GetActiveWorkflowView();
|
||
// if(wfView == NULL)
|
||
// {
|
||
// return;
|
||
// }
|
||
// WorkflowSceneManager* wfScene = dynamic_cast<WorkflowSceneManager *>(wfView->GetScene());
|
||
// if(wfScene != NULL)
|
||
// {
|
||
// wfScene->slotCutItem();
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotCopyItems()
|
||
{
|
||
// WorkflowWidget *wfView = GetActiveWorkflowView();
|
||
// if(wfView == NULL)
|
||
// {
|
||
// return;
|
||
// }
|
||
|
||
// WorkflowSceneManager* wfScene = dynamic_cast<WorkflowSceneManager *>(wfView->GetScene());
|
||
// if(wfScene != NULL)
|
||
// {
|
||
// wfScene->slotCopy();
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::slotOnWorkflowRefreshed(pai::objectmodel::PaiObject* pObj)
|
||
{
|
||
// PaiWorkflowDataModel *pWorkflowModel = dynamic_cast< PaiWorkflowDataModel* > (pObj);
|
||
// if(pWorkflowModel)
|
||
// {
|
||
// //重新加载一次,跟数据库同步,新建工作流刷新不做任何事情
|
||
// if(pWorkflowModel->GetDBID() > 0)
|
||
// {
|
||
// if(GetObjectModelService()->GetObjectLockManager()->IsObjectLocked(pWorkflowModel->GetDBID(),false))
|
||
// {
|
||
// // 被刷新工组流为当前打开工作流时，需要刷新显示
|
||
// if(GetActiveWorkflow() && GetActiveWorkflow()->GetDBID() == pWorkflowModel->GetDBID())
|
||
// {
|
||
// //清理模块参数编辑面板
|
||
// CParameterEditor* pEditor = dynamic_cast<CParameterEditor*>(GetParameterEditor());
|
||
// if (pEditor != NULL)
|
||
// {
|
||
// pEditor->Clear();
|
||
// }
|
||
// //重新设置场景
|
||
// SaveHelper::GetActiveWorkflowView()->SetWorkflow(pWorkflowModel, false);
|
||
// }
|
||
// else
|
||
// {
|
||
// PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(m_ViewID);
|
||
// if(pPageService != NULL)
|
||
// {
|
||
// QWidget* pWorkflowTabs = pPageService->GetWidgetView("A");
|
||
// if(pWorkflowTabs != NULL)
|
||
// {
|
||
// QList< WorkflowWidget* > lstWorkflowWidgets = pWorkflowTabs->findChildren< WorkflowWidget* > ();
|
||
// foreach(WorkflowWidget* pWorkflowWidget, lstWorkflowWidgets)
|
||
// {
|
||
// if(pWorkflowWidget)
|
||
// {
|
||
// PaiWorkflowDataModel* pWorkflow = pWorkflowWidget->GetWorkflow();
|
||
// if(pWorkflow->GetDBID() == pWorkflowModel->GetDBID())
|
||
// {
|
||
// pWorkflowWidget->SetWorkflow(pWorkflowModel, false);
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
}
|
||
|
||
pai::objectmodel::PaiWorkflowDataModel* WorkflowPluginControl::GetActiveWorkflow()
|
||
{
|
||
// if(GetActiveWorkflowView())
|
||
// {
|
||
return ::GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow();//->GetWorkflow();
|
||
// }
|
||
// return NULL;
|
||
}
|
||
|
||
QString WorkflowPluginControl::GetWorkflowBaseName(const QString &workflowFileName, const QString &suffix)
|
||
{
|
||
QFileInfo fi(workflowFileName);
|
||
QString workflowFile = fi.fileName();
|
||
//找到后缀开始的位置，找不到返回-1
|
||
int pos = workflowFile.lastIndexOf(suffix);
|
||
if(pos >= 0)
|
||
{
|
||
return workflowFile.remove(pos,suffix.size());
|
||
}
|
||
else
|
||
{
|
||
return workflowFile;
|
||
}
|
||
}
|
||
|
||
QList<pai::objectmodel::PaiWorkflowDataModel*> WorkflowPluginControl::GetOpenedWorkflows()
|
||
{
|
||
QList< PaiWorkflowDataModel* > lstWorkflows;
|
||
// PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(m_ViewID);
|
||
// if(pPageService != NULL)
|
||
// {
|
||
// QWidget* pWorkflowTabs = pPageService->GetWidgetView("A");
|
||
// if(pWorkflowTabs != NULL)
|
||
// {
|
||
// QList< WorkflowWidget* > lstWorkflowWidgets = pWorkflowTabs->findChildren< WorkflowWidget* > ();
|
||
// foreach(WorkflowWidget* pWorkflowWidget, lstWorkflowWidgets)
|
||
// {
|
||
// PaiWorkflowDataModel* pWorkflow = pWorkflowWidget->GetWorkflow();
|
||
// if (pWorkflow)
|
||
// {
|
||
// lstWorkflows.prepend(pWorkflow);
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
return lstWorkflows;
|
||
}
|
||
|
||
void WorkflowPluginControl::SlotRunWelllogModule()
|
||
{
|
||
//slotSaveAsTemplate();
|
||
CWellLogWorkflowDataModel * pWorkflowDataModel =dynamic_cast<CWellLogWorkflowDataModel*>( ::GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow() );
|
||
if (pWorkflowDataModel != NULL)
|
||
{
|
||
// //检查当前井次是否存在，因为有可能被删除
|
||
// CBaseObject* subtree=CPaiObjectHelper::GetSubtree(::GetProject(),pWorkflowDataModel->GetCurrentWellRoundPath());
|
||
// /*if(!subtree)//说明该井次已经被删除，需要重新选择当前井次
|
||
// {
|
||
// QMessageBox::warning(NULL, "提示","如下井次不存在，请检查数据："+pWorkflowDataModel->GetCurrentWellRoundPath());
|
||
// return;
|
||
// }*/
|
||
// m_pWellLogWorkflowRunner->GetRunTimeContext()->SetCurrentWellRoundPath(pWorkflowDataModel->GetCurrentWellRoundPath());
|
||
// AppendConsole(pai::log::PAI_INFO,"开始执行....");
|
||
m_pWellLogWorkflowRunner->RunWorkFlow(pWorkflowDataModel);
|
||
}
|
||
}
|
||
void WorkflowPluginControl::SlotRunWelllogModule(float sdep,float edep)
|
||
{
|
||
//slotSaveAsTemplate();
|
||
CWellLogWorkflowDataModel * pWorkflowDataModel =dynamic_cast<CWellLogWorkflowDataModel*>( ::GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow() );
|
||
if (pWorkflowDataModel != NULL)
|
||
{
|
||
// //检查当前井次是否存在，因为有可能被删除
|
||
// CBaseObject* subtree=CPaiObjectHelper::GetSubtree(::GetProject(),pWorkflowDataModel->GetCurrentWellRoundPath());
|
||
// /*if(!subtree)//说明该井次已经被删除，需要重新选择当前井次
|
||
// {
|
||
// QMessageBox::warning(NULL, "提示","如下井次不存在，请检查数据："+pWorkflowDataModel->GetCurrentWellRoundPath());
|
||
// return;
|
||
// }*/
|
||
m_pWellLogWorkflowRunner->GetRunTimeContext()->SetCurrentWellRoundPath(pWorkflowDataModel->GetCurrentWellRoundPath());
|
||
// AppendConsole(pai::log::PAI_INFO,"开始执行....");
|
||
m_pWellLogWorkflowRunner->RunWorkFlow(pWorkflowDataModel,sdep,edep);
|
||
}
|
||
}
|
||
|
||
void WorkflowPluginControl::DisplayCaculatedCurveOnWellSectionWindow(Qt::CheckState checkstate)
|
||
{
|
||
// //判断是否已经显示曲线，如果已经显示，就清除
|
||
// CVecWindow *pOSGWindow = dynamic_cast<CVecWindow*>(::GetWorkflowConsole()->GetVSplitter()->widget(0));
|
||
// int wellcount=pOSGWindow->GetSceneManager()->GetDocument()->GetChildrenCount();
|
||
// PaiObject* pWellTrack = pOSGWindow->GetSceneManager()->GetDocument()->GetChildByType( GetOSGWellTrackID());
|
||
// CWellLogWorkflowDataModel * pWorkflowDataModel =dynamic_cast<CWellLogWorkflowDataModel*>( ::GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow() );
|
||
|
||
// CBaseObject* wellTrack = dynamic_cast<CBaseObject*>(pWellTrack);
|
||
// //将曲线上树，通过模板刷新数据
|
||
// if (checkstate ==Qt::Checked)
|
||
// {
|
||
// std::map<std::string,pai::datamodel::CObjWellLog*> logCurveContainer = m_pWellLogWorkflowRunner->GetRunTimeContext()->GetLogCurveContainer();
|
||
// std::map<std::string,pai::datamodel::CObjWellLog*>::iterator it = logCurveContainer.begin();
|
||
// for (;it != logCurveContainer.end();it++)
|
||
// {
|
||
// pai::datamodel::CObjWellLog* pCurve = it->second;
|
||
// if(pCurve->GetSlfFileName()!="")
|
||
// {
|
||
// AddCurvesToDataTree(pCurve);
|
||
// continue;
|
||
// }
|
||
// if(pCurve->GetProperty().size()>0){//有效数据才上树TODO 加入多维数据判断
|
||
// //检查数据是否是有效数据 TODO 删掉没有上树的数据，保证内存不泄露
|
||
// bool validatecurve=false;
|
||
// for(int sampleindex=0;sampleindex<pCurve->GetProperty().size();sampleindex++){
|
||
// float samplevalue=pCurve->GetData(sampleindex);
|
||
// if(samplevalue!=samplevalue) continue;//NaN
|
||
// if(samplevalue > std::numeric_limits<float>::max()) //INF
|
||
// continue;
|
||
// if(samplevalue <- std::numeric_limits<float>::max()) //-INF
|
||
// continue;
|
||
// if(samplevalue>=999999) continue;//诡异的极大值
|
||
// if(samplevalue<=-999999) continue;//诡异的极小值
|
||
// validatecurve=true;
|
||
// break;
|
||
// }
|
||
// if (!validatecurve){
|
||
// AppendConsole(pai::log::PAI_INFO,"发现无效数据，抛弃："+pCurve->GetName());
|
||
// QApplication::processEvents();
|
||
// continue;
|
||
// }
|
||
// AppendConsole(pai::log::PAI_INFO," 上树开始："+pCurve->GetName());
|
||
// AddCurvesToDataTree(pCurve);
|
||
// QApplication::processEvents();
|
||
// if(!pWorkflowDataModel->IsSingleModuleMode()){//只有组合模块才进行绘制，单方法由模板进行刷新
|
||
// pCurve->SetCheckState( checkstate );
|
||
// AppendConsole(pai::log::PAI_INFO," 开始绘制："+pCurve->GetName());
|
||
// CVecDisplayObjectCommand::ClickObjectCommand( pCurve, pOSGWindow );
|
||
// QApplication::processEvents();
|
||
// }
|
||
// }
|
||
// }
|
||
// if(pWorkflowDataModel->IsSingleModuleMode()){
|
||
|
||
// RefreshMapArea(pOSGWindow);
|
||
// }
|
||
// //TODO 计算范围内刷新
|
||
// }
|
||
}
|
||
|
||
void WorkflowPluginControl::AddCurvesToDataTree(CObjWellLog * pWelllogCurve)
|
||
{
|
||
// CObjWelllogRound * m_pParent = m_pWellLogWorkflowRunner->GetRunTimeContext()->GetCurrentWellRound();
|
||
// if(m_pParent)
|
||
// {
|
||
// //增加深度道
|
||
// //首先判断树上有没有重复节点
|
||
// CObjWellLog *existwelllog=m_pParent->GetWellLogByName(pWelllogCurve->GetName());
|
||
// if (existwelllog)
|
||
// {
|
||
// if (existwelllog == pWelllogCurve)//基本上都是输入曲线
|
||
// {
|
||
// return;
|
||
// }
|
||
// else
|
||
// {
|
||
// QAction * pAction = ::GetGlobalCommand().GetAction(QUuid(GetViewCmdID_SwitchMode()),true);
|
||
// if (pAction->isChecked())//非覆盖模式
|
||
// {
|
||
// pWelllogCurve->SetName(m_pParent->GetNextChildName(existwelllog->GetName()));
|
||
// //将计算结果挂到数据树上
|
||
// m_pParent->AddChild(pWelllogCurve);
|
||
// CObjProject::AddIDMap( pWelllogCurve->GetID(),pWelllogCurve );
|
||
// }
|
||
// else//覆盖模式,内容覆盖，而该曲线还在树上
|
||
// {
|
||
// //如果非slf文件，则直接把数据拿过来，否则重新从slf加载即可
|
||
// if(existwelllog->GetSlfFileName()=="")
|
||
// {
|
||
// existwelllog->SetProperty(&pWelllogCurve->GetMD(),&pWelllogCurve->GetProperty());
|
||
// //TODO 删掉pWelllogCurve
|
||
// }
|
||
// else
|
||
// {
|
||
// existwelllog->isLoad=false;
|
||
// existwelllog->LoadFromSLF();//更新数据
|
||
// }
|
||
// }
|
||
// // if (QMessageBox::Yes == QMessageBox::information(NULL,"输出曲线","该名称节点已存在，是否覆盖？",QMessageBox::Yes,QMessageBox::No))
|
||
// // {
|
||
// // m_pParent->RemoveChild(childList[index],true);
|
||
// // }
|
||
// // else
|
||
// // {
|
||
// // pWelllogCurve->SetName(m_pParent->GetNextChildName(childList[index]->GetName()));
|
||
// // }
|
||
|
||
// }
|
||
// }
|
||
// else//没有该曲线，直接上树
|
||
// {
|
||
// m_pParent->AddChild(pWelllogCurve);
|
||
// CObjProject::AddIDMap( pWelllogCurve->GetID(),pWelllogCurve );
|
||
// }
|
||
|
||
|
||
// }
|
||
}
|
||
// void WorkflowPluginControl::ApplyTemplate(CVecWindow * pWindow)
|
||
// {
|
||
// QString strTemplatePath = ::GetTemplatePath();
|
||
// QSettings *inioperator = new QSettings(::GetConfPath()+"module-template.ini",QSettings::IniFormat);
|
||
// QString strValue;
|
||
// CWellLogWorkflowDataModel * pWorkflow = dynamic_cast<CWellLogWorkflowDataModel*>(::GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow());
|
||
// // if(pWorkflow->GetModuleCount()==0) return;
|
||
// if(pWorkflow->GetModuleCount()>1)//组合模块模式
|
||
// {
|
||
// QString wkfname=pWorkflow->GetName();
|
||
// strValue =inioperator->value(wkfname).toString();
|
||
// }
|
||
// else{
|
||
// CWellLogWorkflowDataModel * pWorkflow = dynamic_cast<CWellLogWorkflowDataModel*>(::GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow());
|
||
// WorkflowSceneManager * pSceneManager = dynamic_cast<WorkflowSceneManager*>(::GetWorkflowConsole()->GetWorkflowWidget()->GetScene());
|
||
|
||
// workflow::CModuleInformation *pModule = pSceneManager->GetSingleSelectedModule();
|
||
// PELibraryModule *pLogModule=NULL;
|
||
|
||
// if (pModule)
|
||
// {
|
||
// pLogModule=dynamic_cast<PELibraryModule *>(pModule->GetModule());
|
||
// if(pLogModule) {
|
||
// if(!pLogModule->strDLLFun.isEmpty()) {
|
||
// if(!pLogModule->strPlot.isEmpty()) strValue=pLogModule->strPlot;
|
||
// else if(pLogModule->Hd) {
|
||
// strValue=pLogModule->Hd->Plot;
|
||
// if(strValue.isEmpty()) strValue=pLogModule->strDLLFun+".tpl";
|
||
// }
|
||
// else strValue=pLogModule->strDLLFun+".tpl";
|
||
// }
|
||
// }
|
||
// else strValue =inioperator->value(QString::fromStdString(pModule->GetModuleID())).toString();
|
||
// }
|
||
|
||
// }
|
||
// QString val=strValue;
|
||
// if (strValue.isEmpty())
|
||
// {
|
||
// QString wellname;
|
||
// QString path;
|
||
// CObjProject *pProject = ::GetProject();
|
||
|
||
// QString slf=pProject->GetCurrentWell();
|
||
// if(!slf.isEmpty())
|
||
// {
|
||
// GetWellNameAndPath(slf,wellname,path);
|
||
// }
|
||
// QString strTempPath=::GetTemplatePath();
|
||
// QString strTplFilter="单井图文件(*.tpl);;多井图文件(*.mpl)";
|
||
// QString temp=path+QDir::separator();
|
||
// QString sourceDir=strTempPath+"well"+QDir::separator();
|
||
// if(!path.isEmpty()) strTempPath=temp;
|
||
// else strTempPath=sourceDir;
|
||
// strTplFilter="单井图文件(*.tpl);;多井图文件(*.mpl)";
|
||
// QString defaultTempleteFile=QFileDialog::getOpenFileName(NULL,QObject::tr("选择模板"),strTempPath,strTplFilter);
|
||
// if(defaultTempleteFile.trimmed()!="")
|
||
// {
|
||
// /* if(defaultTempleteFile.indexOf("template")>-1) {
|
||
// CObjProject *pProject = ::GetProject();
|
||
// QString name;
|
||
// if(pProject)name=pProject->GetName();
|
||
// QString wellname;
|
||
// QString path;
|
||
// QString slf=pProject->GetCurrentWell();
|
||
// if(!slf.isEmpty())
|
||
// {
|
||
// GetWellNameAndPath(slf,wellname,path);
|
||
// }
|
||
// QString Templetename;
|
||
// QString Templetepath;
|
||
// if(!slf.isEmpty())
|
||
// {
|
||
// GetWellNameAndPath(defaultTempleteFile,Templetename,Templetepath);
|
||
// }
|
||
// QString TempleteFile=path+QDir::separator()+wellname+Templetename+".tpl";
|
||
// QFile::copy(defaultTempleteFile,TempleteFile);
|
||
// defaultTempleteFile=TempleteFile;
|
||
// }
|
||
// */
|
||
// pWindow->GetSceneManager()->GetDocument()->SetTemplateFileName(defaultTempleteFile);
|
||
// QString windowname;
|
||
// windowname=pWindow->GetWindowDocument()->GetName();
|
||
// QFileInfo afile(defaultTempleteFile);
|
||
// windowname=windowname+"_"+afile.completeBaseName()+"_";
|
||
// //qDebug()<<QString::fromStdString(GenTimeStamp())<<"模板开始刷新："+defaultTempleteFile;
|
||
// pWindow->GetSceneManager()->GetDocument()->ApplyTemplate(defaultTempleteFile);
|
||
|
||
// pWindow->GetSceneManager()->UpdateAll();
|
||
// pWindow->GetSceneManager()->GetCameraCommand().TranslateGDIPixel( 0,0) ;
|
||
// return;
|
||
// }
|
||
// }
|
||
// else {
|
||
// strValue=QString("well")+QDir::separator()+strValue;
|
||
// }
|
||
// QString wellname;
|
||
// QString path;
|
||
// CObjProject *pProject = ::GetProject();
|
||
// CBaseObject* subtree=pProject->GetCurrentObject();
|
||
// CObjWelllogRound * m_pParent =dynamic_cast<pai::datamodel::CObjWelllogRound*>(subtree);
|
||
// if(m_pParent) {
|
||
// QString slf=m_pParent->GetSlfFileName();
|
||
// GetWellNameAndPath(slf,wellname,path);
|
||
// }
|
||
// if(wellname.isEmpty()) return;
|
||
// QString temp=path+QDir::separator()+wellname+val;
|
||
// QString sourceDir=::GetTemplatePath()+strValue;
|
||
// QDir dir;
|
||
// if(!dir.exists(temp)) {
|
||
// if(dir.exists(sourceDir)) {
|
||
// if(QFile::copy(sourceDir,temp)) sourceDir=temp;
|
||
// }
|
||
// }
|
||
// else sourceDir=temp;
|
||
// pWindow->GetWindowDocument()->ApplyTemplate(sourceDir);
|
||
// pWindow->GetSceneManager()->UpdateAll();
|
||
|
||
// delete inioperator;
|
||
// }
|
||
|
||
// //计算完成后，刷新图形区域，更新深度范围，更新改了的曲线
|
||
// void WorkflowPluginControl::RefreshMapArea(CVecWindow * pWindow)
|
||
// {
|
||
// PaiObject* pWellTrack = pWindow->GetSceneManager()->GetDocument()->GetChildByType( GetOSGWellTrackID());
|
||
// if(!pWellTrack) return;
|
||
// CObjectViewInfo* trackinfo=pWindow->GetSceneManager()->GetViewInfo(pWellTrack->GetID());
|
||
// CWellLogWorkflowDataModel * pWorkflowDataModel =dynamic_cast<CWellLogWorkflowDataModel*>( ::GetWorkflowConsole()->GetWorkflowWidget()->GetWorkflow() );
|
||
// PELibraryModule* amodule= dynamic_cast<PELibraryModule*>(pWorkflowDataModel->GetModule(0)->GetModule());
|
||
|
||
// if(trackinfo&&amodule)
|
||
// {
|
||
// CWellViewInfo *pWellViewInfo = dynamic_cast<CWellViewInfo*>( trackinfo );
|
||
// QScrollBar* vScroll=NULL;
|
||
// int value=0;
|
||
// CQtViewer *pView=dynamic_cast<CQtViewer *>(pWindow->GetSceneManager()->GetVecViwer());
|
||
// if(pView) {
|
||
// vScroll=pView->GetVScroll();
|
||
// if(vScroll)
|
||
// {
|
||
// value=vScroll->value();
|
||
// vScroll->setValue(0);
|
||
// }
|
||
// }
|
||
// CVecWindowCommand::ViewInfoPropetyChanged( "TopDepth", pWellViewInfo,pWellViewInfo->GetTopDepth());
|
||
// if(pView)pView->UpdateScrollbar();
|
||
// if(vScroll) {
|
||
// if(value>vScroll->maximum()) value=vScroll->maximum()-1;
|
||
// vScroll->setValue(value);
|
||
// }
|
||
// }
|
||
|
||
// }
|