自创实体类从AcDbCurve派生,实现一些类方法并动态绘制 _FTOOL(膜结构设计与绘图MSDD)

admin1

功能：自创实体类从AcDbCurve派生,实现一些类方法并动态绘制 _FTOOL(膜结构设计与绘图MSDD)
FTOOL软件  由中国空间膜结构协会定制，
(膜结构设计与绘图MSDD)  Membrane structure design and drawing
需要联系作者：QQ 463017170

1. MyCurve.cpp：
   
2. 
   
3. #include "StdAfx.h"
   
4. #include "MyCurve.h"
   
5. #include "actrans.h"
   
6. #include "aced.h"
   
7. 
   
8. //-----------------------------------------------------------------------------
   
9. Adesk::UInt32 CMyCurve::kCurrentVersionNumber =1 ;
   
10. 
    
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. )
    
21. 
    
22. //-----------------------------------------------------------------------------
    
23. static double pi()
    
24. {
    
25. return atan(1.0)*4;
    
26. }
    
27. CMyCurve::CMyCurve () : AcDbCurve () {
    
28. }
    
29. 
    
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. }
    
53. 
    
54. CMyCurve::~CMyCurve () {
    
55. delete pCurve;
    
56. }
    
57. 
    
58. //-----------------------------------------------------------------------------
    
59. //----- AcDbObject protocols
    
60. //- Dwg Filing protocol
    
61. void CMyCurve::reset(const AcGePoint3d &ptLast)
    
62. {
    
63. pCurve=new CMyCurve(ptCenter,ptLast);
    
64. }
    
65. 
    
66. AcGePoint3d CMyCurve::getCenterPoint()
    
67. {
    
68. return ptCenter;
    
69. }
    
70. void CMyCurve::setCenterPoint(const AcGePoint3d &ptcen)
    
71. {
    
72. pCurve=new CMyCurve(ptcen,ptEnd);
    
73. }
    
74. 
    
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);
    
93. 
    
94. return (pFiler->filerStatus ()) ;
    
95. }
    
96. 
    
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);
     
118. 
     
119. return (pFiler->filerStatus ()) ;
     
120. }
     
121. 
     
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. }
     
131. 
     
132. void CMyCurve::subViewportDraw (AcGiViewportDraw *mode) {
     
133. assertReadEnabled () ;
     
134. AcDbCurve::subViewportDraw (mode) ;
     
135. }
     
136. 
     
137. Adesk::UInt32 CMyCurve::subViewportDrawLogicalFlags (AcGiViewportDraw *vd) {
     
138. assertReadEnabled () ;
     
139. return (AcDbCurve::subViewportDrawLogicalFlags (vd)) ;
     
140. }
     
141. 
     
142. Adesk::UInt32 CMyCurve::subSetAttributes (AcGiDrawableTraits *traits) {
     
143. assertReadEnabled () ;
     
144. return (AcDbCurve::subSetAttributes (traits)) ;
     
145. }
     
146. 
     
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. }
     
160. 
     
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. }
     
174. 
     
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)
     
182. 
     
183. return (AcDbCurve::subGetGripPoints (gripPoints, osnapModes, geomIds)) ;
     
184. }
     
185. 
     
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)
     
190. 
     
191. return (AcDbCurve::subMoveGripPointsAt (indices, offset)) ;
     
192. }
     
193. 
     
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 () ;
     
199. 
     
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. }
     
205. 
     
206. Acad::ErrorStatus CMyCurve::subMoveGripPointsAt (
     
207. const AcDbVoidPtrArray &gripAppData, const AcGeVector3d &offset,
     
208. const int bitflags
     
209. ) {
     
210. assertWriteEnabled () ;
     
211. 
     
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. }
     
217. 
     
218. //-----------------------------------------------------------------------------
     
219. //----- AcDbCurve protocols
     
220. //- Curve property tests.
     
221. Adesk::Boolean CMyCurve::isClosed () const {
     
222. assertReadEnabled () ;
     
223. return (AcDbCurve::isClosed ()) ;
     
224. }
     
