// GISDlg.cpp : implementation file
//

#include "stdafx.h"
#include "GISDlg.h"
#include <math.h>
#include "label.h"
//#include <atlimage.h>
#include "shapedrawingoptions.h"
#include "shape.h"
#include "labelcategory.h"
#include "ScreenCapture.h"
#include "SetSaveLineID.h"

//#include "8BMapDLL_type.h"

#include <fstream>
#include <sstream>
#include <iostream>
#include "vectortoraster.h"
#include "SaveLineEditSetting.h"
#include "ModifyLinePointDlg.h"

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

/////////////////////////////////////////////////////////////////////////////
// CGISDlg dialog

const double DEG2RAD = 0.017453292519943295769236907684886127134428718885417;

DWORD LineClr[15] = {RGB(0,255,0),RGB(255,0,0), RGB(0,0,255),RGB(128,128,0), RGB(0,0,0),RGB(0,255,0),RGB(255,0,0), RGB(0,0,255),RGB(128,128,0), RGB(0,0,0),RGB(0,255,0),RGB(255,0,0), RGB(0,0,255),RGB(124,252,0/*127,255,170*/), RGB(0,0,0)}; 

//�������ݶ�ʱ���ص�����
void FAR PASCAL CatchMTimerDraw(WORD IDEvent, WORD uReserved, DWORD dwUser,DWORD dwReserved1,DWORD dwReserve2)
{
	::PostMessage(g_mapHwnd, WM_SEND_DRAWUAV, FALSE, 0);
}

CGISDlg::CGISDlg(CWnd* pParent /*=NULL*/)
: CBCGPDialog(CGISDlg::IDD, pParent)
{
	EnableVisualManagerStyle(TRUE, TRUE);
	//{{AFX_DATA_INIT(CGISDlg)
	// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT

	m_MsgHwnd = NULL;
	m_MsgID = 0;      //���������ϢID
    m_LineLoadMsgID=0;  //װ������  
	m_drawPlanFlyLine = -1;

	//��γ�ȶԻ�����ʾ��ʶ
	m_bHaveShowLonLatDlg = false;

	//�º�����ƶԻ�����ʾ��ʶ
	m_bHaveShowLineDesign = false;

	//2��֮���ˮƽ���������ʾ�ı�ʶ
	m_bHaveShowDistanceDlg = false;

	//�Ƿ��Ѿ������˵�ͼ
	m_bHaveAddMap = false;

	

	for (int i = 0;i<3;i++)
	{
		//�������ͼ��ID
		m_flyTrackLayerID[i] = -1;

		//UAV�������ͼ��ID
		m_UAVFlyTrackLayerID[i] = -1;

		//�Ƿ��Ѿ���������˻��ķ��й켣
		m_bFirstDrawUAVTrack[i] = false;

		m_drawTrackPtNum[i] = 0;
	}
	//
	for (int i = 0;i<MAX_PLANE_NUM_ADS;i++)
	{
		//�������ͼ��ID
		//m_flyTrackLayerID[i] = -1;

		//UAV�������ͼ��ID
		m_UAVFlyTrackLayerID_ADS[i] = -1;

		m_bWithin100km_ADS[i] = false;
	}
	m_iCurrentADSid = 0;
	m_iTotalADSnum = 0;

	//��ͼ��ʾ�����ȡ��߶ȵ���
	m_onePerWidth = 0;
	m_onePerHeight = 0;

	m_mapAreaHalfWidth = 0;
	m_mapAreaHalfHeight = 0;

	//�������״̬
	m_bLineDesign = false;

	//��������������
	m_ptNum = 18;

	//������
	memset(m_ppUavPtArray,0,sizeof(double)*18*2);
	memset(m_ppUavPtArray_ADS,0,sizeof(double)*18*2);

	m_ptPlane[0] = CPoint(0, -13);
	m_ptPlane[1] = CPoint(2, -9);
	m_ptPlane[2] = CPoint(2, -6);
	m_ptPlane[3] = CPoint(12, 4);
	m_ptPlane[4] = CPoint(12, 6);
	m_ptPlane[5] = CPoint(2, 2);
	m_ptPlane[6] = CPoint(1, 10);
	m_ptPlane[7] = CPoint(3, 12);
	m_ptPlane[8] = CPoint(3, 13);
	m_ptPlane[9] = CPoint(0, 13);
	m_ptPlane[10] = CPoint(-3, 13);
	m_ptPlane[11] = CPoint(-3, 12);
	m_ptPlane[12] = CPoint(-1, 10);
	m_ptPlane[13] = CPoint(-2, 2);
	m_ptPlane[14] = CPoint(-12, 6);
	m_ptPlane[15] = CPoint(-12, 4);
	m_ptPlane[16] = CPoint(-2, -6);
	m_ptPlane[17] = CPoint(-2, -9);

	m_ptPlane_ADS[0] = CPoint(0, -13);
	m_ptPlane_ADS[1] = CPoint(2, -9);
	m_ptPlane_ADS[2] = CPoint(2, -6);
	m_ptPlane_ADS[3] = CPoint(12, 4);
	m_ptPlane_ADS[4] = CPoint(12, 6);
	m_ptPlane_ADS[5] = CPoint(2, 2);
	m_ptPlane_ADS[6] = CPoint(1, 10);
	m_ptPlane_ADS[7] = CPoint(3, 12);
	m_ptPlane_ADS[8] = CPoint(3, 13);
	m_ptPlane_ADS[9] = CPoint(0, 13);
	m_ptPlane_ADS[10] = CPoint(-3, 13);
	m_ptPlane_ADS[11] = CPoint(-3, 12);
	m_ptPlane_ADS[12] = CPoint(-1, 10);
	m_ptPlane_ADS[13] = CPoint(-2, 2);
	m_ptPlane_ADS[14] = CPoint(-12, 6);
	m_ptPlane_ADS[15] = CPoint(-12, 4);
	m_ptPlane_ADS[16] = CPoint(-2, -6);
	m_ptPlane_ADS[17] = CPoint(-2, -9);

	//��ͼ��ʾ�������Ͻ�X����
	m_leftTopX = 0;

	//��ͼ��ʾ�������Ͻ�Y����
	m_leftTopY = 0;

	//Ŀ����SHPͼ��ID��
	m_targetPtShapeID = 0;

	//�Ƿ��Ѿ�������SHPĿ���עͼ��
	m_bHaveCreateTargetShp = false;

	//��עƫ����
	m_labelWarpValue = 15;

	//�ܹ���Ŀ������
	m_totalPointNum = 512;

	//�º�����Ƶĺ����������	2016.01.06
	m_MaxNumofLinePt = 255;
// 	m_pNewDesignLineStruct = new tmpPT[m_MaxNumofLinePt];				//��������
// 	memset(m_pNewDesignLineStruct, 0, sizeof(tmpPT)*m_MaxNumofLinePt);	//��ʼ��

	m_pNewDesignLineStruct = new PtStruct[m_MaxNumofLinePt];				//��������
	memset(m_pNewDesignLineStruct, 0, sizeof(PtStruct)*m_MaxNumofLinePt);	//��ʼ��

	m_NowNumLineDesign = 0;												//��ǰ����ĸ���

	m_lineMaxPointNum = 255;											//һ���������ĺ������
	m_pDesignLineStruct = new PtStruct[m_lineMaxPointNum];				//��������
	memset(m_pDesignLineStruct, 0, sizeof(PtStruct)*m_lineMaxPointNum);  //��ʼ��
	m_designLinePointNum = 0;					  						 //��ǰ�������

	//���߱��ͼ��ID��ʼ��
	m_designLineLayerID = -1;
	m_designLineLayerID2 = -1;

	//Ŀ�����ͼ���ID��
	m_targetDrawLayerID = -1;

	//��ʱ���ͼ��
	m_tempLayerID = -1; 
	/****************����<�༭����>����***********************************/
	/*****by Wu 2023.09.11*******/
	//ѡ�и���ͼ��
	m_highLightLineLayerID = -1;
	//���ε�ͼ��
	m_tempTerrainPointsLayerID = -1;
	m_tempshpPointLayerID = -1;
	m_tempshpLineLayerID = -1;
	//�洢������ID
	circlingPointID = -1;   
	m_lineSelectedID = -1;

	GLOBAL_X = 0;
	GLOBAL_Y = 0;

	//�༭���պ���״̬
	m_bEditLine = false;
	//���պ�����ʾ״̬
	//m_bShowBackLine = false;
	//��ק�ƶ���־
	m_dragFlag = false;
	// ѡ��ģʽ
	m_bSelectFeatureFlag = false;

	//
	m_KTPtShpLayerID = -1;  //��Ͷ��ͼ��
	//m_pDesignKTLineDlg = NULL;
	/****************/

	/*****By Wu 2023.10.16********/
	m_distLabelLayer = -1; //�༭ʱ��ʾ��λ�Ǻ;���

	//�������ر�����ʼ��
	m_bPolylineMeasure = false;  //������־
	m_numPolylineMeasurePts = 0;     //������
	m_bMeasureDrag = false;   //�Ƿ��������
	//���������������߶�ͼ��
	m_polylineMeasureLineLayerID = -1;

	//��ע������������ע��ͼ��
	m_polylineMeasureLabelLayerID = -1;

	//�����������ĵ���ŵı�עͼ��
	m_polylineMeasurePtLayerID[0] = -1;
	m_polylineMeasurePtLayerID[1] = -1;
	/************************************************************/
	//��ʶ�Ƿ�����ʱͼ���Ͻ��б�ע
	m_beTemLayerDrawing = true;

	//��ǰ��Ƶĺ�������	
	memset(&m_curDesignPoint, 0, sizeof(PtStruct));

	//�Ƿ��Ѿ������µĺ���
	m_bAddNewPoint = false;

	int i = 0;
	int j = 0;

	//////////////////�뺽����ʾ��ص�������/////////////////////
	m_totalFlyLines = 14;     //�ܵķ��к�����ԭ5��Ϊ14 20221121

	DrawLineDataStruct m_pFlyLines[14]; //���к��������� ԭ5 ��Ϊ12
	memset(m_pFlyLines, 0, sizeof(DrawLineDataStruct)*m_totalFlyLines);


	m_flyLineNum = 0;		 //�������

	//���к��߱�ע��
	m_flyLinesLayerID = -1;

	//�Ƿ��Ѿ����������˻�����Shp��ͼ��
	m_bHaveCreateUAVShpLayer = false;

	//���˻�����Shp��ͼ��ID
	m_uavShapileLayerID = -1;

	//���߱��ͼ���Shpͼ��ID���飬ÿ�����߾���2�����ͼ�㣺1��ͼ��Ϊ���㡢��һ��ͼ��Ϊ����//5��Ϊ8 20221121
	long m_ppPlanLineShpLayerIDArr[14][2];
	for (i=0; i<14; i++)
	{
		for (j=0; j<2; j++)
		{
			m_ppPlanLineShpLayerIDArr[i][j] = -1;
		}
	}

	//�����Ƿ��Ѿ����ı�־
	for (i=0; i<14; i++)
	{
		m_pHaveDrawLineFlag[i] = false;
	}

	m_pLineSectDlg = NULL;
	m_pTargetDlg = NULL;

	//��һ�������Ƿ��Ѿ����
	m_bDesignFirstPoint = true;

	m_pFlyLineDesign = NULL;

	m_pLineDesign = NULL;

	m_bShowToolBar = false;

	//����վλ��
	g_gcsLon = 0;   //����
	g_gcsLat = 0;   //�
	g_gcsAlt = 0;   //�߶�

	memset(&m_guidePtInfo, 0, sizeof(GuidePointData));

	//����վλ�õ�ʸ��ͼ��
	m_gcsPtShpLayerID = -1;

	//������λ�õ�ʸ��ͼ��
	m_guidePtShpLayerID = -1;

	//��ǰ���༭�ĺ�������
	memset(&m_curEditLinePoint, 0, sizeof(PtStruct));
	//Ŀ���ʸ��ͼ��ID��	
	//memset(m_pTargetShapfileID, 0, sizeof(long)*MAX_TARGET_NUM);

	//�������߶�
	m_toolbarHeight = 0;

	//�Ƿ�����Զ����εı�ʶ
	m_bAutoMove = true;

	memset(m_pCallBackShapfileID, 0, sizeof(long)*255);

	//������ģʽ
	m_guidePointMode = 0;

	m_bGuideMode =false ;//��������ģʽĬ��Ϊfalse
	///////
	m_bSetPointModel=false;     //û�д����õ㹤��ģʽ
	m_bEndSetPoint=false;
	m_iPtSel=-1;

	m_bLDSetPoint = FALSE;

	m_canvasLayerID = -1;

	memset(&m_infoData,0,sizeof(m_infoData));

	m_targetSelID = 0;

	m_bSelectDropPoint = false;

	m_gisManager = GISManager::getInstance();

	for (int i=0;i<g_iDemAltPtNum;i++)
	{
		g_lDemAltLayerID[i]  = -1;
		g_lDemAltDisLayerID[i] = -1;
		g_lDemPtNumLayerID[i] = -1;
	}

	m_bPlotDemArea = false;

	m_bEnableShowADSB = true;

}


CGISDlg::~CGISDlg()
{
	timeKillEvent(TimerID_Draw);

	if(m_Layer != NULL) 
	{
		delete m_Layer;
		m_Layer = NULL;
	}

	if (m_pLonLatDlg != NULL)
	{
		delete m_pLonLatDlg;
		m_pLonLatDlg = NULL;
	}

	if (m_pHZDistanceDlg != NULL)
	{
		delete m_pHZDistanceDlg;
		m_pHZDistanceDlg = NULL;
	}

	if (m_pFlyLineDesign != NULL)
	{
		delete m_pFlyLineDesign;
		m_pFlyLineDesign = NULL;
	}

	if (m_pLineDesign != NULL)
	{
		delete m_pLineDesign;
		m_pLineDesign = NULL;
	}


	if (m_pDesignLineStruct != NULL)
	{
		delete []m_pDesignLineStruct;
		m_pDesignLineStruct = NULL;
	}

	//2016.01.06
	if (m_pNewDesignLineStruct != NULL)
	{
		delete []m_pNewDesignLineStruct;
		m_pNewDesignLineStruct = NULL;
	}

	if (m_pLineSectDlg != NULL)
	{
		delete m_pLineSectDlg;
		m_pLineSectDlg = NULL;
	}	
	
	if (m_pTargetDlg != NULL)
	{
		delete m_pTargetDlg;
		m_pTargetDlg = NULL;
	}

	if(m_gisManager != NULL)
	{
		m_gisManager->DestroyObject();
		m_gisManager = NULL;
	}
}


void CGISDlg::DoDataExchange(CDataExchange* pDX)
{
	CBCGPDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_MAP1, m_map);
}


BEGIN_MESSAGE_MAP(CGISDlg, CBCGPDialog)

	//{{AFX_MSG_MAP(CGISDlg)
	ON_WM_MOUSEMOVE()
//	ON_WM_MOUSEWHEEL()
	ON_COMMAND(ID_ADDPOINT, OnAddpoint)
	ON_MESSAGE(WM_SET_LAYER_STATUS, OnSetLayerStatus)
	ON_MESSAGE(WM_CLOSE_LONLAT_DIALOG, OnCloseLonLatDialog)
	ON_MESSAGE(WM_CLOSE_DISTANCE_DIALOG, OnCloseShowDistanceDialog)
	ON_MESSAGE(WM_CLOSE_LINEDESIGN_DIALOG, OnCloseLineDesignDialog) 
	ON_MESSAGE(WM_ADD_LINE_POINT, OnAddLinePoint)			  //���Ӻ���
	ON_MESSAGE(WM_EDIT_LINE_POINT, OnEditLinePoint)			  //�༭����
	ON_MESSAGE(WM_DELETE_LINE_POINT, OnDeleteLinePoint) 	  //ɾ������
	ON_MESSAGE(WM_SAVE_LINE_POINTS, OnSaveLinePoints) 		  //���溽��       
	ON_COMMAND(IDT_BUTTON1, OnAddMapData)					 //���ص�ͼ����
	ON_COMMAND(IDT_BUTTON2, OnAddRasterImage)				 //����դ��Ӱ������
	ON_COMMAND(IDT_BUTTON3, OnAddFlyLineData)				 //���غ�������
	ON_COMMAND(IDT_BUTTON4, OnLayerManage)					 //ͼ�����
	ON_COMMAND(IDT_BUTTON5, OnRemoveAllLayers)				 //�������ͼ��
 	ON_COMMAND(IDM_DESIGN_MYFLYLINE, OnFlyLineDesign)		//�������		2015.11.25	���κ�����ƶԻ���
	ON_COMMAND(IDT_BUTTON6, OnMenuLinePtCtrlShow/*OnMapSelect*/)					 //��ͼѡ��
	ON_COMMAND(IDT_BUTTON7, OnMapZoomIn)					 //��ͼ�Ŵ�
	ON_COMMAND(IDT_BUTTON8, OnMapZoomOut)					 //��ͼ��С
	ON_COMMAND(IDT_BUTTON9, OnMapMove)						 //��ͼ����	
	ON_COMMAND(IDT_BUTTON10, OnMapFullScreen)				 //��ͼȫ����ʾ
	ON_COMMAND(IDT_BUTTON11, OnEraseTrack)					 //�������
	ON_COMMAND(IDT_BUTTON12, OnShowLonLatInfo)				 //��ʾ��γ����Ϣ
	ON_COMMAND(IDT_BUTTON13, OnSurvey)						 //����2��֮��ľ���
	ON_COMMAND(IDT_BUTTON14, OnShowCtrlMenu/*OnPrint*/)			//��������		  	 //��ӡ���	
	ON_COMMAND(IDT_BUTTON15, OnZhangCW)					  	 //��ӡ���	
	ON_NOTIFY_EX(TTN_NEEDTEXT,0,OnToolTipsNotify)			 //��ť������ʾ	
	ON_COMMAND(IDM_GUIDE_FLY1, OnGuideMode1)
	ON_COMMAND(IDM_DESIGN_MYFLYLINE, OnDesignLine)
	ON_UPDATE_COMMAND_UI(IDM_GUIDE_FLY1, OnUpdateGuideMode1)
	ON_COMMAND(IDM_GUIDE_FLY2, OnGuideMode2)
	ON_UPDATE_COMMAND_UI(IDM_GUIDE_FLY2, OnUpdateGuideMode2)
	ON_COMMAND(IDM_SHOW_LINE1, OnShowLine1)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE1, OnUpdateLineDisplay1)
	ON_COMMAND(IDM_SHOW_LINE2, OnShowLine2)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE2, OnUpdateLineDisplay2)
	ON_COMMAND(IDM_SHOW_LINE3, OnShowLine3)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE3, OnUpdateLineDisplay3)
	ON_COMMAND(IDM_SHOW_LINE4, OnShowLine4)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE4, OnUpdateLineDisplay4)
	ON_COMMAND(IDM_SHOW_LINE5, OnShowLine5)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE5, OnUpdateLineDisplay5)
	ON_COMMAND(IDM_AUTO_MOVE, OnAutoMove)
	ON_UPDATE_COMMAND_UI(IDM_AUTO_MOVE, OnUpdateAutoMov)
	ON_MESSAGE(WM_CHECK_FLY_LINE_STATUS, OnCheckFlyLineShowStatus)
	ON_COMMAND(IDM_REMOVE_GUIDE_DRAW, OnRemoveGuidePtDraw)
	ON_COMMAND(IDM_OPEN_FLYLINE, OnAddFlyLineData)
	ON_COMMAND(ID_ENDDESIGN, OnEnddesign)
	//}}AFX_MSG_MAP

	ON_COMMAND(ID_CLEARPOINT, OnClearpoint)
	ON_COMMAND(ID_EDITPOINT, OnEditpoint)
	ON_COMMAND(ID_DELPOINT, OnDelpoint)
	//ON_COMMAND(IDM_BINDLINE1, &CGISDlg::OnBindline1)
	ON_COMMAND(IDM_BINDLINE2, OnBindline2)
	ON_COMMAND(ID_LOAD_MYLINE1, OnLoadMyline1)
	ON_COMMAND(IDM_BINDLINE3, OnBindline3)
	ON_COMMAND(IDM_BINDLINE4, OnBindline4)
	ON_COMMAND(IDM_BINDLINE5, OnBindline5)
	ON_COMMAND(IDM_LAYERMNG, OnLayermng)
	ON_COMMAND(IDM_ADDGTARGET, OnAddgtarget)

	//ON_MESSAGE(MESSAGE_DRAWZK, &CGISDlg::DRAW_ZK)

	//	ON_WM_MOUSEHWHEEL()
	ON_COMMAND(ID_NLINEDESIGN, &CGISDlg::OnNlinedesign)
	ON_UPDATE_COMMAND_UI(ID_NLINEDESIGN, &CGISDlg::OnUpdateNlinedesign)
	ON_COMMAND(ID_SHOW_PD10, &CGISDlg::OnShowPd10)
	ON_UPDATE_COMMAND_UI(ID_SHOW_PD10, &CGISDlg::OnUpdateShowPd10)
	ON_COMMAND(ID_SHOW_HS11, &CGISDlg::OnShowHs11)
	ON_UPDATE_COMMAND_UI(ID_SHOW_HS11, &CGISDlg::OnUpdateShowHs11)
	ON_COMMAND(ID_BIND_HS11, &CGISDlg::OnBindHs11)
	ON_COMMAND(ID_SHOW_TC12, &CGISDlg::OnShowTc12)
	ON_COMMAND(ID_BIND_TC12, &CGISDlg::OnBindTc12)
	ON_UPDATE_COMMAND_UI(ID_SHOW_TC12, &CGISDlg::OnUpdateShowTc12)
	ON_WM_SIZE()
	ON_COMMAND(ID_32855, &CGISDlg::On32855)
	ON_WM_MOVE()
	ON_MESSAGE(WM_SEL_UAV, &CGISDlg::OnSelUav)
	ON_COMMAND(ID_ADD_TARGET, &CGISDlg::OnAddTarget)
	ON_MESSAGE(WM_DRAW_TARGET, &CGISDlg::OnDrawTarget)
	ON_WM_SHOWWINDOW()
	ON_COMMAND(ID_TARGET_DELETE, &CGISDlg::OnTargetDelete)

	ON_MESSAGE(WM_SEND_SELECTTARGET, &CGISDlg::OnSendSelectTarget)
	ON_MESSAGE(WM_SEND_CLOSEDEMALT, &CGISDlg::OnSendCloseDemAlt)

	ON_MESSAGE(WM_SHOW_POINTINMAP, &CGISDlg::OnShowPointInMap)
	ON_MESSAGE(WM_SHOW_ISVISIBLE, &CGISDlg::OnShowPointVisible)
	ON_MESSAGE(WM_SHOW_NOTVISIBLE, &CGISDlg::OnShowPointNotVisible)
	ON_MESSAGE(WM_SEND_CLEARSHAPE, &CGISDlg::OnSendClearShape)

	ON_MESSAGE(WM_SHOW_VISI_REALTIME, &CGISDlg::OnShowAreaVisible)
	ON_MESSAGE(WM_SHOW_NOTVISI_REALTIME, &CGISDlg::OnShowAreaNotVisible)
	ON_MESSAGE(WM_SHOW_VISI_DELETE, &CGISDlg::OnShowClearArea)
	ON_MESSAGE(WM_ADD_LINELAYER, &CGISDlg::OnAddLineLayer)
	ON_MESSAGE(WM_DEL_LINELAYER, &CGISDlg::OnDelLineLayer)
	ON_MESSAGE(WM_SEND_REGIONTOGIS, &CGISDlg::OnSendRegionToGis)
	ON_MESSAGE(WM_DRAW_LINEPOINT, &CGISDlg::OnDrawLinePoint)
	ON_MESSAGE(WM_SHOW_CRASH_REALTIME, &CGISDlg::OnShowCrashArea)
	ON_MESSAGE(WM_SEND_DRAWFIGHT, &CGISDlg::OnSendDrawFight)
	ON_MESSAGE(WM_SEND_DRAWDEMREGION, &CGISDlg::OnSendDrawDemRegion)

	ON_MESSAGE(WM_SEND_MAPLOCATION,&CGISDlg::OnZoomToLocation)

	ON_COMMAND(ID__MENU_LIGHTREGION, &CGISDlg::OnMenuLightRegion)
	ON_COMMAND(ID_MENU_ENTRYPOINT, &CGISDlg::OnMenuEntryPoint)
	ON_COMMAND(ID_MENU_PLOTDEMAREA, &CGISDlg::OnMenuPlotdemArea)

	ON_MESSAGE(WM_SEND_MAPCURSORMODE, &CGISDlg::OnSetMapCursorMode) //����Map CursorMode
	ON_MESSAGE(WM_SEND_DRAWMARKER, &CGISDlg::OnDrawMarker) //��ʾ�����ر�ǵ�
	ON_COMMAND(ID_MENU_CLEARGCS, &CGISDlg::OnMenuClearGCS)
	ON_COMMAND(ID_MENU_ADSB, &CGISDlg::OnMenuADSB)

	ON_MESSAGE(WM_SEND_DRAWUAV, &CGISDlg::OnTimerDrawUAV) //�������˻�

	//���߱༭    // -----by Wu 2023.09.14
	ON_COMMAND(ID_SELECT_LINE, OnMapSelect)  //ѡ����
	ON_COMMAND(ID_EDIT_NODE, OnEditLine)  //�༭����
	ON_COMMAND(ID_EDIT_LINE, ShowModifyPointDlg)	//�޸ĺ���
	ON_COMMAND(ID_EDIT_SAVE, ShowEditSaveDlg)	//����༭
/*
	ON_COMMAND(ID_MODIFY_LINEPOINT, OnMapSelect);  //�޸ĺ��㺽��
	ON_COMMAND(ID_EDIT_SAVE, OnMapSelect);  //����༭*/
	

/*
	//��������6-8
	ON_COMMAND(IDM_SHOW_LINE6, &CGISDlg::OnShowLine6)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE6, &CGISDlg::OnUpdateShowLine6)
	ON_COMMAND(IDM_SHOW_LINE7, &CGISDlg::OnShowLine7)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE7, &CGISDlg::OnUpdateShowLine7)
	ON_COMMAND(IDM_SHOW_LINE8, &CGISDlg::OnShowLine8)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE8, &CGISDlg::OnUpdateShowLine8)
	ON_COMMAND(IDM_BINDLINE6, &CGISDlg::OnBindline6)
	ON_COMMAND(IDM_BINDLINE7, &CGISDlg::OnBindline7)
	ON_COMMAND(IDM_BINDLINE8, &CGISDlg::OnBindline8)
	ON_COMMAND(IDM_SHOW_LINE9, &CGISDlg::OnShowLine9)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE9, &CGISDlg::OnUpdateShowLine9)
	ON_COMMAND(IDM_SHOW_LINE10, &CGISDlg::OnShowLine10)
	ON_UPDATE_COMMAND_UI(IDM_SHOW_LINE10, &CGISDlg::OnUpdateShowLine10)
	ON_COMMAND(IDM_BINDLINE9, &CGISDlg::OnBindline9)
	ON_COMMAND(IDM_BINDLINE10, &CGISDlg::OnBindline10)*/
	END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CGISDlg message handlers


BOOL CGISDlg::OnInitDialog()
{
	CBCGPDialog::OnInitDialog();	

	SetWindowPos(NULL,0 ,0 ,600, 700, SWP_NOZORDER|SWP_NOMOVE);

	//���ܣ���������������
	CreateFloatToolBar();
	//���ھ��
	g_mapHwnd = this->GetSafeHwnd();

	//����ͼ������Ի���
	m_Layer = new CMapLayerManage();
	m_Layer->Create(IDD_DIALOG_LAYER_MANAGE); 

	//������ȫ��Ļ�е�GIS��ʾ����
	m_gisAreaInScreen = m_rcGISArea;
	m_gisAreaInScreen.top += 32;

	//������γ�ȶԻ���
	m_pLonLatDlg = new CLonLatDlg();
	m_pLonLatDlg->MoveToGivenArea(m_gisAreaInScreen);
	m_pLonLatDlg->Create(IDD_XY_DIALOG); 

	//2��֮���ˮƽ������ʾ�Ի������
	m_pHZDistanceDlg = new CShowHZDistanceDlg();
	m_pHZDistanceDlg->MoveToGivenArea(m_gisAreaInScreen);
	m_pHZDistanceDlg->Create(IDD_DISTANCE_DIALOG); 

	//������ƶԻ���
	m_pFlyLineDesign = new CFlyLineDesign();
	m_pFlyLineDesign->MoveToGivenArea(m_gisAreaInScreen);
	m_pFlyLineDesign->Create(IDD_DIALOG_FLYLINE_DESIGN);

// 	m_pLineDesign = new CLineDesign();
// 	m_pLineDesign->Create(IDD_DLG_LINEDESIGN);

	//�������ʱ���������ݶԻ���
	m_pLineSectDlg = new CLineSectDisAZDlg();
	m_pLineSectDlg->MoveToGivenArea(m_gisAreaInScreen);
	m_pLineSectDlg->Create(IDD_DIALOG_LINE_SECT);

	m_pTargetDlg = new CTargetDlg();
	m_pTargetDlg->Create(IDD_DIALOG_TARGET,this);

	//������ǵ�Ի���
	m_dlgMarker.Create(IDD_DIALOG_MARKER,this);
	m_dlgMarker.MoveToGivenArea(m_gisAreaInScreen);

	//��ͼ��ʾ�����ȡ��߶ȵ���
	m_onePerWidth = 1.0/m_rcGISArea.Width();
	m_onePerHeight = 1.0/m_rcGISArea.Height();

	//��ͼ��ʾ�����ȡ��߶�
	m_mapAreaHalfWidth = 0.5*m_rcGISArea.Width();
	m_mapAreaHalfHeight = 0.5*m_rcGISArea.Height();

	//����
	m_rcgisSmallArea = m_rcGISArea;
	m_rcgisSmallArea.top = 24;	

	//�������߶�
	m_toolbarHeight = m_rcgisSmallArea.top;

	m_ToolBar.ShowWindow(SW_SHOW);  
    m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone); 

	m_gisManager->m_pMapCwnd = GetDlgItem(IDC_MAP1);
	m_gisManager->setMap(&m_map);

	m_dlgLightRegion.Create(IDD_DIALOG_LIGHTREGION,this);

	m_DlgDemAlt.Create(IDD_DIALOG_DEMALT,this);

	//��ý�嶨ʱ��
	timeBeginPeriod(0);
	TimerID_Draw = timeSetEvent(500, 1, (LPTIMECALLBACK)CatchMTimerDraw, (DWORD)NULL, TIME_PERIODIC);
	if(!TimerID_Draw)
	{
		BCGPMessageBox(_T("��ý�嶨ʱ����������!"),MB_OK|MB_ICONEXCLAMATION,0);
	}

	//�������ߵ�ͼ����
	AddTianDiTuService();
	//�������ߵ�ͼ����
	LoadTianDiTuService();

	m_map.SetScalebarVisible(true);  //��ʾ������

	return TRUE;
}

