设为首页收藏本站

中国膜结构网

 找回密码
 立即注册

QQ登录

只需一步,快速开始

膜结构车棚
膜结构车棚膜结构资质国产膜材 膜结构网中国膜结构协会
查看: 142|回复: 0

setDimValue Jig更新光标点

[复制链接]
  • TA的每日心情
    开心
    2021-6-19 14:40
  • 签到天数: 1539 天

    [LV.Master]伴坛终老

    发表于 2020-12-23 20:32 | 显示全部楼层 |阅读模式
    1. #include "StdAfx.h"
    2. #include "JigMensola.h"
    3. #include "SctBlocchi.h"
    4. #include "SctQuotatura.h"
    5. #include "SctDynBlock.h"

    6. //#include "sctLib\SctUtility.h"
    7. //#include "sctLib\SctBlocchi.h"
    8. //#include "Campata.h"
    9. //#include "Configurazione.h"

    10. extern CString BLOCCHI;
    11. extern bool JIGCQE;
    12. extern AcGeVector3d vettore;
    13. extern bool UPDATEPOINTCQE;


    14. JigMensola::JigMensola(void)
    15. {
    16.        
    17.        
    18. }


    19. //JigMensola::JigMensola(AcDbVoidPtrArray m_polylines,AcGePoint3d pInse,vector<PuntoDiSospensione> pds,int modIns)
    20. //{
    21. //        intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
    22. //        //this->m_ids_lines=m_ids_lines;
    23. //        this->pInse=pInse;
    24. //        this->m_polylines=m_polylines;
    25. //        this->pds=pds;
    26. //        this->modIns=modIns;
    27. //}       
    28. //

    29. JigMensola::~JigMensola(void)
    30. {
    31.         intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
    32. }

    33. BOOL WinCallBack1(MSG *pMsg)
    34. {
    35.       if(pMsg->message== WM_KEYDOWN)
    36.       {
    37.             if((pMsg->wParam)== VK_CONTROL)//ENTER Pressed

    38.             {
    39.                         /*        static AcGePoint3d pointTmp1;
    40.                                 AcEdJig::DragStatus stato = AcEdJig::kNormal;
    41.                                 stat = acquirePoint(pointTmp1);
    42.                         acutPrintf(L"\nCONTROL  %.0f;%.0f;%.0f",pointTmp1.x,pointTmp1.y,pointTmp1.z);*/
    43.                                 //AcGePoint3d point;
    44.                                 //Acad::ErrorStatus es;
    45.                                 //AcDbBlockTableRecord *pBlockTableRecord;
    46.                                 //
    47.                                 ////se non c'è alcuno SNAP Point esce
    48.                                 //if (0==snapPoints.length())
    49.                                 //        return FALSE;

    50.                                 ////resetta sul primo snapPoint
    51.                                 //if (pc>=snapPoints.length())
    52.                                 //        pc=0;
    53.                                 //
    54.                                 ////verifica che l'id sia valido
    55.                                 //if (id.isValid() && !id.isErased() && !id.isNull())
    56.                                 //{
    57.                                 //        es= acdbOpenObject (pBlockTableRecord, id, AcDb::kForWrite);
    58.                                 //        if (Acad::eOk==es)
    59.                                 //        {
    60.                                 //                acutPrintf(L"\n origin [%d]: %.3f,%.3f,%.3f",pc,snapPoints.at(pc).x,snapPoints.at(pc).y,snapPoints.at(pc).z);
    61.                                 //                pBlockTableRecord->setOrigin(snapPoints.at(pc));
    62.                                 //                pc=pc+1;
    63.                                 //               
    64.                                 //                pBlockTableRecord->close();
    65.                                 //        }
    66.                                 //}
    67.                                 //
    68.                                 return TRUE; //Block message for AutoCAD
    69.             }
    70.             return FALSE;

    71.       }
    72.       return FALSE;
    73. }



    74. bool JigMensola::doIt(CString nomeBlocco,AcDbObjectId idColonna, CString layer,AcGePoint3d *pInse)
    75. {
    76.        
    77.        
    78.         Acad::ErrorStatus es;
    79.         AcDbObjectId idBlock,id,id_quota1,id_quota2,id_quota3,id_quota4;
    80.         AcGePoint3d pMinCol,pMaxCol,PinseCol;
    81.         //sctUtility::getExtents(idColonna,&pMinCol,&pMaxCol);
    82.         double rot=0;
    83.         sctUtility::getBlockInfo(idColonna,&rot,&PinseCol);
    84.                 SctDynBlock dyn;
    85.                
    86.                 pMinCol=PinseCol;
    87.                 pMinCol.z=0.0;
    88.                 pMaxCol.x=PinseCol.x+dyn.getPropValueDouble(idColonna,L"L");
    89.                 pMaxCol.y=PinseCol.y+dyn.getPropValueDouble(idColonna,L"H");
    90.                 pMaxCol.z=0.0;

    91.         SctBlocchi b;
    92.         if (!b.addBlockToDatabase(nomeBlocco,&idBlock))
    93.                 return false;

    94.         m_block= new AcDbBlockReference(AcGePoint3d(0,0,0),idBlock);

    95.         int p=0;
    96.         id=idBlock;
    97.         AcGeMatrix3d mat;
    98.         mat.setToIdentity();

    99.         //Set dell'allineamento iniziale del blocco che viene inserito
    100.         //Il blocco deve essere disegnato con la parte passante rivolta sulla Y

    101.         /*quota1=true;
    102.         quota2=true;
    103.         quota3=true;
    104.         quota4=true;*/
    105.         quota=0;
    106.         AcGePoint3dArray puntiGrip;
    107.         AcDbEntity* obj;
    108.     AcDbIntArray geomIds;
    109.   /* AcDbEntity m_quota;*/
    110.     AcGePoint3d tmpPt;
    111.         AcGePoint3d pIns;
    112.         AcGePoint3d arr,part,mid;
    113.         arr[0]=pMinCol.x;
    114.         arr[1]=0;
    115.         arr[2]=0;
    116.         part[0]=pMaxCol.x;
    117.         part[1]=0;
    118.         part[2]=0;
    119.         partenza=part;
    120.         entityList.append(m_block);
    121.         sctUtility::mid_point(&mid,part,arr);
    122.         EntQ1= new AcDbAlignedDimension(part,arr,mid);
    123.         entityList.append(EntQ1);

    124.         ///SctQuotatura *sq=new SctQuotatura();
    125.         //sq->QuotaDuePunti(part,arr,0,0,L"STEEL",&id_quota1,L"QUOTE_PROVA",15,15,L"");
    126.         part[0]=pMaxCol.x;
    127.         part[1]=pMaxCol.y;
    128.         part[2]=0;
    129.         partenza1=part;
    130.         sctUtility::mid_point(&mid,part,arr);
    131.         EntQ2= new AcDbAlignedDimension(part,arr,mid);
    132.         entityList.append(EntQ2);
    133.         ////sq->QuotaDuePunti(part,arr,0,0,L"STEEL",&id_quota2,L"QUOTE_PROVA",15,15,L"");
    134.         part[0]=pMinCol.x;
    135.         part[1]=0;
    136.         part[2]=0;
    137.         partenza2=part;
    138.         ////sq->QuotaDuePunti(part,arr,0,0,L"STEEL",&id_quota3,L"QUOTE_PROVA",15,15,L"");
    139.         ////sq->QuotaDuePunti(part,arr,0,0,L"STEEL",&id_quota4,L"QUOTE_PROVA",15,15,L"");*/
    140.         sctUtility::mid_point(&mid,part,arr);
    141.         EntQ3= new AcDbAlignedDimension(part,arr,mid);
    142.         entityList.append(EntQ3);
    143.         EntQ4= new AcDbAlignedDimension(part,arr,mid);
    144.         entityList.append(EntQ4);
    145.         m_entityList.setEntityList (entityList);
    146.        

    147.        

    148.        

    149.         //per appendere tutte le entità
    150.         //append();
    151.         AcEdJig::setDispPrompt(L"\nInserisci ....");
    152.         /*acedRegisterFilterWinMsg(WinCallBack1);
    153.         AcEdJig::DragStatus stat = AcEdJig::drag();
    154.         acedRemoveFilterWinMsg(WinCallBack1);
    155.         quota++;*/
    156.         AcEdJig::DragStatus stat = AcEdJig::kNormal;
    157.         bool primoGiro=true;
    158.         JIGCQE = false;
    159.         UPDATEPOINTCQE=false;
    160.         while(stat!=AcEdJig::kCancel||primoGiro)
    161.         {
    162.                  
    163.                  stat = AcEdJig::drag();
    164.                  
    165.                  
    166.                  primoGiro=false;
    167.                  quota++;
    168.                  //acutPrintf(L"\nSTAT %d quota %d", stat, quota);
    169.                  m_dimData.removeAll();
    170.                  

    171.                  acutPrintf(L"\nSTAT %d quota %d", stat, quota);
    172.                  //m_cursorPoint=pEnd;
    173.                  /*Nsettata=-1;*/
    174.         }
    175.         JIGCQE = false;
    176.         UPDATEPOINTCQE = false;
    177.         AcDbEntity *Ent=NULL;
    178.                
    179.         //E' necessario aggiungere i dati estesi con le linee di taglio
    180.         //altrimenti i tubi non vengono tagliati
    181.         /*AcDbEntity *pEnt=NULL;
    182.         if (acdbOpenObject(pEnt,m_block1->id(),AcDb::kForWrite)==Acad::eOk)
    183.         {
    184.                         pEnt->setLayer(layer);
    185.                         pEnt->close();
    186.                         pEnt=NULL;
    187.         }*/

    188.         //SctUtility::AccendiUnLayer(layer,0);

    189.         pInse->x=m_cursorPoint.x;
    190.         pInse->y=m_cursorPoint.y;

    191.         return false;
    192. }


    193. AcEdJig::DragStatus JigMensola::sampler()
    194. {
    195.         DragStatus stat=AcEdJig::kNormal;
    196.        
    197.     {
    198.                 //inserimento blocco e richiesta punto
    199.                 AcEdJig::setUserInputControls(
    200.                         (UserInputControls)(AcEdJig::kAccept3dCoordinates | AcEdJig::kNoNegativeResponseAccepted | AcEdJig::kNoZeroResponseAccepted));
    201.                
    202.                 static AcGePoint3d pointTmp;

    203.                 /*if (UPDATEPOINTCQE)
    204.                 {
    205.                        
    206.                         return AcEdJig::kNoChange;
    207.                 }*/
    208.                 /*if(SETDIM)
    209.                 {
    210.                         SETDIM=false;
    211.                         return AcEdJig::kNoChange;
    212.                 }
    213.                 else*/
    214.                         stat = acquirePoint(pointTmp);
    215.                
    216.                 //acutPrintf(L"\npointTmp %.0f;%.0f;%.0f\n",pointTmp.x,pointTmp.y,pointTmp.z);
    217.                 if(pointTmp != m_cursorPoint/*&& settataQuota!=true*/)
    218.                 {
    219.                         acutPrintf(L"\npointTmp %.0f;%.0f;%.0f m_cursorPoint %.0f;%.0f;%.0f",pointTmp.x,pointTmp.y,pointTmp.z,m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z);
    220.                         m_cursorPoint = pointTmp;       
    221.                        
    222.                 }
    223.                 else if (stat == AcEdJig::kNormal)
    224.                 {
    225.                         /*m_cursorPoint.set(m_NEWcursorPoint.x,m_NEWcursorPoint.y,m_NEWcursorPoint.z);
    226.                         settataQuota = false;*/
    227.                         //acutPrintf(L"\nelse %.0f;%.0f;%.0f\n",m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z);
    228.                                 return AcEdJig::kNoChange;
    229.                 }
    230.          }

    231.         return stat;
    232. }


    233. Adesk::Boolean JigMensola::update()
    234. {
    235.        
    236.         AcDbBlockReference* pRef=NULL;
    237.         AcDbPolyline *pLine=NULL;
    238.         AcDbLine* pQ=NULL;
    239.         AcDbAlignedDimension* pQuo=NULL;
    240.         AcDbEntity *xEntH=NULL;
    241.         Acad::ErrorStatus es;
    242.         AcGeVector3d dir1;
    243.         AcGeVector3d dir2;
    244.         acutPrintf(L"\nupdate");
    245.         double distanzaCond=0.6;
    246.         /*distanzaCond=Configurazione::getInstance().getDistanzaConduttori()*0.5;
    247.         */
    248.         //inserimento dell'elemento
    249.         intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
    250.         pEnd=AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z);
    251.        
    252.         intersectionPoints.removeAll();
    253.         AcDbPolyline *tracciatura=NULL;
    254.         AcGePoint3d start;
    255.         AcGePoint3d midP;

    256.         //JIGCQE = true;
    257.         for(int j=0;j<m_entityList.m_entities.length()/*-1*/;j++)
    258.         {
    259.                 xEntH=static_cast<AcDbEntity*>(m_entityList.m_entities.at(j));
    260.                

    261.                 //l'entità che si sta aggiornando è la linea di tracciatura mensola
    262.                 if(xEntH->isKindOf(AcDbBlockReference::desc()) && j==0)
    263.                 {
    264.                        
    265.                                        
    266.                 //L'utente sta inserendo il blocco che si deve allineare automaticamente
    267.                 //al tubo o ai tubi ammesso che esista
    268.                 pRef=static_cast<AcDbBlockReference*>(m_block);
    269.                 if (settataQuota)
    270.                 {
    271.                         pEnd=dimEndNew;
    272.                        
    273.                         settataQuota = false;
    274.                 }

    275.                
    276.                 //JIGCQE = true;
    277.                
    278.                 es=pRef->setPosition(pEnd);
    279.                 //m_cursorPoint = pEnd;
    280.                 //JIGCQE = true;
    281.                 //JIGCQE = true;
    282.                 //acutPrintf(L"\nUPDATE pEnd %.0f;%.0f;%.0f\n",pEnd.x,pEnd.y,pEnd.z);
    283.                 es=pRef->setScaleFactors(AcGeScale3d(1,1,1));
    284.                 //allineaAssi(pRef);
    285.                 }

    286.                 //if(xEntH->isKindOf(AcDbLine::desc()) && j==1)
    287.                 //{
    288.                 //        pQ=AcDbLine::cast(xEntH);
    289.                 //        pQ->setEndPoint(pEnd);
    290.                 //       
    291.                 //}


    292.                
    293.                 //if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==1)
    294.                 //{
    295.                 ////quota 1       
    296.                 //       
    297.                 //        AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(m_dimData.at(0)) ;
    298.                 //        int inputNumber =-1 ;
    299.                 //        //- Find the dim data being passed so we can determine the input number
    300.                 //        if ( m_dimData.find (dimDataNC, inputNumber) )
    301.                 //        {
    302.                 //                //- Now get the dimension
    303.                 //                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    304.                 //                //- Check it's the type of dimension we want
    305.                 //                AcDbAlignedDimension *p =AcDbAlignedDimension::cast (pDim) ;

    306.                 //                //- If ok
    307.                 //                if(p)
    308.                 //                {
    309.                 //                        AcGePoint3d mid;
    310.                 //                        start=p->xLine1Point();
    311.                 //                        start.y=pEnd.y;
    312.                 //                        sctUtility::mid_point(&mid,start,pEnd);
    313.                 //                        /*mid.x=(ref1.x+m_cursorPoint.x)/2.0;
    314.                 //                        mid.y=(ref1.y+m_cursorPoint.y)/2.0;
    315.                 //                        mid.z=m_cursorPoint.z;*/

    316.                 //                        p->setXLine1Point(start);
    317.                 //                        p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
    318.                 //                        p->setDimLinePoint(mid);
    319.                 //                        p->setDynamicDimension(true);
    320.                 //                }
    321.                 //        }
    322.                 //       
    323.                 //}
    324.                 //        //pQuo=AcDbAlignedDimension::cast(xEntH);
    325.                 //        //start=pQuo->xLine1Point();
    326.                 //        //start.y=pEnd.y;
    327.                 //        //sctUtility::mid_point(&midP,start,pEnd);
    328.                 //        //
    329.                 //        //es=pQuo->setXLine1Point(start);
    330.                 //        //es=pQuo->setXLine2Point(pEnd);
    331.                 //        //pQuo->setDimLinePoint(midP);
    332.                 //        //
    333.                 //        ///*Ptest.x=pEnd.x+fabs(start.x-pEnd.x)/2;
    334.                 //        //Ptest.y=pEnd.y;
    335.                 //        //Ptest.z=0;
    336.                 //        //es=pQuo->setTextPosition(Ptest);*/
    337.                 //
    338.                 //
    339.                 //}

    340.                 if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==1)
    341.                 {
    342.                 //quota 2
    343.                         pQuo=AcDbAlignedDimension::cast(xEntH);
    344.                         start=pQuo->xLine1Point();
    345.                         start.y=pEnd.y;
    346.                        
    347.                         sctUtility::mid_point(&midP,start,pEnd);
    348.                        
    349.                         es=pQuo->setXLine1Point(start);
    350.                         es=pQuo->setXLine2Point(pEnd);
    351.                         pQuo->setDimLinePoint(midP);
    352.                         /*Ptest.y=pEnd.y+fabs(start.y-pEnd.y)/2;
    353.                         Ptest.x=pEnd.x;
    354.                         Ptest.z=0;
    355.                         es=pQuo->setTextPosition(Ptest);*/
    356.                
    357.                
    358.                 }
    359.                 if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==2)
    360.                 {
    361.                 //quota 2
    362.                         pQuo=AcDbAlignedDimension::cast(xEntH);
    363.                         start=pQuo->xLine1Point();
    364.                         start.x=pEnd.x;
    365.                        
    366.                         sctUtility::mid_point(&midP,start,pEnd);
    367.                        
    368.                         es=pQuo->setXLine1Point(start);
    369.                         es=pQuo->setXLine2Point(pEnd);
    370.                         pQuo->setDimLinePoint(midP);
    371.                         /*Ptest.y=pEnd.y+fabs(start.y-pEnd.y)/2;
    372.                         Ptest.x=pEnd.x;
    373.                         Ptest.z=0;
    374.                         es=pQuo->setTextPosition(Ptest);*/
    375.                
    376.                
    377.                 }
    378.                 if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==3)
    379.                 {
    380.                 //quota 3       
    381.                         pQuo=AcDbAlignedDimension::cast(xEntH);
    382.                         start=pQuo->xLine1Point();
    383.                         start.y=pEnd.y;
    384.                        
    385.                         sctUtility::mid_point(&midP,start,pEnd);
    386.                        
    387.                         es=pQuo->setXLine1Point(start);
    388.                         es=pQuo->setXLine2Point(pEnd);
    389.                         pQuo->setDimLinePoint(midP);
    390.                 /*        Ptest.x=pEnd.x+fabs(start.x-pEnd.x)/2;
    391.                         Ptest.y=pEnd.y;
    392.                         Ptest.z=0;
    393.                         es=pQuo->setTextPosition(Ptest);*/

    394.                
    395.                
    396.                 }
    397.                 if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==4)
    398.                 {
    399.                 //quota 4
    400.                         pQuo=AcDbAlignedDimension::cast(xEntH);
    401.                         start=pQuo->xLine1Point();
    402.                         start.x=pEnd.x;
    403.                        
    404.                         sctUtility::mid_point(&midP,start,pEnd);
    405.                        
    406.                         es=pQuo->setXLine1Point(start);
    407.                         es=pQuo->setXLine2Point(pEnd);
    408.                         pQuo->setDimLinePoint(midP);
    409.                         /*Ptest.y=pEnd.y+fabs(start.y-pEnd.y)/2;
    410.                         Ptest.x=pEnd.x;
    411.                         Ptest.z=0;
    412.                         es=pQuo->setTextPosition(Ptest);*/

    413.                
    414.                
    415.                 }

    416.         //al tubo o ai tubi ammesso che esista
    417.                 /*pRef=static_cast<AcDbBlockReference*>();
    418.                 es=pRef->setPosition(pEnd);
    419.                 es=pRef->setScaleFactors(AcGeScale3d(1,1,1));*/
    420.         }

    421.         int valoreQuota=quota%4;
    422.         if (valoreQuota==0 /*|| Nsettata==0*/)
    423.         {
    424.                         AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(m_dimData.at(0)) ;
    425.                         int inputNumber =-1 ;
    426.                         //- Find the dim data being passed so we can determine the input number
    427.                         if ( m_dimData.find (dimDataNC, inputNumber) )
    428.                         {
    429.                                 //- Now get the dimension
    430.                                 AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    431.                                 //- Check it's the type of dimension we want
    432.                                 AcDbAlignedDimension *p =AcDbAlignedDimension::cast (pDim) ;
    433.                                 //- If ok
    434.                                 if (p) {
    435.                                         AcGePoint3d mid;

    436.                                         start=partenza;
    437.                                         start.y=pEnd.y;
    438.                                         sctUtility::mid_point(&mid,start,pEnd);
    439.                                         /*mid.x=(ref1.x+m_cursorPoint.x)/2.0;
    440.                                         mid.y=(ref1.y+m_cursorPoint.y)/2.0;
    441.                                         mid.z=m_cursorPoint.z;*/

    442.                                         p->setXLine1Point(start);
    443.                                         p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
    444.                                         p->setDimLinePoint(mid);
    445.                                         p->setDynamicDimension(true);
    446.                                         //d->setDimension(p);
    447.                                 }
    448.                         }
    449.                 }
    450.        
    451.         if (valoreQuota==1|| Nsettata==1)
    452.                 {
    453.                         AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(m_dimData.at(0)) ;
    454.                         int inputNumber =-1 ;
    455.                         //- Find the dim data being passed so we can determine the input number
    456.                         if ( m_dimData.find (dimDataNC, inputNumber) )
    457.                         {
    458.                                 //- Now get the dimension
    459.                                 AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    460.                                 //- Check it's the type of dimension we want
    461.                                 AcDbAlignedDimension *p =AcDbAlignedDimension::cast (pDim) ;
    462.                                 //- If ok
    463.                                 if (p) {
    464.                                         AcGePoint3d mid;

    465.                                         start=partenza1;

    466.                                         start.x=pEnd.x;
    467.                                         sctUtility::mid_point(&mid,start,pEnd);
    468.                                         /*mid.x=(ref1.x+m_cursorPoint.x)/2.0;
    469.                                         mid.y=(ref1.y+m_cursorPoint.y)/2.0;
    470.                                         mid.z=m_cursorPoint.z;*/

    471.                                         p->setXLine1Point(start);
    472.                                         p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
    473.                                         p->setDimLinePoint(mid);
    474.                                         p->setDynamicDimension(true);
    475.                                         //d->setDimension(p);
    476.                                 }
    477.                         }
    478.                 }
    479.         if (valoreQuota==2|| Nsettata==2)
    480.                 {
    481.                         AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(m_dimData.at(0)) ;
    482.                         int inputNumber =-1 ;
    483.                         //- Find the dim data being passed so we can determine the input number
    484.                         if ( m_dimData.find (dimDataNC, inputNumber) )
    485.                         {
    486.                                 //- Now get the dimension
    487.                                 AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    488.                                 //- Check it's the type of dimension we want
    489.                                 AcDbAlignedDimension *p =AcDbAlignedDimension::cast (pDim) ;
    490.                                 //- If ok
    491.                                 if (p) {
    492.                                         AcGePoint3d mid;

    493.                                         start=partenza2;

    494.                                         start.y=pEnd.y;
    495.                                         sctUtility::mid_point(&mid,start,pEnd);
    496.                                         /*mid.x=(ref1.x+m_cursorPoint.x)/2.0;
    497.                                         mid.y=(ref1.y+m_cursorPoint.y)/2.0;
    498.                                         mid.z=m_cursorPoint.z;*/

    499.                                         p->setXLine1Point(start);
    500.                                         p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
    501.                                         p->setDimLinePoint(mid);
    502.                                         p->setDynamicDimension(true);
    503.                                         //d->setDimension(p);
    504.                                 }
    505.                         }
    506.                 }
    507.         if (valoreQuota==3|| Nsettata==3)
    508.                 {
    509.                         AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(m_dimData.at(0)) ;
    510.                         int inputNumber =-1 ;
    511.                         //- Find the dim data being passed so we can determine the input number
    512.                         if ( m_dimData.find (dimDataNC, inputNumber) )
    513.                         {
    514.                                 //- Now get the dimension
    515.                                 AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    516.                                 //- Check it's the type of dimension we want
    517.                                 AcDbAlignedDimension *p =AcDbAlignedDimension::cast (pDim) ;
    518.                                 //- If ok
    519.                                 if (p) {
    520.                                         AcGePoint3d mid;

    521.                                         start=partenza2;

    522.                                         start.x=pEnd.x;
    523.                                         sctUtility::mid_point(&mid,start,pEnd);
    524.                                         /*mid.x=(ref1.x+m_cursorPoint.x)/2.0;
    525.                                         mid.y=(ref1.y+m_cursorPoint.y)/2.0;
    526.                                         mid.z=m_cursorPoint.z;*/

    527.                                         p->setXLine1Point(start);
    528.                                         p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
    529.                                         p->setDimLinePoint(mid);
    530.                                         p->setDynamicDimension(true);
    531.                                         //d->setDimension(p);
    532.                                 }
    533.                         }
    534.                 }
    535.         /*if(settataQuota)*/
    536.         Nsettata=-1;
    537.         return Adesk::kTrue;
    538. }


    539. //PuntoDiSospensione JigMensola::cercaPds(AcGePoint3d p,AcDbPolyline *tracciatura)
    540. //{
    541. //        double distanza=1000000000;
    542. //        AcGePoint3d punto,pTrovato;
    543. //        PuntoDiSospensione pd;
    544. //        int indice=0;
    545. //        double distanzaPdsLineaTeoricaTracciatura=0.0;
    546. //        AcDbLine *teorica=new AcDbLine();
    547. //        AcGePoint3dArray intersectionPoints;
    548. //        intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
    549. //        for (int i=0;i<pds.size();i++)
    550. //        {
    551. //                intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
    552. //                teorica->setStartPoint(pds.at(i).getPinse());
    553. //                teorica->setEndPoint(p);
    554. //                teorica->intersectWith (tracciatura, AcDb::kOnBothOperands, intersectionPoints);
    555. //
    556. //                tracciatura->getClosestPointTo(pds.at(i).getPinse(),pTrovato);
    557. //                distanzaPdsLineaTeoricaTracciatura=pTrovato.distanceTo(pds.at(i).getPinse());
    558. //                acutPrintf(L"\n%.2f",distanzaPdsLineaTeoricaTracciatura);
    559. //                //la nuova campata NON deve intesercare la linea di tracciatura teorica
    560. //                if (intersectionPoints.length()==0)
    561. //                {
    562. //                        if(pds.at(i).getPinse().distanceTo(p)<distanza)
    563. //                        {
    564. //                                if (distanzaPdsLineaTeoricaTracciatura<0.4)
    565. //                                {
    566. //                                        distanza=pds.at(i).getPinse().distanceTo(p);
    567. //                                        indice=i;
    568. //                               
    569. //                                        punto=pds.at(i).getPinse();
    570. //                                }
    571. //                        }
    572. //                }
    573. //        }
    574. //
    575. //        delete teorica;teorica=NULL;
    576. //        intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
    577. //
    578. //        if (indice<pds.size())
    579. //                pd=pds.at(indice);
    580. //
    581. //
    582. //        return pd;
    583. //}
    584. //
    585. //

    586. AcDbEntity *JigMensola::entity() const
    587. {
    588. // check to make sure we called setEntityList
    589. if (!m_entityList.m_calledSetEntityList)
    590.   AfxMessageBox (L"Error - You must call setEntityList \
    591.   before calling asdkMultiJig::drag()");

    592. return (const_cast<asdkEntityList *>(&m_entityList));
    593. }



    594. AcDbObjectId JigMensola::append(AcDbDatabase *dwg,
    595. const ACHAR *requiredSpace)
    596. {
    597.          // get the total number of entities registered
    598.         int length = m_entityList.m_entities.length ();
    599.          // loop round the registered
    600.          // entities and add the to the space
    601.         for (int i=0; i<length; ++i)
    602.         {
    603.                 postToDwg ((AcDbEntity *)m_entityList.m_entities[i],
    604.                 dwg, requiredSpace);
    605.         }

    606.          // get the id of the first entity drawn
    607.         AcDbObjectId id =
    608.           ((AcDbEntity *)m_entityList.m_entities[0])->id ();

    609.          // close the entities added
    610.         for (int i=0; i<length; ++i)
    611.           ((AcDbEntity *)m_entityList.m_entities[i])->close ();

    612.         // return the object id
    613.         return (id);
    614. }



    615. AcDbObjectId JigMensola::append(int posEnt,AcDbDatabase *dwg,
    616. const ACHAR *requiredSpace)
    617. {
    618.          // get the total number of entities registered
    619.         int length = m_entityList.m_entities.length ();
    620.          // loop round the registered
    621.          // entities and add the to the space
    622.         if (posEnt<length)
    623.         {
    624.                 postToDwg ((AcDbEntity *)m_entityList.m_entities[posEnt],
    625.                 dwg, requiredSpace);
    626.         }

    627.          // get the id of the first entity drawn
    628.         AcDbObjectId id =
    629.           ((AcDbEntity *)m_entityList.m_entities[posEnt])->id ();

    630.          ((AcDbEntity *)m_entityList.m_entities[posEnt])->close ();

    631.         // return the object id
    632.         return (id);
    633. }



    634. Acad::ErrorStatus JigMensola::postToDwg (AcDbEntity *pEnt, AcDbDatabase *pDb,
    635. const ACHAR *requiredSpace)
    636. {
    637. // if the default database is to be used
    638. if (pDb == NULL)
    639.   pDb = acdbHostApplicationServices()->workingDatabase ();

    640. AcDbBlockTable *blockTable = NULL;
    641. // get a pointer to the block table
    642. Acad::ErrorStatus es = pDb->getBlockTable (blockTable,
    643.   AcDb::kForRead);
    644. // if it failed then abort
    645. if (es != Acad::eOk)
    646.   return (es);

    647. AcDbBlockTableRecord *blockTableRecord = NULL;
    648. // now get a pointer to the model space entity records
    649. es = blockTable->getAt (requiredSpace,
    650.   blockTableRecord, AcDb::kForWrite);
    651. // can close the block table
    652. // itself as we don't need it anymore
    653. blockTable->close ();
    654. // if it failed then abort
    655. if (es != Acad::eOk)
    656.   return (es);
    657. // otherwise put the entity into the model space
    658. es = blockTableRecord->appendAcDbEntity (pEnt);
    659. // now close it up
    660. blockTableRecord->close();

    661. return (es);
    662. }
    663. AcDbDimDataPtrArray * JigMensola::dimData(const double dimScale)
    664. {
    665.         acutPrintf(L"\nSTARTdimData");
    666.         int valoreQuota=quota%4;
    667.         if (valoreQuota==0)
    668.         {
    669.                 AcDbAlignedDimension * pDimension = new AcDbAlignedDimension;
    670.                 pDimension->setDatabaseDefaults();
    671.                 pDimension->setNormal(AcGeVector3d::kZAxis);
    672.                 pDimension->setElevation(0.0);
    673.                 pDimension->setDimscale(dimScale);
    674.                 pDimension->setHorizontalRotation(0.);
    675.                 pDimension->setDynamicDimension(true);

    676.                 AcDbObjectId idStile;

    677.                 /*ACHAR* stile=L"Standard";

    678.                 if(stile!=NULL)
    679.                         AcDbSymbolUtilities::getDimStyleId(idStile,stile,acdbHostApplicationServices()->workingDatabase());
    680.                 */
    681.                 //mid_point(&midP,AcGePoint3d(0,0,0),AcGePoint3d(0,0,0));
    682.                 //es=quota->setDimLinePoint(midP);
    683.                 //pDimension->setDimensionStyle(idStile);

    684.                 AcDbDimData * pDimData = new AcDbDimData(pDimension);
    685.                 pDimData->setDimFocal(true);
    686.                 pDimData->setDimHideIfValueIsZero(true);
    687.                 pDimData->setDimEditable(true);
    688.        

    689.                  m_dimData.append(pDimData);
    690.         }

    691.         if (valoreQuota==1)
    692.         {
    693.                 AcDbAlignedDimension * pDimension = new AcDbAlignedDimension;
    694.                 pDimension->setDatabaseDefaults();
    695.                 pDimension->setNormal(AcGeVector3d::kZAxis);
    696.                 pDimension->setElevation(0.0);
    697.                 pDimension->setDimscale(dimScale);
    698.                 pDimension->setHorizontalRotation(0.);
    699.                 pDimension->setDynamicDimension(true);

    700.                 AcDbObjectId idStile;

    701.                 /*ACHAR* stile=L"Standard";

    702.                 if(stile!=NULL)
    703.                         AcDbSymbolUtilities::getDimStyleId(idStile,stile,acdbHostApplicationServices()->workingDatabase());
    704.                 */
    705.                 //mid_point(&midP,AcGePoint3d(0,0,0),AcGePoint3d(0,0,0));
    706.                 //es=quota->setDimLinePoint(midP);
    707.                 //pDimension->setDimensionStyle(idStile);

    708.                 AcDbDimData * pDimData = new AcDbDimData(pDimension);
    709.                 pDimData->setDimFocal(true);
    710.                 pDimData->setDimHideIfValueIsZero(true);
    711.                 pDimData->setDimEditable(true);
    712.        
    713.                  m_dimData.append(pDimData);
    714.         }

    715.         if (valoreQuota==2)
    716.         {
    717.                 AcDbAlignedDimension * pDimension = new AcDbAlignedDimension;
    718.                 pDimension->setDatabaseDefaults();
    719.                 pDimension->setNormal(AcGeVector3d::kZAxis);
    720.                 pDimension->setElevation(0.0);
    721.                 pDimension->setDimscale(dimScale);
    722.                 pDimension->setHorizontalRotation(0.);
    723.                 pDimension->setDynamicDimension(true);

    724.                 AcDbObjectId idStile;

    725.                 /*ACHAR* stile=L"Standard";

    726.                 if(stile!=NULL)
    727.                         AcDbSymbolUtilities::getDimStyleId(idStile,stile,acdbHostApplicationServices()->workingDatabase());
    728.                 */
    729.                 //mid_point(&midP,AcGePoint3d(0,0,0),AcGePoint3d(0,0,0));
    730.                 //es=quota->setDimLinePoint(midP);
    731.                 //pDimension->setDimensionStyle(idStile);

    732.                 AcDbDimData * pDimData = new AcDbDimData(pDimension);
    733.                 pDimData->setDimFocal(true);
    734.                 pDimData->setDimHideIfValueIsZero(true);
    735.                 pDimData->setDimEditable(true);
    736.        
    737.                  m_dimData.append(pDimData);
    738.         }

    739.         if (valoreQuota==3)
    740.         {
    741.                 AcDbAlignedDimension * pDimension = new AcDbAlignedDimension;
    742.                 pDimension->setDatabaseDefaults();
    743.                 pDimension->setNormal(AcGeVector3d::kZAxis);
    744.                 pDimension->setElevation(0.0);
    745.                 pDimension->setDimscale(dimScale);
    746.                 pDimension->setHorizontalRotation(0.);
    747.                 pDimension->setDynamicDimension(true);

    748.                 AcDbObjectId idStile;

    749.                 /*ACHAR* stile=L"Standard";

    750.                 if(stile!=NULL)
    751.                         AcDbSymbolUtilities::getDimStyleId(idStile,stile,acdbHostApplicationServices()->workingDatabase());
    752.                 */
    753.                 //mid_point(&midP,AcGePoint3d(0,0,0),AcGePoint3d(0,0,0));
    754.                 //es=quota->setDimLinePoint(midP);
    755.                 //pDimension->setDimensionStyle(idStile);

    756.                 AcDbDimData * pDimData = new AcDbDimData(pDimension);
    757.                 pDimData->setDimFocal(true);
    758.                 pDimData->setDimHideIfValueIsZero(true);
    759.                 pDimData->setDimEditable(true);
    760.        
    761.                  m_dimData.append(pDimData);
    762.         }
    763.         acutPrintf(L"\nENDdimData");
    764.        
    765.         return &m_dimData;


    766. }

    767. Acad::ErrorStatus JigMensola::setDimValue (const AcDbDimData *pDimData, const double dimValue) {
    768.         Acad::ErrorStatus es =Acad::eOk ;
    769.         int valoreQuota=quota%4;
    770.         JIGCQE = true;
    771.         acutPrintf(L"\nSTARTsetdimvalue");
    772.         if (valoreQuota==0)
    773.         {
    774.                  //SAMPLE CODE:
    775.                 //- Convert the const pointer to non const
    776.                 AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
    777.                 int inputNumber =-1 ;
    778.                 //- Find the dim data being passed so we can determine the input number
    779.                 if ( m_dimData.find (dimDataNC, inputNumber) ) {
    780.                         //- Now get the dimension
    781.                         if(inputNumber==0)
    782.                         {
    783.                                 AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    784.                                 //- Check it's the type of dimension we want
    785.                                 AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
    786.                                 //- If ok
    787.                                 if ( pAlnDim ) {
    788.                                         //- Extract the dimensions as they are now
    789.                                         AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
    790.                                         AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
    791.                                         //- Lets get the new point entered by the user
    792.                                         //AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
    793.                                         ////- Finally set the end dim point
    794.                                         //pAlnDim->setXLine2Point (dimEndNew) ;
    795.                                         //- Now update the jig data to reflect the dynamic dimension input
    796.                                         //mInputPoints [mCurrentInputLevel] =dimEndNew ;
    797.                                        
    798.                                         dimEndNew=dimStart;
    799.                                         dimEndNew.x=dimStart.x-dimValue;
    800.                                         vettore=dimEndNew-pEnd;
    801.                                         //m_cursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
    802.                                         /*
    803.                                         m_NEWcursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
    804.                                         pEnd = dimEndNew;*/
    805.                                         pAlnDim->setXLine2Point (dimEndNew) ;
    806.                                         //acutPrintf(L"\setdimvalue pEnd %.0f;%.0f;%.0f\n",pEnd.x,pEnd.y,pEnd.z);
    807.                                         /*AcEdJig::DragStatus stat = AcEdJig::drag();*/
    808.                                         /*pointTmp=dimEndNew*/;
    809.                                 }
    810.                         }
    811.                 }
    812.                 Nsettata=1;
    813.         }
    814.         if (valoreQuota==1)
    815.         {
    816.                  //SAMPLE CODE:
    817.                 //- Convert the const pointer to non const
    818.                 AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
    819.                 int inputNumber =-1 ;
    820.                 //- Find the dim data being passed so we can determine the input number
    821.                 if ( m_dimData.find (dimDataNC, inputNumber) ) {
    822.                         //- Now get the dimension
    823.                         if(inputNumber==0)
    824.                         {
    825.                                 AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    826.                                 //- Check it's the type of dimension we want
    827.                                 AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
    828.                                 //- If ok
    829.                                 if ( pAlnDim ) {
    830.                                         //- Extract the dimensions as they are now
    831.                                         AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
    832.                                         AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
    833.                                         //- Lets get the new point entered by the user
    834.                                         //AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
    835.                                         ////- Finally set the end dim point
    836.                                         //pAlnDim->setXLine2Point (dimEndNew) ;
    837.                                        
    838.                                         dimEndNew=dimStart;
    839.                                         dimEndNew.y=dimStart.y-dimValue;
    840.                                         vettore=dimEndNew-pEnd;
    841.                                         m_cursorPoint=dimEndNew;
    842.                                         m_NEWcursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
    843.                                         //- Now update the jig data to reflect the dynamic dimension input
    844.                                         //mInputPoints [mCurrentInputLevel] =dimEndNew ;
    845.                                 }
    846.                         }
    847.                 }
    848.                 Nsettata=2;
    849.         }

    850.         if (valoreQuota==2)
    851.         {
    852.                  //SAMPLE CODE:
    853.                 //- Convert the const pointer to non const
    854.                 AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
    855.                 int inputNumber =-1 ;
    856.                 //- Find the dim data being passed so we can determine the input number
    857.                 if ( m_dimData.find (dimDataNC, inputNumber) ) {
    858.                         //- Now get the dimension
    859.                         if(inputNumber==0)
    860.                         {
    861.                                 AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    862.                                 //- Check it's the type of dimension we want
    863.                                 AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
    864.                                 //- If ok
    865.                                 if ( pAlnDim ) {
    866.                                         //- Extract the dimensions as they are now
    867.                                         AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
    868.                                         AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
    869.                                         //- Lets get the new point entered by the user
    870.                                         //AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
    871.                                         ////- Finally set the end dim point
    872.                                         //pAlnDim->setXLine2Point (dimEndNew) ;
    873.                                        
    874.                                         dimEndNew=dimStart;
    875.                                         dimEndNew.x=dimStart.x+dimValue;
    876.                                         vettore=dimEndNew-pEnd;
    877.                                         m_cursorPoint=dimEndNew;
    878.                                         m_NEWcursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
    879.                                         //- Now update the jig data to reflect the dynamic dimension input
    880.                                         //mInputPoints [mCurrentInputLevel] =dimEndNew ;
    881.                                 }
    882.                         }
    883.                 }
    884.                 Nsettata=3;
    885.         }

    886.         if (valoreQuota==3)
    887.         {
    888.                  //SAMPLE CODE:
    889.                 //- Convert the const pointer to non const
    890.                 AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
    891.                 int inputNumber =-1 ;
    892.                 //- Find the dim data being passed so we can determine the input number
    893.                 if ( m_dimData.find (dimDataNC, inputNumber) ) {
    894.                         //- Now get the dimension
    895.                         if(inputNumber==0)
    896.                         {
    897.                                 AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
    898.                                 //- Check it's the type of dimension we want
    899.                                 AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
    900.                                 //- If ok
    901.                                 if ( pAlnDim ) {
    902.                                         //- Extract the dimensions as they are now
    903.                                         AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
    904.                                         AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
    905.                                         //- Lets get the new point entered by the user
    906.                                         //AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
    907.                                         ////- Finally set the end dim point
    908.                                         //pAlnDim->setXLine2Point (dimEndNew) ;
    909.                                        
    910.                                         dimEndNew=dimStart;
    911.                                         dimEndNew.y=dimStart.y+dimValue;
    912.                                         vettore=dimEndNew-pEnd;
    913.                                         m_cursorPoint=dimEndNew;
    914.                                         m_NEWcursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
    915.                                         //- Now update the jig data to reflect the dynamic dimension input
    916.                                         //mInputPoints [mCurrentInputLevel] =dimEndNew ;
    917.                                 }
    918.                         }
    919.                 }
    920.                 Nsettata=0;
    921.         }
    922.         //JIGCQE = true;
    923.         settataQuota=true;
    924.         SETDIM=true;
    925.         acutPrintf(L"\nENDsetdimvalue");
    926.         return (es) ;
    927. }
    复制代码
    回复


    http://www.mjgw.org/ 专业从事膜结构设计、制作加工、施工安装的膜结构工程服务,能够为客户提供专业的膜结构整体解决方案。做中国最好的膜结构综合服务平台。欢迎大家联系电话:198-7840-1958,QQ:463017170.
    相关关键词:膜结构车棚,膜结构车棚覆盖,膜结构车棚公司,膜结构车棚多少钱,膜结构车棚厂家,膜结构车棚价格,社区膜结构车棚,膜结构车棚膜布厂家 ,膜结构车棚哪家好,膜结构车棚多少钱一米,膜结构车棚报价,膜结构车棚哪里有,膜结构车棚定制,膜结构车棚安装,膜结构车棚设计,膜结构车棚电话,膜结构车棚加工,膜结构车棚膜布价格,膜结构车棚批发,膜结构车棚制造商,膜结构车棚生产厂家,膜结构车棚设计,膜结构车棚施工,膜结构车棚多少钱一平米,膜结构车棚订制,张拉膜车棚,张拉膜车棚覆盖,张拉膜车棚公司,张拉膜车棚多少钱,张拉膜车棚厂家,张拉膜车棚价格,社区张拉膜车棚,张拉膜车棚膜布厂家 ,张拉膜车棚哪家好,张拉膜车棚多少钱一米,张拉膜车棚报价,张拉膜车棚哪里有,张拉膜车棚定制,张拉膜车棚安装,张拉膜车棚设计,张拉膜车棚电话,张拉膜车棚加工,张拉膜车棚膜布价格,张拉膜车棚批发,张拉膜车棚制造商,张拉膜车棚生产厂家,张拉膜车棚设计,张拉膜车棚施工,张拉膜车棚多少钱一平米,张拉膜车棚订制,常用膜材品牌:德国杜肯、法国法拉利、德国海德斯、德国米乐、日本平岗、韩国秀博、比利时希运、美国赫虏伯、中国科宝、上海慧遥。

    使用道具 举报

    您需要登录后才可以回帖 登录 | 立即注册

    本版积分规则

    关闭

    推荐膜材品牌上一条 /6 下一条

    进口膜材 国产膜材 pvdf膜材ptfe膜材ETFE膜材
    最好的膜结构公司 一级膜结构资质 膜结构一级资质
    膜结构设计-膜结构十大品牌-etfe设计-充气膜结构
    诺科膜结构
    遨都膜结构设计
    中国膜结构网
    中国空间膜结构

    QQ|申请友链|手机版|中国膜结构论坛