repos_ecs/DrawIDE/IDE/DrawObj.cpp

// CDrawObj.cpp: implementation of the CDrawObj class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "BaseProDlg.h"
#include "DynamicProPage.h"
#include "computer.h"
#include "bardlg.h"
#include "curvedlg.h"
#include "MainFrm.h"
#include "IDEView.h"
#include "datainputdlg.h"
#include "CommondServer.h"
#include "gradient.h"
#include "BitmapPage.h"
#include "datapage.h"
#include "logicpage.h"
#include "SingleBarPage.h"
#include "ArcPage.h"
#include "WatchPage.h"
#include "ReportBasePage.h"
#include "ReportColPage.h"
#include "YkCmdDlg.h"
#include "Dlg_OCX.h"
#include "Dlg_Flash.h"
#include "SysLib.h"
#include "Dlg_Pwd.h"

#include "DlgEditPwd.h"
#include "SystemParaSetDlg.h"
#include <math.h>

extern CMainFrame *g_pMainFrm;
#pragma warning (disable : 4805)

#define DIR_UP		0
#define DIR_DOWN	1
#define DIR_LEFT	2
#define DIR_RIGHT	3
#define PIE			3.1415926

// 表盘
#define HOURSCALE       65
#define MINUTESCALE     80
#define HHAND           TRUE
#define MHAND           FALSE
#define SECONDSCALE     80
#define MAXBLOBWIDTH    25
#define BUFLEN          30
#define REPAINT         0
#define HANDPAINT       1

#define UPDATE                  0
#define REDRAW                  1

#define OPEN_TLEN               450
#define ICON_TLEN               45000

#define CLKSCALE                ((INT)8000)
// END

// 表盘
typedef struct
{
	SHORT sin;
	SHORT cos;
} TRIG;

TRIG CirTab[] = {     // circle sin, cos, table
	{ -7999, -0     },
	{ -7956, -836   },
	{ -7825, -1663  },
	{ -7608, -2472  },
	{ -7308, -3253  },
	{ -6928, -4000  },
	{ -6472, -4702  },
	{ -5945, -5353  },
	{ -5353, -5945  },
	{ -4702, -6472  },
	{ -3999, -6928  },
	{ -3253, -7308  },
	{ -2472, -7608  },
	{ -1663, -7825  },
	{ -836 , -7956  },

	{ 0,     -7999  },
	{ 836,   -7956  },
	{ 1663,  -7825  },
	{ 2472,  -7608  },
	{ 3253,  -7308  },
	{ 3999,  -6928  },
	{ 4702,  -6472  },
	{ 5353,  -5945  },
	{ 5945,  -5353  },
	{ 6472,  -4702  },
	{ 6928,  -4000  },
	{ 7308,  -3253  },
	{ 7608,  -2472  },
	{ 7825,  -1663  },
	{ 7956,  -836   },

	{ 8000,  0      },
	{ 7956,  836    },
	{ 7825,  1663   },
	{ 7608,  2472   },
	{ 7308,  3253   },
	{ 6928,  4000   },
	{ 6472,  4702   },
	{ 5945,  5353   },
	{ 5353,  5945   },
	{ 4702,  6472   },
	{ 3999,  6928   },
	{ 3253,  7308   },
	{ 2472,  7608   },
	{ 1663,  7825   },
	{ 836,   7956   },

	{ 0,     7999   },
	{ -836,  7956   },
	{ -1663, 7825   },
	{ -2472, 7608   },
	{ -3253, 7308   },
	{ -4000, 6928   },
	{ -4702, 6472   },
	{ -5353, 5945   },
	{ -5945, 5353   },
	{ -6472, 4702   },
	{ -6928, 3999   },
	{ -7308, 3253   },
	{ -7608, 2472   },
	{ -7825, 1663   },
	{ -7956, 836    }
};
// End


IMPLEMENT_SERIAL(CAction, CObject, 0)

CAction::CAction() :CObject()
{
	m_nActionType = YK_COMMOND;
	m_strVariant = _T("");
	m_strActionValue = _T("");
	m_strPicPath = _T("");
}

void CAction::Serialize(CArchive& ar)
{
	CObject::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_nActionType;
		ar << m_strVariant;
		ar << m_strActionValue;
		ar << m_strPicPath;
	}
	else
	{
		ar >> m_nActionType;
		ar >> m_strVariant;
		ar >> m_strActionValue;
		ar >> m_strPicPath;
	}
}


CAction& CAction::operator=(CAction& action)
{
	m_nActionType = action.m_nActionType;
	m_strVariant = action.m_strVariant;
	m_strActionValue = action.m_strActionValue;
	m_strPicPath = action.m_strPicPath;
	return *this;
}


CAction* CAction::Clone(void)
{
	CAction* pAction = new CAction;
	*pAction = *this;
	pAction->m_nActionType = m_nActionType;
	pAction->m_strVariant = m_strVariant;
	pAction->m_strActionValue = m_strActionValue;
	pAction->m_strPicPath = m_strPicPath;
	return pAction;
}


//---------------------------------------------- CDrawObj ---------
CStringArray CDrawObj::drawsName;
CPtrArray CDrawObj::drawsRuntimeClass;

BOOL CDrawObj::bRuning = FALSE;	// 是否处于运行状态;

IMPLEMENT_SERIAL(CDrawObj, CObject, 0)

CDrawObj::CDrawObj() :CObject()
{
	m_pView = NULL;
	m_nLineWidth = 1;
	m_strLineType = "PS_SOLID";
	m_clrFore = RGB(0, 0, 0);
	m_clrFill = RGB(0, 0, 255);
	m_clrLine = RGB(0, 0, 0);		// 线色
	m_clrBack = RGB(255, 0, 0);
	m_clrCurrentFore = RGB(0, 255, 0);
	m_clrCurrentBack = RGB(255, 0, 0);
	m_clrCurrentLine = RGB(0, 255, 255);
	m_bLocked = FALSE;

	m_strCaption = "";
	m_logfont.lfHeight = -12;
	m_logfont.lfWidth = 0;
	m_logfont.lfEscapement = 0;
	m_logfont.lfOrientation = 0;
	m_logfont.lfWeight = FW_NORMAL;
	m_logfont.lfItalic = FALSE;
	m_logfont.lfUnderline = FALSE;
	m_logfont.lfStrikeOut = FALSE;
	if (strcmp(g_strLanguage, "ENG") == 0)
	{
		m_logfont.lfCharSet = GB2312_CHARSET;
	}
	else if (strcmp(g_strLanguage, "CHS") == 0)
	{
		m_logfont.lfCharSet = GB2312_CHARSET;
	}
	else if (strcmp(g_strLanguage, "CHT") == 0)
	{
		m_logfont.lfCharSet = CHINESEBIG5_CHARSET;
	}

	m_logfont.lfOutPrecision = OUT_STROKE_PRECIS;
	m_logfont.lfClipPrecision = CLIP_STROKE_PRECIS;
	m_logfont.lfQuality = DEFAULT_QUALITY;//DRAFT_QUALITY;
	m_logfont.lfPitchAndFamily = FIXED_PITCH | FF_MODERN;

	if (strcmp(g_strLanguage, "ENG") == 0)
	{
		strcpy(m_logfont.lfFaceName, g_strTimesNewRoman);
	}
	else if (strcmp(g_strLanguage, "CHS") == 0)
	{
		strcpy(m_logfont.lfFaceName, g_strTimesNewRoman);
	}
	else if (strcmp(g_strLanguage, "CHT") == 0)
	{
		strcpy(m_logfont.lfFaceName, g_strFontNameCHT);
	}

	m_bVertiSize = FALSE;
	m_bHorizSize = FALSE;
	m_bHorizPos = FALSE;
	m_bVertiPos = FALSE;
	m_bShow = TRUE;
	m_bShowtemp = TRUE;
	m_bDynShow = FALSE;
	m_nHorAlign = 0;
	m_nVerAlign = 0;

	m_clrDynBack = RGB(255, 0, 0);
	m_strDynBackCon = "";
	m_clrDynLine = RGB(0, 255, 0);
	m_strDynLineCon = "";
	m_fCurrentValue = 0.0;

	m_bDynFore = FALSE;
	m_bDynBack = FALSE;
	m_bDynLine = FALSE;
	m_bOnButtonDown = false;
	m_bOnButtonUp = false;
	m_bOnMove = false;
	m_nFillMode = 0;
	m_rctCurrent = m_rect;

	m_bHisFreshed = false;
	m_bModifyMore = FALSE;

	m_bFlag1 = true;
	m_bFlag2 = true;
	m_bFlag3 = true;
}


void CDrawObj::RegisterClass(CString strName, CRuntimeClass* pRuntimeClass)
{
	if (pRuntimeClass->IsDerivedFrom(RUNTIME_CLASS(CDrawObj)))
	{
		int i = 0;
		int nSize = drawsName.GetSize();
		for (i = 0; i < nSize; i++)
		{
			if ((strName == drawsName[i]) || (pRuntimeClass == drawsRuntimeClass[i]))
			{
				break;
			}
		}
		if (i == nSize)
		{
			drawsName.Add(strName);
			drawsRuntimeClass.Add(pRuntimeClass);
		}
	}
}

CDrawObj& CDrawObj::operator=(CDrawObj& drawObj)
{
	m_rect = drawObj.m_rect;
	m_pView = drawObj.m_pView;
	m_strLineType = drawObj.m_strLineType;
	m_clrLine = drawObj.m_clrLine;
	m_clrFore = drawObj.m_clrFore;
	m_clrBack = drawObj.m_clrBack;
	m_clrLine = drawObj.m_clrLine;
	m_strCaption = drawObj.m_strCaption;
	m_logfont = drawObj.m_logfont;
	m_nLineWidth = drawObj.m_nLineWidth;
	m_bVariant = drawObj.m_bVariant;
	m_bDynShow = drawObj.m_bDynShow;
	m_strDynShow = drawObj.m_strDynShow;

	m_clrDynFore = drawObj.m_clrDynFore;
	m_strDynForeCon = drawObj.m_strDynForeCon;
	m_clrDynBack = drawObj.m_clrDynBack;
	m_strDynBackCon = drawObj.m_strDynBackCon;
	m_clrDynLine = drawObj.m_clrDynLine;
	m_strDynLineCon = drawObj.m_strDynLineCon;
	m_bDynFore = drawObj.m_bDynFore;
	m_bDynBack = drawObj.m_bDynBack;
	m_bDynLine = drawObj.m_bDynLine;

	m_strHoriPos = drawObj.m_strHoriPos;
	m_strHoriSize = drawObj.m_strHoriSize;
	m_strVertiPos = drawObj.m_strVertiPos;
	m_strVertiSize = drawObj.m_strVertiSize;
	m_bVertiSize = drawObj.m_bVertiSize;
	m_bVertiPos = drawObj.m_bVertiPos;
	m_bHorizSize = drawObj.m_bHorizSize;
	m_bHorizPos = drawObj.m_bHorizPos;

	m_downAction = drawObj.m_downAction;
	m_bOnButtonDown = drawObj.m_bOnButtonDown;
	return *this;
}

/************************************************************************/
/*  函数：Fresh[10/28/2016 Home];
/*  描述：刷新页面中所有图元;
/*  参数：;
/*  	[IN] ：;
/*  	[OUT] ：;
/*  	[IN/OUT] ：;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
bool CDrawObj::Fresh(OUT CRect &RECT)
{
	if (m_bVariant)
	{// 如果是变量;
// 		int nValue = (int)pVariantsManager->GetAnalogValue(m_strCaption);
// 		if( nValue == -1 ) return false;
// 		m_fCurrentValue = pVariantsManager->GetAnalogValue(m_strCaption);
// 		int tmp = (int)m_fCurrentValue;
// 		m_strCurrentCaption.Format("%d", tmp);
	}
	else
	{
		m_strCurrentCaption = m_strCaption;
	}

	m_rctCurrent = m_rect;

	// 计算当前大小;
	if (m_bVertiSize)
	{
		CRealComputer com;
		com.SetFormula(m_strVertiSize);
		int tmp = com.GetResult();
		int height = m_rctCurrent.Height();
		CRect rect = m_rctCurrent;
		rect.NormalizeRect();
		if (m_nVerAlign)
		{
			if (rect.top != m_rctCurrent.top)
			{
				m_rctCurrent.bottom -= tmp - height;
			}
			else
			{
				m_rctCurrent.top -= tmp - height;
			}
		}
		else
		{
			if (rect.top != m_rctCurrent.top)
			{
				m_rctCurrent.top += tmp - height;
			}
			else
			{
				m_rctCurrent.bottom += tmp - height;
			}
		}
	}
	//if (m_bHorizSize) modify by chn 2012.02.06
	//{
	//	CRealComputer com;
	//	com.SetFormula(m_strHoriSize);
	//	int tmp = com.GetResult();
	//	int width = m_rctCurrent.Width();
	//	CRect rect = m_rctCurrent; 
	//	rect.NormalizeRect();
	//	if ( m_nHorAlign )
	//	{
	//		if (rect.right != m_rctCurrent.right )
	//		{
	//			m_rctCurrent.right -= tmp-width;
	//		}
	//		else
	//		{
	//			m_rctCurrent.left -= tmp-width;
	//		}
	//	}
	//	else
	//	{
	//		if (rect.right != m_rctCurrent.right )
	//		{
	//			m_rctCurrent.left += tmp-width;
	//		}
	//		else
	//		{
	//			m_rctCurrent.right += tmp-width;
	//		}
	//	}
	//}

	// 计算当前位置
	if (m_bVertiPos)
	{
		CRealComputer com;
		com.SetFormula(m_strVertiPos);
		int tmp = com.GetResult();
		int yPos = ((CPoint)m_rctCurrent.TopLeft()).y;
		m_rctCurrent.OffsetRect(0, tmp - yPos);
	}
	if (m_bHorizPos)
	{
		CRealComputer com;
		com.SetFormula(m_strHoriPos);
		int tmp = com.GetResult();
		int xPos = ((CPoint)m_rctCurrent.TopLeft()).x;
		m_rctCurrent.OffsetRect(tmp - xPos, 0);
	}

	m_clrCurrentFore = m_clrFore;
	m_clrCurrentBack = m_clrBack;
	m_clrCurrentLine = m_clrLine;
	// 计算当前的动态颜色；
	if (m_bDynFore == 1)
	{
		CRealComputer com;
		com.SetFormula(m_strDynForeCon);
		int tmp = com.GetResult();
		if (tmp)
		{
			if (!m_bHorizSize)
				m_clrCurrentFore = m_clrDynFore;
			else
			{
				if (m_bFlag1)
					m_clrCurrentFore = m_clrDynFore;
				else
				{
					//m_clrCurrentBack = RGB( 230, 241, 249 );
					//m_clrCurrentLine = RGB( 230, 241, 249 );
					m_clrCurrentFore = RGB(230, 241, 249);
				}

				m_bFlag1 = !m_bFlag1;
			}
		}
	}
	if (m_bDynBack == 1)
	{
		CRealComputer com;
		com.SetFormula(m_strDynBackCon);
		int tmp = com.GetResult();

		//if( -1 != m_strDynBackCon.Find("WTH10_1_Temp_1") )
		//{
		//	int a=0;
		//}
		if (tmp)
		{
			if (!m_bHorizSize)
				m_clrCurrentBack = m_clrDynBack;
			else
			{
				if (m_bFlag2)
					m_clrCurrentBack = m_clrDynBack;
				else
				{
					m_clrCurrentBack = RGB(230, 241, 249);
					m_clrCurrentLine = RGB(230, 241, 249);
					m_clrCurrentFore = RGB(230, 241, 249);
				}

				m_bFlag2 = !m_bFlag2;
			}
		}
	}
	if (m_bDynLine == 1)
	{
		CRealComputer com;
		com.SetFormula(m_strDynLineCon);
		int tmp = com.GetResult();

		if (tmp)
		{
			if (!m_bHorizSize)
				m_clrCurrentLine = m_clrDynLine;
			else
			{
				if (m_bFlag3)
					m_clrCurrentLine = m_clrDynLine;
				else
				{
					//m_clrCurrentBack = RGB( 230, 241, 249 );
					m_clrCurrentLine = RGB(230, 241, 249);
					//m_clrCurrentFore = RGB( 230, 241, 249 );
				}

				m_bFlag3 = !m_bFlag3;
			}
		}
	}

	// 判断是否显示；
	//if( m_strDynShow!="" && m_bDynShow==0 )		LOG4C((LOG_NOTICE, "m_strDynShow=< %s >,m_bDynShow = %d",m_strDynShow,m_bDynShow));
	if (m_bDynShow == 1)
	{
		CRealComputer com;
		com.SetFormula(m_strDynShow);
		m_bShow = (int)com.GetResult();

		////测试用
		//if( -1 != m_strDynShow.Find("Caross_1_StartORShutStatus") )
		//{
		//	if( m_bShow==0 )
		//		m_bShow = 1;
		//	else
		//		m_bShow = 0;
		//}
		//if( -1 != m_strDynShow.Find("Caross_2_StartORShutStatus") )
		//{
		//	if( m_bShow==0 )
		//		m_bShow = 1;
		//	else
		//		m_bShow = 0;
		//}
	}

	RECT = m_rect;
	return true;
}

CDrawObj* CDrawObj::Clone(void)
{
	CDrawObj *pObj = new CDrawObj;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strLineType = m_strLineType;
	pObj->m_clrLine = m_clrLine;
	pObj->m_clrFore = m_clrFore;
	pObj->m_clrBack = m_clrBack;
	pObj->m_clrLine = m_clrLine;
	pObj->m_strCaption = m_strCaption;
	pObj->m_logfont = m_logfont;

	pObj->m_nLineWidth = m_nLineWidth;
	pObj->m_bVariant = m_bVariant;
	pObj->m_bDynShow = m_bDynShow;
	pObj->m_strDynShow = m_strDynShow;

	pObj->m_clrDynFore = m_clrDynFore;
	pObj->m_strDynForeCon = m_strDynForeCon;
	pObj->m_clrDynBack = m_clrDynBack;
	pObj->m_strDynBackCon = m_strDynBackCon;
	pObj->m_clrDynLine = m_clrDynLine;
	pObj->m_strDynLineCon = m_strDynLineCon;
	pObj->m_bDynFore = m_bDynFore;
	pObj->m_bDynBack = m_bDynBack;
	pObj->m_bDynLine = m_bDynLine;

	pObj->m_strHoriPos = m_strHoriPos;
	pObj->m_strHoriSize = m_strHoriSize;
	pObj->m_strVertiPos = m_strVertiPos;
	pObj->m_strVertiSize = m_strVertiSize;
	pObj->m_bVertiSize = m_bVertiSize;
	pObj->m_bVertiPos = m_bVertiPos;
	pObj->m_bHorizSize = m_bHorizSize;
	pObj->m_bHorizPos = m_bHorizPos;
	pObj->m_downAction = m_downAction;
	pObj->m_upAction = m_upAction;
	pObj->m_moveAction = m_moveAction;
	pObj->m_bOnButtonUp = m_bOnButtonUp;
	pObj->m_bOnButtonDown = m_bOnButtonDown;
	pObj->m_bOnMove = m_bOnMove;
	return pObj;
}

void CDrawObj::Serialize(CArchive& ar)
{
	CObject::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_rect;
		ar << m_clrFore;		// 前景色
		ar << m_clrLine;		// 线色
		ar << m_clrBack;		// 背景色
		ar << m_clrFill;		// 填充色
		ar << m_nLineWidth;
		ar << m_strLineType;
		ar << m_strCaption;
		ar << m_bVariant;

		ar << m_clrDynFore;
		ar << m_strDynForeCon;
		ar << m_bDynFore;
		ar << m_clrDynBack;
		ar << m_strDynBackCon;
		ar << m_clrDynLine;
		ar << m_strDynLineCon;
		ar << m_bDynBack;
		ar << m_bDynLine;

		ar << m_bDynShow;
		ar << m_strDynShow;
		//if( m_strDynShow!="" )	LOG4C((LOG_NOTICE, "m_strDynShow=< %s >,m_bDynShow = %d",m_strDynShow,m_bDynShow));
		ar << m_strHoriPos;
		ar << m_strHoriSize;
		ar << m_strVertiPos;
		ar << m_strVertiSize;
		ar << m_bVertiSize;
		ar << m_bVertiPos;
		ar << m_bHorizSize;
		ar << m_bHorizPos;
		ar << m_bOnButtonUp;
		ar << m_bOnButtonDown;
		ar << m_bOnMove;

		ar << m_nHorAlign;
		ar << m_nVerAlign;
		ar << m_nFillMode;

		ar.Write(&m_logfont, sizeof(LOGFONT));
	}
	else
	{
		ar >> m_rect;
		ar >> m_clrFore;		// 前景色
		ar >> m_clrLine;		// 线色
		ar >> m_clrBack;		// 背景色
		ar >> m_clrFill;		// 填充色
		ar >> m_nLineWidth;
		ar >> m_strLineType;
		ar >> m_strCaption;
		ar >> m_bVariant;

		ar >> m_clrDynFore;
		ar >> m_strDynForeCon;
		ar >> m_bDynFore;
		ar >> m_clrDynBack;
		ar >> m_strDynBackCon;
		ar >> m_clrDynLine;
		ar >> m_strDynLineCon;
		ar >> m_bDynBack;
		ar >> m_bDynLine;

		ar >> m_bDynShow;
		ar >> m_strDynShow;
		//if( m_strDynShow!="" )	LOG4C((LOG_NOTICE, "m_strDynShow=< %s >,m_bDynShow = %d",m_strDynShow,m_bDynShow));
		ar >> m_strHoriPos;
		ar >> m_strHoriSize;
		ar >> m_strVertiPos;
		ar >> m_strVertiSize;
		ar >> m_bVertiSize;
		ar >> m_bVertiPos;
		ar >> m_bHorizSize;
		ar >> m_bHorizPos;
		ar >> m_bOnButtonUp;
		ar >> m_bOnButtonDown;
		ar >> m_bOnMove;

		ar >> m_nHorAlign;
		ar >> m_nVerAlign;
		ar >> m_nFillMode;

		ar.Read(&m_logfont, sizeof(LOGFONT));
		m_rctCurrent = m_rect;
	}
	m_downAction.Serialize(ar);
	m_upAction.Serialize(ar);
	m_moveAction.Serialize(ar);

	m_clrCurrentLine = m_clrLine;
	m_clrCurrentFore = m_clrFore;
	m_clrCurrentBack = m_clrBack;
}

BOOL CDrawObj::OnAttrib(void)
{// 可设置成回调函数,让外部实现回调细节;
	CPropertySheet sheet;
	CBaseProDlg pageBase;
	pageBase.m_clrBack = m_clrBack;
	pageBase.m_clrFore = m_clrFore;
	pageBase.m_clrLine = m_clrLine;
	pageBase.m_clrFill = m_clrFill;
	pageBase.m_logfont = m_logfont;
	pageBase.m_strCaption = m_strCaption;
	pageBase.m_strLineWidth.Format("%d", m_nLineWidth);
	pageBase.m_strLineType = m_strLineType;
	pageBase.m_bDynShow = m_bDynShow;
	pageBase.m_strShowCondition = m_strDynShow;
	pageBase.m_bVariant = m_bVariant;
	pageBase.m_nFillMode = m_nFillMode;
	sheet.AddPage(&pageBase);

	// 编辑多个
	if (m_bModifyMore)
	{
		//CDataPage page;
		//page.m_nFormat = 1;
		//sheet.AddPage(&page);
		pageBase.m_bMoreEdit = true;
		sheet.Construct(g_strParamSet);
		sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

		if (sheet.DoModal() == IDOK)
		{
			m_clrBack = pageBase.m_clrBack;
			m_clrFore = pageBase.m_clrFore;
			m_clrLine = pageBase.m_clrLine;
			m_clrFill = pageBase.m_clrFill;
			m_logfont = pageBase.m_logfont;
			m_nLineWidth = atoi(pageBase.m_strLineWidth);
			m_strLineType = pageBase.m_strLineType;
			m_nFillMode = pageBase.m_nFillMode;

			for (int i = 0; i < (int)pageBase.m_vtbitmapList.size(); i++)
			{
				delete pageBase.m_vtbitmapList[i];
			}
			return TRUE;
		}

		for (int i = 0; i < (int)pageBase.m_vtbitmapList.size(); i++)
		{
			delete pageBase.m_vtbitmapList[i];
		}
		return FALSE;
	}

	CDynamicProPage pageDynamic;
	pageDynamic.m_clrForeColor = m_clrDynFore;
	pageDynamic.m_strForeColorCondition = m_strDynForeCon;
	pageDynamic.m_bForeColor = m_bDynFore;
	pageDynamic.m_strHoriPos = m_strHoriPos;
	pageDynamic.m_strHoriSize = m_strHoriSize;
	pageDynamic.m_strVertiPos = m_strVertiPos;
	pageDynamic.m_strVertiSize = m_strVertiSize;
	pageDynamic.m_bVertiSize = m_bVertiSize;
	pageDynamic.m_bVertiPos = m_bVertiPos;
	pageDynamic.m_bHorizSize = m_bHorizSize;
	pageDynamic.m_bHorizPos = m_bHorizPos;
	pageDynamic.m_bBackColor = m_bDynBack;
	pageDynamic.m_bLineColor = m_bDynLine;
	pageDynamic.m_clrBackColor = m_clrDynBack;
	pageDynamic.m_clrLineColor = m_clrDynLine;
	pageDynamic.m_strBackColorCondition = m_strDynBackCon;
	pageDynamic.m_strFLineColorCondition = m_strDynLineCon;
	pageDynamic.m_downAction = m_downAction;
	pageDynamic.m_upAction = m_upAction;
	pageDynamic.m_moveAction = m_moveAction;
	pageDynamic.m_bOnButtonUp = m_bOnButtonUp;
	pageDynamic.m_bOnButtonDown = m_bOnButtonDown;
	//pageDynamic.m_bOnMove = m_bOnMove;

	pageDynamic.m_nHorAlign = m_nHorAlign;
	pageDynamic.m_nVerAlign = m_nVerAlign;

	sheet.AddPage(&pageDynamic);

	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (OnAttrib(sheet))
	{
		m_clrBack = pageBase.m_clrBack;
		m_clrFore = pageBase.m_clrFore;
		m_clrLine = pageBase.m_clrLine;
		m_clrFill = pageBase.m_clrFill;
		m_logfont = pageBase.m_logfont;
		m_strCaption = pageBase.m_strCaption;
		m_nLineWidth = atoi(pageBase.m_strLineWidth);
		m_strLineType = pageBase.m_strLineType;
		m_bDynShow = pageBase.m_bDynShow;
		m_strDynShow = pageBase.m_strShowCondition;
		m_bVariant = pageBase.m_bVariant;
		m_nFillMode = pageBase.m_nFillMode;

		m_clrDynFore = pageDynamic.m_clrForeColor;
		m_strDynForeCon = pageDynamic.m_strForeColorCondition;
		m_bDynBack = pageDynamic.m_bBackColor;
		m_bDynLine = pageDynamic.m_bLineColor;
		m_clrDynBack = pageDynamic.m_clrBackColor;
		m_clrDynLine = pageDynamic.m_clrLineColor;
		m_strDynBackCon = pageDynamic.m_strBackColorCondition;
		m_strDynLineCon = pageDynamic.m_strFLineColorCondition;

		m_bDynFore = pageDynamic.m_bForeColor;
		m_strHoriPos = pageDynamic.m_strHoriPos;
		m_strHoriSize = pageDynamic.m_strHoriSize;
		m_strVertiPos = pageDynamic.m_strVertiPos;
		m_strVertiSize = pageDynamic.m_strVertiSize;
		m_bVertiSize = pageDynamic.m_bVertiSize;
		m_bVertiPos = pageDynamic.m_bVertiPos;
		m_bHorizSize = pageDynamic.m_bHorizSize;
		m_bHorizPos = pageDynamic.m_bHorizPos;
		m_downAction = pageDynamic.m_downAction;
		m_upAction = pageDynamic.m_upAction;
		m_moveAction = pageDynamic.m_moveAction;

		m_bOnButtonUp = pageDynamic.m_bOnButtonUp;
		m_bOnButtonDown = pageDynamic.m_bOnButtonDown;
		//m_bOnMove = pageDynamic.m_bOnMove;
		m_nHorAlign = pageDynamic.m_nHorAlign;
		m_nVerAlign = pageDynamic.m_nVerAlign;

		for (int i = 0; i < (int)pageBase.m_vtbitmapList.size(); i++)
		{
			//m_vtbitmapList.pop_back();
			delete pageBase.m_vtbitmapList[i];
		}
		Invalidate();
		return TRUE;
	}

	for (int i = 0; i < (int)pageBase.m_vtbitmapList.size(); i++)
	{
		//m_vtbitmapList.pop_back();
		delete pageBase.m_vtbitmapList[i];
	}
	return FALSE;
}

BOOL CDrawObj::OnAttrib(CPropertySheet& sheet)
{
	CString strName;
	int nSize = drawsRuntimeClass.GetSize();

	int i = 0;
	for (i = 0; i < nSize; i++)
	{
		CRuntimeClass* pRuntimeClass = (CRuntimeClass*)drawsRuntimeClass[i];
		if (IsKindOf(pRuntimeClass))
		{
			strName = drawsName[i];
			break;
		}
	}
	if (i == nSize) return FALSE;

	sheet.Construct(g_strParamSet);
	if (sheet.DoModal() == IDOK)
	{
		return TRUE;
	}
	return FALSE;
}

void CDrawObj::Draw(CDC* pDC)
{
	if (!g_bRun)
	{// 编辑状态下;
		m_clrCurrentLine = m_clrLine;
		m_clrCurrentFore = m_clrFore;
		m_clrCurrentBack = m_clrBack;
	}
}

void CDrawObj::DrawText(CDC* pDC)
{
	COLORREF clrFore = m_clrFore;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrFore = m_clrCurrentFore;
		rect = m_rctCurrent;
	}
	pDC->SetTextColor(clrFore);
	pDC->SetTextAlign(TA_CENTER | TA_TOP);

	CFont font;
	font.CreateFontIndirect(&m_logfont);
	CFont* pOldFont = pDC->SelectObject(&font);
	int height = abs(m_logfont.lfHeight);
	rect.NormalizeRect();
	int nX0 = (rect.left + rect.right) / 2;
	int nY0 = (rect.top + rect.bottom) / 2;
	if (rect.Width() >= rect.Height())
	{
		pDC->TextOut(nX0, nY0 - height / 2, m_strCaption);
	}
	else
	{
		int xt = nX0;
		int yt = nY0;
		int Length = m_strCaption.GetLength();
		const char *p = (const char*)m_strCaption;
		int ystart = yt;
		int i = 0;
		for (i = 0; i < Length; i++)
		{
			ystart -= height / 2;
			if (*(p + i) < 0) i++;
		}
		for (i = 0; i < Length; i++)
		{
			if (*(p + i) < 0)
			{
				pDC->TextOut(xt, ystart, p + i, 2);
				i++;
			}
			else pDC->TextOut(xt, ystart, p + i, 1);
			ystart += height;
		}
	}

	pDC->SelectObject(pOldFont);
	DeleteObject(font);
}

/************************************************************************/
/*  函数：Layout[10/30/2016 Home];
/*  描述：布局图元;
/*  参数：;
/*  	[IN] Sharp：要布局的图元形状;
/*  	[IN/OUT] pLayout：布局信息;
/*  返回：void;
/*  注意：;
/*  示例：;
/*
/*  修改：;
/*  日期：;
/*  内容：;
/************************************************************************/
void CDrawObj::Layout(IN BYTE Sharp, IN OUT LAYOUTSTRUCT* pLayout)
{
	ASSERT(Sharp > 0);
	pLayout->rect = m_rect;
	pLayout->rect.NormalizeRect();
	pLayout->nX1 = pLayout->rect.left;
	pLayout->nX2 = pLayout->rect.right;
	pLayout->nY1 = pLayout->rect.top;
	pLayout->nY2 = pLayout->rect.bottom;
	pLayout->nXX = pLayout->nX2 - pLayout->nX1;
	pLayout->nYY = pLayout->nY2 - pLayout->nY1;
	pLayout->nX0 = (pLayout->nX1 + pLayout->nX2) / 2;
	pLayout->nY0 = (pLayout->nY1 + pLayout->nY2) / 2;
	pLayout->bXInvert = m_rect.left > m_rect.right;
	pLayout->bYInvert = m_rect.top > m_rect.bottom;
	if (pLayout->nXX >= pLayout->nYY)
	{
		pLayout->bHoriz = TRUE;
		pLayout->nMinSize = min(pLayout->nXX / Sharp, pLayout->nYY);
	}
	else
	{
		pLayout->bHoriz = FALSE;
		pLayout->nMinSize = min(pLayout->nXX, pLayout->nYY / Sharp);
	}
}