//���ܣ��������ͼ����Ӱ���ͼ����
void CGISDlg::AddTianDiTuService()
{
	string baseurl = "http://{switch:t0,t1,t2,t3,t4,t5,t6,t7}.tianditu.gov.cn/img_w/wmts?service=wmts&request=GetTile&version=1.0.0&LAYER=img&tileMatrixSet=w&TileMatrix={zoom}&TileRow={y}&TileCol={x}&style=default&format=tiles&tk=";
	//string baseurl_vec = "http://t0.tianditu.gov.cn/vec_w/wmts?service=wmts&request=GetTile&version=1.0.0&LAYER=vec&tileMatrixSet=w&TileMatrix={zoom}&TileRow={y}&TileCol={x}&style=default&format=tiles&tk=";
	string key = "53d93c1a8b3400b050817ac001bdb60e";//����Key���շ�������1w�Ρ�
	//string key = "5ff7526440d3a7dab78037697c4679fa";

	mapWindow::ITiles* pTiles = m_map.GetTiles();
	mapWindow::ITileProvidersPtr providers = pTiles->GetProviders();

	//pTiles->ClearCache(mapWindow::tkCacheType::Disk);//�������Tiles����
	//int providerId = (int)mapWindow::tkTileProvider::ProviderCustom + 1;    // (1024 + 1) should be unique across application runs in case disk caching is used
	int providerId = mapWindow::tkTileProvider::ProviderCustom;
	_bstr_t copyright = "TianDiTu,All Rights Reserved";

	bool su = providers->Add(providerId, "TianDiTu",
		(baseurl+key).c_str(),//(_bstr_t)url.c_str(),
		mapWindow::tkTileProjection::SphericalMercator, 0, 18);//,"TianDiTu,All Rights Reserved"

	m_map.put_ZoomBarMaxZoom(18);//�������������18��
	//pTiles->ProviderId = providerId; //���ǰ����
	//Tile��������
	//pTiles->put_UseCache(mapWindow::tkCacheType::Disk,true);//Ĭ������´��ڴ�״̬
	//pTiles->put_UseCache(mapWindow::tkCacheType::RAM, true);//Ĭ������´��ڴ�״̬
	//�������ص���Ƭ���ӵ�������
	//pTiles->put_DoCaching(mapWindow::tkCacheType::RAM, true);//Ĭ������´��ڴ�״̬
	 pTiles->put_DoCaching(mapWindow::tkCacheType::Disk,true);//���Ĭ�Ϲر�
	//��������ھ��д����Ƶ��ļ�������Զ��������ļ���һ��ֻ��ʹ��һ�����ݿ⡣
	//pTiles->put_UseCache(mapWindow::tkCacheType::Disk, true); //Ĭ������´��ڴ�״̬
	 pTiles->put_DiskCacheFilename(_bstr_t("./mwtiles.db3")); 

	//���������͵Ļ��棬�������û������������С�������û���ʱ����ɾ����ɵ���Ƭ���Ա�Ϊ���µ���Ƭ�ڳ��ռ�
	//pTiles->put_MaxCacheSize(mapWindow::tkCacheType::RAM, 200.0); //��С�� MB Ϊ��λ;Ĭ��Ϊ 100
	 pTiles->put_MaxCacheSize(mapWindow::tkCacheType::Disk, 300.0);//��С�� MB Ϊ��λ;Ĭ��Ϊ 100
}

//���ܣ��������ͼ����Ӱ���ͼ����
void CGISDlg::LoadTianDiTuService()
{
	mapWindow::IGlobalSettingsPtr glSettingsPtr;
	glSettingsPtr.CreateInstance("MapWinGIS.GlobalSettings");
	m_map.put_ReuseTileBuffer(true);
	//m_map.SetMouseWheelSpeed(1);//Ĭ��ֵΪ 0.5������ 0.1 - 10.0 ��Χ�ڵ�ֵ��ֵ 1.0 ���ر����������š�

	m_map.put_GrabProjectionFromData(false); //����ͼ��Ϊ0ʱͶӰ�ÿյ������ߵ�ͼ����ʾ
	m_map.put_Projection(mapWindow::tkMapProjection::PROJECTION_WGS84);
	m_map.GetTiles()->ProviderId = mapWindow::tkTileProvider::ProviderCustom;
	m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
	m_map.put_ZoomBehavior(mapWindow::tkZoomBehavior::zbUseTileLevels);
	//m_map.put_KnownExtents(mapWindow::tkKnownExtents::keChina);
	m_map.GetTiles()->Visible = true;
	if (m_map.GetNumLayers()==0)
	{
		m_map.put_Longitude(100);
		m_map.put_Latitude(37);
		//m_map.put_CurrentZoom(4);
		m_map.ZoomToTileLevel(6);
	}
	m_map.Redraw3(mapWindow::RedrawSkipAllLayers, True);
	
	//�Ƿ��Ѿ������˵�ͼ
	m_bHaveAddMap = true;
}

//���ܣ����ŵ�Ŀ��λ��
void CGISDlg::ZoomToLocation(double lon,double lat)
{
	m_map.put_Projection(mapWindow::tkMapProjection::PROJECTION_WGS84);
	m_map.GetTiles()->Visible = true;
	m_map.put_Longitude(lon);
	m_map.put_Latitude(lat);
	m_map.put_CurrentZoom(16);
	m_map.Redraw3(mapWindow::RedrawSkipAllLayers, True);
	//�Ƿ��Ѿ������˵�ͼ
	m_bHaveAddMap = true;
}

//���ܣ����ص�ͼ���ݣ�����ʸ������
void CGISDlg::OnAddMapData()
{
	TCHAR s[10000];
	s[0]=0;
	CFileDialog dlg(true);
	dlg.m_ofn.lpstrTitle=_T("�򿪱����ļ�");
	dlg.m_ofn.lpstrFile=s;
	dlg.m_ofn.nMaxFile=sizeof(s)/sizeof(TCHAR);
	TCHAR filter[500]=_T("SHAPE�ļ�(*.shp)\0*.shp");
	dlg.m_ofn.lpstrFilter=filter;
	dlg.m_ofn.Flags|=OFN_ALLOWMULTISELECT|OFN_ENABLESIZING|OFN_EXPLORER;
	if(dlg.DoModal()==IDCANCEL) return;

	POSITION pos;
	pos=dlg.GetStartPosition();
	CString path;
	long count=0;
	while(pos)
	{
		path=dlg.GetNextPathName(pos);
		count++;
	}	
	pos=dlg.GetStartPosition();
	while(pos)
	{
		path=dlg.GetNextPathName(pos);
		Openlocalfile(path);
	}
	// ��ȡ�ڵ�������Ϣ
	CString fileName = GetSoftwareCurrentDirectory() + "\\map.ini";
	::WritePrivateProfileString("map","layer",path,fileName);

}



//���ܣ�����դ��Ӱ������
void CGISDlg::OnAddRasterImage()
{	
	TCHAR s[10000];
	s[0]=0;
	CFileDialog dlg(true);
	dlg.m_ofn.lpstrTitle=_T("�򿪱����ļ�");
	dlg.m_ofn.lpstrFile=s;
	dlg.m_ofn.nMaxFile=sizeof(s)/sizeof(TCHAR);
	//TCHAR filter[500]=_T("SHAPE�ļ�(*.shp)\0*.shp\0IMG�ļ�(*.img)\0*.img\0GeoTIFF�ļ�(*.tif)\0*.tif\0ASC�ļ�(*.asc)\0*.asc\0�����ļ�(*.*)\0*.*\0");

	TCHAR filter[500]=_T("GeoTIFF�ļ�(*.tif)\0*.tif\0�����ļ�(*.*)\0*.*\0");
	dlg.m_ofn.lpstrFilter=filter;
	dlg.m_ofn.Flags|=OFN_ALLOWMULTISELECT|OFN_ENABLESIZING|OFN_EXPLORER;
	if(dlg.DoModal()==IDCANCEL) return;

	POSITION pos;
	pos=dlg.GetStartPosition();
	CString path;
	long count=0;
	while(pos)
	{
		path=dlg.GetNextPathName(pos);
		count++;
	}	
	pos=dlg.GetStartPosition();
	while(pos)
	{
		path=dlg.GetNextPathName(pos);
		Openlocalfile(path);
	}
	// ��ȡ�ڵ�������Ϣ
	CString fileName = GetSoftwareCurrentDirectory() + "\\map.ini";
	::WritePrivateProfileString("map","layer",path,fileName);
}



//���ܣ����ļ�ѡ��Ի��򣬼��غ��������ļ�
void CGISDlg::OnAddFlyLineData()
{	
	//δ���ص�ͼ������
	if (!m_bHaveAddMap)
	{
		return;
	}	

	if (m_flyLineNum > m_totalFlyLines)
	{
		AfxMessageBox(_T("�Ѽ��غ�����>12��"));
		return;
	}

	//�����ļ��Ի���
	CFileDialog dlg(true, ".txt","*.txt",OFN_HIDEREADONLY, "�����ļ�(*.txt)|*.txt|", NULL);

	if (dlg.DoModal() == IDOK)
	{
		//��ȡ��·�ļ�����������
		OnShowGivenLine(dlg.GetPathName());
	}			
}



//���ܣ����е�ͼ�ķŴ����
void CGISDlg::OnMapZoomIn()	  
{
	
	m_bSetPointModel=FALSE;
	//m_bLineDesign=FALSE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;
	m_map.SetCursorMode(0);  

	m_bLDSetPoint = FALSE;

	m_bSelectFeatureFlag = false;

}

//��ͼ��С
void CGISDlg::OnMapZoomOut()
{
	m_bSetPointModel=FALSE;
	//m_bLineDesign=FALSE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;
	m_map.SetCursorMode(1);

	m_bLDSetPoint = FALSE;

	m_bSelectFeatureFlag = false;
}

//��ͼ����
void CGISDlg::OnMapMove()
{
	m_bSetPointModel=FALSE;
	//m_bLineDesign=FALSE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;
	if (m_map.GetCursorMode()==mapWindow::tkCursorMode::cmPan)
	{
		m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
	}
	else
	{
		m_map.SetCursorMode(mapWindow::tkCursorMode::cmPan);
	}

	m_bLDSetPoint = FALSE;

	m_bSelectFeatureFlag = false;
}


//���ܣ���ͼѡ��
void CGISDlg::OnMapSelect()
{
	m_bSetPointModel=FALSE;
	//m_bLineDesign=FALSE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;
	m_map.SetCursorMode(3);

	m_bLDSetPoint = FALSE;

	if (!m_bEditLine) //�Ǻ��߱༭ģʽ�¿�ѡ
	{
		m_bSelectFeatureFlag = true;  // by Wu
	}
	else
	{
		m_map.SetCursorMode(5);
	}
}


//��ͼȫ����ʾ
void CGISDlg::OnMapFullScreen()
{
	m_bSetPointModel=FALSE;
	//m_bLineDesign=FALSE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;
	m_map.ZoomToMaxExtents();
	m_map.SetCursorMode(4);

	m_bLDSetPoint = FALSE;

	m_bSelectFeatureFlag = false;
}


//���ܣ�����2��֮��ľ���
void CGISDlg::OnSurvey()
{
	m_bSelectFeatureFlag = false;

	m_bSetPointModel=FALSE;
//	m_bLineDesign=FALSE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;

	m_bLDSetPoint = FALSE;

	m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
	//�����
	if (m_bPolylineMeasure)
	{
		ClearPloylineMeasure();
		m_bPolylineMeasure = false;
		m_numPolylineMeasurePts = 0;
		m_bMeasureDrag = false;
	}
	else
	{
		m_bPolylineMeasure = true;
	}

/*
	//����
	m_pHZDistanceDlg->ResetCoordinateData();

	if (!m_bHaveShowDistanceDlg)
	{
		m_bHaveShowDistanceDlg = true;

		//��ʾ��������
		m_pHZDistanceDlg->ShowWindow(SW_SHOW);
	}
	else
	{
		m_bHaveShowDistanceDlg = false;

		//������������
		m_pHZDistanceDlg->ShowWindow(SW_HIDE);
	}*/
}


//�������
void CGISDlg::OnEraseTrack()
{
	EraseTrack(0);
	EraseTrack(1);
	EraseTrack(2);
}

 //�������
void CGISDlg::EraseTrack(int uavid)
{
	if (uavid<0||uavid>2)
	{
		return;
	}
	m_bSetPointModel=FALSE;
	//m_bLineDesign=FALSE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;

	m_bLDSetPoint = FALSE;

	//�Ѿ���������˻��ķ��й켣���������
	if (m_bFirstDrawUAVTrack[uavid])
	{
		//������˻��ı��ͼ��
		if (m_flyTrackLayerID[uavid] != -1)
		{
			m_map.RemoveLayer(m_flyTrackLayerID[uavid]);
		}

		if (m_UAVFlyTrackLayerID[uavid] != -1)
		{
			m_map.RemoveLayer(m_UAVFlyTrackLayerID[uavid]);
		}

		m_bFirstDrawUAVTrack[uavid] = false;

		m_map.Redraw();
	}	

}

//�����������Ŀ�������
void CGISDlg::OnEraseAllTargets()
{
	//����Ŀ����������0ʱ
	if (m_targetPointNum > 0)
	{
		//��������Label
		m_map.ClearLabels(m_targetDrawLayerID);

		m_map.ClearDrawing(m_targetDrawLayerID);

		m_targetDrawLayerID = -1;

		m_map.Redraw();
	}	
}


//���ܣ��������˻��ķ��к��㣬���Ƴ����˻��ķ��к���
//���룺���˻��ĵ�ǰ�ľ���dX��γ��dY�������yaw, ���ԣ���Ϊ��λ��
void CGISDlg::AddFlyPoint(int uavId,const double dX, const double dY, const double yaw,bool control)
{
	//δ���ص�ͼ������
	if (!m_bHaveAddMap)
	{
		return;
	}

	//������ľ�γ����ֵ��Χ���м�飬���Ƿ���Ч
	double fabsLon = fabs(dX);
	double fabsLat = fabs(dY);

	//�ж����ݷ�Χ�Ƿ���Ч
	if ((fabsLon<=0.000001) || (fabsLon>180) || (fabsLat<=0.000001) || (fabsLat>90) || (yaw<0) || (yaw>360))
	{
		return;
	}

	if (m_bAutoMove)
	{
		//�Զ����Σ�ʹ�ɻ���ʾ�ڵ�ͼ�м�
		if (control)
		{
			AutomaticMoveMap(dX, dY);
		}
	}

	//��溽������zcw
	m_drawTrackPtNum[uavId]++;


	//�����˺�����������200-��2000  2017.07.05
	if (m_drawTrackPtNum[uavId] >= 100)
	{
		//�������
		EraseTrack(uavId);
		m_drawTrackPtNum[uavId] = 0;
	}

	//����UAV�ķ��й켣
	DrawUAV(uavId,dX, dY, yaw,control);

	/*static int num = 0;
	if (num == 1)
	{
		DrawCanvas();
		num = 0;
	}
	num++;*/

	//ʵʱͨ�ӷ���
	//m_dlgLightRegion.AnalysisRealTime(dY, distance, angleGU, g_gcsLon, g_gcsLat);
	//m_dlgLightRegion.DrawVisiAreaRealTime(dY, distance, angleGU, g_gcsLon, g_gcsLat);
	m_dlgLightRegion.DrawCrashAreaRealTime(dY, dX, dY);

	//ˢ�µ�ͼ��ÿ5֡ˢ��һ�Σ�
	m_map.Redraw();	
}
void CGISDlg::AddFlyPoint_ADS(const int uavNum, const int uavid, const double lon, const double lat, const double yaw, const bool control, const CString strPlaneName)
{
	//δ���ص�ͼ������
	if (!m_bHaveAddMap)
	{
		return;
	}

	//������ľ�γ����ֵ��Χ���м�飬���Ƿ���Ч
	double fabsLon = fabs(lon);
	double fabsLat = fabs(lat);

	//�ж����ݷ�Χ�Ƿ���Ч
	if ((fabsLon<=0.000001) || (fabsLon>180) || (fabsLat<=0.000001) || (fabsLat>90) || (yaw<0) || (yaw>360))
	{
		return;
	}

	//����UAV�ķ��й켣
	DrawUAV_ADS(uavNum, uavid, lon, lat, yaw, control, strPlaneName);

	//ˢ�µ�ͼ��ÿ5֡ˢ��һ�Σ�
	m_map.Redraw();	
}


void CGISDlg::Openlocalfile(CString file)
{
	int error=0;
	CString filetype=GetFileType(file);
	CString filename=GetFileName(file);
	filetype.MakeLower();	

	if(filetype.Compare("shp")==0)
	{
		mapWindow::IShapefilePtr shape;
		shape.CreateInstance("MapWinGIS.Shapefile");
		if( !shape->Open((_bstr_t)file,NULL))
		{
			error=1;
		}
		_bstr_t pro=shape->GetProjection();

		//���õ�ͼ�ı���ɫΪ��ɫ
		m_map.SetBackColor(RGB(255,255,255));

		int shpLayerPose = m_map.AddLayer(shape,true);

		//�ƶ����׶�
		m_map.MoveLayerBottom(shpLayerPose);

		m_Layer->AddLayerInfo(filename,1);

		//�Ƿ��Ѿ������˵�ͼ
		m_bHaveAddMap = true;
	}
	else if(filetype.Compare("img")==0)
	{
		mapWindow::IImagePtr image;
		image.CreateInstance("MapWinGIS.Image");
		if( !image->Open((_bstr_t)file,mapWindow::IMG_FILE,true,NULL))
		{
			error=1;
		}

		//���õ�ͼ�ı���ɫΪ��ɫ
		m_map.SetBackColor(RGB(255,255,255));

		m_map.AddLayer(image,true);
		m_Layer->AddLayerInfo(filename,2);


		//�Ƿ��Ѿ������˵�ͼ
		m_bHaveAddMap = true;
	}
	else if(filetype.Compare("tif")==0)
	{
		mapWindow::IImagePtr image;
		image.CreateInstance("MapWinGIS.Image");
		if( !image->Open((_bstr_t)file,mapWindow::TIFF_FILE,true,NULL))
		{
			error=1;
		}

		//���õ�ͼ�ı���ɫΪ��ɫ
		m_map.SetBackColor(RGB(255,255,255));

		int tiffLayerID =  m_map.AddLayer(image,true);

		m_Layer->AddLayerInfo(filename,2);

		//�Ƿ��Ѿ������˵�ͼ
		m_bHaveAddMap = true;
	}

	else if(filetype.Compare("asc")==0)
	{
		mapWindow::IImagePtr image;
		image.CreateInstance("MapWinGIS.Image");
		if( !image->Open((_bstr_t)file,mapWindow::ASC_FILE,true,NULL))
		{
			error=1;
		}

		//���õ�ͼ�ı���ɫΪ��ɫ
		m_map.SetBackColor(RGB(255,255,255));

		m_map.AddLayer(image,true);
		m_Layer->AddLayerInfo(filename,2);

		//�Ƿ��Ѿ������˵�ͼ
		m_bHaveAddMap = true;
	}
	/*if(m_bHaveAddMap)
	{
		ReadTargetIni(true);
	}*/
	
	if(error==1)
	{
		CString msg="�޷��� "+file;
		AfxMessageBox(msg);
	}

	m_gisManager->m_bHaveAddMap = m_bHaveAddMap;
}

CString CGISDlg::GetFileType(CString file)
{
	CString type;
	long len=file.GetLength();
	int pos=file.ReverseFind('.');
	type=file.Right(len-pos-1);
	return type;
}

CString CGISDlg::GetFileName(CString file)
{
	CString name;
	long len=file.GetLength();
	int pos=file.ReverseFind('\\');
	name=file.Right(len-pos-1);
	return name;
}

