kev/Drawer/Module/GeoSigmaDraw/ItemSelect.h

#pragma once

#include <functional>
#include "itemfocusrect.h"
#include <GdiPlus.h>
#include "QTransformTracker.h"
#include "VoronoiMap/InterfaceElements.h"
#include "Util.h"

namespace NItem
{
/**
 * 框选处理类
 */
class CItemSelect : public CItemFocusRect
{
public:
	enum SelectMode
	{
		selnone, // 单选
		netSelect,
		move,
		size,
	};
	SelectMode selectMode;
	bool m_isLocationChanged;
public:
	CItemSelect(CSigmaDoc * ppDoc);
	virtual ~CItemSelect(void);

	virtual void OnLButtonDblClk(UINT nFlags, CPoint point) override;
	virtual void OnLButtonDown(CDC *pDC, UINT nFlags, CPoint point, int vk) override;
	virtual void OnLButtonUp(CDC *pDC, UINT nFlags, CPoint point, int vk=0) override;
	virtual int OnMouseMove(CDC *pDC, UINT nFlags, CPoint point) override;
	void MoveElementsTo(CPoint point);
	virtual void OnRButtonDown(UINT nFlags, CPoint point) override;
	virtual BOOL OnMoving();
	void DrawTrackPath(CDC* pDC);
	virtual BOOL OnSetCursor(CPoint pt, int& handle);
	BOOL OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) override;
	BOOL OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags) override;
	virtual void OnDraw(CXyDC* pDC) override;
	virtual void OnDraw(CXyDC* pXyDC, CDC* pDC) override;

	/**
	 * 创建龟背图，如果有三角网，则根据三角网生成，如果没有，根据点和边框生成
	 *
	 * \return
	 */
	int CreateVoronoiMap();
	int CreateVoronoiMap(POSITION& posCurve, CPositionList& addCurveList);

	/**
	 * 创建三角网
	 * 
	 * \return 
	 */
	int CreateDelaunayMap();
	int CreateDelaunayMap(POSITION& posCurve, CPositionList& addCurveList);

	/**
	 * 对选中的点进行抽稀，剔除一些点 
	 * 
	 * \param minSpacing 最小间距
	 * \return 
	 */
	int SimplifySelectPoints(double minSpacing);

	void ReloadTrackerPath(void);
	
	/**
	 * 删除选中的图元
	 * 
	 */
	virtual int DeleteSelection(void);

	void InvalidateSelection(void);

	QTransformTracker& GetTracker();

	//HTracker * GetTracker();
	void EnableTracker(bool bEnbale);
	//QTransformTracker* GetQTracker(void);
	bool InitItemForGrid();
	CPositionList m_selection; // 被选中的图元列表
	CRect8 m_lastRect; // 记录最后一次选中时的 Rect
	int GetSelectedCount(void);
	bool GetPointsZRange(double& zMin, double& zMax);
	bool SetPointsColor(CString colorItemsData, double dWidth, double dHeight);
	void SelectWithinRect(CRect8 rect, BOOL bAdd = FALSE);
	void SetEnableRotate(bool enable);

protected:
	vector<int> SelectTypes;
	void CloneSelection();
	void Remove(POSITION posObj);

	int nDragHandle;
	CRect8 m_posRect;

	bool m_bPointTextSelected;	//是否是点元素的文本部分被选中
	CItem  * m_pItemForGrid;
	//HTracker m_tracker;
	QTransformTracker  m_Tracker;
	bool m_bTrackerEnable;
	bool m_bEnableRotate;
	
public:
	vector<int>& GetSelectTypes() { return SelectTypes; }
	void SetSelectTypes(int* types, int size);
	void Deselect(POSITION posObj);
	void LoadRectPath(Gdiplus::GraphicsPath &path, CRect8 rect);
	void LoadCurvePath(Gdiplus::GraphicsPath& path, CCurveEx* pc);
	void LoadPath(POSITION pos);
	void LoadPath(COne* pOne);
	int EndTransformSelection(UINT nFlags, CPoint point, int handle);
	BOOL TransformSelection(float* matrix, int nMode, void* pActionItem);

	void SelectSameLayer(void);
	void SelectSameProperty(void);
	void Select(POSITION posObj, BOOL bAdd, CPoint2D& point);
	void Select(POSITION posObj, BOOL bAdd = FALSE);
	void Select(CPositionList& select, BOOL bAdd = FALSE);

	int CurveInRegion(CCurveEx* pCurve, CCurveEx* pRgn);
	int IsInside(CCurveEx* pRgn, CRect8& rgnRange, COne* pOne);
	int SelectInCurve();
	int SelectInCurve(int elementType);
	int SelectInCurveEx(double factor);
	int SelectInCurveEx(int elementType, double factor);
	int SelectSamePropertyElements();
	void MakeViewData(COne * pOneSelect, CString &strSelect);
	int SelectByNames(CString& data);
	void SelectAll(void);
	void ClearAll(CDC* pDC);
	void ReversalSelectAll(void);
	void SelectAll(UINT nElementType, BOOL bAdd = FALSE);
	virtual void CancelSelection(void);
	BOOL IsSelected(POSITION pos);

	int GetCountSelected(void);
	void OffsetSelected(double dx, double dy);
	CRect8 GetSelectedRect(void);
	CRect GetTrackerRect();
	
	void DeleteItemGrid(void);
	void GetSelectedNames(CString& names);
	bool Past(int nPasteMode);	//0=粘贴到当前文件，1=粘贴到当前层，2=粘贴为符号
	void PasteNative(CXy* pDraw, CPositionList& list, COleDataObject& dataObject, bool bPasteInCurrentLayer);
	void Serialize  (CXy* pDraw, CPositionList& list, CArchive& ar,               bool bPasteInCurrentLayer);
	bool WriteData(CXy* pDraw, BYTE*& outBuffer, int& destLen, int formatCode);
	POSITION PasteEmbedded(CXy* pDraw, COleDataObject& dataObject, CPoint point);
	void Copy(void);

	BOOL IsSameType(void);					//选中的信息类型是否统一
	BOOL IsElementType(int nElementType);	
	BOOL IsCanPaste(void);

	CItem* GetItemForGrid(void);
	CItem* FindItemForGrid(POSITION pos, BOOL bMulElement=FALSE);
	BOOL IsCanMoveCoor(COne* pOne);

	POSITION SelectionToFillPath(void);
	POSITION GroupSelectionToSymbol();
	POSITION GroupSelectionToBlock();
	BOOL UngroupAll(int& layerCount);
	BOOL UngroupSymbol(POSITION pos, bool nReplaceExist, int& layerCount);

	BOOL IsSelectionChanged;
	CItem* GetItem() {
		return m_pItemForGrid;
	}

	void SetItem(CItem * pOther) {
		this->m_pItemForGrid = pOther;
	}

	/**
	 * 获取所有被选中的图元
	 * 
	 * \return 
	 */
	std::list<COne*> SelectionCones();

	/**
	 * 获取选中的点数量，如果是选中了一个封闭曲线，将返回封闭曲线内的点数量
	 */
	int PointCount();

	/**
	 * 元文件打散 （emf）
	 * \param pos 当前选中图元
	 * \return
	 */
	int DisperseMetaEmf(POSITION pos, CXy* pXy, long timestamp);

	/**
	 * 保存当前图元为KML
	 * \param pos 当前选中图元
	 * \return
	 */
	int SaveSelectKml(POSITION pos, CXy* pXy, CString path);

