#include "stdafx.h"
#include "SigmaView.h"
#include "SectionDoc.h"
#include "ItemSelect.h"
#include "ItemProportion.h"
#include "ItemEllipse.h"
#include "ItemCircle.h"
#include "ItemArc.h"
#include "ItemPointEdit.h"
#include "ItemFrame.h"
#include "ItemGrid.h"
#include "ItemNet.h"
#include "ItemText.h"
#include "ItemCurveEdit.h"
#include "ItemRectangle.h"
#include "ItemSolid.h"
#include "ItemSelectElement.h"
#include "ItemBreakCurve.h"
#include "actionmodifieditem.h"
#include "ActionModifiedMeshItem.h"
#include "ActionEmbellishItem.h"
#include "ActionAddItem.h"
#include <atlstr.h>
#include "VtkInterface.h"
#include "DrawOperator/FormatReader/GenerateImageMesh.h"

static CItemSelectElement * GetCItemSelectElementFromView(CSigmaView * pView)
{
	if (pView == NULL)
		return 0;

	CItem * pItem = pView->GetItem();
	if (pItem == NULL)
		return 0;

	CItemSelectElement * itemSelect = dynamic_cast<CItemSelectElement *>(pItem);
	return itemSelect;
}

CItemSelect * GetItemSelectFromView(CSigmaView * pView)
{
	if (pView == NULL)
		return 0;

	CItem * pItem = pView->GetItem();
	if (pItem == NULL)
		return 0;

	CItemSelect * itemSelect = dynamic_cast<CItemSelect *>(pItem);
	return itemSelect;
}

CItemBreakCurve * GetCItemBreakCurveFromView(CSigmaView *pView)
{
	if (pView == NULL)
		return 0;

	CItem * pItem = pView->GetItem();
	if (pItem == NULL)
		return 0;

	CItemBreakCurve * itemBreakCurve = dynamic_cast<CItemBreakCurve *>(pItem);

	return itemBreakCurve;
}
extern "C" __declspec(dllexport)
int SelectGetCount(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;

	return itemSelect->GetCountSelected();
}

extern "C" __declspec(dllexport)
bool SelectStatusChanged(CSigmaView* pView) 
{
	if (pView == NULL)
		return false;

	CItem * pItem = pView->GetItem();
	if (pItem == NULL)
		return false;

	CItemSelect * itemSelect = dynamic_cast<CItemSelect *>(pItem);
	if (itemSelect == NULL)
		return false;
	return itemSelect->IsSelectionChanged;
}

extern "C" __declspec(dllexport)
bool SelectIsSameType(CSigmaView* pView)
{
	if (pView == NULL)
		return false;

	CItem * pItem = pView->GetItem();
	if (pItem == NULL)
		return false;

	CItemSelect * itemSelect = dynamic_cast<CItemSelect *>(pItem);
	if (itemSelect == NULL)
		return false;
	return itemSelect->IsSameType();
}

extern "C" __declspec(dllexport)
bool SelectIsOnMoving(CSigmaView* pView)
{
	CItemSelect * pItem = GetItemSelectFromView(pView);
	if (pItem == nullptr)
	{
		return false;
	}
	return  pItem->OnMoving();
}

extern "C" __declspec(dllexport)
void SelectMoveElementsTo(CSigmaView* pView, int x, int y) {
	CItemSelect * pItem = GetItemSelectFromView(pView);
	if (pItem == nullptr)
	{
		return;
	}
	pItem->MoveElementsTo(CPoint(x, y));
}