int CDrawObj::GetHandleCount(void)
{
	return 8;
}

CPoint CDrawObj::GetHandle(int nHandle)
{
#if 0
	int x, y, xCenter, yCenter;

	xCenter = m_rect.left + m_rect.Width() / 2;
	yCenter = m_rect.top + m_rect.Height() / 2;

	switch (nHandle)
	{
	case 1:	x = m_rect.left; 	y = m_rect.top; 	break;
	case 2:	x = xCenter;		y = m_rect.top; 	break;
	case 3:	x = m_rect.right;	y = m_rect.top;		break;
	case 4:	x = m_rect.right;	y = yCenter;		break;
	case 5:	x = m_rect.right;	y = m_rect.bottom;	break;
	case 6:	x = xCenter;		y = m_rect.bottom;	break;
	case 7:	x = m_rect.left;	y = m_rect.bottom;	break;
	case 8:	x = m_rect.left;	y = yCenter;		break;
	}
	return CPoint(x, y);
#else
	if (nHandle == 1)
		return CPoint(m_rect.left, m_rect.top);
	else if (nHandle == 2)
		return CPoint(m_rect.left + m_rect.Width() / 2, m_rect.top);
	else if (nHandle == 3)
		return CPoint(m_rect.right, m_rect.top);
	else if (nHandle == 4)
		return CPoint(m_rect.right, m_rect.top + m_rect.Height() / 2);
	else if (nHandle == 5)
		return CPoint(m_rect.right, m_rect.bottom);
	else if (nHandle == 6)
		return CPoint(m_rect.left + m_rect.Width() / 2, m_rect.bottom);
	else if (nHandle == 7)
		return CPoint(m_rect.left, m_rect.bottom);
	else if (nHandle == 8)
		return CPoint(m_rect.left, m_rect.top + m_rect.Height() / 2);

	return CPoint(0, 0);
#endif
}

CRect CDrawObj::GetHandleRect(int nHandle)
{
	CRect rect;
	CPoint point = GetHandle(nHandle);
	rect.SetRect(point.x - 3, point.y - 3, point.x + 3, point.y + 3);
	return rect;
}

HCURSOR CDrawObj::GetHandleCursor()
{
	return AfxGetApp()->LoadCursor(IDC_CURSOR2);
}


void CDrawObj::MoveTo(CRect rect)
{
	if (rect == m_rect) return;

	Invalidate();
	m_rect = rect;
	Invalidate();
}

void CDrawObj::MoveHandleTo(int nHandle, CPoint point)
{
	CRect rect = m_rect;
	switch (nHandle)
	{
	case 1:	rect.left = point.x;	rect.top = point.y;		break;
	case 2:	rect.top = point.y;	break;
	case 3:	rect.right = point.x;	rect.top = point.y;		break;
	case 4:	rect.right = point.x;	break;
	case 5:	rect.right = point.x;	rect.bottom = point.y;	break;
	case 6:	rect.bottom = point.y;	break;
	case 7:	rect.left = point.x;	rect.bottom = point.y;	break;
	case 8:	rect.left = point.x;	break;
	}
	MoveTo(rect);
}

void CDrawObj::DrawTracker(CDC* pDC)
{
	// 除CDrawPoly对象外,其他图元都是返回8个点;
	int nHandleCount = GetHandleCount();
	for (int nHandle = 1; nHandle <= nHandleCount; nHandle++)
	{
		CPoint handle = GetHandle(nHandle);
		pDC->PatBlt(handle.x - 3, handle.y - 3, 7, 7, DSTINVERT);
	}
}

int CDrawObj::HitTest(CPoint point)
{
	int nHandleCount = GetHandleCount();
	for (int nHandle = 1; nHandle <= nHandleCount; nHandle++)
	{
		CRect rc = GetHandleRect(nHandle);
		if (rc.PtInRect(point)) return nHandle;
	}
	return 0;
}

BOOL CDrawObj::Intersects(CRect rect)
{
	CRect fixed = m_rect;
	fixed.NormalizeRect();
	CRect rectT = rect;
	rectT.NormalizeRect();
	return !(rectT & fixed).IsRectEmpty();
}

void CDrawObj::Invalidate(void)
{
	CRect rect = m_rect;
	rect.NormalizeRect();
	rect.InflateRect(5, 5, 5, 5);
	CClientDC dc(m_pView);
	m_pView->OnPrepareDC(&dc);
	dc.LPtoDP(&rect);
	m_pView->InvalidateRect(rect, FALSE);
}

int CDrawObj::GetPenStyle(CString penType)
{
	if (penType == "PS_SOLID")
	{
		return PS_SOLID;
	}
	else if (penType == "PS_DASH")
	{
		return PS_DASH;
	}
	else if (penType == "PS_DOT")
	{
		return PS_DOT;
	}
	else if (penType == "PS_DASHDOT")
	{
		return PS_DASHDOT;
	}
	else if (penType == "PS_DASHDOTDOT")
	{
		return PS_DASHDOTDOT;
	}
	else if (penType == "PS_NULL")
	{
		return PS_NULL;
	}
	return PS_SOLID;
}

// 控制类型：
//		遥控：控分；控合；取反
//		遥设：设定；固定；动态输入
//		      增减；固定；动态
void CDrawObj::ProcessAction(int type)
{
	CAction action;
	switch (type)
	{
	case MOUSE_CLICK_DOWN:
		action = m_downAction;		break;
	case MOUSE_CLICK_UP:
		action = m_upAction;		break;
	case MOUSE_MOVE:
		action = m_moveAction;		break;
	};

	// exit
	if (action.m_nActionType == EXIT_COMMOND)
	{
		CMainFrame *pFrame = (CMainFrame*)AfxGetApp()->m_pMainWnd;
		pFrame->OnSuperEnd();
		return;
	}

	// link
	else if (action.m_nActionType == LINK_COMMOND)
	{
		char picDir[_MAX_PATH] = { 0 };
		strcpy(picDir, g_strDirectory);
		strcat(picDir, "\\");
		strcat(picDir, _PICTUREDIR);
		strcat(picDir, action.m_strVariant);
		strcat(picDir, ".view");
		//CString str;
		//str = action.m_strPicPath + ".view";
		CMainFrame *pFrame = (CMainFrame*)AfxGetApp()->m_pMainWnd;
		pFrame->AddIDEView(action.m_strVariant, picDir);
		return;
	}
	// extern link
	else if (action.m_nActionType == EXTERN_COMMOND)
	{
		ShellExecute(0, "open", action.m_strActionValue, NULL, NULL, SW_SHOWNORMAL);
	}
	// 测试报警
	else if (action.m_nActionType == TEST_ALARM)
	{

	}
	// 报警记录
	else if (action.m_nActionType == ALARM_RECORD)
	{

	}
	// 通知记录
	else if (action.m_nActionType == NOTICE_RECORD)
	{

	}
	// 设备日志
	else if (action.m_nActionType == DEVICE_LOG)
	{
		CString strFileName;
		//strFileName.Format("%s\\Query.exe", g_strDirectory); 
		//ShellExecute(0, "open", strFileName, NULL, NULL, SW_SHOWNORMAL); 
	}
	// 系统日志
	else if (action.m_nActionType == SYSTEM_LOG)
	{

	}
	// 变量管理
	else if (action.m_nActionType == VAR_MANAGE)
	{

	}
	// 用户管理
	else if (action.m_nActionType == USER_MANAGE)
	{

	}
	// 修改密码
	else if (action.m_nActionType == PWD_MANAGE)
	{
	}
	// 首页设置
	else if (action.m_nActionType == FIRST_PAGE)
	{
		CSystemParaSetDlg dlg;
		dlg.m_bStartRun = g_bStartRun;
		dlg.m_bAlarmVoice = g_bAlarmVoice;
		dlg.m_bEventAlarm = g_bEventAlarm;
		dlg.m_bHideTask = g_bHideTask;
		dlg.m_strStartPic = g_strStartPic;
		dlg.m_strStartPath = g_strStartPath;
		if (dlg.DoModal() == IDOK)
		{
#if 0	//程序退出之前不改变状态
			g_bStartRun = dlg.m_bStartRun;
#endif
			//int nPos = dlg.m_strStartPath.Find("\\\\");
			//if( nPos!=-1 )
			//{
			//	dlg.m_strStartPath.Delete( nPos );
			//}
			//
			//int nLen = dlg.m_strStartPath.GetLength();
			//nPos = dlg.m_strStartPath.Find("view");
			//CString sTemp;
			//if( nPos<nLen-7 )
			//	sTemp = dlg.m_strStartPath.Right( nLen-nPos-7 );
			//if( sTemp!="" )
			//	g_strStartPic = sTemp+"\\"+dlg.m_strStartPic;
			//else
			g_strStartPic = dlg.m_strStartPic;
			g_strStartPath = dlg.m_strStartPath;
			g_bEventAlarm = dlg.m_bEventAlarm;
			g_bAlarmVoice = dlg.m_bAlarmVoice;
			g_bHideTask = dlg.m_bHideTask;
			g_pMainFrm->StoreRunPara(dlg.m_bStartRun);
		}
	}
	// 导航树
	else if (action.m_nActionType == NAVIGATION_TREE)
	{
		g_pMainFrm->m_hleftDockBar.ShowWindow(SW_SHOW);
		SendMessage(g_pMainFrm->m_hleftDockBar, WM_MY_INVALIDATE, 0, 0);
	}

	// set yt SET_COMMOND为设置  YT_COMMOND为调节
	if ((action.m_nActionType == SET_COMMOND) || (action.m_nActionType == YT_COMMOND))
	{
		if (g_bHaveControlPwd)
		{
			CDlg_Pwd Dlg_Pwd;
			Dlg_Pwd.m_nShowType = 1;
			if (Dlg_Pwd.DoModal() != IDOK)
				return;
		}

		if (m_downAction.m_strActionValue == "")
		{
			CDataInputDlg dlg;
			dlg.m_strVarName = action.m_strVariant;
			if (dlg.DoModal() == IDOK)
			{
				action.m_strActionValue = dlg.m_strData;
			}
			else
			{
				return;
			}
		}
		else
		{
			MessageBox(NULL, "命令已经发送", "提示", MB_OK);
		}
	}

	// yk 控制
	if (action.m_nActionType == YK_COMMOND)
	{
		if (g_bHaveControlPwd)
		{
			CDlg_Pwd Dlg_Pwd;
			Dlg_Pwd.m_nShowType = 1;
			if (Dlg_Pwd.DoModal() != IDOK)
				return;
		}

		CYkCmdDlg dlg;
		if (m_downAction.m_strActionValue == "")
			dlg.m_strValue = "1-0";
		else
			dlg.m_strValue = m_downAction.m_strActionValue;

		if (dlg.DoModal() == IDOK)
		{
			action.m_strActionValue = dlg.m_strValue;
		}
		else
		{
			return;
		}
	}

	CCommondServer server;
	server.PushCommondToDevice(&action);
}


void CDrawObj::DrawFrame(CDC *pDC)
{
	CRect rect = m_rect;
	rect.NormalizeRect();
	CRect rectLeft = CRect(rect.left - 4, rect.top - 4, rect.left, rect.bottom);
	CRect rectBottom = CRect(rect.left - 4, rect.bottom, rect.right, rect.bottom + 4);
	CRect rectRight = CRect(rect.right, rect.top, rect.right + 4, rect.bottom + 4);
	CRect rectTop = CRect(rect.left, rect.top - 4, rect.right + 4, rect.top);

	pDC->FillSolidRect(rectLeft, RGB(0, 0, 255));
	pDC->FillSolidRect(rectBottom, RGB(0, 0, 255));
	pDC->FillSolidRect(rectRight, RGB(0, 0, 255));
	pDC->FillSolidRect(rectTop, RGB(0, 0, 255));
}


void CDrawObj::DrawVKedu(CDC* pDC, CRect rect, int nKedu, COLORREF clrKedu)
{
	CPen pen(PS_SOLID, 1, clrKedu);
	CPen *pOldPen = pDC->SelectObject(&pen);
	pDC->MoveTo(rect.TopLeft());
	pDC->LineTo(rect.left, rect.bottom);
	//for(int i=0;i<=nKedu;i++)
	//{
	//	int nY = rect.top + i*(rect.Height()*1.0/nKedu);
	//	if (i == nKedu )
	//		nY = rect.bottom;
	//	pDC->MoveTo(rect.left, nY);
	//	pDC->LineTo(rect.right, nY);
	//}
	pDC->SelectObject(pOldPen);
	DeleteObject(pen);
}


void CDrawObj::DrawHKedu(CDC* pDC, CRect rect, int nKedu, COLORREF clrKedu)
{
	CPen pen(PS_SOLID, 1, clrKedu);
	CPen *pOldPen = pDC->SelectObject(&pen);
	pDC->MoveTo(rect.right, rect.bottom);
	pDC->LineTo(rect.left, rect.bottom);
	for (int i = 0; i <= nKedu; i++)
	{
		int nX = rect.left + i*(rect.Width()*1.0 / nKedu);
		pDC->MoveTo(nX, rect.top);
		pDC->LineTo(nX, rect.bottom);
	}
	pDC->SelectObject(pOldPen);
	DeleteObject(pen);
}


void CDrawObj::DrawArcKedu(CDC* pDC, CRect rect, int nStartAngle, int nEndAngle, int nKedu, COLORREF clrKedu)
{
	CPen pen(PS_SOLID, 1, clrKedu);
	CPen *pOldPen = pDC->SelectObject(&pen);
	pDC->SelectObject(pOldPen);
	DeleteObject(pen);
}

