/**
 * @file ModuleGraphicsItem.cpp
 * @brief 模块图元的绘制类
 * @date 2011-08-17
 */
#include <QPainter>
#include <QGradient>
#include <QPalette>
#include <QtDebug>
#include <QApplication>
#include <QGraphicsScene>
#include <QGraphicsSceneMouseEvent>
#include <QDebug>
#include <QGraphicsView>
#include <QObject>
#include <QGraphicsProxyWidget>
#include <QCompleter>
#include <QAbstractItemView>
#include <QStringListModel>

#include "PaiWorkflowDataModel.h"
#include "ModuleGraphicsItem.h"
#include "ModuleInformation.h"
#include "Module.h"
#include "PaiModuleStyle.h"
#include "ModuleToolBarGraphicsItem.h"
#include "PaiDropEventAnalyser.h"
#include "PaiObject.h"
#include "PaiSeisData.h"
#include "PaiSurvey.h"
#include "PaiJobParameterItem.h"
#include "GeneralWorkflowScene.h"
#include "PaiClearLineEdit.h"
#include "ModuleConnectGraphicsItem.h"
#include "PaiGrid.h"
#include "PaiGeometry.h"
#include "PaiStatics.h"
#include "PaiVelModel.h"
#include "PaiVelPairs.h"
#include "ModuleParameterUtil.h"
#include "PaiBaseMaster.h"
#include "PaiDataMaster.h"
#include "PaiTraceEdit.h"
#include "PaiFirstArrival.h"
#include "PaiMute.h"
#include "PaiHorizon.h"
#include "WorkflowConst.h"
#include "PaiJobParameterItemWidget.h"
#include "ModuleMonitorGraphicsItem.h"

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

// 画连接虚线的状态
bool g_bSceneLineDrawing = false;

void SetSceneLineDrawing(bool drawing)
{
    g_bSceneLineDrawing = drawing;
}
bool GetSceneLineDrawing()
{
    return g_bSceneLineDrawing;
}

////////////////////////////////////////////////////////////////////////////////////////////
pai::graphics2d::ModuleGraphicsItemEventAgent ModuleGraphicsItem::m_EventAgent;

void ModuleGraphicsItemEventAgent::ModulePortSelectionChanged(pai::graphics2d::ModuleGraphicsItem *pItem,
                                                              bool selected)
{
    emit PortSelectionChanged(pItem, selected);
}

void ModuleGraphicsItemEventAgent::ItemNeedCenterOn(pai::graphics2d::ModuleGraphicsItem *pItem)
{
    emit ModuleCenterOn(pItem);
}

void ModuleGraphicsItemEventAgent::ItemNeedBeDelete(pai::graphics2d::GeneralWorkflowScene *pScene,
                                                    pai::graphics2d::ModuleGraphicsItem *pItem)
{
    emit DeleteModule(pScene, pItem);
}

void ModuleGraphicsItemEventAgent::DoubleClickModule(CModuleInformation *pInfo, bool readOnly)
{
    emit DoubleClick(pInfo, readOnly);
}

void ModuleGraphicsItemEventAgent::ClickModule(CModuleInformation *pModule, bool readOnly)
{
    emit ModuleClicked(pModule, readOnly);
}

void ModuleGraphicsItemEventAgent::ClickSelectedModule(CModuleInformation *pModule)
{
    emit ClickSelectedItem(pModule);
}

void ModuleGraphicsItemEventAgent::ItemSetEnabled(pai::graphics2d::ModuleGraphicsItem *pItem , bool enabled)
{
    emit SetEnalbed(pItem, enabled);
}

void ModuleGraphicsItemEventAgent::ItemSetName(pai::graphics2d::ModuleGraphicsItem *pItem)
{
    emit SetName(pItem);
}

void ModuleGraphicsItemEventAgent::UpdataModule(pai::graphics2d::ModuleGraphicsItem *pItem)
{
    emit UpdateItem(pItem);
}

void ModuleGraphicsItemEventAgent::ModulePortHoveringChanged(pai::graphics2d::ModuleGraphicsItem *pItem,
                                                             bool hovering)
{
    emit PortHoveringChanged(pItem, hovering);
}

void ModuleGraphicsItemEventAgent::SetMonitoring(pai::graphics2d::ModuleGraphicsItem *pItem, bool monitor)
{
    emit SetModuleMonitoring(pItem,monitor);
}

void ModuleGraphicsItemEventAgent::ShowColorEditor(pai::graphics2d::ModuleMonitorGraphicsItem *pMonitor)
{
    emit ShowMonitorColorEditor(pMonitor);
}

void ModuleGraphicsItemEventAgent::UpdateMonitorColor(const QString& color)
{
    emit ChangeMonitorColor(color);
}

////////////////////////////////////////////////////////////////////////////////////////
ModuleGraphicsItem::ModuleGraphicsItem(CModuleInformation *pModule,
                                       pai::graphics2d::PaiModuleStyle *pStyle,
                                       bool job,
                                       QGraphicsItem *pParent) :
    QGraphicsItem(pParent),
    m_pModule(NULL),
    m_pStyle(pStyle),
    m_pToolBarItem(NULL),
    m_pMonitorItem(NULL),
    m_size(pStyle->GetSize()),
    m_OnMoving(false),
    m_OnHovering(false),
    m_InitialValidated(false),
    m_monitoring(false),
    m_job(job),
    m_pCJobParameterItem(NULL),
    m_JobType(false)
{
    if(!m_job)
    {
        setFlag(QGraphicsItem::ItemIsMovable, true);
        setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
        setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
    }
    //在作业日志查看中让其模块能进行选择和获取焦点，解决模块Info信息筛选的问题。
    setFlag(QGraphicsItem::ItemIsFocusable, true);
    setFlag(QGraphicsItem::ItemIsSelectable, true);

    setAcceptDrops(true);
    setAcceptHoverEvents(true);
    SetModule(pModule);
    if (pStyle->GetPosition() != QPointF(0, 0))
    {
        setPos(pStyle->GetPosition());
    }
    
    InitModuleNameEdit();
    InitDropType();
}

