boss-data/src/SelectTarget.cpp

// ************************************************************************** //
// SelectTarget.cpp : implementation of the CSelectTarget class
// Copyright(c)2010 Naiky Company. All rights reserved.
//
// Abstract:
//   ���ļ���ʵ����CSelectTarget�࣬ͼ�ε�ѡ���ܡ�
// 
// ********************  Version 1  *******************
// [ά����Ա]: ��§            [ά������]: 2010-05-20
// [ά������]: �������档
// ************************************************************************** //

#include "stdafx.h"
#include "SelectTarget.h"

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

// ����ͼ���ж�ʱֻ��ȷ��С�������λ�� ---- �ƺ��� 2016-01-07
#define DOUBLE_ROUGHEQU(nX_, nY_) ncmath::IsEqual(nX_, nY_, 1e-3)

using namespace nce;
using namespace ncmath;

CS_T s_szLAYERN = _DEFCS(_CSV(17152),
	_CHINESE("ͼ��%d")
	_ENGLISH("Layer %d"));
CS_T s_szTITLE = _DEFCS(_CSV(17160),
	_CHINESE("ѡ��Сͼ��")
	_ENGLISH("Select Tiny"));
CS_T s_szSELECT_X = _DEFCS(_CSV(17161),
	_CHINESE("X�ߴ�С��")
	_ENGLISH("X less than"));
CS_T s_szSELECT_Y = _DEFCS(_CSV(17162),
	_CHINESE("Y�ߴ�С��")
	_ENGLISH("Y less than"));
CS_T s_szOK = _DEFCS(_CSV(17163),
	_CHINESE("ȷ��")
	_ENGLISH("OK"));
CS_T s_szCANCEL = _DEFCS(_CSV(17164),
	_CHINESE("ȡ��")
	_ENGLISH("Cancel"));

////////////////////////////////////////////////////////////////////////////////
// ѡ��Сͼ�εĶԻ��� ---- ��� 2015-11-29
// 
class CSelectTinyDlg : public CDialog
{
	DECLARE_DYNAMIC(CSelectTinyDlg)

public:
	CSelectTinyDlg(CWnd* pParent_ = NULL);
	virtual ~CSelectTinyDlg();

	GUARD_BEGIN(CSelectTinyDlg);
	double m_nWidth;
	double m_nHeight;
	GUARD_END(CSelectTinyDlg);

protected:
	virtual void DoDataExchange(CDataExchange* pDX_);
	virtual BOOL OnInitDialog();
};

IMPLEMENT_DYNAMIC(CSelectTinyDlg, CDialog)

CSelectTinyDlg::CSelectTinyDlg(CWnd* pParent_/* = NULL*/)
: CDialog(IDD_DLG_SELECTTINY, pParent_)
{
	m_nWidth = 1.0;
	m_nHeight = 1.0;
	LOAD_PARAM(this, CSelectTinyDlg);
}

CSelectTinyDlg::~CSelectTinyDlg()
{
	SAVE_PARAM(this, CSelectTinyDlg);
}

void CSelectTinyDlg::DoDataExchange(CDataExchange* pDX_)
{
	CDialog::DoDataExchange(pDX_);

	DDX_Text(pDX_, IDC_EDT_SELECTTINY_X, m_nWidth);
	DDV_MinMaxDouble(pDX_, m_nWidth, 0.1, 100.0);
	DDX_Text(pDX_, IDC_EDT_SELECTTINY_Y, m_nHeight);
	DDV_MinMaxDouble(pDX_, m_nHeight, 0.1, 100.0);
}

BOOL CSelectTinyDlg::OnInitDialog()
{
	if (!__super::OnInitDialog())
		return FALSE;

	// Ϊ�Ի�������Ӣ�Ľ��� ---- �߿�ϼ 2016-01-25
	SetWindowText(_GETCS(s_szTITLE));
	SetDlgItemText(IDC_STC_SELECTTINY_X, _GETCS(s_szSELECT_X));
	SetDlgItemText(IDC_STC_SELECTTINY_Y, _GETCS(s_szSELECT_Y));
	SetDlgItemText(IDOK, _GETCS(s_szOK));
	SetDlgItemText(IDCANCEL, _GETCS(s_szCANCEL));

	return TRUE;
}

////////////////////////////////////////////////////////////////////////////////
// Local function declarations
// 
// ����һ�������Ĺ۲촰����������һ��CAD���󻮷�Ϊ�����������֣����ֵ��жϰ취��
// ��������Ӿ��Σ�Ȼ������Ӿ��εİ������ཻ��ϵ���жϡ�
//   FullInside : ������ȫ�ڹ۲촰��
//   PartInside : ���󲿷��ڹ۲촰��
//   NotInside  : ������ȫ���ڹ۲촰��
// �۲촰ViewPortӦΪ��Ч������λ�õ�ӦΪ��Ч������ӦΪ�Ǹ�����������OUT��ָ���
// ����ΪNULL��ΪNULLʱ��ʾ����Ҫ�ռ���һ���ֵĶ���     ---- ��� 2011-07-16
static void _DivideObjectsIntoThree(const CadObjectList* plistSource_, const DRECT& rcViewport_,
	CadObjectList* plistFullInside_, CadObjectList* plistPartInside_, CadObjectList* plistNotInside_);

////////////////////////////////////////////////////////////////////////////////
// CSelectTarget ---- ��� 2011-07-16
// 
CSelectTarget* CSelectTarget::ms_pSelectTarget = NULL;

CSelectTarget* GetSelectTarget()
{
	return CSelectTarget::ms_pSelectTarget;
}

IMPLEMENT_DYNAMIC(CSelectTarget, CMouseMsgTarget)
BEGIN_MESSAGE_MAP(CSelectTarget, CMouseMsgTarget)
	ON_COMMAND(IDCMD_SELECTTARGET_SELECT, OnSelect)
	ON_UPDATE_COMMAND_UI(IDCMD_SELECTTARGET_SELECT, OnUpdateSelect)
	ON_COMMAND(IDCMD_SELECTTARGET_SELECTALL, OnSelectAll)
	ON_UPDATE_COMMAND_UI(IDCMD_SELECTTARGET_SELECTALL, OnUpdateSelectAll)
	ON_COMMAND(IDCMD_SELECTTARGET_SELECTUNCLOSE, OnSelectUnclose)
	ON_UPDATE_COMMAND_UI(IDCMD_SELECTTARGET_SELECTUNCLOSE, OnUpdateSelectUnclose)
	ON_COMMAND(IDCMD_SELECTTARGET_SELECTTINY, OnSelectTiny)
	ON_UPDATE_COMMAND_UI(IDCMD_SELECTTARGET_SELECTTINY, OnUpdateSelectTiny)
	ON_COMMAND_RANGE(IDCMD_SELECTTARGET_SELECTBYCOLOR0, IDCMD_SELECTTARGET_SELECTBYCOLOR7, OnSelectByColor)
	ON_UPDATE_COMMAND_UI_RANGE(IDCMD_SELECTTARGET_SELECTBYCOLOR0, IDCMD_SELECTTARGET_SELECTBYCOLOR7, OnUpdateSelectByColor)
	ON_COMMAND_RANGE(IDCMD_SELECTTARGET_SELECTBYTYPE0, IDCMD_SELECTTARGET_SELECTBYTYPE15, OnSelectByType)
	ON_UPDATE_COMMAND_UI_RANGE(IDCMD_SELECTTARGET_SELECTBYTYPE0, IDCMD_SELECTTARGET_SELECTBYTYPE15, OnUpdateSelectByType)
	ON_COMMAND(IDCMD_SELECTTARGET_SELECTREV, OnSelectRev)
	ON_UPDATE_COMMAND_UI(IDCMD_SELECTTARGET_SELECTREV, OnUpdateSelectRev)
	ON_COMMAND(IDCMD_SELECTTARGET_CLEARSELECT, OnClearSelect)
	ON_UPDATE_COMMAND_UI(IDCMD_SELECTTARGET_CLEARSELECT, OnUpdateClearSelect)
	ON_TARGET_MESSAGE(TM_SELECT_SELECTALL, SelectAll)
	ON_TARGET_MESSAGE(TM_SELECT_SELECTBYCOLORE, SelectByColore)
	ON_COMMAND(IDCMD_SELECTTARGET_SELECTSIMILAR, OnSelectSimilar)
	ON_UPDATE_COMMAND_UI(IDCMD_SELECTTARGET_SELECTSIMILAR, OnUpdateSelectSimilar)
END_MESSAGE_MAP()

CSelectTarget::CSelectTarget(CNceDC* pNceDC_)
{
	ASSERT(ms_pSelectTarget == NULL);
	ms_pSelectTarget = this;

	m_pFileTarget = NULL;
	m_pNceDC = pNceDC_;
	m_nSeleToleranceDP = 6;
	m_ptLButtonDown = DPOINT2(c_nINVALID_DOUBLE, c_nINVALID_DOUBLE);
	m_ptTemp = DPOINT2(c_nINVALID_DOUBLE, c_nINVALID_DOUBLE);
	m_rcSelObjsBoundRect = DRECT(c_nINVALID_DOUBLE, c_nINVALID_DOUBLE, c_nINVALID_DOUBLE, c_nINVALID_DOUBLE);

	// �Ҽ��˵� ---- ��� 2010-08-16
	m_pRButtonMenu_NoneSelected = NULL;
	m_pRButtonMenu_SingleSelected = NULL;
	m_pRButtonMenu_MultiSelected = NULL;

	m_hCursor = AfxGetApp()->LoadCursor(IDC_CUR_SELECT);
}

CSelectTarget::~CSelectTarget()
{
	ASSERT(ms_pSelectTarget == this);
	ms_pSelectTarget = NULL;
}

void CSelectTarget::Initialize()
{
	__super::Initialize();

	m_pFileTarget = GetFileTarget();
	ASSERT(m_pFileTarget);

	// ��ѡ��Target���������Ϣ������������󣬼����е�Target��������ʱ���ж�ѡ��Target�Ƿ���
	// Wanglou 2010-06-13
	MouseMsgTargetList* _pMsgTargetList = GetMouseMsgTargetList();
	_pMsgTargetList->remove(this);
	_pMsgTargetList->push_back(this);
}

