#include "stdafx.h"
#include "SigmaView.h"
#include "DrawOperator/LibraryManager.h"
#include "ActionSortItem.h"
#include "ActionDeleteLayerItem.h"

// CMarkTreeList
#define LOAD_MODE_MARK			0x0001
#define LOAD_MODE_EMBELLISH		0x0002
#define LOAD_MODE_CURRENT		0x0004
#define LOAD_MODE_DEFAULT		LOAD_MODE_MARK | LOAD_MODE_EMBELLISH | LOAD_MODE_CURRENT

// 树项
#define LIB_ITEM_DIRECTORY			0x00000010	//文件夹目录

#define LIB_ITEM_MARK_ROOT			0x00000020	//符号根目录
#define LIB_ITEM_MARK_CURRENT		0x00000040	//当前文件的符号树项
#define LIB_ITEM_MARK_FILE			0x00000080	//符号树文件项
#define LIB_ITEM_MARK_DIR			0x00000100	//符号树子目录项

#define LIB_ITEM_EMBELLISH_ROOT		0x00000200	//修饰根目录
#define LIB_ITEM_EMBELLISH_FILE		0x00000400	//修饰树文件项
#define LIB_ITEM_EMBELLISH_DIR		0x00000800	//修饰树子目录项

CCurveEx* pCurve;
POSITION pos = NULL, posRect;
CXy* pXyBak;
CXy* pxyMark;
CXy* pxySymbolWin;
CXy* pxySymbol = new CXy();
CXy* pxyCurrentXyBak = new CXy();

static CString GetMarkLibraryPath()
{
	static HMODULE hm = NULL;

	if (hm == NULL) {
		GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
			GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
			(LPCSTR)&GetMarkLibraryPath,
			&hm);
	}

	char szModulePath[MAX_PATH];
	char szModuleDir[MAX_PATH];

	GetModuleFileNameA(hm, szModulePath, MAX_PATH);

	const char* pPos = strrchr(szModulePath, '\\');
	strncpy_s(szModuleDir, szModulePath, pPos - szModulePath);
	CString path = szModuleDir;
	path += "\\..\\Mark\\";
	CSplitPath sp;
	CString str = sp.GetAbsolutePath(path);

	if (!CFindFileEx::IsDirectoryExists(str))
		return _T("");

	return str;
}

static void CheckLibraryInited(CLibraryManager *pLib)
{
	if (pLib->m_libXy.IsEmpty())
	{
		pLib->InitLib(GetMarkLibraryPath(), true);
	}
}

CBitmap* Mark_GetBitmap(CXy* pXy, CDC* pdc, int cx, int cy)
{
	CDC dc;	dc.CreateCompatibleDC(pdc);
	CXyDC pDC; pDC.Create(&dc);

	CRect rt(0, 0, cx, cy);

	rt.DeflateRect(1, 1);

	int planes = dc.GetDeviceCaps(PLANES);
	int bpp = dc.GetDeviceCaps(BITSPIXEL);

	CBitmap* pBitmap, *pOldBitmap;
	pBitmap = new CBitmap();
	pBitmap->CreateBitmap(cx, cy, planes, bpp, NULL);
	pOldBitmap = dc.SelectObject(pBitmap);

	dc.FillSolidRect(0, 0, cx, cy, RGB(255, 255, 255));

	CRect8 rect(1e100, -1e100, -1e100, 1e100);
	if (pXy != NULL)
	{
		if (pXy->GetCount() > 0)
		{
			pXy->GetRange(rect);
			pXy->m_range = rect;
			pDC.Extend(rect, rt, EXTEND_MODE_CENTER);
			pXy->Draw(pDC);
		}
	}

	dc.SelectObject(pOldBitmap);
	return pBitmap;
}

static BOOL DrawMark(CXy* pXy, HDC hdcMem, int cx, int cy)
{
	CDC* pDC = CDC::FromHandle(hdcMem);

	CBitmap* pBitmap = Mark_GetBitmap(pXy, pDC, cx, cy);

	CDC dc; dc.CreateCompatibleDC(pDC);

	CBitmap* pOldBitmap = (CBitmap*)dc.SelectObject(pBitmap);

	pDC->BitBlt(0, 0, cx, cy, &dc, 0, 0, SRCCOPY);

	dc.SelectObject(pOldBitmap);

	delete pBitmap;

	pDC->DeleteDC();

	return TRUE;
}