//��ʾ�Ҽ��˵�
void CGISDlg::OnShowRMenu()
{
	//����Ҽ����ʱ��������ݲ˵�
	if (!m_bLineDesign)
	{

		//��ʾ��ݲ˵�
		CMenu   menu;

		POINT   pt;
		GetCursorPos( &pt );


		//�����ڻط�ģʽʱ�����á���������������װ���Ӳ˵����Ȼ�ɫ
		menu.LoadMenu(IDR_MENU2);	

		//����1
		if (m_pHaveDrawLineFlag[0])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE1, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE1, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����2
		if (m_pHaveDrawLineFlag[1])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE2, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE2, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����3
		if (m_pHaveDrawLineFlag[2])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE3, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE3, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����4
		if (m_pHaveDrawLineFlag[3])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE4, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE4, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����5
		if (m_pHaveDrawLineFlag[4])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE5, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE5, MF_BYCOMMAND | MF_UNCHECKED );
		}

		/*
		//����6
		if (m_pHaveDrawLineFlag[5])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE6, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE6, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����7
		if (m_pHaveDrawLineFlag[6])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE7, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE7, MF_BYCOMMAND | MF_UNCHECKED );
		}
		//����8
		if (m_pHaveDrawLineFlag[7])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE8, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE8, MF_BYCOMMAND | MF_UNCHECKED );
		}
		//����9
		if (m_pHaveDrawLineFlag[8])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE9, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE9, MF_BYCOMMAND | MF_UNCHECKED );
		}
		//����10
		if (m_pHaveDrawLineFlag[9])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE10, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE10, MF_BYCOMMAND | MF_UNCHECKED );
		}
		*/

		//����14  ���պ���
		if (m_pHaveDrawLineFlag[13])
		{
			menu.CheckMenuItem( ID_SHOW_PD10, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_SHOW_PD10, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����11  Ӧ������
		if (m_pHaveDrawLineFlag[10])
		{
			menu.CheckMenuItem( ID_SHOW_HS11, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_SHOW_HS11, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����12  ������
		if (m_pHaveDrawLineFlag[11])
		{
			menu.CheckMenuItem( ID_SHOW_TC12, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_SHOW_TC12, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_bAutoMove)
		{
			menu.CheckMenuItem( IDM_AUTO_MOVE, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_AUTO_MOVE, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_guidePointMode == 1)
		{
			menu.CheckMenuItem( IDM_GUIDE_FLY1, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_GUIDE_FLY1, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_guidePointMode == 2)
		{
			menu.CheckMenuItem( IDM_GUIDE_FLY2, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_GUIDE_FLY2, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_bPlotDemArea)
		{
			menu.CheckMenuItem( ID_MENU_PLOTDEMAREA, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_MENU_PLOTDEMAREA, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_bEnableShowADSB)
		{
			menu.CheckMenuItem( ID_MENU_ADSB, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_MENU_ADSB, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//������ݲ˵�
		menu.GetSubMenu( 0 )->TrackPopupMenu( TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, this );


	}
}


//���ܣ��Զ�����,����֤���˻�����ڵ�ͼ������
//ʵ��ԭ����1���Ȼ�õ�ͼ��ǰ����ʾ����
//          2���ٸ������˻��ĵ�ǰ���꣬�ƶ���ͼ
void CGISDlg::AutomaticMoveMap(double dX, double dY)
{
	//����ÿ�����صľ�γ��ֵ
	double lonDegreePerPixel = 0;
	double latDegreePerPixel = 0;

	mapWindow::IExtentsPtr pExtents;
	pExtents = m_map.GetExtents();   

	double xMin = 0;
	double yMin = 0;
	double zMin = 0;

	double xMax = 0;
	double yMax = 0;
	double zMax = 0;

	pExtents->GetBounds(&xMin,&yMin,&zMin,&xMax,&yMax,&zMax);

	if(dX < xMin || dX > xMax || dY < yMin || dY > yMax)
	{
	lonDegreePerPixel = (xMax-xMin) * m_onePerWidth;
	latDegreePerPixel = (yMax-yMin) * m_onePerHeight;

	//��ʾ��Χ
	double xNewMin = 0;
	double yNewMin = 0;
	double zNewMin = 0;

	double xNewMax = 0;
	double yNewMax = 0;
	double zNewMax = 0;	 

	//���ȷ�������
	double lonIncrement = lonDegreePerPixel*m_mapAreaHalfWidth;		

	//γ�ȷ�������
	double latIncrement = latDegreePerPixel*m_mapAreaHalfHeight;		

	xNewMin = dX - lonIncrement;
	xNewMax = dX + lonIncrement;

	yNewMin = dY - latIncrement;
	yNewMax = dY + latIncrement;

	//�����µ���ʾ��Χ
	pExtents->SetBounds(xNewMin,yNewMin,zNewMin,xNewMax,yNewMax,zNewMax);	
	m_map.SetExtents(pExtents);	
	}
}

//���ܣ������Ի�����ʾ����γ����Ϣ
void CGISDlg::OnShowLonLatInfo()
{
	if (!m_bHaveShowLonLatDlg)   //δ�����Ի����򵯳��Ի�����ʾ
	{
		m_bHaveShowLonLatDlg = true;

		m_pLonLatDlg->SetLonLatInfo(0,0);
		m_pLonLatDlg->ShowWindow(SW_SHOW);


	}
	else
	{
		m_bHaveShowLonLatDlg = false;
		m_pLonLatDlg->ShowWindow(SW_HIDE);
	}	
}



//����:ɾ������ͼ��
void CGISDlg::OnRemoveAllLayers()
{
	if (!m_bHaveAddMap)
	{
		return;
	}

	//�������
	OnEraseTrack();

	for(int i=0;i<MAX_PLANE_NUM_ADS;i++)
	{
		//������˻��ı��ͼ��
		if (m_UAVFlyTrackLayerID_ADS[i] != -1)
		{
			//m_map.ClearLabels(m_UAVFlyTrackLayerID_ADS[i]);
			//m_map.ClearDrawing(m_UAVFlyTrackLayerID_ADS[i]);
			m_map.RemoveLayer(m_UAVFlyTrackLayerID_ADS[i]);
			m_UAVFlyTrackLayerID_ADS[i] = -1;

			m_bWithin100km_ADS[i] = false;
		}
	}

	//�Ѿ�����˵����ļ���ɾ�����е�����
	if (m_drawPlanFlyLine != -1)
	{
		m_map.ClearDrawing(m_drawPlanFlyLine);

		m_drawPlanFlyLine = -1;
	}

	if(m_targetDrawLayerID != -1)
	{
		m_map.RemoveLayer(m_targetDrawLayerID);
		m_targetDrawLayerID = -1;
	}

	//���������ʱ�漰����ͼ��
	if (m_longGroundID != 0)
	{
		ClearPointShape(m_longGroundID);
		m_longGroundID = 0;
	}

	if (m_visbleCircleLayerID > 0)
	{
		m_map.GetShapefile(m_visbleCircleLayerID).EditClear();

		m_visbleCircleLayerID = -1;
	}

	if (m_notVisibleCircleLayerID > 0)
	{
		m_map.GetShapefile(m_notVisibleCircleLayerID).EditClear();

		m_notVisibleCircleLayerID = -1;
	}

	if (m_visiRealCircleLayerID > 0)
	{
		m_map.GetShapefile(m_visiRealCircleLayerID).EditClear();

		m_visiRealCircleLayerID = -1;
	}

	if (m_notVisiRealCircleLayerID > 0)
	{
		m_map.GetShapefile(m_notVisiRealCircleLayerID).EditClear();

		m_notVisiRealCircleLayerID = -1;
	}

	if (m_RealCircleLayerID > 0)
	{
		m_map.GetShapefile(m_RealCircleLayerID).EditClear();

		m_RealCircleLayerID = -1;
	}

	for (int i=0;i<20;i++)
	{
		if (m_longContourLineID[i] > 0)
		{
			m_map.GetShapefile(m_longContourLineID[i]).EditClear();

			m_longContourLineID[i] = -1;
		}

		if (m_longContourTextID[i] != 0)
		{
			ClearPointShape(m_longContourTextID[i]);
			m_longContourTextID[i] = 0;
		}
	}

	for (int i=0;i<500;i++)
	{
		if (m_DemRegionLayerID[i] > 0)
		{
			m_map.GetShapefile(m_DemRegionLayerID[i]).EditClear();

			m_DemRegionLayerID[i] = -1;
		}
	}

	if (m_longSelectLineID > 0)
	{
		m_map.GetShapefile(m_longSelectLineID).EditClear();

		m_longSelectLineID = -1;
	}

	if (m_longLabelPlotID != 0)
	{
		ClearPointShape(m_longLabelPlotID);
		m_longLabelPlotID = 0;
	}

	if (m_longLinePointID != 0)
	{
		ClearPointShape(m_longLinePointID);
		m_longLinePointID = 0;
	}

	if (m_crashAreaLayerID > 0)
	{
		m_map.GetShapefile(m_crashAreaLayerID).EditClear();

		m_crashAreaLayerID = -1;
	}

	if (m_fightRegionLayerID > 0)
	{
		m_map.GetShapefile(m_fightRegionLayerID).EditClear();

		m_fightRegionLayerID = -1;
	}

	//����̷߳���ͼ��
	for (int i=0;i<g_iDemAltPtNum;i++)
	{
		m_map.RemoveLayer(g_lDemAltLayerID[i]);
		if (g_lDemAltDisLayerID[i] > 0)
		{
			//������ĵ�ʸ��ͼ��
			ClearPointShape(g_lDemAltDisLayerID[i]);
			g_lDemAltDisLayerID[i] = -1;
		}

		if (g_lDemPtNumLayerID[i] > 0)
		{
			//������ĵ�ʸ��ͼ��
			ClearPointShape(g_lDemPtNumLayerID[i]);
			g_lDemPtNumLayerID[i] = -1;
		}
	}

	//�����ǵ����ͼ��
	for (int i=0;i<g_iMarkerPtNum;i++)
	{
		if (g_lMarkerLayerID[i] > 0)
		{
			ClearPointShape(g_lMarkerLayerID[i]);
			g_lMarkerLayerID[i] = 0;
		}
	}
	m_designLinePointNum = 0;
	//m_map.RemoveAllLayers();
	m_map.ClearDrawing(m_designLineLayerID);
	m_map.ClearDrawing(m_designLineLayerID2);
	m_map.RemoveLayer(m_designLineLayerID);
	m_map.RemoveLayer(m_designLineLayerID2);
	m_map.RemoveAllLayers();
	memset(m_pDesignLineStruct, 0, sizeof(PtStruct)*m_lineMaxPointNum);
	m_Layer->RemoveAll();
	m_map.Redraw();
	for (int i=0;i<13;i++)
	{
		m_pHaveDrawLineFlag[i] = false;
	}
	//���õ�ͼ�ı���ɫΪ��ɫ
	m_map.SetBackColor(RGB(0,0,0));

	//�Ƿ��Ѿ������˵�ͼ
	m_bHaveAddMap = false;
}



//����:ͼ�����
void CGISDlg::OnLayerManage()
{
	m_Layer->ShowWindow(SW_SHOW);
}


//���ܣ�����ͼ�����ʾ������
LRESULT CGISDlg::OnSetLayerStatus(WPARAM wParam, LPARAM lParam)
{
	if (lParam == 0)  //����ͼ��
	{
		m_map.SetLayerVisible(wParam, false);
	}
	else if (lParam == 1)  //��ʾͼ��
	{
		m_map.SetLayerVisible(wParam, true);
	}

	return 0;
}


BEGIN_EVENTSINK_MAP(CGISDlg, CBCGPDialog)
	ON_EVENT(CGISDlg, IDC_MAP1, 1, CGISDlg::MouseDownMap1, VTS_I2 VTS_I2 VTS_I4 VTS_I4)
	ON_EVENT(CGISDlg, IDC_MAP1, 2, CGISDlg::MouseUpMap1, VTS_I2 VTS_I2 VTS_I4 VTS_I4)
	ON_EVENT(CGISDlg, IDC_MAP1, 3, CGISDlg::MouseMoveMap1, VTS_I2 VTS_I2 VTS_I4 VTS_I4)
	ON_EVENT(CGISDlg, IDC_MAP1, DISPID_DBLCLICK, CGISDlg::MouseDblClickMap1, VTS_NONE)
END_EVENTSINK_MAP()



// �����������¼�
void CGISDlg::MouseDownMap1(short Button, short Shift, long x, long y)
{
	double dX = 0;
	double dY = 0;

	GLOBAL_X = x;
	GLOBAL_Y = y;

	CString str_bt;
	TRACE(_T("mapWindow clicked\n"));
	// TRACE(_T(str_bt.Format("%d",Button)));
	// ѡ���ǵ�ʱ
	if (g_bSelectMarker && (Button == 1))
	{
		g_bSelectMarker = false;
		//TRACE(g_bSelectMarker);
		// return;
	}
	
	if (m_bHaveShowDistanceDlg && (Button == 1))
	{
		//��������ת����������
		m_map.PixelToProj(x,y, &dX, &dY);

		//���õ�ľ��ȡ�γ��
		m_pHZDistanceDlg->SetPtCoordinate(dX, dY);
	}

	/***************************************����� by Wu 2023.10.16*****************************************/
	if (m_bPolylineMeasure && (Button == 1))
	{
		if (m_bEndMeasure)
		{
			ClearPloylineMeasure();
			m_bEndMeasure = false;
		}
		//��������ת����������
		m_map.PixelToProj(x,y, &dX, &dY);

		m_numPolylineMeasurePts++;
		m_posPolylineMeasurePts[m_numPolylineMeasurePts-1][0] = dX;
		m_posPolylineMeasurePts[m_numPolylineMeasurePts-1][1] = dY;
		if (m_numPolylineMeasurePts==1) //���
		{
			AddPointShapeLayer(m_polylineMeasurePtLayerID[0], dX, dY, _T("���"), _T(""), RGB(255,0,0));//��ע���
			m_bMeasureDrag = true;
			return;
		}

		//�����߶�
		if (m_polylineMeasureLineLayerID==-1)
		{
			//������ͼ��
			CreateEmptyShapfile(m_polylineMeasureLineLayerID, 1, RGB(0,255,0));
		}
		if (m_numPolylineMeasurePts==2)
		{
			AddOnePoint2Shapfile(m_polylineMeasureLineLayerID, 1, m_posPolylineMeasurePts[0][0], m_posPolylineMeasurePts[0][1]);
		}
		AddOnePoint2Shapfile(m_polylineMeasureLineLayerID, 1, dX, dY);

		if (m_polylineMeasurePtLayerID[1]==-1)
		{
			CreateEmptyShapfile(m_polylineMeasurePtLayerID[1], 0, RGB(0,255,0));
			mapWindow::IShapeDrawingOptionsPtr  pShapeDrawingOption;
			pShapeDrawingOption.CreateInstance("MapWinGIS.ShapeDrawingOptions");	
			pShapeDrawingOption->FillColor = RGB(0,255,0);
			pShapeDrawingOption->PointSize = 12;
			pShapeDrawingOption->PutPointType(mapWindow::tkPointSymbolType::ptSymbolStandard);
			pShapeDrawingOption->PutPointShape(mapWindow::tkPointShapeType::ptShapeStar);
			(m_map.GetShapefile(m_polylineMeasurePtLayerID[1])).SetDefaultDrawingOptions(pShapeDrawingOption);
		}
		//AddOnePoint2Shapfile(m_polylineMeasurePtLayerID[1],0,dX, dY);
		//���ƽڵ�
		mapWindow::IPointPtr pintPtr;
		pintPtr.CreateInstance("MapWinGIS.Point");	
		mapWindow::IShapePtr shapePtr;
		shapePtr.CreateInstance("MapWinGIS.Shape");
		shapePtr->Create(mapWindow::SHP_POINT);
		//����
		pintPtr->x = dX;  
		//�
		pintPtr->y = dY;  
		long i = m_numPolylineMeasurePts-2;
		shapePtr->InsertPoint(pintPtr, &i);	
		//�����ʸ��
		(m_map.GetShapefile(m_polylineMeasurePtLayerID[1])).EditInsertShape(shapePtr, &i);

		//���Ʋ���ע��
		if (m_polylineMeasureLabelLayerID!=-1)
		{
			m_map.ClearDrawing(m_polylineMeasureLabelLayerID);
		}
		m_polylineMeasureLabelLayerID = m_map.NewDrawing(1);
		DrawDistLabel(m_polylineMeasureLabelLayerID,m_posPolylineMeasurePts,m_numPolylineMeasurePts,1);
	}

	//�Ҽ�����������
	if (m_bPolylineMeasure && (Button == 2))
	{
		EndPolylineMessure();
		return;
	}
	/*******************************************************************************************************/

	/*******************************************by Wu 2023.09.14*******************************************/
	//ѡ��Ҫ��
	if (m_bSelectFeatureFlag && (Button == 1)) 
	{
		//��������ת��γ������
		m_map.PixelToProj(x,y, &dX, &dY);
		double pt[2] = {dX,dY};

		m_lineSelectedID = IsSelectLine(pt);
		ClearHighLightLine();
		if (m_lineSelectedID==11)  //��ʱ���λ��պ���
		{
			return;
		}
		if (m_lineSelectedID>0) 
		{
			m_editLineDataGroup = m_ShowedLineDataList[m_lineSelectedID];
			DrawHighLightLine(m_editLineDataGroup.linePts,m_editLineDataGroup.linePointNum);
		}
	}
	//���պ��߱༭
	if (m_bEditLine && (Button == 1))
	{
		if (m_lineSelectedID<=0)
		{
			return;
		}
		//��������ת��γ������
		m_map.PixelToProj(x,y, &dX, &dY);
		m_iPtSel=GetPtSel(m_editLineDataGroup.pts,m_editLineDataGroup.pointNum,x,y);
		if (m_iPtSel<0) //ѡ�зǽڵ㣬������������
		{
			//m_editLineDataGroup = m_ShowedLineDataList[m_lineSelectedID];
			double pt[2] = {dX,dY};
			vector<double> lineX,lineY;
			TransformToVectorPoints(m_editLineDataGroup,lineX,lineY);
			int addPointPos = topologicalAnalysis.isPointInPolyLine(pt,lineX,lineY);
			if (addPointPos==0) //����㲻������
			{
				return;
			}
			if (m_lineSelectedID==11)
			{
				if (addPointPos>m_editLineDataGroup.linePointNum-4) return; //���պ�������4,5,6���߲��ñ༭
			}


			//�������ӵ�����
			double linePt1[2] = {m_editLineDataGroup.linePts[addPointPos-1].dX,m_editLineDataGroup.linePts[addPointPos-1].dY};
			double linePt2[2] = {m_editLineDataGroup.linePts[addPointPos].dX,m_editLineDataGroup.linePts[addPointPos].dY};
			double targetPt[2] = {0.0,0.0};
			topologicalAnalysis.GetPointToLineVerticalCross(linePt1,linePt2,pt,targetPt);
			//���ӵ�����
			AddPointInLine(addPointPos,targetPt,m_editLineDataGroup);

			if (m_distLabelLayer!=-1)
			{
				m_map.ClearDrawing(m_distLabelLayer);//�������ͷ�λ�DZ��
			}

			//��������
			ClearDrawedLine(m_editLineDataGroup.lineID-1);
			//��溽��
			DrawFlyLine(m_editLineDataGroup);
		}

	}

	//�Ҽ��༭����
	if (m_bEditLine && (Button == 2))
	{
		double lon,lat;
		//��������ת��γ������
		m_map.PixelToProj(x,y, &lon, &lat);
		int selectedPointID = GetPtSel(m_editLineDataGroup.pts,m_editLineDataGroup.pointNum,x,y);
		if (selectedPointID>=0)
		{
			if (m_lineSelectedID==11)
			{
				if (selectedPointID>=m_editLineDataGroup.pointNum-3 || selectedPointID==0) //���պ�������1,4,5,6,����
				{
					return;
				}
			}

			ShowModifyPointDlg(selectedPointID);
			return;
		}

		ShowEditSaveDlg();
		return;
	}

	/***************************************************************************************************************/

	//���ں������ģʽʱ��������괦��ѡ��ģʽʱ
	if (m_bLineDesign  && (Button == 1))
	{
		////if (m_map.GetCursorMode()!=5)                 //����Ϊ����ͷ״̬
		////{
		//	m_map.SetCursorMode(5);

		///*}*/
		//��������ת��γ������
		m_map.PixelToProj(x,y, &dX, &dY);

		if (m_bPtEdit )             //���ں���༭ģʽʱ
		{	
			m_iPtSel=GetPtSel(x,y);
		}
		if (m_bSetPointModel)//�õ�
		{
			
			POINT   pt;
			GetCursorPos( &pt );

			//��������ת��γ������
			m_map.PixelToProj(x,y, &dX, &dY);

			//������
			m_curDesignPoint.nPt = m_designLinePointNum+1;

			//���㾭��
			m_curDesignPoint.dX = dX;

			//�����
			m_curDesignPoint.dY = dY;

			m_pDesignLineStruct[m_designLinePointNum] = m_curDesignPoint;

			//�����ż���������1
			m_designLinePointNum++;

			m_bAddNewPoint = true;
		}
		 if (m_bPtDel)//ɾ��
		{
			int iSel=GetPtSel(x,y);
			int i=0;
			if (iSel!=-1)
			{ 
				for (i=iSel;i<m_designLinePointNum-1;i++)
				{
					m_pDesignLineStruct[i]=m_pDesignLineStruct[i+1];
					m_pDesignLineStruct[i].nPt=m_pDesignLineStruct[i].nPt-1;
				}

				m_designLinePointNum--;
			}
		}
		DrawLineDesign();
	}

	//�º������ 2016.01.05
	//�����ں�����ƣ�������괦��ѡ��ģʽʱ
	if (m_bHaveShowLineDesign && (Button == 1))
	{
		m_map.PixelToProj(x,y, &dX, &dY);

		if (m_bLDSetPoint)
		{
			POINT pt;
			GetCursorPos(&pt);

			//���ص�����ת����γ������
			m_map.PixelToProj(x, y, &dX, &dY);

			//������
			m_CurNewDesignPt.nPt = m_NowNumLineDesign + 1;

			//��ǰ��Ƶĺ���ľ���
			m_CurNewDesignPt.dX = dX;

			//��ǰ��Ƶĺ����γ��
			m_CurNewDesignPt.dY = dY;

			//��ǰ��Ƶĺ���ĸ߶�
			m_CurNewDesignPt.nH = 0;

			//��ǰ��Ƶĺ�����ٶ�
			m_CurNewDesignPt.nV = 0;

			//��ǰ��Ƶĺ��������������
			m_CurNewDesignPt.ch1 = 0x02;

			//��ǰ��Ƶĺ���ĺ�·������
			m_CurNewDesignPt.ch2 = 0x01;

			m_pLineDesign->ShowLonLat(dX, dY);

			m_pNewDesignLineStruct[m_NowNumLineDesign] = m_CurNewDesignPt;

			m_pLineDesign->InsertPt(m_CurNewDesignPt);
			//�����ż�����+1
			m_NowNumLineDesign++;


			//CLineDesign dlg;
			//dlg.ShowLonLat(m_curDesignPoint.dX, m_curDesignPoint.dX);
		}
	}


	//����Ҽ����ʱ��������ݲ˵�
	if (Button == 2 && !m_bLineDesign)
	{
				//ɾ���Ѿ�����ֱ��
		m_map.ClearDrawing(m_tempLayerID);
		m_map.Redraw();

		//��ʾ��ݲ˵�

		CMenu   menu;

		POINT   pt;
		GetCursorPos( &pt );
		bool bSel = false;
		for (int i = 0;i<255;i++)
		{
			if (m_targets[i].id <= 0)
			{
				continue;
			}
			double pixX = 0;
			double pixY = 0;
			m_map.ProjToPixel(m_targets[i].lon,m_targets[i].lat, &pixX, &pixY);
			if (fabs(x-pixX)<5 && fabs(y-pixY)<5 )
			{
				bSel = true;
				m_targetSelID = m_targets[i].id;
				break;
			}
		}

		if (bSel)
		{
			menu.LoadMenu(IDR_MENU_TARGET);	
			//������ݲ˵�
			menu.GetSubMenu( 0 )->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON, pt.x,pt.y, this );
			return;
		}

		//�����ڻط�ģʽʱ�����á���������������װ���Ӳ˵����Ȼ�ɫ
		menu.LoadMenu(IDR_MENU2);	

		//����1
		if (m_pHaveDrawLineFlag[0])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE1, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE1, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����2
		if (m_pHaveDrawLineFlag[1])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE2, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE2, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����3
		if (m_pHaveDrawLineFlag[2])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE3, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE3, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����4
		if (m_pHaveDrawLineFlag[3])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE4, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE4, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����5
		if (m_pHaveDrawLineFlag[4])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE5, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE5, MF_BYCOMMAND | MF_UNCHECKED );
		}

/*
		//����6
		if (m_pHaveDrawLineFlag[5])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE6, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE6, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����7
		if (m_pHaveDrawLineFlag[6])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE7, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE7, MF_BYCOMMAND | MF_UNCHECKED );
		}
		//����8
		if (m_pHaveDrawLineFlag[7])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE8, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE8, MF_BYCOMMAND | MF_UNCHECKED );
		}
		//����9
		if (m_pHaveDrawLineFlag[8])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE9, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE9, MF_BYCOMMAND | MF_UNCHECKED );
		}
		//����10
		if (m_pHaveDrawLineFlag[9])
		{
			menu.CheckMenuItem( IDM_SHOW_LINE10, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_SHOW_LINE10, MF_BYCOMMAND | MF_UNCHECKED );
		}*/


		//����14  ���պ���
		if (m_pHaveDrawLineFlag[13])
		{
			menu.CheckMenuItem( ID_SHOW_PD10, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_SHOW_PD10, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����11  Ӧ������
		if (m_pHaveDrawLineFlag[10])
		{
			menu.CheckMenuItem( ID_SHOW_HS11, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_SHOW_HS11, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//����12  ������
		if (m_pHaveDrawLineFlag[11])
		{
			menu.CheckMenuItem( ID_SHOW_TC12, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_SHOW_TC12, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_bAutoMove)
		{
			menu.CheckMenuItem( IDM_AUTO_MOVE, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_AUTO_MOVE, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_guidePointMode == 1)
		{
			menu.CheckMenuItem( IDM_GUIDE_FLY1, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_GUIDE_FLY1, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_guidePointMode == 2)
		{
			menu.CheckMenuItem( IDM_GUIDE_FLY2, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( IDM_GUIDE_FLY2, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_bPlotDemArea)
		{
			menu.CheckMenuItem( ID_MENU_PLOTDEMAREA, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_MENU_PLOTDEMAREA, MF_BYCOMMAND | MF_UNCHECKED );
		}

		if (m_bEnableShowADSB)
		{
			menu.CheckMenuItem( ID_MENU_ADSB, MF_BYCOMMAND | MF_CHECKED );
		}
		else
		{
			menu.CheckMenuItem( ID_MENU_ADSB, MF_BYCOMMAND | MF_UNCHECKED );
		}

		//������ݲ˵�
		menu.GetSubMenu( 0 )->TrackPopupMenu( TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, this );

		//��������ת��γ������
		m_map.PixelToProj(x, y, &m_guidePtInfo.guidePtLon, &m_guidePtInfo.guidePtLat);
	}



	if (Button == 2 && m_bLineDesign)   //���߱༭ʱ��ֹͣ�༭
	{
		CMenu   tmenu;
		tmenu.LoadMenu(IDR_FLOATINGMENU);	
		CRect rc=CRect(0,0,x,y);
		ClientToScreen(&rc);
		//������ݲ˵�
		tmenu.GetSubMenu( 0 )->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON, rc.right,rc.bottom, this );
		return;

	}

	//���ڵر��Ի���ѡ��ģʽʱ��������괦��ѡ��ģʽ,�������
	if (m_bSelectDropPoint && (m_map.GetCursorMode() == 3) && (Button == 1))
	{
		m_bSelectDropPoint = false;

		double _ptLon = 0.0, _ptLat = 0.0;

		//��������ת��γ������
		m_map.PixelToProj(x, y, &_ptLon, &_ptLat);

		//�����������Ϣ
		if (m_pTargetDlg && m_pTargetDlg->GetSafeHwnd())
		{
			m_pTargetDlg->ShowPointPosition(_ptLon,_ptLat);
		}
	}

	//���ڿ���������Ի���ѡ��ģʽʱ��������괦��ѡ��ģʽ,�������
	if (g_bSelectDropPoint && (m_map.GetCursorMode() == 3) && (Button == 1))
	{
		g_bSelectDropPoint = false;

		double _ptLon = 0.0, _ptLat = 0.0;

		//��������ת��γ������
		m_map.PixelToProj(x, y, &_ptLon, &_ptLat);

		//�����������Ϣ,�����ͨ�ӷ���
		if (m_dlgLightRegion.GetSafeHwnd())
		{
			m_dlgLightRegion.ShowPointPosition(_ptLon,_ptLat);
			m_dlgLightRegion.LosBetweenTwoPoints();
		}
	}

	//�̷߳���ѡ��
	if (g_bDemAnalysising && (Button == 1))
	{
		g_iDemPointNum++;

		//��������ת��γ������
		double _ptLon = 0.0, _ptLat = 0.0;
		m_map.PixelToProj(x, y, &_ptLon, &_ptLat);

		g_dDemPtLon[g_iDemPointNum-1] = _ptLon;
		g_dDemPtLat[g_iDemPointNum-1] = _ptLat;

		CString str;
		str.Format(_T("%d"), g_iDemPointNum);

		//��ʾ�����ű�ע
		AddTextToPointShapeLayer(g_lDemPtNumLayerID[g_iDemPointNum-1], _ptLon, _ptLat, str, _T(""), RGB(255,0,0));

		if (g_iDemPointNum >= g_iDemAltPtNum)
		{
			BCGPMessageBox(_T("��ʱ��֧�����10����ĸ̷߳�����"));

			g_bDemAnalysising = false;

			m_DlgDemAlt.DrawDemAltBetweenPts(g_dDemPtLon, g_dDemPtLat, g_iDemPointNum);

			if (m_DlgDemAlt.GetSafeHwnd())
			{
				m_DlgDemAlt.ShowWindow(TRUE);
			}
		}
	}

	//ѡ������
	if (m_bGuideMode && (Button == 1))
	{
		m_bGuideMode = false;
		m_map.PixelToProj(x,y,&m_guidePtInfo.guidePtLon,&m_guidePtInfo.guidePtLat);
		DrawGuidePoint(m_guidePtInfo.guideMode,m_guidePtInfo.guidePtLon,m_guidePtInfo.guidePtLat);
		switch(m_guidePointMode)
		{
		case 0:
			break;
		case 1:
			{
				m_struMapOut.cmd = MapCmd_Guide1;
				m_struMapOut.lon = m_guidePtInfo.guidePtLon;
				m_struMapOut.lat = m_guidePtInfo.guidePtLat;

				::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP, (int)(&m_struMapOut),0);
			}
			break;
		case 2:
			{
				m_struMapOut.cmd = MapCmd_Guide2;
				m_struMapOut.lon = m_guidePtInfo.guidePtLon;
				m_struMapOut.lat = m_guidePtInfo.guidePtLat;

				::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP, (int)(&m_struMapOut),0);
			}
			break;
		default:
			break;
		}
	}


}

//���˫���¼�
void CGISDlg::MouseDblClickMap1()
{
	//�����̷߳���
	if (g_bDemAnalysising)
	{
		g_bDemAnalysising = false;

		m_DlgDemAlt.DrawDemAltBetweenPts(g_dDemPtLon, g_dDemPtLat, g_iDemPointNum);

		if (m_DlgDemAlt.GetSafeHwnd())
		{
			m_DlgDemAlt.ShowWindow(TRUE);
		}
	}

	/*********************************by Wu 2023.09.20********************************************/
	double dX = 0;
	double dY = 0;

	//��������ת��γ������
	m_map.PixelToProj(GLOBAL_X,GLOBAL_Y, &dX, &dY);
	//˫��ɾ������
	if (m_bEditLine)
	{
		int ptSelected = GetPtSel(m_editLineDataGroup.pts,m_editLineDataGroup.pointNum,GLOBAL_X,GLOBAL_Y);
		if (m_editLineDataGroup.lineID==11) //���պ�������1,4,5,6����
		{
			if (ptSelected==0 || (ptSelected>=m_editLineDataGroup.pointNum-3))
			{
				return;
			}
		}
		if (ptSelected>=0)
		{
			if (m_distLabelLayer!=-1)
			{
				m_map.ClearDrawing(m_distLabelLayer);//�������ͷ�λ�DZ��
			}

			RemovePointInLine(ptSelected,m_editLineDataGroup);

			//��������
			ClearDrawedLine(m_editLineDataGroup.lineID-1);
			//��溽��
			DrawFlyLine(m_editLineDataGroup);	
		}
	}

	/*********************************************************************************************/
	
	if (g_b981APad)  //ƽ��ģʽ˫��������
	{
		if (m_bPolylineMeasure)
		{
			EndPolylineMessure();
		}
	}

}

// �����������ƶ��¼�
void CGISDlg::MouseMoveMap1(short Button, short Shift, long x, long y)
{	
	if (Button == 2)
	{
		return;
	}

	//��ʾ��γ������ʱ
	if (m_bHaveShowLonLatDlg && m_pLonLatDlg ->GetAutoEditStatus())
	{
		double dX = 0;
		double dY = 0;

		m_map.PixelToProj(x,y, &dX, &dY);

		//����������ʾ
		m_pLonLatDlg->SetLonLatInfo(dX, dY);
	}


	/*****************************************by Wu 2023.09.14*******************************************/
	//�༭����ʱ
	if (m_bEditLine && Button == 1)
	{
		double dX = 0;
		double dY = 0;

		//��������ת��γ������
		m_map.PixelToProj(x, y, &dX, &dY);
		if (m_iPtSel==-1)
		{
			return;
		}
		if (m_editLineDataGroup.lineID==11)  //���պ���1,4,5,6���ñ༭
		{
			if (m_iPtSel==0 || (m_iPtSel>=m_editLineDataGroup.pointNum-3))
			{
				return;
			}
		}

		int n_pts = m_editLineDataGroup.pointNum;
		bool isClosedLine;
		if (m_editLineDataGroup.pts[n_pts-1].ch1==2) //�DZպϺ���
		{
			isClosedLine = false;
		}
		else
		{
			isClosedLine = true;
		}

		m_dragFlag = true;
		m_editLineDataGroup.pts[m_iPtSel].dX = dX;
		m_editLineDataGroup.pts[m_iPtSel].dY = dY;
		m_editLineDataGroup.linePts[m_iPtSel].dX = dX;
		m_editLineDataGroup.linePts[m_iPtSel].dY = dY;
		if (m_iPtSel==0 && isClosedLine) //ѡ�����ʱ����Ҫͬ���޸����յ������
		{
			int endpt = m_editLineDataGroup.linePointNum - 1;
			m_editLineDataGroup.linePts[endpt].dX = dX;
			m_editLineDataGroup.linePts[endpt].dY = dY;
		}
		if (m_iPtSel==n_pts-1 && !isClosedLine) //�DZպϺ����յ�
		{
			m_editLineDataGroup.linePts[n_pts].dX = dX;
			m_editLineDataGroup.linePts[n_pts].dY = dY;
		}
		//��������
		ClearDrawedLine(m_editLineDataGroup.lineID-1);
		//��溽��
		DrawFlyLine(m_editLineDataGroup);
		//��ק����ʱ��ʾ����ͷ�λ��
		if (m_distLabelLayer!=-1)
		{
			m_map.ClearDrawing(m_distLabelLayer);
		}
		m_distLabelLayer = m_map.NewDrawing(1);
		if (m_iPtSel==0)//ѡ�����
		{
			int endpt = m_editLineDataGroup.pointNum - 1;
			DrawDistLabelEx(m_distLabelLayer,m_editLineDataGroup.pts[m_iPtSel].dX,m_editLineDataGroup.pts[m_iPtSel].dY,m_editLineDataGroup.pts[m_iPtSel+1].dX,m_editLineDataGroup.pts[m_iPtSel+1].dY,0);
			if (isClosedLine)
			{
				DrawDistLabelEx(m_distLabelLayer,m_editLineDataGroup.pts[m_iPtSel].dX,m_editLineDataGroup.pts[m_iPtSel].dY,m_editLineDataGroup.pts[endpt].dX,m_editLineDataGroup.pts[endpt].dY,0);
			}	
		}
		else if (m_iPtSel==m_editLineDataGroup.pointNum - 1) //ѡ���յ�
		{
			DrawDistLabelEx(m_distLabelLayer,m_editLineDataGroup.pts[m_iPtSel].dX,m_editLineDataGroup.pts[m_iPtSel].dY,m_editLineDataGroup.pts[m_iPtSel-1].dX,m_editLineDataGroup.pts[m_iPtSel-1].dY,0);
			if (isClosedLine)
			{
				DrawDistLabelEx(m_distLabelLayer,m_editLineDataGroup.pts[m_iPtSel].dX,m_editLineDataGroup.pts[m_iPtSel].dY,m_editLineDataGroup.pts[0].dX,m_editLineDataGroup.pts[0].dY,0);
			}	
		}
		else
		{
			DrawDistLabelEx(m_distLabelLayer,m_editLineDataGroup.pts[m_iPtSel].dX,m_editLineDataGroup.pts[m_iPtSel].dY,m_editLineDataGroup.pts[m_iPtSel-1].dX,m_editLineDataGroup.pts[m_iPtSel-1].dY,0);
			DrawDistLabelEx(m_distLabelLayer,m_editLineDataGroup.pts[m_iPtSel].dX,m_editLineDataGroup.pts[m_iPtSel].dY,m_editLineDataGroup.pts[m_iPtSel+1].dX,m_editLineDataGroup.pts[m_iPtSel+1].dY,0);
		}


		return;
	}
	/*****************************************************************************************************************/

	/*****************************************����� by Wu 2023.10.16************************************************/
	if (m_bPolylineMeasure && m_bMeasureDrag)
	{
		double dX = 0;
		double dY = 0;

		//��������ת��γ������
		m_map.PixelToProj(x, y, &dX, &dY);

		//ɾ���Ѿ�����ֱ��
		m_map.ClearDrawing(m_tempLayerID);
		//�½���ʱ���ͼ��
		m_tempLayerID = m_map.NewDrawing(1);
		//����ֱ��
		if (m_tempLayerID!=-1)
		{
			m_map.DrawLineEx(m_tempLayerID,m_posPolylineMeasurePts[m_numPolylineMeasurePts-1][0], m_posPolylineMeasurePts[m_numPolylineMeasurePts-1][1], dX, dY, 2, RGB(0,255,0));	

			//��ʾ�߶εľ���ͷ�λ
			DrawDistLabelEx(m_tempLayerID,m_posPolylineMeasurePts[m_numPolylineMeasurePts-1][0], m_posPolylineMeasurePts[m_numPolylineMeasurePts-1][1], dX, dY);
		}	
	}

	/****************************************************************************************************************/


	//�º������ʱ
	if (m_bHaveShowLineDesign)
	{
		double dX = 0;
		double dY = 0;

		m_map.PixelToProj(x,y, &dX, &dY);

		//������ƶԻ�����ʾ��γ��
		//m_pLineDesign->ShowLonLat(dX, dY);
	}

	//�������ʱ
	if (m_bLineDesign)
	{
		double dX = 0;
		double dY = 0;

		//��������ת��γ������
		m_map.PixelToProj(x, y, &dX, &dY);

		if (m_bPtEdit )  //���ں���༭ģʽʱ
		{
			if (m_iPtSel==-1)
			{
				return;
			}

			m_pDesignLineStruct[m_iPtSel].dX=dX;
			m_pDesignLineStruct[m_iPtSel].dY=dY;
			DrawLineDesign();
			return;

			//�ж�����Ƿ�ѡ�д��༭�ĺ���
			if (BeMouseClickedLinePoint(m_curEditLinePoint, x, y))
			{
				//�༭����
				m_pFlyLineDesign->EditPoint(dX, dY);
			}

			return;
		}

		if (m_bDesignFirstPoint)
		{
			//������Ϣ��ֵ����ʾ������Ϣ���Լ��������ԭ��ľ���ͷ�λ��
			m_pLineSectDlg->InputPointCoordinate(dX, dY);

			//������
			m_curDesignPoint.nPt = m_designLinePointNum+1;

			//���㾭��
			m_curDesignPoint.dX = dX;

			//�����
			m_curDesignPoint.dY = dY;
			
			//���Ӻ���
			m_pFlyLineDesign->AddPoint(m_curDesignPoint);

			return;
		}

		//�Ѿ�������ʱ���ͼ��ʱ��ɾ����ͼ�㣬���±�ע
		if (m_designLinePointNum>0 && m_beTemLayerDrawing)
		{
			//������Ϣ��ֵ����ʾ������Ϣ���Լ��������ԭ��ľ���ͷ�λ��
			m_pLineSectDlg->InputPointCoordinate(dX, dY);

			//ɾ���Ѿ�����ֱ��
			m_map.ClearDrawing(m_tempLayerID);

			//�½���ʱ���ͼ��
			m_tempLayerID = m_map.NewDrawing(1);

			//������
			m_curDesignPoint.nPt = m_designLinePointNum+1;

			//���㾭��
			m_curDesignPoint.dX = dX;

			//�����
			m_curDesignPoint.dY = dY;

			//���Ӻ���
			m_pFlyLineDesign->AddPoint(m_curDesignPoint);

			//����ֱ��
			if (m_tempLayerID!=-1)
			{
				m_map.DrawLineEx(m_tempLayerID,m_pDesignLineStruct[m_designLinePointNum-1].dX, m_pDesignLineStruct[m_designLinePointNum-1].dY, dX, dY, 2, RGB(0,255,0));	
			    DrawDistLabelEx(m_tempLayerID, m_pDesignLineStruct[m_designLinePointNum-1].dX, m_pDesignLineStruct[m_designLinePointNum-1].dY, dX, dY);
			}
					 
		}
	}

	//���ڿ���������Ի���ѡ��ģʽʱ��������괦��ѡ��ģʽ
	if (m_bSelectDropPoint && (m_map.GetCursorMode() == 3))
	{
		double _ptLon = 0.0, _ptLat = 0.0;

		//��������ת��γ������
		m_map.PixelToProj(x, y, &_ptLon, &_ptLat);

		//�����������Ϣ
		if (m_pTargetDlg && m_pTargetDlg->GetSafeHwnd())
		{
			m_pTargetDlg->ShowPointPosition(_ptLon,_ptLat);
		}
	}

	//���ڿ���������Ի���ѡ��ģʽʱ��������괦��ѡ��ģʽ
	if (g_bSelectDropPoint && (m_map.GetCursorMode() == 3))
	{
		double _ptLon = 0.0, _ptLat = 0.0;

		//��������ת��γ������
		m_map.PixelToProj(x, y, &_ptLon, &_ptLat);

		//�����������Ϣ
		if (m_dlgLightRegion.GetSafeHwnd())
		{
			m_dlgLightRegion.ShowPointPosition(_ptLon,_ptLat);
		}

		if (m_longSelectLineID > 0)
		{
			m_map.GetShapefile(m_longSelectLineID).EditClear();
		}

		m_gisManager->CreateEmptyLineShapfile(m_longSelectLineID,RGB(0,255,0),2);
		m_gisManager->AddOnePoint2Shapfile(m_longSelectLineID,1,m_dlgLightRegion.m_dGroundLon,m_dlgLightRegion.m_dGroundLat);
		m_gisManager->AddOnePoint2Shapfile(m_longSelectLineID,1,_ptLon,_ptLat);

		double _distance = 0.0, _angle = 0.0;
		CalculateTwoPtsDistanceAzimuth(_distance, _angle, m_dlgLightRegion.m_dGroundLon,m_dlgLightRegion.m_dGroundLat, _ptLon, _ptLat, 3);

		CString str;
		str.Format(_T("D:%.1fkm  A:%.1f��"), _distance/1000, _angle);

		if (m_longLabelPlotID != 0)
		{
			ClearPointShape(m_longLabelPlotID);
			m_longLabelPlotID = 0;
		}
		//��ע����ͷ�λ
		AddPointShapeLayer(m_longLabelPlotID,_ptLon, _ptLat, str, _T("��ɫ"), RGB(255,0,0));
	}

	if (g_bDemAnalysising && g_iDemPointNum>=1)
	{
		double lon = 0, lat = 0;
		m_map.PixelToProj(x, y, &lon, &lat);

		double _dis = 0;
		CalculateTwoPtsDistance(_dis, g_dDemPtLon[g_iDemPointNum-1], g_dDemPtLat[g_iDemPointNum-1], lon, lat, 3);

		//���˵�����˫������ʱ�����һ���߶�
		if (_dis > 30)
		{
			m_map.RemoveLayer(g_lDemAltLayerID[g_iDemPointNum-1]);

			//������ͼ��
			CreateEmptyShapfile(g_lDemAltLayerID[g_iDemPointNum-1], 1, RGB(0,0,255));

			//�����߶�
			AddOnePoint2Shapfile(g_lDemAltLayerID[g_iDemPointNum-1], 1, g_dDemPtLon[g_iDemPointNum-1], g_dDemPtLat[g_iDemPointNum-1]);
			AddOnePoint2Shapfile(g_lDemAltLayerID[g_iDemPointNum-1], 1, lon, lat);

			//��ʾ�߶εľ���ͷ�λ
			DrawLineLabel(g_lDemAltDisLayerID[g_iDemPointNum-1], g_dDemPtLon[g_iDemPointNum-1], g_dDemPtLat[g_iDemPointNum-1], lon, lat);
		}
	}

	//ѡ���ǵ�ʱ
	if (g_bSelectMarker)
	{
		TRACE("g_bSelectMarker = true\n");
		double _ptLon = 0.0, _ptLat = 0.0;

		//��������ת��γ������
		m_map.PixelToProj(x, y, &_ptLon, &_ptLat);

		m_dlgMarker.ShowMarkerCoordinate(_ptLon, _ptLat);
		return;
	}
}

//���ܣ����ڵ�ʸ��ͼ����Ŀ���
//���룺��ͼ������drawLayerID
//		�����꣬����lon, γ��lat
//      ������strPtName    
//      �����ɫstrColor
//      ���������ɫ��ֵfontColor
void CGISDlg::AddTextToPointShapeLayer(long &drawLayerID, const double lon, const double lat, const CString strPtName, const CString strColor, unsigned long fontColor)
{
	//�жϵ�ʸ��ͼ���Ƿ��Ѿ����ڣ�������ɾ��
	if (drawLayerID > 0)
	{
		//������ĵ�ʸ��ͼ��
		ClearPointShape(drawLayerID);
	}

	/////////////////////�½���ʸ��ͼ�����Ŀ��///////////////////////////////////
	//������ͼ��
	CreateEmptyShapfile(drawLayerID, 0, RGB(0,255,0));

	/////////////////////��SHPͼ���м���Ŀ����ע��Ϣ///////////////////////////////

	//Label����
	CLabels labesPtr;
	labesPtr = (m_map.GetShapefile(drawLayerID)).GetLabels();

	CLabelCategory labelCategory = labesPtr.AddCategory(strColor);
	labelCategory.SetFontColor(fontColor);
	labelCategory.SetAlignment(1);
	labelCategory.SetFontBold(TRUE);
	labelCategory.SetFontName(_T("Times New Roman"));
	labelCategory.SetFontSize(12);

	//����Labels
	labesPtr.AddLabel(strPtName, lon+0.0002, lat+0.0002, 0, 0);

	//���»���
	m_map.Redraw();
}

//���ܣ���ʾ���������߶εľ���ͷ�λ
void CGISDlg::DrawLineLabel(long &drawLayerID, const double ptLon1, const double ptLat1, const double ptLon2, const double ptLat2)
{
	//û�м��ص�ͼ������
	if (!m_bHaveAddMap)
	{
		return;
	}

	double _dis, _angle;
	CalculateTwoPtsDistanceAzimuth(_dis, _angle, ptLon1, ptLat1, ptLon2, ptLat2, 3);

	CString str = _T("");

	if ( _dis < 1000)
	{
		str.Format(_T("%.1fm/%.1f��"), _dis, _angle);		
	} 
	else
	{
		str.Format(_T("%.2fkm/%.1f��"), _dis*0.001,_angle);
	}

	//������Ŀ��֮������λ�ù�ϵ�������ֱ�ע
	double textLon = 0;
	double textLat = 0;

	//�����ע������
	TargetPos2LabelPos(textLon, textLat, (ptLon1 + ptLon2)/2, (ptLat1 + ptLat2)/2);

	//�жϵ�ʸ��ͼ���Ƿ��Ѿ����ڣ�������ɾ��
	if (drawLayerID > 0)
	{
		//������ĵ�ʸ��ͼ��
		ClearPointShape(drawLayerID);
		drawLayerID = -1;
	}

	if (_T("") != str)
	{
		//������ͼ��
		CreateEmptyShapfile(drawLayerID, 0, RGB(255,0,0)); //��ɫ

		//Label����
		CLabels labesPtr;
		labesPtr = (m_map.GetShapefile(drawLayerID)).GetLabels();

		CLabelCategory labelCategory = labesPtr.AddCategory(_T(""));
		labelCategory.SetFontColor(RGB(255,255,0));
		labelCategory.SetAlignment(1);
		labelCategory.SetFontBold(TRUE);
		labelCategory.SetFontName(_T("Times New Roman"));
		labelCategory.SetFontSize(10);

		labesPtr.AddLabel(str, textLon, textLat, 0, 0);
	}

	//�ػ�
	m_map.Redraw();
}

//���ܣ���ʾ���������߶εľ���ͷ�λ
void CGISDlg::DrawDistLabelEx(long drawLayerID, const double ptLon1, const double ptLat1, const double ptLon2, const double ptLat2,int pos)
{
	double _dis, _angle;
	CalculateTwoPtsDistanceAzimuth(_dis, _angle,  ptLon1, ptLat1, ptLon2, ptLat2, 3);

	CString str = _T("");
	if ( _dis < 1000)
	{
		str.Format(_T("%dm;%.1f��"), int(_dis), _angle);		
	} 
	else
	{
		if(_dis<1000)
		{
			str.Format(_T("%.2fkm;%.1f��"), _dis*0.001, _angle);	
		}
		else
		{
			str.Format(_T("%.2fkm;%.1f��"), _dis*0.001,_angle);
		}
	}

	//������Ŀ��֮������λ�ù�ϵ�������ֱ�ע
	double textLon = 0;
	double textLat = 0;

	//�����ע������
	//TargetPos2LabelPos(textLon, textLat, (ptLon1 + ptLon2)/2, (ptLat1 + ptLat2)/2);
	switch (pos)
	{
	case -1://��˵�
		TargetPos2LabelPos(textLon, textLat, ptLon1, ptLat1);
		break;
	case 0://�м�˵�
		TargetPos2LabelPos(textLon, textLat, (ptLon1 + ptLon2)/2, (ptLat1 + ptLat2)/2);
		break;
	case 1://�Ҷ˵�
		TargetPos2LabelPos(textLon, textLat, ptLon2, ptLat2);
		break;
	}

	CLabels drawLabels = m_map.GetDrawingLabels(drawLayerID);
	//drawLabels.SetAvoidCollisions(false);
	/*
	CLabelCategory labelCategory = drawLabels.AddCategory(_T("dist"));
	labelCategory.SetFontName(_T("����"));
	labelCategory.SetFontSize(12);
	labelCategory.SetOffsetX(8);
	labelCategory.SetFrameVisible(true);
	labelCategory.SetFrameTransparency(180);
	*/

	drawLabels.SetFontName(_T("����"));
	//drawLabels.SetFontName(_T("Arial"));
	drawLabels.SetFontColor(RGB(220,220,220));
	drawLabels.SetFontSize(12);
	drawLabels.SetFontBold(true);
	drawLabels.SetOffsetX(8);
	drawLabels.SetFrameVisible(true);
	drawLabels.SetFrameOutlineWidth(0);
	drawLabels.SetFrameTransparency(150);
	drawLabels.SetFrameBackColor(RGB(50,50,50));
	drawLabels.SetFrameOutlineColor(RGB(50,50,50));
	
	//labelCategory.SetLineOrientation(mapWindow::tkLineLabelOrientation::lorParallel);

	//drawLabels.AddLabel(str,textLon,textLat,_angle-90,0);
	drawLabels.AddLabel(str,textLon,textLat,0,0);

	//�ػ�
	m_map.Redraw();
}

//����:��ʾ����֮��ľ���ͷ�λ
void CGISDlg::DrawDistLabel(long drawLayerID,const double pts[][2], const int ptNum,int pos)
{
	double _dis, _angle;
	double dist_total = 0;
	int i = 0;
	for (i=0; i<ptNum-1; i++)
	{

		CalculateTwoPtsDistanceAzimuth(_dis, _angle, pts[i][0], pts[i][1], pts[i+1][0], pts[i+1][1], 3);

		dist_total += _dis;

		CString str = _T("");
		if(i==0)
		{
			if ( dist_total < 1000)
			{
				str.Format(_T("%dm;%.1f��"), int(dist_total), _angle);		
			} 
			else
			{
				if(_dis<1000)
				{
					str.Format(_T("%.2fkm;%.1f��"), dist_total*0.001, _angle);	
				}
				else
				{
					str.Format(_T("%.2fkm;%.1f��"), dist_total*0.001,_angle);
				}
			}
		}
		else
		{
			if ( dist_total < 1000)
			{
				str.Format(_T("%dm(+%dm);%.1f��"), int(dist_total), int(_dis), _angle);		
			} 
			else
			{
				if(_dis<1000)
				{
					str.Format(_T("%.2fkm(+%dm);%.1f��"), dist_total*0.001, int(_dis), _angle);	
				}
				else
				{
					str.Format(_T("%.2fkm(+%.2fkm);%.1f��"), dist_total*0.001,_dis*0.001,_angle);
				}
			}
		}

		//������Ŀ��֮������λ�ù�ϵ�������ֱ�ע
		double textLon = 0;
		double textLat = 0;

		//�����ע������
		switch (pos)
		{
		case -1: //��˵�
			TargetPos2LabelPos(textLon, textLat, pts[i][0], pts[i][1]);
			break;
		case 0: //�м�
			TargetPos2LabelPos(textLon, textLat, (pts[i][0] + pts[i+1][0])/2, (pts[i][1] + pts[i+1][1])/2);
			break;
		case 1: //�Ҷ˵�
			TargetPos2LabelPos(textLon, textLat, pts[i+1][0], pts[i+1][1]);
			break;
		}

		CLabels drawLabels = m_map.GetDrawingLabels(drawLayerID);
		CLabelCategory labelCategory = drawLabels.AddCategory(_T("totaldist"));
		labelCategory.SetFontName(_T("����"));
		labelCategory.SetFontColor(RGB(220,220,220));
		labelCategory.SetFontBold(true);
		labelCategory.SetFontSize(10);
		labelCategory.SetOffsetX(10);
		labelCategory.SetFrameTransparency(150);
		labelCategory.SetFrameVisible(true);
		labelCategory.SetFrameBackColor(RGB(50,50,50));
		labelCategory.SetFrameOutlineColor(RGB(50,50,50));

		if (pos==0)
		{
			drawLabels.AddLabel(str,textLon,textLat,_angle-90,0);
		}
		else
		{
			drawLabels.AddLabel(str,textLon,textLat,0,0);
		}

		//�ػ�
		m_map.Redraw();
		//m_map.DrawLabelEx(drawLayerID,str,textLon,textLat,_angle);
	}
}

//����:��ʾ����֮��ľ���ͷ�λ
void CGISDlg::DrawDistLebel(long drawLayerID,const PtStruct *pts, const int ptNum)
{
	double _dis, _angle;
	double dist_total = 0;
	int i = 0;
	for (i=0; i<ptNum-1; i++)
	{

		CalculateTwoPtsDistanceAzimuth(_dis, _angle, pts[i].dX, pts[i].dY, pts[i+1].dX, pts[i+1].dY, 3);

		dist_total += _dis;

		CString str = _T("");
		if(i==0)
		{
			if ( dist_total < 1000)
			{
				str.Format(_T("%dm;%.1f��"), int(dist_total), _angle);		
			} 
			else
			{
				if(_dis<1000)
				{
					str.Format(_T("%.2fkm;%.1f��"), dist_total*0.001, _angle);	
				}
				else
				{
					str.Format(_T("%.2fkm;%.1f��"), dist_total*0.001,_angle);
				}
			}
		}
		else
		{
			if ( dist_total < 1000)
			{
				str.Format(_T("%dm(+%dm);%.1f��"), int(dist_total), int(_dis), _angle);		
			} 
			else
			{
				if(_dis<1000)
				{
					str.Format(_T("%.2fkm(+%.dm);%.1f��"), dist_total*0.001, int(_dis), _angle);	
				}
				else
				{
					str.Format(_T("%.2fkm(+%.2fkm);%.1f��"), dist_total*0.001,_dis*0.001,_angle);
				}
			}
		}

		//������Ŀ��֮������λ�ù�ϵ�������ֱ�ע
		double textLon = 0;
		double textLat = 0;

		//�����ע������
		TargetPos2LabelPos(textLon, textLat, (pts[i].dX + pts[i+1].dX)/2, (pts[i].dY + pts[i+1].dY)/2);

		CLabels drawLabels = m_map.GetDrawingLabels(drawLayerID);
		CLabelCategory labelCategory = drawLabels.AddCategory(_T("totaldist"));
		labelCategory.SetFontName(_T("����"));
		labelCategory.SetFontColor(RGB(220,220,220));
		labelCategory.SetFontBold(true);
		labelCategory.SetFontSize(12);
		labelCategory.SetOffsetX(10);
		labelCategory.SetFrameTransparency(150);
		labelCategory.SetFrameVisible(true);
		labelCategory.SetFrameBackColor(RGB(50,50,50));
		labelCategory.SetFrameOutlineColor(RGB(50,50,50));

		drawLabels.AddLabel(str,textLon,textLat,_angle-90,0);
		//�ػ�
		m_map.Redraw();
		//m_map.DrawLabelEx(drawLayerID,str,textLon,textLat,_angle);
	}
}

//���������
void CGISDlg::ClearPloylineMeasure()
{
	m_map.RemoveLayer(m_polylineMeasureLineLayerID);
	m_map.RemoveLayer(m_polylineMeasurePtLayerID[0]);
	m_map.RemoveLayer(m_polylineMeasurePtLayerID[1]);
	m_map.ClearDrawing(m_polylineMeasureLabelLayerID);
	m_map.ClearDrawing(m_tempLayerID);

	m_polylineMeasureLineLayerID = -1;
	m_polylineMeasureLabelLayerID = -1;
	m_polylineMeasurePtLayerID[0] = -1;
	m_polylineMeasurePtLayerID[1] = -1;

	m_map.Redraw();
}

//���ܣ��ر���ʾ���ȡ�γ�ȵ���������
LRESULT CGISDlg::OnCloseLonLatDialog(WPARAM wParam, LPARAM lParam)
{	
	OnShowLonLatInfo();

	return 0;
}



//���ܣ��ر���ʾ2��֮��ľ�γ���������������
LRESULT CGISDlg::OnCloseShowDistanceDialog(WPARAM wParam, LPARAM lParam)
{	
	OnSurvey();

	return 0;
}


//���ܣ����к�����ƣ������������ݶԻ���
void CGISDlg::OnFlyLineDesign()
{
	//return;
	//�Ѿ����ص�ͼ
	 	if (m_bHaveAddMap)
	 	{
	 		//�Ѿ����ں������״̬ʱ������
	 		if (m_bLineDesign)
	 		{
	 			return;
	 		}
	 		else
	 		{
	 			m_bLineDesign = true;
	 
	 			//��Ƶ�һ������
	 			m_bDesignFirstPoint = true;
	 		}

	 		//������еĺ�������
	 		m_pFlyLineDesign->ClearCurrentData();
	 
	 		//��ʾ������ƶԻ���	
	 		//m_pFlyLineDesign->ShowWindow(SW_SHOW);

			
	 	
	 		//��ʾ����
	 		//m_pLineSectDlg->ShowWindow(SW_SHOW);
	 
	 		//�������Ϊ��ѡ����ʽ
	 		m_map.SetCursorMode(3);
	 	}
	 	else
	 	{
	 		AfxMessageBox(_T("���ȼ��ص�ͼ���ݣ�"));
	 	}	
}


//���ܣ�����GIS����ʾ����
void CGISDlg::SetGISWindowArea(const CRect gisArea)//������������ΪGIS�Ի������Ļ��������
{	
	//������ȫ��Ļ�е�GIS��ʾ����
	m_rcGISArea = gisArea;
}

//���ܣ���ʾGIS�Ի�������
void ShowDlg(const CRect rc, CWnd* pParent)
{
	  //pParent->Create(IDD_DIALOG1,pParent);
	
}

//���ܣ��������ڱ�����˻���18��������
void CGISDlg::CalculateUAVPolygonCoordinate(const double dX, const double dY, const double yaw)
{	
	double pixelX = 0;
	double pixelY = 0;

	m_map.ProjToPixel(dX, dY,	&pixelX, &pixelY);

	// ���ɻ�
	//������
	double sinang = sin(yaw * DEG2RAD);
	double cosang = cos(yaw * DEG2RAD);

	//��ת�����������
	double rotatePixelX = 0;
	double rotatePixelY = 0;

	//���㾭��������ת��ƽ�ƺ�����˻�����
	for(int k=0; k<m_ptNum; k++)   //��18������
	{
		rotatePixelX = pixelX + (m_ptPlane[k].x * cosang - m_ptPlane[k].y * sinang);	  //X������������
		rotatePixelY = pixelY + (m_ptPlane[k].x * sinang + m_ptPlane[k].y * cosang);	  //Y������������

		//��������ת��γ������
		m_map.PixelToProj(rotatePixelX, rotatePixelY, &m_ppUavPtArray[k][0], &m_ppUavPtArray[k][1]);
	}
}
void CGISDlg::CalculateUAVPolygonCoordinate_ADS(const double dX, const double dY, const double yaw)
{	
	double pixelX = 0;
	double pixelY = 0;

	m_map.ProjToPixel(dX, dY,	&pixelX, &pixelY);

	// ���ɻ�
	//������
	double sinang = sin(yaw * DEG2RAD);
	double cosang = cos(yaw * DEG2RAD);

	//��ת�����������
	double rotatePixelX = 0;
	double rotatePixelY = 0;

	//���㾭��������ת��ƽ�ƺ�����˻�����
	for(int k=0; k<m_ptNum; k++)   //��18������
	{
		rotatePixelX = pixelX + (m_ptPlane_ADS[k].x * cosang - m_ptPlane_ADS[k].y * sinang);	  //X������������
		rotatePixelY = pixelY + (m_ptPlane_ADS[k].x * sinang + m_ptPlane_ADS[k].y * cosang);	  //Y������������

		//��������ת��γ������
		m_map.PixelToProj(rotatePixelX, rotatePixelY, &m_ppUavPtArray_ADS[k][0], &m_ppUavPtArray_ADS[k][1]);
	}
}

//���ܣ����յ�������ƶԻ����˳���Ϣ�����д���
LRESULT CGISDlg::OnCloseLineDesignDialog(WPARAM wParam, LPARAM lParam)
{
	//������Ʊ�ʶΪFALSE
	m_bLineDesign = false;

	//����뺽�������صı�ע����
	RemoveDesignLineData();

	//���غ������ʱ����ʾ�������ݵĶԻ���
	m_pLineSectDlg->ShowWindow(SW_HIDE);

	return 0;
}

//���ܣ�ɾ��������Ƶ����ݣ������������ݺͺ��߱������
void CGISDlg::RemoveDesignLineData()
{
	//��Ƶĺ����������0ʱ
	if (m_designLinePointNum > 0)
	{
		m_designLinePointNum = 0;

		//����������ʱ�����ı����Ϣ
		ClearDrawingInLineDesign();
		//m_map.RedrawWindow(m_designLineLayerID2);

	}
}

//���ܣ�����������ʱ��������
void CGISDlg::ClearDrawingInLineDesign()
{
	/////////////����������/////////////

	//ɾ���Ѿ�����ֱ��
	m_map.ClearDrawing(m_tempLayerID);
	m_map.ClearDrawing(m_designLineLayerID);
	if (m_designLineLayerID2 != -1)
	{
		m_map.RemoveLayer(m_designLineLayerID2);
	}
	m_map.ClearLabels(m_designLineLayerID);
}

// �����ֹ����¼�
void CGISDlg::MouseWheel(short zDelta)
{
	m_bSetPointModel=FALSE;


	//m_bHaveShowLineDesign = TRUE;

	//m_bLDSetPoint = FALSE;
	//m_bLineDesign=FALSE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;
	if (m_bHaveAddMap)
	{
		//���ַŴ���С
		m_map.ZoomIn(0.0005 * zDelta);
	}
}


//���ܣ�����Ŀ��㣬�ڵ�ͼ��ʾ��������
//���룺Ŀ����nPt������dX��γ��dY
void CGISDlg::AddTargetPoint(const int nPt, const double dX, const double dY)
{
	//û�м��ص�ͼ
	if (!m_bHaveAddMap)
	{
		return;
	}

	CString str;
	str.Format(_T("Target%d"), nPt);

	//��������ɫ
	CString strColor = _T("��ɫ");

	//���ڵ�ͼ����б�ע
	AddPointShapeLayer(m_targetDrawLayerID, dX, dY, str, strColor, RGB(0,255,0));
}


//���ܣ���ʸ��ͼ���ж�̬�������˻�
//���룺����dX��γ��dY,�����yaw
//˵��������ר�����ڻ������˻���ʸ����ͼ�㣬ÿ����ɾ���ϴα���Shp�������±��
void CGISDlg::DrawUAV(int uavid, const double dX, const double dY, const double yaw,bool control)
{
	if (uavid<0||uavid>2)
	{
		return;
	}
	//2017.03 by ZCW
	/*
	//��һ�α�溽�����½����ͼ��
	if (!m_bFirstDrawUAVTrack)
	{
		//�������˻��켣�߱��ͼ��
		CreateEmptyShapfile(m_flyTrackLayerID, 1, RGB(255,0,0));

		//�������˻�������ͼ��
		CreateEmptyShapfile(m_UAVFlyTrackLayerID, 2, RGB(255,0,0));

		m_bFirstDrawUAVTrack = true;
	}
	else
	{
		//���������˻��Ĺ켣
		m_map.RemoveLayer(m_UAVFlyTrackLayerID);

		//�������˻�������ͼ��
		CreateEmptyShapfile(m_UAVFlyTrackLayerID, 2, RGB(255,0,0));
	}

	//�������˻��켣��
	AddOnePoint2Shapfile(m_flyTrackLayerID, 1, dX, dY);

	//���������˻���ͼ��ĵ�����
	CalculateUAVPolygonCoordinate(dX, dY, yaw);

	//	AddUAVPoints2Polygon(m_UAVFlyTrackLayerID);

	//�����µ����˻�shp
	for (int i=0; i<m_ptNum; i++)
	{
		AddOnePoint2Shapfile(m_UAVFlyTrackLayerID, 2, m_ppUavPtArray[i][0], m_ppUavPtArray[i][1]);
	}
	*/

	COLORREF color = RGB(255,255,0);
	if (control)
	{
		color = RGB(255,0,0);
	}

	//��һ�α�溽�����½����ͼ��
	if (!m_bFirstDrawUAVTrack[uavid])
	{
		//�������˻��켣�߱��ͼ��
		CreateEmptyShapfile(m_flyTrackLayerID[uavid], 1,color);

		//�������˻�������ͼ��
		CreateEmptyShapfile(m_UAVFlyTrackLayerID[uavid], 2, color);

		m_bFirstDrawUAVTrack[uavid] = true;
	}
	//�������˻��켣��
	AddOnePoint2Shapfile(m_flyTrackLayerID[uavid], 1, dX, dY);

	//���������˻���ͼ��ĵ�����
	CalculateUAVPolygonCoordinate(dX, dY, yaw);

	int i = 0;

	//ɾ�����е�shpͼ��
	for (i=0; i<m_ptNum; i++)
	{
		(m_map.GetShapefile(m_UAVFlyTrackLayerID[uavid])).EditDeleteShape(i);
	}
	//(m_map.GetShapefile(m_UAVFlyTrackLayerID2)).EditClear();
	//�����µ����˻�shp
	for (i=0; i<m_ptNum; i++)
	{
		AddOnePoint2Shapfile(m_UAVFlyTrackLayerID[uavid], 2, m_ppUavPtArray[i][0], m_ppUavPtArray[i][1]);
	}

}

void CGISDlg::DrawUAV_ADS(const int uavNum, const int uavid, const double lon, const double lat, const double yaw, const bool control, const CString strPlaneName)
{
	m_bWithin100km_ADS[uavid] = control; //�Ƿ���100km��

	m_dLon_ADS[uavid] = lon;
	m_dLat_ADS[uavid] = lat;
	m_dYaw_ADS[uavid] = yaw;

	m_strPlaneName_ADS[uavid] = strPlaneName;

	m_iTotalADSnum = uavNum;
}

//����;ˢ�³����ĺ���
//˵����Ŀ������Ʊ�עλ������Ŀ���λ�ô���Y�����ƫ������Ŵ���С����ʱ����ע��Ŀ���λ�������Ǻ�
void CGISDlg::OnRefreshInfo()
{

}


//���ܣ���ӡ���������ͼ��ʾ�������ע��Ϣ�����bmp�ļ���
void CGISDlg::OnPrint()
{
	CRect rc;
	GetClientRect(&rc);
	//m_map.MoveWindow(0,0,rc.Width(),rc.Height(),1);


	CRect rcGISCopyArea = m_gisAreaInScreen;
	rcGISCopyArea.top += m_toolbarHeight;

	CScreenCapture capture;		

	capture.ScreenGISArea(rcGISCopyArea);	
}

void CGISDlg::OnShowCtrlMenu()
{
	/*if (!m_bLineDesign)
	{
		return;
	}

	if (m_bLineDesign) */  //���߱༭ʱ��ֹͣ�༭
	{
		if (m_map.GetCursorMode() != mapWindow::tkCursorMode::cmNone)
		{
			m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
		}
		
		//TRACE(_T("�������\n"));
		////�����������Ա༭  
		//int iSel=GetPtSel(m_LBtnDownX,m_LBtnDownY);
		//if (iSel!=-1)
		//{ 
		//	double dPointX, dPointY;
		//	//��������ת����������
		//	m_map.PixelToProj(m_LBtnDownX, m_LBtnDownY, &dPointX, &dPointY);

		//	//���õ�ľ��ȡ�γ��
		//	m_DlgLinePointAttri.SetPtCoordinate(dPointX, dPointY, iSel, m_designLinePointNum, m_pDesignLineStruct);
		//}

		if (g_b981APad)
		{
			CMenu   tmenu;
			tmenu.LoadMenu(IDR_FLOATINGMENU);        
			POINT   pt;
			GetCursorPos( &pt );
			//������ݲ˵�
			tmenu.GetSubMenu( 0 )->TrackPopupMenu( TPM_LEFTALIGN | TPM_LEFTBUTTON, pt.x, pt.y, this );
		}


		return;

	}
}

void CGISDlg::OnMenuLinePtCtrlShow()
{
	//����Ҽ����ʱ��������ݲ˵�
	if (g_b981APad)
	{
		OnShowRMenu();
	}
	else
	{
		OnMapSelect();
	}
}


void CGISDlg::OnZhangCW()
{
	int i = 0;
}

BOOL CGISDlg::OnToolTipsNotify(UINT id,NMHDR* pNMHDR,LRESULT* pResult)
{
	TOOLTIPTEXT* pT = (TOOLTIPTEXT*)pNMHDR;
	UINT nID = pNMHDR->idFrom;
	switch (nID)
	{
	case IDT_BUTTON1: 
		pT->lpszText = "����ʸ����ͼ";
			break;
	case IDT_BUTTON2: 
		pT->lpszText = "����դ���ͼ";
			break;
	case IDT_BUTTON3: 
		pT->lpszText = "���Ӻ���";
			break;
	case IDT_BUTTON4: 
		pT->lpszText = "ͼ�����";
			break;
	case IDT_BUTTON5: 
		pT->lpszText = "ɾ��ȫ��ͼ��";
			break;
	case IDT_BUTTON6: 
		pT->lpszText = "��ͼѡ��";
			break;
	case IDT_BUTTON7: 
		pT->lpszText = "�Ŵ�";
			break;
	case IDT_BUTTON8: 
		pT->lpszText = "��С";
			break;
	case IDT_BUTTON9: 
		pT->lpszText = "����";
			break;
	case IDT_BUTTON10: 
		pT->lpszText = "ȫͼ";
			break;
	case IDT_BUTTON11: 
		pT->lpszText = "�������";
			break;
	case IDT_BUTTON12: 
		pT->lpszText = "��ͼ��λ";
			break;
	case IDT_BUTTON13: 
		pT->lpszText = "����";
			break;
	case IDT_BUTTON14: 
		pT->lpszText = "����";
		break;
	default:
		pT->lpszText ="";
	}
	return true;
}

//���ܣ�ɾ������ID�ŵ�Ŀ���
void CGISDlg::DeleteTarget(const int nPt)
{
	//�жϸ�����Ŀ�����Ƿ�Ϸ�
	//if (nPt >= MAX_TARGET_NUM)
	//{
	//	return;
	//}

	//int i = nPt-1;

	////ɾ�����б�ע��Ŀ�����Ϣ
	//if (m_pTargetShapfileID[i] != 0)
	//{
	//	//�жϵ�ʸ��ͼ���Ƿ��Ѿ����ڣ�������ɾ��
	//	ClearPointShape(m_pTargetShapfileID[i]);
	//	m_pTargetShapfileID[i] = 0;
	//}

}

//���ܣ�ɾ������Ŀ���
void CGISDlg::DeleteAllTargets()
{
	//ɾ�����б�ע��Ŀ�����Ϣ
	//for (int i=0; i<MAX_TARGET_NUM; i++)
	//{
	//	if (m_pTargetShapfileID[i] != 0)
	//	{
	//		//�жϵ�ʸ��ͼ���Ƿ��Ѿ����ڣ�������ɾ��
	//		ClearPointShape(m_pTargetShapfileID[i]);

	//		m_pTargetShapfileID[i] = 0;
	//	}
	//}
}


//���ܣ�����Ŀ�������λ�ü���Ŀ���ű�עλ��
//���룺Ŀ���λ�þ��ȡ�targetLon��γ�ȡ�targetLat
//�����Ŀ����עλ�þ��ȡ�labelLon��γ�ȡ�labelLat
void CGISDlg::TargetPos2LabelPos(double &labelLon, double &labelLat, const double targetLon, const double targetLat)
{
	double textPixelX = 0;
	double textPixelY = 0;

	//��������ת��������
	m_map.ProjToPixel(targetLon, targetLat, &textPixelX, &textPixelY);

	//y�������ƫ����ֵ
	textPixelY -= m_labelWarpValue;

	//��������ת��������
	m_map.PixelToProj(textPixelX, textPixelY, &labelLon, &labelLat);
}


//���ܣ��ڵ�ͼ��ʾ�����Ŀ���
//���룺Ŀ���������targetInfo
//	    ���ͼ��ID��drawLayerID
//��������ͼ��ID��drawLayerID
void CGISDlg::DrawTarget(long &drawLayerID, const PtStruct targetInfo)
{
	//û�м��ص�ͼ������
	if (!m_bHaveAddMap)
	{
		return;
	}

	//��һ�α��ʱ�������µı��ͼ��
	if (drawLayerID == -1)
	{	
		//�������ͼ��
		drawLayerID = m_map.NewDrawing(1);
	}	

	CString str = _T("");

// 	��ʾ���߱��
// 	if (targetInfo.lineID <= 0)    //����ʾ������
// 	{
// 

		str.Format(_T("%d"), targetInfo.nPt);
// 	}
// 	else						   //��ʾ���ߺͺ����ţ��ԡ�X-XX����ʽ������ʾ
// 	{
// 		str.Format(_T("%d-%d"), targetInfo.lineID,targetInfo.nPt);
// 	}

	//���Ŀ���
	m_map.DrawPoint(targetInfo.dX, targetInfo.dY, 10,  RGB(0,0,255));	

	/* mapwinGIS 4.9.3�����
	//���ñ���������ɫ
	m_map.LabelColor(drawLayerID, RGB(0,255,0));
	//���ñ��������ֺ�
	m_map.LayerFont(drawLayerID, _T("����"), 20);
	*/

	/* mapwinGIS 4.9.3����� */
	CLabels labels = m_map.GetDrawingLabels(drawLayerID);
	labels.SetFrameVisible(false);
	labels.SetFontColor(RGB(0,255,0));
	labels.SetFontName(_T("����"));
	labels.SetFontSize(20);

	//������Ŀ��֮������λ�ù�ϵ�������ֱ�ע
	double textLon = 0;
	double textLat = 0;

	//�����ע������
	TargetPos2LabelPos(textLon, textLat, targetInfo.dX, targetInfo.dY);

	//��עĿ����ǩ����
	TRACE(str);
	TRACE("\n");
	//m_map.AddLabel(drawLayerID, str, RGB(255,255,0), textLon, textLat, 1);
	m_map.DrawLabelEx(drawLayerID, str,textLon, textLat,0);


	//�ػ�str
	m_map.Redraw();
}



//���ܣ����Ӻ��������ɺ󣬵�ͼ��ʾ�����к����ע
LRESULT CGISDlg::OnAddLinePoint(WPARAM wParam, LPARAM lParam)
{	
	//����������ʱ�ı�ע��Ϣ
	ClearDrawingInLineDesign();

	m_tempLayerID = -1;

	//���뺽�����ݼ�����
	m_pDesignLineStruct[m_designLinePointNum] = m_curDesignPoint;

	//�����ż���������1
	//m_designLinePointNum++;

	//������Ƶĺ�������
	DrawDesignLineData();

	//����ƶ�ʱ����ֱ��
	m_beTemLayerDrawing = true;

	//�Ƿ��Ѿ������µĺ���
	m_bAddNewPoint = true;

	//������ʾ���������ݣ���ʶ�����һ�����ε����
	m_pLineSectDlg->SetLineSectStatus();

	return 0;
}

//���ܣ������Ƶĺ������ݣ��������㼰���ע����������
void CGISDlg::DrawDesignLineData()
{

	//�½�����
	if (m_designLineLayerID2!=-1)
	{
		m_map.RemoveLayer(m_designLineLayerID2);
		m_designLineLayerID2 = -1;
	}
	
	
	m_map.ClearDrawing(m_designLineLayerID);
	m_designLineLayerID = m_map.NewDrawing(1);
	long index = m_map.GetLayerPosition(m_designLineLayerID);
	BOOL b= m_map.MoveLayerUp(index);
	int i = 0;	

	//���ƺ��㼰���ע
	for (i=0; i<m_designLinePointNum; i++)
	{
		DrawTarget(m_designLineLayerID, m_pDesignLineStruct[i]);

	}
	if (m_designLinePointNum>1)
	{
		CreateEmptyShapfile(m_designLineLayerID2,1,RGB(0,255,0));
		AddPoints2Shapfile(m_designLineLayerID2,1,m_pDesignLineStruct,m_designLinePointNum);
	    DrawDistLebel(m_designLineLayerID,m_pDesignLineStruct,m_designLinePointNum);
	}
	
	//���ƺ���֮�������
	/*for (i=0; i<m_designLinePointNum-1; i++)
	{
		m_map.DrawLineEx(m_designLineLayerID,m_pDesignLineStruct[i].dX, m_pDesignLineStruct[i].dY,
			m_pDesignLineStruct[i+1].dX, m_pDesignLineStruct[i+1].dY, 2, RGB(0,255,0));
	}*/
}


//���ܣ��༭���㣬����󣬵�ͼ��ʾ�����к����ע
LRESULT CGISDlg::OnEditLinePoint(WPARAM wParam, LPARAM lParam)
{
	//���º�������
	PtStruct ptEdit;
	memcpy(&ptEdit, (PtStruct *)wParam, sizeof(PtStruct));

	if (lParam == 0)   //�������ݱ༭
	{		
		//����ƶ�ʱ����ֱ��
		m_beTemLayerDrawing = true;
	}
	else if (lParam == 1)     //����༭ģʽ
	{
		//����ƶ�ʱ����ֱ��
		m_beTemLayerDrawing = false;
	}

	//�������ݸ���
	m_pDesignLineStruct[ptEdit.nPt-1] = ptEdit;		

	//����������ʱ�ı�ע��Ϣ
	ClearDrawingInLineDesign();

	//������Ƶĺ�������
	DrawDesignLineData();

	//��ǰ���༭�ĺ�������
	memcpy(&m_curEditLinePoint, &ptEdit, sizeof(PtStruct));

	return 0;
}


//���ܣ�ɾ�����㣬����󣬵�ͼ��ʾ�����к����ע
LRESULT CGISDlg::OnDeleteLinePoint(WPARAM wParam, LPARAM lParam)
{
	//ɾ����ĵ��
	int deletePtID = (int)wParam;

	if ((deletePtID > (m_designLinePointNum-1)) || (deletePtID<0))
	{
		return 0;
	}

	//����ɾ����ĵ�ţ����º������ݼ���
	for (int i=deletePtID; i<m_designLinePointNum-1; i++)
	{
		m_pDesignLineStruct[i] = m_pDesignLineStruct[i+1];
		m_pDesignLineStruct[i].nPt --;
	}

	//�ܵĺ��������ȥ1
	m_designLinePointNum --;

	//����������ʱ�ı�ע��Ϣ
	ClearDrawingInLineDesign();

	//������Ƶĺ�������
	DrawDesignLineData();

	//����ƶ�ʱ����ֱ��
	m_beTemLayerDrawing = true;

	return 0;
}


//���ܣ����溽�ߣ�����󣬵�ͼ��ʾ�����к����ע
LRESULT CGISDlg::OnSaveLinePoints(WPARAM wParam, LPARAM lParam)
{
	//������Ʊ�ʶΪFALSE
	m_bLineDesign = false;

	//����뺽�������صı�ע����
	RemoveDesignLineData();

	//���غ������ʱ����ʾ�������ݵĶԻ���
	m_pLineSectDlg->ShowWindow(SW_HIDE);

	return 0;
}

//���ܣ������յ�shpfileͼ��
//���룺ʸ��ͼ������shpType��0Ϊ����ͼ�㣻1Ϊ��ͼ�㣻2Ϊ��ͼ�㣩
//���룺������ɫdrawColor
//�����ʸ��ͼ��ID��shpLayerID��
void CGISDlg::CreateEmptyShapfile(long &shpLayerID, const int shpType, const unsigned long drawColor)
{
	long fieldIndex = 0;

	//Ŀ����SHPͼ��
	mapWindow::IShapefilePtr targetPtShape;
	targetPtShape.CreateInstance("MapWinGIS.Shapefile");		

	//�����յ�ͼ��
	if (shpType == 0)   //��ͼ��
	{
		targetPtShape->CreateNewWithShapeID(_T(""), mapWindow::SHP_POINT);
	}
	else if (shpType == 1)   //��ͼ��
	{
		targetPtShape->CreateNewWithShapeID(_T(""), mapWindow::SHP_POLYLINE);
	}
	else if (shpType == 2)   //��ͼ��
	{
		targetPtShape->CreateNewWithShapeID(_T(""), mapWindow::SHP_POLYGON);
	}
	else
	{
		shpLayerID = -1; 
		return;
	}

	//����field����1
	mapWindow::IFieldPtr fieldPtr1;
	fieldPtr1.CreateInstance("MapWinGIS.Field");	

	fieldPtr1->Key = (_bstr_t)("X");
	fieldPtr1->Type = mapWindow::DOUBLE_FIELD;
	targetPtShape->EditInsertField(fieldPtr1, &fieldIndex, NULL);

	//����field����2
	mapWindow::IFieldPtr fieldPtr2;
	fieldPtr2.CreateInstance("MapWinGIS.Field");	

	fieldPtr2->Key = (_bstr_t)("Y");
	fieldPtr2->Type = mapWindow::DOUBLE_FIELD;
	targetPtShape->EditInsertField(fieldPtr2, &fieldIndex, NULL);

	//Ŀ����ͼ������ͼ��
	shpLayerID = m_map.AddLayer(targetPtShape, true);

	mapWindow::IShapeDrawingOptionsPtr  pShapeDrawingOption;
	pShapeDrawingOption.CreateInstance("MapWinGIS.ShapeDrawingOptions");	

	if (shpType == 0)   //��ͼ��
	{
		pShapeDrawingOption->FillColor = drawColor;
		pShapeDrawingOption->PointSize = 20;
		//pShapeDrawingOption->SetDefaultPointSymbol(mapWindow::tkDefaultPointSymbol::dpsDiamond);
		//pShapeDrawingOption->PutFillColor(drawColor);
		//pShapeDrawingOption->PutPointSize(18);
		pShapeDrawingOption->PutPointType(mapWindow::tkPointSymbolType::ptSymbolStandard);
		pShapeDrawingOption->PutPointShape(mapWindow::tkPointShapeType::ptShapeStar);
		
		//m_map.SetShapeLayerPointType(shpLayerID, mapWindow::ptDiamond);
		//m_map.SetShapeLayerStippleColor(shpLayerID, drawColor);
	}
	else if (shpType == 1)   //��ͼ��
	{
		pShapeDrawingOption->LineColor = drawColor;
		pShapeDrawingOption->LineWidth = 2;
	}
	else if (shpType == 2)   //��ͼ��
	{
		pShapeDrawingOption->FillColor = drawColor;
	}

	(m_map.GetShapefile(shpLayerID)).SetDefaultDrawingOptions(pShapeDrawingOption);
}


//���ܣ���shpfile��ͼ�������Ӻ�������
//���룺ʸ��ͼ��ID��shpLayerID
//      �������ݼ���pts���������ptNum
void CGISDlg::AddPoints2PointShapfile(const long shpLayerID, const PtStruct *pts, const int ptNum)
{
	for (long i=0; i<ptNum; i++)
	{
		mapWindow::IPointPtr pintPtr;
		pintPtr.CreateInstance("MapWinGIS.Point");	

		mapWindow::IShapePtr shapePtr;
		shapePtr.CreateInstance("MapWinGIS.Shape");

		shapePtr->Create(mapWindow::SHP_POINT);


		//����
		pintPtr->x = pts[i].dX;  

		//�
		pintPtr->y = pts[i].dY;  

		shapePtr->InsertPoint(pintPtr, &i);	


		//������ʸ��
		(m_map.GetShapefile(shpLayerID)).EditInsertShape(shapePtr, &i);		
	}
}


//���ܣ���shpfile��ͼ�������Ӻ�������
//���룺ʸ��ͼ��ID��shpLayerID
//      �������ݼ���pts���������ptNum
void CGISDlg::AddPoints2LineShapfile(const long shpLayerID, const PtStruct *pts, const int ptNum)
{
	mapWindow::IShapePtr shapePtr;
	shapePtr.CreateInstance("MapWinGIS.Shape");

	//������ʸ��shapfile
	shapePtr->Create(mapWindow::SHP_POLYLINE);

	long i = 0;

	for (i=0; i<ptNum; i++)
	{
		mapWindow::IPointPtr pintPtr;
		pintPtr.CreateInstance("MapWinGIS.Point");	

		//����
		pintPtr->x = pts[i].dX;  

		//�
		pintPtr->y = pts[i].dY;  

		shapePtr->InsertPoint(pintPtr, &i);	
	}

	//������ͼ��ʸ��
	(m_map.GetShapefile(shpLayerID)).EditInsertShape(shapePtr, &i);		
}


//���ܣ���shpfileͼ�������Ӻ�������
//���룺ʸ��ͼ��ID��shpLayerID��ʸ��ͼ������shpType��0Ϊ����ͼ�㣻1Ϊ��ͼ�㣻2Ϊ��ͼ�㣩
//      �������ݼ���pts���������ptNum
void CGISDlg::AddPoints2Shapfile(const long shpLayerID, const int shpType, const PtStruct *pts, const int ptNum)
{
	long i = 0;

	//���ͼ���м��뺽������
	if (shpType == 0)                        //��ͼ��
	{
		for (i=0; i<ptNum; i++)
		{
			mapWindow::IPointPtr pintPtr;
			pintPtr.CreateInstance("MapWinGIS.Point");	

			mapWindow::IShapePtr shapePtr;
			shapePtr.CreateInstance("MapWinGIS.Shape");

			shapePtr->Create(mapWindow::SHP_POINT);

			//����
			pintPtr->x = pts[i].dX;  

			//�
			pintPtr->y = pts[i].dY;  

			shapePtr->InsertPoint(pintPtr, &i);	

			//������ʸ��
			(m_map.GetShapefile(shpLayerID)).EditInsertShape(shapePtr, &i);		
		}
	}
	else if ((shpType == 1) || (shpType == 2))  //��ͼ�����ͼ��
	{
		mapWindow::IShapePtr shapePtr;
		shapePtr.CreateInstance("MapWinGIS.Shape");

		//����shp
		if (shpType == 1)    //��ʸ��
		{
			shapePtr->Create(mapWindow::SHP_POLYLINE);
		}
		else				 //��ʸ��
		{
			shapePtr->Create(mapWindow::SHP_POLYGON);
		}

		for (i=0; i<ptNum; i++)
		{
			mapWindow::IPointPtr pintPtr;
			pintPtr.CreateInstance("MapWinGIS.Point");	

			//����
			pintPtr->x = pts[i].dX;  

			//�
			pintPtr->y = pts[i].dY;  

			shapePtr->InsertPoint(pintPtr, &i);	
		}

		//������ʸ��
		(m_map.GetShapefile(shpLayerID)).EditInsertShape(shapePtr, &i);		
	}	
}


//���ܣ�����shpfile��ͼ���淽������UAV
void CGISDlg::AddUAVPoints2Polygon(const long shpLayerID)
{
	//������ͼ��
	mapWindow::IShapePtr shapePtr;
	shapePtr.CreateInstance("MapWinGIS.Shape");
	shapePtr->Create(mapWindow::SHP_POLYGON);

	long shpNum = 0;

	for (int i=0; i<18; i++)
	{
		mapWindow::IPointPtr pintPtr;
		pintPtr.CreateInstance("MapWinGIS.Point");	

		//����
		pintPtr->x = m_ppUavPtArray[i][0];  

		//�
		pintPtr->y = m_ppUavPtArray[i][1];  

		//��ǰshp�в���һ����������
		shapePtr->InsertPoint(pintPtr, &shpNum);
	}

	shpNum = 0;

	(m_map.GetShapefile(shpLayerID)).EditClear();

	//��shpfile�ļ��в���shp�ļ�
	(m_map.GetShapefile(shpLayerID)).EditInsertShape(shapePtr, &shpNum);

}


//���ܣ���shpfileͼ��������1����������
//���룺ʸ��ͼ��ID��shpLayerID��shp����shpType
//      �������ݣ����ȡ�dX; γ�ȡ�dY
void CGISDlg::AddOnePoint2Shapfile(const long shpLayerID, const int shpType, const double dX, const double dY)
{
	mapWindow::IPointPtr pintPtr;
	pintPtr.CreateInstance("MapWinGIS.Point");	

	//����
	pintPtr->x = dX;  

	//�
	pintPtr->y = dY;  

	//shpfile�ļ��е�shpͼ�����
	long shpNum = (m_map.GetShapefile(shpLayerID)).GetNumShapes();

	//�ж��Ƿ��Ѿ����ڸ�shpͼ�㣬�����ڣ������µ�shpͼ��
	if (shpNum == 0)
	{
		mapWindow::IShapePtr shapePtr;
		shapePtr.CreateInstance("MapWinGIS.Shape");

		if (shpType == 0)		//��ͼ��
		{
			shapePtr->Create(mapWindow::SHP_POINT);
		}
		else if (shpType == 1)  //��ͼ��
		{
			shapePtr->Create(mapWindow::SHP_POLYLINE);
		}
		else if (shpType == 2)  //��ͼ��
		{
			shapePtr->Create(mapWindow::SHP_POLYGON);
		}

		//��ǰshp�в���һ����������
		shapePtr->InsertPoint(pintPtr, &shpNum);

		//��shpfile�ļ��в���shp�ļ�
		(m_map.GetShapefile(shpLayerID)).EditInsertShape(shapePtr, &shpNum);		
	}
	else
	{
		//��õ�ǰ��shp
		CShape shape = (m_map.GetShapefile(shpLayerID)).GetShape(shpNum-1);

		//��ǰ�ĺ������
		long curLinePts = shape.GetNumPoints();

		//��ǰshp�в���һ����������
		shape.InsertPoint(pintPtr, &curLinePts);
	}
}


//���ܣ��ڵ�ͼ��ʾ������װ���ķ��к�������
//���룺���������弯��linePtArray�����ߵĺ������ptNum
//˵������ͼ��ʾ���Ѿ�����˸ú��ߣ��������棬���±�溽��
void CGISDlg::DrawBindingLine(const PtStruct *linePtArray, const int ptNum)
{
	if (ptNum == 0 )
	{
		return;				
	}

	//�������ݼ���
	DrawLineDataStruct lineDataArr;

	//����������ת���ĺ������ݼ���
	m_lineManage.LinePoint2DrawLinePoints(lineDataArr, linePtArray, ptNum);

	//��������
	ClearDrawedLine(lineDataArr.lineID-1);

	//�������ݵ����߼�����
	m_pFlyLines[lineDataArr.lineID-1] = lineDataArr;

	//��ͼ��������
   //DrawFlyLine(m_pFlyLines[lineDataArr.lineID-1]);
   DrawFlyLine(lineDataArr);
	
}

//���ܣ������к���
//���룺��������lineData
void CGISDlg::DrawFlyLine(const DrawLineDataStruct lineData)
{
	//field����ֵ
	long fieldIndex = 0;

	//����������
	int lineID = lineData.lineID-1;

	//û��Ŀ����SHPͼ�㣬������ͼ��
	if (!m_pHaveDrawLineFlag[lineID])
	{		
		//������ͼ��
		CreateEmptyShapfile(m_ppPlanLineShpLayerIDArr[lineID][0], 0, /*RGB(0,255,0)*/LineClr[lineID]);

		//������ͼ��
		CreateEmptyShapfile(m_ppPlanLineShpLayerIDArr[lineID][1], 1, /*RGB(0,255,0)*/LineClr[lineID]);

		//������ͼ��ɹ�
		m_pHaveDrawLineFlag[lineID] = true;
	}

	//���ͼ����뺽������
	AddPoints2PointShapfile(m_ppPlanLineShpLayerIDArr[lineID][0], lineData.pts, lineData.pointNum);


	//����ͼ����뺽������
	AddPoints2LineShapfile(m_ppPlanLineShpLayerIDArr[lineID][1], lineData.linePts, lineData.linePointNum);

	/////////////////////��SHPͼ���м���Ŀ����ע��Ϣ///////////////////////////////

	//Label����
	CLabels labesPtr;
	labesPtr = (m_map.GetShapefile(m_ppPlanLineShpLayerIDArr[lineID][0])).GetLabels();

	//CLabelCategory labelCategory = labesPtr.AddCategory(_T("��ɫ"));
	//labelCategory.SetFontColor(/*RGB(255,0,0)*/LineClr[lineID]);
	//labelCategory.SetAlignment(1);
	//labelCategory.SetFontBold(TRUE);
	//labelCategory.SetFontName(LPCTSTR("����"));
	//labelCategory.SetFontSize(12);
	//labesPtr.SetAvoidCollisions(FALSE);
	labesPtr.SetFontColor(/*RGB(255,0,0)*/LineClr[lineID]);
	labesPtr.SetAlignment(1);
	labesPtr.SetFontBold(true);
	labesPtr.SetFontName(LPCTSTR("����"));
	labesPtr.SetFontSize(16);
	labesPtr.put_FontSize2(16);
	labesPtr.SetFrameVisible(false);
	labesPtr.SetAvoidCollisions(FALSE); 


	CString strText = _T("");

	//��溽�������
	for (long i=0; i<lineData.pointNum; i++)
	{
		//��ע��Ϣ
		if ( 14 ==lineData.lineID)
		{
			strText.Format(_T("������½��") /*lineData.lineID, */ /*lineData.pts[i].nPt*/);
		}
		else
		{
            strText.Format(_T("%d-%d"), lineData.lineID,  lineData.pts[i].nPt);
		}
		
		//����Labels
		labesPtr.AddLabel((LPCTSTR)strText, lineData.pts[i].dX, lineData.pts[i].dY, 0, 0);
	}	
	/////////////////////��SHPͼ���м���Ŀ����ע��Ϣ///////////////////////////////

	//���»���
	m_map.Redraw();
}


//���ܣ����ݵ�ͼ�ؼ�����ʾ�ֱ����ƶ���ͼ�ؼ�
//˵����������ʾ�ֱ��ʺ���Ʒֱ���֮��ļ��ι�ϵ
//���룺�ƶ���ʾ������moveToArea
void CGISDlg::MoveGISShowWindow(const CRect moveToArea)
{
	CRect gisRect;

	//X����ֱ���
	double cx = 1.0*moveToArea.Width()/m_rcDesignGISWindow.Width();

	//Y����ֱ���
	double cy = 1.0*moveToArea.Height()/m_rcDesignGISWindow.Height();

	gisRect.left = static_cast<int>(m_rcDesignGISWindow.left*cx);
	gisRect.top = static_cast<int>(m_rcDesignGISWindow.top*cy);

	gisRect.right = moveToArea.right;
	gisRect.bottom = moveToArea.bottom;

	//��ͼ��ʾ�����ȡ��߶ȵ���
	m_onePerWidth = 1.0/gisRect.Width();
	m_onePerHeight = 1.0/gisRect.Height();

	//��ͼ��ʾ�����ȡ��߶�
	m_mapAreaHalfWidth = 0.5*gisRect.Width();
	m_mapAreaHalfHeight = 0.5*gisRect.Height();

	//��ͼ�ؼ��ƶ�����������
	GetDlgItem(IDC_MAP1)->MoveWindow(gisRect, TRUE);
}


void CGISDlg::OnMouseMove(UINT nFlags, CPoint point) 
{	
	CBCGPDialog::OnMouseMove(nFlags, point);
}


//���ܣ���������������
void CGISDlg::CreateFloatToolBar()
{
	CBitmap bm;  

	UINT Resource[14]={IDB_BITMAP_ADD_SHPFILE, IDB_BITMAP_ADD_IMGFILE, IDB_BITMAP_ADD_FLYLINE, 
		IDB_BITMAP_LAYER_MANAGE, IDB_BITMAP_DELETE_LAYER,
		IDB_BITMAP_SELECT, IDB_BITMAP_ZOOMIN, IDB_BITMAP_ZOOMOUT,
		IDB_BITMAP_MOVE, IDB_BITMAP_FULLSCREEN, IDB_BITMAP_RULER,
		IDB_BITMAP_XY, IDB_BITMAP_SURVEY,  
		IDB_BITMAP10/*IDB_BITMAP_PRINT*/};          //λͼID����  


	m_ImageList.Create(24, 24, ILC_COLOR24|ILC_MASK, 0, 0);                  //����Image List  

	CRect rcToolBar;
	/*rcToolBar.top = m_rcGISArea.top;
	rcToolBar.left = m_rcGISArea.right-24;
	rcToolBar.bottom = m_rcGISArea.bottom;
	rcToolBar.right = m_rcGISArea.right;*/
	//m_ToolBar.Create(TBSTYLE_FLAT | CCS_TOP | WS_VISIBLE | /*WS_BORDER |*/ CCS_ADJUSTABLE | TBSTYLE_TOOLTIPS, rcToolBar, this, IDR_TOOLBAR1);                    //����Toolbar Control  
	m_ToolBar.Create(TBSTYLE_FLAT | CCS_TOP | WS_VISIBLE | /*WS_BORDER |*/ TBSTYLE_TOOLTIPS, rcToolBar, this, IDR_TOOLBAR1);                    //����Toolbar Control  

	m_ToolBar.SetBitmapSize(CSize(24, 24));  

	int buttonItems = 14;

	int i;  

	for(i=0; i<buttonItems; i++)  
	{  
		bm.LoadBitmap(Resource[i]);  
		m_ImageList.Add(&bm, (CBitmap *)NULL);  
		bm.Detach();  
	}  

	m_ToolBar.SetImageList(&m_ImageList);  

	TBBUTTON Buttons[14];														  	 //����TBBUTTON�ṹ������  
	CString str;  

	for(i=0; i<buttonItems; i++)  
	{  
		str.LoadString(IDT_BUTTON1+i);                                                //IDS_FILE����String Table�����ӵ�String  
		//	   Buttons[i].iString = m_ToolBar.AddStrings(str);  
		Buttons[i].iString = NULL;  

		Buttons[i].dwData=0;  
		Buttons[i].fsState=TBSTATE_ENABLED;  
		Buttons[i].fsStyle=TBSTYLE_BUTTON;  
		Buttons[i].iBitmap=i;  
		Buttons[i].idCommand = IDT_BUTTON1+i;		//��ť������Ӧ  

		
	}  
	m_ToolBar.EnableToolTips(true);//���ӹ������ϰ�ť��ʾ����

	m_ToolBar.AddButtons(buttonItems, Buttons);  
	m_ToolBar.AutoSize();  

	//m_ToolBar.ShowWindow(SW_HIDE);  
	RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST, 0);
}


BOOL CGISDlg::OnToolTipText(UINT,NMHDR* pNMHDR,LRESULT*   pResult)  
{     
	ASSERT(pNMHDR->code == TTN_NEEDTEXTA || pNMHDR->code == TTN_NEEDTEXTW);         //   UNICODE��Ϣ     
	TOOLTIPTEXTA*   pTTTA = (TOOLTIPTEXTA*)pNMHDR;     TOOLTIPTEXTW*   pTTTW = (TOOLTIPTEXTW*)pNMHDR;     //TCHAR   szFullText[512];     
	CString strTipText;     
	UINT   nID = pNMHDR->idFrom;         

	if(pNMHDR->code == TTN_NEEDTEXTA  &&  (pTTTA->uFlags & TTF_IDISHWND) ||  pNMHDR->code == TTN_NEEDTEXTW  &&  (pTTTW->uFlags & TTF_IDISHWND))    
	{//   idFrom��������HWND                          
		nID = ::GetDlgCtrlID((HWND)nID);     
	}  

	if(nID != 0)   //��Ϊ�ָ���    
	{            //AfxLoadString(nID,   szFullText);            //strTipText=szFullText;            
		strTipText.LoadString(nID);            
		strTipText = strTipText.Mid(strTipText.Find('\n',0)+1);           

#ifndef  _UNICODE            
		if(pNMHDR->code == TTN_NEEDTEXTA)            
		{                  
			lstrcpyn(pTTTA->szText,strTipText,sizeof(pTTTA->szText));            
		}            
		else            
		{                   
			_mbstowcsz(pTTTW->szText,   strTipText,   sizeof(pTTTW->szText));           
		}   
#else            
		if(pNMHDR->code == TTN_NEEDTEXTA)            
		{                   
			_wcstombsz(pTTTA->szText,strTipText,sizeof(pTTTA->szText));            
		}            
		else            
		{                   
			lstrcpyn(pTTTW->szText,strTipText,sizeof(pTTTW->szText));            
		}   
#endif                     
		*pResult   =   0;              //ʹ��������ʾ������������      

		::SetWindowPos(pNMHDR->hwndFrom,HWND_TOP,0,0,0,0, SWP_NOACTIVATE|SWP_NOSIZE|SWP_NOMOVE|SWP_NOOWNERZORDER);   

		return   TRUE;     
	}      
	return   TRUE;   
}   


//���ܣ����õ���վλ��
//���룺����dX��γ��dY���߶�alt
void CGISDlg::SetGCSPosition(const double dX, const double dY, const double alt)
{
	//����վλ��
	g_gcsLon = dX;   //����
	g_gcsLat = dY;   //�
	g_gcsAlt = alt;   //�߶�

	CString str = _T("GCS");

	CString strColor = _T("��ɫ");

	//���ڵ�ͼ����б�ע
	AddPointShapeLayer(m_gcsPtShpLayerID, dX, dY, str, strColor, RGB(255,0,0));
}

//���ܣ�������ʽһ�����������͵���������
void CGISDlg::OnGuideMode1()
{	
	//�жϵ�ͼ�Ƿ��Ѿ����أ�û�м��ط���
	if ( !m_bHaveAddMap )  //û�м��ص�ͼ?
	{
		AfxMessageBox( _T( "���ȼ��ص�ͼ��" ) );
		return;
	}

	m_guidePtInfo.guideMode = 1;

	m_guidePointMode = 1;

	m_bGuideMode = true; //��������ģʽΪ��

	//2023.4.3 JackLiu
	/*
	DrawGuidePoint(1, m_guidePtInfo.guidePtLon, m_guidePtInfo.guidePtLat);
	m_struMapOut.cmd=MapCmd_Guide1;
	m_struMapOut.lon = m_guidePtInfo.guidePtLon;
	m_struMapOut.lat = m_guidePtInfo.guidePtLat;

	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP, (int)(&m_struMapOut),0);*/

	//::PostMessage(HWND_BROADCAST, WM_SEND_GUIDEPOINT_INFO , WPARAM(&m_guidePtInfo) , 1);
	//::PostMessage(m_MsgHwnd, m_MsgID, WPARAM(&m_guidePtInfo)   , 1);
}


//���ܣ�������ʽ�������������͵���������
void CGISDlg::OnGuideMode2()
{
	//�жϵ�ͼ�Ƿ��Ѿ����أ�û�м��ط���
	if ( !m_bHaveAddMap )  //û�м��ص�ͼ?
	{
		AfxMessageBox( _T( "���ȼ��ص�ͼ��" ) );
		return;
	}

	m_guidePtInfo.guideMode = 2;

	m_guidePointMode = 2;

	m_bGuideMode = true; //��������ģʽΪ��

	//2023.4.3 JackLiu

	/*DrawGuidePoint(2,m_guidePtInfo.guidePtLon, m_guidePtInfo.guidePtLat);
	m_struMapOut.cmd=MapCmd_Guide2;
	m_struMapOut.lon = m_guidePtInfo.guidePtLon;
	m_struMapOut.lat = m_guidePtInfo.guidePtLat;

	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP, (int)(&m_struMapOut),0);*/

	//::PostMessage(m_MsgHwnd, m_MsgID, WPARAM(&m_guidePtInfo) , 2);

	//::PostMessage(HWND_BROADCAST, WM_SEND_GUIDEPOINT_INFO , WPARAM(&m_guidePtInfo) , 2);
}

//���ܣ���ʾ1�ź���
void CGISDlg::OnShowLine1()
{
	SetFlyLineShowStatus(1);
}	

//���ܣ���ʾ2�ź���
void CGISDlg::OnShowLine2()
{
	SetFlyLineShowStatus(2);
}	

//���ܣ���ʾ3�ź���
void CGISDlg::OnShowLine3()
{
	SetFlyLineShowStatus(3);
}	
//���ܣ���ʾ4�ź���
void CGISDlg::OnShowLine4()
{
	SetFlyLineShowStatus(4);
}	
//���ܣ���ʾ5�ź���
void CGISDlg::OnShowLine5()
{
	SetFlyLineShowStatus(5);
}
//���ܣ���ʾ6�ź���
void CGISDlg::OnShowLine6()
{
	SetFlyLineShowStatus(6);
}
//���ܣ���ʾ7�ź���
void CGISDlg::OnShowLine7()
{
	SetFlyLineShowStatus(7);
}
//���ܣ���ʾ8�ź���
void CGISDlg::OnShowLine8()
{
	SetFlyLineShowStatus(8);
}
//���ܣ���ʾ9�ź���
void CGISDlg::OnShowLine9()
{
	SetFlyLineShowStatus(9);
}
//���ܣ���ʾ10�ź���
void CGISDlg::OnShowLine10()
{
	SetFlyLineShowStatus(10);
}

//���ܣ�����Ѿ����ĺ���
//���룺���߱��lineID����0��ʼ����
void CGISDlg::ClearDrawedLine(const int lineID)
{
	if (m_pHaveDrawLineFlag[lineID])
	{
		//������ĵ�ʸ��ͼ��
		ClearPointShape(m_ppPlanLineShpLayerIDArr[lineID][0]);

		//����Ѿ����ĺ���
		m_map.RemoveLayer(m_ppPlanLineShpLayerIDArr[lineID][1]);

		m_pHaveDrawLineFlag[lineID] = false;
	}
}

//���ܣ�������ݲ˵��뺽����ʾ��صIJ���
//      1)�����Ѿ���ע�������ʾ
//      2)����δ��ע��������ʾ
//���룺���߱��lineID
void CGISDlg::SetFlyLineShowStatus(const int lineID)
{
	int lineIndex = lineID - 1;

	//�Ѿ���棬�������
	if (m_pHaveDrawLineFlag[lineIndex])
	{
		//��������
		ClearDrawedLine(lineIndex);

		//ˢ��
		m_map.Redraw();

		//��ʶ��false
		m_pHaveDrawLineFlag[lineIndex] = false;
	}
	else
	{

		TCHAR filter[500]=_T("�����ļ�(*.txt)\0*.txt\0��");
		
		CFileDialog LineRouteDlg(TRUE, NULL, NULL, OFN_HIDEREADONLY, filter, NULL);
		/*LineRouteDlg.m_ofn.lpstrInitialDir = strRouteFileDir;*/
		LineRouteDlg.m_ofn.lpstrFilter="txt(*.txt)\0*.txt"; 
		LineRouteDlg.m_ofn.lpstrTitle = "ѡ����ʾ�������ɵĺ���";
		if (LineRouteDlg.DoModal() == IDOK)  //�û�����OK��ť��ֹ�Ի���ķ���ֵ
		{
			CString str = LineRouteDlg.GetPathName();   //��ȡ�ļ�·����
			OnShowGivenLine(str/*GetFlyLineName(lineID)*/);
			
		}
		
		
	}
}

void CGISDlg::OnUpdateLineDisplay1( CCmdUI *pCmdUI )
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[0]);                                //��1�ź���ѡ�к󣬴��ϼǺ�
}

void CGISDlg::OnUpdateLineDisplay2( CCmdUI *pCmdUI )
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[1]);
}

void CGISDlg::OnUpdateLineDisplay3( CCmdUI *pCmdUI )
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[2]);
}

void CGISDlg::OnUpdateLineDisplay4( CCmdUI *pCmdUI )
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[3]);
}

void CGISDlg::OnUpdateLineDisplay5( CCmdUI *pCmdUI )
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[4]);
}

void CGISDlg::OnUpdateShowLine6(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[5]);
}