extern "C" __declspec(dllexport)
void SelectDrawTrackPath(CSigmaView* pView, HDC hdcMem)
{
	CItemSelect * pItem = GetItemSelectFromView(pView);
	if (pItem == nullptr)
	{
		return;
	}
	CDC *pDC = CDC::FromHandle(hdcMem);
	pItem->DrawTrackPath(pDC);
}
extern "C" __declspec(dllexport)
void SelectGetTrackerRect(CSigmaView* pView, int& left, int& top, int& right, int& bottom)
{
	CItemSelect * pItem = GetItemSelectFromView(pView);
	if (pItem == nullptr)
	{
		return;
	}
	CRect rect = pItem->GetTrackerRect();
	left = rect.left;
	top = rect.top;
	right = rect.right;
	bottom = rect.bottom;
}
BOOL Select_InsertMesh(CSigmaView* pView, LPCTSTR meshFile, POSITION& newMeshPos)
{
	CXy* pXyCurrent = pView->m_pDoc->GetDraw();
	CString strExt;
	CSplitPath sp(meshFile);
	strExt = sp.GetExtension();
	strExt.MakeLower();
	CXy* pxy = new CXy;
	pxy->m_bRealTimeDraw = false;
	if (strExt == _T(".dfb") || strExt == _T(".dft"))
		pView->m_pDoc->SerializeRead(pxy, meshFile);
	else if (!pxy->ReadOtherWithExtension(meshFile))	//读取其它类型不成功时
		pxy->ReadWithExtension(meshFile);
	if (!pxy->GetProjection().IsEmpty() && !pXyCurrent->GetProjection().IsEmpty())
		pxy->ChangeToProjection(pXyCurrent->GetProjection());

	POSITION posNew = pxy->FindFirstElement(DOUBLEFOX_MESH);
	if (posNew == nullptr) {
		delete pxy;
		return false;
	}
	CMesh* pMeshNew = (CMesh*)(pxy->GetAt(posNew))->value;
	CFunction2D* pGridNew = (CFunction2D*)pMeshNew->GetMesh();
	long numxNew, numyNew;
	pMeshNew->GetNumber(numxNew, numyNew);

	CMesh* pMesh = new CMesh;
	pMesh->SetMeshType(MESH_DFG);
	//pMesh->m_bRealTimeDraw = pMeshOld->m_bRealTimeDraw;
	CDimension2D* m_pDfg = new CDimension2D;
	m_pDfg->Create(numxNew, numyNew, pGridNew->P0[0], pGridNew->P0[1], pGridNew->delt[0], pGridNew->delt[1]);
	m_pDfg->SetRange(pGridNew->range[0], pGridNew->range[1]);

	pMesh->SetMesh(m_pDfg, MESH_DFG, FALSE);
	for (int i = 0; i < numxNew; i++) {
		for (int j = 0; j < numyNew; j++) {
			pMesh->GetDfg()->SetValue(i, j, pMeshNew->GetValue(i, j));
		}
	}
    COne* pOneMesh = pXyCurrent->CreateOne(pMesh, DOUBLEFOX_MESH);
	POSITION posMesh = pXyCurrent->AddHeadOne(pOneMesh);
	//POSITION posMesh = pXyCurrent->AddElement(pMesh, DOUBLEFOX_MESH);
	CLayer * pLayer = pXyCurrent->FindAddLayer("背景");
	//COne* pOneMesh = pXyCurrent->GetAt(posMesh);
	pOneMesh->SetLayer(pLayer);
	pView->m_pDoc->SetActionItem(new CActionAddItem(pView->m_pDoc, IDS_STRING_ACTION_ADD, pOneMesh));

	newMeshPos = posMesh;
	pMesh->GetBitmap();
	pXyCurrent->EnableMeshPackage(pXyCurrent->IsEnableMeshPackage(), true);

	delete pxy;
	return true;
}
extern "C" __declspec(dllexport)
BOOL Select_ReplaceMesh(CSigmaView* pView, LPCTSTR meshFile, POSITION oldMeshPos, POSITION& newMeshPos)
{
	CXy* pXyCurrent = pView->m_pDoc->GetDraw();
	if (oldMeshPos == nullptr)
	{
		oldMeshPos = pXyCurrent->FindFirstElement(DOUBLEFOX_MESH);
	}
	if (oldMeshPos == nullptr) {
		return Select_InsertMesh(pView, meshFile, newMeshPos);
	}
	CString strExt;
	CSplitPath sp(meshFile);
	strExt = sp.GetExtension();
	strExt.MakeLower();
	CXy* pxy = new CXy;
	pxy->m_bRealTimeDraw = false;
	if (strExt == _T(".dfb") || strExt == _T(".dft"))
		pView->m_pDoc->SerializeRead(pxy, meshFile);
	else if (!pxy->ReadOtherWithExtension(meshFile))	//读取其它类型不成功时
		pxy->ReadWithExtension(meshFile);
	if (!pxy->GetProjection().IsEmpty() && !pXyCurrent->GetProjection().IsEmpty())
		pxy->ChangeToProjection(pXyCurrent->GetProjection());

	//CPositionList select;
	//pView->m_pDoc->GetDraw()->MoveInBottom(pxy, select);
	POSITION posNew = pxy->FindFirstElement(DOUBLEFOX_MESH);
	if (posNew == nullptr) {
		delete pxy;
		return false;
	}
	COne* pNewOne = pxy->GetAt(posNew);
	//pxy->RemoveAtNoClear(posNew);

	COne* pOldOne = pXyCurrent->GetAt(oldMeshPos);

	//先屏蔽撤销回退
	//CActionModifiedMesh* pAction = new CActionModifiedMesh(pView->m_pDoc, IDS_STRING_PANE_COLOR_BAR);
	//pAction->BackupOldItem(oldMeshPos, pOldOne);

	//pNewOne->m_pParentXY = pXyCurrent;
	//POSITION posInsert = pXyCurrent->InsertElementAfter(oldMeshPos, pNewOne);

	//pNewOne->SetLayer(pOldOne->GetLayer());

	CMesh* pMeshNew = (CMesh*)pNewOne->value;
	CMesh* pMeshOld = (CMesh*)pOldOne->value;

	CMesh* pMesh = new CMesh;
	pMesh->SetMeshType(MESH_DFG);
	pMesh->m_bRealTimeDraw = pMeshOld->m_bRealTimeDraw;
	CDimension2D* m_pDfg = new CDimension2D;
	
	//*(CGrid*)m_pDfg = *(CGrid*)(pMeshNew->GetDfg());
	CFunction2D* pGridNew = (CFunction2D*)pMeshNew->GetMesh();
	long numxNew, numyNew;
	pMeshNew->GetNumber(numxNew, numyNew);
	//pMeshNew->y
	m_pDfg->Create(numxNew, numyNew, pGridNew->P0[0], pGridNew->P0[1], pGridNew->delt[0], pGridNew->delt[1]);
	m_pDfg->SetRange(pGridNew->range[0], pGridNew->range[1]);

	pMesh->SetMesh(m_pDfg, MESH_DFG, FALSE);
	for (int i = 0; i < numxNew; i++) {
		for (int j = 0; j < numyNew; j++) {
			pMesh->GetDfg()->SetValue(i, j, pMeshNew->GetValue(i, j));
		}
	}
	COne *pOne = new COne;
	pOne->SetType(DOUBLEFOX_MESH);
	pOne->value = pMesh;
	pOne->CloneOtherParameter(*pOldOne);
	pMesh->CloneOtherParamter(*pMeshOld);
	pMesh->GetBitmap();

	newMeshPos = pXyCurrent->AddHeadOne(pOne);

	//pMeshNew->CloneOtherParamter(*pMeshOld);

	//long numx, numy;
	//pMeshOld->GetNumber(numx, numy);
	//long numxNew, numyNew;
	//pMeshNew->GetNumber(numxNew, numyNew);

	//for (int i = 0; i < numx && i < numxNew; i++) {
	//	for (int j = 0; j < numy && j < numyNew; j++) {
	//		pMeshOld->SetZ(i, j, pMeshNew->GetValue(i, j));
	//	}
	//}
	pXyCurrent->RemoveAt(pOldOne);
	pXyCurrent->EnableMeshPackage(pXyCurrent->IsEnableMeshPackage(), true);

	delete pxy;

	//先屏蔽
	//pAction->BackupNewItem();
	//pView->m_pDoc->SetActionItem(pAction);

	return true;
}
extern "C" __declspec(dllexport)
BOOL Select_CreateMeshColorBar(CSigmaView* pView, ColorPoint* colorPoints, int length, LPCTSTR barSavePath, LPCTSTR xmlSavePath,
	double minz, double maxz)
{
	std::vector<ColorPoint> vector(colorPoints, colorPoints + length);
	GenerateImageMesh * pColorBar = new GenerateImageMesh();
	bool state = pColorBar->CreateMeshColorBar(vector, barSavePath, minz, maxz, xmlSavePath);
	delete pColorBar;
	
	return state;
}
extern "C" __declspec(dllexport)
BOOL Select_CreateColorBarData(CSigmaView* pView, POSITION oldMeshPos, ColorPoint* colorPoints,
	int numColors, int &vSize, double zmin, double zmax, int colorType, int sortType)
{
	COne * pOne1 = pView->m_pDoc->GetDraw()->GetAt(oldMeshPos);

	if (pOne1 == 0) return false;
	CImageInsert* pValue = (CImageInsert*)pOne1->GetValue();
	GenerateImageMesh * pColorBar = new GenerateImageMesh();
	pColorBar->SetImageBase((CxImage)*pValue->m_pImage);
	pColorBar->SetZminByZmax(zmin, zmax);

	GenerateImageMesh::ColorMethod colorMethod;
	GenerateImageMesh::SortMethod  sortMethod;
	switch (colorType)
	{
	case 0:
		colorMethod = GenerateImageMesh::ColorMethod::HSV_M;
		break;
	case 1:
		colorMethod = GenerateImageMesh::ColorMethod::UNIFORMSAMPLING_M;
		break;
	case 2:
		colorMethod = GenerateImageMesh::ColorMethod::KMEANS_M;
		break;
	default:
		break;
	}

	switch (sortType)
	{
	case 0:
		sortMethod = GenerateImageMesh::SortMethod::BRIGHTNESS_SORT;
		break;
	case 1:
	{
		if(colorType == 0 || colorType == 1)
			sortMethod = GenerateImageMesh::SortMethod::HUE_SORT;

		if(colorType == 2)
			sortMethod = GenerateImageMesh::SortMethod::HUE_SORT_COLD;

		break;
	}
		break;
	default:
		break;
	}
	
	std::vector<ColorPoint> vector;
	bool state = pColorBar->CreateColorBarData(vector, colorMethod, sortMethod, numColors);
	for (int i = 0; i < vector.size(); ++i) {
		colorPoints[i] = vector[i];
	}
	vSize = vector.size();

	delete pColorBar;
	return state;
}
extern "C" __declspec(dllexport)
BOOL Select_CreateReplaceMesh(CSigmaView* pView, POSITION oldMeshPos, POSITION& newMeshPos,
	int colorNum, double gridZmin, double gridZmax,
	int numX, int numY, double dLocationX, double dLocationY
	, double dDeltX, double dDeltY, double dMaxX, double dMaxY, ColorPoint* colorPoints, ColorPoint* colorListPoints, int colorListNum)
{
	COne * pOne1 = pView->m_pDoc->GetDraw()->GetAt(oldMeshPos);
	
	if (pOne1 == 0)
		return false;
	CImageInsert* pValue = (CImageInsert*)pOne1->GetValue();
	CLayer * lay = pOne1->GetLayer();
	//CString str = lay->GetName();

	GenerateImageMesh * pCreateMesh = new GenerateImageMesh();
	pCreateMesh->SetImageBase((CxImage)*pValue->m_pImage);
	pCreateMesh->SetZminByZmax(gridZmin, gridZmax);

	std::vector<ColorPoint> vector(colorPoints, colorPoints + colorNum);
	std::vector<ColorPoint> vectorColor(colorListPoints, colorListPoints + colorListNum);
	//放入xy
	CMesh * pMesh = pCreateMesh->CreateImageMeshProcess(numX, numY, dLocationX, dLocationY, dDeltX, dDeltY, dMaxX, dMaxY,  vector, vectorColor);
	pMesh->GetBitmap();
	CXy* pXyCurrent = pView->m_pDoc->GetDraw();
	COne* pOneMesh = pXyCurrent->CreateOne(pMesh, DOUBLEFOX_MESH);
	POSITION posMesh = pXyCurrent->AddHeadOne(pOneMesh);
	CLayer * pLayer = pXyCurrent->FindAddLayer("背景");
	pOneMesh->SetLayer(pLayer);
	pView->m_pDoc->SetActionItem(new CActionAddItem(pView->m_pDoc, IDS_STRING_ACTION_ADD, pOneMesh));

	newMeshPos = posMesh;
	
	pXyCurrent->EnableMeshPackage(pXyCurrent->IsEnableMeshPackage(), true);
	

	//COne * pOne = new COne;
	//pOne->SetType(DOUBLEFOX_MESH);
	//pOne->value = pMesh;
	//newMeshPos = pXyCurrent->AddHeadOne(pOne);
	//pXyCurrent->EnableMeshPackage(pXyCurrent->IsEnableMeshPackage(), true);

	return true;
}
extern "C" __declspec(dllexport)
BOOL Select_ReselectByPosition(CSigmaView* pView, POSITION posNew) {
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return FALSE;
	itemSelect->Select(posNew, false);
	return TRUE;
}
extern "C" __declspec(dllexport)
BOOL Select_GetElementByPosition(CSigmaView* pView, BYTE*& buffElement, int& buffLen, POSITION elementPtr, bool allContent)
{
	if (pView->m_pDoc == 0)
		return FALSE;

	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(elementPtr));
	if (pOne == 0)
		return FALSE;

	if (pOne->GetType() == DOUBLEFOX_MESH) {
		if (allContent) {
			return pOne->WriteMemory(buffElement, 0, buffLen, 3);
		}
		else {
			((CMesh*)(pOne->value))->WriteElementDML(buffElement, buffLen);
		}
		return TRUE;
	}
	else if (pOne->GetType() == DOUBLEFOX_TEXT) {
		((CText*)(pOne->value))->color = pOne->color;
		return pOne->WriteMemory(buffElement, 0, buffLen, 3);
	}
	else if (pOne->GetType() == DOUBLEFOX_ELLIPSE)
	{
		((CEllipse*)(pOne->value))->color = pOne->color;
		return pOne->WriteMemory(buffElement, 0, buffLen, 3);
	}
	else if (pOne->GetType() == DOUBLEFOX_CIRCLE)
	{
		((CCircle*)(pOne->value))->color = pOne->color;
		return pOne->WriteMemory(buffElement, 0, buffLen, 3);
	}
	else if (pOne->GetType() == DOUBLEFOX_ARC)
	{
		((CArc*)(pOne->value))->color = pOne->color;
		return pOne->WriteMemory(buffElement, 0, buffLen, 3);
	}
	else if (pOne->GetType() == DOUBLEFOX_SCALERULER)
	{
		((CScaleRuler*)(pOne->value))->color = pOne->color;
		return pOne->WriteMemory(buffElement, 0, buffLen, 3);
	}
	else if (pOne->GetType() == DOUBLEFOX_PROPORTION)
	{
		((CProportion*)(pOne->value))->color = pOne->color;
		return pOne->WriteMemory(buffElement, 0, buffLen, 3);
	}
	else if (pOne->GetType() == DOUBLEFOX_IMAGE)
	{
		((CImageInsert*)(pOne->value))->WriteElementDML(buffElement, buffLen);
	}
	else if (pOne->GetType() == DOUBLEFOX_BLOCK)
	{
		if (allContent)
		{
			pOne->WriteMemory(buffElement, 0, buffLen, 3);
		}
		else {
			pOne->WriteSummaryMemory(buffElement, 0, buffLen, 3);
		}
		return true;
	}
	else
	{
		return pOne->WriteMemory(buffElement, 0, buffLen, 3);
	}
	return false;
}
extern "C" __declspec(dllexport)
BOOL Select_IsElementLocationChanged(CSigmaView* pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	return itemSelect->m_isLocationChanged;
}
extern "C" __declspec(dllexport)
BOOL GetElementByLocation(CSigmaView* pView, BYTE*& buffElement, int& buffLen
	, int mouseX, int mouseY)
{
	CPoint2D pt;
	pt.x0 = mouseX;
	pt.y0 = mouseY;
	pt = pView->m_pDoc->GetDC().GetReal(pt);
	POSITION pos = pView->m_pDoc->GetSelectedItem(pt);
	if (pos == nullptr) {
		return false;
	}
	BOOL bReturn = Select_GetElementByPosition(pView, buffElement, buffLen, pos, false);

	return bReturn;
}
extern "C" __declspec(dllexport)
BOOL SelectGetPointsZRange(CSigmaView * pView, double& zMin, double& zMax)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	return itemSelect->GetPointsZRange(zMin, zMax);
}
extern "C" __declspec(dllexport)
BOOL SelectSetPointsColor(CSigmaView * pView, LPCTSTR colorItemsData, double dWidth, double dHeight)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	return itemSelect->SetPointsColor(colorItemsData, dWidth, dHeight);
}
extern "C" __declspec(dllexport)
const BSTR GetSelectedNames(CSigmaView * pView) {
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	if (itemSelect->m_selection.IsEmpty())
		return false;

	CString strData("");	
	itemSelect->GetSelectedNames(strData);

	return strData.AllocSysString();
}
extern "C" __declspec(dllexport)
BOOL SelectGetElement(CSigmaView * pView, BYTE*& buffElement, int& buffLen, POSITION& elementPtr, bool allContent)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	if (itemSelect->m_selection.IsEmpty())
		return false;
	POSITION pos = itemSelect->m_selection.GetHead();
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	elementPtr = pos;
	BOOL bReturn = Select_GetElementByPosition(pView, buffElement, buffLen, elementPtr, allContent);
	// 需要释放 free(buffElement);
	return bReturn;
}
extern "C" __declspec(dllexport)
BOOL SelectGetElementPositions(CSigmaView * pView, POSITION*& array, int & len) {
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	if (itemSelect->m_selection.IsEmpty())
		return false;
	len = itemSelect->m_selection.GetCount();
	array = new POSITION[len];

	POSITION pos, pt;
	pos = itemSelect->m_selection.GetHeadPosition();
	int i = 0;
	while (pos != NULL)
	{
		pt = itemSelect->m_selection.GetNext(pos);
		array[i++] = pt;
	}
	//array = pPositions;
	return true;
}
// 选择包含在边界曲线内的所有图元
extern "C" __declspec(dllexport)
int SelectInCurveRange(CSigmaView * pView) {
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return 0;

	return itemSelect->SelectInCurve();
}

