mfc数轴实现

#pragma once
#include <afxwin.h>
#include <memory>
#include "project_scjd/YwEmpDataControl.h"
#include "cg/fyq_interpreter.h"
#include "cg/File_TbCatalog2017.h"
class CFyqEntity;
class CRuleNodeEntity;
class CPositionNodeEntity;
class CArrowEntity;
class CNodeEntity;
typedef shared_ptr<CFyqEntity>      EntityPtr;
typedef shared_ptr<CRuleNodeEntity>     RuleNodePtr;
typedef shared_ptr<CPositionNodeEntity>  PointNodePtr;
typedef shared_ptr<CArrowEntity>    ArrowPtr;
typedef shared_ptr<CNodeEntity>        BaseNodeEntity;

typedef std::vector<EntityPtr>        VecEntity;
typedef std::vector<RuleNodePtr> VecRule;
typedef std::vector<PointNodePtr> VecPointNode;
#define radius 7
#define SelectedColor RGB(111, 111, 0)
#define NoSelectedColor RGB(118, 238, 0)
enum EntityGrade {
    EG_Arrow, EG_Axis, EG_RuleNode, EG_PositionNode
};
enum MenuID { MI_Edit = 1, MI_Delete, MI_AddPositionNode };

#define MI_Edit_Tip  "编辑"  
#define MI_Delete_Tip  "删除"  
#define MI_AddPositionNode_Tip  "添加坐标"  

class CFyqEntity
{

public:
    CFyqEntity();
    ~CFyqEntity();
    virtual int GetGrade() 
    {
        return -1;
    }
    virtual CRect GetBoundingBox()
    {
        return m_rect;
    }
    virtual void  OnDraw(CDC* pDC);
    virtual    void  DrawBoundingBox(CDC* pDC);
    virtual bool UpdateInfo(CWnd* pWnd); 
    virtual vecInt GetMenuIDvec()
    {
        vecInt vec;
        return vec;
    }
public:
    void    SetSelected(bool val);
    bool    bSelected();
    bool    m_bSelected;
    CPoint        m_Origin;//原点
    CRect        m_rect;//轮廓
    CString        m_sContent;//显示内容
};


class CArrowEntity : public CFyqEntity
{
public:
    CArrowEntity(CPoint& origin, CPoint& uppoint, CPoint& downpoint)
    {
        m_originPoint = origin;
        m_upPoint = uppoint;
        m_downPoint = downpoint;
    }
    void SetPoint(CPoint& origin, CPoint& uppoint, CPoint& downpoint)
    {
        m_originPoint = origin;
        m_upPoint = uppoint;
        m_downPoint = downpoint;
        m_rect.SetRect(m_upPoint.x, m_upPoint.y, m_originPoint.x, m_downPoint.y);
    }
public:
    virtual int GetGrade() { return EG_Arrow; }
    virtual CRect GetBoundingBox();
    virtual void  OnDraw(CDC* pDC);
public:
    CPoint   m_upPoint;
    CPoint   m_downPoint;
    CPoint     m_originPoint;

};

class CAxisEntity : public CFyqEntity
{
public:
    CAxisEntity(CPoint& start, CPoint& end);
    virtual int GetGrade() { return EG_Axis; }
    virtual CRect GetBoundingBox();
    virtual void  OnDraw(CDC* pDC);
    virtual vecInt GetMenuIDvec();
    
public:
    void SetStartPoint(CPoint &pt);
    void SetEndPoint(CPoint &pt);
    void SetArrow(ArrowPtr arrow);
private:
    CPoint   m_start;
    CPoint   m_end;
    ArrowPtr m_Arrow;
};

class CNodeEntity : public CFyqEntity
{
public:
    CNodeEntity();
public:
    virtual int GetGrade() = 0;
    virtual CRect GetBoundingBox();
    virtual void  OnDraw(CDC* pDC);
public:
    void SetRect(CPoint pt1, CPoint pt2);
    void SetContent(CString val);
    CString GetContent();
    CRect GetRect();
    bool GetUpdate()
    {
        return m_bupdate;
    }
    void SetUpdate(int flag)
    {
        m_bupdate = flag;
    }
protected:
    bool m_bupdate;
};

class CRuleNodeEntity : public CNodeEntity
{
public:
    CRuleNodeEntity();
    CRuleNodeEntity(PointNodePtr leftnode,PointNodePtr rightnode,CString& str,int high, int low,int SheetMaxH);
    ~CRuleNodeEntity();
    virtual int GetGrade() { return EG_RuleNode; }
    virtual void OnDraw(CDC* pDC);
    virtual bool UpdateInfo(CWnd* pWnd); 
    virtual vecInt GetMenuIDvec();
    PointNodePtr GetleftNode() {
        return m_pleftNode;
    }
    PointNodePtr GetRightNode() {
        return m_pRightNode;
    }
    void Sethigh(int x)
    {
        m_nhigh = x;
        m_sContent.Format("%d高,%d低", m_nhigh, m_nlow);
    }
    void Setlow(int x)
    {
        m_nlow = x;
        m_sContent.Format("%d高,%d低", m_nhigh, m_nlow);
    }
    int Gethigh()
    {
        return m_nhigh;
    }
    int Getlow()
    {
        return m_nlow;
    }
    void SetSheetHigh(int high)
    {
        m_nsheetHigh = high;
    }
public:
    PointNodePtr m_pleftNode;
    PointNodePtr m_pRightNode;
private:
    int m_nhigh;
    int m_nlow;
    int m_nsheetHigh;
};