void CGISDlg::OnUpdateShowLine7(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[6]);
}


void CGISDlg::OnUpdateShowLine8(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[7]);
}

void CGISDlg::OnUpdateShowLine9(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[8]);
}

void CGISDlg::OnUpdateShowLine10(CCmdUI *pCmdUI)
{
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[9]);
}

//���ܣ���ʾ����
//���룺�����ļ�����strLineFileName
void CGISDlg::OnShowGivenLine(const CString strLineFileName)
{
	//�жϵ�ͼ�Ƿ��Ѿ����أ�û�м��ط���
	if ( !m_bHaveAddMap )  //û�м��ص�ͼ?
	{
		BCGPMessageBox( _T( "���ȼ��ص�ͼ��" ) );
		return;
	}
	if (_T("") == strLineFileName)
	{
		return;
	}

	//�ж��ļ��Ƿ����
	if (!SearchDirectory(strLineFileName))
	{
		BCGPMessageBox( _T( "��·�ļ������ڣ�" ) );
		return;
	}

	//�������ݼ���
	DrawLineDataStruct lineDataGroup;

	//��ʼ��
	memset(&lineDataGroup, 0, sizeof(DrawLineDataStruct));

	//�����ļ���ȡ�ɹ�
	if (m_lineManage.ReadLineDataFromFile(lineDataGroup, strLineFileName))
	{
		//�жϺ��ߺ��Ƿ���ȷ��lineIDȡֵ1-8,10-11,13����add by jackwong 2018.08.01��
		if(lineDataGroup.lineID<1 || /*(*/lineDataGroup.lineID>14 /*&& lineDataGroup.lineID<10)*/ /*|| lineDataGroup.lineID==14 *//*|| lineDataGroup.lineID>13*/)
		{
			BCGPMessageBox("���ߺŲ���ȷ��");
			return;
		}
		/*******************by Wu 2023.09.14****************************/
		m_ShowedLineDataList[lineDataGroup.lineID] = lineDataGroup;

		if (lineDataGroup.lineID==11) //���պ���  �洢�����������ڱ༭
		{
			//��ʼ��
			//memset(&backLineDataGroup, 0, sizeof(DrawLineDataStruct));
			backLineDataGroup = lineDataGroup;

			//Σ�յ��ε���
			ClearDangerousTerrainPoints();
			double height = backLineDataGroup.linePts[0].nH;
			double pts[128][2];
			for (int i=0;i<backLineDataGroup.linePointNum;i++)
			{
				pts[i][0] = backLineDataGroup.linePts[i].dX;
				pts[i][1] = backLineDataGroup.linePts[i].dY;
			}
			DrawDangerousTerrainPoints(pts,backLineDataGroup.linePointNum,height);
		}
		/**********************************************************************************/

		//��������
		ClearDrawedLine(lineDataGroup.lineID-1);

		//��溽��
     	DrawFlyLine(lineDataGroup);	
	}
}

