// 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