LOGBRUSH CDrawObj::GetBrush()
{
	LOGBRUSH brushlog;
	brushlog.lbColor = m_clrCurrentBack;
	if (m_nFillMode == 0)
		brushlog.lbStyle = BS_NULL;
	else if (m_nFillMode == 1)
		brushlog.lbStyle = BS_SOLID;
	else if (m_nFillMode < 8)
	{
		brushlog.lbStyle = BS_HATCHED;
		brushlog.lbHatch = m_nFillMode - 2;
	}
	else
		brushlog.lbStyle = BS_SOLID;
	return brushlog;
}



//---------------------------------------------- CDrawComposite ---
IMPLEMENT_SERIAL(CDrawComposite, CDrawObj, 0)

CDrawComposite::CDrawComposite() :CDrawObj()
{
}


CDrawComposite::CDrawComposite(CDrawObjList &ObjList) : CDrawObj()
{
	m_ObjList.RemoveAll();
	POSITION pos = ObjList.GetHeadPosition();
	bool bFirst = true;
	while (pos != NULL)
	{
		CDrawObj *pObj = ObjList.GetNext(pos);
		CDrawObj *pNewObj = pObj->Clone();
		m_ObjList.AddTail(pNewObj);
		if (bFirst)
		{
			m_rect = pNewObj->m_rect;
			bFirst = false;
		}
		else
		{
			int nLeft = min(m_rect.left, pNewObj->m_rect.left);
			int nTop = min(m_rect.top, pNewObj->m_rect.top);
			int nBottom = max(m_rect.bottom, pNewObj->m_rect.bottom);
			int nRight = max(m_rect.right, pNewObj->m_rect.right);
			m_rect = CRect(nLeft, nTop, nRight, nBottom);
		}
	}

	pos = m_ObjList.GetHeadPosition();
	while (pos != NULL)
	{
		CDrawObj *pObj = m_ObjList.GetNext(pos);
		pObj->m_dbLeftRate = (pObj->m_rect.left - m_rect.left)*1.0 / m_rect.Width();
		pObj->m_dbRightRate = (pObj->m_rect.right - m_rect.left)*1.0 / m_rect.Width();
		pObj->m_dbTopRate = (pObj->m_rect.top - m_rect.top)*1.0 / m_rect.Height();
		pObj->m_dbBottomRate = (pObj->m_rect.bottom - m_rect.top)*1.0 / m_rect.Height();
	}
}

CDrawComposite::~CDrawComposite()
{
	POSITION pos = m_ObjList.GetHeadPosition();
	while (pos != NULL) delete m_ObjList.GetNext(pos);
	m_ObjList.RemoveAll();
}


CDrawComposite& CDrawComposite::operator=(CDrawComposite& drawObj)
{
	CDrawComposite* pComposite = new CDrawComposite();
	return *pComposite;
}


CDrawObj* CDrawComposite::Clone(void)
{
	CDrawComposite* pComposite = new CDrawComposite();
	*((CDrawObj*)pComposite) = *(CDrawObj*)this;

	pComposite->m_ObjList.RemoveAll();
	POSITION pos = m_ObjList.GetHeadPosition();
	bool bFirst = true;
	while (pos != NULL)
	{
		CDrawObj *pObj = m_ObjList.GetNext(pos);
		CDrawObj *pNewObj = pObj->Clone();
		pComposite->m_ObjList.AddTail(pNewObj);
		if (bFirst)
		{
			pComposite->m_rect = pNewObj->m_rect;
			bFirst = false;
		}
		else
		{
			int nLeft = min(pComposite->m_rect.left, pNewObj->m_rect.left);
			int nTop = min(pComposite->m_rect.top, pNewObj->m_rect.top);
			int nBottom = max(pComposite->m_rect.bottom, pNewObj->m_rect.bottom);
			int nRight = max(pComposite->m_rect.right, pNewObj->m_rect.right);
			pComposite->m_rect = CRect(nLeft, nTop, nRight, nBottom);
		}
	}

	pos = pComposite->m_ObjList.GetHeadPosition();
	while (pos != NULL)
	{
		CDrawObj *pObj = pComposite->m_ObjList.GetNext(pos);
		pObj->m_dbLeftRate = (pObj->m_rect.left - pComposite->m_rect.left)*1.0 / pComposite->m_rect.Width();
		pObj->m_dbRightRate = (pObj->m_rect.right - pComposite->m_rect.left)*1.0 / pComposite->m_rect.Width();
		pObj->m_dbTopRate = (pObj->m_rect.top - pComposite->m_rect.top)*1.0 / pComposite->m_rect.Height();
		pObj->m_dbBottomRate = (pObj->m_rect.bottom - pComposite->m_rect.top)*1.0 / pComposite->m_rect.Height();
	}

	return pComposite;
}


void CDrawComposite::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	m_ObjList.Serialize(ar);

	POSITION pos = m_ObjList.GetHeadPosition();
	while (pos != NULL)
	{
		CDrawObj *pObj = m_ObjList.GetNext(pos);
		pObj->m_dbLeftRate = (pObj->m_rect.left - m_rect.left)*1.0 / m_rect.Width();
		pObj->m_dbRightRate = (pObj->m_rect.right - m_rect.left)*1.0 / m_rect.Width();
		pObj->m_dbTopRate = (pObj->m_rect.top - m_rect.top)*1.0 / m_rect.Height();
		pObj->m_dbBottomRate = (pObj->m_rect.bottom - m_rect.top)*1.0 / m_rect.Height();
	}
}


void CDrawComposite::Draw(CDC* pDC)
{
	POSITION pos = m_ObjList.GetHeadPosition();
	while (pos != NULL)
	{
		CDrawObj* pObj = m_ObjList.GetNext(pos);
		CRect rect = pObj->m_rect;
		rect.NormalizeRect();
		rect.InflateRect(5, 5, 5, 5);
		if (rect.IntersectRect(&rect, &m_rect))
		{
			pObj->Draw(pDC);
		}
	}
}

void CDrawComposite::MoveTo(CRect rect)
{
	if (rect == m_rect)
	{
		return;
	}

	POSITION pos = m_ObjList.GetHeadPosition();
	while (pos != NULL)
	{
		CDrawObj* pObj = m_ObjList.GetNext(pos);
		pObj->m_rect.left = rect.left + pObj->m_dbLeftRate*rect.Width();
		pObj->m_rect.right = rect.left + pObj->m_dbRightRate*rect.Width();
		pObj->m_rect.top = rect.top + pObj->m_dbTopRate * rect.Height();
		pObj->m_rect.bottom = rect.top + pObj->m_dbBottomRate * rect.Height();
	}

	m_rect = rect;
	Invalidate();
}


//////////////////////////////////////////////////////////////////////////
//---------------------------------------------- CDrawTLine --------
IMPLEMENT_SERIAL(CDrawTLine, CDrawObj, 0)

CDrawTLine::CDrawTLine() :CDrawObj()
{
}

CDrawObj* CDrawTLine::Clone(void)
{
	CDrawTLine *pObj = new CDrawTLine;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawTLine::Draw(CDC* pDC)
{
	COLORREF clrLine = m_clrLine;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		rect = m_rctCurrent;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);
	rect.NormalizeRect();
	if (rect.Width() >= rect.Height())
	{
		int nY0 = (rect.top + rect.bottom) / 2;
		pDC->MoveTo(rect.left, nY0);
		pDC->LineTo(rect.right, nY0);
	}
	else
	{
		int nX0 = (rect.left + rect.right) / 2;
		pDC->MoveTo(nX0, rect.top);
		pDC->LineTo(nX0, rect.bottom);
	}
	pDC->SelectObject(pOldPen);
	DeleteObject(pen);
}



//////////////////////////////////////////////////////////////////////////
//---------------------------------------------- CDrawLine --------
IMPLEMENT_SERIAL(CDrawLine, CDrawObj, 0)

CDrawLine::CDrawLine() :CDrawObj()
{
}

CDrawObj* CDrawLine::Clone(void)
{
	CDrawLine *pObj = new CDrawLine;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawLine::Draw(CDC* pDC)
{
	COLORREF clrLine = m_clrLine;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		rect = m_rctCurrent;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);
	pDC->MoveTo(rect.left, rect.top);
	pDC->LineTo(rect.right, rect.bottom);
	pDC->SelectObject(pOldPen);

	DeleteObject(pen);
}



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

//---------------------------------------------- CDrawText --------
IMPLEMENT_SERIAL(CDrawText, CDrawObj, 0)

CDrawText::CDrawText() :CDrawObj()
{
	m_strCaption = g_strCharacter;
	m_clrFore = RGB(0, 0, 0);
}

CDrawObj* CDrawText::Clone(void)
{
	CDrawText *pObj = new CDrawText;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}
bool CDrawText::Fresh(CRect &RECT)
{
	CDrawObj::Fresh(RECT);

	//Invalidate( );
	RECT = m_rect;
	return true;
}
void CDrawText::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	if (!pDC->IsPrinting())
	{// 非打印状态下;
		CRect rectRgn = m_rctCurrent;
		if (!bRuning) rectRgn = m_rect;
		rectRgn.NormalizeRect();
		pDC->LPtoDP(&rectRgn);
		CRgn rgn;
		rgn.CreateRectRgnIndirect(&rectRgn);
		pDC->SelectClipRgn(&rgn);
		DrawText(pDC);
		pDC->SelectClipRgn(NULL);

		DeleteObject(rgn);
	}
	else
		DrawText(pDC);
}

void CDrawText::DrawText(CDC* pDC)
{
	COLORREF clrFore = m_clrFore;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrFore = m_clrCurrentFore;
		rect = m_rctCurrent;
	}
	pDC->SetTextColor(clrFore);
	pDC->SetTextAlign(TA_LEFT | TA_TOP);

	CFont font;
	font.CreateFontIndirect(&m_logfont);
	CFont* pOldFont = pDC->SelectObject(&font);
	int height = abs(m_logfont.lfHeight);
	rect.NormalizeRect();
	//int nX0 = (rect.left+rect.right) / 2;
	//int nY0 = (rect.top+rect.bottom) / 2;
	//if(rect.Width()>=rect.Height())
	//{
	//	int yt = nY0;
	//	int Length = m_strCaption.GetLength();
	//	const char *p = (const char*)m_strCaption;
	//	int ystart = yt;
	//	for(int i=0;i<Length;i++)
	//	{
	//		ystart -= height / 2;
	//		if(*(p+i)<0) i++;
	//	}
	//	pDC->TextOut(rect.left, ystart, m_strCaption);
	//}
	//else
	//{
	//	int xt = nX0;
	//	int yt = nY0;
	//	int Length = m_strCaption.GetLength();
	//	const char *p = (const char*)m_strCaption;
	//	int ystart = yt;
	//	for(int i=0;i<Length;i++)
	//	{
	//		ystart -= height / 2;
	//		if(*(p+i)<0) i++;
	//	}
	//	for(i=0;i<Length;i++)
	//	{
	//		if(*(p+i)<0)
	//		{
	//			pDC->TextOut(xt,ystart,p+i,2);
	//			i++;
	//		}
	//		else pDC->TextOut(xt,ystart,p+i,1);
	//		ystart += height;
	//	}
	//}

	//pDC->SelectObject(pOldFont);
	//DeleteObject( font );

	int nX0 = (rect.left + rect.right) / 2;
	int nY0 = (rect.top + rect.bottom) / 2;

	CSize sizeText = pDC->GetTextExtent(m_strCaption);
	int nInterval = sizeText.cy / 2;
	int nYText = nY0 - nInterval + 1;

	int nXText;
	//pDC->SetTextAlign(TA_CENTER|TA_TOP);
	nXText = rect.left;

	//pDC->SetTextColor(txtColor);
	pDC->TextOut(nXText, nYText, m_strCaption);
	pDC->SelectObject(pOldFont);

	DeleteObject(font);
}


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

//---------------------------------------------- CDrawRect --------
IMPLEMENT_SERIAL(CDrawRect, CDrawObj, 0)

CDrawRect::CDrawRect() :CDrawObj()
{
}

CDrawObj* CDrawRect::Clone(void)
{
	CDrawRect *pObj = new CDrawRect;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strLineType = m_strLineType;
	pObj->m_clrLine = m_clrLine;
	return pObj;
}

void CDrawRect::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	COLORREF clrLine = m_clrCurrentLine;
	CRect rect = m_rctCurrent;
	if (!bRuning)
	{
		clrLine = m_clrLine;
		rect = m_rect;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);

	// CBrush
	LOGBRUSH brushlog = GetBrush();
	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);
	if (m_nFillMode < 8)
	{
		pDC->Rectangle(rect);
	}
	else	// 渐变填充
	{
		CGradient gradient;
		CRect tmp = rect;
		switch (m_nFillMode)
		{
		case 8:
			gradient.HorizontalGradient(pDC, rect, m_clrFill, m_clrBack);
			break;
		case 9:
			gradient.HorizontalGradient(pDC, rect, m_clrBack, m_clrFill);
			break;
		case 10:
			tmp.NormalizeRect();
			tmp.right = (tmp.left + tmp.right) / 2 + 1;
			gradient.HorizontalGradient(pDC, tmp, m_clrFill, m_clrBack);
			tmp = rect;
			tmp.NormalizeRect();
			tmp.left = (tmp.left + tmp.right) / 2 - 1;
			gradient.HorizontalGradient(pDC, tmp, m_clrBack, m_clrFill);
			break;
		case 11:
			gradient.VerticalGradient(pDC, rect, m_clrFill, m_clrBack);
			break;
		case 12:
			gradient.VerticalGradient(pDC, rect, m_clrBack, m_clrFill);
			break;
		case 13:
			tmp.NormalizeRect();
			tmp.top = (tmp.top + tmp.bottom) / 2 - 1;
			gradient.VerticalGradient(pDC, tmp, m_clrBack, m_clrFill);
			tmp = rect;
			tmp.NormalizeRect();
			tmp.bottom = (tmp.top + tmp.bottom) / 2 + 1;
			gradient.VerticalGradient(pDC, tmp, m_clrFill, m_clrBack);
			break;
		}
	}

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	DeleteObject(pen);
	DeleteObject(m_brush);
}



//---------------------------------------------- CDrawRoundRect --------
IMPLEMENT_SERIAL(CDrawRoundRect, CDrawObj, 0)

CDrawRoundRect::CDrawRoundRect() :CDrawObj()
{
}

CDrawObj* CDrawRoundRect::Clone(void)
{
	CDrawRoundRect *pObj = new CDrawRoundRect;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strLineType = m_strLineType;
	pObj->m_clrLine = m_clrLine;
	return pObj;
}

void CDrawRoundRect::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	COLORREF clrLine = m_clrCurrentLine;
	CRect rect = m_rctCurrent;
	if (!bRuning)
	{
		clrLine = m_clrLine;
		rect = m_rect;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);

	// CBrush
	LOGBRUSH brushlog = GetBrush();

	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);
	CPoint pt;
	pt.x = 20;
	pt.y = 20;
	pDC->RoundRect(rect, pt);

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	DeleteObject(pen);
	DeleteObject(m_brush);
}

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

//---------------------------------------------- CDrawOval --------
IMPLEMENT_SERIAL(CDrawOval, CDrawObj, 0)

CDrawOval::CDrawOval() :CDrawObj()
{
}

CDrawObj* CDrawOval::Clone(void)
{
	CDrawOval *pObj = new CDrawOval;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawOval::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	COLORREF clrLine = m_clrLine;
	COLORREF clrBack = m_clrBack;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrBack = m_clrCurrentBack;
		rect = m_rctCurrent;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);

	// CBrush
	LOGBRUSH brushlog = GetBrush();

	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);

	pDC->Ellipse(rect);
	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	DeleteObject(pen);
	DeleteObject(m_brush);
}


//---------------------------------------------- CDrawPie --------
IMPLEMENT_SERIAL(CDrawPie, CDrawObj, 0)

CDrawPie::CDrawPie() :CDrawObj()
{
	m_nStartAngle = 0;
	m_nSweepAngle = 90;
}


CDrawObj* CDrawPie::Clone(void)
{
	CDrawPie *pObj = new CDrawPie;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}


void CDrawPie::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	COLORREF clrLine = m_clrLine;
	COLORREF clrBack = m_clrBack;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrBack = m_clrCurrentBack;
		rect = m_rctCurrent;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);

	// CBrush
	LOGBRUSH brushlog = GetBrush();
	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);

	rect.NormalizeRect();

	// 根据角度计算两个点；
	CPoint s = CPoint(rect.right, (rect.top + rect.bottom) / 2);

	CRgn  rgn;
	rgn.CreateEllipticRgnIndirect(rect);

	int bLeft = (m_nSweepAngle > 90 && m_nSweepAngle < 270) ? -1 : 1;
	CPoint e;

	bool bIn = true;
	for (int i = 0; i < rect.Width() / 2; i++)
	{
		e.x = rect.CenterPoint().x + i*bLeft;
		e.y = rect.CenterPoint().y - i*bLeft*tan(m_nSweepAngle*PIE / 180);
		if (!rgn.PtInRegion(e))
		{
			break;
		}
	}
	pDC->Pie(&rect, s, e);
	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);
	DeleteObject(pen);
	DeleteObject(m_brush);
	DeleteObject(rgn);
}


BOOL CDrawPie::OnAttrib(CPropertySheet& sheet)
{
	CArcPage page;
	page.m_nStartAngle = m_nStartAngle;
	page.m_nSweepAngle = m_nSweepAngle;

	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_nStartAngle = page.m_nStartAngle;
		m_nSweepAngle = page.m_nSweepAngle;
		return TRUE;
	}
	return FALSE;
}


void CDrawPie::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);
	if (ar.IsStoring())
	{
		ar << m_nStartAngle;
		ar << m_nSweepAngle;
	}
	else
	{
		ar >> m_nStartAngle;
		ar >> m_nSweepAngle;
	}
}


//---------------------------------------------- CDrawFan --------
IMPLEMENT_SERIAL(CDrawFan, CDrawObj, 0)

CDrawFan::CDrawFan() :CDrawObj()
{
	m_nStep = 0;
	m_bComputed = false;
	m_bRun = false;
	m_clrLine = RGB(0, 0, 0);
	m_clrBack = RGB(255, 255, 0);
	m_clrFore = RGB(0, 255, 0);
}


CDrawObj* CDrawFan::Clone(void)
{
	CDrawFan *pObj = new CDrawFan;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strLogic = m_strLogic;
	return pObj;
}


void CDrawFan::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);
	if (ar.IsStoring())
	{
		ar << m_strLogic;
	}
	else
	{
		ar >> m_strLogic;
	}
}


BOOL CDrawFan::OnAttrib(CPropertySheet& sheet)
{
	CLogicPage page;
	page.m_strLogic = m_strLogic;

	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_strLogic = page.m_strLogic;
		return TRUE;
	}
	return FALSE;
}


bool CDrawFan::Fresh(CRect &RECT)
{
	CDrawObj::Fresh(RECT);
	CRealComputer com;
	com.SetFormula(m_strLogic);
	m_bRun = (int)com.GetResult();
	RECT = m_rect;
	return true;
}


void CDrawFan::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	COLORREF clrLine = m_clrLine;
	COLORREF clrBack = m_clrBack;
	COLORREF clrFore = m_clrFore;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrBack = m_clrCurrentBack;
		clrFore = m_clrCurrentFore;
		rect = m_rctCurrent;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);
	rect.NormalizeRect();

	if (bRuning && m_bRun)
	{
		m_nStep++;
		m_nStep = m_nStep % 8;
	}

	// 计算落点数组
	if (!bRuning || !m_bComputed)
	{
		CPoint center = rect.CenterPoint();
		float h = rect.Height();
		float w = rect.Width();
		float y = 0;

		tagPoint[0] = CPoint(rect.right, (rect.top + rect.bottom) / 2);
		tagPoint[2] = CPoint((rect.left + rect.right) / 2, rect.top);
		tagPoint[4] = CPoint(rect.left, (rect.top + rect.bottom) / 2);
		tagPoint[6] = CPoint((rect.left + rect.right) / 2, rect.bottom);
		int x = 0;
		for (x = w / 4; x < w / 2; x++)
		{
			y = 1.0*x*rect.Height() / rect.Width();
			float delta = x*x*(h / 2)*(h / 2) + y*y*(w / 2)*(w / 2) - (h / 2)*(h / 2)*(w / 2)*(w / 2);
			if (delta > -1 && delta < 1)
			{
				break;
			}
		}
		int yP = (int)y;
		tagPoint[1] = center + CSize(x, -yP);
		tagPoint[3] = center + CSize(-x, -yP);
		tagPoint[5] = center + CSize(-x, yP);
		tagPoint[7] = center + CSize(x, yP);
		m_bComputed = true;
	}

	CBrush brush(m_clrBack);
	pDC->SelectObject(&brush);
	pDC->Pie(&rect, tagPoint[m_nStep], tagPoint[(m_nStep + 2) % 8]);
	pDC->Pie(&rect, tagPoint[(m_nStep + 4) % 8], tagPoint[(m_nStep + 6) % 8]);
	CBrush brush1(m_clrFore);
	CBrush *pOldBrush = pDC->SelectObject(&brush1);
	pDC->Pie(&rect, tagPoint[(m_nStep + 2) % 8], tagPoint[(m_nStep + 4) % 8]);
	pDC->Pie(&rect, tagPoint[(m_nStep + 6) % 8], tagPoint[(m_nStep) % 8]);
	pDC->SelectObject(pOldBrush);
	pDC->SelectObject(pOldPen);

	DeleteObject(pen);
	DeleteObject(brush);
	DeleteObject(brush1);
}


//---------------------------------------------- CDrawArc --------
IMPLEMENT_SERIAL(CDrawArc, CDrawObj, 0)

CDrawArc::CDrawArc() :CDrawObj()
{
	m_nStartAngle = 0;
	m_nSweepAngle = 120;
}


CDrawObj* CDrawArc::Clone(void)
{
	CDrawArc *pObj = new CDrawArc;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_nStartAngle = m_nStartAngle;
	pObj->m_nSweepAngle = m_nSweepAngle;
	return pObj;
}


void CDrawArc::Draw(CDC* pDC)
{
	CRect rect = m_rect;
	COLORREF clrLine = m_clrLine;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		rect = m_rctCurrent;
	}

	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);
	int x = (rect.left + rect.right) / 2;
	int y = (rect.top + rect.bottom) / 2;
	int r = (rect.Width() < rect.Height() ? rect.Width() : rect.Height()) / 2;
	pDC->MoveTo(x + r * cos(m_nStartAngle * PIE / 180), y - r * sin(m_nStartAngle * PIE / 180));
	pDC->AngleArc(x, y, r, m_nStartAngle, m_nSweepAngle);
	pDC->SelectObject(pOldPen);

	DeleteObject(pen);
}


BOOL CDrawArc::OnAttrib(CPropertySheet& sheet)
{
	CArcPage page;
	page.m_nStartAngle = m_nStartAngle;
	page.m_nSweepAngle = m_nSweepAngle;

	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_nStartAngle = page.m_nStartAngle;
		m_nSweepAngle = page.m_nSweepAngle;
		return TRUE;
	}
	return FALSE;
}