225. 
     
226. Adesk::Boolean CMyCurve::isPeriodic () const {
     
227. assertReadEnabled () ;
     
228. return (AcDbCurve::isPeriodic ()) ;
     
229. }
     
230. 
     
231. //- Get planar and start/end geometric properties.
     
232. Acad::ErrorStatus CMyCurve::getStartParam (double &param) const {
     
233. assertReadEnabled () ;
     
234. return (AcDbCurve::getStartParam (param)) ;
     
235. }
     
236. 
     
237. Acad::ErrorStatus CMyCurve::getEndParam (double &param) const {
     
238. assertReadEnabled () ;
     
239. return (AcDbCurve::getEndParam (param)) ;
     
240. }
     
241. 
     
242. Acad::ErrorStatus CMyCurve::getStartPoint (AcGePoint3d &point) const {
     
243. assertReadEnabled () ;
     
244. return (AcDbCurve::getStartPoint (point)) ;
     
245. }
     
246. 
     
247. Acad::ErrorStatus CMyCurve::getEndPoint (AcGePoint3d &point) const {
     
248. assertReadEnabled () ;
     
249. return (AcDbCurve::getEndPoint (point)) ;
     
250. }
     
251. 
     
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. }
     
257. 
     
258. Acad::ErrorStatus CMyCurve::getParamAtPoint (const AcGePoint3d &point, double &param) const {
     
259. assertReadEnabled () ;
     
260. return (AcDbCurve::getParamAtPoint (point, param)) ;
     
261. }
     
262. 
     
263. Acad::ErrorStatus CMyCurve::getDistAtParam (double param, double &dist) const {
     
264. assertReadEnabled () ;
     
265. return (AcDbCurve::getDistAtParam (param, dist)) ;
     
266. }
     
267. 
     
268. Acad::ErrorStatus CMyCurve::getParamAtDist (double dist, double &param) const {
     
269. assertReadEnabled () ;
     
270. return (AcDbCurve::getParamAtDist (dist, param)) ;
     
271. }
     
272. 
     
273. Acad::ErrorStatus CMyCurve::getDistAtPoint (const AcGePoint3d &point , double &dist) const {
     
274. assertReadEnabled () ;
     
275. return (AcDbCurve::getDistAtPoint (point, dist)) ;
     
276. }
     
277. 
     
278. Acad::ErrorStatus CMyCurve::getPointAtDist (double dist, AcGePoint3d &point) const {
     
279. assertReadEnabled () ;
     
280. return (AcDbCurve::getPointAtDist (dist, point)) ;
     
281. }
     
282. 
     
283. //- Derivative information.
     
284. Acad::ErrorStatus CMyCurve::getFirstDeriv (double param, AcGeVector3d &firstDeriv) const {
     
285. assertReadEnabled () ;
     
286. return (AcDbCurve::getFirstDeriv (param, firstDeriv)) ;
     
287. }
     
288. 
     
289. Acad::ErrorStatus CMyCurve::getFirstDeriv (const AcGePoint3d &point, AcGeVector3d &firstDeriv) const {
     
290. assertReadEnabled () ;
     
291. return (AcDbCurve::getFirstDeriv (point, firstDeriv)) ;
     
292. }
     
293. 
     
294. Acad::ErrorStatus CMyCurve::getSecondDeriv (double param, AcGeVector3d &secDeriv) const {
     
295. assertReadEnabled () ;
     
296. return (AcDbCurve::getSecondDeriv (param, secDeriv)) ;
     
297. }
     
298. 
     
299. Acad::ErrorStatus CMyCurve::getSecondDeriv (const AcGePoint3d &point, AcGeVector3d &secDeriv) const {
     
300. assertReadEnabled () ;
     
301. return (AcDbCurve::getSecondDeriv (point, secDeriv)) ;
     
302. }
     
303. 
     
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. }
     
309. 
     
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. }
     
314. 
     
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. }
     
