自创实体类从AcDbCurve派生,实现一些类方法并动态绘制

admin

1. MyCurve.cpp：
3. #include "StdAfx.h"
4. #include "MyCurve.h"
5. #include "actrans.h"
6. #include "aced.h"
8. //-----------------------------------------------------------------------------
9. Adesk::UInt32 CMyCurve::kCurrentVersionNumber =1 ;
11. //-----------------------------------------------------------------------------
12. ACRX采用DXF采用DEFINE采用MEMBERS (
13. CMyCurve, AcDbCurve,
14. AcDb::kDHL采用CURRENT, AcDb::kMReleaseCurrent,
15. AcDbProxyEntity::kNoOperation, MYCURVE,
16. TESTCMYENTITY1APP
17. |Product Desc: A description for your object
18. |Company: Your company name
19. |WEB Address: Your company WEB site address
20. )
22. //-----------------------------------------------------------------------------
23. static double pi()
24. {
25. return atan(1.0)*4;
26. }
27. CMyCurve::CMyCurve () : AcDbCurve () {
28. }
30. CMyCurve::CMyCurve(const AcGePoint3d &ptC,const AcGePoint3d &ptE,int Layer/* =6 */,int num/* =25 */) : AcDbCurve () {
31. ptCenter=ptC;
32. ptEnd=ptE;
33. layers=Layer;
34. number=num;
35. AcGePoint2d pt1,pt2;
36. pt1.x=ptCenter.x;
37. pt1.y=ptCenter.y;
38. pt2.x=ptEnd.x;
39. pt2.y=ptEnd.y;
40. double radius=pt1.distanceTo(pt2);
41. AcGePoint3dArray pts;
42. AcGePoint3d pt;
43. for (int i=0;i<number*layers;i++)
44. {
45. pt.x=ptCenter.x+radius*cos(2*i*pi()/number);
46. pt.y=ptCenter.y+radius*sin(2*i*pi()/number);
47. pt.z=ptCenter.z+i*((ptEnd.z-ptCenter.z)/layers)/number;
48. pts.append(pt);
49. }
50. AcDb3dPolyline* p3dPline=new AcDb3dPolyline(k3dSimplePoly,pts);
51. pCurve=(CMyCurve*)p3dPline;
52. }
54. CMyCurve::~CMyCurve () {
55. delete pCurve;
56. }
58. //-----------------------------------------------------------------------------
59. //----- AcDbObject protocols
60. //- Dwg Filing protocol
61. void CMyCurve::reset(const AcGePoint3d &ptLast)
62. {
63. pCurve=new CMyCurve(ptCenter,ptLast);
64. }
66. AcGePoint3d CMyCurve::getCenterPoint()
67. {
68. return ptCenter;
69. }
70. void CMyCurve::setCenterPoint(const AcGePoint3d &ptcen)
71. {
72. pCurve=new CMyCurve(ptcen,ptEnd);
73. }
75. void CMyCurve::setEndPoint(const AcGePoint3d &pten)
76. {
77. pCurve=new CMyCurve(ptCenter,pten);
78. }
79. Acad::ErrorStatus CMyCurve::dwgOutFields (AcDbDwgFiler *pFiler) const {
80. assertReadEnabled () ;
81. //----- Save parent class information first.
82. Acad::ErrorStatus es =AcDbCurve::dwgOutFields (pFiler) ;
83. if ( es != Acad::eOk )
84. return (es) ;
85. //----- Object version number needs to be saved first
86. if ( (es =pFiler->writeUInt32 (CMyCurve::kCurrentVersionNumber)) != Acad::eOk )
87. return (es) ;
88. //----- Output params
89. pFiler->writeItem(ptCenter);
90. pFiler->writeItem(ptEnd);
91. pFiler->writeItem(layers);
92. pFiler->writeItem(number);
94. return (pFiler->filerStatus ()) ;
95. }
97. Acad::ErrorStatus CMyCurve::dwgInFields (AcDbDwgFiler *pFiler) {
98. assertWriteEnabled () ;
99. //----- Read parent class information first.
100. Acad::ErrorStatus es =AcDbCurve::dwgInFields (pFiler) ;
101. if ( es != Acad::eOk )
102. return (es) ;
103. //----- Object version number needs to be read first
104. Adesk::UInt32 version =0 ;
105. if ( (es =pFiler->readUInt32 (&version)) != Acad::eOk )
106. return (es) ;
107. if ( version > CMyCurve::kCurrentVersionNumber )
108. return (Acad::eMakeMeProxy) ;
109. //- Uncomment the 2 following lines if your current object implementation cannot
110. //- support previous version of that object.
111. //if ( version < CMyCurve::kCurrentVersionNumber )
112. // return (Acad::eMakeMeProxy) ;
113. //----- Read params
114. pFiler->readItem(&ptCenter);
115. pFiler->readItem(&ptEnd);
116. pFiler->readItem(&layers);
117. pFiler->readItem(&number);
119. return (pFiler->filerStatus ()) ;
120. }
122. //-----------------------------------------------------------------------------
123. //----- AcDbEntity protocols
124. Adesk::Boolean CMyCurve::subWorldDraw (AcGiWorldDraw *mode) {
125. assertReadEnabled () ;
126. acutPrintf(采用T("\nsubworldDraw"));
127. //------ Returning Adesk::kFalse here will force viewportDraw() call
128. pCurve->subWorldDraw(mode);
129. return (Adesk::kFalse) ;
130. }
132. void CMyCurve::subViewportDraw (AcGiViewportDraw *mode) {
133. assertReadEnabled () ;
134. AcDbCurve::subViewportDraw (mode) ;
135. }
137. Adesk::UInt32 CMyCurve::subViewportDrawLogicalFlags (AcGiViewportDraw *vd) {
138. assertReadEnabled () ;
139. return (AcDbCurve::subViewportDrawLogicalFlags (vd)) ;
140. }
142. Adesk::UInt32 CMyCurve::subSetAttributes (AcGiDrawableTraits *traits) {
143. assertReadEnabled () ;
144. return (AcDbCurve::subSetAttributes (traits)) ;
145. }
147. //- Osnap points protocol
148. Acad::ErrorStatus CMyCurve::subGetOsnapPoints (
149. AcDb::OsnapMode osnapMode,
150. int gsSelectionMark,
151. const AcGePoint3d &pickPoint,
152. const AcGePoint3d &lastPoint,
153. const AcGeMatrix3d &viewXform,
154. AcGePoint3dArray &snapPoints,
155. AcDbIntArray &geomIds) const
156. {
157. assertReadEnabled () ;
158. return (AcDbCurve::subGetOsnapPoints (osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds)) ;
159. }
161. Acad::ErrorStatus CMyCurve::subGetOsnapPoints (
162. AcDb::OsnapMode osnapMode,
163. int gsSelectionMark,
164. const AcGePoint3d &pickPoint,
165. const AcGePoint3d &lastPoint,
166. const AcGeMatrix3d &viewXform,
167. AcGePoint3dArray &snapPoints,
168. AcDbIntArray &geomIds,
169. const AcGeMatrix3d &insertionMat) const
170. {
171. assertReadEnabled () ;
172. return (AcDbCurve::subGetOsnapPoints (osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds, insertionMat)) ;
173. }
175. //- Grip points protocol
176. Acad::ErrorStatus CMyCurve::subGetGripPoints (
177. AcGePoint3dArray &gripPoints, AcDbIntArray &osnapModes, AcDbIntArray &geomIds
178. ) const {
179. assertReadEnabled () ;
180. //----- This method is never called unless you return eNotImplemented
181. //----- from the new getGripPoints() method below (which is the default implementation)
183. return (AcDbCurve::subGetGripPoints (gripPoints, osnapModes, geomIds)) ;
184. }
186. Acad::ErrorStatus CMyCurve::subMoveGripPointsAt (const AcDbIntArray &indices, const AcGeVector3d &offset) {
187. assertWriteEnabled () ;
188. //----- This method is never called unless you return eNotImplemented
189. //----- from the new moveGripPointsAt() method below (which is the default implementation)
191. return (AcDbCurve::subMoveGripPointsAt (indices, offset)) ;
192. }
194. Acad::ErrorStatus CMyCurve::subGetGripPoints (
195. AcDbGripDataPtrArray &grips, const double curViewUnitSize, const int gripSize,
196. const AcGeVector3d &curViewDir, const int bitflags
197. ) const {
198. assertReadEnabled () ;
200. //----- If you return eNotImplemented here, that will force AutoCAD to call
201. //----- the older getGripPoints() implementation. The call below may return
202. //----- eNotImplemented depending of your base class.
203. return (AcDbCurve::subGetGripPoints (grips, curViewUnitSize, gripSize, curViewDir, bitflags)) ;
204. }
206. Acad::ErrorStatus CMyCurve::subMoveGripPointsAt (
207. const AcDbVoidPtrArray &gripAppData, const AcGeVector3d &offset,
208. const int bitflags
209. ) {
210. assertWriteEnabled () ;
212. //----- If you return eNotImplemented here, that will force AutoCAD to call
213. //----- the older getGripPoints() implementation. The call below may return
214. //----- eNotImplemented depending of your base class.
215. return (AcDbCurve::subMoveGripPointsAt (gripAppData, offset, bitflags)) ;
216. }
218. //-----------------------------------------------------------------------------
219. //----- AcDbCurve protocols
220. //- Curve property tests.
221. Adesk::Boolean CMyCurve::isClosed () const {
222. assertReadEnabled () ;
223. return (AcDbCurve::isClosed ()) ;
224. }
226. Adesk::Boolean CMyCurve::isPeriodic () const {
227. assertReadEnabled () ;
228. return (AcDbCurve::isPeriodic ()) ;
229. }
231. //- Get planar and start/end geometric properties.
232. Acad::ErrorStatus CMyCurve::getStartParam (double &param) const {
233. assertReadEnabled () ;
234. return (AcDbCurve::getStartParam (param)) ;
235. }
237. Acad::ErrorStatus CMyCurve::getEndParam (double &param) const {
238. assertReadEnabled () ;
239. return (AcDbCurve::getEndParam (param)) ;
240. }
242. Acad::ErrorStatus CMyCurve::getStartPoint (AcGePoint3d &point) const {
243. assertReadEnabled () ;
244. return (AcDbCurve::getStartPoint (point)) ;
245. }
247. Acad::ErrorStatus CMyCurve::getEndPoint (AcGePoint3d &point) const {
248. assertReadEnabled () ;
249. return (AcDbCurve::getEndPoint (point)) ;
250. }
252. //- Conversions to/from parametric/world/distance.
253. Acad::ErrorStatus CMyCurve::getPointAtParam (double param, AcGePoint3d &point) const {
254. assertReadEnabled () ;
255. return (AcDbCurve::getPointAtParam (param, point)) ;
256. }
258. Acad::ErrorStatus CMyCurve::getParamAtPoint (const AcGePoint3d &point, double &param) const {
259. assertReadEnabled () ;
260. return (AcDbCurve::getParamAtPoint (point, param)) ;
261. }
263. Acad::ErrorStatus CMyCurve::getDistAtParam (double param, double &dist) const {
264. assertReadEnabled () ;
265. return (AcDbCurve::getDistAtParam (param, dist)) ;
266. }
268. Acad::ErrorStatus CMyCurve::getParamAtDist (double dist, double &param) const {
269. assertReadEnabled () ;
270. return (AcDbCurve::getParamAtDist (dist, param)) ;
271. }
273. Acad::ErrorStatus CMyCurve::getDistAtPoint (const AcGePoint3d &point , double &dist) const {
274. assertReadEnabled () ;
275. return (AcDbCurve::getDistAtPoint (point, dist)) ;
276. }
278. Acad::ErrorStatus CMyCurve::getPointAtDist (double dist, AcGePoint3d &point) const {
279. assertReadEnabled () ;
280. return (AcDbCurve::getPointAtDist (dist, point)) ;
281. }
283. //- Derivative information.
284. Acad::ErrorStatus CMyCurve::getFirstDeriv (double param, AcGeVector3d &firstDeriv) const {
285. assertReadEnabled () ;
286. return (AcDbCurve::getFirstDeriv (param, firstDeriv)) ;
287. }
289. Acad::ErrorStatus CMyCurve::getFirstDeriv (const AcGePoint3d &point, AcGeVector3d &firstDeriv) const {
290. assertReadEnabled () ;
291. return (AcDbCurve::getFirstDeriv (point, firstDeriv)) ;
292. }
294. Acad::ErrorStatus CMyCurve::getSecondDeriv (double param, AcGeVector3d &secDeriv) const {
295. assertReadEnabled () ;
296. return (AcDbCurve::getSecondDeriv (param, secDeriv)) ;
297. }
299. Acad::ErrorStatus CMyCurve::getSecondDeriv (const AcGePoint3d &point, AcGeVector3d &secDeriv) const {
300. assertReadEnabled () ;
301. return (AcDbCurve::getSecondDeriv (point, secDeriv)) ;
302. }
304. //- Closest point on curve.
305. Acad::ErrorStatus CMyCurve::getClosestPointTo (const AcGePoint3d &givenPnt, AcGePoint3d &pointOnCurve, Adesk::Boolean extend /*=Adesk::kFalse*/) const {
306. assertReadEnabled () ;
307. return (AcDbCurve::getClosestPointTo (givenPnt, pointOnCurve, extend)) ;
308. }
310. Acad::ErrorStatus CMyCurve::getClosestPointTo (const AcGePoint3d &givenPnt, const AcGeVector3d &direction, AcGePoint3d &pointOnCurve, Adesk::Boolean extend /*=Adesk::kFalse*/) const {
311. assertReadEnabled () ;
312. return (AcDbCurve::getClosestPointTo (givenPnt, direction, pointOnCurve, extend)) ;
313. }
315. //- Get a projected copy of the curve.
316. Acad::ErrorStatus CMyCurve::getOrthoProjectedCurve (const AcGePlane &plane, AcDbCurve *&projCrv) const {
317. assertReadEnabled () ;
318. return (AcDbCurve::getOrthoProjectedCurve (plane, projCrv)) ;
319. }
321. Acad::ErrorStatus CMyCurve::getProjectedCurve (const AcGePlane &plane, const AcGeVector3d &projDir, AcDbCurve *&projCrv) const {
322. assertReadEnabled () ;
323. return (AcDbCurve::getProjectedCurve (plane, projDir, projCrv)) ;
324. }
326. //- Get offset, spline and split copies of the curve.
327. Acad::ErrorStatus CMyCurve::getOffsetCurves (double offsetDist, AcDbVoidPtrArray &offsetCurves) const {
328. assertReadEnabled () ;
329. return (AcDbCurve::getOffsetCurves (offsetDist, offsetCurves)) ;
330. }
332. Acad::ErrorStatus CMyCurve::getOffsetCurvesGivenPlaneNormal (const AcGeVector3d &normal, double offsetDist, AcDbVoidPtrArray &offsetCurves) const {
333. assertReadEnabled () ;
334. return (AcDbCurve::getOffsetCurvesGivenPlaneNormal (normal, offsetDist, offsetCurves)) ;
335. }
337. Acad::ErrorStatus CMyCurve::getSpline (AcDbSpline *&spline) const {
338. assertReadEnabled () ;
339. return (AcDbCurve::getSpline (spline)) ;
340. }
342. Acad::ErrorStatus CMyCurve::getSplitCurves (const AcGeDoubleArray &params, AcDbVoidPtrArray &curveSegments) const {
343. assertReadEnabled () ;
344. return (AcDbCurve::getSplitCurves (params, curveSegments)) ;
345. }
347. Acad::ErrorStatus CMyCurve::getSplitCurves (const AcGePoint3dArray &points, AcDbVoidPtrArray &curveSegments) const {
348. assertReadEnabled () ;
349. return (AcDbCurve::getSplitCurves (points, curveSegments)) ;
350. }
352. //- Extend the curve.
353. Acad::ErrorStatus CMyCurve::extend (double newParam) {
354. assertReadEnabled () ;
355. return (AcDbCurve::extend (newParam)) ;
356. }
358. Acad::ErrorStatus CMyCurve::extend (Adesk::Boolean extendStart, const AcGePoint3d &toPoint) {
359. assertReadEnabled () ;
360. return (AcDbCurve::extend (extendStart, toPoint)) ;
361. }
363. //- Area calculation.
364. Acad::ErrorStatus CMyCurve::getArea (double &area) const {
365. assertReadEnabled () ;
366. return (AcDbCurve::getArea (area)) ;
367. }
369. MyJig.cpp：
371. #include "StdAfx.h"
372. #include "MyJig.h"
373. #include <math.h>
374. #include "..\..\cmyentity1\cmyentity1\entity.h"
376. //-----------------------------------------------------------------------------
377. CMyJig::CMyJig () : AcEdJig ()
378. {
379. m采用pEnt=NULL;
380. }
382. CMyJig::~CMyJig () {
383. }
385. //-----------------------------------------------------------------------------
386. static AcDbObjectId AddToModelSpace(AcDbEntity *pEnt)
387. {
388. AcDbBlockTable *pBlockTable;
389. acdbHostApplicationServices()->workingDatabase() ->getBlockTable(pBlockTable, AcDb::kForRead);
390. AcDbBlockTableRecord *pBlockTableRecord;
392. pBlockTable->getAt(ACDB采用MODEL采用SPACE, pBlockTableRecord,AcDb::kForWrite);
393. AcDbObjectId entId;
394. pBlockTableRecord->appendAcDbEntity(entId, pEnt);
395. pEnt->close();
396. pBlockTable->close();
397. pBlockTableRecord->close();
398. return entId;
399. }
400. static AcDbObjectId AddToCurrentSpace(AcDbEntity *pEnt)
401. {
402. AcDbBlockTable *pBlockTable;
403. AcDbDatabase *pDb=acdbHostApplicationServices()->workingDatabase();
404. pDb->getBlockTable(pBlockTable, AcDb::kForRead);
405. AcDbObjectId currentSpaceId=pDb->currentSpaceId();
406. AcDbBlockTableRecord *pBlockTableRecord;
407. if (acdbOpenObject(pBlockTableRecord,currentSpaceId,AcDb::kForWrite)!=Acad::eOk)
408. {
409. return AcDbObjectId::kNull;
410. }
411. AcDbObjectId entId;
412. pBlockTableRecord->appendAcDbEntity(entId, pEnt);
413. pBlockTable->close();
414. pBlockTableRecord->close();
415. return entId;
416. }
418. static double pi()
419. {
420. return atan(1.0)*4;
421. }
422. bool CMyJig::doIt(const AcGePoint3d &ptCenter)
423. {
424. m采用ptCenter=ptCenter;
425. m采用pEnt=new CMyCurve(m采用ptCenter,m采用ptCenter,6,25);
426. setDispPrompt(采用T("指定下一点："));
427. AcEdJig::DragStatus stat=drag();
429. if (stat==kNormal)
430. {
431. AddToModelSpace(m采用pEnt);
432. m采用pEnt->close();
433. return true;
434. }
435. else
436. {
437. delete m采用pEnt;
438. return false;
439. }
440. }
442. AcEdJig::DragStatus CMyJig::sampler () {
443. setUserInputControls((UserInputControls)(AcEdJig::kAccept3dCoordinates|AcEdJig::kNoNegativeResponseAccepted|AcEdJig::kNullResponseAccepted));
444. static AcGePoint3d pt;
445. DragStatus stat=acquirePoint(m采用ptCur);
446. if (pt!=m采用ptCur)
447. {
448. pt=m采用ptCur;
449. }
450. else if (stat==AcEdJig::kNormal)
451. {
452. return AcEdJig::kNoChange;
453. }
454. return stat;
455. }
457. //-----------------------------------------------------------------------------
458. //- Jigged entity update
459. Adesk::Boolean CMyJig::update () {
460. // AcGeVector2d ver(m采用ptCur.x-m采用ptCenter.x,m采用ptCur.y-m采用ptCenter.y);
461. // for (int i=1;i<4;i++)
462. // {
463. // AcGePoint3d pt;
464. // ver.rotateBy(2*pi()/3);
465. // pt.x=m采用ptCenter.x+ver.x;
466. // pt.y=m采用ptCenter.y+ver.y;
467. // pt.z=m采用ptCenter.z;
468. // m采用pEnt->setVertexAt(i-1,pt);
469. // }
470. m采用pEnt->reset(m采用ptCur);
471. return Adesk::kTrue;
472. }
474. //-----------------------------------------------------------------------------
475. //- Jigged entity pointer return
476. AcDbEntity *CMyJig::entity () const {
477. return m采用pEnt;
478. }
482. acrxEntryPoint.cpp：
484. #include "StdAfx.h"
485. #include "resource.h"
486. #include "..\CMyEntity1\Entity.h"
487. #include "acgi.h"
488. #include "myjig.h"
489. #include "..\..\cmyentity1\cmyentity1\mycurve.h"
492. //-----------------------------------------------------------------------------
493. #define szRDS 采用RXST("zff")
495. //-----------------------------------------------------------------------------
496. //----- ObjectARX EntryPoint
497. class CObjectARXApp : public AcRxArxApp {
499. public:
500. CObjectARXApp () : AcRxArxApp () {}
502. virtual AcRx::AppRetCode On采用kInitAppMsg (void *pkt) {
503. // TODO: Load dependencies here
505. // You *must* call On采用kInitAppMsg here
506. AcRx::AppRetCode retCode =AcRxArxApp::On采用kInitAppMsg (pkt) ;
508. // TODO: Add your initialization code here
510. return (retCode) ;
511. }
513. virtual AcRx::AppRetCode On采用kUnloadAppMsg (void *pkt) {
514. // TODO: Add your code here
516. // You *must* call On采用kUnloadAppMsg here
517. AcRx::AppRetCode retCode =AcRxArxApp::On采用kUnloadAppMsg (pkt) ;
519. // TODO: Unload dependencies here
521. return (retCode) ;
522. }
524. virtual void RegisterServerComponents () {
525. }
526. static double pi()
527. {
528. return atan(1.0)*4;
529. }
530. static AcDbObjectId AddToModelSpace(AcDbEntity *pEnt)
531. {
532. AcDbBlockTable *pBlockTable;
533. acdbHostApplicationServices()->workingDatabase() ->getBlockTable(pBlockTable, AcDb::kForRead);
534. AcDbBlockTableRecord *pBlockTableRecord;
536. pBlockTable->getAt(ACDB采用MODEL采用SPACE, pBlockTableRecord,AcDb::kForWrite);
537. AcDbObjectId entId;
538. pBlockTableRecord->appendAcDbEntity(entId, pEnt);
539. pBlockTable->close();
540. pBlockTableRecord->close();
541. return entId;
542. }
543. static AcDbObjectId AddToCurrentSpace(AcDbEntity *pEnt)
544. {
545. AcDbBlockTable *pBlockTable;
546. AcDbDatabase *pDb=acdbHostApplicationServices()->workingDatabase();
547. pDb->getBlockTable(pBlockTable, AcDb::kForRead);
548. AcDbObjectId currentSpaceId=pDb->currentSpaceId();
549. AcDbBlockTableRecord *pBlockTableRecord;
550. if (acdbOpenObject(pBlockTableRecord,currentSpaceId,AcDb::kForWrite)!=Acad::eOk)
551. {
552. return AcDbObjectId::kNull;
553. }
554. AcDbObjectId entId;
555. pBlockTableRecord->appendAcDbEntity(entId, pEnt);
556. pBlockTable->close();
557. pBlockTableRecord->close();
558. return entId;
559. }
561. static void zffObjectARX采用MyCommand1(void)
562. {
563. ads采用point pt;
564. acedGetPoint(NULL,采用T("指定中心点："),pt);
565. CMyJig jig;
566. jig.doIt(asPnt3d(pt));
567. }
568. } ;
570. //-----------------------------------------------------------------------------
571. IMPLEMENT采用ARX采用ENTRYPOINT(CObjectARXApp)
573. ACED采用ARXCOMMAND采用ENTRY采用AUTO(CObjectARXApp, zffObjectARX, 采用MyCommand1, MyCommand1, ACRX采用CMD采用TRANSPARENT, NULL)
576. https://www.cnblogs.com/NewAutoMan/p/6373661.html

复制代码