protected:
	CXy* SelectionToXy();
	
private:	
	/**
	 * 获取选中的所有多边形，如果存在未闭合，但是首尾相距不大的情况，将统计一个新的闭合曲线
	 * 
	 * \return 
	 * \note 它返回的是创建新的多边形，需要手动释放
	 */
	std::vector<CCurveEx*> CollectPolygons();

	/**
	 * 判断该图元是否可以并且可编辑
	 * 
	 * \param pOne
	 * \return 
	 */
	static bool COneVisibleAndEditable(COne *pOne);

	/**
	 * 收集目标图层的所有折线
	 * 
	 * \param layer 图层名称
	 * \return 
	 */
	std::list<CPolyline> CollectLayerPolyline(CString layer);

	/**
	 * 获取边框内的断层线
	 * 
	 * \param pBlock 边框线
	 * \param layerName 断层层位
	 * \return 
	 */
	std::list<CCurveEx*> CollectFlts(CCurveEx *pBlock);

	/**
	 * 获取边框内的井
	 * 
	 * \param pBlock 边框线
	 * \return 
	 */
	std::vector<CWellPoint> CollectWells(CCurveEx *pBlock);

	/**
	 * 返回井后的第一个图元
	 * 
	 * \return 
	 */
	POSITION FirstPositionAfterWell();

	/**
	 * 绘制结果到图层
	 * 
	 * \param layerName 图层名称
	 * \param result    三角网或龟背图
	 * \param addCurveList 用作撤消的列表
	 */
	void DrawResultToLayer(CString layerName, std::list<CPolyline>& result, CPositionList& addCurveList);

	/**
	 * 绘制三角网
	 * 
	 * \param flts   断层
	 * \param wells  井
	 * \param border 边框线
	 * \param results 出参，绘制后的线
	 * \return
	 */
	int DrawDelaunay(std::list<CPolyline> &flts, std::vector<CWellPoint> &wells, CPolyline &border, std::list<CPolyline> *results);

	/**
	 * 绘制龟背图
	 * 
	 * \param flts   断层
	 * \param wells  井
	 * \param border 边框线
	 * \param results 出参，绘制后的线
	 * \return 
	 */
	int DrawVorono(std::list<CPolyline> &flts, std::vector<CWellPoint> &wells, CPolyline &border, std::list<CPolyline> *results);

	/**
	 * 通过三角网获取井信息
	 * 
	 * \param flts 三角网折线
	 * \return 
	 */
	std::vector<CWellPoint> GetWellByDelaunay(std::list<CPolyline> &flts);

	std::list<COne*> PositionsToCones(CPositionList &list);

	/**
	 * 获取框选区域的 PointXYZ
	 * 
	 * \return 
	 */
	std::vector<CPointXYZ> SelectedPointXYZs();

	/**
	 * 获取封闭曲线内的点
	 * 
	 * \param curves 封闭曲线
	 * \return 
	 */
	std::vector<CPointXYZ> GetPointsInCurves(std::vector<CCurveEx *> &curves);

	/**
	 * 找出需要被删除的点，即不再抽稀结果列表中的点
	 * 
	 * \param removedPoints 抽稀出来的点
	 * \param needRemoved 出参，要被删除的节点
	 * \return 
	 */
	int FindNeedRemovePoints(const std::vector<CPointXYZ> &removePoints, CPositionList &needRemoved);

	/**
	 * 
	 * \param points
	 * \param idxReserved
	 * \param 
	 * \return 
	 */
	static bool CPointXYZIdxContains(const std::vector<CPointXYZ> &points, const CPointXYZ &point);

	/**
	 * 获取没有上下标的文本，只是移除了上下标，上下标里面的文字还在
	 * 
	 * \param text
	 * \return 
	 */
	CString RemoveSuperSubscript(const CString& text);

	/**
	 * 获取上下标内容拼接成的字符串
	 * 
	 * \param text
	 * \return 
	 */
	CString GetSuperSubscript(const CString& text);
};

}