logplus/ModuleConsole/src/WorkflowPlugin.cpp

/**
 * @file WorkflowPlugin.cpp
 * @date 2011-6-27
 */
#include <QTextStream>
#include <QWebFrame>
#include <QUndoGroup>
#include <QFileInfo>
#include <QWebPage>
#include <QTreeWidgetItem>

#include "WorkflowPlugin.h"
#include "ModuleGraphicsItem.h"
#include "ConsoleGUIService.h"
#include "ViewExtension.h"
#include "WorkflowWidget.h"
#include "PaiWorkflowSubmitter.h"
#include "PaiSurvey.h"
#include "ObjectModelService.h"
#include "PaiModuleTree.h"
#include "PaiMessageBox.h"
#include "PaiTextEdit.h"
#include "WorkflowSceneManager.h"
#include "PaiModuleToolBarView.h"
#include "WorkflowToolBarView.h"
#include "WorkflowConst.h"
#include "ParameterEditorModel.h"
#include "PaiWorkflowMaster.h"
#include "PaiObjectSelection.h"
#include "PAIConst.h"
#include "ParameterProperty.h"
#include "GlobalUtility.h"
#include "ModuleInformation.h"
#include "PaiBalloonTip.h"
#include "Utils.h"
#include "PaiWebViewWidget.h"
#include "SaveHelper.h"
#include "BrowseWorkflowCmd.h"
#include "PaiWorkflowTemplateTree.h"
#include "ParameterEditor.h"
#include "ShareActionExtension.h"
#include "PaiAction.h"
#include "PaiHelp.h"

using namespace pai;
using namespace pai::gui;
using namespace pai::graphics2d;
using namespace pai::objectmodel;

CPaiWorkflowPlugin::CPaiWorkflowPlugin() :
    m_pParameterEditor(NULL),
    m_control(GetID())
{
}

CPaiWorkflowPlugin::~CPaiWorkflowPlugin()
{
}

void CPaiWorkflowPlugin::Integrate()
{
    connect(&pai::objectmodel::PaiObject::m_EventAgent,
            SIGNAL(PropertyChanged(pai::objectmodel::PaiObject* ,const QString&,const QVariant& )), &m_control,
            SLOT(slotOnWorkflowPropertyChanged(pai::objectmodel::PaiObject* ,const QString&,const QVariant& )));

    // 注册菜单扩展管理
    Register(new ShareActionExtension(&m_control), ILocation());
}

void CPaiWorkflowPlugin::slotActiveAreaTabPage(const QString& strAreaName, const std::string& activedViewID)
{
    WorkflowWidget* pWorkflowView = m_control.GetActiveWorkflowView();
    if(pWorkflowView != NULL && pWorkflowView->GetScene() != NULL && strAreaName == g_szB1)
    {
        if(QString::fromStdString(activedViewID) == g_szModules ||
                QString::fromStdString(activedViewID) == g_szParameters)
        {
            PaiBalloonTip::HideBalloon();
        }
        QWebPage* pWebInfo = GetWebHelpInfo();
        if(pWebInfo
                && pWebInfo != NULL
                && pWebInfo->mainFrame() != NULL)
        {
            //获取B1区CPaiModuleToolBarView
            PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetID());
            ViewExtension *pModuleViewExtension = NULL;
            CPaiModuleToolBarView* moduleToolBar = NULL;
            if(pPageService)
            {
                pModuleViewExtension = dynamic_cast< ViewExtension* > (pPageService->GetExtension(QString(tr(g_szModules)).toStdString()));
                if(pModuleViewExtension)
                {
                    moduleToolBar = dynamic_cast< CPaiModuleToolBarView* > (pModuleViewExtension->GetView());
                }
            }
            //场景中没有选中模块时
            if(pWorkflowView->GetScene()->selectedItems().count() == 0)
            {
                // 工作流模块列表。<br>您可以通过展开分类来浏览和选择模块
                if(QString::fromStdString(activedViewID) == g_szModules)
                {
                    if(moduleToolBar)
                    {
                        moduleToolBar->GetModuleTree()->selectModules("");
                    }
                    pWebInfo->mainFrame()->setHtml(tr(g_szSelectModule));
                }
                // 选择模块之后，你可以在此处填写模块参数
                else if(QString::fromStdString(activedViewID) == g_szParameters)
                {
                    if(m_pParameterEditor)
                    {
                        m_pParameterEditor->Clear();
                    }
                    pWebInfo->mainFrame()->setHtml(tr(g_szSetparameters));
                }
            }
            else
            {
                //更新提示信息
                if(QString::fromStdString(activedViewID) == g_szModules)
                {
                    if(moduleToolBar && moduleToolBar->GetModuleTree())
                    {
                        QList<QTreeWidgetItem *> itemLst  = moduleToolBar->GetModuleTree()->selectedItems ();
                        //如果模块树上选中模块或者场景中选中模块个数不等于1时，设置B2区信息
                        if(itemLst.isEmpty() || pWorkflowView->GetScene()->selectedItems().count() != 1)
                        {
                            moduleToolBar->GetModuleTree()->selectModules("");
                            pWebInfo->mainFrame()->setHtml(tr(g_szSelectModule));
                        }
                        else
                        {
                            slotShowHelpDoc(itemLst.last(),1);
                        }
                    }
                }
                else if(QString::fromStdString(activedViewID) == g_szParameters)
                {
                    if(m_pParameterEditor)
                    {
                        slotShowDescription(m_pParameterEditor->currentIndex());
                    }
                }
            }
            // 工作流模版列表。<br>您可以选择需要的模版快速进行工作流编辑
            if(QString::fromStdString(activedViewID) == g_szTemplates)
            {
                pWebInfo->mainFrame()->setHtml(tr(g_szTemplateList));
            }
        }
    }
}

