开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > GDI/图象编程 > 查看源码
QGISView.cpp
资源名称：QGIS.rar　[点击查看]
上传用户：oybseng
上传日期：2015-04-27
资源大小：7831k
文件大小：83k
源码类别：

GDI/图象编程

开发平台：

Visual C++

QGISView.cpp：源码内容
  1. // QGISView.cpp : implementation of the CQGISView class
  2. //
  4. #include "stdafx.h"
  5. #include "QGIS.h"
  6. #include "math.h"
  8. #include "MainFrm.h"
  9. #include "QGISDoc.h"
  10. #include "QGISView.h"
  11. #include "include/Resource.h"
  12. #include "QObjects/include/Resource.h"
  13. #include "QObjects/include/QBaseObj.h"
  14. #include "QObjects/include/QMapObj.h"
  15. #include "QObjects/include/QLayerObj.h"
  16. #include "QObjects/include/QPointObj.h"
  17. #include "QObjects/include/QLineObj.h"
  18. #include "QObjects/include/QCoordSys.h"
  19. #include "QObjects/include/QSelObjManager.h"
  20. #include "QObjects/include/QLineObj.h"
  21. #include "QObjects/include/QGISAlgorithmLib.h"
  22. #include "QObjects/include/QGlobalObj.h"
  23. #include "QDlg/DlgLayerManager.h"
  24. #include "QDlg/qdlgptattset.h"
  25. #include "QDlg/dlgmapattset.h"
  26. #include "QDlg/DlgLineAttSet.h"
  27. #include "QDlg/DlgLineBeThin.h"
  28. #include "QDlg/QDlgTextSet.h"
  29. #include "QObjects/include/QTextObj.h"
  30. #include "QReadExcelToMap.h"
  32. #ifdef _DEBUG
  33. #define new DEBUG_NEW
  34. #undef THIS_FILE
  35. static char THIS_FILE[] = __FILE__;
  36. #endif
  38. // extern int g_nPixelsPerInchX;
  39. // extern int g_nPixelsPerInchY;
  40. // extern double g_fEffectiveDistance;
  42. /////////////////////////////////////////////////////////////////////////////
  43. // CQGISView
  45. IMPLEMENT_DYNCREATE(CQGISView, CView)
  47. BEGIN_MESSAGE_MAP(CQGISView, CView)
  48. //{{AFX_MSG_MAP(CQGISView)
  49. ON_WM_LBUTTONDOWN()
  50. ON_WM_LBUTTONUP()
  51. ON_WM_MOUSEMOVE()
  52. ON_WM_RBUTTONDOWN()
  53. ON_WM_CANCELMODE()
  54. ON_COMMAND(IDM_MENU_ADD_LINE_QGIS, OnMenuAddLineQgis)
  55. ON_COMMAND(IDM_MENU_ADD_POINT_QGIS, OnMenuAddPointQgis)
  56. ON_WM_SETCURSOR()
  57. ON_COMMAND(IDM_MENU_SET_MAP_ATT, OnMenuSetMapAtt)
  58. ON_WM_SIZE()
  59. ON_COMMAND(IDM_MENU_PT_SELECT_OBJ_QGIS, OnMenuPtSelectObjQgis)
  60. ON_WM_TIMER()
  61. ON_COMMAND(IDM_MENU_USELECT_OBJ_QGIS, OnMenuUselectObjQgis)
  62. ON_COMMAND(IDM_MENU_LINE_ATT_SET, OnMenuLineAttSet)
  63. ON_UPDATE_COMMAND_UI(IDM_MENU_LINE_ATT_SET, OnUpdateMenuLineAttSet)
  64. ON_COMMAND(IDM_MENU_RECT_SELECT_OBJ_QGIS, OnMenuRectSelectObjQgis)
  65. ON_COMMAND(IDM_MENU_DELETE_OBJ_QGIS, OnMenuDeleteObjQgis)
  66. ON_COMMAND(IDM_MENU_ADD_POLYLINE, OnMenuAddPolyline)
  67. ON_COMMAND(ID_EDIT_BUTTON_ARROW, OnEditButtonArrow)
  68. ON_COMMAND(IDM_MENU_MOVE_OBJ_QGIS, OnMenuMoveObjQgis)
  69. ON_UPDATE_COMMAND_UI(IDM_MENU_MOVE_OBJ_QGIS, OnUpdateMenuMoveObjQgis)
  70. ON_COMMAND(IDM_MENU_HIDE_OBJ_QGIS, OnMenuHideObjQgis)
  71. ON_UPDATE_COMMAND_UI(IDM_MENU_HIDE_OBJ_QGIS, OnUpdateMenuHideObjQgis)
  72. ON_COMMAND(IDM_MENU_SHOW_OBJ_QGIS, OnMenuShowObjQgis)
  73. ON_COMMAND(IDM_MENU_ROTATE_OBJ_QGIS, OnMenuRotateObjQgis)
  74. ON_UPDATE_COMMAND_UI(IDM_MENU_ROTATE_OBJ_QGIS, OnUpdateMenuRotateObjQgis)
  75. ON_COMMAND(IDM_MENU_CUT_LINE_QGIS, OnMenuCutLineQgis)
  76. ON_UPDATE_COMMAND_UI(IDM_MENU_CUT_LINE_QGIS, OnUpdateMenuCutLineQgis)
  77. ON_COMMAND(IDM_MENU_DELETE_LINE_QGIS, OnMenuDeleteLineQgis)
  78. ON_UPDATE_COMMAND_UI(IDM_MENU_DELETE_LINE_QGIS, OnUpdateMenuDeleteLineQgis)
  79. ON_COMMAND(IDM_MENU_MOVE_LINE_QGIS, OnMenuMoveLineQgis)
  80. ON_UPDATE_COMMAND_UI(IDM_MENU_MOVE_LINE_QGIS, OnUpdateMenuMoveLineQgis)
  81. ON_UPDATE_COMMAND_UI(IDM_MENU_ROTATE_LINE_QGIS, OnUpdateMenuRotateLineQgis)
  82. ON_COMMAND(IDM_MENU_ROTATE_LINE_QGIS, OnMenuRotateLineQgis)
  83. ON_COMMAND(IDM_MENU_LINK_LINE_QGIS_, OnMenuLinkLineQgis)
  84. ON_COMMAND(IDM_MENU_MIRROR_LINE_X_QGIS, OnMenuMirrorLineXQgis)
  85. ON_COMMAND(IDM_MENU_MIRROR_LINE_Y_QGIS, OnMenuMirrorLineYQgis)
  86. ON_COMMAND(IDM_MENU_MIRROR_O_QGIS, OnMenuMirrorOQgis)
  87. ON_COMMAND(IDM_MENU_ADD_RECT_QGIS, OnMenuAddRectQgis)
  88. ON_COMMAND(IDM_MENU_LAYER_MANAGER_QGIS, OnMenuLayerManagerQgis)
  89. ON_COMMAND(IDM_MENU_ADD_CIRCLE_QGIS, OnMenuAddCircleQgis)
  90. ON_COMMAND(IDM_MENU_ADD_ELLIPSE_QGIS, OnMenuAddEllipseQgis)
  91. ON_UPDATE_COMMAND_UI(IDM_MENU_POINT_ATTSET_QGIS, OnUpdateMenuPointAttsetQgis)
  92. ON_COMMAND(IDM_MENU_POINT_ATTSET_QGIS, OnMenuPointAttsetQgis)
  93. ON_COMMAND(IDM_MENU_LINK_POINT_TO_LINE_QGIS, OnMenuLinkPointToLineQgis)
  94. ON_COMMAND(IDM_MENU_ADD_POLYLINE_STREAM, OnMenuAddPolylineStream)
  95. ON_COMMAND(IDM_MENU_REFRESH_VIEW, OnMenuRefreshView)
  96. ON_COMMAND(IDM_MENU_DRAW_ALLOBJ_IN_VIEW, OnMenuDrawAllobjInView)
  97. ON_COMMAND(ID_MENU_MOVE_MAP, OnMenuMoveMap)
  98. ON_COMMAND(IDM_MENU_AXIS_QGIS, OnMenuAxisQgis)
  99. //}}AFX_MSG_MAP
  100. // Standard printing commands
  101. ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
  102. ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
  103. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
  104. ON_UPDATE_COMMAND_UI(ID_MENU_INTERPRETATION_CURVE, &CQGISView::OnUpdateMenuInterpretationCurve)
  105. ON_UPDATE_COMMAND_UI(ID_MENU_TWICE_BCURVE, &CQGISView::OnUpdateMenuTwiceBcurve)
  106. ON_UPDATE_COMMAND_UI(ID_MENU_THIRD_BCURVE, &CQGISView::OnUpdateMenuThirdBcurve)
  107. ON_COMMAND(ID_MENU_INTERPRETATION_CURVE, &CQGISView::OnMenuInterpretationCurve)
  108. ON_COMMAND(ID_MENU_TWICE_BCURVE, &CQGISView::OnMenuTwiceBcurve)
  109. ON_COMMAND(ID_MENU_THIRD_BCURVE, &CQGISView::OnMenuThirdBcurve)
  110. ON_COMMAND(IDM_MENU_SELECT_POINT_QGIS, &CQGISView::OnMenuSelectPointQgis)
  111. ON_COMMAND(IDM_MENU_PT_LINK_TO_LINE_QGIS, &CQGISView::OnMenuPtLinkToLineQgis)
  112. ON_UPDATE_COMMAND_UI(IDM_MENU_PT_LINK_TO_LINE_QGIS, &CQGISView::OnUpdateMenuPtLinkToLineQgis)
  113. ON_COMMAND(ID_MENU_ADD_VERVICAL_LINE_QGIS, &CQGISView::OnMenuAddVervicalLineQgis)
  114. ON_COMMAND(ID_MENU_ADD_HORI_LINE_QGIS, &CQGISView::OnMenuAddHoriLineQgis)
  115. ON_COMMAND(ID_DGLSPK_LINE_GETPT_QGIS, &CQGISView::OnDglspkLineGetptQgis)
  116. ON_UPDATE_COMMAND_UI(ID_DGLSPK_LINE_GETPT_QGIS, &CQGISView::OnUpdateDglspkLineGetptQgis)
  117. ON_COMMAND(ID_MENU_ADD_TEXT_QGIS, &CQGISView::OnMenuAddTextQgis)
  118. ON_COMMAND(IDM_MENU_TEXT_PARA_SET, &CQGISView::OnMenuTextParaSet)
  119. ON_COMMAND(ID_MENU_READ_EXCEL_QGIS, &CQGISView::OnMenuReadExcelQgis)
  120. END_MESSAGE_MAP()
  122. /////////////////////////////////////////////////////////////////////////////
  123. // CQGISView construction/destruction
  125. CQGISView::CQGISView()
  126. {
  127. // TODO: add construction code here
  128. m_nLbtDown = 0;
  129. m_ptBegin = CQPoint(0,0);
  130. m_ptOld = CQPoint(0,0);
  131. m_ptEnd = CQPoint(0,0);
  132. m_bDrawAxis = FALSE;
  133. m_nSelectType = QGIS_SELECT_UNKNOWN;
  134. }
  136. CQGISView::~CQGISView()
  137. {
  138. m_nLbtDown = 0;
  139. m_bDrawAxis = FALSE;
  140. m_nSelectType = QGIS_SELECT_UNKNOWN;
  141. }
  143. BOOL CQGISView::PreCreateWindow(CREATESTRUCT& cs)
  144. {
  145. // TODO: Modify the Window class or styles here by modifying
  146. //  the CREATESTRUCT cs
  148. return CView::PreCreateWindow(cs);
  149. }
  151. /////////////////////////////////////////////////////////////////////////////
  152. // CQGISView drawing
  154. void CQGISView::OnDraw(CDC* pDC)
  155. {
  156. CQGISDoc* pDoc = GetDocument();
  157. ASSERT_VALID(pDoc);
  159. CQCoordSys * pSys = pDoc->m_pMap->GetCoordSysPointer();
  160. ASSERT_VALID(pSys);
  162. g_QObj.g_nPixelsPerInchX = pDC->GetDeviceCaps(LOGPIXELSX);
  163. g_QObj.g_nPixelsPerInchY = pDC->GetDeviceCaps(LOGPIXELSY);
  165. COLORREF cl = RGB(0,0,255);
  166. CQMapObj * pMap = pDoc->m_pMap;
  167. pMap->Display(pSys,pDC,R2_COPYPEN,0,&cl);
  168. long lWndX = 0,lWndY = 0;
  169. //DrawAxis(m_bDrawAxis,pDC,lWndX,lWndY);
  170. }
  172. /////////////////////////////////////////////////////////////////////////////
  173. // CQGISView printing
  175. BOOL CQGISView::OnPreparePrinting(CPrintInfo* pInfo)
  176. {
  177. // default preparation
  178. return DoPreparePrinting(pInfo);
  179. }
  181. void CQGISView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  182. {
  183. // TODO: add extra initialization before printing
  184. }
  186. void CQGISView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  187. {
  188. // TODO: add cleanup after printing
  189. }
  191. /////////////////////////////////////////////////////////////////////////////
  192. // CQGISView diagnostics
  194. #ifdef _DEBUG
  195. void CQGISView::AssertValid() const
  196. {
  197. CView::AssertValid();
  198. }
  200. void CQGISView::Dump(CDumpContext& dc) const
  201. {
  202. CView::Dump(dc);
  203. }
  205. CQGISDoc* CQGISView::GetDocument() // non-debug version is inline
  206. {
  207. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CQGISDoc)));
  208. return (CQGISDoc*)m_pDocument;
  209. }
  210. #endif //_DEBUG
  212. /////////////////////////////////////////////////////////////////////////////
  213. // CQGISView message handlers
  216. void CQGISView::OnLButtonDown(UINT nFlags, CPoint point) 
  217. {
  218. // TODO: Add your message handler code here and/or call default
  219. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  220. ASSERT(pDoc);
  221. CQMapObj * pMap = pDoc->m_pMap;
  222. ASSERT(pMap);
  223. CQCoordSys * pCoordSys = pMap->GetCoordSysPointer();
  224. ASSERT(pCoordSys);
  225. CDC * pDC = GetDC();
  226. CQSelObjManager * pSM = pMap->GetSelObjManager();
  227. ASSERT(pSM);
  229. CQPoint ptWorld;
  230. pCoordSys->LPtoWP(point,&ptWorld);
  232. static int nDrawEllipseTimes = 0; //绘制椭圆的次数
  233. //在第一次绘制椭圆的时候会弹出对话框，提示如何绘制
  235. switch(pDoc->m_MenuItemID)
  236. {
  237. case IDM_MENU_ADD_POINT_QGIS:   //添加点图元
  238. {
  239. CQPointObj * ptObj = new CQPointObj(ptWorld);
  240. ptObj->SetObjMapID(pMap->GetMapID());
  241. ptObj->SetObjLayerID(pMap->GetCurLayer()->GetLayerID());
  243. CBoundaryRect BRect;
  244. ptObj->GetBoundingRect(&BRect);
  245. pMap->AddObject(ptObj);
  246. CRect rect;
  247. pCoordSys->WPtoLP(BRect,&rect);
  248. InvalidateRect(rect);
  249. break;
  250. }
  251. case IDM_MENU_ADD_LINE_QGIS:   //添加线图元 两点直线 非折线对象 折线对象需要通过右键结束操作
  252. {
  253. if(m_nLbtDown == 0)    //当鼠标第一次点击
  254. {
  255. SetCapture();      //捕捉鼠标指针
  256. m_ptBegin = ptWorld;
  257. m_ptOld = ptWorld;
  258. m_ptEnd = ptWorld;
  259. m_nLbtDown++;
  260. }
  261. else
  262. {
  263. m_nLbtDown = 0;
  264. m_ptEnd = ptWorld;
  265. CQLineObj * pLine = new CQLineObj;
  266. pLine->SetObjMapID(pMap->GetMapID());
  267. pLine->SetObjLayerID(pMap->GetCurLayer()->GetLayerID());
  268. pLine->m_PtList.AddPoint(&m_ptBegin);
  269. pLine->m_PtList.AddPoint(&m_ptEnd);
  270. int n = pLine->m_PtList.GetSize();
  272. CBoundaryRect BRect;
  273. CRect rect;
  274. pLine->CalculateBoundary(&BRect);
  275. pMap->AddObject(pLine);
  276. pCoordSys->WPtoLP(BRect,&rect);
  277. InvalidateRect(rect,TRUE);
  278. ReleaseCapture();
  279. }
  280. break;
  281. }
  282. case IDM_MENU_PT_SELECT_OBJ_QGIS:  // 鼠标点选对象
  283. {
  284. if(m_nLbtDown==0)
  285. {
  286. m_ptBegin = ptWorld;
  287. m_nLbtDown++;
  288. }
  289. break;
  290. }
  291. case IDM_MENU_RECT_SELECT_OBJ_QGIS: //矩形选择
  292. {
  293. if(m_nLbtDown == 0)
  294. {
  295. m_ptBegin = ptWorld;
  296. m_ptOld = ptWorld;
  297. m_nLbtDown++;
  298. }
  299. break;
  300. }
  301. case IDM_MENU_ADD_POLYLINE:  //添加折线
  302. {
  303. if(m_nLbtDown == 0)
  304. {
  305. m_ptBegin = ptWorld;
  306. m_ptOld = ptWorld;
  307. m_ptEnd = ptWorld;
  308. m_nLbtDown++;
  309. m_ptArray.DeleteAll();
  310. m_ptArray.AddPoint(m_ptBegin.GetX(),m_ptBegin.GetY());
  311. SetCapture();
  312. }
  313. else
  314. {
  315. if(m_ptBegin != ptWorld)
  316. {
  317. m_ptBegin = ptWorld;
  318. m_ptOld = ptWorld;
  319. m_ptEnd = ptWorld;
  320. m_ptArray.AddPoint(ptWorld.GetX(),ptWorld.GetY());
  321. m_nLbtDown++;
  322. }
  323. }
  325. break;
  326. }
  327. case IDM_MENU_MOVE_LINE_QGIS:
  328. case IDM_MENU_MOVE_OBJ_QGIS:
  329. {
  330. if(pSM->GetSelObjCount()<=0)break;
  331. if(m_nLbtDown == 0)
  332. {
  333. m_ptBegin = ptWorld;
  334. m_ptOld = ptWorld;
  335. m_nLbtDown++;
  336. SetCapture();
  337. }
  338. else
  339. {
  340. double dx = ptWorld.GetX() - m_ptBegin.GetX();
  341. double dy = ptWorld.GetY() - m_ptBegin.GetY();
  343. int nSelObj = pSM->GetSelObjCount();
  344. POSITION pos = pSM->GetHeadPosition();
  345. while (pos)
  346. {
  347. CQBaseObj * pObj = pSM->GetNext(pos);
  348. COLORREF cl = pObj->GetObjPenColor();
  349. if(pObj && !pObj->GetObjDeleted() && !pObj->GetObjHided())
  350. {
  351. pObj->Display(pCoordSys,pDC,R2_COPYPEN,0,&cl);
  352. }
  353. }
  354. m_nLbtDown = 0;
  355. ReleaseCapture();
  356. InvalidateRect(NULL,TRUE);
  357. }
  358. break;
  359. }
  360. case IDM_MENU_ROTATE_LINE_QGIS:
  361. case IDM_MENU_ROTATE_OBJ_QGIS:  //图元的旋转
  362. {
  363. if(m_nLbtDown == 0)  //第一次鼠标电击 记录点位坐标
  364. {
  365. m_ptBegin = ptWorld;
  366. m_ptOld = ptWorld;
  367. m_ptEnd = ptWorld;
  368. SetCapture();
  369. m_nLbtDown++;
  370. }
  371. else
  372. {
  373. POSITION pos = pSM->GetHeadPosition();
  374. while (pos)
  375. {
  376. CQBaseObj * pObj = pSM->GetNext(pos);
  377. COLORREF cl = pObj->GetObjPenColor();
  378. if(pObj && !pObj->GetObjDeleted() && !pObj->GetObjHided())
  379. {
  380. pObj->Display(pCoordSys,pDC,R2_COPYPEN,0,&cl);
  381. }
  382. }
  383. m_nLbtDown = 0;
  384. ReleaseCapture();
  385. InvalidateRect(NULL,TRUE);
  386. }
  387. break;
  388. }
  389. case IDM_MENU_CUT_LINE_QGIS: //剪断线
  390. {
  391. if(m_nLbtDown == 0)
  392. {
  393. m_ptBegin = ptWorld;
  394. m_nLbtDown++;
  395. SetCapture();
  396. }
  397. break;
  398. }
  399. case IDM_MENU_MIRROR_LINE_X_QGIS:
  400. {
  401. static BOOL bSelected1 = FALSE;
  402. if(m_nLbtDown == 0)  //假如是第一次点击
  403. {
  404. m_ptBegin = ptWorld;
  405. m_nLbtDown++;
  407. pSM->RemoveAllSelObj();
  408. if(pMap->Select(pSM,pCoordSys,m_ptBegin,g_QObj.g_fEffectiveDistance))
  409. {
  410. pSM->BeginFlash((CWnd *)this,2,1000);
  411. pSM->FlashObj(pCoordSys,this->GetSafeHwnd());
  412. bSelected1 = TRUE;
  413. }
  414. else
  415. {
  416. bSelected1 = FALSE;
  417. m_nLbtDown = 0;
  418. }
  419. }
  420. else if(m_nLbtDown == 1 && bSelected1)
  421. {
  422. m_ptOld = ptWorld;
  423. m_nLbtDown = 0;
  424. CQBaseObj * pObj = (CQBaseObj *)pSM->GetCurSelObj();
  425. if(pObj->GetObjType() != QGIS_OBJ_LINE) break;
  426. CQLineObj * pOldLine = NULL;
  427. pOldLine = (CQLineObj *)pObj;
  428. if(!pOldLine)break;
  429. CQLineObj * pNewLine = new CQLineObj;
  430. pOldLine->Mirror(1,m_ptOld,pNewLine);
  431. if(pNewLine->m_PtList.GetSize()<=1)
  432. {
  433. delete pNewLine;
  434. break;           //镜像操作失败 
  435. }
  436. else
  437. {
  438. CQLayerObj * pMirrorLayer = NULL;
  439. pMirrorLayer = pMap->FindLayer(pOldLine->GetObjLayerID());
  440. if(!pMirrorLayer)break;
  441. pNewLine->CalculateBoundary(NULL);
  442. pMirrorLayer->AddObject(pNewLine);
  443. pNewLine->SetObjLayerID(pOldLine->GetObjLayerID());
  444. pNewLine->SetObjMapID(pOldLine->GetObjMapID());
  445. pSM->EndFlash((CWnd *)this,2);
  446. }
  447. Invalidate();
  448. }
  449. break;
  450. }
  451. case IDM_MENU_MIRROR_LINE_Y_QGIS:
  452. {
  453. static BOOL bSelected1 = FALSE;
  454. if(m_nLbtDown == 0)  //假如是第一次点击
  455. {
  456. m_ptBegin = ptWorld;
  457. m_nLbtDown++;
  459. pSM->RemoveAllSelObj();
  460. if(pMap->Select(pSM,pCoordSys,m_ptBegin,g_QObj.g_fEffectiveDistance))
  461. {
  462. pSM->BeginFlash((CWnd *)this,2,1000);
  463. pSM->FlashObj(pCoordSys,this->GetSafeHwnd());
  464. bSelected1 = TRUE;
  465. }
  466. else
  467. {
  468. bSelected1 = FALSE;
  469. m_nLbtDown = 0;
  470. }
  471. }
  472. else if(m_nLbtDown == 1 && bSelected1)
  473. {
  474. m_ptOld = ptWorld;
  475. m_nLbtDown = 0;
  476. CQBaseObj * pObj = (CQBaseObj *)pSM->GetCurSelObj();
  477. if(pObj->GetObjType() != QGIS_OBJ_LINE) break;
  478. CQLineObj * pOldLine = NULL;
  479. pOldLine = (CQLineObj *)pObj;
  480. if(!pOldLine)break;
  481. CQLineObj * pNewLine = new CQLineObj;
  482. pOldLine->Mirror(0,m_ptOld,pNewLine);
  483. if(pNewLine->m_PtList.GetSize()<=1)
  484. {
  485. delete pNewLine;
  486. break;           //镜像操作失败 
  487. }
  488. else
  489. {
  490. CQLayerObj * pMirrorLayer = NULL;
  491. pMirrorLayer = pMap->FindLayer(pOldLine->GetObjLayerID());
  492. if(!pMirrorLayer)break;
  493. pNewLine->CalculateBoundary(NULL);
  494. pMirrorLayer->AddObject(pNewLine);
  495. pNewLine->SetObjLayerID(pOldLine->GetObjLayerID());
  496. pNewLine->SetObjMapID(pOldLine->GetObjMapID());
  497. pSM->EndFlash((CWnd *)this,2);
  498. }
  499. Invalidate();
  500. }
  501. break;
  502. }
  503. case IDM_MENU_MIRROR_O_QGIS:
  504. {
  505. static BOOL bSelected1 = FALSE;
  506. if(m_nLbtDown == 0)  //假如是第一次点击
  507. {
  508. m_ptBegin = ptWorld;
  509. m_nLbtDown++;
  511. pSM->RemoveAllSelObj();
  512. if(pMap->Select(pSM,pCoordSys,m_ptBegin,g_QObj.g_fEffectiveDistance))
  513. {
  514. pSM->BeginFlash((CWnd *)this,2,1000);
  515. pSM->FlashObj(pCoordSys,this->GetSafeHwnd());
  516. bSelected1 = TRUE;
  517. }
  518. else
  519. {
  520. bSelected1 = FALSE;
  521. m_nLbtDown = 0;
  522. }
  523. }
  524. else if(m_nLbtDown == 1 && bSelected1)
  525. {
  526. m_ptOld = ptWorld;
  527. m_nLbtDown = 0;
  528. CQBaseObj * pObj = (CQBaseObj *)pSM->GetCurSelObj();
  529. if(pObj->GetObjType() != QGIS_OBJ_LINE) break;
  530. CQLineObj * pOldLine = NULL;
  531. pOldLine = (CQLineObj *)pObj;
  532. if(!pOldLine)break;
  533. CQLineObj * pNewLine = new CQLineObj;
  534. pOldLine->Mirror(2,m_ptOld,pNewLine);
  535. if(pNewLine->m_PtList.GetSize()<=1)
  536. {
  537. delete pNewLine;
  538. break;           //镜像操作失败 
  539. }
  540. else
  541. {
  542. CQLayerObj * pMirrorLayer = NULL;
  543. pMirrorLayer = pMap->FindLayer(pOldLine->GetObjLayerID());
  544. if(!pMirrorLayer)break;
  545. pNewLine->CalculateBoundary(NULL);
  546. pMirrorLayer->AddObject(pNewLine);
  547. pNewLine->SetObjLayerID(pOldLine->GetObjLayerID());
  548. pNewLine->SetObjMapID(pOldLine->GetObjMapID());
  549. pSM->EndFlash((CWnd *)this,2);
  550. }
  551. Invalidate();
  552. }
  553. break;
  554. }
  555. case IDM_MENU_LINK_LINE_QGIS_: //连接线
  556. {
  557. static BOOL bSelected1 = FALSE;
  558. if(m_nLbtDown == 0)  //假如是第一次点击
  559. {
  560. m_ptBegin = ptWorld;
  561. m_nLbtDown++;
  563. pSM->RemoveAllSelObj();
  564. if(pMap->Select(pSM,pCoordSys,m_ptBegin,g_QObj.g_fEffectiveDistance))
  565. {
  566. pSM->BeginFlash((CWnd *)this,2,1000);
  567. pSM->FlashObj(pCoordSys,this->GetSafeHwnd());
  568. bSelected1 = TRUE;
  569. }
  570. else
  571. {
  572. bSelected1 = FALSE;
  573. m_nLbtDown = 0;
  574. }
  575. }
  576. else if(m_nLbtDown == 1)
  577. {
  578. if(bSelected1 == TRUE)
  579. {
  580. m_ptOld = ptWorld;
  581. if(pMap->Select(pSM,pCoordSys,m_ptOld,g_QObj.g_fEffectiveDistance))
  582. {
  583. pSM->BeginFlash((CWnd *)this,2,1000);
  584. pSM->FlashObj(pCoordSys,this->GetSafeHwnd());
  585. m_nLbtDown = 0;
  586. int nSelObjCount = pSM->GetSelObjCount();
  587. if(nSelObjCount != 2)break;
  588. POSITION pos = pSM->GetHeadPosition();
  589. CQBaseObj * pObj1 = (CQBaseObj *)pSM->GetNext(pos);
  590. CQBaseObj * pObj2 = (CQBaseObj *)pSM->GetNext(pos);
  591. if(pObj1->GetObjType() != QGIS_OBJ_LINE || pObj2->GetObjType() != QGIS_OBJ_LINE)
  592. {
  593. break;
  594. }
  595. else
  596. {
  597. CQLineObj * pLine1 = (CQLineObj *)pObj1;
  598. CQLineObj * pLine2 = (CQLineObj *)pObj2;
  599. int nPtNum1 = pLine1->m_PtList.GetSize();
  600. int nPtNum2 = pLine2->m_PtList.GetSize();
  601. if(nPtNum1 == 0 || nPtNum2 == 0)break;
  602. CQPoint * ptEndLine1 = NULL;
  603. ptEndLine1 = pLine1->m_PtList.GetPoint(nPtNum1-1); // 取得第一条线的终点
  604. CQPoint * ptBeginLine2 = NULL;
  605. ptBeginLine2 = pLine2->m_PtList.GetPoint(0);
  606. CQPoint * ptEndLine2 = NULL;
  607. ptEndLine2 = pLine2->m_PtList.GetPoint(nPtNum2-1);
  608. if(!ptEndLine1 || !ptBeginLine2 || !ptEndLine2)break;
  609. double dDis1 = ptEndLine1->Distance(*ptBeginLine2);
  610. double dDis2 = ptEndLine1->Distance(*ptEndLine2);
  611. if(dDis1-dDis2<=1e-5) // 第一条线的终点离第二条线的起点近
  612. {
  613. //从第一个点开始装
  614. int nPtNUm = pLine2->m_PtList.GetSize();
  615. for(int n=0;n<nPtNUm;n++)
  616. {
  617. pLine1->m_PtList.AddPoint(pLine2->m_PtList.GetPoint(n));
  618. }
  619. }
  620. else
  621. {
  622. //从最后一个点开始装
  623. int nptNum = pLine2->m_PtList.GetSize();
  624. for(int m=nptNum-1;m>=0;m--)
  625. {
  626. pLine1->m_PtList.AddPoint(pLine2->m_PtList.GetPoint(m));
  627. }
  628. }
  629. CQLayerObj * pLayer = NULL;
  630. pLayer = pMap->FindLayer(pLine2->GetObjLayerID());
  631. if(!pLayer)break;
  632. pLayer->Deleteobject(pLine2);
  633. pLine2 = NULL;
  634. CBoundaryRect Brect;
  635. pLine1->CalculateBoundary(&Brect);
  636. CRect rect;
  637. pCoordSys->WPtoLP(Brect,&rect);
  638. pSM->EndFlash((CWnd *)this,2);
  639. InvalidateRect(rect,TRUE);
  640. }
  641. }
  642. }
  643. }
  644. break;
  645. }
  646. case IDM_MENU_ADD_RECT_QGIS:
  647. {
  648. if(m_nLbtDown == 0) //假如是鼠标第一次点击
  649. {
  650. m_ptBegin = ptWorld;
  651. m_ptOld = ptWorld;
  652. m_ptEnd = ptWorld;
  653. m_nLbtDown++;
  654. SetCapture();
  655. }
  656. else if(m_nLbtDown == 1)
  657. {
  658. m_nLbtDown = 0;
  659. m_ptEnd = ptWorld;
  660. if(m_ptEnd != m_ptBegin)
  661. {
  662. CQLineObj * pNewLine = new CQLineObj;
  663. CQPoint pt1,pt2;
  664. pt1.SetPoint(m_ptBegin.GetX(),m_ptEnd.GetY());
  665. pt2.SetPoint(m_ptEnd.GetX(),m_ptBegin.GetY());
  666. pNewLine->m_PtList.AddPoint(&m_ptBegin);
  667. pNewLine->m_PtList.AddPoint(&pt1);
  668. pNewLine->m_PtList.AddPoint(&m_ptEnd);
  669. pNewLine->m_PtList.AddPoint(&pt2);
  670. pNewLine->m_PtList.AddPoint(&m_ptBegin);
  671. pNewLine->SetLineClosed(TRUE);
  672. pNewLine->SetObjMapID(pMap->GetMapID());
  673. pNewLine->SetObjLayerID(pMap->GetCurLayer()->GetLayerID());
  674. CBoundaryRect Brect;
  675. pNewLine->CalculateBoundary(&Brect);
  676. double dStep = 5.0;
  677. Brect.Lager(dStep);
  678. pMap->AddObject(pNewLine);
  679. CRect rectTemp;
  680. pCoordSys->WPtoLP(Brect,&rectTemp);
  681. InvalidateRect(rectTemp,TRUE);
  682. ReleaseCapture();
  683. }
  684. }
  685. break;
  686. }
  687. case IDM_MENU_ADD_CIRCLE_QGIS:  //鼠标画圆
  688. {
  689. if(m_nLbtDown == 0)     //如果是 第一次单击
  690. {
  691. m_nLbtDown += 1;
  692. m_ptBegin = ptWorld;
  693. m_ptOld = ptWorld;
  694. m_ptEnd = ptWorld;
  695. SetCapture();       //捕捉鼠标
  696. }
  697. else if(m_nLbtDown == 1 && m_ptBegin != ptWorld)//假如是第二次单击
  698. {
  699. m_ptEnd = ptWorld;
  700. long rCr = (GetEndPos().x - GetBeginPos().x)*(GetEndPos().x - GetBeginPos().x) +
  701. (GetEndPos().y - GetBeginPos().y)*(GetEndPos().y - GetBeginPos().y);
  702. rCr = static_cast<long>(sqrt(static_cast<double>(rCr)));
  703. double fR = pCoordSys->LLtoWL(rCr);
  704. if(fR>0)
  705. {
  706. CQEllipseObj * pCircle = new CQEllipseObj(m_ptBegin.GetX(),m_ptBegin.GetY(),fR,fR,0,2*PI,0);
  707. pMap->AddObject(pCircle);
  709. CBoundaryRect bRect;
  710. pCircle->CalculateBoundary(&bRect);
  711. bRect.Lager(3);
  712. CRect rect;
  713. pCoordSys->WPtoLP(bRect,&rect);
  714. InvalidateRect(rect,TRUE);
  715. }
  716. m_nLbtDown = 0;
  717. ReleaseCapture();
  718. break;
  719. }
  720. break;
  721. }
  722. case IDM_MENU_ADD_ELLIPSE_QGIS:
  723. {
  724. if(m_nLbtDown == 0)
  725. {
  726. m_nLbtDown++;
  727. SetCapture();
  728. m_ptBegin = ptWorld;
  729. m_ptOld = ptWorld;
  730. m_ptEnd = ptWorld;
  731. }
  732. else if(m_nLbtDown == 1 && m_ptBegin != ptWorld)
  733. {
  734. double dx = m_ptBegin.GetX()-ptWorld.GetX();
  735. double dy = m_ptBegin.GetY()-ptWorld.GetY();
  736. double fLongAxis = sqrt(dx*dx + dy*dy)/2.0;
  737. m_Ellipse.SetLongAxis(fLongAxis);
  738. m_Ellipse.SetShortAxis(fLongAxis); // 在没有调整椭圆形状的时候 先让其形状为圆形
  739. double dcx = (m_ptBegin.GetX()+ptWorld.GetX())/2.0;
  740. double dcy = (m_ptBegin.GetY()+ptWorld.GetY())/2.0;
  741. m_Ellipse.SetCenterPoint(dcx,dcy);
  742. ptCenter.SetPoint(dcx,dcy);
  743. m_Ellipse.SetStartAngleRad(0.0f);
  744. m_Ellipse.SetEndAngleRad(2*PI);
  745. double fRotateAngle = atan2(dy,dx);  //旋转角度
  746. if(fRotateAngle<0)fRotateAngle+=2*PI;
  747. else if(fRotateAngle>2*PI) fRotateAngle -= 2*PI;
  748. m_Ellipse.SetRotateAngleRad(fRotateAngle);
  750. pDC->SetROP2(R2_NOT);
  751. m_ptOld.SetPoint(dcx,dcy);
  752. COLORREF cl = RGB(0,0,0);
  753. DrawEllipse(m_Ellipse,pDC);
  754. pDC->MoveTo(GetBeginPos());     //擦除长轴线
  755. pDC->LineTo(point);
  756. m_nLbtDown++;
  757. }
  758. else if(m_nLbtDown == 2 && ptWorld != ptCenter)
  759. {
  760. m_Ellipse.GetCenterPoint(ptCenter);
  761. double dx = ptCenter.GetX()-ptWorld.GetX();
  762. double dy = ptCenter.GetY()-ptWorld.GetY(); //确定椭圆短轴
  763. double fShortAxis = sqrt(dx*dx+dy*dy);
  764. m_Ellipse.SetShortAxis(fShortAxis);
  765. double fflag = max(abs(m_ptBegin.GetX()-ptWorld.GetX()),abs(m_ptEnd.GetY()-ptWorld.GetY()));
  766. if(fflag>0)
  767. {
  768. CQEllipseObj * pElipse = NULL;
  769. pElipse = CreateEllipse(m_Ellipse);
  770. if(pElipse)
  771. {
  772. pMap->AddObject(pElipse);
  773. CBoundaryRect bRect;
  774. pElipse->CalculateBoundary(&bRect);
  775. bRect.Lager(3.0);
  776. CRect rect;
  777. pCoordSys->WPtoLP(bRect,&rect);
  778. InvalidateRect(rect,TRUE);
  779. m_nLbtDown = 0;
  780. ReleaseCapture();
  781. }
  782. else
  783. {
  784. m_nLbtDown = 0;
  785. ReleaseCapture();
  786. }
  787. }
  788. }
  789. break;
  790. }
  791. case IDM_MENU_ADD_POLYLINE_STREAM: //造流线
  792. {
  793. if(m_nLbtDown == 0)        //鼠标第一次单击
  794. {
  795. m_ptBegin = ptWorld;
  796. m_ptOld = ptWorld;
  797. m_ptEnd = ptWorld;
  798. SetCapture();          //设置鼠标捕捉
  799. m_ptArray.AddPoint(ptWorld.GetX(),ptWorld.GetY());
  800. m_nLbtDown++;
  801. }
  802. break;
  803. }
  804. case ID_MENU_MOVE_MAP:
  805. {
  806. if(m_nLbtDown == 0) //假如是第一次单击视图
  807. {
  808. ++m_nLbtDown;
  809. m_ptBegin = ptWorld;
  810. m_ptOld = ptWorld;
  811. m_ptEnd = ptWorld;
  812. m_bDrawAxis = FALSE;
  813. SetCapture();
  815. long lOrX,lOrY;
  816. pCoordSys->GetStartOfWnd(lOrX,lOrY);
  817. CRect rectAxis = DrawAxis(m_bDrawAxis,pDC,lOrX,lOrY);
  818. InvalidateRect(rectAxis,TRUE);
  819. }
  820. break;
  821. }
  822. case IDM_MENU_LINK_POINT_TO_LINE_QGIS: //连点成线
  823. {
  824. if(m_nLbtDown == 0) // 第一次点击
  825. {
  826. pSM->RemoveAllSelObj(); //清空选择列表
  827. SetCapture();
  828. if(pMap->SingleSelect(pSM,pCoordSys,ptWorld,g_QObj.g_fEffectiveDistance,QGIS_OBJ_POINT) == 0)
  829. {
  830. m_nLbtDown = 0;
  831. break;
  832. }
  833. else
  834. {
  835. m_nLbtDown++;
  836. CQBaseObj * pObj = pSM->GetCurSelObj();
  837. if(pObj->GetObjType() == QGIS_OBJ_POINT)
  838. {
  839. m_vecObj.push_back(pObj);
  840. }
  841. }
  843. }
  844. else //  点击一次以上
  845. {
  846. if(pMap->SingleSelect(pSM,pCoordSys,ptWorld,g_QObj.g_fEffectiveDistance,QGIS_OBJ_POINT) == 0)
  847. {
  848. break;
  849. }
  850. else
  851. {
  852. m_nLbtDown++;
  853. CQBaseObj * pObj = pSM->GetCurSelObj();
  854. if(pObj->GetObjType() == QGIS_OBJ_POINT)
  855. {
  856. m_vecObj.push_back(pObj);
  857. }
  858. }
  859. }
  861. pSM->RemoveAll();
  862. break;
  863. }
  864. case ID_MENU_ADD_HORI_LINE_QGIS: //添加水平线
  865. //水平线只改变线条的X坐标而Y坐标不变
  866. {
  867. if(m_nLbtDown == 0)
  868. {
  869. SetCapture();
  870. m_ptBegin = ptWorld;
  871. m_ptOld = ptWorld;
  872. m_ptEnd = ptWorld;
  873. m_nLbtDown++;
  874. }
  875. else
  876. {
  877. m_ptEnd = ptWorld;
  878. CBoundaryRect bRect;
  879. CRect rect;
  880. CQLineObj * pHorLine = new CQLineObj;
  881. pHorLine->m_PtList.AddPoint(m_ptBegin.GetX(),m_ptBegin.GetY());
  882. pHorLine->m_PtList.AddPoint(m_ptEnd.GetX(),m_ptBegin.GetY());
  883. pHorLine->CalculateBoundary(&bRect);
  884. pCoordSys->WPtoLP(bRect,&rect);
  885. pMap->AddObject(pHorLine);
  886. InvalidateRect(rect,TRUE);
  887. m_nLbtDown = 0;
  888. ReleaseCapture();
  889. }
  890. break;
  891. }
  892. case ID_MENU_ADD_VERVICAL_LINE_QGIS:
  893. {
  894. if(m_nLbtDown == 0)
  895. {
  896. SetCapture();
  897. m_nLbtDown++;
  898. m_ptBegin = ptWorld;
  899. m_ptOld = ptWorld;
  900. m_ptEnd = ptWorld;
  901. }
  902. else
  903. {
  904. CBoundaryRect bRect;
  905. CRect rect;
  906. CQLineObj * pVerLine = new CQLineObj;
  907. m_ptEnd = ptWorld;
  908. pVerLine->m_PtList.AddPoint(m_ptBegin.GetX(),m_ptBegin.GetY());
  909. pVerLine->m_PtList.AddPoint(m_ptBegin.GetX(),m_ptEnd.GetY());
  910. pVerLine->CalculateBoundary(&bRect);
  911. pMap->AddObject(pVerLine);
  912. pCoordSys->WPtoLP(bRect,&rect);
  913. InvalidateRect(rect,TRUE);
  914. ReleaseCapture();
  915. m_nLbtDown = 0;
  916. }
  917. break;
  918. }
  919. case ID_MENU_ADD_TEXT_QGIS: //添加标住对象
  920. {
  921. CQTextObj * pTextObj = new CQTextObj;
  922. pTextObj->SetPos(ptWorld);
  924. QDlgTextSet dlg(pTextObj);
  926. if(dlg.DoModal() == IDOK)
  927. {
  928. CBoundaryRect bRect;
  929. CRect rect;
  930. pMap->AddObject(pTextObj);
  931. pTextObj->CalculateBoundary(&bRect);
  932. pCoordSys->WPtoLP(bRect,&rect);
  933. InvalidateRect(rect,TRUE);
  934. }
  935. else
  936. {
  937. delete pTextObj;
  938. pTextObj = NULL;
  939. }
  941. break;
  942. }
  943. case ID_MENU_READ_EXCEL_QGIS:
  944. {
  945. CQPoint ptExcelStartPt = ptWorld;
  946. CQReadExcelToView ReadExcelToMap(pMap,pCoordSys,ptExcelStartPt);
  947. CWaitCursor wait;
  948. BOOL bSuccess = ReadExcelToMap.ReadExcelFromPC();
  950. CBoundaryRect brect;
  951. pMap->CalculateBoundary(&brect);
  952. CRect rectMap;
  953. pCoordSys->WPtoLP(brect,&rectMap);
  954. if(bSuccess)
  955. {
  956. AfxMessageBox("Excel文件矢量化完成");
  957. }
  958. pDoc->m_MenuItemID = 0;
  959. break;
  960. }
  961. default:
  962. {
  963. m_nLbtDown = 0;
  964. break;
  965. }
  967. }
  968. CView::OnLButtonDown(nFlags, point);
  969. }
  971. void CQGISView::OnLButtonUp(UINT nFlags, CPoint point) 
  972. {
  973. // TODO: Add your message handler code here and/or call default
  974. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  975. ASSERT(pDoc);
  976. CQMapObj * pMap = pDoc->m_pMap;
  977. ASSERT(pMap);
  978. CQCoordSys * pCoordSys = pMap->GetCoordSysPointer();
  979. ASSERT(pCoordSys);
  980. CQSelObjManager * pSM = pMap->GetSelObjManager();
  981. ASSERT(pSM);
  983. CDC * pDC = GetDC();
  985. CQPoint ptWorld;
  986. pCoordSys->LPtoWP(point,&ptWorld);
  988. switch(pDoc->m_MenuItemID)
  989. {
  990. case IDM_MENU_PT_SELECT_OBJ_QGIS:
  991. {
  992. if(m_nLbtDown != 0)
  993. {
  994. pSM->RemoveAllSelObj(); //去除所有选中的图元对象
  995. if(pMap->Select(pSM,pCoordSys,ptWorld,g_QObj.g_fEffectiveDistance))
  996. {
  997. pSM->BeginFlash((CWnd *)this,2,1000);
  998. pSM->FlashObj(pCoordSys,this->GetSafeHwnd());
  999. m_nLbtDown = 0;
  1000. }
  1001. }
  1002. break;
  1003. }
  1004. case IDM_MENU_CUT_LINE_QGIS: // 剪断线
  1005. {
  1006. if(m_nLbtDown>0)
  1007. {
  1008. BOOL bInLine = FALSE;
  1009. CQBaseObj * pObj = pSM->GetCurSelObj();
  1010. if(pObj->GetObjType() != QGIS_OBJ_LINE) break;
  1011. CQLineObj * pLine = (CQLineObj *)pObj;
  1012. CQPoint * ptFirst = NULL,* ptSecond = NULL;
  1013. int nPtcount = pLine->m_PtList.GetSize();
  1014. for(int i=0;i<nPtcount-1;i++)
  1015. {
  1016. ptFirst = pLine->m_PtList.GetPoint(i);
  1017. ptSecond = pLine->m_PtList.GetPoint(i+1);
  1018. if(!ptFirst || !ptSecond) return;
  1019. bInLine = m_ptBegin.PtInLine(*ptFirst,*ptSecond);
  1020. if(bInLine == TRUE)break;
  1021. }
  1022. if(bInLine)
  1023. {
  1024. CQLineObj * pCutLine = new CQLineObj;
  1025. CQPointArray ptTmArray;
  1026. int nFirst = -1;
  1027. FindNearestTwoPoints(nFirst,&m_ptBegin,pLine);
  1028. pCutLine->m_PtList.AddPoint(m_ptBegin.GetX(),m_ptBegin.GetY());
  1029. if(nFirst+1 == nPtcount-1)
  1030. {
  1031. pCutLine->m_PtList.AddPoint(pLine->m_PtList.GetPoint(nFirst+1));
  1032. }
  1033. else if(nFirst+1<nPtcount)
  1034. {
  1035. for(int m=nFirst+1;m<nPtcount;m++)
  1036. {
  1037. pCutLine->m_PtList.AddPoint(pLine->m_PtList.GetPoint(m));
  1038. }
  1039. }
  1040. for(int kk=0;kk<=nFirst;kk++)
  1041. {
  1042. ptTmArray.AddPoint(pLine->m_PtList.GetPoint(kk));
  1043. }
  1045. CBoundaryRect bRect1,bRect2;
  1046. pLine->m_PtList.Copy(ptTmArray);
  1047. pLine->m_PtList.AddPoint(m_ptBegin.GetX(),m_ptBegin.GetY());
  1048. pLine->CalculateBoundary(&bRect1);
  1049. pCutLine->CalculateBoundary(&bRect2);
  1050. pLine->SetShowPointFlag(TRUE);
  1051. pCutLine->SetShowPointFlag(TRUE);
  1052. bRect2.Union(&bRect1);
  1053. double fstep = 2.5f;
  1054. bRect2.Lager(fstep);
  1055. pCutLine->SetObjLayerID(pLine->GetObjLayerID());
  1056. pCutLine->SetObjMapID(pLine->GetObjMapID());
  1057. pMap->AddObject(pCutLine);
  1058. CRect rectTm;
  1059. m_nLbtDown = 0;
  1060. ReleaseCapture();
  1061. pCoordSys->WPtoLP(bRect2,&rectTm);
  1062. pSM->EndFlash((CWnd *)this,2);
  1063. InvalidateRect(rectTm,TRUE);
  1064. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  1065. }
  1066. }
  1067. m_nLbtDown = 0;
  1068. ReleaseCapture();
  1069. break;
  1070. }
  1071. case IDM_MENU_ADD_POLYLINE_STREAM:   //添加流线
  1072. {
  1073. if(m_nLbtDown>0)
  1074. {
  1075. int nPtSize = m_ptArray.GetSize();
  1076. if(nPtSize < 2) //若点集中点的数量少于2 则退出
  1077. {
  1078. m_ptArray.RemoveAll();
  1079. m_nLbtDown = 0;
  1080. ReleaseCapture();
  1081. }
  1082. else
  1083. {
  1084. CBoundaryRect bRect;
  1085. CRect rectTemp;
  1086. CQLineObj * pStreamLine = new CQLineObj;
  1087. pStreamLine->m_PtList.Copy(m_ptArray);
  1088. pStreamLine->CalculateBoundary(&bRect);
  1089. pMap->AddObject(pStreamLine);
  1090. m_ptArray.DeleteAll(); //删除点阵里所有的点
  1092. ReleaseCapture();
  1093. m_nLbtDown = 0;
  1094. pCoordSys->WPtoLP(bRect,&rectTemp);
  1095. InvalidateRect(rectTemp);
  1096. }
  1097. }
  1098. break;
  1099. }
  1100. case ID_MENU_MOVE_MAP:
  1101. {
  1102. m_nLbtDown = 0;
  1103. ReleaseCapture();
  1104. long lOrX,lOry;
  1105. pCoordSys->GetStartOfWnd(lOrX,lOry);
  1106. DrawAxis(m_bDrawAxis,pDC,lOrX,lOry);
  1107. break;
  1108. }
  1109. case IDM_MENU_RECT_SELECT_OBJ_QGIS:
  1110. {
  1111. if(m_nLbtDown>0)
  1112. {
  1113. pDC->SetROP2(R2_NOT);
  1114. pDC->SelectStockObject(NULL_BRUSH);
  1115. m_nLbtDown = 0;
  1116. m_ptOld = ptWorld;
  1117. double fMinx = min(m_ptBegin.GetX(),ptWorld.GetX());
  1118. double fMinY = min(m_ptBegin.GetY(),ptWorld.GetY());
  1119. double fMaxX = max(m_ptBegin.GetX(),ptWorld.GetX());
  1120. double fMaxY = max(m_ptBegin.GetY(),ptWorld.GetY());
  1121. CBoundaryRect bRect;
  1122. bRect.m_fMinX = fMinx;
  1123. bRect.m_fMinY = fMinY;
  1124. bRect.m_fMaxX = fMaxX;
  1125. bRect.m_fMaxY = fMaxY;
  1126. long lMinx,lMinY,lMaxX,lMaxY;
  1127. pCoordSys->WPtoLP(fMinx,fMinY,&lMinx,&lMinY);
  1128. pCoordSys->WPtoLP(fMaxX,fMaxY,&lMaxX,&lMaxY);
  1129. pDC->Rectangle(lMinx,lMinY,lMaxX,lMaxY);
  1130. pSM->RemoveAllSelObj();
  1132. if(m_nSelectType == QGIS_SELECT_UNKNOWN)
  1133. {
  1134. if(pMap->Select(pSM,pCoordSys,bRect))
  1135. {
  1136. pSM->BeginFlash((CWnd *)this,2,1000);
  1137. pSM->FlashObj(pCoordSys,this->GetSafeHwnd());
  1138. }
  1139. }
  1140. else if(m_nSelectType == QGIS_SELECT_POINT) //假如是选择点
  1141. {
  1142. if(pMap->Select(pSM,pCoordSys,bRect))
  1143. {
  1144. POSITION pos = pSM->GetHeadPosition();
  1145. CQSelObjManager * pTmSel = new CQSelObjManager;
  1146. CQBaseObj * pObj = pSM->GetHead();
  1147. while (pos)
  1148. {
  1149. CQBaseObj * pObj = pSM->GetNext(pos);
  1150. if(pObj && pObj->GetObjDeleted()!=TRUE && pObj->GetObjHided()!=TRUE && pObj->GetObjType()==QGIS_OBJ_POINT)
  1151. {
  1152. pObj->SetObjSelected(FALSE);
  1153. pTmSel->AddSelObj(pObj);
  1154. }
  1155. }
  1156. pSM->RemoveAllSelObj();
  1157. if(pTmSel->GetSelObjCount()>0)
  1158. {
  1159. POSITION pos_2 = pTmSel->GetHeadPosition();
  1160. while (pos_2)
  1161. {
  1162. CQBaseObj * pObj = pTmSel->GetNext(pos_2);
  1163. pObj->SetObjSelected(FALSE);
  1164. pSM->AddSelObj(pObj);
  1165. }
  1166. pTmSel->RemoveAllSelObj();
  1167. }
  1169. pSM->BeginFlash((CWnd *)this,2,1000);
  1170. pSM->FlashObj(pCoordSys,this->GetSafeHwnd());
  1171. delete pTmSel;
  1172. pTmSel = NULL;
  1173. }
  1174. }
  1175. }
  1176. m_nLbtDown = 0;
  1177. ReleaseCapture();
  1178. break;
  1179. }
  1180. default:
  1181. {
  1182. break;
  1183. }
  1184. }
  1185. CView::OnLButtonUp(nFlags, point);
  1186. }
  1188. void CQGISView::OnMouseMove(UINT nFlags, CPoint point) 
  1189. {
  1190. // TODO: Add your message handler code here and/or call default
  1191. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1192. ASSERT(pDoc);
  1193. CQMapObj * pMap = pDoc->m_pMap;
  1194. ASSERT(pMap);
  1196. CQSelObjManager * pSM = pMap->GetSelObjManager();
  1197. ASSERT(pSM);
  1199. CQCoordSys * pCoordSys = pMap->GetCoordSysPointer();
  1200. ASSERT(pCoordSys);
  1201. CDC * pDC = GetDC();
  1203. CPen pen(PS_SOLID,0,RGB(0,0,255));
  1204. CPen * pOldPen = pDC->SelectObject(&pen);
  1206. CQPoint ptWorld;
  1207. pCoordSys->LPtoWP(point,&ptWorld);
  1209. COLORREF cl = RGB(0,0,0);
  1211. ///////////////////////////////////////////////////////////
  1212. CStatusBar * pStatus = NULL;
  1213. CString szMapScale; //定义一个临时变量用于存储鼠标的坐标值 
  1214. CString szMousePos;
  1215. //获取状态栏的窗口指针
  1216. pStatus = (CStatusBar *)AfxGetApp()->m_pMainWnd->GetDescendantWindow(AFX_IDW_STATUS_BAR);
  1217. if(pStatus)
  1218. {
  1219. CString szMapUnit =  pCoordSys->GetUnitNameCHS();
  1220. const char * pchar = LPCTSTR(szMapUnit);
  1221. szMapScale.Format("当前地图比例尺1:%f",pMap->GetCoordSysPointer()->GetMapScale());
  1222. pStatus->SetPaneText(1,szMapScale);
  1223. szMousePos.Format("X  =%10.5f%s,Y  =%10.5f%s",ptWorld.GetX(),pchar,ptWorld.GetY(),pchar);
  1224. pStatus->SetPaneText(2,szMousePos);
  1225. }
  1226. ///////////////////////////////////////////////////////////
  1228. switch(pDoc->m_MenuItemID)
  1229. {
  1230. case IDM_MENU_ADD_LINE_QGIS: //当前是画线操作
  1231. {
  1233. if(m_nLbtDown>0)     //假如鼠标已经点击了
  1234. {
  1235. pDC->SetROP2(R2_NOT);
  1236. //设置为不填充状态
  1237. if(m_ptEnd != m_ptBegin)
  1238. {
  1239. pDC->MoveTo(GetBeginPos());
  1240. pDC->LineTo(GetEndPos());
  1241. }
  1242. m_ptEnd = ptWorld;
  1243. pDC->MoveTo(GetBeginPos());
  1244. pDC->LineTo(GetEndPos());
  1245. }
  1246. break;
  1247. }
  1248. case IDM_MENU_RECT_SELECT_OBJ_QGIS:
  1249. {
  1250. if(m_nLbtDown >0)
  1251. {
  1252. pDC->SetROP2(R2_NOT);
  1253. pDC->SelectStockObject(NULL_BRUSH);
  1254. CPoint ptBegin,ptOld;
  1255. pCoordSys->WPtoLP(m_ptBegin,&ptBegin);
  1256. if(m_ptOld != m_ptBegin)
  1257. {
  1258. pCoordSys->WPtoLP(m_ptOld,&ptOld);
  1259. long lMinx = min(ptBegin.x,ptOld.x);
  1260. long lMinY = min(ptBegin.y,ptOld.y);
  1261. long lMaxX = max(ptBegin.x,ptOld.x);
  1262. long lMaxY = max(ptBegin.y,ptOld.y);
  1263. pDC->Rectangle(lMinx,lMinY,lMaxX,lMaxY);
  1264. }
  1265. m_ptOld = ptWorld;
  1266. pCoordSys->WPtoLP(m_ptOld,&ptOld);
  1267. long lMinx = min(ptBegin.x,ptOld.x);
  1268. long lMinY = min(ptBegin.y,ptOld.y);
  1269. long lMaxX = max(ptBegin.x,ptOld.x);
  1270. long lMaxY = max(ptBegin.y,ptOld.y);
  1271. pDC->Rectangle(lMinx,lMinY,lMaxX,lMaxY);
  1272. break;
  1273. }
  1274. }
  1275. case IDM_MENU_ADD_POLYLINE:
  1276. {
  1277. if(m_nLbtDown>0)
  1278. {
  1279. if(m_ptOld != m_ptBegin)
  1280. {
  1281. pDC->SetROP2(R2_NOT);
  1282. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1283. pCoordSys->WPtoLP(m_ptOld,&m_ptLOld);
  1284. pDC->MoveTo(m_ptLBegin);
  1285. pDC->LineTo(m_ptLOld);
  1286. }
  1287. pDC->SetROP2(R2_NOT);
  1288. m_ptOld = ptWorld;
  1289. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1290. pCoordSys->WPtoLP(m_ptOld,&m_ptLOld);
  1291. pDC->MoveTo(m_ptLBegin);
  1292. pDC->LineTo(m_ptLOld);
  1293. }
  1294. break;
  1295. }
  1296. case IDM_MENU_MOVE_LINE_QGIS:
  1297. case IDM_MENU_MOVE_OBJ_QGIS:
  1298. {
  1299. if(m_nLbtDown>0)
  1300. {
  1301. CBoundaryRect BRect,bAllRect;
  1302. COLORREF cl = RGB(160,160,160);
  1303. if(m_ptOld != m_ptBegin)
  1304. {
  1305. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1306. pCoordSys->WPtoLP(m_ptOld,&m_ptLOld);
  1308. double dx = ptWorld.GetX() - m_ptOld.GetX();
  1309. double dy = ptWorld.GetY() - m_ptOld.GetY();
  1311. int nSelObj = pSM->GetSelObjCount();
  1312. POSITION pos = pSM->GetHeadPosition();
  1313. while (pos)
  1314. {
  1315. CQBaseObj * pObj = pSM->GetNext(pos);
  1316. if(pObj && !pObj->GetObjDeleted() && !pObj->GetObjHided())
  1317. {
  1318. pObj->Display(pCoordSys,pDC,R2_NOT,2,&cl);
  1319. pObj->Move(dx,dy);
  1320. pObj->Display(pCoordSys,pDC,R2_NOT,2,&cl);
  1321. }
  1322. }
  1324. pDC->SetROP2(R2_NOT);
  1325. pDC->MoveTo(m_ptLBegin);
  1326. pDC->LineTo(m_ptLOld);
  1327. }
  1328. m_ptOld = ptWorld;
  1329. pDC->SetROP2(R2_NOT);
  1330. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1331. pCoordSys->WPtoLP(m_ptOld,&m_ptLOld);
  1332. pDC->MoveTo(m_ptLBegin);
  1333. pDC->LineTo(m_ptLOld);
  1334. }
  1335. break;
  1336. }
  1337. case IDM_MENU_ROTATE_LINE_QGIS:
  1338. case IDM_MENU_ROTATE_OBJ_QGIS:
  1339. {
  1340. if(m_nLbtDown>0)
  1341. {
  1342. if(pSM->GetSelObjCount()<=0)break;
  1343. CObList tmSelObjs; 
  1344. POSITION pos = pSM->GetHeadPosition();
  1345. while (pos)
  1346. {
  1347. CQBaseObj * pObj = pSM->GetNext(pos);
  1348. if(!pObj) continue;
  1349. tmSelObjs.AddTail(pObj);
  1350. }
  1351.      pSM->EndFlash((CWnd *)this,2);
  1352. COLORREF cl = RGB(0,0,0);
  1354. // m_ptEnd = ptWorld;
  1355. pDC->SetROP2(R2_NOT);
  1356. if(m_ptOld != m_ptBegin)
  1357. {
  1358. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1359. pCoordSys->WPtoLP(m_ptOld,&m_ptLOld);
  1361. double fAngle1 = atan2(ptWorld.GetY()-m_ptBegin.GetY(),ptWorld.GetX()-m_ptBegin.GetX());
  1362. double fAngle2 = atan2(m_ptOld.GetY()-m_ptBegin.GetY(),m_ptOld.GetX()-m_ptBegin.GetX());
  1363. double fAngle = CQGISAlgorithmLib::RadianToDegree(fAngle1-fAngle2);
  1365. pos = tmSelObjs.GetHeadPosition();
  1366. while (pos)
  1367. {
  1368. CQBaseObj * pObj = (CQBaseObj *)tmSelObjs.GetNext(pos);
  1369. pObj->Display(pCoordSys,pDC,R2_NOT,2,&cl);
  1370. pObj->Rotate(m_ptBegin,fAngle);
  1371. pObj->Display(pCoordSys,pDC,R2_NOT,2,&cl);
  1372. }
  1375. pDC->MoveTo(m_ptLBegin);
  1376. pDC->LineTo(m_ptLOld);
  1377. }
  1378. m_ptOld = ptWorld;
  1379. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1380. pCoordSys->WPtoLP(m_ptOld,&m_ptLOld);
  1381. pDC->MoveTo(m_ptLBegin);
  1382. pDC->LineTo(m_ptLOld);
  1384. pos = tmSelObjs.GetHeadPosition();
  1385. while (pos)
  1386. {
  1387. CQBaseObj * pObj = (CQBaseObj *)tmSelObjs.GetNext(pos);
  1388. pSM->AddSelObj(pObj);
  1389. }
  1390. tmSelObjs.RemoveAll();
  1391. }
  1392. break;
  1393. }
  1394. case IDM_MENU_ADD_RECT_QGIS:
  1395. {
  1396. if(m_nLbtDown > 0)
  1397. {
  1398. CPoint pt1,pt2;
  1399. pDC->SetROP2(R2_NOT);
  1400. if(m_ptOld != m_ptBegin)
  1401. {
  1402. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1403. pCoordSys->WPtoLP(m_ptOld,&m_ptLOld);
  1404. pt1.x = m_ptLBegin.x;
  1405. pt1.y = m_ptLOld.y;
  1406. pt2.x = m_ptLOld.x;
  1407. pt2.y = m_ptLBegin.y;
  1408. pDC->MoveTo(m_ptLBegin);
  1409. pDC->LineTo(pt1);
  1410. pDC->LineTo(m_ptLOld);
  1411. pDC->LineTo(pt2);
  1412. pDC->LineTo(m_ptLBegin);
  1413. }
  1414. m_ptOld = ptWorld;
  1415. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1416. pCoordSys->WPtoLP(m_ptOld,&m_ptLOld);
  1417. pt1.x = m_ptLBegin.x;
  1418. pt1.y = m_ptLOld.y;
  1419. pt2.x = m_ptLOld.x;
  1420. pt2.y = m_ptLBegin.y;
  1421. pDC->MoveTo(m_ptLBegin);
  1422. pDC->LineTo(pt1);
  1423. pDC->LineTo(m_ptLOld);
  1424. pDC->LineTo(pt2);
  1425. pDC->LineTo(m_ptLBegin);
  1426. }
  1427. break;
  1428. }
  1429. case IDM_MENU_ADD_CIRCLE_QGIS:
  1430. {
  1431. if(m_nLbtDown == 1)
  1432. {
  1433. long lCr = 0;
  1434. double fR = 0;
  1435. CPen crpen(PS_DASH,0,RGB(0,0,255));
  1436. CPen * pOldPenCr = pDC->SelectObject(&crpen);
  1437. pDC->SelectStockObject(NULL_BRUSH);
  1438. if(m_ptOld != m_ptBegin)
  1439. {
  1440. pDC->SetROP2(R2_NOT);
  1441. lCr = (GetOldPos().x-GetBeginPos().x)*(GetOldPos().x-GetBeginPos().x) + 
  1442. (GetOldPos().y-GetBeginPos().y)*(GetOldPos().y-GetBeginPos().y);
  1443. lCr = static_cast<long>(sqrt(static_cast<double>(lCr)));
  1444. CPoint pt = GetBeginPos();
  1445. pDC->Ellipse(pt.x-lCr,pt.y-lCr,pt.x+lCr,pt.y+lCr);
  1446. }
  1447. m_ptOld = ptWorld;
  1448. pDC->SetROP2(R2_NOT);
  1449. lCr = (GetOldPos().x-GetBeginPos().x)*(GetOldPos().x-GetBeginPos().x) + 
  1450. (GetOldPos().y-GetBeginPos().y)*(GetOldPos().y-GetBeginPos().y);
  1451. lCr = static_cast<long>(sqrt(static_cast<double>(lCr)));
  1452. CPoint pt = GetBeginPos();
  1453. pDC->Ellipse(pt.x-lCr,pt.y-lCr,pt.x+lCr,pt.y+lCr);
  1454. pDC->SelectObject(pOldPenCr);
  1455. }
  1456. break;
  1457. }
  1458. case IDM_MENU_ADD_ELLIPSE_QGIS:
  1459. {
  1460. m_ptEnd = ptWorld;
  1462. if(m_nLbtDown==1)
  1463. {
  1464. pDC->SetROP2(R2_NOT);
  1465. pDC->MoveTo(GetBeginPos());
  1466. pDC->LineTo(GetOldPos());
  1467. pDC->MoveTo(GetBeginPos());
  1468. pDC->LineTo(GetEndPos());
  1469. }
  1470. else if(m_nLbtDown==2)
  1471. {
  1472. long lx=0,ly=0;
  1473. CQPoint ptCenter;
  1474. pDC->SetROP2(R2_NOT);
  1475. m_Ellipse.GetCenterPoint(ptCenter);
  1476. pCoordSys->WPtoLP(ptCenter.GetX(),ptCenter.GetY(),&lx,&ly);
  1477. pDC->MoveTo(lx,ly);
  1478. pDC->LineTo(GetOldPos());
  1479. pDC->MoveTo(lx,ly);
  1480. pDC->LineTo(GetEndPos());
  1482. //DrawEllipse(m_EllipsePara);
  1483. COLORREF cl = RGB(0,0,0);
  1484. DrawEllipse(m_Ellipse,pDC);
  1485. double dx = ptCenter.GetX() - ptWorld.GetX();
  1486. double dy = ptCenter.GetY() - ptWorld.GetY();
  1487. double fShortAxis = sqrt( dx*dx + dy*dy );//椭圆短轴
  1488. m_Ellipse.SetShortAxis(fShortAxis);
  1489. //DrawEllipse(m_EllipsePara);
  1490. DrawEllipse(m_Ellipse,pDC);
  1491. }
  1492. else
  1493. {
  1495. }
  1496. m_ptOld = ptWorld;
  1497. break;
  1499. }
  1500. case IDM_MENU_ADD_POLYLINE_STREAM:  //造流线
  1501. {
  1502. if(m_nLbtDown>0 && MK_LBUTTON && nFlags)
  1503. {
  1504. pDC->SetROP2(R2_NOT);
  1505. pDC->MoveTo(GetBeginPos());
  1506. pDC->LineTo(point);
  1507. m_ptBegin = ptWorld;
  1508. m_ptArray.AddPoint(ptWorld.GetX(),ptWorld.GetY());
  1509. m_nLbtDown++;
  1510. break;
  1511. }
  1512. }
  1513. case ID_MENU_MOVE_MAP:
  1514. {
  1515. if((m_ptOld!=ptWorld) && (nFlags&MK_LBUTTON) && m_nLbtDown==1)
  1516. {
  1517. long dx,dy;
  1518. dx=point.x-GetOldPos().x;
  1519. dy=point.y-GetOldPos().y;
  1520. pCoordSys->Translate(GetOldPos(),point);
  1521. ScrollWindow(dx,dy);
  1522. m_ptOld = ptWorld;
  1523. }
  1525. break;
  1526. }
  1527. case ID_MENU_ADD_HORI_LINE_QGIS: //水平线的操作
  1528. {
  1529. if(m_nLbtDown>0)
  1530. {
  1531. pDC->SetROP2(R2_NOT);
  1532. if(m_ptOld != m_ptBegin)
  1533. {
  1534. pDC->MoveTo(GetBeginPos().x,GetBeginPos().y);
  1535. pDC->LineTo(GetOldPos().x,GetBeginPos().y);
  1536. }
  1537. m_ptOld = ptWorld;
  1538. pDC->MoveTo(GetBeginPos().x,GetBeginPos().y);
  1539. pDC->LineTo(GetOldPos().x,GetBeginPos().y);
  1540. }
  1541. break;
  1542. }
  1543. case ID_MENU_ADD_VERVICAL_LINE_QGIS: // 对垂直线的操作
  1544. {
  1545. if(m_nLbtDown>0)
  1546. {
  1547. pDC->SetROP2(R2_NOT);
  1548. if(m_ptOld != m_ptBegin)
  1549. {
  1550. pDC->MoveTo(GetBeginPos().x,GetBeginPos().y);
  1551. pDC->LineTo(GetBeginPos().x,GetOldPos().y);
  1552. }
  1553. m_ptOld = ptWorld;
  1554. pDC->MoveTo(GetBeginPos().x,GetBeginPos().y);
  1555. pDC->LineTo(GetBeginPos().x,GetOldPos().y);
  1556. }
  1557. break;
  1558. }
  1559. default:
  1560. {
  1561. break;
  1562. }
  1563. }
  1565. pDC->SelectObject(pOldPen);
  1566. CView::OnMouseMove(nFlags, point);
  1567. }
  1569. void CQGISView::OnRButtonDown(UINT nFlags, CPoint point) 
  1570. {
  1571. // TODO: Add your message handler code here and/or call default
  1572. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1573. ASSERT(pDoc);
  1574. CQMapObj * pMap = pDoc->m_pMap;
  1575. ASSERT(pMap);
  1576. CQCoordSys * pCoordSys = pMap->GetCoordSysPointer();
  1577. ASSERT(pCoordSys);
  1578. CDC * pDC = GetDC();
  1579. CQSelObjManager * pSM = pMap->GetSelObjManager();
  1580. ASSERT(pSM);
  1582. CQPoint ptWorld;
  1583. pCoordSys->LPtoWP(point,&ptWorld);
  1585. switch(pDoc->m_MenuItemID)
  1586. {
  1587. case IDM_MENU_ADD_LINE_QGIS:
  1588. {
  1589. if(m_nLbtDown == 1)
  1590. {
  1591. pDC->SetROP2(R2_NOT);
  1592. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1593. pDC->MoveTo(m_ptLBegin);
  1594. pDC->LineTo(point);
  1595. m_ptArray.DeleteAll();
  1596. m_nLbtDown = 0;
  1597. ReleaseCapture();
  1598. }
  1599. break;
  1600. }
  1601. case IDM_MENU_ADD_POLYLINE:
  1602. {
  1603. if(m_nLbtDown == 1)
  1604. {
  1605. pDC->SetROP2(R2_NOT);
  1606. pCoordSys->WPtoLP(m_ptBegin,&m_ptLBegin);
  1607. pDC->MoveTo(m_ptLBegin);
  1608. pDC->LineTo(point);
  1609. m_ptArray.DeleteAll();
  1610. m_nLbtDown = 0;
  1611. ReleaseCapture();
  1612. }
  1613. else
  1614. {
  1615. CQLineObj * pLine = new CQLineObj;
  1616. pLine->m_PtList.Copy(m_ptArray);
  1617. pLine->SetObjLayerID(pMap->GetCurLayer()->GetLayerID());
  1618. pLine->SetObjMapID(pMap->GetMapID());
  1620. if(pLine && pLine->m_PtList.GetSize()>1)
  1621. {
  1622. CBoundaryRect BRect;
  1623. pLine->CalculateBoundary(&BRect);
  1624. pMap->AddObject(pLine);
  1625. CRect rect;
  1626. pCoordSys->WPtoLP(BRect,&rect);
  1627. rect.left = min(rect.left,point.x);
  1628. rect.top = min(rect.top,point.y);
  1629. rect.right = max(rect.right,point.x);
  1630. rect.bottom = max(rect.bottom,point.y);
  1631. InvalidateRect(rect);
  1632. m_nLbtDown = 0;
  1633. ReleaseCapture();
  1634. }
  1635. }
  1636. m_nLbtDown = 0;
  1637. break;
  1638. }
  1639. case IDM_MENU_MOVE_LINE_QGIS:
  1640. case IDM_MENU_MOVE_OBJ_QGIS: //移动对象在点击右键后结束
  1641. {
  1642. m_nLbtDown = 0;
  1643. if(pSM->GetSelObjCount()>0)
  1644. pSM->EndFlash((CWnd *)this,2);
  1645. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  1646. ReleaseCapture();
  1647. break;
  1648. }
  1649. case IDM_MENU_ROTATE_LINE_QGIS:
  1650. case IDM_MENU_ROTATE_OBJ_QGIS: //移动对象的操作
  1651. {
  1652. m_nLbtDown = 0;
  1653. if(pSM->GetSelObjCount()>0)
  1654. pSM->EndFlash((CWnd *)this,2);
  1655. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  1656. ReleaseCapture();
  1657. break;
  1658. }
  1659. case IDM_MENU_ADD_CIRCLE_QGIS:
  1660. {
  1661. if(m_nLbtDown == 1) //假如单击了一次后不想再 画了 
  1662. {
  1663. m_nLbtDown = 0;
  1664. ReleaseCapture();
  1665. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  1666. m_ptOld = ptWorld;
  1667. pDC->SetROP2(R2_NOT);
  1668. pDC->SelectStockObject(NULL_BRUSH);
  1669. long lCr = (GetOldPos().x-GetBeginPos().x)*(GetOldPos().x-GetBeginPos().x) + 
  1670. (GetOldPos().y-GetBeginPos().y)*(GetOldPos().y-GetBeginPos().y);
  1671. lCr = static_cast<long>(sqrt(static_cast<double>(lCr)));
  1672. CPoint pt = GetBeginPos();
  1673. pDC->Ellipse(pt.x-lCr,pt.y-lCr,pt.x+lCr,pt.y+lCr);
  1674. }
  1675. break;
  1676. }
  1677. case IDM_MENU_ADD_ELLIPSE_QGIS:  //绘制椭圆形时的操作
  1678. {
  1679. if(m_nLbtDown == 1)  //假如单击了一次就不想画了 
  1680. {
  1681. m_nLbtDown = 0;  //结束鼠标输入
  1682. ReleaseCapture(); //释放鼠标捕捉
  1683. pDC->SetROP2(R2_NOT);
  1684. pDC->MoveTo(GetBeginPos());
  1685. pDC->LineTo(point);
  1686. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  1687. }
  1688. else if(m_nLbtDown == 2) // 如果鼠标单击了两次
  1689. {
  1690. //就要绘制一个椭圆
  1691. pDC->SetROP2(R2_NOT);
  1692. CQEllipseObj tmEllipse;
  1693. tmEllipse.Copy(m_Ellipse);// 设置临时椭圆对象的参数
  1694. DrawEllipse(tmEllipse,pDC);
  1696. CPoint ptTemp;
  1697. pCoordSys->WPtoLP(ptCenter,&ptTemp);
  1698. pDC->MoveTo(ptTemp);
  1699. pDC->LineTo(point);
  1701. m_nLbtDown = 0;
  1702. ReleaseCapture();
  1703. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  1704. }
  1705. break;
  1706. }
  1707. case IDM_MENU_LINK_POINT_TO_LINE_QGIS:  //连点成线
  1708. {
  1709. if(m_nLbtDown == 0)
  1710. {
  1711. ReleaseCapture();
  1712. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  1713. break;
  1714. }
  1715. else
  1716. {
  1717. int nptSize = m_vecObj.size();
  1718. if(nptSize>=2)
  1719. {
  1720. BOOL bCreated = TRUE;
  1721. CQLineObj * pNewLine = new CQLineObj;
  1722. for(int i=0;i<nptSize;i++)
  1723. {
  1724. CQPointObj * pPt = dynamic_cast<CQPointObj *>(m_vecObj.at(i));
  1725. if(pPt == NULL)
  1726. {
  1727. bCreated = FALSE;
  1728. break;
  1729. }
  1730. else
  1731. {
  1732. double dx=0.0f,dy=0.0f;
  1733. pPt->GetPointPos(dx,dy);
  1734. pNewLine->m_PtList.AddPoint(dx,dy);
  1735. }
  1736. }
  1738. if(bCreated == FALSE)
  1739. {
  1740. delete pNewLine;
  1741. pNewLine = NULL;
  1742. }
  1743. else
  1744. {
  1745. pNewLine->SetObjName(CString("连点成线对象"));
  1746. CBoundaryRect bRect;
  1747. pNewLine->CalculateBoundary(&bRect);
  1748. CRect rectLine;
  1749. pCoordSys->WPtoLP(bRect,&rectLine);
  1750. pMap->AddObject(pNewLine);
  1751. InvalidateRect(rectLine,FALSE);
  1752. }
  1753. }
  1755. m_nLbtDown = 0;
  1756. ReleaseCapture();
  1757. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  1758. m_vecObj.clear();
  1759. break;
  1760. }
  1761. }
  1762. case ID_MENU_ADD_HORI_LINE_QGIS: //水平线
  1763. {
  1764. if(m_nLbtDown == 1)
  1765. {
  1766. //假如在画线的过程想要结束
  1767. ReleaseCapture();
  1768. m_nLbtDown = 0;
  1769. CRect rect;
  1770. rect.left = GetBeginPos().x - 1;
  1771. rect.top = GetBeginPos().y - 1;
  1772. rect.right = point.x + 2;
  1773. rect.bottom = GetBeginPos().y + 1;
  1774. InvalidateRect(rect,TRUE);
  1775. }
  1776. break;
  1777. }
  1778. case ID_MENU_ADD_VERVICAL_LINE_QGIS:
  1779. {
  1780. if(m_nLbtDown == 1)
  1781. {
  1782. ReleaseCapture();
  1783. m_nLbtDown = 0;
  1784. CRect rect;
  1785. rect.left = GetBeginPos().x - 1;
  1786. rect.top = GetBeginPos().y - 1;
  1787. rect.right = GetOldPos().x + 1;
  1788. rect.bottom = GetOldPos().y +1;
  1789. InvalidateRect(rect,TRUE);
  1790. }
  1791. break;
  1792. }
  1793. case ID_MENU_ADD_TEXT_QGIS:
  1794. {
  1795. m_nLbtDown = 0;
  1796. pDoc->m_MenuItemID = 0;
  1797. break;
  1798. }
  1799. }
  1801. CView::OnRButtonDown(nFlags, point);
  1802. }
  1804. void CQGISView::OnCancelMode() 
  1805. {
  1806. CView::OnCancelMode();
  1808. // TODO: Add your message handler code here
  1810. }
  1812. void CQGISView::OnMenuAddLineQgis() 
  1813. {
  1814. // TODO: Add your command handler code here
  1815. CQGISDoc * pDoc = GetDocument(); //获取文档指针
  1816. ASSERT(pDoc);
  1817. pDoc->m_MenuItemID = IDM_MENU_ADD_LINE_QGIS;
  1818. m_nLbtDown = 0;
  1819. }
  1821. void CQGISView::OnMenuAddPointQgis() 
  1822. {
  1823. // TODO: Add your command handler code here
  1824. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1825. ASSERT(pDoc);
  1826. pDoc->m_MenuItemID = IDM_MENU_ADD_POINT_QGIS;
  1827. m_nLbtDown = 0;
  1828. }
  1830. BOOL CQGISView::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1831. {
  1832. // TODO: Add your message handler code here and/or call default
  1833. CQGISDoc * pDoc = GetDocument();
  1834. ASSERT(pDoc);
  1835. if(pDoc->m_MenuItemID == IDM_MENU_ADD_POINT_QGIS ||
  1836. pDoc->m_MenuItemID == IDM_MENU_ADD_LINE_QGIS ||
  1837. pDoc->m_MenuItemID == IDM_MENU_PT_SELECT_OBJ_QGIS ||
  1838. pDoc->m_MenuItemID == IDM_MENU_RECT_SELECT_OBJ_QGIS ||
  1839. pDoc->m_MenuItemID == IDM_MENU_ADD_POLYLINE ||
  1840. pDoc->m_MenuItemID == IDM_MENU_CUT_LINE_QGIS ||
  1841. pDoc->m_MenuItemID == IDM_MENU_MIRROR_LINE_X_QGIS ||
  1842. pDoc->m_MenuItemID == IDM_MENU_MIRROR_LINE_Y_QGIS ||
  1843. pDoc->m_MenuItemID == IDM_MENU_MIRROR_O_QGIS || 
  1844. pDoc->m_MenuItemID == ID_MENU_ADD_VERVICAL_LINE_QGIS ||
  1845. pDoc->m_MenuItemID == ID_MENU_ADD_HORI_LINE_QGIS ||
  1846. pDoc->m_MenuItemID == IDM_MENU_ADD_LINE_QGIS ||
  1847. pDoc->m_MenuItemID == ID_MENU_ADD_TEXT_QGIS ||
  1848. pDoc->m_MenuItemID == ID_MENU_READ_EXCEL_QGIS)
  1849. {
  1850. HCURSOR hCursor;
  1851. //测试中发现 替换为LoadCursor就无法显示 
  1852. //得出结论 Loadcursor针对自定义的光标资源
  1853. hCursor = AfxGetApp()->LoadStandardCursor(IDC_CROSS);
  1854. SetCursor(hCursor);
  1855. ShowCursor(TRUE);
  1856. return TRUE;
  1857. }
  1858. else if(pDoc->m_MenuItemID == ID_MENU_MOVE_MAP)
  1859. {
  1860. HCURSOR hCursor;
  1861. hCursor = AfxGetApp()->LoadCursor(IDC_CURSOR_MOVE_MAP);
  1862. SetCursor(hCursor);
  1863. ShowCursor(TRUE);
  1864. return TRUE;
  1865. }
  1866. else
  1867. {
  1868. HCURSOR hCursor;
  1869. hCursor = AfxGetApp()->LoadStandardCursor(IDC_ARROW);
  1870. SetCursor(hCursor);
  1871. ShowCursor(TRUE);
  1872. return TRUE;
  1873. }
  1874. return CView::OnSetCursor(pWnd,nHitTest,message);
  1875. }
  1877. void CQGISView::OnMenuSetMapAtt() 
  1878. {
  1879. // TODO: Add your command handler code here
  1880. CDlgMapAttSet dlg;
  1881. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1882. CQMapObj * pMap = pDoc->m_pMap;
  1883. if(!pMap)return;
  1885. if(dlg.DoModal() == IDOK)
  1886. {
  1887. CQCoordSys * pSys = pMap->GetCoordSysPointer();
  1888. double fMapScale = dlg.m_lMapScale;
  1889. pSys->SetMapScale(fMapScale);
  1890. pSys->SetUnitType(dlg.m_nUnitType);
  1891. pMap->GetBoundary()->m_fMinX = dlg.m_fLeftX;
  1892. pMap->GetBoundary()->m_fMinY = dlg.m_fLeftY;
  1893. pMap->GetBoundary()->m_fMaxX = dlg.m_fRightX;
  1894. pMap->GetBoundary()->m_fMaxY = dlg.m_fRightY;
  1895. pSys->SetViewportOrg(static_cast<long>(dlg.m_fLeftX),static_cast<long>(dlg.m_fLeftY));
  1896. }
  1897. }
  1899. void CQGISView::OnSize(UINT nType, int cx, int cy) 
  1900. {
  1901. CView::OnSize(nType, cx, cy);
  1903. // TODO: Add your message handler code here
  1904. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1905. CQMapObj * pMap = pDoc->m_pMap;
  1906. ASSERT(pMap);
  1907. pMap->GetCoordSysPointer()->SetViewport(0,0,cx,cy);
  1908. pMap->GetCoordSysPointer()->SetWndport(0,0,cx,cy);
  1909. pMap->GetCoordSysPointer()->SetStartOfWnd(10,cy-10);
  1910. }
  1912. CPoint CQGISView::GetBeginPos() 
  1913. {
  1914. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1915. CQMapObj * pMap = pDoc->m_pMap;
  1916. CQCoordSys * pSys = pMap->GetCoordSysPointer();
  1917. ASSERT(pSys);
  1919. CPoint ptBegin;
  1920. pSys->WPtoLP(m_ptBegin,&ptBegin);
  1921. return ptBegin;
  1922. }
  1924. CPoint CQGISView::GetOldPos() 
  1925. {
  1926. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1927. CQMapObj * pMap = pDoc->m_pMap;
  1928. CQCoordSys * pSys = pMap->GetCoordSysPointer();
  1929. ASSERT(pSys);
  1931. CPoint ptOld;
  1932. pSys->WPtoLP(m_ptOld,&ptOld);
  1933. return ptOld;
  1934. }
  1936. CPoint CQGISView::GetEndPos() 
  1937. {
  1938. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1939. CQMapObj * pMap = pDoc->m_pMap;
  1940. CQCoordSys * pSys = pMap->GetCoordSysPointer();
  1941. ASSERT(pSys);
  1943. CPoint ptEnd;
  1944. pSys->WPtoLP(m_ptEnd,&ptEnd);
  1945. return ptEnd;
  1946. }
  1948. CQPoint CQGISView::GetwBeginPos()
  1949. {
  1950. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1951. CQMapObj * pMap = pDoc->m_pMap;
  1952. CQCoordSys * pSys = pMap->GetCoordSysPointer();
  1953. ASSERT(pSys);
  1955. CQPoint ptwBegin;
  1956. pSys->LPtoWP(m_ptLBegin,&ptwBegin);
  1957. return ptwBegin;
  1958. }
  1960. CQPoint CQGISView::GetWOldPos()
  1961. {
  1962. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1963. CQMapObj * pMap = pDoc->m_pMap;
  1964. CQCoordSys * pSys = pMap->GetCoordSysPointer();
  1965. ASSERT(pSys);
  1967. CQPoint ptwBegin;
  1968. pSys->LPtoWP(m_ptLBegin,&ptwBegin);
  1969. return ptwBegin;
  1970. }
  1972. CQPoint CQGISView::GetWEndPos()
  1973. {
  1974. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1975. CQMapObj * pMap = pDoc->m_pMap;
  1976. CQCoordSys * pSys = pMap->GetCoordSysPointer();
  1977. ASSERT(pSys);
  1979. CQPoint ptwEnd;
  1980. pSys->LPtoWP(m_ptLBegin,&ptwEnd);
  1981. return ptwEnd;
  1982. }
  1984. void CQGISView::OnMenuPtSelectObjQgis() 
  1985. {
  1986. // TODO: Add your command handler code here
  1987. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1988. pDoc->m_MenuItemID = IDM_MENU_PT_SELECT_OBJ_QGIS;
  1989. m_nLbtDown = 0;
  1990. pDoc->m_pMap->GetSelObjManager()->BeginFlash((CWnd*)this,2,1000);
  1991. }
  1993. void CQGISView::OnTimer(UINT nIDEvent) 
  1994. {
  1995. // TODO: Add your message handler code here and/or call default
  1996. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  1997. ASSERT(pDoc);
  1998. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  1999. ASSERT(pSel);
  2001. if(pSel->GetSelObjCount()>0)
  2002. {
  2003. pSel->FlashObj(pDoc->m_pMap->GetCoordSysPointer(),this->GetSafeHwnd());
  2004. }
  2006. CView::OnTimer(nIDEvent);
  2007. }
  2009. //放弃选中
  2010. void CQGISView::OnMenuUselectObjQgis() 
  2011. {
  2012. // TODO: Add your command handler code here
  2013. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2014. ASSERT(pDoc);
  2015. CQMapObj * pMap = pDoc->m_pMap;
  2016. ASSERT(pMap);
  2018. CRect rectTemp;
  2019. pMap->GetSelObjManager()->GetScreenRect(pMap->GetCoordSysPointer(),rectTemp);
  2020. pMap->GetSelObjManager()->RemoveAllSelObj(); //除去所有选中图元
  2021. pMap->GetSelObjManager()->EndFlash(this->GetSafeHwnd(),2);
  2022. InvalidateRect(rectTemp,TRUE);
  2023. m_nSelectType = QGIS_SELECT_UNKNOWN;
  2024. }
  2026. void CQGISView::OnMenuLineAttSet() 
  2027. {
  2028. // TODO: Add your command handler code here
  2029. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2030. ASSERT(pDoc);
  2032. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2033. ASSERT(pSel);
  2035. CQCoordSys * pSys = pDoc->m_pMap->GetCoordSysPointer();
  2036. ASSERT(pSys);
  2038. CQLayerObj * pCurLayer = pDoc->m_pMap->GetCurLayer();
  2039. ASSERT(pCurLayer);
  2041. CQBaseObj * pObj = pSel->GetCurSelObj();
  2042. if(pObj->GetObjType() != QGIS_OBJ_LINE)
  2043. return;
  2044. CDlgLineAttSet dlg(pCurLayer,1,(CQLineObj*)pObj);
  2045. if(dlg.DoModal() == IDOK)
  2046. {
  2047. CQLineObj * ppObj = (CQLineObj *)pCurLayer->FindObj(pObj->GetObjID());
  2048. short nObjLineType = dlg.m_nLineStyle;
  2049. ppObj->SetobjLineType(nObjLineType);
  2050. ppObj->SetObjLineWidth(dlg.m_fLineWidth);
  2051. ppObj->SetObjPenColor(dlg.m_crLine);
  2052. ppObj->SetLineClosed(dlg.m_nLineClosed);
  2053. ppObj->SetShowPointFlag(dlg.m_bLineShowPt);
  2054. CBoundaryRect Brect;
  2055. ppObj->CalculateBoundary(&Brect);
  2056. CRect rect;
  2057. pSys->WPtoLP(Brect,&rect);
  2058. InvalidateRect(rect);
  2059. }
  2060. }
  2062. void CQGISView::OnUpdateMenuLineAttSet(CCmdUI* pCmdUI) 
  2063. {
  2064. // TODO: Add your command update UI handler code here
  2065. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2066. ASSERT(pDoc);
  2068. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2069. ASSERT(pSel);
  2071. int nSel = pSel->GetSelObjCount();
  2072. if(nSel == 0) 
  2073. {
  2074. pCmdUI->Enable(FALSE);
  2075. return;
  2076. }
  2078. CQBaseObj * pObj = pSel->GetCurSelObj();
  2079. if(pObj->GetObjType() == QGIS_OBJ_LINE && nSel == 1)
  2080. pCmdUI->Enable(TRUE);
  2081. else
  2082. pCmdUI->Enable(FALSE);
  2083. }
  2085. void CQGISView::OnMenuRectSelectObjQgis() 
  2086. {
  2087. // TODO: Add your command handler code here
  2088. CQGISDoc * pDoc = (CQGISDoc*)GetDocument();
  2089. pDoc->m_MenuItemID = IDM_MENU_RECT_SELECT_OBJ_QGIS;
  2090. m_nLbtDown = 0;
  2091. pDoc->m_pMap->GetSelObjManager()->BeginFlash((CWnd*)this,2,1000);
  2092. }
  2094. void CQGISView::OnMenuDeleteObjQgis() 
  2095. {
  2096. // TODO: Add your command handler code here
  2097. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2098. ASSERT(pDoc);
  2100. CQSelObjManager * pSM = pDoc->m_pMap->GetSelObjManager();
  2101. ASSERT(pSM);
  2103. CQMapObj * pMap = pDoc->m_pMap;
  2104. ASSERT(pMap);
  2106. if(pSM->GetSelObjCount()>0)
  2107. {
  2108. //  int nLayercount = pDoc->m_pMap->GetLayerCount();
  2109. //  for(int i=0;i<nLayercount;i++)
  2110. //  {
  2111. //  CQLayerObj * pLayer = pMap->GetLayer(i);
  2112. //  if(pLayer && pLayer->GetShowFlag() && !pLayer->GetDeleteFlag())
  2113. //  {
  2114. //  int nObjCount = pLayer->GetObjCount();
  2115. //  for(int j=0;j<nObjCount;j++)
  2116. //  {
  2117. //  CQBaseObj * pObj = pLayer->GetObj(j);
  2118. //  if(pObj && !pObj->GetObjDeleted() && !pObj->GetObjHided())
  2119. //  {
  2120. //  POSITION pos = pSM->GetHeadPosition();
  2121. //  while (pos)
  2122. //  {
  2123. //  CQBaseObj * psmObj = pSM->GetNext(pos);
  2124. //  if(psmObj->GetObjID() == pObj->GetObjID())
  2125. //  {
  2126. //  pObj->SetObjDeleted(TRUE);
  2127. //  }
  2128. //  }
  2129. //  }
  2130. //  }
  2131. //  }
  2132. // }
  2133. POSITION pos = pSM->GetHeadPosition();
  2134. while(pos)
  2135. {
  2136. CQBaseObj * pObj = pSM->GetNext(pos);
  2137. pObj->SetObjDeleted(TRUE);
  2138. }
  2140. CRect rectTemp;
  2141. pMap->GetSelObjManager()->GetScreenRect(pMap->GetCoordSysPointer(),rectTemp);
  2142. pMap->GetSelObjManager()->RemoveAllSelObj(); //除去所有选中图元
  2143. InvalidateRect(rectTemp);
  2144. pMap->GetSelObjManager()->EndFlash(this->GetSafeHwnd(),2);
  2146. }
  2148. }
  2150. //添加折线对象
  2151. void CQGISView::OnMenuAddPolyline() 
  2152. {
  2153. // TODO: Add your command handler code here
  2154. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2155. ASSERT(pDoc);
  2157. pDoc->m_MenuItemID = IDM_MENU_ADD_POLYLINE;
  2158. m_nLbtDown=0;
  2159. }
  2161. void CQGISView::OnEditButtonArrow() 
  2162. {
  2163. // TODO: Add your command handler code here
  2164. CQGISDoc * pDoc = (CQGISDoc*)GetDocument();
  2165. pDoc->m_MenuItemID = ID_EDIT_BUTTON_ARROW;
  2166. m_nLbtDown = 0;
  2167. }
  2169. void CQGISView::OnMenuMoveObjQgis() 
  2170. {
  2171. // TODO: Add your command handler code here
  2172. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2173. ASSERT(pDoc);
  2175. pDoc->m_MenuItemID = IDM_MENU_MOVE_OBJ_QGIS;
  2176. m_nLbtDown = 0;
  2177. }
  2179. void CQGISView::OnUpdateMenuMoveObjQgis(CCmdUI* pCmdUI) 
  2180. {
  2181. // TODO: Add your command update UI handler code here
  2182. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2183. ASSERT(pDoc);
  2185. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2186. ASSERT(pSel);
  2188. int nSel = pSel->GetSelObjCount();
  2189. if(nSel == 0) 
  2190. {
  2191. pCmdUI->Enable(FALSE);
  2192. return;
  2193. }
  2195. pCmdUI->Enable(TRUE);
  2196. }
  2198. void CQGISView::OnMenuHideObjQgis() 
  2199. {
  2200. // TODO: Add your command handler code here
  2201. CQGISDoc * pDoc  = (CQGISDoc *)GetDocument();
  2202. ASSERT(pDoc);
  2203. CQSelObjManager * pSM = pDoc->m_pMap->GetSelObjManager();
  2204. ASSERT(pSM);
  2206. int nSelCount = pSM->GetCount();
  2207. if(nSelCount == 0)return;
  2208. POSITION pos = pSM->GetHeadPosition();
  2209. while (pos)
  2210. {
  2211. CQBaseObj * pObj = pSM->GetNext(pos);
  2212. if(!pObj || pObj->GetObjDeleted() || pObj->GetObjHided()) continue;
  2213. pObj->SetObjHided(TRUE);
  2214. }
  2215. InvalidateRect(NULL,FALSE);
  2216. pSM->EndFlash((CWnd *)this,2);
  2217. }
  2219. void CQGISView::OnUpdateMenuHideObjQgis(CCmdUI* pCmdUI) 
  2220. {
  2221. // TODO: Add your command update UI handler code here
  2222. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2223. ASSERT(pDoc);
  2224. int nSel = pDoc->m_pMap->GetSelObjManager()->GetSelObjCount();
  2225. if(nSel)
  2226. pCmdUI->Enable(TRUE);
  2227. else
  2228. pCmdUI->Enable(FALSE);
  2229. }
  2231. void CQGISView::OnMenuShowObjQgis() 
  2232. {
  2233. // TODO: Add your command handler code here
  2234. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2235. ASSERT(pDoc);
  2237. CQMapObj * pMap = pDoc->m_pMap;
  2238. ASSERT(pMap);
  2240. int nLayerCount = pMap->GetLayerCount();
  2241. for(int i=0;i<nLayerCount;i++)
  2242. {
  2243. CQLayerObj * pLayer = pMap->GetLayer(i);
  2244. if(!pLayer || pLayer->GetDeleteFlag() || !pLayer->GetShowFlag()) continue;
  2245. int nObjCount = pLayer->GetObjCount();
  2246. for(int j=0;j<nObjCount;j++)
  2247. {
  2248. CQBaseObj * pObj = pLayer->GetObj(j);
  2249. if(!pObj || pObj->GetObjDeleted() || !pObj->GetObjHided()) continue;
  2250. pObj->SetObjHided(FALSE);
  2251. }
  2252. }
  2253. InvalidateRect(NULL,FALSE);
  2254. }
  2257. void CQGISView::OnMenuRotateObjQgis() 
  2258. {
  2259. // TODO: Add your command handler code here
  2260. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2261. ASSERT(pDoc);
  2263. pDoc->m_MenuItemID = IDM_MENU_ROTATE_OBJ_QGIS;
  2264. m_nLbtDown = 0;
  2265. }
  2267. void CQGISView::OnUpdateMenuRotateObjQgis(CCmdUI* pCmdUI) 
  2268. {
  2269. // TODO: Add your command update UI handler code here
  2270. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2271. ASSERT(pDoc);
  2272. int nSel = pDoc->m_pMap->GetSelObjManager()->GetSelObjCount();
  2273. if(nSel)
  2274. pCmdUI->Enable(TRUE);
  2275. else
  2276. pCmdUI->Enable(FALSE);
  2277. }
  2281. void CQGISView::OnMenuCutLineQgis() 
  2282. {
  2283. // TODO: Add your command handler code here
  2284. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2285. ASSERT(pDoc);
  2286. pDoc->m_MenuItemID = IDM_MENU_CUT_LINE_QGIS; //剪断线
  2287. m_nLbtDown = 0;
  2288. }
  2290. void CQGISView::OnUpdateMenuCutLineQgis(CCmdUI* pCmdUI) 
  2291. {
  2292. // TODO: Add your command update UI handler code here
  2293. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2294. ASSERT(pDoc);
  2295. int nSel = pDoc->m_pMap->GetSelObjManager()->GetSelObjCount();
  2297. if(nSel == 1 && pDoc->m_pMap->GetSelObjManager()->GetCurSelObj()->GetObjType() == QGIS_OBJ_LINE)
  2298. pCmdUI->Enable(TRUE);
  2299. else
  2300. pCmdUI->Enable(FALSE);
  2302. }
  2304. void CQGISView::FindNearestTwoPoints(int &nFirst,CQPoint *pPt, CQLineObj *pLine)
  2305. {
  2306. if(!pLine || !pPt)return;
  2307. int nPtCount = pLine->m_PtList.GetSize();
  2308. if(nPtCount <=1 )return;
  2309. else   //这里要使用排序算法
  2310. {
  2311. vector<double> dDis;
  2312. CQPoint * ptf = NULL;
  2313. for(int i=0;i<nPtCount;i++)
  2314. {
  2315. ptf = pLine->m_PtList.GetPoint(i);
  2316. double fDis = pPt->Distance(*ptf);
  2317. dDis.push_back(fDis);  //将到每个点的距离都保存起来  进行排序
  2318. }
  2319. double fMin = dDis[0];
  2320. nFirst = 0;
  2321. for(int m=0;m<nPtCount;m++)
  2322. {
  2323. double fd = dDis[m];
  2324. if(fd<=fMin)
  2325. {
  2326. fMin = fd;
  2327. nFirst = m;
  2328. }
  2329. }
  2330. }
  2331. }
  2333. void CQGISView::OnMenuDeleteLineQgis() 
  2334. {
  2335. // TODO: Add your command handler code here
  2336. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2337. ASSERT(pDoc);
  2338. CQSelObjManager * pSM = pDoc->m_pMap->GetSelObjManager();
  2339. ASSERT(pSM);
  2341. int nSelCount = pSM->GetSelObjCount();
  2342. POSITION pos = pSM->GetHeadPosition();
  2343. while (pos)
  2344. {
  2345. CQBaseObj * pObj = pSM->GetNext(pos);
  2346. if(pObj && !pObj->GetObjDeleted() && !pObj->GetObjHided())
  2347. {
  2348. pObj->SetObjDeleted(TRUE);
  2349. }
  2350. }
  2352. pSM->EndFlash((CWnd *)this,2);
  2353. InvalidateRect(NULL,TRUE);
  2354. }
  2356. void CQGISView::OnUpdateMenuDeleteLineQgis(CCmdUI* pCmdUI) 
  2357. {
  2358. // TODO: Add your command update UI handler code here
  2359. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2360. CQSelObjManager * pSM = pDoc->m_pMap->GetSelObjManager();
  2361. int nSelObj = pSM->GetSelObjCount();
  2362. BOOL bTrue = TRUE;
  2363. POSITION pos = pSM->GetHeadPosition();
  2364. while (pos)
  2365. {
  2366. CQBaseObj * pObj = (CQBaseObj *)pSM->GetNext(pos);
  2367. if(pObj->GetObjType() == QGIS_OBJ_POINT)
  2368. {
  2369. bTrue = FALSE;
  2370. break;
  2371. }
  2372. }
  2373. pCmdUI->Enable(bTrue);
  2374. }
  2376. void CQGISView::OnMenuMoveLineQgis() 
  2377. {
  2378. // TODO: Add your command handler code here
  2379. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2380. pDoc->m_MenuItemID = IDM_MENU_MOVE_LINE_QGIS;
  2381. m_nLbtDown = 0;
  2382. }
  2384. void CQGISView::OnUpdateMenuMoveLineQgis(CCmdUI* pCmdUI) 
  2385. {
  2386. // TODO: Add your command update UI handler code here
  2387. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2388. CQSelObjManager * pSM = pDoc->m_pMap->GetSelObjManager();
  2389. int nSelObj = pSM->GetSelObjCount();
  2390. BOOL bTrue = TRUE;
  2391. POSITION pos = pSM->GetHeadPosition();
  2392. while (pos)
  2393. {
  2394. CQBaseObj * pObj = (CQBaseObj *)pSM->GetNext(pos);
  2395. if(pObj->GetObjType() == QGIS_OBJ_POINT)
  2396. {
  2397. bTrue = FALSE;
  2398. break;
  2399. }
  2400. }
  2401. pCmdUI->Enable(bTrue);
  2402. }
  2404. void CQGISView::OnUpdateMenuRotateLineQgis(CCmdUI* pCmdUI) 
  2405. {
  2406. // TODO: Add your command update UI handler code here
  2407. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2408. CQSelObjManager * pSM = pDoc->m_pMap->GetSelObjManager();
  2409. int nSelObj = pSM->GetSelObjCount();
  2410. BOOL bTrue = TRUE;
  2411. POSITION pos = pSM->GetHeadPosition();
  2412. while (pos)
  2413. {
  2414. CQBaseObj * pObj = (CQBaseObj *)pSM->GetNext(pos);
  2415. if(pObj->GetObjType() == QGIS_OBJ_POINT)
  2416. {
  2417. bTrue = FALSE;
  2418. break;
  2419. }
  2420. }
  2421. pCmdUI->Enable(bTrue);
  2422. }
  2424. void CQGISView::OnMenuRotateLineQgis() 
  2425. {
  2426. // TODO: Add your command handler code here
  2427. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2428. pDoc->m_MenuItemID = IDM_MENU_ROTATE_LINE_QGIS;
  2429. m_nLbtDown = 0;
  2430. }
  2432. void CQGISView::OnMenuLinkLineQgis() 
  2433. {
  2434. // TODO: Add your command handler code here
  2435. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2436. pDoc->m_MenuItemID = IDM_MENU_LINK_LINE_QGIS_;
  2437. m_nLbtDown = 0;
  2438. }
  2440. void CQGISView::OnMenuMirrorLineXQgis() 
  2441. {
  2442. // TODO: Add your command handler code here
  2443. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2444. pDoc->m_MenuItemID = IDM_MENU_MIRROR_LINE_X_QGIS;
  2445. m_nLbtDown = 0;
  2446. }
  2448. void CQGISView::OnMenuMirrorLineYQgis() 
  2449. {
  2450. // TODO: Add your command handler code here
  2451. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2452. pDoc->m_MenuItemID = IDM_MENU_MIRROR_LINE_Y_QGIS;
  2453. m_nLbtDown = 0;
  2454. }
  2456. void CQGISView::OnMenuMirrorOQgis() 
  2457. {
  2458. // TODO: Add your command handler code here
  2459. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2460. pDoc->m_MenuItemID = IDM_MENU_MIRROR_O_QGIS;
  2461. m_nLbtDown = 0;
  2462. }
  2464. //添加矩形
  2465. void CQGISView::OnMenuAddRectQgis() 
  2466. {
  2467. // TODO: Add your command handler code here
  2468. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2469. pDoc->m_MenuItemID = IDM_MENU_ADD_RECT_QGIS;
  2470. m_nLbtDown = 0;
  2471. }
  2473. void CQGISView::OnMenuLayerManagerQgis() 
  2474. {
  2475. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2476. ASSERT(pDoc);
  2478. CQCoordSys * pSys = NULL;
  2480. CQMapObj * pMap = pDoc->m_pMap;
  2481. ASSERT(pMap);
  2483. pSys = pMap->GetCoordSysPointer();
  2484. ASSERT(pSys);
  2486. CDlgLayerManager layerdlg(0,pMap);
  2487. if(layerdlg.DoModal() == IDOK)
  2488. {
  2489. CBoundaryRect Brect;
  2490. CRect rectTemp;
  2491. pMap->CalculateBoundary(&Brect);
  2492. pSys->WPtoLP(Brect,&rectTemp);
  2493. InvalidateRect(rectTemp,TRUE);
  2494. }
  2495. }
  2497. void CQGISView::OnMenuAddCircleQgis() 
  2498. {
  2499. // TODO: Add your command handler code here
  2500. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2501. pDoc->m_MenuItemID =  IDM_MENU_ADD_CIRCLE_QGIS;
  2502. m_nLbtDown = 0;
  2503. }
  2505. void CQGISView::OnMenuAddEllipseQgis() 
  2506. {
  2507. // TODO: Add your command handler code here
  2508. CQGISDoc * pDoc = (CQGISDoc *)GetDocument();
  2509. pDoc->m_MenuItemID =  IDM_MENU_ADD_ELLIPSE_QGIS;
  2510. m_nLbtDown = 0;
  2511. CString szHelp = "本系统绘制椭圆，先拖动鼠标左键确定两端点确定椭圆的大小，然后在拉动橡皮线对椭圆的形状进行调整";
  2512. AfxMessageBox(szHelp);
  2513. }
  2515. //创建一个椭圆对象 并且返回其指针
  2516. CQEllipseObj * CQGISView::CreateEllipse(CQEllipseObj & Ellipse)
  2517. {
  2518. CQEllipseObj * pEllipse = new CQEllipseObj;
  2519. CQPoint centerPt;
  2520. Ellipse.GetCenterPoint(centerPt);
  2521. pEllipse->SetEllipseParams(centerPt.GetX(),centerPt.GetY(),Ellipse.GetLongAxis(),Ellipse.GetShortAxis(),
  2522. Ellipse.GetStartAngleRad(),Ellipse.GetEndAngleRad(),Ellipse.GetRotateAngleRad());
  2523. return pEllipse;
  2524. }
  2526. void CQGISView::DrawEllipse(CQEllipseObj & ellipse,CDC * pDC)
  2527. {
  2528.   CQCoordSys * pCs = GetDocument()->m_pMap->GetCoordSysPointer();
  2529. if(!pCs)return;
  2531. double x=0,y=0;//世界坐标
  2532. //////////////////////////////////////////////////////////////////////////
  2533. x = ellipse.GetStartAngleRad() - ellipse.GetRotateAngleRad();
  2534. y = ellipse.GetEndAngleRad() - ellipse.GetRotateAngleRad();
  2535. double dStart = min(x,y);
  2536. double dEnd = max(x,y);
  2537. double dStep = fabs(dEnd-dStart) / 100;//100个点绘制椭圆
  2538. if(dStep==0) return;
  2540. long lx=0,ly=0;//逻辑坐标
  2541. double a = ellipse.GetLongAxis();
  2542. double b = ellipse.GetShortAxis();
  2543. double i = dStart;
  2544. double xx=0,yy=0;
  2545. double ro = 0;
  2547. ro = a*b / sqrt( b*b*cos(i)*cos(i) + a*a*sin(i)*sin(i) );
  2548. x = cos(i) * ro;
  2549. y = sin(i) * ro;
  2550. xx = x*cos(ellipse.GetRotateAngleRad()) - y*sin(ellipse.GetRotateAngleRad());
  2551. yy = x*sin(ellipse.GetRotateAngleRad()) + y*cos(ellipse.GetRotateAngleRad());
  2552. CQPoint ptCenter;
  2553. ellipse.GetCenterPoint(ptCenter);
  2554. xx += ptCenter.GetX();
  2555. yy += ptCenter.GetY();
  2556. pCs->WPtoLP(xx,yy, &lx,&ly);
  2557. pDC->MoveTo(lx,ly);
  2559. for(;i<=dEnd;i+=dStep)
  2560. {
  2561. ro = a*b / sqrt( b*b*cos(i)*cos(i) + a*a*sin(i)*sin(i) );
  2562. x = cos(i) * ro;
  2563. y = sin(i) * ro;
  2564. xx = x*cos(ellipse.GetRotateAngleRad()) - y*sin(ellipse.GetRotateAngleRad());
  2565. yy = x*sin(ellipse.GetRotateAngleRad()) + y*cos(ellipse.GetRotateAngleRad());
  2566. xx += ptCenter.GetX();
  2567. yy += ptCenter.GetY();
  2568. pCs->WPtoLP(xx,yy, &lx,&ly);
  2569. pDC->LineTo(lx,ly);
  2570. }
  2572. i = dEnd;
  2573. ro = a*b / sqrt( b*b*cos(i)*cos(i) + a*a*sin(i)*sin(i) );
  2574. x = cos(i) * ro;
  2575. y = sin(i) * ro;
  2576. xx = x*cos(ellipse.GetRotateAngleRad()) - y*sin(ellipse.GetRotateAngleRad());
  2577. yy = x*sin(ellipse.GetRotateAngleRad()) + y*cos(ellipse.GetRotateAngleRad());
  2578. xx += ptCenter.GetX();
  2579. yy += ptCenter.GetY();
  2580. pCs->WPtoLP(xx,yy, &lx,&ly);
  2581. pDC->LineTo(lx,ly);
  2582. }
  2584. //保证点属性菜单 打开后有意义
  2585. void CQGISView::OnUpdateMenuPointAttsetQgis(CCmdUI* pCmdUI) 
  2586. {
  2587. // TODO: Add your command update UI handler code here
  2588. CQGISDoc * pDoc = GetDocument(); //获取文档对象的指针
  2589. ASSERT(pDoc);
  2590. CQSelObjManager * psel = pDoc->m_pMap->GetSelObjManager(); //选择对象管理器
  2591. ASSERT(psel);
  2593. int nSel = psel->GetSelObjCount();
  2594. if(nSel == 0) 
  2595. {
  2596. pCmdUI->Enable(FALSE);
  2597. return;
  2598. }
  2600. CQBaseObj * pObj = psel->GetCurSelObj();
  2601. if(pObj->GetObjType() == QGIS_OBJ_POINT && nSel == 1)
  2602. pCmdUI->Enable(TRUE);
  2603. else
  2604. pCmdUI->Enable(FALSE);
  2605. }
  2608. void CQGISView::OnMenuPointAttsetQgis() 
  2609. {
  2610. // TODO: Add your command handler code here
  2611. CQGISDoc * pDoc = GetDocument();
  2612. ASSERT(pDoc);
  2614. CQMapObj * pMap = pDoc->m_pMap;
  2615. ASSERT(pMap);
  2617. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2618. ASSERT(pSel);   // 获取选择对象管理器
  2620. CQCoordSys * pSys = pMap->GetCoordSysPointer();
  2621. ASSERT(pSys);
  2623. CQPointObj * pPoint = NULL;
  2624. pPoint = static_cast<CQPointObj *>(pSel->GetCurSelObj()); //static_cast在向下转换中是安全的
  2625. if(pPoint != NULL)
  2626. {
  2627. CQDlgPtAttSet ptDlg(pMap,pPoint);
  2628. if(ptDlg.DoModal() == IDOK)
  2629. {
  2630. CBoundaryRect bRect;
  2631. pPoint->CalculateBoundary(&bRect);
  2632. CRect rect;
  2633. pSys->WPtoLP(bRect,&rect);
  2634. pSel->EndFlash((CWnd*)this,2);
  2635. InvalidateRect(rect,TRUE);
  2636. }
  2637. }
  2638. }
  2640. //连点成线功能采取交互形式，每次选中一个点加入到线对象里
  2641. void CQGISView::OnMenuLinkPointToLineQgis() 
  2642. {
  2643. CQGISDoc * pDoc = GetDocument();
  2644. ASSERT(pDoc);
  2646. pDoc->m_MenuItemID = IDM_MENU_LINK_POINT_TO_LINE_QGIS;
  2647. m_nLbtDown = 0;
  2648. }
  2650. //添加流线
  2651. void CQGISView::OnMenuAddPolylineStream() 
  2652. {
  2653. // TODO: Add your command handler code here
  2654. CQGISDoc * pDoc = GetDocument();
  2655. ASSERT(pDoc);
  2657. pDoc->m_MenuItemID =  IDM_MENU_ADD_POLYLINE_STREAM;
  2658. m_nLbtDown = 0;
  2659. }
  2661. //刷新视图的代码
  2662. void CQGISView::OnMenuRefreshView() 
  2663. {
  2664. // TODO: Add your command handler code here
  2665. CQGISDoc * pDoc = GetDocument();
  2666. ASSERT(pDoc);
  2668. CQMapObj * pMap = pDoc->m_pMap;
  2669. ASSERT(pMap);
  2671. CQCoordSys * pCoord = pMap->GetCoordSysPointer();
  2672. ASSERT(pCoord);
  2674. CBoundaryRect bRect;
  2675. CRect rectTemp;
  2676. pMap->CalculateBoundary(&bRect);
  2677. pCoord->WPtoLP(bRect,&rectTemp);
  2678. InvalidateRect(rectTemp);
  2679. }
  2681. //全图显示
  2682. void CQGISView::OnMenuDrawAllobjInView() 
  2683. {
  2684. // TODO: Add your command handler code here
  2685. CQGISDoc * pDoc = GetDocument();
  2686. ASSERT(pDoc);
  2688. CQMapObj * pMap = pDoc->m_pMap;
  2689. ASSERT(pMap);
  2691. CQCoordSys * pCoord = pMap->GetCoordSysPointer();
  2692. ASSERT(pCoord);
  2694. pMap->DisplayAllInView(pCoord,this);
  2695. }
  2697. //图幅移动功能
  2698. void CQGISView::OnMenuMoveMap() 
  2699. {
  2700. CQGISDoc * pDoc = GetDocument(); //获取文档指针
  2701. ASSERT(pDoc);
  2703. if(pDoc->m_MenuItemID != ID_MENU_MOVE_MAP)
  2704. {
  2705. pDoc->m_MenuItemID = ID_MENU_MOVE_MAP;
  2706. pDoc->m_hCursorCur = ::LoadCursor(AfxGetInstanceHandle(),
  2707. MAKEINTRESOURCE(IDC_CURSOR_MOVE_MAP));
  2708. m_nLbtDown = 0;
  2709. }
  2710. }
  2712. CRect CQGISView::DrawAxis(BOOL bDraw,CDC * pDC,long &lWndX,long &lWndY)
  2713. {
  2714. //绘制坐标系的代码
  2715. if(pDC == NULL)
  2716. return CRect(0,0,0,0);
  2717. if(bDraw != TRUE)
  2718. return CRect(0,0,0,0);
  2720. CRect rectAxis;
  2721. long lOx = lWndX,lOy = lWndY;
  2722. long xArrow = (long)(5*tan(PI/4));
  2723. long Dx = lOx+80;
  2724. CPen pen(PS_SOLID,0,RGB(0,0,0));
  2725. CPen * pOldPen = pDC->SelectObject(&pen);
  2726. CBrush brush(RGB(0,0,0));
  2727. CBrush * pOldBrush = pDC->SelectObject(&brush);
  2728. pDC->MoveTo(lOx,lOy-80);
  2729. pDC->LineTo(lOx,lOy);
  2730. pDC->LineTo(lOx+80,lOy);
  2731. pDC->Ellipse(lOx-2,lOy-2,lOx+2,lOy+2);
  2732. //画向上的箭头的右半部分
  2733. pDC->MoveTo(lOx,lOy-80);
  2734. pDC->LineTo(lOx+xArrow,lOy-70);
  2735. pDC->TextOut(lOx+xArrow+10,lOy-70,"X");
  2736. //画向上的箭头的左半部分
  2737. pDC->MoveTo(lOx,lOy-80);
  2738. pDC->LineTo(lOx-xArrow,lOy-70);
  2739. //画向右的箭头
  2740. pDC->MoveTo(lOx+70,lOy+xArrow);
  2741. pDC->LineTo(lOx+80,lOy);
  2742. pDC->LineTo(lOx+70,lOy-xArrow);
  2743. pDC->TextOut(lOx+60,lOy-xArrow-15,"Y");
  2745. rectAxis.left = lOx-5;
  2746. rectAxis.top = lOy-80;
  2747. rectAxis.bottom = lOy+xArrow;
  2748. rectAxis.right = lOx+90;
  2750. pDC->SelectObject(pOldBrush);
  2751. pDC->SelectObject(pOldPen);
  2753. return rectAxis;
  2754. }
  2756. void CQGISView::OnMenuAxisQgis() 
  2757. {
  2758. CQGISDoc * pDoc = GetDocument();
  2759. ASSERT(pDoc);
  2761. CQCoordSys * pSys = pDoc->m_pMap->GetCoordSysPointer();
  2762. ASSERT(pSys);
  2764. static BOOL bShowAxis = FALSE;
  2765. static CRect rectAxis;
  2767. if((bShowAxis = !bShowAxis)!=FALSE)
  2768. {
  2769. CClientDC dc(this);
  2770. long lOrX = 0,lOrY = 0;
  2771. pSys->GetStartOfWnd(lOrX,lOrY);
  2772. m_bDrawAxis = TRUE;
  2773. rectAxis = DrawAxis(m_bDrawAxis,&dc,lOrX,lOrY);
  2774. }
  2775. else
  2776. {
  2777. m_bDrawAxis = FALSE;
  2778. InvalidateRect(rectAxis,TRUE);
  2779. }
  2780. }
  2782. //曲线光滑
  2783. void CQGISView::OnUpdateMenuInterpretationCurve(CCmdUI *pCmdUI)
  2784. {
  2785. CQGISDoc * pDoc = GetDocument();
  2786. ASSERT(pDoc);
  2788. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2789. ASSERT(pSel);
  2791. if(pSel->GetSelObjCount() == 0)
  2792. {
  2793. pCmdUI->SetCheck(0);
  2794. }
  2795. else
  2796. {
  2797. POSITION pos = pSel->GetHeadPosition();
  2798. WORD nCheck = 0;
  2799. while (pos)
  2800. {
  2801. CQBaseObj * pObj = pSel->GetNext(pos);
  2802. if(pObj->GetObjType() == QGIS_OBJ_LINE)
  2803. {
  2804. nCheck = 1;
  2805. break;
  2806. }
  2807. }
  2808. pCmdUI->SetCheck(nCheck);
  2809. }
  2810. }
  2812. void CQGISView::OnUpdateMenuTwiceBcurve(CCmdUI *pCmdUI)
  2813. {
  2814. CQGISDoc * pDoc = GetDocument();
  2815. ASSERT(pDoc);
  2817. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2818. ASSERT(pSel);
  2820. if(pSel->GetSelObjCount() == 0)
  2821. {
  2822. pCmdUI->SetCheck(0);
  2823. }
  2824. else
  2825. {
  2826. POSITION pos = pSel->GetHeadPosition();
  2827. WORD nCheck = 0;
  2828. while (pos)
  2829. {
  2830. CQBaseObj * pObj = pSel->GetNext(pos);
  2831. if(pObj->GetObjType() == QGIS_OBJ_LINE)
  2832. {
  2833. nCheck = 1;
  2834. break;
  2835. }
  2836. }
  2837. pCmdUI->SetCheck(nCheck);
  2838. }
  2839. }
  2841. void CQGISView::OnUpdateMenuThirdBcurve(CCmdUI *pCmdUI)
  2842. {
  2843. CQGISDoc * pDoc = GetDocument();
  2844. ASSERT(pDoc);
  2846. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2847. ASSERT(pSel);
  2849. if(pSel->GetSelObjCount() == 0)
  2850. {
  2851. pCmdUI->SetCheck(0);
  2852. }
  2853. else
  2854. {
  2855. POSITION pos = pSel->GetHeadPosition();
  2856. WORD nCheck = 0;
  2857. while (pos)
  2858. {
  2859. CQBaseObj * pObj = pSel->GetNext(pos);
  2860. if(pObj->GetObjType() == QGIS_OBJ_LINE)
  2861. {
  2862. nCheck = 1;
  2863. break;
  2864. }
  2865. }
  2866. pCmdUI->SetCheck(nCheck);
  2867. }
  2868. }
  2870. void CQGISView::OnMenuInterpretationCurve()
  2871. {
  2872. CQGISDoc * pDoc = GetDocument();
  2873. ASSERT(pDoc);
  2875. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2876. ASSERT(pSel);
  2878. CQCoordSys * pCoordsys = pDoc->m_pMap->GetCoordSysPointer();
  2879. ASSERT(pCoordsys);
  2881. POSITION pos = pSel->GetHeadPosition();
  2882. CBoundaryRect bRect,bUnionRect;
  2883. while (pos)
  2884. {
  2885. CQBaseObj * pObj = pSel->GetNext(pos);
  2886. if(pObj->GetObjType() == QGIS_OBJ_LINE)
  2887. {
  2888. CQLineObj * pLine = dynamic_cast<CQLineObj *>(pObj);
  2889. if(pLine != NULL)
  2890. {
  2891. pLine->PtListBeThin(0.00001f);
  2892. pLine->SetSplineType(1);
  2893. pLine->CalculateBoundary(&bRect);
  2894. bRect.Lager(1.0f);
  2895. bUnionRect.Union(&bRect);
  2896. }
  2897. }
  2898. }
  2900. if(bRect.IsValid() != FALSE)
  2901. {
  2902. CRect rectTm;
  2903. pCoordsys->WPtoLP(bRect,&rectTm);
  2904. InvalidateRect(rectTm,TRUE);
  2905. }
  2907. pSel->EndFlash(this->GetSafeHwnd(),1);
  2908. }
  2910. //二次样条
  2911. void CQGISView::OnMenuTwiceBcurve()
  2912. {
  2913. CQGISDoc * pDoc = GetDocument();
  2914. ASSERT(pDoc);
  2916. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2917. ASSERT(pSel);
  2919. CQCoordSys * pCoordsys = pDoc->m_pMap->GetCoordSysPointer();
  2920. ASSERT(pCoordsys);
  2922. POSITION pos = pSel->GetHeadPosition();
  2923. CBoundaryRect bRect,bUnionRect;
  2924. while (pos)
  2925. {
  2926. CQBaseObj * pObj = pSel->GetNext(pos);
  2927. if(pObj->GetObjType() == QGIS_OBJ_LINE)
  2928. {
  2929. CQLineObj * pLine = dynamic_cast<CQLineObj *>(pObj);
  2930. if(pLine != NULL)
  2931. {
  2932. pLine->PtListBeThin(0.00001f);
  2933. pLine->SetSplineType(2);
  2934. pLine->CalculateBoundary(&bRect);
  2935. bUnionRect.Union(&bRect);
  2936. }
  2937. }
  2938. }
  2940. if(bRect.IsValid() != FALSE)
  2941. {
  2942. CRect rectTm;
  2943. pCoordsys->WPtoLP(bRect,&rectTm);
  2944. InvalidateRect(rectTm,TRUE);
  2945. }
  2947. pSel->EndFlash(this->GetSafeHwnd(),1);
  2948. }
  2950. //三次样条
  2951. void CQGISView::OnMenuThirdBcurve()
  2952. {
  2953. CQGISDoc * pDoc = GetDocument();
  2954. ASSERT(pDoc);
  2956. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  2957. ASSERT(pSel);
  2959. CQCoordSys * pCoordsys = pDoc->m_pMap->GetCoordSysPointer();
  2960. ASSERT(pCoordsys);
  2962. POSITION pos = pSel->GetHeadPosition();
  2963. CBoundaryRect bRect,bUnionRect;
  2964. while (pos)
  2965. {
  2966. CQBaseObj * pObj = pSel->GetNext(pos);
  2967. if(pObj->GetObjType() == QGIS_OBJ_LINE)
  2968. {
  2969. CQLineObj * pLine = dynamic_cast<CQLineObj *>(pObj);
  2970. if(pLine != NULL)
  2971. {
  2972. pLine->PtListBeThin(0.00001f);
  2973. pLine->SetSplineType(3);
  2974. pLine->CalculateBoundary(&bRect);
  2975. bUnionRect.Union(&bRect);
  2976. }
  2977. }
  2978. }
  2980. if(bRect.IsValid() != FALSE)
  2981. {
  2982. CRect rectTm;
  2983. pCoordsys->WPtoLP(bRect,&rectTm);
  2984. InvalidateRect(rectTm,TRUE);
  2985. }
  2987. pSel->EndFlash(this->GetSafeHwnd(),1);
  2988. }
  2990. //选择点
  2991. void CQGISView::OnMenuSelectPointQgis()
  2992. {
  2993. CQGISDoc * pDoc = GetDocument();
  2994. ASSERT(pDoc);
  2996. pDoc->m_MenuItemID = IDM_MENU_RECT_SELECT_OBJ_QGIS;
  2997. m_nLbtDown = 0;
  2998. m_nSelectType = QGIS_SELECT_POINT; //选择点
  2999. }
  3001. void CQGISView::OnMenuPtLinkToLineQgis()
  3002. {
  3003. CQGISDoc * pDoc = GetDocument();
  3004. ASSERT(pDoc);
  3006. CQSelObjManager * pSM = pDoc->m_pMap->GetSelObjManager();
  3007. ASSERT(pSM);
  3009. CQCoordSys * pCoordSys = pDoc->m_pMap->GetCoordSysPointer();
  3010. ASSERT(pCoordSys);
  3012. if(pSM->GetSelObjCount()>2)
  3013. return;
  3015. POSITION pos = pSM->GetHeadPosition();
  3016. CQPointObj * pPt = NULL;
  3017. CQLineObj * pLine = NULL;
  3018. CQBaseObj * pObj = NULL;
  3019. while (pos)
  3020. {
  3021. pObj = pSM->GetNext(pos);
  3022. if(pObj->GetObjType() == QGIS_OBJ_POINT)
  3023. {
  3024. pPt = dynamic_cast<CQPointObj *>(pObj);
  3025. }
  3026. else if(pObj->GetObjType() == QGIS_OBJ_LINE)
  3027. {
  3028. pLine = dynamic_cast<CQLineObj *>(pObj);
  3029. }
  3030. }
  3032. if(pPt!=NULL && pLine!=NULL)
  3033. {
  3034. //求出点到直线两端点的距离
  3035. CBoundaryRect bRect;
  3036. int nPtCount = pLine->m_ptListDisplay.GetSize();
  3037. CQPoint ptPt;
  3038. double dx=0.0f,dy=0.0f;
  3039. pPt->GetPointPos(dx,dy);
  3040. ptPt.SetPoint(dx,dy);
  3041. CQPoint * ptOne = pLine->m_PtList.GetPoint(0);
  3042. CQPoint * ptLast = pLine->m_PtList.GetPoint(nPtCount-1);
  3043. double dDisOne=0.0f,dDisTwo=0.0f;
  3044. dDisOne = ptPt.Distance(*ptOne);
  3045. dDisTwo = ptPt.Distance(*ptLast);
  3046. if(dDisOne<=dDisTwo)
  3047. {
  3048. pLine->m_PtList.InsertAt(0,ptPt.GetX(),ptPt.GetY());
  3049. }
  3050. else
  3051. {
  3052. pLine->m_PtList.AddPoint(ptPt.GetX(),ptPt.GetY());
  3053. }
  3054. pLine->CalculateBoundary(&bRect);
  3055. CRect rect;
  3056. pCoordSys->WPtoLP(bRect,&rect);
  3057. InvalidateRect(rect,FALSE);
  3058. }
  3059. pSM->EndFlash(this->GetSafeHwnd(),2);
  3060. }
  3062. void CQGISView::OnUpdateMenuPtLinkToLineQgis(CCmdUI *pCmdUI)
  3063. {
  3064. CQGISDoc * pDoc = GetDocument();
  3065. ASSERT(pDoc);
  3067. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  3068. ASSERT(pSel);
  3070. POSITION pos = pSel->GetHeadPosition();
  3071. int nSelCount = pSel->GetSelObjCount();
  3072. if(nSelCount<=0)
  3073. {
  3074. pCmdUI->Enable(FALSE);
  3075. return;
  3076. }
  3078. int i=0;
  3079. while (pos)
  3080. {
  3081. CQBaseObj * pObj = pSel->GetNext(pos);
  3082. if(pObj->GetObjType() == QGIS_OBJ_POINT || pObj->GetObjType() == QGIS_OBJ_LINE)
  3083. {
  3084. break;
  3085. }
  3086. ++i;
  3087. }
  3089. if(i>nSelCount || nSelCount>2)
  3090. {
  3091. pCmdUI->Enable(FALSE);
  3092. }
  3093. else
  3094. {
  3095. pCmdUI->Enable(TRUE);
  3096. }
  3097. }
  3099. //添加垂直线
  3100. void CQGISView::OnMenuAddVervicalLineQgis()
  3101. {
  3102. CQGISDoc * pDoc = GetDocument();
  3103. ASSERT(pDoc);
  3105. pDoc->m_MenuItemID = ID_MENU_ADD_VERVICAL_LINE_QGIS;
  3106. m_nLbtDown = 0;
  3107. }
  3109. // 添加水平线
  3110. void CQGISView::OnMenuAddHoriLineQgis()
  3111. {
  3112. CQGISDoc * pDoc = GetDocument();
  3113. ASSERT(pDoc);
  3115. pDoc->m_MenuItemID = ID_MENU_ADD_HORI_LINE_QGIS;
  3116. m_nLbtDown = 0;
  3117. }
  3120. void CQGISView::OnDglspkLineGetptQgis()
  3121. {
  3122. CQGISDoc * pDoc = GetDocument();
  3123. ASSERT(pDoc);
  3125. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  3126. ASSERT(pSel);
  3128. CQCoordSys * pCoordObj = pDoc->m_pMap->GetCoordSysPointer();
  3129. ASSERT(pCoordObj);
  3131. if(pSel->GetSelObjCount() == 1)
  3132. {
  3133. CQBaseObj * pBase = pSel->GetCurSelObj();
  3134. if(pBase != NULL && pBase->GetObjType() == QGIS_OBJ_LINE)
  3135. {
  3136. CQLineObj * pLine = dynamic_cast<CQLineObj *>(pBase);
  3137. if(pLine != NULL)
  3138. {
  3139. double fBeThin = 0.0f;
  3140. CDlgLineBeThin dlg;
  3141. if(dlg.DoModal() == IDOK)
  3142. {
  3143. fBeThin = dlg.m_fBeThin;
  3144. CQGISAlgorithmLib::PtListLess(pLine->m_PtList,fBeThin);
  3145. CBoundaryRect bRect;
  3146. pLine->CalculateBoundary(&bRect);
  3147. CRect rect;
  3148. pCoordObj->WPtoLP(bRect,&rect);
  3149. InvalidateRect(rect,TRUE);
  3150. pSel->EndFlash(this->GetSafeHwnd(),2);
  3151. }
  3152. }
  3153. }
  3154. }
  3155. }
  3157. void CQGISView::OnUpdateDglspkLineGetptQgis(CCmdUI *pCmdUI)
  3158. {
  3159. CQGISDoc * pDoc = GetDocument();
  3160. ASSERT(pDoc);
  3162. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  3163. ASSERT(pSel);
  3165. if(pSel->GetSelObjCount() == 0)
  3166. {
  3167. pCmdUI->Enable(FALSE);
  3168. }
  3169. else
  3170. {
  3171. if(pSel->GetSelObjCount() == 1)
  3172. {
  3173. CQBaseObj * pbase = pSel->GetCurSelObj();
  3174. if(pbase->GetObjType() == QGIS_OBJ_LINE)
  3175. {
  3176. pCmdUI->Enable(TRUE);
  3177. return;
  3178. }
  3179. }
  3180. }
  3181. pCmdUI->Enable(FALSE);
  3182. }
  3184. void CQGISView::OnMenuAddTextQgis()
  3185. {
  3186. CQGISDoc * pDoc = GetDocument();
  3187. ASSERT(pDoc);
  3189. pDoc->m_MenuItemID = ID_MENU_ADD_TEXT_QGIS;
  3190. m_nLbtDown = 0;
  3191. }
  3194. void CQGISView::OnMenuTextParaSet()
  3195. {
  3196. CQGISDoc * pDoc = GetDocument();
  3197. ASSERT(pDoc);
  3199. CQSelObjManager * pSel = pDoc->m_pMap->GetSelObjManager();
  3200. ASSERT(pSel);
  3202. CQCoordSys * pSys = pDoc->m_pMap->GetCoordSysPointer();
  3203. ASSERT(pSys);
  3205. POSITION pos = pSel->GetHeadPosition();
  3206. CQTextObj * pTextObj = NULL;
  3207. while (pos)
  3208. {
  3209. CQBaseObj * pObj = pSel->GetNext(pos);
  3210. if(pObj->GetObjType() == QGIS_OBJ_LABEL)
  3211. {
  3212. pTextObj = dynamic_cast<CQTextObj *>(pObj);
  3213. break;
  3214. }
  3215. }
  3217. if(pTextObj != NULL)
  3218. {
  3219. QDlgTextSet dlg(pTextObj);
  3220. if(dlg.DoModal() == IDOK)
  3221. {
  3222. CBoundaryRect bRect;
  3223. CRect rect;
  3224. pTextObj->CalculateBoundary(&bRect);
  3225. pSys->WPtoLP(bRect,&rect);
  3226. pSel->EndFlash(this->GetSafeHwnd(),2);
  3227. InvalidateRect(rect,TRUE);
  3228. }
  3229. }
  3230. }
  3232. //Excel文件矢量化
  3233. void CQGISView::OnMenuReadExcelQgis()
  3234. {
  3235. CQGISDoc * pDoc = GetDocument();
  3236. ASSERT(pDoc);
  3238. pDoc->m_MenuItemID = ID_MENU_READ_EXCEL_QGIS;
  3239. m_nLbtDown = 0;
  3240. }