Egalware/TestEGr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fb6ae8f16490244ad20a4e74baab9c456750abc0
TestEGr/TestEGrDlg.cpp
T
Dario Sassi 2c565fe62a TestEGr 2.1a2 : 
- ricompilazione con VS2017
- primo utilizzo di EgtInterface.
2019-01-19 17:10:33 +00:00

1501 lines
48 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2013-2014
//----------------------------------------------------------------------------
// File : TestEGrDlg.cpp Data : 29.01.14 Versione : 1.5a1
// Contenuto : Implementazione della classe gestione dialogo principale.
//
//
//
// Modifiche : 29.01.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "TestEGr.h"
#include "TestEGrDlg.h"
#include "TestEGrUtils.h"
#include "resource.h"
#include "/EgtDev/Include/EgtIniFile.h"
#include "/EgtDev/Include/EgtILogger.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include "/EgtDev/Include/EgtPointerOwner.h"
#include "/EgtDev/Include/EGnCmdParser.h"
#include "/EgtDev/Include/EGkGeomDB.h"
#include "/EgtDev/Include/EGkGdbExecutor.h"
#include "/EgtDev/Include/EExExcExecutor.h"
#include "/EgtDev/Include/EGrScene.h"
#include "/EgtDev/Include/EGrSceExecutor.h"
#include "/EgtDev/Include/EExImportCnc.h"
#include "/EgtDev/Include/EExImportDxf.h"
#include "/EgtDev/Include/EExImportStl.h"
#include "/EgtDev/Include/EExImportBtl.h"
#include "/EgtDev/Include/EExExportDxf.h"
#include "/EgtDev/Include/EExExportStl.h"
using namespace std ;
//----------------------------------------------------------------------------
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//----------------------------------------------------------------------------
// CAboutDlg dialog used for App About
//----------------------------------------------------------------------------
class CAboutDlg : public CDialog
{
public :
CAboutDlg( CWnd* pParent) ;
protected :
BOOL OnInitDialog( void) ;
DECLARE_MESSAGE_MAP()
} ;
//----------------------------------------------------------------------------
CAboutDlg::CAboutDlg( CWnd* pParent) : CDialog( IDD_ABOUTBOX, pParent)
{
}
//----------------------------------------------------------------------------
BOOL
CAboutDlg::OnInitDialog( void)
{
CDialog::OnInitDialog() ;
GetDlgItem( IDC_EXEVER)->SetWindowText( stringtoW( GetExeNameVer())) ;
string sInfo ;
GetSceneInfo( sInfo) ;
ReplaceString( sInfo, "\n", "\r\n") ;
sInfo += "\r\n" ;
GetDlgItem( IDC_EXEINFO)->SetWindowText( stringtoW( sInfo)) ;
return TRUE ;
}
BEGIN_MESSAGE_MAP( CAboutDlg, CDialog)
END_MESSAGE_MAP()
//----------------------------------------------------------------------------
// CTestEGrDlg dialog
//----------------------------------------------------------------------------
CTestEGrDlg::CTestEGrDlg( const std::string& sFileToOpen, ILogger* pLogGen, ILogger* pLogCmd, CWnd* pParent)
:CDialog( IDD_TESTEGR_DIALOG, pParent)
{
m_hIcon = AfxGetApp()->LoadIcon( IDR_MAINFRAME) ;
// eventuale file da caricare all'avvio
m_sFileToOpen = sFileToOpen ;
// memorizzo i puntatori ai logger generale e dei comandi
m_pLogGen = pLogGen ;
m_pLogCmd = pLogCmd ;
// inizializzazioni varie
m_pGeomDB = nullptr ;
m_pCmdParser = nullptr ;
m_pImgList = nullptr ;
m_nOldIdTree = GDB_ID_NULL ;
m_bModified = false ;
}
//----------------------------------------------------------------------------
CTestEGrDlg::~CTestEGrDlg( void)
{
// ripristino ultima entità selezionata sull'albero delle entità
RevertOldIdInTree() ;
// cancello esecutore di comandi
if ( m_pCmdParser != nullptr)
delete m_pCmdParser ;
m_pCmdParser = nullptr ;
// cancello GeomDB
if ( m_pGeomDB != nullptr)
delete m_pGeomDB ;
m_pGeomDB = nullptr ;
// cancello ImgList
if ( m_pImgList != nullptr)
delete m_pImgList ;
m_pImgList = nullptr ;
}
//----------------------------------------------------------------------------
BEGIN_MESSAGE_MAP( CTestEGrDlg, CDialog)
ON_WM_SYSCOMMAND()
ON_WM_PAINT()
ON_WM_QUERYDRAGICON()
ON_WM_SIZE()
ON_WM_CLOSE()
ON_BN_CLICKED( IDC_NEW, OnFileNew)
ON_BN_CLICKED( IDC_OPEN, OnFileOpen)
ON_BN_CLICKED( IDC_SAVE, OnFileSave)
ON_BN_CLICKED( IDC_IMPORT, OnFileImport)
ON_BN_CLICKED( IDC_EXPORT, OnFileExport)
ON_BN_CLICKED( IDC_EXEC, OnFileExec)
ON_CONTROL_RANGE( BN_CLICKED, IDC_WIREFRAME, IDC_SHADING, OnShowMode)
ON_BN_CLICKED( IDC_SHOWCURVEDIR, OnShowCurveDir)
ON_BN_CLICKED( IDC_ANALYZE, OnAnalyze)
ON_BN_CLICKED( IDC_GETDIST, OnGetDistance)
ON_CONTROL_RANGE( BN_CLICKED, IDC_ZOOM_ALL, IDC_ZOOM_OUT, OnZoom)
ON_CONTROL_RANGE( BN_CLICKED, IDC_VIEW_TOP, IDC_VIEW_ISO, OnView)
ON_BN_CLICKED( IDC_CLOSE, OnClose)
ON_NOTIFY( TVN_SELCHANGED, IDC_TREE, OnTreeSelChanged)
ON_NOTIFY( NM_DBLCLK, IDC_TREE, OnTreeDoubleClick)
END_MESSAGE_MAP()
//----------------------------------------------------------------------------
BOOL
CTestEGrDlg::OnInitDialog( void)
{
CDialog::OnInitDialog() ;
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX) ;
ASSERT(IDM_ABOUTBOX < 0xF000) ;
CMenu* pSysMenu = GetSystemMenu( FALSE) ;
if ( pSysMenu != NULL) {
BOOL bNameValid ;
CString strAboutMenu ;
bNameValid = strAboutMenu.LoadString( IDS_ABOUTBOX) ;
ASSERT( bNameValid) ;
if ( ! strAboutMenu.IsEmpty()) {
pSysMenu->AppendMenu( MF_SEPARATOR) ;
pSysMenu->AppendMenu( MF_STRING, IDM_ABOUTBOX, strAboutMenu) ;
}
}
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon( m_hIcon, TRUE) ; // Set big icon
SetIcon( m_hIcon, FALSE) ; // Set small icon
// salvo le dimensioni del client
CRect rectClient ;
GetClientRect( &rectClient) ;
m_nPrevCx = rectClient.right ;
m_nPrevCy = rectClient.bottom ;
// salvo le dimensioni della barra di destra e di quella in basso
CRect rectView ;
GetDlgItem( IDC_SCENE)->GetWindowRect( rectView) ;
ScreenToClient( &rectView) ;
m_nLeftBarW = rectView.left - rectClient.left ;
m_nRightBarW = rectClient.right - rectView.right ;
m_nBottomBarH = rectClient.bottom - rectView.bottom ;
// creo il DB geometrico
m_pGeomDB = CreateGeomDB() ;
if ( m_pGeomDB == nullptr)
LOG_ERROR( m_pLogGen, "Error in CreateGeomDB")
// inizializzo il DB geometrico
PrepareGeomDB() ;
// creo la vista per la scena
if ( ! m_View.Create( this, IDC_SCENE))
LOG_ERROR( m_pLogGen, "Error in CreateSceneView")
// recupero i parametri della scena
int nDriver = GetPrivateProfileInt( "OpenGL", "Driver", 2, AfxGetApp()->m_pszProfileName) ;
bool b2Buff = ( GetPrivateProfileInt( "OpenGL", "DoubleBuffer", 1, AfxGetApp()->m_pszProfileName) == 1) ;
int nColorBits = GetPrivateProfileInt( "OpenGL", "ColorBits", 16, AfxGetApp()->m_pszProfileName) ;
int nDepthBits = GetPrivateProfileInt( "OpenGL", "DepthBits", 16, AfxGetApp()->m_pszProfileName) ;
// creazione della scena
if ( ! m_View.StartScene( nDriver, b2Buff, nColorBits, nDepthBits))
LOG_ERROR( m_pLogGen, "Error in StartScene")
// recupero i colori dello sfondo e li imposto
if ( m_View.GetScene() != nullptr) {
Color ColorTop( 186, 203, 226) ;
GetIniColor( "Scene", "BackTop", ColorTop) ;
Color ColorBottom( 102, 102, 102) ;
GetIniColor( "Scene", "BackBottom", ColorBottom) ;
m_View.GetScene()->SetBackground( ColorTop, ColorBottom) ;
}
// recupero il tipo di visualizzazione e lo imposto
if ( m_View.GetScene() != nullptr) {
int nShMode = GetPrivateProfileInt( "Scene", "ShowMode", 0, AfxGetApp()->m_pszProfileName) ;
m_View.GetScene()->SetShowMode( nShMode) ;
UpdateShowModeButtons() ;
}
// recupero lo stato di visualizzazione direzione curve
if ( m_View.GetScene() != nullptr) {
bool bCrvDir = ( GetPrivateProfileInt( "Scene", "CurveDir", 0, AfxGetApp()->m_pszProfileName) != 0) ;
m_View.GetScene()->SetShowCurveDirection( bCrvDir) ;
UpdateShowCurveDir() ;
}
// recupero gli angoli di vista e li imposto
if ( m_View.GetScene() != nullptr) {
double dAngVdeg = 0, dAngOdeg = 0 ;
GetViewAngles( "Scene", "View", dAngVdeg, dAngOdeg) ;
m_View.GetScene()->SetCamera( dAngVdeg, dAngOdeg, 0) ;
UpdateViewButtons() ;
}
// recupero gli attributi della linea di distanza e del rettangolo per ZoomWin e li imposto
if ( m_View.GetScene() != nullptr) {
Color colDstL( 0, 0, 0) ;
GetIniColor( "Scene", "DistLine", colDstL) ;
m_View.GetScene()->SetGeoLineAttribs( colDstL) ;
bool bOutline = true ;
Color colRect( 0, 0, 0) ;
GetIniZoomWinAttrib( "Scene", "ZoomWin", bOutline, colRect) ;
m_View.GetScene()->SetWinRectAttribs( bOutline, colRect) ;
}
// recupero il colore di marcatura e lo imposto
if ( m_View.GetScene() != nullptr) {
Color colMark( 192, 192, 0) ;
GetIniColor( "Scene", "Mark", colMark) ;
m_View.GetScene()->SetMark( colMark) ;
}
// imposto il DB geometrico
if ( m_View.GetScene() != nullptr)
m_View.GetScene()->Init( m_pGeomDB) ;
// log con info sulla scena
string sSceneInfo ;
m_View.GetSceneInfo( sSceneInfo) ;
LOG_INFO( m_pLogGen, sSceneInfo.c_str())
// recupero il posizionamento della finestra del dialogo
WINDOWPLACEMENT winPlace ;
if ( GetIniWinPlace( "General", "WinPlace", winPlace))
SetWindowPlacement( &winPlace) ;
// preparo l'esecutore
PrepareExecutor() ;
// collego l'oggetto al control
m_Cmd.SubclassDlgItem( IDC_COMMAND, this) ;
// preparo il Tree
PrepareTree() ;
// eventuale apertura o esecuzione di file all'avvio
if ( ! m_sFileToOpen.empty()) {
// imposto cursore attesa
CWaitCursor wait ;
// ricavo l'estensione
string sDummy ;
string sExt ;
SplitLast( m_sFileToOpen, ".", sDummy, sExt) ;
ToUpper( sExt) ;
// apro il file
if ( sExt == "NGE" || sExt == "NFE") {
if ( ! FileOpen( m_sFileToOpen))
AfxMessageBox( L"Error loading file (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
// importo CNC o DXF o STL
else if ( sExt == "CNC" || sExt == "DXF" || sExt == "STL") {
if ( ! FileImport( m_sFileToOpen))
AfxMessageBox( L"Error importing file (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
// eseguo lo script
else if ( sExt == "TSC") {
if ( ! FileExec( m_sFileToOpen))
AfxMessageBox( L"Error executing file (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
// errore
else
AfxMessageBox( L"File extension not recognized", MB_ICONSTOP|MB_OK) ;
}
return TRUE ; // return TRUE unless you set the focus to a control
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::GetViewAngles( const char* szSection, const char* szKey, double& dAngVdeg, double& dAngOdeg)
{
string sTmp = GetPrivateProfileStringUtf8( szSection, szKey, "", AfxGetApp()->m_pszProfileName) ;
if ( ! sTmp.empty()) {
STRVECTOR vsParams ;
Tokenize( sTmp, ",", vsParams) ;
if ( vsParams.size() >= 2) {
FromString( vsParams[0], dAngVdeg) ;
FromString( vsParams[1], dAngOdeg) ;
return true ;
}
}
return false ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::GetIniColor( const char* szSection, const char* szKey, Color& cCol)
{
string sTmp = GetPrivateProfileStringUtf8( szSection, szKey, "", AfxGetApp()->m_pszProfileName) ;
if ( ! sTmp.empty()) {
STRVECTOR vsParams ;
Tokenize( sTmp, ",", vsParams) ;
if ( vsParams.size() >= 3) {
int nRed ;
FromString( vsParams[0], nRed) ;
int nGreen ;
FromString( vsParams[1], nGreen) ;
int nBlue ;
FromString( vsParams[2], nBlue) ;
cCol.Set( nRed, nGreen, nBlue) ;
return true ;
}
}
return false ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::GetIniZoomWinAttrib( const char* szSection, const char* szKey,
bool& bOutline, Color& colRect)
{
string sTmp = GetPrivateProfileStringUtf8( szSection, szKey, "", AfxGetApp()->m_pszProfileName) ;
if ( ! sTmp.empty()) {
STRVECTOR vsParams ;
Tokenize( sTmp, ",", vsParams) ;
if ( vsParams.size() >= 5) {
FromString( vsParams[0], bOutline) ;
int nRed ;
FromString( vsParams[1], nRed) ;
int nGreen ;
FromString( vsParams[2], nGreen) ;
int nBlue ;
FromString( vsParams[3], nBlue) ;
int nAlpha ;
FromString( vsParams[4], nAlpha) ;
colRect.Set( nRed, nGreen, nBlue, nAlpha) ;
return true ;
}
}
return false ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::GetIniWinPlace( const char* szSection, const char* szKey, WINDOWPLACEMENT& winPlace)
{
string sTmp = GetPrivateProfileStringUtf8( szSection, szKey, "", AfxGetApp()->m_pszProfileName) ;
if ( ! sTmp.empty()) {
STRVECTOR vsParams ;
Tokenize( sTmp, ",", vsParams) ;
if ( vsParams.size() >= 5) {
int nVal ;
winPlace.length = sizeof( WINDOWPLACEMENT) ;
winPlace.flags = 0 ;
FromString( vsParams[0], nVal) ;
winPlace.showCmd = (( nVal != 1) ? SW_SHOW : SW_SHOWMAXIMIZED) ;
FromString( vsParams[1], nVal) ;
winPlace.rcNormalPosition.left = nVal ;
FromString( vsParams[2], nVal) ;
winPlace.rcNormalPosition.top = nVal ;
FromString( vsParams[3], nVal) ;
winPlace.rcNormalPosition.right = nVal ;
FromString( vsParams[4], nVal) ;
winPlace.rcNormalPosition.bottom = nVal ;
return true ;
}
}
return false ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnSysCommand( UINT nID, LPARAM lParam)
{
if ( (nID & 0xFFF0) == IDM_ABOUTBOX) {
CAboutDlg dlgAbout( this) ;
dlgAbout.DoModal() ;
}
else {
CDialog::OnSysCommand( nID, lParam) ;
}
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnPaint( void)
{
if ( IsIconic()) {
CPaintDC dc( this) ; // device context for painting
SendMessage( WM_ICONERASEBKGND, reinterpret_cast<WPARAM>( dc.GetSafeHdc()), 0) ;
// Center icon in client rectangle
int cxIcon = GetSystemMetrics( SM_CXICON) ;
int cyIcon = GetSystemMetrics( SM_CYICON) ;
CRect rect ;
GetClientRect( &rect) ;
int x = ( rect.Width() - cxIcon + 1) / 2 ;
int y = ( rect.Height() - cyIcon + 1) / 2 ;
// Draw the icon
dc.DrawIcon( x, y, m_hIcon) ;
}
else {
// ridisegno dialogo
CDialog::OnPaint() ;
}
}
//----------------------------------------------------------------------------
HCURSOR
CTestEGrDlg::OnQueryDragIcon( void)
{
return static_cast<HCURSOR>( m_hIcon) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnSize( UINT nType, int cx, int cy)
{
CDialog::OnSize( nType, cx, cy) ;
// se ridotta a icona non si fa alcunché
if ( cx <= 0 || cy <= 0 || nType == SIZE_MINIMIZED)
return ;
// se cambiata dimensione
if ( nType == SIZE_RESTORED || nType == SIZE_MAXIMIZED) {
// spostamento bottoni
MoveDlgItem( IDC_NEW, IP_TR, cx, cy) ;
MoveDlgItem( IDC_OPEN, IP_TR, cx, cy) ;
MoveDlgItem( IDC_SAVE, IP_TR, cx, cy) ;
MoveDlgItem( IDC_EXPORT, IP_TR, cx, cy) ;
MoveDlgItem( IDC_IMPORT, IP_TR, cx, cy) ;
MoveDlgItem( IDC_EXEC, IP_TR, cx, cy) ;
MoveDlgItem( IDC_SEPAR, IP_TR, cx, cy) ;
MoveDlgItem( IDC_WIREFRAME, IP_TR, cx, cy) ;
MoveDlgItem( IDC_HIDDENLINE, IP_TR, cx, cy) ;
MoveDlgItem( IDC_SHADING, IP_TR, cx, cy) ;
MoveDlgItem( IDC_SHOWCURVEDIR, IP_TR, cx, cy) ;
MoveDlgItem( IDC_ANALYZE, IP_TR, cx, cy) ;
MoveDlgItem( IDC_GETDIST, IP_TR, cx, cy) ;
MoveDlgItem( IDC_ZOOM_ALL, IP_TR, cx, cy) ;
MoveDlgItem( IDC_ZOOM_IN, IP_TR, cx, cy) ;
MoveDlgItem( IDC_ZOOM_OUT, IP_TR, cx, cy) ;
MoveDlgItem( IDC_VIEW_TOP, IP_TR, cx, cy) ;
MoveDlgItem( IDC_VIEW_FRONT, IP_TR, cx, cy) ;
MoveDlgItem( IDC_VIEW_BACK, IP_TR, cx, cy) ;
MoveDlgItem( IDC_VIEW_LEFT, IP_TR, cx, cy) ;
MoveDlgItem( IDC_VIEW_RIGHT, IP_TR, cx, cy) ;
MoveDlgItem( IDC_VIEW_ISO, IP_TR, cx, cy) ;
MoveDlgItem( IDC_COMMAND, IP_BR, cx, cy) ;
MoveDlgItem( IDC_CLOSE, IP_BR, cx, cy) ;
// spostamento e adattamento tree e associati
MoveDlgItem( IDC_TREE, IP_TL, cx, cy) ;
MoveDlgItem( IDC_DATA, IP_TL, cx, cy) ;
CRect rectData ;
if ( GetWindowRect( GetDlgItem( IDC_DATA), rectData))
ReshapeDlgItem( IDC_DATA, IR_H, 0, cy - rectData.top - m_nBottomBarH) ;
// spostamento e adattamento barre sotto
MoveDlgItem( IDC_INFO, IP_BL, cx, cy) ;
ReshapeDlgItem( IDC_INFO, IR_W, cx - m_nLeftBarW - m_nRightBarW, 0) ;
MoveDlgItem( IDC_COORD, IP_BR, cx, cy) ;
// adattamento vista della scena
CRect rectView ;
if ( GetWindowRect( &m_View, rectView))
m_View.Resize( m_nLeftBarW, rectView.top,
cx - m_nLeftBarW - m_nRightBarW, cy - m_nBottomBarH - rectView.top) ;
// salvo la nuova dimensione
m_nPrevCx = cx ;
m_nPrevCy = cy ;
// lancio ridisegno
RedrawWindow( NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW) ;
}
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::MoveDlgItem( int nID, int nPos, int cx, int cy)
{
CWnd* pBtn ;
if ( ( pBtn = GetDlgItem( nID)) == nullptr)
return false ;
CRect rect ;
pBtn->GetWindowRect( rect) ;
ScreenToClient( &rect) ;
int nX ;
int nY ;
switch ( nPos) {
case IP_TR :
nX = rect.left + cx - m_nPrevCx ;
nY = rect.top ;
break ;
default : // IP_TL
nX = rect.left ;
nY = rect.top ;
break ;
case IP_BR :
nX = rect.left + cx - m_nPrevCx ;
nY = rect.top + cy - m_nPrevCy ;
break ;
case IP_BL :
nX = rect.left ;
nY = rect.top + cy - m_nPrevCy ;
break ;
}
return ( pBtn->SetWindowPos( NULL, nX, nY, 0, 0, SWP_NOSIZE | SWP_NOZORDER) != 0) ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::ReshapeDlgItem( int nID, int nFlag, int nW, int nH)
{
CWnd* pBtn ;
if ( ( pBtn = GetDlgItem( nID)) == nullptr)
return false ;
CRect rect ;
pBtn->GetWindowRect( rect) ;
ScreenToClient( &rect) ;
int nWu ;
int nHu ;
switch ( nFlag) {
case IR_W :
nWu = nW ;
nHu = rect.Height() ;
break ;
case IR_H :
nWu = rect.Width() ;
nHu = nH ;
break ;
default : // IR_WH
nWu = nW ;
nHu = nH ;
break ;
}
return ( pBtn->SetWindowPos( NULL, 0, 0, nWu, nHu, SWP_NOMOVE | SWP_NOZORDER) != 0) ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::GetWindowRect( CWnd* pWnd, CRect& rect)
{
if ( pWnd == nullptr || ! ::IsWindow( pWnd->m_hWnd))
return false ;
pWnd->GetWindowRect( rect) ;
ScreenToClient( &rect) ;
return true ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OutInfo( const string& sOut, bool bLog)
{
CWnd* pWnd = GetDlgItem( IDC_INFO) ;
if ( pWnd != nullptr)
pWnd->SetWindowText( stringtoW( sOut)) ;
if ( bLog)
LOG_INFO( m_pLogGen, sOut.c_str())
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OutData( const string& sOut, bool bLog)
{
CWnd* pWnd = GetDlgItem( IDC_DATA) ;
if ( pWnd != nullptr)
pWnd->SetWindowText( stringtoW( sOut)) ;
if ( bLog)
LOG_INFO( m_pLogGen, sOut.c_str())
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnCancel( void)
{
// Per disabilitare l'uscita sulla pressione di ESC
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnClose( void)
{
// gestisco eventuale file corrente modificato
if ( ! ManageModified())
return ;
// se scena ok
if ( m_View.GetScene() != nullptr) {
// salvo il tipo di visualizzazione
int nShMode = m_View.GetScene()->GetShowMode() ;
WritePrivateProfileInt( "Scene", "ShowMode", nShMode, AfxGetApp()->m_pszProfileName) ;
// salvo stato visualizzazione direzione curve
bool bCrvDir = m_View.GetScene()->GetShowCurveDirection() ;
WritePrivateProfileInt( "Scene", "CurveDir", bCrvDir, AfxGetApp()->m_pszProfileName) ;
// salvo gli angoli di vista
double dAngVdeg, dAngOdeg ;
m_View.GetScene()->GetCamera( &dAngVdeg, &dAngOdeg) ;
string sOut = ToString( dAngVdeg, 1) + "," + ToString( dAngOdeg, 1) ;
WritePrivateProfileStringUtf8( "Scene", "View", sOut.c_str(), AfxGetApp()->m_pszProfileName) ;
}
// salvo lo stato della finestra del dialogo
WINDOWPLACEMENT winPlace ;
if ( GetWindowPlacement( &winPlace)) {
string sOut ;
sOut = ToString( ( winPlace.showCmd == SW_SHOWMAXIMIZED ? 1 : 0)) + "," +
ToString( winPlace.rcNormalPosition.left) + "," +
ToString( winPlace.rcNormalPosition.top) + "," +
ToString( winPlace.rcNormalPosition.right) + "," +
ToString( winPlace.rcNormalPosition.bottom) ;
WritePrivateProfileStringUtf8( "General", "WinPlace", sOut.c_str(), AfxGetApp()->m_pszProfileName) ;
}
m_View.Destroy() ;
EndDialog( IDCLOSE) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnFileNew( void)
{
// gestisco eventuale file corrente modificato
if ( ! ManageModified())
return ;
// reinizializzo il progetto
if ( ! FileNew())
AfxMessageBox( L"Error on file new (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnFileOpen( void)
{
// gestisco eventuale file corrente modificato
if ( ! ManageModified())
return ;
// visualizzo il dialogo di scelta file
CFileDialog dlg( TRUE, L"*.Nge", NULL,
OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY|OFN_NOCHANGEDIR,
L"New geometry EgalTech (*.Nge)|*.Nge|New font EgalTech (*.Nfe)|*.Nfe||", NULL, 0, FALSE) ;
// imposto il direttorio iniziale
wstring wsDir = stringtoW( GetPrivateProfileStringUtf8( "General", "LastNgeDir", "", AfxGetApp()->m_pszProfileName)) ;
if ( ! wsDir.empty())
dlg.m_ofn.lpstrInitialDir = wsDir.c_str() ;
// lancio il dialogo di scelta file
if ( dlg.DoModal() != IDOK)
return ;
// recupero la path del file
string sFilePath = WtoA( dlg.GetPathName()) ;
if ( sFilePath.empty())
return ;
// imposto cursore attesa
CWaitCursor wait ;
// divido in nome e direttorio e salvo quest'ultimo
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
if ( ! sFileDir.empty())
WritePrivateProfileStringUtf8( "General", "LastNgeDir", sFileDir.c_str(), AfxGetApp()->m_pszProfileName) ;
// carico il file
if ( ! FileOpen( sFilePath))
AfxMessageBox( L"Error loading file (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnFileSave( void)
{
// verifico e sistemo l'estensione
string sFileTitle ;
string sFileExt ;
SplitLast( m_sFileName, ".", sFileTitle, sFileExt) ;
string sTemp = sFileExt ;
ToUpper( sTemp) ;
if ( sTemp != "NGE" && sTemp != "NFE")
m_sFileName = sFileTitle + ".Nge" ;
// visualizzo il dialogo di scelta file
CFileDialog dlg( FALSE, L"*.Nge", stringtoW( m_sFileName),
OFN_PATHMUSTEXIST|OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_NOCHANGEDIR,
L"New geometry EgalTech (*.Nge)|*.Nge|New font EgalTech (*.Nfe)|*.Nfe||", NULL, 0, FALSE) ;
// imposto il direttorio iniziale
wstring wsDir = stringtoW( GetPrivateProfileStringUtf8( "General", "LastNgeDir", "", AfxGetApp()->m_pszProfileName)) ;
if ( ! wsDir.empty())
dlg.m_ofn.lpstrInitialDir = wsDir.c_str() ;
// lancio il dialogo di scelta file
if ( dlg.DoModal() != IDOK)
return ;
// recupero la path del file
string sFilePath = WtoA( dlg.GetPathName()) ;
if ( sFilePath.empty())
return ;
// imposto cursore attesa
CWaitCursor wait ;
// divido in nome e direttorio e salvo quest'ultimo
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
if ( ! sFileDir.empty())
WritePrivateProfileStringUtf8( "General", "LastNgeDir", sFileDir.c_str(), AfxGetApp()->m_pszProfileName) ;
// salvo il file
if ( ! FileSave( sFilePath))
AfxMessageBox( L"Error saving file (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnFileImport( void)
{
// gestisco eventuale file corrente modificato
if ( ! ManageModified())
return ;
// visualizzo il dialogo di scelta file
CFileDialog dlg( TRUE, L"*.*", NULL,
OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY|OFN_NOCHANGEDIR,
L"All Files (*.*)|*.*|"
L"AutoCAD Drawing Exchange (*.dxf) |*.dxf|"
L"Stereolithography (*.stl) |*.stl|"
L"Beam (*.btl) |*.btl|"
L"Part Program (*.cnc) |*.cnc||",
NULL, 0, FALSE) ;
// imposto il direttorio iniziale
wstring wsDir = stringtoW( GetPrivateProfileStringUtf8( "General", "LastImpDir", "", AfxGetApp()->m_pszProfileName)) ;
if ( ! wsDir.empty())
dlg.m_ofn.lpstrInitialDir = wsDir.c_str() ;
// lancio il dialogo di scelta file
if ( dlg.DoModal() != IDOK)
return ;
// recupero la path del file
string sFilePath = WtoA( dlg.GetPathName()) ;
if ( sFilePath.empty())
return ;
// imposto cursore attesa
CWaitCursor wait ;
// divido in nome e direttorio e salvo quest'ultimo
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
if ( ! sFileDir.empty())
WritePrivateProfileStringUtf8( "General", "LastImpDir", sFileDir.c_str(), AfxGetApp()->m_pszProfileName) ;
// carico il file
if ( ! FileImport( sFilePath))
AfxMessageBox( L"Error importing file (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnFileExport( void)
{
// visualizzo il dialogo di scelta file
CFileDialog dlg( FALSE, L"*.*", NULL,
OFN_PATHMUSTEXIST|OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT|OFN_NOCHANGEDIR,
L"All Files (*.*)|*.*|"
L"AutoCAD Drawing Exchange (*.dxf) |*.dxf|"
L"Stereolithography (*.stl) |*.stl||",
NULL, 0, FALSE) ;
// imposto il direttorio iniziale
wstring wsDir = stringtoW( GetPrivateProfileStringUtf8( "General", "LastExpDir", "", AfxGetApp()->m_pszProfileName)) ;
if ( ! wsDir.empty())
dlg.m_ofn.lpstrInitialDir = wsDir.c_str() ;
// lancio il dialogo di scelta file
if ( dlg.DoModal() != IDOK)
return ;
// recupero la path del file
string sFilePath = WtoA( dlg.GetPathName()) ;
if ( sFilePath.empty())
return ;
// imposto cursore attesa
CWaitCursor wait ;
// divido in nome e direttorio e salvo quest'ultimo
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
if ( ! sFileDir.empty())
WritePrivateProfileStringUtf8( "General", "LastExpDir", sFileDir.c_str(), AfxGetApp()->m_pszProfileName) ;
// salvo il file
if ( ! FileExport( sFilePath))
AfxMessageBox( L"Error exporting file (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnFileExec( void)
{
// visualizzo il dialogo di scelta file
CFileDialog dlg( TRUE, L"*.Tsc", NULL,
OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY|OFN_NOCHANGEDIR,
L"Test script EgalTech (*.Tsc) |*.Tsc||", NULL, 0, FALSE) ;
// imposto il direttorio iniziale
wstring wsDir = stringtoW( GetPrivateProfileStringUtf8( "General", "LastTscDir", "", AfxGetApp()->m_pszProfileName)) ;
if ( ! wsDir.empty())
dlg.m_ofn.lpstrInitialDir = wsDir.c_str() ;
// lancio il dialogo di scelta file
if ( dlg.DoModal() != IDOK)
return ;
// recupero la path del file
string sFilePath = WtoA( dlg.GetPathName()) ;
if ( sFilePath.empty())
return ;
// imposto cursore attesa
CWaitCursor wait ;
// divido in nome e direttorio e salvo quest'ultimo
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
if ( ! sFileDir.empty())
WritePrivateProfileStringUtf8( "General", "LastTscDir", sFileDir.c_str(), AfxGetApp()->m_pszProfileName) ;
// eseguo lo script
if ( ! FileExec( sFilePath))
AfxMessageBox( L"Error executing file (look at Log file)", MB_ICONSTOP|MB_OK) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnShowMode( UINT nID)
{
m_View.ShowMode( nID) ;
UpdateShowModeButtons() ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::UpdateShowModeButtons( void)
{
int nSM = m_View.GetScene()->GetShowMode() ;
(( CButton*) GetDlgItem( IDC_WIREFRAME))->SetCheck( ( nSM == SM_WIREFRAME ? BST_CHECKED : BST_UNCHECKED)) ;
(( CButton*) GetDlgItem( IDC_HIDDENLINE))->SetCheck( ( nSM == SM_HIDDENLINE ? BST_CHECKED : BST_UNCHECKED)) ;
(( CButton*) GetDlgItem( IDC_SHADING))->SetCheck( ( nSM == SM_SHADING ? BST_CHECKED : BST_UNCHECKED)) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnShowCurveDir( void)
{
bool bShow = ( (( CButton*) GetDlgItem( IDC_SHOWCURVEDIR))->GetCheck() == BST_CHECKED) ;
m_View.ShowCurveDir( bShow) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnAnalyze( void)
{
m_View.SetAnalyze() ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnGetDistance( void)
{
m_View.SetGetDistance() ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::UpdateShowCurveDir( void)
{
bool bShow = m_View.GetScene()->GetShowCurveDirection() ;
(( CButton*) GetDlgItem( IDC_SHOWCURVEDIR))->SetCheck( ( bShow ? BST_CHECKED : BST_UNCHECKED)) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnZoom( UINT nID)
{
m_View.Zoom( nID) ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::OnView( UINT nID)
{
m_View.View( nID) ;
UpdateViewButtons() ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::UpdateViewButtons( void)
{
int nVw = m_View.GetScene()->GetCameraDir() ;
(( CButton*) GetDlgItem( IDC_VIEW_TOP))->SetCheck( ( nVw == CT_TOP ? BST_CHECKED : BST_UNCHECKED)) ;
(( CButton*) GetDlgItem( IDC_VIEW_FRONT))->SetCheck( ( nVw == CT_FRONT ? BST_CHECKED : BST_UNCHECKED)) ;
(( CButton*) GetDlgItem( IDC_VIEW_BACK))->SetCheck( ( nVw == CT_BACK ? BST_CHECKED : BST_UNCHECKED)) ;
(( CButton*) GetDlgItem( IDC_VIEW_LEFT))->SetCheck( ( nVw == CT_LEFT ? BST_CHECKED : BST_UNCHECKED)) ;
(( CButton*) GetDlgItem( IDC_VIEW_RIGHT))->SetCheck( ( nVw == CT_RIGHT ? BST_CHECKED : BST_UNCHECKED)) ;
(( CButton*) GetDlgItem( IDC_VIEW_ISO))->SetCheck( ( nVw == CT_ISO_SW ? BST_CHECKED : BST_UNCHECKED)) ;
}
//----------------------------------------------------------------------------
BOOL
CTestEGrDlg::PreTranslateMessage( MSG* pMsg)
{
// se messaggio rotella mouse e non settata cattura
if ( pMsg->message == WM_MOUSEWHEEL && GetCapture() == nullptr) {
// invio il messaggio alla finestra del dialogo su cui si trova il mouse
CPoint ptClient = pMsg->pt ;
ScreenToClient( &ptClient) ;
pMsg->hwnd = ::ChildWindowFromPoint( m_hWnd, ptClient) ;
if ( pMsg->hwnd == nullptr)
return 1 ;
}
// passo al gestore di default
return CDialog::PreTranslateMessage( pMsg) ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::PrepareGeomDB( void)
{
if ( m_pGeomDB == nullptr)
return false ;
// pulisco e reinizializzo
m_pGeomDB->Init() ;
// imposto il materiale di default tramite colore
Color colDef( 0, 0, 0) ;
GetIniColor( "GeomDB", "DefaultColor", colDef) ;
m_pGeomDB->SetDefaultMaterial( colDef) ;
return true ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::PrepareExecutor( void)
{
// verifico validità DB geometrico
if ( m_pGeomDB == nullptr) {
LOG_ERROR( m_pLogGen, "GeomDB invalid")
return false ;
}
// eventuale distruzione vecchio esecutore
if ( m_pCmdParser != nullptr)
delete m_pCmdParser ;
m_pCmdParser = nullptr ;
// creo oggetti per esecuzione e ne verifico la validità
PtrOwner<IGdbExecutor> pGdbExec( CreateGdbExecutor()) ;
if ( IsNull( pGdbExec)) {
LOG_ERROR( m_pLogGen, "Error in CreateGdbExecutor")
return false ;
}
PtrOwner<IExcExecutor> pExcExec( CreateExcExecutor()) ;
if ( IsNull( pExcExec)) {
LOG_ERROR( m_pLogGen, "Error in CreateExcExecutor")
return false ;
}
PtrOwner<ISceExecutor> pSceExec( CreateSceExecutor()) ;
if ( IsNull( pSceExec)) {
LOG_ERROR( m_pLogGen, "Error in CreateSceExecutor")
return false ;
}
m_pCmdParser = CreateCmdParser() ;
if ( m_pCmdParser == nullptr) {
LOG_ERROR( m_pLogGen, "Error in CreateCmdParser")
return false ;
}
// inizializzazioni
pGdbExec->SetGeomDB( m_pGeomDB) ;
pExcExec->SetGeomDB( m_pGeomDB) ;
pSceExec->SetScene( m_View.GetScene()) ;
m_pCmdParser->SetExecutor( Release( pGdbExec)) ;
m_pCmdParser->AddExecutor( Release( pExcExec)) ;
m_pCmdParser->AddExecutor( Release( pSceExec)) ;
m_pCmdParser->Init() ;
return true ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::ManageModified( void)
{
// se non modificato, procedo normalmente
if ( ! m_bModified)
return true ;
// chiedo cosa fare
string sMsg ;
sMsg = "Salvare le modifiche" ;
if ( ! m_sFileName.empty())
sMsg += " a " + m_sFileName ;
sMsg += " ?" ;
switch ( AfxMessageBox( stringtoW( sMsg), MB_YESNOCANCEL)) {
case IDYES :
OnFileSave() ;
return ( ! m_bModified) ;
break ;
case IDNO :
return true ;
break ;
default :
return false ;
break ;
}
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::FileNew( void)
{
// verifico validità DB geometrico
if ( m_pGeomDB == nullptr) {
LOG_ERROR( m_pLogGen, "GeomDB invalid")
return false ;
}
// pulisco l'albero delle entità
ClearTree() ;
// reinizializzazione (con pulizia) del DB geometrico
PrepareGeomDB() ;
// visualizzo con zoom all
m_View.Zoom( IDC_ZOOM_ALL) ;
// inserisco il nome del file nel titolo della finestra
m_sFileName.clear() ;
m_bModified = false ;
EmitTitle() ;
// log dei comandi
LOG_INFO( m_pLogCmd, "NEW")
return true ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::FileOpen( const string& sFilePath)
{
// verifico validità DB geometrico
if ( m_pGeomDB == nullptr) {
LOG_ERROR( m_pLogGen, "GeomDB invalid")
return false ;
}
// divido in nome e direttorio
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
// inserisco il nome del file nel titolo della finestra
m_sFileName = sFileName ;
m_bModified = false ;
EmitTitle() ;
// emetto info
string sInfo = "Open File = " + sFilePath ;
LOG_INFO( m_pLogGen, sInfo.c_str())
// pulisco l'albero delle entità
ClearTree() ;
// reinizializzazione (con pulizia) del DB geometrico
PrepareGeomDB() ;
// carico il file
if ( ! m_pGeomDB->Load( sFilePath))
return false ;
// log dei comandi
LOG_INFO( m_pLogCmd, ( "LOAD( " + sFilePath + ")").c_str())
// visualizzo con zoom all
PerformanceCounter Counter ;
Counter.Start() ;
m_View.Zoom( IDC_ZOOM_ALL) ;
Counter.Stop() ;
string sOut = "First ZoomAll time = " + ToString( Counter.GetTime(), 2) + " ms" ;
// emetto info
::OutInfo( sOut) ;
// aggiorno l'albero delle entità
LoadTree() ;
return true ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::FileSave( const string& sFilePath)
{
// verifico validità DB geometrico
if ( m_pGeomDB == nullptr) {
LOG_ERROR( m_pLogGen, "GeomDB invalid")
return false ;
}
// divido in nome e direttorio
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
// inserisco il nome del file nel titolo della finestra
m_sFileName = sFileName ;
m_bModified = false ;
EmitTitle() ;
// emetto info
string sInfo = "Save File = " + sFilePath ;
LOG_INFO( m_pLogGen, sInfo.c_str())
// recupero flag per salvatggio binario
int nSaveType = GetPrivateProfileInt( "GeomDB", "SaveType", 2, AfxGetApp()->m_pszProfileName) ;
// salvo il file
if ( ! m_pGeomDB->Save( GDB_ID_ROOT, sFilePath, nSaveType))
return false ;
// log dei comandi
string sSaveType ;
switch ( nSaveType) {
case 0 : sSaveType = "T" ; break ;
case 1 : sSaveType = "B" ; break ;
case 2 : default : sSaveType = "CT" ; break ;
}
string sSave = "SAVE( " + sFilePath + ", " + sSaveType + ")" ;
LOG_INFO( m_pLogCmd, sSave.c_str())
return true ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::FileImport( const string& sFilePath)
{
// verifico validità DB geometrico
if ( m_pGeomDB == nullptr) {
LOG_ERROR( m_pLogGen, "GeomDB invalid")
return false ;
}
// divido in nome e direttorio
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
// recupero l'estensione
string sFileTitle ;
string sFileExt ;
SplitLast( sFileName, ".", sFileTitle, sFileExt) ;
ToUpper( sFileExt) ;
// verifico che l'estensione sia supportata
if ( sFileExt != "CNC" && sFileExt != "DXF" && sFileExt != "STL" && sFileExt != "BTL") {
// emetto info
string sInfo = "File type (" + sFileExt + ") not recognized" ;
LOG_INFO( m_pLogGen, sInfo.c_str())
return false ;
}
// inserisco il nome del file nel titolo della finestra
m_sFileName = sFileTitle + ".Nge" ;
m_bModified = true ;
EmitTitle() ;
// emetto info
string sInfo = "Import File = " + sFilePath ;
LOG_INFO( m_pLogGen, sInfo.c_str())
// pulisco l'albero delle entità
ClearTree() ;
// reinizializzazione (con pulizia) del DB geometrico
PrepareGeomDB() ;
bool bOk = true ;
// importo il file CNC
if ( sFileExt == "CNC") {
// aggiungo un gruppo pezzo
int nPartId = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
// preparo l'importatore
PtrOwner<IImportCnc> pImpCnc( CreateImportCnc()) ;
if ( IsNull( pImpCnc)) {
LOG_ERROR( m_pLogGen, "Error : CreateImportCnc")
bOk = false ;
}
// eseguo l'importazione
else if ( ! pImpCnc->Import( sFilePath, m_pGeomDB, nPartId)) {
LoadTree() ;
bOk = false ;
}
// log dei comandi
LOG_INFO( m_pLogCmd, "RESET( $P1)")
LOG_INFO( m_pLogCmd, "GR.XY( $P1, $ROOT, ORIG)")
LOG_INFO( m_pLogCmd, ( "IMPORTCNC( " + sFilePath + ", $P1)").c_str())
}
// importo il file DXF
else if ( sFileExt == "DXF") {
// aggiungo un gruppo pezzo
int nPartId = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
// preparo l'importatore
PtrOwner<IImportDxf> pImpDxf( CreateImportDxf()) ;
if ( IsNull( pImpDxf)) {
LOG_ERROR( m_pLogGen, "Error : CreateImportDxf")
bOk = false ;
}
// eseguo l'importazione
else if ( ! pImpDxf->Import( sFilePath, m_pGeomDB, nPartId)) {
LoadTree() ;
bOk = false ;
}
// log dei comandi
LOG_INFO( m_pLogCmd, "RESET( $P1)")
LOG_INFO( m_pLogCmd, "GR.XY( $P1, $ROOT, ORIG)")
LOG_INFO( m_pLogCmd, ( "IMPORTDXF( " + sFilePath + ", $P1)").c_str())
}
// importo il file STL
else if ( sFileExt == "STL") {
// aggiungo un gruppo pezzo e un gruppo layer
int nPartId = m_pGeomDB->AddGroup( GDB_ID_NULL, GDB_ID_ROOT, Frame3d()) ;
int nLayerId = m_pGeomDB->AddGroup( GDB_ID_NULL, nPartId, Frame3d()) ;
// preparo l'importatore
PtrOwner<IImportStl> pImpStl( CreateImportStl()) ;
if ( IsNull( pImpStl)) {
LOG_ERROR( m_pLogGen, "Error : CreateImportStl")
bOk = false ;
}
// eseguo l'importazione
else if ( ! pImpStl->Import( sFilePath, m_pGeomDB, nLayerId)) {
LoadTree() ;
bOk = false ;
}
// log dei comandi
LOG_INFO( m_pLogCmd, "RESET( ($P1, $L1))")
LOG_INFO( m_pLogCmd, "GR.XY( $P1, $ROOT, ORIG)")
LOG_INFO( m_pLogCmd, "GR.XY( $L1, $P1, ORIG)")
LOG_INFO( m_pLogCmd, ( "IMPORTSTL( " + sFilePath + ", $L1)").c_str())
}
// importo il file BTL
else if ( sFileExt == "BTL") {
// preparo l'importatore
PtrOwner<IImportBtl> pImpBtl( CreateImportBtl()) ;
if ( IsNull( pImpBtl)) {
LOG_ERROR( m_pLogGen, "Error : CreateImportBtl")
bOk = false ;
}
// eseguo l'importazione
else if ( ! pImpBtl->Import( sFilePath, m_pGeomDB)) {
LoadTree() ;
bOk = false ;
}
// nessun log dei comandi
}
// visualizzo con zoom all
PerformanceCounter Counter ;
Counter.Start() ;
m_View.Zoom( IDC_ZOOM_ALL) ;
Counter.Stop() ;
string sOut = "First ZoomAll time = " + ToString( Counter.GetTime(), 2) + " ms" ;
// emetto info
::OutInfo( sOut) ;
// aggiorno l'albero delle entità
LoadTree() ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::FileExport( const string& sFilePath)
{
// divido in nome e direttorio
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
// recupero l'estensione
string sFileTitle ;
string sFileExt ;
SplitLast( sFileName, ".", sFileTitle, sFileExt) ;
ToUpper( sFileExt) ;
// verifico che l'estensione sia supportata
if ( sFileExt != "DXF" && sFileExt != "STL") {
// emetto info
string sInfo = "File type (" + sFileExt + ") not recognized" ;
LOG_INFO( m_pLogGen, sInfo.c_str())
return false ;
}
// emetto info
string sInfo = "Export File = " + sFilePath ;
LOG_INFO( m_pLogGen, sInfo.c_str())
// esporto il file DXF
if ( sFileExt == "DXF") {
// preparo l'esportatore
PtrOwner<IExportDxf> pExpDxf( CreateExportDxf()) ;
if ( IsNull( pExpDxf)) {
LOG_ERROR( m_pLogGen, "Error : CreateExportDxf")
return false ;
}
// eseguo l'esportazione
if ( ! pExpDxf->Export( m_pGeomDB, GDB_ID_ROOT, sFilePath)) {
return false ;
}
// log dei comandi
LOG_INFO( m_pLogCmd, ( "EXPORTDXF( 0, " + sFilePath + ")").c_str())
}
// esporto il file STL
else if ( sFileExt == "STL") {
// preparo l'esportatore
PtrOwner<IExportStl> pExpStl( CreateExportStl()) ;
if ( IsNull( pExpStl)) {
LOG_ERROR( m_pLogGen, "Error : CreateExportStl")
return false ;
}
// eseguo l'esportazione
if ( ! pExpStl->Export( m_pGeomDB, GDB_ID_ROOT, sFilePath)) {
return false ;
}
// log dei comandi
LOG_INFO( m_pLogCmd, ( "EXPORTSTL( 0, " + sFilePath + ")").c_str())
}
return true ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::FileExec( const string& sFilePath)
{
// verifico validità esecutore
if ( m_pCmdParser == nullptr) {
LOG_ERROR( m_pLogGen, "CmdParser invalid")
return false ;
}
// divido in nome e direttorio
string sFileDir ;
string sFileName ;
SplitLast( sFilePath, "\\", sFileDir, sFileName) ;
// inserisco il nome del file nel titolo della finestra
m_sFileName = sFileName ;
m_bModified = true ;
EmitTitle() ;
// emetto info
string sInfo = "Exec File = " + sFilePath ;
LOG_INFO( m_pLogGen, sInfo.c_str())
// pulisco l'albero delle entità
ClearTree() ;
// imposto il direttorio dello script
m_pCmdParser->SetDirReplace( "<TSCDIR>", sFileDir) ;
// esecuzione script
bool bOk = m_pCmdParser->Run( sFilePath) ;
// log dei comandi
LOG_INFO( m_pLogCmd, ( "RUN( " + sFilePath + ")").c_str())
// aggiorno visualizzazione
m_View.Redraw() ;
// aggiorno l'albero delle entità
LoadTree() ;
// aggiorno stato bottoni
UpdateShowModeButtons() ;
UpdateViewButtons() ;
return bOk ;
}
//----------------------------------------------------------------------------
bool
CTestEGrDlg::LineExec( const string& sLine)
{
// verifico validità esecutore
if ( m_pCmdParser == nullptr) {
LOG_ERROR( m_pLogGen, "CmdParser invalid")
return false ;
}
// ripristino stato oggetto marcato
int nIdOld = RevertOldIdInTree() ;
// eseguo il comando
bool bOk = m_pCmdParser->ExecLine( sLine) ;
// log dei comandi
if ( bOk)
LOG_INFO( m_pLogCmd, sLine.c_str())
else
LOG_INFO( m_pLogCmd, ( "// " + sLine).c_str())
// dichiaro file modificato
m_bModified = true ;
EmitTitle() ;
// aggiorno l'albero delle entità e tento di riselezionare l'oggetto prima marcato
LoadTree() ;
if ( ! m_pGeomDB->ExistsObj( nIdOld) ||
! SelectIdInTree( nIdOld))
m_View.Redraw() ;
// aggiorno stato bottoni
UpdateShowModeButtons() ;
UpdateViewButtons() ;
return bOk ;
}
//----------------------------------------------------------------------------
void
CTestEGrDlg::EmitTitle( void)
{
string sTitle ;
// nome file
if ( m_sFileName.empty())
sTitle = "New" ;
else
sTitle = m_sFileName ;
// indicazione di modificato
if ( m_bModified)
sTitle += "*" ;
// dati del prodotto
sTitle += " - EgalTech TestEGr" ;
// emissione del titolo
SetWindowText( stringtoW( sTitle)) ;
}
Reference in New Issue View Git Blame Copy Permalink