void CDrawArc::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);
	if (ar.IsStoring())
	{
		ar << m_nStartAngle;
		ar << m_nSweepAngle;
	}
	else
	{
		ar >> m_nStartAngle;
		ar >> m_nSweepAngle;
	}
}


//---------------------------------------------- CDrawPoly --------

IMPLEMENT_SERIAL(CDrawPoly, CDrawObj, 0)

CDrawPoly::CDrawPoly() :CDrawObj()
{
	m_points = NULL;
	m_nPoints = 0;
	m_nAllocPoints = 0;
}
CDrawPoly::~CDrawPoly()
{
	//chn mem
	if (m_points != NULL)
	{
		delete[] m_points;
		m_points = NULL;
	}
}
void CDrawPoly::AddPoint(const CPoint& point)
{
	ASSERT_VALID(this);
	if (m_nPoints < 0) return;
	if (m_nPoints == m_nAllocPoints)
	{
		CPoint* newPoints = new CPoint[m_nAllocPoints + 10];
		if (m_points != NULL)
		{
			memcpy(newPoints, m_points, sizeof(CPoint) * m_nAllocPoints);
			delete[] m_points;
		}
		m_points = newPoints;
		m_nAllocPoints += 10;
	}

	if (m_nPoints == 0 || m_points[m_nPoints - 1] != point)
	{
		m_points[m_nPoints++] = point;
		if (!RecalcBounds())
		{
			Invalidate();
		}
	}
}

BOOL CDrawPoly::RecalcBounds()
{
	ASSERT_VALID(this);

	if (m_nPoints == 0)
		return FALSE;

	CRect bounds(m_points[0], CSize(0, 0));
	for (int i = 1; i < m_nPoints; ++i)
	{
		if (m_points[i].x < bounds.left)
			bounds.left = m_points[i].x;
		if (m_points[i].x > bounds.right)
			bounds.right = m_points[i].x;
		if (m_points[i].y < bounds.top)
			bounds.top = m_points[i].y;
		if (m_points[i].y > bounds.bottom)
			bounds.bottom = m_points[i].y;
	}

	if (bounds == m_rect)
		return FALSE;

	Invalidate();
	m_rect = bounds;
	Invalidate();

	return TRUE;
}

void CDrawPoly::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);

	COLORREF clrLine = m_clrLine;
	COLORREF clrBack = m_clrBack;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrBack = m_clrCurrentBack;
		rect = m_rctCurrent;
	}

	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);

	// CBrush
	LOGBRUSH brushlog = GetBrush();
	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);

	if (m_nFillMode < 8)
	{
		pDC->Polygon(m_points, m_nPoints);
	}
	else	// 渐变填充
	{
		CGradient gradient;
		HRGN hRgn = CreatePolygonRgn(m_points, m_nPoints, ALTERNATE);
		CRect tmp = rect;
		switch (m_nFillMode)
		{
		case 8:
			gradient.HorizontalGradient(pDC, hRgn, m_clrFill, clrBack);
			break;
		case 9:
		case 10:
			gradient.HorizontalGradient(pDC, hRgn, clrBack, m_clrFill);
			break;
		case 11:
			gradient.VerticalGradient(pDC, hRgn, m_clrFill, clrBack);
			break;
		case 12:
		case 13:
			gradient.VerticalGradient(pDC, hRgn, m_clrBack, m_clrFill);
			break;
		}
		DeleteObject(hRgn);
	}

	pDC->SelectObject(pOldBrush);
	pDC->SelectObject(pOldPen);

	DeleteObject(pen);
	DeleteObject(m_brush);
}

void CDrawPoly::Serialize(CArchive& ar)
{
	int i;
	CDrawObj::Serialize(ar);
	if (ar.IsStoring())
	{
		ar << (WORD)m_nPoints;
		ar << (WORD)m_nAllocPoints;
		for (i = 0; i < m_nPoints; i++)
			ar << m_points[i];
	}
	else
	{
		WORD wTemp;
		ar >> wTemp; m_nPoints = wTemp;
		ar >> wTemp; m_nAllocPoints = wTemp;
		m_points = new CPoint[m_nAllocPoints];
		for (i = 0; i < m_nPoints; i++)
			ar >> m_points[i];
	}
}

CDrawObj* CDrawPoly::Clone()
{
	CDrawPoly* pClone = new CDrawPoly();
	*((CDrawObj*)pClone) = *(CDrawObj*)this;
	pClone->m_points = new CPoint[m_nAllocPoints];
	memcpy(pClone->m_points, m_points, sizeof(CPoint) * m_nPoints);
	pClone->m_nAllocPoints = m_nAllocPoints;
	pClone->m_nPoints = m_nPoints;
	return pClone;
}

void CDrawPoly::MoveTo(CRect rect)
{
	ASSERT_VALID(this);
	if (rect == m_rect)
		return;

	Invalidate();

	for (int i = 0; i < m_nPoints; i += 1)
	{
		m_points[i].x += rect.left - m_rect.left;
		m_points[i].y += rect.top - m_rect.top;
	}

	m_rect = rect;
	Invalidate();
}

int CDrawPoly::GetHandleCount()
{
	return m_nPoints;
}

CPoint CDrawPoly::GetHandle(int nHandle)
{
	ASSERT_VALID(this);

	ASSERT(nHandle >= 1 && nHandle <= m_nPoints);
	return m_points[nHandle - 1];
}

void CDrawPoly::MoveHandleTo(int nHandle, CPoint point)
{
	ASSERT(nHandle >= 1 && nHandle <= m_nPoints);
	if (m_points[nHandle - 1] == point)
		return;
	m_points[nHandle - 1] = point;
	RecalcBounds();
	Invalidate();
}


//---------------------------------------------- CDrawMLine --------

IMPLEMENT_SERIAL(CDrawMLine, CDrawPoly, 0)

CDrawMLine::CDrawMLine() :CDrawPoly()
{

}

void CDrawMLine::Draw(CDC* pDC)
{
	ASSERT_VALID(this);

	COLORREF clrLine = m_clrLine;
	COLORREF clrBack = m_clrBack;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrBack = m_clrCurrentBack;
		rect = m_rctCurrent;
	}

	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);

	if (m_nPoints > 0)
		pDC->MoveTo(m_points[0]);
	for (int i = 1; i < m_nPoints; i++)
		pDC->LineTo(m_points[i]);

	pDC->SelectObject(pOldPen);

	DeleteObject(pen);
}


CDrawObj* CDrawMLine::Clone()
{
	CDrawMLine* pClone = new CDrawMLine();
	*((CDrawObj*)pClone) = *(CDrawObj*)this;
	pClone->m_points = new CPoint[m_nAllocPoints];
	memcpy(pClone->m_points, m_points, sizeof(CPoint) * m_nPoints);
	pClone->m_nAllocPoints = m_nAllocPoints;
	pClone->m_nPoints = m_nPoints;
	return pClone;
}


//---------------------------------------------- CDrawArrow -------
IMPLEMENT_SERIAL(CDrawArrow, CDrawObj, 0)

CDrawArrow::CDrawArrow() :CDrawObj()
{
}

CDrawObj* CDrawArrow::Clone(void)
{
	CDrawArrow *pObj = new CDrawArrow;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawArrow::Draw(CDC* pDC)
{
	CRect rect = m_rect;
	rect.NormalizeRect();
	int nXX = rect.right - rect.left;
	int nYY = rect.bottom - rect.top;

	if (nXX < 2 || nYY < 2) return;
	if (nXX >= nYY)
	{
		if (m_rect.left >= m_rect.right)
			DrawArrow(pDC, rect, DIR_LEFT, m_clrBack);
		else
			DrawArrow(pDC, rect, DIR_RIGHT, m_clrBack);
	}
	else
	{
		if (m_rect.top >= m_rect.bottom)
			DrawArrow(pDC, rect, DIR_DOWN, m_clrBack);
		else
			DrawArrow(pDC, rect, DIR_UP, m_clrBack);
	}
}


void CDrawArrow::DrawArrow(CDC* pDC, CRect rect, BYTE Direction, COLORREF clrArrow)
{
	if (Direction == DIR_UP || Direction == DIR_DOWN)
	{
		int middle = (rect.left + rect.right) / 2;
		for (int i = 0; i < rect.Height(); i++)
		{
			int nY = rect.top + i;
			if (Direction == DIR_DOWN)
			{
				int nX1 = rect.left + i*((1.0*rect.Width() / 2) / rect.Height());
				int nX2 = rect.right - i*((1.0*rect.Width() / 2) / rect.Height());
				CRect rect1(nX1, nY, nX2, nY + 1);
				pDC->FillSolidRect(rect1, clrArrow);
			}
			else
			{
				int nX1 = middle - i*((1.0*rect.Width() / 2) / rect.Height());
				int nX2 = middle + i*((1.0*rect.Width() / 2) / rect.Height());
				CRect rect1(nX1, nY, nX2, nY + 1);
				pDC->FillSolidRect(rect1, clrArrow);
			}
		}
	}
	if (Direction == DIR_LEFT || Direction == DIR_RIGHT)
	{
		int middle = (rect.top + rect.bottom) / 2;
		for (int i = 0; i < rect.Width(); i++)
		{
			int nX = rect.left + i;
			if (Direction == DIR_RIGHT)
			{
				int nY1 = rect.top + i*((1.0*rect.Height() / 2) / rect.Width());
				int nY2 = rect.bottom - i*((1.0*rect.Height() / 2) / rect.Width());
				CRect rect1(nX, nY1, nX + 1, nY2);
				pDC->FillSolidRect(rect1, clrArrow);
			}
			else
			{
				int nY1 = middle + i*((1.0*rect.Height() / 2) / rect.Width());
				int nY2 = middle - i*((1.0*rect.Height() / 2) / rect.Width());
				CRect rect1(nX, nY1, nX + 1, nY2);
				pDC->FillSolidRect(rect1, clrArrow);
			}
		}
	}
}



//---------------------------------------------- CDrawBreaker --------
IMPLEMENT_SERIAL(CDrawBreaker, CDrawObj, 0)

CDrawBreaker::CDrawBreaker() :CDrawObj()
{
}

CDrawObj* CDrawBreaker::Clone(void)
{
	CDrawBreaker *pObj = new CDrawBreaker;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawBreaker::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	COLORREF clrLine = m_clrLine;
	COLORREF clrBack = m_clrBack;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrBack = m_clrCurrentBack;
		rect = m_rctCurrent;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CBrush brush(clrBack);
	CPen* pOldPen = pDC->SelectObject(&pen);
	CBrush* pOldBrush = pDC->SelectObject(&brush);

	rect.NormalizeRect();
	int nMidX = rect.left + rect.Width() / 2;
	pDC->MoveTo(nMidX, rect.top);
	pDC->LineTo(nMidX, rect.top + rect.Height() / 4);

	pDC->MoveTo(nMidX, rect.top + rect.Height() * 3 / 4);
	pDC->LineTo(nMidX, rect.bottom);

	rect.DeflateRect(0, rect.Height() / 4, 0, rect.Height() / 4);
	pDC->Rectangle(rect);

	pDC->SelectObject(pOldPen);
	pDC->SelectObject(pOldBrush);

	DeleteObject(pen);
	DeleteObject(brush);
}


//---------------------------------------------- CDrawSwitch --------
IMPLEMENT_SERIAL(CDrawSwitch, CDrawObj, 0)

CDrawSwitch::CDrawSwitch() :CDrawObj()
{
	m_clrLine = RGB(0, 255, 0);
	m_bRun = FALSE;
	m_strLogic = "";
}


CDrawObj* CDrawSwitch::Clone(void)
{
	CDrawSwitch *pObj = new CDrawSwitch;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strLogic = m_strLogic;
	return pObj;
}


void CDrawSwitch::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);
	if (ar.IsStoring())
	{
		ar << m_strLogic;
	}
	else
	{
		ar >> m_strLogic;
	}
}


BOOL CDrawSwitch::OnAttrib(CPropertySheet& sheet)
{
	CLogicPage page;
	page.m_strLogic = m_strLogic;

	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_strLogic = page.m_strLogic;
		return TRUE;
	}
	return FALSE;
}


bool CDrawSwitch::Fresh(CRect &RECT)
{
	CDrawObj::Fresh(RECT);
	CRealComputer com;
	com.SetFormula(m_strLogic);
	m_bRun = (int)com.GetResult();
	RECT = m_rect;
	return true;
}


void CDrawSwitch::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	CRect rect = m_rect;
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, (bRuning&&m_bRun) ? RGB(255, 0, 0) : RGB(0, 255, 0));
	CPen* pOldPen = pDC->SelectObject(&pen);


	rect.NormalizeRect();
	int nMidX = rect.left + rect.Width() / 2;
	pDC->MoveTo(nMidX, rect.top);
	pDC->LineTo(nMidX, rect.top + rect.Height() / 4);
	pDC->MoveTo(rect.left + rect.Width() / 4, rect.top + rect.Height() / 4);
	pDC->LineTo(rect.right - rect.Width() / 4, rect.top + rect.Height() / 4);

	if (bRuning && m_bRun)
	{
		pDC->MoveTo(nMidX, rect.top + rect.Height() / 4);
		pDC->LineTo(nMidX, rect.top + rect.Height() * 3 / 4);
	}
	else
	{
		pDC->MoveTo(rect.left, rect.top + rect.Height() / 4);
		pDC->LineTo(nMidX, rect.top + rect.Height() * 3 / 4);
	}

	pDC->MoveTo(nMidX, rect.top + rect.Height() * 3 / 4);
	pDC->LineTo(nMidX, rect.bottom);

	pDC->SelectObject(pOldPen);
	DeleteObject(pen);
}

//---------------------------------------------- CDrawGrid --------
IMPLEMENT_SERIAL(CDrawGrid, CDrawObj, 0)

CDrawGrid::CDrawGrid() :CDrawObj()
{
	m_clrLine = RGB(0, 255, 0);
}

CDrawObj* CDrawGrid::Clone(void)
{
	CDrawGrid *pObj = new CDrawGrid;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawGrid::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	COLORREF clrLine = m_clrLine;
	COLORREF clrBack = m_clrBack;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrBack = m_clrCurrentBack;
		rect = m_rctCurrent;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);
	rect.NormalizeRect();

	int nXNum = 5;
	int nYNum = 5;
	int nDX = rect.Width() / nXNum;
	int nDY = rect.Height() / nYNum;
	for (int i = 0; i <= nXNum; i++)
	{
		int nX = rect.left + nDX*i;
		pDC->MoveTo(nX, rect.top);
		pDC->LineTo(nX, rect.top + nDY*nYNum);
	}
	for (int j = 0; j <= nYNum; j++)
	{
		int nY = rect.top + nDY*j;
		pDC->MoveTo(rect.left, nY);
		pDC->LineTo(rect.left + nDX*nXNum, nY);
	}

	pDC->SelectObject(pOldPen);
	DeleteObject(pen);
}



//---------------------------------------------- CDrawTable --------
IMPLEMENT_SERIAL(CDrawTable, CDrawObj, 0)

CDrawTable::CDrawTable() :CDrawObj()
{
	m_clrLine = RGB(0, 255, 0);
	m_clrFore = RGB(255, 255, 0);
	m_nFillMode = 0;
	m_bAddAve = false;
	m_bAddMax = false;
	m_bAddMin = false;
	m_bShowRowHead = true;
	m_nType = 0;
	for (int i = 0; i < 8; i++)
	{
		CColPro* pObj = new CColPro;
		m_colList.AddTail(pObj);
	}
}

CDrawObj* CDrawTable::Clone(void)
{
	CDrawTable *pObj = new CDrawTable;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawTable::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);
	if (ar.IsStoring())
	{
		ar << m_bAddAve;
		ar << m_bAddMax;
		ar << m_bAddMin;
		ar << m_nType;
		ar << m_bShowRowHead;
	}
	else
	{
		m_colList.RemoveAll();
		ar >> m_bAddAve;
		ar >> m_bAddMax;
		ar >> m_bAddMin;
		ar >> m_nType;
		ar >> m_bShowRowHead;
	}
	m_colList.Serialize(ar);
}


BOOL CDrawTable::OnAttrib(CPropertySheet& sheet)
{
	CReportBasePage page;
	page.m_bAddAve = m_bAddAve;
	page.m_bAddMin = m_bAddMin;
	page.m_bAddMax = m_bAddMax;
	page.m_nType = m_nType;
	page.m_bShowRowHead = m_bShowRowHead;
	sheet.AddPage(&page);

	CReportColPage cPage;
	POSITION pos = m_colList.GetHeadPosition();
	while (pos != NULL)
	{
		CColPro* pObj = m_colList.GetNext(pos);
		CColPro *pNewObj = pObj->Clone();
		cPage.m_colList.AddTail(pNewObj);
	}

	sheet.AddPage(&cPage);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_bAddAve = page.m_bAddAve;
		m_bAddMin = page.m_bAddMin;
		m_bAddMax = page.m_bAddMax;
		m_nType = page.m_nType;
		m_bShowRowHead = page.m_bShowRowHead;

		m_colList.RemoveAll();
		pos = cPage.m_colList.GetHeadPosition();
		while (pos != NULL)
		{
			CColPro* pObj = cPage.m_colList.GetNext(pos);
			CColPro *pNewObj = pObj->Clone();
			m_colList.AddTail(pNewObj);
		}

		return TRUE;
	}
	return FALSE;
}


CString CDrawTable::GetColFormat(int col)
{
	int i = 1;
	POSITION pos = m_colList.GetHeadPosition();
	while (pos != NULL)
	{
		CColPro* pObj = m_colList.GetNext(pos);
		if (i == col)
		{
			return pObj->m_strFormat;
		}
		i++;
	}
	return "####";
}


void CDrawTable::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	COLORREF clrLine = m_clrLine;
	COLORREF clrFore = m_clrFore;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrFore = m_clrCurrentFore;
		rect = m_rctCurrent;
	}

	// CBrush
	LOGBRUSH brushlog = GetBrush();
	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);
	if (m_nFillMode < 8)
	{
		pDC->Rectangle(rect);
	}
	else	// 渐变填充
	{
		CGradient gradient;
		CRect tmp = rect;
		switch (m_nFillMode)
		{
		case 8:
			gradient.HorizontalGradient(pDC, rect, m_clrFill, m_clrBack);
			break;
		case 9:
			gradient.HorizontalGradient(pDC, rect, m_clrBack, m_clrFill);
			break;
		case 10:
			tmp.NormalizeRect();
			tmp.right = (tmp.left + tmp.right) / 2 + 1;
			gradient.HorizontalGradient(pDC, tmp, m_clrFill, m_clrBack);
			tmp = rect;
			tmp.NormalizeRect();
			tmp.left = (tmp.left + tmp.right) / 2 - 1;
			gradient.HorizontalGradient(pDC, tmp, m_clrBack, m_clrFill);
			break;
		case 11:
			gradient.VerticalGradient(pDC, rect, m_clrFill, m_clrBack);
			break;
		case 12:
			gradient.VerticalGradient(pDC, rect, m_clrBack, m_clrFill);
			break;
		case 13:
			tmp.NormalizeRect();
			tmp.top = (tmp.top + tmp.bottom) / 2 - 1;
			gradient.VerticalGradient(pDC, tmp, m_clrBack, m_clrFill);
			tmp = rect;
			tmp.NormalizeRect();
			tmp.bottom = (tmp.top + tmp.bottom) / 2 + 1;
			gradient.VerticalGradient(pDC, tmp, m_clrFill, m_clrBack);
			break;
		}
	}
	pDC->SelectObject(pOldBrush);

	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);
	rect.NormalizeRect();
	pDC->SetTextColor(clrFore);
	CFont font;
	font.CreateFontIndirect(&m_logfont);
	CFont* pOldFont = pDC->SelectObject(&font);

	int nXNum = m_colList.GetCount();
	if (m_bShowRowHead)
		nXNum++;

	int nYNum;
	if (m_nType == 0)
		nYNum = 25;
	else
		nYNum = 32;

	if (m_bAddAve)	nYNum++;
	if (m_bAddMax)	nYNum++;
	if (m_bAddMin)	nYNum++;

	float nDX = 1.0*rect.Width() / nXNum;
	float nDY = 1.0*rect.Height() / nYNum;

	int i = 0;
	for (i = 0; i <= nXNum; i++)
	{
		int nX = rect.left + nDX*i;
		if (i == nXNum) nX = rect.right;
		pDC->MoveTo(nX, rect.top);
		pDC->LineTo(nX, rect.bottom);
	}

	int j = 0;
	for (j = 0; j <= nYNum; j++)
	{
		int nY = rect.top + nDY*j;
		if (j == nYNum) nY = rect.bottom;
		pDC->MoveTo(rect.left, nY);
		pDC->LineTo(rect.right, nY);
	}

	for (i = m_bShowRowHead ? 1 : 0; i < nXNum; i++)
		for (j = 1; j < nYNum; j++)
		{
			pDC->SetTextAlign(TA_RIGHT | TA_TOP);
			int y = rect.top + nDY*j + 5;
			int x = rect.left + nDX*(i + 1) - 5;
			CString format = GetColFormat(i);
			if (!bRuning)
				pDC->TextOut(x, y, format);
			else
			{
				format.Replace("#", "0");
				pDC->TextOut(x, y, format);
			}
		}

	// 画列名
	int col = m_bShowRowHead ? 1 : 0;
	POSITION pos = m_colList.GetHeadPosition();
	while (pos != NULL)
	{
		CColPro* pObj = m_colList.GetNext(pos);
		int y = rect.top + 5;
		int x = rect.left + nDX*(col + 1) - 5;
		pDC->TextOut(x, y, pObj->m_strTitle);
		col++;
	}

	pDC->SetTextAlign(TA_LEFT);
	// 画行名
	if (m_bShowRowHead)
	{
		int col = 1;
		if (m_nType == 0)
		{
			for (int i = 0; i < 24; i++)
			{
				int y = rect.top + nDY*col + 5;
				int x = rect.left + 5;
				CString tmp;
				tmp.Format(g_strHour, i + 1);
				pDC->TextOut(x, y, tmp);
				col++;
			}
		}
		else
		{
			for (int i = 0; i < 31; i++)
			{
				int y = rect.top + nDY*col + 5;
				int x = rect.left + 5;
				CString tmp;
				tmp.Format(g_strDate, i + 1);
				pDC->TextOut(x, y, tmp);
				col++;
			}
		}
		if (m_bAddAve)
		{
			int y = rect.top + nDY*col + 5;
			int x = rect.left + 5;
			pDC->TextOut(x, y, g_strMean);
			col++;
		}
		if (m_bAddMax)
		{
			int y = rect.top + nDY*col + 5;
			int x = rect.left + 5;
			pDC->TextOut(x, y, g_strMaxValues);
			col++;
		}
		if (m_bAddMin)
		{
			int y = rect.top + nDY*col + 5;
			int x = rect.left + 5;
			pDC->TextOut(x, y, g_strMinValues);
			col++;
		}

	}
	pDC->SelectObject(pOldPen);
	DeleteObject(pen);
	DeleteObject(m_brush);
	DeleteObject(font);
}


//---------------------------------------------- CDrawZhePipe --------
IMPLEMENT_SERIAL(CDrawZhePipe, CDrawObj, 0)

CDrawZhePipe::CDrawZhePipe() :CDrawObj()
{
	m_clrLine = RGB(0, 255, 0);
}

