setDimValue Jig更新光标点

admin1

[code]#include "StdAfx.h"
#include "JigMensola.h"
#include "SctBlocchi.h"
#include "SctQuotatura.h"
#include "SctDynBlock.h"

//#include "sctLib\SctUtility.h"
//#include "sctLib\SctBlocchi.h"
//#include "Campata.h"
//#include "Configurazione.h"

extern CString BLOCCHI;
extern bool JIGCQE;
extern AcGeVector3d vettore;
extern bool UPDATEPOINTCQE;


JigMensola::JigMensola(void)
{
       
       
}


//JigMensola::JigMensola(AcDbVoidPtrArray m_polylines,AcGePoint3d pInse,vector<PuntoDiSospensione> pds,int modIns)
//{
//        intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
//        //this->m_ids_lines=m_ids_lines;
//        this->pInse=pInse;
//        this->m_polylines=m_polylines;
//        this->pds=pds;
//        this->modIns=modIns;
//}       
//

JigMensola::~JigMensola(void)
{
        intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
}

BOOL WinCallBack1(MSG *pMsg)
{
      if(pMsg->message== WM_KEYDOWN)
      {
            if((pMsg->wParam)== VK_CONTROL)//ENTER Pressed

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

                                ////resetta sul primo snapPoint
                                //if (pc>=snapPoints.length())
                                //        pc=0;
                                //
                                ////verifica che l'id sia valido
                                //if (id.isValid() && !id.isErased() && !id.isNull())
                                //{
                                //        es= acdbOpenObject (pBlockTableRecord, id, AcDb::kForWrite);
                                //        if (Acad::eOk==es)
                                //        {
                                //                acutPrintf(L"\n origin [%d]: %.3f,%.3f,%.3f",pc,snapPoints.at(pc).x,snapPoints.at(pc).y,snapPoints.at(pc).z);
                                //                pBlockTableRecord->setOrigin(snapPoints.at(pc));
                                //                pc=pc+1;
                                //               
                                //                pBlockTableRecord->close();
                                //        }
                                //}
                                //
                                return TRUE; //Block message for AutoCAD
            }
            return FALSE;

      }
      return FALSE;
}