//���ܣ���浼����λ��
//���룺����������guideMode��1Ϊ��������1,2Ϊ��������2��������dX��γ��dY
void CGISDlg::DrawGuidePoint(const BYTE guideMode, const double dX, const double dY)
{
	CString str = _T("");

	if (guideMode == 1)    //������1
	{ 
		str = _T("GuidePoint1");
	}
	else if (guideMode == 2)    //������2
	{
		str = _T("GuidePoint2");
	}

	CString strColor = _T("��ɫ");

	//���ڵ�ͼ����б�ע
	AddPointShapeLayer(m_guidePtShpLayerID, dX, dY, str, strColor, RGB(255,0,0));
}


//���ܣ����ڵ�ʸ��ͼ����Ŀ���
//���룺��ͼ������drawLayerID
//		�����꣬����dX, γ��dY
//      ������strPtName    
//      �����ɫstrColor
//      ���������ɫ��ֵfontColor
void CGISDlg::AddPointShapeLayer(long &drawLayerID, const double dX, const double dY, const CString strPtName, const CString strColor, unsigned long fontColor)
{
	//�жϵ�ʸ��ͼ���Ƿ��Ѿ����ڣ�������ɾ��
	if (drawLayerID != -1)
	{
		//������ĵ�ʸ��ͼ��
		ClearPointShape(drawLayerID);
	}

	///////////////////////////////////�½���ʸ��ͼ�����Ŀ��///////////////////////////////////
	//������ͼ��
	//CreateEmptyShapfile(drawLayerID, 0, RGB(0,255,0));
	CreateEmptyShapfile(drawLayerID, 0, fontColor);

	PtStruct pointDataArr[1];
	pointDataArr[0].dX = dX;
	pointDataArr[0].dY = dY;

	//���ͼ����뺽������
	AddPoints2PointShapfile(drawLayerID, pointDataArr, 1);

	/////////////////////��SHPͼ���м���Ŀ����ע��Ϣ///////////////////////////////

	//Label����
	CLabels labesPtr;
	CShapefile shp = m_map.GetShapefile(drawLayerID);
	labesPtr = (m_map.GetShapefile(drawLayerID)).GetLabels();

	labesPtr.SetFontColor(fontColor);
	labesPtr.SetAlignment(1);
	labesPtr.SetFontBold(TRUE);
	labesPtr.SetFontName(_T("Times New Roman"));
	labesPtr.SetFontSize(11);
	labesPtr.put_FontSize2(11);
	labesPtr.SetFrameVisible(false);

/*
	CLabelCategory labelCategory = labesPtr.AddCategory(strColor);
	labelCategory.SetFontColor(fontColor);
	labelCategory.SetAlignment(1);
	labelCategory.SetFontBold(TRUE);
	labelCategory.SetFontName(_T("Times New Roman"));
	labelCategory.SetFontSize(11);
	labelCategory.SetFrameVisible(false);*/

	//����Labels
	labesPtr.AddLabel((LPCTSTR)strPtName, dX, dY, 0, 0);

	/////////////////////��SHPͼ���м���Ŀ����ע��Ϣ///////////////////////////////

	//���»���
	m_map.Redraw();
}


