DarioS
1025 lines
36 KiB
C++
1025 lines
36 KiB
C++
//----------------------------------------------------------------------------
|
|
// EgalTech 2015-2015
|
|
//----------------------------------------------------------------------------
|
|
// File : EXE_GdbPartLayers.cpp Data : 04.05.15 Versione : 1.6e1
|
|
// Contenuto : Funzioni di gestione pezzi e layer relativi per EXE.
|
|
//
|
|
//
|
|
//
|
|
// Modifiche : 29.01.15 DS Creazione modulo.
|
|
//
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
//--------------------------- Include ----------------------------------------
|
|
#include "stdafx.h"
|
|
#include "EXE.h"
|
|
#include "EXE_Const.h"
|
|
#include "EXE_Macro.h"
|
|
#include "/EgtDev/Include/EXeExecutor.h"
|
|
#include "/EgtDev/Include/EGkCurve.h"
|
|
#include "/EgtDev/Include/EGkChainCurves.h"
|
|
#include "/EgtDev/Include/EGkStringUtils3d.h"
|
|
|
|
using namespace std ;
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static bool
|
|
ExeIsUserObj( IGeomDB* pGeomDB, int nId)
|
|
{
|
|
int nLev ;
|
|
return ( pGeomDB->GetCalcLevel( nId, nLev) && nLev == GDB_LV_USER) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static bool
|
|
ExeIsSystemObj( IGeomDB* pGeomDB, int nId)
|
|
{
|
|
int nLev ;
|
|
return ( pGeomDB->GetCalcLevel( nId, nLev) && nLev == GDB_LV_SYSTEM) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static bool
|
|
ExeIsVisibleObj( IGeomDB* pGeomDB, int nId)
|
|
{
|
|
int nStat ;
|
|
return ( pGeomDB->GetCalcStatus( nId, nStat) && nStat != GDB_ST_OFF) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
ExeVerifyOrNext( IGeomDB* pGeomDB, int nId, bool bOnlyVisible)
|
|
{
|
|
while ( nId != GDB_ID_NULL) {
|
|
if ( ExeIsUserObj( pGeomDB, nId) &&
|
|
! pGeomDB->ExistsInfo( nId, GDB_SI_SOURCE) &&
|
|
( ! bOnlyVisible || ExeIsVisibleObj( pGeomDB, nId)))
|
|
return nId ;
|
|
nId = pGeomDB->GetNextGroup( nId) ;
|
|
}
|
|
return GDB_ID_NULL ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
ExeVerifyOrPrev( IGeomDB* pGeomDB, int nId, bool bOnlyVisible)
|
|
{
|
|
while ( nId != GDB_ID_NULL) {
|
|
if ( ExeIsUserObj( pGeomDB, nId) &&
|
|
( ! bOnlyVisible || ExeIsVisibleObj( pGeomDB, nId)))
|
|
return nId ;
|
|
nId = pGeomDB->GetPrevGroup( nId) ;
|
|
}
|
|
return GDB_ID_NULL ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
static int
|
|
ExeGhostVerifyOrNext( IGeomDB* pGeomDB, int nId)
|
|
{
|
|
while ( nId != GDB_ID_NULL) {
|
|
if ( ExeIsSystemObj( pGeomDB, nId) &&
|
|
pGeomDB->ExistsInfo( nId, GDB_SI_SOURCE)) {
|
|
int nPartId = GDB_ID_NULL ;
|
|
pGeomDB->GetInfo( nId, GDB_SI_SOURCE, nPartId) ;
|
|
int nRawId = pGeomDB->GetParentId( nPartId) ;
|
|
if ( ExeIsRawPart( nRawId))
|
|
return nId ;
|
|
}
|
|
nId = pGeomDB->GetNextGroup( nId) ;
|
|
}
|
|
return GDB_ID_NULL ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
ExeIsPart( int nPartId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico sia un pezzo (gruppo sotto la radice con livello utente)
|
|
if ( pGeomDB->GetGdbType( nPartId) == GDB_TY_GROUP &&
|
|
pGeomDB->GetParentId( nPartId) == GDB_ID_ROOT &&
|
|
ExeIsUserObj( pGeomDB, nPartId))
|
|
return true ;
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
ExeIsLayer( int nLayerId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico sia un layer (gruppo sotto un pezzo con livello utente)
|
|
if ( pGeomDB->GetGdbType( nLayerId) == GDB_TY_GROUP &&
|
|
ExeIsPart( pGeomDB->GetParentId( nLayerId)) &&
|
|
ExeIsUserObj( pGeomDB, nLayerId))
|
|
return true ;
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetCurrPart( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, GDB_ID_NULL)
|
|
// recupero il pezzo corrente
|
|
return pGseCtx->m_nCurrPart ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetCurrLayer( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, GDB_ID_NULL)
|
|
// recupero il pezzo corrente
|
|
return pGseCtx->m_nCurrLayer ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
ExeSetCurrPartLayer( int nPartId, int nLayerId)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
|
|
bool bOk = true ;
|
|
// verifico validità e visibilità pezzo
|
|
if ( pGeomDB->GetParentId( nPartId) == GDB_ID_ROOT &&
|
|
ExeIsUserObj( pGeomDB, nPartId) &&
|
|
ExeIsVisibleObj( pGeomDB, nPartId)) {
|
|
if ( nPartId != pGseCtx->m_nCurrPart)
|
|
pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
|
|
pGseCtx->m_nCurrPart = nPartId ;
|
|
}
|
|
else {
|
|
if ( nPartId == pGseCtx->m_nCurrPart || nPartId == GDB_ID_NULL) {
|
|
pGseCtx->m_nCurrPart = GDB_ID_NULL ;
|
|
pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
|
|
}
|
|
bOk = false ;
|
|
}
|
|
// verifico validità e visibilità layer
|
|
if ( pGeomDB->GetParentId( nLayerId) == pGseCtx->m_nCurrPart &&
|
|
ExeIsUserObj( pGeomDB, nLayerId) &&
|
|
ExeIsVisibleObj( pGeomDB, nLayerId)) {
|
|
pGseCtx->m_nCurrLayer = nLayerId ;
|
|
}
|
|
else {
|
|
if ( nLayerId == pGseCtx->m_nCurrLayer || nLayerId == GDB_ID_NULL)
|
|
pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
|
|
bOk = false ;
|
|
}
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtSetCurrPartLayer(" + ToString( nPartId) + "," +
|
|
ToString( nLayerId) + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco il risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
ExeResetCurrPartLayer( void)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
// reset
|
|
pGseCtx->m_nCurrPart = GDB_ID_NULL ;
|
|
pGseCtx->m_nCurrLayer = GDB_ID_NULL ;
|
|
// cerco il primo pezzo con un layer visibile
|
|
int nPartId = ExeGetFirstPart( true) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
// cerco il primo layer visibile del pezzo
|
|
int nLayerId = ExeGetFirstLayer( nPartId, true) ;
|
|
if ( nLayerId != GDB_ID_NULL) {
|
|
// assegno il pezzo corrente
|
|
pGseCtx->m_nCurrPart = nPartId ;
|
|
// assegno il layer corrente
|
|
pGseCtx->m_nCurrLayer = nLayerId ;
|
|
// esco dal ciclo di ricerca
|
|
break ;
|
|
}
|
|
nPartId = ExeGetNextPart( nPartId, true) ;
|
|
}
|
|
// se non ho trovato layer visibile mi accontento del primo pezzo visibile
|
|
if ( pGseCtx->m_nCurrPart == GDB_ID_NULL)
|
|
pGseCtx->m_nCurrPart = ExeGetFirstPart( true) ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtResetCurrPartLayer()"
|
|
" -- Ids=" + ToString( pGseCtx->m_nCurrPart) + "," + ToString( pGseCtx->m_nCurrLayer) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco il risultato
|
|
return true ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetPartCount( bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, 0)
|
|
// conto i pezzi, considerando richiesta di visibilità
|
|
int nCount = 0 ;
|
|
int nPartId = ExeGetFirstPart( bOnlyVisible) ;
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
++ nCount ;
|
|
nPartId = ExeGetNextPart( nPartId, bOnlyVisible) ;
|
|
}
|
|
return nCount ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetFirstPart( bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// recupero il primo gruppo sotto la radice
|
|
int nPartId = pGeomDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
// verifico oppure passo al primo successivo valido
|
|
return ExeVerifyOrNext( pGeomDB, nPartId, bOnlyVisible) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetNextPart( int nId, bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// recupero il successivo gruppo
|
|
int nPartId = pGeomDB->GetNextGroup( nId) ;
|
|
// verifico oppure passo al primo successivo valido
|
|
return ExeVerifyOrNext( pGeomDB, nPartId, bOnlyVisible) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetLastPart( bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// recupero l'ultimo gruppo sotto la radice
|
|
int nPartId = pGeomDB->GetLastGroupInGroup( GDB_ID_ROOT) ;
|
|
// verifico oppure passo al primo precedente valido
|
|
return ExeVerifyOrPrev( pGeomDB, nPartId, bOnlyVisible) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetPrevPart( int nId, bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// recupero il precedente gruppo
|
|
int nPartId = pGeomDB->GetPrevGroup( nId) ;
|
|
// verifico oppure passo al primo precedente valido
|
|
return ExeVerifyOrPrev( pGeomDB, nPartId, bOnlyVisible) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetFirstLayer( int nPartId, bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// verifico il pezzo (livello utente e se richiesto visibile)
|
|
if ( ! ExeIsUserObj( pGeomDB, nPartId) ||
|
|
( bOnlyVisible && ! ExeIsVisibleObj( pGeomDB, nPartId)))
|
|
return GDB_ID_NULL ;
|
|
// recupero il primo layer nel pezzo
|
|
int nLayerId = pGeomDB->GetFirstGroupInGroup( nPartId) ;
|
|
// verifico oppure passo al primo successivo valido
|
|
return ExeVerifyOrNext( pGeomDB, nLayerId, bOnlyVisible) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetNextLayer( int nId, bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// recupero il successivo gruppo
|
|
int nLayerId = pGeomDB->GetNextGroup( nId) ;
|
|
// verifico sia visibile oppure passo al primo successivo visibile
|
|
return ExeVerifyOrNext( pGeomDB, nLayerId, bOnlyVisible) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetLastLayer( int nPartId, bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// verifico il pezzo (livello utente e se richiesto visibile)
|
|
if ( ! ExeIsUserObj( pGeomDB, nPartId) ||
|
|
( bOnlyVisible && ! ExeIsVisibleObj( pGeomDB, nPartId)))
|
|
return GDB_ID_NULL ;
|
|
// recupero l'ultimo layer nel pezzo
|
|
int nLayerId = pGeomDB->GetLastGroupInGroup( nPartId) ;
|
|
// verifico oppure passo al primo precedente valido
|
|
return ExeVerifyOrPrev( pGeomDB, nLayerId, bOnlyVisible) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetPrevLayer( int nId, bool bOnlyVisible)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// recupero il precedente gruppo
|
|
int nLayerId = pGeomDB->GetPrevGroup( nId) ;
|
|
// verifico sia visibile oppure passo al primo precedente visibile
|
|
return ExeVerifyOrPrev( pGeomDB, nLayerId, bOnlyVisible) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetFirstGhostPart( void)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// recupero il primo gruppo sotto la radice
|
|
int nPartId = pGeomDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
// verifico oppure passo al primo successivo valido
|
|
return ExeGhostVerifyOrNext( pGeomDB, nPartId) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
int
|
|
ExeGetNextGhostPart( int nId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// recupero il successivo gruppo
|
|
int nPartId = pGeomDB->GetNextGroup( nId) ;
|
|
// verifico oppure passo al primo successivo valido
|
|
return ExeGhostVerifyOrNext( pGeomDB, nPartId) ;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------
|
|
bool
|
|
ExeEraseEmptyParts( void)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// recupero il primo pezzo
|
|
int nPartId = ExeVerifyOrNext( pGeomDB, pGeomDB->GetFirstGroupInGroup( GDB_ID_ROOT), false) ;
|
|
// ciclo sui pezzi
|
|
while ( nPartId != GDB_ID_NULL) {
|
|
// verifico se il pezzo non contiene alcuna entità geometrica
|
|
bool bFound = false ;
|
|
// ciclo sui layer dei pezzi
|
|
int nLayerId = ExeVerifyOrNext( pGeomDB, pGeomDB->GetFirstGroupInGroup( nPartId), false) ;
|
|
while ( nLayerId != GDB_ID_NULL) {
|
|
// verifico se il layer contiene qualcosa
|
|
if ( pGeomDB->GetGroupObjs( nLayerId) > 0) {
|
|
bFound = true ;
|
|
break ;
|
|
}
|
|
// passo al layer successivo
|
|
nLayerId = ExeVerifyOrNext( pGeomDB, pGeomDB->GetNextGroup( nLayerId), false) ;
|
|
}
|
|
// verifico se gruppo sorgente di pezzo in gruppo di lavorazione
|
|
if ( pGeomDB->ExistsInfo( nPartId, GDB_SI_SOURCE))
|
|
bFound = true ;
|
|
// salvo Id pezzo corrente
|
|
int nOldId = nPartId ;
|
|
// passo al pezzo successivo
|
|
nPartId = ExeVerifyOrNext( pGeomDB, pGeomDB->GetNextGroup( nPartId), false) ;
|
|
// se corrente da cancellare, procedo
|
|
if ( ! bFound)
|
|
pGeomDB->Erase( nOldId) ;
|
|
}
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtEraseEmptyParts()"
|
|
" -- Ok=" + ToString( true) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static bool
|
|
MySelectGroupObjs( IGeomDB* pGeomDB, int nGrpId, int nFilter)
|
|
{
|
|
bool bOk = true ;
|
|
// Ciclo sugli oggetti del gruppo
|
|
int nId = pGeomDB->GetFirstInGroup( nGrpId) ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
// Se è gruppo seleziono i suoi componenti (ma non il gruppo)
|
|
if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP) {
|
|
if ( ! MySelectGroupObjs( pGeomDB, nId, nFilter))
|
|
bOk = false ;
|
|
}
|
|
// altrimenti, se selezionabile lo seleziono direttamente
|
|
else {
|
|
if ( ( pGeomDB->GetGeoType( nId) & nFilter) != 0) {
|
|
if ( ! pGeomDB->SelectObj( nId))
|
|
bOk = false ;
|
|
}
|
|
}
|
|
// Passo al successivo
|
|
nId = pGeomDB->GetNext( nId) ;
|
|
}
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static bool
|
|
MyDeselectGroupObjs( IGeomDB* pGeomDB, int nGrpId)
|
|
{
|
|
bool bOk = true ;
|
|
// Ciclo sugli oggetti del gruppo
|
|
int nId = pGeomDB->GetFirstInGroup( nGrpId) ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
// Se è gruppo deseleziono i suoi componenti
|
|
if ( pGeomDB->GetGdbType( nId) == GDB_TY_GROUP) {
|
|
if ( ! MyDeselectGroupObjs( pGeomDB, nId))
|
|
bOk = false ;
|
|
}
|
|
// Eseguo deselezione (anche del gruppo per maggior sicurezza)
|
|
if ( ! pGeomDB->DeselectObj( nId))
|
|
bOk = false ;
|
|
// Passo al successivo
|
|
nId = pGeomDB->GetNext( nId) ;
|
|
}
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSelectPartObjs( int nPartId)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
|
|
// verifico sia veramente un pezzo
|
|
bool bOk = ExeIsPart( nPartId) ;
|
|
// eseguo selezione
|
|
bOk = bOk && MySelectGroupObjs( pGeomDB, nPartId, pGseCtx->m_nObjFilterForSelect) ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtSelectPartObjs(" + ToString( nPartId) + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDeselectPartObjs( int nPartId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico sia veramente un pezzo
|
|
bool bOk = ExeIsPart( nPartId) ;
|
|
// eseguo deselezione (anche del pezzo per maggior sicurezza)
|
|
bOk = bOk && MyDeselectGroupObjs( pGeomDB, nPartId) && pGeomDB->DeselectObj( nPartId) ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtDeselectPartObjs(" + ToString( nPartId) + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSelectLayerObjs( int nLayerId)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
|
|
// verifico sia veramente un layer o almeno un gruppo di un pezzo
|
|
bool bOk = ExeIsLayer( nLayerId) ||
|
|
( ( pGeomDB->GetGdbType( nLayerId) == GDB_TY_GROUP) && ExeIsPart( pGeomDB->GetParentId( nLayerId))) ;
|
|
// eseguo selezione
|
|
bOk = bOk && MySelectGroupObjs( pGeomDB, nLayerId, pGseCtx->m_nObjFilterForSelect) ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtSelectLayerObjs(" + ToString( nLayerId) + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDeselectLayerObjs( int nLayerId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// verifico sia veramente un layer o almeno un gruppo di un pezzo
|
|
bool bOk = ExeIsLayer( nLayerId) ||
|
|
( ( pGeomDB->GetGdbType( nLayerId) == GDB_TY_GROUP) && ExeIsPart( pGeomDB->GetParentId( nLayerId))) ;
|
|
// eseguo deselezione (anche del layer per maggior sicurezza)
|
|
bOk = bOk && MyDeselectGroupObjs( pGeomDB, nLayerId) && pGeomDB->DeselectObj( nLayerId) ;
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtDeselectLayerObjs(" + ToString( nLayerId) + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeSelectPathObjs( int nId, bool bHaltOnFork)
|
|
{
|
|
GseContext* pGseCtx = GetCurrGseContext() ;
|
|
VERIFY_CTX_GEOMDB( pGseCtx, false)
|
|
IGeomDB* pGeomDB = pGseCtx->m_pGeomDB ;
|
|
// verifico appartenga ad un layer (di un pezzo libero o in un grezzo)
|
|
int nIdLayer = pGeomDB->GetParentId( nId) ;
|
|
int nIdPart = pGeomDB->GetParentId( nIdLayer) ;
|
|
bool bOk = ( nIdLayer != GDB_ID_NULL && nIdPart != GDB_ID_NULL &&
|
|
( ExeIsLayer( nIdLayer) || ExeGetRawPartFromPart( nIdPart) != GDB_ID_NULL)) ;
|
|
// verifico sia abilitata la selezione di curve
|
|
bOk = bOk && ( pGseCtx->m_nObjFilterForSelect & GEO_CURVE) != 0 ;
|
|
// seleziono percorso a partire da entità indicata usando tutte le curve del pezzo
|
|
const int CHAIN_SIZE = 1000 ;
|
|
const double CHAIN_TOLER = 10 * EPS_SMALL ;
|
|
Point3d ptNear ;
|
|
ChainCurves chainC ;
|
|
bOk = bOk && chainC.Init( true, CHAIN_TOLER, CHAIN_SIZE) ;
|
|
// ciclo sui layer del pezzo
|
|
for ( int nLayId = pGeomDB->GetFirstGroupInGroup( nIdPart) ;
|
|
nLayId != GDB_ID_NULL ;
|
|
nLayId = pGeomDB->GetNextGroup( nLayId)) {
|
|
// ciclo sulle entità del layer
|
|
for ( int nEntId = pGeomDB->GetFirstInGroup( nLayId) ;
|
|
nEntId != GDB_ID_NULL ;
|
|
nEntId = pGeomDB->GetNext( nEntId)) {
|
|
// non deve essere nascosta
|
|
int nEntStat ;
|
|
pGeomDB->GetCalcStatus( nEntId, nEntStat) ;
|
|
if ( nEntStat == GDB_ST_OFF)
|
|
continue ;
|
|
// recupero la curva e il suo riferimento
|
|
ICurve* pCrv = GetCurve( pGeomDB->GetGeoObj( nEntId)) ;
|
|
if ( pCrv == nullptr)
|
|
continue ;
|
|
Frame3d frCrv ;
|
|
if ( ! pGeomDB->GetGlobFrame( nEntId, frCrv))
|
|
continue ;
|
|
// recupero i dati della curva necessari al concatenamento e li assegno
|
|
Point3d ptStart, ptEnd ;
|
|
Vector3d vtStart, vtEnd ;
|
|
if ( ! pCrv->GetStartPoint( ptStart) || ! pCrv->GetStartDir( vtStart) ||
|
|
! pCrv->GetEndPoint( ptEnd) || ! pCrv->GetEndDir( vtEnd))
|
|
continue ;
|
|
ptStart.ToGlob( frCrv) ;
|
|
vtStart.ToGlob( frCrv) ;
|
|
ptEnd.ToGlob( frCrv) ;
|
|
vtEnd.ToGlob( frCrv) ;
|
|
if ( nEntId == nId)
|
|
ptNear = ptStart + CHAIN_TOLER * vtStart ;
|
|
bOk = bOk && chainC.AddCurve( nEntId, ptStart, vtStart, ptEnd, vtEnd) ;
|
|
}
|
|
}
|
|
// recupero il primo percorso concatenato
|
|
INTVECTOR vId2s ;
|
|
bOk = bOk && chainC.GetChainFromNear( ptNear, bHaltOnFork, vId2s) ;
|
|
for ( size_t i = 0 ; i < vId2s.size() ; ++i) {
|
|
pGeomDB->SetStatus( abs( vId2s[i]), GDB_ST_SEL) ;
|
|
}
|
|
// se richiesto, salvo il comando Lua equivalente
|
|
if ( IsCmdLog()) {
|
|
string sLua = "EgtSelectPathObjs(" + ToString( nId) + "," +
|
|
( bHaltOnFork ? "true" : "false") + ")" +
|
|
" -- Ok=" + ToString( bOk) ;
|
|
LOG_INFO( GetCmdLogger(), sLua.c_str()) ;
|
|
}
|
|
// restituisco risultato
|
|
return bOk ;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
ExeIsDuploBase( IGeomDB* pGeomDB, int nId)
|
|
{
|
|
if ( pGeomDB == nullptr)
|
|
return false ;
|
|
int nLevel ;
|
|
string sName ;
|
|
return ( pGeomDB->GetLevel( nId, nLevel) && nLevel == GDB_LV_SYSTEM &&
|
|
pGeomDB->GetName( nId, sName) && sName == DUPLO_BASE) ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static int
|
|
GetDuploBase( IGeomDB* pGeomDB, bool bCreate = false)
|
|
{
|
|
// verifica collegamento a DB geometrico
|
|
if ( pGeomDB == nullptr)
|
|
return GDB_ID_NULL ;
|
|
// cerco il gruppo di base dei duplicati nella radice
|
|
int nId = pGeomDB->GetFirstGroupInGroup( GDB_ID_ROOT) ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
// verifico se gruppo cercato
|
|
if ( ExeIsDuploBase( pGeomDB, nId))
|
|
return nId ;
|
|
// passo al successivo
|
|
nId = pGeomDB->GetNextGroup( nId) ;
|
|
}
|
|
// non trovato, se non richiesta creazione ritorno
|
|
if ( ! bCreate)
|
|
return GDB_ID_NULL ;
|
|
// devo creare il gruppo di base delle lavorazioni
|
|
int nDuploBaseId = pGeomDB->InsertGroup( GDB_ID_NULL, GDB_ID_ROOT, GDB_FIRST_SON, GLOB_FRM) ;
|
|
if ( nDuploBaseId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// imposto nome del gruppo
|
|
pGeomDB->SetName( nDuploBaseId, DUPLO_BASE) ;
|
|
// imposto livello del gruppo a System
|
|
pGeomDB->SetLevel( nDuploBaseId, GDB_LV_SYSTEM) ;
|
|
// imposto visualizzazione a nascosto
|
|
pGeomDB->SetStatus( nDuploBaseId, GDB_ST_OFF) ;
|
|
return nDuploBaseId ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
static bool
|
|
IsPartForDuplo( IGeomDB* pGeomDB, int nPartId)
|
|
{
|
|
// è veramente un pezzo
|
|
if ( ExeIsPart( nPartId))
|
|
return true ;
|
|
// è un pezzo spostato altrove
|
|
int nBaseId, nLev ;
|
|
if ( pGeomDB->GetInfo( nPartId, GDB_SI_BASE, nBaseId) &&
|
|
pGeomDB->GetGdbType( nPartId) == GDB_TY_GROUP &&
|
|
pGeomDB->GetParentId( nBaseId) == GDB_ID_ROOT &&
|
|
pGeomDB->GetLevel( nPartId, nLev) && nLev == GDB_LV_USER)
|
|
return true ;
|
|
// altrimenti non è un pezzo
|
|
return false ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int
|
|
ExeDuploNew( int nSouId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// Verifico sia un pezzo
|
|
if ( ! IsPartForDuplo( pGeomDB, nSouId))
|
|
return GDB_ID_NULL ;
|
|
// Recupero il gruppo base dei duplicati
|
|
int nDuploBaseId = GetDuploBase( pGeomDB, true) ;
|
|
if ( nDuploBaseId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// Eseguo la copia del pezzo
|
|
int nNewId = pGeomDB->Copy( nSouId, GDB_ID_NULL, nDuploBaseId) ;
|
|
if ( nNewId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
int nBaseId ;
|
|
if ( pGeomDB->GetInfo( nSouId, GDB_SI_BASE, nBaseId) &&
|
|
pGeomDB->GetGdbType( nBaseId) == GDB_TY_GROUP)
|
|
*pGeomDB->GetGroupFrame( nNewId) = *pGeomDB->GetGroupFrame( nBaseId) ;
|
|
// Aggiorno info del sorgente
|
|
INTVECTOR vnRef ;
|
|
pGeomDB->GetInfo( nSouId, GDB_SI_DUPLIST, vnRef) ;
|
|
if ( find( vnRef.begin(), vnRef.end(), nNewId) == vnRef.end()) {
|
|
vnRef.push_back( nNewId) ;
|
|
pGeomDB->SetInfo( nSouId, GDB_SI_DUPLIST, vnRef) ;
|
|
}
|
|
// Aggiorno info del duplicato
|
|
pGeomDB->SetInfo( nNewId, GDB_SI_DUPSOU, nSouId) ;
|
|
pGeomDB->RemoveInfo( nNewId, GDB_SI_DUPLIST) ;
|
|
// Dichiaro progetto modificato
|
|
ExeSetModified() ;
|
|
|
|
return nNewId ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDuploCount( int nSouId, int& nCount)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Verifico sia un pezzo
|
|
if ( ! IsPartForDuplo( pGeomDB, nSouId))
|
|
return false ;
|
|
// Recupero info del sorgente
|
|
INTVECTOR vnRef ;
|
|
pGeomDB->GetInfo( nSouId, GDB_SI_DUPLIST, vnRef) ;
|
|
// Conto i reali duplo
|
|
nCount = 0 ;
|
|
for ( int i = 0 ; i < int( vnRef.size()) ; ++ i) {
|
|
if ( ExeIsDuplo( vnRef[i]))
|
|
++ nCount ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDuploList( int nSouId, INTVECTOR& vnRef)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Verifico sia un pezzo
|
|
if ( ! IsPartForDuplo( pGeomDB, nSouId))
|
|
return false ;
|
|
// Recupero info del sorgente
|
|
pGeomDB->GetInfo( nSouId, GDB_SI_DUPLIST, vnRef) ;
|
|
// Elimino duplo non più esistenti
|
|
for ( int i = int( vnRef.size()) - 1 ; i >= 0 ; -- i) {
|
|
if ( ! ExeIsDuplo( vnRef[i]))
|
|
vnRef.erase( vnRef.begin() + i) ;
|
|
}
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDuploSetModified( int nSouId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Verifico sia un pezzo
|
|
if ( ! IsPartForDuplo( pGeomDB, nSouId))
|
|
return false ;
|
|
// Verifico ci siano dei duplicati che dipendono dal pezzo
|
|
if ( ! pGeomDB->ExistsInfo( nSouId, GDB_SI_DUPLIST))
|
|
return true ;
|
|
// Imposto il flag di modificato
|
|
if ( ! pGeomDB->SetInfo( nSouId, GDB_SI_DUPMODIF, true))
|
|
return false ;
|
|
// Dichiaro progetto modificato
|
|
ExeSetModified() ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDuploGetModified( int nSouId, bool& bModif)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Verifico sia un pezzo
|
|
if ( ! IsPartForDuplo( pGeomDB, nSouId))
|
|
return false ;
|
|
// recupero il flag di modificato
|
|
if ( ! pGeomDB->GetInfo( nSouId, GDB_SI_DUPMODIF, bModif))
|
|
bModif = false ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDuploSetLocked( int nDupId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Verifico sia un duplo
|
|
if ( ! ExeIsDuplo( nDupId))
|
|
return false ;
|
|
// Imposto il flag di bloccato
|
|
if ( ! pGeomDB->SetInfo( nDupId, GDB_SI_DUPLOCKED, true))
|
|
return false ;
|
|
// Dichiaro progetto modificato
|
|
ExeSetModified() ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDuploResetLocked( int nDupId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Verifico sia nel gruppo base dei duplicati o scambiato con un gruppo da esso
|
|
int nDuploBaseId = GetDuploBase( pGeomDB) ;
|
|
if ( nDuploBaseId == GDB_ID_NULL)
|
|
return false ;
|
|
int nDBaseId = GDB_ID_NULL ;
|
|
if ( pGeomDB->GetParentId( nDupId) != nDuploBaseId) {
|
|
if ( ! pGeomDB->GetInfo( nDupId, GDB_SI_BASE, nDBaseId) ||
|
|
pGeomDB->GetParentId( nDBaseId) != nDuploBaseId)
|
|
return false ;
|
|
}
|
|
// Verifico abbia un sorgente
|
|
int nOrigId ;
|
|
if ( ! pGeomDB->GetInfo( nDupId, GDB_SI_DUPSOU, nOrigId) || pGeomDB->GetGdbType( nOrigId) != GDB_TY_GROUP)
|
|
return false ;
|
|
// Verifico bloccaggio
|
|
bool bLocked ;
|
|
if ( ! pGeomDB->GetInfo( nDupId, GDB_SI_DUPLOCKED, bLocked))
|
|
bLocked = false ;
|
|
pGeomDB->RemoveInfo( nDupId, GDB_SI_DUPLOCKED) ;
|
|
if ( ! bLocked)
|
|
return true ;
|
|
// Verifico necessità di aggiornamento
|
|
bool bToUpdate ;
|
|
if ( ! pGeomDB->GetInfo( nDupId, GDB_SI_DUPTOUPDATE, bToUpdate))
|
|
bToUpdate = false ;
|
|
pGeomDB->RemoveInfo( nDupId, GDB_SI_DUPTOUPDATE) ;
|
|
if ( ! bToUpdate) {
|
|
// Dichiaro progetto modificato
|
|
ExeSetModified() ;
|
|
return true ;
|
|
}
|
|
// Eseguo aggiornamento
|
|
int nDStat = GDB_ST_ON ;
|
|
if ( nDBaseId != GDB_ID_NULL) {
|
|
pGeomDB->GetStatus( nDupId, nDStat) ;
|
|
pGeomDB->GroupSwap( nDupId, nDBaseId, true, true) ;
|
|
}
|
|
// recupero il riferimento del vecchio duplo
|
|
Frame3d frCopy ;
|
|
pGeomDB->GetGroupFrame( nDupId, frCopy) ;
|
|
// aggiorno
|
|
pGeomDB->Erase( nDupId) ;
|
|
int nNewId = pGeomDB->Copy( nOrigId, nDupId, nDuploBaseId) ;
|
|
if ( nNewId == GDB_ID_NULL)
|
|
return false ;
|
|
// riapplico il riferimento vecchio
|
|
*pGeomDB->GetGroupFrame( nNewId) = frCopy ;
|
|
// sistemo le info
|
|
pGeomDB->SetInfo( nNewId, GDB_SI_DUPSOU, nOrigId) ;
|
|
pGeomDB->RemoveInfo( nNewId, GDB_SI_DUPLIST) ;
|
|
pGeomDB->RemoveInfo( nNewId, GDB_SI_DUPMODIF) ;
|
|
// Se necessario rieseguo swap al contrario
|
|
if ( nDBaseId != GDB_ID_NULL) {
|
|
pGeomDB->SetStatus( nNewId, nDStat) ;
|
|
pGeomDB->GroupSwap( nNewId, nDBaseId, true, true) ;
|
|
}
|
|
// Dichiaro progetto modificato
|
|
ExeSetModified() ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDuploGetLocked( int nDupId, bool& bLocked)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Verifico sia un duplo
|
|
if ( ! ExeIsDuplo( nDupId))
|
|
return false ;
|
|
// Recupero il flag di bloccato
|
|
if ( ! pGeomDB->GetInfo( nDupId, GDB_SI_DUPLOCKED, bLocked))
|
|
bLocked = false ;
|
|
return true ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeDuploUpdate( int nSouId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Verifico sia un pezzo
|
|
if ( ! IsPartForDuplo( pGeomDB, nSouId))
|
|
return false ;
|
|
// Verifico se modificato da ultimo update
|
|
bool bModif = false ;
|
|
pGeomDB->GetInfo( nSouId, GDB_SI_DUPMODIF, bModif) ;
|
|
if ( ! bModif)
|
|
return true ;
|
|
// Recupero il gruppo base dei duplicati
|
|
int nDuploBaseId = GetDuploBase( pGeomDB) ;
|
|
if ( nDuploBaseId == GDB_ID_NULL)
|
|
return false ;
|
|
// recupero le copie
|
|
INTVECTOR vnRef ;
|
|
pGeomDB->GetInfo( nSouId, GDB_SI_DUPLIST, vnRef) ;
|
|
// verifico siano aggiornabili
|
|
bool bAllOk = true ;
|
|
for ( int nCopyId : vnRef) {
|
|
if ( pGeomDB->GetParentId( nCopyId) != nDuploBaseId)
|
|
bAllOk = false ;
|
|
}
|
|
if ( ! bAllOk)
|
|
return false ;
|
|
// eseguo gli aggiornamenti
|
|
for ( int nCopyId : vnRef) {
|
|
// se bloccato, non eseguo aggiornamento
|
|
bool bLocked ;
|
|
if ( pGeomDB->GetInfo( nCopyId, GDB_SI_DUPLOCKED, bLocked) && bLocked) {
|
|
pGeomDB->SetInfo( nCopyId, GDB_SI_DUPTOUPDATE, true) ;
|
|
continue ;
|
|
}
|
|
// recupero il riferimento del vecchio duplo
|
|
Frame3d frCopy ;
|
|
pGeomDB->GetGroupFrame( nCopyId, frCopy) ;
|
|
// aggiorno
|
|
pGeomDB->Erase( nCopyId) ;
|
|
int nNewId = pGeomDB->Copy( nSouId, nCopyId, nDuploBaseId) ;
|
|
if ( nNewId == GDB_ID_NULL) {
|
|
bAllOk = false ;
|
|
continue ;
|
|
}
|
|
// riapplico il riferimento vecchio
|
|
*pGeomDB->GetGroupFrame( nNewId) = frCopy ;
|
|
// sistemo le info
|
|
pGeomDB->SetInfo( nNewId, GDB_SI_DUPSOU, nSouId) ;
|
|
pGeomDB->RemoveInfo( nNewId, GDB_SI_DUPLIST) ;
|
|
pGeomDB->RemoveInfo( nNewId, GDB_SI_DUPMODIF) ;
|
|
}
|
|
// reset flag di modificato
|
|
pGeomDB->RemoveInfo( nSouId, GDB_SI_DUPMODIF) ;
|
|
// Dichiaro progetto modificato
|
|
ExeSetModified() ;
|
|
return bAllOk ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeIsDuplo( int nDupId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Recupero il gruppo base dei duplicati
|
|
int nDuploBaseId = GetDuploBase( pGeomDB) ;
|
|
if ( nDuploBaseId == GDB_ID_NULL)
|
|
return false ;
|
|
// Verifico sia un duplicato (gruppo sotto quello dei duplicati con riferimento a originale)
|
|
int nBaseId ;
|
|
if ( pGeomDB->GetGdbType( nDupId) == GDB_TY_GROUP &&
|
|
( pGeomDB->GetParentId( nDupId) == nDuploBaseId ||
|
|
( pGeomDB->GetInfo( nDupId, GDB_SI_BASE, nBaseId) && pGeomDB->GetParentId( nBaseId) == nDuploBaseId)) &&
|
|
pGeomDB->ExistsInfo( nDupId, GDB_SI_DUPSOU))
|
|
return true ;
|
|
else
|
|
return false ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int
|
|
ExeDuploGetOriginal( int nDupId)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, GDB_ID_NULL)
|
|
// Recupero il gruppo base dei duplicati
|
|
int nDuploBaseId = GetDuploBase( pGeomDB) ;
|
|
if ( nDuploBaseId == GDB_ID_NULL)
|
|
return GDB_ID_NULL ;
|
|
// Verifico sia un duplicato (gruppo sotto quello dei duplicati con riferimento a originale)
|
|
if ( pGeomDB->GetGdbType( nDupId) != GDB_TY_GROUP ||
|
|
pGeomDB->GetParentId( nDupId) != nDuploBaseId ||
|
|
! pGeomDB->ExistsInfo( nDupId, GDB_SI_DUPSOU))
|
|
return GDB_ID_NULL ;
|
|
// Recupero l'indice dell'originale
|
|
int nOrigId = GDB_ID_NULL ;
|
|
pGeomDB->GetInfo( nDupId, GDB_SI_DUPSOU, nOrigId) ;
|
|
return nOrigId ;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool
|
|
ExeInsertDuplo( int nInsGrp)
|
|
{
|
|
IGeomDB* pGeomDB = GetCurrGeomDB() ;
|
|
VERIFY_GEOMDB( pGeomDB, false)
|
|
// Cerco il gruppo dei duplicati sotto il gruppo di inserimento
|
|
int nInsDplId = pGeomDB->GetFirstNameInGroup( nInsGrp, DUPLO_BASE) ;
|
|
if ( nInsDplId == GDB_ID_NULL)
|
|
return true ;
|
|
// Recupero il gruppo base dei duplicati
|
|
int nDuploBaseId = GetDuploBase( pGeomDB, true) ;
|
|
if ( nDuploBaseId == GDB_ID_NULL)
|
|
return false ;
|
|
// Sistemo i duplicati
|
|
int nId = pGeomDB->GetFirstInGroup( nInsDplId) ;
|
|
while ( nId != GDB_ID_NULL) {
|
|
int nNextId = pGeomDB->GetNext( nId) ;
|
|
int nSouId ;
|
|
if ( pGeomDB->GetInfo( nId, GDB_SI_DUPSOU, nSouId) && ExeIsPart( nSouId)) {
|
|
pGeomDB->Relocate( nId, nDuploBaseId) ;
|
|
}
|
|
else
|
|
pGeomDB->Erase( nId) ;
|
|
nId = nNextId ;
|
|
}
|
|
// Rimuovo il gruppo dei duplicati di inserimento
|
|
pGeomDB->Erase( nInsDplId) ;
|
|
|
|
return true ;
|
|
}
|