// 选择包含在边界曲线内的所有图元
extern "C" __declspec(dllexport)
int SelectTypeInCurveRange(CSigmaView * pView, int elementType) {
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return 0;

	return itemSelect->SelectInCurve(elementType);
}

// 选择包含和与区域叠超面积超过图元面积一定百分比的图元
extern "C" __declspec(dllexport)
int SelectInCurveRangeEx(CSigmaView * pView, double factor) {
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return 0;

	return itemSelect->SelectInCurveEx(factor);
}

// 选择包含和与区域叠超面积超过图元面积一定百分比的图元
extern "C" __declspec(dllexport)
int SelectTypeInCurveRangeEx(CSigmaView * pView, int elementType, double factor) {
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return 0;

	return itemSelect->SelectInCurveEx(elementType, factor);
}
extern "C" __declspec(dllexport)
int Select_SamePropertyElements(CSigmaView* pView)
{
	CItemSelect *itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return 0;
	return itemSelect->SelectSamePropertyElements();
}
extern "C" __declspec(dllexport)
void Select_SetTypes(CSigmaView* pView, int* types, int size)
{
	CItemSelect *itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
	{
		return;
	}
	itemSelect->SetSelectTypes(types, size);
}
// 获得所有选择的图元
extern "C" __declspec(dllexport)
bool Select_GetElements(CSigmaView * pView, BYTE*& buffElement, int& buffLen)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	if (itemSelect->m_selection.IsEmpty())
		return false;
	BOOL bReturn = itemSelect->WriteData(pView->m_pDoc->GetDraw(), buffElement, buffLen, 3);
	// 需要释放 free(buffElement);
	return bReturn;
}