//���ܣ������ͼ���ע��Ϣ
//���룺��ͼ��ID��layerID
void CGISDlg::ClearPointShape(long layerID)
{
	if (layerID == -1)
	{
		return;
	}
	CLabels labesPtr;
	CShapefile sf = m_map.GetShapefile(layerID);
	if (sf)
	{
		labesPtr = sf.GetLabels();
		//�����ע��Ϣ
		labesPtr.RemoveCategory(0);
		labesPtr.Clear();		

		//����Ѿ����ĺ���
		m_map.RemoveLayer(layerID);
	}
	//labesPtr = (m_map.GetShapefile(layerID)).GetLabels();

	
}

LRESULT CGISDlg::OnCheckFlyLineShowStatus(WPARAM wParam, LPARAM lParam)
{
	//���߱��
	int lineIndex = wParam-1;

	if (m_pHaveDrawLineFlag[lineIndex])
	{
		//��������
		ClearDrawedLine(lineIndex);

		//ˢ��
		m_map.Redraw();

		//��ʶ��false
		m_pHaveDrawLineFlag[lineIndex] = false;
	}

	return 0;

}

// ���ܣ����÷��͵�����ʽ��Ϣ���;������Ϣ��
void CGISDlg::SetMsgInfo(const HWND hwnd, const UINT msgID)
{
	m_MsgHwnd = hwnd;
	m_MsgID  = msgID;
}

// ���ܣ����ú���װ����Ϣ���;������Ϣ��
void CGISDlg::SetLoadLineMsgInfo(const HWND hwnd, const UINT msgID)
{
	m_MsgHwnd = hwnd;
	m_LineLoadMsgID  = msgID;
}

//���ܣ��ж�����Ƿ�ѡ�к���
//���룺��������curpoint���������������x��y
//����ֵ��true�������ѡ�к���
//        false�������δѡ�к���
bool CGISDlg::BeMouseClickedLinePoint(const PtStruct curpoint, const long x, const long y)
{
	CRect rc;

	double ptPixelX = 0;
	double ptPixelY = 0;

	//��������ת����������
	m_map.ProjToPixel(curpoint.dX, curpoint.dY, &ptPixelX, &ptPixelY);

	rc.left	= static_cast<long>(ptPixelX - 20);
	rc.top	= static_cast<long>(ptPixelY - 20);
	rc.right = static_cast<long>(ptPixelX + 20);
	rc.bottom = static_cast<long>(ptPixelY + 20);

	CPoint xy;
	xy.x = x;
	xy.y = y;

	if(rc.PtInRect(xy))
	{
		return true;
	}

	return false;
}

void CGISDlg::MouseUpMap1(short Button, short Shift, long x, long y) 
{
	m_iPtSel=-1;

}

//���ܣ��Ƿ�����Զ�����
void CGISDlg::OnAutoMove()
{
	if (m_bAutoMove)
	{
		m_bAutoMove = false;
	}
	else
	{
		m_bAutoMove = true;
	}


}

void CGISDlg::OnDesignLine()             //�������
{

	if (m_bHaveAddMap)
	{
		//�Ѿ����ں������״̬ʱ������
		if (m_bLineDesign)
		{
			return;
		}
		else
		{
			m_bLineDesign = true;

			// 			//��Ƶ�һ������
			// 			m_bDesignFirstPoint = true;
		}

		// 		//������еĺ�������
		// 		m_pFlyLineDesign->ClearCurrentData();
		// 		
		// 		//��ʾ������ƶԻ���	
		// 		m_pFlyLineDesign->ShowWindow(SW_SHOW);
		// 		
		// 		//��ʾ����
		// 		m_pLineSectDlg->ShowWindow(SW_SHOW);
		// 		
		// 		//�������Ϊ��ѡ����ʽ
		// 		m_map.SetCursorMode(3);
	}
	else
	{
		BCGPMessageBox(_T("���ȼ��ص�ͼ���ݣ�"));
	}	


	if(m_bLineDesign  ==  false)
	{

		m_bLineDesign=true;        //�������ģʽ����
	}

}

void CGISDlg::OnData()
{
	AfxMessageBox("this is test!!!");
}



void CGISDlg::OnUpdateAutoMov( CCmdUI *pCmdUI )
{
	pCmdUI->SetCheck(m_bAutoMove);
}


//���ܣ������յ�λ��
//���룺����������callbackMode��1Ϊ���յ�1��2Ϊ���յ�2��������dX��γ��dY
void CGISDlg::DrawCallBackPoint(const BYTE callbackMode, const double dX, const double dY)
{
	//û�м��ص�ͼ
	if (!m_bHaveAddMap)
	{
		return;
	}

	if ((callbackMode>255) || (callbackMode<1))
	{
		return;
	}

	CString str;
	str.Format(_T("CallbackPoint%d"), callbackMode);

	//��������ɫ
	CString strColor = _T("��ɫ");

	//���ڵ�ͼ����б�ע
	AddPointShapeLayer(m_pCallBackShapfileID[callbackMode-1], dX, dY, str, strColor, RGB(0,255,0));
}

//���ܣ�ȡ����ͼ�����ĵ�����
void CGISDlg::OnRemoveGuidePtDraw()
{
	//�жϵ�ʸ��ͼ���Ƿ��Ѿ����ڣ�������ɾ��
	if (m_guidePtShpLayerID != -1)
	{
		//������ĵ�ʸ��ͼ��
		ClearPointShape(m_guidePtShpLayerID);

		m_guidePtShpLayerID = -1;
	}

	//������ģʽ
	m_guidePointMode = 0;

	m_bGuideMode = false ;

	//��ʾ��ݲ˵�
	CMenu menu;
	menu.LoadMenuA(IDR_MENU2);
	menu.CheckMenuItem(IDM_GUIDE_FLY1,MF_BYCOMMAND|MF_UNCHECKED);
	menu.CheckMenuItem(IDM_GUIDE_FLY2,MF_BYCOMMAND|MF_UNCHECKED);
	m_map.Redraw();
}

void CGISDlg::OnUpdateGuideMode1( CCmdUI *pCmdUI )
{
	if (m_guidePointMode == 1)
	{
		pCmdUI->SetCheck(1);
	}
	else
	{
		pCmdUI->SetCheck(0);
	}
}


void CGISDlg::OnUpdateGuideMode2( CCmdUI *pCmdUI )
{
	if (m_guidePointMode == 2)
	{
		pCmdUI->SetCheck(1);
	}
	else
	{
		pCmdUI->SetCheck(0);
	}
}

void CGISDlg::OnAddpoint()         //����Ϊ�õ㹤��״̬
{
	// TODO: Add your command handler code here
	m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
	//m_map.SetCursorMode(5);
	m_bSetPointModel=TRUE;
	m_bLineDesign=TRUE;
	m_bPtDel=FALSE;
	m_bPtEdit=FALSE;

	m_bDesignFirstPoint = false;

	//��ƺ���ʱ���������ʾ�ĺ���
	if(m_bLineDesign)
	{
		for(int i=0;i<sizeof(m_pHaveDrawLineFlag) / sizeof(m_pHaveDrawLineFlag[0]);i++)
		{
			if(m_pHaveDrawLineFlag[i])
			{
				m_map.RemoveLayer(m_ppPlanLineShpLayerIDArr[i][1]);
				m_map.RemoveLayer(m_ppPlanLineShpLayerIDArr[i][0]);
			}
		}
	}
	
}

void CGISDlg::OnEnddesign()     //�����༭
{
	// TODO: Add your command handler code here
	
		//m_bEndSetPoint=TRUE;
		m_bSetPointModel=FALSE;
		m_bLineDesign=FALSE;
		m_bPtDel=FALSE;
		m_bPtEdit=FALSE;
		
        m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);

       ///////Save the Designed Line
		if (m_designLinePointNum <= 0)
		{
			return;
		}

		//�����ļ�·��
		CString strFlyLineName = _T("");

		//���߱��
		int designLineID = 0;

		//��·������
		int lineProperty = 0;

		//���߸߶�
		double lineHeight = 1500.0;

		//�պϱ�־
		int designLineCE = 0;

		//��������ѡ��Ի���
		CSetSaveLineID dlg;

		if (dlg.DoModal() == IDOK)
		{
			//��·�ļ���
			strFlyLineName = dlg.m_strFlyLineName;

			//���߱��
			designLineID = dlg.m_designLineID;

			//��·������
			lineProperty = dlg.m_lineProperty;

			//���߸߶�
			lineHeight = dlg.m_LineHgt;

			//�պϱ�־
			if(dlg.m_bClosedLine==0) designLineCE+=2;
		}
		else
		{	
			//δ����ʱ��Ҳ������ѻ��Ƶĺ��ߵĺ����ݣ�add by jackwong 2018.08.01��
			memset(m_pDesignLineStruct, 0, sizeof(PtStruct)*m_lineMaxPointNum);  //��ʼ���½�һ������
			m_designLinePointNum = 0;	
			ClearDrawingInLineDesign();

			return ;
		}

		CString strRouteFileDir = GetSoftwareCurrentDirectory() + _T("\\Route");

		TCHAR s[10000];
		s[0]=0;
		CFileDialog dlgSave(FALSE, _T(".txt"), _T("*.txt"));
		dlgSave.m_ofn.lpstrTitle=_T("���溽���ļ�");
		dlgSave.m_ofn.lpstrFile=s;
		dlgSave.m_ofn.nMaxFile=sizeof(s)/sizeof(TCHAR);

		TCHAR filter[500]=_T("�����ļ�(*.txt)\0*.txt\0");
		dlgSave.m_ofn.lpstrFilter=filter;
		dlgSave.m_ofn.Flags|=OFN_OVERWRITEPROMPT|OFN_HIDEREADONLY|OFN_CREATEPROMPT;
		dlgSave.m_ofn.lpstrInitialDir = strRouteFileDir;
		if (IDOK == dlgSave.DoModal())
		{
			strFlyLineName = dlgSave.GetPathName();	


		////���������
		FILE   *fp = fopen(strFlyLineName, "w" );
		if ( fp == NULL )
		{
			BCGPMessageBox("�����ļ���ʧ�ܣ�����");
		}
		else
		{
			PtStruct pt;
			memset(&pt, 0, sizeof(PtStruct));

			//ԭ������д��
			fprintf(fp, "%d, %d, %lf, %lf, %.2lf, %d, %02X, %02X\n", designLineID, 0, g_gcsLon, g_gcsLat, 0.0, 0, 0, 3);

			//�������㼯������
			for ( int i = 0; i < m_designLinePointNum; i++ )
			{
				pt = m_pDesignLineStruct[i];

				//�������һ���������д���ļ�
				if ( i < (m_designLinePointNum-1))
				{
					fprintf(fp, "%d, %d, %lf, %lf, %.2lf, %d, %02X, %02X\n", designLineID, pt.nPt, pt.dX, pt.dY, lineHeight, pt.nV, pt.ch1, 3);
				}
				else//�����һ����ĺ�����������д���ļ�
				{
					fprintf(fp, "%d, %d, %lf, %lf, %.2lf, %d, %02X, %02X\n", designLineID, pt.nPt, pt.dX, pt.dY, lineHeight, pt.nV, designLineCE/*pt.ch1*/, lineProperty);
				}
			}

			fclose( fp );   

			//��������ɹ��Ի���
			BCGPMessageBox(_T("�����ļ�����ɹ���"));

          }
		}

		memset(m_pDesignLineStruct, 0, sizeof(PtStruct)*m_lineMaxPointNum);  //��ʼ���½�һ������
		m_designLinePointNum = 0;	
		
		
		ClearDrawingInLineDesign();
        int lineIndex =designLineID - 1;
		
		if (m_pHaveDrawLineFlag[lineIndex])
		{
			//��������
			ClearDrawedLine(lineIndex);
			OnShowGivenLine(strFlyLineName/*GetFlyLineName(designLineID)*/);
			//OnShowGivenLine(GetFlyLineName(designLineID));
		}
		else
		{
			OnShowGivenLine(strFlyLineName/*GetFlyLineName(designLineID)*/);
		}
		//�������Ϊ0
}

void CGISDlg::OnClearpoint()         //�������
{
	//m_map.SetCursorMode(5);
	m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
	m_bPtEdit=FALSE;                //�༭
	m_bPtDel=FALSE;                 //ɾ��
	m_bSetPointModel=FALSE;
	m_bLineDesign=TRUE;
	m_bLDSetPoint = FALSE;
	RemoveDesignLineData();
}

void CGISDlg::OnEditProper()    //����
{
	// TODO: �ڴ�����������������
	/*m_map.SetCursorMode(5);
	m_bSetPointModel=FALSE;
	m_bLineDesign=TRUE;
	m_bPtDel=FALSE;
	m_bPtEdit=TRUE;*/
}


void CGISDlg::OnEditpoint()    //�༭
{
	// TODO: �ڴ�����������������
	//m_map.SetCursorMode(5);
	m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
	m_bSetPointModel=FALSE;
	m_bLineDesign=TRUE;
	m_bPtDel=FALSE;
	m_bPtEdit=TRUE;
}


int CGISDlg::GetPtSel(int x,int y)//��ȡ���ѡȡ�ĵ��
{
	int i=0;
	double px=0;
	double py=0;

	int dis=10.0;

	for (i=0;i<m_designLinePointNum;i++)
	{
		//��������ת����������
		m_map.ProjToPixel(m_pDesignLineStruct[i].dX,m_pDesignLineStruct[i].dY, &px, &py);
		if (fabs(px-x)<dis&&fabs(py-y)<dis)
		{
			return i;
		}
	}
	return -1;
}

//���� by Wu 2023.09.14
int CGISDlg::GetPtSel(PtStruct* m_pLinePtStruct,int m_PointNum,int x,int y)
{
	int i=0;
	double px=0;
	double py=0;

	int dis=10.0;

	for (i=0;i<m_PointNum;i++)
	{
		//��������ת����������
		m_map.ProjToPixel(m_pLinePtStruct[i].dX,m_pLinePtStruct[i].dY, &px, &py);
		if (fabs(px-x)<dis&&fabs(py-y)<dis)
		{
			return i;
		}
	}
	return -1;
}

void CGISDlg::OnDelpoint()      //ɾ��
{
	// TODO: �ڴ�����������������
	
    //m_map.SetCursorMode(5);
	m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
	m_bSetPointModel=FALSE;
	m_bLineDesign=TRUE;
	m_bPtDel=TRUE;
	m_bPtEdit=FALSE;
	m_bDesignFirstPoint=true;
}

void CGISDlg::DrawLineDesign()
{
	//����������ʱ�ı�ע��Ϣ
	ClearDrawingInLineDesign();
	//������Ƶĺ�������
	DrawDesignLineData();
}

// ���ܣ��༭���պ���  ------by Wu  2023.09.14
void CGISDlg::OnEditLine()
{
	m_map.SetCursorMode(mapWindow::tkCursorMode::cmNone);
	if (m_lineSelectedID > 0 && m_bSelectFeatureFlag)  //���պ����Ƿ���ʾ
	{
		m_bEditLine = true;

		ClearHighLightLine();
	}
	m_bSelectFeatureFlag = false;
}

//void CGISDlg::OnBindline1()
//{
//	::PostMessage(m_MsgHwnd,m_LineLoadMsgID,1,0);            //���͸�������װ������1
//}
void CGISDlg::OnBindline2()                                  //���͸�������װ������2
{
	// TODO: �ڴ�����������������

	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=2;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
	//::PostMessage(m_MsgHwnd,m_LineLoadMsgID,2,0);  
}

void CGISDlg::OnLoadMyline1()                                //���͸�������װ������1
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=1;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
	//::PostMessage(m_MsgHwnd,m_LineLoadMsgID,1,0);  
}

void CGISDlg::OnBindline3()                                  //���͸�������װ������3
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=3;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
	//::PostMessage(m_MsgHwnd,m_LineLoadMsgID,3,0); 
}

void CGISDlg::OnBindline4()                                  //���͸�������װ������4
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=4;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
    //::PostMessage(m_MsgHwnd,m_LineLoadMsgID,4,0); 
}

void CGISDlg::OnBindline5()                                  //���͸�������װ������5
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=5;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
	//::PostMessage(m_MsgHwnd,m_LineLoadMsgID,5,0); 
}

void CGISDlg::OnBindline6()                  //���͸�������װ������6
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=6;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}

void CGISDlg::OnBindline7()                          //���͸�������װ������7
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=7;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}

void CGISDlg::OnBindline8()                           //���͸�������װ������8
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=8;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}

void CGISDlg::OnBindline9()
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=9;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}

void CGISDlg::OnBindline10()
{
	// TODO: �ڴ�����������������
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=10;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}



void CGISDlg::OnLayermng()                                   //ͼ�����
{
	// TODO: �ڴ�����������������
	m_Layer->ShowWindow(SW_SHOW);

}


void CGISDlg::OnAddgtarget()
{
	// TODO: �ڴ�����������������
}




//void CGISDlg::OnMouseHWheel(UINT nFlags, short zDelta, CPoint pt)
//{
//	// �˹���Ҫ�� Windows Vista ����߰汾��
//	// _WIN32_WINNT ���ű��� >= 0x0600��
//	// TODO: �ڴ�������Ϣ������������/�����Ĭ��ֵ
//
//	CBCGPDialog::OnMouseHWheel(nFlags, zDelta, pt);
//}

void CGISDlg::SetRouteLine(int iLine ,PTLIST *pList)
{

	CString sRouteDir = GetSoftwareCurrentDirectory();
	//2015.11.24
	CString	str;
	str.Format("%d", iLine);
	CString m_sRoute = sRouteDir + _T( "\\route" ) + str + _T( ".txt" );

	//2015.10.24	���Ӷ�ȡ�����ļ�
// 	if (!SearchDirectory(m_sRoute))
// 	{
// 		str = m_sRoute + "���߲�����";
// 		MessageBox(str, "��ͼ");
// 	}
// 
// 	DrawLineDataStruct	CXLineGroup;
// 	m_lineManage.ReadLineDataFromFile(CXLineGroup,m_sRoute);


// 	DrawLineDataStruct	CXLineGroup;
// 	if (m_lineManage.ReadLineDataFromFile(CXLineGroup,m_sRoute))
// 	{
// 		int idNum = m_lineManage.line->GetCount();
// 		//int idNum = CXLineGroup.linePointNum;
// 		POSITION ps = m_lineManage.line->GetHeadPosition();
// 		for (int i = 0; i < idNum; i++)
// 		{
// 			PtStruct pt = m_lineManage.line->GetNext(ps);
// 			pList->AddTail(pt);
// 		}
// 
// 
// 	}
// 	else
// 	{
// 		MessageBox("��·�ļ�����","��ͼ");
// 		pList->RemoveAll();
// 	}

}


//2016.02.19
// LRESULT CGISDlg::DRAW_ZK(WPARAM wParam, LPARAM lParam)
// {
// 	if (!m_bHaveAddMap)
// 	{
// 		return FALSE;
// 	}
// 	tagDRAWZK DrZk = m_DRAWZK;
// 
// 	CString str="";
// 
// 	str.Format("���ߺ�:%02d	���ɾ�:%d	ƫ����:%.2f	�߶ȸ���:%.2f	�ɻ�����:%.2f	����:%.2f\n\
// 			   �����:%02d	��ƫ��:%d	�������:%.2f	���ٸ���:%.2f		�ɻ���λ:%.2f", 
// 			   DrZk.ID_Line, DrZk.Dis_DF, DrZk.Yaw_Offset, DrZk.Heg_GD, DrZk.Dis_Air, DrZk.Heg_GRD,\
// 			   DrZk.ID_Pt, DrZk.Dis_Offset, DrZk.Yaw_GD, DrZk.AirSpeed_GD, DrZk.Azi_Air);
// 
// 
// 	//GetDlgItem( IDC_STATIC_MAPSHOW )->EnableWindow( TRUE );
// 	//GetDlgItem(IDC_STATIC_MAPSHOW)->SetWindowText(str);
// 
// 	return 0;
// }

void CGISDlg::OnNlinedesign()
{
	// TODO: �ڴ�����������������

	m_bLDSetPoint = TRUE;

	m_pLineDesign = new CLineDesign();
	m_pLineDesign->Create(IDD_DLG_LINEDESIGN,this);
	m_pLineDesign->ShowWindow(TRUE);

	if (!m_bHaveShowLineDesign)
	{
		m_bHaveShowLineDesign = true;
		//m_pLineDesign->ShowLonLat(0, 0);
		m_pLineDesign->ShowWindow(SW_SHOW);
	} 
	else
	{
		m_bHaveShowLineDesign = false;
		m_pLineDesign->ShowWindow(SW_HIDE);
	}

}


void CGISDlg::OnUpdateNlinedesign(CCmdUI *pCmdUI)
{
	// TODO: �ڴ�������������û����洦���������
}