bool JigMensola::doIt(CString nomeBlocco,AcDbObjectId idColonna, CString layer,AcGePoint3d *pInse)
{
       
       
        Acad::ErrorStatus es;
        AcDbObjectId idBlock,id,id_quota1,id_quota2,id_quota3,id_quota4;
        AcGePoint3d pMinCol,pMaxCol,PinseCol;
        //sctUtility::getExtents(idColonna,&pMinCol,&pMaxCol);
        double rot=0;
        sctUtility::getBlockInfo(idColonna,&rot,&PinseCol);
                SctDynBlock dyn;
               
                pMinCol=PinseCol;
                pMinCol.z=0.0;
                pMaxCol.x=PinseCol.x+dyn.getPropValueDouble(idColonna,L"L");
                pMaxCol.y=PinseCol.y+dyn.getPropValueDouble(idColonna,L"H");
                pMaxCol.z=0.0;

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

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

        int p=0;
        id=idBlock;
        AcGeMatrix3d mat;
        mat.setToIdentity();

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

        /*quota1=true;
        quota2=true;
        quota3=true;
        quota4=true;*/
        quota=0;
        AcGePoint3dArray puntiGrip;
        AcDbEntity* obj;
    AcDbIntArray geomIds;
  /* AcDbEntity m_quota;*/
    AcGePoint3d tmpPt;
        AcGePoint3d pIns;
        AcGePoint3d arr,part,mid;
        arr[0]=pMinCol.x;
        arr[1]=0;
        arr[2]=0;
        part[0]=pMaxCol.x;
        part[1]=0;
        part[2]=0;
        partenza=part;
        entityList.append(m_block);
        sctUtility::mid_point(&mid,part,arr);
        EntQ1= new AcDbAlignedDimension(part,arr,mid);
        entityList.append(EntQ1);

        ///SctQuotatura *sq=new SctQuotatura();
        //sq->QuotaDuePunti(part,arr,0,0,L"STEEL",&id_quota1,L"QUOTE_PROVA",15,15,L"");
        part[0]=pMaxCol.x;
        part[1]=pMaxCol.y;
        part[2]=0;
        partenza1=part;
        sctUtility::mid_point(&mid,part,arr);
        EntQ2= new AcDbAlignedDimension(part,arr,mid);
        entityList.append(EntQ2);
        ////sq->QuotaDuePunti(part,arr,0,0,L"STEEL",&id_quota2,L"QUOTE_PROVA",15,15,L"");
        part[0]=pMinCol.x;
        part[1]=0;
        part[2]=0;
        partenza2=part;
        ////sq->QuotaDuePunti(part,arr,0,0,L"STEEL",&id_quota3,L"QUOTE_PROVA",15,15,L"");
        ////sq->QuotaDuePunti(part,arr,0,0,L"STEEL",&id_quota4,L"QUOTE_PROVA",15,15,L"");*/
        sctUtility::mid_point(&mid,part,arr);
        EntQ3= new AcDbAlignedDimension(part,arr,mid);
        entityList.append(EntQ3);
        EntQ4= new AcDbAlignedDimension(part,arr,mid);
        entityList.append(EntQ4);
        m_entityList.setEntityList (entityList);
       

       

       

        //per appendere tutte le entità
        //append();
        AcEdJig::setDispPrompt(L"\nInserisci ....");
        /*acedRegisterFilterWinMsg(WinCallBack1);
        AcEdJig::DragStatus stat = AcEdJig::drag();
        acedRemoveFilterWinMsg(WinCallBack1);
        quota++;*/
        AcEdJig::DragStatus stat = AcEdJig::kNormal;
        bool primoGiro=true;
        JIGCQE = false;
        UPDATEPOINTCQE=false;
        while(stat!=AcEdJig::kCancel||primoGiro)
        {
                 
                 stat = AcEdJig::drag();
                 
                 
                 primoGiro=false;
                 quota++;
                 //acutPrintf(L"\nSTAT %d quota %d", stat, quota);
                 m_dimData.removeAll();
                 

                 acutPrintf(L"\nSTAT %d quota %d", stat, quota);
                 //m_cursorPoint=pEnd;
                 /*Nsettata=-1;*/
        }
        JIGCQE = false;
        UPDATEPOINTCQE = false;
        AcDbEntity *Ent=NULL;
               
        //E' necessario aggiungere i dati estesi con le linee di taglio
        //altrimenti i tubi non vengono tagliati
        /*AcDbEntity *pEnt=NULL;
        if (acdbOpenObject(pEnt,m_block1->id(),AcDb::kForWrite)==Acad::eOk)
        {
                        pEnt->setLayer(layer);
                        pEnt->close();
                        pEnt=NULL;
        }*/

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

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

        return false;
}


AcEdJig::DragStatus JigMensola::sampler()
{
        DragStatus stat=AcEdJig::kNormal;
       
    {
                //inserimento blocco e richiesta punto
                AcEdJig::setUserInputControls(
                        (UserInputControls)(AcEdJig::kAccept3dCoordinates | AcEdJig::kNoNegativeResponseAccepted | AcEdJig::kNoZeroResponseAccepted));
               
                static AcGePoint3d pointTmp;

                /*if (UPDATEPOINTCQE)
                {
                       
                        return AcEdJig::kNoChange;
                }*/
                /*if(SETDIM)
                {
                        SETDIM=false;
                        return AcEdJig::kNoChange;
                }
                else*/
                        stat = acquirePoint(pointTmp);
               
                //acutPrintf(L"\npointTmp %.0f;%.0f;%.0f\n",pointTmp.x,pointTmp.y,pointTmp.z);
                if(pointTmp != m_cursorPoint/*&& settataQuota!=true*/)
                {
                        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);
                        m_cursorPoint = pointTmp;       
                       
                }
                else if (stat == AcEdJig::kNormal)
                {
                        /*m_cursorPoint.set(m_NEWcursorPoint.x,m_NEWcursorPoint.y,m_NEWcursorPoint.z);
                        settataQuota = false;*/
                        //acutPrintf(L"\nelse %.0f;%.0f;%.0f\n",m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z);
                                return AcEdJig::kNoChange;
                }
         }

        return stat;
}