extern "C" __declspec(dllexport)
bool Select_WriteTemplate(CSigmaView* pView, LPCTSTR outputFile)
{
	CFile fw;
	if (!fw.Open(outputFile, CFile::modeCreate | CFile::modeWrite))
	{
		return false;
	}

	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	if (itemSelect->m_selection.IsEmpty())
		return false;

	CXy* pxy = pView->m_pDoc->GetDraw();
	pxy->DFD_WriteMark(*(CFile*)&fw, CUR_VERSION, 1);
	pxy->DFD_WriteLegend(*(CFile*)&fw, CUR_VERSION, 1);
	pxy->DFD_Write(*(CFile*)&fw, itemSelect->m_selection);
	fw.Close();
	return true;
}

/**
 * 获取选中的多边形，只有选中一个图元并且该图元是多边形时，返回该图元信息
 * \return
 */
extern "C" __declspec(dllexport)
POSITION SelectGetPolygon(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == nullptr)
	{
		return nullptr;
	}

	if (itemSelect->m_selection.GetCount() != 1)
	{
		return nullptr;
	}

	POSITION pt = itemSelect->m_selection.GetHead();
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pt));
	if (pOne->GetType() == DOUBLEFOX_CURVE)
	{
		CCurveEx* pCurve = (CCurveEx*)(pOne->value);
		if (IsPolygon(pCurve))
		{
			return pt;
		}
	}

	return nullptr;
}