CDrawObj* CDrawZhePipe::Clone(void)
{
	CDrawZhePipe *pObj = new CDrawZhePipe;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawZhePipe::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	CRect rect = m_rctCurrent;
	COLORREF clrFill = m_clrCurrentBack;
	if (!bRuning)
	{
		clrFill = m_clrBack;
		rect = m_rect;
	}

	unsigned char red = (unsigned char)(GetRValue(clrFill));
	unsigned char green = (unsigned char)(GetGValue(clrFill));
	unsigned char blue = (unsigned char)(GetBValue(clrFill));
	unsigned char cred, cgreen, cblue;
	int width = abs(rect.Width() / 2);

	int i = 0;
	for (i = 0; i < width; i++)
	{
		int crate = abs(rect.Width() / 4);
		if (i < crate)
		{
			cred = (int)(red + i*(255.0 - red)*1.0 / crate);
			cgreen = (int)(green + i*(255.0 - green)*1.0 / crate);
			cblue = (int)(blue + i*(255.0 - blue)*1.0 / crate);
		}
		else
		{
			cred = 510 - (int)(red + i*(255.0 - red)*1.0 / crate);
			cgreen = 510 - (int)(green + i*(255.0 - green)*1.0 / crate);
			cblue = 510 - (int)(blue + i*(255.0 - blue)*1.0 / crate);
		}
		COLORREF color = RGB(cred, cgreen, cblue);
		CRect rct = CRect(rect.left + i, rect.top, rect.left + i + 1, rect.bottom);
		if (rect.left > rect.right)
			rct = CRect(rect.left - i, rect.top, rect.left - i - 1, rect.bottom);
		pDC->FillSolidRect(rct, color);
	}

	int height = abs(rect.Height() / 2);
	for (i = 0; i < height; i++)
	{
		int crate = abs(rect.Height() / 4);
		if (i < crate)
		{
			cred = (int)(red + i*(255.0 - red)*1.0 / crate);
			cgreen = (int)(green + i*(255.0 - green)*1.0 / crate);
			cblue = (int)(blue + i*(255.0 - blue)*1.0 / crate);
		}
		else
		{
			cred = 510 - (int)(red + i*(255.0 - red)*1.0 / crate);
			cgreen = 510 - (int)(green + i*(255.0 - green)*1.0 / crate);
			cblue = 510 - (int)(blue + i*(255.0 - blue)*1.0 / crate);
		}
		COLORREF color = RGB(cred, cgreen, cblue);
		float rate = 1.0*abs(rect.Width()) / abs(rect.Height());
		CRect rct = CRect(rect.left + i*rate, rect.top + i, rect.right, rect.top + i + 1);
		if (rect.left > rect.right)
		{
			rct = CRect(rect.left - i*rate, rect.top + i, rect.right, rect.top + i + 1);
		}
		if (rect.top > rect.bottom)
		{
			rct = CRect(rect.left + i*rate - 1, rect.top - i, rect.right, rect.top - i + 1);
			if (rect.left > rect.right)
			{
				rct = CRect(rect.left - i*rate, rect.top - i, rect.right, rect.top - i + 1);
			}
		}
		pDC->FillSolidRect(rct, color);
	}
}


//---------------------------------------------- CDrawYPipe --------
IMPLEMENT_SERIAL(CDrawYPipe, CDrawObj, 0)

CDrawYPipe::CDrawYPipe() :CDrawObj()
{
	m_clrLine = RGB(0, 255, 0);
}

CDrawObj* CDrawYPipe::Clone(void)
{
	CDrawPipe *pObj = new CDrawPipe;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawYPipe::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	CRect rect = m_rctCurrent;
	COLORREF clrFill = m_clrCurrentBack;
	if (!bRuning)
	{
		clrFill = m_clrBack;
		rect = m_rect;
	}

	unsigned char red = (unsigned char)(GetRValue(clrFill));
	unsigned char green = (unsigned char)(GetGValue(clrFill));
	unsigned char blue = (unsigned char)(GetBValue(clrFill));
	unsigned char cred, cgreen, cblue;
	int width = abs(rect.Width() / 2);

	int i = 0;
	for (i = 0; i < width; i++)
	{
		int crate = abs(rect.Width() / 4);
		if (i < crate)
		{
			cred = (int)(red + i*(255.0 - red)*1.0 / crate);
			cgreen = (int)(green + i*(255.0 - green)*1.0 / crate);
			cblue = (int)(blue + i*(255.0 - blue)*1.0 / crate);
		}
		else
		{
			cred = 510 - (int)(red + i*(255.0 - red)*1.0 / crate);
			cgreen = 510 - (int)(green + i*(255.0 - green)*1.0 / crate);
			cblue = 510 - (int)(blue + i*(255.0 - blue)*1.0 / crate);
		}
		COLORREF color = RGB(cred, cgreen, cblue);
		CRect rct = CRect(rect.left + i, rect.top, rect.left + i + 1, rect.bottom);
		if (rect.left > rect.right)
			rct = CRect(rect.left - i, rect.top, rect.left - i - 1, rect.bottom);
		pDC->FillSolidRect(rct, color);
	}

	int middle = (rect.top + rect.bottom) / 2;
	int height = abs(rect.Height() / 4);
	for (i = 0; i < height; i++)
	{
		cred = (int)(255 - i*(255.0 - red)*1.0 / height);
		cgreen = (int)(255 - i*(255.0 - green)*1.0 / height);
		cblue = (int)(255 - i*(255.0 - blue)*1.0 / height);
		COLORREF color = RGB(cred, cgreen, cblue);

		float rate = 1.0*abs(rect.Width()) / abs(rect.Height());
		CRect rct = CRect(rect.left + abs(rect.Width()) / 4 + i*rate, middle + i, rect.right, middle + i + 1);
		CRect rct1 = CRect(rect.left + abs(rect.Width()) / 4 + i*rate, middle - i, rect.right, middle - i - 1);
		if (rect.left > rect.right)
		{
			rct = CRect(rect.left - i*rate - abs(rect.Width()) / 4, middle + i, rect.right, middle + i + 1);
			rct1 = CRect(rect.left - i*rate - abs(rect.Width()) / 4, middle - i, rect.right, middle - i - 1);
		}
		if (rect.top > rect.bottom)
		{
			rct = CRect(rect.left + abs(rect.Width()) / 4 + i*rate - 1, middle - i, rect.right, middle - i + 1);
			rct1 = CRect(rect.left + abs(rect.Width()) / 4 + i*rate, middle + i, rect.right, middle + i - 1);
			if (rect.left > rect.right)
			{
				rct = CRect(rect.left - abs(rect.Width()) / 4 - i*rate, middle - i, rect.right, middle - i + 1);
				rct1 = CRect(rect.left - abs(rect.Width()) / 4 - i*rate, middle + i, rect.right, middle + i - 1);
			}
		}
		pDC->FillSolidRect(rct, color);
		pDC->FillSolidRect(rct1, color);
	}
}

//---------------------------------------------- CDrawPipe --------
IMPLEMENT_SERIAL(CDrawPipe, CDrawObj, 0)

CDrawPipe::CDrawPipe() :CDrawObj()
{
	m_clrLine = RGB(0, 255, 0);
}

CDrawObj* CDrawPipe::Clone(void)
{
	CDrawPipe *pObj = new CDrawPipe;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawPipe::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	CRect rect = m_rctCurrent;
	COLORREF clrFill = m_clrCurrentBack;
	if (!bRuning)
	{
		clrFill = m_clrBack;
		rect = m_rect;
	}

	rect.NormalizeRect();
	CRect tmp = rect;
	CGradient gradient;
	if (rect.Width() < rect.Height())
	{
		tmp.NormalizeRect();
		tmp.right = (tmp.left + tmp.right) / 2 + 1;
		gradient.HorizontalGradient(pDC, tmp, clrFill, RGB(255, 255, 255));
		tmp = rect;
		tmp.NormalizeRect();
		tmp.left = (tmp.left + tmp.right) / 2 - 1;
		gradient.HorizontalGradient(pDC, tmp, RGB(255, 255, 255), clrFill);
	}
	else
	{
		tmp.NormalizeRect();
		tmp.top = (tmp.top + tmp.bottom) / 2 - 1;
		gradient.VerticalGradient(pDC, tmp, RGB(255, 255, 255), clrFill);
		tmp = rect;
		tmp.NormalizeRect();
		tmp.bottom = (tmp.top + tmp.bottom) / 2 + 1;
		gradient.VerticalGradient(pDC, tmp, clrFill, RGB(255, 255, 255));
	}
}


//---------------------------------------------- CDrawBitmap --------
IMPLEMENT_SERIAL(CDrawBitmap, CDrawObj, 0)

CDrawBitmap::CDrawBitmap() :CDrawObj()
{
	m_strStaticFile = "home.bmp";
	//m_strStaticFile = "";
	m_strDynFile = "";
	m_bDyn = FALSE;
	m_strDynCondition = "";
	m_bStretch = FALSE;
	m_bUseDnyFile = FALSE;

	m_image = NULL;
}

CDrawBitmap::~CDrawBitmap()
{
	if (m_image)
	{
		delete m_image;
		m_image = NULL;
	}
}

CDrawObj* CDrawBitmap::Clone(void)
{
	CDrawBitmap *pObj = new CDrawBitmap;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strStaticFile = m_strStaticFile;
	pObj->m_strDynFile = m_strDynFile;
	pObj->m_bDyn = m_bDyn;
	pObj->m_strDynCondition = m_strDynCondition;
	pObj->m_bStretch = m_bStretch;
	pObj->m_bUseDnyFile = m_bUseDnyFile;
	return pObj;
}

bool CDrawBitmap::Fresh(CRect &RECT)
{
	CDrawObj::Fresh(RECT);
	CRealComputer com;
	com.SetFormula(m_strDynCondition);
	m_bUseDnyFile = com.GetResult();
	RECT = m_rect;

	CString sTemp1 = m_strStaticFile, sTemp2 = m_strDynFile;
	sTemp1 = sTemp1.MakeLower();
	sTemp2 = sTemp2.MakeLower();
	if (-1 != sTemp1.Find(".bmp") || -1 != sTemp2.Find(".bmp"))
		return true;
	else if (-1 != sTemp1.Find(".png") || -1 != sTemp2.Find(".png"))
		return true;
	else if (-1 != sTemp1.Find(".gif") || -1 != sTemp2.Find(".gif"))
	{
		if (!m_bShow)
		{
			m_bShowtemp = FALSE;
			return true;
		}
		else if (!m_bShowtemp)
		{
			m_bShowtemp = TRUE;
			return true;
		}
		else
			return false;
	}
	else if (-1 != sTemp1.Find(".jpg") || -1 != sTemp2.Find(".jpg"))
		return true;

	return true;
}

void CDrawBitmap::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_strStaticFile;
		ar << m_strDynFile;
		ar << m_bDyn;
		ar << m_strDynCondition;
		ar << m_bStretch;
	}
	else
	{
		ar >> m_strStaticFile;
		ar >> m_strDynFile;
		ar >> m_bDyn;
		ar >> m_strDynCondition;
		ar >> m_bStretch;
	}
}

void CDrawBitmap::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning)
	{
		CString sTemp1 = m_sOldFilePath;
		sTemp1 = sTemp1.MakeLower();

		if (-1 != sTemp1.Find(".gif"))
		{
			if (m_image)
			{
				delete m_image;
				m_image = NULL;
			}
		}
		return;
	}

	CRect rect = m_rect;
	rect.NormalizeRect();
	int nX1 = rect.left;
	int nY1 = rect.top;
	int nXX = rect.right - rect.left;
	int nYY = rect.bottom - rect.top;
	char curDir[256];
	strcpy(curDir, g_strDirectory);
	strcat(curDir, "\\");
	strcat(curDir, _BITMAPDIR);

#if 1
	CString sTemp1 = m_strStaticFile, sTemp2 = m_strDynFile;
	sTemp1 = sTemp1.MakeLower();
	sTemp2 = sTemp2.MakeLower();
	if (-1 != sTemp1.Find(".bmp") || -1 != sTemp2.Find(".bmp"))
	{
		if (bRuning && m_bDyn && m_bUseDnyFile)
			DisplayBMP(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strDynFile, m_bStretch);
		else
			DisplayBMP(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strStaticFile, m_bStretch);
	}
	else if (-1 != sTemp1.Find(".png") || -1 != sTemp2.Find(".png"))
	{
		if (bRuning && m_bDyn && m_bUseDnyFile)
			DisplayPNG(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strDynFile, m_bStretch);
		else
			DisplayPNG(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strStaticFile, m_bStretch);
	}
	else if (-1 != sTemp1.Find(".gif") || -1 != sTemp2.Find(".gif"))
	{
		if (bRuning && m_bDyn && m_bUseDnyFile)
			DisplayGIF(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strDynFile, m_bStretch);
		else
			DisplayGIF(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strStaticFile, m_bStretch);
	}
	else if (-1 != sTemp1.Find(".jpg") || -1 != sTemp2.Find(".jpg"))
	{
		if (bRuning && m_bDyn && m_bUseDnyFile)
			DisplayJPG(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strDynFile, m_bStretch);
		else
			DisplayJPG(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strStaticFile, m_bStretch);
	}
#else
	if (bRuning && m_bDyn && m_bUseDnyFile)
		DisplayJPG(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strDynFile, m_bStretch);
	else
		DisplayJPG(pDC, nX1, nY1, nXX, nYY, CString(curDir) + m_strStaticFile, m_bStretch);
#endif
}

BOOL CDrawBitmap::DisplayJPG(CDC* pDC,int nStartX,int nStartY,int nWidth,int nHeight,CString strJPGFile,BOOL bStretch)
{
	CString sTemp1 = m_sOldFilePath;
	sTemp1 = sTemp1.MakeLower();

	if (-1 != sTemp1.Find(".gif"))
	{
		if (m_image)
		{
			delete m_image;
			m_image = NULL;
		}
	}

	BSTR strtmp = strJPGFile.AllocSysString();
	Graphics graphics(pDC->m_hDC);
	Image image(strtmp, FALSE);
	SysFreeString(strtmp);

	if (bStretch)
	{
		graphics.DrawImage(&image, nStartX, nStartY, nWidth, nHeight);
	}
	else
	{
		Rect rcDest(nStartX, nStartY, nWidth, nHeight);
		graphics.DrawImage(&image, rcDest, 0, 0, nWidth, nHeight, UnitPixel);
	}

	return TRUE;
}

BOOL CDrawBitmap::DisplayBMP(CDC* pDC, int nStartX, int nStartY, int nWidth, int nHeight, CString strBMPFile, BOOL bStretch)
{
#if 0
	CString sTemp1 = m_sOldFilePath;
	sTemp1 = sTemp1.MakeLower();

	if (-1 != sTemp1.Find(".gif"))
	{
		if (m_image)
		{
			delete m_image;
			m_image = NULL;
		}
	}

	GdiplusStartupInput m_gdiplusStartupInput;
	//  ULONG_PTR m_pGdiToken;

	wchar_t m_wstrServerName[255];
	MultiByteToWideChar(CP_ACP, 0, strBMPFile, -1, m_wstrServerName, 256);
	Graphics graphics(pDC->m_hDC);
	//wchar_t * p=strJPGFile.AllocSysStrinig();
	Image image(m_wstrServerName, FALSE);

	if (bStretch)
	{
		graphics.DrawImage(&image, nX1, nY1, nXX, nYY);
	}
	else
	{
		WORD Width = (WORD)image.GetWidth();
		WORD Height = (WORD)image.GetHeight();
		//Width = min(Width,nXX);
		//Height = min(Height,nYY);
		//graphics.DrawImage( &image, nX1,nY1,Width,Height );
		graphics.DrawImage(&image, nX1, nY1, 0, 0, nXX, nYY, UnitPixel);
	}

	return true;
#else
	CString sTemp1 = m_sOldFilePath;
	sTemp1 = sTemp1.MakeLower();

	if (-1 != sTemp1.Find(".gif"))
	{
		if (m_image)
		{
			delete m_image;
			m_image = NULL;
		}
	}

	OFSTRUCT of;
	unsigned fh = OpenFile((char const*)strBMPFile, &of, OF_READ);
	if (fh == -1) return FALSE;

	DWORD size = (DWORD)(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
	HANDLE hDIBInfo = GlobalAlloc(GMEM_MOVEABLE, size);

	SetStretchBltMode(pDC->m_hDC, HALFTONE);
	BITMAPFILEHEADER bf;
	LPBITMAPINFOHEADER lpbi;
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIBInfo);
	_lread(fh, (LPSTR)&bf, sizeof(bf));
	_lread(fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER));
	WORD nClrs = (WORD)lpbi->biClrUsed;
	size = ((((lpbi->biWidth*lpbi->biBitCount) + 31)&~31) >> 3)*lpbi->biHeight;
	if (nClrs == 0 && lpbi->biBitCount != 24) nClrs = 1 << lpbi->biBitCount;
	if (lpbi->biClrUsed == 0) lpbi->biClrUsed = (DWORD)nClrs;
	if (lpbi->biSizeImage == 0) lpbi->biSizeImage = size;

	WORD Size = (WORD)lpbi->biSize;
	WORD Width = (WORD)lpbi->biWidth;
	WORD Height = (WORD)lpbi->biHeight;
	WORD ClrUsed = (WORD)lpbi->biClrUsed;
	WORD BitCount = (WORD)lpbi->biBitCount;
	DWORD SizeImage = lpbi->biSizeImage;
	WORD SizeRGB = nClrs * sizeof(RGBQUAD);
	WORD SizeHeader = Size + SizeRGB;

	GlobalUnlock(hDIBInfo);
	hDIBInfo = GlobalReAlloc(hDIBInfo, SizeHeader + SizeImage, 0);
	lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIBInfo);
	_lread(fh, (LPSTR)(lpbi)+Size, SizeRGB);
	if (bf.bfOffBits != 0L) _llseek(fh, bf.bfOffBits, SEEK_SET);

	DWORD ul = SizeImage;
	BYTE *hp = (BYTE *)((LPSTR)lpbi + SizeHeader);
	while (ul > 30000L)
	{
		_lread(fh, (LPSTR)hp, 30000L);
		ul -= 30000L;
		hp += 30000L;
	}
	_lread(fh, (LPSTR)hp, (WORD)ul);
	_lclose(fh);

	HPALETTE hPalette, hOldPal;
	HANDLE hPalHeader = NULL;

	HDC hDC = pDC->m_hDC;
	LPBITMAPINFOHEADER lpHeader = lpbi;
	WORD wDIBUse = DIB_RGB_COLORS;

	if (ClrUsed)
	{
		WORD size = sizeof(LOGPALETTE) + ClrUsed * sizeof(PALETTEENTRY);
		NPLOGPALETTE npPal = (NPLOGPALETTE)LocalAlloc(LMEM_FIXED, size);
		npPal->palVersion = 0x300;
		npPal->palNumEntries = ClrUsed;
		RGBQUAD FAR *lpRGB = (RGBQUAD FAR *)((LPSTR)lpbi + Size);
		for (WORD i = 0; i < ClrUsed; i++, lpRGB++)
		{
			npPal->palPalEntry[i].peRed = lpRGB->rgbRed;
			npPal->palPalEntry[i].peGreen = lpRGB->rgbGreen;
			npPal->palPalEntry[i].peBlue = lpRGB->rgbBlue;
			npPal->palPalEntry[i].peFlags = 0;
		}
		hPalette = CreatePalette((LPLOGPALETTE)npPal);
		LocalFree((HANDLE)npPal);
		hOldPal = SelectPalette(hDC, hPalette, FALSE);
		RealizePalette(hDC);

		if (BitCount != 24)
		{
			size = Size + ClrUsed * sizeof(WORD);
			hPalHeader = GlobalAlloc(GMEM_MOVEABLE, size);
			LPBITMAPINFOHEADER lpPalInfo;
			lpPalInfo = (LPBITMAPINFOHEADER)GlobalLock(hPalHeader);
			*lpPalInfo = *lpbi;
			WORD FAR *lpTable = (WORD FAR *)((LPSTR)lpPalInfo + Size);
			for (WORD i = 0; i < ClrUsed; i++) *lpTable++ = i;
			GlobalUnlock(hPalHeader);
			lpHeader = (LPBITMAPINFOHEADER)GlobalLock(hPalHeader);
			wDIBUse = DIB_PAL_COLORS;
		}
	}

	HDC hMemDC = CreateCompatibleDC(hDC);
	HBITMAP hDDBitmap = CreateCompatibleBitmap(hDC, Width, Height);
	SetDIBits(hDC, hDDBitmap, 0, Height, (LPSTR)lpbi + SizeHeader,
		(LPBITMAPINFO)lpHeader, wDIBUse);
	HBITMAP hOldBitmap = (HBITMAP)SelectObject(hMemDC, hDDBitmap);
	if (bStretch)
	{
		StretchBlt(hDC, nStartX, nStartY, nWidth, nHeight, hMemDC, 0, 0, Width, Height, SRCCOPY);
	}
	else
	{
		Width = min(Width, nWidth);
		Height = min(Height, nHeight);
		BitBlt(hDC, nStartX, nStartY, Width, Height, hMemDC, 0, 0, SRCCOPY);
	}
	SelectObject(hMemDC, hOldBitmap);
	DeleteDC(hMemDC);
	DeleteObject(hDDBitmap);

	if (ClrUsed)
	{
		SelectPalette(hDC, hOldPal, FALSE);
		DeleteObject(hPalette);
		if (BitCount != 24)
		{
			GlobalUnlock(hPalHeader);
			GlobalFree(hPalHeader);
		}
	}

	GlobalUnlock(hDIBInfo);
	GlobalFree(hDIBInfo);
	return TRUE;
#endif
}

BOOL CDrawBitmap::DisplayPNG(CDC* pDC, int nStartX, int nStartY, int nWidth, int nHeight, CString strPNGFile, BOOL bStretch)
{
	CString sTemp1 = m_sOldFilePath;
	sTemp1 = sTemp1.MakeLower();

	if (-1 != sTemp1.Find(".gif"))
	{
		if (m_image)
		{
			delete m_image;
			m_image = NULL;
		}
	}

	BSTR strtmp = strPNGFile.AllocSysString();
	Graphics graphics(pDC->m_hDC);
	Image image(strtmp, FALSE);
	SysFreeString(strtmp);

	if (bStretch)
	{
		graphics.DrawImage(&image, nStartX, nStartY, nWidth, nHeight);
	}
	else
	{
		Rect rcDest(nStartX, nStartY, nWidth, nHeight);
		graphics.DrawImage(&image, rcDest, 0, 0, nWidth, nHeight, UnitPixel);
	}

	return true;
}