Adesk::Boolean JigMensola::update()
{
       
        AcDbBlockReference* pRef=NULL;
        AcDbPolyline *pLine=NULL;
        AcDbLine* pQ=NULL;
        AcDbAlignedDimension* pQuo=NULL;
        AcDbEntity *xEntH=NULL;
        Acad::ErrorStatus es;
        AcGeVector3d dir1;
        AcGeVector3d dir2;
        acutPrintf(L"\nupdate");
        double distanzaCond=0.6;
        /*distanzaCond=Configurazione::getInstance().getDistanzaConduttori()*0.5;
        */
        //inserimento dell'elemento
        intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
        pEnd=AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z);
       
        intersectionPoints.removeAll();
        AcDbPolyline *tracciatura=NULL;
        AcGePoint3d start;
        AcGePoint3d midP;

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

                //l'entità che si sta aggiornando è la linea di tracciatura mensola
                if(xEntH->isKindOf(AcDbBlockReference::desc()) && j==0)
                {
                       
                                       
                //L'utente sta inserendo il blocco che si deve allineare automaticamente
                //al tubo o ai tubi ammesso che esista
                pRef=static_cast<AcDbBlockReference*>(m_block);
                if (settataQuota)
                {
                        pEnd=dimEndNew;
                       
                        settataQuota = false;
                }

               
                //JIGCQE = true;
               
                es=pRef->setPosition(pEnd);
                //m_cursorPoint = pEnd;
                //JIGCQE = true;
                //JIGCQE = true;
                //acutPrintf(L"\nUPDATE pEnd %.0f;%.0f;%.0f\n",pEnd.x,pEnd.y,pEnd.z);
                es=pRef->setScaleFactors(AcGeScale3d(1,1,1));
                //allineaAssi(pRef);
                }

                //if(xEntH->isKindOf(AcDbLine::desc()) && j==1)
                //{
                //        pQ=AcDbLine::cast(xEntH);
                //        pQ->setEndPoint(pEnd);
                //       
                //}


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

                //                //- If ok
                //                if(p)
                //                {
                //                        AcGePoint3d mid;
                //                        start=p->xLine1Point();
                //                        start.y=pEnd.y;
                //                        sctUtility::mid_point(&mid,start,pEnd);
                //                        /*mid.x=(ref1.x+m_cursorPoint.x)/2.0;
                //                        mid.y=(ref1.y+m_cursorPoint.y)/2.0;
                //                        mid.z=m_cursorPoint.z;*/

                //                        p->setXLine1Point(start);
                //                        p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
                //                        p->setDimLinePoint(mid);
                //                        p->setDynamicDimension(true);
                //                }
                //        }
                //       
                //}
                //        //pQuo=AcDbAlignedDimension::cast(xEntH);
                //        //start=pQuo->xLine1Point();
                //        //start.y=pEnd.y;
                //        //sctUtility::mid_point(&midP,start,pEnd);
                //        //
                //        //es=pQuo->setXLine1Point(start);
                //        //es=pQuo->setXLine2Point(pEnd);
                //        //pQuo->setDimLinePoint(midP);
                //        //
                //        ///*Ptest.x=pEnd.x+fabs(start.x-pEnd.x)/2;
                //        //Ptest.y=pEnd.y;
                //        //Ptest.z=0;
                //        //es=pQuo->setTextPosition(Ptest);*/
                //
                //
                //}

                if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==1)
                {
                //quota 2
                        pQuo=AcDbAlignedDimension::cast(xEntH);
                        start=pQuo->xLine1Point();
                        start.y=pEnd.y;
                       
                        sctUtility::mid_point(&midP,start,pEnd);
                       
                        es=pQuo->setXLine1Point(start);
                        es=pQuo->setXLine2Point(pEnd);
                        pQuo->setDimLinePoint(midP);
                        /*Ptest.y=pEnd.y+fabs(start.y-pEnd.y)/2;
                        Ptest.x=pEnd.x;
                        Ptest.z=0;
                        es=pQuo->setTextPosition(Ptest);*/
               
               
                }
                if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==2)
                {
                //quota 2
                        pQuo=AcDbAlignedDimension::cast(xEntH);
                        start=pQuo->xLine1Point();
                        start.x=pEnd.x;
                       
                        sctUtility::mid_point(&midP,start,pEnd);
                       
                        es=pQuo->setXLine1Point(start);
                        es=pQuo->setXLine2Point(pEnd);
                        pQuo->setDimLinePoint(midP);
                        /*Ptest.y=pEnd.y+fabs(start.y-pEnd.y)/2;
                        Ptest.x=pEnd.x;
                        Ptest.z=0;
                        es=pQuo->setTextPosition(Ptest);*/
               
               
                }
                if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==3)
                {
                //quota 3       
                        pQuo=AcDbAlignedDimension::cast(xEntH);
                        start=pQuo->xLine1Point();
                        start.y=pEnd.y;
                       
                        sctUtility::mid_point(&midP,start,pEnd);
                       
                        es=pQuo->setXLine1Point(start);
                        es=pQuo->setXLine2Point(pEnd);
                        pQuo->setDimLinePoint(midP);
                /*        Ptest.x=pEnd.x+fabs(start.x-pEnd.x)/2;
                        Ptest.y=pEnd.y;
                        Ptest.z=0;
                        es=pQuo->setTextPosition(Ptest);*/

               
               
                }
                if(xEntH->isKindOf(AcDbAlignedDimension::desc()) && j==4)
                {
                //quota 4
                        pQuo=AcDbAlignedDimension::cast(xEntH);
                        start=pQuo->xLine1Point();
                        start.x=pEnd.x;
                       
                        sctUtility::mid_point(&midP,start,pEnd);
                       
                        es=pQuo->setXLine1Point(start);
                        es=pQuo->setXLine2Point(pEnd);
                        pQuo->setDimLinePoint(midP);
                        /*Ptest.y=pEnd.y+fabs(start.y-pEnd.y)/2;
                        Ptest.x=pEnd.x;
                        Ptest.z=0;
                        es=pQuo->setTextPosition(Ptest);*/

               
               
                }

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

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

                                        start=partenza;
                                        start.y=pEnd.y;
                                        sctUtility::mid_point(&mid,start,pEnd);
                                        /*mid.x=(ref1.x+m_cursorPoint.x)/2.0;
                                        mid.y=(ref1.y+m_cursorPoint.y)/2.0;
                                        mid.z=m_cursorPoint.z;*/

                                        p->setXLine1Point(start);
                                        p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
                                        p->setDimLinePoint(mid);
                                        p->setDynamicDimension(true);
                                        //d->setDimension(p);
                                }
                        }
                }
       
        if (valoreQuota==1|| Nsettata==1)
                {
                        AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(m_dimData.at(0)) ;
                        int inputNumber =-1 ;
                        //- Find the dim data being passed so we can determine the input number
                        if ( m_dimData.find (dimDataNC, inputNumber) )
                        {
                                //- Now get the dimension
                                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
                                //- Check it's the type of dimension we want
                                AcDbAlignedDimension *p =AcDbAlignedDimension::cast (pDim) ;
                                //- If ok
                                if (p) {
                                        AcGePoint3d mid;

                                        start=partenza1;

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

                                        p->setXLine1Point(start);
                                        p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
                                        p->setDimLinePoint(mid);
                                        p->setDynamicDimension(true);
                                        //d->setDimension(p);
                                }
                        }
                }
        if (valoreQuota==2|| Nsettata==2)
                {
                        AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(m_dimData.at(0)) ;
                        int inputNumber =-1 ;
                        //- Find the dim data being passed so we can determine the input number
                        if ( m_dimData.find (dimDataNC, inputNumber) )
                        {
                                //- Now get the dimension
                                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
                                //- Check it's the type of dimension we want
                                AcDbAlignedDimension *p =AcDbAlignedDimension::cast (pDim) ;
                                //- If ok
                                if (p) {
                                        AcGePoint3d mid;

                                        start=partenza2;

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

                                        p->setXLine1Point(start);
                                        p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
                                        p->setDimLinePoint(mid);
                                        p->setDynamicDimension(true);
                                        //d->setDimension(p);
                                }
                        }
                }
        if (valoreQuota==3|| Nsettata==3)
                {
                        AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(m_dimData.at(0)) ;
                        int inputNumber =-1 ;
                        //- Find the dim data being passed so we can determine the input number
                        if ( m_dimData.find (dimDataNC, inputNumber) )
                        {
                                //- Now get the dimension
                                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
                                //- Check it's the type of dimension we want
                                AcDbAlignedDimension *p =AcDbAlignedDimension::cast (pDim) ;
                                //- If ok
                                if (p) {
                                        AcGePoint3d mid;

                                        start=partenza2;

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

                                        p->setXLine1Point(start);
                                        p->setXLine2Point(AcGePoint3d(m_cursorPoint.x,m_cursorPoint.y,m_cursorPoint.z));
                                        p->setDimLinePoint(mid);
                                        p->setDynamicDimension(true);
                                        //d->setDimension(p);
                                }
                        }
                }
        /*if(settataQuota)*/
        Nsettata=-1;
        return Adesk::kTrue;
}