ModuleGraphicsItem::ModuleGraphicsItem(QGraphicsItem *pParent) :
    QGraphicsItem(pParent),
    m_pModule(NULL),
    m_pStyle(NULL),
    m_pToolBarItem(NULL),
    m_pMonitorItem(NULL),
    m_size(200, 60),
    m_OnMoving(false),
    m_OnHovering(false),
    m_InitialValidated(false),
    m_monitoring(false),
    m_pCJobParameterItem(NULL),
    m_JobType(false)
{
    setFlag(QGraphicsItem::ItemIsSelectable, true);
    setFlag(QGraphicsItem::ItemIsMovable, true);
    setFlag(QGraphicsItem::ItemSendsScenePositionChanges, true);
    setFlag(QGraphicsItem::ItemSendsGeometryChanges, true);
    setFlag(QGraphicsItem::ItemIsFocusable, true);
    setAcceptDrops(true);
    setAcceptHoverEvents(true);
    InitModuleNameEdit();
    InitDropType();
}

ModuleGraphicsItem::~ModuleGraphicsItem()
{
    //因为清空场景时，这个widget占用内存虽然被释放了，但是指针没有置空
    if(m_pEdit)
    {
        m_pEdit = NULL;
    }
}

int ModuleGraphicsItem::type() const
{
    return Type;
}

void ModuleGraphicsItem::InitModuleNameEdit()
{
    //初始化模块名称输入框
    m_pEdit = new pai::gui::PaiClearLineEdit();
    m_pEdit->resize(180, 22);
    m_pEdit->setPlaceholderText(QString("Valid module name"));
    QGraphicsProxyWidget *pProxy = new QGraphicsProxyWidget(this);
    pProxy->setWidget(m_pEdit);
    pProxy->hide();

    //下拉框
    QCompleter *completer = new QCompleter();
    //在ModuleItem中添加widget
    QGraphicsProxyWidget *pPopupProxy = new QGraphicsProxyWidget(this);
    pPopupProxy->setWidget(completer->popup());
    completer->setCaseSensitivity(Qt::CaseInsensitive);
    m_pEdit->setCompleter(completer);

    QObject::connect(completer->popup(), SIGNAL(clicked(const QModelIndex &)),
                     m_pEdit, SIGNAL(editingFinished()), Qt::UniqueConnection);
    QObject::connect(m_pEdit, SIGNAL(editingFinished()),
                     &m_EventAgent, SIGNAL(EditingFinished()), Qt::UniqueConnection);

}
void ModuleGraphicsItem::InitDropType()
{
    m_SupportedDropType << QUuid(PaiSeisData::GetTypeIDString())
                        << QUuid(PaiGrid::GetTypeIDString())
                        << QUuid(PaiGeometry::GetTypeIDString())
                        << QUuid(PaiStatics::GetTypeIDString())
                        << QUuid(PaiVelModel::GetTypeIDString())
                        << QUuid(PaiVelPairs::GetTypeIDString())
                        << QUuid(PaiTraceEdit::GetTypeIDString())
                        << QUuid(PaiFirstArrival::GetTypeIDString())
                        << QUuid(PaiMute::GetTypeIDString())
                        << QUuid(PaiHorizon::GetTypeIDString());
}

QGraphicsView* ModuleGraphicsItem::GetView() const
{
    return scene()->views().at(0);
}

void ModuleGraphicsItem::SetStyle(pai::graphics2d::PaiModuleStyle *pStyle)
{
    m_pStyle = pStyle;
}

void ModuleGraphicsItem::SetModule(CModuleInformation *pModule)
{
	qreal dHeight = m_size.height();
    qreal dWidth = m_size.width();

    qreal dPortDiameter = 14.0;

    if(m_pStyle)
    {
        dPortDiameter = m_pStyle->GetPortDiameter();
    }

    qreal dDefaultPortPadding = dPortDiameter + 20.0;

    m_pModule = pModule;
    m_InputPorts.clear();
    m_OutputPorts.clear();

    if((pModule == NULL) || (pModule->IsBlankModule()))
    {
        return;
    }

    std::vector < Port > vecInputPorts;
    if((m_pModule->GetModule()) && (m_pModule->GetModule()->GetMetaData()))
    {
        m_pModule->GetModule()->GetMetaData()->GetInputPorts(vecInputPorts);
    }

	//////////////////////////////////////////BK改，当输入点为空时，添加新的点
	//
	if(vecInputPorts.empty())
	{
		Port rTop;
		rTop.type = PORT_INPUT;
		rTop.order=1;
		vecInputPorts.push_back(rTop);
	}
	
	//////////////////////////////

    qreal dAllPortLength = dDefaultPortPadding * (vecInputPorts.size() - 1);
    qreal dMaxPortLength = dWidth - dPortDiameter;
    qreal dPixelStep = dMaxPortLength / (vecInputPorts.size() - 1);
    if(dPixelStep > dDefaultPortPadding)
    {
        dPixelStep = dDefaultPortPadding;
    }
    qreal dPixelPortX = -dAllPortLength / 2;
    if(dPixelPortX < -dMaxPortLength / 2)
    {
        dPixelPortX = -dMaxPortLength / 2;
    }

    for(std::vector< Port >::const_iterator it = vecInputPorts.begin(); it != vecInputPorts.end(); ++it)
    {
        ModulePortGraphicsItem port(m_pStyle, QPointF(dPixelPortX, -dHeight / 2 - 1), dPortDiameter, Top);
        m_InputPorts.append(port);

        dPixelPortX += dPixelStep;
    }

    std::vector < Port > vecOutputPorts;
    if((m_pModule->GetModule()) && (m_pModule->GetModule()->GetMetaData()))
    {
        m_pModule->GetModule()->GetMetaData()->GetOutputPorts(vecOutputPorts);
    }

	///////////////改
	if(vecOutputPorts.empty())
	{
		Port rBottom;
		rBottom.type = PORT_OUTPUT;
		rBottom.order=2;

		vecOutputPorts.push_back(rBottom);
	}
	////////////////////////
    dAllPortLength = dDefaultPortPadding * (vecOutputPorts.size() - 1);

    dPixelStep = dMaxPortLength / (vecOutputPorts.size() + 1);

    if(dPixelStep > dDefaultPortPadding)
    {
        dPixelStep = dDefaultPortPadding;
    }
    dPixelPortX = -dAllPortLength / 2;
    if(dPixelPortX < -dMaxPortLength / 2)
    {
        dPixelPortX = -(dMaxPortLength) / 2;
    }

    for(std::vector< Port >::const_iterator it = vecOutputPorts.begin(); it != vecOutputPorts.end(); ++it)
    {
        ModulePortGraphicsItem port(m_pStyle, QPointF(dPixelPortX, dHeight / 2 + 1), dPortDiameter, Bottom);
        m_OutputPorts.append(port);

        dPixelPortX += dPixelStep;
    }

    update();
}