// ������ػ��棬����ѡ�ж���������ѡ�вο���������ѡ�ж�����Ӿ��εȡ� ---- ��� 2011-06-10
BOOL CSelectTarget::Update(UINT nSenderID_, WPARAM nHint_, LPARAM pObject_)
{
	GetSelectedCadObjects(true);
	GetSelectedRefLines(true);
	GetSelObjsBoundRect(true);

	// ����������Ϣ���� ---- ��� 2015-11-29
	m_nCloseCount = 0;
	m_nUncloseCount = 0;
	m_nColorMask = 0;
	m_nTypeMask = 0;
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	ASSERT(_pCadGroup);
	int _nCount = _pCadGroup->GetNumOfChild();
	for (int _i = 0; _i < _nCount; _i++)
	{
		CCadObject* _pCad = _pCadGroup->GetAt(_i);
		ASSERT(_pCad);
		if (_pCad->IsClose())
			m_nCloseCount++;
		else
			m_nUncloseCount++;

		m_nColorMask |= (1 << _pCad->GetParamIndex());

		if (_pCad->GetType() == caddot)			m_nTypeMask |= 0x0001;
		if (_pCad->GetType() == cadline)		m_nTypeMask |= 0x0002;
		if (_pCad->GetType() == cadbeeline)		m_nTypeMask |= 0x0004;
		if (_pCad->GetType() == cadcircle)		m_nTypeMask |= 0x0008;
		if (_pCad->GetType() == cadarc)			m_nTypeMask |= 0x0010;
		if (_pCad->GetType() == cadellipse)		m_nTypeMask |= 0x0020;
		if (_pCad->GetType() == cadellipsearc)	m_nTypeMask |= 0x0040;
		if (_pCad->GetType() == cadrectangle)	m_nTypeMask |= 0x0100;
		if (_pCad->GetType() == cadpolygon)		m_nTypeMask |= 0x0200;
		if (_pCad->GetType() == cadstar)		m_nTypeMask |= 0x0400;
		if (_pCad->GetType() == cadpolyline)	m_nTypeMask |= 0x0800;
		if (_pCad->GetType() == cadgroup)		m_nTypeMask |= 0x2000;
		if (_pCad->GetType() == cadtext)		m_nTypeMask |= 0x4000;
	}

	return TRUE;
}

void CSelectTarget::Activate()
{
	// Base class first ---- ��� 2010-07-14
	__super::Activate();

	// ����ѡ��ģʽ�����������ģʽ ---- ��� 2010-05-28
	while (!ms_stackPreMouseMsgTargets.empty())
		ms_stackPreMouseMsgTargets.pop();
}

void CSelectTarget::OnSelect()
{
	Activate();
}

void CSelectTarget::OnUpdateSelect(CCmdUI *pCmdUI_)
{
	if (IsActive() || GetActiveTarget() == NULL)
		pCmdUI_->SetCheck(TRUE);
	else
		pCmdUI_->SetCheck(FALSE);
}

void CSelectTarget::OnSelectAll()
{
	// ���������������������ѡ���� ---- ��� 2010-07-17
	if (!IsActive() && GetActiveTarget() != NULL)
		return;

	SelectAll();
	UpdateAllVisions();
}

void CSelectTarget::OnUpdateSelectAll(CCmdUI* pCmdUI_)
{
	// ���������������������ѡ���� ---- ��� 2010-07-17
	if (!IsActive() && GetActiveTarget() != NULL)
	{
		pCmdUI_->Enable(FALSE);
		return;
	}

	pCmdUI_->Enable((m_nCloseCount + m_nUncloseCount) > 0);
}

void CSelectTarget::OnSelectRev()
{
	// ���������������������ѡ���� ---- ��� 2010-07-17
	if (!IsActive() && GetActiveTarget() != NULL)
		return;

	SelectRev();
	UpdateAllVisions();
}

void CSelectTarget::OnUpdateSelectRev(CCmdUI* pCmdUI_)
{
	// ���������������������ѡ���� ---- ��� 2010-07-17
	if (!IsActive() && GetActiveTarget() != NULL)
	{
		pCmdUI_->Enable(FALSE);
		return;
	}

	pCmdUI_->Enable((m_nCloseCount + m_nUncloseCount) > 0);
}

void CSelectTarget::OnClearSelect()
{
	// ���������������������ѡ���� ---- ��� 2010-07-17
	if (!IsActive() && GetActiveTarget() != NULL)
		return;

	ClearSelect();
	UpdateAllVisions();
}

void CSelectTarget::OnUpdateClearSelect(CCmdUI* pCmdUI_)
{
	// ���������������������ѡ���� ---- ��� 2010-07-17
	if (!IsActive() && GetActiveTarget() != NULL)
	{
		pCmdUI_->Enable(FALSE);
		return;
	}

	pCmdUI_->Enable(m_listSelectedCadObjects.size() > 0 || GetSelectedRefLines()->size() > 0);
}

void CSelectTarget::OnSelectUnclose()
{
	if (!IsActive() && GetActiveTarget() != NULL)
		return;

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCad = _pCadGroup->GetAt(_i);
		ASSERT(_pCad);
		_pCad->Select(_pCad->GetType() != cadgroup && !_pCad->IsClose());
	}

	GetSelectedCadObjects(true);
	UpdateAllVisions();
}

void CSelectTarget::OnUpdateSelectUnclose(CCmdUI* pCmdUI_)
{
	if (!IsActive() && GetActiveTarget() != NULL)
	{
		pCmdUI_->Enable(FALSE);
		return;
	}

	pCmdUI_->Enable(m_nUncloseCount > 0);
}

void CSelectTarget::OnSelectTiny()
{
	if (!IsActive() && GetActiveTarget() != NULL)
		return;

	// Ҫ�����Ի�����ߴ� ---- ��� 2015-11-29
	CSelectTinyDlg _dlg;
	if (_dlg.DoModal() != IDOK)
		return;

	double _nWidth = max(0.1, _dlg.m_nWidth);
	double _nHeight = max(0.1, _dlg.m_nHeight);
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCad = _pCadGroup->GetAt(_i);
		ASSERT(_pCad);
		DRECT _rc = _pCad->GetBoundRect();
		_pCad->Select(DOUBLE_LESS(_rc.width, _nWidth) && DOUBLE_LESS(_rc.height, _nHeight));
	}

	GetSelectedCadObjects(true);
	UpdateAllVisions();
}

void CSelectTarget::OnUpdateSelectTiny(CCmdUI* pCmdUI_)
{
	if (!IsActive() && GetActiveTarget() != NULL)
	{
		pCmdUI_->Enable(FALSE);
		return;
	}

	pCmdUI_->Enable((m_nCloseCount + m_nUncloseCount) > 0);
}

void CSelectTarget:: OnSelectByColor(UINT nID_)
{
	if (!IsActive() && GetActiveTarget() != NULL)
		return;

	// Ҫѡ��ڼ���ͼ�㣬Base0 ---- ��� 2015-11-29
	int _nParamIndex = nID_ - IDCMD_SELECTTARGET_SELECTBYCOLOR0;

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCad = _pCadGroup->GetAt(_i);
		ASSERT(_pCad);
		_pCad->Select(_pCad->GetParamIndex() == _nParamIndex);
	}

	GetSelectedCadObjects(true);
	UpdateAllVisions();
}

void CSelectTarget::OnUpdateSelectByColor(CCmdUI* pCmdUI_)
{
	// ����POPUP�˵� ---- ��� 2015-11-29
	if (pCmdUI_->m_pSubMenu != NULL)
	{
		bool _bEnable = (IsActive() || GetActiveTarget() == NULL) && m_nColorMask != 0;
		pCmdUI_->m_pMenu->EnableMenuItem(pCmdUI_->m_nIndex, MF_BYPOSITION | (_bEnable ? MF_ENABLED : MF_GRAYED));
		return;
	}

	if (m_nColorMask == 0)
	{
		return;
	}

	// �����Ӳ˵�ʱ��ʾ��ǰ����Щ��ɫ��ͼ�� ---- ��� 2015-11-29
	CMenu* pMenu_ = pCmdUI_->m_pMenu;
	if (pMenu_ == NULL || pCmdUI_->m_nIndex != 0)
	{
		return;
	}

	for (int _i = 0; _i < 8; _i++)
	{
		pMenu_->DeleteMenu(IDCMD_SELECTTARGET_SELECTBYCOLOR0 + _i, MF_BYCOMMAND);
	}

	for (int _i = 0; _i < 8; _i++)
	{
		if (!(m_nColorMask & (1 << _i)))
			continue;

		CString _strName;
		_strName.Format(_GETCS(s_szLAYERN), _i + 1);
		pMenu_->InsertMenu(pCmdUI_->m_nIndex++, MF_STRING | MF_BYPOSITION, IDCMD_SELECTTARGET_SELECTBYCOLOR0 + _i, _strName);
	}

	// update end menu count
	pCmdUI_->m_nIndex--; // point to last menu added
	pCmdUI_->m_nIndexMax = pMenu_->GetMenuItemCount();

	pCmdUI_->m_bEnableChanged = TRUE;    // all the added items are enabled
}

void CSelectTarget::OnSelectByType(UINT nID_)
{
	if (!IsActive() && GetActiveTarget() != NULL)
		return;

	// Ҫѡ���������͵� ---- ��� 2015-11-29
	cad_t _nType = cadobject;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 0)	_nType = caddot;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 1)	_nType = cadline;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 2)	_nType = cadbeeline;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 3)	_nType = cadcircle;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 4)	_nType = cadarc;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 5)	_nType = cadellipse;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 6)	_nType = cadellipsearc;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 8)	_nType = cadrectangle;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 9)	_nType = cadpolygon;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 10)	_nType = cadstar;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 11)	_nType = cadpolyline;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 13)	_nType = cadgroup;
	if (nID_ == IDCMD_SELECTTARGET_SELECTBYTYPE0 + 14)	_nType = cadtext;

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCad = _pCadGroup->GetAt(_i);
		ASSERT(_pCad);
		_pCad->Select(_pCad->GetType() == _nType);
	}

	GetSelectedCadObjects(true);
	UpdateAllVisions();
}