BOOL CDrawBitmap::DisplayGIF(CDC* pDC, int nX1, int nY1, int nXX, int nYY, CString strJPGFile, BOOL bStretch)
{
	if (m_sOldFilePath != strJPGFile)
	{
		if (m_image)
		{
			delete m_image;
			m_image = NULL;
		}
	}

	if (m_image == NULL)
	{
		//char curDir[256] = {0};
		////strcpy(curDir, g_strDirectory);
		//strcat(curDir, ".\\\\");
		//strcat(curDir, _BITMAPDIR);

		//if( m_strStaticFile=="" )//gif 路徑為Bitmap，默認名為StounU.gif
		//	m_strStaticFile = "StounU.gif";

		//CString strGifFileName = CString(curDir) + m_strStaticFile;
		m_sOldFilePath = strJPGFile;
		// GDI+
		m_image = new ImageEx(StrToWchar(strJPGFile));
	}

	if (m_image)
	{
		//CRect rect = m_rect;
		//rect.NormalizeRect();
		//int nX1 = rect.left;
		//int nY1 = rect.top;

		//CPoint pt(nX1, nY1);
		CMainFrame* pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd();
		HWND hwnd = m_pView->GetSafeHwnd();//pFrame->m_pActiveView->m_hWnd;
		m_image->InitAnimation(hwnd, CRect(nX1, nY1, nX1 + nXX, nY1 + nYY), bStretch);
	}

	return true;
}

BOOL CDrawBitmap::OnAttrib(CPropertySheet& sheet)
{
	CBitmapPage page;

	page.m_strDynFile = m_strDynFile;
	page.m_strStaticFile = m_strStaticFile;
	page.m_bStretch = m_bStretch;
	page.m_bDyn = m_bDyn;
	page.m_strDynCondition = m_strDynCondition;

	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_strDynFile = page.m_strDynFile;
		m_strStaticFile = page.m_strStaticFile;
		m_bStretch = page.m_bStretch;
		m_bDyn = page.m_bDyn;
		m_strDynCondition = page.m_strDynCondition;
		return TRUE;
	}

	return FALSE;
}

//---------------------------------------------- CDrawGif --------
IMPLEMENT_SERIAL(CDrawGif, CDrawObj, 0)

CDrawGif::CDrawGif() :CDrawObj()
{
	//m_strStaticFile = "statusAlarm.gif";
	m_strStaticFile = "";
	m_strDynFile = "";
	m_bDyn = FALSE;
	m_strDynCondition = "";
	m_bStretch = TRUE;
	m_bUseDnyFile = FALSE;

	//char curDir[256] = {0};
	////strcpy(curDir, g_strDirectory);
	//strcat(curDir, ".\\\\");
	//strcat(curDir, _BITMAPDIR);

	//CString strGifFileName = CString(curDir) + m_strStaticFile;
	// GDI+
	m_image = NULL;
}

CDrawGif::~CDrawGif()
{
	if (m_image)
	{
		delete m_image;
		m_image = NULL;
	}
}

CDrawObj* CDrawGif::Clone(void)
{
	CDrawGif *pObj = new CDrawGif;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strStaticFile = m_strStaticFile;
	pObj->m_strDynFile = m_strDynFile;
	pObj->m_bDyn = m_bDyn;
	pObj->m_strDynCondition = m_strDynCondition;
	pObj->m_bStretch = m_bStretch;
	pObj->m_bUseDnyFile = m_bUseDnyFile;
	return pObj;
}


bool CDrawGif::Fresh(CRect &RECT)
{
	CDrawObj::Fresh(RECT);
	CRealComputer com;
	com.SetFormula(m_strDynCondition);
	m_bUseDnyFile = com.GetResult();

	//this->Invalidate( );
	//if( m_image )
	//{
	//	CRect rect = m_rect;
	//	rect.NormalizeRect();
	//	int nX1 = rect.left;
	//	int nY1 = rect.top;

	//	CPoint pt(nX1, nY1);
	//	CMainFrame* pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd();
	//	HWND hwnd = pFrame->m_pActiveView->m_hWnd;
	//	m_image->InitAnimation(hwnd, pt);
	//}
	RECT = m_rect;
	return false;
}

void CDrawGif::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_strStaticFile;
		ar << m_strDynFile;
		ar << m_bDyn;
		ar << m_strDynCondition;
		ar << m_bStretch;
	}
	else
	{
		ar >> m_strStaticFile;
		ar >> m_strDynFile;
		ar >> m_bDyn;
		ar >> m_strDynCondition;
		ar >> m_bStretch;
	}
}

void CDrawGif::Draw(CDC* pDC)
{
	if (m_image == NULL)
	{
		char curDir[256] = { 0 };
		//strcpy(curDir, g_strDirectory);
		strcat(curDir, ".\\\\");
		strcat(curDir, _BITMAPDIR);

		if (m_strStaticFile == "")//gif 路徑為Bitmap，默認名為StounU.gif
			m_strStaticFile = "StounU.gif";

		CString strGifFileName = CString(curDir) + m_strStaticFile;
		// GDI+
		m_image = new ImageEx(StrToWchar(strGifFileName));
	}

	if (m_image)
	{
		CRect rect = m_rect;
		rect.NormalizeRect();
		int nX1 = rect.left;
		int nY1 = rect.top;

		CPoint pt(nX1, nY1);
		CMainFrame* pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd();
		HWND hwnd = pFrame->m_pActiveView->m_hWnd;
		m_image->InitAnimation(hwnd, pt);
	}
}

BOOL CDrawGif::OnAttrib(CPropertySheet& sheet)
{
	CBitmapPage page;

	page.m_strDynFile = m_strDynFile;
	page.m_strStaticFile = m_strStaticFile;
	page.m_bStretch = m_bStretch;
	page.m_bDyn = m_bDyn;
	page.m_strDynCondition = m_strDynCondition;

	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_strDynFile = page.m_strDynFile;
		m_strStaticFile = page.m_strStaticFile;
		m_bStretch = page.m_bStretch;
		m_bDyn = page.m_bDyn;
		m_strDynCondition = page.m_strDynCondition;

		char curDir[256];
		strcpy(curDir, g_strDirectory);
		strcat(curDir, "\\");
		strcat(curDir, _BITMAPDIR);

		CString strGifFileName = CString(curDir) + m_strStaticFile;
		m_image->FromFile(StrToWchar(strGifFileName));
		CRect rect = m_rect;
		rect.NormalizeRect();
		int nX1 = rect.left;
		int nY1 = rect.top;

		CPoint pt(nX1, nY1);
		CMainFrame* pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd();
		HWND hwnd = pFrame->m_pActiveView->m_hWnd;
		m_image->InitAnimation(hwnd, pt);
		return TRUE;
	}
	return FALSE;
}


//---------------------------------------------- CDrawTransfer --------
IMPLEMENT_SERIAL(CDrawTransfer, CDrawObj, 0)

CDrawTransfer::CDrawTransfer() :CDrawObj()
{
	m_clrLine = RGB(0, 255, 0);
}

CDrawObj* CDrawTransfer::Clone(void)
{
	CDrawTransfer *pObj = new CDrawTransfer;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawTransfer::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;

	COLORREF clrLine = m_clrLine;
	COLORREF clrBack = m_clrBack;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrLine = m_clrCurrentLine;
		clrBack = m_clrCurrentBack;
		rect = m_rctCurrent;
	}
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);

	rect.NormalizeRect();

	int x = (rect.left + rect.right) / 2;
	int y = (rect.top + rect.bottom) / 2;
	int r = min(rect.Width(), rect.Height()) * 0.25;

	DrawCircle(pDC, CPoint(x, y - 0.7*r), r);

	CPen pen1(GetPenStyle(m_strLineType), m_nLineWidth, clrBack);
	pDC->SelectObject(&pen1);

	pDC->SelectObject(&pen1);
	DrawCircle(pDC, CPoint(x, y + 0.7*r), r);

	pDC->SelectObject(pOldPen);
	DeleteObject(pen);
	DeleteObject(pen1);
}


void CDrawTransfer::DrawCircle(CDC *pDC, POINT origin, int radius)
{
	pDC->MoveTo(origin.x + radius, origin.y);
	pDC->AngleArc(origin.x, origin.y, radius, 0, 360);

}


//---------------------------------------------- CDrawButton ------
IMPLEMENT_SERIAL(CDrawButton, CDrawObj, 0)

CDrawButton::CDrawButton() :CDrawObj()
{
	m_clrFore = RGB(255, 255, 255);
	m_clrBack = RGB(255, 128, 0);
	m_strCaption = "按钮";
	m_clrCurrentBack = m_clrBack;
}

CDrawObj* CDrawButton::Clone(void)
{
	CDrawButton *pObj = new CDrawButton;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawButton::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	CRect rect = m_rctCurrent;
	COLORREF color = m_clrCurrentBack;
	if (!bRuning)
	{
		rect = m_rect;
		color = m_clrBack;
	}
	pDC->FillSolidRect(rect, color);

	int Width = 2;
	int nR0 = GetRValue(color);
	int nG0 = GetGValue(color);
	int nB0 = GetBValue(color);
	int nRMin = nR0 / 2;
	int nGMin = nG0 / 2;
	int nBMin = nB0 / 2;
	int nRMax = min(nR0 * 2, 255);
	int nGMax = min(nG0 * 2, 255);
	int nBMax = min(nB0 * 2, 255);
	for (int i = 0; i < Width; i++)
	{
		int n = i;
		int nR1 = (n*nR0 + (Width - n)*nRMax) / Width;
		int nG1 = (n*nG0 + (Width - n)*nGMax) / Width;
		int nB1 = (n*nB0 + (Width - n)*nBMax) / Width;
		COLORREF clrLight = RGB(nR1, nG1, nB1);
		int nR2 = (n*nR0 + (Width - n)*nRMin) / Width;
		int nG2 = (n*nG0 + (Width - n)*nGMin) / Width;
		int nB2 = (n*nB0 + (Width - n)*nBMin) / Width;
		COLORREF clrDark = RGB(nR2, nG2, nB2);
		pDC->Draw3dRect(rect, clrLight, clrDark);
		rect.DeflateRect(1, 1, 1, 1);
	}
	DrawText(pDC);
}


//---------------------------------------------- CDrawDatabox -----
IMPLEMENT_SERIAL(CDrawDatabox, CDrawObj, 0)

CDrawDatabox::CDrawDatabox() :CDrawObj()
{
	m_clrLine = RGB(0, 0, 0);
	m_clrBack = RGB(255, 0, 0);//RGB(255,128,0);
	m_clrFore = RGB(0, 0, 0);
	m_clrFill = RGB(255, 0, 0);
	m_nFillMode = 0;
	m_nFormat = 1;
	m_bVariant = true;
}

CDrawObj* CDrawDatabox::Clone(void)
{
	CDrawDatabox *pObj = new CDrawDatabox;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_nFormat = m_nFormat;
	pObj->m_nFillMode = m_nFillMode;
	return pObj;
}
bool CDrawDatabox::Fresh(CRect &RECT)
{
	CDrawObj::Fresh(RECT);

	//InvalidateRect( g_pMainFrm->GetSafeHwnd(),m_rctCurrent,false );
	//Invalidate( );
	RECT = m_rect;
	return true;
}
void CDrawDatabox::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	CRect rectRgn = m_rctCurrent;
	COLORREF clrPen = m_clrCurrentLine;
	COLORREF clrBrush = m_clrCurrentBack;
	COLORREF clrText = m_clrCurrentFore;

	if (!bRuning)
	{
		rectRgn = m_rect;
		clrPen = m_clrLine;
		clrBrush = m_clrBack;
		clrText = m_clrFore;
	}

	CString value = "";
	if (!m_bVariant)
		value = m_strCaption;
	else
	{
		int nValue = 0;
		switch (m_nFormat)
		{
		case 0:
			nValue = (int)m_fCurrentValue;
			value.Format("%d", nValue);
			break;
		case 1:
			value.Format("%.1f", m_fCurrentValue);
			break;
		case 2:
			value.Format("%.2f", m_fCurrentValue);
			break;
		case 3:
			value.Format("%.3f", m_fCurrentValue);
			break;
		}
	}

	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, clrPen);
	CPen* pOldPen = pDC->SelectObject(&pen);

	CBrush brush;
	CBrush* pOldBrush;
	if (m_bVariant)
	{
		int nRet = 0;//pVariantsManager->VarIsAlarm( m_strCaption );

		if (nRet == 1 && bRuning)//报警
		{
			brush.CreateSolidBrush(clrBrush);
			pOldBrush = pDC->SelectObject(&brush);
		}
		else
		{
			LOGBRUSH logBrush = GetBrush();

			brush.CreateBrushIndirect(&logBrush);
			pOldBrush = pDC->SelectObject(&brush);
		}
	}
	else
	{
		LOGBRUSH logBrush = GetBrush();

		brush.CreateBrushIndirect(&logBrush);
		pOldBrush = pDC->SelectObject(&brush);
	}

	pDC->Rectangle(rectRgn);
	//pDC->SelectObject(pOldPen);
	//pDC->SelectObject(pOldBrush);

	rectRgn.NormalizeRect();
	pDC->LPtoDP(&rectRgn);
	CRgn rgn;
	rgn.CreateRectRgnIndirect(&rectRgn);
	pDC->SelectClipRgn(&rgn);
	DrawText(pDC, value);
	pDC->SelectClipRgn(NULL);

	DeleteObject(pen);
	DeleteObject(brush);
	DeleteObject(rgn);
}

void CDrawDatabox::DrawText(CDC* pDC, CString& strText)
{
	CRect rect = m_rctCurrent;
	COLORREF txtColor = m_clrCurrentFore;
	if (!bRuning)
	{
		rect = m_rect;
		txtColor = m_clrFore;
	}

	int nX0 = (rect.left + rect.right) / 2;
	int nY0 = (rect.top + rect.bottom) / 2;

	CFont font;
	font.CreateFontIndirect(&m_logfont);
	CFont* pOldFont = pDC->SelectObject(&font);

	CSize sizeText = pDC->GetTextExtent(strText);
	int nInterval = sizeText.cy / 2;
	int nYText = nY0 - nInterval + 1;

	int nXText;
	pDC->SetTextAlign(TA_CENTER | TA_TOP);
	nXText = nX0;

	pDC->SetTextColor(txtColor);
	pDC->TextOut(nXText, nYText, strText);
	pDC->SelectObject(pOldFont);

	DeleteObject(font);
}


void CDrawDatabox::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_nFormat;
	}
	else
	{
		ar >> m_nFormat;
	}
}

BOOL CDrawDatabox::OnAttrib(CPropertySheet& sheet)
{
	CDataPage page;
	page.m_nFormat = m_nFormat;
	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_nFormat = page.m_nFormat;
		return TRUE;
	}

	return FALSE;
}


//---------------------------------------------- CDrawWatch -----
IMPLEMENT_SERIAL(CDrawWatch, CDrawObj, 0)

CDrawWatch::CDrawWatch() :CDrawObj()
{
	m_clrLine = RGB(255, 0, 0);
	m_clrBack = RGB(192, 192, 192);
	m_clrFore = RGB(0, 0, 0);
	m_nLineWidth = 1;
	m_nLowwer = 0;
	m_nUpper = 1000;
	m_strVar = "";
}


CDrawObj* CDrawWatch::Clone(void)
{
	CDrawWatch *pObj = new CDrawWatch;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawWatch::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	CRect rectRgn = m_rctCurrent;
	COLORREF clrPen = m_clrCurrentLine;
	COLORREF clrBrush = m_clrCurrentBack;
	COLORREF clrText = m_clrCurrentFore;

	if (!bRuning)
	{
		rectRgn = m_rect;
		clrPen = m_clrLine;
		clrBrush = m_clrBack;
		clrText = m_clrFore;
	}
	if (!m_bVariant)
		m_strCurrentCaption = m_strCaption;

	rectRgn.NormalizeRect();
	CBrush brush(clrText);
	CBrush *prebrush = pDC->SelectObject(&brush);
	pDC->FillSolidRect(rectRgn, clrBrush);

	int top = rectRgn.top + 10;
	int middle = rectRgn.bottom - 40;
	if (middle < top) middle = top;
	CRect rectPie = CRect(rectRgn.left + 10, top, rectRgn.right - 10, top + 2 * (middle - top));
	CPoint s = CPoint(rectRgn.right - 10, middle);
	CPoint e = CPoint(rectRgn.left + 10, middle);

	INT		HorzRes = pDC->GetDeviceCaps(HORZRES);
	INT		VertRes = pDC->GetDeviceCaps(VERTRES);
	INT		VertSize = pDC->GetDeviceCaps(VERTSIZE);
	INT		HorzSize = pDC->GetDeviceCaps(HORZSIZE);
	m_lAspectN = ((LONG)VertRes * 100) / (LONG)VertSize;
	m_lAspectD = ((LONG)HorzRes * 100) / (LONG)HorzSize;

	// 画指针
	CPen pen(GetPenStyle(m_strLineType), m_nLineWidth, m_clrLine);
	CPen* pOldPen = pDC->SelectObject(&pen);
	pDC->MoveTo(rectPie.CenterPoint());

	// 计算指针位置
	rectPie.DeflateRect(5, 5, 5, 5);
	CRgn  rgn;
	rgn.CreateEllipticRgnIndirect(rectPie);
	float angle = 180 - 180 * (m_fCurrentValue - m_nLowwer) / (m_nUpper - m_nLowwer);
	int bLeft = 1;
	if (angle < 90) bLeft = -1;

	CPoint lastPoint;
	int clockRadius = min(m_rect.Width() / 2 - 10, m_rect.Height() - 50) - 10;
	lastPoint.x = rectPie.CenterPoint().x + clockRadius*cos(angle / 180 * PI);
	lastPoint.y = rectPie.CenterPoint().y - clockRadius*sin(angle / 180 * PI);

	pDC->LineTo(lastPoint);
	pDC->SelectObject(pOldPen);

	pDC->DrawEdge(&rectRgn, BDR_RAISEDOUTER, BF_RECT);
	rectRgn.DeflateRect(1, 1);
	pDC->DrawEdge(rectRgn, BDR_RAISEDOUTER, BF_RECT);
	rectRgn.left = rectRgn.left + 5;
	rectRgn.right = rectRgn.right - 5;
	rectRgn.top = rectRgn.top + 5;
	rectRgn.bottom = rectRgn.bottom - 35;
	pDC->DrawEdge(&rectRgn, BDR_SUNKENOUTER, BF_RECT);
	pDC->SelectObject(prebrush);
	pDC->SelectObject(pOldPen);

	//DrawFace(pDC);

	DeleteObject(pen);
	DeleteObject(brush);
	DeleteObject(rgn);
}
void CDrawWatch::DrawFace(CDC* pDC)
{
	INT        i;
	RECT       tRect;
	tagPOINT   clockCenter;

	char c[5] = { 0 };
	int clockRadius = min(m_rect.Width() / 2 - 10, m_rect.Height() - 50);
	clockCenter.y = m_rect.bottom - 20;
	clockCenter.x = m_rect.left + m_rect.Width() / 2;

	for (i = 0; i < 31; i++)
	{
		tRect.top = (INT)(((LONG)(CirTab[i].cos) * clockRadius) / CLKSCALE + clockCenter.y - 20);
		tRect.left = (INT)(((LONG)(CirTab[i].sin) * clockRadius) / CLKSCALE + clockCenter.x);

		if (i % 5)
		{
			tRect.right = tRect.left + 2;
			tRect.bottom = tRect.top + 2;
			pDC->FillSolidRect(&tRect, RGB(255, 0, 0));
		}
		else
		{
			tRect.right = tRect.left + 2;
			tRect.bottom = tRect.top + 2;

			if ((i / 5) == 0)
				_itoa(m_nLowwer, c, 10);
			else
				_itoa((m_nUpper - m_nLowwer) * i / 30, c, 10);

			pDC->SetTextColor(m_clrFore);
			pDC->TextOut(tRect.left - 1, tRect.top - 2, c, (int)strlen(c));
		}
	}
}
void CDrawWatch::DrawText(CDC* pDC, CString& strText)
{
	CRect rect = m_rctCurrent;
	COLORREF txtColor = m_clrCurrentFore;
	if (!bRuning)
	{
		rect = m_rect;
		txtColor = m_clrFore;
	}

	int nX0 = (rect.left + rect.right) / 2;
	int nY0 = (rect.top + rect.bottom) / 2;

	CFont font;
	font.CreateFontIndirect(&m_logfont);
	CFont* pOldFont = pDC->SelectObject(&font);

	CSize sizeText = pDC->GetTextExtent(strText);
	int nInterval = sizeText.cy / 2;
	int nYText = nY0 - nInterval + 1;

	int nXText;
	pDC->SetTextAlign(TA_CENTER | TA_TOP);
	nXText = nX0;

	pDC->SetTextColor(txtColor);
	pDC->TextOut(nXText, nYText, strText);
	pDC->SelectObject(pOldFont);

	DeleteObject(font);
}

void CDrawWatch::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_nLowwer;
		ar << m_nUpper;
		ar << m_strVar;
	}
	else
	{
		ar >> m_nLowwer;
		ar >> m_nUpper;
		ar >> m_strVar;
	}
}


BOOL CDrawWatch::OnAttrib(CPropertySheet& sheet)
{
	CWatchPage page;
	page.m_nLowwer = m_nLowwer;
	page.m_nUpper = m_nUpper;
	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_nLowwer = page.m_nLowwer;
		m_nUpper = page.m_nUpper;
		return TRUE;
	}
	return FALSE;
}

//---------------------------------------------- CDrawSingleBar -----
IMPLEMENT_SERIAL(CDrawSingleBar, CDrawObj, 0)

CDrawSingleBar::CDrawSingleBar() :CDrawObj()
{
	m_clrLine = RGB(0, 0, 64);
	m_clrBack = RGB(192, 192, 192);
	m_clrFore = RGB(255, 0, 0);
	m_nLineWidth = 2;
	m_nLowwer = 0;
	m_nUpper = 100;
}

CDrawObj* CDrawSingleBar::Clone(void)
{
	CDrawSingleBar *pObj = new CDrawSingleBar;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDrawSingleBar::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;
	CRect rectRgn = m_rctCurrent;
	COLORREF clrPen = m_clrCurrentLine;
	COLORREF clrBrush = m_clrCurrentBack;
	COLORREF clrText = m_clrCurrentFore;

	if (!bRuning)
	{
		rectRgn = m_rect;
		clrPen = m_clrLine;
		clrBrush = m_clrBack;
		clrText = m_clrFore;
	}
	if (!m_bVariant)
		m_strCurrentCaption = m_strCaption;

	rectRgn.NormalizeRect();
	CBrush brush(clrText);
	CBrush *prebrush = pDC->SelectObject(&brush);
	pDC->FillSolidRect(rectRgn, clrBrush);

	pDC->DrawEdge(&rectRgn, BDR_RAISEDOUTER, BF_RECT);

	CRect kedu = rectRgn;
	kedu.left += 3;
	kedu.right = kedu.left + 5;
	kedu.top += 4;
	kedu.bottom -= 5;
	DrawVKedu(pDC, kedu, 50, m_clrLine);

	rectRgn.left = rectRgn.left + 10;
	rectRgn.right = rectRgn.right - 4;
	rectRgn.top = rectRgn.top + 4;
	rectRgn.bottom = rectRgn.bottom - 4;
	pDC->DrawEdge(&rectRgn, BDR_SUNKENOUTER, BF_RECT);

	// 画值
	rectRgn.NormalizeRect();
	rectRgn.left = rectRgn.left + 3;
	rectRgn.right = rectRgn.right - 3;
	float rate = (m_fCurrentValue - m_nLowwer) / (m_nUpper - m_nLowwer);
	rectRgn.top = rectRgn.top + rectRgn.Height()*rate;
	rectRgn.bottom = rectRgn.bottom - 3;
	pDC->FillSolidRect(rectRgn, clrText);

	pDC->SelectObject(prebrush);

	DeleteObject(brush);
}