extern "C" __declspec(dllexport)
BOOL MarkLoopName(CSigmaView * pView, char* markId, int idLen, char* markName, int nameLen)
{
	CMapStringToPtrNoCase* pmap = pView->m_pDoc->m_pXy->GetMark();

	if (pmap == NULL|| pmap->GetCount()==0) return FALSE;

	CString idList, nameList;

	POSITION pos = pmap->GetStartPosition();

	while (pos)
	{
		void* pVoid;
		CString id;

		pmap->GetNextAssoc(pos, id, pVoid);

		CXy* pMark = (CXy*)pVoid;

		idList.AppendFormat("%s\r\n", id);
		nameList.AppendFormat("%s\r\n", pMark->m_strName);
	}

	strncpy(markId, idList.GetBuffer(), min(idList.GetLength() + 1, idLen));
	strncpy(markName, nameList.GetBuffer(), min(nameList.GetLength() + 1, idLen));

	return TRUE;
}


extern "C" __declspec(dllexport)
BOOL MarkLibraryLoopName(char* path, int pathLen)
{
	CLibraryManager* pLib = AfxGetMarkLibMgr();

	if (pLib == NULL) return FALSE;

	CheckLibraryInited(pLib);

	CString pathList;

	POSITION pos = pLib->m_libXy.GetHeadPosition();

	while (pos)
	{
		POSITION current = pos;

		CLibraryItem* pItem = (CLibraryItem*)pLib->m_libXy.GetNext(pos);

		CString path = pLib->GetTreePathName(pItem->m_strFileName);

		pathList.AppendFormat("%s\r\n", path);
	}

	strncpy(path, pathList.GetBuffer(), min(pathList.GetLength() + 1, pathLen));

	return TRUE;
}


extern "C" __declspec(dllexport)
BOOL MarkLibraryLoopMark(char* libPath, char* markId, int idLen, char* markName, int nameLen)
{
	CLibraryManager* pLib = AfxGetMarkLibMgr();

	if (pLib == NULL) return FALSE;

	CheckLibraryInited(pLib);

	CString idList, nameList;

	POSITION libraryPos = pLib->m_libXy.GetHeadPosition();

	while (libraryPos)
	{
		CLibraryItem* pItem = (CLibraryItem*)pLib->m_libXy.GetNext(libraryPos);
		CString path = pLib->GetTreePathName(pItem->m_strFileName);

		if (path == libPath)
		{
			if (pItem->m_pxy == NULL)
				pItem->Read();
			if (pItem->m_pxy == NULL)
			{
				return FALSE;
			}

			CMapStringToPtrNoCase* pmap = pItem->m_pxy->GetMark();
			if (pmap == NULL || pmap->GetCount()==0) return FALSE;

			POSITION pos = pmap->GetStartPosition();

			while (pos)
			{
				void* pVoid;
				CString id;

				pmap->GetNextAssoc(pos, id, pVoid);
				CXy* pMark = (CXy*)pVoid;
				idList.AppendFormat("%s\r\n", id);
				nameList.AppendFormat("%s\r\n", pMark->m_strName);
			}
			break;
		}
	}

	strncpy(markId, idList.GetBuffer(), min(idList.GetLength() + 1, idLen));
	strncpy(markName, nameList.GetBuffer(), min(nameList.GetLength() + 1, idLen));


	return TRUE;
}


extern "C" __declspec(dllexport)
BOOL MarkDrawByName(CSigmaView* pView, char* id, HDC hdcMem, int cx, int cy)
{
	CXy* pXy = (CXy*)pView->m_pDoc->m_pXy->FindMark(id);

	if (pXy == NULL) return FALSE;

	return DrawMark(pXy, hdcMem, cx, cy);
}


extern "C" __declspec(dllexport)
BOOL MarkLibraryDrawByName(char* id, HDC hdcMem, int cx, int cy)
{
	CLibraryManager* pLib = AfxGetMarkLibMgr();

	if (pLib == NULL) return FALSE;

	CheckLibraryInited(pLib);

	CXy *pXy = pLib->FindMark(id);

	if (pXy == NULL) return FALSE;

	return DrawMark(pXy, hdcMem, cx, cy);
}

extern "C" __declspec(dllexport)
BOOL MarkCopyLibraryToDocument(CSigmaView* pView, char* id)
{
	CXy* pXy = pView->m_pDoc->m_pXy;

	if (pXy == NULL) return FALSE;

	//如果已存在符号, 则直接返回成功
	if (pXy->FindMark(id) != NULL) return TRUE;

	CLibraryManager* pLib = AfxGetMarkLibMgr();

	if (pLib == NULL) return FALSE;

	CheckLibraryInited(pLib);

	CXy* pNew = pLib->FindMark(id);

	if (pNew == NULL) return FALSE;

	CXy* pmark = new CXy;
	*pmark = *pNew;

	pXy->AddMark(pmark);

	return TRUE;
}