class CPositionNodeEntity : public CNodeEntity
{
public:
    CPositionNodeEntity(CPoint& point,int number,int flag);
    CPositionNodeEntity(int number, int flag);
    virtual int GetGrade() { return EG_PositionNode; }
    virtual void OnDraw(CDC* pDC);
    virtual bool UpdateInfo(CWnd* pWnd); 
    virtual vecInt GetMenuIDvec();

    void SetPointx(int x)
    {
        m_nx = x;
    }
    void SetRealX(int x)
    {
        m_Origin.x = x;
        m_rect.TopLeft().x = m_Origin.x - radius;
        m_rect.BottomRight().x = m_Origin.x + radius;
    }
    void SetRealY(int y)
    {
        m_Origin.y = y;
        m_rect.TopLeft().y = m_Origin.y - radius;
        m_rect.BottomRight().y = m_Origin.y + radius;
    }
    int GetPointx()
    {
        return m_nx;
    }
    void SetNextNode(PointNodePtr node)
    {
        m_pNextNode = node;
    }
    void SetLastNode(PointNodePtr node)
    {
        m_pLastNode = node;
    }

    PointNodePtr GetNextNode()
    {
        return m_pNextNode;
    }
    PointNodePtr GetLastNode()
    {
        return m_pLastNode;
    }

    void SetLastRule(RuleNodePtr node)
    {
        m_pLastRule = node;
    }
    void SetRule(RuleNodePtr node)
    {
        m_pRule = node;
    }
    int GetX()
    {
        return m_nx;
    }
private:
    int m_nx;
    PointNodePtr m_pNextNode;
    PointNodePtr m_pLastNode;
    RuleNodePtr m_pLastRule;
    RuleNodePtr m_pRule;
    int m_flag;

};


class CFyqEnityMgr
{
public:
    CFyqEnityMgr();

    bool CreateEntities(Cfyq_expression* exp,CRect& rect);
    void OnDraw(CDC* pDC, CRect& rect);
    CRect GetBoundingBox();
    EntityPtr SelectEntity(CPoint pt);
    void SetSelected(bool val);
    bool IsEmpty();
    void SetScopeToExpression(Cfyq_expression* exp);
public://编辑
    bool EditEntity(CPoint pt, CWnd* pWnd);
    bool EditNodeBackGround(CPoint pt, CWnd* pWnd);
    bool DeleteEntity(EntityPtr pEnt);
    bool AddPositionNode(CPoint &point);
    void AddPositionNode(int numx);
    void DeleteRule(PointNodePtr start, PointNodePtr end);
    PointNodePtr ExistPointNode(int nNum);
    RuleNodePtr ExistRule(int nNum);
public:
    void findRule();
    void findPosition();
protected:
    VecEntity        m_Entities;
    VecRule            m_VecRule;
    VecPointNode    m_VecPoint;
    PointNodePtr    m_lastNode;

    BaseNodeEntity    m_LastSelected;

    int                m_nPointCount;
    int                m_nNowHigh;
    //CFile_TbCatalogTreeCtrl *m_pCtrl;
};




/////////////////////////////////////////////////////////////////////////////
//去高去低编辑框
class FLY_DBASE_API CD_EditHighLowDlg : public CXTPResizeDialog
{
public:
    CD_EditHighLowDlg(CWnd* pParent = NULL);
    ~CD_EditHighLowDlg();

    void SetValue(CString str, int nHighNum, int nLowNum,int max,CPoint& point);
public:
    virtual BOOL OnInitDialog();
    virtual void DoDataExchange(CDataExchange* pDX);
    virtual void OnOK();
    DECLARE_MESSAGE_MAP()
public:
    CString m_sHighNum;
    CString m_sLowNum;
    CString m_sShowAdd;
    int        m_nHighNum;
    int        m_nLowNum;
    int        m_Max;
    CPoint  m_point;
};
//修改已存在的点
class FLY_DBASE_API CD_EditPointDlg : public CXTPResizeDialog
{
public:
    CD_EditPointDlg(CWnd* pParent = NULL);
    ~CD_EditPointDlg();

    void SetValue(CString str, int max, int min,CPoint &point);
public:
    virtual BOOL OnInitDialog();
    virtual void DoDataExchange(CDataExchange* pDX);
    virtual void OnOK();
    DECLARE_MESSAGE_MAP()
public:
    CString m_sShowPoint;
    CString m_sEditPoint;
    int m_nMax;
    int m_nMin;
    int m_nNum;
    CPoint m_point;
};



class FLY_DBASE_API CD_AddPointDlg : public CXTPResizeDialog
{
public:
    CD_AddPointDlg(CWnd* pParent = NULL);
    ~CD_AddPointDlg();

public:
    virtual BOOL OnInitDialog();
    virtual void DoDataExchange(CDataExchange* pDX);
    void SetValue(CPoint& point);
    virtual void OnOK();
    DECLARE_MESSAGE_MAP()
public:
    CString m_sAddPoint;
    int        m_nNum;
    CPoint  m_point;
};

#include "stdafx.h"
#include <afxwin.h>
#include <memory>

#include "ZbFile_Add_MaxMin.h"
#include "Resource.h"
CString GetMenuStringByID(int nID)
{
    switch (nID)
    {
    case MI_Edit:
        return MI_Edit_Tip;
    case MI_Delete:
        return MI_Delete_Tip;
    case MI_AddPositionNode:
        return MI_AddPositionNode_Tip;
    default:
        break;
    }
    return _T("");
}

CFyqEntity::CFyqEntity()
{
    m_bSelected = false;
}