void ModuleGraphicsItem::SetDisable(bool isDisable)
{
    if(m_pStyle)
    {
        m_pStyle->SetDisableFlag(isDisable);
    }
    if (m_pModule)
    {
    	m_pModule->SetEnabled(!isDisable);
    }

}
bool ModuleGraphicsItem::IsDisable() const
{
    return m_pStyle->IsDisable();
}

void ModuleGraphicsItem::SetToolBarItem(pai::graphics2d::ModuleToolBarGraphicsItem *pToolBarItem)
{
    m_pToolBarItem = pToolBarItem;
}

CModuleInformation* ModuleGraphicsItem::GetModule() const
{
    return m_pModule;
}

pai::graphics2d::PaiModuleStyle* ModuleGraphicsItem::GetModuleStyle() const
{
    return m_pStyle;
}

pai::graphics2d::ModuleToolBarGraphicsItem* ModuleGraphicsItem::GetToolBar() const
{
    return m_pToolBarItem;
}

QRectF ModuleGraphicsItem::boundingRect() const
{
    const int nExposedPortHeight = 10;//圆圈半径7+热区3
    const int adjustValue = 2;//四个角的矩形
    qreal dWidth = m_size.width() + adjustValue;
    qreal dHeight = m_size.height();
    qreal dPenWidth = 1;
    return QRectF(-dWidth / 2 - dPenWidth / 2,
                  -dHeight / 2 - dPenWidth / 2 - nExposedPortHeight,
                  dWidth + dPenWidth,
                  dHeight + dPenWidth * 2 + nExposedPortHeight * 2);
}