extern "C" __declspec(dllexport)
int SelectGetElementType(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return 0;
	if (itemSelect->m_selection.IsEmpty())
		return 0;
	if (itemSelect->m_selection.GetCount() != 1) {
		return 0;
	}
	POSITION pos = itemSelect->m_selection.GetHead();
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));
	return pOne->GetType();
}

extern "C" __declspec(dllexport)
void* SelectGetMesh(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return 0;
	if (itemSelect->m_selection.IsEmpty())
		return 0;
	if (itemSelect->m_selection.GetCount() != 1) {
		return 0;
	}
	POSITION pos = itemSelect->m_selection.GetHead();
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));
	if (pOne->GetType() == DOUBLEFOX_MESH)
	{
		KevVtkMeshData *pKevVtkMeshData = new KevVtkMeshData;
		CMesh *pMesh = (CMesh *)pOne->GetValue();
		double zmin, zmax;
		pMesh->GetM(zmin, zmax);
		pKevVtkMeshData->m_zMin = zmin;
		pKevVtkMeshData->m_zMax = zmax;
		double x0, y0;
		pMesh->GetOrg(x0, y0);
		pKevVtkMeshData->x0 = x0;
		pKevVtkMeshData->y0 = y0;
		double dx, dy;
		pMesh->GetDelt(dx, dy);
		pKevVtkMeshData->dx = dx;
		pKevVtkMeshData->dy = dy;
		CGrid* pGrid = pMesh->GetMesh();
		long numX = pGrid->xnum();
		long numY = pGrid->ynum();
		pKevVtkMeshData->numX = numX;
		pKevVtkMeshData->numY = numY;
		CDimension3D* pdfg = pMesh->GetDfg();
		if (pdfg == NULL)
			return nullptr;
		pKevVtkMeshData->num = pdfg->num;
		pKevVtkMeshData->P0 = pdfg->P0;
		pKevVtkMeshData->delt = pdfg->delt;
		double* pShadow = new double[pdfg->total];
		std::memcpy(pShadow, pdfg->u, pdfg->total*sizeof(double));
		pKevVtkMeshData->shadow_u = pShadow;
		pKevVtkMeshData->origin_u = pdfg->u;
		pKevVtkMeshData->range = pdfg->range;
		pKevVtkMeshData->n = pdfg->n;
		CColorBase& color = pMesh->color;
		for (int i = 0; i < color.sizeColor(); i++)
		{
			CColorItem& item = color.GetColorItem(i);
			KevVtkColorItem *pColorItem = new KevVtkColorItem();
			pColorItem->z = item.z;
			pColorItem->color[0] = item.color.rgbRed;
			pColorItem->color[1] = item.color.rgbGreen;
			pColorItem->color[2] = item.color.rgbBlue;
			pColorItem->color[3] = item.color.rgbReserved;
			pColorItem->gradient = item.m_bContinue;
			pKevVtkMeshData->m_colorList.push_back(pColorItem);
		}
		pKevVtkMeshData->id = pMesh->GetId();
		pKevVtkMeshData->m_layerName = pOne->GetLayer()->GetPathName();
		return pKevVtkMeshData;
	}
	else
	{
		return nullptr;
	}
}