CFyqEntity::~CFyqEntity()
{

}
void CFyqEntity::OnDraw(CDC* pDC)
{
    if (m_bSelected)
    {
        DrawBoundingBox(pDC);
    }
}
void CFyqEntity::DrawBoundingBox(CDC* pDC)
{
    CRect rt = GetBoundingBox();
    if (this->GetGrade() == EG_PositionNode)
    {
        pDC->Ellipse(m_Origin.x - radius, m_Origin.y - radius, m_Origin.x + radius, m_Origin.y + radius);
    }
    else
    {
        if (this->GetGrade() == EG_RuleNode)
        {
            pDC->SelectStockObject(NULL_BRUSH);
            pDC->SelectStockObject(NULL_PEN);
        }
        pDC->Rectangle(rt);
    }
}
bool CFyqEntity::UpdateInfo(CWnd* pWnd)
{
    return true;
}

void CFyqEntity::SetSelected(bool val)
{
    m_bSelected = val;
}

bool CFyqEntity::bSelected()
{
    return m_bSelected;
}



////////////////////////////////////////////////////////////////////

CRect CArrowEntity::GetBoundingBox()
{
    return m_rect;
}

void CArrowEntity::OnDraw(CDC* pDC)
{
    CFyqEntity::OnDraw(pDC);
        //绘制箭头  
    pDC->MoveTo(m_originPoint);
    pDC->LineTo(m_upPoint);
    pDC->MoveTo(m_originPoint);
    pDC->LineTo(m_downPoint);
}

CAxisEntity::CAxisEntity(CPoint& start, CPoint& end)
{
    m_start = start;
    m_end = end;
}

//////////////////////////////////////////////////////////////////////////////

CRect CAxisEntity::GetBoundingBox()
{
    CRect rtArrow = m_Arrow->GetBoundingBox();
    CRect Allrt;
    m_rect;
    Allrt.UnionRect(m_rect, rtArrow);
    return Allrt;
}

void CAxisEntity::OnDraw(CDC* pDC)
{
    CFyqEntity::OnDraw(pDC);
    pDC->MoveTo(m_start);
    pDC->LineTo(m_end);
}

vecInt CAxisEntity::GetMenuIDvec()
{
    vecInt  temMenu;
    temMenu.push_back(MI_AddPositionNode);
    return temMenu;
}


void CAxisEntity::SetStartPoint(CPoint &pt)
{
    m_start = pt;
}

void CAxisEntity::SetEndPoint(CPoint &pt)
{
    m_end = pt;
    m_rect.SetRect(m_start.x, m_start.y - 5, m_end.x, m_end.y + 5);
}

void CAxisEntity::SetArrow(ArrowPtr arrow)
{
    m_Arrow = arrow;
}

//////////////////////////////////////////////////////////////////////////////
CNodeEntity::CNodeEntity()
{
    m_bupdate = false;
}

CRect CNodeEntity::GetBoundingBox()
{
    return m_rect;
}

void CNodeEntity::OnDraw(CDC* pDC)
{
    CFyqEntity::OnDraw(pDC);
    pDC->MoveTo(m_rect.TopLeft());
    pDC->LineTo(m_rect.BottomRight());
}

void CNodeEntity::SetRect(CPoint pt1, CPoint pt2)
{
    m_rect.SetRect(pt1, pt2);
}

void CNodeEntity::SetContent(CString val)
{
    m_sContent = val;
}

CRect CNodeEntity::GetRect()
{
    return m_rect;
}

CString CNodeEntity::GetContent()
{
    return m_sContent;
}


///////////////////////////////////////////////////////////////////////
CRuleNodeEntity::CRuleNodeEntity()
{
    m_pleftNode = NULL;
    m_pRightNode = NULL;
    m_nhigh = -1;
    m_nlow = -1;
}

CRuleNodeEntity::CRuleNodeEntity(PointNodePtr leftnode, PointNodePtr rightnode, CString& str, int high, int low,int SheetMaxH)
{
    m_pleftNode = leftnode;
    m_pRightNode = rightnode;
    
    m_rect.SetRect(leftnode->m_Origin.x, SheetMaxH, rightnode->m_Origin.x, rightnode->m_Origin.y);

    m_sContent = str;
    m_nhigh = high;
    m_nlow = low;
    m_nsheetHigh = SheetMaxH;
}    

CRuleNodeEntity::~CRuleNodeEntity()
{

}

void CRuleNodeEntity::OnDraw(CDC* pDC)
{
    CFyqEntity::OnDraw(pDC);
    CBrush brush;
    if (m_bupdate)
        brush.CreateSolidBrush(SelectedColor);
    else
        pDC->SelectStockObject(NULL_BRUSH);
    m_bupdate = 0;

    pDC->SelectStockObject(NULL_PEN);

    CBrush* pOldbrush = pDC->SelectObject(&brush);
    pDC->Rectangle(((m_pleftNode->m_Origin.x + m_pRightNode->m_Origin.x) / 2) - 25, m_nsheetHigh,
        ((m_pleftNode->m_Origin.x + m_pRightNode->m_Origin.x) / 2) + 25, m_pRightNode->m_Origin.y);
    if (pOldbrush)
        pDC->SelectObject(pOldbrush);

    pDC->SetTextColor(RGB(25, 155, 12));
    m_rect.SetRect(((m_pleftNode->m_Origin.x+ m_pRightNode->m_Origin.x)/2) - 30,m_nsheetHigh,
        ((m_pleftNode->m_Origin.x + m_pRightNode->m_Origin.x) / 2) + 30, m_pRightNode->m_Origin.y);
    pDC->DrawText(m_sContent, m_rect, DT_CENTER | DT_SINGLELINE | DT_VCENTER);
    pDC->SetTextColor(RGB(0, 0, 0));
}

