mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-25 08:36:14 +00:00
1935 lines
52 KiB
C++
1935 lines
52 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// 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 Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// MainFrm.cpp : implementation of the CMainFrame class
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "master.h"
|
|
|
|
#include "MainFrm.h"
|
|
//#include "RegionPropertiesDlg.h"
|
|
//#include "NewGeorgesFormDlg.h"
|
|
//#include "PrimNameDlg.h"
|
|
#include "NameEditDlg.h"
|
|
#include "ChooseTag.h"
|
|
#include "ChooseDir.h"
|
|
#include "exportdlg.h"
|
|
#include "exportcbdlg.h"
|
|
#include "continentcfg.h"
|
|
#include "continentPropertiesDlg.h"
|
|
|
|
#include "../georges_dll/georges_interface.h"
|
|
#include "../logic_editor_dll/logic_editor_interface.h"
|
|
|
|
#include "nel/misc/file.h"
|
|
#include "nel/misc/stream.h"
|
|
|
|
using namespace NLMISC;
|
|
using namespace std;
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#ifdef NL_NEW
|
|
#undef new
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Do not parse following directories
|
|
char *gSysDir[MAX_SYS_DIR] =
|
|
{
|
|
".",
|
|
"..",
|
|
"ZoneBitmaps",
|
|
"ZoneLigos",
|
|
"dfn",
|
|
"tmp",
|
|
"cvs"
|
|
};
|
|
|
|
// Do not display files with those extensions
|
|
#define MAX_INVALID_EXT 1
|
|
char *gInvalidExt[MAX_INVALID_EXT] =
|
|
{
|
|
".log"
|
|
};
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// ---------------------------------------------------------------------------
|
|
SEnvironnement::SEnvironnement()
|
|
{
|
|
MasterX = 0;
|
|
MasterY = 0;
|
|
MasterTreeX = 0;
|
|
MasterTreeY = 0;
|
|
MasterTreeCX = 100;
|
|
MasterTreeCY = 100;
|
|
MasterTreeLocked = true;
|
|
|
|
char tmp[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, tmp);
|
|
ContinentsDir = tmp;
|
|
ContinentsDir += "\\Continents\\";
|
|
|
|
WorldEdOpened = false;
|
|
WorldEdX = 50;
|
|
WorldEdY = 50;
|
|
WorldEdCX = 600;
|
|
WorldEdCY = 400;
|
|
|
|
GeorgesOpened = false;
|
|
GeorgesX = 50;
|
|
GeorgesY = 50;
|
|
GeorgesCX = 300;
|
|
GeorgesCY = 300;
|
|
|
|
LogicEditorOpened = false;
|
|
LogicEditorX = 50;
|
|
LogicEditorY = 50;
|
|
LogicEditorCX = 300;
|
|
LogicEditorCY = 300;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
bool SEnvironnement::load (const std::string &filename)
|
|
{
|
|
if (!openRead(filename))
|
|
return false;
|
|
// Master
|
|
MasterX = getInt ("MASTA_PosX");
|
|
MasterY = getInt ("MASTA_PosY");
|
|
MasterTreeX = getInt ("MASTA_TreePosX");
|
|
MasterTreeY = getInt ("MASTA_TreePosY");
|
|
MasterTreeCX = getInt ("MASTA_TreeSizeX");
|
|
MasterTreeCY = getInt ("MASTA_TreeSizeY");
|
|
MasterTreeLocked = getBool ("MASTA_TreeLocked");
|
|
ContinentsDir = getStr ("MASTA_ContinentsDir");
|
|
DefaultDFNDir = getStr ("MASTA_DefaultDFNDir");
|
|
DefaultGameElemDir = getStr ("MASTA_DefaultGameElemDir");
|
|
|
|
// WorldEditor
|
|
WorldEdOpened = getBool ("WE_Opened");
|
|
WorldEdX = getInt ("WE_PosX");
|
|
WorldEdY = getInt ("WE_PosY");
|
|
WorldEdCX = getInt ("WE_SizeX");
|
|
WorldEdCY = getInt ("WE_SizeY");
|
|
|
|
// Georges
|
|
GeorgesOpened = getBool ("GG_Opened");
|
|
GeorgesX = getInt ("GG_PosX");
|
|
GeorgesY = getInt ("GG_PosY");
|
|
GeorgesCX = getInt ("GG_SizeX");
|
|
GeorgesCY = getInt ("GG_SizeY");
|
|
|
|
// LogicEditor
|
|
LogicEditorOpened = getBool ("LE_Opened");
|
|
LogicEditorX = getInt ("LE_PosX");
|
|
LogicEditorY = getInt ("LE_PosY");
|
|
LogicEditorCX = getInt ("LE_SizeX");
|
|
LogicEditorCY = getInt ("LE_SizeY");
|
|
|
|
// Export options
|
|
ExportOptions.loadcf (*cf);
|
|
close ();
|
|
return true;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
bool SEnvironnement::save (const std::string &filename)
|
|
{
|
|
if (!openWrite(filename))
|
|
return false;
|
|
|
|
putCommentLine ("------");
|
|
putCommentLine ("Master");
|
|
putCommentLine ("------");
|
|
putInt ("MASTA_PosX", MasterX);
|
|
putInt ("MASTA_PosY", MasterY);
|
|
putInt ("MASTA_TreePosX", MasterTreeX);
|
|
putInt ("MASTA_TreePosY", MasterTreeY);
|
|
putInt ("MASTA_TreeSizeX", MasterTreeCX);
|
|
putInt ("MASTA_TreeSizeY", MasterTreeCY);
|
|
putBool ("MASTA_TreeLocked", MasterTreeLocked);
|
|
putStr ("MASTA_ContinentsDir", ContinentsDir);
|
|
putStr ("MASTA_DefaultDFNDir", DefaultDFNDir);
|
|
putStr ("MASTA_DefaultGameElemDir",DefaultGameElemDir);
|
|
|
|
putCommentLine ("-----------");
|
|
putCommentLine ("WorldEditor");
|
|
putCommentLine ("-----------");
|
|
putBool ("WE_Opened", WorldEdOpened);
|
|
putInt ("WE_PosX", WorldEdX);
|
|
putInt ("WE_PosY", WorldEdY);
|
|
putInt ("WE_SizeX", WorldEdCX);
|
|
putInt ("WE_SizeY", WorldEdCY);
|
|
|
|
putCommentLine ("-------");
|
|
putCommentLine ("Georges");
|
|
putCommentLine ("-------");
|
|
putBool ("GG_Opened", GeorgesOpened);
|
|
putInt ("GG_PosX", GeorgesX);
|
|
putInt ("GG_PosY", GeorgesY);
|
|
putInt ("GG_SizeX", GeorgesCX);
|
|
putInt ("GG_SizeY", GeorgesCY);
|
|
|
|
putCommentLine ("-----------");
|
|
putCommentLine ("LogicEditor");
|
|
putCommentLine ("-----------");
|
|
putBool ("LE_Opened", LogicEditorOpened);
|
|
putInt ("LE_PosX", LogicEditorX);
|
|
putInt ("LE_PosY", LogicEditorY);
|
|
putInt ("LE_SizeX", LogicEditorCX);
|
|
putInt ("LE_SizeY", LogicEditorCY);
|
|
|
|
// Export options
|
|
ExportOptions.save (f);
|
|
close();
|
|
return true;
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMasterCB
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// ---------------------------------------------------------------------------
|
|
CMasterCB::CMasterCB ()
|
|
{
|
|
_MainFrame = NULL;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMasterCB::setMainFrame (CMainFrame*pMF)
|
|
{
|
|
_MainFrame = pMF;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
vector<string> &CMasterCB::getAllPrimZoneNames ()
|
|
{
|
|
return _PrimZoneList;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMasterCB::setAllPrimZoneNames (vector<string> &primZoneList)
|
|
{
|
|
_PrimZoneList = primZoneList;
|
|
//_MainFrame->georgesUpdatePatatoid();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMasterCB::multiTransfert (const std::vector<std::string> &vText, bool append)
|
|
{
|
|
_GroupPrimList = vText;
|
|
_MainFrame->georgesPutGroupText (_GroupPrimList, append);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMasterCB::transfert (const string &sText)
|
|
{
|
|
_Text = sText;
|
|
_MainFrame->georgesPutText (_Text);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMasterCB::lineUp ()
|
|
{
|
|
_MainFrame->georgesLineUp ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMasterCB::lineDown ()
|
|
{
|
|
_MainFrame->georgesLineDown ();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMainFrame
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//IMPLEMENT_DYNCREATE(CMainFrame, CFrameWnd)
|
|
|
|
BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
|
|
//{{AFX_MSG_MAP(CMainFrame)
|
|
// NOTE - the ClassWizard will add and remove mapping macros here.
|
|
// DO NOT EDIT what you see in these blocks of generated code !
|
|
|
|
ON_COMMAND(ID_CONTINENT_SAVE, onContinentSave)
|
|
ON_COMMAND(ID_CONTINENT_EXPORT, onContinentExport)
|
|
|
|
//ON_COMMAND(ID_CONTINENT_DELETE, OnContinentDelete)
|
|
|
|
ON_COMMAND(ID_OPTIONS_TREELOCK, onOptionsTreeLock)
|
|
|
|
ON_COMMAND(ID_OPTIONS_SETCONTINENTSDIR, onOptionsSetContinentsDir)
|
|
ON_COMMAND(ID_OPTIONS_SETDEFAULTDFNDIR, onOptionsSetDefaultDFNDir)
|
|
ON_COMMAND(ID_OPTIONS_SETDEFAULTGAMEELEMDIR, onOptionsSetDefaultGameElemDir)
|
|
|
|
ON_COMMAND(ID_WINDOWS_WORLDEDITOR, onWindowsWorldEditor)
|
|
ON_COMMAND(ID_WINDOWS_GEORGES, onWindowsGeorges)
|
|
ON_COMMAND(ID_WINDOWS_LOGICEDITOR, onWindowsLogicEditor)
|
|
ON_COMMAND(ID_WINDOWS_RESET, onWindowsReset)
|
|
|
|
ON_WM_CREATE()
|
|
ON_WM_ERASEBKGND()
|
|
ON_WM_SIZE()
|
|
ON_WM_MOVE()
|
|
ON_WM_CLOSE()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMainFrame construction/destruction
|
|
|
|
// ---------------------------------------------------------------------------
|
|
CMainFrame::CMainFrame()
|
|
{
|
|
_WorldEditor = NULL;
|
|
_Georges = NULL;
|
|
_LogicEditor = NULL;
|
|
_Tree = NULL;
|
|
_Export = NULL;
|
|
_ExportCBDlg = NULL;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
CMainFrame::~CMainFrame()
|
|
{
|
|
delete _Export;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Used by getAllInterfaces method to retrieve all DLLs and tools Interfaces
|
|
|
|
typedef IWorldEditor* (*IWORLDEDITOR_GETINTERFACE)(int version);
|
|
const char *IWORLDEDITOR_GETINTERFACE_NAME = "IWorldEditorGetInterface";
|
|
typedef void (*IWORLDEDITOR_RELINTERFACE)(IWorldEditor*pWE);
|
|
const char *IWORLDEDITOR_RELINTERFACE_NAME = "IWorldEditorReleaseInterface";
|
|
|
|
typedef IGeorges* (*IGEORGES_GETINTERFACE)(int version);
|
|
const char *IGEORGES_GETINTERFACE_NAME = "IGeorgesGetInterface";
|
|
typedef void (*IGEORGES_RELINTERFACE)(IGeorges *pGeorges);
|
|
const char *IGEORGES_RELINTERFACE_NAME = "IGeorgesReleaseInterface";
|
|
|
|
typedef ILogicEditor* (*ILOGICEDITOR_GETINTERFACE)(int version);
|
|
const char *ILOGICEDITOR_GETINTERFACE_NAME = "ILogicEditorGetInterface";
|
|
typedef void (*ILOGICEDITOR_RELINTERFACE)(ILogicEditor *pLogicEditor);
|
|
const char *ILOGICEDITOR_RELINTERFACE_NAME = "ILogicEditorReleaseInterface";
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::getAllInterfaces ()
|
|
{
|
|
SetCurrentDirectory (_MasterExeDir.c_str());
|
|
|
|
// Get WorldEditor Interface
|
|
if (_WorldEditor == NULL)
|
|
{
|
|
IWORLDEDITOR_GETINTERFACE IWEGetInterface = NULL;
|
|
|
|
#if defined NL_RELEASE_DEBUG
|
|
_WorldEditorModule = AfxLoadLibrary ("WorldEditor_rd.dll");
|
|
#elif defined NL_DEBUG_FAST
|
|
_WorldEditorModule = AfxLoadLibrary ("WorldEditor_df.dll");
|
|
#elif defined _DEBUG
|
|
_WorldEditorModule = AfxLoadLibrary ("WorldEditor_debug.dll");
|
|
#elif defined NDEBUG
|
|
_WorldEditorModule = AfxLoadLibrary ("WorldEditor.dll");
|
|
#endif
|
|
if (_WorldEditorModule != NULL)
|
|
{
|
|
IWEGetInterface = (IWORLDEDITOR_GETINTERFACE)::GetProcAddress (_WorldEditorModule, IWORLDEDITOR_GETINTERFACE_NAME);
|
|
if (IWEGetInterface != NULL)
|
|
_WorldEditor = IWEGetInterface (WORLDEDITOR_VERSION);
|
|
}
|
|
else
|
|
{
|
|
MessageBox("WorldEditor dll not Loaded", "Warning");
|
|
}
|
|
}
|
|
|
|
// Get Georges Interface
|
|
if (_Georges == NULL)
|
|
{
|
|
IGEORGES_GETINTERFACE IGGetInterface = NULL;
|
|
|
|
#if defined NL_RELEASE_DEBUG
|
|
_GeorgesModule = AfxLoadLibrary ("Georges_dll_rd.dll");
|
|
#elif defined NL_DEBUG_FAST
|
|
_GeorgesModule = AfxLoadLibrary ("Georges_dll_debug_fast.dll");
|
|
#elif defined _DEBUG
|
|
_GeorgesModule = AfxLoadLibrary ("Georges_dll_debug.dll");
|
|
#elif defined NDEBUG
|
|
_GeorgesModule = AfxLoadLibrary ("Georges_dll.dll");
|
|
#endif
|
|
if (_GeorgesModule != NULL)
|
|
{
|
|
IGGetInterface = (IGEORGES_GETINTERFACE)::GetProcAddress (_GeorgesModule, IGEORGES_GETINTERFACE_NAME);
|
|
if (IGGetInterface != NULL)
|
|
_Georges = IGGetInterface (GEORGES_VERSION);
|
|
}
|
|
else
|
|
{
|
|
MessageBox("Georges dll not Loaded", "Warning");
|
|
}
|
|
}
|
|
|
|
// Get LogicEditor Interface
|
|
if (_LogicEditor == NULL)
|
|
{
|
|
ILOGICEDITOR_GETINTERFACE ILEGetInterface = NULL;
|
|
|
|
#if defined NL_RELEASE_DEBUG
|
|
_LogicEditorModule = AfxLoadLibrary ("Logic_Editor_rd.dll");
|
|
#elif defined NL_DEBUG_FAST
|
|
_LogicEditorModule = AfxLoadLibrary ("Logic_Editor_df.dll");
|
|
#elif defined _DEBUG
|
|
_LogicEditorModule = AfxLoadLibrary ("Logic_Editor_debug.dll");
|
|
#elif defined NDEBUG
|
|
_LogicEditorModule = AfxLoadLibrary ("Logic_Editor.dll");
|
|
#endif
|
|
if (_LogicEditorModule != NULL)
|
|
{
|
|
ILEGetInterface = (ILOGICEDITOR_GETINTERFACE)::GetProcAddress (_LogicEditorModule, ILOGICEDITOR_GETINTERFACE_NAME);
|
|
if (ILEGetInterface != NULL)
|
|
_LogicEditor = ILEGetInterface (LOGIC_EDITOR_VERSION);
|
|
}
|
|
else
|
|
{
|
|
MessageBox("LogicEditor dll not Loaded", "Warning");
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::releaseAllInterfaces()
|
|
{
|
|
// Release the WorldEditor interface
|
|
if (_WorldEditor != NULL)
|
|
{
|
|
IWORLDEDITOR_RELINTERFACE IWERelInterface = NULL;
|
|
IWERelInterface = (IWORLDEDITOR_RELINTERFACE)::GetProcAddress (_WorldEditorModule, IWORLDEDITOR_RELINTERFACE_NAME);
|
|
IWERelInterface (_WorldEditor);
|
|
}
|
|
|
|
// Release the Georges interface
|
|
if (_Georges != NULL)
|
|
{
|
|
IGEORGES_RELINTERFACE IGRelInterface = NULL;
|
|
IGRelInterface = (IGEORGES_RELINTERFACE)::GetProcAddress (_GeorgesModule, IGEORGES_RELINTERFACE_NAME);
|
|
IGRelInterface (_Georges);
|
|
}
|
|
|
|
// Release the LogicEditor interface
|
|
if (_LogicEditor != NULL)
|
|
{
|
|
ILOGICEDITOR_RELINTERFACE ILERelInterface = NULL;
|
|
ILERelInterface = (ILOGICEDITOR_RELINTERFACE)::GetProcAddress (_LogicEditorModule, ILOGICEDITOR_RELINTERFACE_NAME);
|
|
ILERelInterface (_LogicEditor);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openFile (const string &fname)
|
|
{
|
|
char curdir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, curdir);
|
|
|
|
string sFullName;
|
|
sFullName = _Environnement.ContinentsDir;
|
|
|
|
sFullName += fname;
|
|
|
|
int size = fname.size();
|
|
|
|
if ((size >= 13) && (stricmp(&fname[size-13],"continent.cfg") == 0))
|
|
{
|
|
openContinentCfgFile (sFullName.c_str());
|
|
}
|
|
else if ((stricmp(&fname[size-5],".prim") == 0) || (stricmp(&fname[size-5],".land") == 0))
|
|
{
|
|
openWorldEditor ();
|
|
openWorldEditorFile (sFullName.c_str());
|
|
}
|
|
else if (stricmp(&fname[size-6],".logic") == 0)
|
|
{
|
|
openLogicEditor ();
|
|
openLogicEditorFile (sFullName.c_str());
|
|
}
|
|
else
|
|
{
|
|
openGeorges ();
|
|
openGeorgesFile (sFullName.c_str());
|
|
}
|
|
|
|
SetCurrentDirectory (curdir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openDir (const string &fname)
|
|
{
|
|
if (_ActivePath == "") return;
|
|
|
|
char curdir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, curdir);
|
|
|
|
string sBaseName;
|
|
sBaseName = _Environnement.ContinentsDir;
|
|
|
|
openDirParse (sBaseName, fname);
|
|
|
|
SetCurrentDirectory (curdir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openDirParse (const std::string &sBaseNameDir, const std::string &sRelativeNameDir)
|
|
{
|
|
WIN32_FIND_DATA findData;
|
|
HANDLE hFind;
|
|
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
|
|
string sFullNamedDir = sBaseNameDir + sRelativeNameDir;
|
|
if (!SetCurrentDirectory (sFullNamedDir.c_str()))
|
|
{
|
|
SetCurrentDirectory (sCurDir);
|
|
return;
|
|
}
|
|
|
|
hFind = FindFirstFile ("*.*", &findData);
|
|
while (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
if (GetFileAttributes(findData.cFileName)&FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
// Look if the name is a system directory
|
|
bool bFound = false;
|
|
for (uint32 i = 0; i < MAX_SYS_DIR; ++i)
|
|
if (stricmp (findData.cFileName, gSysDir[i]) == 0)
|
|
{
|
|
bFound = true;
|
|
break;
|
|
}
|
|
if (!bFound) // No, ok lets recurse it
|
|
{
|
|
string newPath = sRelativeNameDir + string("\\") + string(findData.cFileName);
|
|
openDirParse (sBaseNameDir, newPath);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Check for invalid extension
|
|
bool bFound = false;
|
|
for (uint32 j = 0; j < MAX_INVALID_EXT; ++j)
|
|
if (strlen(findData.cFileName) > strlen(gInvalidExt[j]))
|
|
if (stricmp(&findData.cFileName[strlen(findData.cFileName)-strlen(gInvalidExt[j])], gInvalidExt[j]) == 0)
|
|
{
|
|
bFound = true;
|
|
break;
|
|
}
|
|
// If the extension is an invalid one -> Do not open the file
|
|
if (!bFound)
|
|
{
|
|
string fileName = sRelativeNameDir + "\\" + findData.cFileName;
|
|
openFile (fileName.c_str());
|
|
}
|
|
}
|
|
if (FindNextFile (hFind, &findData) == 0)
|
|
break;
|
|
}
|
|
FindClose (hFind);
|
|
|
|
SetCurrentDirectory (sCurDir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openContinentCfgFile (const string &filename)
|
|
{
|
|
SContinentCfg cfg;
|
|
cfg.load (filename);
|
|
_WorldEditor->setDataDir (cfg.LandDir.c_str());
|
|
openWorldEditor ();
|
|
openWorldEditorFile (cfg.LandFile.c_str());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openWorldEditor()
|
|
{
|
|
if (_Environnement.WorldEdOpened)
|
|
return;
|
|
_Environnement.WorldEdOpened = true;
|
|
if (_WorldEditor != NULL)
|
|
_WorldEditor->initUILight (_Environnement.WorldEdX, _Environnement.WorldEdY,
|
|
_Environnement.WorldEdCX, _Environnement.WorldEdCY);
|
|
GetMenu()->CheckMenuItem (ID_WINDOWS_WORLDEDITOR, MF_CHECKED);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openWorldEditorFile (const string &fileName)
|
|
{
|
|
_WorldEditor->loadFile (fileName.c_str());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::closeWorldEditor()
|
|
{
|
|
if (_WorldEditor == NULL) return;
|
|
if (!_Environnement.WorldEdOpened) return;
|
|
|
|
//onContinentSave ();
|
|
_Environnement.WorldEdOpened = false;
|
|
RECT r;
|
|
CFrameWnd *pFW = (CFrameWnd*)_WorldEditor->getMainFrame();
|
|
pFW->GetWindowRect(&r);
|
|
WINDOWPLACEMENT wp;
|
|
pFW->GetWindowPlacement (&wp);
|
|
if (wp.showCmd == SW_SHOWNORMAL)
|
|
{
|
|
_Environnement.WorldEdY = r.top;
|
|
_Environnement.WorldEdX = r.left;
|
|
_Environnement.WorldEdCY = r.bottom - r.top;
|
|
_Environnement.WorldEdCX = r.right - r.left;
|
|
}
|
|
_WorldEditor->releaseUI ();
|
|
GetMenu()->CheckMenuItem (ID_WINDOWS_WORLDEDITOR, MF_UNCHECKED);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openGeorges ()
|
|
{
|
|
if (_Georges == NULL) return;
|
|
if (_Environnement.GeorgesOpened)
|
|
return;
|
|
_Environnement.GeorgesOpened = true;
|
|
if (_Georges != NULL)
|
|
{
|
|
_Georges->initUILight (SW_SHOW, _Environnement.GeorgesX, _Environnement.GeorgesY,
|
|
_Environnement.GeorgesCX, _Environnement.GeorgesCY);
|
|
}
|
|
GetMenu()->CheckMenuItem (ID_WINDOWS_GEORGES, MF_CHECKED);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openGeorgesFile (const string &fileName)
|
|
{
|
|
if (_Georges == NULL) return;
|
|
georgesSetPathesFromActive ();
|
|
_Georges->LoadDocument (fileName);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::closeGeorges ()
|
|
{
|
|
if (_Georges == NULL) return;
|
|
if (!_Environnement.GeorgesOpened) return;
|
|
|
|
_Environnement.GeorgesOpened = false;
|
|
RECT r;
|
|
CFrameWnd *pFW = (CFrameWnd*)_Georges->getMainFrame();
|
|
pFW->GetWindowRect(&r);
|
|
WINDOWPLACEMENT wp;
|
|
pFW->GetWindowPlacement (&wp);
|
|
if (wp.showCmd == SW_SHOWNORMAL)
|
|
{
|
|
_Environnement.GeorgesY = r.top;
|
|
_Environnement.GeorgesX = r.left;
|
|
_Environnement.GeorgesCY = r.bottom - r.top;
|
|
_Environnement.GeorgesCX = r.right - r.left;
|
|
}
|
|
_Georges->releaseUI ();
|
|
GetMenu()->CheckMenuItem (ID_WINDOWS_GEORGES, MF_UNCHECKED);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::georgesSetPathesFromActive ()
|
|
{
|
|
if (_Georges == NULL) return;
|
|
if (_ActivePath == "")
|
|
{
|
|
string sDir;
|
|
sDir = _Environnement.ContinentsDir;
|
|
_Georges->SetDirLevel (sDir);
|
|
|
|
_Georges->SetDirDfnTyp (_Environnement.DefaultDFNDir);
|
|
_Georges->SetDirPrototype (_Environnement.DefaultGameElemDir);
|
|
}
|
|
else
|
|
{
|
|
string sDir;
|
|
|
|
int i = 0;
|
|
if (_ActivePath[i] == '\\') ++i;
|
|
for (; i < (int)_ActivePath.size(); ++i)
|
|
{
|
|
if (_ActivePath[i] == '\\') break;
|
|
sDir += _ActivePath[i];
|
|
}
|
|
|
|
sDir = _Environnement.ContinentsDir + sDir + "\\";
|
|
|
|
_Georges->SetDirLevel (sDir);
|
|
|
|
SContinentCfg cfg;
|
|
string sTmp = sDir + "continent.cfg";
|
|
cfg.load (sTmp.c_str());
|
|
_Georges->SetDirDfnTyp (cfg.DfnDir);
|
|
_Georges->SetDirPrototype (cfg.GameElemDir);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/*
|
|
void CMainFrame::georgesUpdatePatatoid ()
|
|
{
|
|
if (_Georges == NULL) return;
|
|
if ((_ActiveWorld == "") || (_ActiveContinent == "") || (_ActiveRegion == "")) return;
|
|
|
|
string sCurDir;
|
|
if (_ActiveWorld == "Continents")
|
|
sCurDir = _Environnement.ContinentsDir;
|
|
else if (_ActiveWorld == "Trash")
|
|
sCurDir = _Environnement.TrashDir;
|
|
else if (_ActiveWorld == "Backup")
|
|
sCurDir = _Environnement.BackupDir;
|
|
sCurDir += _ActiveContinent + "\\" + _ActiveRegion + "\\";
|
|
_Georges->SetDirLevel (sCurDir);
|
|
|
|
if (_ActiveContinent != "")
|
|
_Georges->SetTypPredef (sCurDir + "tmp\\patat_name.typ", _MasterCB.getAllPrimZoneNames());
|
|
}
|
|
*/
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::georgesPutGroupText (const std::vector<std::string> &vText, bool append)
|
|
{
|
|
if (_Georges == NULL) return;
|
|
_Georges->PutGroupText (vText, append);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::georgesPutText (const std::string &sText)
|
|
{
|
|
if (_Georges == NULL) return;
|
|
_Georges->PutText (sText);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::georgesLineUp ()
|
|
{
|
|
if (_Georges == NULL) return;
|
|
_Georges->LineUp ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::georgesLineDown ()
|
|
{
|
|
if (_Georges == NULL) return;
|
|
_Georges->LineDown ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/*
|
|
void CMainFrame::georgesCreateFilesWhenNewRegion ()
|
|
{
|
|
// When we arrive in this function the current directory is the new Continent being created
|
|
if (_Georges == NULL)
|
|
return;
|
|
|
|
CreateDirectory ("tmp", NULL);
|
|
char curdir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, curdir);
|
|
string fullname = string(curdir) + "\\tmp\\patat_name.typ";
|
|
vector< pair< string, string > > lpsx;
|
|
vector< pair< string, string > > lpsx2;
|
|
lpsx.push_back (make_pair(string("PatatFrite"), string("PatatFrite")));
|
|
lpsx.push_back (make_pair(string("PatatVapeur"), string("PatatVapeur")));
|
|
_Georges->MakeTyp (fullname, "String", "PATAT", "true", "", "", "PatatFrite", &lpsx, &lpsx2);
|
|
}
|
|
*/
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::georgesCreatePlantName ()
|
|
{
|
|
if (_Georges == NULL) return;
|
|
WIN32_FIND_DATA fdTmp;
|
|
char curdir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, curdir);
|
|
|
|
try
|
|
{
|
|
string plantname = _Environnement.DefaultDFNDir;
|
|
if (!SetCurrentDirectory(plantname.c_str()))
|
|
return;
|
|
|
|
plantname += "tmp\\plant_name.typ";
|
|
|
|
// If plantname file do not already exists
|
|
HANDLE hFind = FindFirstFile(plantname.c_str(), &fdTmp);
|
|
if (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
FindClose (hFind);
|
|
if (!DeleteFile (plantname.c_str()))
|
|
{
|
|
MessageBox (plantname.c_str(), "Cannot overwrite");
|
|
return;
|
|
}
|
|
}
|
|
|
|
vector< pair< string, string > > lpsx;
|
|
vector< pair< string, string > > lpsx2;
|
|
lpsx.push_back (std::make_pair(string("xxx.plant"), string("xxx.plant")));
|
|
lpsx.push_back (std::make_pair(string("yyy.plant"), string("yyy.plant")));
|
|
_Georges->MakeTyp (plantname, String, FileBrowser, "", "", "xxx.plant", &lpsx);
|
|
|
|
// Parse the plant directory and add all these predef
|
|
string plantdir = _Environnement.DefaultGameElemDir;
|
|
if (!SetCurrentDirectory (plantdir.c_str()))
|
|
return;
|
|
|
|
vector<string> allPlants;
|
|
CExport::getAllFiles (".plant", allPlants);
|
|
|
|
for (uint32 i = 0; i < allPlants.size(); ++i)
|
|
{
|
|
char fName[_MAX_FNAME];
|
|
char ext[_MAX_FNAME];
|
|
::_splitpath((const char*)allPlants[i].c_str(), NULL, NULL, fName, ext);
|
|
allPlants[i] = string(fName) + string(ext);
|
|
}
|
|
|
|
// todo Hulud : handle this another way..
|
|
// _Georges->SetTypPredef ("plant_name.typ", allPlants);
|
|
}
|
|
catch(NLMISC::Exception &e)
|
|
{
|
|
MessageBox (e.what(), "Warning", MB_ICONERROR|MB_OK);
|
|
}
|
|
SetCurrentDirectory (curdir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openLogicEditor ()
|
|
{
|
|
if (_Environnement.LogicEditorOpened)
|
|
return;
|
|
_Environnement.LogicEditorOpened = true;
|
|
if (_LogicEditor != NULL)
|
|
_LogicEditor->initUILight (_Environnement.LogicEditorX, _Environnement.LogicEditorY,
|
|
_Environnement.LogicEditorCX, _Environnement.LogicEditorCY);
|
|
GetMenu()->CheckMenuItem (ID_WINDOWS_LOGICEDITOR, MF_CHECKED);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::openLogicEditorFile (const string &fileName)
|
|
{
|
|
_LogicEditor->loadFile (fileName.c_str());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::closeLogicEditor ()
|
|
{
|
|
if (!_Environnement.LogicEditorOpened)
|
|
return;
|
|
_Environnement.LogicEditorOpened = false;
|
|
RECT r;
|
|
CFrameWnd *pFW = (CFrameWnd*)_LogicEditor->getMainFrame();
|
|
pFW->GetWindowRect(&r);
|
|
WINDOWPLACEMENT wp;
|
|
pFW->GetWindowPlacement (&wp);
|
|
if (wp.showCmd == SW_SHOWNORMAL)
|
|
{
|
|
_Environnement.LogicEditorY = r.top;
|
|
_Environnement.LogicEditorX = r.left;
|
|
_Environnement.LogicEditorCY = r.bottom - r.top;
|
|
_Environnement.LogicEditorCX = r.right - r.left;
|
|
}
|
|
_LogicEditor->releaseUI ();
|
|
GetMenu()->CheckMenuItem (ID_WINDOWS_LOGICEDITOR, MF_UNCHECKED);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::updateTree()
|
|
{
|
|
_Tree->update (_Environnement.ContinentsDir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::deltree (const std::string &dirName)
|
|
{
|
|
// Get all directory object
|
|
vector<string> toremovelist;
|
|
WIN32_FIND_DATA findData;
|
|
HANDLE hFind;
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
if (!SetCurrentDirectory (dirName.c_str()))
|
|
return;
|
|
hFind = FindFirstFile ("*.*", &findData);
|
|
while (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
// Look if the name is a system directory
|
|
if ((stricmp (findData.cFileName, ".") != 0) && (stricmp (findData.cFileName, "..") != 0))
|
|
{
|
|
if (findData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
// If this is a directory deltree and delete the directory
|
|
deltree (findData.cFileName);
|
|
toremovelist.push_back (findData.cFileName);
|
|
}
|
|
else
|
|
{
|
|
// If this is a file delete
|
|
if (!DeleteFile (findData.cFileName))
|
|
displayLastErrorDialog ();
|
|
}
|
|
}
|
|
if (FindNextFile (hFind, &findData) == 0)
|
|
break;
|
|
}
|
|
FindClose (hFind);
|
|
SetCurrentDirectory (dirName.c_str());
|
|
for (uint32 i = 0; i < toremovelist.size(); ++i)
|
|
{
|
|
if (!RemoveDirectory (toremovelist[i].c_str()))
|
|
displayLastErrorDialog ();
|
|
}
|
|
SetCurrentDirectory (sCurDir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::displayLastErrorDialog ()
|
|
{
|
|
LPVOID lpMsgBuf;
|
|
FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
(LPTSTR) &lpMsgBuf, 0, NULL);
|
|
// Display the string.
|
|
MessageBox ((LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONERROR);
|
|
// Free the buffer.
|
|
LocalFree (lpMsgBuf);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/*int getMaxTag(const std::string &dirName, const std::string &tagName)
|
|
{
|
|
WIN32_FIND_DATA findData;
|
|
HANDLE hFind;
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
SetCurrentDirectory (dirName.c_str());
|
|
string tmp = tagName + "*";
|
|
hFind = FindFirstFile (tmp.c_str(), &findData);
|
|
int ret = 0;
|
|
while (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
int nb = (findData.cFileName[tagName.size()+0]-'0')*100 +
|
|
(findData.cFileName[tagName.size()+1]-'0')*10 +
|
|
(findData.cFileName[tagName.size()+2]-'0')*1;
|
|
if (nb > ret)
|
|
ret = nb;
|
|
if (FindNextFile (hFind, &findData) == 0)
|
|
break;
|
|
}
|
|
FindClose (hFind);
|
|
SetCurrentDirectory (sCurDir);
|
|
return ret;
|
|
}*/
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::copytree (const string &srcDir, const string &dstDir)
|
|
{
|
|
WIN32_FIND_DATA findData;
|
|
HANDLE hFind;
|
|
string tmp = srcDir + "\\*";
|
|
hFind = FindFirstFile (tmp.c_str(), &findData);
|
|
while (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
bool bFound = false;
|
|
for (uint32 i = 0; i < MAX_SYS_DIR; ++i)
|
|
if (stricmp (findData.cFileName, gSysDir[i]) == 0)
|
|
{
|
|
bFound = true;
|
|
break;
|
|
}
|
|
if (!bFound)
|
|
{
|
|
if (findData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
string newDirSrc = srcDir + "\\" + findData.cFileName;
|
|
string newDirDst = dstDir + "\\" + findData.cFileName;
|
|
if (!CreateDirectory(newDirDst.c_str(), NULL))
|
|
displayLastErrorDialog ();
|
|
copytree (newDirSrc, newDirDst);
|
|
}
|
|
else
|
|
{
|
|
string fnameSrc = srcDir + "\\" + findData.cFileName;
|
|
string fnameDst = dstDir + "\\" + findData.cFileName;
|
|
if (!CopyFile(fnameSrc.c_str(), fnameDst.c_str(), false))
|
|
displayLastErrorDialog ();
|
|
}
|
|
}
|
|
|
|
if (FindNextFile (hFind, &findData) == 0)
|
|
break;
|
|
}
|
|
FindClose (hFind);
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::continentDelete (const string &contName)
|
|
{
|
|
string srcDir = _Environnement.ContinentsDir + contName;
|
|
deltree (srcDir);
|
|
RemoveDirectory (srcDir.c_str());
|
|
updateTree ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::regionOpen (const string &path)
|
|
{
|
|
setActivePath (path);
|
|
openDir (path);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::regionRename (const string &path)
|
|
{
|
|
if (path == "") return;
|
|
int pos = path.rfind('\\');
|
|
if (pos == string::npos) return;
|
|
string smallpath;
|
|
int i;
|
|
for (i = 0; i <= pos; ++i)
|
|
smallpath += path[i];
|
|
string dirname;
|
|
for (; i < (int)path.size(); ++i)
|
|
dirname += path[i];
|
|
smallpath = _Environnement.ContinentsDir + smallpath;
|
|
char curdir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, curdir);
|
|
SetCurrentDirectory (smallpath.c_str());
|
|
|
|
CNameEditDlg dlg;
|
|
dlg.Title = "Change the directory name";
|
|
dlg.Comment = "Enter the new directory name";
|
|
dlg.Name = dirname.c_str();
|
|
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
if (!MoveFile (dirname.c_str(), dlg.Name))
|
|
displayLastErrorDialog ();
|
|
}
|
|
|
|
SetCurrentDirectory (curdir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::regionNewPrim (const string &path)
|
|
{
|
|
if (path == "") return;
|
|
if (_WorldEditor == NULL) return;
|
|
|
|
// Ask the name to the user
|
|
CNameEditDlg dlg;
|
|
dlg.Title = "New Prim File Name";
|
|
dlg.Comment = "Enter the name of the new .PRIM file";
|
|
dlg.Name = "NewPrim";
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
string primname = dlg.Name;
|
|
if (primname != "")
|
|
{
|
|
string sTmp = _Environnement.ContinentsDir + path + "\\" + primname;
|
|
_WorldEditor->createEmptyPrimFile (sTmp.c_str());
|
|
updateTree ();
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::regionNewGeorges (const string &path)
|
|
{
|
|
if (path == "")
|
|
return;
|
|
if (_Georges == NULL)
|
|
return;
|
|
|
|
// Ask the user the .dfn to use
|
|
CNameEditDlg dlg;
|
|
dlg.Title = "New Form File Name";
|
|
dlg.Comment = "Enter the name of the new Form file";
|
|
dlg.Name = "NewForm";
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
char curdir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, curdir);
|
|
|
|
// setActivePath (path);
|
|
|
|
// \todo load from the continent.cfg
|
|
string newDir = _Georges->GetDirDfnTyp ();
|
|
|
|
CFileDialog fd (true, "*.dfn", NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,
|
|
"Definition (*.dfn)|*.dfn", this);
|
|
fd.m_ofn.lpstrInitialDir = newDir.c_str();
|
|
if (fd.DoModal() == IDOK)
|
|
{
|
|
string sTmp = _Environnement.ContinentsDir + path + "\\" + (LPCSTR)dlg.Name;
|
|
_Georges->createInstanceFile (sTmp, (LPCSTR)fd.GetFileName());
|
|
}
|
|
|
|
SetCurrentDirectory (curdir);
|
|
updateTree ();
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::regionNewSubRegion (const std::string &path)
|
|
{
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
|
|
CNameEditDlg dlg(this);
|
|
dlg.Title = "New Sub Region";
|
|
dlg.Comment = "Enter the name of the new sub region";
|
|
dlg.Name = "NewSubRegion";
|
|
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
if (dlg.Name != "")
|
|
{
|
|
string tmpDir = _Environnement.ContinentsDir + path;
|
|
SetCurrentDirectory (tmpDir.c_str());
|
|
CreateDirectory ((LPCSTR)dlg.Name, NULL);
|
|
SetCurrentDirectory (dlg.Name);
|
|
updateTree ();
|
|
}
|
|
}
|
|
|
|
SetCurrentDirectory (sCurDir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::regionDelete (const std::string &path)
|
|
{
|
|
string srcDir = _Environnement.ContinentsDir + path;
|
|
deltree (srcDir);
|
|
if (!RemoveDirectory (srcDir.c_str()))
|
|
displayLastErrorDialog ();
|
|
updateTree ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::fileOpen (const std::string &sFileFullName)
|
|
{
|
|
openFile (sFileFullName);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::fileRename (const std::string &sFileFullName)
|
|
{
|
|
if (sFileFullName == "") return;
|
|
int pos = sFileFullName.rfind('\\');
|
|
if (pos == string::npos) return;
|
|
string smallpath;
|
|
int i;
|
|
for (i = 0; i <= pos; ++i)
|
|
smallpath += sFileFullName[i];
|
|
string filename;
|
|
for (; i < (int)sFileFullName.size(); ++i)
|
|
filename += sFileFullName[i];
|
|
smallpath = _Environnement.ContinentsDir + smallpath;
|
|
char curdir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, curdir);
|
|
SetCurrentDirectory (smallpath.c_str());
|
|
|
|
CNameEditDlg dlg;
|
|
dlg.Title = "Change the name of the file";
|
|
dlg.Comment = "Enter the new file name";
|
|
dlg.Name = filename.c_str();
|
|
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
if (!MoveFile (filename.c_str(), dlg.Name))
|
|
{
|
|
MessageBox ("Cannot rename file", "Error", MB_ICONERROR|MB_OK);
|
|
}
|
|
}
|
|
|
|
SetCurrentDirectory (curdir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::fileDelete (const std::string &sFileFullName)
|
|
{
|
|
if (sFileFullName.size() > 4)
|
|
if (stricmp(&sFileFullName.c_str()[sFileFullName.size()-4], ".cfg") == 0)
|
|
return;
|
|
string fullname = _Environnement.ContinentsDir + sFileFullName;
|
|
DeleteFile (fullname.c_str());
|
|
updateTree ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::copy (const std::string &sPathSrc, const std::string &sPathDst)
|
|
{
|
|
string sSrc = _Environnement.ContinentsDir + sPathSrc;
|
|
string sDst = _Environnement.ContinentsDir + sPathDst;
|
|
|
|
if (GetFileAttributes(sSrc.c_str())&FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
copytree (sSrc, sDst);
|
|
}
|
|
else
|
|
{
|
|
int zepos = sSrc.rfind('\\');
|
|
for (int i = zepos; i < (int)sSrc.size(); ++i)
|
|
sDst += sSrc[i];
|
|
if (!CopyFile (sSrc.c_str(), sDst.c_str(), TRUE))
|
|
displayLastErrorDialog ();
|
|
}
|
|
updateTree();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::setActivePath (const std::string &pathName)
|
|
{
|
|
_ActivePath = pathName;
|
|
if (_ActivePath == "") return;
|
|
string sContinentDir;
|
|
int i = 0;
|
|
if (pathName[i] == '\\') ++i;
|
|
for (; i < (int)pathName.size(); ++i)
|
|
{
|
|
if (pathName[i] == '\\') break;
|
|
sContinentDir += pathName[i];
|
|
}
|
|
|
|
sContinentDir = _Environnement.ContinentsDir + sContinentDir;
|
|
|
|
if (_Georges != NULL)
|
|
{
|
|
georgesSetPathesFromActive ();
|
|
}
|
|
|
|
if ((_Environnement.WorldEdOpened) && (_ActivePath != ""))
|
|
{
|
|
// Open continent.cfg to load the .land
|
|
SContinentCfg cfg;
|
|
string sTmp = sContinentDir + "\\continent.cfg";
|
|
cfg.load (sTmp.c_str());
|
|
_WorldEditor->setDataDir(cfg.LandDir.c_str());
|
|
_WorldEditor->loadFile (cfg.LandFile.c_str());
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::OnSize (UINT nType, int cx, int cy)
|
|
{
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::OnMove (int x, int y)
|
|
{
|
|
RECT r;
|
|
GetWindowRect (&r);
|
|
_Environnement.MasterY = r.top;
|
|
_Environnement.MasterX = r.left;
|
|
if ((_Tree != NULL) && (_Environnement.MasterTreeLocked))
|
|
{
|
|
_Tree->SetWindowPos (&wndTop, x, y, 0, 0, SWP_NOSIZE);
|
|
SetFocus();
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
int CMainFrame::OnCreate (LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
// Create the menu
|
|
if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
|
|
return -1;
|
|
|
|
CoInitialize (NULL);
|
|
|
|
// Create the tree
|
|
_Tree = new CMasterTreeDlg ();
|
|
_Tree->Create (IDD_MASTERTREE, this);
|
|
|
|
// Load tools and get interface
|
|
getAllInterfaces ();
|
|
|
|
// Restore all (windows position and size, menu checked, etc...)
|
|
// TREE
|
|
_Tree->SetWindowPos (&wndTop, _Environnement.MasterTreeX, _Environnement.MasterTreeY,
|
|
_Environnement.MasterTreeCX, _Environnement.MasterTreeCY, SWP_SHOWWINDOW);
|
|
_Tree->ShowWindow (SW_SHOW);
|
|
_Tree->update (_Environnement.ContinentsDir);
|
|
if (_Environnement.MasterTreeLocked)
|
|
GetMenu()->CheckMenuItem (ID_OPTIONS_TREELOCK, MF_CHECKED);
|
|
|
|
// WORLDEDITOR
|
|
if (_WorldEditor != NULL)
|
|
{
|
|
_MasterCB.setMainFrame (this);
|
|
_WorldEditor->setMasterCB (&_MasterCB);
|
|
_WorldEditor->setDataDir (_Environnement.ContinentsDir.c_str());
|
|
}
|
|
if (_Environnement.WorldEdOpened)
|
|
{
|
|
_Environnement.WorldEdOpened = false;
|
|
openWorldEditor ();
|
|
}
|
|
|
|
// GEORGES
|
|
if (_Georges != NULL)
|
|
{
|
|
_Georges->SetDirDfnTyp (_Environnement.DefaultDFNDir);
|
|
_Georges->SetDirPrototype (_Environnement.DefaultGameElemDir);
|
|
georgesCreatePlantName ();
|
|
}
|
|
if (_Environnement.GeorgesOpened)
|
|
{
|
|
_Environnement.GeorgesOpened = false;
|
|
openGeorges ();
|
|
}
|
|
|
|
// LOGICEDITOR
|
|
// if (_LogicEditor != NULL)
|
|
// _LogicEditor->setRootDir (_Environnement.RootDir.c_str());
|
|
if (_Environnement.LogicEditorOpened)
|
|
{
|
|
_Environnement.LogicEditorOpened = false;
|
|
openLogicEditor ();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
BOOL CMainFrame::PreCreateWindow (CREATESTRUCT& cs)
|
|
{
|
|
// Load the config file
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
_MasterExeDir = string(sCurDir) + "\\";
|
|
try
|
|
{
|
|
_Environnement.load (_MasterExeDir+"master.cfg");
|
|
}
|
|
catch (Exception&e)
|
|
{
|
|
MessageBox (e.what(), "Warning");
|
|
}
|
|
|
|
// Restore the master window position
|
|
cs.x = _Environnement.MasterX;
|
|
cs.y = _Environnement.MasterY;
|
|
|
|
if (!CFrameWnd::PreCreateWindow(cs))
|
|
return FALSE;
|
|
|
|
cs.style = WS_OVERLAPPED;
|
|
cs.cx = 360;
|
|
cs.cy = GetSystemMetrics (SM_CYCAPTION) +
|
|
GetSystemMetrics (SM_CYMENU) +
|
|
GetSystemMetrics (SM_CYFRAME);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
BOOL CMainFrame::PreTranslateMessage (MSG*pMsg)
|
|
{
|
|
if (_Georges != NULL)
|
|
{
|
|
CWnd *pWnd = (CWnd*)_Georges->getMainFrame();
|
|
CWnd *pFocusWnd = CWnd::GetFocus();
|
|
if (pWnd != NULL)
|
|
{
|
|
while (pFocusWnd != NULL)
|
|
{
|
|
if (pWnd->m_hWnd == pFocusWnd->m_hWnd)
|
|
return _Georges->PreTranslateMessage (pMsg);
|
|
pFocusWnd = pFocusWnd->GetParent();
|
|
}
|
|
}
|
|
}
|
|
return CFrameWnd::PreTranslateMessage (pMsg);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
BOOL CMainFrame::OnEraseBkgnd (CDC* pDC)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
bool CMainFrame::createDirIfNotExist (const string& dirName, const string& errorMsg)
|
|
{
|
|
char sCurDir[MAX_PATH];
|
|
SECURITY_ATTRIBUTES sa;
|
|
sa.nLength = sizeof(sa);
|
|
sa.lpSecurityDescriptor = NULL;
|
|
sa.bInheritHandle = true;
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
if (!SetCurrentDirectory (dirName.c_str()))
|
|
{
|
|
if (!CreateDirectory (dirName.c_str(), &sa))
|
|
{
|
|
MessageBox (errorMsg.c_str(), "Error", MB_ICONERROR|MB_OK);
|
|
SetCurrentDirectory (sCurDir);
|
|
return false;
|
|
}
|
|
}
|
|
SetCurrentDirectory (sCurDir);
|
|
return true;
|
|
}
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::continentNew ()
|
|
{
|
|
if (!createDirIfNotExist (_Environnement.ContinentsDir, "Cannot create Continents system directory"))
|
|
return;
|
|
|
|
// Create the new continent
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
SetCurrentDirectory (_Environnement.ContinentsDir.c_str());
|
|
CreateDirectory ("NewContinent", NULL);
|
|
SContinentCfg cfg;
|
|
cfg.save ("NewContinent\\continent.cfg");
|
|
|
|
SetCurrentDirectory (_Environnement.ContinentsDir.c_str());
|
|
SetCurrentDirectory ("NewContinent");
|
|
|
|
// Ok so now create default files
|
|
// _WorldEditor->createDefaultFiles (newDirName.c_str());
|
|
// georgesCreateFilesWhenNewContinent ();
|
|
|
|
continentProperties ("NewContinent");
|
|
|
|
_Tree->update (_Environnement.ContinentsDir);
|
|
SetCurrentDirectory (sCurDir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::continentOpen (const std::string &contName)
|
|
{
|
|
setActivePath (contName);
|
|
openDir (contName);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::continentProperties (const string &contName)
|
|
{
|
|
CContinentPropertiesDlg cp(this);
|
|
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
|
|
string worldDir;
|
|
worldDir = _Environnement.ContinentsDir;
|
|
|
|
if (!SetCurrentDirectory (worldDir.c_str()))
|
|
return;
|
|
if (!SetCurrentDirectory (contName.c_str()))
|
|
return;
|
|
|
|
SContinentCfg cfg;
|
|
cfg.load ("continent.cfg");
|
|
|
|
cp.ContinentName = contName.c_str();
|
|
|
|
cp.LandFile = cfg.LandFile.c_str();
|
|
cp.LandDir = cfg.LandDir.c_str();
|
|
cp.DfnDir = cfg.DfnDir.c_str();
|
|
cp.GameElemDir = cfg.GameElemDir.c_str();
|
|
|
|
cp.LandBankFile = cfg.LandBankFile.c_str();
|
|
cp.LandFarBankFile = cfg.LandFarBankFile.c_str();
|
|
cp.LandTileNoiseDir = cfg.LandTileNoiseDir.c_str();
|
|
cp.LandZoneWDir = cfg.LandZoneWDir.c_str();
|
|
cp.OutIGDir = cfg.OutIGDir.c_str();
|
|
|
|
if (cp.DoModal() == IDOK)
|
|
{
|
|
cfg.LandFile = cp.LandFile;
|
|
cfg.LandDir = cp.LandDir;
|
|
cfg.DfnDir = cp.DfnDir;
|
|
cfg.GameElemDir = cp.GameElemDir;
|
|
|
|
cfg.LandBankFile = cp.LandBankFile;
|
|
cfg.LandFarBankFile = cp.LandFarBankFile;
|
|
cfg.LandTileNoiseDir = cp.LandTileNoiseDir;
|
|
cfg.LandZoneWDir = cp.LandZoneWDir;
|
|
cfg.OutIGDir = cp.OutIGDir;
|
|
|
|
SetCurrentDirectory (worldDir.c_str());
|
|
SetCurrentDirectory (contName.c_str());
|
|
cfg.save ("continent.cfg");
|
|
if (cp.ContinentName != CString(contName.c_str()))
|
|
{
|
|
// Rename the directory
|
|
SetCurrentDirectory (worldDir.c_str());
|
|
if (!MoveFile (contName.c_str(), cp.ContinentName))
|
|
{
|
|
MessageBox ("Cannot rename directory", "Error", MB_ICONERROR|MB_OK);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetCurrentDirectory (_Environnement.ContinentsDir.c_str());
|
|
deltree ("NewContinent");
|
|
RemoveDirectory("NewContinent");
|
|
}
|
|
SetCurrentDirectory (sCurDir);
|
|
updateTree ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::continentNewRegion (const string &contName)
|
|
{
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
|
|
CNameEditDlg dlg(this);
|
|
dlg.Title = "New Region";
|
|
dlg.Comment = "Enter the name of the new region";
|
|
dlg.Name = "NewRegion";
|
|
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
if (dlg.Name != "")
|
|
{
|
|
string tmpDir = _Environnement.ContinentsDir + contName;
|
|
SetCurrentDirectory (tmpDir.c_str());
|
|
CreateDirectory ((LPCSTR)dlg.Name, NULL);
|
|
SetCurrentDirectory (dlg.Name);
|
|
updateTree ();
|
|
}
|
|
}
|
|
|
|
SetCurrentDirectory (sCurDir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Save all in all modules
|
|
void CMainFrame::onContinentSave ()
|
|
{
|
|
if (_Environnement.WorldEdOpened)
|
|
{
|
|
if (_WorldEditor)
|
|
_WorldEditor->saveOpenedFiles();
|
|
}
|
|
if (_Environnement.GeorgesOpened)
|
|
{
|
|
// if (_Georges)
|
|
// _Georges->saveOpenedFiles();
|
|
}
|
|
if (_Environnement.LogicEditorOpened)
|
|
{
|
|
// if (_LogicEditor)
|
|
// _LogicEditor->saveOpenedFiles();
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onContinentExport ()
|
|
{
|
|
onContinentSave ();
|
|
|
|
char sCurDir[MAX_PATH];
|
|
GetCurrentDirectory (MAX_PATH, sCurDir);
|
|
string sTmp = _Environnement.ContinentsDir;
|
|
SetCurrentDirectory (sTmp.c_str());
|
|
|
|
vector<string> vRegNames;
|
|
WIN32_FIND_DATA fd;
|
|
HANDLE hFind = FindFirstFile ("*.*", &fd);
|
|
while (hFind != INVALID_HANDLE_VALUE)
|
|
{
|
|
bool bFound = false;
|
|
for (uint32 i = 0; i < MAX_SYS_DIR; ++i)
|
|
if (stricmp (fd.cFileName, gSysDir[i]) == 0)
|
|
{
|
|
bFound = true;
|
|
break;
|
|
}
|
|
if (!bFound)
|
|
{
|
|
if ((fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) != 0)
|
|
{
|
|
vRegNames.push_back (string(fd.cFileName));
|
|
}
|
|
}
|
|
if (FindNextFile (hFind, &fd) == 0)
|
|
break;
|
|
}
|
|
FindClose (hFind);
|
|
|
|
if (vRegNames.size() == 0)
|
|
return;
|
|
|
|
CExportDlg dlg (this);
|
|
|
|
// _Environnement.ExportOptions.SourceDir = _ActiveContinent;
|
|
dlg.setOptions (_Environnement.ExportOptions, vRegNames);
|
|
if (dlg.DoModal() == IDOK)
|
|
{
|
|
if (_ExportCBDlg != NULL)
|
|
_ExportCBDlg->DestroyWindow();
|
|
_ExportCBDlg = new CExportCBDlg();
|
|
//Check if new succeeded and we got a valid pointer to a dialog object
|
|
if (_Export == NULL)
|
|
_Export = new CExport;
|
|
if (_ExportCBDlg != NULL)
|
|
{
|
|
BOOL ret = _ExportCBDlg->Create (IDD_EXPORTCB, this);
|
|
if (!ret) //Create failed.
|
|
{
|
|
delete _ExportCBDlg;
|
|
_ExportCBDlg = NULL;
|
|
}
|
|
_ExportCBDlg->ShowWindow (SW_SHOW);
|
|
}
|
|
|
|
_Environnement.ExportOptions.PrimFloraDir = _Environnement.ContinentsDir + _Environnement.ExportOptions.PrimFloraDir;
|
|
|
|
SetCurrentDirectory (_MasterExeDir.c_str());
|
|
try
|
|
{
|
|
_Environnement.save (_MasterExeDir+"master.cfg");
|
|
|
|
_Export->newExport (_Environnement.ExportOptions, _ExportCBDlg->getExportCB());
|
|
|
|
}
|
|
catch(Exception&e)
|
|
{
|
|
MessageBox (e.what(), "Error", MB_ICONERROR|MB_OK);
|
|
}
|
|
|
|
_ExportCBDlg->setFinishedButton ();
|
|
while (_ExportCBDlg->getFinished () == false)
|
|
{
|
|
_ExportCBDlg->pump ();
|
|
}
|
|
_ExportCBDlg->DestroyWindow ();
|
|
}
|
|
SetCurrentDirectory (sCurDir);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
/*void CMainFrame::OnContinentDelete ()
|
|
{
|
|
CChooseDir chooseDir(this);
|
|
chooseDir.setPath (_Environnement.ContinentsDir);
|
|
if (chooseDir.DoModal() == IDOK)
|
|
{
|
|
continentDelete (chooseDir.getSelected());
|
|
}
|
|
}*/
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onOptionsTreeLock ()
|
|
{
|
|
_Environnement.MasterTreeLocked = !_Environnement.MasterTreeLocked;
|
|
if (_Environnement.MasterTreeLocked)
|
|
{
|
|
GetMenu()->CheckMenuItem (ID_OPTIONS_TREELOCK, MF_CHECKED);
|
|
_Tree->SetWindowPos (&wndTop, _Environnement.MasterX, _Environnement.MasterY+45, 0, 0, SWP_NOSIZE);
|
|
SetFocus();
|
|
}
|
|
else
|
|
GetMenu()->CheckMenuItem (ID_OPTIONS_TREELOCK, MF_UNCHECKED);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
int CALLBACK BrowseCallbackProc (HWND hwnd,UINT uMsg,LPARAM lp, LPARAM pData)
|
|
{
|
|
switch(uMsg)
|
|
{
|
|
case BFFM_INITIALIZED:
|
|
SendMessage (hwnd, BFFM_SETSELECTION, TRUE, pData);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onOptionsSetContinentsDir ()
|
|
{
|
|
BROWSEINFO bi;
|
|
char str[MAX_PATH];
|
|
ITEMIDLIST* pidl;
|
|
char sTemp[1024];
|
|
|
|
bi.hwndOwner = this->m_hWnd;
|
|
bi.pidlRoot = NULL;
|
|
bi.pidlRoot = NULL;
|
|
bi.pszDisplayName = sTemp;;
|
|
bi.lpszTitle = "Choose the continents path";
|
|
bi.ulFlags = 0;
|
|
bi.lpfn = BrowseCallbackProc;
|
|
|
|
char sDir[512];
|
|
strcpy(sDir, _Environnement.ContinentsDir.c_str());
|
|
bi.lParam = (LPARAM)sDir;
|
|
|
|
bi.iImage = 0;
|
|
pidl = SHBrowseForFolder (&bi);
|
|
if (!SHGetPathFromIDList(pidl, str))
|
|
{
|
|
return;
|
|
}
|
|
_Environnement.ContinentsDir = str;
|
|
if (_Environnement.ContinentsDir[_Environnement.ContinentsDir.size()-1] != '\\')
|
|
_Environnement.ContinentsDir += "\\";
|
|
// TREE
|
|
_Tree->update (_Environnement.ContinentsDir);
|
|
// WORLDEDITOR
|
|
if (_WorldEditor != NULL)
|
|
_WorldEditor->setDataDir (_Environnement.ContinentsDir.c_str());
|
|
// GEORGES
|
|
if (_Georges != NULL)
|
|
{
|
|
//_Georges->SetRootDirectory (_Environnement.RootDir + "common");
|
|
//_Georges->SetWorkDirectory (_Environnement.RootDir + "common\\dfn");
|
|
georgesCreatePlantName ();
|
|
}
|
|
// LOGICEDITOR
|
|
// if (_LogicEditor != NULL)
|
|
// _LogicEditor->setRootDir (_Environnement.RootDir.c_str());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onOptionsSetDefaultDFNDir ()
|
|
{
|
|
BROWSEINFO bi;
|
|
char str[MAX_PATH];
|
|
ITEMIDLIST* pidl;
|
|
char sTemp[1024];
|
|
|
|
bi.hwndOwner = this->m_hWnd;
|
|
bi.pidlRoot = NULL;
|
|
bi.pidlRoot = NULL;
|
|
bi.pszDisplayName = sTemp;;
|
|
bi.lpszTitle = "Choose the default DFN path";
|
|
bi.ulFlags = 0;
|
|
bi.lpfn = BrowseCallbackProc;
|
|
|
|
char sDir[512];
|
|
strcpy(sDir, _Environnement.DefaultDFNDir.c_str());
|
|
bi.lParam = (LPARAM)sDir;
|
|
|
|
bi.iImage = 0;
|
|
pidl = SHBrowseForFolder (&bi);
|
|
if (!SHGetPathFromIDList(pidl, str))
|
|
{
|
|
return;
|
|
}
|
|
_Environnement.DefaultDFNDir = str;
|
|
if (_Environnement.DefaultDFNDir[_Environnement.DefaultDFNDir.size()-1] != '\\')
|
|
_Environnement.DefaultDFNDir += "\\";
|
|
|
|
// GEORGES
|
|
if (_Georges != NULL)
|
|
{
|
|
_Georges->SetDirDfnTyp (_Environnement.DefaultDFNDir);
|
|
georgesCreatePlantName ();
|
|
}
|
|
// LOGICEDITOR
|
|
// if (_LogicEditor != NULL)
|
|
// _LogicEditor->setRootDir (_Environnement.RootDir.c_str());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onOptionsSetDefaultGameElemDir ()
|
|
{
|
|
BROWSEINFO bi;
|
|
char str[MAX_PATH];
|
|
ITEMIDLIST* pidl;
|
|
char sTemp[1024];
|
|
|
|
bi.hwndOwner = this->m_hWnd;
|
|
bi.pidlRoot = NULL;
|
|
bi.pidlRoot = NULL;
|
|
bi.pszDisplayName = sTemp;;
|
|
bi.lpszTitle = "Choose the default GameElem path";
|
|
bi.ulFlags = 0;
|
|
bi.lpfn = BrowseCallbackProc;
|
|
|
|
char sDir[512];
|
|
strcpy(sDir, _Environnement.DefaultGameElemDir.c_str());
|
|
bi.lParam = (LPARAM)sDir;
|
|
|
|
bi.iImage = 0;
|
|
pidl = SHBrowseForFolder (&bi);
|
|
if (!SHGetPathFromIDList(pidl, str))
|
|
{
|
|
return;
|
|
}
|
|
_Environnement.DefaultGameElemDir = str;
|
|
if (_Environnement.DefaultGameElemDir[_Environnement.DefaultGameElemDir.size()-1] != '\\')
|
|
_Environnement.DefaultGameElemDir += "\\";
|
|
|
|
// GEORGES
|
|
if (_Georges != NULL)
|
|
{
|
|
_Georges->SetDirPrototype (_Environnement.DefaultGameElemDir);
|
|
georgesCreatePlantName ();
|
|
}
|
|
// LOGICEDITOR
|
|
// if (_LogicEditor != NULL)
|
|
// _LogicEditor->setRootDir (_Environnement.RootDir.c_str());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onWindowsWorldEditor ()
|
|
{
|
|
if (!_Environnement.WorldEdOpened)
|
|
openWorldEditor ();
|
|
else
|
|
closeWorldEditor ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onWindowsGeorges ()
|
|
{
|
|
if (!_Environnement.GeorgesOpened)
|
|
openGeorges ();
|
|
else
|
|
closeGeorges ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onWindowsLogicEditor ()
|
|
{
|
|
if (!_Environnement.LogicEditorOpened)
|
|
openLogicEditor ();
|
|
else
|
|
closeLogicEditor ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::onWindowsReset ()
|
|
{
|
|
bool redo = false;
|
|
|
|
redo = (_Environnement.WorldEdOpened == true);
|
|
closeWorldEditor ();
|
|
_Environnement.WorldEdX = 50;
|
|
_Environnement.WorldEdY = 50;
|
|
_Environnement.WorldEdCX = 600;
|
|
_Environnement.WorldEdCY = 400;
|
|
if (redo)
|
|
openWorldEditor ();
|
|
|
|
redo = (_Environnement.GeorgesOpened == true);
|
|
closeGeorges ();
|
|
_Environnement.GeorgesX = 50;
|
|
_Environnement.GeorgesY = 50;
|
|
_Environnement.GeorgesCX = 300;
|
|
_Environnement.GeorgesCY = 300;
|
|
if (redo)
|
|
openGeorges ();
|
|
|
|
redo = (_Environnement.LogicEditorOpened == true);
|
|
closeLogicEditor ();
|
|
_Environnement.LogicEditorX = 50;
|
|
_Environnement.LogicEditorY = 50;
|
|
_Environnement.LogicEditorCX = 300;
|
|
_Environnement.LogicEditorCY = 300;
|
|
if (redo)
|
|
openLogicEditor ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
void CMainFrame::OnClose ()
|
|
{
|
|
RECT r;
|
|
|
|
// Master Tree saves
|
|
_Tree->GetWindowRect (&r);
|
|
_Environnement.MasterTreeX = r.left;
|
|
_Environnement.MasterTreeY = r.top;
|
|
_Environnement.MasterTreeCX = r.right-r.left;
|
|
_Environnement.MasterTreeCY = r.bottom-r.top;
|
|
|
|
// WorldEditor saves
|
|
if (_Environnement.WorldEdOpened)
|
|
{
|
|
closeWorldEditor ();
|
|
_Environnement.WorldEdOpened = true;
|
|
}
|
|
|
|
// Georges saves
|
|
if (_Environnement.GeorgesOpened)
|
|
{
|
|
closeGeorges ();
|
|
_Environnement.GeorgesOpened = true;
|
|
}
|
|
|
|
// LogicEditor saves
|
|
if (_Environnement.LogicEditorOpened)
|
|
{
|
|
closeLogicEditor ();
|
|
_Environnement.LogicEditorOpened = true;
|
|
}
|
|
|
|
// Save the environnement
|
|
SetCurrentDirectory (_MasterExeDir.c_str());
|
|
try
|
|
{
|
|
_Environnement.save (_MasterExeDir+"master.cfg");
|
|
}
|
|
catch(Exception&e)
|
|
{
|
|
MessageBox (e.what(), "Error", MB_ICONERROR|MB_OK);
|
|
}
|
|
|
|
releaseAllInterfaces ();
|
|
|
|
DestroyWindow();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMainFrame diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CMainFrame::AssertValid() const
|
|
{
|
|
CFrameWnd::AssertValid();
|
|
}
|
|
|
|
void CMainFrame::Dump(CDumpContext& dc) const
|
|
{
|
|
CFrameWnd::Dump(dc);
|
|
}
|
|
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMainFrame message handlers
|
|
|