aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-24 01:48:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/ryzom/tools/leveldesign/master/MainFrm.cpp

1936 lines
54 KiB
C++
Raw Normal View History

Merge default to gsoc2011-guildmissions
2011-05-30 15:05:13 +00:00
// 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
Reference in a new issue Copy permalink