pai::objectmodel::PaiWorkflowDataModel* CPaiWorkflowPlugin::GetActiveWorkflow()
{
    if(m_control.GetActiveWorkflowView())
    {
        return m_control.GetActiveWorkflowView()->GetWorkflow();
    }
    return NULL;
}

void CPaiWorkflowPlugin::slotOnActiveTabPage(const QString &id)
{
    if(id == QString::fromStdString(GetStringID()))
    {
        if(GetActiveWorkflow() != NULL)
        {
            //切换页签时对权限进行处理即设置按钮的可用性
            m_control.UpdateSaveActions(true, GetActiveWorkflow());
            GetObjectModelService()->GetObjectSelection()->Select(GetActiveWorkflow()->GetID(), true);
            if(m_pParameterEditor != NULL)
            {
                ParameterEditorModel* editorModel =
                        dynamic_cast< ParameterEditorModel * > (m_pParameterEditor->model());
                if(editorModel != NULL)
                {
                    editorModel->SetCurrentWorkflowID(QUuid(GetActiveWorkflow()->GetID()));
                }
            }
        }
    }
}

void CPaiWorkflowPlugin::Dispose()
{
    disconnect(&pai::objectmodel::PaiObject::m_EventAgent,
            SIGNAL(PropertyChanged(pai::objectmodel::PaiObject* ,const QString&,const QVariant& )), &m_control,
            SLOT(slotOnWorkflowPropertyChanged(pai::objectmodel::PaiObject* ,const QString&,const QVariant& )));

    // 关闭界面并析构资源
    if(GetConsoleGUIService()->GetViewTabService()->GetExtension(GetStringID()))
    {
        GetConsoleGUIService()->GetViewTabService()->Unregister(GetStringID());
    }
}

bool CPaiWorkflowPlugin::Show(PaiObject *obj)
{
    if(dynamic_cast< PaiWorkflowDataModel* > (obj))
    {
        PaiWorkflowDataModel* pWorkflow = dynamic_cast< PaiWorkflowDataModel* > (obj);
        if(!pWorkflow)
        {
            return false;
        }

        if(!_ShowWorkflow(pWorkflow))
        {
            return false;
        }

        if(m_pParameterEditor != NULL)
        {
            ParameterEditorModel* pEditorModel = dynamic_cast< ParameterEditorModel * > (m_pParameterEditor->model());
            if(pEditorModel != NULL && GetActiveWorkflow())
            {
                pEditorModel->SetCurrentWorkflowID(QUuid(GetActiveWorkflow()->GetID()));
            }
        }
        Active(obj);
        return true;
    }
    return false;
}

bool CPaiWorkflowPlugin::Active(pai::objectmodel::PaiObject* pObj)
{
    GetConsoleGUIService()->GetViewTabService()->ActivateTabWidget(this->GetStringID());

    // to fix 27548, 如果是工作流模板对象，则不试图在数据树上选中节点
    PaiWorkflowDataModel *pWorkflow = dynamic_cast< PaiWorkflowDataModel* > (pObj);
    if(pWorkflow && !pWorkflow->IsTemplate())
    {
        GetObjectModelService()->GetObjectSelection()->Select(pWorkflow->GetID(), true);
    }
    return true;
}

PluginInformation CPaiWorkflowPlugin::GetInformation()
{
    PluginInformation info;
    info.SetID(GetID());
    info.SetName("PaiWorkflowPlugin");
    info.SetProvider("Qunzhihe");
    info.SetVersion("1.0.0.0");
    info.SetBrief("PaiWorkflowPlugin Display");
    return info;
}

void CPaiWorkflowPlugin::OpenWorkflowHelp()
{
    //要跳转到的html文档的名称
    pai::gui::PaiHelp::Show("2.2.7workflowmanagement");
}

