Category

Development Platform
Home > SourceCode/Document > Graph program > View Code
Contour.cpp
Package: solidgraph_sources.zip　[view]
Upload User: kairuinn
Upload Date: 2009-02-07
Package Size: 2922k
Code Size: 30k
Category:

Graph program

Development Platform:

Visual C++

Contour.cpp：Code Content
  1. #include "stdafx.h"
  3. #include "Contour.h"
  5. #include "..//Dialogs//ContScenarDlg.h"
  6. #include "..//Dialogs//ContObjDlg.h"
  8. #include "..//resource.h"
  10. #include <math.h>
  12. int     contour_name_index = 1;
  14. Contour::Contour(IApplicationInterface* appI):
  15. m_app(appI)
  16. , m_start_object(NULL)
  17. , m_scenar(-1)
  18. , m_step(0)
  19. , m_lines(false)
  20. , m_scenar_panel(NULL)
  21. , m_get_object_panel(NULL)
  22. , m_select_obj_type_panel(NULL)
  23. , m_get_first_point(NULL)
  24. , m_get_second_point(NULL)
  25. , m_get_third_point(NULL)
  26. , m_isFirstPoint(true)
  27. , m_isSecondPoint(false)
  28. , m_isLastPointOnArc(false)
  29. , m_exist_arc_data(false)
  30. , m_can_close(false)
  32. {
  33. ASSERT(m_app);
  34. }
  36. Contour::~Contour()
  37. {
  38. size_t sz =m_objects.size();
  39. for (size_t i=0;i<sz;i++)
  40. sgCObject::DeleteObject(m_objects[i]);
  41. m_objects.clear();
  43. m_app->GetCommandPanel()->RemoveAllDialogs();
  44. if (m_scenar_panel)
  45. {
  46. m_scenar_panel->DestroyWindow();
  47. delete m_scenar_panel;
  48. m_scenar_panel = NULL;
  49. }
  50. if (m_select_obj_type_panel)
  51. {
  52. m_select_obj_type_panel->DestroyWindow();
  53. delete m_select_obj_type_panel;
  54. m_select_obj_type_panel = NULL;
  55. }
  56. m_app->GetViewPort()->InvalidateViewPort();
  57. }
  60. bool    Contour::PreTranslateMessage(MSG* pMsg)
  61. {
  62. /*if (pMsg->message==WM_KEYUP||
  63. pMsg->message==WM_CHAR)
  64. return false;*/
  66. if (pMsg->message==WM_KEYUP||pMsg->message==WM_KEYDOWN || 
  67. pMsg->message==WM_CHAR)
  68. {
  69. if (pMsg->wParam==VK_RETURN)
  70. {
  71. OnEnter();
  72. return true;
  73. }
  74. if (pMsg->wParam==VK_ESCAPE)
  75. {
  76. m_app->StopCommander();
  77. return true;
  78. }
  79. switch(m_step) 
  80. {
  81. case 0:
  82. if (m_get_first_point)
  83. m_get_first_point->GetWindow()->SendMessage(pMsg->message,
  84. pMsg->wParam,
  85. pMsg->lParam);
  86. break;
  87. case 1:
  88. if (m_get_second_point)
  89. m_get_second_point->GetWindow()->SendMessage(pMsg->message,
  90. pMsg->wParam,
  91. pMsg->lParam);
  92. break;
  93. case 2:
  94. if (m_get_third_point)
  95. m_get_third_point->GetWindow()->SendMessage(pMsg->message,
  96. pMsg->wParam,
  97. pMsg->lParam);
  98. break;
  99. }
  100. if (pMsg->message==WM_KEYDOWN)
  101. return false;
  102. else 
  103. return true;
  104. }
  105. else
  106. {
  107. if (pMsg->hwnd == m_app->GetViewPort()->GetWindow()->m_hWnd)
  108. {
  109. switch(pMsg->message) 
  110. {
  111. case WM_MOUSEMOVE:
  112. MouseMove(pMsg->wParam,GET_X_LPARAM(pMsg->lParam),GET_Y_LPARAM(pMsg->lParam));
  113. return true;
  114. case WM_LBUTTONDOWN:
  115. LeftClick(pMsg->wParam,GET_X_LPARAM(pMsg->lParam),GET_Y_LPARAM(pMsg->lParam));
  116. return true;
  117. default:
  118. return false;
  119. }
  120. }
  121. }
  122. return false;
  123. }
  125. static   bool isObjAddToList(sgCObject* o)
  126. {
  127. if (o->GetType()==SG_OT_LINE ||
  128. o->GetType()==SG_OT_ARC)
  129. return true;
  130. if (o->GetType()==SG_OT_CONTOUR)
  131. {
  132. sgCContour* cc = reinterpret_cast<sgCContour*>(o);
  133. if (cc->IsClosed())
  134. return false;
  135. else
  136. return true;
  137. }
  138. return false;
  139. }
  141. void  Contour::SwitchScenario(int newScen)
  142. {
  143. SWITCH_RESOURCE
  144. switch(newScen) {
  145. case 1:
  146. m_lines = false;
  147. if (m_scenar==0)
  148. break;
  149. m_scenar = 0;
  150. if (m_select_obj_type_panel!=NULL)
  151. {
  152. m_app->GetCommandPanel()->RemoveDialog(m_select_obj_type_panel);
  153. m_select_obj_type_panel->DestroyWindow();
  154. delete m_select_obj_type_panel;
  155. m_select_obj_type_panel = NULL;
  156. }
  157. if (m_get_first_point)
  158. {
  159. m_app->GetCommandPanel()->RemoveDialog(m_get_first_point);
  160. m_get_first_point = NULL;
  161. }
  162. if (m_get_second_point)
  163. {
  164. m_app->GetCommandPanel()->RemoveDialog(m_get_second_point);
  165. m_get_second_point = NULL;
  166. }
  167. if (m_get_third_point)
  168. {
  169. m_app->GetCommandPanel()->RemoveDialog(m_get_third_point);
  170. m_get_third_point = NULL;
  171. }
  172. if (m_get_object_panel==NULL)
  173. {
  174. CString lab;
  175. lab.LoadString(IDS_OBJECT);
  176. m_get_object_panel = 
  177. reinterpret_cast<IGetObjectsPanel*>(m_app->GetCommandPanel()->
  178. AddDialog(IBaseInterfaceOfGetDialogs::GET_OBJECTS_DLG,
  179. lab,false));
  180. m_get_object_panel->EnableControls(true);
  181. m_get_object_panel->SetMultiselectMode(false);
  182. m_get_object_panel->FillList(isObjAddToList);
  183. m_app->GetCommandPanel()->EnableRadio(0,true);
  184. m_app->GetCommandPanel()->EnableRadio(1,true);
  185. }
  186. m_message.LoadString(IDS_CHOISE_FIRST_OBJ_OF_PATH);
  187. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  188. {
  189. size_t sz =m_objects.size();
  190. for (size_t i=0;i<sz;i++)
  191. sgCObject::DeleteObject(m_objects[i]);
  192. }
  193. break;
  194. case 0:
  195. if (m_scenar==1)
  196. break;
  197. m_scenar = 1;
  198. if (m_get_object_panel!=NULL)
  199. {
  200. m_app->GetCommandPanel()->RemoveDialog(m_get_object_panel);
  201. m_get_object_panel = NULL;
  202. }
  203. if (m_select_obj_type_panel==NULL)
  204. {
  205. m_select_obj_type_panel = new CContObjDlg;
  206. m_select_obj_type_panel->Create(IDD_CONT_OBJ_TYPE,
  207. m_app->GetCommandPanel()->GetDialogsContainerWindow());
  208. m_select_obj_type_panel->SetCommander(this);
  209. m_message.LoadString(IDS_CONT_OBJ_TYPE);
  210. m_app->GetCommandPanel()->AddDialog(m_select_obj_type_panel,m_message,false);
  212. m_select_obj_type_panel->EnableControls(true);
  213. m_app->GetCommandPanel()->EnableRadio(1,true);
  215. m_select_obj_type_panel->OnBnClickedContObjRadio1();
  216. }
  217. m_message.LoadString(IDS_ENTER_POINT_COORDS);
  218. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  219. break;
  220. default:
  221. ASSERT(0);
  222. break;
  223. }
  224. }
  226. void Contour::SwitchObjectType(int newObjType)
  227. {
  228. SWITCH_RESOURCE
  229. switch(newObjType) 
  230. {
  231. case 0:
  232. if (m_lines)
  233. break;
  234. if (m_step==1)
  235. {
  236. if (m_get_third_point)
  237. {
  238. m_app->GetCommandPanel()->RemoveDialog(m_get_third_point);
  239. m_get_third_point = NULL;
  240. }
  241. m_lines = true;
  242. break;
  243. }
  244. m_lines = true;
  245. if (m_get_first_point)
  246. {
  247. m_app->GetCommandPanel()->RemoveDialog(m_get_first_point);
  248. m_get_first_point = NULL;
  249. }
  250. if (m_get_second_point)
  251. {
  252. m_app->GetCommandPanel()->RemoveDialog(m_get_second_point);
  253. m_get_second_point = NULL;
  254. }
  255. if (m_get_third_point)
  256. {
  257. m_app->GetCommandPanel()->RemoveDialog(m_get_third_point);
  258. m_get_third_point = NULL;
  259. }
  260. if (m_get_first_point==NULL)
  261. {
  262. m_message.LoadString(IDS_FIRST_POINT);
  263. m_get_first_point = 
  264. reinterpret_cast<IGetPointPanel*>(m_app->GetCommandPanel()->
  265. AddDialog(IBaseInterfaceOfGetDialogs::GET_POINT_DLG,
  266. m_message,true));
  267. }
  268. if (m_get_second_point==NULL)
  269. {
  270. m_message.LoadString(IDS_SECOND_POINT);
  271. m_get_second_point = 
  272. reinterpret_cast<IGetPointPanel*>(m_app->GetCommandPanel()->
  273. AddDialog(IBaseInterfaceOfGetDialogs::GET_POINT_DLG,
  274. m_message,true));
  275. }
  276. m_app->GetCommandPanel()->SetActiveRadio(2);
  277. break;
  278. case 1:
  279. if (!m_lines)
  280. break;
  281. if (m_step==1)
  282. {
  283. if (m_get_third_point==NULL)
  284. {
  285. m_message.LoadString(IDS_POINT_ON_ARC);
  286. m_get_third_point = 
  287. reinterpret_cast<IGetPointPanel*>(m_app->GetCommandPanel()->
  288. AddDialog(IBaseInterfaceOfGetDialogs::GET_POINT_DLG,
  289. m_message,true));
  290. }
  291. m_lines = false;
  292. break;
  293. }
  294. m_lines = false;
  295. if (m_get_first_point)
  296. {
  297. m_app->GetCommandPanel()->RemoveDialog(m_get_first_point);
  298. m_get_first_point = NULL;
  299. }
  300. if (m_get_second_point)
  301. {
  302. m_app->GetCommandPanel()->RemoveDialog(m_get_second_point);
  303. m_get_second_point = NULL;
  304. }
  305. if (m_get_third_point)
  306. {
  307. m_app->GetCommandPanel()->RemoveDialog(m_get_third_point);
  308. m_get_third_point = NULL;
  309. }
  310. if (m_get_first_point==NULL)
  311. {
  312. m_message.LoadString(IDS_BEG_POINT);
  313. m_get_first_point = 
  314. reinterpret_cast<IGetPointPanel*>(m_app->GetCommandPanel()->
  315. AddDialog(IBaseInterfaceOfGetDialogs::GET_POINT_DLG,
  316. m_message,true));
  317. }
  318. if (m_get_second_point==NULL)
  319. {
  320. m_message.LoadString(IDS_END_POINT);
  321. m_get_second_point = 
  322. reinterpret_cast<IGetPointPanel*>(m_app->GetCommandPanel()->
  323. AddDialog(IBaseInterfaceOfGetDialogs::GET_POINT_DLG,
  324. m_message,true));
  325. }
  326. if (m_get_third_point==NULL)
  327. {
  328. m_message.LoadString(IDS_POINT_ON_ARC);
  329. m_get_third_point = 
  330. reinterpret_cast<IGetPointPanel*>(m_app->GetCommandPanel()->
  331. AddDialog(IBaseInterfaceOfGetDialogs::GET_POINT_DLG,
  332. m_message,true));
  333. }
  334. m_app->GetCommandPanel()->SetActiveRadio(2);
  335. break;
  336. default:
  337. ASSERT(0);
  338. break;
  339. }
  340. }
  342. void  Contour::SendCommanderMessage(ICommander::COMMANDER_MESSAGE mes, void* params)
  343. {
  344. if (mes==ICommander::CM_SWITCH_ROLLUP_DIALOG)
  345. {
  346. ASSERT(params!=NULL);
  347. int   newActiveDlg = *(reinterpret_cast<int*>(params));
  349. ASSERT(newActiveDlg<=1);
  350. m_step = (unsigned int)newActiveDlg;
  351. /*if (newActiveDlg==0)
  352. {
  353. m_app->GetCommandPanel()->EnableRadio(1,false);
  354. m_message.LoadString(IDS_CHOISE_TRANS_OBJ);
  355. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  356. }*/
  357. //m_app->GetViewPort()->InvalidateViewPort();
  358. return;
  359. }
  360. if (mes==ICommander::CM_SELECT_OBJECT)
  361. {
  362. ASSERT(params!=NULL);
  363. ASSERT(m_scenar==0);
  364. sgCObject* so = (sgCObject*)params;
  365. if (so!=m_start_object)
  366. {
  367. m_app->GetViewPort()->SetHotObject(so);
  368. m_start_object = so;
  369. }
  370. m_app->GetViewPort()->InvalidateViewPort();
  371. }
  372. }
  375. void  Contour::Start()
  376. {
  377. SWITCH_RESOURCE
  378. m_app->GetCommandPanel()->RemoveAllDialogs();
  380. CString lab;
  381. lab.LoadString(IDS_TOOLTIP_FIVETH);
  382. m_app->StartCommander(lab);
  384. m_scenar_panel = new CContScenarDlg;
  385. m_scenar_panel->Create(IDD_CONT_SCENARS_DLG,
  386. m_app->GetCommandPanel()->GetDialogsContainerWindow());
  387. m_scenar_panel->SetCommander(this);
  389. m_message.LoadString(IDS_CONT_SCENAR);
  390. m_app->GetCommandPanel()->AddDialog(m_scenar_panel,m_message,false);
  392. m_app->GetCommandPanel()->EnableRadio(0,true);
  394. }
  396. static  void get_end_points_of_object(sgCObject* ob, SG_POINT& bP, SG_POINT& eP)
  397. {
  398. if (ob->GetType()==SG_OT_ARC)
  399. {
  400. sgCArc* arcO = reinterpret_cast<sgCArc*>(ob);
  401. const SG_ARC* arcG = arcO->GetGeometry();
  402. bP = arcG->begin;
  403. eP = arcG->end;
  404. }
  405. else
  406. if (ob->GetType()==SG_OT_LINE)
  407. {
  408. sgCLine* lineO = reinterpret_cast<sgCLine*>(ob);
  409. const SG_LINE* lineG = lineO->GetGeometry();
  410. bP = lineG->p1;
  411. eP = lineG->p2;
  412. }
  413. else
  414. if (ob->GetType()==SG_OT_CONTOUR)
  415. {
  416. sgCContour* cO = reinterpret_cast<sgCContour*>(ob);
  417. //cO->GetEndPoints(bP,eP);
  418. bP = cO->GetPointFromCoefficient(0.0);
  419. eP = cO->GetPointFromCoefficient(1.0);
  420. }
  421. else
  422. {
  423. ASSERT(0);
  424. }
  425. }
  427. void  Contour::CreateContour(sgCObject* stObj)
  428. {
  429. std::vector<sgCObject*>   ArcAndLines;
  430. std::vector<sgCObject*>   goodOnPath;
  432. goodOnPath.push_back(stObj);
  434. SG_POINT  zeroBegP;
  435. SG_POINT  zeroEndP;
  437. get_end_points_of_object(stObj, zeroBegP, zeroEndP);
  439. sgCObject*  curObj = sgGetScene()->GetObjectsList()->GetHead();
  440. while (curObj) 
  441. {
  442. if (curObj->GetType()==SG_OT_ARC ||
  443. curObj->GetType()==SG_OT_LINE )
  444. {
  445. if (curObj!=stObj)
  446. ArcAndLines.push_back(curObj);
  447. }
  448. else
  449. {
  450. if (curObj->GetType()==SG_OT_CONTOUR)
  451. {
  452. sgCContour* ccont = reinterpret_cast<sgCContour*>(curObj);
  453. if (!ccont->IsClosed())
  454. {
  455. if (curObj!=stObj)
  456. ArcAndLines.push_back(curObj);
  457. }
  458. }
  459. }
  460. curObj = sgGetScene()->GetObjectsList()->GetNext(curObj);
  461. }
  463. #define MIN_DIST   0.0000001
  465. for (size_t i=0; i<ArcAndLines.size(); i++)
  466. {
  467. if (sgSpaceMath::PointsDistance(zeroEndP,zeroBegP)<MIN_DIST)
  468. break;
  469. if (ArcAndLines[i]==NULL)
  470. continue;
  472. SG_POINT begP;
  473. SG_POINT endP;
  475. get_end_points_of_object(ArcAndLines[i], begP, endP);
  477. bool  yes = false;
  479. if (sgSpaceMath::PointsDistance(begP,zeroBegP)<MIN_DIST)
  480. {
  481. zeroBegP = endP;
  482. yes = true;
  483. goto metlab;
  484. }
  485. if (sgSpaceMath::PointsDistance(endP,zeroBegP)<MIN_DIST)
  486. {
  487. zeroBegP = begP;
  488. yes = true;
  489. goto metlab;
  490. }
  492. if (sgSpaceMath::PointsDistance(begP,zeroEndP)<MIN_DIST)
  493. {
  494. zeroEndP = endP;
  495. yes = true;
  496. goto metlab;
  497. }
  498. if (sgSpaceMath::PointsDistance(endP,zeroEndP)<MIN_DIST)
  499. {
  500. zeroEndP = begP;
  501. yes = true;
  502. goto metlab;
  503. }
  504. metlab:
  505. if (yes)
  506. {
  507. goodOnPath.push_back(ArcAndLines[i]);
  508. //ArcAndLines.erase(&ArcAndLines[i]);
  509. ArcAndLines[i] = NULL;
  510. i = -1;
  511. continue;
  512. }
  513. yes = false;
  514. }
  516. if (goodOnPath.size()>1)
  517. {
  518. sgGetScene()->StartUndoGroup();
  519. sgCContour* cont = sgCContour::CreateContour(&goodOnPath[0],goodOnPath.size());
  520. if (!cont)
  521. return;
  522. SWITCH_RESOURCE
  523. m_message.LoadString(IDS_TOOLTIP_FIVETH);
  524. CString nmInd;
  525. nmInd.Format("%i",contour_name_index);
  526. m_message+=nmInd;
  527. cont->SetName(m_message);
  528. contour_name_index++;
  529. sgGetScene()->AttachObject(cont);
  530. sgGetScene()->EndUndoGroup();
  531. }
  532. else
  533. {
  534. if (goodOnPath.size()==0)
  535. {
  536. m_message.LoadString(IDS_ERR_PATH_NO_OBJ);
  537. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  538. m_message);
  539. return;
  540. }
  541. if (goodOnPath.size()==1)
  542. {
  543. m_message.LoadString(IDS_ERR_PATH_ONE_OBJ);
  544. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  545. m_message);
  546. return;
  547. }
  548. }
  550. }
  552. void  Contour::CreateContourFromObjects()
  553. {
  554. size_t sz = m_objects.size();
  555. if (sz==0)
  556. {
  557. m_message.LoadString(IDS_ERR_PATH_NO_OBJ);
  558. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  559. m_message);
  560. return;
  561. }
  562. if (sz==1)
  563. {
  564. m_message.LoadString(IDS_ERR_PATH_ONE_OBJ);
  565. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  566. m_message);
  567. return;
  568. }
  569. if (sz>1)
  570. {
  571. sgGetScene()->StartUndoGroup();
  572. sgCContour* cont = sgCContour::CreateContour(&m_objects[0],sz);
  573. if (!cont)
  574. return;
  575. SWITCH_RESOURCE
  576. m_message.LoadString(IDS_TOOLTIP_FIVETH);
  577. CString nmInd;
  578. nmInd.Format("%i",contour_name_index);
  579. m_message+=nmInd;
  580. cont->SetName(m_message);
  581. contour_name_index++;
  582. sgGetScene()->AttachObject(cont);
  583. sgGetScene()->EndUndoGroup();
  584. m_objects.clear();
  585. m_isFirstPoint = true;
  586. m_isSecondPoint = false;
  587. m_isLastPointOnArc = false;
  588. m_exist_arc_data = false;
  589. m_can_close =false;
  590. m_message.LoadString(IDS_FIRST_POINT);
  591. m_app->GetCommandPanel()->RenameRadio(2,m_message);
  592. m_app->GetCommandPanel()->SetActiveRadio(2);
  593. m_app->GetCommandPanel()->EnableRadio(3,false);
  594. m_step = 0;
  595. }
  596. }
  598. void  Contour::MouseMove(unsigned int nFlags,int pX,int pY)
  599. {
  600. if (m_scenar==0)
  601. {
  602. if (!(nFlags & MK_LBUTTON))
  603. {
  604. int snapSz = m_app->GetViewPort()->GetSnapSize();
  606. sgCObject* ho = m_app->GetViewPort()->GetTopObject(
  607. m_app->GetViewPort()->GetHitsInRect(CRect(pX-snapSz, pY-snapSz,
  608. pX+snapSz, pY+snapSz)));
  609. if (ho && isObjAddToList(ho))
  610. {
  611. m_app->GetViewPort()->SetHotObject(ho);
  612. if (m_get_object_panel)
  613. m_get_object_panel->SelectObject(ho,true);
  614. }
  615. else
  616. {
  617. m_app->GetViewPort()->SetHotObject(NULL);
  618. if (m_get_object_panel)
  619. m_get_object_panel->SelectObject(NULL,true);
  620. }
  621. m_app->GetViewPort()->InvalidateViewPort();
  622. }
  623. return;
  624. }
  625. if (m_scenar==1)
  626. {
  627. IViewPort::GET_SNAP_IN in_arg;
  628. in_arg.scrX = pX;
  629. in_arg.scrY = pY;
  630. in_arg.snapType = SNAP_SYSTEM;
  631. switch(m_step) 
  632. {
  633. case 0:
  634. if (m_get_first_point)
  635. {
  636. in_arg.XFix = m_get_first_point->IsXFixed();
  637. in_arg.YFix = m_get_first_point->IsYFixed();
  638. in_arg.ZFix = m_get_first_point->IsZFixed();
  639. m_get_first_point->GetPoint(in_arg.FixPoint.x,in_arg.FixPoint.y,in_arg.FixPoint.z);
  640. IViewPort::GET_SNAP_OUT out_arg;
  641. m_app->GetViewPort()->GetWorldPointAfterSnap(in_arg,out_arg);
  642. m_cur_point = out_arg.result_point;
  643. m_get_first_point->SetPoint((float)(m_cur_point.x),(float)(m_cur_point.y),(float)(m_cur_point.z));
  644. }
  645. break;
  646. case 1:
  647. if (m_get_second_point)
  648. {
  649. in_arg.XFix = m_get_second_point->IsXFixed();
  650. in_arg.YFix = m_get_second_point->IsYFixed();
  651. in_arg.ZFix = m_get_second_point->IsZFixed();
  652. m_get_second_point->GetPoint(in_arg.FixPoint.x,in_arg.FixPoint.y,in_arg.FixPoint.z);
  653. IViewPort::GET_SNAP_OUT out_arg;
  654. m_app->GetViewPort()->GetWorldPointAfterSnap(in_arg,out_arg);
  655. m_cur_point = out_arg.result_point;
  656. m_get_second_point->SetPoint((float)(m_cur_point.x),(float)(m_cur_point.y),(float)(m_cur_point.z));
  657. }
  658. break;
  659. case 2:
  660. if (m_lines)
  661. {
  662. ASSERT(0);
  663. return;
  664. }
  665. if (m_get_third_point)
  666. {
  667. in_arg.XFix = m_get_third_point->IsXFixed();
  668. in_arg.YFix = m_get_third_point->IsYFixed();
  669. in_arg.ZFix = m_get_third_point->IsZFixed();
  670. m_get_third_point->GetPoint(in_arg.FixPoint.x,in_arg.FixPoint.y,in_arg.FixPoint.z);
  671. IViewPort::GET_SNAP_OUT out_arg;
  672. m_app->GetViewPort()->GetWorldPointAfterSnap(in_arg,out_arg);
  673. m_cur_point = out_arg.result_point;
  674. m_get_third_point->SetPoint((float)(m_cur_point.x),(float)(m_cur_point.y),(float)(m_cur_point.z));
  675. }
  676. if (!m_lines)
  677. {
  678. m_exist_arc_data = m_arc_geo.FromThreePoints(m_tmp_first_point,m_tmp_second_point,
  679. m_cur_point,false);
  680. }
  681. break;
  682. default:
  683. ASSERT(0);
  684. return;
  685. }
  686. m_app->GetViewPort()->InvalidateViewPort();
  687. }
  688. }
  690. void  Contour::LeftClick(unsigned int nFlags,int pX,int pY)
  691. {
  692. SWITCH_RESOURCE
  693. if (m_scenar==0)
  694. {
  695. m_start_object = m_app->GetViewPort()->GetHotObject();
  697. if (m_start_object==NULL)
  698. {
  699. m_message.LoadString(IDS_ERR_PATH_NO_OBJ);
  700. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  701. m_message);
  702. return;
  703. }
  705. CreateContour(m_start_object);
  707. m_get_object_panel->RemoveAllObjects();
  708. m_get_object_panel->FillList(isObjAddToList);
  710. return;
  711. }
  712. if (m_scenar==1)
  713. {
  714. if (m_isFirstPoint)
  715. {
  716. m_tmp_first_point = m_cur_point;
  717. m_isFirstPoint = false;
  718. m_isSecondPoint = true;
  719. if (m_objects.size()==0)
  720. m_first_point = m_cur_point;
  721. m_step=1;
  722. m_app->GetCommandPanel()->SetActiveRadio(m_step+2);
  723. m_app->GetCommandPanel()->EnableRadio(m_step+1,false);
  724. m_message.LoadString(IDS_PREV);
  725. m_app->GetCommandPanel()->RenameRadio(m_step+1,m_message);
  726. }
  727. else
  728. if (m_isSecondPoint)
  729. {
  730. if (sgSpaceMath::PointsDistance(m_tmp_first_point,m_cur_point)<0.00001)
  731. {
  732. m_message.LoadString(IDS_ERR_PNT_AS_PREV);
  733. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  734. m_message);
  735. return;
  736. }
  737. if (m_lines)
  738. {
  739. if (m_get_first_point)
  740. m_get_first_point->SetPoint(m_cur_point.x,
  741. m_cur_point.y,
  742. m_cur_point.z);
  743. sgCLine* ll = sgCreateLine(m_tmp_first_point.x,
  744. m_tmp_first_point.y,
  745. m_tmp_first_point.z,
  746. m_cur_point.x,
  747. m_cur_point.y,
  748. m_cur_point.z);
  749. m_objects.push_back(ll);
  750. m_tmp_first_point = m_cur_point;
  751. m_isFirstPoint = false;
  752. m_isSecondPoint = true;
  753. }
  754. else
  755. {
  756. m_tmp_second_point = m_cur_point;
  757. m_isFirstPoint = false;
  758. m_isSecondPoint = false;
  759. m_isLastPointOnArc = true;
  760. m_step=2;
  761. m_app->GetCommandPanel()->SetActiveRadio(m_step+2);
  762. m_app->GetCommandPanel()->EnableRadio(m_step+1,false);
  763. if (m_select_obj_type_panel)
  764. m_select_obj_type_panel->EnableLineType(false);
  765. }
  767. int snSz = m_app->GetViewPort()->GetSnapSize();
  768. double  coords[3];
  769. m_app->GetViewPort()->ProjectWorldPoint(m_first_point,coords[0],coords[1],coords[2]);
  770. if (sqrt((coords[0]-pX)*(coords[0]-pX)+
  771. (coords[1]-pY)*(coords[1]-pY))<=snSz ||
  772. sgSpaceMath::PointsDistance(m_first_point,m_cur_point)<0.00001)
  773. m_can_close = true;
  774. if (m_lines && m_can_close)
  775. {
  776. m_message.LoadString(IDS_CLOSE_CONTOUR);
  777. if (AfxMessageBox(m_message,MB_YESNO)==IDYES)
  778. {
  779. sgCObject* lastO = m_objects[m_objects.size()-1];
  780. ASSERT(lastO->GetType()==SG_OT_LINE);
  781. sgCLine* lastL = reinterpret_cast<sgCLine*>(lastO);
  782. m_tmp_first_point = lastL->GetGeometry()->p1;
  783. sgCObject::DeleteObject(lastO);
  784. m_objects.pop_back();
  785. sgCLine* ll = sgCreateLine(m_tmp_first_point.x,
  786. m_tmp_first_point.y,
  787. m_tmp_first_point.z,
  788. m_first_point.x,
  789. m_first_point.y,
  790. m_first_point.z);
  791. m_objects.push_back(ll);
  792. CreateContourFromObjects();
  793. }
  794. else
  795. m_can_close = false;
  796. }
  797. }
  798. else
  799. if (m_isLastPointOnArc)
  800. {
  801. if (sgSpaceMath::IsPointsOnOneLine(m_tmp_first_point,m_tmp_second_point,m_cur_point))
  802. {
  803. m_message.LoadString(IDS_ARC_ERR_ON_LINE);
  804. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  805. m_message);
  806. return;
  807. }
  808. ASSERT(!m_lines);
  809. ASSERT(m_exist_arc_data);
  810. sgCArc* aa = sgCreateArc(m_arc_geo);
  811. m_objects.push_back(aa);
  812. m_tmp_first_point = m_tmp_second_point;
  813. m_isFirstPoint = false;
  814. m_isSecondPoint = true;
  815. m_isLastPointOnArc = false;
  816. m_exist_arc_data = false;
  817. m_step =1;
  818. m_app->GetCommandPanel()->SetActiveRadio(m_step+2);
  819. m_app->GetCommandPanel()->EnableRadio(m_step+3,false);
  820. if (m_get_first_point)
  821. m_get_first_point->SetPoint(m_tmp_first_point.x,
  822. m_tmp_first_point.y,
  823. m_tmp_first_point.z);
  824. if (m_select_obj_type_panel)
  825. m_select_obj_type_panel->EnableLineType(true);
  826. if (m_can_close)
  827. {
  828. m_message.LoadString(IDS_CLOSE_CONTOUR);
  829. if (AfxMessageBox(m_message,MB_YESNO)==IDYES)
  830. {
  831. sgCObject* lastO = m_objects[m_objects.size()-1];
  832. ASSERT(lastO->GetType()==SG_OT_ARC);
  833. sgCArc* lastA = reinterpret_cast<sgCArc*>(lastO);
  834. m_tmp_first_point = lastA->GetGeometry()->begin;
  835. sgCObject::DeleteObject(lastO);
  836. m_objects.pop_back();
  837. m_arc_geo.FromThreePoints(m_tmp_first_point,m_first_point,
  838. m_cur_point,false);
  839. sgCArc* aa = sgCreateArc(m_arc_geo);
  840. m_objects.push_back(aa);
  841. CreateContourFromObjects();
  842. }
  843. else
  844. m_can_close = false;
  845. }
  846. }
  847. else
  848. {
  849. ASSERT(0);
  850. }
  851. }
  853.     
  854. }
  856. void  Contour::Draw()
  857. {
  858. if (m_scenar==1)
  859. {
  860. float pC[3];
  861. m_app->GetViewPort()->GetPainter()->GetUserColorPoints(pC[0],pC[1],pC[2]);
  862. m_app->GetViewPort()->GetPainter()->SetCurColor(pC[0],pC[1],pC[2]);
  863. m_app->GetViewPort()->GetPainter()->DrawPoint(m_cur_point);
  864. m_app->GetViewPort()->GetPainter()->GetUserColorLines(pC[0],pC[1],pC[2]);
  865. m_app->GetViewPort()->GetPainter()->SetCurColor(pC[0],pC[1],pC[2]);
  866. size_t sz = m_objects.size();
  867. for(size_t i=0;i<sz;i++)
  868. {
  869. if (m_objects[i]->GetType()==SG_OT_LINE)
  870. {
  871. sgCLine* tmpl = reinterpret_cast<sgCLine*>(m_objects[i]);
  872. m_app->GetViewPort()->GetPainter()->DrawLine(*tmpl->GetGeometry());
  873. continue;
  874. }
  875. if (m_objects[i]->GetType()==SG_OT_ARC)
  876. {
  877. sgCArc* tmpa = reinterpret_cast<sgCArc*>(m_objects[i]);
  878. m_app->GetViewPort()->GetPainter()->DrawArc(*tmpa->GetGeometry());
  879. continue;
  880. }
  881. }
  882. if (m_exist_arc_data)
  883. {
  884. m_app->GetViewPort()->GetPainter()->DrawArc(m_arc_geo);
  885. }
  886. if (m_isSecondPoint)
  887. {
  888. SG_LINE lll;
  889. lll.p1 = m_tmp_first_point;
  890. lll.p2 = m_cur_point;
  891. m_app->GetViewPort()->GetPainter()->DrawLine(lll);
  892. }
  893. }
  894. }
  896. void  Contour::OnEnter()
  897. {
  898. SWITCH_RESOURCE
  899. if (m_scenar==0)
  900. {
  901. m_start_object = m_app->GetViewPort()->GetHotObject();
  903. if (m_start_object==NULL)
  904. {
  905. m_message.LoadString(IDS_ERR_PATH_NO_OBJ);
  906. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  907. m_message);
  908. return;
  909. }
  911. CreateContour(m_start_object);
  913. m_get_object_panel->RemoveAllObjects();
  914. m_get_object_panel->FillList(isObjAddToList);
  916. return;
  917. }
  918. if (m_scenar==1)
  919. {
  920. switch(m_step) 
  921. {
  922. case 0:
  923. if (m_get_first_point)
  924. m_get_first_point->GetPoint(m_cur_point.x,
  925. m_cur_point.y,
  926. m_cur_point.z);
  927. break;
  928. case 1:
  929. if (m_get_second_point)
  930. m_get_second_point->GetPoint(m_cur_point.x,
  931. m_cur_point.y,
  932. m_cur_point.z);
  933. break;
  934. case 2:
  935. if (m_get_third_point)
  936. m_get_third_point->GetPoint(m_cur_point.x,
  937. m_cur_point.y,
  938. m_cur_point.z);
  939. break;
  940. }
  942. if (m_isFirstPoint)
  943. {
  944. m_tmp_first_point = m_cur_point;
  945. m_isFirstPoint = false;
  946. m_isSecondPoint = true;
  947. if (m_objects.size()==0)
  948. m_first_point = m_cur_point;
  949. m_step=1;
  950. m_app->GetCommandPanel()->SetActiveRadio(m_step+2);
  951. m_app->GetCommandPanel()->EnableRadio(m_step+1,false);
  952. m_message.LoadString(IDS_PREV);
  953. m_app->GetCommandPanel()->RenameRadio(m_step+1,m_message);
  954. }
  955. else
  956. if (m_isSecondPoint)
  957. {
  958. if (sgSpaceMath::PointsDistance(m_tmp_first_point,m_cur_point)<0.00001)
  959. {
  960. m_message.LoadString(IDS_ERR_PNT_AS_PREV);
  961. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  962. m_message);
  963. goto unfix;
  964. }
  965. if (m_lines)
  966. {
  967. if (m_get_first_point)
  968. m_get_first_point->SetPoint(m_cur_point.x,
  969. m_cur_point.y,
  970. m_cur_point.z);
  971. sgCLine* ll = sgCreateLine(m_tmp_first_point.x,
  972. m_tmp_first_point.y,
  973. m_tmp_first_point.z,
  974. m_cur_point.x,
  975. m_cur_point.y,
  976. m_cur_point.z);
  977. m_objects.push_back(ll);
  978. m_tmp_first_point = m_cur_point;
  979. m_isFirstPoint = false;
  980. m_isSecondPoint = true;
  981. }
  982. else
  983. {
  984. m_tmp_second_point = m_cur_point;
  985. m_isFirstPoint = false;
  986. m_isSecondPoint = false;
  987. m_isLastPointOnArc = true;
  988. m_step=2;
  989. m_app->GetCommandPanel()->SetActiveRadio(m_step+2);
  990. m_app->GetCommandPanel()->EnableRadio(m_step+1,false);
  991. if (m_select_obj_type_panel)
  992. m_select_obj_type_panel->EnableLineType(false);
  993. }
  995. if (sgSpaceMath::PointsDistance(m_first_point,m_cur_point)<0.00001)
  996. m_can_close = true;
  997. if (m_lines && m_can_close)
  998. {
  999. m_message.LoadString(IDS_CLOSE_CONTOUR);
  1000. if (AfxMessageBox(m_message,MB_YESNO)==IDYES)
  1001. {
  1002. sgCObject* lastO = m_objects[m_objects.size()-1];
  1003. ASSERT(lastO->GetType()==SG_OT_LINE);
  1004. sgCLine* lastL = reinterpret_cast<sgCLine*>(lastO);
  1005. m_tmp_first_point = lastL->GetGeometry()->p1;
  1006. sgCObject::DeleteObject(lastO);
  1007. m_objects.pop_back();
  1008. sgCLine* ll = sgCreateLine(m_tmp_first_point.x,
  1009. m_tmp_first_point.y,
  1010. m_tmp_first_point.z,
  1011. m_first_point.x,
  1012. m_first_point.y,
  1013. m_first_point.z);
  1014. m_objects.push_back(ll);
  1015. CreateContourFromObjects();
  1016. }
  1017. else
  1018. m_can_close = false;
  1019. }
  1020. }
  1021. else
  1022. if (m_isLastPointOnArc)
  1023. {
  1024. if (sgSpaceMath::IsPointsOnOneLine(m_tmp_first_point,m_tmp_second_point,m_cur_point))
  1025. {
  1026. m_message.LoadString(IDS_ARC_ERR_ON_LINE);
  1027. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  1028. m_message);
  1029. goto unfix;
  1030. }
  1031. ASSERT(!m_lines);
  1032. if (m_arc_geo.FromThreePoints(m_tmp_first_point,
  1033. m_tmp_second_point,
  1034. m_cur_point,
  1035. false))
  1036. {
  1037. sgCArc* aa = sgCreateArc(m_arc_geo);
  1038. m_objects.push_back(aa);
  1039. m_tmp_first_point = m_tmp_second_point;
  1040. m_isFirstPoint = false;
  1041. m_isSecondPoint = true;
  1042. m_isLastPointOnArc = false;
  1043. m_exist_arc_data = false;
  1044. m_step =1;
  1045. m_app->GetCommandPanel()->SetActiveRadio(m_step+2);
  1046. m_app->GetCommandPanel()->EnableRadio(m_step+3,false);
  1047. if (m_get_first_point)
  1048. m_get_first_point->SetPoint(m_tmp_first_point.x,
  1049. m_tmp_first_point.y,
  1050. m_tmp_first_point.z);
  1051. if (m_select_obj_type_panel)
  1052. m_select_obj_type_panel->EnableLineType(true);
  1053. if (m_can_close)
  1054. {
  1055. m_message.LoadString(IDS_CLOSE_CONTOUR);
  1056. if (AfxMessageBox(m_message,MB_YESNO)==IDYES)
  1057. {
  1058. sgCObject* lastO = m_objects[m_objects.size()-1];
  1059. ASSERT(lastO->GetType()==SG_OT_ARC);
  1060. sgCArc* lastA = reinterpret_cast<sgCArc*>(lastO);
  1061. m_tmp_first_point = lastA->GetGeometry()->begin;
  1062. sgCObject::DeleteObject(lastO);
  1063. m_objects.pop_back();
  1064. m_arc_geo.FromThreePoints(m_tmp_first_point,m_first_point,
  1065. m_cur_point,false);
  1066. sgCArc* aa = sgCreateArc(m_arc_geo);
  1067. m_objects.push_back(aa);
  1068. CreateContourFromObjects();
  1069. }
  1070. else
  1071. m_can_close = false;
  1072. }
  1073. }
  1074. else
  1075. {
  1076. m_message.LoadString(IDS_ARC_ERR_ON_LINE);
  1077. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  1078. m_message);
  1079. goto unfix;
  1080. }
  1081. }
  1082. else
  1083. {
  1084. ASSERT(0);
  1085. }
  1086. }
  1087. unfix:
  1088. if (m_get_first_point)
  1089. {
  1090. m_get_first_point->XFix(false);
  1091. m_get_first_point->YFix(false);
  1092. m_get_first_point->ZFix(false);
  1093. }
  1094. if (m_get_second_point)
  1095. {
  1096. m_get_second_point->XFix(false);
  1097. m_get_second_point->YFix(false);
  1098. m_get_second_point->ZFix(false);
  1099. }
  1100. if (m_get_third_point)
  1101. {
  1102. m_get_third_point->XFix(false);
  1103. m_get_third_point->YFix(false);
  1104. m_get_third_point->ZFix(false);
  1105. }
  1106. m_app->GetViewPort()->InvalidateViewPort();
  1107. }
  1109. unsigned int  Contour::GetItemsCount()
  1110. {
  1111. return 1;
  1112. }
  1114. void         Contour::GetItem(unsigned int itemID, CString& itSrt)
  1115. {
  1116. SWITCH_RESOURCE
  1117. if (itemID==0) 
  1118. {
  1119. itSrt.LoadString(IDS_END_OPER);
  1120. }
  1121. else
  1122. {
  1123. ASSERT(0);
  1124. }
  1125. }
  1127. void     Contour::GetItemState(unsigned int itemID, bool& enbl, bool& checked)
  1128. {
  1129. enbl = true;
  1130. checked = false;
  1131. }
  1133. HBITMAP   Contour::GetItemBitmap(unsigned int)
  1134. {
  1135. return NULL;
  1136. }
  1138. void         Contour::Run(unsigned int itemID)
  1139. {
  1140. switch(itemID) 
  1141. {
  1142. case 0:
  1143. if (m_objects.size()==0)
  1144. {
  1145. m_message.LoadString(IDS_ERR_PATH_NO_OBJ);
  1146. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  1147. m_message);
  1148. return;
  1149. }
  1150. if (m_objects.size()==1)
  1151. {
  1152. m_message.LoadString(IDS_ERR_PATH_ONE_OBJ);
  1153. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  1154. m_message);
  1155. return;
  1156. }
  1157. CreateContourFromObjects();
  1158. break;
  1159. default:
  1160. ASSERT(0);
  1161. }
  1162. }