//PuntoDiSospensione JigMensola::cercaPds(AcGePoint3d p,AcDbPolyline *tracciatura)
//{
//        double distanza=1000000000;
//        AcGePoint3d punto,pTrovato;
//        PuntoDiSospensione pd;
//        int indice=0;
//        double distanzaPdsLineaTeoricaTracciatura=0.0;
//        AcDbLine *teorica=new AcDbLine();
//        AcGePoint3dArray intersectionPoints;
//        intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
//        for (int i=0;i<pds.size();i++)
//        {
//                intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
//                teorica->setStartPoint(pds.at(i).getPinse());
//                teorica->setEndPoint(p);
//                teorica->intersectWith (tracciatura, AcDb::kOnBothOperands, intersectionPoints);
//
//                tracciatura->getClosestPointTo(pds.at(i).getPinse(),pTrovato);
//                distanzaPdsLineaTeoricaTracciatura=pTrovato.distanceTo(pds.at(i).getPinse());
//                acutPrintf(L"\n%.2f",distanzaPdsLineaTeoricaTracciatura);
//                //la nuova campata NON deve intesercare la linea di tracciatura teorica
//                if (intersectionPoints.length()==0)
//                {
//                        if(pds.at(i).getPinse().distanceTo(p)<distanza)
//                        {
//                                if (distanzaPdsLineaTeoricaTracciatura<0.4)
//                                {
//                                        distanza=pds.at(i).getPinse().distanceTo(p);
//                                        indice=i;
//                               
//                                        punto=pds.at(i).getPinse();
//                                }
//                        }
//                }
//        }
//
//        delete teorica;teorica=NULL;
//        intersectionPoints.setLogicalLength(0).setPhysicalLength(0);
//
//        if (indice<pds.size())
//                pd=pds.at(indice);
//
//
//        return pd;
//}
//
//

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

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