bool CRuleNodeEntity::UpdateInfo(CWnd* pWnd)
{
    CString str;
    str.Format("当大于等于%d家,小于%d家时", m_pleftNode->GetPointx(), m_pRightNode->GetPointx());

    int x1 = m_rect.TopLeft().x;
    int y2 = m_rect.BottomRight().y;
    CPoint point(x1, y2);
    ClientToScreen(pWnd->GetSafeHwnd(), &point);



    CD_EditHighLowDlg dlg;
     dlg.SetValue(str, m_nhigh, m_nlow, m_pRightNode->GetPointx(),point);
    if (IDOK == dlg.DoModal())
    {
        Sethigh(dlg.m_nHighNum);
        Setlow(dlg.m_nHighNum);
    }
    return true;
}

vecInt CRuleNodeEntity::GetMenuIDvec()
{
    vecInt  temMenu;
    temMenu.push_back(MI_Edit);
    return temMenu;
}

////////////////////////////////////////////////////////////////////////////////////////

CPositionNodeEntity::CPositionNodeEntity(CPoint& point, int number,int flag)
{
    m_bupdate = false;
    m_Origin = point;
    m_flag = flag;
    if (!flag)
    {

    }
    else
    {
        m_rect.TopLeft().x = m_Origin.x - radius;
        m_rect.TopLeft().y = m_Origin.y - radius;

        m_rect.BottomRight().x = m_Origin.x + radius;
        m_rect.BottomRight().y = m_Origin.y + radius;
    }

    m_nx = number;
    CString str;
    str.Format("%d", number);
    m_sContent = str;
}

CPositionNodeEntity::CPositionNodeEntity(int number, int flag)
{
    m_flag = flag;
    m_nx = number;
    CString str;
    str.Format("%d", number);
    m_sContent = str;
}

void CPositionNodeEntity::OnDraw(CDC* pDC)
{
    if (!m_flag)
    {
        return;
    }

    CFyqEntity::OnDraw(pDC);
    //设半径为8
    CBrush brush;
     if(m_bupdate)
         brush.CreateSolidBrush(SelectedColor);
    else
        brush.CreateSolidBrush(NoSelectedColor);
    m_bupdate = 0;
    
    CBrush * pOldbrush = pDC->SelectObject(&brush);
    HPEN hPen = CreatePen(PS_SOLID,1, RGB(0, 0, 0));
    pDC->SelectObject(hPen);
    pDC->Ellipse(m_Origin.x - radius, m_Origin.y - radius, m_Origin.x + radius, m_Origin.y + radius);
    if (pOldbrush)
        pDC->SelectObject(pOldbrush);
    
    CRect rect(m_Origin.x - radius, m_Origin.y - radius, m_Origin.x + radius, m_Origin.y + radius);
    CString str;
    str.Format("%d", m_nx);
    m_sContent = str;
    pDC->DrawText(str, &rect, DT_CENTER | DT_SINGLELINE | DT_VCENTER);
    DeleteObject(hPen);
}

bool CPositionNodeEntity::UpdateInfo(CWnd* pWnd)
{
    CString str;
    str.Format("当前为%d,修改为：", m_nx);
    CD_EditPointDlg dlg;
    int min, max;
    if (m_pLastNode)
    {
        min = m_pLastNode->GetPointx();
    }
    else
    {
        min = 3;
    }
    if (m_pNextNode)
    {
        max = m_pNextNode->GetPointx();
    }
    else
    {
        max = 10000;
    }
    int x1 = m_rect.TopLeft().x;
    int y2 = m_rect.BottomRight().y;
    CPoint point(x1, y2);
    ClientToScreen(pWnd->GetSafeHwnd(), &point);
    dlg.SetValue(str,max,min, point);
    if (IDOK == dlg.DoModal())
    {
        SetPointx(dlg.m_nNum);
    }
    return true;
}

vecInt CPositionNodeEntity::GetMenuIDvec()
{
    vecInt  temMenu;
    temMenu.push_back(MI_Edit);
    temMenu.push_back(MI_Delete);
    return temMenu;
}

////////////////////////////////////////////////////////////////////////////////////////
CFyqEnityMgr::CFyqEnityMgr()
{
    m_nPointCount = 0;

}