bool CPaiWorkflowPlugin::OpenView()
{
    try
    {
        //pageService注册到主控台内容区划分3部分A、B1、B2
        PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->Register(GetID(),
                                                                                          QIcon(g_szWorkflowPng),
                                                                                          g_szWorkflowEditor, g_szAB);
        //让A区页签的标题显示从左下开始
        pPageService->SetTabPosition(g_szA, QTabWidget::South);
        //设置A区主区域，可修改编辑
        pPageService->SetPrimaryArea(g_szA);

        // 工作流内容区和参数编辑区的默认宽度比例应该是7:3
        GetConsoleGUIService()->GetViewTabService()->SetDefaultPageStretchFactor(GetID(), g_szA, 7);
        GetConsoleGUIService()->GetViewTabService()->SetDefaultPageStretchFactor(GetID(), g_szB, 3);

        //当点击A区页签的关闭按钮时，关闭整个插件
        connect(pPageService,SIGNAL(PageWillBeClosed(const QString&)),
                &m_control, SLOT(slotOnClosePluginTabPage(const QString&)));
        //当切换到当前插件页签时，把当前页签激活并且更新控件
        GetConsoleGUIService()->GetViewTabService()->ConnectWithTabWidget(SIGNAL(CurrentTabChanged(const QString&)),
                this, SLOT(slotOnActiveTabPage(const QString&)));

        //"Save" action，初始化置灰，有更新权限，然后注册到toolbar
        PaiAction* pSaveAction = new PaiAction(QIcon(g_szSavePng), g_szSave, NULL);
        pSaveAction->setEnabled(false);
        pSaveAction->SetPermission(pai::gui::PaiAction::UPDATE);
        connect(pSaveAction, SIGNAL(triggered()), &m_control, SLOT(slotSaveWorkflow()));
        pPageService->GetToolBarService()->Register(pSaveAction);
        pPageService->GetMenuService()->Register(pSaveAction, g_szMenu);

        //注册save as菜单到MENU
        QMenu* saveasMenu = new QMenu();
        saveasMenu->setTitle(tr(g_szSaveAs));
        pPageService->GetMenuService()->Register(saveasMenu, tr(g_szMenu));

        //"Save as Workflow" action，初始化可用，有更新权限，然后注册到toolbar
        PaiAction* pSaveasWorkflowAction = new PaiAction(QIcon(g_szSaveasPng), g_szSaveasWfDot, NULL);
        pSaveasWorkflowAction->setEnabled(true);
        //因有可能本工区没有Upadate权限但其他工区有update权限，故此Action不能根据本工区的Update权限变化可用性
        connect(pSaveasWorkflowAction, SIGNAL(triggered()), &m_control, SLOT(slotSaveAsWorkflow()));
        pPageService->GetToolBarService()->Register(pSaveasWorkflowAction);
        pPageService->GetMenuService()->Register(pSaveasWorkflowAction, g_szMenuSaveAs);

        //"Save as Template" action，初始化可用，有更新权限，然后注册到toolbar
        PaiAction* pSaveasTemplateAction = new PaiAction(QIcon(g_szSaveTempPng), g_szSaveTempDot, NULL);
        pSaveasTemplateAction->setEnabled(true);
        connect(pSaveasTemplateAction, SIGNAL(triggered()), &m_control, SLOT(slotSaveAsTemplate()));
        pPageService->GetToolBarService()->Register(pSaveasTemplateAction);
        pPageService->GetMenuService()->Register(pSaveasTemplateAction, g_szMenuSaveAs);

        //"Save as Picture" action，初始化可用，有更新权限，然后注册到toolbar
        PaiAction* pSaveasPictureAction = new PaiAction(QIcon(g_szSavePicture), g_szSaveAsPictureDot, NULL);
        pSaveasPictureAction->setEnabled(false);
        connect(pSaveasPictureAction, SIGNAL(triggered()), &m_control, SLOT(slotSaveWorkflowAsImageFile()));
        pPageService->GetToolBarService()->Register(pSaveasPictureAction);
        pPageService->GetMenuService()->Register(pSaveasPictureAction, g_szMenuSaveAs);

        //"Save as All" action，初始化置灰，有更新权限，然后注册到toolbar
        PaiAction* pSaveallAction = new PaiAction(QIcon(g_szSaveallPng), g_szSaveall, NULL);
        pSaveallAction->setEnabled(false);
        connect(pSaveallAction, SIGNAL(triggered()), &m_control, SLOT(slotSaveAllWorkflows()));
        pPageService->GetToolBarService()->Register(pSaveallAction);
        pPageService->GetMenuService()->Register(pSaveallAction, g_szMenu);

        //添加分割线
        QAction* pMenuSeparatorAction = new QAction("", NULL);
        pMenuSeparatorAction->setSeparator(true);
        pPageService->GetToolBarService()->Register(pMenuSeparatorAction);
        pPageService->GetMenuService()->Register(pMenuSeparatorAction, g_szMenu);

        //添加Undo Action
        QAction *pUndoAction = m_control.GetUndoAction();
        pPageService->GetToolBarService()->Register(pUndoAction);
        pPageService->GetMenuService()->Register(pUndoAction, g_szMenu);

        //添加Redo Action
        QAction *pRedoAction = m_control.GetRedoAction();
        pPageService->GetToolBarService()->Register(pRedoAction);
        pPageService->GetMenuService()->Register(pRedoAction, g_szMenu);

        //添加剪切 Action
        PaiAction* pCutAction = new PaiAction(QIcon(g_szCutPng), g_szCut, NULL);
        pCutAction->setEnabled(false);
        pPageService->GetToolBarService()->Register(pCutAction);
        pPageService->GetMenuService()->Register(pCutAction, g_szMenu);
        connect(pCutAction, SIGNAL(triggered()), &m_control, SLOT(slotCutItems()));

        //添加Copy Action
        PaiAction* pCopyAction = new PaiAction(QIcon(g_szCopyPng), g_szCopy, NULL);
        pCopyAction->setEnabled(false);
        pPageService->GetToolBarService()->Register(pCopyAction);
        pPageService->GetMenuService()->Register(pCopyAction, g_szMenu);
        connect(pCopyAction, SIGNAL(triggered()), &m_control, SLOT(slotCopyItems()));

        //添加Paste Action
        PaiAction* pPasteAction = new PaiAction(QIcon(g_szPastePng), g_szPaste, NULL);
        pPasteAction->setEnabled(false);
        pPageService->GetToolBarService()->Register(pPasteAction);
        pPageService->GetMenuService()->Register(pPasteAction, g_szMenu);
        connect(pPasteAction, SIGNAL(triggered()), &m_control, SLOT(slotPasteItems()));

        //添加分割符
        QAction* pSndMenuSeparatorAction = new QAction("", NULL);
        pSndMenuSeparatorAction->setSeparator(true);
        pPageService->GetToolBarService()->Register(pSndMenuSeparatorAction);
        pPageService->GetMenuService()->Register(pSndMenuSeparatorAction, g_szMenu);

        //添加详细信息预览 Action
        QAction* pBrowseAction = new QAction(QIcon(g_szBrowsePng), g_szDetailsDot, NULL);
        pBrowseAction->setEnabled(false);
        connect(pBrowseAction, SIGNAL(triggered()), this, SLOT(slotBrowseWorkflow()));
        pPageService->GetToolBarService()->Register(pBrowseAction);
        pPageService->GetMenuService()->Register(pBrowseAction, g_szMenu);

        //添加Submit Action
        PaiAction* pSubmitAction = new PaiAction(QIcon(g_szSubmitPng), g_szSubmit, NULL);
        connect(pSubmitAction, SIGNAL(triggered()), &m_control, SLOT(slotPreSubmitWorkflow()));
        pSubmitAction->setEnabled(false);
        pSubmitAction->SetPermission(pai::gui::PaiAction::UPDATE);
        pPageService->GetToolBarService()->Register(pSubmitAction);
        pPageService->GetMenuService()->Register(pSubmitAction, g_szMenu);

        //添加尝试运行 Action
        QAction* pTryRunAction = new QAction(QIcon(g_szWValidataPng), g_szTryRunDot, NULL);
        pTryRunAction->setEnabled(false);
        pPageService->GetToolBarService()->Register(pTryRunAction);
        pPageService->GetMenuService()->Register(pTryRunAction, g_szMenu);

        //添加对比 Action
        QAction* pCompareAction = new QAction(QIcon(g_szComparePng), g_szCompare, NULL);
        pCompareAction->setEnabled(false);
        pPageService->GetToolBarService()->Register(pCompareAction);
        pPageService->GetMenuService()->Register(pCompareAction, g_szMenu);

        //添加分割符
        QAction* pFourthMenuSeparatorAction = new QAction("", NULL);
        pFourthMenuSeparatorAction->setSeparator(true);
        pPageService->GetToolBarService()->Register(pFourthMenuSeparatorAction);
        pPageService->GetMenuService()->Register(pFourthMenuSeparatorAction, g_szMenu);

        //添加弹簧
        pPageService->GetToolBarService()->AddSpacer();

        //添加打印 Action
        QAction* pPrintAction = new QAction(QIcon(g_szPrintPng), g_szPrint, NULL);
        pPrintAction->setEnabled(false);
        connect(pPrintAction, SIGNAL(triggered()), &m_control, SLOT(slotSaveWorkflowAsImageFile()));
        pPageService->GetToolBarService()->Register(pPrintAction);
        pPageService->GetMenuService()->Register(pPrintAction, g_szMenu);

        //添加分割符
        QAction* pThirdMenuSeparatorAction = new QAction("", NULL);
        pThirdMenuSeparatorAction->setSeparator(true);
        pPageService->GetToolBarService()->Register(pThirdMenuSeparatorAction);
        pPageService->GetMenuService()->Register(pThirdMenuSeparatorAction, g_szMenu);

        //把ParameterEditor树添加到B1区
        m_pParameterEditor = new CParameterEditor(NULL);
        pPageService->Register(new ViewExtension(m_pParameterEditor, g_szParameters, "", "", false), g_szB1);

        //把ModuleToolBarView添加到B1区
        CPaiModuleToolBarView* moduleToolBar = new CPaiModuleToolBarView(NULL);
        pPageService->Register(new ViewExtension(moduleToolBar, g_szModules, "", "", false), g_szB1);
        connect(moduleToolBar->GetModuleTree(),SIGNAL(itemClicked(QTreeWidgetItem * , int )),this,SLOT(slotShowHelpDoc(QTreeWidgetItem * , int)));

        //把WorkflowTemplateTree树添加到B1区
        CPaiWorkflowTemplateTree *pTemplateTree = new CPaiWorkflowTemplateTree(QUuid());
        pPageService->Register(new ViewExtension(pTemplateTree, g_szTemplates, "", "", false), g_szB1);
        m_control.SetActiveTemplate(pTemplateTree);
        connect(pTemplateTree, SIGNAL(itemEdit(QList< pai::objectmodel::PaiObject* > )), this,
                SLOT(slotShowTemplate(QList< pai::objectmodel::PaiObject* > )));
        connect(pTemplateTree, SIGNAL(itemDelete(QList< pai::objectmodel::PaiObject* > )), this,
                SLOT(slotDeleteTemplate(QList< pai::objectmodel::PaiObject* > )));
        connect(pTemplateTree, SIGNAL(importTemplates(ImportType)), &m_control, SLOT(slotImportWorkflows(ImportType)));
        connect(pTemplateTree, SIGNAL(exportTemplates(ImportType)), &m_control, SLOT(slotExportWorkflows(ImportType)));

        //向B2区添加tab
        PaiTextEdit* pLblDataRelation = new PaiTextEdit(g_szDataInfoDot, NULL);
        pPageService->Register(new ViewExtension(pLblDataRelation, g_szDataRelation, "", "", false), g_szB2);
        pLblDataRelation->setReadOnly(true);

        //向B2区添加tab
        PaiWebViewWidget *pWebviewWidget = new PaiWebViewWidget(NULL);
        QWebPage* pWebInfo = new QWebPage(pWebviewWidget->GetWebView());
        pWebviewWidget->setPage(pWebInfo);
        pWebInfo->mainFrame()->setHtml(tr(g_szSelectModule));
        pPageService->Register(new ViewExtension(pWebviewWidget, g_szInfo, "", "", false), g_szB2);

        connect(pPageService,SIGNAL(AreaActiveViewChanged(const QString&, const std::string&)),
                this, SLOT(slotActiveAreaTabPage(const QString&,const std::string&)));

        connect(m_pParameterEditor,SIGNAL(clicked(const QModelIndex &)),this,SLOT(slotShowDescription(const QModelIndex&)));
        pPageService->RegisterViewsMenu();

        //添加workflowhHelp
        QAction* pWorkflowHelpAction = new QAction("Help", NULL);
        connect(pWorkflowHelpAction,SIGNAL(triggered()),this,SLOT(OpenWorkflowHelp()));
        pPageService->GetMenuService()->Register(pWorkflowHelpAction, g_szMenu);

        // 为了美观，向B区下边缘添加一个空白让B2的底边提高一点使其与工作流的工作区域平齐
        pPageService->AddPagePlaceHolder(g_szB, 0, 0, 0, 22);

        return true;
    }
    catch(pai::error::generic_error & e)
    {
        pai::gui::PaiMessageBox::Critical(NULL, PAI_NAME,
                                          QString(g_szOpenView).append(e.what()));
        pai::log::Info(_FLF(g_szOpenView + e.what()));
        GetConsoleGUIService()->GetViewTabService()->Unregister(GetID().toString().toStdString());
        return false;
    }
}

