/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
// Modeler.cpp : Defines the class behaviors for the application.
//
#include "stdafx.h"
#include <Engine/Templates/Stock_CModelData.h>
#include <Engine/Templates/Stock_CTextureData.h>
#ifdef _DEBUG
#undef new
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
// Macros used for ini i/o operations
#define INI_READ( strname, def) \
wcscpy( strIni, theApp.GetProfileString( L"Modeler prefs", CString(strname), CString(def)))
#define GET_FLAG( var) \
if( wcscmp( strIni, L"YES") == 0) var = TRUE; \
else var = FALSE;
#define GET_COLOR( var) \
swscanf( strIni, L"0X%08x", &var);
#define GET_INDEX( var) \
swscanf( strIni, L"%d", &var);
#define GET_FLOAT( var) \
swscanf( strIni, L"%f", &var);
#define SET_FLAG( var) \
if( var) wcscpy( strIni, L"YES"); \
else wcscpy( strIni, L"NO");
#define SET_COLOR( var) \
swprintf( strIni, L"0x%08x", var); \
_wcsupr( strIni);
#define SET_INDEX( var) \
swprintf( strIni, L"%d", var); \
_wcsupr( strIni);
#define SET_FLOAT( var) \
swprintf( strIni, L"%f", var); \
_wcsupr( strIni);
#define INI_WRITE( strname) \
theApp.WriteProfileString( L"Modeler prefs", CString(strname), strIni)
BOOL GetFlagFromProfile( CTString strVarName, BOOL bDefault)
{
CTString strDefault;
if( bDefault) strDefault = "YES";
else strDefault = "NO";
CTString strTemp = CStringA(theApp.GetProfileString( L"Modeler prefs", CString(strVarName), CString(strDefault)));
if( strTemp == "YES") return TRUE;
return FALSE;
};
void SetFlagToProfile( CTString strVarName, BOOL bValue)
{
if( bValue) theApp.WriteProfileString( L"Modeler prefs", CString(strVarName), L"YES");
else theApp.WriteProfileString( L"Modeler prefs", CString(strVarName), L"NO");
};
INDEX GetIndexFromProfile( CTString strVarName, INDEX iDefault)
{
CTString strDefault;
strDefault.PrintF("%d", iDefault);
CTString strTemp = CStringA(theApp.GetProfileString( L"Modeler prefs", CString(strVarName), CString(strDefault)));
INDEX iValue;
sscanf( strTemp, "%d", &iValue);
return iValue;
};
void SetIndexToProfile( CTString strVarName, INDEX iValue)
{
CTString strTemp;
strTemp.PrintF("%d", iValue);
theApp.WriteProfileString( L"Modeler prefs", CString(strVarName), CString(strTemp));
};
COLOR GetColorFromProfile( CTString strVarName, COLOR colDefault)
{
CTString strDefault;
strDefault.PrintF("0x%08x", colDefault);
CTString strTemp = CStringA(theApp.GetProfileString( L"Modeler prefs", CString(strVarName), CString(strDefault)));
COLOR colValue;
sscanf( strTemp, "0x%08x", &colValue);
return colValue;
};
void SetColorToProfile( CTString strVarName, COLOR colValue)
{
CTString strTemp;
strTemp.PrintF("0x%08x", colValue);
theApp.WriteProfileString( L"Modeler prefs", CString(strVarName), CString(strTemp));
};
/////////////////////////////////////////////////////////////////////////////
// CModelerApp
BEGIN_MESSAGE_MAP(CModelerApp, CWinApp)
//{{AFX_MSG_MAP(CModelerApp)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
ON_COMMAND(ID_FILE_NEW, OnFileNew)
ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
ON_COMMAND(ID_FILE_PREFERENCES, OnFilePreferences)
//}}AFX_MSG_MAP
// Standard file based document commands
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
// Standard print setup command
ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
UINT APIENTRY ModelerFileRequesterHook( HWND hdlg, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
if( uiMsg == WM_INITDIALOG)
{
CRect rectMainFrame, rectFileReqPos, rectFileReqNewPos;
CMainFrame* pMainFrame = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
LONG left, top;
GetWindowRect( GetParent( hdlg), rectFileReqPos);
pMainFrame->GetWindowRect( rectMainFrame);
left = (rectMainFrame.right - rectMainFrame.left)/2
- rectFileReqPos.Width()/2;
top = (rectMainFrame.bottom - rectMainFrame.top)/2
- rectFileReqPos.Height()/2;
MoveWindow( GetParent( hdlg), left, top,
rectFileReqPos.Width(), rectFileReqPos.Height(), TRUE);
}
return 0;
}
/////////////////////////////////////////////////////////////////////////////
// CModelerApp construction
CModelerApp::CModelerApp()
{
m_bRefreshPatchPalette = FALSE;
m_OnIdlePaused = FALSE;
m_pLampModelData = NULL;
m_pFloorModelData = NULL;
m_pCollisionBoxModelData = NULL;
m_ptdCollisionBoxTexture = NULL;
m_ptdLamp = NULL;
m_ptdFloorTexture = NULL;
m_pfntFont = NULL;
}
CBcgTexture::CBcgTexture()
{
wt_TextureData = NULL;
}
CBcgTexture::~CBcgTexture()
{
}
CModelerApp::~CModelerApp()
{
if( m_pLampModelData != NULL)
{
_pModelStock->Release( m_pLampModelData);
delete m_LampModelObject;
}
if( m_pCollisionBoxModelData != NULL)
{
_pModelStock->Release( m_pCollisionBoxModelData);
delete m_pCollisionBoxModelObject;
m_pCollisionBoxModelObject = NULL;
}
if( m_pFloorModelData != NULL)
{
_pModelStock->Release( m_pFloorModelData);
delete m_pFloorModelObject;
m_pFloorModelObject = NULL;
}
if( m_ptdCollisionBoxTexture != NULL)
{
_pTextureStock->Release( m_ptdCollisionBoxTexture);
m_ptdCollisionBoxTexture = NULL;
}
if( m_ptdLamp != NULL)
{
_pTextureStock->Release( m_ptdLamp);
m_ptdLamp = NULL;
}
if( m_ptdFloorTexture != NULL)
{
_pTextureStock->Release( m_ptdFloorTexture);
m_ptdFloorTexture = NULL;
}
FORDELETELIST( CBcgTexture, wt_ListNode, m_WorkingTextures, litTex)
{
ASSERT( litTex->wt_TextureData != NULL);
_pTextureStock->Release( litTex->wt_TextureData);
delete &litTex.Current();
}
FORDELETELIST( CWorkingPatch, wp_ListNode, m_WorkingPatches, litPatch)
{
CTextureData *pTD = litPatch->wp_TextureData;
_pTextureStock->Release( litPatch->wp_TextureData);
delete &litPatch.Current();
}
SE_EndEngine();
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CModelerApp object
CModelerApp theApp;
/////////////////////////////////////////////////////////////////////////////
// CModelerApp initialization
BOOL CModelerApp::InitInstance()
{
BOOL bResult;
CTSTREAM_BEGIN {
bResult = SubInitInstance();
} CTSTREAM_END;
return bResult;
}
BOOL CModelerApp::SubInitInstance()
{
wchar_t strIni[ 128];
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need.
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
// settings will be saved into registry instead of ini file
SetRegistryKey( L"CroTeam");
LoadStdProfileSettings(8); // Load standard INI file options (including MRU)
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
CMultiDocTemplate* pDocTemplate;
m_pdtModelDocTemplate = pDocTemplate = new CMultiDocTemplate(
IDR_MDLDOCTYPE,
RUNTIME_CLASS(CModelerDoc),
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
RUNTIME_CLASS(CModelerView));
AddDocTemplate(pDocTemplate);
m_pdtScriptTemplate = pDocTemplate = new CMultiDocTemplate(
IDR_SCRIPTDOCTYPE,
RUNTIME_CLASS(CScriptDoc),
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
RUNTIME_CLASS(CScriptView));
AddDocTemplate(pDocTemplate);
// initialize engine, without network
SE_InitEngine(""); // DO NOT SPECIFY NAME HERE!
SE_LoadDefaultFonts();
// create main MDI Frame window
CMainFrame* pMainFrame = new CMainFrame;
if( !pMainFrame->LoadFrame(IDR_MAINFRAME)) return FALSE;
m_pMainWnd = pMainFrame;
// set main window for engine
SE_UpdateWindowHandle( m_pMainWnd->m_hWnd);
// Enable drag/drop open
m_pMainWnd->DragAcceptFiles();
// Enable DDE Execute open
EnableShellOpen();
RegisterShellFileTypes(TRUE);
// Parse command line for standard shell commands, DDE, file open
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
// load startup script
_pShell->Execute( "include \"Scripts\\Modeler_startup.ini\"");
m_iApi=GAT_OGL;
m_iApi=GetProfileInt(L"Display modes", L"SED Gfx API", GAT_OGL);
// (re)set default display mode
_pGfx->ResetDisplayMode((enum GfxAPIType) m_iApi);
m_Preferences.ReadFromIniFile();
// load background textures
INDEX iWorkingTexturesCt = theApp.GetProfileInt( L"Modeler prefs",
L"Modeler working textures count", -1);
if( iWorkingTexturesCt != -1) {
char strWTName[ 128];
for( INDEX i=0; i<iWorkingTexturesCt; i++) {
sprintf( strWTName, "Working texture %02d", i);
INI_READ( strWTName, "Error in INI .file!");
AddModelerWorkingTexture( CTString(CStringA(strIni)));
}
}
// load working patches
INDEX iWorkingPatchesCt = theApp.GetProfileInt( L"Modeler prefs",
L"Modeler working patches count", -1);
char strWPName[ 128];
for( INDEX i=0; i<iWorkingPatchesCt; i++) {
sprintf( strWPName, "Working patch %02d", i);
INI_READ( strWPName, "Error in INI .file!");
AddModelerWorkingPatch( CTString(CStringA(strIni)));
}
pMainFrame->m_StainsComboBox.Refresh();
// don't start new document automatically
cmdInfo.m_nShellCommand = CCommandLineInfo::FileNothing;
// create temporary directory to contain copy/paste mapping all
CreateDirectoryA( _fnmApplicationPath + "Temp\\", NULL);
// try to
try
{ // load lamp model
DECLARE_CTFILENAME( fnLampName, "Models\\Editor\\Lamp.mdl");
m_pLampModelData = _pModelStock->Obtain_t( fnLampName);
m_LampModelObject = new CModelObject;
m_LampModelObject->SetData(m_pLampModelData);
m_LampModelObject->SetAnim( 0);
// load lamp's texture
DECLARE_CTFILENAME( fnLampTex, "Models\\Editor\\SpotLight.tex");
m_ptdLamp = _pTextureStock->Obtain_t( fnLampTex);
m_LampModelObject->mo_toTexture.SetData( m_ptdLamp);
// load collision box model
DECLARE_CTFILENAME( fnCollisionBox, "Models\\Editor\\CollisionBox.mdl");
m_pCollisionBoxModelData = _pModelStock->Obtain_t( fnCollisionBox);
m_pCollisionBoxModelObject = new CModelObject;
m_pCollisionBoxModelObject->SetData(m_pCollisionBoxModelData);
m_pCollisionBoxModelObject->SetAnim( 0);
// load collision box's texture
DECLARE_CTFILENAME( fnCollisionBoxTex, "Models\\Editor\\CollisionBox.tex");
m_ptdCollisionBoxTexture = _pTextureStock->Obtain_t( fnCollisionBoxTex);
m_pCollisionBoxModelObject->mo_toTexture.SetData( m_ptdCollisionBoxTexture);
// load floor model
DECLARE_CTFILENAME( fnFloor, "Models\\Editor\\Floor.mdl");
m_pFloorModelData = _pModelStock->Obtain_t( fnFloor);
m_pFloorModelObject = new CModelObject;
m_pFloorModelObject->SetData(m_pFloorModelData);
m_pFloorModelObject->SetAnim( 0);
// load collision box's texture
DECLARE_CTFILENAME( fnFloorTex, "Models\\Editor\\Floor.tex");
m_ptdFloorTexture = _pTextureStock->Obtain_t( fnFloorTex);
m_pFloorModelObject->mo_toTexture.SetData( m_ptdFloorTexture);
DECLARE_CTFILENAME( fnShadowTex, "Textures\\Effects\\Shadow\\SimpleModelShadow.tex");
// setup simple model shadow texture
_toSimpleModelShadow.SetData_t( fnShadowTex);
}
catch( char *err_str)
{ // report error and continue without models
AfxMessageBox( CString(err_str));
// if we allocated model object for collision box
if( m_pCollisionBoxModelObject != NULL) {
// delete it
delete m_pCollisionBoxModelObject;
m_pCollisionBoxModelObject = NULL;
}
// if we loaded collision box's texture
if( m_ptdCollisionBoxTexture != NULL) {
// release it and
_pTextureStock->Release( m_ptdCollisionBoxTexture);
m_ptdCollisionBoxTexture = NULL;
}
// if we loaded lamp's texture
if( m_ptdLamp != NULL) {
// release it and
_pTextureStock->Release( m_ptdLamp);
m_ptdLamp = NULL;
}
// if we allocated model object for floor
if( m_pFloorModelObject != NULL) {
// delete it
delete m_pFloorModelObject;
m_pFloorModelObject = NULL;
}
// if we loaded floor's texture
if( m_ptdFloorTexture != NULL) {
// release it and
_pTextureStock->Release( m_ptdFloorTexture);
m_ptdFloorTexture = NULL;
}
}
// assign system font
m_pfntFont = _pfdDisplayFont;
// Dispatch commands specified on the command line
if( !ProcessShellCommand(cmdInfo)) return FALSE;
// The main window has been initialized, so show and update it.
m_nCmdShow = SW_SHOWMAXIMIZED; // maximize main frame !!!
pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();
// if stating modeler for the first time
if( m_bFirstTimeStarted) {
// call preferences
OnFilePreferences();
}
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
// No message handlers
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
// No message handlers
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
// App command to run the dialog
void CModelerApp::OnAppAbout()
{
CAboutDlg aboutDlg;
aboutDlg.DoModal();
}
/////////////////////////////////////////////////////////////////////////////
// CModelerApp commands
static TIME timeLastTick=TIME(0);
BOOL CModelerApp::OnIdle(LONG lCount)
{
if( _pTimer != NULL)
{
TIME timeCurrentTick = _pTimer->GetRealTimeTick();
if( (timeCurrentTick > timeLastTick) && !m_OnIdlePaused)
{
_pTimer->SetCurrentTick( timeCurrentTick);
timeLastTick = timeCurrentTick;
POSITION pos = m_pdtModelDocTemplate->GetFirstDocPosition();
while (pos!=NULL) {
CModelerDoc *pmdCurrent = (CModelerDoc *)m_pdtModelDocTemplate->GetNextDoc(pos);
pmdCurrent->OnIdle();
}
((CMainFrame *)m_pMainWnd)->OnIdle( lCount);
}
}
// if application is active
extern BOOL _bApplicationActive;
if (_bApplicationActive) {
// never release idle
return CWinApp::OnIdle(lCount) || TRUE;
// if application is inactive
} else {
// release idle when not needed
return CWinApp::OnIdle(lCount);
}
}
/////////////////////////////////////////////////////////////////////////////
void CModelerApp::CreateNewDocument( CTFileName fnRequestedFile)
{
CTFileName fnMdlFile = fnRequestedFile.FileDir() + fnRequestedFile.FileName() + ".mdl";
CTFileName fnScriptFile = fnRequestedFile.FileDir() + fnRequestedFile.FileName() + ".scr";
if( fnRequestedFile.FileExt() != ".scr")
{
if( GetFileAttributesA( _fnmApplicationPath + fnScriptFile) != -1)
{
if( MessageBoxA( m_pMainWnd->m_hWnd, "Script file allready exists, "
"do you want to overwrite it?",
"Warning !", MB_YESNO | MB_ICONWARNING |
MB_DEFBUTTON1| MB_SYSTEMMODAL | MB_TOPMOST) == IDYES)
{
DeleteFileA( _fnmApplicationPath + fnScriptFile);
}
else
{
return;
}
}
CEditModel em;
try
{
em.CreateScriptFile_t( fnRequestedFile);
}
catch( char *err_str)
{
AfxMessageBox( CString(err_str));
return;
}
}
else if( GetFileAttributesA( _fnmApplicationPath + fnMdlFile) != -1)
{
if( MessageBoxA( m_pMainWnd->m_hWnd, "Model file allready exists, do you want to "
"overwrite it and loose all possible data describing mapping, "
"colored polygons, patch positions, ... ?",
"Warning !", MB_YESNO | MB_ICONWARNING |
MB_DEFBUTTON1| MB_SYSTEMMODAL | MB_TOPMOST) != IDYES)
return;
}
// Now we create document instance of type CModelerDoc
CDocument* pDocument = m_pdtModelDocTemplate->CreateNewDocument();
if (pDocument == NULL)
{
TRACE0("CDocTemplate::CreateNewDocument returned NULL.\n");
AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);
return;
}
ASSERT_VALID(pDocument);
BOOL bAutoDelete = pDocument->m_bAutoDelete;
pDocument->m_bAutoDelete = FALSE; // don't destroy if something goes wrong
CFrameWnd* pFrame = m_pdtModelDocTemplate->CreateNewFrame(pDocument, NULL);
pDocument->m_bAutoDelete = bAutoDelete;
if (pFrame == NULL)
{
AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);
delete pDocument; // explicit delete on error
return;
}
ASSERT_VALID(pFrame);
pDocument->SetModifiedFlag();
pDocument->SetPathName( CString(_fnmApplicationPath + fnMdlFile), FALSE);
pDocument->SetTitle( CString(fnMdlFile.FileName() + ".mdl"));
char strError[ 256];
if( !((CModelerDoc *)pDocument)->CreateModelFromScriptFile( fnScriptFile, strError))
{
pDocument->OnCloseDocument(); // explicit delete on error
AfxMessageBox( CString(strError));
return;
}
m_pdtModelDocTemplate->InitialUpdateFrame(pFrame, pDocument, TRUE);
}
void CModelerApp::OnFileNew()
{
// call file requester for opening documents
CDynamicArray<CTFileName> afnCreateModel;
_EngineGUI.FileRequester( "Create new model from 3D or script file",
"3D objects and scripts\0*.lwo;*.obj;*.3ds;*.scr\0"
FILTER_3DOBJ FILTER_LWO FILTER_OBJ FILTER_3DS FILTER_SCR FILTER_ALL FILTER_END,
"Create model directory", "Models\\", "", &afnCreateModel);
// create new models
FOREACHINDYNAMICARRAY( afnCreateModel, CTFileName, itModel)
{
// create new models
CreateNewDocument( itModel.Current());
}
}
/////////////////////////////////////////////////////////////////////////////
void CModelerApp::OnFileOpen()
{
// call file requester for opening documents
CDynamicArray<CTFileName> afnOpenModel;
_EngineGUI.FileRequester( "Open model or script file",
"Model files (*.mdl)\0*.mdl\0"
"Script files (*.scr)\0*.scr\0"
"Model or script files (*.mdl; *.scr)\0*.mdl;*.scr\0"
"All files (*.*)\0*.*\0\0",
"Open model directory", "Models\\", "", &afnOpenModel);
// create new models
FOREACHINDYNAMICARRAY( afnOpenModel, CTFileName, itModel)
{
// we will use full file name to call OnOpenDocument()
CTFileName fnFullRequestedFile = _fnmApplicationPath + itModel.Current();
// choose right document template using file's extension
CDocTemplate *pDocTemplate = m_pdtModelDocTemplate;
BOOL bScriptDocument = FALSE;
if( fnFullRequestedFile.FileExt() == ".scr")
{
pDocTemplate = m_pdtScriptTemplate;
bScriptDocument = TRUE;
}
// Now we create document instance
CDocument* pDocument = pDocTemplate->CreateNewDocument();
if (pDocument == NULL)
{
TRACE0("CDocTemplate::CreateNewDocument returned NULL.\n");
AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);
return;
}
ASSERT_VALID(pDocument);
// Model documents must be opened before view creation
if( !bScriptDocument)
{
if( !pDocument->OnOpenDocument( CString(fnFullRequestedFile)))
{
AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);
//delete pDocument; // explicit delete on error
return;
}
}
// View creation
BOOL bAutoDelete = pDocument->m_bAutoDelete;
pDocument->m_bAutoDelete = FALSE; // don't destroy if something goes wrong
CFrameWnd* pFrame = pDocTemplate->CreateNewFrame(pDocument, NULL);
pDocument->m_bAutoDelete = bAutoDelete;
if (pFrame == NULL)
{
AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);
delete pDocument; // explicit delete on error
return;
}
ASSERT_VALID(pFrame);
// Script documents must be opened after view creation
if( bScriptDocument)
{
if( !pDocument->OnOpenDocument( CString(fnFullRequestedFile)))
{
AfxMessageBox(AFX_IDP_FAILED_TO_CREATE_DOC);
delete pDocument; // explicit delete on error
return;
}
}
pDocument->SetModifiedFlag( FALSE);
pDocument->SetPathName( CString(fnFullRequestedFile), TRUE);
pDocument->SetTitle( CString(fnFullRequestedFile.FileName() + fnFullRequestedFile.FileExt()));
pDocTemplate->InitialUpdateFrame(pFrame, pDocument, TRUE);
}
}
void CModelerApp::OnFilePreferences()
{
CMainFrame* pMainFrame = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
CDlgPreferences dlg;
if( dlg.DoModal() == IDOK)
{
m_Preferences = dlg.m_Prefs;
// change wiew's background texture
CModelerView *pModelerView = CModelerView::GetActiveView();
if( pModelerView != NULL) {
pModelerView->m_fnBcgTexture = dlg.m_Prefs.ap_DefaultWinBcgTexture;
}
pModelerView = CModelerView::GetActiveMappingNormalView();
if( pModelerView != NULL) {
CModelerDoc *pDoc = pModelerView->GetDocument();
pDoc->UpdateAllViews( NULL);
}
}
}
int CModelerApp::ExitInstance()
{
m_Preferences.WriteToIniFile();
WriteProfileInt(L"Display modes", L"SED Gfx API", m_iApi);
return CWinApp::ExitInstance();
}
BOOL CModelerApp::AddModelerWorkingTexture( CTFileName fnTexName)
{
CBcgTexture *pNewWT = new CBcgTexture;
pNewWT->wt_FileName = fnTexName;
try
{
pNewWT->wt_TextureData = _pTextureStock->Obtain_t( fnTexName);
}
catch( char *err_str)
{
MessageBoxA( m_pMainWnd->m_hWnd, err_str, "Warning!", MB_OK|MB_ICONHAND|MB_SYSTEMMODAL);
if( pNewWT != NULL) delete pNewWT;
return FALSE;
}
pNewWT->wt_toTexture.SetData( pNewWT->wt_TextureData);
m_WorkingTextures.AddTail( pNewWT->wt_ListNode);
return TRUE;
}
BOOL CModelerApp::AddModelerWorkingPatch( CTFileName fnPatchName)
{
FOREACHINLIST( CWorkingPatch, wp_ListNode, m_WorkingPatches, itPatch)
{
if( itPatch->wp_FileName == fnPatchName)
{
char achrMessage[ 256];
sprintf( achrMessage, "Working patch \"%s\" already exists.", (CTString&)fnPatchName);
AfxMessageBox( CString(achrMessage));
return FALSE;
}
}
CWorkingPatch *pNewWP = new CWorkingPatch;
pNewWP->wp_FileName = fnPatchName;
try
{
pNewWP->wp_TextureData = _pTextureStock->Obtain_t( pNewWP->wp_FileName);
}
catch( char *err_str)
{
MessageBoxA( m_pMainWnd->m_hWnd, err_str, "Warning!", MB_OK|MB_ICONHAND|MB_SYSTEMMODAL);
delete pNewWP;
return FALSE;
}
m_WorkingPatches.AddTail( pNewWP->wp_ListNode);
return TRUE;
}
const CTextureObject *CModelerApp::GetValidBcgTexture( CTFileName fnTexName)
{
const CTextureObject *ptoResult = NULL;
FOREACHINLIST( CBcgTexture, wt_ListNode, m_WorkingTextures, it_wt)
{
if( it_wt->wt_FileName == fnTexName)
{
return &it_wt->wt_toTexture;
}
}
if( !m_WorkingTextures.IsEmpty())
{
ptoResult = &(LIST_HEAD( m_WorkingTextures, CBcgTexture, wt_ListNode)->wt_toTexture);
}
return ptoResult;
}
const CTFileName CModelerApp::NextPrevBcgTexture( CTFileName fnTexName, INDEX iNextPrev)
{
INDEX ctTextures = m_WorkingTextures.Count();
ASSERT( ctTextures > 1);
CStaticArray<CTFileName> afnTemp;
afnTemp.New( ctTextures);
INDEX iCurrent = -1;
INDEX iIter = 0;
// add textures to static array and remember current texture's index by name
FOREACHINLIST( CBcgTexture, wt_ListNode, m_WorkingTextures, it_wt)
{
afnTemp[iIter] = it_wt->wt_FileName;
if( it_wt->wt_FileName == fnTexName)
{
iCurrent = iIter;
}
iIter++;
}
// texture must be found
ASSERT( iCurrent != -1);
// return
return( afnTemp[(iCurrent+ctTextures+iNextPrev) % ctTextures]);
}
/////////////////////////////////////////////////////////////////////////////
// CAppPrefs routines
CAppPrefs::~CAppPrefs()
{
}
// Modeler ini read function for preferences
void CAppPrefs::ReadFromIniFile()
{
wchar_t strIni[ 128];
INI_READ( "Copy existing window preferences", "NO");
GET_FLAG( ap_CopyExistingWindowPrefs);
INI_READ( "Floor is visible by default", "YES");
GET_FLAG( ap_bIsFloorVisibleByDefault);
INI_READ( "Bcg is visible by default", "YES");
GET_FLAG( ap_bIsBcgVisibleByDefault);
INI_READ( "Set default colors", "YES");
GET_FLAG( ap_SetDefaultColors);
INI_READ( "Auto maximize window", "YES");
GET_FLAG( ap_AutoMaximizeWindow);
INI_READ( "Auto window fit", "YES");
GET_FLAG( ap_AutoWindowFit);
INI_READ( "Allways see lamp", "NO");
GET_FLAG( ap_AllwaysSeeLamp);
INI_READ( "Allow sound lock", "NO");
GET_FLAG( ap_bAllowSoundLock);
INI_READ( "Default ambient color", "0X3F3F3FFF");
GET_COLOR( ap_colDefaultAmbientColor);
INI_READ( "Default model heading", "180.0");
GET_FLOAT( ap_fDefaultHeading);
INI_READ( "Default model pitch", "0.0");
GET_FLOAT( ap_fDefaultHeading);
INI_READ( "Default model banking", "0.0");
GET_FLOAT( ap_fDefaultBanking);
INI_READ( "Default FOW", "90.0");
GET_FLOAT( ap_fDefaultFOW);
INI_READ( "Normal view ink color", "0X00000000");
GET_COLOR( ap_DefaultInkColor);
INI_READ( "Normal view paper color", "0XAAAAAAAA");
GET_COLOR( ap_DefaultPaperColor);
INI_READ( "Mapping view active surface color", "0X00000000");
GET_COLOR( ap_MappingActiveSurfaceColor);
INI_READ( "Mapping view inactive surface color", "0X80808000");
GET_COLOR( ap_MappingInactiveSurfaceColor);
INI_READ( "Mapping view paper color", "0XFFFFFFFF");
GET_COLOR( ap_MappingPaperColor);
INI_READ( "Mapping view win bcg color", "0XAAAAAAAA");
GET_COLOR( ap_MappingWinBcgColor);
INI_READ( "Default background texture", "");
ap_DefaultWinBcgTexture = CTString(CStringA(strIni));
CMainFrame* pMainFrame = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
}
// Modeler ini write function for preferences
void CAppPrefs::WriteToIniFile()
{
wchar_t strIni[ 128];
SET_FLAG( ap_CopyExistingWindowPrefs);
INI_WRITE( "Copy existing window preferences");
SET_FLAG( ap_bIsFloorVisibleByDefault);
INI_WRITE( "Floor is visible by default");
SET_FLAG( ap_bIsBcgVisibleByDefault);
INI_WRITE( "Bcg is visible by default");
SET_FLAG( ap_SetDefaultColors);
INI_WRITE( "Set default colors");
SET_FLAG( ap_AutoMaximizeWindow);
INI_WRITE( "Auto maximize window");
SET_FLAG( ap_AutoWindowFit);
INI_WRITE( "Auto window fit");
SET_FLAG( ap_AllwaysSeeLamp);
INI_WRITE( "Allways see lamp");
SET_FLAG( ap_bAllowSoundLock);
INI_WRITE( "Allow sound lock");
SET_COLOR( ap_colDefaultAmbientColor);
INI_WRITE( "Default ambient color");
SET_FLOAT( ap_fDefaultHeading);
INI_WRITE( "Default model heading");
SET_FLOAT( ap_fDefaultHeading);
INI_WRITE( "Default model pitch");
SET_FLOAT( ap_fDefaultBanking);
INI_WRITE( "Default model banking");
SET_FLOAT( ap_fDefaultFOW);
INI_WRITE( "Default FOW");
SET_COLOR( ap_DefaultInkColor);
INI_WRITE( "Normal view ink color");
SET_COLOR( ap_DefaultPaperColor);
INI_WRITE( "Normal view paper color");
SET_COLOR( ap_MappingActiveSurfaceColor);
INI_WRITE( "Mapping view active surface color");
SET_COLOR( ap_MappingInactiveSurfaceColor);
INI_WRITE( "Mapping view inactive surface color");
SET_COLOR( ap_MappingPaperColor);
INI_WRITE( "Mapping view paper color");
SET_COLOR( ap_MappingWinBcgColor);
INI_WRITE( "Mapping view win bcg color");
wcscpy( strIni, CString(ap_DefaultWinBcgTexture));
INI_WRITE( "Default background texture");
// Now for working textures
INDEX iWorkingTexturesCt = theApp.m_WorkingTextures.Count();
theApp.WriteProfileInt( L"Modeler prefs", L"Modeler working textures count",
iWorkingTexturesCt);
INDEX iWTCt = 0;
FOREACHINLIST( CBcgTexture, wt_ListNode, theApp.m_WorkingTextures, it_wt)
{
char strWTName[ 128];
sprintf( strWTName, "Working texture %02d", iWTCt);
theApp.WriteProfileString( L"Modeler prefs", CString(strWTName), CString(it_wt->wt_FileName));
iWTCt++;
}
// And now for patches....
INDEX iWorkingPatchesCt = theApp.m_WorkingPatches.Count();
theApp.WriteProfileInt( L"Modeler prefs", L"Modeler working patches count",
iWorkingPatchesCt);
INDEX iWPCt = 0;
FOREACHINLIST( CWorkingPatch, wp_ListNode, theApp.m_WorkingPatches, it_wp)
{
char strWPName[ 128];
sprintf( strWPName, "Working patch %02d", iWPCt);
theApp.WriteProfileString( L"Modeler prefs", CString(strWPName), CString(it_wp->wp_FileName));
iWPCt++;
}
}
int CModelerApp::Run()
{
int iResult;
CTSTREAM_BEGIN {
iResult=CWinApp::Run();
} CTSTREAM_END;
return CWinApp::Run();
}
CModelerView* CModelerApp::GetActiveView(void)
{
CModelerView *res;
CMainFrame* pMainFrame = STATIC_DOWNCAST(CMainFrame, AfxGetMainWnd());
res = DYNAMIC_DOWNCAST(CModelerView, pMainFrame->GetActiveFrame()->GetActiveView());
return res;
}
CModelerDoc *CModelerApp::GetDocument()
{
// obtain current view ptr
CModelerView *pModelerView = GetActiveView();
// if view does not exist, return
if( pModelerView == NULL)
{
return NULL;
}
// obtain document ptr
CModelerDoc *pDoc = pModelerView->GetDocument();
// return it
return pDoc;
}