#include "stdafx.h"
#include "globalFunc.h"
#include "TBlockEdJig.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBlockPreview::CBlockPreview(const TCHAR* szBlkName, XPoint pt, double nScaleX, double nScaleY, double dRadius)
{
    m_nSacle = nScaleX;
    m_nSacleY = nScaleY;
	m_dRadius = dRadius;
    m_csBlkName = szBlkName;
	m_ptIns = pt;
	m_pBlkRef = new AcDbBlockReference();
	AcDbBlockTable* pBlockTable;
	AcDbObjectId recordId;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
#if ARX > 24
	if(Acad::eOk == pBlockTable->getAt(szBlkName, recordId)){
#else
	if(Acad::eOk == pBlockTable->getAt(szBlkName, recordId, AcDb::kForRead)){
#endif
		m_pBlkRef->setBlockTableRecord(recordId);
		m_pBlkRef->setPosition(pt);
		m_pBlkRef->setScaleFactors(AcGeScale3d(m_nSacle, m_nSacleY, 1));
	}
    pBlockTable->close();
	
}

CBlockPreview::~CBlockPreview()
{
	if(m_pBlkRef)
		delete m_pBlkRef;
}

Adesk::Boolean CBlockPreview::subWorldDraw(AcGiWorldDraw *pWd)
{
	if(m_dRadius > 1)
	{
		AcDbCircle cir(m_ptIns, AcGeVector3d::kZAxis, m_dRadius);
		cir.worldDraw(pWd);
	}
	if(m_pBlkRef)
	{
		m_nRotate = g_Option::instance().g_nInsBlkRotate;
		m_pBlkRef->setRotation(GlobalFunc::Ucs2Wcs(m_nRotate));

		if(m_bReversal)
			m_pBlkRef->setScaleFactors(AcGeScale3d(-m_nSacle, m_nSacleY, 1));
		else
			m_pBlkRef->setScaleFactors(AcGeScale3d(m_nSacle, m_nSacleY, 1));
		
		m_pBlkRef->setPosition(m_ptIns);
		m_pBlkRef->worldDraw(pWd);
	}
	return Adesk::kTrue;
}
	

//******************************************************************************
//******************************************************************************
TBlockEdJig::TBlockEdJig(const TCHAR* szBlkName, XPoint pt, double nScale, bool bUpdatePScale)
{
	m_nSacle = nScale;
    m_nSacleY = nScale;
	m_pBlkRef = new AcDbBlockReference();
	m_csBlkName = szBlkName;
	AcDbBlockTable* pBlockTable;
	AcDbObjectId recordId;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
#if ARX > 24
	if(Acad::eOk == pBlockTable->getAt(szBlkName, recordId)){
#else
	if(Acad::eOk == pBlockTable->getAt(szBlkName, recordId, AcDb::kForRead)){
#endif
		m_pBlkRef->setBlockTableRecord(recordId);
		m_pBlkRef->setPosition(pt);
		m_pBlkRef->setScaleFactors(AcGeScale3d(m_nSacle, m_nSacle, 1));
	}
    pBlockTable->close();
	m_bInsCenPt = FALSE;
	m_bReversal = FALSE;
	m_bJigRotate = FALSE;
	m_iQuadrant = -1;
	m_bUpdatePScale = bUpdatePScale;
}

TBlockEdJig::TBlockEdJig(const TCHAR* szBlkName, XPoint pt, double nScaleX, double nScaleY, bool bUpdatePScale)
{
    m_nSacle = nScaleX;
    m_nSacleY = nScaleY;
    m_pBlkRef = new AcDbBlockReference();
    m_csBlkName = szBlkName;
    AcDbBlockTable* pBlockTable;
    AcDbObjectId recordId;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
#if ARX > 24
    if(Acad::eOk == pBlockTable->getAt(szBlkName, recordId)){
#else
    if(Acad::eOk == pBlockTable->getAt(szBlkName, recordId, AcDb::kForRead)){
#endif
        m_pBlkRef->setBlockTableRecord(recordId);
        m_pBlkRef->setPosition(pt);
        m_pBlkRef->setScaleFactors(AcGeScale3d(nScaleX, nScaleY, 1));
    }
    pBlockTable->close();
    m_bInsCenPt = FALSE;
    m_bReversal = FALSE;
    m_bJigRotate = FALSE;
    m_iQuadrant = -1;
	m_bUpdatePScale = bUpdatePScale;
}

TBlockEdJig::TBlockEdJig(const TCHAR* szBlkName, XPoint pt, double nScale, AcGeVector3d vectBase, double dDist, bool bUpdatePScale)
{
	m_iQuadrant = -1;
	m_nSacle = nScale;
    m_nSacleY = nScale;
    m_dDist = dDist;
	m_pBlkRef = new AcDbBlockReference();
	m_ptIns = pt;
	m_csBlkName = szBlkName;
	AcDbBlockTable* pBlockTable;
	AcDbObjectId recordId;
    acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
#if ARX > 24
	if(Acad::eOk == pBlockTable->getAt(szBlkName, recordId)){
#else
	if(Acad::eOk == pBlockTable->getAt(szBlkName, recordId, AcDb::kForRead)){
#endif
		m_pBlkRef->setBlockTableRecord(recordId);
		m_pBlkRef->setPosition(pt);
		m_pBlkRef->setScaleFactors(AcGeScale3d(m_nSacle, m_nSacle, 1));
	}
    pBlockTable->close();
	m_bInsCenPt = FALSE;
	m_bReversal = FALSE;
	m_bJigRotate = TRUE;
	m_vectBase = vectBase;
	m_vectBase.normalize();
	m_bUpdatePScale = bUpdatePScale;
}

TBlockEdJig::~TBlockEdJig()
{
	if(m_pBlkRef)
		delete m_pBlkRef;
}

 

AcEdJig::DragStatus 
TBlockEdJig::GetPoint(XPoint &pt)
{
	if(!m_ptRef)
		return acquirePoint(pt);
	else
		return acquirePoint(pt, m_ptRef);
}

 
void TBlockEdJig::SetUpdatePScale(bool bVal)
{
	m_bUpdatePScale = bVal;
}

int TBlockEdJig::DoIt(int *keyIndex)
{
    int nRet = TSymbEdJig::DoIt(keyIndex);
    return nRet;
}

// 更新实体数据
Adesk::Boolean TBlockEdJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
	if(g_Option::instance().g_csInsBlkName != m_csBlkName){
		m_csBlkName = g_Option::instance().g_csInsBlkName;
		AcDbBlockTable* pBlockTable;
		AcDbObjectId recordId;
		acdbCurDwg()->getBlockTable(pBlockTable, AcDb::kForRead);
	#if ARX > 24
		if(Acad::eOk == pBlockTable->getAt(m_csBlkName, recordId)){
	#else
		if(Acad::eOk == pBlockTable->getAt(m_csBlkName, recordId, AcDb::kForRead)){
	#endif
			m_pBlkRef->setBlockTableRecord(recordId);
		}
        pBlockTable->close();
	}
	m_nRotate = g_Option::instance().g_nInsBlkRotate;
	// cet 2017.9.28 add 图块随图纸比例变化
	double dScale = m_nSacle;
	double dScaleY = m_nSacleY;
	if (m_bUpdatePScale)
	{
		dScale *= GlobalFunc::DocGetPScale() / 100;
		dScaleY *= GlobalFunc::DocGetPScale() / 100;
	}
	if(m_bJigRotate){
		AcGeVector3d vectTmp(m_ptResult.x - m_ptIns.x, m_ptResult.y - m_ptIns.y, 0);
		vectTmp.normalize();
		double dAng = m_vectBase.angleTo(vectTmp, AcGeVector3d::kZAxis);
        AcGeVector3d vtRet = vectTmp.orthoProject(m_vectBase);
        vtRet.normalize();
        AcGePoint3d ptNewLoc = m_ptIns;
        ptNewLoc += vtRet*m_dDist;
        m_pBlkRef->setPosition(ptNewLoc);
        m_ptRetIns = ptNewLoc;
 
	 	if(dAng >= 0 && dAng < PI/2){
			m_iQuadrant = 0;
			m_pBlkRef->setRotation(m_nRotate);
			m_pBlkRef->setScaleFactors(AcGeScale3d(dScale, dScaleY, 1));
		} 
		else if(dAng >= PI/2 && dAng < PI){
			m_iQuadrant = 1;
		    m_pBlkRef->setRotation(m_nRotate);
			m_pBlkRef->setScaleFactors(AcGeScale3d(-dScale, dScaleY, 1));
		}
		else if(dAng >= PI && dAng < PI/2*3){
			m_iQuadrant = 2;
			m_pBlkRef->setScaleFactors(AcGeScale3d(dScale, dScaleY, 1));
			m_pBlkRef->setRotation(m_nRotate - PI);
		}
		else if(dAng >= PI/2*3 && dAng < PI*2){
			m_iQuadrant = 3;
			m_pBlkRef->setScaleFactors(AcGeScale3d(-dScale, dScaleY, 1));
			m_pBlkRef->setRotation(m_nRotate - PI);
		}
	}
	else{
		if(m_bReversal)
			m_pBlkRef->setScaleFactors(AcGeScale3d(-dScale, dScaleY, 1));
		else
			m_pBlkRef->setScaleFactors(AcGeScale3d(dScale, dScaleY, 1));
		if(m_bInsCenPt){
			m_pBlkRef->setPosition(m_ptResult);
			AcDbExtents extents;
			m_pBlkRef->getGeomExtents(extents);
			AcGePoint3d pMax = extents.maxPoint();
			AcGePoint3d pMin = extents.minPoint();
			XPoint ptCen;
			ptCen[0] = (pMax[0] + pMin[0]) / 2;
			ptCen[1] = (pMax[1] + pMin[1]) / 2;
			ptCen[2] = 0;
			m_mat.setToTranslation(AcGeVector3d(m_ptResult[0] - ptCen[0], m_ptResult[1] - ptCen[1], 0));
		}
		m_pBlkRef->setRotation(GlobalFunc::Ucs2Wcs(m_nRotate));
		m_ptIns = m_ptResult;
		m_ptIns.TransformBy(m_mat);
		m_pBlkRef->setPosition(m_ptIns);
	}

	return bRet;
}

AcDbEntity* TBlockEdJig::entity() const
{
	return (AcDbEntity *)m_pBlkRef;
}

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

 

TBlockExJig::TBlockExJig(const TCHAR* szBlkName, XPoint pt, double nScaleX, double nScaleY, double dRadius)
{
	m_pBlkRef = new CBlockPreview(szBlkName, pt, nScaleX, nScaleY, dRadius);
	
}
 
TBlockExJig::~TBlockExJig()
{
	if(m_pBlkRef)
		delete m_pBlkRef;
}

 

AcEdJig::DragStatus  TBlockExJig::GetPoint(XPoint &pt)
{
	if(!m_ptRef)
		return acquirePoint(pt);
	else
		return acquirePoint(pt, m_ptRef);
}

 
int TBlockExJig::DoIt(int *keyIndex)
{
    int nRet = TSymbEdJig::DoIt(keyIndex);
    return nRet;
}

// 更新实体数据
Adesk::Boolean TBlockExJig::update()
{
    Adesk::Boolean bRet=Adesk::kTrue;
	m_pBlkRef->m_ptIns = m_ptResult; 

	return bRet;
}

AcDbEntity* TBlockExJig::entity() const
{
	return (AcDbEntity *)m_pBlkRef;
}