EgtExchange/ImportDxfTabs.cpp

//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : ImportDxfTabs.cpp       Data : 21.04.14         Versione : 1.5d4
// Contenuto : Implementazione di ImportDxf : gestione delle tavole.
//
//
//
// Modifiche : 21.04.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "ImportDxf.h"
#include "DxfConst.h"
#include "DllMain.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"

using namespace std ;

//----------------------------------------------------------------------------
bool
ImportDxf::ReadTables( bool& bFileEnd)
{
  // ciclo di lettura
   bool bOk = true ;
   bool bSectEnd = false ;
   string sTabName ;
   do {
     // leggo intestazione entità, per avere il tipo
      bool bOkLoc = GetTableName( sTabName, bSectEnd, bFileEnd) ;
      if ( bOkLoc  &&  ! bSectEnd) {
        // se Layer
         if ( sTabName == "LAYER") {
            if ( ! ReadLayerTable( bFileEnd))
               bOkLoc = false ;
         }
        // se Style
         else if ( sTabName == "STYLE") {
            if ( ! ReadStyleTable( bFileEnd))
               bOkLoc = false ;
         }
        // altrimenti
         else {
            if ( ! SkipTable( bFileEnd))
               bOkLoc = false ;
         }
      }
     // gestisco eventuale errore
      if ( ! bOkLoc) {
         bOk = false ;
         string sOut = "ImportDxf : Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
         LOG_ERROR( GetEExLogger(), sOut.c_str())
      }
   } while ( ! bSectEnd) ;

   return bOk ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::GetTableName( string& sTabName, bool& bSectEnd, bool& bFileEnd)
{
  // inizializzo
   sTabName.clear() ;
   bSectEnd = false ;
   bFileEnd = false ;
  // leggo il primo Item (mi aspetto 0 -> TABLE)
   int nCode = ReadNextItem() ;
   if ( nCode == CODE_NULL) {
      bSectEnd = true ;
      bFileEnd = true ;
      return false ;
   }
   if ( nCode != 0)
      return false ;
   if ( m_sCurrItem == "SECTION") {
      UngetItem() ;
      bSectEnd = true ;
      return true ;
   }
   if ( m_sCurrItem == "ENDSEC") {
      bSectEnd = true ;
      return true ;
   }
   if ( m_sCurrItem == "EOF") {
      bSectEnd = true ;
      bFileEnd = true ;
      return true ;
   }
   if ( m_sCurrItem != "TABLE")
      return false ;
  // leggo il secondo Item (mi aspetto 2 -> NomeTavola)
   nCode = ReadNextItem() ;
   if ( nCode == CODE_NULL) {
      bFileEnd = true ;
      return false ;
   }
   if ( nCode != 2)
      return false ;
   sTabName = m_sCurrItem ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::SkipTable( bool& bFileEnd)
{
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item ( cerco 0 -> ENDTAB)
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
   } while ( nCode != 0  ||  m_sCurrItem != "ENDTAB") ;
   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadLayerTable( bool& bFileEnd)
{
   bFileEnd = false ;
   bool bOk = true ;
  // ciclo sui diversi layer (fino a fine tavola 0-> ENDTAB)
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // se intestazione Layer ( 0 -> LAYER)
      if ( nCode == 0  &&  m_sCurrItem == "LAYER") {
         if ( ! ReadLayer( bFileEnd)) {
            bOk = false ;
            string sOut = "ImportDxf : Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
         }
        // per forzare la rilettura dell'ultimo gruppo che è stato rifiutato
         nCode = CODE_NULL ;
      }
   } while ( nCode != 0  ||  m_sCurrItem != "ENDTAB") ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadLayer( bool& bFileEnd)
{
   string sName ;
   int    nColor = COL_BYLAYER ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 2 :
         sName = m_sCurrItem ;
         break ;
      case 62 :
         FromString( m_sCurrItem, nColor) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // eventuale aggiustamento del nome per caratteri non ammessi
   ValidateVal( sName) ;
  // inserisco il layer nel DB geometrico
   int nId = m_pGDB->AddGroup( GDB_ID_NULL, m_nIdGroup, GLOB_FRM) ;
   if ( nId == GDB_ID_NULL)
      return false ;
  // assegnazione nome
   if ( ! m_pGDB->SetName( nId, sName))
      return false ;
  // assegnazione flag
   if ( ! m_pGDB->SetInfo( nId, DXF_INFO, 1))
      return false ;
  // aggiorno Map dei Layer
   m_nmLayer.insert( NameMap::value_type( sName, nId)) ;
  // eventuale assegnazione del colore
   Color cCol ;
   if ( ColorFromACI( nColor, cCol)) {
      if ( ! m_pGDB->SetMaterial( nId, cCol))
         return false ;
   }
   return true ;
}

//----------------------------------------------------------------------------
int
ImportDxf::GetLayerId( const string& sName)
{
  // se trovo il layer nel map, ne restituisco l'Id
   NameMap::iterator Iter = m_nmLayer.find( sName) ;
   if ( Iter != m_nmLayer.end())
      return Iter->second ;

  // inserisco un nuovo layer nel DB geometrico
   int nId = m_pGDB->AddGroup( GDB_ID_NULL, m_nIdGroup, GLOB_FRM) ;
   if ( nId == GDB_ID_NULL)
      return GDB_ID_NULL ;
  // assegnazione nome
   if ( ! m_pGDB->SetName( nId, sName))
      return GDB_ID_NULL ;
  // aggiorno Map dei Layer
   if ( m_nmLayer.insert( NameMap::value_type( sName, nId)).second)
      return nId ;

   return GDB_ID_NULL ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadStyleTable( bool& bFileEnd)
{
   bFileEnd = false ;
   bool bOk = true ;
  // ciclo sui diversi layer (fino a fine tavola 0-> ENDTAB)
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // se intestazione Style ( 0 -> STYLE)
      if ( nCode == 0  &&  m_sCurrItem == "STYLE") {
         if ( ! ReadStyle( bFileEnd)) {
            bOk = false ;
            string sOut = "ImportDxf : Error on line " + ToString( m_theScanner.GetCurrLineNbr()) ;
            LOG_ERROR( GetEExLogger(), sOut.c_str())
         }
        // per forzare la rilettura dell'ultimo gruppo che è stato rifiutato
         nCode = CODE_NULL ;
      }
   } while ( nCode != 0  ||  m_sCurrItem != "ENDTAB") ;
   return bOk ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::ReadStyle( bool& bFileEnd)
{
   string sName ;
   string sFont ;
   double dH = 0 ;
   double dRat = 1 ;
  // ciclo di lettura degli item della linea
   bFileEnd = false ;
   int nCode = CODE_NULL ;
   do {
     // leggo un Item
      nCode = ReadNextItem() ;
      if ( nCode == CODE_NULL) {
         bFileEnd = true ;
         return false ;
      }
     // eventuale gestione
      switch ( nCode) {
      case 2 :
         sName = m_sCurrItem ;
         break ;
      case 3 :
         sFont = m_sCurrItem ;
         break ;
      case 40 :
         FromString( m_sCurrItem, dH) ;
         break ;
      case 41 :
         FromString( m_sCurrItem, dRat) ;
         break ;
      }
   } while ( nCode != 0) ;
   UngetItem() ;
  // eventuale aggiustamento del nome per caratteri non ammessi e trasformazione in maiuscolo
   ValidateVal( sName) ;
   ToUpper( sName) ;
  // sistemazioni sui nomi dei font
   string sFontName ;
   string sExt ;
   SplitLast( sFont, ".", sFontName, sExt) ;
   ToUpper( sExt) ;
   if ( sExt == "TTF")
      sFont = sFontName ;
   else if ( sExt == "SHX")
      sFont = sFontName + ".Nfe" ;
   else if ( sExt.empty()  &&  sFontName == "txt")
      sFont = sFontName + ".Nfe" ;
  // aggiorno Map degli Style
   Style style( sFont, dH, dRat) ;
   m_smStyle.insert( StyleMap::value_type( sName, style)) ;

   return true ;
}

//----------------------------------------------------------------------------
bool
ImportDxf::GetStyleData( const string& sStyle, string& sFont, double& dH, double& dRat)
{
  // se trovo il layer nel map, ne restituisco l'Id
   StyleMap::iterator Iter = m_smStyle.find( sStyle) ;
   if ( Iter != m_smStyle.end()) {
      sFont = Iter->second.sFont ;
      dH = Iter->second.dH ;
      dRat = Iter->second.dRat ;
      return true ;
   }
   else {
      sFont = "txt.Nfe" ;
      dH = 0 ;
      dRat = 1 ;
      return false ;
   }
}