bool CPaiWorkflowPlugin::_ShowWorkflow(PaiWorkflowDataModel* pWorkflowObject)
{
    try
    {
        PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetID());
        if(pPageService != NULL)
        {
            ViewExtension *pViewExtension =
                dynamic_cast< ViewExtension* > (pPageService->GetExtension(pWorkflowObject->GetID().toString().toStdString()));

            if(pViewExtension == NULL)
            {
                WorkflowWidget* pWorkflowView = new WorkflowWidget(pWorkflowObject);
                WorkflowSceneManager *pWorkflowScene = new WorkflowSceneManager(0,0,800,750);
                pWorkflowView->SetScene(pWorkflowScene);
                pWorkflowScene->SetSubToolBarName(pWorkflowView->GetID() + g_szStyleToolBarName);

                CWorkflowToolBarView* pWorkflowTool = new CWorkflowToolBarView(pWorkflowView, GetID());
                pWorkflowScene->SetParameterEditor(m_pParameterEditor);

                //处理数据树上添加或者删除地震数据时，对工作流的影响
                // connect(&pai::objectmodel::PaiObject::m_EventAgent,
                //         SIGNAL(ObjectRemoveChild(pai::objectmodel::PaiObject* ,pai::objectmodel::PaiObject* )), pWorkflowScene,
                //         SLOT(slotOnObjectRemoveChild(pai::objectmodel::PaiObject* ,pai::objectmodel::PaiObject* )));

                connect(&pai::objectmodel::PaiObject::m_EventAgent,
                        SIGNAL(ObjectAddChildren(pai::objectmodel::PaiObject* ,QList<pai::objectmodel::PaiObject*>&)), pWorkflowScene,
                        SLOT(slotOnObjectAddChildren(pai::objectmodel::PaiObject* ,QList<pai::objectmodel::PaiObject*>&)));

                connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent, SIGNAL(signalClick(CModuleInformation*, bool)),
                        m_pParameterEditor, SLOT(slotOpen(CModuleInformation*, bool)));

				disconnect(pWorkflowView->GetScene(), SIGNAL(signalOpenModuleParam(CModuleInformation*)),
					m_pParameterEditor, SLOT(slotForceOpen(CModuleInformation*)));
                connect(pWorkflowView->GetScene(), SIGNAL(signalOpenModuleParam(CModuleInformation*)),
                        m_pParameterEditor, SLOT(slotForceOpen(CModuleInformation*)));

                connect(pWorkflowView->GetScene(), SIGNAL(doubleClickModule(CModuleInformation* ,bool)), m_pParameterEditor,
                        SLOT(slotOpen(CModuleInformation*, bool)));

                connect(pWorkflowView->GetScene(), SIGNAL(doubleClickModule(CModuleInformation*, bool)), &m_control,
                        SLOT( slotActivateParameterEditor(CModuleInformation*, bool)));

                connect(pWorkflowView->GetScene(), SIGNAL(signalSelectModule(CModuleInformation*)),
                        this, SLOT(slotShowHelpDocForSceneSelect(CModuleInformation*)));

                connect(pWorkflowView->GetScene(), SIGNAL(signalSelectModule(CModuleInformation*)),
                        &m_control, SLOT(slotActivateModuleTree(CModuleInformation*)));

                connect(&pai::graphics2d::ModuleGraphicsItem::m_EventAgent, SIGNAL(signalClick(CModuleInformation*, bool)),
                        &m_control, SLOT(slotActivateModuleTree(CModuleInformation*, bool)));//当当前模块为空时将B1区切换到模块树为当前激活页签

                connect(m_pParameterEditor->model(),
                        SIGNAL(signalErrorInfoChanged(CModuleInformation *,bool,const pai::module::CModuleCheckResult, ValidateEventSource)),
                        pWorkflowView->GetScene(),
                        SLOT(slotOnModuleParameterError(CModuleInformation*,bool ,const pai::module::CModuleCheckResult, ValidateEventSource)));

                //该链接用来当用户修改参数编辑面版的参数后，通知工作流对象的状态为已修改，属于暂时的做法
                connect(m_pParameterEditor->itemDelegate(), SIGNAL(commitData(QWidget*)), pWorkflowView->GetScene(), SLOT(slotOnModuleParamDataChanged()));

                ViewExtension *pModuleViewExtension =
                                dynamic_cast< ViewExtension* > (pPageService->GetExtension(QString(tr(g_szModules)).toStdString()));
                CPaiModuleToolBarView* moduleToolBar =
                        dynamic_cast< CPaiModuleToolBarView* > (pModuleViewExtension->GetView());

                connect(moduleToolBar->GetModuleTree(),SIGNAL(DeliverModule(const QString&)),pWorkflowView->GetScene(),SLOT(slotAddModule(const QString&)));
                connect(m_control.GetTemplateTree(),SIGNAL(itemDoubleClicked(pai::objectmodel::PaiObject*)),pWorkflowView->GetScene(),SLOT(slotApplyTemplate(pai::objectmodel::PaiObject*)));
                // connect the module selected signal for module tree menu sensitive
                connect(pWorkflowView->GetScene(),SIGNAL(moduleSelectedSignal(bool)), moduleToolBar->GetModuleTree() ,SLOT(moduleSelectedSlot(bool)) );

                // connect the module selected signal for module tree menu sensitive
                connect( moduleToolBar->GetModuleTree() ,SIGNAL(menuClicked(const QString&,const QString&)),
                        pWorkflowView->GetScene() ,SLOT(slotOnModuleMenuClick(const QString& ,const QString&)) );
                connect(pWorkflowView->GetScene(), SIGNAL(signalSelectModule(CModuleInformation*)),
                        moduleToolBar->GetModuleTree(), SLOT(slotSelectModule(CModuleInformation*)));

                pViewExtension = new ViewExtension(pWorkflowTool, pWorkflowObject->GetName(), "",
                                                   pWorkflowObject->GetID().toString().toStdString());
                pViewExtension->SetSubtilte(pWorkflowObject->GetFullPathName());

                pPageService->Register(pViewExtension, g_szA, true);
                pPageService->SetSubtilte(pWorkflowObject->GetFullPathName());

                QObject::connect(pPageService, SIGNAL(AreaBecameEmpty(QString)), &m_control,
                                 SLOT(slotCloseWorkflowPlugin(QString)), Qt::UniqueConnection); //syr

                //当用户点击下方的关闭按钮时，提示用户保存
                QObject::connect(pViewExtension, SIGNAL(ViewWillBeClosed(const QString&)),
                        &m_control, SLOT(slotCloseWorkflowWidget(const QString&)), Qt::UniqueConnection);
                connect(pViewExtension, SIGNAL(CurrentTabChanged(const QString&)), &m_control, SLOT(slotOnActiveCurrentWorkflow(const QString&)), Qt::UniqueConnection);

                //第一次打开工作流插件时，设置活动的workflowWidget，其它情况下活动workflowWidget设置在切换页签时做
                QTabWidget* pTabWidget = dynamic_cast<QTabWidget*> (pPageService->GetWidgetView(g_szA));
                if( pTabWidget && pTabWidget->count() == 1)
                {
                    SaveHelper::SetActiveWorkflowView(pWorkflowView);
                }

                m_control.GetUndoGroup()->addStack(pWorkflowScene->GetUndoStack());

                connect(&pai::objectmodel::PaiObject::m_EventAgent, SIGNAL(ObjectRefreshed(pai::objectmodel::PaiObject*)),
                        &m_control, SLOT(slotOnWorkflowRefreshed(pai::objectmodel::PaiObject*)));
            }
            QTabWidget* pTabWidget = dynamic_cast<QTabWidget*> (pPageService->GetWidgetView(g_szA));

            if (pTabWidget != NULL)
            {
                pTabWidget->setCurrentWidget(dynamic_cast<QWidget*> (pViewExtension->GetView()));
            }

            if(pTabWidget!=NULL && pTabWidget->count()==1)
            {
                //QApplication::processEvent及PageService的UpdateLayout方法不再在这里调用，因为PageService里的WorkspaceSplitter已经handle了这部分功能
                //将当前窗口设置为活动窗口，用于接收键盘事件
                QWidget *w = dynamic_cast<QWidget*> (pViewExtension->GetView());
                w->activateWindow(); //将当前窗口设置为活动窗口，用于接收键盘事件

                //为前一个WorkflowWidget保存B类页选择的ExtensionID, 必须在设置新的工作流数据模型之前调用
                m_control.HandleCurrentWorkEnvironment(HandleEnvironment_BeforeUnselect);

                m_control.HandleCurrentWorkEnvironment(HandleEnvironment_AfterSelect);
            }
            //使得模块树激活
            pPageService->ActiveView(g_szModules);
            return true;
        }
    }
    catch(pai::error::generic_error & e)
    {
        pai::gui::PaiMessageBox::Critical(NULL, PAI_NAME, QString(g_szShowWorkflow).append(e.what()));
        pai::log::Info(_FLF(g_szShowWorkflow + e.what()));
        GetConsoleGUIService()->GetViewTabService()->Unregister(GetID().toString().toStdString());
    }
    return false;
}