bool CFyqEnityMgr::CreateEntities(Cfyq_expression* exp, CRect& rect)
{
    //该函数里面所有的坐标限于第一次初始化 修改到ondraw里面修改


/*    m_pCtrl = pCtrl;*/
    m_Entities.clear();
    std::vector<std::vector<int>> vecScope;
    vecScope = exp->GetScopeMinMax();
    CPoint leftupPoint = rect.TopLeft();
    CPoint rightdownPoint = rect.BottomRight();
    int SheetMaxH = rightdownPoint.y - 10;            //一开始起始y
    int TextAreaWidth = leftupPoint.x; //一开始起始x 因为是横着画的
    int MaxX = rightdownPoint.x;        // 最远x
    //坐标轴
    CPoint pstart(rect.TopLeft().x, SheetMaxH);
    CPoint pend(MaxX, SheetMaxH);
    auto ptrAxis = make_shared<CAxisEntity>(pstart, pend);
    m_Entities.push_back(ptrAxis);
    //箭头
    CPoint puppoint(pend.x - 10, pend.y - 5);
    CPoint pdownpoint(pend.x - 10, pend.y + 5);
    auto ptrArrow = make_shared<CArrowEntity>(pend, puppoint, pdownpoint);
    m_Entities.push_back(ptrArrow);
    ptrAxis->SetArrow(ptrArrow);
    int xMaxGrad = 5; //步进为5，目前动态计算还未完成
    //坐标点

    for (int i = 0; i < vecScope.size(); ++i)
    {
        int nBegin = vecScope[i][0];
        int nEnd = vecScope[i][1];
        int nhigh = vecScope[i][2];
        int nlow = vecScope[i][3];
        if (nBegin == 0)
        {
            continue;
        }
        CPoint pointend;
        CPoint pointstart(rect.TopLeft().x + nBegin * xMaxGrad * 10 - xMaxGrad * 25, SheetMaxH);
        pointend.x = rect.TopLeft().x + nEnd * xMaxGrad * 10 - xMaxGrad * 25;
        if (pointend.x > MaxX)
        {
            pointend.x = MaxX;
        }
        pointend.y = SheetMaxH;
        
        CString str;
        str.Format("%d高,%d低", nhigh, nlow);

        RuleNodePtr ptrLastRule = ExistRule(nBegin);
        PointNodePtr ptrPositionstart = ExistPointNode(nBegin);
        
        if (ptrPositionstart == NULL)
        {
            ptrPositionstart = make_shared<CPositionNodeEntity>(pointstart, nBegin,1);
            m_Entities.push_back(ptrPositionstart);
        }
        PointNodePtr ptrPositionend;
        if(pointend.x == MaxX)
                ptrPositionend = make_shared<CPositionNodeEntity>(pointend, nEnd,0);
        else
                ptrPositionend = make_shared<CPositionNodeEntity>(pointend, nEnd, 1);

        auto ptrCRuleNodeEnitiy = make_shared<CRuleNodeEntity>(ptrPositionstart, ptrPositionend,str, nhigh, nlow, leftupPoint.y);
        
        ptrPositionstart->SetRule(ptrCRuleNodeEnitiy);
        if (ptrLastRule != NULL)
        {
            ptrPositionstart->SetLastRule(ptrLastRule);
        }
        
        
        m_Entities.push_back(ptrPositionend);
        m_Entities.push_back(ptrCRuleNodeEnitiy);
        ptrPositionstart->SetNextNode(ptrPositionend);
        ptrPositionend->SetLastNode(ptrPositionstart);
        if (i == vecScope.size() - 1)
        {
            m_lastNode = ptrPositionend;
        }
    }
    return true;
}
void CFyqEnityMgr::OnDraw(CDC* pDC, CRect& rect)
{
    CPoint leftupPoint = rect.TopLeft();
    m_nNowHigh = leftupPoint.y;
    
    int TextAreaWidth = leftupPoint.x; //一开始起始x 因为是横着画的
    m_nPointCount = 0;
    CPoint rightdownPoint = rect.BottomRight();
    int SheetMaxH = rightdownPoint.y - 10;            //一开始起始y
    int MaxX = rightdownPoint.x;        // 最远x
    CPoint pStart(leftupPoint.x, SheetMaxH);
    CPoint pend(MaxX, SheetMaxH);
    CPoint puppoint(pend.x - 10, pend.y - 5);
    CPoint pdownpoint(pend.x - 10, pend.y + 5);
    m_lastNode->m_Origin = pend;
    for (auto it = m_Entities.begin(); it != m_Entities.end(); it++)
    {
        if ((*it)->GetGrade() == EG_Arrow)
        {
            std::dynamic_pointer_cast<CArrowEntity>(*it)->SetPoint(pend, puppoint, pdownpoint);
        }
        if ((*it)->GetGrade() == EG_Axis)
        {
            std::dynamic_pointer_cast<CAxisEntity>(*it)->SetStartPoint(pStart);
            std::dynamic_pointer_cast<CAxisEntity>(*it)->SetEndPoint(pend);
        }
        if ((*it)->GetGrade() == EG_PositionNode)
        {
            ++m_nPointCount;
        }
    }
    //根据点的个数动态计算步进
    findPosition();
    sort(m_VecPoint.begin(), m_VecPoint.end(), [](PointNodePtr node1, PointNodePtr node2)
    {
        return node1->GetX() < node2->GetX();
    });
    int xMaxGrad = -1;
    if(m_VecPoint.size() > 1)
        xMaxGrad = (MaxX - 100 - TextAreaWidth) / (10 * m_VecPoint[m_VecPoint.size() - 2]->GetX());

    for (auto it = m_Entities.begin(); it != m_Entities.end(); it++)
    {
        if ((*it)->GetGrade() == EG_PositionNode && (*it) != m_lastNode)
        {
            CPoint point;
            int number = std::dynamic_pointer_cast<CPositionNodeEntity>(*it)->GetX();
            point.x = TextAreaWidth + xMaxGrad * number * 10 - xMaxGrad * 20;
            point.y = SheetMaxH;
            std::dynamic_pointer_cast<CPositionNodeEntity>(*it)->SetRealX(point.x);
            std::dynamic_pointer_cast<CPositionNodeEntity>(*it)->SetRealY(point.y);
        }
        if ((*it)->GetGrade() == EG_RuleNode)
        {
            std::dynamic_pointer_cast<CRuleNodeEntity>(*it)->SetSheetHigh(m_nNowHigh);
        }
    }
    for (auto it = m_Entities.begin(); it != m_Entities.end(); it++)
    {
        (*it)->OnDraw(pDC);
    }
}

EntityPtr CFyqEnityMgr::SelectEntity(CPoint pt)
{
    vecInt  SelOrder;
    SelOrder.push_back(EG_RuleNode);
    SelOrder.push_back(EG_PositionNode);
    SelOrder.push_back(EG_Axis);

    for (int i = 0; i < SelOrder.size(); i++)
    {
        int order = SelOrder[i];
        auto it = find_if(m_Entities.begin(), m_Entities.end(), [=](EntityPtr ptr)
        {
            if (order == ptr->GetGrade())
            {
                CRect rt = ptr->GetBoundingBox();
                if (rt.PtInRect(pt))
                    return true;
            }
            return false;
        });
        if (it != m_Entities.end())
        {
            return (*it);
        }
    }
    return nullptr;
}

