EgtExecutor/AuxTools.cpp

//----------------------------------------------------------------------------
//  EgalTech 2014-2015
//----------------------------------------------------------------------------
// File : AuxTools.cpp           Data : 07.01.15        Versione : 1.6a1
// Contenuto : Funzioni ausiliarie.
//
//
//
// Modifiche : 07.01.15 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

#include "stdafx.h"
#include "EXE.h"
#include "EXE_Macro.h"
#include "AuxTools.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EMkDispositionConst.h"
#include "/EgtDev/Include/EXeConst.h"
#include "/EgtDev/Include/EGnStringUtils.h"

using namespace std ;

//----------------------------------------------------------------------------
string
StringToLuaString( const string& sText)
{
   string sLuaText = sText ;
   ReplaceString( sLuaText, "\\", "\\\\") ;
   ReplaceString( sLuaText, "'", "\\'") ;
   return sLuaText ;
}

//----------------------------------------------------------------------------
const string
IdToString( int nId)
{
   GseContext* pCtx = GetCurrGseContext() ;
   VERIFY_CTX( pCtx, "GDB_ID.NULL")
   switch ( nId) {
   case GDB_ID_ROOT : return "GDB_ID.ROOT" ;
   case GDB_ID_NULL : return "GDB_ID.NULL" ;
   case GDB_ID_SEL : return "GDB_ID.SEL" ;
   case GDB_ID_GRID : return "GDB_ID.GRID" ;
   case GDB_ID_CURRPART : return "GDB_ID.CP" ;
   case GDB_ID_CURRLAYER : return "GDB_ID.CL" ;
   default :
      if ( nId == pCtx->m_nCurrPart)
         return "GDB_ID.CP" ;
      else if ( nId == pCtx->m_nCurrLayer)
         return "GDB_ID.CL" ;
      else
         return ToString( nId) ;
   }
}

//----------------------------------------------------------------------------
const string
IdListToString( const INTVECTOR& vIds)
{
   string sIds ;
   sIds.reserve( 6 * vIds.size()) ;
   for ( size_t i = 0 ; i < vIds.size() ; ++ i)
      sIds += ( vIds[i] != GDB_ID_SEL ? ToString( vIds[i]) : "GDB_ID.SEL") + "," ;
   if ( ! sIds.empty())
      sIds.pop_back() ;
   return sIds ;
}

//----------------------------------------------------------------------------
const string
SelListToString( const SELVECTOR& vIds)
{
   string sIds ;
   sIds.reserve( 12 * vIds.size()) ;
   for ( size_t i = 0 ; i < vIds.size() ; ++ i)
      sIds += "{" + ToString( vIds[i]) + "}," ;
   if ( ! sIds.empty())
      sIds.pop_back() ;
   return sIds ;
}

//----------------------------------------------------------------------------
const char*
NgeTypeToString( int nNgeType)
{
   switch ( nNgeType) {
   case GDB_SV_TXT : return "GDB_NT.TXT" ;
   case GDB_SV_BIN : return "GDB_NT.BIN" ;
   default :
   case GDB_SV_CMPTXT : return "GDB_NT.CMPTXT" ;
   }
}

//----------------------------------------------------------------------------
const char*
SepToString( int nSep)
{
   switch ( nSep) {
   default :
   case SEP_STD : return "GDB_PT.STD" ;
   case SEP_TG : return "GDB_PT.TG" ;
   case SEP_PERP : return "GDB_PT.PERP" ;
   case SEP_MINDIST : return "GDB_PT.MIND" ;
   }
}

//----------------------------------------------------------------------------
const char*
InsToString( int nIns)
{
   switch ( nIns) {
   case GDB_FIRST_SON : return "GDB_IN.FIRST_SON" ;
   default :
   case GDB_LAST_SON : return "GDB_IN.LAST_SON" ;
   case GDB_BEFORE : return "GDB_IN.BEFORE" ;
   case GDB_AFTER : return "GDB_IN.AFTER" ;
   }
}

//----------------------------------------------------------------------------
const char*
RefTypeToString( int nRefType)
{
   switch ( nRefType) {
   case RTY_GLOB : return "GDB_RT.GLOB" ;
   default : 
   case RTY_LOC : return "GDB_RT.LOC" ;
   case RTY_GRID : return "GDB_RT.GRID" ;
   }
}

//----------------------------------------------------------------------------
const char*
ETxtInsPosToString( int nETxtInsPos)
{
   switch ( nETxtInsPos) {
   case ETXT_IPTL : return "GDB_TI.TL" ;
   case ETXT_IPTC : return "GDB_TI.TC" ;
   case ETXT_IPTR : return "GDB_TI.TR" ;
   case ETXT_IPML : return "GDB_TI.ML" ;
   case ETXT_IPMC : return "GDB_TI.MC" ;
   case ETXT_IPMR : return "GDB_TI.MR" ;
   default :
   case ETXT_IPBL : return "GDB_TI.BL" ;
   case ETXT_IPBC : return "GDB_TI.BC" ;
   case ETXT_IPBR : return "GDB_TI.BR" ;
   }
}

//----------------------------------------------------------------------------
const char*
OffsTypeToString( int nOffsType)
{
   switch ( nOffsType) {
   default : 
   case ICurve::OFF_FILLET : return "GDB_OT.FILLET" ;
   case ICurve::OFF_CHAMFER : return "GDB_OT.CHAMFER" ;
   case ICurve::OFF_EXTEND : return "GDB_OT.EXTEND" ;
   }
}

//----------------------------------------------------------------------------
const char*
InterpTypeToString( int nIntpType)
{
   switch ( nIntpType) {
   case ITT_ARCS : return "GDB_PI.ARCS" ;
   default : 
   case ITT_ARCS_CORNER : return "GDB_PI.ARCS_CORNER" ;
   case ITT_CUBICS : return "GDB_PI.CUBICS" ;
   }
}

//----------------------------------------------------------------------------
const char*
ApproxTypeToString( int nApprType)
{
   switch ( nApprType) {
   case APP_LINES : return "GDB_CA.LINES" ;
   case APP_LEFT_LINES : return "GDB_CA.LEFT_LINES" ;
   case APP_RIGHT_LINES : return "GDB_CA.RIGHT_LINES" ;
   default : 
   case APP_ARCS : return "GDB_CA.ARCS" ;
   }
}

//----------------------------------------------------------------------------
const char*
RawPartCornerPosToString( int nFlag)
{
   switch ( nFlag) {
   case MCH_CR_TL : return "MCH_CR.TL" ;
   case MCH_CR_TR : return "MCH_CR.TR" ;
   default : 
   case MCH_CR_BL : return "MCH_CR.BL" ;
   case MCH_CR_BR : return "MCH_CR.BR" ;
   }
}

//----------------------------------------------------------------------------
const char*
RawPartCenterPosToString( int nFlag)
{
   switch ( nFlag) {
   case MCH_CE_TC : return "MCH_CE.TC" ;
   default : 
   case MCH_CE_ML : return "MCH_CE.ML" ;
   case MCH_CE_MR : return "MCH_CE.MR" ;
   case MCH_CE_BC : return "MCH_CE.BC" ;
   case MCH_CE_MC : return "MCH_CE.MC" ;
   }
}