QList< QUuid > CPaiWorkflowPlugin::GetSupportedTypeIDs() const
{
    QList < QUuid > lstTypeIDs;
    lstTypeIDs << QUuid(PaiWorkflowDataModel::GetTypeIDString());
    lstTypeIDs << QUuid();  //设定一个Null值的QUuid作为分隔符，分割符之前的支持显示，分割符之后的用来支持其他业务。
    lstTypeIDs << QUuid(PaiSurvey::GetTypeIDString());
    lstTypeIDs << QUuid(PaiWorkflowMaster::GetTypeIDString());  //暂时支持下WorkflowMaster,因为目前阶段和步骤都没做，工作流暂时挂到WorkflowMaster下
    return lstTypeIDs;
}

bool CPaiWorkflowPlugin::Handle(QList< pai::objectmodel::PaiObject* > & contextObjs, QList<pai::gui::PaiAction*> & actions)
{
    //双击工区或右键单击工区注册new workflow Action
    if(contextObjs.count() == 1)
    {
        //获取对象的SurveyID和对象类型
        long long SurveyID = contextObjs.first()->GetDBID();
        QUuid typeID = contextObjs.first()->GetTypeID();

        if (typeID == QUuid(PaiSurvey::GetTypeIDString()))
        {
            PaiAction* pNewWorkflowAction = new PaiAction(QIcon(":/f_new_workflow.png"), tr(g_szNewWorkflowDot), this);
            pNewWorkflowAction->SetActionFlags(pNewWorkflowAction->GetFlags() | PaiAction::TreeFloatingAct);
            pNewWorkflowAction->SetPermissions(pai::gui::PaiAction::UPDATE);
            pNewWorkflowAction->setData(QVariant(SurveyID));
            connect(pNewWorkflowAction, SIGNAL(triggered()), &m_control, SLOT(slotNewWorkflow()));

            actions.append(pNewWorkflowAction);
            return true;
        }
    }

    QList< PaiAction* > lstAppendedActions;
    if(m_control.BuildTreeMenuActionsForObject(contextObjs, lstAppendedActions))
    {
        actions.append(lstAppendedActions);
        return true;
    }

    return false;
}