AcDbObjectId JigMensola::append(AcDbDatabase *dwg,
const ACHAR *requiredSpace)
{
         // get the total number of entities registered
        int length = m_entityList.m_entities.length ();
         // loop round the registered
         // entities and add the to the space
        for (int i=0; i<length; ++i)
        {
                postToDwg ((AcDbEntity *)m_entityList.m_entities[i],
                dwg, requiredSpace);
        }

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

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

        // return the object id
        return (id);
}



AcDbObjectId JigMensola::append(int posEnt,AcDbDatabase *dwg,
const ACHAR *requiredSpace)
{
         // get the total number of entities registered
        int length = m_entityList.m_entities.length ();
         // loop round the registered
         // entities and add the to the space
        if (posEnt<length)
        {
                postToDwg ((AcDbEntity *)m_entityList.m_entities[posEnt],
                dwg, requiredSpace);
        }

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

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

        // return the object id
        return (id);
}



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

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

AcDbBlockTableRecord *blockTableRecord = NULL;
// now get a pointer to the model space entity records
es = blockTable->getAt (requiredSpace,
  blockTableRecord, AcDb::kForWrite);
// can close the block table
// itself as we don't need it anymore
blockTable->close ();
// if it failed then abort
if (es != Acad::eOk)
  return (es);
// otherwise put the entity into the model space
es = blockTableRecord->appendAcDbEntity (pEnt);
// now close it up
blockTableRecord->close();

