ViewVC Help

View File | Revision Log | View Changeset | Root Listing

root/Oni2/AE/Installer/trunk/source/installer.cpp

Comparing AE/Installer/trunk/source/installer.cpp (file contents):
Revision 502 by iritscen, Mon Mar 22 16:51:50 2010 UTC vs.
Revision 551 by gumby, Thu May 27 20:30:35 2010 UTC

#	Line 17 | Line 17
17		#include "boost/date_time/gregorian/gregorian.hpp"
18		#include "boost/date_time/date_parsing.hpp"
19		#include "boost/date_time/posix_time/posix_time.hpp"
20	+	#include <boost/algorithm/string.hpp>
21		#include "installer.h"
22		#include "aeinstallerapp.h"
23
#	Line 26 | Line 27 | using namespace boost::posix_time;
27		// externs declared in installer.h
28		string strInstallCfg = "../GameDataFolder/Add.cfg";
29		string strEUFN = "Edition"; // GetUpdateStatus() may set this to "Edition-patch" later, but this is the assumed name of the new Edition folder in Updates/
30	+	extern MainWindow* TheWindow;
31
32		int globalizeData(void)
33		{
#	Line 230 | Line 232 | int globalizeData(void)
232
233
234		if ( strcmp(levels[i].c_str(), "0") ){
235	<	system((strOniSplit + " -move:overwrite ../GameDataFolder/level" + levels[i] + "_Final ../GameDataFolder/level" + levels[i] + "_Final/AKEV/AKEV*.oni").c_str());
235	>	system((strOniSplit + " -move:overwrite ../GameDataFolder/level" + levels[i] + "_Final ../GameDataFolder/level" + levels[i] +
236	>	"_Final/AKEV/AKEV*.oni").c_str());
237		remove(  "../GameDataFolder/level" + levels[i] + "_Final/AKEV" );
238		}
239
#	Line 244 | Line 247 | int globalizeData(void)
247		for (int i = 0; i < 15; i++)
248		{
249		logfile << "\tReimporting level" << levels[i] << "_Final.oni\n";
250	<	setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + " reimporting level" + levels[i]+"_Final.oni");
250	>	setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + " reimporting level" +
251	>	levels[i] + "_Final.oni");
252		logfile << (strOniSplit + " " + strImportOption + " ../GameDataFolder/level" + levels[i] + "_Final VanillaDats/level" + levels[i] + "_Final/level"
253		+ levels[i] + "_Final/level" + levels[i] + "_Final.oni >> Globalize.log").c_str() << '\n';
254		string sys_str = (strOniSplit + " " + strImportOption + " ../GameDataFolder/level" + levels[i] + "_Final VanillaDats/level" + levels[i] + "_Final/level"
#	Line 269 | Line 273 | int globalizeData(void)
273		setStatusArea("Step " + lexical_cast<std::string>(parts_done + 1) + "/" + lexical_cast<std::string>(total_steps) + ": moving level0_Characters" );
274		copy((path)"../GameDataFolder/level0_Characters", (path)("VanillaDats/level0_Final"));
275		GDFPaths.push_back( Characters );
276	+	//concactates level0....
277		for(int i = 0; i < GDFPaths.size(); i++)
278		{
279		directory_iterator end_iter;
#	Line 283 | Line 288 | int globalizeData(void)
288		}
289		}
290		}
291	+	//?: syntax is fun.
292	+	//condition ? value_if_true : value_if_false
293	+	(is_empty(Characters)   ? remove( Characters )  : 1);
294	+	(is_empty(Particles)    ? remove( Particles )   : 1);
295	+	(is_empty(Textures)             ? remove( Textures )    : 1);
296	+	(is_empty(Sounds)               ? remove( Sounds )              : 1);
297	+	(is_empty(TRAC)                 ? remove( TRAC )                : 1);
298	+	(is_empty(TRAM)                 ? remove( TRAM )                : 1);
299	+	(is_empty(Animations)   ? remove( Animations )  : 1);
300
301		create_directory((path)"../GameDataFolder/IGMD");
302		copy((path)"packages/VanillaBSL/IGMD", (path)"../GameDataFolder");
303		setProgressBar( 1000 );
304	<
305	<	if(exists("../../persist.dat"))
306	<	if(!exists("../persist.dat"))
307	<
294	<	//TODO: Concatenate level0 Dirs.
295	<
296	<	copy("../../persist.dat","..");
297	<	if(exists("../../key_config.txt"))
298	<	if(!exists("../key_config.txt"))
299	<	copy("../../key_config.txt","..");
300	<
304	>
305	>	if(exists("../../persist.dat") && !exists("../persist.dat")) copy("../../persist.dat","..");
306	>	if(exists("../../key_config.txt")&& !exists("../key_config.txt")) copy("../../key_config.txt","..");
307	>
308		#ifndef WIN32
309		/* On Mac only, set the current GDF to the AE GDF by writing to Oni's global preferences file (thankfully a standard OS X ".plist" XML file).
310		Tests for presence of prefs with [ -f ] before doing anything so it doesn't create a partial prefs file -- just in case user has never
311		run Oni before :-p */
312	<	string fullAEpath = escapePath(system_complete(".").parent_path().parent_path().string()); // get full path for Edition/ (Oni wants the folder that *contains* the GDF)
313	<	char prefsCommand[300] = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '";
312	>	string fullAEpath = escapePath(system_complete(".").parent_path().parent_path().string()); // get full path for Edition/ (Oni wants folder that *contains* the GDF)
313	>	//bad Iritscen, bad! fixed buffers can cause crashes.
314	>	/*char prefsCommand[300] = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '";
315		strcat(prefsCommand, fullAEpath.c_str());
316		strcat(prefsCommand, "'"); // path string is enclosed in single quotes to avoid the need to escape UNIX-unfriendly characters
317	<	system(prefsCommand);
317	>	*/
318	>	string prefsCommand = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '"
319	>	+ fullAEpath + "'";
320	>	system(prefsCommand.c_str());
321	>
322		#endif
323
324		setStatusArea((string)"Done! Now select your mod packages and click install.");
#	Line 340 | Line 352 | vector<ModPackage> getPackages(string pa
352
353		if (!file.fail())
354		{
355	<	package = fileToModPackage(file);
355	>	package = fileToModPackage(file, dir_itr->path().filename());
356		if (package.installerVersion.compare(INSTALLER_VERSION) < 1)  // if mod requires newer version of the Installer, we won't add it to the list
357		{
358		#ifdef WIN32
#	Line 364 | Line 376 | vector<ModPackage> getPackages(string pa
376		return packages;
377		}
378
379	<	ModPackage fileToModPackage(fstream &file)
380	<	{
369	<	/*
370	<	This converts a file to a ModPackage struct.
371	<
372	<	A few notes...
373	<	"iter" is the current word we are on. I should have named it "token" or something, but I don't have multiple iterators, so its ok.
374	<	I refer to (*iter) at the beginning of each if statement block. I could probably store it as a variable, but I'm pretty sure that dereferencing a pointer\iterator isn't much
375	<	slower than reading a variable.
376	<	*/
379	>	ModPackage fileToModPackage(fstream &file, string modName)
380	>	{
381		ModPackage package;
382		string line;
383	<	static string AEInstallVersion = "AEInstallVersion"; // used for comparing to the current token...
384	<	static string NameOfMod = "NameOfMod";
385	<	static string ARROW = "->";
386	<	static string ModString = "ModString";
387	<	static string Platform = "Platform";
388	<	static string HasOnis = "HasOnis";
389	<	static string HasDeltas = "HasDeltas";
390	<	static string HasBSL = "HasBSL";
391	<	static string HasDats = "HasDats";
392	<	static string IsEngine = "IsEngine";
393	<	static string Readme = "Readme";
394	<	static string GlobalNeeded = "GlobalNeeded";
395	<	static string Category = "Category";
396	<	static string Creator = "Creator";
383	>	const string AEInstallVersion = "AEInstallVersion"; // used for comparing to the current token...
384	>	const string NameOfMod = "NameOfMod";
385	>	const string ARROW = "->";
386	>	const string ModString = "ModString";
387	>	const string ModVersion = "ModVersion";
388	>	const string Platform = "Platform";
389	>	const string HasOnis = "HasOnis";
390	>	const string HasDeltas = "HasDeltas";
391	>	const string HasBSL = "HasBSL";
392	>	const string HasDats = "HasDats";
393	>	const string IsEngine = "IsEngine";
394	>	const string Readme = "Readme";
395	>	const string GlobalNeeded = "GlobalNeeded";
396	>	const string Category = "Category";
397	>	const string Creator = "Creator";
398	>	package.modStringName = modName;
399		while (!file.eof())
400		{
401		getline(file,line);
#	Line 416 | Line 422 | ModPackage fileToModPackage(fstream &fil
422		else if (!ModString.compare(*iter))
423		{
424		iter++; iter++;
425	<	package.modStringName = *iter;
425	>	//package.modStringName = *iter;
426		iter++;
427	<	package.modStringVersion = atoi((*iter).c_str());
427	>	package.modStringVersion = atof((*iter).c_str());
428	>	}
429	>	else if (!ModString.compare(*iter))
430	>	{
431	>	iter++; iter++;
432	>	package.modStringVersion = atof((*iter).c_str());
433		}
434		else if (!Platform.compare(*iter))
435		{
#	Line 433 | Line 444 | ModPackage fileToModPackage(fstream &fil
444		else if (!HasBSL.compare(*iter))
445		{
446		iter++; iter++;
447	<	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.hasBSL = true;
447	>	if (boost::iequals(*iter, "Yes")) package.hasBSL = true;
448		else if (boost::iequals(*iter, "Addon")) package.hasAddon = true;
449		}
450		else if (!HasDeltas.compare(*iter))
#	Line 558 | Line 569 | void recompileAll(vector<string> install
569
570
571		setProgressBar( (int)(1000 * (float)(j-1) / (float)numberOfDats) ); //100% * dat we're on / total dats
572	<	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +  dir_itr->path().filename() + " ");
572	>	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +
573	>	dir_itr->path().filename() + " ");
574
575		system(importCommand.c_str());
576		j++;
#	Line 585 | Line 597 | void recompileAll(vector<string> install
597		else if(splitInstances == false){
598		directory_iterator end_iter;
599
600	<	for ( directory_iterator dir_itr( vanilla_dir );
601	<	dir_itr != end_iter;
602	<	++dir_itr )
603	<	{
604	<	if ( is_directory( dir_itr->status() ) )
605	<	{
606	<	numberOfDats++;
600	>
601	>	char levelnums[256] = {0};
602	>
603	>
604	>
605	>	for(int k = 0; k < 256; k++) {
606	>	if( exists( (path)("./VanillaDats/level" + lexical_cast<std::string>(k) + "_final/") ) ) {
607	>	levelnums[k] = 1;
608	>
609		}
610		}
611	<
611	>
612	>	for (int i = installedMods.size() - 1; i >= 0; i--) {                                                   //Iterates through the installed mods (backwards :P)
613	>	for (unsigned int j = 0; j < globalPackages.size(); ++j) {                              //looking in the global packages
614	>	if (globalPackages[j].modStringName == installedMods[i]) {      //for a mod that has BSL in it
615	>	for(int k = 0; k < 256; k++) {
616	>	if( globalPackages[j].hasOnis &&
617	>	exists( (path)("packages/" + globalPackages[j].modStringName + "/oni/level" + lexical_cast<std::string>(k) + "_final/") ) ) {
618	>	levelnums[k] = 1;
619	>
620	>	}
621	>	}
622	>	}
623	>	}
624	>	}
625	>	for (int levelnum = 0; levelnum < 256; levelnum++)
626	>	if (levelnums[levelnum])
627	>	numberOfDats++;
628	>
629		out << numberOfDats;
630		datString = out.str();
631	<
632	<	for ( directory_iterator dir_itr( vanilla_dir );
602	<	dir_itr != end_iter;
603	<	++dir_itr )
604	<	{
631	>
632	>	for(int levelnum = 0; levelnum < 256; levelnum++) {
633		try
634		{
635	<	if ( is_directory( dir_itr->status() ) )
635	>	if ( levelnums[levelnum] )
636		{
637	<	importCommand = strOniSplit + " " + strImportOption + " " + vanilla_dir.string() + dir_itr->path().filename() + " ";
637	>	importCommand = strOniSplit + " " + strImportOption + " " + vanilla_dir.string() + "level" + lexical_cast<std::string>(levelnum) + "_Final ";
638		for (unsigned int i = 0; i < installedMods.size(); ++i) {
639	<	if (exists("packages/" + installedMods[i] + "/oni/" + dir_itr->path().filename()  ))
640	<	importCommand += " packages/" + installedMods[i] + "/oni/" + dir_itr->path().filename();
639	>	if (exists((path)("packages/" + installedMods[i] + "/oni/level" + lexical_cast<std::string>(levelnum) + "_final") ))
640	>	importCommand += " packages/" + installedMods[i] + "/oni/level" + lexical_cast<std::string>(levelnum) + "_Final";
641		}
642	<	importCommand += " ../GameDataFolder/" + dir_itr->path().filename() + ".dat >> Install.log";
642	>	importCommand += " ../GameDataFolder/level" + lexical_cast<std::string>(levelnum) + "_Final.dat >> Install.log";
643
644		setProgressBar( (int)(1000 * (float)(j-1) / (float)numberOfDats) ); //100% * dat we're on / total dats
645	<	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +  dir_itr->path().filename() + " ");
645	>	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +
646	>	"level" + lexical_cast<std::string>(levelnum) + "_Final"+ " ");
647		system(importCommand.c_str());
648		j++;
649		}
#	Line 634 | Line 663 | void recompileAll(vector<string> install
663		vector<string> skippedfolders;
664
665		ofstream BSLlog("BSL.log");
666	+	if(exists("../GameDataFolder/BSLBackup/")) {
667	+	remove_all("../GameDataFolder/BSLBackup/");
668	+	}
669	+	else {
670	+	create_directory("../GameDataFolder/BSLBackup/");
671	+	}
672	+	copy("../GameDataFolder/IGMD/", "../GameDataFolder/BSLBackup/");
673		for ( directory_iterator dir_itr( "../GameDataFolder/IGMD/" ), end_itr;
674		dir_itr != end_itr;
675		++dir_itr ) {
#	Line 646 | Line 682 | void recompileAll(vector<string> install
682		for (int i = installedMods.size() - 1; i >= 0; i--) {                                                   //Iterates through the installed mods (backwards :P)
683		for (unsigned int j = 0; j < globalPackages.size(); ++j) {                              //looking in the global packages
684		if (globalPackages[j].modStringName == installedMods[i]) {      //for a mod that has BSL in it
685	<	if(!(globalPackages[j].hasAddon || globalPackages[j].hasBSL)) break; //skip non-BSL
685	>	if(globalPackages[j].hasBSL) break; //skip non-BSL
686		if( exists( "packages/" + globalPackages[j].modStringName + "/BSL/" ) ) {
687		copyBSL("packages/" + globalPackages[j].modStringName + "/BSL", BSLfolders, globalPackages[j] );
688		BSLlog << "Copied " <<  globalPackages[j].modStringName << "!\n";
#	Line 655 | Line 691 | void recompileAll(vector<string> install
691		}
692		}
693
694	+
695	+
696		ModPackage emptyPackage;
697		emptyPackage.modStringName = "VanillaBSL";
698		emptyPackage.hasBSL = 1;
699		copyBSL("packages/VanillaBSL/IGMD", BSLfolders, emptyPackage);
700		BSLlog.close();
701	<
701	>
702	>	for (int i = installedMods.size() - 1; i >= 0; i--) {                                                   //Iterates through the installed mods (backwards :P)
703	>	for (unsigned int j = 0; j < globalPackages.size(); ++j) {                              //looking in the global packages
704	>	if (globalPackages[j].modStringName == installedMods[i]) {      //for a mod that has BSL in it
705	>	if(!globalPackages[j].hasAddon) break; //skip non-BSL
706	>	if( exists( "packages/" + globalPackages[j].modStringName + "/BSL/" ) ) {
707	>	copyBSL("packages/" + globalPackages[j].modStringName + "/BSL", BSLfolders, globalPackages[j] );
708	>	BSLlog << "Copied " <<  globalPackages[j].modStringName << "!\n";
709	>	}
710	>	}
711	>	}
712	>	}
713	>
714		logfile << "Writing config file";
715		writeInstalledMods(installedMods);
716		setProgressBar(1000);
#	Line 691 | Line 741 | void recompileAll(vector<string> install
741
742		void copyBSL(string copypath, vector<string>& BSLfolders, ModPackage pkg)
743		{
744	<	ofstream BSLlog("BSL2.log", ios::app );
744	>	ofstream BSLlog("BSL.log", ios::app );
745
746		try {
747		for ( directory_iterator dir_itr( copypath ), end_itr;
#	Line 701 | Line 751 | void copyBSL(string copypath, vector<str
751		if ( is_directory( dir_itr->path() ) && dir_itr->path().string() != ".svn" ) {
752		BSLlog << "Testing " << dir_itr->path().string() << " HasBSL: " << pkg.hasBSL << " HasAddon: " << pkg.hasAddon << "\n";
753		int skip_folder = 0;
754	<
755	<	for(unsigned int k = 0; k < BSLfolders.size(); k++)             {//iterate through already found BSL folders
756	<	BSLlog << "testing " << dir_itr->path().filename() << " vs " << BSLfolders[k] << "\n";
757	<	if(dir_itr->path().filename() == BSLfolders[k]) {
758	<	skip_folder = 1;
759	<	BSLlog << "skipping " << BSLfolders[k] << " in " << pkg.modStringName << "\n";
760	<	break;
754	>	if(!pkg.hasAddon) {
755	>	for(unsigned int k = 0; k < BSLfolders.size(); k++)             {//iterate through already found BSL folders
756	>	BSLlog << "testing " << dir_itr->path().filename() << " vs " << BSLfolders[k] << "\n";
757	>	if(dir_itr->path().filename() == BSLfolders[k]) {
758	>	skip_folder = 1;
759	>	BSLlog << "skipping " << BSLfolders[k] << " in " << pkg.modStringName << "\n";
760	>	break;
761	>	}
762		}
763		}
764		if (!skip_folder && !exists("../GameDataFolder/IGMD/" + dir_itr->path().filename() + "/ignore.txt")) {
#	Line 722 | Line 773 | void copyBSL(string copypath, vector<str
773		copy_file(bsl_itr->path(),  "../GameDataFolder/IGMD/" + dir_itr->path().filename() + "/" + bsl_itr->path().filename());
774		}
775		}
776	<	BSLfolders.push_back( dir_itr->path().filename() ); //add back check for addon
777	<	BSLlog << "Pushing " << dir_itr->path().filename() << "\n" ;
776	>	if( !pkg.hasAddon ) {
777	>	BSLfolders.push_back( dir_itr->path().filename() ); //add back check for addon
778	>	BSLlog << "Pushing " << dir_itr->path().filename() << "\n" ;
779	>	}
780		}
781		}
782		}
#	Line 799 | Line 852 | vector<string> getInstallString(string C
852		|                                                          Installer to be replaced (when the new Installer                     |
853		|                                                          launches, this function will be called again but will        |
854		|                                                          return UPDATE_SIMP_AVAIL or UPDATE_GLOB_AVAIL)                       |
855	+	|  UPDATE_PKG_AVAIL                     -- A newer version of individual package(s) is available        |
856		\* UPDATE_CONT_UPD                      -- Currently unused                                                                                */
857		int GetUpdateStatus(Install_info_cfg *currentAE, Install_info_cfg *updateAE, bool *installerJustUpdated)
858		{
#	Line 827 | Line 881 | int GetUpdateStatus(Install_info_cfg *cu
881		else
882		return UPDATE_LOG_READ_ERR;
883		}
884	<
885	<	// Is there an update folder, and is it a monthly release or a patch?
886	<	if (!exists("../updates/Edition"))
884	>
885	>	// Is there an update in the updates/ folder, and is it a monthly release or a patch?
886	>	bool firstParty = 0;
887	>	// First create the folder if it's missing, so users are never left wondering where updates are supposed to be put
888	>	if (!exists("../updates"))
889	>	create_directory("../updates");
890	>	if (exists("../updates/Edition"))
891		{
892	+	firstParty = 1;
893	+	}
894	+	else {
895		strEUFN = "Edition-patch";
896	<	if (!exists("../updates/Edition-patch"))
897	<	return UPDATE_NO_UPD_AVAIL;
896	>	if (exists("../updates/Edition-patch")) {
897	>	firstParty = 1;
898	>	}
899	>
900		}
901	<
902	<	// Unlike the current AE's version info, we *need* to find the update's version info or we won't continue
903	<	string updateCfgPath = ("../updates/" + strEUFN + "/install/packages/Globalize/Install_Info.cfg");
904	<	updateAECfg.open(updateCfgPath.c_str());
905	<	if (!updateAECfg.fail())
906	<	{
907	<	if (!ReadInstallInfoCfg(&updateAECfg, updateAE))
901	>
902	>	if(firstParty) {
903	>	// Unlike the current AE's version info, we *need* to find the update's version info or we won't continue
904	>	string updateCfgPath = ("../updates/" + strEUFN + "/install/packages/Globalize/Install_Info.cfg");
905	>	updateAECfg.open(updateCfgPath.c_str());
906	>	if (!updateAECfg.fail())
907	>	{
908	>	if (!ReadInstallInfoCfg(&updateAECfg, updateAE))
909	>	return UPDATE_LOG_READ_ERR;
910	>
911	>	updateAECfg.close();
912	>	updateAECfg.clear();
913	>	}
914	>	else
915		return UPDATE_LOG_READ_ERR;
846	–
847	–	updateAECfg.close();
848	–	updateAECfg.clear();
849	–	}
850	–	else
851	–	return UPDATE_LOG_READ_ERR;
916
917	<	// Now we check for an Installer update in progress
918	<	if (exists("Update.log"))
919	<	{
920	<	updateLog.open("Update.log");
921	<	if (!updateLog.fail())
858	<	{
859	<	vector<string> lines;
860	<	string line;
861	<	int num_lines = 0;
862	<	bool readingInstallerVersion = false, doneReadingFile = false;
863	<
864	<	while (!updateLog.eof() && !doneReadingFile)
917	>	// Now we check for an Installer update in progress
918	>	if (exists("Update.log"))
919	>	{
920	>	updateLog.open("Update.log");
921	>	if (!updateLog.fail())
922		{
923	<	getline(updateLog, line);
924	<	lines.push_back(line);
925	<	num_lines++;
926	<	vector<string> tokens;
927	<	vector<string>::iterator iter;
928	<	tokenize(line, tokens);
872	<	iter = tokens.begin();
873	<	if (!readingInstallerVersion && tokens.capacity() >= 4)
923	>	vector<string> lines;
924	>	string line;
925	>	int num_lines = 0;
926	>	bool readingInstallerVersion = false, doneReadingFile = false;
927	>
928	>	while (!updateLog.eof() && !doneReadingFile)
929		{
930	<	if (!strInstaller.compare(*iter))
930	>	getline(updateLog, line);
931	>	lines.push_back(line);
932	>	num_lines++;
933	>	vector<string> tokens;
934	>	vector<string>::iterator iter;
935	>	tokenize(line, tokens);
936	>	iter = tokens.begin();
937	>	if (!readingInstallerVersion && tokens.capacity() >= 4)
938		{
939	<	if (!strBeing.compare(*++iter))
940	<	readingInstallerVersion = true;
941	<	else if (!strWas.compare(*iter))
942	<	*installerJustUpdated = true; // our third indirect return value after currentAE and updateAE
939	>	if (!strInstaller.compare(*iter))
940	>	{
941	>	if (!strBeing.compare(*++iter))
942	>	readingInstallerVersion = true;
943	>	else if (!strWas.compare(*iter))
944	>	*installerJustUpdated = true; // our third indirect return value after currentAE and updateAE
945	>	}
946		}
947	<	}
883	<	else if (readingInstallerVersion && tokens.capacity() >= 3)
884	<	{
885	<	readingInstallerVersion = false;
886	<	string installerVersion = INSTALLER_VERSION;
887	<	if (installerVersion.compare(*iter)) // then the shell script-powered replacement failed
888	<	return UPDATE_INST_REPL_ERR;
889	<	else
947	>	else if (readingInstallerVersion && tokens.capacity() >= 3)
948		{
949	<	updateLog.close();
950	<	updateLog.clear();
951	<	Sleep(1000);
952	<	remove("Update.log");
953	<	ofstream newUpdateLog("Update.log");
896	<	if (!newUpdateLog.fail())
949	>	readingInstallerVersion = false;
950	>	string installerVersion = INSTALLER_VERSION;
951	>	if (installerVersion.compare(*iter)) // then the shell script-powered replacement failed
952	>	return UPDATE_INST_REPL_ERR;
953	>	else
954		{
955	<	// Write over old log with updated information
956	<	ptime startTime(second_clock::local_time());
957	<	string strStartTime = to_simple_string(startTime);
958	<	string newUpdateLine = installerVersion + " on " + strStartTime;
959	<	for (int a = 0; a < lines.capacity() - 2; a++) // if there were even lines in the log before this at all
955	>	updateLog.close();
956	>	updateLog.clear();
957	>	Sleep(1000);
958	>	remove("Update.log");
959	>	ofstream newUpdateLog("Update.log");
960	>	if (!newUpdateLog.fail())
961		{
962	<	newUpdateLog << lines[a].c_str();
963	<	newUpdateLog << "\n";
962	>	// Write over old log with updated information
963	>	ptime startTime(second_clock::local_time());
964	>	string strStartTime = to_simple_string(startTime);
965	>	string newUpdateLine = installerVersion + " on " + strStartTime;
966	>	for (int a = 0; a < lines.capacity() - 2; a++) // if there were even lines in the log before this at all
967	>	{
968	>	newUpdateLog << lines[a].c_str();
969	>	newUpdateLog << "\n";
970	>	}
971	>	newUpdateLog << "Installer was updated to:\n";
972	>	newUpdateLog << newUpdateLine.c_str();
973	>	*installerJustUpdated = true; // this value is indirectly returned to AEInstallerApp::OnInit()
974	>	doneReadingFile = true;
975	>	newUpdateLog.close();
976	>	newUpdateLog.clear();
977	>	//return UPDATE_CONT_UPD; // as noted above, we are not using this return value; in fact, we want...
978	>	//                                                       ...the code to continue running down through the Edition version check
979		}
980	<	newUpdateLog << "Installer was updated to:\n";
981	<	newUpdateLog << newUpdateLine.c_str();
909	<	*installerJustUpdated = true; // this value is indirectly returned to AEInstallerAp::OnInit()
910	<	doneReadingFile = true;
911	<	newUpdateLog.close();
912	<	newUpdateLog.clear();
913	<	//return UPDATE_CONT_UPD; // as noted above, we are not using this return value; in fact, we want...
914	<	//                                                       ...the code to continue running down through the Edition version check
980	>	else
981	>	return UPDATE_LOG_READ_ERR;
982		}
916	–	else
917	–	return UPDATE_LOG_READ_ERR;
983		}
984		}
985	+	updateLog.close();
986	+	updateLog.clear();
987		}
988	<	updateLog.close();
989	<	updateLog.clear();
988	>	else
989	>	return UPDATE_LOG_READ_ERR;
990		}
991	<	else
992	<	return UPDATE_LOG_READ_ERR;
926	<	}
927	<
928	<	if (updateAE->AEVersion.compare(currentAE->AEVersion) >= 1) // is the release update newer than what's installed?
929	<	{
930	<	if (!strEUFN.compare("Edition-patch")) // if update is a patch...
991	>
992	>	if (updateAE->AEVersion.compare(currentAE->AEVersion) >= 1) // is the release update newer than what's installed?
993		{
994	<	if (currentAE->AEVersion.compare(updateAE->AEVersion.substr(0, updateAE->AEVersion.length() - 1))) // ...is it for a different month?
995	<	return UPDATE_MNTH_REQD_ERR;
994	>	if (!strEUFN.compare("Edition-patch")) // if update is a patch...
995	>	{
996	>	if (currentAE->AEVersion.compare(updateAE->AEVersion.substr(0, updateAE->AEVersion.length() - 1))) // ...is it for a different month?
997	>	return UPDATE_MNTH_REQD_ERR;
998	>	}
999	>	string strNewInstallerPath = "../updates/" + strEUFN + "/install/" + strInstallerName;
1000	>	string installerVersion = INSTALLER_VERSION;
1001	>	if (updateAE->InstallerVersion.compare(installerVersion) >= 1)
1002	>	{
1003	>	if (exists(strNewInstallerPath))
1004	>	return UPDATE_INST_AVAIL;
1005	>	}
1006	>	else if (updateAE->globalizationRequired)
1007	>	return UPDATE_GLOB_AVAIL;
1008	>	else
1009	>	return UPDATE_SIMP_AVAIL;
1010		}
1011	<	string strNewInstallerPath = "../updates/" + strEUFN + "/install/" + strInstallerName;
1012	<	string installerVersion = INSTALLER_VERSION;
1013	<	if (updateAE->InstallerVersion.compare(installerVersion) >= 1)
1011	>	}
1012	>	try
1013	>	{
1014	>	directory_iterator end;
1015	>	if (exists("../updates"))
1016		{
1017	<	if (exists(strNewInstallerPath))
1018	<	return UPDATE_INST_AVAIL;
1017	>	for (directory_iterator install_iter("../updates"); install_iter != end; ++install_iter)
1018	>	{
1019	>	ModPackage installedPackage, updatePackage;
1020	>	if (is_directory(install_iter->path()) && exists(install_iter->path().string() + "/Mod_Info.cfg"))
1021	>	{
1022	>	fstream file;
1023	>	file.open((install_iter->path().string() + "/Mod_Info.cfg").c_str());
1024	>	if (!file.fail())
1025	>	updatePackage = fileToModPackage(file, install_iter->path().filename());
1026	>	else
1027	>	{
1028	>	file.close();
1029	>	continue;
1030	>	}
1031	>	if (exists("packages/" + install_iter->path().filename() + "/Mod_Info.cfg"))
1032	>	{
1033	>	file.close();
1034	>	file.clear();
1035	>	file.open(("packages/" + install_iter->path().filename() + "/Mod_Info.cfg").c_str());
1036	>	if (!file.fail())
1037	>	installedPackage = fileToModPackage(file, install_iter->path().filename());
1038	>	file.close();
1039	>	if (updatePackage.modStringVersion > installedPackage.modStringVersion)
1040	>	{
1041	>	if (updatePackage.installerVersion <= INSTALLER_VERSION)
1042	>	return UPDATE_PKG_AVAIL;
1043	>	}
1044	>	}
1045	>	else
1046	>	{
1047	>	file.close();
1048	>	return UPDATE_PKG_AVAIL;
1049	>	}
1050	>	}
1051	>	}
1052		}
942	–	else if (updateAE->globalizationRequired)
943	–	return UPDATE_GLOB_AVAIL;
944	–	else
945	–	return UPDATE_SIMP_AVAIL;
1053		}
1054	<	else
1055	<	return UPDATE_NO_UPD_AVAIL;
1056	<
1054	>	catch (exception & ex) {
1055	>	//      setStatusArea("Warning, handled exception: " + (string)ex.what());
1056	>	}
1057	>
1058		return UPDATE_NO_UPD_AVAIL;
1059		}
1060
#	Line 960 | Line 1068 | bool ReadInstallInfoCfg(fstream *fileHan
1068		string strDaodanVersion = "Daodan_Version";
1069		string strOniSplitVersion = "OniSplit_Version";
1070		string strGUIWinVersion = "GUI_Win_Version";
1071	<	string strGUIMacVersion = "GUI_Mac_Version";
1071	>	string strGUIMacVersion = "GUI_Mac_Version";
1072		string strReglobalize = "Reglobalize";
1073		string strDeleteList = "Delete_List";
1074		string strArrow = "->";
#	Line 1172 | Line 1280 | bool ProcessInstallerUpdate(Install_info
1280
1281		string popenCommand = "../updates/" + strEUFN + "/install/";
1282		#ifdef WIN32
1175	–	// TODO: Fill in Windows equivalent of code below :-3
1283		popenCommand = "replace_installer.bat";
1284		#else
1285		// We can't just use '~' to mean "the home directory" because we need to check the path in C...
#	Line 1205 | Line 1312 | bool ProcessInstallerUpdate(Install_info
1312
1313		bool ProcessAEUpdate(Install_info_cfg *currentAE, Install_info_cfg *updateAE, bool *installerJustUpdated)
1314		{
1315	+	try {
1316		fstream file;
1317		string line;
1318		vector<string> tokens, updateStarted;
#	Line 1224 | Line 1332 | bool ProcessAEUpdate(Install_info_cfg *c
1332		string strOniApp = "Oni.exe";
1333		#else
1334		string strOniApp = "Oni.app";
1227	–	#endif
1335		bool needNewTrashDir = false;
1336	+	#endif
1337	+
1338		bool readingVerAndDate = false;
1339
1231	–	// TODO: Fill in Windows equivalent of code below
1340		#ifdef WIN32
1341	<	string strTrashDir = "Trash\\";
1341	>	//string strTrashDir = "Trash\\"; // string unused in Windows because files are simply deleted
1342		#else
1343		FILE *fUserName = NULL;
1344		char chrUserName[32];
#	Line 1265 | Line 1373 | bool ProcessAEUpdate(Install_info_cfg *c
1373		if (readingVerAndDate && tokens.capacity() >= 3)
1374		tokenize(tokens[2], updateStarted, "-");
1375		}
1376	+	#ifndef WIN32
1377		if (updateStarted.capacity() < 3)
1378		needNewTrashDir = true;
1379		else
#	Line 1274 | Line 1383 | bool ProcessAEUpdate(Install_info_cfg *c
1383		if (!exists(strTrashDir))
1384		needNewTrashDir = true;
1385		}
1386	+	#endif
1387		}
1388		#ifndef WIN32
1389		if (!*installerJustUpdated || needNewTrashDir) // prepare a new directory for deleted files to go to
#	Line 1290 | Line 1400 | bool ProcessAEUpdate(Install_info_cfg *c
1400		// Special code to replace our special files -- the Oni app, OniSplit, the Daodan DLL, and the GUI for OniSplit
1401		if (exists(strPathToEUFN + strOniApp))
1402		{
1403	<	if (exists(strOniApp))
1404	<	rename((path)strOniApp, (path)(strTrashDir + strOniApp));
1405	<	rename((path)(strPathToEUFN + strOniApp), (path)strOniApp);
1403	>	if (exists("../" + strOniApp))
1404	>	#ifdef WIN32
1405	>	remove((path)("../" + strOniApp));
1406	>	#else
1407	>	rename((path)("../" + strOniApp), (path)(strTrashDir + strOniApp));
1408	>	#endif
1409	>	rename((path)(strPathToEUFN + strOniApp), (path)("../" + strOniApp));
1410		}
1411		if (updateAE->OniSplitVersion.compare(currentAE->OniSplitVersion) >= 1)
1412		{
1413		if (exists(strPathToEUFNInstall + strOniSplit))
1414		{
1415		if (exists(strOniSplit))
1416	+	#ifdef WIN32
1417	+	remove((path)strOniSplit);
1418	+	#else
1419		rename((path)strOniSplit, (path)(strTrashDir + strOniSplit));
1420	+	#endif
1421		rename((path)(strPathToEUFNInstall + strOniSplit), (path)strOniSplit);
1422		}
1423		}
#	Line 1309 | Line 1427 | bool ProcessAEUpdate(Install_info_cfg *c
1427		if (exists(strPathToEUFN + strDaodan))
1428		{
1429		if (exists(("../" + strDaodan)))
1430	<	rename((path)("../" + strDaodan), (path)(strTrashDir + strDaodan));
1430	>	remove((path)("../" + strDaodan));
1431		rename((path)(strPathToEUFN + strDaodan), (path)("../" + strDaodan));
1432		}
1433		}
#	Line 1318 | Line 1436 | bool ProcessAEUpdate(Install_info_cfg *c
1436		if (exists(strPathToEUFNInstall + strWinGUI))
1437		{
1438		if (exists((path)strWinGUI))
1439	<	rename((path)strWinGUI, (path)(strTrashDir + strWinGUI));
1439	>	remove((path)strWinGUI);
1440		if (exists(strWinGUILang))
1441	<	rename((path)strWinGUILang, (path)(strTrashDir + strWinGUILang));
1441	>	remove((path)strWinGUILang);
1442		rename((path)(strPathToEUFNInstall + strWinGUI), (path)strWinGUI);
1443		rename((path)(strPathToEUFNInstall + strWinGUILang), (path)strWinGUILang);
1444		}
#	Line 1353 | Line 1471 | bool ProcessAEUpdate(Install_info_cfg *c
1471		while (curPos != string::npos && curPos < thePath.size())
1472		{
1473		aParentPath = aParentPath + thePath.substr(lastPos, curPos - lastPos);
1474	+	#ifndef WIN32
1475		if (!exists(strTrashDir + aParentPath))
1476		create_directory(strTrashDir + aParentPath);
1477	+	#endif
1478		lastPos = curPos + 1;
1479		curPos = thePath.find("/", lastPos);
1480		aParentPath = aParentPath + "/";
#	Line 1367 | Line 1487 | bool ProcessAEUpdate(Install_info_cfg *c
1487		}
1488		}
1489
1490	<	// Now we crawl the update's package folders for newer versions and move them over, trashing ones that are already present
1371	<	vector<ModPackage> updatePackages, currentPackages;
1372	<	bool matchFound;
1373	<	updatePackages.reserve(256);
1374	<	currentPackages.reserve(256);
1375	<
1376	<	currentPackages = getPackages();
1377	<	updatePackages = getPackages(strPathToEUFNPackages);
1378	<
1379	<	for (vector<ModPackage>::iterator iter1 = updatePackages.begin(); iter1 != updatePackages.end(); iter1++)
1380	<	{
1381	<	matchFound = false;
1382	<	for (vector<ModPackage>::iterator iter2 = currentPackages.begin(); iter2 != currentPackages.end(); iter2++)
1383	<	{
1384	<	if (!iter1->modStringName.compare(iter2->modStringName))
1385	<	{
1386	<	matchFound = true;
1387	<	if (iter1->modStringVersion > iter2->modStringVersion)
1388	<	{
1389	<	#ifndef WIN32
1390	<	rename((path)(strPathToPackages + iter2->modStringName), (path)(strTrashDir + iter2->modStringName));
1391	<	#else
1392	<	remove((path)(strPathToPackages + iter2->modStringName));
1393	<	#endif
1394	<	rename((path)(strPathToEUFNPackages + iter1->modStringName), (path)(strPathToPackages + iter1->modStringName));
1395	<	}
1396	<	}
1397	<	}
1398	<	if (!matchFound) // then there's no old package in the way, so just move in the one from the update
1399	<	rename((path)(strPathToEUFNPackages + iter1->modStringName), (path)(strPathToPackages + iter1->modStringName));
1400	<	}
1490	>	ProcessPackageUpdates(strPathToEUFNPackages, strPathToPackages);
1491
1492		// Next, we get a list of which files and folders in the update's Globalize folder to move over; all files not starting with '.' will be moved...
1493		// ...and folders which do not exist in the current AE will be created there
#	Line 1429 | Line 1519 | bool ProcessAEUpdate(Install_info_cfg *c
1519		for (vector<string>::iterator iter = filesToMove.begin(); iter != filesToMove.end(); iter++)
1520		{
1521		if (exists(strPathToPackages + strGlobalize + *iter))
1522	+	#ifdef WIN32
1523	+	remove((path)(strPathToPackages + strGlobalize + *iter));
1524	+	#else
1525		rename((path)(strPathToPackages + strGlobalize + *iter), (path)(strTrashDir + *iter));
1526	+	#endif
1527		rename((path)(strPathToEUFNPackages + strGlobalize + *iter), (path)(strPathToPackages + strGlobalize + *iter));
1528		}
1529
1530		// Clean up after ourselves, trashing any packages or programs in the update package that are not newer than the current AE
1531	+	#ifdef WIN32
1532	+	remove_all((path)strPathToEUFN);
1533	+	#else
1534		create_directory(strTrashDir + "Unneeded update files");
1535		rename((path)strPathToEUFN, (path)(strTrashDir + "Unneeded update files/" + strEUFN));
1536	<
1536	>	#endif
1537		// Write to log that we are finished with update
1538		ptime end_time(second_clock::local_time());
1539		string progressMsg2 = "Edition was updated to:\n" +
#	Line 1454 | Line 1551 | bool ProcessAEUpdate(Install_info_cfg *c
1551		CheckForGlobalization(true); // the 'true' value forces re-globalization
1552
1553		globalPackages = getPackages(); // refresh the list in memory
1554	+	wxCommandEvent e;
1555	+	TheWindow->OnRefreshButtonClick( e );
1556	+	return true;
1557	+	}
1558	+	catch (exception & ex)
1559	+	{
1560	+	setStatusArea("Warning, handled exception: " + (string)ex.what());
1561	+	return false;
1562	+	}
1563
1564	<	// TODO: Refresh the packages list in the window
1564	>	}
1565
1566	<	return true;
1566	>	void ProcessPackageUpdates(string pathToUpdate, string strPathToPackages)
1567	>	{
1568	>	ptime startTime(second_clock::local_time());
1569	>	#ifdef WIN32
1570	>	string strTrashDir = "Trash\\"; // string unused in Windows because files are simply deleted
1571	>	#else
1572	>	FILE *fUserName = NULL;
1573	>	char chrUserName[32];
1574	>	fUserName = popen("whoami", "r");
1575	>	fgets(chrUserName, sizeof(chrUserName), fUserName);
1576	>	pclose(fUserName);
1577	>	string strUserName = (string)chrUserName; // stringsblaaarrrgggghhhh
1578	>	int endOfName = strUserName.find("\n", 0);
1579	>	string strTrashDir = "/Users/" + strUserName.substr(0, endOfName) + "/.Trash/";
1580	>	bool needNewTrashDir = true;
1581	>	tm tmStartTime = to_tm(startTime);
1582	>	#endif
1583	>
1584	>	try
1585	>	{
1586	>	directory_iterator end;
1587	>	for (directory_iterator update_iter(pathToUpdate); update_iter != end; ++update_iter)
1588	>	{
1589	>	ModPackage installedPackage, updatePackage;
1590	>	string updtPath = update_iter->path().string();
1591	>	string updtFolder = update_iter->path().filename();
1592	>	string updtModInfo = updtPath + "/Mod_Info.cfg";
1593	>	string instModInfo = strPathToPackages + "/" + updtFolder + "/Mod_Info.cfg";
1594	>	if (!boost::iequals(updtFolder, "Edition")
1595	>	&& !boost::iequals(updtFolder, "Edition-patch")
1596	>	&& is_directory(update_iter->path())
1597	>	&& exists(updtModInfo))
1598	>	{
1599	>	fstream file;
1600	>	file.open((updtModInfo).c_str());
1601	>	if (!file.fail())
1602	>	updatePackage = fileToModPackage(file, updtFolder);
1603	>	else
1604	>	{
1605	>	file.close();
1606	>	continue;
1607	>	}
1608	>	if (exists(instModInfo))
1609	>	{
1610	>	file.close();
1611	>	file.clear();
1612	>	file.open(instModInfo.c_str());
1613	>	if (!file.fail())
1614	>	{
1615	>	installedPackage = fileToModPackage(file, updtFolder);
1616	>	}
1617	>	file.close();
1618	>	}
1619	>	file.close();
1620	>	if (updatePackage.modStringVersion > installedPackage.modStringVersion)
1621	>	{
1622	>	if (updatePackage.installerVersion <= INSTALLER_VERSION)
1623	>	{
1624	>	if(exists(strPathToPackages +  "/" + updatePackage.modStringName)) {
1625	>	#ifdef WIN32
1626	>	remove_all((path)(strPathToPackages +  "/" + updatePackage.modStringName));
1627	>	#else
1628	>	if (needNewTrashDir)
1629	>	{
1630	>	strTrashDir = strTrashDir + "Old_packages_" + boost::lexical_cast<string>(tmStartTime.tm_hour) + "-" +
1631	>	boost::lexical_cast<string>(tmStartTime.tm_min) + "-" + boost::lexical_cast<string>(tmStartTime.tm_sec) + "/";
1632	>	create_directory(strTrashDir);
1633	>	needNewTrashDir = false;
1634	>	}
1635	>	rename((path)(strPathToPackages +  "/" + updatePackage.modStringName), (path)(strTrashDir + updatePackage.modStringName));
1636	>	#endif
1637	>	}
1638	>	rename((path)(pathToUpdate + "/" + updatePackage.modStringName), (path)(strPathToPackages + "/" + updatePackage.modStringName));
1639	>	}
1640	>	}
1641	>	}
1642	>	}
1643	>	}
1644	>	catch (exception & ex)
1645	>	{
1646	>	setStatusArea("Warning, handled exception: " + (string)ex.what());
1647	>	}
1648	>	wxCommandEvent e;
1649	>	TheWindow->OnRefreshButtonClick( e );
1650		}
1651
1652		/* MakePathLocalToGlobalize is a function used once by ProcessAEUpdate() that takes a file in an        \

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)