void CDrawSingleBar::DrawText(CDC* pDC, CString& strText)
{
	CRect rect = m_rctCurrent;
	COLORREF txtColor = m_clrCurrentFore;
	if (!bRuning)
	{
		rect = m_rect;
		txtColor = m_clrFore;
	}

	int nX0 = (rect.left + rect.right) / 2;
	int nY0 = (rect.top + rect.bottom) / 2;

	CFont font;
	font.CreateFontIndirect(&m_logfont);
	CFont* pOldFont = pDC->SelectObject(&font);

	CSize sizeText = pDC->GetTextExtent(strText);
	int nInterval = sizeText.cy / 2;
	int nYText = nY0 - nInterval + 1;

	int nXText;
	pDC->SetTextAlign(TA_CENTER | TA_TOP);
	nXText = nX0;

	pDC->SetTextColor(txtColor);
	pDC->TextOut(nXText, nYText, strText);
	pDC->SelectObject(pOldFont);

	DeleteObject(font);
}


BOOL CDrawSingleBar::OnAttrib(CPropertySheet& sheet)
{
	CSingleBarPage page;
	page.m_nLower = m_nLowwer;
	page.m_nUpper = m_nUpper;
	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_nLowwer = page.m_nLower;
		m_nUpper = page.m_nUpper;
		return TRUE;
	}
	return FALSE;
}

//---------------------------------------------- CDraw3dCircle ----
IMPLEMENT_SERIAL(CDraw3dCircle, CDrawObj, 0)

CDraw3dCircle::CDraw3dCircle()
{
	m_clrFore = RGB(0, 255, 0);
	m_clrBack = RGB(0, 128, 0);
	m_clrLine = RGB(255, 255, 255);
	//m_clrCurrentLine = RGB( 255,255,255 );
}

CDrawObj* CDraw3dCircle::Clone(void)
{
	CDraw3dCircle *pObj = new CDraw3dCircle;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	return pObj;
}

void CDraw3dCircle::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	if (!m_bShow && bRuning) return;
	COLORREF clrPen = m_clrLine;
	CRect rect = m_rctCurrent;
	COLORREF color = m_clrCurrentBack;
	if (!bRuning)
	{
		rect = m_rect;
		color = m_clrBack;
	}

	rect.NormalizeRect();
	int nX0 = (rect.left + rect.right) / 2;
	int nY0 = (rect.top + rect.bottom) / 2;
	int nRadius = min(rect.Width() / 2, rect.Height() / 2);

	rect = CRect(nX0 - nRadius, nY0 - nRadius, nX0 + nRadius, nY0 + nRadius);
	CBrush brush;
	brush.CreateSolidBrush(color);
	pDC->SelectObject(&brush);
	CPen framePen;
	framePen.CreatePen(PS_NULL, m_nLineWidth, m_clrLine);
	pDC->SelectObject(&framePen);
	pDC->Ellipse(rect);

	CPen arcpen;
	arcpen.CreatePen(PS_SOLID, 2, m_clrCurrentLine);//RGB(255,255,255));
	pDC->SelectObject(&arcpen);
	pDC->Arc(CRect(nX0 - nRadius / 2, nY0 - nRadius / 2, nX0 + nRadius / 2, nY0 + nRadius / 2),
		CPoint(nX0, nY0 - nRadius / 2), CPoint(nX0 - nRadius / 2, nY0));

	DeleteObject(arcpen);
	DeleteObject(brush);
}


//---------------------------------------------- CDrawBar -------
IMPLEMENT_SERIAL(CDrawBar, CDrawObj, 0)

CDrawBar::CDrawBar() :CDrawObj()
{
	m_clrBar1 = RGB(255, 0, 0);
	m_clrBar2 = RGB(0, 255, 0);
	m_clrBar3 = RGB(0, 0, 255);
	m_nLowwer = 0;
	m_nUpper = 200;
	m_strVar1 = "";
	m_strVar2 = "";
	m_strVar3 = "";

	m_nValue1 = 0;
	m_nValue2 = 0;
	m_nValue3 = 0;

	m_clrFill = RGB(255, 255, 255);
	m_nFillMode = 1;
}


CDrawObj* CDrawBar::Clone(void)
{
	CDrawBar *pObj = new CDrawBar;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_clrBar1 = m_clrBar1;
	pObj->m_clrBar2 = m_clrBar2;
	pObj->m_clrBar3 = m_clrBar3;
	pObj->m_nLowwer = m_nLowwer;
	pObj->m_nUpper = m_nUpper;
	pObj->m_strVar1 = m_strVar1;
	pObj->m_strVar2 = m_strVar2;
	pObj->m_strVar3 = m_strVar3;

	return pObj;
}


void CDrawBar::DrawBar(CDC* pDC, int data, int x1, int x2, COLORREF clrBar)
{
	CRect rect = m_rect;
	rect.NormalizeRect();
	float rate = (1.0*(data - m_nLowwer)) / (m_nUpper - m_nLowwer);
	int y1 = rect.bottom - int(rect.Height()*rate);
	y1 = max(rect.top, y1);
	y1 = min(rect.bottom, y1);
	pDC->FillSolidRect(x1, y1, x2 - x1, rect.bottom - y1, clrBar);
}

void CDrawBar::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	CRect rect = m_rect;
	rect.NormalizeRect();
	int width = rect.Width();

	LOGBRUSH brushlog = GetBrush();
	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);
	if (m_nFillMode < 8)
	{
		pDC->Rectangle(rect);
	}

	int num = GetBarNum();
	int barWidth = width;
	if (num != 0)
	{
		barWidth = width / (num * 2 + 1);
	}
	int hadDraw = 0;

	// 画刻度
	CPen pen(PS_SOLID, 1, RGB(255, 255, 255));
	CPen* pOldPen = pDC->SelectObject(&pen);
	pDC->MoveTo(rect.left, rect.top);
	pDC->LineTo(rect.left, rect.bottom);
	pDC->LineTo(rect.right, rect.bottom);
	pDC->LineTo(rect.right, rect.top);
	pDC->LineTo(rect.left, rect.top);
	pDC->SelectObject(pOldPen);

	if (bRuning)
	{
		if (!m_strVar1.IsEmpty())
		{
			int left = rect.left + barWidth;
			int right = rect.left + barWidth * 2;
			DrawBar(pDC, m_nValue1, left, right, m_clrBar1);
			hadDraw++;
		}

		if (!m_strVar2.IsEmpty())
		{
			int left = rect.left + barWidth + hadDraw*barWidth * 2;
			int right = rect.left + barWidth * 2 + hadDraw*barWidth * 2;
			DrawBar(pDC, m_nValue2, left, right, m_clrBar2);
			hadDraw++;
		}

		if (!m_strVar3.IsEmpty())
		{
			int left = rect.left + barWidth + hadDraw*barWidth * 2;
			int right = rect.left + barWidth * 2 + hadDraw*barWidth * 2;
			DrawBar(pDC, m_nValue3, left, right, m_clrBar3);
		}
	}
	else
	{
		DrawBar(pDC, 50, rect.left + width / 7, rect.left + width / 7 * 2, m_clrBar1);
		DrawBar(pDC, 100, rect.left + width / 7 * 3, rect.left + width / 7 * 4, m_clrBar2);
		DrawBar(pDC, 150, rect.left + width / 7 * 5, rect.left + width / 7 * 6, m_clrBar3);
	}
	// 网格
	CPen penGrid(PS_DOT, 1, RGB(128, 128, 128));
	pOldPen = pDC->SelectObject(&penGrid);
	for (int i = 1; i < 5; i++)
	{
		pDC->MoveTo(rect.left, rect.top + rect.Height() / 5 * i);
		pDC->LineTo(rect.right, rect.top + rect.Height() / 5 * i);
	}
	pDC->SelectObject(pOldPen);

	DeleteObject(pen);
	DeleteObject(penGrid);
	DeleteObject(m_brush);
}

void CDrawBar::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_clrBar1;
		ar << m_clrBar2;
		ar << m_clrBar3;
		ar << m_nLowwer;
		ar << m_nUpper;
		ar << m_strVar1;
		ar << m_strVar2;
		ar << m_strVar3;
	}
	else
	{
		ar >> m_clrBar1;
		ar >> m_clrBar2;
		ar >> m_clrBar3;
		ar >> m_nLowwer;
		ar >> m_nUpper;
		ar >> m_strVar1;
		ar >> m_strVar2;
		ar >> m_strVar3;
	}
}

BOOL CDrawBar::OnAttrib(CPropertySheet& sheet)
{
	CBarPage page;
	page.m_nLowwer = m_nLowwer;
	page.m_nUpper = m_nUpper;
	page.m_strVar1 = m_strVar1;
	page.m_strVar2 = m_strVar2;
	page.m_strVar3 = m_strVar3;
	page.m_clrBar1 = m_clrBar1;
	page.m_clrBar2 = m_clrBar2;
	page.m_clrBar3 = m_clrBar3;
	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_nLowwer = page.m_nLowwer;
		m_nUpper = page.m_nUpper;
		m_strVar1 = page.m_strVar1;
		m_strVar2 = page.m_strVar2;
		m_strVar3 = page.m_strVar3;
		m_clrBar1 = page.m_clrBar1;
		m_clrBar2 = page.m_clrBar2;
		m_clrBar3 = page.m_clrBar3;
		return TRUE;
	}
	return FALSE;
}


bool CDrawBar::Fresh(CRect &RECT)
{
	if (!m_strVar1.IsEmpty())
	{
		// 		int nValue = (int) pVariantsManager->GetAnalogValue(m_strVar1);
		// 		if( nValue == -1 ) return true;
		// 		m_nValue1 = (int) pVariantsManager->GetAnalogValue(m_strVar1);
	}
	if (!m_strVar2.IsEmpty())
	{
		// 		int nValue = (int) pVariantsManager->GetAnalogValue(m_strVar2);
		// 		if( nValue == -1 ) return true;
		// 		m_nValue2 = (int) pVariantsManager->GetAnalogValue(m_strVar2);
	}
	if (!m_strVar3.IsEmpty())
	{
		// 		int nValue = (int) pVariantsManager->GetAnalogValue(m_strVar3);
		// 		if( nValue == -1 ) return true;
		// 		m_nValue3 = (int) pVariantsManager->GetAnalogValue(m_strVar3);
	}
	RECT = m_rect;
	return true;
}

int CDrawBar::GetBarNum()
{
	int num = 0;
	if (!m_strVar1.IsEmpty())
	{
		num++;
	}
	if (!m_strVar2.IsEmpty())
	{
		num++;
	}
	if (!m_strVar3.IsEmpty())
	{
		num++;
	}
	return num;
}


//---------------------------------------------- CDrawCurve -------
IMPLEMENT_SERIAL(CDrawCurve, CDrawObj, 0)

CDrawCurve::CDrawCurve() :CDrawObj()
{
	m_clrFore = RGB(0, 0, 0);
	//m_clrFill = RGB(0, 0, 255);
	//m_clrLine = RGB(0, 0, 255);		// 线色
	m_clrBack = RGB(64, 128, 128);
	//m_clrCurrentFore = RGB(0, 0, 255);
	//m_clrCurrentBack = RGB(0, 0, 255);
	//m_clrCurrentLine = RGB(0, 0, 255);

	m_clrFill = RGB(255, 255, 255);
	m_clrCurve1 = RGB(255, 0, 0);
	m_clrCurve2 = RGB(0, 255, 0);
	m_clrCurve3 = RGB(0, 0, 255);
	m_clrLine = RGB(0, 0, 0);
	m_nLowwer = 0;
	m_nUpper = 200;
	m_strVar1 = "";
	m_strVar2 = "";
	m_strVar3 = "";
	m_nFillMode = 1;

	m_fValue1 = 0.0;
	m_fValue2 = 0.0;
	m_fValue3 = 0.0;


	for (int i = 0; i < 60; i++)
	{
		m_nValue1[i] = 0;
		m_nValue2[i] = 0;
		m_nValue3[i] = 0;
	}
}


CDrawObj* CDrawCurve::Clone(void)
{
	CDrawCurve *pObj = new CDrawCurve;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_clrCurve1 = m_clrCurve1;
	pObj->m_clrCurve2 = m_clrCurve2;
	pObj->m_clrCurve3 = m_clrCurve3;
	pObj->m_nLowwer = m_nLowwer;
	pObj->m_nUpper = m_nUpper;
	pObj->m_strVar1 = m_strVar1;
	pObj->m_strVar2 = m_strVar2;
	pObj->m_strVar3 = m_strVar3;

	return pObj;
}


void CDrawCurve::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	CRect rect = m_rect;
	rect.NormalizeRect();

	CString sText;

	LOGBRUSH brushlog = GetBrush();
	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);
	if (m_nFillMode < 8)
	{
		pDC->Rectangle(rect);
	}
	DeleteObject(m_brush);

	// 边框
	pDC->DrawEdge(rect, BDR_RAISEDINNER, BF_RECT);
	CRect inner;
	inner.left = rect.left + 40;
	inner.right = rect.right - 10;
	inner.top = rect.top + 10;
	inner.bottom = rect.bottom - 30;
	//pDC->DrawEdge(&inner,EDGE_ETCHED ,BF_RECT);

	// 显示60个点，1s一个点
	if (bRuning)
	{
		if (!m_strVar1.IsEmpty())
		{
			DrawCurve(pDC, inner, m_nValue1, m_clrCurve1);
		}
		if (!m_strVar2.IsEmpty())
		{
			DrawCurve(pDC, inner, m_nValue2, m_clrCurve2);
		}
		if (!m_strVar3.IsEmpty())
		{
			DrawCurve(pDC, inner, m_nValue3, m_clrCurve3);
		}
	}
	else
	{
		for (int i = 0; i < 60; i++)
		{
			m_nValue1[i] = 100 + (i % 10) * 4 - (i % 15);
			m_nValue2[i] = 80 + (i % 15) * 3 - i;
			m_nValue3[i] = 60 + (i % 20) * 3 + i;
		}
		DrawCurve(pDC, inner, m_nValue1, m_clrCurve1);
		DrawCurve(pDC, inner, m_nValue2, m_clrCurve2);
		DrawCurve(pDC, inner, m_nValue3, m_clrCurve3);
	}


	// 网格
	CPen penGrid(PS_DOT, 1, RGB(192, 192, 192));
	CPen* pOldPen = pDC->SelectObject(&penGrid);

	pDC->SetTextColor(m_clrFore);
	pDC->SetTextAlign(TA_RIGHT);

	int Y = 0;
	float rate = 0;//(1.0*(m_nLowerLimit-m_nLowwer)) / (m_nUpper-m_nLowwer);

	int nSpace = (m_nUpper - m_nLowwer) / 10;
	if (nSpace % 10 != 0)
		nSpace += (10 - nSpace % 10);

	if (m_nUpper == 2 && m_nLowwer == 0)
		nSpace = 1;

	for (int i = m_nLowwer + nSpace; i < m_nUpper; i += nSpace)
	{
		rate = (1.0*(i - m_nLowwer)) / (m_nUpper - m_nLowwer);
		Y = inner.bottom - int(inner.Height()*rate);
		if (Y > inner.bottom)
			Y = inner.bottom;
		if (Y < inner.top)
			Y = inner.top;
		pDC->MoveTo(inner.left, Y);
		pDC->LineTo(inner.right, Y);
		sText.Format("%d", i);
		pDC->TextOut(inner.left - 5, Y - 7, sText);
	}
	DeleteObject(penGrid);

	CPen penFrame(PS_SOLID, 1, RGB(0, 0, 0));
	pDC->SelectObject(&penFrame);
	pDC->MoveTo(inner.left, inner.top);
	pDC->LineTo(inner.right, inner.top);
	pDC->LineTo(inner.right, inner.bottom);

	CRect leftKedu = inner;
	leftKedu.right = leftKedu.left + 5;
	DrawVKedu(pDC, leftKedu, 50, m_clrLine);

	CRect bottomKedu = inner;
	bottomKedu.top = leftKedu.bottom - 5;
	DrawHKedu(pDC, bottomKedu, 60, m_clrLine);

	pDC->SelectObject(pOldPen);
	DeleteObject(penFrame);

	////////////////////
	if (m_strVarDes1 != "")
	{
		pDC->SetTextAlign(TA_LEFT);
		pDC->SetTextColor(m_clrCurve1);
		sText.Format("%s【%0.1f】", m_strVarDes1, m_fValue1);
		pDC->TextOut(rect.left + 20, rect.bottom - 23, sText);
	}

	if (m_strVarDes2 != "")
	{
		pDC->SetTextAlign(TA_CENTER);
		pDC->SetTextColor(m_clrCurve2);
		sText.Format("%s【%0.1f】", m_strVarDes2, m_fValue2);
		pDC->TextOut(rect.left + rect.Width() / 2, rect.bottom - 23, sText);
	}

	if (m_strVarDes3 != "")
	{
		pDC->SetTextAlign(TA_RIGHT);
		pDC->SetTextColor(m_clrCurve3);
		sText.Format("%s【%0.1f】", m_strVarDes3, m_fValue3);
		pDC->TextOut(rect.right - 20, rect.bottom - 23, sText);
	}
}

void CDrawCurve::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_clrCurve1;
		ar << m_clrCurve2;
		ar << m_clrCurve3;
		ar << m_nLowwer;
		ar << m_nUpper;
		ar << m_strVar1;
		ar << m_strVar2;
		ar << m_strVar3;
	}
	else
	{
		ar >> m_clrCurve1;
		ar >> m_clrCurve2;
		ar >> m_clrCurve3;
		ar >> m_nLowwer;
		ar >> m_nUpper;
		ar >> m_strVar1;
		ar >> m_strVar2;
		ar >> m_strVar3;

		//得到 上限，下限
		int nLowwer1 = 0, nUpper1 = 0, nLowwer2 = 0, nUpper2 = 0, nLowwer3 = 0, nUpper3 = 0;
		// 		pVariantsManager->GetAnalogValue(m_strVar1,nLowwer1,nUpper1);
		// 		pVariantsManager->GetAnalogValue(m_strVar2,nLowwer2,nUpper2);
		// 		pVariantsManager->GetAnalogValue(m_strVar3,nLowwer3,nUpper3);

		m_nLowwer = nLowwer1;
		if (nLowwer2 < nLowwer1 && nLowwer2 < nLowwer3)
			m_nLowwer = nLowwer2;
		if (nLowwer3 < nLowwer1 && nLowwer3 < nLowwer2)
			m_nLowwer = nLowwer3;

		m_nUpper = nUpper1;
		if (nUpper2 > nUpper1 && nUpper2 > nUpper3)
			m_nUpper = nUpper2;
		if (nUpper3 > nUpper1 && nUpper3 > nUpper2)
			m_nUpper = nUpper3;

		if (m_nLowwer == m_nUpper)
		{
			m_nLowwer = 0;
			m_nUpper = 2;
		}
		else
		{
			m_nLowwer = getMin(m_nLowwer);
			m_nUpper = getMax(m_nUpper);
		}
		//得到 描述
// 		pVariantsManager->GetAnalogValue(m_strVar1,m_strVarDes1);
// 		pVariantsManager->GetAnalogValue(m_strVar2,m_strVarDes2);
// 		pVariantsManager->GetAnalogValue(m_strVar3,m_strVarDes3);
	}
}

int CDrawCurve::getMin(int iLowwer)
{
	int nRet = 0;

	nRet = iLowwer - 20;
	if (nRet < 0)
		nRet = 0;

	int nMod = nRet % 10;
	if (nMod != 0)
		nRet -= nMod;

	return nRet;
}
int CDrawCurve::getMax(int iUpper)
{
	int nRet = 0;

	nRet = iUpper + 20;

	int nMod = nRet % 10;
	if (nMod != 0)
		nRet += (10 - nMod);

	return nRet;
}
BOOL CDrawCurve::OnAttrib(CPropertySheet& sheet)
{
	CurvePage page;
	page.m_nLowwer = m_nLowwer;
	page.m_nUpper = m_nUpper;
	page.m_strVar1 = m_strVar1;
	page.m_strVar2 = m_strVar2;
	page.m_strVar3 = m_strVar3;
	page.m_clrCurve1 = m_clrCurve1;
	page.m_clrCurve2 = m_clrCurve2;
	page.m_clrCurve3 = m_clrCurve3;
	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_nLowwer = page.m_nLowwer;
		m_nUpper = page.m_nUpper;
		m_strVar1 = page.m_strVar1;
		m_strVar2 = page.m_strVar2;
		m_strVar3 = page.m_strVar3;
		m_clrCurve1 = page.m_clrCurve1;
		m_clrCurve2 = page.m_clrCurve2;
		m_clrCurve3 = page.m_clrCurve3;
		return TRUE;
	}
	return FALSE;
}


bool CDrawCurve::Fresh(CRect &RECT)
{
	SYSTEMTIME st;
	GetLocalTime(&st);
	if (m_nSecond != st.wSecond)
	{
		m_nSecond = st.wSecond;
	}
	else
		return true;

	if (g_nRunEditVarTick == 0)
		g_nRunEditVarTick = GetTickCount();

	if (GetTickCount() - g_nRunEditVarTick > 1000 * 2)
	{
		g_bRunEditVar = false;
	}
	else if (g_bRunEditVar)
	{
		//得到 上限，下限
		int nLowwer1 = 0, nUpper1 = 0, nLowwer2 = 0, nUpper2 = 0, nLowwer3 = 0, nUpper3 = 0;
		// 		pVariantsManager->GetAnalogValue(m_strVar1,nLowwer1,nUpper1);
		// 		pVariantsManager->GetAnalogValue(m_strVar2,nLowwer2,nUpper2);
		// 		pVariantsManager->GetAnalogValue(m_strVar3,nLowwer3,nUpper3);

		m_nLowwer = nLowwer1;
		if (nLowwer2 < nLowwer1 && nLowwer2 < nLowwer3)
			m_nLowwer = nLowwer2;
		if (nLowwer3 < nLowwer1 && nLowwer3 < nLowwer2)
			m_nLowwer = nLowwer3;

		m_nUpper = nUpper1;
		if (nUpper2 > nUpper1 && nUpper2 > nUpper3)
			m_nUpper = nUpper2;
		if (nUpper3 > nUpper1 && nUpper3 > nUpper2)
			m_nUpper = nUpper3;

		if (m_nLowwer == m_nUpper)
		{
			m_nLowwer = 0;
			m_nUpper = 2;
		}
		else
		{
			m_nLowwer = getMin(m_nLowwer);
			m_nUpper = getMax(m_nUpper);
		}
		//得到 描述
// 		pVariantsManager->GetAnalogValue(m_strVar1,m_strVarDes1);
// 		pVariantsManager->GetAnalogValue(m_strVar2,m_strVarDes2);
// 		pVariantsManager->GetAnalogValue(m_strVar3,m_strVarDes3);
	}

	if (!m_strVar1.IsEmpty())
	{
		for (int i = 0; i < 59; i++)
		{
			m_nValue1[i] = m_nValue1[i + 1];
		}
		//m_fValue1 = pVariantsManager->GetAnalogValue(m_strVar1);
		m_nValue1[59] = (int)m_fValue1;
	}
	if (!m_strVar2.IsEmpty())
	{
		for (int i = 0; i < 59; i++)
		{
			m_nValue2[i] = m_nValue2[i + 1];
		}
		//m_fValue2 = pVariantsManager->GetAnalogValue(m_strVar2);
		m_nValue2[59] = (int)m_fValue2;
	}
	if (!m_strVar3.IsEmpty())
	{
		for (int i = 0; i < 59; i++)
		{
			m_nValue3[i] = m_nValue3[i + 1];
		}
		//m_fValue3 = pVariantsManager->GetAnalogValue(m_strVar3);
		m_nValue3[59] = (int)m_fValue3;
	}

	RECT = m_rect;
	return true;
}