return (es);
}
AcDbDimDataPtrArray * JigMensola::dimData(const double dimScale)
{
        acutPrintf(L"\nSTARTdimData");
        int valoreQuota=quota%4;
        if (valoreQuota==0)
        {
                AcDbAlignedDimension * pDimension = new AcDbAlignedDimension;
                pDimension->setDatabaseDefaults();
                pDimension->setNormal(AcGeVector3d::kZAxis);
                pDimension->setElevation(0.0);
                pDimension->setDimscale(dimScale);
                pDimension->setHorizontalRotation(0.);
                pDimension->setDynamicDimension(true);

                AcDbObjectId idStile;

                /*ACHAR* stile=L"Standard";

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

                AcDbDimData * pDimData = new AcDbDimData(pDimension);
                pDimData->setDimFocal(true);
                pDimData->setDimHideIfValueIsZero(true);
                pDimData->setDimEditable(true);
       

                 m_dimData.append(pDimData);
        }

        if (valoreQuota==1)
        {
                AcDbAlignedDimension * pDimension = new AcDbAlignedDimension;
                pDimension->setDatabaseDefaults();
                pDimension->setNormal(AcGeVector3d::kZAxis);
                pDimension->setElevation(0.0);
                pDimension->setDimscale(dimScale);
                pDimension->setHorizontalRotation(0.);
                pDimension->setDynamicDimension(true);

                AcDbObjectId idStile;

                /*ACHAR* stile=L"Standard";

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

                AcDbDimData * pDimData = new AcDbDimData(pDimension);
                pDimData->setDimFocal(true);
                pDimData->setDimHideIfValueIsZero(true);
                pDimData->setDimEditable(true);
       
                 m_dimData.append(pDimData);
        }

        if (valoreQuota==2)
        {
                AcDbAlignedDimension * pDimension = new AcDbAlignedDimension;
                pDimension->setDatabaseDefaults();
                pDimension->setNormal(AcGeVector3d::kZAxis);
                pDimension->setElevation(0.0);
                pDimension->setDimscale(dimScale);
                pDimension->setHorizontalRotation(0.);
                pDimension->setDynamicDimension(true);

                AcDbObjectId idStile;

                /*ACHAR* stile=L"Standard";

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

                AcDbDimData * pDimData = new AcDbDimData(pDimension);
                pDimData->setDimFocal(true);
                pDimData->setDimHideIfValueIsZero(true);
                pDimData->setDimEditable(true);
       
                 m_dimData.append(pDimData);
        }

        if (valoreQuota==3)
        {
                AcDbAlignedDimension * pDimension = new AcDbAlignedDimension;
                pDimension->setDatabaseDefaults();
                pDimension->setNormal(AcGeVector3d::kZAxis);
                pDimension->setElevation(0.0);
                pDimension->setDimscale(dimScale);
                pDimension->setHorizontalRotation(0.);
                pDimension->setDynamicDimension(true);

                AcDbObjectId idStile;

                /*ACHAR* stile=L"Standard";

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

                AcDbDimData * pDimData = new AcDbDimData(pDimension);
                pDimData->setDimFocal(true);
                pDimData->setDimHideIfValueIsZero(true);
                pDimData->setDimEditable(true);
       
                 m_dimData.append(pDimData);
        }
        acutPrintf(L"\nENDdimData");
       
        return &m_dimData;


}

Acad::ErrorStatus JigMensola::setDimValue (const AcDbDimData *pDimData, const double dimValue) {
        Acad::ErrorStatus es =Acad::eOk ;
        int valoreQuota=quota%4;
        JIGCQE = true;
        acutPrintf(L"\nSTARTsetdimvalue");
        if (valoreQuota==0)
        {
                 //SAMPLE CODE:
                //- Convert the const pointer to non const
                AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
                int inputNumber =-1 ;
                //- Find the dim data being passed so we can determine the input number
                if ( m_dimData.find (dimDataNC, inputNumber) ) {
                        //- Now get the dimension
                        if(inputNumber==0)
                        {
                                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
                                //- Check it's the type of dimension we want
                                AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
                                //- If ok
                                if ( pAlnDim ) {
                                        //- Extract the dimensions as they are now
                                        AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
                                        AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
                                        //- Lets get the new point entered by the user
                                        //AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
                                        ////- Finally set the end dim point
                                        //pAlnDim->setXLine2Point (dimEndNew) ;
                                        //- Now update the jig data to reflect the dynamic dimension input
                                        //mInputPoints [mCurrentInputLevel] =dimEndNew ;
                                       
                                        dimEndNew=dimStart;
                                        dimEndNew.x=dimStart.x-dimValue;
                                        vettore=dimEndNew-pEnd;
                                        //m_cursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
                                        /*
                                        m_NEWcursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
                                        pEnd = dimEndNew;*/
                                        pAlnDim->setXLine2Point (dimEndNew) ;
                                        //acutPrintf(L"\setdimvalue pEnd %.0f;%.0f;%.0f\n",pEnd.x,pEnd.y,pEnd.z);
                                        /*AcEdJig::DragStatus stat = AcEdJig::drag();*/
                                        /*pointTmp=dimEndNew*/;
                                }
                        }
                }
                Nsettata=1;
        }
        if (valoreQuota==1)
        {
                 //SAMPLE CODE:
                //- Convert the const pointer to non const
                AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
                int inputNumber =-1 ;
                //- Find the dim data being passed so we can determine the input number
                if ( m_dimData.find (dimDataNC, inputNumber) ) {
                        //- Now get the dimension
                        if(inputNumber==0)
                        {
                                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
                                //- Check it's the type of dimension we want
                                AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
                                //- If ok
                                if ( pAlnDim ) {
                                        //- Extract the dimensions as they are now
                                        AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
                                        AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
                                        //- Lets get the new point entered by the user
                                        //AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
                                        ////- Finally set the end dim point
                                        //pAlnDim->setXLine2Point (dimEndNew) ;
                                       
                                        dimEndNew=dimStart;
                                        dimEndNew.y=dimStart.y-dimValue;
                                        vettore=dimEndNew-pEnd;
                                        m_cursorPoint=dimEndNew;
                                        m_NEWcursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
                                        //- Now update the jig data to reflect the dynamic dimension input
                                        //mInputPoints [mCurrentInputLevel] =dimEndNew ;
                                }
                        }
                }
                Nsettata=2;
        }

        if (valoreQuota==2)
        {
                 //SAMPLE CODE:
                //- Convert the const pointer to non const
                AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
                int inputNumber =-1 ;
                //- Find the dim data being passed so we can determine the input number
                if ( m_dimData.find (dimDataNC, inputNumber) ) {
                        //- Now get the dimension
                        if(inputNumber==0)
                        {
                                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
                                //- Check it's the type of dimension we want
                                AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
                                //- If ok
                                if ( pAlnDim ) {
                                        //- Extract the dimensions as they are now
                                        AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
                                        AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
                                        //- Lets get the new point entered by the user
                                        //AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
                                        ////- Finally set the end dim point
                                        //pAlnDim->setXLine2Point (dimEndNew) ;
                                       
                                        dimEndNew=dimStart;
                                        dimEndNew.x=dimStart.x+dimValue;
                                        vettore=dimEndNew-pEnd;
                                        m_cursorPoint=dimEndNew;
                                        m_NEWcursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
                                        //- Now update the jig data to reflect the dynamic dimension input
                                        //mInputPoints [mCurrentInputLevel] =dimEndNew ;
                                }
                        }
                }
                Nsettata=3;
        }

        if (valoreQuota==3)
        {
                 //SAMPLE CODE:
                //- Convert the const pointer to non const
                AcDbDimData *dimDataNC =const_cast<AcDbDimData *>(pDimData) ;
                int inputNumber =-1 ;
                //- Find the dim data being passed so we can determine the input number
                if ( m_dimData.find (dimDataNC, inputNumber) ) {
                        //- Now get the dimension
                        if(inputNumber==0)
                        {
                                AcDbDimension *pDim =(AcDbDimension *)dimDataNC->dimension () ;
                                //- Check it's the type of dimension we want
                                AcDbAlignedDimension *pAlnDim =AcDbAlignedDimension::cast (pDim) ;
                                //- If ok
                                if ( pAlnDim ) {
                                        //- Extract the dimensions as they are now
                                        AcGePoint3d dimStart =pAlnDim->xLine1Point () ;
                                        AcGePoint3d dimEnd =pAlnDim->xLine2Point () ;
                                        //- Lets get the new point entered by the user
                                        //AcGePoint3d dimEndNew =dimStart + (dimEnd - dimStart).normalize () * dimValue ;
                                        ////- Finally set the end dim point
                                        //pAlnDim->setXLine2Point (dimEndNew) ;
                                       
                                        dimEndNew=dimStart;
                                        dimEndNew.y=dimStart.y+dimValue;
                                        vettore=dimEndNew-pEnd;
                                        m_cursorPoint=dimEndNew;
                                        m_NEWcursorPoint.set(dimEndNew.x,dimEndNew.y,dimEndNew.z);
                                        //- Now update the jig data to reflect the dynamic dimension input
                                        //mInputPoints [mCurrentInputLevel] =dimEndNew ;
                                }
                        }
                }
                Nsettata=0;
        }
        //JIGCQE = true;
        settataQuota=true;
        SETDIM=true;
        acutPrintf(L"\nENDsetdimvalue");
        return (es) ;
}[/code]

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=6764][color=Red]法拉利膜材中国代理商 - 膜结构网[/color][/size][/url]