320. 
     
321. Acad::ErrorStatus CMyCurve::getProjectedCurve (const AcGePlane &plane, const AcGeVector3d &projDir, AcDbCurve *&projCrv) const {
     
322. assertReadEnabled () ;
     
323. return (AcDbCurve::getProjectedCurve (plane, projDir, projCrv)) ;
     
324. }
     
325. 
     
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. }
     
331. 
     
332. Acad::ErrorStatus CMyCurve::getOffsetCurvesGivenPlaneNormal (const AcGeVector3d &normal, double offsetDist, AcDbVoidPtrArray &offsetCurves) const {
     
333. assertReadEnabled () ;
     
334. return (AcDbCurve::getOffsetCurvesGivenPlaneNormal (normal, offsetDist, offsetCurves)) ;
     
335. }
     
336. 
     
337. Acad::ErrorStatus CMyCurve::getSpline (AcDbSpline *&spline) const {
     
338. assertReadEnabled () ;
     
339. return (AcDbCurve::getSpline (spline)) ;
     
340. }
     
341. 
     
342. Acad::ErrorStatus CMyCurve::getSplitCurves (const AcGeDoubleArray &params, AcDbVoidPtrArray &curveSegments) const {
     
343. assertReadEnabled () ;
     
344. return (AcDbCurve::getSplitCurves (params, curveSegments)) ;
     
345. }
     
346. 
     
347. Acad::ErrorStatus CMyCurve::getSplitCurves (const AcGePoint3dArray &points, AcDbVoidPtrArray &curveSegments) const {
     
348. assertReadEnabled () ;
     
349. return (AcDbCurve::getSplitCurves (points, curveSegments)) ;
     
350. }
     
351. 
     
352. //- Extend the curve.
     
353. Acad::ErrorStatus CMyCurve::extend (double newParam) {
     
354. assertReadEnabled () ;
     
355. return (AcDbCurve::extend (newParam)) ;
     
356. }
     
357. 
     
358. Acad::ErrorStatus CMyCurve::extend (Adesk::Boolean extendStart, const AcGePoint3d &toPoint) {
     
359. assertReadEnabled () ;
     
360. return (AcDbCurve::extend (extendStart, toPoint)) ;
     
361. }
     
362. 
     
363. //- Area calculation.
     
364. Acad::ErrorStatus CMyCurve::getArea (double &area) const {
     
365. assertReadEnabled () ;
     
366. return (AcDbCurve::getArea (area)) ;
     
367. }
     
368. 
     
369. MyJig.cpp：
     
370. 
     
371. #include "StdAfx.h"
     
372. #include "MyJig.h"
     
373. #include <math.h>
     
374. #include "..\..\cmyentity1\cmyentity1\entity.h"
     
375. 
     
376. //-----------------------------------------------------------------------------
     
377. CMyJig::CMyJig () : AcEdJig ()
     
378. {
     
379. m_pEnt=NULL;
     
380. }
     
381. 
     
382. CMyJig::~CMyJig () {
     
383. }
     
384. 
     
385. //-----------------------------------------------------------------------------
     
386. static AcDbObjectId AddToModelSpace(AcDbEntity *pEnt)
     
387. {
     
388. AcDbBlockTable *pBlockTable;
     
389. acdbHostApplicationServices()->workingDatabase() ->getBlockTable(pBlockTable, AcDb::kForRead);
     
390. AcDbBlockTableRecord *pBlockTableRecord;
     
391. 
     
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. }
     
417. 
     
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();
     
428. 
     
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. }
     
441. 
     
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. }
     
456. 
     
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. }
     
473. 
     
474. //-----------------------------------------------------------------------------
     
475. //- Jigged entity pointer return
     
476. AcDbEntity *CMyJig::entity () const {
     
477. return m_pEnt;
     
478. }
     
479. 
     
480. 
     
481. 
     
482. acrxEntryPoint.cpp：
     
483. 
     
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"
     
490. 
     
491. 
     