void CSelectTarget:: OnUpdateSelectByType(CCmdUI* pCmdUI_)
{
	// ����POPUP�˵� ---- ��� 2015-11-29
	if (pCmdUI_->m_pSubMenu != NULL)
	{
		bool _bEnable = (IsActive() || GetActiveTarget() == NULL) && m_nTypeMask != 0;
		pCmdUI_->m_pMenu->EnableMenuItem(pCmdUI_->m_nIndex, MF_BYPOSITION | (_bEnable ? MF_ENABLED : MF_GRAYED));
		return;
	}

	if (m_nTypeMask == 0)
	{
		return;
	}

	// �����Ӳ˵�ʱ��ʾ��ǰ����Щ��ɫ��ͼ�� ---- ��� 2015-11-29
	CMenu* pMenu_ = pCmdUI_->m_pMenu;
	if (pMenu_ == NULL || pCmdUI_->m_nIndex != 0)
	{
		return;
	}

	for (int _i = 0; _i < 15; _i++)
	{
		pMenu_->DeleteMenu(IDCMD_SELECTTARGET_SELECTBYTYPE0 + _i, MF_BYCOMMAND);
	}

	static const CString c_sstrNames[] =
	{
		CCadDot().GetName(),
		CCadLine().GetName(),
		CCadBeeline().GetName(),
		CCadCircle().GetName(),
		CCadArc().GetName(),
		CCadEllipse().GetName(),
		CCadEllipseArc().GetName(),
		_T("CadMmultiSegments"),
		CCadRectangle().GetName(),
		CCadPolygon().GetName(),
		CCadStar().GetName(),
		CCadPolyline().GetName(),
		_T("CadPath"),
		CCadGroup().GetName(),
		CCadText().GetName(),
		_T("CadBmp"),
	};
	for (int _i = 0; _i < 15; _i++)
	{
		if (!(m_nTypeMask & (1 << _i)))
			continue;

		CString _strName = c_sstrNames[_i];
		pMenu_->InsertMenu(pCmdUI_->m_nIndex++, MF_STRING | MF_BYPOSITION, IDCMD_SELECTTARGET_SELECTBYTYPE0 + _i, _strName);
	}

	// update end menu count
	pCmdUI_->m_nIndex--; // point to last menu added
	pCmdUI_->m_nIndexMax = pMenu_->GetMenuItemCount();

	pCmdUI_->m_bEnableChanged = TRUE;    // all the added items are enabled
}

// ���������µ���Ӧ���� Wanglou 2010-06-13
BOOL CSelectTarget::OnLButtonDown(UINT nFlags_, DPOINT2 point_)
{
	if (!IsActive() && GetActiveTarget() != NULL)
		return FALSE;

	if (IsInvalidDouble(m_ptLButtonDown.x) || IsInvalidDouble(m_ptLButtonDown.y))
		m_ptLButtonDown = point_;
	return TRUE;
}

// ��������������Ӧ���� Wanglou 2010-06-13
BOOL CSelectTarget::OnLButtonUp(UINT nFlags_, DPOINT2 point_)
{
	if (!IsActive() && GetActiveTarget() != NULL)
		return FALSE;

	if (IsInvalidDouble(m_ptLButtonDown.x) || IsInvalidDouble(m_ptLButtonDown.y))
		return FALSE;

	CadObjectList _listSelectedCads = *GetSelectedCadObjects();
	CadObjectList _listSelectedRefs = *GetSelectedRefLines();

	// �ſ���������ж����������º͵���ĵط����Բ���ͬһ���㣬�������㹻����
	// ���º͵��𴦵ľ��벻������ѡ�ݲ��1/2����Ϊ�ǵ��������Ϊ�ǵ�ѡ��������
	// Ϊ��ѡ��                                         ---- ��� 2011-07-16
	double _nTolerance = GetSelectToleranceLP();
	if (abs(m_ptLButtonDown.x - point_.x) <= _nTolerance / 2.
		&& abs(m_ptLButtonDown.y - point_.y) <= _nTolerance / 2.)
	{
		SelectByPoint(nFlags_, point_, _nTolerance);
	}
	else
	{
		SelectByRect(nFlags_, m_ptLButtonDown, point_);
	}

	// ������Ϣ��������Targetѡ��Ķ������˸ı� Wanglou 2010-06-13
	//SendTargetMessage(ID_TARGET_BROADCAST, TN_SELECT_CHANGE, (WPARAM)GetSelectedCadObjects());//&m_listSelectedCadObjects);
	Reset();

	bool _bChanged = _listSelectedCads != *GetSelectedCadObjects() || _listSelectedRefs != *GetSelectedRefLines();
	if (_bChanged)
	{
		// ��Ϊ�仯������ ---- ���� 2013.06.17
		UpdateAllVisions();
	}
	else
	{
		// û�б仯ҲҪ�����Լ�(����ѡ���) ---- ���� 2013.06.17
		UpdateVisions();
	}
	return TRUE;
}

BOOL CSelectTarget::OnRButtonUp(UINT nFlags_, DPOINT2 point_)
{
	if (!IsActive() && GetActiveTarget() != NULL)
		return FALSE;

	if (IsValidDouble(m_ptLButtonDown.x) || IsValidDouble(m_ptLButtonDown.y))
	{
		Reset();
		UpdateVisions();
	}
	else
	{
		// �����λ��(Screen����) ---- ��� 2010-08-16
		ASSERT(m_pNceDC);
		CPoint _ptPos = m_pNceDC->LPtoDP_Point(point_);
		CWnd* _pWnd = m_pNceDC->GetWindow();
		ASSERT(_pWnd);
		_pWnd->ClientToScreen(&_ptPos);

		// �����Ҽ��˵� ---- ��� 2010-08-16
		// ����ѡ�вο���ʱ���Ҽ��˵�-------liangyan 2013-10-23
		if (m_listSelectedCadObjects.size() == 0 && m_pRButtonMenu_NoneSelected && m_listSelectedRefLines.size() == 0)
			m_pRButtonMenu_NoneSelected->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON , _ptPos.x, _ptPos.y, AfxGetMainWnd());
		else if (m_listSelectedCadObjects.size() == 1 && m_pRButtonMenu_SingleSelected)
			m_pRButtonMenu_SingleSelected->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON , _ptPos.x, _ptPos.y, AfxGetMainWnd());
		else if (m_pRButtonMenu_MultiSelected || m_listSelectedRefLines.size() != 0)
			m_pRButtonMenu_MultiSelected->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON , _ptPos.x, _ptPos.y, AfxGetMainWnd());
	}

	return TRUE;
}

BOOL CSelectTarget::OnMouseMove(UINT nFlags_, DPOINT2 point_)
{
	if (!IsActive() && GetActiveTarget() != NULL)
		return FALSE;

	if (IsInvalidDouble(m_ptLButtonDown.x) || IsInvalidDouble(m_ptLButtonDown.y))
		return FALSE;

	m_ptTemp = point_;
	UpdateVisions();
	return TRUE;
}

BOOL CSelectTarget::OnKeyDown(UINT nChar_, UINT nRepCnt_, UINT nFlags_)
{
	if (nChar_ == VK_ESCAPE && (IsActive() || GetActiveTarget() == NULL))
	{
		// Esc���ѡ�� ---- ���崺 2012-5-27
		ClearSelect();
		UpdateAllVisions();
		return TRUE;
	}

	return FALSE;
}

// ��ѡ����ʵ��: ���ȿ���ѡ��ο��ߣ��������ѡ��ο��������ctrl��shift����״̬
// ����Ϊ��ͨ����ѡ����ѡ����ѡ��
//   ��ѡֻ����һ��ͼ�Σ��㵽����1�����㲻������0����     ---- ��� 2011-07-16
// �ο���Ҳ����ctrl��shift����״̬ ����Ϊ��ͨ����ѡ����ѡ����ѡ-----liangyan 2013-10-19
BOOL CSelectTarget::SelectByPoint(UINT nFlags_, const DPOINT2& point_, double nTolerance_)
{
	bool _bCtrlKeyDown = (nFlags_ & MK_CONTROL) != 0;
	bool _bShiftKeyDown = (nFlags_ & MK_SHIFT) != 0;
	BOOL _nRet = FALSE;

	// ���ֵ�ѡģʽ ---- ��� 2011-07-16
	if (!_bCtrlKeyDown && !_bShiftKeyDown)
	{
		if (SelectRefLine(point_, nTolerance_))
			_nRet = TRUE;
		else
			_nRet = _SelectByPoint_Normal(point_, nTolerance_);
	}
	else if (_bCtrlKeyDown && !_bShiftKeyDown)
	{
		_nRet = _SelectByPoint_Increase(point_, nTolerance_);
	}
	else if (!_bCtrlKeyDown && _bShiftKeyDown)
	{
		_nRet = _SelectByPoint_Decrease(point_, nTolerance_);
	}
	else
	{
		ASSERT(_bCtrlKeyDown && _bShiftKeyDown);
		_nRet = _SelectByPoint_Reverse(point_, nTolerance_);
	}

	// ����ѡ�ж������� ---- ��� 2011-07-16
	GetSelectedCadObjects(true);
	GetSelectedRefLines(true);
	return _nRet;
}

// ��ѡ--��ͨģʽ�� ���㵽����ѡ�е㵽��ͼ�Σ�������ȥѡ�У����㲻���������о�ȥ
// ѡ�С�
//   �����õ�ѡ������͵�ѡ�ݲ��һ���۲촰���Σ�Ȼ����ݸ�ͼ��������۲촰��
// �������ཻ�����ϵ������ͼ�ν��з��࣬�����ཻ��ͼ�����ȫ�����Լ�������ͼ��
// ������ɸ���                                           ---- ��� 2011-07-16
BOOL CSelectTarget::_SelectByPoint_Normal(const DPOINT2& point_, double nTolerance_)
{
	ASSERT(nTolerance_ >= 0.);
	ASSERT(m_pFileTarget);

	// ����۲촰���β����� ---- ��� 2011-07-16
	DRECT _rcViewport(point_.x - nTolerance_, point_.y - nTolerance_,
		2. * nTolerance_, 2. * nTolerance_);
	const CadObjectList* _plistCurrentGroup = m_pFileTarget->GetCurrentCadGroup()->GetObjectsList();
	ASSERT(_plistCurrentGroup);
	CadObjectList _listFullInside;
	CadObjectList _listPartInside;
	_DivideObjectsIntoThree(_plistCurrentGroup, _rcViewport, &_listFullInside, &_listPartInside, NULL);

	// �ռ����ǵ�ͼ�μ� ---- ��� 2011-07-16
	CadObjectList _listTarget;
	const int _c_nMaxCount = 10;	// ��࿼��FullInside�����е�N��
	int _nCurCount = 0;
	for (CadObjectList::iterator _it = _listFullInside.begin(); _it != _listFullInside.end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		_listTarget.push_back(_pCad);
		_nCurCount++;

		if (_nCurCount >= _c_nMaxCount)
		{
			break;
		}
	}
	for (CadObjectList::iterator _it = _listPartInside.begin(); _it != _listPartInside.end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		_listTarget.push_back(_pCad);
	}

	// ���в��� ---- ��� 2011-07-16
	CCadObject* _pCadSelected = nce::Hit(&_listTarget, point_, nTolerance_, NULL);

	// Carry out ������ ---- ��� 2011-07-16
	for (CadObjectList::const_iterator _it = _plistCurrentGroup->begin(); _it != _plistCurrentGroup->end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		_pCad->Select(false);
	}

	if (_pCadSelected)
	{
		_pCadSelected->Select(true);
	}

	return (_pCadSelected != NULL);
}