void ModuleGraphicsItem::paint(QPainter *pPainter, const QStyleOptionGraphicsItem *pOption, QWidget *pWidget)
{
    const int iHighLightHeight = 14;// 高光的高度为14像素
    const qreal EPS = 1e-10;

    qreal dWidth = m_size.width();
    qreal dHeight = m_size.height();
    qreal dStop = iHighLightHeight / dHeight;

    int eStatus = pai::graphics2d::PaiModuleStyle::Normal;

    if(isSelected())// 选中的优先级最高，无论什么状态，选中的绘制都一样
    {
        eStatus |= pai::graphics2d::PaiModuleStyle::Selected;
    }

    if(m_pStyle != NULL)
    {
        if(m_pStyle->IsSaved())
        {
            eStatus |= pai::graphics2d::PaiModuleStyle::Saved;
        }

        if(m_pStyle->IsError())
        {
            eStatus |= pai::graphics2d::PaiModuleStyle::Error;
        }

        if(m_pStyle->IsWarning())
        {
            eStatus |= pai::graphics2d::PaiModuleStyle::Warning;
        }

        if(m_pStyle->IsDisable())
        {
            eStatus |= pai::graphics2d::PaiModuleStyle::Disable;
        }
    }

    QRectF rect(-dWidth / 2, -dHeight / 2, dWidth, dHeight);
    QPainterPath path;
    path.addRoundedRect(rect, 5.0, 5.0);

    QLinearGradient linearGrad(QPointF(0, -dHeight / 2), QPointF(0, dHeight / 2));
    QColor beginColor;
    QColor endColor;
    // 高光部分的渐变
    if(m_pStyle != NULL)
    {
        m_pStyle->GetHighColor(eStatus, beginColor, endColor);
    }
    linearGrad.setColorAt(0, beginColor);
    linearGrad.setColorAt(dStop, endColor);
    // 正常光部分的渐变
    if(m_pStyle != NULL)
    {
        m_pStyle->GetColor(eStatus, beginColor, endColor);
    }
    linearGrad.setColorAt(dStop + EPS, beginColor);
    linearGrad.setColorAt(1, endColor);

    // 边框
    QColor marginColor(Qt::red);
    if(m_OnHovering)
    {
        eStatus |= pai::graphics2d::PaiModuleStyle::MouseOn;
    }
    if(m_pStyle != NULL)
    {
        m_pStyle->GetMarginColor(eStatus, marginColor);
    }

    // 开始绘制
    QBrush oldBrush = pPainter->brush();
    QPen oldPen = pPainter->pen();
    QBrush brush(linearGrad);
    QPen pen(marginColor);

    pen.setWidth((isSelected() || m_OnHovering) ? 2.0 : 1.0);

    pPainter->setPen(pen);
    pPainter->setBrush(brush);

    pPainter->drawPath(path);

    // 外边框
    if(!m_OnHovering && !isSelected())
    {
        QColor marginLightColor(Qt::red);
        m_pStyle->GetMarginColor(eStatus, marginLightColor);
        rect.adjust(-1, -1, 1, 1);
        pPainter->setPen(marginLightColor);
        pPainter->drawRoundedRect(rect, 5.0, 5.0);
    }
    pPainter->setPen(oldPen);
    pPainter->setBrush(oldBrush);
    // 绘制模块错误图标
    if(m_pStyle->IsError())
    {
        QPixmap errorIcon(":/MError.png");

        int iIconWidth = errorIcon.width();

        qreal dIconPosX = static_cast< qreal > (-iIconWidth / 2);

        qreal dIconPosY = (m_size.height() / 2 -
                           pPainter->fontMetrics().height() / 2) / 2 -
                           m_size.height() / 2 -
                           iIconWidth / 2;

        pPainter->drawPixmap(QPointF(dIconPosX, dIconPosY), errorIcon);
    }
    // 绘制模块名字
    QFont oldFont = pPainter->font();
    QFont newFont = QApplication::font();
    if(m_pStyle->IsWarning())
    {
        QRectF rectBelowPort; // to avoid the fonts being covered by the port.
        rectBelowPort.setRect(rect.x(), rect.y() + 7, rect.width(), rect.height() - 7);
        pPainter->setPen(Qt::red);
        newFont.setPixelSize(11);
        pPainter->setFont(newFont);
        pPainter->drawText(rectBelowPort, Qt::AlignTop | Qt::AlignHCenter, "Parameters incomplete!");
    }

    pPainter->setPen(Qt::black);
    pPainter->setFont(oldFont);
    if((m_pModule != NULL) &&
        (!m_pModule->IsBlankModule()) &&
        m_pModule->GetModule() &&
        m_pModule->GetModule()->GetMetaData())
    {
        pPainter->drawText(boundingRect(),
                           Qt::AlignCenter,
                           QString::fromStdString(m_pModule->GetModule()->GetMetaData()->GetName()));
    }

    // 绘制端口
    QList< ModulePortGraphicsItem >::iterator it;
    for(it = m_InputPorts.begin(); it != m_InputPorts.end(); ++it)
    {
        (*it).paint(pPainter, pOption, pWidget);
    }
    for(it = m_OutputPorts.begin(); it != m_OutputPorts.end(); ++it)
    {
        (*it).paint(pPainter, pOption, pWidget);
    }

    // 画选中的模块的四个角
    if(isSelected())
    {
        //获得四个角的矩形区域
        int adjustValue = 8 / 2;
        QColor fillColor("#00A8FF");
        QBrush fillBrush(fillColor);
        QRectF leftTop(-dWidth / 2, -dHeight / 2, 0, 0);
        leftTop.adjust(-adjustValue, -adjustValue, adjustValue, adjustValue);

        QRectF rightTop(dWidth / 2, -dHeight / 2, 0, 0);
        rightTop.adjust(-adjustValue, -adjustValue, adjustValue, adjustValue);

        QRectF leftBottom(-dWidth / 2, dHeight / 2, 0, 0);
        leftBottom.adjust(-adjustValue, -adjustValue, adjustValue, adjustValue);

        QRectF rightBottom(dWidth / 2, dHeight / 2, 0, 0);
        rightBottom.adjust(-adjustValue, -adjustValue, adjustValue, adjustValue);

        pPainter->fillRect(leftTop, fillBrush);
        pPainter->fillRect(rightTop, fillBrush);
        pPainter->fillRect(leftBottom, fillBrush);
        pPainter->fillRect(rightBottom, fillBrush);
    }
    //画完了ModuleItem以后调整m_pEdit位置,只有显示时才执行
    if(!m_pEdit->isHidden())
    {
        m_pEdit->move(rect.center().toPoint() - m_pEdit->graphicsProxyWidget()->rect().center().toPoint());
        m_pEdit->completer()->popup()->move(QPoint(-90, 11));
    }
}

QPointF ModuleGraphicsItem::GetPortPostion(PortDirection portDirection, int portIndex) const
{
    if(portDirection == Top)
    {
        if((portIndex < 0) || (portIndex >= m_InputPorts.size()))
        {
            return QPointF();
        }
        return pos() + m_InputPorts.at(portIndex).m_center;
    }
    else
    {
        if((portIndex < 0) || (portIndex >= m_OutputPorts.size()))
        {
            return QPointF();
        }
        return pos() + m_OutputPorts.at(portIndex).m_center;
    }
}
QRectF ModuleGraphicsItem::GetPortBoundingRect(PortDirection portDirection,int portIndex) const
{
    if(portDirection == Top)
    {
        if((portIndex < 0) || (portIndex >= m_InputPorts.size()))
        {
            return QRectF();
        }
        return m_InputPorts.at(portIndex).boundingRect();
    }
    else
    {
        if((portIndex < 0) || (portIndex >= m_OutputPorts.size()))
        {
            return QRectF();
        }
        return m_OutputPorts.at(portIndex).boundingRect();
    }
}

QSizeF ModuleGraphicsItem::GetSize() const
{
    return m_size;
}

void ModuleGraphicsItem::GetHoveringPort(PortDirection& portDirection, int& portIndex)
{
    QList<ModulePortGraphicsItem>::iterator it;

    int i = 0;
    for(it = m_InputPorts.begin(); it != m_InputPorts.end(); ++it)
    {

        if(it->m_OnHovering)
        {
            portDirection = Top;
            portIndex = i;
            return;
        }
        ++i;
    }
    i = 0;
    for(it = m_OutputPorts.begin(); it != m_OutputPorts.end(); ++it)
    {
        if(it->m_OnHovering)
        {
            portDirection = Bottom;
            portIndex = i;
            return;
        }
        ++i;
    }
    portIndex = -1;
}