492. //-----------------------------------------------------------------------------
     
493. #define szRDS _RXST("zff")
     
494. 
     
495. //-----------------------------------------------------------------------------
     
496. //----- ObjectARX EntryPoint
     
497. class CObjectARXApp : public AcRxArxApp {
     
498. 
     
499. public:
     
500. CObjectARXApp () : AcRxArxApp () {}
     
501. 
     
502. virtual AcRx::AppRetCode On_kInitAppMsg (void *pkt) {
     
503. // TODO: Load dependencies here
     
504. 
     
505. // You *must* call On_kInitAppMsg here
     
506. AcRx::AppRetCode retCode =AcRxArxApp::On_kInitAppMsg (pkt) ;
     
507. 
     
508. // TODO: Add your initialization code here
     
509. 
     
510. return (retCode) ;
     
511. }
     
512. 
     
513. virtual AcRx::AppRetCode On_kUnloadAppMsg (void *pkt) {
     
514. // TODO: Add your code here
     
515. 
     
516. // You *must* call On_kUnloadAppMsg here
     
517. AcRx::AppRetCode retCode =AcRxArxApp::On_kUnloadAppMsg (pkt) ;
     
518. 
     
519. // TODO: Unload dependencies here
     
520. 
     
521. return (retCode) ;
     
522. }
     
523. 
     
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;
     
535. 
     
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. }
     
560. 
     
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. } ;
     
569. 
     
570. //-----------------------------------------------------------------------------
     
571. IMPLEMENT_ARX_ENTRYPOINT(CObjectARXApp)
     
572. 
     
573. ACED_ARXCOMMAND_ENTRY_AUTO(CObjectARXApp, zffObjectARX, _MyCommand1, MyCommand1, ACRX_CMD_TRANSPARENT, NULL)
     

复制代码

jxmjg

  法拉利膜材作为一种高性能的建筑材料，在建筑、汽车及广告等多个领域有着广泛的应用。以下是对法拉利膜材型号、特点及优点的详细分析：
[img]http://www.mjgou.com/data/attachment/forum/202403/13/223041uiqmeujen4jjj6zv.jpg[/img]
[b]一、法拉利膜材型号[/b]
法拉利膜材有多种型号，包括但不限于以下几种：1302 S2 Flexlight Advanced：这是一种高性能IV型柔性复合膜材，以其卓越的透光性、耐久性和易维护性而受到青睐。942、1202 S2、1002 S2、902 S2、1212 S2、912 S2：这些型号同样属于法拉利膜材系列，各自具有不同的特性和适用范围，但具体特点需根据具体型号进一步分析。需要注意的是，法拉利膜材的型号可能随着产品更新换代而有所变化，具体型号及其特性请参考最新产品资料。
[img=860,1255]http://www.mjgou.com/data/attachment/forum/202403/13/223254bbblwlbvbvsbwlsl.jpg[/img]
[b]二、法拉利膜材特点[/b]
法拉利膜材的特点主要体现在以下几个方面：
1、高强度与耐用性：法拉利膜材采用高强度材料制成，具有良好的抗拉强度和撕裂强度，能够承受较大的外力作用而不易破损。耐用性强，能够在恶劣气候条件下保持稳定的性能，延长使用寿命。
2、透光性与美观性：部分型号如1302 S2 Flexlight Advanced具有高透光性，能够在保持室内光线充足的同时，提供清晰的视野。膜材表面平整光滑，色彩丰富多样，能够满足不同建筑和装饰需求，提升整体美观性。
3、轻质与灵活性：法拉利膜材重量较轻，便于运输和安装，能够降低施工成本和时间。膜材具有一定的柔韧性，能够适应各种复杂形状和结构的设计要求。
4、环保与可回收性：法拉利膜材符合环保要求，部分材料可回收利用，减少了对环境的影响。
[img]http://www.mjgou.com/data/attachment/forum/202403/13/223128owhn0099rrds5h5y.jpg[/img]
[b]三、法拉利膜材优点[/b]
法拉利膜材的优点主要体现在以下几个方面：
1、提升建筑性能：高强度与耐用性使得法拉利膜材能够提升建筑的稳定性和安全性，延长使用寿命。透光性与美观性使得建筑内部光线充足、视野开阔，同时提升整体美观度。
2、降低施工成本：轻质特性使得运输和安装成本降低，施工效率提高。膜材的柔韧性使得施工更加灵活多变，能够适应各种复杂地形和结构要求。
3、节能环保：部分材料可回收利用，符合环保要求，减少了对环境的影响。良好的透光性能够减少室内照明需求，降低能耗。
4、广泛应用领域：
法拉利膜材不仅适用于建筑领域（如体育设施、商业设施、文化设施、交通设施等），还广泛应用于汽车及广告领域（如高档车辆贴膜保护和装饰、广告招贴等），展现出其多功能的特性。