extern "C" __declspec(dllexport)
void DrawSymbolXy(CSigmaView* pView, CXy* m_pXy, HDC hdc)
{
	CDC *pDC = CDC::FromHandle(hdc);
	CXyDC dc;
	dc.Create(pDC);

	CRect rt;
	rt = pView->GetClientRect();
	dc.SetViewRect(rt);
	m_pXy->Draw(dc, false);
}

extern "C" __declspec(dllexport)
CXy* GetDocData(CSigmaView* pView) {
	return (CXy*)pView->m_pDoc->m_pXy;
}

extern "C" __declspec(dllexport)
void SetMarkDataSymbol(CSigmaView* pView, LPCTSTR symbolName)
{
	CXy* m_pXy = (CXy*)pView->m_pDoc->m_pXy->FindMark(symbolName);
	(CXy*)pView->m_pDoc->m_pXy = m_pXy;
	//return;
}


//extern "C" __declspec(dllexport)
//void SetMark2Data(CSigmaView* pView, LPCTSTR symbolName)
//{	
//	CXy* m_pXy = (CXy*)pxySymbol->FindMark(symbolName);
//	(CXy*)pView->m_pDoc->m_pXy = m_pXy;
//	//return;
//}

//extern "C" __declspec(dllexport)
//void SetMarkView(CSigmaView* pView, LPCTSTR symbolName)
//{	
//	CXy* m_pXy = (CXy*)pView->m_pDoc->m_pXy->FindMark(symbolName);
//	(CXy*)pView->m_pDoc->m_pXy = m_pXy;
//	//return;
//}

extern "C" __declspec(dllexport)
void SetMark2Data(CSigmaView* pView, LPCTSTR symbolName)
{	
	(CXy*)pView->m_pDoc->m_pXy = pxySymbol;
	//return;
}

//extern "C" __declspec(dllexport)
//void DocBak(CSigmaView* pView)
//{
//	*pxySymbol = *pView->m_pDoc->m_pXy;
//}

extern "C" __declspec(dllexport)
void DocBak(CSigmaView* pView, LPCTSTR symbolName)
{
	CXy* m_pxy = (CXy*)pView->m_pDoc->m_pXy->FindMark(symbolName);
	*pxySymbol = *m_pxy;
}

extern "C" __declspec(dllexport)
void CopyCurrentFileXy(CXy* CurrentXy)
{
	*pxyCurrentXyBak = *CurrentXy;
}

extern "C" __declspec(dllexport)
void CurrDocEditSymbol(CSigmaView* pView, CXy* pXy, LPCTSTR symbolName) {
	if (pView == NULL)
	{
		return;
	}

	CXy* pxybsk = new CXy();
	*pxybsk = *pXy;
	CXy* m_pXy11 = (CXy*)pxybsk->FindMark(symbolName);
	*m_pXy11 = *pXyBak;
	(CXy*)pView->m_pDoc->m_pXy = pxybsk;
}

extern "C" __declspec(dllexport)
void SymbolDocEdit(CSigmaView* pView, CXy* pXy, LPCTSTR symbolName) {
	if (pView == NULL)
	{
		return;
	}

	CXy* pxybsk = new CXy();
	pxySymbolWin = new CXy();
	*pxybsk = *pXy;
	CXy* m_pXy11 = (CXy*)pxybsk->FindMark(symbolName);
	*m_pXy11 = *pXyBak;
	*pxySymbolWin = *pView->m_pDoc->m_pXy;
	(CXy*)pView->m_pDoc->m_pXy = pxybsk;
	pxySymbolWin = m_pXy11;
}

extern "C" __declspec(dllexport)
void SetDocData(CSigmaView* pView, CXy* pXy) {
	if (pView == NULL)
	{
		return;
	}

	(CXy*)pView->m_pDoc->m_pXy = pXy;
}

// 符号库新建符号
extern "C" __declspec(dllexport)
BOOL MarkLibraryNewSymbol(char* id, HDC hdcMem, int cx, int cy)
{
	CLibraryManager * pLib = AfxGetMarkLibMgr();
	if (pLib == NULL) return FALSE;
	CheckLibraryInited(pLib);
	CXy * pXy = new CXy;
	if (pXy == NULL) return FALSE;
	return DrawMark(pXy, hdcMem, cx, cy);
}

extern "C" __declspec(dllexport)
void CreateNewSymbol(CSigmaView* pView, LPCTSTR symbolName)
{
	CXy * pXy = new CXy;
	pXy->m_strName = symbolName;
	pView->m_pDoc->m_pXy->AddMark(pXy);
}