void CDrawCurve::DrawCurve(CDC* pDC, CRect rect, int* data, COLORREF color)
{
	rect.NormalizeRect();
	CPen PenBackGrid(PS_SOLID, m_nLineWidth, color);
	CPen* pOldPen = pDC->SelectObject(&PenBackGrid);
	bool f = false;
	for (int i = 0; i < 60; i++)
	{
		CPoint point;
		point.x = rect.left + i*(1.0*rect.Width() / 59);
		float rate = (1.0*(data[i] - m_nLowwer)) / (m_nUpper - m_nLowwer);
		point.y = rect.bottom - int(rect.Height()*rate);
		if (point.y > rect.bottom)
			point.y = rect.bottom;
		if (point.y < rect.top)
			point.y = rect.top;
		if (point.x < rect.left)
			point.x = rect.left;
		if (point.x > rect.right)
			point.x = rect.right;

		if (!f && point.y != rect.bottom)
		{
			f = true;
			pDC->MoveTo(point);
		}
		else if (f)
		{
			pDC->LineTo(point);
		}
	}
	pDC->SelectObject(pOldPen);

	DeleteObject(PenBackGrid);
}



//---------------------------------------------- CDrawHisCurve -------
IMPLEMENT_SERIAL(CDrawHisCurve, CDrawObj, 0)

CDrawHisCurve::CDrawHisCurve() :CDrawObj()
{
	m_clrFill = RGB(255, 255, 255);
	m_clrCurve1 = RGB(255, 0, 0);
	m_clrCurve2 = RGB(0, 255, 0);
	m_clrCurve3 = RGB(0, 0, 255);
	m_clrLine = RGB(0, 0, 0);
	m_nLowwer = 0;
	m_nUpper = 200;
	m_strVar1 = "";
	m_strVar2 = "";
	m_strVar3 = "";
	m_nFillMode = 1;

	for (int i = 0; i < 60; i++)
	{
		m_nValue1[i] = 0;
		m_nValue2[i] = 0;
		m_nValue3[i] = 0;
	}
}


CDrawObj* CDrawHisCurve::Clone(void)
{
	CDrawHisCurve *pObj = new CDrawHisCurve;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_clrCurve1 = m_clrCurve1;
	pObj->m_clrCurve2 = m_clrCurve2;
	pObj->m_clrCurve3 = m_clrCurve3;
	pObj->m_nLowwer = m_nLowwer;
	pObj->m_nUpper = m_nUpper;
	pObj->m_strVar1 = m_strVar1;
	pObj->m_strVar2 = m_strVar2;
	pObj->m_strVar3 = m_strVar3;

	return pObj;
}


void CDrawHisCurve::Draw(CDC* pDC)
{
	CDrawObj::Draw(pDC);
	CRect rect = m_rect;
	rect.NormalizeRect();

	LOGBRUSH brushlog = GetBrush();
	CBrush m_brush;
	m_brush.CreateBrushIndirect(&brushlog);
	CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);
	if (m_nFillMode < 8)
	{
		pDC->Rectangle(rect);
	}

	// 边框
	pDC->DrawEdge(rect, BDR_RAISEDINNER, BF_RECT);
	CRect inner;
	inner.left = rect.left + 40;
	inner.right = rect.right - 10;
	inner.top = rect.top + 10;
	inner.bottom = rect.bottom - 30;

	// 显示60个点，1s一个点
	if (bRuning)
	{
		if (!m_strVar1.IsEmpty())
		{
			DrawCurve(pDC, inner, m_nValue1, m_clrCurve1);
		}
		if (!m_strVar2.IsEmpty())
		{
			DrawCurve(pDC, inner, m_nValue2, m_clrCurve2);
		}
		if (!m_strVar3.IsEmpty())
		{
			DrawCurve(pDC, inner, m_nValue3, m_clrCurve3);
		}
	}
	else
	{
		for (int i = 0; i < 60; i++)
		{
			m_nValue1[i] = 100 + (i % 10) * 4 - (i % 15);
			m_nValue2[i] = 80 + (i % 15) * 3 - i;
			m_nValue3[i] = 60 + (i % 20) * 3 + i;
		}
		DrawCurve(pDC, inner, m_nValue1, m_clrCurve1);
		DrawCurve(pDC, inner, m_nValue2, m_clrCurve2);
		DrawCurve(pDC, inner, m_nValue3, m_clrCurve3);
	}


	// 网格
	CPen penGrid(PS_DOT, 1, RGB(192, 192, 192));
	CPen* pOldPen = pDC->SelectObject(&penGrid);

	int i = 0;
	for (i = 1; i < 5; i++)
	{
		pDC->MoveTo(inner.left, inner.top + inner.Height()*i / 5);
		pDC->LineTo(inner.right, inner.top + inner.Height()*i / 5);
	}

	for (i = 1; i < 6; i++)
	{
		pDC->MoveTo(inner.left + inner.Width()*i / 6, inner.top);
		pDC->LineTo(inner.left + inner.Width()*i / 6, inner.bottom);
	}

	CPen penFrame(PS_SOLID, 1, RGB(0, 0, 0));
	pDC->SelectObject(&penFrame);
	pDC->MoveTo(inner.left, inner.top);
	pDC->LineTo(inner.right, inner.top);
	pDC->LineTo(inner.right, inner.bottom);

	CRect leftKedu = inner;
	leftKedu.right = leftKedu.left + 5;
	DrawVKedu(pDC, leftKedu, 50, m_clrLine);

	CRect bottomKedu = inner;
	bottomKedu.top = leftKedu.bottom - 5;
	DrawHKedu(pDC, bottomKedu, 60, m_clrLine);

	pDC->SelectObject(pOldPen);

	DeleteObject(m_brush);
	DeleteObject(penGrid);
	DeleteObject(penFrame);
}


void CDrawHisCurve::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_clrCurve1;
		ar << m_clrCurve2;
		ar << m_clrCurve3;
		ar << m_nLowwer;
		ar << m_nUpper;
		ar << m_strVar1;
		ar << m_strVar2;
		ar << m_strVar3;
	}
	else
	{
		ar >> m_clrCurve1;
		ar >> m_clrCurve2;
		ar >> m_clrCurve3;
		ar >> m_nLowwer;
		ar >> m_nUpper;
		ar >> m_strVar1;
		ar >> m_strVar2;
		ar >> m_strVar3;
	}
}


BOOL CDrawHisCurve::OnAttrib(CPropertySheet& sheet)
{
	CurvePage page;
	page.m_nLowwer = m_nLowwer;
	page.m_nUpper = m_nUpper;
	page.m_strVar1 = m_strVar1;
	page.m_strVar2 = m_strVar2;
	page.m_strVar3 = m_strVar3;
	page.m_clrCurve1 = m_clrCurve1;
	page.m_clrCurve2 = m_clrCurve2;
	page.m_clrCurve3 = m_clrCurve3;
	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_nLowwer = page.m_nLowwer;
		m_nUpper = page.m_nUpper;
		m_strVar1 = page.m_strVar1;
		m_strVar2 = page.m_strVar2;
		m_strVar3 = page.m_strVar3;
		m_clrCurve1 = page.m_clrCurve1;
		m_clrCurve2 = page.m_clrCurve2;
		m_clrCurve3 = page.m_clrCurve3;
		return TRUE;
	}
	return FALSE;
}


bool CDrawHisCurve::Fresh(CRect &RECT)
{
	SYSTEMTIME st;
	GetLocalTime(&st);
	if (m_nSecond != st.wSecond)
	{
		m_nSecond = st.wSecond;
	}
	else
		return true;

	if (!m_strVar1.IsEmpty())
	{
		for (int i = 0; i < 59; i++)
		{
			m_nValue1[i] = m_nValue1[i + 1];
		}
		//m_nValue1[59] = (int) pVariantsManager->GetAnalogValue(m_strVar1);
	}
	if (!m_strVar2.IsEmpty())
	{
		for (int i = 0; i < 59; i++)
		{
			m_nValue2[i] = m_nValue2[i + 1];
		}
		//m_nValue2[59] = (int) pVariantsManager->GetAnalogValue(m_strVar2);
	}
	if (!m_strVar3.IsEmpty())
	{
		for (int i = 0; i < 59; i++)
		{
			m_nValue3[i] = m_nValue3[i + 1];
		}
		//m_nValue3[59] = (int) pVariantsManager->GetAnalogValue(m_strVar3);
	}
	RECT = m_rect;
	return true;
}


void CDrawHisCurve::DrawCurve(CDC* pDC, CRect rect, int* data, COLORREF color)
{
	rect.NormalizeRect();
	CPen PenBackGrid(PS_SOLID, 1, color);
	CPen* pOldPen = pDC->SelectObject(&PenBackGrid);
	for (int i = 0; i < 60; i++)
	{
		CPoint point;
		point.x = rect.left + i*(1.0*rect.Width() / 59);
		float rate = (1.0*(data[i] - m_nLowwer)) / (m_nUpper - m_nLowwer);
		point.y = rect.bottom - int(rect.Height()*rate);
		if (point.y > rect.bottom)
			point.y = rect.bottom;
		if (point.y < rect.top)
			point.y = rect.top;
		if (point.x < rect.left)
			point.x = rect.left;
		if (point.x > rect.right)
			point.x = rect.right;

		if (i == 0)
		{
			pDC->MoveTo(point);
		}
		else
		{
			pDC->LineTo(point);
		}
	}
	pDC->SelectObject(pOldPen);
}
//---------------------------------------------- CDrawOCX --------
IMPLEMENT_SERIAL(CDrawOCX, CDrawObj, 0)

CDrawOCX::CDrawOCX() :CDrawObj()
{
	m_clrFore = RGB(0x80, 0x00, 0x00);;
	m_clrBack = RGB(0xD1, 0xE1, 0xF8);//(120, 120, 120);
	m_strCaption = "OCX";
	m_strOcxPath = "";
	m_nOcxIndex = 0;
}

CDrawObj* CDrawOCX::Clone(void)
{
	CDrawOCX *pObj = new CDrawOCX;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strOcxPath = m_strOcxPath;
	pObj->m_nOcxIndex = m_nOcxIndex;
	return pObj;
}
bool CDrawOCX::Fresh(CRect &RECT)
{
	CDrawObj::Fresh(RECT);

	RECT = m_rect;

	if (!m_bShow)
	{
		m_bShowtemp = FALSE;
		return true;
	}
	else if (!m_bShowtemp)
	{
		m_bShowtemp = TRUE;
		return true;
	}
	else
		return false;
}
void CDrawOCX::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning) return;

	if (!g_bRun)
	{
		CRect rect = m_rctCurrent;
		COLORREF color = m_clrCurrentBack;
		if (!bRuning)
		{
			rect = m_rect;
			color = m_clrBack;
		}
		pDC->FillSolidRect(rect, color);

		CPen pen(GetPenStyle(m_strLineType), 5, RGB(255, 128, 0));
		CPen* pOldPen = pDC->SelectObject(&pen);

		// CBrush
		LOGBRUSH brushlog = GetBrush();

		CBrush m_brush;
		m_brush.CreateBrushIndirect(&brushlog);
		CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);
		pDC->Rectangle(rect);

		CBrush *pBrushNull = CBrush::FromHandle((HBRUSH)GetStockObject(NULL_BRUSH));
		pOldBrush = pDC->SelectObject(pBrushNull);//选入设备描述表

		CPen pen2(GetPenStyle(m_strLineType), 2, RGB(255, 255, 255));
		pOldPen = pDC->SelectObject(&pen2);
		//rect.left+=1;
		//rect.right-=1;
		//rect.top+=1;
		//rect.bottom-=1;
		pDC->Rectangle(rect);


		pDC->SelectObject(pOldPen);
		pDC->SelectObject(pOldBrush);
		DrawText(pDC);

		DeleteObject(m_brush);
		DeleteObject(pBrushNull);
		DeleteObject(pen);
		DeleteObject(pen2);
	}
	else
	{
	}
}
void CDrawOCX::DrawText(CDC* pDC)
{
	CFont *pFont = NULL;
	COLORREF clrFore = m_clrFore;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrFore = m_clrCurrentFore;
		rect = m_rctCurrent;
	}
	pDC->SetTextColor(clrFore);
	pDC->SetTextAlign(TA_LEFT | TA_TOP);

	CFont font;
	font.CreateFontIndirect(&m_logfont);
	CFont* pOldFont = pDC->SelectObject(&font);
	int height = abs(m_logfont.lfHeight);
	rect.NormalizeRect();
	int nX0 = (rect.left + rect.right) / 2;
	int nY0 = (rect.top + rect.bottom) / 2;
	//if(rect.Width()>=rect.Height())
	{
		pFont = new CFont;
		pFont->CreateFont(rect.Height() * 2 / 4, // nHeight 
			0, // nWidth 
			0, // nEscapement 
			0, // nOrientation 
			FW_BOLD, // nWeight 
			false, // bItalic 
			FALSE, // bUnderline 
			0, // cStrikeOut 
			ANSI_CHARSET, // nCharSet 
			OUT_DEFAULT_PRECIS, // nOutPrecision 
			CLIP_DEFAULT_PRECIS, // nClipPrecision 
			DEFAULT_QUALITY, // nQuality 
			DEFAULT_PITCH | FF_SWISS, // nPitchAndFamily 
			_T("黑体")); // lpszFac
		pDC->SelectObject(pFont);
		pDC->DrawText(m_strCaption, -1, &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	}

	DeleteObject(font);

	pDC->SelectObject(pOldFont);
	if (pFont)
		delete pFont;
}
BOOL CDrawOCX::OnAttrib(CPropertySheet& sheet)
{
	CDlg_OCX page;

	page.m_sEdit_OCXPath = m_strOcxPath;
	page.m_nComb_OCXIndex = m_nOcxIndex;

	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_strOcxPath = page.m_sEdit_OCXPath;
		m_nOcxIndex = page.m_nComb_OCXIndex;
		return TRUE;
	}
	return FALSE;
}
void CDrawOCX::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_strOcxPath;
		ar << m_nOcxIndex;
	}
	else
	{
		ar >> m_strOcxPath;
		ar >> m_nOcxIndex;
	}
}
//---------------------------------------------- CDrawFlash --------
IMPLEMENT_SERIAL(CDrawFlash, CDrawObj, 0)

CDrawFlash::CDrawFlash() :CDrawObj()
{
	m_clrFore = RGB(0x80, 0x00, 0x00);;
	m_clrBack = RGB(0xD1, 0xE1, 0xF8);//(120, 120, 120);
	m_strCaption = "swf";
	m_strFlashPath = "";

	m_pCtrlFlash = NULL;
	m_bFlashCreate = false;
}

CDrawFlash::~CDrawFlash()
{
	if (m_pCtrlFlash)
	{
		delete m_pCtrlFlash;
		m_pCtrlFlash = NULL;
		m_bFlashCreate = false;
	}
}

CDrawObj* CDrawFlash::Clone(void)
{
	CDrawFlash *pObj = new CDrawFlash;
	*((CDrawObj*)pObj) = *(CDrawObj*)this;
	pObj->m_strFlashPath = m_strFlashPath;
	return pObj;
}

void CDrawFlash::Serialize(CArchive& ar)
{
	CDrawObj::Serialize(ar);

	if (ar.IsStoring())
	{
		ar << m_strFlashPath;
	}
	else
	{
		ar >> m_strFlashPath;
	}
}

bool CDrawFlash::Fresh(CRect &RECT)
{
	CDrawObj::Fresh(RECT);

	RECT = m_rect;
#if 1
	if (m_pCtrlFlash)
	{
		CRect rect = m_rect;
		rect.NormalizeRect();
		int nX1 = rect.left;
		int nY1 = rect.top;

		CPoint pt(nX1, nY1);
		CMainFrame* pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd();
		HWND hwnd = pFrame->m_pActiveView->m_hWnd;
		//m_image->InitAnimation(hwnd, pt);

		if (!m_bFlashCreate && m_strFlashPath != "")
		{
			m_bFlashCreate = true;
			m_pCtrlFlash->Create("", "", WS_CHILD | WS_VISIBLE, rect, CWnd::FromHandle(hwnd), 10000);
			char curDir[256] = { 0 };
			strcpy(curDir, g_strDirectory);
			strcat(curDir, "\\");
			strcat(curDir, _BITMAPDIR);
			CString strFileName = m_strFlashPath;//CString(curDir) + 
			m_pCtrlFlash->SetMovie(strFileName);
		}

		int a = rand() % 100;
		CString str;
		str.Format("当前值：%d", a);
		if (m_pCtrlFlash)
			m_pCtrlFlash->SetVariable("a", str);
	}
#endif

	if (!m_bShow)
	{
		m_bShowtemp = FALSE;
		return true;
	}
	else if (!m_bShowtemp)
	{
		m_bShowtemp = TRUE;
		return true;
	}
	else
		return false;
}

void CDrawFlash::Draw(CDC* pDC)
{
	if (!m_bShow && bRuning)
	{
		if (m_pCtrlFlash)
		{
			delete m_pCtrlFlash;
			m_pCtrlFlash = NULL;
			m_bFlashCreate = false;
		}
		return;
	}

	if (!g_bRun)
	{
		CRect rect = m_rctCurrent;
		COLORREF color = m_clrCurrentBack;
		if (!bRuning)
		{
			rect = m_rect;
			color = m_clrBack;
		}
		pDC->FillSolidRect(rect, color);

		CPen pen(GetPenStyle(m_strLineType), 5, RGB(255, 128, 0));
		CPen* pOldPen = pDC->SelectObject(&pen);

		// CBrush
		LOGBRUSH brushlog = GetBrush();

		CBrush m_brush;
		m_brush.CreateBrushIndirect(&brushlog);
		CBrush* pOldBrush = (CBrush*)pDC->SelectObject(&m_brush);
		pDC->Rectangle(rect);

		CBrush *pBrushNull = CBrush::FromHandle((HBRUSH)GetStockObject(NULL_BRUSH));
		pOldBrush = pDC->SelectObject(pBrushNull);//选入设备描述表

		CPen pen2(GetPenStyle(m_strLineType), 2, RGB(255, 255, 255));
		pOldPen = pDC->SelectObject(&pen2);
		//rect.left+=1;
		//rect.right-=1;
		//rect.top+=1;
		//rect.bottom-=1;
		pDC->Rectangle(rect);
		pDC->SelectObject(pOldPen);
		pDC->SelectObject(pOldBrush);
		DrawText(pDC);

		DeleteObject(m_brush);
		DeleteObject(pBrushNull);
		DeleteObject(pen);
		DeleteObject(pen2);
	}
	if (g_bRun)
	{
		if (m_pCtrlFlash == NULL)
		{
			//char curDir[256] = {0};
			////strcpy(curDir, g_strDirectory);
			//strcat(curDir, ".\\\\");
			//strcat(curDir, _BITMAPDIR);

			//if( m_strStaticFile=="" )//gif 路徑為Bitmap，默認名為StounU.gif
			//	m_strStaticFile = "StounU.gif";

			//CString strGifFileName = CString(curDir) + m_strStaticFile;
			//GDI+
			m_pCtrlFlash = new CShockwaveFlash();
		}

		if (m_pCtrlFlash)
		{
			CRect rect = m_rect;
			rect.NormalizeRect();
			int nX1 = rect.left;
			int nY1 = rect.top;

			CPoint pt(nX1, nY1);
			CMainFrame* pFrame = (CMainFrame*)AfxGetApp()->GetMainWnd();
			HWND hwnd = pFrame->m_pActiveView->m_hWnd;
			//m_image->InitAnimation(hwnd, pt);

			if (!m_bFlashCreate && m_strFlashPath != "")
			{
				m_bFlashCreate = true;
				m_pCtrlFlash->Create("", "", WS_CHILD | WS_VISIBLE, rect, CWnd::FromHandle(hwnd), 10000);
				char curDir[256] = { 0 };
				strcpy(curDir, g_strDirectory);
				strcat(curDir, "\\");
				strcat(curDir, _BITMAPDIR);
				CString strFileName = m_strFlashPath;//CString(curDir) + 
				m_pCtrlFlash->SetMovie(strFileName);
			}

			int a = rand() % 100;
			CString str;
			str.Format("当前值：%d", a);
			if (m_pCtrlFlash)
				m_pCtrlFlash->SetVariable("a", str);
		}
	}
}

BOOL CDrawFlash::OnAttrib(CPropertySheet& sheet)
{
	CDlg_Flash page;

	page.m_sEdit_FlashPath = m_strFlashPath;

	sheet.AddPage(&page);
	sheet.Construct(g_strParamSet);
	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;

	if (sheet.DoModal() == IDOK)
	{
		m_strFlashPath = page.m_sEdit_FlashPath;
		return TRUE;
	}
	return FALSE;
}
void CDrawFlash::DrawText(CDC* pDC)
{
	CFont *pFont = NULL;
	COLORREF clrFore = m_clrFore;
	CRect rect = m_rect;
	if (bRuning)
	{
		clrFore = m_clrCurrentFore;
		rect = m_rctCurrent;
	}
	pDC->SetTextColor(clrFore);
	pDC->SetTextAlign(TA_LEFT | TA_TOP);

	CFont font;
	font.CreateFontIndirect(&m_logfont);
	CFont* pOldFont = pDC->SelectObject(&font);
	int height = abs(m_logfont.lfHeight);
	rect.NormalizeRect();
	int nX0 = (rect.left + rect.right) / 2;
	int nY0 = (rect.top + rect.bottom) / 2;
	//if(rect.Width()>=rect.Height())
	{
		pFont = new CFont;
		pFont->CreateFont(rect.Height() * 2 / 4, // nHeight 
			0, // nWidth 
			0, // nEscapement 
			0, // nOrientation 
			FW_BOLD, // nWeight 
			false, // bItalic 
			FALSE, // bUnderline 
			0, // cStrikeOut 
			ANSI_CHARSET, // nCharSet 
			OUT_DEFAULT_PRECIS, // nOutPrecision 
			CLIP_DEFAULT_PRECIS, // nClipPrecision 
			DEFAULT_QUALITY, // nQuality 
			DEFAULT_PITCH | FF_SWISS, // nPitchAndFamily 
			_T("黑体")); // lpszFac
		pDC->SelectObject(pFont);
		pDC->DrawText(m_strCaption, -1, &rect, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
	}

	pDC->SelectObject(pOldFont);

	DeleteObject(font);
	if (pFont)
		delete pFont;
}