// ��ѡ--��ѡģʽ�� ���㵽����ѡ�е㵽��ͼ�Σ����㲻��������������
//   ��Ϊ�Ǽ�ѡ�����뿼�ǵ�ǰδѡ�е�ͼ�Σ���ѡ�е�ͼ�β����ǣ�ͬǰ�����õ�ѡ��
// ����͵�ѡ�ݲ��һ���۲촰���Σ�Ȼ����ݸ�ͼ��������۲촰�İ������ཻ����
// ��ϵ��δѡ��ͼ�ν��з��࣬�����ཻ��ͼ�����ȫ�����Լ�������ͼ��������ɸ���
//                                                       ---- ��� 2011-07-16
BOOL CSelectTarget::_SelectByPoint_Increase(const DPOINT2& point_, double nTolerance_)
{
	ASSERT(nTolerance_ >= 0.);
	ASSERT(m_pFileTarget);

	// ����۲촰���β����� ---- ��� 2011-07-16
	DRECT _rcViewport(point_.x - nTolerance_, point_.y - nTolerance_,
		2. * nTolerance_, 2. * nTolerance_);
	const CadObjectList* _plistCurrentGroup = m_pFileTarget->GetCurrentCadGroup()->GetObjectsList();
	CCadGroup* _pRefLines = m_pFileTarget->GetCurrentRefLines();
	ASSERT(_plistCurrentGroup || _pRefLines);;
	CadObjectList _listFullInside;
	CadObjectList _listPartInside;
	_DivideObjectsIntoThree(_plistCurrentGroup, _rcViewport, &_listFullInside, &_listPartInside, NULL);

	// �ռ����ǵ�ͼ�μ� ---- ��� 2011-07-16
	CadObjectList _listTarget;
	const int _c_nMaxCount = 10;	// ��࿼��FullInside�����е�N��
	int _nCurCount = 0;
	for (CadObjectList::iterator _it = _listFullInside.begin(); _it != _listFullInside.end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		if (_pCad->IsSelected())
		{
			continue;
		}

		_listTarget.push_back(_pCad);
		_nCurCount++;

		if (_nCurCount >= _c_nMaxCount)
		{
			break;
		}
	}
	for (CadObjectList::iterator _it = _listPartInside.begin(); _it != _listPartInside.end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		if (!_pCad->IsSelected())
		{
			_listTarget.push_back(_pCad);
		}
	}
	// ���в��� ---- ��� 2011-07-16
	CCadObject* _pCadSelected = nce::Hit(&_listTarget, point_, nTolerance_, NULL);
	CCadObject* _pRefLinesSelected = Hit(_pRefLines, point_, nTolerance_);
	// ��ѡʱ��Cad����Ͳο��߲���ͬʱѡ�У��������Cad������Ӧ��������вο��ߵ�ѡ��״̬��
	// ����ο������У���Ӧ�������Cad�����ѡ��״̬-----liangyan 2013-10-19
	int _nCount = _pRefLines->GetNumOfChild();
	if (_pCadSelected)
	{
		for (int _i = 0; _i < _nCount; _i++)
			_pRefLines->GetAt(_i)->Select(false);
		_pCadSelected->Select(true);
	}
	if(_pRefLinesSelected)
	{
		for (CadObjectList::const_iterator _iter = _plistCurrentGroup->begin(); _iter != _plistCurrentGroup->end(); _iter++)
		{
			if ((*_iter)->IsSelected())
				(*_iter)->Select(false);
		}
		_pRefLinesSelected->Select(true);
	}
	return (_pCadSelected != NULL|| _pRefLinesSelected != NULL);
}

// ��ѡ--��ѡģʽ�� ���㵽����ȥѡ�е㵽��ͼ�Σ����㲻��������������
//   ��Ϊ�Ǽ�ѡ�����뿼�ǵ�ǰ��ѡ�е�ͼ�Σ�δѡ�е�ͼ�β����ǣ�ͬǰ�����õ�ѡ��
// ����͵�ѡ�ݲ��һ���۲촰���Σ�Ȼ����ݸ�ͼ��������۲촰�İ������ཻ����
// ��ϵ����ѡ��ͼ�ν��з��࣬�����ཻ��ͼ�����ȫ�����Լ�������ͼ��������ɸ���
//                                                       ---- ��� 2011-07-16
BOOL CSelectTarget::_SelectByPoint_Decrease(const DPOINT2& point_, double nTolerance_)
{
	ASSERT(nTolerance_ >= 0.);
	ASSERT(m_pFileTarget);

	// ����۲촰���β����� ---- ��� 2011-07-16
	DRECT _rcViewport(point_.x - nTolerance_, point_.y - nTolerance_,
		2. * nTolerance_, 2. * nTolerance_);
	const CadObjectList* _plistSelectedCadObjects = GetSelectedCadObjects();
	CCadGroup* _pRefLines = m_pFileTarget->GetCurrentRefLines();
	ASSERT(_plistSelectedCadObjects || _pRefLines);
	CadObjectList _listFullInside;
	CadObjectList _listPartInside;
	_DivideObjectsIntoThree(_plistSelectedCadObjects, _rcViewport, &_listFullInside, &_listPartInside, NULL);

	// �ռ����ǵ�ͼ�μ� ---- ��� 2011-07-16
	CadObjectList _listTarget;
	const int _c_nMaxCount = 10;	// ��࿼��FullInside�����е�N��
	int _nCurCount = 0;
	for (CadObjectList::iterator _it = _listFullInside.begin(); _it != _listFullInside.end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		_listTarget.push_back(_pCad);
		_nCurCount++;

		if (_nCurCount >= _c_nMaxCount)
		{
			break;
		}
	}
	for (CadObjectList::iterator _it = _listPartInside.begin(); _it != _listPartInside.end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		_listTarget.push_back(_pCad);
	}

	// ���в��� ---- ��� 2011-07-16
	CCadObject* _pCadSelected = nce::Hit(&_listTarget, point_, nTolerance_, NULL);
	// Carry out ������ ---- ��� 2011-07-16
	if (_pCadSelected)
	{
		_pCadSelected->Select(false);
	}
	// shift�����ο��ߵļ�ѡ���� ---liangyan 2013-10-19
	CCadObject* _pRefLinesSelected = Hit(_pRefLines, point_, nTolerance_);
	if (_pRefLinesSelected)
	{
		_pRefLinesSelected->Select(false);
	}
	return (_pCadSelected != NULL || _pRefLinesSelected != NULL);
}

// ��ѡ--��ѡģʽ�� ���㵽����תѡ��״̬�����㲻��������������
//   ͬǰ�����õ�ѡ������͵�ѡ�ݲ��һ���۲촰���Σ�Ȼ����ݸ�ͼ��������۲�
// ���İ������ཻ�����ϵ������ͼ�ν��з��࣬�����ཻ��ͼ�����ȫ�����Լ�������
// ͼ��������ɸ���
//                                                       ---- ��� 2011-07-16
BOOL CSelectTarget::_SelectByPoint_Reverse(const DPOINT2& point_, double nTolerance_)
{
	ASSERT(nTolerance_ >= 0.);
	ASSERT(m_pFileTarget);

	// ����۲촰���β����� ---- ��� 2011-07-16
	DRECT _rcViewport(point_.x - nTolerance_, point_.y - nTolerance_,
		2. * nTolerance_, 2. * nTolerance_);
	const CadObjectList* _plistCurrentGroup = m_pFileTarget->GetCurrentCadGroup()->GetObjectsList();
	CCadGroup* _pRefLines = m_pFileTarget->GetCurrentRefLines();
	ASSERT(_plistCurrentGroup || _pRefLines);
	CadObjectList _listFullInside;
	CadObjectList _listPartInside;
	_DivideObjectsIntoThree(_plistCurrentGroup, _rcViewport, &_listFullInside, &_listPartInside, NULL);

	// �ռ����ǵ�ͼ�μ� ---- ��� 2011-07-16
	CadObjectList _listTarget;
	const int _c_nMaxCount = 10;	// ��࿼��FullInside�����е�N��
	int _nCurCount = 0;
	for (CadObjectList::iterator _it = _listFullInside.begin(); _it != _listFullInside.end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		_listTarget.push_back(_pCad);
		_nCurCount++;

		if (_nCurCount >= _c_nMaxCount)
		{
			break;
		}
	}
	for (CadObjectList::iterator _it = _listPartInside.begin(); _it != _listPartInside.end(); _it++)
	{
		CCadObject* _pCad = *_it;
		ASSERT(_pCad);
		_listTarget.push_back(_pCad);
	}

	// ���в��� ---- ��� 2011-07-16
	// ctrl + shift��ѡʱ��Cad����Ͳο��߲���ͬʱѡ�У��������Cad������Ӧ��������вο��ߵ�ѡ��״̬��
	// ����ο������У���Ӧ�������Cad�����ѡ��״̬-----liangyan 2013-10-19
	CCadObject* _pCadSelected = nce::Hit(&_listTarget, point_, nTolerance_, NULL);
	CCadObject* _pRefLinesSelected = Hit(_pRefLines, point_, nTolerance_);
	int _nCount = _pRefLines->GetNumOfChild();
	if (_pCadSelected)
	{
		for (int _i = 0; _i < _nCount; _i++)
			_pRefLines->GetAt(_i)->Select(false);
		_pCadSelected->Select(!_pCadSelected->IsSelected());
	}
	if(_pRefLinesSelected)
	{
		for (CadObjectList::const_iterator _iter = _plistCurrentGroup->begin(); _iter != _plistCurrentGroup->end(); _iter++)
		{
			if ((*_iter)->IsSelected())
				(*_iter)->Select(false);
		}
		_pRefLinesSelected->Select(!_pRefLinesSelected->IsSelected());
	}
	return (_pCadSelected != NULL || _pRefLinesSelected != NULL);
}