void CFyqEnityMgr::SetSelected(bool val)
{
    for (auto it = m_Entities.begin(); it != m_Entities.end(); it++)
    {
        (*it)->SetSelected(val);
    }
}

bool CFyqEnityMgr::IsEmpty()
{
    return m_Entities.empty();
}

void CFyqEnityMgr::SetScopeToExpression(Cfyq_expression* exp)
{
    m_VecRule.clear();
    for (int i = 0; i < m_Entities.size(); ++i)
    {
        if (m_Entities[i]->GetGrade() == EG_RuleNode)
        {
            auto ptr = std::dynamic_pointer_cast<CRuleNodeEntity>(m_Entities[i]);
            m_VecRule.push_back(ptr);
        }
    }
    sort(m_VecRule.begin(), m_VecRule.end(), [&](RuleNodePtr node1, RuleNodePtr node2)
    {
        return node1->GetleftNode()->GetPointx() < node2->GetleftNode()->GetPointx();
    });

    int dMinCount;
    int dMaxCount;
    int dMaxNumber;
    int dMinNumber;
    CString str;
    if (m_VecRule.size() == 1)
    {
        dMinCount = m_VecRule[0]->GetleftNode()->GetPointx();
        dMaxCount = m_VecRule[0]->GetRightNode()->GetPointx();
        dMaxNumber = m_VecRule[0]->Gethigh();
        dMinNumber = m_VecRule[0]->Getlow();
        str.Format("%d,%d,%d,%d", dMinCount, dMaxCount, dMaxNumber, dMinNumber);
        exp->GetScopeFromTree();
        exp->m_vecScope[0]->ReplaceScope(str);
    }
    else if (m_VecRule.size() > 1)
    {
        CString ans;
        for (int i = 0; i < m_VecRule.size(); ++i)
        {
            dMinCount = m_VecRule[i]->GetleftNode()->GetPointx();
            dMaxCount = m_VecRule[i]->GetRightNode()->GetPointx();
            dMaxNumber = m_VecRule[i]->Gethigh();
            dMinNumber = m_VecRule[i]->Getlow();
            if (i == m_VecRule.size() - 1)
            {
                str.Format("%d,%d,%d,%d", dMinCount, dMaxCount, dMaxNumber, dMinNumber);
            }
            else
            {
                str.Format("%d,%d,%d,%d;", dMinCount, dMaxCount, dMaxNumber, dMinNumber);
            }
            ans += str;
        }
        exp->GetScopeFromTree();
        exp->m_vecScope[0]->ReplaceScope(ans);
    }
}