extern "C" __declspec(dllexport)
void DeleteSymbol(CSigmaView* pView, LPCTSTR symbolName)
{
	CXy* m_pXy = (CXy*)pView->m_pDoc->m_pXy->FindMark(symbolName);
	if (m_pXy != NULL)
	{
		pView->m_pDoc->m_pXy->RemoveMark(m_pXy->m_strName);//删除	
	}
}

void  RectangleRangePic(CSigmaView* pView)
{
	CString layerName = "RectRangeBackground";
	//CXy* pxyMark = new CXy();
	pxyMark = new CXy();
	CXy* pxy = pView->m_pDoc->m_pXy;
	if (pxy == NULL)
	{
		return;
	}

	*pxyMark = *pxy;
	CLayer* pLayer = pxyMark->FindLayer(layerName);
	if (pLayer == NULL)
	{
		pLayer = new CLayer;
		pLayer->SetName(layerName);
		pxyMark->AddLayer(pLayer);
	}

	CPointList bp;
	dfPoint point;
	point.x0 = 0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	point.x0 = -0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	point.x0 = -0.5;
	point.y0 = -0.5;
	bp.AddTail(point);
	point.x0 = 0.5;
	point.y0 = -0.5;
	bp.AddTail(point);
	point.x0 = 0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	
	pCurve = new CCurveEx;
	pCurve->SetPoints(bp, 2);
	pCurve->width = 0.001;
	pCurve->SetName("RectRange");
	posRect = pxyMark->AddElement(pCurve, DOUBLEFOX_CURVE);
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(posRect));

	//设置图层
	pOne->SetLayer(pLayer);
	if (pOne->HowToViewCurve == NULL)
	{
		pOne->HowToViewCurve = new CHowToViewCurve();
	}

	//pOne->color = RGB(0, 0, 255);
	pOne->HowToViewCurve->EnableDrawSourceCurve(TRUE);
	pOne->HowToViewCurve->IsSolid();
	CCurveProperties* pCurveView = new CCurveProperties();
	pCurveView->SetCurveType(PLINE_SOLID);
	pCurveView->color = RGB(255, 255, 255);
	pOne->HowToViewCurve->Add(pCurveView);	
	pView->m_pDoc->m_pXy = pxyMark;
	pxyMark->MoveToBack(posRect);
}

extern "C" __declspec(dllexport)
void  RectangleRange(CSigmaView* pView)
{
	if (pView == NULL)
	{
		return;
	}

	CXy* pxyMarkRect = new CXy();
	CXy* pxy = pView->m_pDoc->m_pXy;
	if (pxy == NULL)
	{
		return;
	}
	*pxyMarkRect = *pxy;
	/*CString layerName = "0";
	CLayer* pLayer = pxyMarkRect->FindLayer(layerName);
	if (pLayer == NULL)
	{
		pLayer = new CLayer;
		pLayer->SetName(layerName);
		pxyMarkRect->AddLayer(pLayer);
	}*/

	CPointList bp;
	dfPoint point;
	point.x0 = 1.1;
	point.y0 = 1;
	bp.AddTail(point);
	point.x0 = -1.1;
	point.y0 = 1;
	bp.AddTail(point);
	point.x0 = -1.1;
	point.y0 = -1;
	bp.AddTail(point);
	point.x0 = 1.1;
	point.y0 = -1;
	bp.AddTail(point);
	point.x0 = 1.1;
	point.y0 = 1;
	bp.AddTail(point);
	pCurve = new CCurveEx;
	pCurve->SetPoints(bp, 2);
	//pCurve->width = 0.00;	
	pCurve->SetName("RectRangeNoPicElem");
	pos = pxyMarkRect->AddElement(pCurve, DOUBLEFOX_CURVE);
	COne* pOne = (COne*)(pxyMarkRect->GetAt(pos));
	if (pOne->HowToViewCurve == NULL)
	{
		pOne->HowToViewCurve = new CHowToViewCurve();
	}

	pOne->color = RGB(192, 192, 192);
	//pOne->SetLayer(pLayer);
	//pOne->color = RGB(255, 0, 0);
	pView->m_pDoc->m_pXy = pxyMarkRect;
	//pxyMarkRect->MoveToFront(pos);
	RectangleRangePic(pView);	
}