// ��ѡ���ܵ�ʵ�ֺ�����ptFirst_��ptSecond_��Ϊ��ѡ����һ���Խ��ߵ����˵� Wanglou 2010-06-13
UINT CSelectTarget::SelectByRect(UINT nFlags_, const DPOINT2& ptFirst_, const DPOINT2& ptSecond_)
{
	// ��ѡ����ѡ�вο��ߣ����һ�Ѳο��ߵ�ѡ��״̬����� Wanglou 2010-08-21
	ASSERT(m_pFileTarget);
	CCadGroup* _pRefLines = m_pFileTarget->GetCurrentRefLines();
	ASSERT(_pRefLines);
	for (int _i = 0; _i < _pRefLines->GetNumOfChild(); _i++)
	{
		CCadObject* _pCad = _pRefLines->GetAt(_i);
		ASSERT(_pCad);
		_pCad->Select(false);
	}

	bool _bCtrlKeyDown = (nFlags_ & MK_CONTROL) != 0;
	bool _bShiftKeyDown = (nFlags_ & MK_SHIFT) != 0;

	// ���ֿ�ѡģʽ ---- ��� 2011-07-16
	UINT _nRet = 0;
	if (!_bCtrlKeyDown && !_bShiftKeyDown)
	{
		_nRet = _SelectByRect_Normal(ptFirst_, ptSecond_);
	}
	else if (_bCtrlKeyDown && !_bShiftKeyDown)
	{
		_nRet = _SelectByRect_Increase(ptFirst_, ptSecond_);
	}
	else if (!_bCtrlKeyDown && _bShiftKeyDown)
	{
		_nRet = _SelectByRect_Decrease(ptFirst_, ptSecond_);
	}
	else
	{
		ASSERT(_bCtrlKeyDown && _bShiftKeyDown);
		_nRet = _SelectByRect_Reverse(ptFirst_, ptSecond_);
	}

	// ����ѡ�ж������� ---- ��� 2011-07-16
	GetSelectedCadObjects(true);
	GetSelectedRefLines(true);

	return _nRet;
}

// ��ѡ--��ͨģʽ�� ͼ����ѡ�������ѡ�У�����ȥѡ�С�  ---- ��� 2011-07-16
UINT CSelectTarget::_SelectByRect_Normal(const DPOINT2& ptFirst_, const DPOINT2& ptSecond_)
{
	// ��ѡ ---- ��� 2011-07-16
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	ASSERT(_pCadGroup);
	UINT _nRet = 0;
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if (_SelectCadObjectByRect(_pCadObject, ptFirst_, ptSecond_))
		{
			_pCadObject->Select(true);
			_nRet++;
		}
		else
		{
			_pCadObject->Select(false);
		}
	}

	return _nRet;
}

// ��ѡ--��ѡģʽ�� ͼ����ѡ�������ѡ�У������޶�����  ---- ��� 2011-07-16
UINT CSelectTarget::_SelectByRect_Increase(const DPOINT2& ptFirst_, const DPOINT2& ptSecond_)
{
	// ��ѡ ---- ��� 2011-07-16
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	ASSERT(_pCadGroup);
	UINT _nRet = 0;
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if (_SelectCadObjectByRect(_pCadObject, ptFirst_, ptSecond_))
		{
			_pCadObject->Select(true);
			_nRet++;
		}
	}

	return _nRet;
}

// ��ѡ--��ѡģʽ�� ͼ����ѡ�������ȥѡ�У������޶�����  ---- ��� 2011-07-16
UINT CSelectTarget::_SelectByRect_Decrease(const DPOINT2& ptFirst_, const DPOINT2& ptSecond_)
{
	// ��ѡ ---- ��� 2011-07-16
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	ASSERT(_pCadGroup);
	UINT _nRet = 0;
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if (_SelectCadObjectByRect(_pCadObject, ptFirst_, ptSecond_))
		{
			_pCadObject->Select(false);
			_nRet++;
		}
	}

	return _nRet;
}

// ��ѡ--��ѡģʽ�� ͼ����ѡ�������תѡ��״̬�������޶����� ---- ��� 2011-07-16
UINT CSelectTarget::_SelectByRect_Reverse(const DPOINT2& ptFirst_, const DPOINT2& ptSecond_)
{
	// ��ѡ ---- ��� 2011-07-16
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	ASSERT(_pCadGroup);
	UINT _nRet = 0;
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if (_SelectCadObjectByRect(_pCadObject, ptFirst_, ptSecond_))
		{
			bool _bSelected = _pCadObject->IsSelected();
			_pCadObject->Select(!_bSelected);
			_nRet++;
		}
	}

	return _nRet;
}

UINT CSelectTarget::_SelectCadObjectByColore(int nColoreIndex_)
{
	ASSERT(m_pFileTarget);
	ASSERT(nColoreIndex_ >= 0);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();

	UINT _nRet = 0;
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetParamIndex() == nColoreIndex_)
		{
			_pCadObject->Select();
			_nRet++;
		}
		else
		{
			_pCadObject->Select(false);
		}
	}

	return _nRet;
}

LRESULT CSelectTarget::SelectByColore(WPARAM wParam_, LPARAM lParam_)
{
	int _nIndex = (int)wParam_;
	ASSERT(_nIndex >= 0);

	return _SelectCadObjectByColore(_nIndex);
}

void CSelectTarget::OnSelectSimilar()
{
	// ѡ������ͼ�Σ���ָ��һ������ͼ�Σ���ѡ���߶�ѡ����ѡ���鶼���ܡ� --- �ƺ��� 2015-12-22
	const CadObjectList* _plistRefObjs = GetSelectedCadObjects();
	if (_plistRefObjs->size() != 1
		|| (*_plistRefObjs->begin())->GetType() == cadgroup
		|| (*_plistRefObjs->begin())->GetType() == cadtext)
	{
		return;
	}

	CCadObject* _pRefObj = *(_plistRefObjs->begin());
	switch(_pRefObj->GetType())
	{
	case caddot:
		{
			_SelectSimilarDot((CCadDot*)_pRefObj);
			break;
		}
	case cadline:
		{
			_SelectSimilarLine((CCadLine*)_pRefObj);
			break;
		}

	case cadcircle:
		{
			_SelectSimilarCircle((CCadCircle*)_pRefObj);
			break;
		}

	case cadarc:
		{
			_SelectSimilarArc((CCadArc*)_pRefObj);
			break;
		}

	case cadellipse:
		{
			_SelectSimilarEllipse((CCadEllipse*)_pRefObj);
			break;
		}

	case cadellipsearc:
		{
			_SelectSimilarEllipseArc((CCadEllipseArc*)_pRefObj);
			break;
		}

	case cadrectangle:
		{
			_SelectSimilarRectangle((CCadRectangle*)_pRefObj);
			break;
		}

	case cadpolygon:
		{
			_SelectSimilarPolygon((CCadPolygon*)_pRefObj);
			break;
		}

	case cadstar:
		{
			_SelectSimilarStar((CCadStar*)_pRefObj);
			break;
		}

	case cadpolyline:
		{
			_SelectSimilarPolyline((CCadPolyline*)_pRefObj);
			break;
		}

	default:
		{
			// do noting
		}
	}

	UpdateAllVisions();
}

void CSelectTarget::OnUpdateSelectSimilar(CCmdUI* pCmdUI_)
{
	const CadObjectList* _pSelectObjs = GetSelectedCadObjects();
	pCmdUI_->Enable(_pSelectObjs && _pSelectObjs->size() > 0);
}

// ���еĵ㶼�����Ƶġ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarDot(const nce::CCadDot* pRefDot_)
{
	if (!pRefDot_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	UINT _nRet = 0;
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefDot_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		if(_pCadObject->GetType() == caddot)
		{
			_pCadObject->Select();
		}
		else
		{
			_pCadObject->Select(false);
		}
	}
}

// ƽ���ҳ�����ȵ���Ϊ����ͼ�Ρ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarLine(const nce::CCadLine* pRefLine_)
{
	if (!pRefLine_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadline)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefLine_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		CCadLine* _pLine = (CCadLine*)_pCadObject;
		DPOINT2 _ptV1 = DPOINT2(_pLine->GetStartPoint() - _pLine->GetEndPoint());
		DPOINT2 _ptV2 = DPOINT2(pRefLine_->GetStartPoint() - pRefLine_->GetEndPoint());
		if (DOUBLE_EQU_ZERO(_ptV1.x * _ptV2.y - _ptV1.y * _ptV2.x)
			&& DOUBLE_ROUGHEQU(_ptV1.GetLength(), _ptV2.GetLength()))
		{
			_pLine->Select();
		}
		else
		{
			_pLine->Select(false);
		}
	}
}

// �뾶��ȵ�ԲΪ����ͼ�Ρ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarCircle(const nce::CCadCircle* pRefCircle_)
{
	if (!pRefCircle_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadcircle)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefCircle_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		CCadCircle* _pCircle = (CCadCircle*)_pCadObject;
		if (DOUBLE_ROUGHEQU(_pCircle->GetRadius(), pRefCircle_->GetRadius()))
		{
			_pCircle->Select(true);
		}
		else
		{
			_pCircle->Select(false);
		}
	}
}

// �뾶��ȳ�����ȵ�Բ��Ϊ����ͼ�Ρ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarArc(const nce::CCadArc* pRefArc_)
{
	if (!pRefArc_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadarc)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefArc_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		CCadArc* _pArc = (CCadArc*)_pCadObject;
		if (DOUBLE_ROUGHEQU(_pArc->GetRadius(), pRefArc_->GetRadius())
			&& DOUBLE_ROUGHEQU(_pArc->GetLength(), pRefArc_->GetLength()))
		{
			_pArc->Select(true);
		}
		else
		{
			_pArc->Select(false);
		}
	}
}

// ������Ͷ̰�����ȵ���Բ��Ϊ����ͼ�Ρ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarEllipse(const nce::CCadEllipse* pRefEllipse_)
{
	if (!pRefEllipse_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadellipse)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefEllipse_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		CCadEllipse* _pEllipse = (CCadEllipse*)_pCadObject;
		if ((DOUBLE_ROUGHEQU(_pEllipse->GetLongRadius(), pRefEllipse_->GetLongRadius())
			&& DOUBLE_ROUGHEQU(_pEllipse->GetShortRadius(), pRefEllipse_->GetShortRadius())))
		{
			_pEllipse->Select(true);
		}
		else
		{
			_pEllipse->Select(false);
		}
	}
}

