Dario Sassi
c50ecf7d53
- piccole migliorie al salvataggio progetti per salvataggio e ripristioni CamStatus.
636 lines
22 KiB
C++
636 lines
22 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2014-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : EXE_GeomDB.cpp Data : 04.05.15 Versione : 1.6e1
|
|
// Contenuto : Funzioni DB geometrico per EXE.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 01.09.14 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "EXE.h"
|
|
#include "EXE_Macro.h"
|
|
#include "AuxTools.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
#include "/EgtDev/Include/EGnFileUtils.h"
|
|
#include "/EgtDev/Include/EgtStringConverter.h"
|
|
#include "/EgtDev/Include/EgtPointerOwner.h"
|
|
|
|
using namespace std ;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int
|
|
ExeInitContext( void)
|
|
{
|
|
// creo e recupero un contesto libero
|
|
int nGseCtx = CreateGseContext() ;
|
|
if ( nGseCtx == 0) {
|
|
ResetCurrGseContext() ;
|
|
LOG_ERROR( GetLogger(), "Error in CreateGseContext (ExeInitContext)")
|
|
return 0 ;
|
|
}
|
|
GseContext* pGseCtx = GetGseContext( nGseCtx) ;
|
|
// inizializzazioni DB geometrico
|
|
PtrOwner<IGeomDB> pGeomDB( CreateGeomDB()) ;
|
|
VERIFY_NULL( Get( pGeomDB), "Error in CreateGeomDB", nGseCtx)
|
|
// inserisco il GeomDB nel contesto
|
|
pGseCtx->m_pGeomDB = Release( pGeomDB) ;
|
|
pGseCtx->m_pGeomDB->Init() ;
|
|
pGseCtx->m_pGeomDB->SetDefaultMaterial( pGseCtx->m_colDef) ;
|
|
// rendo corrente il contesto
|
|
SetCurrGseContext( nGseCtx) ;
|
|
// log avvio Context (DB geometrico)
|
|
string sLog = "Context " + ToString( nGseCtx) + " started" ;
|
|
LOG_INFO( GetLogger(), sLog.c_str())
|
|
|
|
return nGseCtx ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDeleteContext( int nGseCtx)
|
|
{
|
|
// se contesto corrente, lo resetto
|
|
if ( nGseCtx == GetIndCurrGseContext())
|
|
ResetCurrGseContext() ;
|
|
// lo cancello
|
|
bool bOk = DeleteGseContext( nGseCtx) ;
|
|
// log arresto Context (DB geometrico + eventuale Scene)
|
|
string sLog = "Context " + ToString( nGseCtx) + ( bOk ? " deleted" : " not found") ;
|
|
LOG_INFO( GetLogger(), sLog.c_str())
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSetCurrentContext( int nGseCtx)
|
|
{
|
|
return SetCurrGseContext( nGseCtx) ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeResetCurrentContext( void)
|
|
{
|
|
return ResetCurrGseContext() ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int
|
|
ExeGetCurrentContext( void)
|
|
{
|
|
return GetIndCurrGseContext() ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSetDefaultMaterial( Color ColDef)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// imposto il materiale di default
|
|
pGseCtx->m_colDef = ColDef ;
|
|
pGseCtx->m_pGeomDB->SetDefaultMaterial( pGseCtx->m_colDef) ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSetGridFrame( const Frame3d& frFrame)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// imposto il riferimento della griglia
|
|
bool bOk = pGeomDB->SetGridFrame( frFrame) ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtSetGridFrame({{" + ToString( frFrame.Orig()) + "},{" +
|
|
ToString( frFrame.VersX()) + "},{" +
|
|
ToString( frFrame.VersY()) + "},{" +
|
|
ToString( frFrame.VersZ()) + "}})" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeGetGridFrame( int nRefId, Frame3d& frFrame)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero il riferimento della griglia
|
|
frFrame = pGeomDB->GetGridFrame() ;
|
|
// se richiesto nel riferimento globale, esco subito
|
|
if ( nRefId == GDB_ID_ROOT)
|
|
return true ;
|
|
// recupero il riferimento destinazione (nRefId può essere un gruppo o una entità)
|
|
Frame3d frDest ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nRefId, frDest) &&
|
|
! pGeomDB->GetGlobFrame( nRefId, frDest))
|
|
return false ;
|
|
// eseguo la trasformazione
|
|
return frFrame.ToLoc( frDest) ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeGetGridVersZ( int nRefId, Vector3d& vtVersZ)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero il versore Z della griglia
|
|
vtVersZ = pGeomDB->GetGridFrame().VersZ() ;
|
|
// se richiesto nel riferimento globale, esco subito
|
|
if ( nRefId == GDB_ID_ROOT)
|
|
return true ;
|
|
// recupero il riferimento destinazione (nRefId può essere un gruppo o una entità)
|
|
Frame3d frDest ;
|
|
if ( ! pGeomDB->GetGroupGlobFrame( nRefId, frDest) &&
|
|
! pGeomDB->GetGlobFrame( nRefId, frDest))
|
|
return false ;
|
|
// eseguo la trasformazione
|
|
return vtVersZ.ToLoc( frDest) ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSetCurrFilePath( const string& sFilePath)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// assegno la path
|
|
pGseCtx->m_sFilePath = sFilePath ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeGetCurrFilePath( string& sFilePath)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// restituisco la path
|
|
sFilePath = pGseCtx->m_sFilePath ;
|
|
return ( ! sFilePath.empty()) ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeEnableModified( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// abilito possibilità di alterare il flag di modifica
|
|
pGseCtx->m_bEnableModified = true ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDisableModified( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// disabilito possibilità di alterare il flag di modifica
|
|
pGseCtx->m_bEnableModified = false ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeGetEnableModified( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// restituisco stato
|
|
return pGseCtx->m_bEnableModified ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSetModified( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// se consentito, imposto il flag
|
|
if ( pGseCtx->m_bEnableModified)
|
|
pGseCtx->m_bModified = true ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSetModified( int nCtx)
|
|
{
|
|
GseContext* pGseCtx = GetGseContext( nCtx) ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// se consentito, imposto il flag
|
|
if ( pGseCtx->m_bEnableModified)
|
|
pGseCtx->m_bModified = true ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeResetModified( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// se consentito, cancello il flag
|
|
if ( pGseCtx->m_bEnableModified)
|
|
pGseCtx->m_bModified = false ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeGetModified( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// restituisco il flag
|
|
return pGseCtx->m_bModified ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeNewFile( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
bool bOk = true ;
|
|
// reinizializzazione (con pulizia) del DB geometrico
|
|
bOk = bOk && pGseCtx->m_pGeomDB->Init() ;
|
|
bOk = bOk && pGseCtx->m_pGeomDB->SetDefaultMaterial( pGseCtx->m_colDef) ;
|
|
// pulizia delle textures
|
|
if ( pGseCtx->m_pScene != nullptr)
|
|
bOk = bOk && pGseCtx->m_pScene->UnloadAllTextures() ;
|
|
// aggiorno stato file corrente
|
|
pGseCtx->m_sFilePath.clear() ;
|
|
ExeResetModified() ;
|
|
// aggiorno pezzo/layer correnti
|
|
bool bPrevCmdLog = SetCmdLog( false) ;
|
|
ExeResetCurrPartLayer() ;
|
|
SetCmdLog( bPrevCmdLog) ;
|
|
// aggiornamento gestore lavorazioni (se installato)
|
|
if ( GetCurrMachMgr() != nullptr)
|
|
ExeUpdateMachMgr() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtNewFile()"
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// scrivo il log
|
|
LOG_INFO( GetLogger(), "New File") ;
|
|
// restituisco il risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeOpenFile( const string& sFilePath)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
bool bOk = true ;
|
|
// reinizializzazione (con pulizia) del DB geometrico
|
|
bOk = bOk && pGseCtx->m_pGeomDB->Init() ;
|
|
bOk = bOk && pGseCtx->m_pGeomDB->SetDefaultMaterial( pGseCtx->m_colDef) ;
|
|
// pulizia delle textures
|
|
if ( pGseCtx->m_pScene != nullptr)
|
|
bOk = bOk && pGseCtx->m_pScene->UnloadAllTextures() ;
|
|
// pulizia gestore lavorazioni (necessaria qui)
|
|
if ( GetCurrMachMgr() != nullptr)
|
|
ExeUpdateMachMgr() ;
|
|
// imposto path corrente del file
|
|
pGseCtx->m_sFilePath = sFilePath ;
|
|
// carico il file
|
|
bOk = bOk && pGseCtx->m_pGeomDB->Load( sFilePath) ;
|
|
// aggiorno stato file corrente
|
|
ExeResetModified() ;
|
|
// aggiorno pezzo/layer correnti
|
|
bool bPrevCmdLog = SetCmdLog( false) ;
|
|
ExeResetCurrPartLayer() ;
|
|
SetCmdLog( bPrevCmdLog) ;
|
|
// aggiornamento gestore lavorazioni
|
|
if ( GetCurrMachMgr() != nullptr)
|
|
ExeUpdateMachMgr() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtOpenFile('" + StringToLuaString( sFilePath) + "')" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// scrivo il log
|
|
{
|
|
string sLog = "Open File " + sFilePath ;
|
|
LOG_INFO( GetLogger(), sLog.c_str()) ;
|
|
}
|
|
// restituisco il risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeInsertFile( const string& sFilePath)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
|
|
// creo gruppo temporaneo di parcheggio
|
|
int nGrp = pGeomDB->InsertGroup( GDB_ID_NULL, GDB_ID_ROOT, GDB_FIRST_SON, GLOB_FRM) ;
|
|
bool bOk = ( nGrp != GDB_ID_NULL) ;
|
|
bOk = bOk && pGeomDB->SetLevel( nGrp, GDB_LV_TEMP) ;
|
|
// carico il file
|
|
bOk = bOk && pGeomDB->Load( sFilePath, nGrp) ;
|
|
// sposto i pezzi sotto la radice
|
|
int nId = pGeomDB->GetFirstGroupInGroup( nGrp) ;
|
|
while ( bOk && nId != GDB_ID_NULL) {
|
|
// prossimo gruppo
|
|
int nNextId = pGeomDB->GetNextGroup( nId) ;
|
|
// se il gruppo corrente è un pezzo, lo sposto
|
|
int nLevel ;
|
|
if ( ! pGeomDB->GetLevel( nId, nLevel) || nLevel == GDB_LV_USER)
|
|
bOk = pGeomDB->Relocate( nId, GDB_ID_ROOT, GDB_LAST_SON) ;
|
|
// passo al prossimo
|
|
nId = nNextId ;
|
|
}
|
|
// se gestite, sistemo le lavorazioni
|
|
IMachMgr* pMchMgr = GetCurrMachMgr() ;
|
|
if ( pMchMgr != nullptr)
|
|
bOk = bOk && ExeInsertMachMgr( nGrp) ;
|
|
// sistemo eventuali pezzi duplicati
|
|
bOk = bOk && ExeInsertDuplo( nGrp) ;
|
|
// sposto i gruppi rimasti sotto la radice
|
|
nId = pGeomDB->GetFirstGroupInGroup( nGrp) ;
|
|
while ( bOk && nId != GDB_ID_NULL) {
|
|
// prossimo gruppo
|
|
int nNextId = pGeomDB->GetNextGroup( nId) ;
|
|
// se non è base per lavorazioni, lo sposto
|
|
if ( pMchMgr == nullptr || ! pMchMgr->IsMachBase( nId))
|
|
bOk = pGeomDB->Relocate( nId, GDB_ID_ROOT, GDB_LAST_SON) ;
|
|
// passo al prossimo
|
|
nId = nNextId ;
|
|
}
|
|
// cancello il gruppo temporaneo
|
|
pGeomDB->Erase( nGrp) ;
|
|
// aggiorno stato file corrente
|
|
ExeSetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtInsertFile('" + StringToLuaString( sFilePath) + "')" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco il risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class CamStatus
|
|
{
|
|
public :
|
|
CamStatus( void) : m_nCurrMachGroup( GDB_ID_NULL), m_nCurrPhase( 0), m_nCurrMachining( GDB_ID_NULL) {
|
|
IMachMgr* pMachMgr = GetCurrMachMgr() ;
|
|
if ( pMachMgr == nullptr)
|
|
return ;
|
|
m_nCurrMachGroup = pMachMgr->GetCurrMachGroup() ;
|
|
if ( m_nCurrMachGroup == GDB_ID_NULL)
|
|
return ;
|
|
m_nCurrPhase = pMachMgr->GetCurrPhase() ;
|
|
if ( m_nCurrPhase == 0)
|
|
return ;
|
|
m_nCurrMachining = pMachMgr->GetCurrMachining() ;
|
|
int nId = pMachMgr->GetPhaseDisposition( m_nCurrPhase) ;
|
|
while ( nId != GDB_ID_NULL && pMachMgr->GetOperationPhase( nId) == m_nCurrPhase) {
|
|
bool bShow = false ;
|
|
pMachMgr->GetOperationStatus( nId, bShow) ;
|
|
m_vIdStat.push_back( ( bShow ? nId : - nId)) ;
|
|
nId = pMachMgr->GetNextOperation( nId) ;
|
|
}
|
|
pMachMgr->ResetCurrMachGroup() ;
|
|
}
|
|
~CamStatus( void) {
|
|
Restore() ;
|
|
}
|
|
void Restore( void) {
|
|
if ( m_nCurrMachGroup == GDB_ID_NULL)
|
|
return ;
|
|
IMachMgr* pMachMgr = GetCurrMachMgr() ;
|
|
if ( pMachMgr == nullptr)
|
|
return ;
|
|
pMachMgr->SetCurrMachGroup( m_nCurrMachGroup) ;
|
|
m_nCurrMachGroup = GDB_ID_NULL ;
|
|
if ( m_nCurrPhase == 0)
|
|
return ;
|
|
pMachMgr->SetCurrPhase( m_nCurrPhase, true) ;
|
|
pMachMgr->SetCurrMachining( m_nCurrMachining) ;
|
|
for ( auto nId : m_vIdStat) {
|
|
pMachMgr->SetOperationStatus( abs( nId), ( nId > 0)) ;
|
|
}
|
|
}
|
|
|
|
private :
|
|
int m_nCurrMachGroup ;
|
|
int m_nCurrPhase ;
|
|
int m_nCurrMachining ;
|
|
INTVECTOR m_vIdStat ;
|
|
} ;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSaveFile( const string& sFilePath, int nFlag)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// se ero in CAM, esco dopo averne salvato lo stato
|
|
CamStatus CurrCamStatus ;
|
|
// imposto path corrente del file
|
|
pGseCtx->m_sFilePath = sFilePath ;
|
|
// salvo il file
|
|
bool bOk = pGseCtx->m_pGeomDB->Save( GDB_ID_ROOT, sFilePath, nFlag) ;
|
|
// eventuale ripristino precedente CAM
|
|
CurrCamStatus.Restore() ;
|
|
// aggiorno stato file corrente
|
|
if ( bOk)
|
|
ExeResetModified() ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtSaveFile('" + StringToLuaString( sFilePath) + "'," +
|
|
NgeTypeToString( nFlag) + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// scrivo il log
|
|
{
|
|
string sLog = "Saved File " + sFilePath ;
|
|
LOG_INFO( GetLogger(), sLog.c_str()) ;
|
|
}
|
|
// restituisco il risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static bool
|
|
IsMachGroupOrWithin( int nId, const IGeomDB* pGeomDB, const IMachMgr* pMachMgr, int& nMachGroupId)
|
|
{
|
|
// default non definito
|
|
nMachGroupId = GDB_ID_NULL ;
|
|
// verifico validità puntatori
|
|
if ( pGeomDB == nullptr || pMachMgr == nullptr)
|
|
return false ;
|
|
// eseguo ricerca
|
|
int nParentId = pGeomDB->GetParentId( nId) ;
|
|
int nPrevParId = nId ;
|
|
while ( nParentId != GDB_ID_NULL && nParentId != GDB_ID_ROOT) {
|
|
if ( pMachMgr->IsMachBase( nParentId)) {
|
|
nMachGroupId = nPrevParId ;
|
|
return true ;
|
|
}
|
|
nPrevParId = nParentId ;
|
|
nParentId = pGeomDB->GetParentId( nParentId) ;
|
|
}
|
|
return false ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSaveObjToFile( const INTVECTOR& vId, const string& sFilePath, int nFlag)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
IMachMgr* pMachMgr = GetCurrMachMgr() ;
|
|
// se uno degli oggetti è la base dei gruppi di lavoro, chiamo la funzione di salvataggio di tutto
|
|
for ( int nId : vId) {
|
|
if ( pMachMgr != nullptr && pMachMgr->IsMachBase( nId))
|
|
return ExeSaveFile( sFilePath, nFlag) ;
|
|
}
|
|
// se uno degli oggetti è un gruppo di lavoro o una sua parte, chiamo la appropriata funzione di salvataggio
|
|
for ( int nId : vId) {
|
|
int nMachGroupId ;
|
|
if ( IsMachGroupOrWithin( nId, pGeomDB, pMachMgr, nMachGroupId)) {
|
|
INTVECTOR vOthId ;
|
|
vOthId.reserve( vId.size()) ;
|
|
for ( int nSouId : vId) {
|
|
if ( nSouId != nId)
|
|
vOthId.push_back( nSouId) ;
|
|
}
|
|
return ExeSaveMachGroupToFile( nMachGroupId, vOthId, sFilePath, nFlag) ;
|
|
}
|
|
}
|
|
// se ero in CAM, non esco <---
|
|
// copio l'oggetto nel file
|
|
bool bOk = pGeomDB->Save( vId, sFilePath, nFlag) ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtSaveObjToFile({" + ToString( vId) + "},'" +
|
|
StringToLuaString( sFilePath) + "'," +
|
|
NgeTypeToString( nFlag) + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco il risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSaveMachGroupToFile( int nMGroupId, const INTVECTOR& vPlusId, const string& sFilePath, int nFlag)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
IMachMgr* pMachMgr = GetCurrMachMgr() ;
|
|
VERIFY_MACHMGR( pMachMgr, false)
|
|
// disabilito registrazione dei comandi
|
|
bool bPrevCmdLog = SetCmdLog( false) ;
|
|
// disabilito possibilità di alterare il flag di modifica
|
|
bool bOldEnabModif = ExeGetEnableModified() ;
|
|
if ( bOldEnabModif)
|
|
ExeDisableModified() ;
|
|
// se ero in CAM, esco dopo averne salvato lo stato
|
|
CamStatus CurrCamStatus ;
|
|
// verifico che gli oggetti Plus non siano gruppi di lavoro o una loro parte
|
|
bool bOk = true ;
|
|
for ( int nPlusId : vPlusId) {
|
|
int nMGrpPlusId ;
|
|
if ( IsMachGroupOrWithin( nPlusId, pGeomDB, pMachMgr, nMGrpPlusId)) {
|
|
bOk = false ;
|
|
break ;
|
|
}
|
|
}
|
|
// recupero eventuali pezzi e foto del gruppo di lavoro
|
|
INTVECTOR vId ;
|
|
int nPhotoId = GDB_ID_NULL ;
|
|
string sPhotoOriPath = "" ;
|
|
bOk = bOk && pMachMgr->SetCurrMachGroup( nMGroupId) ;
|
|
if ( bOk) {
|
|
// aggiungo gruppo di lavoro
|
|
vId.emplace_back( nMGroupId) ;
|
|
// aggiungo pezzi
|
|
int nRawId = pMachMgr->GetFirstRawPart() ;
|
|
while ( nRawId != GDB_ID_NULL) {
|
|
int nPartId = pMachMgr->GetFirstPartInRawPart( nRawId) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
if ( find( vId.begin(), vId.end(), nPartId) == vId.end()) {
|
|
vId.emplace_back( nPartId) ;
|
|
// potrebbe essere un duplicato, recupero eventuale originale
|
|
int nOrigId = GDB_ID_NULL ; pGeomDB->GetInfo( nPartId, GDB_SI_DUPSOU, nOrigId) ;
|
|
if ( ExeIsPart( nOrigId) && find( vId.begin(), vId.end(), nOrigId) == vId.end())
|
|
vId.emplace_back( nOrigId) ;
|
|
}
|
|
nPartId = pMachMgr->GetNextPartInRawPart( nPartId) ;
|
|
}
|
|
nRawId = pMachMgr->GetNextRawPart( nRawId) ;
|
|
}
|
|
// aggiungo eventuale foto
|
|
static const string PHOTO_GRP = "Photos" ;
|
|
static const string PHOTO_NAME = "Raw" ;
|
|
string sMGroupName = pMachMgr->GetMachGroupName( nMGroupId) ;
|
|
nPhotoId = pGeomDB->GetFirstNameInGroup( pGeomDB->GetFirstNameInGroup( GDB_ID_ROOT, PHOTO_GRP), PHOTO_NAME + sMGroupName) ;
|
|
if ( nPhotoId != GDB_ID_NULL) {
|
|
vId.emplace_back( nPhotoId) ;
|
|
ExeGetPhotoPath( nPhotoId, sPhotoOriPath) ;
|
|
string sPhotoNewPath = ChangeFileExtension( sFilePath, GetFileExtension( sPhotoOriPath)) ;
|
|
ExeChangePhotoPath( nPhotoId, sPhotoNewPath) ;
|
|
CopyFileEgt( sPhotoOriPath, sPhotoNewPath) ;
|
|
}
|
|
// disattivo gruppo di lavoro
|
|
pMachMgr->ResetCurrMachGroup() ;
|
|
}
|
|
// aggiungo gli oggetti plus
|
|
if ( bOk)
|
|
vId.insert( vId.end(), vPlusId.begin(), vPlusId.end()) ;
|
|
// salvo gli oggetti appena identificati
|
|
bOk = bOk && pGeomDB->Save( vId, sFilePath, nFlag) ;
|
|
// eventuale ripristino dati fotografia
|
|
if ( nPhotoId != GDB_ID_NULL)
|
|
ExeChangePhotoPath( nPhotoId, sPhotoOriPath) ;
|
|
// eventuale ripristino precedente CAM
|
|
CurrCamStatus.Restore() ;
|
|
// ripristino possibilità di alterare il flag di modifica
|
|
if ( bOldEnabModif)
|
|
ExeEnableModified() ;
|
|
// ripristino registrazione dei comandi
|
|
SetCmdLog( bPrevCmdLog) ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtSaveMachGroupToFile(" + ToString( nMGroupId) + ",{" +
|
|
ToString( vPlusId) + "},'" +
|
|
StringToLuaString( sFilePath) + "'," +
|
|
NgeTypeToString( nFlag) + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco il risultato
|
|
return bOk ;
|
|
}
|