汇锋膜材代理商

汇锋膜材，作为一种高性能复合材料，在建筑、环保、电子等多个领域展现了广泛的应用价值。以下是对汇锋膜材的详细分析：
[b]一、公司背景与实力[/b]
浙江汇锋新材料股份有限公司（汇锋新材）成立于2001年，坐落于浙江省海宁市，是一家集研发、生产、销售于一体的现代化新型高科技公司。该公司拥有汇锋新材料、汇锋薄膜科技、汇锋塑胶科技三个主要厂区，占地面积超过10万平方米，并在中国新三板挂牌上市（股票代码：836141）。汇锋新材还与世界十大膜材生产商日本平冈展开合作，其产品在国内外市场上享有盛誉。
[b]二、产品特点[/b]
1、高性能：
2、轻质化：汇锋膜材具有很高的比强度和比刚度，单位重量下的性能优于传统建材和金属材料。
3、耐候性强：具有超强抗紫外线、耐氧化、防腐蚀性能，户外应用不褪色、不脆裂，耐候级别可达12000小时以上（国标耐人工气候老化测试结果）。
4、机械强度高：能够承受较大的外力作用，确保结构的稳定性和安全性。
5、防火性能：部分产品达到防火标准，提高建筑的安全性。
6、环保安全：采用环保无毒原材料生产，无有害物质排放，符合国家环保政策。使用水性油墨印刷，不含重金属，绿色环保。
7、多功能性：具有自洁功能，易清洁，减少维护成本。延展性好，适应各种加工需求。部分产品具有优异的透光性和隔热性能，有助于节能减排。
[b]三、应用领域[/b]
建筑领域：用于墙体、屋面、幕墙、天光板、隔热材料等，具有重量轻、强度高、防水、隔热、耐候性好等优点。应用于新型建材中，逐渐取代传统建筑材料。
环保领域：制作成污水处理设备、废水处理设备、气体处理设备等，具有防腐、耐酸碱、耐高温等特点。
电子领域：作为电子产品的外壳、电容器、电池隔膜等，提高电子产品的性能指标。
其他领域：在航空航天、交通设施、文化设施等多个领域也有广泛应用。
[b]四、技术创新与发展[/b]
汇锋新材注重技术创新和产品研发，不断推出适应市场需求的新产品。例如，其PVDF高耐候钢板膜和装饰膜不仅具有优异的耐候性和耐化学腐蚀性，还提供多种花色选择，满足客户的多样化需求。此外，汇锋新材还积极采用环保技术和材料，推动绿色建筑和可持续发展。
[b]五、市场认可度与前景[/b]
随着全球对环保、节能和可持续发展的重视不断加深，高性能、环保型膜材的市场需求持续增长。汇锋膜材凭借其优异的性能和广泛的应用领域在市场上赢得了广泛的认可。未来，随着技术的不断进步和市场的不断发展，汇锋膜材有望在更多领域发挥重要作用，为建筑、环保、电子等行业提供更高品质、更环保的解决方案。
综上所述，汇锋膜材作为一种高性能、环保型复合材料，在建筑、环保、电子等多个领域展现了广泛的应用前景和市场潜力。随着市场需求的不断增长和技术的不断进步，汇锋膜材有望成为推动相关行业发展的重要力量。