void ModuleGraphicsItem::GetSelectedPort(PortDirection& portDirection, int& portIndex)
{
    QList<ModulePortGraphicsItem>::iterator it;

    int i = 0;
    for(it = m_InputPorts.begin(); it != m_InputPorts.end(); ++it)
    {

        if(it->m_selected)
        {
            portDirection = Top;
            portIndex = i;
            return;
        }
        ++i;
    }
    i = 0;
    for(it = m_OutputPorts.begin(); it != m_OutputPorts.end(); ++it)
    {
        if(it->m_selected)
        {
            portDirection = Bottom;
            portIndex = i;
            return;
        }
        ++i;
    }
    portIndex = -1;
}
bool ModuleGraphicsItem::HasPortSelected() const
{
    QList< ModulePortGraphicsItem >::const_iterator it;
    for(it = m_InputPorts.begin(); it != m_InputPorts.end(); ++it)
    {

        if(it->m_selected)
        {
            return true;
        }
    }

    for(it = m_OutputPorts.begin(); it != m_OutputPorts.end(); ++it)
    {
        if(it->m_selected)
        {
            return true;
        }
    }
    return false;
}
void ModuleGraphicsItem::CancelPortSelect()
{
    QList< ModulePortGraphicsItem >::iterator it;
    for(it = m_InputPorts.begin(); it != m_InputPorts.end(); ++it)
    {

        if(it->m_selected)
        {
            it->m_selected = false;
            return;
        }
    }

    for(it = m_OutputPorts.begin(); it != m_OutputPorts.end(); ++it)
    {
        if(it->m_selected)
        {
            it->m_selected = false;
            return;
        }
    }
}

void ModuleGraphicsItem::SetWorkflow(pai::objectmodel::PaiWorkflowDataModel *pWorkflow)
{
	m_pWorkflow = pWorkflow;
}

void ModuleGraphicsItem::SetJobType(bool jobType)
{
    m_JobType = jobType;
}

void ModuleGraphicsItem::UpdateView()
{
    if(this->scene() != NULL)
    {
        if(this->scene()->views().count() > 0)
        {
            this->scene()->views().at(0)->update();
        }
    }
}

void ModuleGraphicsItem::hoverEnterEvent(QGraphicsSceneHoverEvent *pEvent)
{
    m_OnHovering = true;
    if(m_pToolBarItem)
    {
        int nCenterWidth = boundingRect().width() / 2 + 2 + m_pToolBarItem->boundingRect().width() / 2;
        m_pToolBarItem->SetOpacityEffect(true);
        m_pToolBarItem->setPos(pos() + QPointF(nCenterWidth, 0.0));
        m_pToolBarItem->AttachModuleItem(this);
        m_pToolBarItem->SetToolBarVisible(true);
    }
    QGraphicsItem::hoverEnterEvent(pEvent);

    if(m_job)
    {
        if(m_JobType)
        {
            if(m_pCJobParameterItem == NULL)
            {
                m_pCJobParameterItem = new pai::gui::PaiJobParameterItem(this);
            }

            GeneralWorkflowScene *pScene = (GeneralWorkflowScene *) this->scene();
            if(pScene != NULL)
            {
                m_pCJobParameterItem->GetWidget()->SetParamEditInfo(m_pWorkflow->GetHtmlModuleInfo(m_pModule->GetModule()));
                //必须使用m_pCJobParameterItem->GetWidget()而不是m_pCJobParameterItem来设置是否显示，因为defect28520
                m_pCJobParameterItem->GetWidget()->show();
                QPointF point = m_pCJobParameterItem->mapToParent(0, 0);
                m_pCJobParameterItem->setPos(point);
            }
            //让模块信息展示框处于最顶层
            setZValue(2);
        }
        else
        {
            //使流转信息处于顶层
            setZValue(1);
        }
    }

    setToolTip(m_error);
}
void ModuleGraphicsItem::SetPortToolTip(bool isInput, unsigned int index)
{
    std::vector < Port > vecPorts;
    if(isInput == true)
    {
        m_pModule->GetModule()->GetMetaData()->GetInputPorts(vecPorts);
    }
    else
    {
        m_pModule->GetModule()->GetMetaData()->GetOutputPorts(vecPorts);
    }

    if(vecPorts.size() > index)
    {
        Port port = vecPorts.at(index);
        //port order + 1 to assure port order tip shows 1,2,3,4
        QString tip = "Order:" + QString::number(port.order + 1) + "\n" +
                      "PortType:" + QString(port.type == PORT_INPUT ? "input" : "output") + "\n" +
                      "Connected Module Type:" + QString::fromStdString(port.connectedModuleType) + "\n" +
                      "Name:" + QString::fromStdString(port.name) + "\n" +
                      "Optional:" + QString(port.optional ? "true" : "false");
        setToolTip(tip);
    }
}
void ModuleGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *pEvent)
{
    QList< ModulePortGraphicsItem >::iterator it;
    bool bFindEnter = false;
    bool bFindLeave = false;

    unsigned int indexOfPort = 0;
    for(it = m_InputPorts.begin(); it != m_InputPorts.end(); ++it)
    {
        if(it->boundingRect().contains(pEvent->pos()))
        {
            it->hoverEnterEvent(pEvent);
            if(g_bSceneLineDrawing)
            {
                m_EventAgent.ModulePortHoveringChanged(this, true);
            }

            update(it->boundingRect());
            bFindEnter = true;
        }
        else
        {
            if(it->m_OnHovering)
            {
                it->hoverLeaveEvent(pEvent);
                update(it->boundingRect());
                bFindLeave = true;
            }
        }
        ++indexOfPort;
    }

    indexOfPort = 0;
    if(!bFindEnter || !bFindLeave)
    {
        for(it = m_OutputPorts.begin(); it != m_OutputPorts.end(); ++it)
        {
            if(it->boundingRect().contains(pEvent->pos()))
            {
                it->hoverEnterEvent(pEvent);
                update(it->boundingRect());
                if(g_bSceneLineDrawing)
                {
                    m_EventAgent.ModulePortHoveringChanged(this, true);
                }
            }
            else
            {
                if(it->m_OnHovering)
                {
                    it->hoverLeaveEvent(pEvent);
                    update(it->boundingRect());
                }
            }
            ++indexOfPort;
        }
    }
    // 端口状态改变时，刷新视口
    UpdateView();
    QGraphicsItem::hoverMoveEvent(pEvent);
}
void ModuleGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *pEvent)
{
    if(m_pToolBarItem)
    {
        // pEvent->pos().x()为鼠标离开时的x坐标。
        // 当鼠标位置在水平方向超出模块图元本身再加上工具条的宽度时，表示鼠标已经完全脱离该图元，此时应该无条件将悬浮状态取消。
        if((pEvent->pos().x() < m_size.width() / 2) ||
           (pEvent->pos().x() > m_size.width() / 2 + m_pToolBarItem->boundingRect().width()))
        {
            m_pToolBarItem->DetachModuleItem();
            this->m_pToolBarItem->SetToolBarVisible(false);
            m_OnHovering = false;
        }
        if(qAbs(pEvent->pos().y()) > (m_size.height() / 2 - 2))
        {
            m_pToolBarItem->DetachModuleItem();
            this->m_pToolBarItem->SetToolBarVisible(false);
            m_OnHovering = false;
        }
    }

    QList< ModulePortGraphicsItem >::iterator it;

    for(it = m_InputPorts.begin(); it != m_InputPorts.end(); ++it)
    {
        it->m_OnHovering = false;
    }
    for(it = m_OutputPorts.begin(); it != m_OutputPorts.end(); ++it)
    {
        it->m_OnHovering = false;
    }

    if(m_job)
    {
        if(m_JobType)
        {
            GeneralWorkflowScene *pScene = (GeneralWorkflowScene *) this->scene();
            if(pScene && m_pCJobParameterItem && m_pCJobParameterItem->GetWidget())
            {
                // 必须使用m_pCJobParameterItem->GetWidget()而不是m_pCJobParameterItem来设置是否显示，因为defect28520
                if(!(m_pCJobParameterItem->GetWidget()->GetMouseEnterWidgetFlag()))
                {
                    if(m_pCJobParameterItem->GetWidget()->GetFixWidgetPosFlag())
                    {
                        m_pCJobParameterItem->GetWidget()->show();
                    }
                    else
                    {
                        m_pCJobParameterItem->GetWidget()->hide();
                    }
                }
            }
        }
        // 鼠标移出时设置回默认Z值
        setZValue(0);
    }
    QGraphicsItem::hoverLeaveEvent(pEvent);

    setToolTip("");
    // 鼠标移出后刷新一下视口，防止进度条被模块遮盖
    UpdateView();
    update();
}