BOOL CGISDlg::ReadLine(int iLine,PTLIST *pList)
{
	if (pList==NULL)
	{
		return FALSE;
	}
	else
	{
		pList->RemoveAll();
	}

	if (iLine<1||iLine>14)			//2015.10.12
	{
		return FALSE;
	}
	CString str;
	CString sLineName=GetFlyLineName(iLine);
	if (!SearchDirectory(sLineName))
	{
		str=sLineName+" ���߲�����";
		MessageBox(str,"��ͼ");
		return FALSE;
	}

	CLineManage tpLine;

	if (tpLine.OpenFlyLineFile(sLineName,iLine,true))
	{
		int idNum=tpLine.line.GetCount();
		POSITION ps=tpLine.line.GetHeadPosition();
		for (int i=0;i<idNum;i++)
		{
			PtStruct pt=tpLine.line.GetNext(ps);
			pList->AddTail(pt);
		}
		return TRUE;
	}
	else
	{
		MessageBox("��·�ļ�����!","��ͼ");
		pList->RemoveAll();
		return FALSE;
	}
}

//��ʾ���պ��ߣ�14��
void CGISDlg::OnShowPd10()
{
	// TODO: �ڴ�����������������
	SetFlyLineShowStatus(14);
}


void CGISDlg::OnUpdateShowPd10(CCmdUI *pCmdUI)
{
	// TODO: �ڴ�������������û����洦���������
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[13]);  
}


void CGISDlg::OnShowHs11()
{
	// TODO: �ڴ�����������������
	SetFlyLineShowStatus(11);
}

//Ӧ������ 11
void CGISDlg::OnUpdateShowHs11(CCmdUI *pCmdUI)
{
	// TODO: �ڴ�������������û����洦���������
	pCmdUI->SetCheck(m_pHaveDrawLineFlag[10]);
}


void CGISDlg::OnBindHs11()
{
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=11;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}

//������ 12
void CGISDlg::OnShowTc12()
{
	SetFlyLineShowStatus(12);
}


void CGISDlg::OnBindTc12()
{
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=12;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}


void CGISDlg::OnUpdateShowTc12(CCmdUI *pCmdUI)
{
		pCmdUI->SetCheck(m_pHaveDrawLineFlag[11]);
}

void CGISDlg::OnSize(UINT nType, int cx, int cy)
{
	CBCGPDialog::OnSize(nType, cx, cy);

	// TODO: �ڴ˴�������Ϣ�����������
	if (m_map.GetSafeHwnd())
	{
		CRect rc;
		GetClientRect(&rc);
		rc.top += 35;
		m_map.MoveWindow(rc);
		//RepositionBars(AFX_IDW_CONTROLBAR_FIRST,AFX_IDW_CONTROLBAR_LAST, 0);
	}
	
}

void CGISDlg::On32855()
{
	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=14;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}

void CGISDlg::UpdateDataInfo(int index,const char* key,double value)
{
	switch (index)
	{
	case 0:
		m_infoData.lineID = value;
		break;
	case 1:
		m_infoData.ptID = value;
		break;
	case 2:
		m_infoData.disDF = value;
		break;
	case 3:
		m_infoData.disCP = value;
		break;
	case 4:
		m_infoData.headingGD = value;
		break;
	case 5:
		m_infoData.anglePH = value;
		break;
	case 6:
		m_infoData.heightGD = value;
		break;
	case 7:
		m_infoData.heightPC = value;
		break;
	case 8:
		m_infoData.speedGD = value;
		break;
	case 9:
		m_infoData.heightCG = value;
		break;
	case 10:
		m_infoData.dis = value;
		break;
	case 11:
		m_infoData.heading = value;
		break;
	default:
		break;
	}
	DrawCanvas();
}

//����ͼ����
void CGISDlg::DrawCanvas()
{				
	COLORREF color = RGB(50,235,50);
	//COLORREF colorback= RGB(0,0,0);//�ڵ�
	CRect rec;
	m_map.GetClientRect(&rec);

	const long leftEdge = rec.left;
	const long topEdge = rec.top + 20;
	const int horizonInter = 11;
	const int verticalInter = rec.Height() / 19;

	CLabels labesPtr;
	if(m_canvasLayerID != -1)
	{	
		labesPtr = m_map.GetDrawingLabels(m_canvasLayerID);
		labesPtr.Clear();
		CString str = "";
		
		str.Format(_T("%-s%-d"),_T("�������:"),m_infoData.lineID);		
		labesPtr.AddLabel(str, leftEdge + horizonInter, topEdge + verticalInter * 1, 0, 0);
		str.Format(_T("%-s%-d"),_T("�������:"),m_infoData.ptID);		
		labesPtr.AddLabel(str, leftEdge + horizonInter, topEdge + verticalInter * 2, 0, 0);
		
		str.Format(_T("%-s%-d"),_T("���ɾ���:"),m_infoData.disDF);		
		labesPtr.AddLabel(str, leftEdge + horizonInter, topEdge + verticalInter * 4, 0, 0);
		str.Format(_T("%-s%-.1lf"),_T("��ƫ����:"),m_infoData.disCP);		
		labesPtr.AddLabel(str, leftEdge + horizonInter, topEdge + verticalInter * 5, 0, 0);

		str.Format(_T("%-s%-.1lf"),_T("�������:"),m_infoData.headingGD);
		labesPtr.AddLabel(str, rec.left + horizonInter/* - 11*/, topEdge + verticalInter * 7, 0, 0);
		str.Format(_T("%-s%-.1lf"),_T("ƫ���Ƕ�:"),m_infoData.anglePH);
		labesPtr.AddLabel(str, rec.left + horizonInter/* - 11*/, topEdge + verticalInter * 8, 0, 0);
			
		str.Format(_T("%-s%-.1lf"),_T("�߶�ƫ��:"),m_infoData.heightPC);
		labesPtr.AddLabel(str, rec.left + horizonInter, topEdge + verticalInter * 10, 0, 0);
		str.Format(_T("%-s%-.1lf"),_T("�߶ȸ���:"),m_infoData.heightGD);
		labesPtr.AddLabel(str, rec.left + horizonInter, topEdge + verticalInter * 11, 0, 0);
		
		str.Format(_T("%-s%-.1lf"),_T("���ٸ���:"),m_infoData.speedGD);
		labesPtr.AddLabel(str, rec.left + horizonInter, topEdge + verticalInter * 13, 0, 0);
		str.Format(_T("%-s%-.1lf"),_T("�����:"),m_infoData.heightCG);
		labesPtr.AddLabel(str, rec.left + horizonInter, topEdge + verticalInter * 14, 0, 0);
		
		str.Format(_T("%-s%-.1lf"),_T("�ɻ�����:"),m_infoData.dis);
		labesPtr.AddLabel(str, rec.left + horizonInter, topEdge + verticalInter * 16, 0, 0);
		str.Format(_T("%-s%-.1lf"),_T("�ɻ���λ:"),m_infoData.heading);
		labesPtr.AddLabel(str, rec.left + horizonInter /*- 5*/, topEdge + verticalInter * 17, 0, 0);
	}
	else
	{
		m_canvasLayerID = m_map.NewDrawing(0);
		labesPtr = m_map.GetDrawingLabels(m_canvasLayerID);
		CLabelCategory left = labesPtr.AddCategory(_T(""));
		left.SetFontColor(color);
		left.SetAlignment(2);//0�����У�1 �Ҷ��룬2��ʾ�����
		left.SetOffsetX(0);
		left.SetOffsetY(0);
		left.SetFontBold(true);
		left.SetFontName(LPCTSTR("����"));
		left.SetFontSize(13);
		left.SetFrameBackColor(RGB(0,0,0));
		left.SetFrameVisible(TRUE);
		left.SetFrameTransparency(0);

		CLabelCategory right = labesPtr.AddCategory(_T(""));
		right.SetFontColor(color);
		right.SetAlignment(2);//0���ң�1 ���У�2��ʾ�����
		right.SetOffsetX(0);
		right.SetOffsetY(0);
		right.SetFontBold(true);
		right.SetFontName(LPCTSTR("����"));
		right.SetFontSize(13);
		right.SetFrameBackColor(RGB(0,0,0));
		right.SetFrameVisible(TRUE);
		right.SetFrameTransparency(0);
	}  
	//m_map.Redraw();
}

void CGISDlg::SetLabelCategory(const long& shapeID, int fontSize /*= 12*/, unsigned long fontColor /*= RGB(255,0,0)*/, unsigned long frameBackColor /*= RGB(0,0,0)*/,
	double XOffset/* = 0*/, double YOffset /*= 0*/)
{
	if(shapeID == -1)
		return;

	CLabels labesPtr;
	labesPtr = (m_map.GetShapefile(shapeID)).GetLabels();

	CLabelCategory labelCategory = labesPtr.AddCategory(_T(""));
	labelCategory.SetFontColor(fontColor);
	labelCategory.SetAlignment(1);
	labelCategory.SetOffsetX(XOffset);
	labelCategory.SetOffsetY(YOffset);
	labelCategory.SetFontBold(TRUE);
	labelCategory.SetFontName(LPCTSTR("����"));
	labelCategory.SetFontSize(fontSize);
	labelCategory.SetFrameBackColor(frameBackColor);
	labelCategory.SetFrameVisible(TRUE);
}


void CGISDlg::OnMove(int x, int y)
{
	CBCGPDialog::OnMove(x, y);

	// TODO: �ڴ˴�������Ϣ�����������
	CRect rc;
	GetClientRect(&rc);
	ClientToScreen(&rc);
	/*if (m_pUavSelDlg1->GetSafeHwnd())
	{
	m_pUavSelDlg1->MoveWindow(rc.left,rc.top+10,50,50);
	}
	if (m_pUavSelDlg2->GetSafeHwnd())
	{
	m_pUavSelDlg2->MoveWindow(rc.left+rc.Width()/2-100,rc.top+10,50,50);
	}
	if (m_pUavSelDlg3->GetSafeHwnd())
	{
	m_pUavSelDlg3->MoveWindow(rc.left+rc.Width()-100,rc.top+10,50,50);
	}*/
	
}


BOOL CGISDlg::OnWndMsg(UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult)
{
	// TODO: �ڴ�����ר�ô����/����û���
	return CBCGPDialog::OnWndMsg(message, wParam, lParam, pResult);
}

//�л��ɻ�
afx_msg LRESULT CGISDlg::OnSelUav(WPARAM wParam, LPARAM lParam)
{

	return 0;
}

//���ӵر��
void CGISDlg::OnAddTarget()
{
	// TODO: �ڴ�����������������
	/*if (m_pTargetDlg->GetSafeHwnd())
	{
		ReadTargetIni(false);
		m_pTargetDlg->ShowWindow(SW_SHOW);
	}*/

	m_dlgMarker.ShowWindow(TRUE);
}

void CGISDlg::ReadTargetIni(bool bDraw)
{
	CString m_MapPath;   //Ĭ�ϴ򿪵�ͼ·��
	char lonBuf[255];
	char latBuf[255];
	CString fileName = GetSoftwareCurrentDirectory() + "\\target.ini";
	CString strTarget ;
	for (int i = 1; i < 255 ; i++)
	{
		if (m_pTargetDlg)
		{
			m_pTargetDlg->SetExistFlag(i,false);
		}
		strTarget.Format("%d",i);
		BOOL blon = GetPrivateProfileString(strTarget,"lon",0,lonBuf,20,fileName);
		BOOL blat = GetPrivateProfileString(strTarget,"lat",0,latBuf,20,fileName);
		if (blon&&blat)
		{
			double lon = atof(lonBuf);
			double lat = atof(latBuf);

			if (fabs(lon)>180.0||fabs(lat)>90.0)//���ݷǷ������
			{
				WritePrivateProfileString(strTarget,"lon",NULL, fileName);
				WritePrivateProfileString(strTarget,"lat",NULL, fileName);
				WritePrivateProfileString(strTarget,"alt",NULL, fileName);
				continue;
			} 

			m_targets[i-1].id = i;
			m_targets[i-1].lon = lon;
			m_targets[i-1].lat = lat;

			if (bDraw)
			{
				AddTargetPoint(i,lon,lat);
			}
			if (m_pTargetDlg)
			{
				m_pTargetDlg->SetExistFlag(i,true);
			}
		}
		else
		{
			m_targets[i-1].id = -1;
		}
		
	}
}

afx_msg LRESULT CGISDlg::OnDrawTarget(WPARAM wParam, LPARAM lParam)
{
	if (m_pTargetDlg->GetSafeHwnd())
	{
		int id = 0;
		double lon = 0.0;
		double lat = 0.0;
		double alt = 0.0;
		m_pTargetDlg->GetTargetLLA(id,lon,lat,alt);
		if (id>0&&id<255)
		{
			m_targets[id-1].id = id;
			m_targets[id-1].lon = lon;
			m_targets[id-1].lat = lat;
		}
		
		AddTargetPoint(id,lon,lat);

	}
	return 0;
}


void CGISDlg::OnShowWindow(BOOL bShow, UINT nStatus)
{
	CBCGPDialog::OnShowWindow(bShow, nStatus);

	// TODO: �ڴ˴�������Ϣ�����������
	if(bShow)
	{
		HCURSOR hCur = LoadCursor(NULL,IDC_ARROW);
		::SetCursor(hCur);
		CString dir = "";
		CString fileName = GetSoftwareCurrentDirectory() + "\\map.ini";
		::GetPrivateProfileString("map", "layer","",dir.GetBuffer(256),256, fileName); 
		dir.ReleaseBuffer(256);
		if(!m_bHaveAddMap)
		{
			CFileFind fd;
			if (fd.FindFile(dir))
			{
				Openlocalfile(dir);
			}
			fd.Close();
		}
	}
	
	
	//ReadTargetIni(true);
}

//ɾ��ѡ�е�Ŀ��㣨��Ϊ����ȷ��ͼ���еĵ㣬���Բ���ȫ��ɾ���ٻ��Ʒ�����
void CGISDlg::OnTargetDelete()
{
	// TODO: �ڴ�����������������
	CString strID = "";
	strID.Format("%d",m_targetSelID);
	
	CString fileName = GetSoftwareCurrentDirectory() + "\\target.ini";
	WritePrivateProfileString(strID,"lon",NULL, fileName);
	WritePrivateProfileString(strID,"lat",NULL, fileName);
	WritePrivateProfileString(strID,"alt",NULL, fileName);


	m_map.GetShapefile(m_targetDrawLayerID).EditClear();
	m_map.GetShapefile(m_targetDrawLayerID).GetLabels().Clear();
	ReadTargetIni(true);
	m_map.Redraw();
	m_targetSelID = 0;
}

//�ڵ�ͼ��ѡ��
afx_msg LRESULT CGISDlg::OnSendSelectTarget(WPARAM wParam, LPARAM lParam)
{
	m_bSelectDropPoint = true;

	//�������Ϊ��ѡ����ʽ
	m_map.SetCursorMode(3);

	return 0;
}

//��ʾ��ע��
afx_msg LRESULT CGISDlg::OnShowPointInMap(WPARAM wParam, LPARAM lParam)
{
	if (!m_bHaveAddMap)
	{
		return 0;
	}

	if (0 == m_longGroundID)
	{
		//���ڵ�ͼ����б�ע
		AddPointShapeLayer(m_longGroundID, m_dlgLightRegion.m_dGroundLon, m_dlgLightRegion.m_dGroundLat, _T("GCS(LOS)"), _T("��ɫ"), RGB(255,0,0));
	}
	else
	{
		ClearPointShape(m_longGroundID);

		m_longGroundID = 0;
	}

	return 0;
}

//��ʾ��������
afx_msg LRESULT CGISDlg::OnShowPointVisible(WPARAM wParam, LPARAM lParam)
{
	if (m_visbleCircleLayerID < 0)
	{
		m_gisManager->CreateEmptyAreaShapfile(m_visbleCircleLayerID,RGB(0,255,0),RGB(0,255,0),40); //��ɫ
	}

	for (int i=0;i<360;i++)
	{
		m_gisManager->AddOnePoint2Shapfile(m_visbleCircleLayerID,2,g_structPointVisible[i].lon,g_structPointVisible[i].lat);
	}

	//�������Ϊ��ʱ�������������ʾ
	if (0 == m_map.GetShapefile(m_visbleCircleLayerID).GetShape(0).GetArea())
	{
		m_map.GetShapefile(m_visbleCircleLayerID).EditClear();
	}

	m_map.Redraw();

	/*structPoint *_structPoint = (structPoint*)wParam;

	m_gisManager->AddOnePoint2Shapfile(m_visbleCircleLayerID,2,_structPoint->lon,_structPoint->lat);*/

	return 0;
}

//��ʾ����������
afx_msg LRESULT CGISDlg::OnShowPointNotVisible(WPARAM wParam, LPARAM lParam)
{
	if (m_notVisibleCircleLayerID < 0)
	{
		m_gisManager->CreateEmptyAreaShapfile(m_notVisibleCircleLayerID,RGB(255,0,0),RGB(255,0,0),40); //��ɫ
	}

	for (int i=0;i<722;i++)
	{
		m_gisManager->AddOnePoint2Shapfile(m_notVisibleCircleLayerID,2,g_structPointNotVisible[i].lon,g_structPointNotVisible[i].lat);
	}

	//�������Ϊ��ʱ�������������ʾ
	if (0 == m_map.GetShapefile(m_notVisibleCircleLayerID).GetShape(0).GetArea())
	{
		m_map.GetShapefile(m_notVisibleCircleLayerID).EditClear();
	}

	m_map.Redraw();

	/*structPoint *_structPoint = (structPoint*)wParam;

	m_gisManager->AddOnePoint2Shapfile(m_notVisibleCircleLayerID,2,_structPoint->lon,_structPoint->lat);*/

	return 0;
}

//������������벻�����������ͼ��
afx_msg LRESULT CGISDlg::OnSendClearShape(WPARAM wParam, LPARAM lParam)
{
	if (m_visbleCircleLayerID > 0)
	{
		m_map.GetShapefile(m_visbleCircleLayerID).EditClear();
	}

	if (m_notVisibleCircleLayerID > 0)
	{
		m_map.GetShapefile(m_notVisibleCircleLayerID).EditClear();
	}

	m_map.Redraw();

	return 0;
}

//ʵʱ��ʾ��������
afx_msg LRESULT CGISDlg::OnShowAreaVisible(WPARAM wParam, LPARAM lParam)
{
	if (m_visiRealCircleLayerID < 0)
	{
		m_gisManager->CreateEmptyAreaShapfile(m_visiRealCircleLayerID,RGB(0,255,0),RGB(0,255,0),40); //��ɫ
	}

	for (int i=0;i <= int(wParam);i++)
	{
		m_gisManager->AddOnePoint2Shapfile(m_visiRealCircleLayerID,2,g_structPointVisiReal[i].lon,g_structPointVisiReal[i].lat);
	}

	//�������Ϊ��ʱ�������������ʾ
	if (0 == m_map.GetShapefile(m_visiRealCircleLayerID).GetShape(0).GetArea())
	{
		m_map.GetShapefile(m_visiRealCircleLayerID).EditClear();
	}

	/*double _uavlon,_uavlat;
	CalculatePtCoordinate(_uavlon, _uavlat, m_dlgLightRegion.m_dRealTime_GCSlon, m_dlgLightRegion.m_dRealTime_GCSlat, m_dlgLightRegion.m_dRealTime_AngToGCS, m_dlgLightRegion.m_dRealTime_DisToGCS, 3);

	if (m_RealCircleLayerID < 0)
	{
		m_gisManager->CreateEmptyAreaShapfile(m_RealCircleLayerID,RGB(0,0,255),RGB(0,0,255),40);
	}

	double ptLon, ptLat;
	for (int i = 0; i<=360;i++)
	{
		CalculatePtCoordinate(ptLon, ptLat, _uavlon, _uavlat, i, 2800, 3);

		m_gisManager->AddOnePoint2Shapfile(m_RealCircleLayerID,2,ptLon, ptLat);
	}*/

	m_map.Redraw();

	return 0;
}

//ʵʱ��ʾ����������
afx_msg LRESULT CGISDlg::OnShowAreaNotVisible(WPARAM wParam, LPARAM lParam)
{
	if (m_notVisiRealCircleLayerID < 0)
	{
		m_gisManager->CreateEmptyAreaShapfile(m_notVisiRealCircleLayerID,RGB(255,0,0),RGB(255,0,0),40); //��ɫ
	}

	for (int i=0;i <= int(wParam);i++)
	{
		m_gisManager->AddOnePoint2Shapfile(m_notVisiRealCircleLayerID,2,g_structPointNotVisiReal[i].lon,g_structPointNotVisiReal[i].lat);
	}

	//�������Ϊ��ʱ�������������ʾ
	if (0 == m_map.GetShapefile(m_notVisiRealCircleLayerID).GetShape(0).GetArea())
	{
		m_map.GetShapefile(m_notVisiRealCircleLayerID).EditClear();
	}

	m_map.Redraw();

	return 0;
}

//���ʵʱ����
afx_msg LRESULT CGISDlg::OnShowClearArea(WPARAM wParam, LPARAM lParam)
{
	if (m_visiRealCircleLayerID > 0)
	{
		m_map.GetShapefile(m_visiRealCircleLayerID).EditClear();
	}

	if (m_notVisiRealCircleLayerID > 0)
	{
		m_map.GetShapefile(m_notVisiRealCircleLayerID).EditClear();
	}

	/*if (m_RealCircleLayerID > 0)
	{
		m_map.GetShapefile(m_RealCircleLayerID).EditClear();
	}*/

	m_map.Redraw();

	return 0;
}

//ɾ��ͨ�ӵȸ���ͼ��
afx_msg LRESULT CGISDlg::OnDelLineLayer(WPARAM wParam, LPARAM lParam)
{
	for (int i=0;i<20;i++)
	{
		if (m_longContourLineID[i] > 0)
		{
			m_map.GetShapefile(m_longContourLineID[i]).EditClear();
		}

		m_gisManager->CreateEmptyLineShapfile(m_longContourLineID[i],RGB(0,255,0),1.5); //��ɫ

		if (m_longContourTextID[i] != 0)
		{
			ClearPointShape(m_longContourTextID[i]);
			m_longContourTextID[i] = 0;
		}
	}

	m_map.Redraw();

	return 0;
}

//���ӵ㵽ͨ�ӵȸ���ͼ��
afx_msg LRESULT CGISDlg::OnAddLineLayer(WPARAM wParam, LPARAM lParam)
{
	structPoint *_structPoint = (structPoint*)wParam;

	m_gisManager->AddOnePoint2Shapfile(m_longContourLineID[(int)lParam],1,_structPoint->lon,_structPoint->lat);

	//���߶�
	if (m_longContourTextID[(int)lParam] == 0)
	{
		//��ע
		CString str;
		str.Format(_T("%dm"), (int)lParam * 500);

		//������ͼ��
		CreateEmptyShapfile(m_longContourTextID[(int)lParam], 0, RGB(255,0,0)); //��ɫ

		//Label����
		CLabels labesPtr;
		labesPtr = (m_map.GetShapefile(m_longContourTextID[(int)lParam])).GetLabels();

		CLabelCategory labelCategory = labesPtr.AddCategory(_T("��ɫ"));
		labelCategory.SetFontColor(RGB(255,0,0));
		labelCategory.SetAlignment(1);
		labelCategory.SetFontBold(TRUE);
		labelCategory.SetFontName(_T("����"));
		labelCategory.SetFontSize(11);

		labesPtr.AddLabel(str, _structPoint->lon, _structPoint->lat + 0.0005, 0, 0);
	}

	m_map.Redraw();

	return 0;
}

//�����������GIS�Ի������Ϣ��Ӧ����
afx_msg LRESULT CGISDlg::OnSendRegionToGis(WPARAM wParam, LPARAM lParam)
{
	if (1 == (int)wParam)
	{
		g_bSelectDropPoint = true;

		//�������Ϊ��ѡ����ʽ
		m_map.SetCursorMode(3);
	}
	else if (2 == (int)wParam)
	{
		if (m_longSelectLineID > 0)
		{
			m_map.GetShapefile(m_longSelectLineID).EditClear();
		}

		if (m_longLabelPlotID != 0)
		{
			ClearPointShape(m_longLabelPlotID);
			m_longLabelPlotID = 0;
		}

		m_map.Redraw();
	}
	else if (3 == (int)wParam)
	{
		structPoint *_structPoint = (structPoint*)lParam;

		if (m_longSelectLineID > 0)
		{
			m_map.GetShapefile(m_longSelectLineID).EditClear();
		}

		m_gisManager->CreateEmptyLineShapfile(m_longSelectLineID,RGB(0,255,0),2);
		m_gisManager->AddOnePoint2Shapfile(m_longSelectLineID,1,m_dlgLightRegion.m_dGroundLon,m_dlgLightRegion.m_dGroundLat);
		m_gisManager->AddOnePoint2Shapfile(m_longSelectLineID,1,_structPoint->lon,_structPoint->lat);

		double _distance = 0.0, _angle = 0.0;
		CalculateTwoPtsDistanceAzimuth(_distance, _angle, m_dlgLightRegion.m_dGroundLon,m_dlgLightRegion.m_dGroundLat,_structPoint->lon,_structPoint->lat, 3);

		CString str;
		str.Format(_T("D:%.1fkm  A:%.1f��"), _distance/1000, _angle);

		if (m_longLabelPlotID != 0)
		{
			ClearPointShape(m_longLabelPlotID);
			m_longLabelPlotID = 0;
		}
		//��ע����ͷ�λ
		AddPointShapeLayer(m_longLabelPlotID,_structPoint->lon,_structPoint->lat, str, _T("��ɫ"), RGB(255,0,0));
	}

	return 0;
}

//��溽���ϵĵ�
afx_msg LRESULT CGISDlg::OnDrawLinePoint(WPARAM wParam, LPARAM lParam)
{
	if (m_longLinePointID > 0)
	{
		ClearPointShape(m_longLinePointID);

		m_longLinePointID = 0;
	}

	if (1 == (int)lParam)
	{
		structPoint *_structPoint = (structPoint*)wParam;

		//���ڵ�ͼ����б�ע
		AddPointShapeLayer(m_longLinePointID, _structPoint->lon, _structPoint->lat, _T("Pt"), _T("��ɫ"), RGB(255,0,0));
	}

	return 0;
}

//��ʾʵʱ��ײ�������
afx_msg LRESULT CGISDlg::OnShowCrashArea(WPARAM wParam, LPARAM lParam)
{
	if (1 == (int)wParam)
	{
		if (m_crashAreaLayerID > 0)
		{
			m_map.GetShapefile(m_crashAreaLayerID).EditClear();
		}

		m_gisManager->CreateEmptyAreaShapfile(m_crashAreaLayerID,RGB(0,255,0),RGB(0,255,0),40); //��ɫ

		for (int i=0;i < 360;i++)
		{
			m_gisManager->AddOnePoint2Shapfile(m_crashAreaLayerID,2,g_structPointCrashReal[i].lon,g_structPointCrashReal[i].lat);
		}

		//�������Ϊ��ʱ�������������ʾ
		if (0 == m_map.GetShapefile(m_crashAreaLayerID).GetShape(0).GetArea())
		{
			m_map.GetShapefile(m_crashAreaLayerID).EditClear();
		}

		m_map.Redraw();
	}
	else if (0 == (int)wParam)
	{
		if (m_crashAreaLayerID > 0)
		{
			m_map.GetShapefile(m_crashAreaLayerID).EditClear();
		}

		m_map.Redraw();
	}

	return 0;
}

//�������÷�Χ
afx_msg LRESULT CGISDlg::OnSendDrawFight(WPARAM wParam, LPARAM lParam)
{
	if (m_fightRegionLayerID > 0)
	{
		m_map.GetShapefile(m_fightRegionLayerID).EditClear();

		m_map.Redraw();
	}

	if (0 == (int)lParam)
	{
		return 0;
	}

	m_gisManager->CreateEmptyAreaShapfile(m_fightRegionLayerID,RGB(0,255,0),RGB(0,255,0),20);

	structPoint *_structPoint = (structPoint*)wParam;

	double ptLon,ptLat;
	for (int i=0;i<=360;i++)
	{
		CalculatePtCoordinate(ptLon, ptLat, _structPoint->lon, _structPoint->lat, i, (int)lParam, 3);

		m_gisManager->AddOnePoint2Shapfile(m_fightRegionLayerID,2,ptLon, ptLat);
	}

	m_map.Redraw();

	return 0;
}

//���Ƹ߳�����
afx_msg LRESULT CGISDlg::OnSendDrawDemRegion(WPARAM wParam, LPARAM lParam)
{
	if (m_DemRegionLayerID[(int)lParam] > 0)
	{
		m_map.GetShapefile(m_DemRegionLayerID[(int)lParam]).EditClear();

		m_DemRegionLayerID[(int)lParam] = -1;

		m_map.Redraw();
	}
	else
	{
		m_gisManager->CreateEmptyAreaShapfile(m_DemRegionLayerID[(int)lParam],RGB(0,0,255),RGB(0,0,255),20);

		structPoint *_structPoint = (structPoint*)wParam;

		m_gisManager->AddOnePoint2Shapfile(m_DemRegionLayerID[(int)lParam],2,_structPoint->lon, _structPoint->lat);
		m_gisManager->AddOnePoint2Shapfile(m_DemRegionLayerID[(int)lParam],2,_structPoint->lon + 1, _structPoint->lat);
		m_gisManager->AddOnePoint2Shapfile(m_DemRegionLayerID[(int)lParam],2,_structPoint->lon + 1, _structPoint->lat+1);
		m_gisManager->AddOnePoint2Shapfile(m_DemRegionLayerID[(int)lParam],2,_structPoint->lon, _structPoint->lat+1);
		m_gisManager->AddOnePoint2Shapfile(m_DemRegionLayerID[(int)lParam],2,_structPoint->lon, _structPoint->lat);

		m_map.Redraw();
	}

	return 0;
}

//���ߵ�ͼ��λ
afx_msg LRESULT CGISDlg::OnZoomToLocation(WPARAM wParam, LPARAM lParam)
{
	//double lon = (double)wParam/1000000;
	//double lat = (double)lParam/1000000;
	double* lon = (double*)wParam;
	double* lat = (double*)lParam;
	ZoomToLocation(*lon,*lat);
	return 0;
}

void CGISDlg::OnMenuLightRegion()
{
	/*if (m_dlgLightRegion.GetSafeHwnd())
	{
		m_dlgLightRegion.ShowWindow(TRUE);
	}*/

	g_bDemAnalysising = true;
	g_iDemPointNum = 0;
}

//�رո̷߳����Ի���ʱ
afx_msg LRESULT CGISDlg::OnSendCloseDemAlt(WPARAM wParam, LPARAM lParam)
{
	//����̷߳���ͼ��
	for (int i=0;i<g_iDemAltPtNum;i++)
	{
		m_map.RemoveLayer(g_lDemAltLayerID[i]);
		if (g_lDemAltDisLayerID[i] > 0)
		{
			//������ĵ�ʸ��ͼ��
			ClearPointShape(g_lDemAltDisLayerID[i]);
			g_lDemAltDisLayerID[i] = -1;
		}

		if (g_lDemPtNumLayerID[i] > 0)
		{
			//������ĵ�ʸ��ͼ��
			ClearPointShape(g_lDemPtNumLayerID[i]);
			g_lDemPtNumLayerID[i] = -1;
		}
	}

	return 0;
}

//��������
void CGISDlg::OnMenuEntryPoint()
{
	m_struMapOut.cmd = MapCmd_EntryPoint;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
}