//extern "C" __declspec(dllexport)
//bool SelectSetGridData(CSigmaView* pView, BYTE* buffElement, int buffLen, POSITION elementPtr)
//{
//	{
//		CActionModifiedItem* m_pAction = NULL;
//		CItemSelect* pSelItem = pView->m_pDoc->GetSelectItem();
//		if (pSelItem)
//		{
//			m_pAction = new CActionModifiedItem(pView->m_pDoc, IDS_STRING_TOOLBAR_EDIT);
//			m_pAction->AddCloneItem(pSelItem->m_selection);
//		}
//		pView->m_pDoc->SetActionItem(m_pAction);
//	}
//	BOOL bEdited = FALSE;
//	POSITION pos;
//	pos = (POSITION)elementPtr;
//	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));
//
//	if (pOne->GetType() == DOUBLEFOX_MESH)
//	{
//		CMesh* pMesh = (CMesh*)(pOne->value);
//		// pMesh->m_bRealTimeDraw = false;
//		// pMesh->ReadElementDML(buffElement, -1, buffLen);
//		//pMesh->SetM(m_zrange.cx, m_zrange.cy);
//
//		pMesh->SetM(pMesh->m_pRuler->zmin, pMesh->m_pRuler->zmax);
//		pMesh->GetBitmap();
//		bEdited = true;
//	}
//	return bEdited;
//}
extern "C" __declspec(dllexport)
BOOL SelectSetElement(CSigmaView* pView, BYTE* buffElement, int buffLen, POSITION elementPtr, bool state, double zmin, double zmax)
{
	if (pView == nullptr || buffElement == nullptr || buffLen <= 0 || elementPtr == nullptr)
	{
		return FALSE;
	}

	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(elementPtr));
	if (pOne == nullptr)
	{
		return FALSE;
	}

	// 由于网格特别占内存，我们进行它的回退进行特殊处理，只备份网格参数，不备份网格数据
	if (pOne->GetType() == DOUBLEFOX_MESH)
	{
		auto pAction = std::make_unique<CActionModifiedMeshItem>(pView->m_pDoc, IDS_STRING_TOOLBAR_EDIT);
		pAction->BackupOldArguments(pOne);
		CMesh* pMesh = (CMesh*)(pOne->value);
		pMesh->m_bRealTimeDraw = false;

		pMesh->ReadElementDML(buffElement,-1, buffLen);

		if (state)
		{
			pMesh->SetM(pMesh->m_pRuler->zmin, pMesh->m_pRuler->zmax);
		}
		else
		{
			//与色标分离后 需要使用属性框中的值
			pMesh->SetM(zmin, zmax);
		}

		pMesh->GetBitmap();
		pAction->BackupNewArguments();
		pView->m_pDoc->SetActionItem(pAction.release());
		return true;
	}

	CActionModifiedItem* pAction = new CActionModifiedItem(pView->m_pDoc, IDS_STRING_TOOLBAR_EDIT);
	pAction->BackupOldItem(elementPtr, pOne);

	BOOL bEdited = FALSE;

	// TODO: 判断属性是否被修改
	if (pOne->GetType() == DOUBLEFOX_SECTION) {
		((CSection*)(pOne->value))->ReadElementDML(buffElement, -1, buffLen);
		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_MESH) {
		CMesh* pMesh = (CMesh*)(pOne->value);
		pMesh->m_bRealTimeDraw = false;

		pMesh->ReadElementDML(buffElement,-1, buffLen);

		pMesh->SetM(pMesh->m_pRuler->zmin, pMesh->m_pRuler->zmax);
		pMesh->GetBitmap();
		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_TEXT) {
		pOne->ReadMemory(buffElement, -1, buffLen, 3);
		CText* pText = (CText*)(pOne->value);
		pText->color= pOne->color;
		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_ELLIPSE)
	{
		pOne->ReadMemory(buffElement, 0, buffLen, 3);
		((CEllipse*)(pOne->value))->color = pOne->color;
		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_CIRCLE)
	{
		pOne->ReadMemory(buffElement, 0, buffLen, 3);
		((CCircle*)(pOne->value))->color = pOne->color;
		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_ARC)
	{
		pOne->ReadMemory(buffElement, 0, buffLen, 3);
		((CArc*)(pOne->value))->color = pOne->color;
		TRACE(_T("CArc Width:"), ((CArc*)(pOne->value))->m_dCurveWidth);
		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_PROPORTION)
	{
		pOne->ReadMemory(buffElement, 0, buffLen, 3);
		((CProportion*)(pOne->value))->color = pOne->color;
		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_SCALERULER)
	{
		pOne->ReadMemory(buffElement, 0, buffLen, 3);
		((CScaleRuler*)(pOne->value))->color = pOne->color;
		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_CURVE)
	{
		CHowToViewCurve* pHWCOld = pOne->HowToViewCurve;
		if (pHWCOld != NULL)
		{
			pHWCOld->Empty();
		}
		pOne->ReadMemory(buffElement, 0, buffLen, 3);
		//if (pOne->HowToViewCurve != nullptr) 
		//{
		//	pOne->HowToViewCurve->EnableDrawSourceCurve(TRUE);
		//	pOne->HowToViewCurve->IsSolid();
		//	CCurveProperties* pCurveView = new CCurveProperties();
		//	pCurveView->SetCurveType(PLINE_SOLID);
		//	pCurveView->color = pOne->color;
		//	pOne->HowToViewCurve->Add(pCurveView);
		//}
		CString strName1 = pOne->GetName();

		bEdited = true;
	}
	else if (pOne->GetType() == DOUBLEFOX_BLOCK)
	{
		pOne->ReadSummaryMemory(buffElement, 0, buffLen, 3);
		bEdited = true;
	}
	else
	{
		if (pOne->HowToViewCurve != NULL)
		{
			pOne->HowToViewCurve->Empty();
		}
		pOne->ReadMemory(buffElement, -1, buffLen, 3);
		bEdited = true;
	}

	pAction->BackupNewItem();
	pView->m_pDoc->SetActionItem(pAction);

	return bEdited;
}

extern "C" __declspec(dllexport)
BOOL SetElementVisibility(CSigmaView * pView, POSITION elementPtr, bool visible)
{
	POSITION pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));
	if (pOne == nullptr)
	{
		return FALSE;
	}
	if (visible == TRUE)
	{
		pOne->SetViewState(VIEW_STATE);       // 设置为可见
	}
	else
	{
		pOne->SetViewState(UNVIEW_STATE);    // 设置为不可见
	}
	return TRUE;
}

extern "C" __declspec(dllexport)
BOOL SelectRemoveCurveStyle(CSigmaView * pView, POSITION elementPtr, int index)
{
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	POSITION pos;
	pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	if (pOne == NULL) return FALSE;

	if (pOne->HowToViewCurve == NULL) return FALSE;
	
	CHowToViewCurve* pHW = pOne->HowToViewCurve;

	pHW->RemoveAt(index);
	if (pHW->GetCount() == 0)
	{
		delete pOne->HowToViewCurve;
		pOne->HowToViewCurve = NULL;
	}
	return TRUE;
}

extern "C" __declspec(dllexport)
BOOL SelectRemovePointStyle(CSigmaView * pView, POSITION elementPtr)
{
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	POSITION pos;
	pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	if (pOne == NULL) return FALSE;

	if (pOne->HowToViewPoint == NULL) return FALSE;

	delete  pOne->HowToViewPoint;
	pOne->HowToViewPoint = nullptr;

	return TRUE;
}

extern "C" __declspec(dllexport)
BOOL SelectMoveUpCurveStyle(CSigmaView * pView, POSITION elementPtr, int nIndex) {
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	POSITION pos;
	pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	if (pOne == NULL) return FALSE;

	if (pOne->HowToViewCurve == NULL) return FALSE;
	
	CHowToViewCurve* pHW = pOne->HowToViewCurve;

	return pHW->MoveUp(nIndex);
}

