//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : ExtText.cpp        Data : 27.05.14          Versione : 1.5e10
// Contenuto : Implementazione della classe Testo.
//
//
//
// Modifiche : 27.05.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "ExtText.h"
#include "GeoObjFactory.h"
#include "NgeWriter.h"
#include "NgeReader.h"
#include "FontManager.h"
#include "FontAux.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGkUiUnits.h"
#include <new>

using namespace std ;

//----------------------------------------------------------------------------
GEOOBJ_REGISTER( EXT_TEXT, NGE_E_TXT, ExtText) ;

//----------------------------------------------------------------------------
ExtText::ExtText( void)
   : 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()
{
}

//----------------------------------------------------------------------------
ExtText::~ExtText( void)
{
}

//----------------------------------------------------------------------------
bool
ExtText::Set( const Point3d& ptP, double dAngDeg, const string& sText, double dH)
{
  // controllo testo non vuoto
   if ( sText.empty())
      return false ;
  // assegno i dati
   m_ptP = ptP ;
   m_vtN = Z_AX ;
   m_vtD = FromPolar( 1, dAngDeg) ;
   m_sText = sText ; 
   m_sFont.clear() ;
   m_nWeight = 400 ;
   m_bItalic = false ;
   m_dHeight = dH ;
   m_dRatio = 1 ;
   m_dAddAdvance = 0 ;
   m_nInsPos = ETXT_IPBL ;

  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::Set( const Point3d& ptP, const Vector3d& vtN, const Vector3d& vtD,
              const string& sText, const string& sFont, bool bItl, double dH)
{
  // controllo testo non vuoto
   if ( sText.empty())
      return false ;
  // controllo lunghezza nome font
   if ( sFont.size() > MAX_FONT_LEN)
      return false ;
  // assegno i dati
   m_ptP = ptP ;
   m_vtN = vtN ;
   m_vtD = vtD ;
   m_sText = sText ; 
   m_sFont = sFont ;
   m_nWeight = 400 ;
   m_bItalic = bItl ;
   m_dHeight = dH ;
   m_dRatio = 1 ;
   m_dAddAdvance = 0 ;
   m_nInsPos = ETXT_IPBL ;

  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::Set( const Point3d& ptP, const Vector3d& vtN, const Vector3d& vtD,
              const string& sText, const string& sFont, int nW, bool bItl, double dH,
              double dRat, double dAddAdv, int nInsPos)
{
  // controllo testo non vuoto
   if ( sText.empty())
      return false ;
  // controllo lunghezza nome font
   if ( sFont.size() > MAX_FONT_LEN)
      return false ;
  // assegno i dati
   m_ptP = ptP ;
   m_vtN = vtN ;
   if ( ! m_vtN.Normalize())
      return false ;
   m_vtD = vtD - m_vtN * ( vtD * m_vtN) ;
   if ( ! m_vtD.Normalize())
      return false ;
   m_sText = sText ; 
   m_sFont = sFont ;
   m_nWeight = nW ;
   m_bItalic = bItl ;
   m_dHeight = dH ;
   m_dRatio = AdjustFontRatio( dRat) ;
   m_dAddAdvance = dAddAdv ;
   m_nInsPos = (( nInsPos >= ETXT_IPTL  &&  nInsPos <= ETXT_IPBR) ? nInsPos : ETXT_IPBL) ;

  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;

   return true ;
}

//----------------------------------------------------------------------------
ExtText*
ExtText::Clone( void) const
{
  // alloco oggetto
   ExtText* pGPt = new(nothrow) ExtText ;
   if ( pGPt != nullptr) {
      if ( ! pGPt->CopyFrom( *this)) {
         delete pGPt ;
         return nullptr ;
      }
   }

   return pGPt ;
}

//----------------------------------------------------------------------------
bool
ExtText::CopyFrom( const IGeoObj* pGObjSrc)
{
   const ExtText* pTxt = dynamic_cast<const ExtText*>( pGObjSrc) ;
   if ( pTxt == nullptr)
      return false ;
   return CopyFrom( *pTxt) ;
}

//----------------------------------------------------------------------------
bool
ExtText::CopyFrom( const ExtText& clSrc)
{
   if ( &clSrc == this)
      return true ;
   m_OGrMgr.Reset() ;
   m_ptP = clSrc.m_ptP ;    
   m_vtN = clSrc.m_vtN ;    
   m_vtD = clSrc.m_vtD ;    
   m_sText = clSrc.m_sText ;  
   m_sFont = clSrc.m_sFont ;  
   m_nWeight = clSrc.m_nWeight ;
   m_bItalic = clSrc.m_bItalic ;
   m_dHeight = clSrc.m_dHeight ;
   m_dRatio = clSrc.m_dRatio ; 
   m_dAddAdvance = clSrc.m_dAddAdvance ;
   m_nInsPos = clSrc.m_nInsPos ; 
   m_nTempProp = clSrc.m_nTempProp ;
   return true ;
}

//----------------------------------------------------------------------------
GeoObjType
ExtText::GetType( void) const
{
   return static_cast<GeoObjType>( GEOOBJ_GETTYPE( ExtText)) ;
}

//----------------------------------------------------------------------------
const string&
ExtText::GetTitle( void) const
{
   static const string sTitle = "Text" ;
   return sTitle ;
}

//----------------------------------------------------------------------------
bool
ExtText::Dump( string& sOut, bool bMM, const char* szNewLine) const
{
  // parametri
   sOut += "P(" + ToString( GetInUiUnits( m_ptP, bMM), 3) + ") " ;
   sOut += " IP=" + ToString( m_nInsPos) + szNewLine ;
   sOut += "VN(" + ToString( m_vtN, 6) + ") " + szNewLine ;
   sOut += "VS(" + ToString( m_vtD, 6) + ") " + szNewLine ;
   sOut += "Txt=" + m_sText + szNewLine ;
   sOut += "Fnt=" + m_sFont + szNewLine ;
   sOut += "W=" + ToString( m_nWeight) ;
   sOut += " I=" + ToString( m_bItalic) ;
   sOut += " H=" + ToString( GetInUiUnits( m_dHeight, bMM), 1) ;
   sOut += " R=" + ToString( m_dRatio, 3) ;
   sOut += " A=" + ToString( GetInUiUnits( m_dAddAdvance, bMM), 1) + szNewLine ;

   return true ;
}

//----------------------------------------------------------------------------
int
ExtText::GetNgeId( void) const
{
   return GEOOBJ_GETNGEID( ExtText) ;
}

//----------------------------------------------------------------------------
bool
ExtText::Save( NgeWriter& ngeOut) const
{
  // punto di inserimento
   if ( ! ngeOut.WritePoint( m_ptP, ";"))
      return false ;
  // flag posizione inserimento
   if ( ! ngeOut.WriteInt( m_nInsPos, ";"))
      return false ;
  // versore normale
   if ( ! ngeOut.WriteVector( m_vtN, ";"))
      return false ;
  // versore di direzione
   if ( ! ngeOut.WriteVector( m_vtD, ";", true))
      return false ;
  // testo
   int nTextLines = int( m_sText.size()) / MAX_TXT_LINE + 
                    ( ( int( m_sText.size()) % MAX_TXT_LINE) > 0 ? 1 : 0) ;
   if ( ! ngeOut.WriteInt( nTextLines, ";", true))
      return false ;
   string sBuff ;
   for ( int i = 0 ; i < nTextLines ; ++ i) {
     // copio i caratteri nel buffer
      sBuff = m_sText.substr( i * MAX_TXT_LINE, MAX_TXT_LINE) ;
     // sostituisco eventuale primo o ultimo spazio con carattere speciale
      if ( sBuff.front() == ' ')
         sBuff.front() = CHR_SPECIAL ;
      if ( sBuff.back() == ' ')
         sBuff.back() = CHR_SPECIAL ;
     // scrivo il testo
      if ( ! ngeOut.WriteString( sBuff, nullptr, true))
         return false ;
   }
  // font
   if ( ! ngeOut.WriteString( m_sFont, ";"))
      return false ;
  // spessore del font
   if ( ! ngeOut.WriteInt( m_nWeight, ","))
      return false ;
  // flag di italico
   if ( ! ngeOut.WriteBool( m_bItalic, ","))
      return false ;
  // altezza del font
   if ( ! ngeOut.WriteDouble( m_dHeight, ","))
      return false ;
  // rapporto larghezza su altezza del font
   if ( ! ngeOut.WriteDouble( m_dRatio, ","))
      return false ;
  // avanzamento addizionale tra caratteri
   if ( ! ngeOut.WriteDouble( m_dAddAdvance, ";", true))
      return false ;
  
   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::Load( NgeReader& ngeIn)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // leggo la prossima linea : punto, posiz. inserimento, normale, direzione
   if ( ! ngeIn.ReadPoint( m_ptP, ";"))
      return false ;
   if ( ! ngeIn.ReadInt( m_nInsPos, ";"))
      return false ;
   if ( ! ngeIn.ReadVector( m_vtN, ";"))
      return false ;
   if ( ! ngeIn.ReadVector( m_vtD, ";", true))
      return false ;
  // leggo la prossima linea : numero di righe di testo
   int nTextLines ;
   if ( ! ngeIn.ReadInt( nTextLines, ";", true))
      return false ;
  // leggo le stringhe che costituisco il testo
   string sBuff ;
   for ( int i = 0 ; i < nTextLines ; ++i) {
     // leggo la linea
      if ( ! ngeIn.ReadString( sBuff, nullptr, true))
         return false ;
     // sostituisco eventuale primo o ultimo carattere speciale con spazio
      if ( sBuff.front() == CHR_SPECIAL)
         sBuff.front() = ' ' ;
      if ( sBuff.back() == CHR_SPECIAL)
         sBuff.back() = ' ' ;
     // la accodo
      m_sText += sBuff ; 
   }
  // leggo la prossima linea : font, spessore, italico, altezza, ratio, addAdvance
   if ( ! ngeIn.ReadString( m_sFont, ";"))
      return false ;
   if ( ! ngeIn.ReadInt( m_nWeight, ","))
      return false ;
   if ( ! ngeIn.ReadBool( m_bItalic, ","))
      return false ;
   if ( ! ngeIn.ReadDouble( m_dHeight, ","))
      return false ;
   if ( ! ngeIn.ReadDouble( m_dRatio, ","))
      return false ;
   if ( ! ngeIn.ReadDouble( m_dAddAdvance, ";", true))
      return false ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
{
  // recupero il font manager
   FontManager& fntMgr = FontManager::GetFontManager() ;

  // imposto il font corrente e i suoi dati
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo il box
   if ( ! fntMgr.GetBBox( m_sText, m_nInsPos, b3Loc))
      return false ;

  // calcolo ed eseguo la trasformazione
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;
   b3Loc.ToGlob( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
{
  // verifico validità del frame
   if ( frRef.GetType() == Frame3d::ERR)
      return false ;

  // recupero il font manager
   FontManager& fntMgr = FontManager::GetFontManager() ;

  // imposto il font corrente e i suoi dati
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo il box
   if ( ! fntMgr.GetBBox( m_sText, m_nInsPos, b3Ref))
      return false ;

  // calcolo ed eseguo la prima trasformazione (per tener conto dell'orientamento del testo)
   Frame3d frTxt ;
   if ( ! frTxt.Set( m_ptP, m_vtN, m_vtD))
      return false ;
   b3Ref.ToGlob( frTxt) ;

  // porto il box nel riferimento passato
   b3Ref.ToGlob( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::Translate( const Vector3d& vtMove)
{
   m_OGrMgr.Reset() ;
   m_ptP.Translate( vtMove) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::Rotate( const Point3d& ptAx, const Vector3d& vtAx, double dCosAng, double dSinAng)
{
   m_OGrMgr.Reset() ; 
   return ( m_ptP.Rotate( ptAx, vtAx, dCosAng, dSinAng)  &&
            m_vtN.Rotate( vtAx, dCosAng, dSinAng)  &&
            m_vtD.Rotate( vtAx, dCosAng, dSinAng)) ;
}

//----------------------------------------------------------------------------
bool
ExtText::Scale( const Frame3d& frRef, double dCoeffX, double dCoeffY, double dCoeffZ)
{
  // verifico non sia nulla
   if ( fabs( dCoeffX) < EPS_ZERO  &&  fabs( dCoeffY) < EPS_ZERO  &&  fabs( dCoeffZ) < EPS_ZERO)
      return false ;

  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;

  // scalo il punto di inserimento
   if ( ! m_ptP.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
      return false ;

  // calcolo il versore altezza testo
   Vector3d vtH = m_vtN ^ m_vtD ;
   vtH.Normalize() ;
  // scalo il versore direzione
   if ( ! m_vtD.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
      return false ;
   double dScaleD = m_vtD.Len() ;
   m_vtD /= dScaleD ;
  // scalo il versore altezza testo
   if ( ! vtH.Scale( frRef, dCoeffX, dCoeffY, dCoeffZ))
      return false ;
  // per il coeff di scalatura considero solo la parte perpendicolare alla nuova direzione start
   double dScaleH = sqrt( vtH.SqLen() - ( vtH * m_vtD) *( vtH * m_vtD)) ;
  // aggiorno il vettore normale
   m_vtN = m_vtD ^ vtH ;
   m_vtN.Normalize() ;
  // aggiorno i parametri altezza testo e ratio
   m_dHeight *= dScaleH ;
   if ( dScaleH > EPS_ZERO)
      m_dRatio *= dScaleD / dScaleH ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::Mirror( const Point3d& ptOn, const Vector3d& vtNorm)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;

  // eseguo il mirror del punto di inserimento
   if ( ! m_ptP.Mirror( ptOn, vtNorm))
      return false ;

  // calcolo il versore altezza testo
   Vector3d vtH = m_vtN ^ m_vtD ;
   vtH.Normalize() ;
  // eseguo il mirror del versore direzione
   if ( ! m_vtD.Mirror( vtNorm))
      return false ;
  // eseguo il mirror del versore altezza testo
   if ( ! vtH.Mirror( vtNorm))
      return false ;
  // aggiorno il vettore normale
   m_vtN = m_vtD ^ vtH ;
   m_vtN.Normalize() ;

   return true ;
}

//----------------------------------------------------------------------------
bool 
ExtText::Shear( const Point3d& ptOn, const Vector3d& vtNorm, const Vector3d& vtDir, double dCoeff)
{
  // verifico validità dei parametri
   if ( vtNorm.IsSmall()  ||  vtDir.IsSmall())
      return false ;

  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;

  // eseguo scorrimento del punto di inserimento
   if ( ! m_ptP.Shear( ptOn, vtNorm, vtDir, dCoeff))
      return false ;

  // calcolo il versore altezza testo
   Vector3d vtH = m_vtN ^ m_vtD ;
   vtH.Normalize() ;
  // eseguo scorrimento del versore direzione
   if ( ! m_vtD.Shear( vtNorm, vtDir, dCoeff))
      return false ;
   double dScaleD = m_vtD.Len() ;
   m_vtD /= dScaleD ;
  // eseguo scorrimento del versore altezza testo
   if ( ! vtH.Shear( vtNorm, vtDir, dCoeff))
      return false ;
  // per il coeff di scalatura considero solo la parte perpendicolare alla nuova direzione start
   double dScaleH = sqrt( vtH.SqLen() - ( vtH * m_vtD) *( vtH * m_vtD)) ;
  // aggiorno il vettore normale
   m_vtN = m_vtD ^ vtH ;
   m_vtN.Normalize() ;
  // aggiorno i parametri altezza testo e ratio
   m_dHeight *= dScaleH ;
   if ( dScaleH > EPS_ZERO)
      m_dRatio *= dScaleD / dScaleH ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::ToGlob( const Frame3d& frRef)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // trasformo punto e versori
   return ( m_ptP.ToGlob( frRef)  &&
            m_vtN.ToGlob( frRef)  &&
            m_vtD.ToGlob( frRef)) ;
}

//----------------------------------------------------------------------------
bool
ExtText::ToLoc( const Frame3d& frRef)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // trasformo punto e versori
   return ( m_ptP.ToLoc( frRef)  &&
            m_vtN.ToLoc( frRef)  &&
            m_vtD.ToLoc( frRef)) ;
}

//----------------------------------------------------------------------------
bool
ExtText::LocToLoc( const Frame3d& frOri, const Frame3d& frDest)
{
  // verifico validità dei frame
   if ( frOri.GetType() == Frame3d::ERR  ||  frDest.GetType() == Frame3d::ERR)
      return false ;
  // se i due riferimenti coincidono, non devo fare alcunché
   if ( AreSameFrame( frOri, frDest))
      return true ;
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ;
  // trasformo punto e versori
   return ( m_ptP.ToGlob( frOri)  &&  m_ptP.ToLoc( frDest)  &&
            m_vtN.ToGlob( frOri)  &&  m_vtN.ToLoc( frDest)  &&
            m_vtD.ToGlob( frOri)  &&  m_vtD.ToLoc( frDest)) ;
}

//----------------------------------------------------------------------------
bool
ExtText::GetHeightVersor( Vector3d& vtH) const
{
   vtH = m_vtN ^ m_vtD ;
   return ( vtH.Normalize()) ;
}

//----------------------------------------------------------------------------
bool
ExtText::GetStartPoint( Point3d& ptStart) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo il box delle maiuscole
   BBox3d b3Loc ;
   if ( ! fntMgr.GetCapBox( m_sText, m_nInsPos, b3Loc))
      return false ;

  // ricavo il punto di inizio
   ptStart = b3Loc.GetMin() ;

  // calcolo ed eseguo la trasformazione (da riferimento canonico font alla entità)
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;
   ptStart.ToGlob( frRef) ;

   return true ;
} 

//----------------------------------------------------------------------------
bool
ExtText::GetOverStartPoint( Point3d& ptStart) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo il box delle maiuscole
   BBox3d b3Loc ;
   if ( ! fntMgr.GetCapBox( m_sText, m_nInsPos, b3Loc))
      return false ;

  // ricavo il punto sopra l'inizio
   ptStart.Set( b3Loc.GetMin().x, b3Loc.GetMax().y, 0)  ;

  // calcolo ed eseguo la trasformazione (da riferimento canonico font alla entità)
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;
   ptStart.ToGlob( frRef) ;

   return true ;
} 

//----------------------------------------------------------------------------
bool
ExtText::GetEndPoint( Point3d& ptEnd) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo il box delle maiuscole
   BBox3d b3Loc ;
   if ( ! fntMgr.GetCapBox( m_sText, m_nInsPos, b3Loc))
      return false ;

  // ricavo il punto di fine
   ptEnd.Set( b3Loc.GetMax().x, b3Loc.GetMin().y, 0) ;

  // calcolo ed eseguo la trasformazione (da riferimento canonico font alla entità)
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;
   ptEnd.ToGlob( frRef) ;

   return true ;
} 

//----------------------------------------------------------------------------
bool
ExtText::GetOverEndPoint( Point3d& ptEnd) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo il box delle maiuscole
   BBox3d b3Loc ;
   if ( ! fntMgr.GetCapBox( m_sText, m_nInsPos, b3Loc))
      return false ;

  // ricavo il punto sopra la fine
   ptEnd = b3Loc.GetMax() ;

  // calcolo ed eseguo la trasformazione (da riferimento canonico font alla entità)
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;
   ptEnd.ToGlob( frRef) ;

   return true ;
} 

//----------------------------------------------------------------------------
bool
ExtText::GetMidPoint( Point3d& ptMid) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo il box delle maiuscole
   BBox3d b3Loc ;
   if ( ! fntMgr.GetCapBox( m_sText, m_nInsPos, b3Loc))
      return false ;

  // assegno il medio
   ptMid.Set( 0.5 * ( b3Loc.GetMin().x + b3Loc.GetMax().x), b3Loc.GetMin().y, 0) ;

  // calcolo ed eseguo la trasformazione (da riferimento canonico font alla entità)
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;
   ptMid.ToGlob( frRef) ;

   return true ;
} 

//----------------------------------------------------------------------------
bool
ExtText::GetCenterPoint( Point3d& ptCen) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo il box delle maiuscole
   BBox3d b3Loc ;
   if ( ! fntMgr.GetCapBox( m_sText, m_nInsPos, b3Loc))
      return false ;

  // ricavo il centro
   ptCen = Media( b3Loc.GetMin(), b3Loc.GetMax(), 0.5) ;

  // calcolo ed eseguo la trasformazione (da riferimento canonico font alla entità)
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;
   ptCen.ToGlob( frRef) ;

   return true ;
} 

//----------------------------------------------------------------------------
bool
ExtText::GetOutline( ICURVEPLIST& lstPC) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo l'outline
   if ( ! fntMgr.GetOutline( m_sText, m_nInsPos, lstPC))
      return false ;

  // calcolo la trasformazione
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;

  // eseguo la trasformazione
   for ( auto& PC : lstPC)
      PC->ToGlob( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::ApproxWithLines( double dLinTol, double dAngTolDeg, POLYLINELIST& lstPL) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo l'outline
   if ( ! fntMgr.ApproxWithLines( m_sText, m_nInsPos, dLinTol, dAngTolDeg, lstPL))
      return false ;

  // calcolo la trasformazione
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;

  // eseguo la trasformazione
   for ( auto& PL : lstPL)
      PL.ToGlob( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::ApproxWithArcs( double dLinTol, double dAngTolDeg, POLYARCLIST& lstPA) const
{
  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo l'outline
   if ( ! fntMgr.ApproxWithArcs( m_sText, m_nInsPos, dLinTol, dAngTolDeg, lstPA))
      return false ;

  // calcolo la trasformazione
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;

  // eseguo la trasformazione
   for ( auto& PA : lstPA)
      PA.ToGlob( frRef) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::Flip( void)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ; 
  // recupero il centro
   Point3d ptCen ;
   if ( ! GetCenterPoint( ptCen))
      return false ;
  // calcolo il nuovo punto di inserimento
   m_ptP += 2 * ( ptCen - m_ptP) ;
  // inverto la direzione di riferimento
   m_vtD *= -1 ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::Mir( bool bOnLen)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ; 

  // se auto-mirror sulla lunghezza del testo
   if ( bOnLen) {
     // faccio mirror sulla lunghezza della posizione di inserimento 
      switch ( m_nInsPos) {
      case ETXT_IPTL : m_nInsPos = ETXT_IPTR ; break ;
      case ETXT_IPTR : m_nInsPos = ETXT_IPTL ; break ;
      case ETXT_IPML : m_nInsPos = ETXT_IPMR ; break ;
      case ETXT_IPMR : m_nInsPos = ETXT_IPML ; break ;
      case ETXT_IPBL : m_nInsPos = ETXT_IPBR ; break ;
      case ETXT_IPBR : m_nInsPos = ETXT_IPBL ; break ;
      }
     // inverto i versori
      m_vtN.Invert() ;
      m_vtD.Invert() ;
   }
  // altrimenti auto-mirror su altezza del testo
   else {
     // faccio mirror sulla altezza della posizione di inserimento 
      switch ( m_nInsPos) {
      case ETXT_IPTL : m_nInsPos = ETXT_IPBL ; break ;
      case ETXT_IPTC : m_nInsPos = ETXT_IPBC ; break ;
      case ETXT_IPTR : m_nInsPos = ETXT_IPBR ; break ;
      case ETXT_IPBL : m_nInsPos = ETXT_IPTL ; break ;
      case ETXT_IPBC : m_nInsPos = ETXT_IPTC ; break ;
      case ETXT_IPBR : m_nInsPos = ETXT_IPTR ; break ;
      }
     // inverto il versore normale
      m_vtN.Invert() ;
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::ModifyText( const string& sText)
{
  // verifico che il testo sia valido
   if ( sText.empty())
      return false ;

  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ; 
  // assegno nuovo test
   m_sText = sText ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::ChangeFont( const string& sFont)
{
  // imposto ricalcolo della grafica
   m_OGrMgr.Reset() ; 
  // assegno nuovo font
   m_sFont = sFont ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ExtText::SplitOnLineBreak( IEXTTEXTPVECTOR& vText) const
{
  // pulisco il risultato
   vText.clear() ;

  // imposto il font corrente e i suoi dati
   FontManager& fntMgr = FontManager::GetFontManager() ;
   if ( ! fntMgr.SetCurrFont( m_sFont, m_nWeight, m_bItalic, m_dHeight, m_dRatio, m_dAddAdvance))
      return false ;

  // richiedo l'elenco delle linee con le rispettive posizioni di inizio
   PNTVECTOR vPt ;
   STRVECTOR vLine ;
   if ( ! fntMgr.GetTextLines( m_sText, m_nInsPos, vPt, vLine)  ||  vPt.size() != vLine.size())
      return false ;

  // calcolo la trasformazione intrinseca
   Frame3d frRef ;
   if ( ! frRef.Set( m_ptP, m_vtN, m_vtD))
      return false ;

  // eseguo la spezzatura
   for ( int i = 0 ; i < int( vPt.size()) ; ++ i) {
     // se la linea è vuota o contiene solo spazi, la salto
      if ( IsEmptyOrSpaces( vLine[i]))
         continue ;
     // creo un nuovo testo come copia del corrente
      ExtText* pText = Clone() ;
      if ( pText == nullptr)
         return false ;
     // lo modifico opportunamente
      Point3d ptIns = vPt[i] ;
      ptIns.ToGlob( frRef) ;
      pText->m_ptP = ptIns ;
      pText->m_sText = vLine[i] ;
      pText->m_nInsPos = ETXT_IPBL ;
     // lo inserisco nel vettore dei testi risultanti
      vText.push_back( pText) ;
   }

   return true ;
}