void  RectangleRangePicSymbol(CSigmaView* pView)
{
	CString layerName = "RectRangeBackground";//Layer:\\RectRangeBackground
	CXy* pxy = pView->m_pDoc->m_pXy;
	if (pxy == NULL)
	{
		return;
	}

	CLayer* pLayer = pxy->FindLayer(layerName);
	if (pLayer == NULL)
	{
		pLayer = new CLayer;
		pLayer->SetName(layerName);
		pxy->AddLayer(pLayer);
	}

	CPointList bp;
	dfPoint point;
	point.x0 = 0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	point.x0 = -0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	point.x0 = -0.5;
	point.y0 = -0.5;
	bp.AddTail(point);
	point.x0 = 0.5;
	point.y0 = -0.5;
	bp.AddTail(point);
	point.x0 = 0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	//point.x0 = 0.512;
	//point.y0 = 0.512;
	//bp.AddTail(point);
	//point.x0 = -0.513;
	//point.y0 = 0.513;
	//bp.AddTail(point);
	//point.x0 = -0.514;
	//point.y0 = -0.514;
	//bp.AddTail(point);
	//point.x0 = 0.5;
	//point.y0 = -0.5;
	//bp.AddTail(point);
	//point.x0 = 0.512;
	//point.y0 = 0.512;
	//bp.AddTail(point);


	pCurve = new CCurveEx;
	pCurve->SetPoints(bp, 2);
	pCurve->width = 0.001;
	pCurve->SetName("RectRange");
	posRect = pxy->AddElement(pCurve, DOUBLEFOX_CURVE);
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(posRect));

	//设置图层
	pOne->SetLayer(pLayer);
	if (pOne->HowToViewCurve == NULL)
	{
		pOne->HowToViewCurve = new CHowToViewCurve();
	}

	//pOne->color = RGB(0, 0, 255);
	pOne->HowToViewCurve->EnableDrawSourceCurve(TRUE);
	pOne->HowToViewCurve->IsSolid();
	CCurveProperties* pCurveView = new CCurveProperties();
	pCurveView->SetCurveType(PLINE_SOLID);
	pCurveView->color = RGB(255, 255, 255);
	pOne->HowToViewCurve->Add(pCurveView);
	pxy->MoveToBack(posRect);

}

extern "C" __declspec(dllexport)
bool SaveFile(CSigmaView* pView)
{
	return pView->m_pDoc->SaveFile();
}

extern "C" __declspec(dllexport)
void  RectangleRangeSymbol(CSigmaView* pView)
{
	if (pView == NULL)
	{
		return;
	}
	CXy* pxy = pView->m_pDoc->m_pXy;
	if (pxy == NULL)
	{
		return;
	}

	CPointList bp;
	dfPoint point;
	point.x0 = 1.1;
	point.y0 = 1;
	bp.AddTail(point);
	point.x0 = -1.1;
	point.y0 = 1;
	bp.AddTail(point);
	point.x0 = -1.1;
	point.y0 = -1;
	bp.AddTail(point);
	point.x0 = 1.1;
	point.y0 = -1;
	bp.AddTail(point);
	point.x0 = 1.1;
	point.y0 = 1;
	bp.AddTail(point);
	pCurve = new CCurveEx;
	pCurve->SetPoints(bp, 2);
	//pCurve->width = 0.00;	
	pCurve->SetName("RectRangeNoPicElem");
	pos = pxy->AddElement(pCurve, DOUBLEFOX_CURVE);
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));
	if (pOne->HowToViewCurve == NULL)
	{
		pOne->HowToViewCurve = new CHowToViewCurve();
	}

	pOne->color = RGB(192, 192, 192);
	//pOne->color = RGB(255, 0, 0);
	RectangleRangePicSymbol(pView);
}


extern "C" __declspec(dllexport)
void  RectRangeWhite(CXy* pxy)
{
	CString layerName = "RectRangeBackground";//Layer:\\RectRangeBackground
	//CXy* pxy = pView->m_pDoc->m_pXy;
	if (pxy == NULL)
	{
		return;
	}

	CLayer* pLayer = pxy->FindLayer(layerName);
	if (pLayer == NULL)
	{
		pLayer = new CLayer;
		pLayer->SetName(layerName);
		pxy->AddLayer(pLayer);
	}

	CPointList bp;
	dfPoint point;
	point.x0 = 0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	point.x0 = -0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	point.x0 = -0.5;
	point.y0 = -0.5;
	bp.AddTail(point);
	point.x0 = 0.5;
	point.y0 = -0.5;
	bp.AddTail(point);
	point.x0 = 0.5;
	point.y0 = 0.5;
	bp.AddTail(point);

	pCurve = new CCurveEx;
	pCurve->SetPoints(bp, 2);
	pCurve->width = 0.001;
	pCurve->SetName("RectRange");
	posRect = pxy->AddElement(pCurve, DOUBLEFOX_CURVE);
	COne* pOne = (COne*)(pxy->GetAt(posRect));

	//设置图层
	pOne->SetLayer(pLayer);
	if (pOne->HowToViewCurve == NULL)
	{
		pOne->HowToViewCurve = new CHowToViewCurve();
	}

	//pOne->color = RGB(0, 0, 255);
	pOne->HowToViewCurve->EnableDrawSourceCurve(TRUE);
	pOne->HowToViewCurve->IsSolid();
	CCurveProperties* pCurveView = new CCurveProperties();
	pCurveView->SetCurveType(PLINE_SOLID);
	pCurveView->color = RGB(255, 255, 255);
	pOne->HowToViewCurve->Add(pCurveView);
	pxy->MoveToBack(posRect);

}