bool ModuleGraphicsItem::PortHit(QGraphicsSceneMouseEvent *pEvent)
{
    QList< ModulePortGraphicsItem >::iterator it;
    bool bFind = false;

    for(it = m_InputPorts.begin(); it != m_InputPorts.end(); ++it)
    {
        if(!bFind && (it->boundingRect().contains(pEvent->pos())))
        {
            it->SetPortSelected(true);
            update(it->boundingRect());
            m_EventAgent.ModulePortSelectionChanged(this, true);
            bFind = true;
        }
        else
        {
            if(it->m_selected)
            {
                it->SetPortSelected(false);
                update(it->boundingRect());
            }
        }
    }
    for(it = m_OutputPorts.begin(); it != m_OutputPorts.end(); ++it)
    {
        if(!bFind && (it->boundingRect().contains(pEvent->pos())))
        {
            it->SetPortSelected(true);
            update(it->boundingRect());
            m_EventAgent.ModulePortSelectionChanged(this, true);
            bFind = true;
        }
        else
        {
            if(it->m_selected)
            {
                it->SetPortSelected(false);
                update(it->boundingRect());
            }
        }
    }
    return bFind;
}

void ModuleGraphicsItem::mousePressEvent(QGraphicsSceneMouseEvent *pEvent)
{
    m_PressedOnPort = PortHit(pEvent);
    bool hasSelection = isSelected();

    QGraphicsItem::mousePressEvent(pEvent);

    m_EventAgent.ClickModule(this->GetModule(), m_job); // 发射点击的信号
    if(hasSelection)
    {
        // 如果点击前模块已经时被选中状态，发射重复点击信号
        m_EventAgent.ClickSelectedModule(this->GetModule());
    }

    update();
}
void ModuleGraphicsItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *pEvent)
{
    QGraphicsItem::mouseReleaseEvent(pEvent);

    setCursor(Qt::ArrowCursor);

    if(m_OnMoving)
    {
        m_OnMoving = false;
        m_EventAgent.ItemNeedCenterOn(this);
    }
}

void ModuleGraphicsItem::mouseMoveEvent(QGraphicsSceneMouseEvent *pEvent)
{
    if(m_PressedOnPort == false)
    {
        setCursor(Qt::ClosedHandCursor);
    }

    QRectF sceneRect(GetView()->sceneRect());

    QGraphicsItem::mouseMoveEvent(pEvent);

    if(m_pStyle)
    {
        QPointF scenePos(pos());
        QPointF sceneMarginPos(scenePos.x() + m_size.width() / 2,
                               scenePos.y() + m_size.height() / 2);

        if(!sceneRect.contains(sceneMarginPos))
        {
            m_OnMoving = true;

            if(sceneRect.bottom() < sceneMarginPos.y())
            {
                sceneRect.setBottom(sceneMarginPos.y());
                GetView()->setSceneRect(sceneRect);
            }
            if(sceneRect.right() < sceneMarginPos.x())
            {
                sceneRect.setRight(sceneMarginPos.x());
                GetView()->setSceneRect(sceneRect);
            }
        }
    }
    if(m_pMonitorItem)
    {
        if(m_pMonitorItem->GetStyle())
        {
            m_pMonitorItem->GetStyle()->SetPosition(pos() + QPointF(-120, -20));
        }
        m_pMonitorItem->setPos(pos() + QPointF(-120, -20));
    }
}

void ModuleGraphicsItem::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* /*pEvent*/)
{
    m_EventAgent.DoubleClickModule(this->GetModule(), m_job); // 发射双击的信号
}

