/**
 * @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);
// 		}
// 	}

// }