// 保存当前打卡文档符号时符号编辑区域背景删掉了，重新画一下
//extern "C" __declspec(dllexport)
void ResetRectBack(CSigmaView* pView, CXy* pxy)
{
	CString layerName = "RectRangeBackground";
	//CXy* pxy = pView->m_pDoc->m_pXy;


	/*if (pxy == NULL)
	{
		return;
	}*/

	CLayer* pLayer = pxy->FindLayer(layerName);
	if (pLayer == NULL)
	{
		pLayer = new CLayer;
		pLayer->SetName(layerName);
		pxy->AddLayer(pLayer);
	}

	CPointList bp;
	dfPoint point;
	point.x0 = 0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	point.x0 = -0.5;
	point.y0 = 0.5;
	bp.AddTail(point);
	point.x0 = -0.5;
	point.y0 = -0.5;
	bp.AddTail(point);
	point.x0 = 0.5;
	point.y0 = -0.5;
	bp.AddTail(point);
	point.x0 = 0.5;
	point.y0 = 0.5;
	bp.AddTail(point);

	pCurve = new CCurveEx;
	pCurve->SetPoints(bp, 2);
	pCurve->width = 0.001;
	pCurve->SetName("RectRange");
	posRect = pxy->AddElement(pCurve, DOUBLEFOX_CURVE);
	//COne* pOne = (COne*)(pView->m_pDoc->m_pXy->GetAt(posRect));
	COne* pOne = (COne*)(pxy->GetAt(posRect));

	//设置图层
	pOne->SetLayer(pLayer);
	if (pOne->HowToViewCurve == NULL)
	{
		pOne->HowToViewCurve = new CHowToViewCurve();
	}

	pOne->color = RGB(0, 0, 255);
	pOne->HowToViewCurve->EnableDrawSourceCurve(TRUE);
	pOne->HowToViewCurve->IsSolid();
	CCurveProperties* pCurveView = new CCurveProperties();
	pCurveView->SetCurveType(PLINE_SOLID);
	//pCurveView->color = RGB(255, 255, 255);
	pCurveView->color = RGB(255, 255, 0);
	pOne->HowToViewCurve->Add(pCurveView);
	pxy->MoveToBack(posRect);
	pView->m_pDoc->m_pXy = pxy;
}


extern "C" __declspec(dllexport)
void DeleteRectangleRange(CSigmaView* pView)
{
	pXyBak = new CXy;
	if (pxyMark == NULL)
	{
		return;
	}
	*pXyBak = *pxyMark;
	if (pView == NULL)
	{
		return;
	}

	COne* pOneRect = pXyBak->FindCurve("RectRangeNoPicElem");
	if (pOneRect != NULL)
	{
		pXyBak->RemoveAt(pOneRect);
	}

	CLayer* pLayer;
	COne* pOne;
	CPositionList elemList;
	CPtrList layerList;
	pLayer = pXyBak->FindLayer("RectRangeBackground");
	pOne = pXyBak->FindCurve("RectRange");
	if (pOne != NULL)
	{
		pXyBak->RemoveAt(pOne);
	}

	if (pLayer)
	{
		layerList.AddTail(pLayer);
		pXyBak->GetElement(pLayer->GetPathName(), elemList, FALSE);
	}	
}


extern "C" __declspec(dllexport)
void DeleteRectFrameSymbol(CSigmaView* pView, CXy* pxy)
{
	POSITION pos = pView->m_pDoc->m_pXy->FindElement("RectRange");
	POSITION posNoPic = pView->m_pDoc->m_pXy->FindElement("RectRangeNoPicElem");
	//POSITION posNoPic = pView->m_pDoc->m_pXy->FindElement("Pline.RectRangeNoPicElem");
	if (pos)
	{
		pView->m_pDoc->m_pXy->RemoveAt(pos);
	}

	if (posNoPic)
	{
		pView->m_pDoc->m_pXy->RemoveAt(posNoPic);
	}
}