CRect CFyqEnityMgr::GetBoundingBox()
{
    CRect rt;
    for (auto it = m_Entities.begin(); it != m_Entities.end(); it++)
    {
        CRect temrt = (*it)->GetBoundingBox();
        rt.UnionRect(rt, temrt);
    }
    return rt;
}
// bool CFyqEnityMgr::LButtonDraw(CPoint pt, CWnd* pWnd)
// {
//     pWnd->InvalidateRect(GetBoundingBox());
//     return true;
// }
bool CFyqEnityMgr::EditEntity(CPoint pt, CWnd* pWnd)
{
    EntityPtr pEnt = SelectEntity(pt);
    SetSelected(false);

    if (nullptr != pEnt)
    {
        pEnt->SetSelected(true);
        pWnd->InvalidateRect(GetBoundingBox());
        vecInt menuid = pEnt->GetMenuIDvec();
        CMenu menu;
        VERIFY(menu.CreatePopupMenu());
        for (int i = 0; i < menuid.size(); i++)
        {
            menu.AppendMenu(MF_STRING, menuid[i], GetMenuStringByID(menuid[i]));
        }
        //除了增加点在数轴上 其他都是在矩形的正下方
        int nCmd;
        CPoint point;
        point.y = pEnt->m_rect.BottomRight().y;
        if (pEnt->GetGrade() == EG_Axis || pEnt->GetGrade() == EG_Arrow)
        {
            point.x = pt.x;
        }
        else
        {
            point.x = pEnt->m_rect.TopLeft().x;
        }
        ClientToScreen(pWnd->GetSafeHwnd(), &point);
        nCmd = TrackPopupMenu(menu.GetSafeHmenu(), TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL | TPM_RETURNCMD,
            point.x, point.y, 0, pWnd->GetSafeHwnd(), 0);
        switch (nCmd)
        {
        case MI_Edit:
        {
            pEnt->UpdateInfo(pWnd);
        }
        break;
        case MI_Delete:
        {
            DeleteEntity(pEnt);
        }
        break;
        case MI_AddPositionNode:
        {
            AddPositionNode(point);
        }
        break;
        default:
            break;
        }
        return true;
    }
    return false;
}
bool CFyqEnityMgr::EditNodeBackGround(CPoint pt, CWnd* pWnd)
{
    auto it = find_if(m_Entities.begin(), m_Entities.end(), [=](EntityPtr ptr)
    {
        if (EG_PositionNode == ptr->GetGrade() || EG_RuleNode == ptr->GetGrade())
        {
            CRect rt = ptr->GetBoundingBox();
            if (rt.PtInRect(pt))
                return true;
        }
        return false;
    });
    if (it == m_Entities.end())
    {
        for (auto it = m_Entities.begin(); it != m_Entities.end(); ++it)
        {
            if ((*it)->GetGrade() == EG_PositionNode || (*it)->GetGrade() == EG_RuleNode)
            {
                std::dynamic_pointer_cast<CNodeEntity>(*it)->SetUpdate(false);
            }
        }
        if (m_LastSelected)
        {
            pWnd->InvalidateRect(&m_LastSelected->GetBoundingBox());
            m_LastSelected = nullptr;
        }
            
        return false;
    }
    else
    {
        std::dynamic_pointer_cast<CNodeEntity>(*it)->SetUpdate(true);
        if ((*it) != m_LastSelected)
        {
            if (m_LastSelected)
            {
                std::dynamic_pointer_cast<CNodeEntity>(m_LastSelected)->SetUpdate(false);
                pWnd->InvalidateRect(&(m_LastSelected)->GetBoundingBox());
            }
            m_LastSelected = std::dynamic_pointer_cast<CNodeEntity>(*it);
            pWnd->InvalidateRect(&(*it)->GetBoundingBox());
        }
        return true;
    }

}
bool CFyqEnityMgr::DeleteEntity(EntityPtr pEnt)
{
    //数据中的
    //不能存在已有的点
    PointNodePtr nowNode = std::dynamic_pointer_cast<CPositionNodeEntity>(pEnt);
    if (nowNode == NULL)
    {
        return false;
    }
    PointNodePtr leftnode = nowNode->GetLastNode();
    PointNodePtr rightnode = nowNode->GetNextNode();
    if (leftnode)
        leftnode->SetNextNode(rightnode);
    rightnode->SetLastNode(leftnode);
    for (auto it = m_Entities.begin(); it != m_Entities.end();)
    {
        if ((*it)->GetGrade() == EG_RuleNode)
        {
            if (std::dynamic_pointer_cast<CRuleNodeEntity>((*it))->GetleftNode() == nowNode ||
                std::dynamic_pointer_cast<CRuleNodeEntity>((*it))->GetRightNode() == nowNode)
            {
                it = m_Entities.erase(it);
            }
            else
            {
                ++it;
            }
        }
        else
        {
            ++it;
        }
    }
    for (auto it = m_Entities.begin(); it != m_Entities.end();)
    {
        if ((*it) == pEnt)
        {
            it = m_Entities.erase(it);
        }
        else
        {
            ++it;
        }
    }
    CString str;
    str.Format("0高,0低");
    if (leftnode)
    {
        auto PtrRule = make_shared<CRuleNodeEntity>(leftnode, rightnode, str, 0, 0, m_nNowHigh);
        m_Entities.push_back(PtrRule);
    }
    return true;
}
//&& -> & 
bool CFyqEnityMgr::AddPositionNode(CPoint &point)
{
    CD_AddPointDlg dlg;
    dlg.SetValue(point);
    if (IDOK == dlg.DoModal())
    {
        AddPositionNode(dlg.m_nNum);
    }
    return true;
}
void CFyqEnityMgr::DeleteRule(PointNodePtr start, PointNodePtr end)
{
    findRule();
    for (auto it = m_Entities.begin(); it != m_Entities.end();)
    {
        if ((*it)->GetGrade() == EG_RuleNode)
        {
            if (std::dynamic_pointer_cast<CRuleNodeEntity>(*it)->GetleftNode() == start
                && std::dynamic_pointer_cast<CRuleNodeEntity>(*it)->GetRightNode() == end)
            {
                it = m_Entities.erase(it);
            }
            else
            {
                ++it;
            }
        }
        else
        {
            ++it;
        }
    }
}
void CFyqEnityMgr::AddPositionNode(int numx)
{
    findPosition();
    //不能存在已有的点
    PointNodePtr ptr;
    CString str;
    str.Format("%d高,%d低", 0, 0);
    sort(m_VecPoint.begin(), m_VecPoint.end(), [](PointNodePtr node1, PointNodePtr node2)
    {
        return node1->GetX() < node2->GetX();
    });
    for (int i = 0; i < m_VecPoint.size() - 1; ++i)
    {
        if (numx > m_VecPoint[i]->GetX() && numx < m_VecPoint[i + 1]->GetX())
        {
            ptr = make_shared<CPositionNodeEntity>(numx,1);
            ptr->SetLastNode(m_VecPoint[i]);
            ptr->SetNextNode(m_VecPoint[i + 1]);
            //删除已有的矩形
            DeleteRule(m_VecPoint[i], m_VecPoint[i + 1]);
            //创建已有矩形
            
            auto PtrFirstRule = make_shared<CRuleNodeEntity>(m_VecPoint[i], ptr, str, 0, 0, m_nNowHigh);
            auto PtrSecondRule = make_shared<CRuleNodeEntity>(ptr, m_VecPoint[i+1], str, 0, 0, m_nNowHigh);
            m_Entities.push_back(ptr);
            m_Entities.push_back(PtrFirstRule);
            m_Entities.push_back(PtrSecondRule);
            return;
        }
    }
    ptr = make_shared<CPositionNodeEntity>(numx, 1);
    ptr->SetNextNode(m_VecPoint[0]);
    auto PtrFirstRule = make_shared<CRuleNodeEntity>(ptr, m_VecPoint[0], str, 0, 0, m_nNowHigh);
    m_Entities.push_back(ptr);
    m_Entities.push_back(PtrFirstRule);
    
}



PointNodePtr CFyqEnityMgr::ExistPointNode(int nNum)
{
    findPosition();
    auto it = find_if(m_VecPoint.begin(), m_VecPoint.end(), [nNum](PointNodePtr node)
    {
        return node->GetX() == nNum;
    });
    if (it != m_VecPoint.end())
    {
        return *it;
    }
    else
    {
        return NULL;
    }
}

RuleNodePtr CFyqEnityMgr::ExistRule(int nNum)
{
    findRule();
    auto it = find_if(m_VecRule.begin(), m_VecRule.end(), [&](RuleNodePtr node)
    {
        return node->GetRightNode()->GetX() == nNum;
    });
    if (it != m_VecRule.end())
    {
        return *it;
    }
    else
    {
        return NULL;
    }
}