bool ModuleGraphicsItem::IsDropTypeValid(const QMimeData *pMimeData)
{
    PaiDropEventAnalyser dropAna(pMimeData);
    // 获取被拖拽的数据
    QList<DraggedData>dataLst = dropAna.GetDraggedData();
    // 查找地震数据
    foreach(DraggedData draggedData, dataLst)
    {
        if(m_SupportedDropType.contains(QUuid(draggedData.dataType)))
        {
            return true;
        }
    }
    return false;
}

bool ModuleGraphicsItem::AddFileToModuleParameter(pai::objectmodel::PaiObject *pObject)
{
    PaiGeoObject *pGeoObject = dynamic_cast< PaiGeoObject* > (pObject);
    if(!pGeoObject)
    {
        return false;
    }

    pai::module::CModuleParameter* pModuleParam = GetModule()->GetModuleParameter();
    if(!pModuleParam)
    {
        return false;
    }

    pai::module::CParameterItem* pParameterItem = NULL;
    std::vector< pai::module::CParameterItem* > vecLeafItems;
    pModuleParam->GetRootParameterItem()->GetParameterItemsWithValidInputType(vecLeafItems);

    bool bFound = false;
    std::vector< pai::module::CParameterItem* >::const_iterator it;
    for(it = vecLeafItems.begin(); it != vecLeafItems.end(); ++it)
    {
        pParameterItem = *it;
        QList< QUuid > acceptDropTypes(pai::ModuleParameterUtil::GetAcceptDropTypes(pParameterItem));

        for(int i = 0; i < acceptDropTypes.size(); ++i)
        {
            if(acceptDropTypes[i] == pObject->GetTypeID())
            {
                bFound = true;
                break;
            }
        }
        if(bFound)
        {
            break;
        }
    }

    if(!bFound)
    {
        return false;
    }

    std::string oldParamValue = pParameterItem->GetStringValue();
    CCompositeParameterItem *pCompositeItem = (CCompositeParameterItem*)(pModuleParam->GetParameterItem("files"));

    QString dataPath = pGeoObject->GetVisibleFile();
    //处理拖拽作业下的地震数据
    if((dynamic_cast< PaiSeisData * > (pGeoObject)) && (dynamic_cast< PaiJob * > (pGeoObject->GetParent())))
    {
        //清空dataPath
        dataPath.clear();
        //获取被拖拽地震数据的逻辑路径
        dataPath = dynamic_cast< PaiSeisData * > (pGeoObject)->GetPhysicalFile();
        PaiSurvey* pSurvey = pGeoObject->GetForebear< PaiSurvey > ();
        if(pSurvey)
        {
            PaiBaseMaster *pMaster = pSurvey->GetMaster(QUuid(pai::objectmodel::PaiDataMaster::GetTypeIDString()));
            if(pMaster)
            {
                dataPath.replace(pGeoObject->GetName(), QString(""));
                dataPath.append(pMaster->GetName() + QString("/") + pGeoObject->GetName());
            }
        }
    }

    if(NULL != pCompositeItem)
    {
        int ifiles_num = pCompositeItem->GetChildCount();
        pai::module::CParameterItem *pItemNeedSetValue = pCompositeItem->GetParameterItem("files[0].filename");

        for(int i = 0; i < ifiles_num; ++i)
        {
            std::stringstream stream;
            stream.str("");
            stream << i;
            string id = "files[" + stream.str() + "]";

            pai::module::CParameterItem *pItem = pCompositeItem->GetParameterItem(id + ".filename");
            if(pItem == NULL)
            {
                continue;
            }

            if(pItem->ValueToString().empty())
            {
                pItemNeedSetValue = pItem;
                break;
            }
        }

        if(pItemNeedSetValue)
        {
            oldParamValue = pItemNeedSetValue->GetStringValue();
            pItemNeedSetValue->SetDefault(dataPath.toStdString());
            pItemNeedSetValue->SetStringValue(pGeoObject->GetPhysicalFile().toStdString());
            if(oldParamValue != pItemNeedSetValue->GetStringValue())
            {
                return true;
            }
        }
    }
    else
    {
        pParameterItem->SetDefault(dataPath.toStdString());
        pParameterItem->SetStringValue(pGeoObject->GetPhysicalFile().toStdString());
        if(oldParamValue != pParameterItem->GetStringValue())
        {
            return true;
        }
    }
    return false;
}

void ModuleGraphicsItem::dragEnterEvent ( QGraphicsSceneDragDropEvent *pEvent)
{
    QGraphicsItem::dragEnterEvent(pEvent);
    if(IsDropTypeValid(pEvent->mimeData()))
    {
        pEvent->accept();
    }
    else
    {
        pEvent->ignore();
    }
}

void ModuleGraphicsItem::dropEvent ( QGraphicsSceneDragDropEvent *pEvent)
{
    QGraphicsItem::dropEvent(pEvent);
    PaiDropEventAnalyser dropAna(pEvent->mimeData());
    //拖拽数据为空
    if(!dropAna.IsAvailable())
    {
        pEvent->ignore();
        return;
    }
    bool addFileSuccess = false;
    //数据树拖拽来的数据
    if((dropAna.GetDataSource() == DRAG_DATATREE) && IsDropTypeValid(pEvent->mimeData()))
    {
        QList<DraggedData>dataLst = dropAna.GetDraggedData();
        foreach(DraggedData draggedData,dataLst)
        {
            bool ok;
            PaiObject *pDragObject = ::GetObjectModelService()->GetObject((draggedData.id).toLongLong(&ok));
            if(ok && pDragObject)
            {
                //添加输入数据
                if(AddFileToModuleParameter(pDragObject))
                {
                    addFileSuccess = true;
                }
            }
        }
        if(addFileSuccess)
        {
            m_EventAgent.UpdataModule(this);
            pEvent->accept();
        }
    }
}