extern "C" __declspec(dllexport)
void DeleteDocRectRange(CSigmaView* pView, CXy* pxy, LPCTSTR markName)
{
	COne* pOne;
	CXy* m_pXy = (CXy*)pxy->FindMark(markName);	
	pOne = m_pXy->FindCurve("RectRangeNoPicElem");
	if (pOne != NULL)
	{
		m_pXy->RemoveAt(pOne);
	}

	CLayer* pLayer;
	CPositionList elemList;
	CPtrList layerList;
	pLayer = m_pXy->FindLayer("RectRangeBackground");
	pOne = m_pXy->FindCurve("RectRange");
	if (pOne != NULL)
	{
		m_pXy->RemoveAt(pOne);
	}

	if (pLayer)
	{
		layerList.AddTail(pLayer);
		m_pXy->GetElement(pLayer->GetPathName(), elemList, FALSE);
	}
}

extern "C" __declspec(dllexport)
void DeleteRectRange(CSigmaView* pView, CXy* pxy, LPCTSTR markName)
{
	COne* pOne;
	CXy* m_pXy = (CXy*)pxy->FindMark(markName);
	pOne = m_pXy->FindCurve("RectRangeNoPicElem");
	if (pOne != NULL)
	{
		m_pXy->RemoveAt(pOne);
	}

	CLayer* pLayer;
	CPositionList elemList;
	CPtrList layerList;
	pLayer = m_pXy->FindLayer("RectRangeBackground");
	pOne = m_pXy->FindCurve("RectRange");
	if (pOne != NULL)
	{
		m_pXy->RemoveAt(pOne);
	}

	if (pLayer)
	{
		layerList.AddTail(pLayer);
		m_pXy->GetElement(pLayer->GetPathName(), elemList, FALSE);
	}
}

extern "C" __declspec(dllexport)
void DeleteDocMarkFrame(CSigmaView* pView, CXy* pxy, LPCTSTR markName)
{
	COne* pOne;
	CXy* m_pXy = (CXy*)pxy->FindMark(markName);
	pOne = m_pXy->FindCurve("RectRangeNoPicElem");
	if (pOne != NULL)
	{
		m_pXy->RemoveAt(pOne);
	}

	CLayer* pLayer;
	CPositionList elemList;
	CPtrList layerList;
	pLayer = m_pXy->FindLayer("RectRangeBackground");
	pOne = m_pXy->FindCurve("RectRange");
	if (pOne != NULL)
	{
		m_pXy->RemoveAt(pOne);
	}

	if (pLayer)
	{
		layerList.AddTail(pLayer);
		m_pXy->GetElement(pLayer->GetPathName(), elemList, FALSE);
	}
}

extern "C" __declspec(dllexport)
void SymbolWindowShow(CSigmaView* pView, CXy* pxy)
{
	//pView->m_pDoc->m_pXy = pxy;
	pxySymbolWin = pxy;
}

extern "C" __declspec(dllexport)
void CurrentSymbolWindowShow(CSigmaView* pView)
{
	pView->m_pDoc->m_pXy = pxyMark;
}

extern "C" __declspec(dllexport)
void DelRectBack(CSigmaView* pView, CXy* pxy)
{
	if (pView == NULL)
	{
		return;
	}

	COne* pOneRect = pxy->FindCurve("RectRangeNoPicElem");
	if (pOneRect != NULL)
	{
		pxy->RemoveAt(pOneRect);
	}

	CLayer* pLayer;
	COne* pOne;
	CPositionList elemList;
	CPtrList layerList;
	pLayer = pxy->FindLayer("RectRangeBackground");
	pOne = pxy->FindCurve("RectRange");
	if (pOne != NULL)
	{
		pxy->RemoveAt(pOne);
	}

	if (pLayer)
	{
		layerList.AddTail(pLayer);
		pxy->GetElement(pLayer->GetPathName(), elemList, FALSE);
	}

	CSigmaDoc* pDoc = pView->m_pDoc;
	if (pDoc != NULL)
	{
		pDoc->SetActionItem(new CActionLayerDeleteItem(pDoc, elemList, layerList));
		//pDoc->Modified();
	}
}





extern "C" __declspec(dllexport)
void DrawCircleSymbol(CSigmaView* pView)
{
	if (pView == NULL)
	{
		return;
	}
	CString layerName = "Layer:\\0";//Layer:\\0
	CXy* pxy = pView->m_pDoc->m_pXy;
	if (pxy == NULL)
	{
		return;
	}

	CLayer* pLayer = pxy->FindLayer(layerName);

	if (pLayer == NULL)
	{
		return;
	}

	CEllipse* pCircle = new CEllipse;
	pCircle->x0 = 0;
	pCircle->y0 = 0;
	pCircle->m_size.cx = 0.5;
	pCircle->m_size.cy = 0.5;
	//pCircle->m_dCurveWidth = 0.02;	
	if (pView->m_pDoc->m_pXy == NULL)
	{
		delete pCircle;
		return;
	}

	POSITION pos = pxy->AddElement(pCircle, DOUBLEFOX_CIRCLE);
	pxy->AddLayer(pLayer);	
	if (pos)
	{
		pView->m_pDoc->Modified();
	}
}