void CPaiWorkflowPlugin::slotShowDescription(const QModelIndex & index)
{
    ParameterProperty* param = static_cast< ParameterProperty* > (index.internalPointer());
    if(param != NULL && param->IsParameterItem())
    {
        QWebPage* pWebInfo = GetWebHelpInfo();
        if(pWebInfo != NULL)
        {
            pWebInfo->mainFrame()->setHtml(QString::fromStdString(param->GetParamItem()->GetDescription()));
        }
    }
    else    //如果没有选择ModelIndex,则清空Info信息显示
    {
        QWebPage* pTempWebInfo = GetWebHelpInfo();
        if(pTempWebInfo != NULL)
        {
            pTempWebInfo->mainFrame()->setHtml(QString::fromStdString(""));
        }
    }
}

void CPaiWorkflowPlugin::slotShowHelpDoc(QTreeWidgetItem * item, int /*column*/)
{
    QString Helpdoc = item->data(0, pai::gui::HintRole).toString();
    ShowHelpDoc(Helpdoc.toStdString());
}

void CPaiWorkflowPlugin::slotShowTemplate(QList< pai::objectmodel::PaiObject* > objectList)
{
    if(objectList.isEmpty())
    {
        return;
    }
    foreach(PaiObject* pObject, objectList)
    {
        PaiWorkflowDataModel* pWorkflow = dynamic_cast<PaiWorkflowDataModel*>(pObject);
        pWorkflow->SetEventEnabled(true);

        if (_ShowWorkflow(pWorkflow) == false)
        {
            return;
        }

        if (m_pParameterEditor)
        {
            ParameterEditorModel* editorModel = dynamic_cast<ParameterEditorModel *> (m_pParameterEditor->model());
            if (editorModel && GetActiveWorkflow())
            {
                editorModel->SetCurrentWorkflowID(QUuid(GetActiveWorkflow()->GetID()));
            }
        }
        Active(pObject);
    }
}