QVariant ModuleGraphicsItem::itemChange(GraphicsItemChange change, const QVariant & value)
{
    QVariant myValue(value);
    if(change == QGraphicsItem::ItemPositionChange)
    {
        if(m_pToolBarItem && isSelected())
        {
            int nCenterWidth = boundingRect().width() / 2 + 2 + m_pToolBarItem->boundingRect().width() / 2;
            m_pToolBarItem->setPos(pos() + QPointF(nCenterWidth, 0.0));
        }
    }
    return QGraphicsItem::itemChange(change, myValue);
}

int ModuleGraphicsItem::GetInputPortCount() const
{
    return m_InputPorts.count();
}

int ModuleGraphicsItem::GetOutputPortCount() const
{
    return m_OutputPorts.count();
}

bool ModuleGraphicsItem::GetInitialValidated() const
{
    return m_InitialValidated;
}
void ModuleGraphicsItem::SetInitialValidated(bool validated)
{
    m_InitialValidated = validated;
}

void ModuleGraphicsItem::SetErrorString(QString error)
{
    m_error = error;
}

void ModuleGraphicsItem::HilightPorts(PortDirection portDirection, bool light)
{
    QList< ModulePortGraphicsItem >& lstPortItems = (portDirection == Top) ? m_InputPorts : m_OutputPorts;
    for(QList< ModulePortGraphicsItem >::iterator it = lstPortItems.begin(); it != lstPortItems.end(); ++it)
    {
        it->m_light = light;
    }
    update();
}

void ModuleGraphicsItem::SetModuleNamePopup(const QList<QString> &moduleNameList)
{
    //初始化pupupView
    QStringListModel *pModel = new QStringListModel(moduleNameList);
    m_pEdit->completer()->setModel(pModel);
    m_pEdit->completer()->popup()->setMinimumHeight(m_pEdit->completer()->popup()->sizeHintForRow(0));
}

void ModuleGraphicsItem::HideModuleNameEditor()
{
    if(m_pEdit && !(m_pEdit->isHidden()))
    {
        m_pEdit->clear();
        m_pEdit->graphicsProxyWidget()->hide();
        if(m_pEdit->completer()->popup() && !(m_pEdit->completer()->popup()->isHidden()))
        {
            m_pEdit->completer()->popup()->hide();
        }
        setZValue(zValue() - MODULE_ZVALUE_STEP);
    }
}

void ModuleGraphicsItem::HideNonBlankModuleEditor()
{
    if(m_pEdit && !(m_pEdit->isHidden()) && m_pModule && !(m_pModule->IsBlankModule()))
    {
        m_pEdit->clear();
        m_pEdit->graphicsProxyWidget()->hide();
        if(m_pEdit->completer()->popup() && !(m_pEdit->completer()->popup()->isHidden()))
        {
            m_pEdit->completer()->popup()->hide();
        }
        setZValue(zValue() - MODULE_ZVALUE_STEP);
    }
}

bool ModuleGraphicsItem::IsEditingModuleName()
{
    if(m_pEdit && !(m_pEdit->isHidden()))
    {
        return true;
    }

    return false;
}

QString ModuleGraphicsItem::GetModuleNameEditorText() const
{
    if(m_pEdit && !(m_pEdit->isHidden()))
    {
        return m_pEdit->text();
    }
    return "";
}

void ModuleGraphicsItem::ShowModuleNameEditor()
{
    if(m_pEdit && (m_pEdit->isHidden()))
    {
        m_pEdit->clear();
        m_pEdit->show();
        m_pEdit->setFocus();
        setZValue(zValue() + MODULE_ZVALUE_STEP);
    }
}

bool ModuleGraphicsItem::IsModuleReadOnly() const
{
    return m_job;
}

bool ModuleGraphicsItem::InPortHasBeenLined(int portIndex) const
{
    if(!scene())
    {
        return false;
    }
    foreach(QGraphicsItem *pItem, scene()->items())
    {
        if (pItem && (pItem->type() == ModuleConnectGraphicsItem::Type))
        {
            ModuleConnectGraphicsItem* pConnectionItem = dynamic_cast<ModuleConnectGraphicsItem*> (pItem);

            if (pConnectionItem &&
               (pConnectionItem->GetEndItem() == this) &&
               (pConnectionItem->GetEndPortIndex() == portIndex))
            {
                return true;
            }
        }
    }
    return false;
}

int ModuleGraphicsItem::GetFreeInPortIndex() const
{
    int inportIndex = -1;
    if(!scene())
    {
        return inportIndex;
    }

    //结束模块的输入端口数量
    int inputPortCount = GetInputPortCount();
    for(int i = 0; i < inputPortCount; ++i)
    {
        //判断是否当前端口i被连接
        bool connected = false;
        foreach(QGraphicsItem *pItem, scene()->items())
        {
            if (pItem && (pItem->type() == ModuleConnectGraphicsItem::Type))
            {
                ModuleConnectGraphicsItem* pConnectionItem = dynamic_cast<ModuleConnectGraphicsItem*> (pItem);

                if (pConnectionItem &&
                   (pConnectionItem->GetEndItem() == this) &&
                   (pConnectionItem->GetEndPortIndex() == i))
                {
                    connected = true;
                    break;
                }
            }
        }
        //如果端口i没有被连接，则端口i设置为被连接端口
        if(!connected)
        {
            inportIndex = i;
            break;
        }
    }
    return inportIndex;
}

void ModuleGraphicsItem::SetMonitoring(bool monitor)
{
    m_monitoring = monitor;
}

bool ModuleGraphicsItem::GetMonitoring() const
{
    return m_monitoring;
}

void ModuleGraphicsItem::SetMonitorItem(pai::graphics2d::ModuleMonitorGraphicsItem *pMonitor)
{
    m_pMonitorItem = pMonitor;
}

pai::graphics2d::ModuleMonitorGraphicsItem* ModuleGraphicsItem::GetMonitorItem() const
{
    return m_pMonitorItem;
}