// �����ᡢ�̰��ᡢ��б�ǡ���ʼ�Ǻ���ֹ����ȵ���Բ����Ϊ����ͼ�Ρ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarEllipseArc(const nce::CCadEllipseArc* pRefEllipseArc_)
{
	if (!pRefEllipseArc_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadellipsearc)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefEllipseArc_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		bool _bSelect = false;
		CCadEllipseArc* _pEllipseArc = (CCadEllipseArc*)_pCadObject;
		if (DOUBLE_ROUGHEQU(_pEllipseArc->GetLongRadius(), pRefEllipseArc_->GetLongRadius())
			&& DOUBLE_ROUGHEQU(_pEllipseArc->GetShortRadius(), pRefEllipseArc_->GetShortRadius())
			&& DOUBLE_ROUGHEQU(_pEllipseArc->GetCentralAngle(), pRefEllipseArc_->GetCentralAngle()))
		{
			if (DOUBLE_ROUGHEQU(_pEllipseArc->GetStartAngle(), pRefEllipseArc_->GetStartAngle())
				&& _pEllipseArc->IsNormalDir() == pRefEllipseArc_->IsNormalDir())
			{
				_bSelect = true;
			}
			if (DOUBLE_ROUGHEQU(_pEllipseArc->GetEndAngle(), pRefEllipseArc_->GetStartAngle())
				&& _pEllipseArc->IsNormalDir() == !pRefEllipseArc_->IsNormalDir())
			{
				_bSelect = true;
			}

			double _nStartAngle = _pEllipseArc->GetStartAngle() + ncmath::c_nPIE;
			if (_nStartAngle >= 2 * ncmath::c_nPIE)
			{
				_nStartAngle -= 2 * ncmath::c_nPIE;
			}
			if (DOUBLE_ROUGHEQU(_nStartAngle, pRefEllipseArc_->GetStartAngle())
				&& _pEllipseArc->IsNormalDir() == pRefEllipseArc_->IsNormalDir())
			{
				_bSelect = true;
			}
			if (DOUBLE_ROUGHEQU(_nStartAngle, pRefEllipseArc_->GetEndAngle())
				&& _pEllipseArc->IsNormalDir() == !pRefEllipseArc_->IsNormalDir())
			{
				_bSelect = true;
			}

			_nStartAngle = 2 * ncmath::c_nPIE - _pEllipseArc->GetStartAngle();
			if (_nStartAngle >= 2 * ncmath::c_nPIE)
			{
				_nStartAngle -= 2 * ncmath::c_nPIE;
			}
			if (DOUBLE_ROUGHEQU(_nStartAngle, pRefEllipseArc_->GetStartAngle())
				&& _pEllipseArc->IsNormalDir() == !pRefEllipseArc_->IsNormalDir())
			{
				_bSelect = true;
			}
			if (DOUBLE_ROUGHEQU(_nStartAngle, pRefEllipseArc_->GetEndAngle())
				&& _pEllipseArc->IsNormalDir() == pRefEllipseArc_->IsNormalDir())
			{
				_bSelect = true;
			}

			_nStartAngle += ncmath::c_nPIE;
			if (_nStartAngle >= 2 * ncmath::c_nPIE)
			{
				_nStartAngle -= 2 * ncmath::c_nPIE;
			}
			if (DOUBLE_ROUGHEQU(_nStartAngle, pRefEllipseArc_->GetStartAngle())
				&& _pEllipseArc->IsNormalDir() == !pRefEllipseArc_->IsNormalDir())
			{
				_bSelect = true;
			}
			if (DOUBLE_ROUGHEQU(_nStartAngle, pRefEllipseArc_->GetEndAngle())
				&& _pEllipseArc->IsNormalDir() == pRefEllipseArc_->IsNormalDir())
			{
				_bSelect = true;
			}
		}
		_pEllipseArc->Select(_bSelect);
	}
}

// ���Ϳ���ȵľ���Ϊ����ͼ�Ρ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarRectangle(const nce::CCadRectangle* pRefRectangle_)
{
	if (!pRefRectangle_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadrectangle)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefRectangle_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		CCadRectangle* _pRectangle = (CCadRectangle*)_pCadObject;
		if ((DOUBLE_ROUGHEQU(_pRectangle->GetWidth(), pRefRectangle_->GetWidth())
			&& DOUBLE_ROUGHEQU(_pRectangle->GetHeitht(), pRefRectangle_->GetHeitht()))
			|| (DOUBLE_ROUGHEQU(_pRectangle->GetWidth(), pRefRectangle_->GetHeitht())
			&& DOUBLE_ROUGHEQU(_pRectangle->GetHeitht(), pRefRectangle_->GetWidth())))
		{
			_pRectangle->Select(true);
		}
		else
		{
			_pRectangle->Select(false);
		}
	}
}

// ���Բ�뾶���ڽ�Բ�뾶��ͬ����������ȵ��������Ϊ����ͼ�Ρ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarPolygon(const nce::CCadPolygon* pRefPolygon_)
{
	if (!pRefPolygon_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadpolygon)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefPolygon_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		CCadPolygon* _pPolygon = (CCadPolygon*)_pCadObject;
		if (_pPolygon->GetNumOfVertexes() == pRefPolygon_->GetNumOfVertexes()
			&& DOUBLE_ROUGHEQU(_pPolygon->GetCircumRadius(), pRefPolygon_->GetCircumRadius())
			&& DOUBLE_ROUGHEQU(_pPolygon->GetInscribedRadius(), pRefPolygon_->GetInscribedRadius()))
		{
			_pPolygon->Select(true);
		}
		else
		{
			_pPolygon->Select(false);
		}
	}
}

// ���Բ�뾶���ڽ�Բ�뾶��ͬ����������ȵ�����Ϊ����ͼ�Ρ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarStar(const nce::CCadStar* pRefStar_)
{
	if (!pRefStar_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadstar)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefStar_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		CCadStar* _pStar = (CCadStar*)_pCadObject;
		if (_pStar->GetNumOfVertexes() == pRefStar_->GetNumOfVertexes()
			&& DOUBLE_ROUGHEQU(_pStar->GetCircumRadius(), pRefStar_->GetCircumRadius())
			&& DOUBLE_ROUGHEQU(_pStar->GetInscribedRadius(), pRefStar_->GetInscribedRadius()))
		{
			_pStar->Select(true);
		}
		else
		{
			_pStar->Select(false);
		}
	}
}