void CPaiWorkflowPlugin::slotDeleteTemplate(QList< pai::objectmodel::PaiObject* > objectList)
{
    PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(m_control.GetViewID());
    foreach(PaiObject* pObj, objectList)
    {
        pai::objectmodel::PaiWorkflowDataModel* pWorkflow = dynamic_cast<pai::objectmodel::PaiWorkflowDataModel*>(pObj);
        if (NULL == pWorkflow)
        {
            continue;
        }

        std::string strWorkflowID = pWorkflow->GetID().toString().toStdString();
        ViewExtension* pViewExtension = dynamic_cast<ViewExtension*> (pPageService->GetExtension(strWorkflowID)); //找到要重设工作流模型的Extension
        if (pViewExtension)
        {
            pPageService->Unregister(strWorkflowID);
        }
    }
}

void CPaiWorkflowPlugin::slotShowHelpDocForSceneSelect(pai::workflow::CModuleInformation* pModuleInformation)
{
    if(NULL != pModuleInformation && (!pModuleInformation->IsBlankModule()))
    {
        pai::module::CModule *pModule = pModuleInformation->GetModule();
        if(NULL != pModule)
        {
            ShowHelpDoc(pModule->GetMetaData()->GetHelpDoc());
        }
    }
    else
    {
        PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetID());
        if(pPageService != NULL)
        {
            QWidget *pActiveWidget = pPageService->GetCurrentView(g_szB1);
            if(pActiveWidget != NULL)
            {
                QString strExtensionID = pActiveWidget->property(g_szExtensionID).toString();
                slotActiveAreaTabPage(g_szB1, strExtensionID.toStdString());
            }
        }
    }
}

