#include "stdafx.h"
#include <set>
#include "DBReactorOfequmke.h"
#include "earthwormdef.h"

CEntityOverrule* CEntityOverrule::g_EntityOverrule = NULL;

namespace LayerTools
{
	bool createNewLayer(LPCTSTR layer)
	{
		if (!layer) return false;
		bool bRel(false);
		AcDbLayerTable *pLayerTbl(NULL);
		acdbCurDwg()->getLayerTable(pLayerTbl, AcDb::kForWrite);
		if (pLayerTbl)
		{
			if (!pLayerTbl->has(layer))
			{
				AcDbLayerTableRecord *pRec = new AcDbLayerTableRecord();
				if (pRec)
				{
					pRec->setName(layer);
					AcCmColor clr;
					clr.setColorIndex(1);
					pRec->setColor(clr);
					pLayerTbl->add(pRec);
					pRec->close();
				}
			}
			bRel = pLayerTbl->has(layer);
			pLayerTbl->close();
		}
		return bRel;
	}

	void deleteLayer(LPCTSTR layer)
	{
		if (!layer) return;
		AcDbLayerTable *pLayerTbl(NULL);
		acdbCurDwg()->getLayerTable(pLayerTbl, AcDb::kForWrite);
		if (pLayerTbl)
		{
			AcDbLayerTableRecord *pRec(NULL);
			if (pLayerTbl->getAt(layer, pRec, AcDb::kForWrite) == Acad::eOk)
			{
				pRec->erase();
				pRec->close();
			}
			pLayerTbl->close();
		}
	}

	void getAllLayers(std::set<CString> &layers)
	{
		AcDbLayerTable *pLayerTbl(NULL);
		acdbCurDwg()->getLayerTable(pLayerTbl, AcDb::kForRead);
		if (pLayerTbl)
		{
			AcDbLayerTableIterator *pItr(NULL);
			AcDbLayerTableRecord *pLayerTblRcd(NULL);
			pLayerTbl->newIterator(pItr);
			if (pItr)
			{
				for (pItr->start(); !pItr->done(); pItr->step())
				{
					if (pItr->getRecord(pLayerTblRcd, AcDb::kForRead) == Acad::eOk)
					{
						AcString layerName(_T(""));
						pLayerTblRcd->getName(layerName);
						layers.insert((LPCTSTR)layerName);
						pLayerTblRcd->close();
					}
				}
				DELETE_PTR(pItr);
			}
			pLayerTbl->close();
		}
	}

	void lockLayers(const std::set<CString> &layers, const bool &bLock)
	{
		AcDbLayerTable *pLayerTbl(NULL);
		acdbCurDwg()->getLayerTable(pLayerTbl, AcDb::kForWrite);
		if (pLayerTbl)
		{
			AcDbLayerTableRecord *pRec(NULL);
			std::set<CString>::const_iterator it(layers.begin());
			for (; it != layers.end(); ++it)
			{
				if (pLayerTbl->getAt(*it, pRec, AcDb::kForWrite) == Acad::eOk)
				{
					pRec->setIsLocked(bLock);
					pRec->close();
				}
			}
			pLayerTbl->close();
		}
	}

	bool setCLayer(LPCTSTR psz)
	{
		if (!psz) return false;
		AcDbLayerTable *pLayerTbl(NULL);
		acdbCurDwg()->getLayerTable(pLayerTbl, AcDb::kForRead);
		if (pLayerTbl)
		{
			AcDbObjectId id;
			if (pLayerTbl->getAt(psz, id) == Acad::eOk)
			{
				acdbCurDwg()->setClayer(id);
			}
			pLayerTbl->close();
		}
		return true;
	}
}

ACRX_NO_CONS_DEFINE_MEMBERS(CEntityOverrule, AcDbObjectOverrule);

CEntityOverrule::CEntityOverrule(const std::set<AcDbObjectId> &ids): m_pOwnerDb(NULL)
{
	m_pOwnerDb = acdbCurDwg();
	m_ids.clear();
	m_ids.insert(ids.begin(), ids.end());
}

inline CEntityOverrule::~CEntityOverrule()
{
	m_ids.clear();
}

ACDB_PORT Acad::ErrorStatus CEntityOverrule::erase(AcDbObject * pSubject, Adesk::Boolean erasing)
{
	if (erasing != Adesk::kTrue || acdbCurDwg() != m_pOwnerDb)
		return AcDbObjectOverrule::erase(pSubject, erasing);

	std::set<AcDbObjectId>::const_iterator it = m_ids.find(pSubject->objectId());
	if (it != m_ids.end())
		return Acad::eNotApplicable;

	return AcDbObjectOverrule::erase(pSubject, erasing);
}

void CEntityOverrule::addOverrule(const std::set<AcDbObjectId> &ids)
{
	if (!g_EntityOverrule)
		g_EntityOverrule = new CEntityOverrule(ids);

	AcRxOverrule::addOverrule(AcDbPolyline::desc(), g_EntityOverrule);
	AcRxOverrule::addOverrule(AcDbLine::desc(), g_EntityOverrule);
	AcRxOverrule::addOverrule(AcDbCircle::desc(), g_EntityOverrule);
	AcRxOverrule::addOverrule(AcDbRay::desc(), g_EntityOverrule);
	CEntityOverrule::setIsOverruling(true);
}

void CEntityOverrule::delOverrule()
{
	if (g_EntityOverrule)
	{
		AcRxOverrule::removeOverrule(AcDbPolyline::desc(), g_EntityOverrule);
		AcRxOverrule::removeOverrule(AcDbLine::desc(), g_EntityOverrule);
		AcRxOverrule::removeOverrule(AcDbRay::desc(), g_EntityOverrule);
		AcRxOverrule::removeOverrule(AcDbCircle::desc(), g_EntityOverrule);
		CEntityOverrule::setIsOverruling(false);
		DELETE_PTR(g_EntityOverrule);
	}
}

void CEntityOverrule::getBindIds(std::set<AcDbObjectId>& ids)
{
	if (g_EntityOverrule)
	{
		g_EntityOverrule->getOverruleIds(ids);
	}
}