// һģһ���Ķ����߲������ơ� ---- �ƺ��� 2015-12-22
void CSelectTarget::_SelectSimilarPolyline(const nce::CCadPolyline* pRefPolyline_)
{
	if (!pRefPolyline_)
	{
		ASSERT(FALSE);
		return;
	}

	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
		ASSERT(_pCadObject);
		if(_pCadObject->GetType() != cadpolyline)
		{
			_pCadObject->Select(false);
			continue;
		}

		// �Լ��϶��������Լ������������ǰ����ÿ�������ID��Ψһ�ġ� ---- �ƺ��� 2016-01-07
		if (_pCadObject->GetID() == pRefPolyline_->GetID())
		{
			_pCadObject->Select(true);
			continue;
		}

		// �����Ƚϡ�
		CCadPolyline* _pPolyline = (CCadPolyline*)_pCadObject;
		if (_pPolyline->GetNodeCount() != pRefPolyline_->GetNodeCount()
			|| !DOUBLE_ROUGHEQU(_pPolyline->GetLength(), pRefPolyline_->GetLength()))
		{
			_pPolyline->Select(false);
			continue;
		}

		if (_pPolyline->GetNodeCount() == 1)
		{
			bool _bSelect = false;
			CCadPolyline::ARCNODE _node = _pPolyline->GetAt(0);
			CCadPolyline::ARCNODE _nodeRef = pRefPolyline_->GetAt(0);
			if (!DOUBLE_EQU_ZERO(_node.nBulge)
				&& DOUBLE_ROUGHEQU(_node.nBulge, _nodeRef.nBulge)
				&& DOUBLE_ROUGHEQU(_pPolyline->GetLength(), pRefPolyline_->GetLength()))
			{
				_bSelect = true;
			}

			DPOINT2 _ptV1 = _node.ptEnd - _pPolyline->GetStartPoint();
			DPOINT2 _ptV2 = _nodeRef.ptEnd - pRefPolyline_->GetStartPoint();
			if (DOUBLE_EQU_ZERO(_node.nBulge)
				&& DOUBLE_ROUGHEQU(_node.nBulge, _nodeRef.nBulge)
				&& DOUBLE_EQU_ZERO(_ptV1.x * _ptV2.y - _ptV1.y * _ptV2.x))
			{
				_bSelect = true;
			}
			_pPolyline->Select(_bSelect);
			continue;
		}

		// �ڽ�����ϸ�ıȶ�֮ǰ��������Ҫ��ȷ�ϴ��ж�ͼ����ԭͼ�ε�������λ���Ƿ��Ǻϣ�
		// �Ƿ���ִ�λ���������ֻ�з��ͼ�λ���֣�����˳��ߵ������ ---- ��˼ 2017-03-17
		bool _bSelect;
		CCadPolyline _RefPolylineCopy = *pRefPolyline_;		// ԭָ��洢�Ķ�����const���͵ģ�����������һ����������ԭ���󣬷���ߵ�
		int _nCount = _pPolyline->GetNodeCount();
		int _nDeviationRange = 1;
		// ����ǷǷ��ͼ�ξͲ�����ڴ�λ�����ˣ�ֻ���Ƿ���ߵ���ƫ�Ʒ�ΧΪ1
		if(_pPolyline->IsClose())
		{
			_nDeviationRange = _nCount;
		}
		for(int _nDeviation = 0; _nDeviation < _nDeviationRange; ++_nDeviation)
		{
			_bSelect = true;
			DPOINT2 _ptStart = _pPolyline->GetStartPoint();
			DPOINT2 _ptStartRef;
			if(_nDeviation == 0)
			{
				_ptStartRef = _RefPolylineCopy.GetStartPoint();
			}
			else
			{
				_ptStartRef = (_RefPolylineCopy.GetAt(_nDeviation - 1)).ptEnd;
			}
			// ����һ�����ƾ���Ŀ��أ�δ֪Ϊ0����Ϊ1���ر�Ϊ2
			int _nMirror = 0;
			for(int _i = 1; _i < _nCount; _i++)
			{
				CCadPolyline::ARCNODE _nodeFirst = _pPolyline->GetAt(_i - 1);
				CCadPolyline::ARCNODE _nodeSecond = _pPolyline->GetAt(_i);

				CCadPolyline::ARCNODE _nodeRefFirst = _RefPolylineCopy.GetAt((_i - 1 + _nDeviation) % _nCount);
				CCadPolyline::ARCNODE _nodeRefSecond = _RefPolylineCopy.GetAt((_i + _nDeviation) % _nCount);

				// �������ֵ������ȣ��ǿ϶�������
				if (!DOUBLE_ROUGHEQU(abs(_nodeFirst.nBulge), abs(_nodeRefFirst.nBulge)))
				{
					_bSelect = false;
					break;
				}

				// ��״̬δ֪ʱ���־���ֵ��ȵ�״��ʱ�����������Ӧ���͹��Ϊ�෴�����򽫾��񿪹ش򿪣����������ȣ���ر�
				// ������߶�Ϊ0���������жϳ������Dz��Ǿ�������_nMirror����Ϊ0���䣬������һ��ѭ�������ж�
				if(_nMirror == 0)
				{
					if(_nodeFirst.nBulge * _nodeRefFirst.nBulge < 0)
					{
						_nMirror = 1;
					}

					if(_nodeFirst.nBulge * _nodeRefFirst.nBulge > 0)
					{
						_nMirror = 2;
					}
					continue;
				}

				// �ھ��񿪹ش򿪵�ʱ�����������Ӧ���͹�Ȳ�����������ȣ����񲻳���������
				else if(_nMirror == 1)
				{
					if(_nodeFirst.nBulge * _nodeRefFirst.nBulge > 0)
					{
						_bSelect = false;
						break;
					}
				}
				// �ھ��񿪹عرյ�ʱ�����������Ӧ���͹�Ȳ�Ϊ���һ�Ϊ�෴�����򲻾��񲻳���������
				else
				{
					if(_nodeFirst.nBulge * _nodeRefFirst.nBulge < 0)
					{
						_bSelect = false;
						break;
					}
				}

				DPOINT2 _ptFirstV = _nodeFirst.ptEnd - _ptStart;
				DPOINT2 _ptSecondV = _nodeSecond.ptEnd - _nodeFirst.ptEnd;
				DPOINT2 _ptFirstVRef = _nodeRefFirst.ptEnd - _ptStartRef;
				DPOINT2 _ptSecondVRef = _nodeRefSecond.ptEnd - _nodeRefFirst.ptEnd;
				if (!DOUBLE_ROUGHEQU(_ptFirstV.GetLength(), _ptFirstVRef.GetLength())
					|| !DOUBLE_ROUGHEQU(_ptSecondV.GetLength(), _ptSecondVRef.GetLength()))
				{
					_bSelect = false;
					break;
				}

				if (!DOUBLE_ROUGHEQU(ncmath::D2GetIncludeAngle(_ptFirstV, _ptSecondV), ncmath::D2GetIncludeAngle(_ptFirstVRef, _ptSecondVRef)))
				{
					_bSelect = false;
					break;
				}
				_ptStart = _nodeFirst.ptEnd;
				_ptStartRef = _nodeRefFirst.ptEnd;
			}
			if(_bSelect)
			{
				break;
			}
		}

		// �����һ�ζԱȲ��Ǻϣ��򽫴��ж�ͼ�εķ���ߵ�һ�κ��ٱȶ� ---- ��˼ 2017-03-17
		if(!_bSelect)
		{
			_RefPolylineCopy.ReverseDir();
			for(int _nDeviation = 0; _nDeviation < _nCount; ++_nDeviation)
			{
				_bSelect = true;
				DPOINT2 _ptStart = _pPolyline->GetStartPoint();
				DPOINT2 _ptStartRef;
				if(_nDeviation == 0)
				{
					_ptStartRef = _RefPolylineCopy.GetStartPoint();
				}
				else
				{
					_ptStartRef = (_RefPolylineCopy.GetAt(_nDeviation - 1)).ptEnd;
				}
				// ����һ�����ƾ���Ŀ��أ�δ֪Ϊ0����Ϊ1���ر�Ϊ2
				int _nMirror = 0;
				for(int _i = 1; _i < _nCount; _i++)
				{
					CCadPolyline::ARCNODE _nodeFirst = _pPolyline->GetAt(_i - 1);
					CCadPolyline::ARCNODE _nodeSecond = _pPolyline->GetAt(_i);

					CCadPolyline::ARCNODE _nodeRefFirst = _RefPolylineCopy.GetAt((_i - 1 + _nDeviation) % _nCount);
					CCadPolyline::ARCNODE _nodeRefSecond = _RefPolylineCopy.GetAt((_i + _nDeviation) % _nCount);


					// �������ֵ������ȣ��ǿ϶�������
					if (!DOUBLE_ROUGHEQU(abs(_nodeFirst.nBulge), abs(_nodeRefFirst.nBulge)))
					{
						_bSelect = false;
						break;
					}

					// ��״̬δ֪ʱ���־���ֵ��ȵ�״��ʱ�����������Ӧ���͹��Ϊ�෴�����򽫾��񿪹ش򿪣����������ȣ���ر�
					// ������߶�Ϊ0���������жϳ������Dz��Ǿ�������_nMirror����Ϊ0���䣬������һ��ѭ�������ж�
					if(_nMirror == 0)
					{
						if(_nodeFirst.nBulge * _nodeRefFirst.nBulge < 0)
						{
							_nMirror = 1;
						}
						
						if(_nodeFirst.nBulge * _nodeRefFirst.nBulge > 0)
						{
							_nMirror = 2;
						}
						continue;
					}

					// �ھ��񿪹ش򿪵�ʱ�����������Ӧ���͹�Ȳ�����������ȣ����񲻳���������
					else if(_nMirror == 1)
					{
						if(_nodeFirst.nBulge * _nodeRefFirst.nBulge > 0)
						{
							_bSelect = false;
							break;
						}
					}
					// �ھ��񿪹عرյ�ʱ�����������Ӧ���͹�Ȳ�Ϊ���һ�Ϊ�෴�����򲻾��񲻳���������
					else
					{
						if(_nodeFirst.nBulge * _nodeRefFirst.nBulge < 0)
						{
							_bSelect = false;
							break;
						}
					}

					DPOINT2 _ptFirstV = _nodeFirst.ptEnd - _ptStart;
					DPOINT2 _ptSecondV = _nodeSecond.ptEnd - _nodeFirst.ptEnd;
					DPOINT2 _ptFirstVRef = _nodeRefFirst.ptEnd - _ptStartRef;
					DPOINT2 _ptSecondVRef = _nodeRefSecond.ptEnd - _nodeRefFirst.ptEnd;
					if (!DOUBLE_ROUGHEQU(_ptFirstV.GetLength(), _ptFirstVRef.GetLength())
						|| !DOUBLE_ROUGHEQU(_ptSecondV.GetLength(), _ptSecondVRef.GetLength()))
					{
						_bSelect = false;
						break;
					}

					if (!DOUBLE_ROUGHEQU(ncmath::D2GetIncludeAngle(_ptFirstV, _ptSecondV), ncmath::D2GetIncludeAngle(_ptFirstVRef, _ptSecondVRef)))
					{
						_bSelect = false;
						break;
					}
					_ptStart = _nodeFirst.ptEnd;
					_ptStartRef = _nodeRefFirst.ptEnd;
				}
				if(_bSelect)
				{
					break;
				}
			}
		}
		_pPolyline->Select(_bSelect);
	}
}

// ������ѡ����Ƿ�ѡ��ͼ�Σ�������ѡ�ͷ�ѡ ---- DingQiang 2011-12-9
BOOL CSelectTarget::_SelectCadObjectByRect(const nce::CCadObject* pCadObject_,
										   const DPOINT2& ptFirst_,
										   const DPOINT2& ptSecond_)
{
	ASSERT(pCadObject_);
	DRECT _rcSelect(ptFirst_, ptSecond_);			// ѡ������
	DRECT _rcBound = pCadObject_->GetBoundRect();	// ͼ����Ӿ���

	// ���ѡ�����ȫ��Χͼ�Σ�����������ѡ�񷵻�TRUE ---- DingQiang 2011-12-9
	if (_rcSelect.Contains(_rcBound))
	{
		return TRUE;
	}

	// ���ѡ���û����ȫ��Χͼ�Σ�����������ѡ�����Ϊ��ѡ���򷴻�FALSE ---- DingQiang 2011-12-9
	if (ptSecond_.x >= ptFirst_.x)
	{
		return FALSE;
	}

	// ���Ϊ��ѡ�����ж�ѡ����ͼ�ε���Ӿ����Ƿ��ཻ��������ཻ�򷵻�FALSE,����
	// ˮƽ���߶κʹ�ֱ���߶���Ӿ���ѡ���һ��û�н��㣬����ʹ��������һ�㼸����
	// ���Եij��ȣ��Է����ж�����ѡ����Ƿ��ཻ          ---- DingQiang 2011-12-9
	if (_rcBound.width == 0)
	{
		_rcBound.width = 1.0e-9;
	}

	if (_rcBound.height == 0)
	{
		_rcBound.height = 1.0e-9;
	}

	if (!_rcSelect.Intersect(_rcBound))
	{
		return FALSE;
	}

	// ���Ϊ��ѡ��ѡ����ͼ�ε���Ӿ����ཻ�����ж�ѡ����Ƿ��ͼ���ཻ����
	// ����ѡ�����ι���һ��CAD���Σ��ٵ���GetIntersection�����ж��Ƿ���ͼ��
	// �н��㡣                                      ---- DingQiang 2011-12-9
	DPOINT2 _ptPoint0 = ptFirst_;
	DPOINT2 _ptPoint1(ptFirst_.x, ptSecond_.y);
	DPOINT2 _ptPoint2 = ptSecond_;
	DPOINT2 _ptPoint3(ptSecond_.x, ptFirst_.y);
	CCadRectangle _CadRectangle(_ptPoint0, _ptPoint1, _ptPoint2, _ptPoint3);

	int _nIntersectionCounts = GetIntersection(&_CadRectangle, pCadObject_, NULL);
	return (_nIntersectionCounts > 0);
}

