diff --git a/CurveArc.cpp b/CurveArc.cpp
index b355fe8..eda7678 100644
--- a/CurveArc.cpp
+++ b/CurveArc.cpp
@@ -59,8 +59,10 @@ class ArcApproxer
 //----------------------------------------------------------------------------
 CurveArc::CurveArc( void)
    : m_nStatus( TO_VERIFY), m_PtCen(), m_VtN(), m_VtS(), m_dRad(),
-     m_dAngCenDeg(), m_dDeltaN(), m_VtExtr(), m_dThick(), m_nTempProp()
+     m_dAngCenDeg(), m_dDeltaN(), m_VtExtr(), m_dThick()
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -578,7 +580,8 @@ CurveArc::CopyFrom( const CurveArc& caSrc)
       return true ;
    m_VtExtr = caSrc.m_VtExtr ;
    m_dThick = caSrc.m_dThick ;
-   m_nTempProp = caSrc.m_nTempProp ;
+   m_nTempProp[0] = caSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = caSrc.m_nTempProp[1] ;
    return Set( caSrc.m_PtCen, caSrc.m_VtN, caSrc.m_dRad,
                caSrc.m_VtS, caSrc.m_dAngCenDeg, caSrc.m_dDeltaN) ;
 }
diff --git a/CurveArc.h b/CurveArc.h
index 768f5c9..69ba383 100644
--- a/CurveArc.h
+++ b/CurveArc.h
@@ -49,10 +49,11 @@ class CurveArc : public ICurveArc, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -211,7 +212,7 @@ class CurveArc : public ICurveArc, public IGeoObjRW
       double   m_dDeltaN ;             // variazione di quota lungo VtN della fine rispetto all'inizio
       Vector3d m_VtExtr ;              // vettore estrusione (normalmente coincide con m_VtN)
       double   m_dThick ;              // spessore
-      int      m_nTempProp ;           // proprietà temporanea 
+      int      m_nTempProp[2] ;        // vettore proprietà temporanee
 } ;
 
 //-----------------------------------------------------------------------------
diff --git a/CurveBezier.cpp b/CurveBezier.cpp
index e0299ad..16533dd 100644
--- a/CurveBezier.cpp
+++ b/CurveBezier.cpp
@@ -45,8 +45,10 @@ GEOOBJ_REGISTER( CRV_BEZIER, NGE_C_BEZ, CurveBezier) ;
 //----------------------------------------------------------------------------
 CurveBezier::CurveBezier( void)
    : m_nStatus( TO_VERIFY), m_nDeg(), m_bRat( false), m_dParSing( -2),
-     m_VtExtr(), m_dThick(), m_nTempProp()
+     m_VtExtr(), m_dThick()
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -283,7 +285,8 @@ CurveBezier::CopyFrom( const CurveBezier& cbSrc)
       m_vWeCtrl = cbSrc.m_vWeCtrl ;
    m_VtExtr = cbSrc.m_VtExtr ;
    m_dThick = cbSrc.m_dThick ;
-   m_nTempProp = cbSrc.m_nTempProp ;
+   m_nTempProp[0] = cbSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = cbSrc.m_nTempProp[1] ;
    return true ;
 }
 
diff --git a/CurveBezier.h b/CurveBezier.h
index 3710ca7..d5e96ac 100644
--- a/CurveBezier.h
+++ b/CurveBezier.h
@@ -51,10 +51,11 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override { return true ; }
@@ -189,7 +190,7 @@ class CurveBezier : public ICurveBezier, public IGeoObjRW
       DBLVECTOR      m_vWeCtrl ;       // vettore dei pesi di controllo
       Vector3d       m_VtExtr ;        // vettore estrusione (normalmente coincide con m_VtN)
       double         m_dThick ;        // spessore
-      int            m_nTempProp ;     // proprietà temporanea 
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee
 } ;
 
 //-----------------------------------------------------------------------------
diff --git a/CurveComposite.cpp b/CurveComposite.cpp
index 65ed355..c9d6239 100644
--- a/CurveComposite.cpp
+++ b/CurveComposite.cpp
@@ -40,8 +40,10 @@ GEOOBJ_REGISTER( CRV_COMPO, NGE_C_CMP, CurveComposite) ;
 
 //----------------------------------------------------------------------------
 CurveComposite::CurveComposite( void)
-   : m_nStatus( TO_VERIFY), m_VtExtr(), m_dThick(), m_ptStart(), m_nTempProp(), m_Iter( m_CrvSmplS.end())
+   : m_nStatus( TO_VERIFY), m_VtExtr(), m_dThick(), m_ptStart(), m_Iter( m_CrvSmplS.end())
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -63,7 +65,8 @@ CurveComposite::Clear( void)
    m_VtExtr = V_NULL ;
    m_dThick = 0 ;
    m_ptStart = ORIG ;
-   m_nTempProp = 0 ;
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
    m_Iter = m_CrvSmplS.end() ;
 
   // imposto ricalcolo della grafica
@@ -541,7 +544,8 @@ CurveComposite::CopyFrom( const CurveComposite& ccSrc)
    Clear() ;
    m_VtExtr = ccSrc.m_VtExtr ;
    m_dThick = ccSrc.m_dThick ;
