Category

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

Graph program

Development Platform:

Visual C++

Equidi.cpp：Code Content
  1. #include "stdafx.h"
  3. #include "Equidi.h"
  5. #include "..//resource.h"
  7. int     equidi_name_index =1;
  9. Equidi::Equidi(IApplicationInterface* appI):
  10. m_app(appI)
  11. , m_start_object(NULL)
  12. , m_get_object_panel(NULL)
  13. , m_get_H_panel(NULL)
  14. , m_step(0)
  15. {
  16. ASSERT(m_app);
  17. }
  19. Equidi::~Equidi()
  20. {
  21. m_app->GetCommandPanel()->RemoveAllDialogs();
  22. m_app->GetViewPort()->InvalidateViewPort();
  23. }
  26. bool    Equidi::PreTranslateMessage(MSG* pMsg)
  27. {
  28. /*if (pMsg->message==WM_KEYUP||
  29. pMsg->message==WM_CHAR)
  30. return false;*/
  32. if (pMsg->message==WM_KEYUP||pMsg->message==WM_KEYDOWN || 
  33. pMsg->message==WM_CHAR)
  34. {
  35. if (pMsg->wParam==VK_RETURN)
  36. {
  37. OnEnter();
  38. return true;
  39. }
  40. if (pMsg->wParam==VK_ESCAPE)
  41. {
  42. m_app->StopCommander();
  43. return true;
  44. }
  45. switch(m_step) {
  46. case 0:
  47. if (m_get_object_panel)
  48. m_get_object_panel->GetWindow()->SendMessage(pMsg->message,
  49. pMsg->wParam,
  50. pMsg->lParam);
  51. break;
  52. case 1:
  53. if (m_get_H_panel)
  54. m_get_H_panel->GetWindow()->SendMessage(pMsg->message,
  55. pMsg->wParam,
  56. pMsg->lParam);
  57. break;
  58. }
  59. if (pMsg->message==WM_KEYDOWN)
  60. return false;
  61. else 
  62. return true;
  63. }
  64. else
  65. {
  66. if (pMsg->hwnd == m_app->GetViewPort()->GetWindow()->m_hWnd)
  67. {
  68. switch(pMsg->message) 
  69. {
  70. case WM_MOUSEMOVE:
  71. MouseMove(pMsg->wParam,GET_X_LPARAM(pMsg->lParam),GET_Y_LPARAM(pMsg->lParam));
  72. return true;
  73. case WM_LBUTTONDOWN:
  74. LeftClick(pMsg->wParam,GET_X_LPARAM(pMsg->lParam),GET_Y_LPARAM(pMsg->lParam));
  75. return true;
  76. default:
  77. return false;
  78. }
  79. }
  80. }
  81. return false;
  82. }
  85. static   bool isObjAddToList(sgCObject* o)
  86. {
  87. if (o->GetType()==SG_OT_CIRCLE ||
  88. o->GetType()==SG_OT_ARC)
  89. return true;
  90. if (o->GetType()==SG_OT_CONTOUR)
  91. {
  92. sgCContour* cc = reinterpret_cast<sgCContour*>(o);
  93. if (!cc->IsLinear() && cc->IsPlane(NULL,NULL))
  94. return true;
  95. else
  96. return false;
  97. }
  98. if (o->GetType()==SG_OT_SPLINE)
  99. {
  100. sgCSpline* cc = reinterpret_cast<sgCSpline*>(o);
  101. if (!cc->IsLinear() && cc->IsPlane(NULL,NULL))
  102. return true;
  103. else
  104. return false;
  105. }
  106. return false;
  107. }
  109. void   Equidi::SendCommanderMessage(ICommander::COMMANDER_MESSAGE mes, void* params)
  110. {
  111. if (mes==ICommander::CM_SWITCH_ROLLUP_DIALOG)
  112. {
  113. ASSERT(params!=NULL);
  114. int   newActiveDlg = *(reinterpret_cast<int*>(params));
  116. ASSERT(newActiveDlg<=1);
  117. m_step = (unsigned int)newActiveDlg;
  118. if (newActiveDlg==0)
  119. {
  120. m_app->GetCommandPanel()->EnableRadio(1,false);
  121. m_message.LoadString(IDS_QEUID_GET_OBJ);
  122. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  123. }
  124. m_app->GetViewPort()->InvalidateViewPort();
  125. return;
  126. }
  127. if (mes==ICommander::CM_SELECT_OBJECT)
  128. {
  129. ASSERT(params!=NULL);
  130. sgCObject* so = (sgCObject*)params;
  131. if (so!=m_start_object)
  132. {
  133. m_app->GetViewPort()->SetHotObject(so);
  134. m_start_object = so;
  135. }
  136. m_app->GetViewPort()->InvalidateViewPort();
  137. }
  138. }
  140. void  Equidi::Start()
  141. {
  142. SWITCH_RESOURCE
  144. m_app->GetCommandPanel()->RemoveAllDialogs();
  146. CString lab;
  147. lab.LoadString(IDS_TOOLTIP_SEVETH);
  148. m_app->StartCommander(lab);
  150. lab.LoadString(IDS_OBJECT);
  151. m_get_object_panel = 
  152. reinterpret_cast<IGetObjectsPanel*>(m_app->GetCommandPanel()->
  153. AddDialog(IBaseInterfaceOfGetDialogs::GET_OBJECTS_DLG,
  154. lab,true));
  156. lab.LoadString(IDS_EQUID_H);
  157. m_get_H_panel = 
  158. reinterpret_cast<IGetNumberPanel*>(m_app->GetCommandPanel()->
  159. AddDialog(IBaseInterfaceOfGetDialogs::GET_NUMBER_DLG,
  160. lab,true));
  162. lab.LoadString(IDS_QEUID_GET_OBJ);
  163. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,lab);
  165. m_app->GetCommandPanel()->SetActiveRadio(0);
  166. m_get_object_panel->SetMultiselectMode(false);
  167. m_get_object_panel->FillList(isObjAddToList);
  169. m_step=0;
  170. }
  172. static  void get_end_points_of_object(sgCObject* ob, SG_POINT& bP, SG_POINT& eP)
  173. {
  174. if (ob->GetType()==SG_OT_ARC)
  175. {
  176. sgCArc* arcO = reinterpret_cast<sgCArc*>(ob);
  177. const SG_ARC* arcG = arcO->GetGeometry();
  178. bP = arcG->begin;
  179. eP = arcG->end;
  180. }
  181. else
  182. if (ob->GetType()==SG_OT_CONTOUR)
  183. {
  184. sgCContour* cO = reinterpret_cast<sgCContour*>(ob);
  185. bP = cO->GetPointFromCoefficient(0.0);
  186. eP = cO->GetPointFromCoefficient(1.0);
  187. }
  188. else
  189. {
  190. ASSERT(0);
  191. }
  192. }
  194. bool  get_point_on_path_after_this(sgCContour* contr, const SG_POINT ppp, SG_POINT& resP)
  195. {
  196. sgCObject* fo = contr->GetChildrenList()->GetHead();
  197. SG_OBJECT_TYPE foT = fo->GetType();
  198. if (foT==SG_OT_LINE)
  199. {
  200. sgCLine* ln = reinterpret_cast<sgCLine*>(fo);
  201. const SG_LINE* lnG = ln->GetGeometry();
  202. if (sgSpaceMath::PointsDistance(lnG->p1,ppp)<0.00001)
  203. {
  204. resP = lnG->p2;
  205. return true;
  206. }
  207. if (sgSpaceMath::PointsDistance(lnG->p2,ppp)<0.00001)
  208. {
  209. resP = lnG->p1;
  210. return true;
  211. }
  212. }
  213. else
  214. if (foT==SG_OT_ARC)
  215. {
  216. sgCArc* ar = reinterpret_cast<sgCArc*>(fo);
  217. const int pntsCnt = ar->GetPointsCount();
  218. const SG_POINT* arcPnts = ar->GetPoints();
  219. if (sgSpaceMath::PointsDistance(*arcPnts,ppp)<0.00001)
  220. {
  221. resP = arcPnts[1];
  222. return true;
  223. }
  224. if (sgSpaceMath::PointsDistance(*(arcPnts+pntsCnt-1),ppp)<0.00001)
  225. {
  226. resP = arcPnts[pntsCnt-2];
  227. return true;
  228. }
  229. }
  230. else
  231. if (foT==SG_OT_CONTOUR)
  232. {
  233. sgCContour* co = reinterpret_cast<sgCContour*>(fo);
  234. if (get_point_on_path_after_this(co, ppp, resP))
  235. return true;
  236. }
  239. sgCObject* so = contr->GetChildrenList()->GetTail();
  240. SG_OBJECT_TYPE soT = so->GetType();
  241. if (soT==SG_OT_LINE)
  242. {
  243. sgCLine* ln = reinterpret_cast<sgCLine*>(so);
  244. const SG_LINE* lnG = ln->GetGeometry();
  245. if (sgSpaceMath::PointsDistance(lnG->p1,ppp)<0.00001)
  246. {
  247. resP = lnG->p2;
  248. return true;
  249. }
  250. if (sgSpaceMath::PointsDistance(lnG->p2,ppp)<0.00001)
  251. {
  252. resP = lnG->p1;
  253. return true;
  254. }
  255. }
  256. else
  257. if (soT==SG_OT_ARC)
  258. {
  259. sgCArc* ar = reinterpret_cast<sgCArc*>(so);
  260. const int pntsCnt = ar->GetPointsCount();
  261. const SG_POINT* arcPnts = ar->GetPoints();
  262. if (sgSpaceMath::PointsDistance(*arcPnts,ppp)<0.00001)
  263. {
  264. resP = arcPnts[1];
  265. return true;
  266. }
  267. if (sgSpaceMath::PointsDistance(*(arcPnts+pntsCnt-1),ppp)<0.00001)
  268. {
  269. resP = arcPnts[pntsCnt-2];
  270. return true;
  271. }
  272. }
  273. else
  274. if (soT==SG_OT_CONTOUR)
  275. {
  276. sgCContour* co = reinterpret_cast<sgCContour*>(so);
  277. if (get_point_on_path_after_this(co, ppp, resP))
  278. return true;
  279. }
  280. return false;
  281. }
  283. bool  Equidi::CheckStartObject()
  284. {
  285. SG_OBJECT_TYPE oT = m_start_object->GetType();
  286. if (oT==SG_OT_ARC)
  287. {
  288. sgCArc* ar = reinterpret_cast<sgCArc*>(m_start_object);
  289. /*const SG_ARC* arcG = ar->GetGeometry();
  290. m_end_points[0] = arcG->begin;
  291. m_end_points[1] = arcG->end;
  292. m_end_vectors[0].x = arcG->center.x-arcG->begin.x;
  293. m_end_vectors[0].y = arcG->center.y-arcG->begin.y;
  294. m_end_vectors[0].z = arcG->center.z-arcG->begin.z;
  295. sgSpaceMath::NormalVector(&m_end_vectors[0]);
  296. m_end_vectors[1].x = arcG->center.x-arcG->end.x;
  297. m_end_vectors[1].y = arcG->center.y-arcG->end.y;
  298. m_end_vectors[1].z = arcG->center.z-arcG->end.z;
  299. sgSpaceMath::NormalVector(&m_end_vectors[1]);
  300. return true;*/
  302. const SG_POINT*  pnts = ar->GetPoints();
  303. m_end_points[0] = pnts[0];
  304. m_end_points[1] = pnts[ar->GetPointsCount()-1];
  305. SG_VECTOR plN = ar->GetGeometry()->normal;
  306. plN.x = -plN.x; plN.y = -plN.y; plN.z = -plN.z;
  307. SG_VECTOR tmpV;
  308. tmpV.x = pnts[1].x - pnts[0].x;
  309. tmpV.y = pnts[1].y - pnts[0].y;
  310. tmpV.z = pnts[1].z - pnts[0].z;
  311. m_end_vectors[0] = sgSpaceMath::VectorsVectorMult(plN,tmpV);
  312. sgSpaceMath::NormalVector(m_end_vectors[0]);
  313. tmpV.x = pnts[ar->GetPointsCount()-1].x - pnts[ar->GetPointsCount()-2].x;
  314. tmpV.y = pnts[ar->GetPointsCount()-1].y - pnts[ar->GetPointsCount()-2].y;
  315. tmpV.z = pnts[ar->GetPointsCount()-1].z - pnts[ar->GetPointsCount()-2].z;
  316. m_end_vectors[1] = sgSpaceMath::VectorsVectorMult(plN,tmpV);
  317. sgSpaceMath::NormalVector(m_end_vectors[1]);
  318. return true;
  319. }
  320. if (oT==SG_OT_CIRCLE)
  321. {
  322. sgCCircle* cr = reinterpret_cast<sgCCircle*>(m_start_object);
  323. const SG_CIRCLE* crG = cr->GetGeometry();
  324. const SG_POINT*  pnts = cr->GetPoints();
  325. m_end_points[0] = pnts[0];
  326. m_end_points[1] = m_end_points[0];
  327. m_end_vectors[0].x = crG->center.x-pnts[0].x;
  328. m_end_vectors[0].y = crG->center.y-pnts[0].y;
  329. m_end_vectors[0].z = crG->center.z-pnts[0].z;
  330. sgSpaceMath::NormalVector(m_end_vectors[0]);
  331. m_end_vectors[1] = m_end_vectors[0];
  332. return true;
  333. }
  334. if (oT==SG_OT_SPLINE)
  335. {
  336. sgCSpline* spl = reinterpret_cast<sgCSpline*>(m_start_object);
  337. const SG_SPLINE* spG = spl->GetGeometry();
  338. const SG_POINT*  pnts = spG->GetPoints();
  339. m_end_points[0] = pnts[0];
  340. if (!spl->IsClosed())
  341. m_end_points[1] = pnts[spG->GetPointsCount()-1];
  342. else
  343. m_end_points[1] = m_end_points[0];
  344. SG_VECTOR plN;
  345. double    plD;
  346. if (!spl->IsPlane(&plN,&plD))
  347. return false;
  348. SG_VECTOR tmpV;
  349. tmpV.x = pnts[1].x - pnts[0].x;
  350. tmpV.y = pnts[1].y - pnts[0].y;
  351. tmpV.z = pnts[1].z - pnts[0].z;
  352. m_end_vectors[0] = sgSpaceMath::VectorsVectorMult(plN,tmpV);
  353. sgSpaceMath::NormalVector(m_end_vectors[0]);
  354. if (!spl->IsClosed())
  355. {
  356. tmpV.x = pnts[spG->GetPointsCount()-1].x - pnts[spG->GetPointsCount()-2].x;
  357. tmpV.y = pnts[spG->GetPointsCount()-1].y - pnts[spG->GetPointsCount()-2].y;
  358. tmpV.z = pnts[spG->GetPointsCount()-1].z - pnts[spG->GetPointsCount()-2].z;
  359. m_end_vectors[1] = sgSpaceMath::VectorsVectorMult(plN,tmpV);
  360. sgSpaceMath::NormalVector(m_end_vectors[1]);
  361. }
  362. else
  363. m_end_vectors[1] = m_end_vectors[0];
  364. return true;
  365. }
  366. if (oT==SG_OT_CONTOUR)
  367. {
  368. sgCContour* cnt = reinterpret_cast<sgCContour*>(m_start_object);
  369. //cnt->GetEndPoints(m_end_points[0],m_end_points[1]);
  370. m_end_points[0] = cnt->GetPointFromCoefficient(0.0);
  371. m_end_points[1] = cnt->GetPointFromCoefficient(1.0);
  372. SG_POINT secP;
  373. SG_VECTOR plN;
  374. double    plD;
  375. if (!cnt->IsPlane(&plN,&plD))
  376. return false;
  377. if (!get_point_on_path_after_this(cnt, m_end_points[0], secP))
  378. {
  379. ASSERT(0);
  380. return false;
  381. }
  382. SG_VECTOR tmpV;
  383. tmpV.x = secP.x - m_end_points[0].x;
  384. tmpV.y = secP.y - m_end_points[0].y;
  385. tmpV.z = secP.z - m_end_points[0].z;
  386. m_end_vectors[0] = sgSpaceMath::VectorsVectorMult(plN,tmpV);
  387. sgSpaceMath::NormalVector(m_end_vectors[0]);
  389. if (!cnt->IsClosed())
  390. {
  391. if (!get_point_on_path_after_this(cnt, m_end_points[1], secP))
  392. {
  393. ASSERT(0);
  394. return false;
  395. }
  396. tmpV.x = m_end_points[1].x - secP.x;
  397. tmpV.y = m_end_points[1].y - secP.y;
  398. tmpV.z = m_end_points[1].z - secP.z;
  399. m_end_vectors[1] = sgSpaceMath::VectorsVectorMult(plN,tmpV);
  400. sgSpaceMath::NormalVector(m_end_vectors[1]);
  401. }
  402. else
  403. {
  404. m_end_points[1] = m_end_points[0];
  405. m_end_vectors[1] = m_end_vectors[0];
  406. }
  407. return true;
  408. }
  409. return false;
  410. }
  412. void  Equidi::MouseMove(unsigned int nFlags,int pX,int pY)
  413. {
  414. switch(m_step) {
  415. case 0:
  416. if (!(nFlags & MK_LBUTTON))
  417. {
  418. int snapSz = m_app->GetViewPort()->GetSnapSize();
  420. sgCObject* ho = m_app->GetViewPort()->GetTopObject(
  421. m_app->GetViewPort()->GetHitsInRect(CRect(pX-snapSz, pY-snapSz,
  422. pX+snapSz, pY+snapSz)));
  423. if (ho && isObjAddToList(ho))
  424. {
  425. m_app->GetViewPort()->SetHotObject(ho);
  426. if (m_get_object_panel)
  427. m_get_object_panel->SelectObject(ho,true);
  428. }
  429. else
  430. {
  431. m_app->GetViewPort()->SetHotObject(NULL);
  432. if (m_get_object_panel)
  433. m_get_object_panel->SelectObject(NULL,true);
  434. }
  435. m_app->GetViewPort()->InvalidateViewPort();
  436. }
  437. break;
  438. case 1:
  439. {
  440. ASSERT(m_get_H_panel);
  442. if (!m_app->GetViewPort()->
  443. ProjectScreenPointOnLine(pX,pY,m_end_points[0],m_end_vectors[0],
  444. m_projection))
  445. {
  446. m_otstup = 0.0;
  447. m_get_H_panel->SetNumber(m_otstup);
  448. break;
  449. }
  450. char sig = (((m_projection.x-m_end_points[0].x)*m_end_vectors[0].x+
  451. (m_projection.y-m_end_points[0].y)*m_end_vectors[0].y+
  452. (m_projection.z-m_end_points[0].z)*m_end_vectors[0].z)>0)?1:-1;
  454. m_otstup = sgSpaceMath::PointsDistance(m_end_points[0],m_projection)*sig;
  455. m_otstup = m_app->ApplyPrecision(m_otstup);
  456. m_projection.x = m_end_points[0].x+m_end_vectors[0].x*m_otstup;
  457. m_projection.y = m_end_points[0].y+m_end_vectors[0].y*m_otstup;
  458. m_projection.z = m_end_points[0].z+m_end_vectors[0].z*m_otstup;
  459. m_get_H_panel->SetNumber(m_otstup);
  460. m_app->GetViewPort()->InvalidateViewPort();
  461. }
  462. break;
  463. default:
  464. ASSERT(0);
  465. return;
  466. }
  467. }
  469. void  Equidi::LeftClick(unsigned int nFlags,int pX,int pY)
  470. {
  471. SWITCH_RESOURCE
  472. switch(m_step) 
  473. {
  474. case 0:
  475. m_start_object = m_app->GetViewPort()->GetHotObject();
  477. if (m_start_object==NULL)
  478. {
  479. m_message.LoadString(IDS_EQ_ERR_NO_OBJ);
  480. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  481. m_message);
  482. return;
  483. }
  486. m_app->GetViewPort()->InvalidateViewPort();
  488. if (CheckStartObject())
  489. {
  490. m_step++;
  491. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  492. m_message.LoadString(IDS_EQUID_GET_H);
  493. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  494. }
  495. break;
  496. case 1:
  497. if (m_start_object->GetType()==SG_OT_ARC)
  498. {
  499. sgCArc* ar = reinterpret_cast<sgCArc*>(m_start_object);
  500. sgCObject* nO = ar->GetEquidistantContour(m_otstup,m_otstup,false);
  501. if (!nO)
  502. {
  503. m_message.LoadString(IDS_EQ_ERR);
  504. m_app->PutMessage(IApplicationInterface::MT_ERROR,m_message);
  505. return;
  506. }
  507. CString nm;
  508. nm.LoadString(IDS_TOOLTIP_SEVETH);
  509. CString nmInd;
  510. nmInd.Format("%i",equidi_name_index);
  511. nm+=nmInd;
  512. nO->SetName(nm);
  513. equidi_name_index++;
  514. sgGetScene()->StartUndoGroup();
  515. sgGetScene()->AttachObject(nO);
  516. m_app->ApplyAttributes(nO);
  517. sgGetScene()->EndUndoGroup();
  518. m_step=0;
  519. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  520. m_app->GetCommandPanel()->EnableRadio(1,false);
  521. if (m_get_object_panel)
  522. m_get_object_panel->AddObject(nO,false);
  523. m_message.LoadString(IDS_QEUID_GET_OBJ);
  524. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  525. m_app->GetViewPort()->InvalidateViewPort();
  526. }
  527. if (m_start_object->GetType()==SG_OT_CIRCLE)
  528. {
  529. sgCCircle* cr = reinterpret_cast<sgCCircle*>(m_start_object);
  530. sgCObject* nO = cr->GetEquidistantContour(m_otstup,m_otstup,false);
  531. if (!nO)
  532. {
  533. m_message.LoadString(IDS_EQ_ERR);
  534. m_app->PutMessage(IApplicationInterface::MT_ERROR,m_message);
  535. return;
  536. }
  537. CString nm;
  538. nm.LoadString(IDS_TOOLTIP_SEVETH);
  539. CString nmInd;
  540. nmInd.Format("%i",equidi_name_index);
  541. nm+=nmInd;
  542. nO->SetName(nm);
  543. equidi_name_index++;
  544. sgGetScene()->StartUndoGroup();
  545. sgGetScene()->AttachObject(nO);
  546. m_app->ApplyAttributes(nO);
  547. sgGetScene()->EndUndoGroup();
  548. m_step=0;
  549. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  550. m_app->GetCommandPanel()->EnableRadio(1,false);
  551. if (m_get_object_panel)
  552. m_get_object_panel->AddObject(nO,false);
  553. m_message.LoadString(IDS_QEUID_GET_OBJ);
  554. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  555. m_app->GetViewPort()->InvalidateViewPort();
  556. }
  557. if (m_start_object->GetType()==SG_OT_SPLINE)
  558. {
  559. sgCSpline* spl = reinterpret_cast<sgCSpline*>(m_start_object);
  560. sgCObject* nO = spl->GetEquidistantContour(m_otstup,m_otstup,false);
  561. if (!nO)
  562. {
  563. m_message.LoadString(IDS_EQ_ERR);
  564. m_app->PutMessage(IApplicationInterface::MT_ERROR,m_message);
  565. return;
  566. }
  567. CString nm;
  568. nm.LoadString(IDS_TOOLTIP_SEVETH);
  569. CString nmInd;
  570. nmInd.Format("%i",equidi_name_index);
  571. nm+=nmInd;
  572. nO->SetName(nm);
  573. equidi_name_index++;
  574. sgGetScene()->StartUndoGroup();
  575. sgGetScene()->AttachObject(nO);
  576. m_app->ApplyAttributes(nO);
  577. sgGetScene()->EndUndoGroup();
  578. m_step=0;
  579. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  580. m_app->GetCommandPanel()->EnableRadio(1,false);
  581. if (m_get_object_panel)
  582. m_get_object_panel->AddObject(nO,false);
  583. m_message.LoadString(IDS_QEUID_GET_OBJ);
  584. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  585. m_app->GetViewPort()->InvalidateViewPort();
  586. }
  587. if (m_start_object->GetType()==SG_OT_CONTOUR)
  588. {
  589. sgCContour* cn = reinterpret_cast<sgCContour*>(m_start_object);
  590. sgCObject* nO = cn->GetEquidistantContour(m_otstup,m_otstup,false);
  591. if (!nO)
  592. {
  593. m_message.LoadString(IDS_EQ_ERR);
  594. m_app->PutMessage(IApplicationInterface::MT_ERROR,m_message);
  595. return;
  596. }
  597. CString nm;
  598. nm.LoadString(IDS_TOOLTIP_SEVETH);
  599. CString nmInd;
  600. nmInd.Format("%i",equidi_name_index);
  601. nm+=nmInd;
  602. nO->SetName(nm);
  603. equidi_name_index++;
  604. sgGetScene()->StartUndoGroup();
  605. sgGetScene()->AttachObject(nO);
  606. m_app->ApplyAttributes(nO);
  607. sgGetScene()->EndUndoGroup();
  608. m_step=0;
  609. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  610. m_app->GetCommandPanel()->EnableRadio(1,false);
  611. if (m_get_object_panel)
  612. m_get_object_panel->AddObject(nO,false);
  613. m_message.LoadString(IDS_QEUID_GET_OBJ);
  614. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  615. m_app->GetViewPort()->InvalidateViewPort();
  616. }
  617. break;
  618. default:
  619. break;
  620. }
  621. }
  623. void  Equidi::Draw()
  624. {
  625. if (m_step==1)
  626. {
  627. float pC[3];
  628. m_app->GetViewPort()->GetPainter()->GetUserColorPoints(pC[0],pC[1],pC[2]);
  629. m_app->GetViewPort()->GetPainter()->SetCurColor(pC[0],pC[1],pC[2]);
  630. m_app->GetViewPort()->GetPainter()->DrawPoint(m_end_points[0]);
  631. m_app->GetViewPort()->GetPainter()->DrawPoint(m_end_points[1]);
  632. m_app->GetViewPort()->GetPainter()->DrawPoint(m_projection);
  633. SG_LINE ln;
  634. ln.p1 = m_end_points[0];
  635. ln.p2 = m_projection;
  636. m_app->GetViewPort()->GetPainter()->GetUserColorLines(pC[0],pC[1],pC[2]);
  637. m_app->GetViewPort()->GetPainter()->SetCurColor(pC[0],pC[1],pC[2]);
  638. m_app->GetViewPort()->GetPainter()->DrawLine(ln);
  639. ln.p1 = m_end_points[1];
  640. ln.p2.x = m_end_points[1].x+m_end_vectors[1].x*m_otstup;
  641. ln.p2.y = m_end_points[1].y+m_end_vectors[1].y*m_otstup;
  642. ln.p2.z = m_end_points[1].z+m_end_vectors[1].z*m_otstup;
  643. m_app->GetViewPort()->GetPainter()->DrawLine(ln);
  644. }
  645. }
  647. void  Equidi::OnEnter()
  648. {
  649. SWITCH_RESOURCE
  650. switch(m_step) 
  651. {
  652. case 0:
  653. m_start_object = m_app->GetViewPort()->GetHotObject();
  655. if (m_start_object==NULL)
  656. {
  657. m_message.LoadString(IDS_EQ_ERR_NO_OBJ);
  658. m_app->PutMessage(IApplicationInterface::MT_ERROR,
  659. m_message);
  660. return;
  661. }
  664. m_app->GetViewPort()->InvalidateViewPort();
  666. if (CheckStartObject())
  667. {
  668. m_step++;
  669. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  670. m_message.LoadString(IDS_EQUID_GET_H);
  671. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  673. }
  674. break;
  675. case 1:
  676. {
  677. ASSERT(m_get_H_panel);
  679. double m_otstup = m_get_H_panel->GetNumber();
  680. if (m_start_object->GetType()==SG_OT_ARC)
  681. {
  682. sgCArc* ar = reinterpret_cast<sgCArc*>(m_start_object);
  683. sgCObject* nO = ar->GetEquidistantContour(m_otstup,m_otstup,false);
  684. if (!nO)
  685. {
  686. m_message.LoadString(IDS_EQ_ERR);
  687. m_app->PutMessage(IApplicationInterface::MT_ERROR,m_message);
  688. return;
  689. }
  690. CString nm;
  691. nm.LoadString(IDS_TOOLTIP_SEVETH);
  692. CString nmInd;
  693. nmInd.Format("%i",equidi_name_index);
  694. nm+=nmInd;
  695. nO->SetName(nm);
  696. equidi_name_index++;
  697. sgGetScene()->StartUndoGroup();
  698. sgGetScene()->AttachObject(nO);
  699. m_app->ApplyAttributes(nO);
  700. sgGetScene()->EndUndoGroup();
  701. m_step=0;
  702. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  703. m_app->GetCommandPanel()->EnableRadio(1,false);
  704. if (m_get_object_panel)
  705. m_get_object_panel->AddObject(nO,false);
  706. m_message.LoadString(IDS_QEUID_GET_OBJ);
  707. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  708. m_app->GetViewPort()->InvalidateViewPort();
  709. }
  710. if (m_start_object->GetType()==SG_OT_CIRCLE)
  711. {
  712. sgCCircle* cr = reinterpret_cast<sgCCircle*>(m_start_object);
  713. sgCObject* nO = cr->GetEquidistantContour(m_otstup,m_otstup,false);
  714. if (!nO)
  715. {
  716. m_message.LoadString(IDS_EQ_ERR);
  717. m_app->PutMessage(IApplicationInterface::MT_ERROR,m_message);
  718. return;
  719. }
  720. CString nm;
  721. nm.LoadString(IDS_TOOLTIP_SEVETH);
  722. CString nmInd;
  723. nmInd.Format("%i",equidi_name_index);
  724. nm+=nmInd;
  725. nO->SetName(nm);
  726. equidi_name_index++;
  727. sgGetScene()->StartUndoGroup();
  728. sgGetScene()->AttachObject(nO);
  729. m_app->ApplyAttributes(nO);
  730. sgGetScene()->EndUndoGroup();
  731. m_step=0;
  732. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  733. m_app->GetCommandPanel()->EnableRadio(1,false);
  734. if (m_get_object_panel)
  735. m_get_object_panel->AddObject(nO,false);
  736. m_message.LoadString(IDS_QEUID_GET_OBJ);
  737. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  738. m_app->GetViewPort()->InvalidateViewPort();
  739. }
  740. if (m_start_object->GetType()==SG_OT_SPLINE)
  741. {
  742. sgCSpline* spl = reinterpret_cast<sgCSpline*>(m_start_object);
  743. sgCObject* nO = spl->GetEquidistantContour(m_otstup,m_otstup,false);
  744. if (!nO)
  745. {
  746. m_message.LoadString(IDS_EQ_ERR);
  747. m_app->PutMessage(IApplicationInterface::MT_ERROR,m_message);
  748. return;
  749. }
  750. CString nm;
  751. nm.LoadString(IDS_TOOLTIP_SEVETH);
  752. CString nmInd;
  753. nmInd.Format("%i",equidi_name_index);
  754. nm+=nmInd;
  755. nO->SetName(nm);
  756. equidi_name_index++;
  757. sgGetScene()->StartUndoGroup();
  758. sgGetScene()->AttachObject(nO);
  759. m_app->ApplyAttributes(nO);
  760. sgGetScene()->EndUndoGroup();
  761. m_step=0;
  762. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  763. m_app->GetCommandPanel()->EnableRadio(1,false);
  764. if (m_get_object_panel)
  765. m_get_object_panel->AddObject(nO,false);
  766. m_message.LoadString(IDS_QEUID_GET_OBJ);
  767. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  768. m_app->GetViewPort()->InvalidateViewPort();
  769. }
  770. if (m_start_object->GetType()==SG_OT_CONTOUR)
  771. {
  772. sgCContour* cn = reinterpret_cast<sgCContour*>(m_start_object);
  773. sgCObject* nO = cn->GetEquidistantContour(m_otstup,m_otstup,false);
  774. if (!nO)
  775. {
  776. m_message.LoadString(IDS_EQ_ERR);
  777. m_app->PutMessage(IApplicationInterface::MT_ERROR,m_message);
  778. return;
  779. }
  780. CString nm;
  781. nm.LoadString(IDS_TOOLTIP_SEVETH);
  782. CString nmInd;
  783. nmInd.Format("%i",equidi_name_index);
  784. nm+=nmInd;
  785. nO->SetName(nm);
  786. equidi_name_index++;
  787. sgGetScene()->StartUndoGroup();
  788. sgGetScene()->AttachObject(nO);
  789. m_app->ApplyAttributes(nO);
  790. sgGetScene()->EndUndoGroup();
  791. m_step=0;
  792. m_app->GetCommandPanel()->SetActiveRadio(m_step);
  793. m_app->GetCommandPanel()->EnableRadio(1,false);
  794. if (m_get_object_panel)
  795. m_get_object_panel->AddObject(nO,false);
  796. m_message.LoadString(IDS_QEUID_GET_OBJ);
  797. m_app->PutMessage(IApplicationInterface::MT_MESSAGE,m_message);
  798. m_app->GetViewPort()->InvalidateViewPort();
  799. }
  800. }
  801. break;
  802. default:
  803. break;
  804. }
  805. }
  807. unsigned int  Equidi::GetItemsCount()
  808. {
  809. return 0;
  810. }
  812. void         Equidi::GetItem(unsigned int, CString&)
  813. {
  814. }
  816. void     Equidi::GetItemState(unsigned int, bool&, bool&)
  817. {
  818. }
  820. HBITMAP   Equidi::GetItemBitmap(unsigned int)
  821. {
  822. return NULL;
  823. }
  825. void         Equidi::Run(unsigned int)
  826. {
  827. }