综上所述，法拉利膜材以其高强度、耐用性、透光性、美观性、轻质灵活性以及环保可回收性等优点，在建筑、汽车及广告等多个领域发挥着重要作用。具体型号的选择应根据实际需求和应用场景进行综合考虑。
[url=http://www.mjgou.com/forum-17-1.html][size=89164][color=Red]法拉利膜材中国代理商 - 膜结构网[/color][/size][/url]

耐弛膜中国代理

耐弛膜材，具有高性能、耐候性、耐久性等特性的膜材品牌或产品系列。以下是对这类膜材的详细介绍：
[b]一、品牌与类型[/b]
品牌：虽然直接以“耐弛”命名的品牌信息不明确，但我们可以将其视为一种高性能膜材的代表。
类型：耐弛膜材可能包括PVC膜材、PVDF膜材以及PTFE膜材等多种类型，这些材料在膜结构建筑、污水处理、空气净化等领域有广泛应用。
[b]二、产品特点[/b]
耐候性：耐弛膜材通常具有优异的耐候性，能够抵抗紫外线、高温、低温等极端天气条件的侵蚀，保持长久的色彩鲜艳和材料性能。
耐久性：材料强度高，抗拉、撕裂性能优异，能够承受各种外力的作用，延长使用寿命。
自洁性：部分耐弛膜材表面经过特殊处理，具有自洁功能，能够减少灰尘和污染物的附着，降低清洁成本。
化学稳定性：耐化学腐蚀性强，能够抵抗多种化学物质的侵蚀，保持材料的稳定性和功能性。
环保性：部分耐弛膜材为可回收材料，符合环保要求，有助于减少建筑垃圾和环境污染。
[b]三、应用领域[/b]
耐弛膜材广泛应用于多个领域，包括但不限于：
建筑领域：作为膜结构建筑的主要材料，用于体育场馆、展览馆、商业设施等建筑的屋顶和墙面覆盖。
污水处理：在污水处理厂中作为污水膜材使用，能够有效去除水中的悬浮物、有机物等污染物。
空气净化：在空气净化设备和系统中作为滤材使用，具有高效的过滤性能和耐化学性。
其他领域：如交通设施（如高速公路隔音屏）、工业设施（如化工厂、制药厂的防腐蚀覆盖材料）等。
[b]四、品牌合作与研发[/b]
耐弛膜材的生产商通常与国内外知名科研院校、膜结构公司等建立紧密的合作关系，进行技术交流、合作及成果交换。通过引进先进的生产设备和技术，不断提升产品的质量和性能。同时，生产商还注重产品的研发和创新，不断推出适应市场需求的新产品。
[b]五、总结[/b]
耐弛膜材作为一类高性能膜材的代表，以其优异的耐候性、耐久性、自洁性和化学稳定性等特点在多个领域得到广泛应用。随着技术的不断进步和市场的不断发展，耐弛膜材的产品种类和应用领域还将不断拓展和完善。然而，需要注意的是，由于“耐弛”并非一个明确的品牌名称，因此在实际应用中需要根据具体的产品信息和品牌标识进行选择。