-   m_nTempProp = ccSrc.m_nTempProp ;
+   m_nTempProp[0] = ccSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = ccSrc.m_nTempProp[1] ;
    for ( auto& pCrv : ccSrc.m_CrvSmplS) {
       if ( ! AddCurve( *pCrv))
          return false ;
@@ -558,7 +562,8 @@ CurveComposite::RelocateFrom( CurveComposite& ccSrc)
    Clear() ;
    m_VtExtr = ccSrc.m_VtExtr ;
    m_dThick = ccSrc.m_dThick ;
-   m_nTempProp = ccSrc.m_nTempProp ;
+   m_nTempProp[0] = ccSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = ccSrc.m_nTempProp[1] ;
    for ( ICurve* pCrv = ccSrc.RemoveFirstOrLastCurve( false) ;
          pCrv != nullptr ;
          pCrv = ccSrc.RemoveFirstOrLastCurve( false)) {
@@ -3243,7 +3248,7 @@ CurveComposite::IsACircle( double dLinTol, Point3d& ptCen, Vector3d& vtN, double
 
 //----------------------------------------------------------------------------
 bool
-CurveComposite::SetCurveTempProp( int nCrv, int nProp)
+CurveComposite::SetCurveTempProp( int nCrv, int nProp, int nPropNum)
 {
   // la curva deve essere validata
    if ( m_nStatus != OK)
@@ -3252,13 +3257,13 @@ CurveComposite::SetCurveTempProp( int nCrv, int nProp)
    if ( nCrv < 0  ||  nCrv >= int( m_CrvSmplS.size()))
       return false ;
   // eseguo assegnazione
-   m_CrvSmplS[nCrv]->SetTempProp( nProp) ;
+   m_CrvSmplS[nCrv]->SetTempProp( nProp, nPropNum) ;
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-CurveComposite::GetCurveTempProp( int nCrv, int& nProp) const
+CurveComposite::GetCurveTempProp( int nCrv, int& nProp, int nPropNum) const
 {
   // la curva deve essere validata
    if ( m_nStatus != OK)
@@ -3267,6 +3272,6 @@ CurveComposite::GetCurveTempProp( int nCrv, int& nProp) const
    if ( nCrv < 0  ||  nCrv >= int( m_CrvSmplS.size()))
       return false ;
   // eseguo recupero
-   nProp = m_CrvSmplS[nCrv]->GetTempProp() ;
+   nProp = m_CrvSmplS[nCrv]->GetTempProp( nPropNum) ;
    return true ;
 }
diff --git a/CurveComposite.h b/CurveComposite.h
index fed9790..e9cf54d 100644
--- a/CurveComposite.h
+++ b/CurveComposite.h
@@ -50,10 +50,11 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -158,8 +159,8 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       bool IsAPoint( void) const override ;
       bool IsALine( double dLinTol, Point3d& ptStart, Point3d& ptEnd) const override ;
       bool IsACircle( double dLinTol, Point3d& ptCen, Vector3d& vtN, double& dRad, bool& bCCW) const override ;
-      bool SetCurveTempProp( int nCrv, int nProp) override ;
-      bool GetCurveTempProp( int nCrv, int& nProp) const override ;
+      bool SetCurveTempProp( int nCrv, int nProp, int nPropNum = 0) override ;
+      bool GetCurveTempProp( int nCrv, int& nProp, int nPropNum = 0) const override ;
 
    public :                      // IGeoObjRW
       int GetNgeId( void) const override ;
@@ -202,7 +203,7 @@ class CurveComposite : public ICurveComposite, public IGeoObjRW
       Vector3d       m_VtExtr ;        // vettore estrusione (normalmente coincide con m_VtN)
       double         m_dThick ;        // spessore
       Point3d        m_ptStart ;       // punto iniziale per composita vuota per Add di linee o archi
-      int            m_nTempProp ;     // proprietà temporanea 
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee 
       mutable PCSD_CONST_ITER m_Iter ; // iteratore
 } ;
 
diff --git a/CurveLine.cpp b/CurveLine.cpp
index f5e2527..79ee00a 100644
--- a/CurveLine.cpp
+++ b/CurveLine.cpp
@@ -29,8 +29,10 @@ GEOOBJ_REGISTER( CRV_LINE, NGE_C_LIN, CurveLine) ;
 
 //----------------------------------------------------------------------------
 CurveLine::CurveLine( void)
-   : m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd(), m_VtExtr(), m_dThick(), m_nTempProp()
+   : m_nStatus( TO_VERIFY), m_PtStart(), m_PtEnd(), m_VtExtr(), m_dThick()
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[0] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -123,7 +125,8 @@ CurveLine::CopyFrom( const CurveLine& clSrc)
       return true ;
    m_VtExtr = clSrc.m_VtExtr ;
    m_dThick = clSrc.m_dThick ;
-   m_nTempProp = clSrc.m_nTempProp ;
+   m_nTempProp[0] = clSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = clSrc.m_nTempProp[1] ;
    return Set( clSrc.m_PtStart, clSrc.m_PtEnd) ;
 }
 
diff --git a/CurveLine.h b/CurveLine.h
index dfb395c..a3179d6 100644
--- a/CurveLine.h
+++ b/CurveLine.h
@@ -49,10 +49,11 @@ class CurveLine : public ICurveLine, public IGeoObjRW
                { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
                { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-               { m_nTempProp = nProp ; }
-      int  GetTempProp( void) const override
-               { return m_nTempProp ; }
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // ICurve
       bool IsSimple( void) const override
@@ -164,7 +165,7 @@ class CurveLine : public ICurveLine, public IGeoObjRW
       Point3d  m_PtEnd ;               // punto finale
       Vector3d m_VtExtr ;              // vettore estrusione
       double   m_dThick ;              // spessore
-      int      m_nTempProp ;           // proprietà temporanea 
+      int      m_nTempProp[2] ;        // vettore proprietà temporanee
 } ;
 
 //-----------------------------------------------------------------------------
diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index 6c33734..6978284 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/ExtDimension.cpp b/ExtDimension.cpp
index bd9e12c..beb3fbd 100644
--- a/ExtDimension.cpp
+++ b/ExtDimension.cpp
@@ -49,6 +49,8 @@ ExtDimension::ExtDimension( void)
    : m_dExtLineLen( STD_EXTLINELEN), m_dArrowLen( STD_ARROWLEN), m_dTextDist( STD_TEXTDIST),
      m_bLenIsMM( true), m_nDecDigit( STD_DECDIGIT), m_sFont( STD_FONT), m_dTextHeight( STD_TEXTHEIGHT)
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -186,7 +188,8 @@ ExtDimension::CopyFrom( const ExtDimension& clSrc)
    m_nDecDigit = clSrc.m_nDecDigit ;
    m_sFont = clSrc.m_sFont ;
    m_dTextHeight = clSrc.m_dTextHeight ;
-   m_nTempProp = clSrc.m_nTempProp ;
+   m_nTempProp[0] = clSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = clSrc.m_nTempProp[1] ;
    return true ;
 }
 
diff --git a/ExtDimension.h b/ExtDimension.h
index fa73734..a7e4e95 100644
--- a/ExtDimension.h
+++ b/ExtDimension.h
@@ -50,10 +50,11 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // IExtDimension
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -148,5 +149,5 @@ class ExtDimension : public IExtDimension, public IGeoObjRW
       int                 m_nDecDigit ;     // numero di cifre decimali
       std::string         m_sFont ;         // font del testo
       double              m_dTextHeight ;   // altezza del testo
-      int                 m_nTempProp ;     // proprietà temporanea 
+      int                 m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
diff --git a/ExtText.cpp b/ExtText.cpp
index 007d9c9..6662878 100644
--- a/ExtText.cpp
+++ b/ExtText.cpp
@@ -35,8 +35,10 @@ GEOOBJ_REGISTER( EXT_TEXT, NGE_E_TXT, ExtText) ;
 //----------------------------------------------------------------------------
 ExtText::ExtText( void)
    : m_pSTM( nullptr), m_bNoSTM( false), m_ptP(), m_vtN( 0, 0, 1), m_vtD( 1, 0, 0), m_sFont(),
-     m_nWeight( 400), m_bItalic( false), m_dHeight( 10), m_dRatio( 1), m_dAddAdvance( 0), m_nTempProp()
+     m_nWeight( 400), m_bItalic( false), m_dHeight( 10), m_dRatio( 1), m_dAddAdvance( 0)
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -184,7 +186,8 @@ ExtText::CopyFrom( const ExtText& clSrc)
    m_dRatio = clSrc.m_dRatio ; 
    m_dAddAdvance = clSrc.m_dAddAdvance ;
    m_nInsPos = clSrc.m_nInsPos ; 
-   m_nTempProp = clSrc.m_nTempProp ;
+   m_nTempProp[0] = clSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = clSrc.m_nTempProp[1] ;
    return true ;
 }
 
diff --git a/ExtText.h b/ExtText.h
index 2da3d7e..053ed4a 100644
--- a/ExtText.h
+++ b/ExtText.h
@@ -50,10 +50,11 @@ class ExtText : public IExtText, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // IExtText
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -143,5 +144,5 @@ class ExtText : public IExtText, public IGeoObjRW
       double         m_dRatio ;        // rapporto tra larghezza e altezza
       double         m_dAddAdvance ;   // avanzamento addizionale tra caratteri
       int            m_nInsPos ;       // posizione del punto di inserimento rispetto al testo
-      int            m_nTempProp ;     // proprietà temporanea 
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
diff --git a/GeoFrame3d.cpp b/GeoFrame3d.cpp
index 58a3373..54d2be4 100644
--- a/GeoFrame3d.cpp
+++ b/GeoFrame3d.cpp
@@ -29,8 +29,10 @@ GEOOBJ_REGISTER( GEO_FRAME3D, NGE_G_FRM, GeoFrame3d) ;
 
 //----------------------------------------------------------------------------
 GeoFrame3d::GeoFrame3d( void)
-   : m_frF(), m_nTempProp()
+   : m_frF()
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -114,7 +116,8 @@ GeoFrame3d::CopyFrom( const GeoFrame3d& gfSrc)
 {
    if ( &gfSrc == this)
       return true ;
-   m_nTempProp = gfSrc.m_nTempProp ;
+   m_nTempProp[0] = gfSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = gfSrc.m_nTempProp[1] ;
    return Set( gfSrc.m_frF) ;
 }
 
diff --git a/GeoFrame3d.h b/GeoFrame3d.h
index 575e53a..728c1b0 100644
--- a/GeoFrame3d.h
+++ b/GeoFrame3d.h
@@ -57,10 +57,11 @@ class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // IGeoFrame3d
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -95,5 +96,5 @@ class GeoFrame3d : public IGeoFrame3d, public IGeoObjRW
    private :
       ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
       Frame3d        m_frF ;           // oggetto
-      int            m_nTempProp ;     // proprietà temporanea 
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
diff --git a/GeoPoint3d.cpp b/GeoPoint3d.cpp
index 72d129f..0f53b5d 100644
--- a/GeoPoint3d.cpp
+++ b/GeoPoint3d.cpp
@@ -28,8 +28,10 @@ GEOOBJ_REGISTER( GEO_PNT3D, NGE_G_PNT, GeoPoint3d) ;
 
 //----------------------------------------------------------------------------
 GeoPoint3d::GeoPoint3d( void)
-   : m_ptP(), m_nTempProp()
+   : m_ptP()
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -82,7 +84,8 @@ GeoPoint3d::CopyFrom( const GeoPoint3d& clSrc)
 {
    if ( &clSrc == this)
       return true ;
-   m_nTempProp = clSrc.m_nTempProp ;
+   m_nTempProp[0] = clSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = clSrc.m_nTempProp[1] ;
    return Set( clSrc.m_ptP) ;
 }
 
diff --git a/GeoPoint3d.h b/GeoPoint3d.h
index da10eed..59f08a0 100644
--- a/GeoPoint3d.h
+++ b/GeoPoint3d.h
@@ -57,10 +57,11 @@ class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // IGeoPoint3d
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -89,5 +90,5 @@ class GeoPoint3d : public IGeoPoint3d, public IGeoObjRW
    private :
       ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
       Point3d        m_ptP ;           // oggetto
-      int            m_nTempProp ;     // proprietà temporanea 
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
diff --git a/GeoVector3d.cpp b/GeoVector3d.cpp
index c6b2fab..eef867a 100644
--- a/GeoVector3d.cpp
+++ b/GeoVector3d.cpp
@@ -29,8 +29,10 @@ GEOOBJ_REGISTER( GEO_VECT3D, NGE_G_VEC, GeoVector3d) ;
 
 //----------------------------------------------------------------------------
 GeoVector3d::GeoVector3d( void)
-   : m_vtV(), m_nTempProp()
+   : m_vtV()
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -98,7 +100,8 @@ GeoVector3d::CopyFrom( const GeoVector3d& clSrc)
 {
    if ( &clSrc == this)
       return true ;
-   m_nTempProp = clSrc.m_nTempProp ;
+   m_nTempProp[0] = clSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = clSrc.m_nTempProp[1] ;
    return Set( clSrc.m_vtV, clSrc.m_ptBase) ;
 }
 
diff --git a/GeoVector3d.h b/GeoVector3d.h
index 4461e2b..aaeac07 100644
--- a/GeoVector3d.h
+++ b/GeoVector3d.h
@@ -65,10 +65,11 @@ class GeoVector3d : public IGeoVector3d, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // IGeoVector3d
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -104,5 +105,5 @@ class GeoVector3d : public IGeoVector3d, public IGeoObjRW
       ObjGraphicsMgr m_OGrMgr ;        // gestore grafica dell'oggetto
       Vector3d       m_vtV ;           // oggetto
       Point3d        m_ptBase ;        // punto base da cui tracciare il vettore
-      int            m_nTempProp ;     // proprietà temporanea 
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
diff --git a/SurfBezier.cpp b/SurfBezier.cpp
index 88ef863..97be565 100644
--- a/SurfBezier.cpp
+++ b/SurfBezier.cpp
@@ -35,8 +35,10 @@ GEOOBJ_REGISTER( SRF_BEZIER, NGE_S_BEZ, SurfBezier) ;
 //----------------------------------------------------------------------------
 SurfBezier::SurfBezier(void)
    : m_pSTM( nullptr), m_nStatus( TO_VERIFY), m_nDegU(), m_nDegV(), m_nSpanU(), m_nSpanV(), m_bRat( false),
-     m_bTrimmed( false), m_pTrimReg( nullptr),  m_nTempProp( 0)
+     m_bTrimmed( false), m_pTrimReg( nullptr)
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -566,7 +568,8 @@ SurfBezier::CopyFrom( const SurfBezier& sbSrc)
    m_vPtCtrl = sbSrc.m_vPtCtrl ;
    if ( sbSrc.m_bRat)
       m_vWeCtrl = sbSrc.m_vWeCtrl ;
-   m_nTempProp = sbSrc.m_nTempProp ;
+   m_nTempProp[0] = sbSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = sbSrc.m_nTempProp[1] ;
    return true ;
 }
 