extern "C" __declspec(dllexport)
BOOL SelectMoveDownCurveStyle(CSigmaView * pView, POSITION elementPtr, int nIndex) {
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	POSITION pos;
	pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	if (pOne == NULL) return FALSE;

	if (pOne->HowToViewCurve == NULL) return FALSE;

	CHowToViewCurve* pHW = pOne->HowToViewCurve;

	return pHW->MoveDown(nIndex);
}
extern "C" __declspec(dllexport)
int RenameElement(CSigmaView * pView, LPCTSTR oldName, LPCTSTR newName, LPCTSTR layerName)
{
	CXy * pXy = pView->m_pDoc->m_pXy;
	if (pXy == NULL) return 0;

	CString strLayer(layerName);
	bool isLayerEmpty = strLayer.IsEmpty();

	CPtrList* pl = pXy->GetValueList();
	POSITION posCurrent = pl->GetHeadPosition();
	COne* pOne;
	int nCount = 0;
	while (posCurrent)
	{
		pOne = pXy->GetAt(posCurrent);
		if (pOne->GetName() == oldName)
		{
			if (!isLayerEmpty && strLayer != pOne->GetLayer()->GetName())
			{
				pl->GetNext(posCurrent);
				continue;
			}
			pOne->SetName(newName);
			nCount++;
		}
		pl->GetNext(posCurrent);
	}
	return nCount;
}
extern "C" __declspec(dllexport)
int ResetCurveStyle(CSigmaView * pView, LPCTSTR curveName, LPCTSTR layerName, int type, BYTE * buffCurve, int bufLen)
{
	CXy * pXy = pView->m_pDoc->m_pXy;
	if (pXy == NULL) return 0;

	CString strLayer(layerName);
	bool isLayerEmpty = strLayer.IsEmpty();

	CPtrList* pl = pXy->GetValueList();
	POSITION posCurrent = pl->GetHeadPosition();
	COne* pOne;
	int nCount = 0;
	while (posCurrent)
	{
		pOne = pXy->GetAt(posCurrent);
		if (pOne->GetType() == DOUBLEFOX_CURVE && pOne->GetName() == curveName)
		{
			if (!isLayerEmpty && strLayer != pOne->GetLayer()->GetName())
			{
				pl->GetNext(posCurrent);
				continue;
			}
			if (pOne->HowToViewCurve == NULL) {
				pOne->HowToViewCurve = new CHowToViewCurve();
			}
			CHowToViewCurve* pHWCOld = pOne->HowToViewCurve;
			pHWCOld->Empty();
			switch (type)
			{
			case CurveArrowHead:
			case CurveArrowTail:
				pHWCOld->Add(new CCurveArrow());
				break;
			case CurveProperties:
				pHWCOld->Add(new CCurveProperties());
				break;
			case CurveLocate:
				pHWCOld->Add(new CCurveLocate());
				break;
			case CurveScale:
				pHWCOld->Add(new CCurveScale());
				break;
			case CurveNameHead:
			case CurveNameTail:
				pHWCOld->Add(new CCurveName());
				break;
			case CurveTwoMark:
				pHWCOld->Add(new CCurveTwoMark());
				break;
			case CurveRgn:
				pHWCOld->Add(new CCurveRgn());
				break;
			case CurveInName:
				pHWCOld->Add(new CCurveInName());
				break;
			case CurveInNameAny:
				pHWCOld->Add(new CCurveInNameAny());
				break;
			case CurveEffect:
				pHWCOld->Add(new CCurveEffect());
				break;
			case CurveCenterName:
				pHWCOld->Add(new CCurveCenterName());
				break;
			}

			pHWCOld->SetAt(pHWCOld->GetCount() - 1, buffCurve, bufLen, 3);

			nCount++;
		}
		pl->GetNext(posCurrent);
	}
	return nCount;
}

extern "C" __declspec(dllexport)
BOOL SelectCreateCurveStyle(CSigmaView * pView, POSITION elementPtr, int type, BYTE * buffCurve, int bufLen)
{
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	POSITION pos;
	pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	if (pOne == NULL) return FALSE;

	if (pOne->HowToViewCurve == NULL) {
		pOne->HowToViewCurve = new CHowToViewCurve();
	}

	CHowToViewCurve* pHWCOld = pOne->HowToViewCurve;

	//为了修饰的Redo/Undo
	CActionEmbellishItem *pActionItem = new CActionEmbellishItem(pView->m_pDoc, ActionTypeLayerEmbellishCurveAdd, pOne);
	pActionItem->SetOldHowToView(pOne); // 备份老修饰

	switch (type)
	{
	case CurveArrowHead:
	case CurveArrowTail:
		pHWCOld->Add(new CCurveArrow());
		break;
	case CurveProperties:
		pHWCOld->Add(new CCurveProperties());
		break;
	case CurveLocate:
		pHWCOld->Add(new CCurveLocate());
		break;
	case CurveScale:
		pHWCOld->Add(new CCurveScale());
		break;
	case CurveNameHead:
	case CurveNameTail:
		pHWCOld->Add(new CCurveName());
		break;
	case CurveTwoMark:
		pHWCOld->Add(new CCurveTwoMark());
		break;
	case CurveRgn:
		pHWCOld->Add(new CCurveRgn());
		break;
	case CurveInName:
		pHWCOld->Add(new CCurveInName());
		break;
	case CurveInNameAny:
		pHWCOld->Add(new CCurveInNameAny());
		break;
	case CurveEffect:
		pHWCOld->Add(new CCurveEffect());
		break;
	case CurveCenterName:
		pHWCOld->Add(new CCurveCenterName());
		break;
	}

	BOOL result = pHWCOld->SetAt(pHWCOld->GetCount() - 1, buffCurve, bufLen, 3) != NULL;
	pActionItem->SetNewHowToView(pOne);
	pView->m_pDoc->SetActionItem(pActionItem);

	return result;
}

extern "C" __declspec(dllexport)
BOOL SelectCreatePointStyle(CSigmaView * pView, POSITION elementPtr, BYTE * buffPoint, int bufLen)
{
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	POSITION pos;
	pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	if (pOne == NULL) return FALSE;

	CHowToViewPoint htp;
	BOOL bSuccess = htp.ReadMemory(buffPoint, bufLen, 3);
	if (bSuccess == FALSE) {
		return FALSE;
	}

	CActionEmbellishItem* pActionItem = new CActionEmbellishItem(pView->m_pDoc, 0, pOne);
	pActionItem->SetOldHowToView(pOne);	//备份老修饰

	if (pOne->HowToViewPoint == NULL) {
		pOne->HowToViewPoint = new CHowToViewPoint();
	}
	*(pOne->HowToViewPoint) = htp;

	pActionItem->SetNewHowToView(pOne);	//备份新修饰

	pView->m_pDoc->Modified();
	pView->m_pDoc->SetActionItem(pActionItem);

	return TRUE;
}
extern "C" __declspec(dllexport)
BOOL SelectGetLayerNames(CSigmaView * pView, BYTE*& buffData, int& bufLen)
{
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	CString layers;
	CPositionList* ppl = &(itemSelect->m_selection);

	if (ppl != NULL && !ppl->IsEmpty())
	{
		layers = pView->m_pDoc->GetSelectedElementLayer(*ppl);
		bufLen = layers.GetLength();
		buffData = new BYTE[bufLen + 1];
		memcpy(buffData, (VOID*)LPCTSTR(layers), bufLen);
	}
	return true;
}
extern "C" __declspec(dllexport)
BOOL SelectGetLayerName(CSigmaView * pView, POSITION elementPtr, char * buffPoint, int bufLen)
{
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	POSITION pos;
	pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	if (pOne == NULL) return FALSE;

	CLayer* pLayer = pOne->GetLayer();

	if (pLayer == NULL) return FALSE;

	CString name = pLayer->GetName();

	strncpy(buffPoint, name.GetBuffer(), min(bufLen, name.GetLength() + 1));
	
	return TRUE;
}

