//----------------------------------------------------------------------------
//  EgalTech 2015-2015
//----------------------------------------------------------------------------
// File : ImportBtl.cpp       Data : 22.08.15         Versione : 1.6h5
// Contenuto : Implementazione della classe per l'importazione BTL.
//
//
//
// Modifiche : 22.08.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "ImportBtl.h"
#include "BtlConst.h"
#include "DllMain.h"
#include "/EgtDev/Include/EExDllMain.h"
#include "/EgtDev/Include/EGkStmStandard.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGnFileUtils.h"
#include "/EgtDev/Include/EgtKeyCodes.h"
#include "/EgtDev/Include/EgtStringEncoder.h"
#include "/EgtDev/Include/EgtStringEncoder.h"

using namespace std ;

//----------------------------------------------------------------------------
bool
SetBtlAuxDir( const string& sBtlAuxDir)
{
   BtlGeom::m_sBtlAuxDir = sBtlAuxDir ;
   return ExistsDirectory( sBtlAuxDir) ;
}

//----------------------------------------------------------------------------
IImportBtl*
CreateImportBtl( void)
{
  // verifico la chiave e le opzioni
   if ( ! VerifyKey( KEYOPT_EEX_INPADV))
      return nullptr ;
  // creo l'oggetto
   return static_cast<IImportBtl*> ( new(nothrow) ImportBtl) ;
}