//���߳�����
void CGISDlg::OnMenuPlotdemArea()
{
	if (m_dlgLightRegion.GetSafeHwnd())
	{
		m_dlgLightRegion.OnBnClickedButtonGetDemRegion();
	}

	m_bPlotDemArea = !m_bPlotDemArea;
}

//���ܣ��ı�CursorMode
afx_msg LRESULT CGISDlg::OnSetMapCursorMode(WPARAM wParam, LPARAM lParam)
{
	m_map.SetCursorMode((long)wParam);
	return 0;
}

//���ܣ���ʾ�����ر�ǵ�
afx_msg LRESULT CGISDlg::OnDrawMarker(WPARAM wParam, LPARAM lParam)
{
	if (int(lParam) == 1) //���ر�ǵ�
	{
		if (g_lMarkerLayerID[(int)wParam] >= 0)
		{
			ClearPointShape(g_lMarkerLayerID[(int)wParam]);
			g_lMarkerLayerID[(int)wParam] = -1;
		}

		g_bMarkerPlot[(int)wParam] = false;
	}
	else //��ʾ��ǵ�
	{
		if (g_lMarkerLayerID[(int)wParam] >= 0)
		{
			ClearPointShape(g_lMarkerLayerID[(int)wParam]);
			g_lMarkerLayerID[(int)wParam] = -1;
		}

		//���ڵ�ͼ����б�ע
		AddPointShapeLayer(g_lMarkerLayerID[(int)wParam], g_iMarkerLon[(int)wParam], g_iMarkerLat[(int)wParam], g_iMarkerName[(int)wParam], _T(""), RGB(255,0,0));

		g_bMarkerPlot[(int)wParam] = true;
	}

	return 0;
}

//�������վ���
void CGISDlg::OnMenuClearGCS()
{
	if (m_gcsPtShpLayerID != -1)
	{
		ClearPointShape(m_gcsPtShpLayerID);
		m_gcsPtShpLayerID = -1;
	}
}

//�Ƿ���ʾADS�ɻ���Ϣ
void CGISDlg::OnMenuADSB()
{
	m_bEnableShowADSB = !m_bEnableShowADSB;
}

//�������˻�
LRESULT CGISDlg::OnTimerDrawUAV(WPARAM wParam, LPARAM lParam)
{
	//δ���ص�ͼ������
	if (!m_bHaveAddMap)
	{
		return 0;
	}

	if (!m_bEnableShowADSB)
	{
		//�������ADS�ɻ��ı��ͼ��
		for(int i=0;i<MAX_PLANE_NUM_ADS;i++)
		{
			if (m_UAVFlyTrackLayerID_ADS[i] != -1)
			{
				//m_map.ClearLabels(m_UAVFlyTrackLayerID_ADS[i]);
				//m_map.ClearDrawing(m_UAVFlyTrackLayerID_ADS[i]);
				m_map.RemoveLayer(m_UAVFlyTrackLayerID_ADS[i]);
				m_UAVFlyTrackLayerID_ADS[i] = -1;
			}
		}

		return 0;
	}

	if (m_iTotalADSnum <= 0)
	{
		return 0;
	}

	if (m_iCurrentADSid < (m_iTotalADSnum - 1))
	{
		m_iCurrentADSid++;
	}
	else
	{
		m_iCurrentADSid = 0;
	}

	static int _ADSidRecord = 0;

	_ADSidRecord = m_iCurrentADSid;

	//whileѭ����ֱ��ij��ADS�ɻ����״̬ΪҪ��棬����ѭ��
	while (m_bWithin100km_ADS[m_iCurrentADSid] == false)
	{
		//���ADS�ɻ�������
		if (m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid] != -1)
		{
			//m_map.ClearLabels(m_UAVFlyTrackLayerID_ADS[i]);
			//m_map.ClearDrawing(m_UAVFlyTrackLayerID_ADS[i]);
			m_map.RemoveLayer(m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid]);
			m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid] = -1;
		}

		TRACE("Remove: %d/%d\n", m_iCurrentADSid, _ADSidRecord);

		if (m_iCurrentADSid < (m_iTotalADSnum - 1))
		{
			m_iCurrentADSid++;
		}
		else
		{
			m_iCurrentADSid = 0;
		}

		//���ٴ�ѭ��������ʱ������ѭ��
		if (m_iCurrentADSid == _ADSidRecord)
		{
			TRACE("return");
			return 0;
		}
	}

	TRACE("ID: %d/%d\n", m_iCurrentADSid, m_iTotalADSnum);

	if (m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid] != -1) //�Ѿ�����˻���
	{
		//m_map.ClearLabels(m_UAVFlyTrackLayerID_ADS[i]);
		//m_map.ClearDrawing(m_UAVFlyTrackLayerID_ADS[i]);
		m_map.RemoveLayer(m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid]);
		m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid] = -1;
	}

	//�������˻�������ͼ��
	CreateEmptyShapfile(m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid], 2, RGB(0,255,0));

	//���������˻���ͼ��ĵ�����
	CalculateUAVPolygonCoordinate_ADS(m_dLon_ADS[m_iCurrentADSid], m_dLat_ADS[m_iCurrentADSid], m_dYaw_ADS[m_iCurrentADSid]);
	
	//�����µ����˻�shp
	for (int i=0; i<m_ptNum; i++)
	{
		AddOnePoint2Shapfile(m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid], 2, m_ppUavPtArray_ADS[i][0], m_ppUavPtArray_ADS[i][1]);
	}

	//Label����
	CLabels labesPtr;
	labesPtr = (m_map.GetShapefile(m_UAVFlyTrackLayerID_ADS[m_iCurrentADSid])).GetLabels();

	//���ñ�ע̫��ʱ�Ƿ��Զ�����
	labesPtr.SetAvoidCollisions(FALSE);

	CLabelCategory labelCategory = labesPtr.AddCategory(m_strColor_ADS[m_iCurrentADSid]);
	labelCategory.SetFontColor(m_fontColor_ADS[m_iCurrentADSid]);
	labelCategory.SetAlignment(1);
	//labelCategory.SetFontBold(TRUE);
	labelCategory.SetFontName(LPCTSTR("΢���ź�"));
	labelCategory.SetFontSize(8);

	//����Labels
	labesPtr.AddLabel((LPCTSTR)m_strPlaneName_ADS[m_iCurrentADSid], m_dLon_ADS[m_iCurrentADSid], m_dLat_ADS[m_iCurrentADSid], 0, 0);

	//�ػ�
	m_map.Redraw();
}


/*************************************by wu 2023.10.10**********************************************/
//���ܣ���ע��Ͷ��
LRESULT CGISDlg::OnDrawKTPoint(WPARAM wParam, LPARAM lParam)
{
	//û�м��ص�ͼ������
	if (!m_bHaveAddMap)
	{
		return 0;
	}

	double* lon = (double*) wParam;
	double* lat = (double*) lParam;

	CString strLon,strLat;
	strLon.Format(_T("%.7f"),*lon);
	strLat.Format(_T("%.7f"),*lat);

	AddPointShapeLayer(m_KTPtShpLayerID, *lon, *lat, (strLon+", "+strLat), _T(""), RGB(255,0,0));

	return 0;
}

//���ܣ������Ͷ��
LRESULT CGISDlg::OnClearKTPoint(WPARAM wParam, LPARAM lParam)
{
	ClearPointShape(m_KTPtShpLayerID);
	m_KTPtShpLayerID = -1;

	return 0;
}

//���ܣ���ʾ��Ͷ����
LRESULT CGISDlg::OnShowKTLine(WPARAM wParam, LPARAM lParam)
{
	CString path = (char*)wParam;
	OnShowGivenLine(path);

	return 0;
}

//���ܣ���ʾ/�رտ�Ͷ����
LRESULT CGISDlg::OnShowKTLine6(WPARAM wParam, LPARAM lParam)
{
	OnShowLine6();

	return 0;
}

//���ܣ�װ����Ͷ����
LRESULT CGISDlg::OnBindKTLine(WPARAM wParam, LPARAM lParam)                                  //���͸�������װ������2
{
	// TODO: �ڴ�����������������

	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=6;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
	//::PostMessage(m_MsgHwnd,m_LineLoadMsgID,2,0);  
	return 0;
}

//���ܣ�װ��Ӧ����
LRESULT CGISDlg::OnBindEPPoint(WPARAM wParam, LPARAM lParam)                                  //���͸�������װ������2
{
	// TODO: �ڴ�����������������

	m_struMapOut.cmd=MapCmd_BindLine;
	m_struMapOut.ID=15;
	::SendMessage(GetParent()->GetSafeHwnd(),MESSAGE_B8MAP,(int)(&m_struMapOut),0);
	//::PostMessage(m_MsgHwnd,m_LineLoadMsgID,2,0);  
	return 0;
}

/* ���ܣ���ȡ�з��յĵ��ε�
 * ������alt[in] �߶���ֵ
 *		vec_alt[out] ������ֵ�ĸ߶�ֵ
		vec_lon[out] ����
		vec_lat[out] �
*/
void CGISDlg::GetDangerousTerrainPoints(double pts[][2],int pointNum,long alt,vector<double>& vec_alt,vector<double>& vec_lon,vector<double>& vec_lat)
{
	//��ȡ����դ����
	mapWindow::IGridHeaderPtr gridHeaderPtr = m_mapElevation.m_grid->GetHeader();
	int n_gridrow = gridHeaderPtr->NumberRows;
	int n_gridcol = gridHeaderPtr->NumberCols;

	//����γ������ת��Ϊդ�����к�
	vector<int> pts_row,pts_col;
	TransformToXY(pts,pointNum,pts_row,pts_col);
	//��դ��
	VectorToRaster vectorToRaster;
	set<vector<int> > resultSet = vectorToRaster.GetRasterLineEx(pts_row,pts_col,n_gridrow-1,n_gridcol-1,1);

	double lat,lon;
	//��ȡΣ�յ�
	for (auto it = resultSet.begin();it!=resultSet.end();it++)
	{
		vector<int> pt = *it;
		int altValue = m_mapElevation.m_grid->GetValue(pt.at(1),pt.at(0));
		if (altValue>=alt) //Σ�յ㱣��
		{
			vec_alt.push_back(altValue);
			//ת��Ϊ��γ��
			m_mapElevation.m_grid->CellToProj(pt.at(1),pt.at(0),&lon,&lat);
			vec_lon.push_back(lon);
			vec_lat.push_back(lat);
			//int i = 0;
		}
	}
}

//���Σ�յ��ε�
int CGISDlg::DrawDangerousTerrainPoints(double pts[][2],int pointNum,long alt)
{
	/*
	double lon[] = {119.711715,119.738307,119.738553,119.711715};
	double lat[] = {32.201856,32.239036,32.178465,32.141285};
	double pts[6][2];
	long shpPointLayerID = -1;
	long shpLineLayerID = -1;
	//vector<double> vec_lon,vec_lat;
	for(int i=0;i<4;i++)
	{
		pts[i][0] = lon[i];
		pts[i][1] = lat[i];
	}
	*/

	if(!m_mapElevation.m_isAdd)
	{
		//BCGPMessageBox("δ���Ӹ߳���Ϣ���޷��жϵ�ǰ���պ����Ƿ�ȫ!");                       
		return 0;
	}

	vector<double> vec_alt;
	vector<double> vec_lon;
	vector<double> vec_lat;
	GetDangerousTerrainPoints(pts,pointNum,alt,vec_alt, vec_lon, vec_lat);

	if (vec_alt.size()==0)
	{
		return -1;
	}

	//�½���ʱ���ͼ��
	if (m_tempTerrainPointsLayerID==-1)
	{
		m_tempTerrainPointsLayerID = m_map.NewDrawing(1);
	}
	//m_map.SetShapePointType(m_tempLayerID,0,mapWindow::tkPointType::ptTriangleUp);
	m_map.SetShapeLayerPointType(m_tempTerrainPointsLayerID,mapWindow::tkPointType::ptTriangleUp);
	CLabels labels = m_map.GetDrawingLabels(m_tempTerrainPointsLayerID);
	//labels.SetAutoOffset(true);
	labels.SetFontColor(RGB(0,255,0));
	labels.SetFontSize(8);
	labels.SetFontBold(true);
	labels.SetOffsetY(-10);

	for (int i=0;i<vec_lon.size();i++)
	{
		/*
		std::stringstream stream;
		stream << std::setprecision(2) << vec_alt.at(i);
		std::string alt = stream.str();
		labels.AddLabel(alt.c_str(),vec_lon.at(i),vec_lat.at(i),0,0);
		*/
		m_map.DrawPointEx(m_tempTerrainPointsLayerID,vec_lon.at(i),vec_lat.at(i),8,RGB(255,0,0));
		//m_map.DrawCircleEx(m_tempLayerID,vec_lon.at(i),vec_lat.at(i),3,RGB(255,0,0),true);
	}
	m_map.Redraw();

	return 1;
}

//���Σ�յ��ε�
void CGISDlg::ClearDangerousTerrainPoints()
{
	if (m_tempTerrainPointsLayerID!=-1)
	{
		m_map.ClearDrawing(m_tempTerrainPointsLayerID);
		m_tempTerrainPointsLayerID = -1;
		m_map.Redraw();
	}
}

// ������ʱ��
void CGISDlg::DrawTempLine(double m_Pts[][2],int pointNum)
{
	//int pointNum = 6;
	PtStruct pts[128];
	PtStruct linePts[128];
	for(int i=0;i<pointNum;i++)
	{
		pts[i].dX = m_Pts[i][0];
		pts[i].dY = m_Pts[i][1];

		linePts[i].dX = m_Pts[i][0];
		linePts[i].dY = m_Pts[i][1];
	}
	linePts[pointNum].dX = m_Pts[0][0];
	linePts[pointNum].dY = m_Pts[0][1];

	//Ŀ����SHPͼ��
	if(m_tempshpPointLayerID == -1)
	{
		CreateEmptyShapfile(m_tempshpPointLayerID,0,LineClr[10]);
	}
	AddPoints2PointShapfile(m_tempshpPointLayerID,pts,pointNum);
	
	//Ŀ����SHPͼ��
	if(m_tempshpLineLayerID == -1)
	{
		CreateEmptyShapfile(m_tempshpLineLayerID,1,LineClr[10]);
	}
	AddPoints2LineShapfile(m_tempshpLineLayerID,linePts,pointNum+1);

	//Label����
	CLabels labesPtr;
	labesPtr = m_map.GetShapefile(m_tempshpLineLayerID).GetLabels();

	CLabelCategory labelCategory = labesPtr.AddCategory(_T("��ɫ"));
	labelCategory.SetFontColor(/*RGB(255,0,0)*/LineClr[10]);
	labelCategory.SetAlignment(1);
	labelCategory.SetFontBold(TRUE);
	labelCategory.SetFontName(LPCTSTR("����"));
	labelCategory.SetFontSize(12);
	labesPtr.SetAvoidCollisions(FALSE);

	CString strText = _T("");
	//��溽�������
	for (long i=0; i<pointNum; i++)
	{
		//��ע��Ϣ
		//strText.Format(_T("%d-%d"), lineData.lineID,  lineData.pts[i].nPt);
		strText.Format(_T("%d"), i+1);
		//����Labels
		labesPtr.AddLabel((LPCTSTR)strText, pts[i].dX, pts[i].dY, 0, 0);
	}	

	m_map.Redraw();
}

//����ѡ�и���ͼ��
void CGISDlg::DrawHighLightLine(const PtStruct *pts, const int ptNum)
{
	if (m_highLightLineLayerID==-1)
	{
		//Ŀ����SHPͼ��
		mapWindow::IShapefilePtr targetPtShape;
		targetPtShape.CreateInstance("MapWinGIS.Shapefile");	

		targetPtShape->CreateNewWithShapeID(_T(""), mapWindow::SHP_POLYLINE);
		//Ŀ����ͼ������ͼ��
		m_highLightLineLayerID = m_map.AddLayer(targetPtShape, true);

		mapWindow::IShapeDrawingOptionsPtr  pShapeDrawingOption;
		pShapeDrawingOption.CreateInstance("MapWinGIS.ShapeDrawingOptions");

		pShapeDrawingOption->LineColor = RGB(242,155,41);
		pShapeDrawingOption->LineWidth = 2;

		(m_map.GetShapefile(m_highLightLineLayerID)).SetDefaultDrawingOptions(pShapeDrawingOption);
	}

	AddPoints2LineShapfile(m_highLightLineLayerID,pts,ptNum);

	m_map.Redraw();
}

//�����ʱ��
void CGISDlg::ClearTempLine()
{
	if (m_tempshpPointLayerID!=-1)
	{
		m_map.RemoveLayer(m_tempshpPointLayerID);
		m_tempshpPointLayerID = -1;
		m_map.GetShapefile(m_tempshpPointLayerID).Close();
	}

	if(m_tempshpLineLayerID!=-1)
	{
		m_map.RemoveLayer(m_tempshpLineLayerID);
		m_tempshpLineLayerID = -1;
		m_map.GetShapefile(m_tempshpLineLayerID).Close();
	}
}

//���������
void CGISDlg::ClearHighLightLine()
{
	if (m_highLightLineLayerID!=-1)
	{
		m_map.RemoveLayer(m_highLightLineLayerID);
		m_highLightLineLayerID = -1;
		m_map.GetShapefile(m_highLightLineLayerID).Close();
	}
}

//ת��ΪGrid����
void CGISDlg::TransformToXY(double pts[][2],int pointNum,vector<int>& ptsRow,vector<int>& ptsCol)
{
	mapWindow::IGridHeaderPtr gridHeaderPtr = m_mapElevation.m_grid->GetHeader();
	int n_gridrow = gridHeaderPtr->NumberRows;
	int n_gridcol = gridHeaderPtr->NumberCols;

	long col1[1],col2[1],col3[1],col4[1];
	long row1[1],row2[1],row3[1],row4[1];
	long col,row;
	for (int i=0;i<pointNum;i++)
	{
		m_mapElevation.m_grid->ProjToCell(pts[i][0],pts[i][1],&col,&row);
		ptsRow.push_back(row);
		ptsCol.push_back(col);
		i;
	}
	
}

//��ȡ����㼯
void CGISDlg::TransformToVectorPoints(DrawLineDataStruct lineDataGroup,vector<double>& lineX,vector<double>& lineY)
{
	
	for (int i=0;i<lineDataGroup.linePointNum;i++)
	{
		lineX.push_back(lineDataGroup.linePts[i].dX);
		lineY.push_back(lineDataGroup.linePts[i].dY);
	}
}

//������
void CGISDlg::AddPointInLine(int ptPos,double* pt,DrawLineDataStruct& editLineDataGroup)
{
	// �޸��߶νṹ
	int lineNum = editLineDataGroup.linePointNum;
	editLineDataGroup.linePointNum = editLineDataGroup.linePointNum + 1; 
	for (int i=lineNum;i>ptPos;i--)  //�����ƶ�����һλ
	{
		editLineDataGroup.linePts[i] = editLineDataGroup.linePts[i-1];
		editLineDataGroup.linePts[i].nPt = editLineDataGroup.linePts[i].nPt + 1; //�޸ĺ����
	}
	//�޸IJ��������
	editLineDataGroup.linePts[ptPos].dX = pt[0];
	editLineDataGroup.linePts[ptPos].dY = pt[1];
	editLineDataGroup.linePts[ptPos].nPt = ptPos+1; //�޸ĺ����
	//�����޶�β�㺽���
	editLineDataGroup.linePts[editLineDataGroup.linePointNum-1].nPt = 1;
	//��������������Ϣ
	editLineDataGroup.linePts[ptPos].nL = editLineDataGroup.lineID;
	editLineDataGroup.linePts[ptPos].nH = editLineDataGroup.linePts[ptPos-1].nH;

	//�޸ĵ㼯�ṹ
	int ptNum = editLineDataGroup.pointNum;
	editLineDataGroup.pointNum = editLineDataGroup.pointNum + 1;
	for (int j=ptNum;j>ptPos;j--)  //�ƶ��㼯����
	{
		editLineDataGroup.pts[j] = editLineDataGroup.pts[j-1];
		editLineDataGroup.pts[j].nPt = editLineDataGroup.pts[j].nPt + 1; //�޸ĺ����
	}
	//�޸IJ��������
	editLineDataGroup.pts[ptPos].dX = pt[0];
	editLineDataGroup.pts[ptPos].dY = pt[1];
	editLineDataGroup.pts[ptPos].nPt = ptPos + 1; //�޸ĺ����
	//��������������Ϣ
	editLineDataGroup.pts[ptPos].nL = editLineDataGroup.lineID;
	editLineDataGroup.pts[ptPos].nH = editLineDataGroup.pts[ptPos-1].nH;
}

//������ɾ����
bool CGISDlg::RemovePointInLine(int ptPos,DrawLineDataStruct& backLineDataGroup)
{
	if (backLineDataGroup.pointNum<=2) //ֱ�߲�����ɾ�ڵ�
	{
		return false;
	}
	// �޸��߶νṹ
	int lineNum = backLineDataGroup.linePointNum;
	backLineDataGroup.linePointNum = backLineDataGroup.linePointNum - 1; 
	for (int i=ptPos;i<lineNum-2;i++)  //�ƶ��߶�����
	{
		backLineDataGroup.linePts[i] = backLineDataGroup.linePts[i+1];
		backLineDataGroup.linePts[i].nPt = backLineDataGroup.linePts[i].nPt -1; //�޸ĺ����
	}
	if (backLineDataGroup.linePointNum==3) //���ֱ�ߣ�����������β��
	{
		backLineDataGroup.linePointNum = 2;
	}
	else //�������
	{
		if (backLineDataGroup.pts[lineNum-2].ch1!=2) //�պϺ���
		{
			backLineDataGroup.linePts[backLineDataGroup.linePointNum-1] = backLineDataGroup.linePts[0];
		}
		
	}
	
	//�޸ĵ㼯�ṹ
	int ptNum = backLineDataGroup.pointNum;
	backLineDataGroup.pointNum = backLineDataGroup.pointNum - 1;
	for (int j=ptPos;j<ptNum-1;j++)  //�ƶ��㼯����
	{
		backLineDataGroup.pts[j] = backLineDataGroup.pts[j+1];
		backLineDataGroup.pts[j].nPt = backLineDataGroup.pts[j].nPt - 1; //�޸ĺ����
	}
	return true;
}

// �Ƿ�ѡ����Ҫ��,��ѡ�з��غ��߱�ţ����򷵻�-1
int CGISDlg::IsSelectLine(double* pt)
{
	if (m_ShowedLineDataList.size()==0)
	{
		return false;
	}
	for(auto i=m_ShowedLineDataList.begin();i!=m_ShowedLineDataList.end();i++)
	{
		//cout<<"��="<<i->first<<" ֵ="<<i->second<<endl;
		std::vector<double> lineX,lineY;
		DrawLineDataStruct lineData = i->second;
		TransformToVectorPoints(lineData,lineX,lineY);
		if(topologicalAnalysis.isPointInPolyLine(pt,lineX,lineY))
		{
			return lineData.lineID;
		};
	}
	return -1;
}
/**************************************************************************************************/

//�༭����ʱ,��ʾ�������öԻ���
void CGISDlg::ShowModifyPointDlg(int selectedPointID)
{
	if (!m_bEditLine)
	{
		return;
	}
	CModifyLinePointDlg dlg;
	dlg.m_editLineDataGroup = m_editLineDataGroup;
	dlg.SetSelectedPointID(selectedPointID);
	if (m_lineSelectedID!=11) //�ǻ��պ��ߣ���������������
	{
		dlg.SetCirclingPointRBTNVisible(false);
	}
	dlg.SetLonLat(m_editLineDataGroup.pts[selectedPointID].dX,m_editLineDataGroup.pts[selectedPointID].dY);
	if (circlingPointID == selectedPointID) //ѡ�������㣬���ð�ťѡ��
	{
		dlg.CheckedCirclingPoint();
	}
	if (dlg.DoModal() == IDOK)
	{
		double targetLat,targetLon;
		int pointID;
		dlg.GetLonLat(targetLon,targetLat,pointID);
		//bool bb = dlg.IsCirclingPoint();
		if (m_lineSelectedID==11) //���պ���
		{
			if (circlingPointID == selectedPointID) //���Ѿ��������������������
			{
				if (!dlg.IsCirclingPoint())   //�洢������
				{
					circlingPointID = -1;
				}
			}
			if (dlg.IsCirclingPoint())   //�洢������
			{
				circlingPointID = selectedPointID;
			}
		}

		//�޸ĵ�����
		m_editLineDataGroup.pts[pointID-1].dX = targetLon;
		m_editLineDataGroup.pts[pointID-1].dY = targetLat;

		//�޸�������
		m_editLineDataGroup.linePts[pointID-1].dX = targetLon;
		m_editLineDataGroup.linePts[pointID-1].dY = targetLat;
		if(pointID==m_editLineDataGroup.linePointNum-1 && m_editLineDataGroup.linePts[m_editLineDataGroup.linePointNum-1].ch1==2){	
			// ����޸ĵ������һ��������Ϊ���պϺ���
			m_editLineDataGroup.linePts[pointID].dX = targetLon;
			m_editLineDataGroup.linePts[pointID].dY = targetLat;
		}
		if (pointID==1 && m_editLineDataGroup.linePts[m_editLineDataGroup.linePointNum-1].ch1==0)
		{	// ����޸ĵ����׸�������Ϊ�պϺ���
			m_editLineDataGroup.linePts[m_editLineDataGroup.linePointNum-1].dX = targetLon;
			m_editLineDataGroup.linePts[m_editLineDataGroup.linePointNum-1].dY = targetLat;
		} //m_editLineDataGroup.linePts[0]->ch1==2 ���պ� 0->�պ�
		
		if (m_distLabelLayer!=-1)
		{
			m_map.ClearDrawing(m_distLabelLayer);//�������ͷ�λ�DZ��
		}
		//��������
		ClearDrawedLine(m_editLineDataGroup.lineID-1);
		//��溽��
		DrawFlyLine(m_editLineDataGroup);
	}
	else
	{
		//return;
	}
	return;
}

void CGISDlg::ShowModifyPointDlg()
{
	ShowModifyPointDlg(0);
}

//��ʾ����༭�Ի���
void CGISDlg::ShowEditSaveDlg()
{
	if (!m_bEditLine)
	{
		return;
	}
	CSaveLineEditSetting saveDlg;
	saveDlg.DoModal();
	int saveStatus = saveDlg.GetSaveStatus();  //-1Ϊ�����棬0Ϊ�����༭��1Ϊ����
	if (saveStatus==-1)
	{
		//��������
		ClearDrawedLine(m_editLineDataGroup.lineID-1);
		//�ָ�δ�༭״̬
		DrawFlyLine(m_ShowedLineDataList[m_lineSelectedID]);
		//���������
		m_map.ClearDrawing(m_distLabelLayer);

		m_bEditLine = false;
		m_bSelectFeatureFlag = false;
		m_lineSelectedID = -1;
		return;
	}
	else if (saveStatus==0)
	{
		return;
	}

	//
	CString dirName = "";
	switch (m_lineSelectedID)
	{
	case 1:
		dirName = "����1\\";
		break;
	case 2:
		dirName = "����2\\";
		break;
	case 3:
		dirName = "����3\\";
		break;
	case 4:
		dirName = "���滬�к���\\";
		break;
	case 5:
		dirName = "������\\";
		break;
	case 6:
		dirName = "��Ͷ����\\";
		break;
	case 10:
		dirName = "�ܵ�����\\";
		break;
	case 11:
		dirName = "���պ���\\";
		break;
	case 13:
		dirName = "ͨ������\\";
		break;
	}

	//���±�����պ���
	CString filename;
	CString strRouteFileDir = GetSoftwareCurrentDirectory() + _T("\\Route\\") + dirName;

	TCHAR s[10000];
	s[0]=0;
	CFileDialog dlg(FALSE, _T(".txt"), _T("*.txt"));
	dlg.m_ofn.lpstrTitle=_T("���溽���ļ�");
	dlg.m_ofn.lpstrFile=s;
	dlg.m_ofn.nMaxFile=sizeof(s)/sizeof(TCHAR);

	TCHAR filter[500]=_T("�����ļ�(*.txt)\0*.txt\0");
	dlg.m_ofn.lpstrFilter=filter;
	dlg.m_ofn.Flags|=OFN_OVERWRITEPROMPT|OFN_HIDEREADONLY|OFN_CREATEPROMPT;
	dlg.m_ofn.lpstrInitialDir = strRouteFileDir;

	if (IDOK == dlg.DoModal())
	{
		filename = dlg.GetPathName();		
		//�����ļ�
		FILE* fp = fopen(filename,"w");
		fprintf(fp,"%d, 0, %lf, %lf, %.2lf, 0, 00, 03\n", m_editLineDataGroup.lineID, 0.0, 0.0, 0.0);
		int n_linePts = m_editLineDataGroup.pointNum;
		for (int i=1;i<=n_linePts;i++)
		{
			PtStruct linePt = m_editLineDataGroup.pts[i-1];
			if (i<n_linePts-1)
			{
				if (circlingPointID==i-1) //������
				{
					fprintf(fp,"%d, %d, %lf, %lf, %.2lf, 0, 01, 03\n", m_editLineDataGroup.lineID, i, linePt.dX, linePt.dY,linePt.nH);
				}
				else
				{
					fprintf(fp,"%d, %d, %lf, %lf, %.2lf, 0, 00, 03\n", m_editLineDataGroup.lineID, i, linePt.dX, linePt.dY,linePt.nH);
				}	
			}
			else if (i==n_linePts-1)
			{
				if (m_lineSelectedID==11)  //���պ���
				{
					fprintf(fp,"%d, %d, %lf, %lf, %.2lf, 0, 00, 07\n", m_editLineDataGroup.lineID,i,linePt.dX,linePt.dY,linePt.nH);
				}
				else
				{
					fprintf(fp,"%d, %d, %lf, %lf, %.2lf, 0, 00, 03\n", m_editLineDataGroup.lineID,i,linePt.dX,linePt.dY,linePt.nH);
				}

			}
			else if (i==n_linePts)
			{
				if (m_lineSelectedID==11)  //���պ���
				{
					fprintf(fp,"%d, %d, %lf, %lf, %.2lf, 0, 00, 0B\n", m_editLineDataGroup.lineID,i,linePt.dX,linePt.dY,linePt.nH);
				}
				else
				{
					if (linePt.ch1==2)  //���Ϻ���
					{
						fprintf(fp,"%d, %d, %lf, %lf, %.2lf, 0, 02, 01\n", m_editLineDataGroup.lineID,i,linePt.dX,linePt.dY,linePt.nH);
					}
					else
					{
						fprintf(fp,"%d, %d, %lf, %lf, %.2lf, 0, 00, 01\n", m_editLineDataGroup.lineID,i,linePt.dX,linePt.dY,linePt.nH);
					}
				}
			}
		}
		fclose(fp);

		OnShowGivenLine(filename);
		//��������
		//ClearDrawedLine(m_editLineDataGroup.lineID-1);
		//��溽��
		//DrawFlyLine(m_editLineDataGroup);
		m_map.ClearDrawing(m_distLabelLayer);
		m_bEditLine = false;
		m_bSelectFeatureFlag = false;
		m_lineSelectedID = -1;
		return;
	}else
	{
		return;
	}
}

//��������
void CGISDlg::EndPolylineMessure()
{
	//ɾ���Ѿ�����ֱ��
	m_map.ClearDrawing(m_tempLayerID);
	m_bMeasureDrag = false;
	m_bEndMeasure = true;
	m_numPolylineMeasurePts = 0;
	return;
}