extern "C" __declspec(dllexport)
BOOL SelectSetLayerByName(CSigmaView * pView, POSITION elementPtr, LPCTSTR layerName)
{
	CXy* pxy = pView->m_pDoc->m_pXy;

	CLayer* pLayer = pxy->FindLayer(layerName);
	
	if (pLayer == NULL) return FALSE;

	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL) return FALSE;
	
	POSITION pos;
	pos = (POSITION)elementPtr;
	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));

	if (pOne == NULL) return FALSE;

	pOne->SetLayer(pLayer);
	
	return TRUE;
}

extern "C" __declspec(dllexport)
int ItemSelectElement_GetCountSelected(CSigmaView * pView)
{
	if (pView == 0)
		return -1;

	CItemSelectElement * item = GetCItemSelectElementFromView(pView);
	if (item == 0)
		return -1;

	return item->GetCountSelected();
}

extern "C" __declspec(dllexport)
int Select_HightLightFirstCurve(CSigmaView * pView, HDC hdc)
{
	if (pView == 0)
		return -1;

	CItemBreakCurve * item = GetCItemBreakCurveFromView(pView);
	if (item == 0)
		return -1;

	CDC *pDC = CDC::FromHandle(hdc);
	pView->SetDrawDC(pDC);

	item->HightLightFirstCurve();
	return 1;
}
extern "C" __declspec(dllexport)
BOOL SelectSetCursor(CSigmaView * pView, int ptX, int ptY, int& handle)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;
	BOOL bSuccess = itemSelect->OnSetCursor(CPoint(ptX, ptY), handle);
	return bSuccess;
}

extern "C" __declspec(dllexport)
int Select_GetKindOfSelectedElement(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;

	if (itemSelect->m_selection.IsEmpty())
		return  -1;

	POSITION pos = itemSelect->m_selection.GetHead();
	if (pos == 0)
		return -1;

	COne* pOne = (COne*)(pView->m_pDoc->GetDraw()->GetAt(pos));
	if (pOne == 0)
		return -1;

	return pOne->GetType();
}
extern "C" __declspec(dllexport)
int Select_ByNames(CSigmaView * pView, LPCTSTR data) {
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return 0;
	CString strData(data);
	itemSelect->SelectByNames(strData);
	return 1;
}
extern "C" __declspec(dllexport)
int Select_SelectAll(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;

	itemSelect->SelectAll();
	return 1;

}
extern "C" __declspec(dllexport)
int Select_ClearAll(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;
	itemSelect->ClearAll(nullptr);
	return 1;
}
extern "C" __declspec(dllexport)
int Select_SelectAllByKind(CSigmaView * pView, int kind)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;

	itemSelect->SelectAll(kind);
	return 1;
}

extern "C" __declspec(dllexport)
int Select_ReloadTrack(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;

	pView->m_pDoc->GetSelectionSet(itemSelect->m_selection);
	itemSelect->ReloadTrackerPath();

	return 0;
}

extern "C" __declspec(dllexport)
int Select_EnableTracker(CSigmaView * pView, int bEnable)
{
	if (pView == 0)
		return -1;

	if (pView->m_pDoc == 0)
		return -1;
	CItemSelect * pSelect = pView->m_pDoc->GetSelectItem();
	if(pSelect)
	{
		pSelect->EnableTracker(bEnable == 1 ? true : false);
	}
	return 1;
}

extern "C" __declspec(dllexport)
int Select_SelectOneGraph(CSigmaView * pView, POSITION pos)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;

	itemSelect->Select(pos, FALSE);
	itemSelect->ReloadTrackerPath();
	return 1;
}
extern "C" __declspec(dllexport)
void Select_CreateGroup(CSigmaView * pView, POSITION& pos)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return;
	pos = itemSelect->GroupSelectionToBlock();
}

extern "C" __declspec(dllexport)
bool Select_UngroupAll(CSigmaView * pView, int& layerCount)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;
	return itemSelect->UngroupAll(layerCount);
}

extern "C" __declspec(dllexport)
bool Select_SaveSelectKml(CSigmaView* pView, POSITION pos, LPCTSTR path)
{
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;

	CXy* pXyCurrent = pView->m_pDoc->GetDraw();
	return itemSelect->SaveSelectKml(pos, pXyCurrent, path);
}

extern "C" __declspec(dllexport)
bool Select_DisperseMetaEmf(CSigmaView* pView, POSITION pos, long timestamp)
{
	CItemSelect* itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return false;

	CXy* pXyCurrent = pView->m_pDoc->GetDraw();
	return itemSelect->DisperseMetaEmf(pos, pXyCurrent, timestamp);
}

extern "C" __declspec(dllexport)
int Select_PointCount(CSigmaView * pView)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == NULL)
		return -1;
	return itemSelect->PointCount();
}

extern "C" __declspec(dllexport)
void SelectChangeToLayer(CSigmaView * pView, LPCTSTR layerName)
{
	CItemSelect * itemSelect = GetItemSelectFromView(pView);
	if (itemSelect == nullptr)
	{
		return;
	}

	CXy* pXy = pView->m_pDoc->m_pXy;
	CLayer* pLayer = pXy->FindLayer(layerName);
	if (pLayer == nullptr)
	{
		return;
	}

	CPositionList& selection = itemSelect->m_selection;

	for (POSITION pos = selection.GetHeadPosition(); pos != nullptr; selection.GetNext(pos))
	{
		POSITION pt = selection.GetAt(pos);
		COne* pOne = (COne*)(pXy->GetAt(pt));
		pOne->SetLayer(pLayer);
	}
}

extern "C" __declspec(dllexport)
BOOL HasMeshState(CSigmaView * pView, POSITION oldMeshPos)
{
	CXy* pXyCurrent = pView->m_pDoc->GetDraw();
	if (oldMeshPos == nullptr)
	{
		oldMeshPos = pXyCurrent->FindFirstElement(DOUBLEFOX_MESH);
	}
	if (oldMeshPos == nullptr) {
		return false;
	}
	else
	{
		return true;
	}
}