void CFyqEnityMgr::findRule()
{
    m_VecRule.clear();
    for (int i = 0; i < m_Entities.size(); ++i)
    {
        if (m_Entities[i]->GetGrade() == EG_RuleNode)
        {
            auto ptr = std::dynamic_pointer_cast<CRuleNodeEntity>(m_Entities[i]);
            m_VecRule.push_back(ptr);
        }
    }
}

void CFyqEnityMgr::findPosition()
{
    m_VecPoint.clear();
    for (int i = 0; i < m_Entities.size(); ++i)
    {
        if (m_Entities[i]->GetGrade() == EG_PositionNode)
        {
            auto ptr = std::dynamic_pointer_cast<CPositionNodeEntity>(m_Entities[i]);
            m_VecPoint.push_back(ptr);
        }
    }
}

///////////////////////////////////////////////////////////////////
CD_EditHighLowDlg::CD_EditHighLowDlg(CWnd* pParent /*= NULL*/)
    :CXTPResizeDialog(IDD_DLG_HighLow, pParent)
{

}

CD_EditHighLowDlg::~CD_EditHighLowDlg()
{

}

BEGIN_MESSAGE_MAP(CD_EditHighLowDlg, CXTPResizeDialog)
END_MESSAGE_MAP()

void CD_EditHighLowDlg::SetValue(CString str, int nHighNum, int nLowNum,int max,CPoint& point)
{
    m_sShowAdd = str;
    m_sHighNum.Format(_T("%d"), nHighNum);
    m_sLowNum.Format(_T("%d"), nLowNum);
    m_Max = max;
    m_point = point;
}

BOOL CD_EditHighLowDlg::OnInitDialog()
{
    __super::OnInitDialog();
    CRect rect(m_point.x, m_point.y+5, m_point.x + 225, m_point.y + 120);
    MoveWindow(&rect);
    UpdateData(FALSE);
    return TRUE;
}

void CD_EditHighLowDlg::DoDataExchange(CDataExchange* pDX)
{
    __super::DoDataExchange(pDX);
    DDX_Text(pDX, IDC_STATIC_ShowAdd, m_sShowAdd);
    DDX_Text(pDX, IDC_EDIT_High, m_sHighNum);
    DDX_Text(pDX, IDC_EDIT_Low, m_sLowNum);
}

void CD_EditHighLowDlg::OnOK()
{
    UpdateData(TRUE);
    m_nHighNum = atoi(m_sHighNum);
    m_nLowNum = atoi(m_sLowNum);
    if (m_nHighNum + m_nLowNum >= m_Max)
    {
        AfxMessageBox("去高去低的企业数不能大于等于最大企业数!");
        return;
    }
    EndDialog(IDOK);
}

////////////////////////////////////////////////////////
CD_EditPointDlg::CD_EditPointDlg(CWnd* pParent /*= NULL*/)
    :CXTPResizeDialog(IDD_Edit_Point, pParent)
{

}

CD_EditPointDlg::~CD_EditPointDlg()
{

}

BEGIN_MESSAGE_MAP(CD_EditPointDlg, CXTPResizeDialog)
END_MESSAGE_MAP()

void CD_EditPointDlg::SetValue(CString str, int max,int min,CPoint& point)
{
    m_sShowPoint = str;
    m_nMax = max;
    m_nMin = min;
    m_point = point;
}
BOOL CD_EditPointDlg::OnInitDialog()
{
    __super::OnInitDialog();
    CRect rect(m_point.x, m_point.y, m_point.x + 180, m_point.y + 80);
    MoveWindow(&rect);
    UpdateData(FALSE);
    return TRUE;
}

void CD_EditPointDlg::DoDataExchange(CDataExchange* pDX)
{
    __super::DoDataExchange(pDX);
    DDX_Text(pDX, IDC_EDIT_Point, m_sEditPoint);
    DDX_Text(pDX, IDC_STATIC_Point, m_sShowPoint);
}

void CD_EditPointDlg::OnOK()
{
    UpdateData(TRUE);
    m_nNum = atoi(m_sEditPoint);
    CString str;
    
    str.Format("输入范围需要大于%d,小于%d!", m_nMin, m_nMax);
    if (!(m_nNum < m_nMax && m_nNum >= m_nMin))
    {
        AfxMessageBox(str);
        return;
    }
    EndDialog(IDOK);
}
///////////////////////////////////////////
CD_AddPointDlg::CD_AddPointDlg(CWnd* pParent /*= NULL*/)
    :CXTPResizeDialog(IDD_ADD_Point, pParent)
{

}

CD_AddPointDlg::~CD_AddPointDlg()
{

}

BEGIN_MESSAGE_MAP(CD_AddPointDlg, CXTPResizeDialog)
END_MESSAGE_MAP()


BOOL CD_AddPointDlg::OnInitDialog()
{
    __super::OnInitDialog();
    CRect rect(m_point.x, m_point.y,m_point.x + 200,m_point.y+70);
    MoveWindow(&rect);
    UpdateData(FALSE);
    return TRUE;
}

void CD_AddPointDlg::DoDataExchange(CDataExchange* pDX)
{
    __super::DoDataExchange(pDX);
    DDX_Text(pDX, IDC_EDIT_AddPoint, m_sAddPoint);
    
}

void CD_AddPointDlg::SetValue(CPoint& point)
{
    m_point = point;
}

void CD_AddPointDlg::OnOK()
{
    UpdateData(TRUE);
    m_nNum = atoi(m_sAddPoint);
    if (m_nNum < 3 || m_nNum >= 10000)
    {
        AfxMessageBox("坐标应大于3，小于10000!");
        return;
    }
    EndDialog(IDOK);
}