BOOL CSelectTarget::SelectRefLine(const DPOINT2& point_, double nTolerance_)
{
	ASSERT(m_pFileTarget);
	CCadGroup* _pRefLines = m_pFileTarget->GetCurrentRefLines();
	if (!_pRefLines || _pRefLines->IsEmpty())
		return FALSE;
	
	// �ο���ֻ��ѡ��һ����ѡ��ڶ��������������ο��ߵ�ѡ��״̬ Wanglou 2010-08-21
	int _nCount = _pRefLines->GetNumOfChild();
	for (int _i = 0; _i < _nCount; _i++)
		_pRefLines->GetAt(_i)->Select(false);

	CCadObject* _pCadObject = Hit(_pRefLines, point_, nTolerance_);
	if (!_pCadObject)
		return FALSE;

	// ���вο��߶�Ϊֱ��,���ѡ���˲ο��ߣ������е�Cad�����ѡ��״̬������� Wanglou 2010-08-21
	ASSERT(_pCadObject->GetType() == cadbeeline);
	ClearSelect();
	_pCadObject->Select(true);
	return TRUE;
}

// ȫѡ
void CSelectTarget::SelectAll()
{
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	if (_pCadGroup->IsEmpty())
		return;
	const CadObjectList* _pCadObjList = _pCadGroup->GetObjectsList();
	bool _bChanged = false;

	// ����� ---- DingQiang 2013-09-23
	m_listSelectedCadObjects.clear();
	for (CadObjectList::const_iterator _iter = _pCadObjList->begin(); _iter != _pCadObjList->end(); _iter++)
	{
		m_listSelectedCadObjects.push_back(*_iter);
		if (!(*_iter)->IsSelected())
		{
			(*_iter)->Select(true);
			_bChanged = true;
		}
	}
}

// ��ѡ
void CSelectTarget::SelectRev()
{
	// ��ת�������ѡ��״̬ ---- ��� 2011-07-18
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	for (int _i = 0; _i < _pCadGroup->GetNumOfChild(); _i++)
	{
		CCadObject* _pCad = _pCadGroup->GetAt(_i);
		ASSERT(_pCad);
		bool _bSelected = _pCad->IsSelected();
		_pCad->Select(!_bSelected);
	}

	// ����ѡ�ж������� ---- ��� 2011-07-18
	GetSelectedCadObjects(true);
}

// ���
void CSelectTarget::ClearSelect()
{
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	if (_pCadGroup && !_pCadGroup->IsEmpty())
	{
		// ���Cad�����ѡ��״̬
		const CadObjectList* _pCadObjList = _pCadGroup->GetObjectsList();
		for (CadObjectList::const_iterator _iter = _pCadObjList->begin(); _iter != _pCadObjList->end(); _iter++)
		{
			if ((*_iter)->IsSelected())
				(*_iter)->Select(false);
		}
		m_listSelectedCadObjects.clear();
	}

	// ����ο��ߵ�ѡ��״̬
	CCadGroup* _pRefLines = m_pFileTarget->GetCurrentRefLines();
	if (_pRefLines && !_pRefLines->IsEmpty())
	{
		int _nCount = _pRefLines->GetNumOfChild();
		for (int _i = 0; _i < _nCount; _i++)
			_pRefLines->GetAt(_i)->Select(false);
	}
}

const CadObjectList* CSelectTarget::GetSelectedCadObjects(bool bArbitrary_/* = false*/)
{
	// ��Ϊǿ�Ƹ��£����FileTarget�������ռ� ---- ��� 2011-06-10
	if (bArbitrary_)
	{
		m_listSelectedCadObjects.clear();

		ASSERT(m_pFileTarget);
		CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
		ASSERT(_pCadGroup);
		int _nCount = _pCadGroup->GetNumOfChild();
		for (int _i = 0; _i < _nCount; _i++)
		{
			CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
			ASSERT(_pCadObject);
			if (_pCadObject->IsSelected())
			{
				m_listSelectedCadObjects.push_back(_pCadObject);
			}
		}
	}

	return &m_listSelectedCadObjects;
}

const nce::CadObjectList* CSelectTarget::GetSelectedRefLines(bool bArbitrary_/* = false*/)
{
	// ��Ϊǿ�Ƹ��£����FileTarget�������ռ� ---- ��� 2011-06-10
	if (bArbitrary_)
	{
		m_listSelectedRefLines.clear();

		ASSERT(m_pFileTarget);
		CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentRefLines();
		ASSERT(_pCadGroup);
		int _nCount = _pCadGroup->GetNumOfChild();
		for (int _i = 0; _i < _nCount; _i++)
		{
			CCadObject* _pCadObject = _pCadGroup->GetAt(_i);
			ASSERT(_pCadObject);
			if (_pCadObject->IsSelected())
			{
				m_listSelectedRefLines.push_back(_pCadObject);
			}
		}
	}

	return &m_listSelectedRefLines;
}

void CSelectTarget::Reset()
{
	m_ptLButtonDown = DPOINT2(c_nINVALID_DOUBLE, c_nINVALID_DOUBLE);
	m_ptTemp = DPOINT2(c_nINVALID_DOUBLE, c_nINVALID_DOUBLE);
}

DRECT CSelectTarget::GetSelObjsBoundRect(bool bArbitrary_/* = false*/)
{
	// bArbitrary_Ϊtrueʱǿ�Ƹ��»��档 ---- ��� 2011-06-16
	if (bArbitrary_)
	{
		// ��ʼ��
		const CadObjectList* _plistSelObjs = GetSelectedCadObjects();
		ASSERT(_plistSelObjs);
		DRECT _rcTotalRect(c_nINVALID_DOUBLE, c_nINVALID_DOUBLE, c_nINVALID_DOUBLE, c_nINVALID_DOUBLE);

		// ����
		for (CadObjectList::const_iterator _it = _plistSelObjs->begin(); _it != _plistSelObjs->end(); _it++)
		{
			DRECT _rect = (*_it)->GetBoundRect();
			if (_it == _plistSelObjs->begin())
				_rcTotalRect = _rect;
			else
				DRECT::Union(_rcTotalRect, _rcTotalRect, _rect);
		}

		// ����
		m_rcSelObjsBoundRect = _rcTotalRect;
	}

	return m_rcSelObjsBoundRect;
}

DRECT CSelectTarget::GetObjsBoundRect(const CadObjectList* pObjectsList_)
{
	if (!pObjectsList_ || pObjectsList_->empty())
		DRECT(0,0,0,0);

	DRECT _rc;
	for (CadObjectList::const_iterator _iter = pObjectsList_->begin(); _iter != pObjectsList_->end(); _iter++)
	{
		DRECT _rect = (*_iter)->GetBoundRect();
		if (_iter == pObjectsList_->begin())
			_rc = _rect;
		else
			DRECT::Union(_rc, _rc, _rect);
	}

	return _rc;
}

void CSelectTarget::SetRButtonMenu_NoneSelected(CMenu* pRButtonMenu_)
{
	ASSERT(pRButtonMenu_);
	ASSERT(pRButtonMenu_->GetSafeHmenu());
	m_pRButtonMenu_NoneSelected = pRButtonMenu_;
}

void CSelectTarget::SetRButtonMenu_SingleSelected(CMenu* pRButtonMenu_)
{
	ASSERT(pRButtonMenu_);
	ASSERT(pRButtonMenu_->GetSafeHmenu());
	m_pRButtonMenu_SingleSelected = pRButtonMenu_;
}

void CSelectTarget::SetRButtonMenu_MultiSelected(CMenu* pRButtonMenu_)
{
	ASSERT(pRButtonMenu_);
	ASSERT(pRButtonMenu_->GetSafeHmenu());
	m_pRButtonMenu_MultiSelected = pRButtonMenu_;
}

////////////////////////////////////////////////////////////////////////////////
// Local function implementations
// 
// ����һ�������Ĺ۲촰����������һ��CAD���󻮷�Ϊ�����������֣����ֵ��жϰ취��
// ��������Ӿ��Σ�Ȼ������Ӿ��εİ������ཻ��ϵ���жϡ�
//   FullInside : ������ȫ�ڹ۲촰��
//   PartInside : ���󲿷��ڹ۲촰��
//   NotInside  : ������ȫ���ڹ۲촰��
// �۲촰ViewPortӦΪ��Ч������λ�õ�ӦΪ��Ч������ӦΪ�Ǹ�����������OUT��ָ���
// ����ΪNULL��ΪNULLʱ��ʾ����Ҫ�ռ���һ���ֵĶ���     ---- ��� 2011-07-16
static void _DivideObjectsIntoThree(IN const CadObjectList* plistSource_,
									IN const DRECT& rcViewport_,
									OUT CadObjectList* plistFullInside_,
									OUT CadObjectList* plistPartInside_,
									OUT CadObjectList* plistNotInside_)
{
	ASSERT(plistSource_);
	ASSERT(IsValidDouble(rcViewport_.x) && IsValidDouble(rcViewport_.y)
		&& rcViewport_.width >= 0. && rcViewport_.height >= 0);

	if (!plistFullInside_ && !plistPartInside_ && !plistNotInside_)
	{
		return;
	}

	for (CadObjectList::const_iterator _it = plistSource_->begin();
		_it != plistSource_->end(); _it++)
	{
		// ����Ӿ��� ---- ��� 2011-07-16
		CCadObject* _pCadObject = *_it;
		ASSERT(_pCadObject);
		DRECT _rcBound = _pCadObject->GetBoundRect();

		// ���жϰ�����ϵ�����ж��ཻ��ϵ ---- ��� 2011-07-16
		if (rcViewport_.Contains(_rcBound))
		{
			if (plistFullInside_)
				plistFullInside_->push_back(_pCadObject);
		}
		else if (rcViewport_.IntersectsWith(_rcBound))
		{
			if (plistPartInside_)
				plistPartInside_->push_back(_pCadObject);
		}
		else
		{
			if (plistNotInside_)
				plistNotInside_->push_back(_pCadObject);
		}
	}
}

LRESULT CSelectTarget::SelectAll(WPARAM wParam_, LPARAM lParam_)
{
	ASSERT(m_pFileTarget);
	CCadGroup* _pCadGroup = m_pFileTarget->GetCurrentCadGroup();
	if (_pCadGroup->IsEmpty())
		return FALSE;
	const CadObjectList* _pCadObjList = _pCadGroup->GetObjectsList();

	// ����� ---- DingQiang 2013-09-23
	m_listSelectedCadObjects.clear();
	for (CadObjectList::const_iterator _iter = _pCadObjList->begin(); _iter != _pCadObjList->end(); _iter++)
	{
		m_listSelectedCadObjects.push_back(*_iter);
		if (!(*_iter)->IsSelected())
		{
			(*_iter)->Select(true);
		}
	}

	return TRUE;
}