lyfz_repos/经典版源码/kernelcode/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 "CommondServer.h"
#include "gradient.h"
#include "BitmapPage.h"
#include "datapage.h"
#include "logicpage.h"
#include "SingleBarPage.h"
#include "ArcPage.h"
#include "WatchPage.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 == "")
		{
			
		}
		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;
		}
	}

	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;
}

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

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

//---------------------------------------------- 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;
}