extern "C" __declspec(dllexport)
void DrawCircleCurrent(CSigmaView* pView)
{
	if (pView == NULL)
	{
		return;
	}
	CString layerName = "Layer:\\0";//Layer:\\0
	CXy* pxy = pxyMark;
	if (pxy == NULL)
	{  
		return;
	}

	CLayer* pLayer = pxy->FindLayer(layerName);

	if (pLayer == NULL)
	{
		return;
	}

	CEllipse* pCircle = new CEllipse;
	pCircle->x0 = 0;
	pCircle->y0 = 0;
	pCircle->m_size.cx = 0.5;
	pCircle->m_size.cy = 0.5;
	//pCircle->m_dCurveWidth = 0.02;	
	if (pView->m_pDoc->m_pXy == NULL)
	{
		delete pCircle;
		return;
	}

	POSITION pos = pxy->AddElement(pCircle, DOUBLEFOX_CIRCLE);
	pxy->AddLayer(pLayer);
	if (pos)
	{
		pView->m_pDoc->Modified();
	}
}

extern "C" __declspec(dllexport)
void SymbolRename(CSigmaView* pView, LPCTSTR symbolOldName, LPCTSTR symbolNewName)
{
	CXy* m_pXy = (CXy*)pView->m_pDoc->m_pXy->FindMark(symbolOldName);
	if (m_pXy != NULL)
	{
		m_pXy->m_strName = symbolNewName;
	}
}

// 清除符号库文件
extern "C" __declspec(dllexport)
void RemoveSymbolLibXy()
{
	CLibraryManager* pLib = AfxGetMarkLibMgr();
	if (pLib == NULL) return;
	pLib->m_libXy.RemoveAll();
}

extern "C" __declspec(dllexport)
void CopySymbol(CSigmaView* pView, LPCTSTR oldSymboleName, LPCTSTR newSymboleName)
{
	if (pView == NULL)
	{
		return;
	}
	CXy* m_pXy = (CXy*)pView->m_pDoc->m_pXy->FindMark(oldSymboleName);
	if (m_pXy == NULL)
	{
		return;
	}
	pos = m_pXy->FindElement("RectRangeNoPicElem");
	//COne* pOne = m_pXy->FindCurve("RectRangeNoPicElem");
	if (pos)
	{
		m_pXy->RemoveAt(pos);
	}

	CXy* pXy = new CXy;
	*pXy = *m_pXy;
	pXy->m_strName = newSymboleName;
	pView->m_pDoc->m_pXy->AddMark(pXy);
}


extern "C" __declspec(dllexport)
void LoadSymbolTree(char* path, int pathLen)
{
	CLibraryManager* pLib = AfxGetMarkLibMgr();
	if (pLib == NULL) return;
	CheckLibraryInited(pLib);
	CString strTreePath;
	CLibraryItem *pItem;
	CString pathList;
	POSITION pos = AfxGetMarkLibMgr()->m_libXy.GetHeadPosition();
	while (pos)
	{
		pItem = (CLibraryItem*)AfxGetMarkLibMgr()->m_libXy.GetNext(pos);
		strTreePath = AfxGetMarkLibMgr()->GetTreePathName(pItem->m_strFileName);
		pathList.AppendFormat("%s\r\n", strTreePath);
	}

	strncpy(path, pathList.GetBuffer(), min(pathList.GetLength() + 1, pathLen));
}

// 保存符号的原始状态，为编辑符号未保存时新建符号做准备
extern "C" __declspec(dllexport)
CXy* SaveSymbolOriginal(CSigmaView* pView, LPCTSTR symbolName)
{
	if (pView == NULL)
	{
		return NULL;
	}
	CXy* m_pXy = (CXy*)pView->m_pDoc->m_pXy->FindMark(symbolName);
	return m_pXy;
}

extern "C" __declspec(dllexport)
void ReplaceSymbol(CSigmaView* pView, LPCTSTR symbolName, CXy* pxy)
{
	if (pxy == NULL)
	{
		return;
	}

	pView->m_pDoc->m_pXy->RemoveMark(symbolName);
	pView->m_pDoc->m_pXy->AddMark(pxy);
}