//----------------------------------------------------------------------------
ImportBtl::ImportBtl( void)
{
   m_nBuild = 10000 ;
   m_dScale = 1 ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::Import( const string& sFile, IGeomDB* pGDB, int nFlag)
{
  // log di informazioni
   LOG_INFO( GetEExLogger(), ( "ImportBtl : " + sFile).c_str())

  // inizializzo lo scanner
   if ( ! m_theScanner.Init( sFile, KEY_COMMENT.c_str())) {
      LOG_ERROR( GetEExLogger(), "  Error on Init")
      return false ;
   }

  // inizializzo il gestore geometria pezzi Btl
   int nFlatVertPos = 0 ;
   if (( nFlag & EIBFLAG_OUTL_FLAT_POS) != 0)
      nFlatVertPos = 4 ;
   else if (( nFlag & EIBFLAG_TS3_POS) != 0)
      nFlatVertPos = 3 ;
   else if (( nFlag & EIBFLAG_FLAT_POS) != 0)
      nFlatVertPos = 1 ;
   else if (( nFlag & EIBFLAG_VERT_POS) != 0)
      nFlatVertPos = 2 ;
   bool bSpecialTrim = (( nFlag & EIBFLAG_SPECIAL_TRIM) != 0) ;
   bool bTrimWithOutline = (( nFlag & EIBFLAG_TRIM_WITH_OUTLINE) != 0) ;
   bool bUseUAttr = (( nFlag & EIBFLAG_USEUATTR) != 0) ;
   if ( ! m_BtlGeom.Init( pGDB, nFlatVertPos, bSpecialTrim, bTrimWithOutline, bUseUAttr)) {
      LOG_ERROR( GetEExLogger(), "  Error on BtlGeom.Init")
      return false ;
   }

  // scrivo nel progetto path del file
   m_BtlGeom.SetUserAttribute( UATD_INFO, IKEY_BTL_PATH + ":" + sFile) ;

  // lettura intestazione
   if ( ! ReadHeader()) {
      string sOut = "  Error (ReadHeader) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
      LOG_ERROR( GetEExLogger(), sOut.c_str())
      return false ;
   }

  // lettura generalitą
   bool bEnd ;
   if ( ! ReadGeneral( bEnd)) {
      string sOut = "  Error (ReadGeneral) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
      LOG_ERROR( GetEExLogger(), sOut.c_str())
      return false ;
   }
   else if ( bEnd) {
      string sOut = "  Error No Parts in Btl file" ;
      LOG_ERROR( GetEExLogger(), sOut.c_str())
      return false ;
   }

  // ciclo sui grezzi
   bool bOk = true ;
   for ( bool bEnd = false ; ! bEnd ;) {
     // leggo un grezzo
      if ( ! ReadObject( RAWPART, bEnd)) {
         // i log di errore sono gią gestiti nella funzione chiamata
         bOk = false ;
      }
     // se aggiunto un grezzo, lo sistemo
      if ( ! bEnd) {
         int nNewPart = m_BtlGeom.GetCurrPartId() ;
         if ( ! m_BtlGeom.AdjustRawPart( nNewPart)) {
            string sOut = "  Error Adjusting RawPart on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
            return false ;
         }
      }
   }

  // ciclo sui pezzi
   for ( bool bEnd = false ; ! bEnd ;) {
     // leggo un pezzo
      if ( ! ReadObject( PART, bEnd)) {
         // i log di errore sono gią gestiti nella funzione chiamata
         bOk = false ;
      }
   }

  // ciclo sui compositi
   for ( bool bEnd = false ; ! bEnd ;) {
     // leggo un composito
      if ( ! ReadObject( COMPOSITE, bEnd)) {
         // i log di errore sono gią gestiti nella funzione chiamata
         bOk = false ;
      }
     // se aggiunto un composito, lo sistemo
      if ( ! bEnd) {
         int nNewPart = m_BtlGeom.GetCurrPartId() ;
         if ( ! m_BtlGeom.AdjustComposite( nNewPart)) {
            string sOut = "  Error Adjusting Composite on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
            return false ;
         }
      }
   }

  // aggiusto riferimenti per grezzi e per compositi
   m_BtlGeom.AdjustRefForRawParts() ;
   m_BtlGeom.AdjustRefForComposites() ;

  // verifica definizione e unicitą SN ed eventuale sistemazione
   m_BtlGeom.AdjustSnForParts() ;

  // eventuale ordinamento degli oggetti secondo SN
   bool bSort = (( nFlag & EIBFLAG_SORT) != 0) ;
   if ( bSort) {
      Point3d ptIns ;
      m_BtlGeom.SortObjects( GDB_ID_ROOT, ptIns) ;
      m_BtlGeom.SortObjects( m_BtlGeom.GetRawPartsGroup(), ptIns) ;
      m_BtlGeom.SortObjects( m_BtlGeom.GetCompositesGroup(), ptIns) ;
   }

   return bOk ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadHeader( void)
{
  // conteggio campi utili letti
   int nRead = 0 ;
  // ciclo sulle linee
   string sLine ;
   while ( m_theScanner.GetLine( sLine)) {
     // se cambio sezione
      if ( sLine[0] == '[') {
         m_theScanner.UngetLine( sLine) ;
         return ( nRead > 0) ;
      }
     // spezzo la linea
      string sKey, sVal ;
      SplitFirst( sLine, ":", sKey, sVal) ;
     // se numero di versione
      if ( sKey == KEY_VERSION) {
         Trim( sVal, " \t\r\n\"") ;
         m_sVersion = sVal ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, m_sVersion) ;
      }
     // se numero di build
      else if ( sKey == KEY_BUILD) {
         Trim( sVal, " \t\r\n\"") ;
         if ( FromString( sVal, m_nBuild))
            ++ nRead ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
      }
     // se edizione
      else if ( sKey == KEY_EDITION) {
         Trim( sVal, " \t\r\n\"") ;
         if ( sVal == "PREFABRICATION")
            m_nEdition = 1 ;
         else
            m_nEdition = 0 ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
      }
   }

   return false ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadGeneral( bool& bEnd)
{
  // default file non finito
   bEnd = false ;
  // conteggio campi utili letti
   int nRead = 0 ;
  // leggo la prossima linea e verifico sia la sezione GENERAL
   string sLine ;
   if ( ! m_theScanner.GetLine( sLine)  ||  sLine != SEC_GENERAL)
      return false ;
  // ciclo sulle linee
   while ( m_theScanner.GetLine( sLine)) {
     // se cambio sezione
      if ( sLine[0] == '[') {
         m_theScanner.UngetLine( sLine) ;
         return ( nRead > 0) ;
      }
     // spezzo la linea
      string sKey, sVal ;
      SplitFirst( sLine, ":", sKey, sVal) ;
      switch ( FindGeneralKey( sKey)) {
      case KEY_GENE_PROJECTNUMBER :             // numero di progetto
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_PROJECTNAME :               // nome di progetto
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_PROJECTPART :               // parte di progetto
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_PROJECTGUID :               // identificativo globale unico di progetto
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_LISTNAME :                  // nome lista
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_CUSTOMER :                  // cliente
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_ARCHITECT :                 // architetto
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_EDITOR :                    // autore
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_DELIVERYDATE :              // data di consegna
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_EXPORTDATE :                // data di esportazione
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_EXPORTTIME :                // ora di esportazione
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_EXPORTRELEASE :             // programma di esportazione
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_LANGUAGE :                  // lingua
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_RANGE :                     // range dei parametri
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_SCALEUNIT :                 // numero di decimali
         {
            Trim( sVal, " \t\r\n\"") ;
            int nUnit ;
            if ( FromString( sVal, nUnit)) {
               m_dScale = pow( 10, - nUnit) ;
               ++ nRead ;
            }
            m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         }
         break ;
      case KEY_GENE_PROCESSINGQUALITY :         // qualitą di lavorazione
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_COMPUTERNAME :              // nome computer
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_USER :                      // nome utente
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_SOURCEFILE :                // file sorgente
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_EXPORTFILE :                // file di esportazione
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_RECESS :                    // finitura angoli interni
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_INFO, sKey, sVal) ;
         break ;
      case KEY_GENE_USERATTRIBUTE :             // attributo utente
         m_BtlGeom.SetUserAttribute( UATD_INFO, sVal) ;
         break ;
      }
   }
  // fine del file
   bEnd = true ;
   return ( nRead > 0) ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadObject( ObjType nType, bool& bEnd)
{
   string sLine ;
  // leggo la prossima linea
   if ( ! m_theScanner.GetLine( sLine)) {
      bEnd = true ;
      return true ;
   }
  // verifico sia la sezione opportuna (PART, RAWPART o COMPOSITE)
   if (( nType == PART  &&  sLine != SEC_PART)  ||
       ( nType == RAWPART  &&  sLine != SEC_RAWPART)  ||
       ( nType == COMPOSITE  &&  sLine != SEC_COMPOSITE)) {
      m_theScanner.UngetLine( sLine) ;
      bEnd = true ;
      return true ;
   }
  // creo il pezzo
   if ( ! m_BtlGeom.CreatePart()) {
      string sOut = "  Error (CreatePart) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
      LOG_ERROR( GetEExLogger(), sOut.c_str())
      SkipCurrSection() ;
      bEnd = false ;
      return false ;
   }
  // ciclo sulle linee con i dati generali del pezzo
   double dLength = 0, dHeight = 0, dWidth = 0 ;
   bool bLength = false, bHeight = false, bWidth = false, bBox = false ;
   int nTrasfCount = 0 ;
   string sUID = "0" ;
   while ( m_theScanner.GetLine( sLine)) {
     // se cambio sezione
      if ( sLine[0] == '[') {
         m_theScanner.UngetLine( sLine) ;
         bEnd = false ;
        // aggiorno outline
         return m_BtlGeom.UpdateOutLine() ;
      }
     // spezzo la linea
      string sKey, sVal ;
      SplitFirst( sLine, ":", sKey, sVal) ;
      switch ( FindPartKey( sKey)) {
      case KEY_PART_TYPE :                      // tipo (solo per Compositi)
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_SINGLEMEMBERNUMBER :        // identificativo di produzione
         {
            int nProdNbr = 0 ;
            if ( FromString( sVal, nProdNbr))
               m_BtlGeom.SetPartProdNbr( nProdNbr) ;
         }
         break ;
      case KEY_PART_ASSEMBLYNUMBER :            // numero di lista nell'assemblato
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_ORDERNUMBER :               // numero di lista nell'ordine
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_DESIGNATION :               // nome
         Trim( sVal, " \t\r\n\"") ;
         if ( ! IsTextUtf8( sVal.c_str()))
            sVal = LPSTR( WtoA( LPWSTR( AtoW( sVal.c_str(), 1252)))) ;
         m_BtlGeom.SetPartName( sVal) ;
         break ;
      case KEY_PART_ANNOTATION :                // annotazione
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_STOREY :                    // sottogruppo
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_GROUP :                     // gruppo
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_PACKAGE :                   // pacco di spedizione
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_MATERIAL :                  // materiale
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_TIMBERGRADE :               // qualitą legname
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_QUALITYGRADE :              // qualitą
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_COUNT :                     // quantitą
         {
            int nCount = 0 ;
            if ( FromString( sVal, nCount))
               m_BtlGeom.SetPartCount( nCount) ;
         }
         break ;
      case KEY_PART_LENGTH :                    // lunghezza (dimensione in X)
         if ( FromString( sVal, dLength)) {
            dLength *= m_dScale ;
            bLength = true ;
         }
         if ( bLength  &&  bHeight  &&  bWidth) {
            if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
               bBox = true ;
         }
         break ;
      case KEY_PART_HEIGHT :                    // altezza (dimensione in Y)
         if ( FromString( sVal, dHeight)) {
            dHeight *= m_dScale ;
            bHeight = true ;
         }
         if ( bLength  &&  bHeight  &&  bWidth) {
            if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
               bBox = true ;
         }
         break ;
      case KEY_PART_WIDTH :                     // larghezza (dimensione in Z)
         if ( FromString( sVal, dWidth)) {
            dWidth *= m_dScale ;
            bWidth = true ;
         }
         if ( bLength  &&  bHeight  &&  bWidth) {
            if ( m_BtlGeom.AddPartBox( dLength, dHeight, dWidth))
               bBox = true ;
         }
         break ;
      case KEY_PART_COLOUR :                    // colore
         {  
            Trim( sVal, " \t\r\n\"") ;
            Color colRes ;
            if ( ReadColor( sVal, colRes))
               m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( colRes)) ;
         }
         break ;
      case KEY_PART_PLANINGLENGTH :             // lunghezza spianatura
         {
            Trim( sVal, " \t\r\n\"") ;
            double dVal ;
            if ( GetParam( sVal, dVal))
               m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ;
         }
         break ;
      case KEY_PART_STARTOFFSET :               // offset iniziale
         {
            Trim( sVal, " \t\r\n\"") ;
            double dVal ;
            if ( GetParam( sVal, dVal))
               m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ;
         }
         break ;
      case KEY_PART_ENDOFFSET :                 // offset finale
         {
            Trim( sVal, " \t\r\n\"") ;
            double dVal ;
            if ( GetParam( sVal, dVal))
               m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( dVal, 3)) ;
         }
         break ;
      case KEY_PART_UID :                       // UID istanza pezzo nella struttura
         Trim( sVal, " \t\r\n\"") ;
         sUID = sVal ;
         break ;
      case KEY_PART_TRANSFORMATION :            // matrice di trasformazione istanza pezzo nella struttura
         {
            Frame3d frRef ;
            if ( ReadTransformation( sVal, frRef)) {
               ++ nTrasfCount ;
               if ( nType == PART)
                  m_BtlGeom.AddPartTransformation( sUID, frRef) ;
               string sUIDKey = sPartKey[KEY_PART_UID] + ToString( nTrasfCount) ;
               m_BtlGeom.SetUserAttribute( UATD_PART, sUIDKey, sUID) ;
               string sTRFKey = sPartKey[KEY_PART_TRANSFORMATION] + ToString( nTrasfCount) ;
               m_BtlGeom.SetUserAttribute( UATD_PART, sTRFKey, ToString( frRef)) ;
            }
         }
         break ;
      case KEY_PART_CAMBER :                    // incurvamento
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_PARTOFFSET :                // offset pezzo
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_PROCESSINGQUALITY :         // qualitą di lavorazione
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_OUTLINE :                   // contorno
        // interpreto l'outline
         m_theScanner.UngetLine( sLine) ;
         if ( ! ReadOutline()) {
            string sOut = "  Error (ReadOutline) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
            SkipCurrSection() ;
            m_BtlGeom.ErasePart() ;
            bEnd = false ;
            return false ;
         }
         break ;
      case KEY_PART_APERTURE :                  // apertura
        // interpreto l'apertura
         m_theScanner.UngetLine( sLine) ;
         if ( ! ReadAperture()) {
            string sOut = "  Error (ReadAperture) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
            SkipCurrSection() ;
            m_BtlGeom.ErasePart() ;
            bEnd = false ;
            return false ;
         }
         break ;
      case KEY_PART_RECESS :                    // finitura angoli interni
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_STOREYTYPE :                // tipo di piano
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_ELEMENTNUMBER :             // numero elemento
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_LAYER :                     // layer
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_MODULENUMBER :              // numero modulo
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_USERATTRIBUTE :             // attributo utente
         m_BtlGeom.SetUserAttribute( UATD_PART, sVal) ;
         break ;
      case KEY_PART_GRAINDIRECTION :            // direzione venatura
         {
            Trim( sVal, " \t\r\n\"") ;
            Vector3d vtDir ;
            bool bAlign ;
            if ( ReadGrainDirection( sVal, vtDir, bAlign))
               m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( vtDir) + ";" + ( bAlign ? "1" : "0")) ;
         }
         break ;
      case KEY_PART_REFERENCESIDE :             // lato di riferimento
         {
            Trim( sVal, " \t\r\n\"") ;
            int nSide ;
            bool bAlign ;
            if ( ReadReferenceSide( sVal, nSide, bAlign))
               m_BtlGeom.SetUserAttribute( UATD_PART, sKey, ToString( nSide) + ";" + ( bAlign ? "1" : "0")) ;
         }
         break ;
      case KEY_PART_ALIGNMENT :                 // allineamento
         Trim( sVal, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal) ;
         break ;
      case KEY_PART_MATERIALTYPE :              // tipo di materiale
         Trim( sVal, " \t\r\n\"") ;
         string sVal1, sVal2 ;
         Split( sVal, ":", true, sVal1, sVal2) ;
         Trim( sVal2, " \t\r\n\"") ;
         m_BtlGeom.SetUserAttribute( UATD_PART, sKey, sVal1 + ": " + sVal2) ;
         break ;
      }
     // se lavorazione, esco dal ciclo
      if ( sKey == sProcKey[KEY_PROC_PROCESSKEY]) {
         m_theScanner.UngetLine( sLine) ;
         break ;
      }
   }
  // verifico sia stato definito il contorno del pezzo
   if ( ! bBox) {
      string sOut = "  Error (AddPartBox) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
      LOG_ERROR( GetEExLogger(), sOut.c_str())
      SkipCurrSection() ;
      m_BtlGeom.ErasePart() ;
      bEnd = false ;
      return false ;
   }

  // interpreto le lavorazioni (processing)
   bool bOk = true ;
   for ( bool bProcEnd = false ; ! bProcEnd ;) {
      if ( ! ReadProcess( nType != PART, bProcEnd)) {
         // i log di errore sono gią gestiti nella funzione chiamata
         bOk = false ;
      }
   }

  // inserisco eventuali contorni liberi
   if ( ! m_BtlGeom.CreateFreeContours())
      bOk = false ;

  // aggiorno outline
   if ( ! m_BtlGeom.UpdateOutLine()) {
      string sOut = "  Error (UpdateOutLine) on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
      LOG_ERROR( GetEExLogger(), sOut.c_str())
      m_BtlGeom.ErasePart() ;
   }

   bEnd = false ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadTransformation( const string& sVal, Frame3d& frRef)
{
  // leggo i valori
   Point3d ptO ;
   GetParam( sVal, PAR_OX, ptO.x) ;
   GetParam( sVal, PAR_OY, ptO.y) ;
   GetParam( sVal, PAR_OZ, ptO.z) ;
   Vector3d vtX ;
   GetParam( sVal, PAR_XX, vtX.x) ;
   GetParam( sVal, PAR_XY, vtX.y) ;
   GetParam( sVal, PAR_XZ, vtX.z) ;
   if ( vtX.IsSmall())
      vtX = X_AX ;
   Vector3d vtY ;
   GetParam( sVal, PAR_YX, vtY.x) ;
   GetParam( sVal, PAR_YY, vtY.y) ;
   GetParam( sVal, PAR_YZ, vtY.z) ;
   if ( vtY.IsSmall())
      vtY = Y_AX ;
  // calcolo il riferimento
   return frRef.Set( ptO, ptO + vtX, ptO + vtY) ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadOutline( void)
{
   bool bProcFound = false ;
   int nSide = BTL_SIDE_NONE ;
   int nContType = 0 ;
   int nContData = 0 ;
   double dContPar = 0 ;
   FCEDEQUE dqFce ;
   STRVECTOR vsUAtt ;
  // ciclo sulle linee
   string sLine ;
   while ( m_theScanner.GetLine( sLine)) {
     // spezzo la linea
      string sKey, sVal ;
      SplitFirst( sLine, ":", sKey, sVal) ;
     // se attributo utente
      if ( sKey == sPartKey[KEY_PART_USERATTRIBUTE]) {
         vsUAtt.emplace_back( sVal) ;
         continue ;
      }
     // se cambio tipologia, concludo
      else if ( sKey != sPartKey[KEY_PART_OUTLINE]) {
         m_theScanner.UngetLine( sLine) ;
         break ;
      }
     // leggo i dati
      // tipo
      int nFlag ;
      GetParamP( sVal, 8, nFlag) ;
      // se non ancora assegnato, leggo se da lavorare
      if ( ! bProcFound) {
         string sToDo ;
         if ( GetInfo( sVal, PAR_PROCESS, sToDo)) {
            if ( sToDo.find( "YES") != 0)
               vsUAtt.emplace_back( "DO:0") ;
            bProcFound = true ;
         }
      }
      // se non ancora assegnata, leggo faccia di riferimento
      if ( nSide == BTL_SIDE_NONE)
         GetInfo( sVal, PAR_SIDE, nSide) ;
      // punto principale
      Point3d ptP ;
      GetParamP( sVal, 1, ptP.x) ;
      GetParamP( sVal, 2, ptP.y) ;
      GetParamP( sVal, 3, ptP.z) ;
      // se inizio leggo tipo contorno, dato e parametro
      if ( nFlag == FreeContourEnt::START) {
         GetParamP( sVal, 13, nContType) ;
         GetParamP( sVal, 14, nContData) ;
         GetParamP( sVal, 15, dContPar) ;
      }
      // se arco leggo il punto intermedio
      Point3d ptM ;
      if ( nFlag == FreeContourEnt::ARC) {
         GetParamP( sVal, 10, ptM.x) ;
         GetParamP( sVal, 11, ptM.y) ;
         GetParamP( sVal, 12, ptM.z) ;
      }
      // angolo di fianco
      double dAng = ( nFlag == FreeContourEnt::START ? FC_SIDEANG_DEF : FC_SIDEANG_NONE) ;
      GetParamP( sVal, 6, dAng) ;
     // aggiungo i dati alla deque
      dqFce.emplace_back( nFlag, ptP, ptM, dAng, 0, 0) ;
   }
  // inserimento del contorno nel pezzo
   return m_BtlGeom.AddPartOutline( nSide, dqFce, nContType, nContData, dContPar, vsUAtt) ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadAperture( void)
{
   bool bProcFound = false ;
   int nSide = BTL_SIDE_NONE ;
   int nContType = 0 ;
   int nContData = 0 ;
   double dContPar = 0 ;
   FCEDEQUE dqFce ;
   STRVECTOR vsUAtt ;
  // ciclo sulle linee
   string sLine ;
   while ( m_theScanner.GetLine( sLine)) {
     // spezzo la linea
      string sKey, sVal ;
      SplitFirst( sLine, ":", sKey, sVal) ;
     // se attributo utente
      if ( sKey == sPartKey[KEY_PART_USERATTRIBUTE]) {
         vsUAtt.emplace_back( sVal) ;
         continue ;
      }
     // se cambio tipologia, concludo
      else if ( sKey != sPartKey[KEY_PART_APERTURE]) {
         m_theScanner.UngetLine( sLine) ;
         break ;
      }
     // leggo i dati
      // tipo
      int nFlag ;
      GetParamP( sVal, 8, nFlag) ;
     // se tipo start ed esistono precedenti entitą, ne derivo una apertura
      if ( nFlag == FreeContourEnt::START  &&  dqFce.size() > 0) {
         if ( ! m_BtlGeom.AddPartAperture( nSide, dqFce, nContType, nContData, dContPar, vsUAtt))
            return false ;
         nSide = BTL_SIDE_NONE ;
         nContType = 0 ;
         nContData = 0 ;
         dContPar = 0 ;
         bProcFound = false ;
         dqFce.clear() ;
         vsUAtt.clear() ;
      }
      // se non ancora assegnato, leggo se da lavorare
      if ( ! bProcFound) {
         string sToDo ;
         if ( GetInfo( sVal, PAR_PROCESS, sToDo)) {
            if ( sToDo.find( "YES") != 0)
               vsUAtt.emplace_back( "DO:0") ;
            bProcFound = true ;
         }
      }
      // se non ancora assegnata, leggo faccia di riferimento
      if ( nSide == BTL_SIDE_NONE)
         GetInfo( sVal, PAR_SIDE, nSide) ;
      // punto principale
      Point3d ptP ;
      GetParamP( sVal, 1, ptP.x) ;
      GetParamP( sVal, 2, ptP.y) ;
      GetParamP( sVal, 3, ptP.z) ;
      // se inizio leggo tipo contorno, dato e parametro
      if ( nFlag == FreeContourEnt::START) {
         GetParamP( sVal, 13, nContType) ;
         GetParamP( sVal, 14, nContData) ;
         GetParamP( sVal, 15, dContPar) ;
      }
      // se arco leggo il punto intermedio
      Point3d ptM ;
      if ( nFlag == FreeContourEnt::ARC) {
         GetParamP( sVal, 10, ptM.x) ;
         GetParamP( sVal, 11, ptM.y) ;
         GetParamP( sVal, 12, ptM.z) ;
      }
      // angolo di fianco
      double dAng = ( nFlag == FreeContourEnt::START ? FC_SIDEANG_DEF : FC_SIDEANG_NONE) ;
      GetParamP( sVal, 6, dAng) ;
     // aggiungo i dati alla deque
      dqFce.emplace_back( nFlag, ptP, ptM, dAng, 0, 0) ;
   }
  // inserimento dell'ultima apertura nel pezzo
   return m_BtlGeom.AddPartAperture( nSide, dqFce, nContType, nContData, dContPar, vsUAtt) ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadColor( const string& sVal, Color& colRes)
{
  // leggo i valori
   string sRes ;
   GetParam( sVal, PAR_R, sRes) ;
   int nRed ; FromString( sRes, nRed) ;
   GetParam( sVal, PAR_G, sRes) ;
   int nGreen ; FromString( sRes, nGreen) ;
   GetParam( sVal, PAR_B, sRes) ;
   int nBlue ; FromString( sRes, nBlue) ;
   GetParam( sVal, PAR_A, sRes) ;
   int nAlpha ; FromString( sRes, nAlpha) ; nAlpha = nAlpha * 100 / 255 ;
   colRes.Set( nRed, nGreen, nBlue, nAlpha) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadGrainDirection( const string& sVal, Vector3d& vtDir, bool& bAlign)
{
  // leggo i valori (possono essere su pił linee consecutive)
   GetParam( sVal, PAR_X, vtDir.x) ;
   if ( ! GetParam( sVal, PAR_Y, vtDir.y)) {
      string sLine ;
      m_theScanner.GetLine( sLine) ;
      if ( ! GetParam( sLine, PAR_Y, vtDir.y)) {
         m_theScanner.UngetLine( sLine) ;
         return false ;
      }
   }
   if ( ! GetParam( sVal, PAR_Z, vtDir.z)) {
      string sLine ;
      m_theScanner.GetLine( sLine) ;
      if ( ! GetParam( sLine, PAR_Z, vtDir.z)) {
         m_theScanner.UngetLine( sLine) ;
         return false ;
      }
   }
   string sRes ;
   if ( ! GetParam( sVal, PAR_ALIGN, sRes)) {
      string sLine ;
      m_theScanner.GetLine( sLine) ;
      if ( ! GetParam( sLine, PAR_ALIGN, sRes)) {
         m_theScanner.UngetLine( sLine) ;
         return false ;
      }
   }
   bAlign = ( sRes == "YES") ;
  // ritorno
   return ( vtDir.Normalize()) ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadReferenceSide( const string& sVal, int& nSide, bool& bAlign)
{
  // leggo i valori (possono essere su pił linee consecutive)
   GetParam( sVal, PAR_SIDE, nSide) ;
   string sRes ;
   if ( ! GetParam( sVal, PAR_ALIGN, sRes)) {
      string sLine ;
      m_theScanner.GetLine( sLine) ;
      if ( ! GetParam( sLine, PAR_ALIGN, sRes)) {
         m_theScanner.UngetLine( sLine) ;
         return false ;
      }
   }
   bAlign = ( sRes == "YES") ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::ReadProcess( bool bObjRef, bool& bProcEnd)
{
   bProcEnd = false ;
   string sLine ;
  // leggo la prossima linea
   if ( ! m_theScanner.GetLine( sLine)) {
      bProcEnd = true ;
      return true ;
   }
  // verifico sia l'istruzione PROCESSKEY
   if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) == string::npos) {
      m_theScanner.UngetLine( sLine) ;
      bProcEnd = true ;
      return true ;
   }
  // recupero i parametri
   string sKey, sVal ;
   SplitFirst( sLine, ":", sKey, sVal) ;
   TrimLeft( sVal) ;
   string sType, sDes ;
   SplitFirst( sVal, " ", sType, sDes) ;
   Trim( sDes) ;
   STRVECTOR vsItem ;
   Tokenize( sType, "-", vsItem) ;
   if ( vsItem.size() < 3) {
      string sOut = "  Error in ProcessType(" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
      LOG_ERROR( GetEExLogger(), sOut.c_str())
      SkipCurrProcess() ;
      bProcEnd = false ;
      return false ;
   }
   int nGroup = 0 ;
   FromString( vsItem[0], nGroup) ;
   int nProc = 0 ;
   FromString( vsItem[1], nProc) ;
   int nSide = 0 ;
   FromString( vsItem[2], nSide) ;
   if ( nGroup != BTL_OBJECT_REF  &&  ( nSide < BTL_SIDE_FRONT  ||  nSide > BTL_SIDE_TOP))
      nSide = BTL_SIDE_FRONT ;
   bool bParams = false ;
   INTVECTOR vnDPar ;
   int nSPar = 0 ;
   DBLVECTOR vdPar ;
   string sPar ;
   int nProcId = 0 ;
   Frame3d frRef ;
   STRVECTOR vsUAtt ;
   string sUID ;
  // ciclo sulle linee
   while ( true) {
     // se fine file, concludo
      if ( ! m_theScanner.GetLine( sLine)) {
         bProcEnd = true ;
         break ;
      }
     // se cambio sezione, concludo
      if ( sLine[0] == '[') {
         m_theScanner.UngetLine( sLine) ;
         bProcEnd = true ;
         break ;
      }
     // se nuova lavorazione, concludo
      if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) != string::npos) {
         m_theScanner.UngetLine( sLine) ;
         bProcEnd = false ;
         break ;
      }
     // spezzo la linea
      string sKey, sVal ;
      SplitFirst( sLine, ":", sKey, sVal) ;
      switch ( FindProcessKey( sKey)) {
      case KEY_PROC_REFERENCEPLANE :               // riferimento
         if ( ! ReadTransformation( sVal, frRef)) {
            string sOut = "  Error : unable to read ReferencePlane  (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
            SkipCurrProcess() ;
            bProcEnd = false ;
            return false ;
         }
         break ;
      case KEY_PROC_PROCESSPARAMETERS :            // parametri
         if ( nProc == BTL_OBJECT_REF) {
            if ( ! GetParam( sVal, PAR_UID, sUID)) {
               string sOut = "  Error in GetProcessParams (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
               LOG_ERROR( GetEExLogger(), sOut.c_str())
               SkipCurrProcess() ;
               bProcEnd = false ;
               return false ;
            }
            bParams = true ;
            break ;
         }
         if ( ! m_BtlGeom.GetProcessParamInfos( nGroup, nProc, nSide, vnDPar, nSPar, vdPar, sPar)) {
            string sOut = "  Error : Unknown Process (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
            SkipCurrProcess() ;
            bProcEnd = false ;
            return true ;
         }
         else if ( ! GetProcessParams( sVal, sType, vnDPar, nSPar, vdPar, sPar)) {
            string sOut = "  Error in GetProcessParams (" + sType + ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
            SkipCurrProcess() ;
            bProcEnd = false ;
            return false ;
         }
         bParams = true ;
         break ;
      case KEY_PROC_PROCESSIDENT :                 // identificativo
         FromString( sVal, nProcId) ;
         break ;
      case KEY_PROC_PROCESSINGQUALITY :            // qualitą di lavorazione
         Trim( sVal, " \t\r\n\"") ;
         vsUAtt.emplace_back( sKey + ":" + sVal) ;
         break ;
      case KEY_PROC_USERATTRIBUTE :                // attributo utente
         vsUAtt.emplace_back( sVal) ;
         break ;
      case KEY_PROC_PRIORITY :                     // prioritą di lavorazione
         Trim( sVal, " \t\r\n\"") ;
         vsUAtt.emplace_back( sKey + ":" + sVal) ;
         break ;
      case KEY_PROC_RECESS :                       // tipo angolo interno
         Trim( sVal, " \t\r\n\"") ;
         vsUAtt.emplace_back( sKey + ":" + sVal) ;
         break ;
      case KEY_PROC_PROCESS :                      // indicazione di produzione
         Trim( sVal) ;
         if ( sVal != "YES")
            vsUAtt.emplace_back( "DO:0") ;
         break ;
      }
   }
  // se riferimento ad oggetto
   if ( nProc == BTL_OBJECT_REF) {
     // inserimento del riferimento nel pezzo
      if ( ! bParams  ||
           ! m_BtlGeom.AddObjectRef( sUID, frRef)) {
         string sOut = "  Error in AddObjectRef (" + sType + ") to Part " + m_BtlGeom.GetPartName() + " on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_ERROR( GetEExLogger(), sOut.c_str())
         bProcEnd = false ;
         return false ;
      }
   }
  // altrimenti lavorazione
   else {
     // inserimento della lavorazione nel pezzo
      if ( ! bParams  ||
           ! m_BtlGeom.AddProcess( nGroup, nProc, nSide, sDes, nProcId, frRef, vnDPar, nSPar, vdPar, sPar, vsUAtt, m_theScanner.GetCurrLineNbr())) {
         string sOut = "  Error in AddProcess (" + sType + ") to Part " + m_BtlGeom.GetPartName() + " on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_ERROR( GetEExLogger(), sOut.c_str())
         bProcEnd = false ;
         return false ;
      }
   }

   bProcEnd = false ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::SkipCurrSection( void)
{
  // ciclo sulle linee
   string sLine ;
   while ( true) {
     // se fine file, concludo
      if ( ! m_theScanner.GetLine( sLine)) {
         break ;
      }
     // se cambio sezione, concludo
      if ( sLine[0] == '[') {
         m_theScanner.UngetLine( sLine) ;
         break ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::SkipCurrProcess( void)
{
  // ciclo sulle linee
   string sLine ;
   while ( true) {
     // se fine file, concludo
      if ( ! m_theScanner.GetLine( sLine)) {
         break ;
      }
     // se cambio sezione, concludo
      if ( sLine[0] == '[') {
         m_theScanner.UngetLine( sLine) ;
         break ;
      }
     // se nuova lavorazione, concludo
      if ( sLine.find( sProcKey[KEY_PROC_PROCESSKEY]) != string::npos) {
         m_theScanner.UngetLine( sLine) ;
         break ;
      }
   }
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetProcessParams( const string& sText, const string& sProcType,
                             const INTVECTOR& vnDPar, int nSPar,
                             DBLVECTOR& vdPar, string& sPar)
{
  // verifico corrispondenza numero definizioni - numero parametri numerici
   if ( vnDPar.size() != vdPar.size())
      return false ;
  // leggo i parametri numerici
   for ( int i = 0 ; i < int( vnDPar.size()) ; ++ i) {
      if ( ! GetParamP( sText, vnDPar[i], vdPar[i])) {
         string sOut = "  Info : P" + ToString( vnDPar[i], 2) + " missing in Process (" + sProcType +
                       ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_DBG_INFO( GetEExLogger(), sOut.c_str())
      }
   }
  // leggo l'eventuale parametro stringa
   if ( nSPar != 0) {
      if ( ! GetParamP( sText, nSPar, sPar)) {
         string sOut = "  Info : P" + ToString( nSPar, 2) + " missing in Process (" + sProcType +
                       ") on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_DBG_INFO( GetEExLogger(), sOut.c_str())
      }
   }

   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetInfo( const string& sText, const string& sPar, string& sVal)
{
  // cerco l'identificativo del parametro
   size_t nPos = sText.find( sPar + ":") ;
   if ( nPos == string::npos)
      return false ;
  // recupero la stringa successiva
   const int SVAL_LEN = 6 ;
   sVal = sText.substr( nPos + sPar.length() + 1, SVAL_LEN) ;
   Trim( sVal, " \t\r\n0") ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetInfo( const string& sText, const string& sPar, int& nVal)
{
   string sVal ;
   if ( ! GetInfo( sText, sPar, sVal))
      return false ;
   nVal = 0 ;
   FromString( sVal, nVal) ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetParam( const string& sPar, double& dVal)
{
   string sVal = sPar ;
   TrimLeft( sVal, " \t\r\n0") ;
   dVal = 0 ;
   FromString( sVal, dVal) ;
   dVal *= m_dScale ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetParam( const string& sText, const string& sPar, int& nVal)
{
  // leggo il parametro
   double dVal ;
   bool bOk = GetParam( sText, sPar, dVal) ;
   nVal = lround( dVal / m_dScale) ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetParam( const string& sText, const string& sPar, double& dVal)
{
  // cerco l'identificativo del parametro
   size_t nPos = sText.find( sPar + ":") ;
   if ( nPos == string::npos)
      return false ;
  // recupero la stringa successiva
   const int SVAL_LEN = 14 ;
   string sVal = sText.substr( nPos + sPar.length() + 1, SVAL_LEN) ;
   TrimLeft( sVal, " \t\r\n0") ;
   dVal = 0 ;
   FromString( sVal, dVal) ;
   dVal *= m_dScale ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetParam( const string& sText, const string& sPar, string& sVal)
{
  // cerco l'identificativo del parametro
   size_t nPos = sText.find( sPar + ":") ;
   if ( nPos == string::npos)
      return false ;
  // cerco i delimitatori della stringa "
   size_t nPosI = sText.find( "\"", nPos + sPar.length() + 1) ;
   size_t nPosF = sText.find( "\"", nPosI + 1) ;
   if ( nPosI != string::npos  &&  nPosF != string::npos) {
      sVal = sText.substr( nPosI + 1, nPosF - nPosI - 1) ;
      return true ;
   }
   else {
      sVal = sText.substr( nPos + sPar.length() + 1) ;
      Trim( sVal, " \t\r\n\"") ;
      return true ;
   }
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetParamP( const string& sText, int nInd, int& nVal)
{
  // verifico se dummy
   if ( nInd < 0)
      return true ;
  // creo l'identificativo
   string sPar = PAR_P + ToString( nInd, 2) ;
  // leggo il parametro
   double dVal = 0 ;
   bool bOk = GetParam( sText, sPar, dVal) ;
   nVal = lround( dVal) ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetParamP( const string& sText, int nInd, double& dVal)
{
  // verifico se dummy
   if ( nInd < 0)
      return true ;
  // creo l'identificativo
   string sPar = PAR_P + ToString( nInd, 2) ;
  // leggo il parametro
   return GetParam( sText, sPar, dVal) ;
}

//----------------------------------------------------------------------------
bool
ImportBtl::GetParamP( const string& sText, int nInd, string& sVal)
{
  // verifico se dummy
   if ( nInd < 0)
      return true ;
  // creo l'identificativo
   string sPar = PAR_P + ToString( nInd, 2) ;
  // leggo il parametro
   return GetParam( sText, sPar, sVal) ;
}