diff --git a/SurfBezier.h b/SurfBezier.h
index 320774b..f64e5a1 100644
--- a/SurfBezier.h
+++ b/SurfBezier.h
@@ -53,10 +53,11 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
                { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
                { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-               { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-               { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // ISurf
       bool IsSimple( void) const override
@@ -165,7 +166,7 @@ class SurfBezier : public ISurfBezier, public IGeoObjRW
       PNTVECTOR       m_vPtCtrl ;       // vettore dei punti di controllo
       DBLVECTOR       m_vWeCtrl ;       // vettore dei pesi di controllo
       SurfFlatRegion* m_pTrimReg ;      // eventuale regione di trim
-      int             m_nTempProp ;     // proprietà temporanea
+      int             m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
 
 //-----------------------------------------------------------------------------
diff --git a/SurfFlatRegion.cpp b/SurfFlatRegion.cpp
index 1353dcc..b5ef968 100644
--- a/SurfFlatRegion.cpp
+++ b/SurfFlatRegion.cpp
@@ -33,8 +33,10 @@ GEOOBJ_REGISTER( SRF_FLATRGN, NGE_S_FRG, SurfFlatRegion) ;
 
 //----------------------------------------------------------------------------
 SurfFlatRegion::SurfFlatRegion( void)
-   : m_pSTM( nullptr), m_nStatus( TO_VERIFY), m_nTempProp()
+   : m_pSTM( nullptr), m_nStatus( TO_VERIFY)
 {
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -55,7 +57,8 @@ SurfFlatRegion::Clear( void)
       delete pLoop ;
    m_vpLoop.clear() ;
 
-   m_nTempProp = 0 ;
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
@@ -397,7 +400,8 @@ SurfFlatRegion::CopyFrom( const SurfFlatRegion& sfrSrc)
       m_vpLoop.push_back( pCrv) ;
    }
    m_vExtInd = sfrSrc.m_vExtInd ;
-   m_nTempProp = sfrSrc.m_nTempProp ;
+   m_nTempProp[0] = sfrSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = sfrSrc.m_nTempProp[1] ;
    m_nStatus = sfrSrc.m_nStatus ;
    return ( m_nStatus == OK  &&  ! m_vpLoop.empty()) ;
 }
diff --git a/SurfFlatRegion.h b/SurfFlatRegion.h
index 9239f34..3ace4b1 100644
--- a/SurfFlatRegion.h
+++ b/SurfFlatRegion.h
@@ -51,10 +51,11 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // ISurf
       bool IsSimple( void) const override
@@ -144,7 +145,7 @@ class SurfFlatRegion : public ISurfFlatRegion, public IGeoObjRW
       Frame3d        m_frF ;           // riferimento intrinseco
       PCRV_DEQUE     m_vpLoop ;        // deque delle curve che formano i loop
       INTVECTOR      m_vExtInd ;       // indice dei loop esterni nel precedente vettore
-      int            m_nTempProp ;     // proprietà temporanea 
+      int            m_nTempProp[2] ;  // vettore proprietà temporanee 
 } ;
 
 //-----------------------------------------------------------------------------
diff --git a/SurfTriMesh.cpp b/SurfTriMesh.cpp
index 86b3e85..fa6de69 100644
--- a/SurfTriMesh.cpp
+++ b/SurfTriMesh.cpp
@@ -41,10 +41,12 @@ GEOOBJ_REGISTER( SRF_TRIMESH, NGE_S_TRM, SurfTriMesh) ;
 SurfTriMesh::SurfTriMesh( void)
    : m_nStatus( TO_VERIFY), m_dLinTol( STM_STD_LIN_TOL), m_dBoundaryAng( STM_STD_BOUNDARY_ANG),
      m_dSmoothAng( STM_STD_SMOOTH_ANG), m_bOriented( false), m_bClosed( false), m_bFaceted( false),
-     m_nTimeStamp( 0), m_nTempProp( 0), m_nMaxTFlag( 0), m_nParts( -1),  m_pHGrd3d( nullptr), m_pPGrd3d( nullptr)
+     m_nTimeStamp( 0), m_nMaxTFlag( 0), m_nParts( -1),  m_pHGrd3d( nullptr), m_pPGrd3d( nullptr)
 {
    m_dCosBndAng = cos( m_dBoundaryAng * DEGTORAD) ;
    m_dCosSmAng = cos( m_dSmoothAng * DEGTORAD) ;
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
 }
 
 //----------------------------------------------------------------------------
@@ -65,7 +67,7 @@ SurfTriMesh::Init( int nNumVert, int nNumTria, int nNumFacet)
   // se superficie vuota
    if ( nNumVert == 0  &&  nNumTria == 0  &&  nNumFacet == 0)
       return true ;
-  // verifico validità parametri
+  // verifico validit� parametri
    if ( nNumVert < 3  ||  nNumTria < 1)
       return false ;
   // prealloco la memoria
@@ -113,7 +115,7 @@ SurfTriMesh::AddVertex( const Point3d& ptVert)
    m_nStatus = TO_VERIFY ;
    m_nParts = - 1 ;
    m_OGrMgr.Reset() ;
-   // Verifico che il punto non sia distante meno di epsilon da un altro già esistente.
+   // Verifico che il punto non sia distante meno di epsilon da un altro gi� esistente.
    Point3d ptAddingPoint ;
    VerifyPointGrid3d() ;
    int nNearestId ;
@@ -243,14 +245,14 @@ SurfTriMesh::RemoveTriangle( int nId)
   // verifico esistenza del triangolo 
    if ( nId < 0  ||  nId >= GetTriangleSize())
       return false ;
-  // verifico se già cancellato
+  // verifico se gi� cancellato
    if ( m_vTria[nId].nIdVert[0] == SVT_DEL)
       return true ;
   // aggiorno eventuali riferimenti dei vertici
    for ( int i = 0 ; i < 3 ; ++ i) {
      // indice vertice
       int nV = m_vTria[nId].nIdVert[i] ;
-     // se vertice non c'è passo al prossimo
+     // se vertice non c'� passo al prossimo
       if ( nV < 0  ||  nV >= int( m_vTria.size()))
          continue ;
       if ( m_vVert[nV].nIdTria == nId) {
@@ -268,7 +270,7 @@ SurfTriMesh::RemoveTriangle( int nId)
    for ( int i = 0 ; i < 3 ; ++ i) {
      // indice triangolo adiacente
       int nAdjT = m_vTria[nId].nIdAdjac[i] ;
-     // se triangolo adiacente non c'è passo al prossimo
+     // se triangolo adiacente non c'� passo al prossimo
       if ( nAdjT == SVT_NULL  ||  m_vTria[nAdjT].nIdVert[0] == SVT_DEL)
          continue ;
      // ne sistemo la contro-adiacenza
@@ -281,7 +283,7 @@ SurfTriMesh::RemoveTriangle( int nId)
    m_vTria[nId].nIdVert[0] = SVT_DEL ;
   // invalido calcolo facce
    m_bFaceted = false ;
-  // invalido calcolo connettività
+  // invalido calcolo connettivit�
    m_nParts = - 1 ;
    return true ;
 }
@@ -347,7 +349,7 @@ SurfTriMesh::GetCentroid( Point3d& ptCen) const
   // la superficie deve essere validata
    if ( m_nStatus != OK)
       return false ;
-  // se la superficie è chiusa, calcolo il centroide del solido
+  // se la superficie � chiusa, calcolo il centroide del solido
    if ( IsClosed()) {
      // applico le formule di R. Nurnberg Imperial College London ad ogni faccia
       Triangle3d Tria ;
@@ -700,13 +702,13 @@ SurfTriMesh::GetTriangleBoundaryEdges( int nId, TriFlags3d& TFlags) const
    for ( int i = 0 ; i < 3 ; ++ i) {
      // indice triangolo adiacente al lato
       int nT = m_vTria[nId].nIdAdjac[i] ;
-     // se già definite le facce, verifico indice faccia
+     // se gi� definite le facce, verifico indice faccia
       if ( m_bFaceted) {
          TFlags.bFlag[i] = ( nT == SVT_NULL  ||  m_vTria[nId].nIdFacet != m_vTria[nT].nIdFacet) ;
       }
      // altrimenti verifico con le normali
       else
-        // se non c'è triangolo adiacente o se forma un angolo oltre il limite, il lato è un contorno
+        // se non c'� triangolo adiacente o se forma un angolo oltre il limite, il lato � un contorno
          TFlags.bFlag[i] = ( nT == SVT_NULL  ||  m_vTria[nId].vtN * m_vTria[nT].vtN < m_dCosBndAng) ;
    }
 
@@ -790,7 +792,7 @@ SurfTriMesh::GetTriangleSmoothNormal( int nT, int nV, Vector3d& vtN) const
    if ( nPos == -1)
       return false ;
 
-  // medio le normali, finché non incontro degli spigoli
+  // medio le normali, finch� non incontro degli spigoli
    vtN = m_vTria[nT].vtN ;
    // parto dal triangolo e vado in direzione positiva
    int nLim = nPos ;
@@ -893,7 +895,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongLoop( nT, 1, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 0 è di contorno
+        // se il lato 0 � di contorno
          else if ( nAdjT[0] == SVT_NULL) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -905,7 +907,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongLoop( nT, 1, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 1 è di contorno
+        // se il lato 1 � di contorno
          else if ( nAdjT[1] == SVT_NULL) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -917,7 +919,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongLoop( nT, 2, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // se il lato 2 è di contorno
+        // se il lato 2 � di contorno
          else if ( nAdjT[2] == SVT_NULL) {
            // ho trovato l'inizio di un loop
             vPL.emplace_back() ;
@@ -929,7 +931,7 @@ SurfTriMesh::GetLoops( POLYLINEVECTOR& vPL) const
             if ( ! MarchAlongLoop( nT, 0, m_nTimeStamp, vPL.back()))
                return false ;
          }
-        // altrimenti non c'è contorno
+        // altrimenti non c'� contorno
          else {
            // marco il triangolo come verificato
             m_vTria[nT].nTemp = m_nTimeStamp ;
@@ -974,10 +976,10 @@ SurfTriMesh::MarchOneTria( int& nT, int& nV, int nTimeStamp,
       return false ;
   // vertice di fine adiacenza e indice del successivo lato
    int nAdjV = Next( nAdjS) ;
-  // verifico se il lato successivo è un bordo
+  // verifico se il lato successivo � un bordo
    int nNextT = m_vTria[nAdjT].nIdAdjac[nAdjV] ;
    if ( nNextT == SVT_NULL) {
-     // se già recuperato
+     // se gi� recuperato
       if ( m_vTria[nAdjT].nTemp == nTimeStamp) {
          bEnd = true ;
          return true ;
@@ -1021,7 +1023,7 @@ SurfTriMesh::GetSilhouette( const Vector3d& vtDir, POLYLINEVECTOR& vPL) const
 
   // Elimino i triangoli con normale non equiversa alla direzione scelta
    for ( int i = 0 ; i < int( pStm->m_vTria.size()) ; ++ i) {
-     // se già cancellato, passo oltre
+     // se gi� cancellato, passo oltre
       if ( pStm->m_vTria[i].nIdVert[0] == SVT_DEL)
          continue ;
      // verifico la normale
@@ -1082,7 +1084,8 @@ SurfTriMesh::CopyFrom( const SurfTriMesh& stmSrc)
    m_vTria = stmSrc.m_vTria ;
    m_vFacet = stmSrc.m_vFacet ;
    m_nTimeStamp = stmSrc.m_nTimeStamp ;
-   m_nTempProp = stmSrc.m_nTempProp ;
+   m_nTempProp[0] = stmSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = stmSrc.m_nTempProp[1] ;
    m_nMaxTFlag = stmSrc.m_nMaxTFlag ;
    m_nParts = stmSrc.m_nParts ;
    return true ;
@@ -1120,7 +1123,7 @@ SurfTriMesh::Dump( string& sOut, bool bMM, const char* szNewLine) const
   // segnalo eventuale incongruenza di orientamento
    if ( ! m_bOriented)
       sOut += string( "Inconsistent Orientation") + szNewLine ;
-  // segnalo numero di parti se più di una
+  // segnalo numero di parti se pi� di una
    int nParts = GetPartCount() ;
    if ( nParts > 1)
       sOut += string( "Parts =") + ToString( nParts) + szNewLine ;
@@ -1351,7 +1354,7 @@ SurfTriMesh::Validate( bool bCorrect)
 
   // Verifico che i triangoli riferiti dalle facce esistano
    for ( int i = 0 ; i < GetFacetSize() && m_nStatus == OK && m_bFaceted ; ++ i) {
-     // verifico validità triangolo riferito 
+     // verifico validit� triangolo riferito 
       if ( m_vFacet[i] <= SVT_NULL  ||
            m_vFacet[i] >= GetTriangleSize()  ||
            m_vTria[ m_vFacet[i]].nIdVert[0] == SVT_DEL)
@@ -1506,7 +1509,7 @@ SurfTriMesh::AdjustAdjacencies( void)
 bool
 SurfTriMesh::AdjustOrientations( void)
 {
-  // se non ci sono almeno 2 triangoli è inutile fare test
+  // se non ci sono almeno 2 triangoli � inutile fare test
    if ( m_vTria.size() < 2) {
       m_bOriented = true ;
       return true ;
@@ -1550,7 +1553,7 @@ SurfTriMesh::AdjustTriaOrientation( TRINTDEQUE& S3iQ)
    S3iQ.pop_front() ;
   // assegno time stamp al triangolo
    m_vTria[nT].nTemp = m_nTimeStamp ;
-  // se c'è triangolo di riferimento, devo verificare se da invertire
+  // se c'� triangolo di riferimento, devo verificare se da invertire
    if ( nRefT != SVT_NULL) {
      // cerco indice half-edge in comune
       int nE = 0 ;
@@ -1568,7 +1571,7 @@ SurfTriMesh::AdjustTriaOrientation( TRINTDEQUE& S3iQ)
    bool bOk = true ;
    for ( int j = 0 ; j < 3 ; ++ j) {
       int nAdjT = m_vTria[nT].nIdAdjac[j] ;
-     // se non c'è adiacenza o va sul triangolo di provenienza
+     // se non c'� adiacenza o va sul triangolo di provenienza
       if ( nAdjT == SVT_NULL  ||  nAdjT == nRefT)
          ;
      // la verifico
@@ -1621,7 +1624,7 @@ SurfTriMesh::TestSealing( void)
 bool
 SurfTriMesh::AdjustTopology( void)
 {
-  // se non è rimasto alcunché di valido, pulisco tutto ed esco
+  // se non � rimasto alcunch� di valido, pulisco tutto ed esco
    if ( GetVertexCount() < 3  ||  GetTriangleCount() < 1) {
       Clear() ;
       m_bOriented = true ;
@@ -1638,7 +1641,7 @@ SurfTriMesh::AdjustTopology( void)
   // verifica adiacenze
    if ( ! AdjustAdjacencies())
       return false ;
-  // verifica continuità orientazione
+  // verifica continuit� orientazione
    if ( ! AdjustOrientations())
       return false ;
   // verifica chiusura
@@ -1676,7 +1679,7 @@ SurfTriMesh::PackVertices( void)
          vVId.push_back( SVT_DEL) ;
       }
    }
-  // se non c'è stata compattazione, esco
+  // se non c'� stata compattazione, esco
    if ( nFirstFree == SVT_NULL)
       return true ;
   // lunghezza vettore indici vertici
@@ -1691,7 +1694,7 @@ SurfTriMesh::PackVertices( void)
      // salto i triangoli cancellati
       if ( vOId[0] == SVT_DEL)
          continue ;
-     // verifico la validità degli indici
+     // verifico la validit� degli indici
       if ( vOId[0] < 0  ||  vOId[0] >= nVIdSize  ||
            vOId[1] < 0  ||  vOId[1] >= nVIdSize  ||
            vOId[2] < 0  ||  vOId[2] >= nVIdSize)
@@ -1731,7 +1734,7 @@ SurfTriMesh::PackTriangles( void)
          vTId.push_back( SVT_DEL) ;
       }
    }
-  // se non c'è stata compattazione, esco
+  // se non c'� stata compattazione, esco
    if ( nFirstFree == SVT_NULL)
       return true ;
   // Invalido HashGrid e Pointgrid
@@ -1746,7 +1749,7 @@ SurfTriMesh::PackTriangles( void)
      // salto vertice cancellato
       if ( nOId == SVT_DEL)
          continue ;
-     // verifico la validità dell'indice
+     // verifico la validit� dell'indice
       if ( nOId < 0  ||  nOId >= nTIdSize)
          return false ;
      // aggiorno    
@@ -1776,7 +1779,7 @@ SurfTriMesh::PackTriangles( void)
      // salto le facets non valide 
       if ( m_vFacet[nId] == SVT_DEL)
          continue ;
-     // verifico validità indice a triangolo
+     // verifico validit� indice a triangolo
       if ( m_vFacet[nId] < 0  ||  m_vFacet[nId] >= nTIdSize)
          return false ;
      // aggiorno
@@ -1879,7 +1882,7 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
    ResetHashGrids3d() ;
    ResetPointGrid3d() ;
 
-  // verifico se la polilinea è chiusa
+  // verifico se la polilinea � chiusa
    bool bClosed = PL.IsClosed() ;
 
   // costruisco la mesh
@@ -1912,7 +1915,7 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
    }
   // se curva chiusa, aggiungo gli ultimi due triangoli
    if ( bClosed) {
-     // non devo aggiungere i vertici, perchè coincidono con quelli iniziali
+     // non devo aggiungere i vertici, perch� coincidono con quelli iniziali
      // aggiungo i due triangoli relativi
       nIdV[0] = nV ;
       nIdV[1] = nV - 1 ;
@@ -1931,7 +1934,7 @@ SurfTriMesh::CreateByExtrusion( const PolyLine& PL, const Vector3d& vtExtr)
 bool
 SurfTriMesh::CreateByPointCurve( const Point3d& ptP, const PolyLine& PL)
 {
-  // verifico validità punto/polilinea
+  // verifico validit� punto/polilinea
    bool bClosed = PL.IsClosed() ;
   // se chiusa, la polilinea deve avere almeno 3 punti
    if ( bClosed) {
@@ -1976,7 +1979,7 @@ SurfTriMesh::CreateByPointCurve( const Point3d& ptP, const PolyLine& PL)
      // aggiorno indice punto precedente su curva
       nIdV[1] = nIdV[2] ;
    }
-  // se chiusa aggiungo l'ultimo triangolo (non il vertice perchè è il primo della curva)
+  // se chiusa aggiungo l'ultimo triangolo (non il vertice perch� � il primo della curva)
    if ( bClosed) {
       nIdV[2] = 1 ;
      // inserisco il triangolo A2p -> A1p -> A1s
@@ -2122,7 +2125,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
       }
      // ciclo sui punti
       while ( bNext1  ||  bNext2) {
-        // se c'è nuovo V1s e la diagonale più corta è V2p -> V1s oppure non c'è V2s
+        // se c'� nuovo V1s e la diagonale pi� corta � V2p -> V1s oppure non c'� V2s
          if ( ! bNext2  ||  ( bNext1  &&  ( nP1s == vPnt2[nP2p].second  ||  vPnt1[nP1s].second == nP2p))) {
            // inserisco il vertice V1s (se ultimo e curve chiuse, prendo il primo)
             if ( nP1s == nTotP1 - 1  &&  bClosed)
@@ -2144,7 +2147,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
             nV1p = nV1s ; nP1p = nP1s ; ++ nP1s ;
             bNext1 = ( nP1s < nTotP1) ;
          }
-        // altrimenti è V1p -> V2s
+        // altrimenti � V1p -> V2s
          else {
            // inserisco il vertice V2s (se ultimo e curve chiuse, prendo il primo)
             if ( nP2s == nTotP2 - 1  &&  bClosed)
@@ -2171,7 +2174,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
    
   // altrimenti rigata con parametrizzazione sincrona sulle due curve
    else {
-     // verifico validità polilinee (devono avere almeno 2 punti e non coincidere se non agli estremi aperti)
+     // verifico validit� polilinee (devono avere almeno 2 punti e non coincidere se non agli estremi aperti)
       if ( ! VerifyPolylinesForTwoCurves( PL1, PL2))
          return false ;
 
@@ -2246,7 +2249,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
       }
      // ciclo sui punti
       while ( bNext1  ||  bNext2) {
-        // se c'è nuovo dA1s e la diagonale più corta è dA2p -> dA1s oppure non c'è dA2s
+        // se c'� nuovo dA1s e la diagonale pi� corta � dA2p -> dA1s oppure non c'� dA2s
          if ( ( bNext1  &&  ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM)  ||  ! bNext2) {
            // inserisco il vertice A1s
             if ( ( nV1s = AddVertex( ptP1s)) == SVT_NULL)
@@ -2270,7 +2273,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
             if ( bNext1)
                dA1s = ( dU1s - dU1F) / dDeltaU1 ;
          }
-        // altrimenti è dA1p -> dA2s
+        // altrimenti � dA1p -> dA2s
          else {
            // inserisco il vertice A2s
             if ( ( nV2s = AddVertex( ptP2s)) == SVT_NULL)
@@ -2299,7 +2302,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
       if ( bClosed) {
          dA1s = 1 ;
          dA2s = 1 ;
-        // se la diagonale più corta è dA2p -> dA1s = 0
+        // se la diagonale pi� corta � dA2p -> dA1s = 0
          if ( ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM) {
            // inserisco il triangolo A2p -> A1p -> A1s = 0
             nIdV[0] = nV2p ;
@@ -2314,7 +2317,7 @@ SurfTriMesh::CreateByTwoCurves( const PolyLine& PL1, const PolyLine& PL2, int nR
             if ( AddTriangle( nIdV) == SVT_NULL)
                return false ;
          }
-        // altrimenti è dA1p -> dA2s = 1
+        // altrimenti � dA1p -> dA2s = 1
          else {
            // inserisco il triangolo A2p -> A1p -> A2s = 1
             nIdV[0] = nV2p ;
@@ -2386,7 +2389,7 @@ SurfTriMesh::VerifyPolylinesForTwoCurves( const PolyLine& PL1, const PolyLine& P
       return false ;
   // verifiche sui punti successivi (non sugli ultimi)
    while ( bNext1  ||  bNext2) {
-     // se c'è nuovo dA1s e la diagonale più corta è dA2p -> dA1s oppure non c'è dA2s
+     // se c'� nuovo dA1s e la diagonale pi� corta � dA2p -> dA1s oppure non c'� dA2s
       if ( ( bNext1  &&  ( dA1s - dA2p) <= ( dA2s - dA1p) + EPS_PARAM)  ||  ! bNext2) {
         // verifico se coincidono
          if ( AreSamePointApprox( ptP2p, ptP1s))
@@ -2397,7 +2400,7 @@ SurfTriMesh::VerifyPolylinesForTwoCurves( const PolyLine& PL1, const PolyLine& P
          if ( bNext1)
             dA1s = ( dU1s - dU1F) / dDeltaU1 ;
       }
-     // altrimenti è dA1p -> dA2s = 1
+     // altrimenti � dA1p -> dA2s = 1
       else {
         // verifico se coincidono
          if ( AreSamePointApprox( ptP1p, ptP2s))
@@ -2501,7 +2504,7 @@ AdjustPolylineForRevolution( PolyLine& PL, const Point3d& ptAx, const Vector3d&
    plTrim.Translate( DIST_SIC * vtTrN) ;
    PL.Trim( plTrim, false) ;
 
-  // Se polilinea risultante è aperta con estremità molto vicine all'asse le porto su questo
+  // Se polilinea risultante � aperta con estremit� molto vicine all'asse le porto su questo
    if ( ! PL.IsClosed()) {
      // verifico l'inizio
       double  dUStart ;
@@ -2580,7 +2583,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
    ResetHashGrids3d() ;
    ResetPointGrid3d() ;
 
-  // verifico se la polilinea è chiusa
+  // verifico se la polilinea � chiusa
    bool bClosed = MyPL.IsClosed() ;
 
   // costruisco la mesh
@@ -2601,7 +2604,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
    // verifico se il punto giace sull'asse e vi sta fisso
    bool bPrevOnAx = bOnlyRev && DistPointLine( ptP, ptAx, vtAx, 1, false).IsSmall() ;
    int  nVPrevOnAx = nV ;
-   // se non è fisso sull'asse, inserisco le copie ruotate
+   // se non � fisso sull'asse, inserisco le copie ruotate
    if ( ! bPrevOnAx) {
       for ( int i = 1 ; i <= nStep ; ++i) {
          ptP.Rotate( ptAx, vtAx, dCosStepRot, dSinStepRot) ;
@@ -2623,7 +2626,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
       bool bOnAx = bOnlyRev && DistPointLine( ptP, ptAx, vtAx, 1, false).IsSmall() ;
       // ciclo sugli step
       for ( int i = 1 ; i <= nStep ; ++i) {
-        // se non è fisso sull'asse, inserisco le copie ruotate
+        // se non � fisso sull'asse, inserisco le copie ruotate
          if ( ! bOnAx) { 
             ptP.Rotate( ptAx, vtAx, dCosStepRot, dSinStepRot) ;
             if ( ! bOnlyRev)
@@ -2632,8 +2635,8 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
                return false ;
             ++ nV ;
          }
-        // per i controlli già fatti non è possibile avere contemp. prec e corr su asse
-        // se il precedente è sull'asse, aggiungo un solo triangolo
+        // per i controlli gi� fatti non � possibile avere contemp. prec e corr su asse
+        // se il precedente � sull'asse, aggiungo un solo triangolo
          if ( bPrevOnAx) {
             nIdV[0] = nVPrevOnAx ;
             nIdV[1] = nV ;
@@ -2641,7 +2644,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
             if ( AddTriangle( nIdV) == SVT_NULL)
                return false ;
          }
-        // se il corrente è sull'asse, aggiungo un solo triangolo
+        // se il corrente � sull'asse, aggiungo un solo triangolo
          else if ( bOnAx) {
             nIdV[0] = nV - ( nStep + 2) + i ;
             nIdV[1] = nIdV[0] + 1 ;
@@ -2661,8 +2664,8 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
       }
      // se rivoluzione completa, aggiungo i due triangoli di chiusura
       if ( bFullRev) {
-        // per i controlli già fatti non è possibile avere contemp. prec e corr su asse
-        // se il precedente è sull'asse, aggiungo un solo triangolo
+        // per i controlli gi� fatti non � possibile avere contemp. prec e corr su asse
+        // se il precedente � sull'asse, aggiungo un solo triangolo
          if ( bPrevOnAx) {
             nIdV[0] = nVPrevOnAx ;
             nIdV[1] = nV - nStep ;
@@ -2670,7 +2673,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
             if ( AddTriangle( nIdV) == SVT_NULL)
                return false ;
          }
-        // se il corrente è sull'asse, aggiungo un solo triangolo
+        // se il corrente � sull'asse, aggiungo un solo triangolo
          else if ( bOnAx) {
             nIdV[0] = nV - 1 ;
             nIdV[1] = nV - ( nStep + 1) ;
@@ -2693,7 +2696,7 @@ SurfTriMesh::CreateByScrewing( const PolyLine& PL, const Point3d& ptAx, const Ve
   // altrimenti ultimo punto di polilinea chiusa
    if ( bClosed) {
       for ( int i = 1 ; i <= nStep ; ++i) {
-        // non devo aggiungere i vertici, perchè coincidono con quelli iniziali
+        // non devo aggiungere i vertici, perch� coincidono con quelli iniziali
         // aggiungo triangolo in basso a sinistra
          nIdV[0] = nV - nStep + i - 1 ; nIdV[1] = nV - nStep + i ; nIdV[2] = i ;
          if ( AddTriangle( nIdV) == SVT_NULL)
@@ -2729,7 +2732,7 @@ SurfTriMesh::AddBiTriangle( const int nIdVert[4])
   //    |    |
   //    1 -> 2
   int nIdV[3] ;
-  // se la diagonale 0->2 è uguale o più corta della 1->3
+  // se la diagonale 0->2 � uguale o pi� corta della 1->3
    if ( SqDist( m_vVert[nIdVert[0]].ptP, m_vVert[nIdVert[2]].ptP) <=
         SqDist( m_vVert[nIdVert[1]].ptP, m_vVert[nIdVert[3]].ptP) + EPS_SMALL) {
      // triangolo 0->1->2
@@ -2791,14 +2794,14 @@ SurfTriMesh::DoCompacting( double dTol)
       }
      // recupero la posizione geometrica del vertice
       Point3d ptP = m_vVert[nId].ptP ;
-     // se non c'è già un vertice con la stessa posizione lo inserisco nel grid
+     // se non c'� gi� un vertice con la stessa posizione lo inserisco nel grid
       int nAliasId ;
       if ( ! VertGrid.Find( ptP, dTol, nAliasId)) {
          VertGrid.InsertPoint( ptP, nId) ;
         // salvo l'Id nel vettore di reindirizzo
          vVId.push_back( nId) ;
       }
-     // c'è un vertice coincidente
+     // c'� un vertice coincidente
       else {
         // salvo l'Id alias nel vettore di reindirizzo
          vVId.push_back( nAliasId) ;
@@ -2818,7 +2821,7 @@ SurfTriMesh::DoCompacting( double dTol)
      // salto i triangoli cancellati
       if ( vOId[0] == SVT_DEL)
          continue ;
-     // verifico la validità degli indici
+     // verifico la validit� degli indici
       if ( vOId[0] < 0  ||  vOId[0] >= nVIdSize  ||
            vOId[1] < 0  ||  vOId[1] >= nVIdSize  ||
            vOId[2] < 0  ||  vOId[2] >= nVIdSize)
@@ -2890,7 +2893,7 @@ SurfTriMesh::DoSewing( const ISurfTriMesh& stmOther, const Frame3d& frOther)
       Point3d ptOP = pOther->m_vVert[nOId].ptP ;
      // la porto nel riferimento della prima superficie
       ptOP.ToGlob( frOther) ;
-     // se non c'è già un vertice con la stessa posizione lo inserisco
+     // se non c'� gi� un vertice con la stessa posizione lo inserisco
       int nNewId ;
       if ( ! VertGrid.Find( ptOP, 2 * EPS_SMALL, nNewId)) {
          if ( ( nNewId = AddVertex( ptOP)) == SVT_NULL)
@@ -2912,7 +2915,7 @@ SurfTriMesh::DoSewing( const ISurfTriMesh& stmOther, const Frame3d& frOther)
      // salto i triangoli cancellati
       if ( vOId[0] == SVT_DEL)
          continue ;
-     // verifico la validità degli indici
+     // verifico la validit� degli indici
       if ( vOId[0] < 0  ||  vOId[0] >= nVIdSize  ||
            vOId[1] < 0  ||  vOId[1] >= nVIdSize  ||
            vOId[2] < 0  ||  vOId[2] >= nVIdSize)
@@ -2964,7 +2967,7 @@ SurfTriMesh::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
   // verifico lo stato
    if ( m_nStatus != OK)
       return false ;
-  // verifico validità del frame
+  // verifico validit� del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
   // assegno il box nel riferimento
@@ -3010,7 +3013,7 @@ SurfTriMesh::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng,
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità dell'asse di rotazione
+  // verifico validit� dell'asse di rotazione
    if ( vtAx.IsSmall())
       return false ;
 
@@ -3077,7 +3080,7 @@ SurfTriMesh::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
    bool bRecalc = ( abs( dCoeffX) < EPS_ZERO  ||  abs( dCoeffY) < EPS_ZERO  ||  abs( dCoeffZ) < EPS_ZERO) ;
    for ( int i = 0 ; i < GetTriangleSize() ; ++ i) {
       if ( m_vTria[i].nIdVert[0] != SVT_DEL) {
-        // se c'è mirror, devo invertire la faccia
+        // se c'� mirror, devo invertire la faccia
          if ( bMirror)
             InvertTriangle( i) ;
         // aggiorno la normale
@@ -3099,7 +3102,7 @@ SurfTriMesh::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double
 bool 
 SurfTriMesh::InvertTriangle( int nT)
 {
-  // controllo validità triangolo
+  // controllo validit� triangolo
    if ( m_vTria[nT].nIdVert[0] == SVT_DEL)
       return true ;
   // scambio di due vertici
@@ -3115,10 +3118,10 @@ SurfTriMesh::InvertTriangle( int nT)
 bool 
 SurfTriMesh::CalcTriangleNormal( int nT)
 {
-  // controllo validità triangolo
+  // controllo validit� triangolo
    if ( m_vTria[nT].nIdVert[0] == SVT_DEL)
       return true ;
-  // controllo validità vertici riferiti dal triangolo
+  // controllo validit� vertici riferiti dal triangolo
    if ( m_vTria[nT].nIdVert[0] < 0  ||
         m_vTria[nT].nIdVert[0] >= GetVertexSize()  ||
         m_vVert[m_vTria[nT].nIdVert[0]].nIdTria == SVT_DEL  ||
@@ -3148,7 +3151,7 @@ SurfTriMesh::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità del piano di specchiatura
+  // verifico validit� del piano di specchiatura
    if ( vtNorm.IsSmall())
       return false ;
 
@@ -3182,7 +3185,7 @@ SurfTriMesh::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d&
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità dei parametri
+  // verifico validit� dei parametri
    if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
       return false ;
 
@@ -3215,7 +3218,7 @@ SurfTriMesh::ToGlob( const Frame3d& frRef)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità del frame
+  // verifico validit� del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
@@ -3247,7 +3250,7 @@ SurfTriMesh::ToLoc( const Frame3d& frRef)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità del frame
+  // verifico validit� del frame
    if ( frRef.GetType() == Frame3d::ERR)
       return false ;
 
@@ -3279,11 +3282,11 @@ SurfTriMesh::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
    if ( m_nStatus != OK)
       return false ;
 
-  // verifico validità dei frame
+  // verifico validit� dei frame
    if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
       return false ;
 
-  // se i due riferimenti coincidono, non devo fare alcunché
+  // se i due riferimenti coincidono, non devo fare alcunch�
    if ( AreSameFrame( frOri, frDest))
       return true ;
 
@@ -3550,7 +3553,7 @@ SurfTriMesh::Cut( const Plane3d& plPlane, bool bSaveOnEq)
    
    bool bModif = false ;
 
-  // Setto i triangoli come né fuori né dentro.
+  // Setto i triangoli come n� fuori n� dentro.
    int nTriaNum = GetTriangleSize() ;
    for ( int nT = 0 ; nT < nTriaNum ; ++ nT) {
       m_vTria[nT].nTempPart = 0 ;
@@ -3644,7 +3647,7 @@ SurfTriMesh::ResetHashGrids3d( void) const
 bool
 SurfTriMesh::VerifyHashGrids3d( void) const
 {
-  // se già calcolato, non devo fare altro
+  // se gi� calcolato, non devo fare altro
    if ( m_pHGrd3d != nullptr)
       return true ;
   // alloco
@@ -3688,7 +3691,7 @@ SurfTriMesh::ResetPointGrid3d( void) const
 bool
 SurfTriMesh::VerifyPointGrid3d( void) const
 {
-   // Se già calcolato, non devo fare altro
+   // Se gi� calcolato, non devo fare altro
    if ( m_pPGrd3d != nullptr)
       return true ;
    // Alloco
@@ -3754,7 +3757,7 @@ SurfTriMesh::VerifyConnection( void) const
   // ciclo sui triangoli
    m_nParts = 0 ;
    for ( int i = 0 ; i < int( m_vTria.size()) ; ++ i) {
-     // salto triangoli cancellati o già assegnati
+     // salto triangoli cancellati o gi� assegnati
       if ( m_vTria[i].nIdVert[0] == SVT_DEL  ||
            m_vTria[i].nPart != SVT_NULL)
          continue ;
diff --git a/SurfTriMesh.h b/SurfTriMesh.h
index a020c28..ff3edaa 100644
--- a/SurfTriMesh.h
+++ b/SurfTriMesh.h
@@ -211,10 +211,11 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; } 
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; } 
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // ISurf
       bool IsSimple( void) const override
@@ -431,7 +432,7 @@ class SurfTriMesh : public ISurfTriMesh, public IGeoObjRW
       TRIAVECTOR     m_vTria ;         // vettore dei triangoli
       INTVECTOR      m_vFacet ;        // vettore delle sfaccettature
       mutable int    m_nTimeStamp ;    // orologio locale 
-      int            m_nTempProp ;     // propriet� temporanea
+      int            m_nTempProp[2] ;  // vettore propriet� temporanee
       int            m_nMaxTFlag ;     // massimo valore dei TFlag dei triangoli
       mutable int    m_nParts ;        // numero di parti connesse (-1 se da calcolare)
       mutable HashGrids3d* m_pHGrd3d ; // Hash Grid 3d nel suo riferimento
diff --git a/VolZmap.cpp b/VolZmap.cpp
index cc0a5bd..36b9a93 100644
--- a/VolZmap.cpp
+++ b/VolZmap.cpp
@@ -35,7 +35,7 @@ GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
 //----------------------------------------------------------------------------
 VolZmap::VolZmap(void)
    : m_nStatus( TO_VERIFY), m_nMapNum( 0), m_nNumBlock( 0), m_nConnectedCompoCount( 0), m_dStep( 10.0),
-     m_nVoxNumPerBlock( N_VOXBLOCK), m_nDexVoxRatio( 1), m_nShape( GENERIC), m_nTempProp( 0), m_Tool( true)
+     m_nVoxNumPerBlock( N_VOXBLOCK), m_nDexVoxRatio( 1), m_nShape( GENERIC), m_Tool( true)
 {
    for ( int i = 0 ; i < N_MAPS ; ++ i) {
       m_nNx[i] = 0 ;
@@ -45,6 +45,8 @@ VolZmap::VolZmap(void)
       m_dMaxZ[i] = 0 ;
       m_nFracLin[i] = 0 ;
    }
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
    m_Tool.SetTolerances( LIN_TOL_STD, ANG_TOL_APPROX_DEG) ;
 }
 
@@ -72,7 +74,8 @@ VolZmap::Clear( void)
       m_Values[i].clear() ;
    }
    m_dStep = EPS_SMALL ;
-   m_nTempProp = 0 ;
+   m_nTempProp[0] = 0 ;
+   m_nTempProp[1] = 0 ;
    m_Tool.Clear() ;
   // imposto ricalcolo della grafica
    m_OGrMgr.Reset() ;
@@ -138,7 +141,8 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc)
 
    m_dStep = vzmSrc.m_dStep ;
    m_nStatus = vzmSrc.m_nStatus ;
-   m_nTempProp = vzmSrc.m_nTempProp ;
+   m_nTempProp[0] = vzmSrc.m_nTempProp[0] ;
+   m_nTempProp[1] = vzmSrc.m_nTempProp[1] ;
 
   // dimensiono membri legati ai blocchi
    m_BlockToUpdate = vzmSrc.m_BlockToUpdate ;
diff --git a/VolZmap.h b/VolZmap.h
index 01fcd39..60736da 100644
--- a/VolZmap.h
+++ b/VolZmap.h
@@ -60,10 +60,11 @@ class VolZmap : public IVolZmap, public IGeoObjRW
               { return m_OGrMgr.GetObjGraphics() ; }
       const IObjGraphics* GetObjGraphics( void) const override
               { return m_OGrMgr.GetObjGraphics() ; }
-      void SetTempProp( int nProp) override
-              { m_nTempProp = nProp ; }
-      int  GetTempProp( void) const override
-              { return m_nTempProp ; }
+      void SetTempProp( int nProp, int nPropInd = 0) override
+              { if ( nPropInd >= 0  &&  nPropInd < 2)
+                   m_nTempProp[nPropInd] = nProp ; } 
+      int  GetTempProp( int nPropInd = 0) const override
+              { return (( nPropInd >= 0  &&  nPropInd < 2) ? m_nTempProp[nPropInd] : 0) ; }
 
    public :                      // IVolZmap
       bool CopyFrom( const IGeoObj* pGObjSrc) override ;
@@ -445,7 +446,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
    private :
       ObjGraphicsMgr m_OGrMgr ;             // gestore grafica dell'oggetto
       Status         m_nStatus ;            // stato
-      int            m_nTempProp ;          // proprietà temporanea
+      int            m_nTempProp[2] ;       // vettore proprietà temporanee
       double         m_dStep ;              // passo delle griglie
       int            m_nMapNum ;            // numero di griglie ( 1 o 3)
       Frame3d        m_MapFrame ;           // riferimento intrinseco dello Zmap