EgtInterface/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 "AuxTools.h"
#include "/EgtDev/Include/EGkExtText.h"
#include "/EgtDev/Include/EMkMachMgr.h"
#include "/EgtDev/Include/EInConst.h"
#include "/EgtDev/Include/EGnStringUtils.h"

using namespace std ;

//----------------------------------------------------------------------------
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 char*
NgeTypeToString( int nNgeType)
{
   switch ( nNgeType) {
   case GDB_SV_TXT : return "'T'" ;
   case GDB_SV_BIN : return "'B'" ;
   default :
   case GDB_SV_CMPTXT : return "'CT'" ;
   }
}

//----------------------------------------------------------------------------
int
StringToNgeType( const string& sNgeType)
{
   string sTmp = sNgeType ;
   ToUpper( sTmp) ;
   if ( sTmp == "T")
      return GDB_SV_TXT ;
   else if ( sTmp == "B")
      return GDB_SV_BIN ;
   else if ( sTmp == "CT")
      return GDB_SV_CMPTXT ;
  // default
   return GDB_SV_CMPTXT ;
}

//----------------------------------------------------------------------------
const char*
SepToString( int nSep)
{
   switch ( nSep) {
   default :
   case SEP_STD : return "'ST'" ;
   case SEP_TG : return "'TG'" ;
   case SEP_PERP : return "'PR'" ;
   case SEP_MINDIST : return "'MD'" ;
   }
}

//----------------------------------------------------------------------------
int
StringToSep( const string& sSep)
{
   string sTmp = sSep ;
   ToUpper( sTmp) ;
   if ( sTmp == "ST")
      return SEP_STD ;
   else if ( sTmp == "TG")
      return SEP_TG ;
   else if ( sTmp == "PR") 
      return SEP_PERP ;
   else if ( sTmp == "MD")
      return SEP_MINDIST ;
  // default
   return SEP_STD ;
}

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

//----------------------------------------------------------------------------
int
StringToIns( const string& sIns)
{
   string sTmp = sIns ;
   ToUpper( sTmp) ;
   if ( sTmp == "LAST_SON")
      return GDB_LAST_SON ;
   else if ( sTmp == "FIRST_SON")
      return GDB_FIRST_SON ;
   else if ( sTmp == "BEFORE") 
      return GDB_BEFORE ;
   else if ( sTmp == "AFTER")
      return GDB_AFTER ;
  // default
   return GDB_LAST_SON ;
}

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

//----------------------------------------------------------------------------
int
StringToRefType( const string& sRefType)
{
   string sTmp = sRefType ;
   ToUpper( sTmp) ;
   if ( sTmp == "GLOB")
      return RTY_GLOB ;
   else if ( sTmp == "LOC") 
      return RTY_LOC ;
   else if ( sTmp == "GRID") 
      return RTY_GRID ;
  // default
   return RTY_LOC ;
}

//----------------------------------------------------------------------------
int
StringToRefId( const string& sRefId)
{
   string sTmp = sRefId ;
   ToUpper( sTmp) ;
   if ( sTmp == "GLOB")
      return GDB_ID_ROOT ;
   else if ( sTmp == "GRID") 
      return GDB_ID_GRID ;
  // default
   return GDB_ID_ROOT ;
}

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

//----------------------------------------------------------------------------
int
ETxtInsPosToString( const string& sETxtInsPos)
{
   string sInsPos = sETxtInsPos ;
   ToUpper( sInsPos) ;
   if ( sInsPos == "TL")
      return ETXT_IPTL ;
   else if ( sInsPos == "TC") 
      return ETXT_IPTC ;
   else if ( sInsPos == "TR") 
      return ETXT_IPTR ;
   else if ( sInsPos == "ML") 
      return ETXT_IPML ;
   else if ( sInsPos == "MC") 
      return ETXT_IPMC ;
   else if ( sInsPos == "MR") 
      return ETXT_IPMR ;
   else if ( sInsPos == "BL") 
      return ETXT_IPBL ;
   else if ( sInsPos == "BC") 
      return ETXT_IPBC ;
   else if ( sInsPos == "BR") 
      return ETXT_IPBR ;
  // default
   return ETXT_IPBL ;
}

//----------------------------------------------------------------------------
const char*
RawPartCornerPosToString( int nFlag)
{
   switch ( nFlag) {
   case RPCR_TL : return "'TL'" ;
   case RPCR_TR : return "'TR'" ;
   default : 
   case RPCR_BL : return "'BL'" ;
   case RPCR_BR : return "'BR'" ;
   }
}

//----------------------------------------------------------------------------
int
StringToRawPartCornerPos( const string& sFlag)
{
   string sTemp = sFlag ;
   ToUpper( sTemp) ;
   if ( sTemp == "TL")
      return RPCR_TL ;
   else if ( sTemp == "TR")
      return RPCR_TR ;
   else if ( sTemp == "BL")
      return RPCR_BL ;
   else if ( sTemp == "BR")
      return RPCR_BR ;
  // default
   return RPCR_BL ;
}

//----------------------------------------------------------------------------
const char*
RawPartCenterPosToString( int nFlag)
{
   switch ( nFlag) {
   case RPCE_TC : return "'TC'" ;
   default : 
   case RPCE_ML : return "'ML'" ;
   case RPCE_MR : return "'MR'" ;
   case RPCE_BC : return "'BC'" ;
   case RPCE_MC : return "'MC'" ;
   }
}

//----------------------------------------------------------------------------
int
StringToRawPartCenterPos( const string& sFlag)
{
   string sTemp = sFlag ;
   ToUpper( sTemp) ;
   if ( sTemp == "TC")
      return RPCE_TC ;
   else if ( sTemp == "ML")
      return RPCE_ML ;
   else if ( sTemp == "MR")
      return RPCE_MR ;
   else if ( sTemp == "BC")
      return RPCE_BC ;
   else if ( sTemp == "MC")
      return RPCE_MC ;
  // default
   return RPCE_ML ;
}