QWebPage* CPaiWorkflowPlugin::GetWebHelpInfo()
{
    PageService* pPageService = GetConsoleGUIService()->GetViewTabService()->GetPageService(GetID());
    if(pPageService != NULL)
    {
        ViewExtension* pViewExtension = dynamic_cast< ViewExtension* > (pPageService->GetExtension(g_szInfo));
        if(pViewExtension != NULL)
        {
            PaiWebViewWidget* pWebViewWidget = dynamic_cast< PaiWebViewWidget* > (pViewExtension->GetView());
            if(pWebViewWidget != NULL)
            {
                return pWebViewWidget->GetWebView()->page();
            }
        }
    }

    return NULL;
}

void CPaiWorkflowPlugin::ShowHelpDoc(std::string strHelp)
{
    QString strHelpDoc = QString::fromStdString(pai::utils::CUtils::GetPaiHome()) + "/doc/"
            + QString::fromStdString(strHelp);

    QFile doc(strHelpDoc);
    doc.open(QIODevice::ReadOnly);
    QTextStream out(&doc);

    QFileInfo fileInfo(strHelpDoc);

    QWebPage* pWebInfo = GetWebHelpInfo();
    if(pWebInfo != NULL)
    {
        pWebInfo->mainFrame()->setHtml(out.readAll(), QUrl::fromLocalFile(fileInfo.absolutePath() + "/"));
    }

    doc.close();
}

void CPaiWorkflowPlugin::slotBrowseWorkflow()
{
    if(m_control.GetActiveWorkflowView())
    {
        BrowseWorkflowCmd browseWorkflowCmd(m_control.GetActiveWorkflowView());
        browseWorkflowCmd.redo();
    }
}

Q_EXPORT_PLUGIN2(WorkflowView, pai::CPaiWorkflowPlugin)