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 489 by gumby, Sun Jan 24 23:58:16 2010 UTC vs.
Revision 562 by gumby, Sun May 30 17:28:34 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/
313	<	char prefsCommand[300] = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '";
314	<	strcat(prefsCommand, fullAEpath.c_str()); // get path of Edition/ folder (Oni wants the folder that *contains* the GDF)
315	<	strcat(prefsCommand, "'"); // path string is enclosed in single quotes to avoid the need to escape UNIX-unfriendly characters
316	<	system(prefsCommand);
312	>	string fullAEpath = escapePath(system_complete(".").parent_path().parent_path().string()); // get full path for Edition/ (Oni wants folder that *contains* the GDF)
313	>	string prefsCommand = "[ -f ~/Library/Preferences/com.godgames.oni.plist ] && defaults write com.godgames.oni RetailInstallationPath -string '"
314	>	+ fullAEpath + "'";
315	>	system(prefsCommand.c_str());
316	>
317		#endif
318
319		setStatusArea((string)"Done! Now select your mod packages and click install.");
#	Line 326 | Line 333 | int globalizeData(void)
333		vector<ModPackage> getPackages(string packageDir)
334		{
335		vector<ModPackage> packages;
336	+	ModPackage package;
337		packages.reserve(256);
338		fstream file;
339		string filename = "\0";
#	Line 337 | Line 345 | vector<ModPackage> getPackages(string pa
345		{
346		file.open((dir_itr->path().string() + "/" + MODINFO_CFG).c_str());
347
348	<	if(!file.fail())
348	>	if (!file.fail())
349		{
350	<	//would prefer to push a pointer to a package, but this will do for now
351	<	packages.push_back(fileToModPackage(file));
350	>	package = fileToModPackage(file, dir_itr->path().filename());
351	>	if (package.installerVersion.compare(INSTALLER_VERSION) < 1)  // if mod requires newer version of the Installer, we won't add it to the list
352	>	{
353	>	#ifdef WIN32
354	>	if (!package.platform.compare("Windows") || !package.platform.compare("Both")) // don't show package if it's not for the right OS
355	>	#else
356	>	if (!package.platform.compare("Macintosh") || !package.platform.compare("Both"))
357	>	#endif
358	>	packages.push_back(package);
359	>	}
360		}
361		file.close();
362		file.clear();
#	Line 355 | Line 371 | vector<ModPackage> getPackages(string pa
371		return packages;
372		}
373
374	<	ModPackage fileToModPackage(fstream &file)
375	<	{
360	<	/*
361	<	This converts a file to a ModPackage struct.
362	<
363	<	A few notes...
364	<	"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.
365	<	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
366	<	slower than reading a variable.
367	<	*/
374	>	ModPackage fileToModPackage(fstream &file, string modName)
375	>	{
376		ModPackage package;
377		string line;
378	<	static string NameOfMod = "NameOfMod";  //used for comparing to the current token...
379	<	//I could have done it in reverse (*iter).compare("ModString") or
380	<	static string ARROW = "->";                             //did something like "ModString".compare(*iter), and it would have been
381	<	static string ModString = "ModString";  //functionably the same.
382	<	static string HasOnis = "HasOnis";
383	<	static string HasDeltas = "HasDeltas";
384	<	static string HasBSL = "HasBSL";
385	<	static string HasDats = "HasDats";
386	<	static string IsEngine = "IsEngine";
387	<	static string Readme = "Readme";
388	<	static string GlobalNeeded = "GlobalNeeded";
389	<	static string Category = "Category";
390	<	static string Creator = "Creator";
391	<	while (! file.eof() )
378	>	const string AEInstallVersion = "AEInstallVersion"; // used for comparing to the current token...
379	>	const string NameOfMod = "NameOfMod";
380	>	const string ARROW = "->";
381	>	const string ModString = "ModString";
382	>	const string ModVersion = "ModVersion";
383	>	const string Platform = "Platform";
384	>	const string HasOnis = "HasOnis";
385	>	const string HasDeltas = "HasDeltas";
386	>	const string HasBSL = "HasBSL";
387	>	const string HasDats = "HasDats";
388	>	const string IsEngine = "IsEngine";
389	>	const string Readme = "Readme";
390	>	const string GlobalNeeded = "GlobalNeeded";
391	>	const string Category = "Category";
392	>	const string Creator = "Creator";
393	>	while (!file.eof())
394		{
395	<	getline (file,line);
395	>	getline(file,line);
396		vector<string> tokens;
397		vector<string>::iterator iter;
398	<	tokenize(line, tokens);                                 //string to vector of "words"
399	<	if (tokens.capacity() >= 3) {                   //make sure they are using enough stuff
400	<	iter = tokens.begin();                          //what word we are on, starts at first word
401	<	/* TODO: Get this "required Installer version" code working
402	<	if (!AEInstallVersion.compare(*iter))
403	<	If mod is too old, skip this mod.
404	<	*/
405	<	/*else*/if (!NameOfMod.compare(*iter))  {       //if it contains the name
406	<	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches the end of the line or a "//" comment
407	<	if (ARROW.compare(*iter) && NameOfMod.compare(*iter)) {                 // ignores "->" and "NameOfMod"
398	>	tokenize(line, tokens);
399	>	if (tokens.capacity() >= 3)
400	>	{
401	>	iter = tokens.begin();
402	>
403	>	if (!AEInstallVersion.compare(*iter))
404	>	{
405	>	iter++; iter++;
406	>	package.installerVersion = *iter;
407	>	}
408	>	else if (!NameOfMod.compare(*iter))
409	>	{
410	>	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) // iterates through the words, ends if it reaches the end of the line or a "//" comment
411	>	{
412	>	if (ARROW.compare(*iter) && NameOfMod.compare(*iter)) // ignores "->" and "NameOfMod"
413		package.name += *iter + " ";
399	–	}
414		}
401	–
415		}
416	<	else if (!ModString.compare(*iter)) {
416	>	else if (!ModString.compare(*iter))
417	>	{
418		iter++; iter++;
419	<	package.modStringName = *iter;
419	>	//package.modStringName = *iter;
420		iter++;
421	<	package.modStringVersion = atoi((*iter).c_str());
421	>	package.modStringVersion = atof((*iter).c_str());
422		}
423	<	else if (!HasOnis.compare(*iter)) {
423	>	else if (!ModVersion.compare(*iter))
424	>	{
425	>	iter++; iter++;
426	>	package.modStringVersion = atof((*iter).c_str());
427	>	}
428	>	else if (!Platform.compare(*iter))
429	>	{
430	>	iter++; iter++;
431	>	package.platform = *iter;
432	>	}
433	>	else if (!HasOnis.compare(*iter))
434	>	{
435		iter++; iter++;
436	<	if ( boost::iequals(*iter, "Yes")) package.hasOnis = 1;
436	>	if (boost::iequals(*iter, "Yes")) package.hasOnis = 1;
437		}
438	<	else if (!HasBSL.compare(*iter)) {
439	<	if(toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.hasBSL = true;
440	<	else if ( boost::iequals(*iter, "Addon")) package.hasAddon = true;
438	>	else if (!HasBSL.compare(*iter))
439	>	{
440	>	iter++; iter++;
441	>	if (boost::iequals(*iter, "Yes")) package.hasBSL = true;
442	>	else if (boost::iequals(*iter, "Addon")) package.hasAddon = true;
443		}
444	<	else if (!HasDeltas.compare(*iter)) {
444	>	else if (!HasDeltas.compare(*iter))
445	>	{
446		iter++; iter++;
447	<	if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.hasDeltas = 1;
447	>	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.hasDeltas = 1;
448		}
449	<	else if (!HasDats.compare(*iter)) {
449	>	else if (!HasDats.compare(*iter))
450	>	{
451		iter++; iter++;
452	<	if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.hasDats = 1;
452	>	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.hasDats = 1;
453		}
454	<	else if (!IsEngine.compare(*iter)) {
454	>	else if (!IsEngine.compare(*iter))
455	>	{
456		iter++; iter++;
457	<	if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.isEngine = 1;
457	>	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.isEngine = 1;
458		}
459	<	else if (!GlobalNeeded.compare(*iter)) {
459	>	else if (!GlobalNeeded.compare(*iter))
460	>	{
461		iter++; iter++;
462	<	if (toupper((*iter)[0]) + toupper((*iter)[1]) + toupper((*iter)[2]) == 'Y' + 'E' + 'S') package.globalNeeded = 1;
463	<	else if (toupper((*iter)[0]) + toupper((*iter)[1]) == 'N' + 'O') package.globalNeeded = 1; // only place where checking for "No" is important atm.
462	>	if (toupper((*iter)[0]) == 'Y' && toupper((*iter)[1]) == 'E' && toupper((*iter)[2]) == 'S') package.globalNeeded = 1;
463	>	else if (toupper((*iter)[0]) == 'N' && toupper((*iter)[1]) == 'O') package.globalNeeded = 1; // only place where checking for "No" is important atm
464		}
465	<	else if (!Category.compare(*iter))  {
466	<	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
467	<	if (ARROW.compare(*iter) && Category.compare(*iter)) {                  // ignores "->" and "Category"
465	>	else if (!Category.compare(*iter))
466	>	{
467	>	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++)
468	>	{
469	>	if (ARROW.compare(*iter) && Category.compare(*iter)) // ignores "->" and "Category"
470		package.category += *iter + " ";
438	–	}
471		}
472		}
473	<	else if (!Creator.compare(*iter))  {    //if it contains the name
474	<	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
475	<	if (ARROW.compare(*iter) && Creator.compare(*iter)) {                   // ignores "->" and "Creator"
473	>	else if (!Creator.compare(*iter))
474	>	{
475	>	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++)
476	>	{
477	>	if (ARROW.compare(*iter) && Creator.compare(*iter)) // ignores "->" and "Creator"
478		package.creator += *iter + " ";
445	–	}
479		}
480		}
481	<	else if (!Readme.compare(*iter))  {     //if it contains the name
482	<	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++) {     // iterates through the words, ends if it reaches end of line or a "//" comment
483	<	if (ARROW.compare(*iter) && Readme.compare(*iter)) {                    // ignores "->" and "Readme"
484	<	if(!(*iter).compare("\\n")) package.readme += '\n';
481	>	else if (!Readme.compare(*iter))
482	>	{
483	>	for ( ; iter !=tokens.end() && SLASHSLASH.compare(*iter); iter++)
484	>	{
485	>	if (ARROW.compare(*iter) && Readme.compare(*iter)) // ignores "->" and "Readme"
486	>	{
487	>	if (!(*iter).compare("\\n")) package.readme += '\n';
488		else package.readme += *iter + " ";
489		}
490		}
491		}
492		}
457	–
493		}
494	<
494	>	package.modStringName = modName;
495		return package;
496		}
497
#	Line 528 | Line 563 | void recompileAll(vector<string> install
563
564
565		setProgressBar( (int)(1000 * (float)(j-1) / (float)numberOfDats) ); //100% * dat we're on / total dats
566	<	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +  dir_itr->path().filename() + " ");
566	>	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +
567	>	dir_itr->path().filename() + " ");
568
569		system(importCommand.c_str());
570		j++;
#	Line 555 | Line 591 | void recompileAll(vector<string> install
591		else if(splitInstances == false){
592		directory_iterator end_iter;
593
594	<	for ( directory_iterator dir_itr( vanilla_dir );
595	<	dir_itr != end_iter;
596	<	++dir_itr )
597	<	{
598	<	if ( is_directory( dir_itr->status() ) )
599	<	{
600	<	numberOfDats++;
594	>
595	>	char levelnums[256] = {0};
596	>
597	>
598	>
599	>	for(int k = 0; k < 256; k++) {
600	>	if( exists( (path)("./VanillaDats/level" + lexical_cast<std::string>(k) + "_final/") ) ) {
601	>	levelnums[k] = 1;
602	>
603		}
604		}
605	<
605	>
606	>	for (int i = installedMods.size() - 1; i >= 0; i--) {                                                   //Iterates through the installed mods (backwards :P)
607	>	for (unsigned int j = 0; j < globalPackages.size(); ++j) {                              //looking in the global packages
608	>	if (globalPackages[j].modStringName == installedMods[i]) {      //for a mod that has BSL in it
609	>	for(int k = 0; k < 256; k++) {
610	>	if( globalPackages[j].hasOnis &&
611	>	exists( (path)("packages/" + globalPackages[j].modStringName + "/oni/level" + lexical_cast<std::string>(k) + "_final/") ) ) {
612	>	levelnums[k] = 1;
613	>
614	>	}
615	>	}
616	>	}
617	>	}
618	>	}
619	>	for (int levelnum = 0; levelnum < 256; levelnum++)
620	>	if (levelnums[levelnum])
621	>	numberOfDats++;
622	>
623		out << numberOfDats;
624		datString = out.str();
625	<
626	<	for ( directory_iterator dir_itr( vanilla_dir );
572	<	dir_itr != end_iter;
573	<	++dir_itr )
574	<	{
625	>
626	>	for(int levelnum = 0; levelnum < 256; levelnum++) {
627		try
628		{
629	<	if ( is_directory( dir_itr->status() ) )
629	>	if ( levelnums[levelnum] )
630		{
631	<	importCommand = strOniSplit + " " + strImportOption + " " + vanilla_dir.string() + dir_itr->path().filename() + " ";
631	>	importCommand = strOniSplit + " " + strImportOption + " " + vanilla_dir.string() + "level" + lexical_cast<std::string>(levelnum) + "_Final ";
632		for (unsigned int i = 0; i < installedMods.size(); ++i) {
633	<	if (exists("packages/" + installedMods[i] + "/oni/" + dir_itr->path().filename()  ))
634	<	importCommand += " packages/" + installedMods[i] + "/oni/" + dir_itr->path().filename();
633	>	if (exists((path)("packages/" + installedMods[i] + "/oni/level" + lexical_cast<std::string>(levelnum) + "_final") ))
634	>	importCommand += " packages/" + installedMods[i] + "/oni/level" + lexical_cast<std::string>(levelnum) + "_Final";
635		}
636	<	importCommand += " ../GameDataFolder/" + dir_itr->path().filename() + ".dat >> Install.log";
636	>	importCommand += " ../GameDataFolder/level" + lexical_cast<std::string>(levelnum) + "_Final.dat >> Install.log";
637
638		setProgressBar( (int)(1000 * (float)(j-1) / (float)numberOfDats) ); //100% * dat we're on / total dats
639	<	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +  dir_itr->path().filename() + " ");
639	>	setStatusArea("Step " + lexical_cast<std::string>(j) + '/' + lexical_cast<std::string>(numberOfDats)+ ": Importing " +
640	>	"level" + lexical_cast<std::string>(levelnum) + "_Final"+ " ");
641		system(importCommand.c_str());
642		j++;
643		}
#	Line 604 | Line 657 | void recompileAll(vector<string> install
657		vector<string> skippedfolders;
658
659		ofstream BSLlog("BSL.log");
660	+	if(!exists("../GameDataFolder/BSLBackup/")) {
661	+	create_directory("../GameDataFolder/BSLBackup/");
662	+	copy("../GameDataFolder/IGMD/", "../GameDataFolder/BSLBackup/");
663	+	}
664	+
665		for ( directory_iterator dir_itr( "../GameDataFolder/IGMD/" ), end_itr;
666		dir_itr != end_itr;
667		++dir_itr ) {
#	Line 616 | Line 674 | void recompileAll(vector<string> install
674		for (int i = installedMods.size() - 1; i >= 0; i--) {                                                   //Iterates through the installed mods (backwards :P)
675		for (unsigned int j = 0; j < globalPackages.size(); ++j) {                              //looking in the global packages
676		if (globalPackages[j].modStringName == installedMods[i]) {      //for a mod that has BSL in it
677	<	if(!(globalPackages[j].hasAddon || globalPackages[j].hasBSL)) break; //skip non-BSL
677	>	if(globalPackages[j].hasBSL) break; //skip non-BSL
678		if( exists( "packages/" + globalPackages[j].modStringName + "/BSL/" ) ) {
679		copyBSL("packages/" + globalPackages[j].modStringName + "/BSL", BSLfolders, globalPackages[j] );
680		BSLlog << "Copied " <<  globalPackages[j].modStringName << "!\n";
#	Line 625 | Line 683 | void recompileAll(vector<string> install
683		}
684		}
685
686	+
687	+
688		ModPackage emptyPackage;
689		emptyPackage.modStringName = "VanillaBSL";
690		emptyPackage.hasBSL = 1;
691		copyBSL("packages/VanillaBSL/IGMD", BSLfolders, emptyPackage);
692		BSLlog.close();
693	<
693	>
694	>	for (int i = installedMods.size() - 1; i >= 0; i--) {                                                   //Iterates through the installed mods (backwards :P)
695	>	for (unsigned int j = 0; j < globalPackages.size(); ++j) {                              //looking in the global packages
696	>	if (globalPackages[j].modStringName == installedMods[i]) {      //for a mod that has BSL in it
697	>	if(!globalPackages[j].hasAddon) break; //skip non-BSL
698	>	if( exists( "packages/" + globalPackages[j].modStringName + "/BSL/" ) ) {
699	>	copyBSL("packages/" + globalPackages[j].modStringName + "/BSL", BSLfolders, globalPackages[j] );
700	>	BSLlog << "Copied " <<  globalPackages[j].modStringName << "!\n";
701	>	}
702	>	}
703	>	}
704	>	}
705	>
706		logfile << "Writing config file";
707		writeInstalledMods(installedMods);
708		setProgressBar(1000);
#	Line 661 | Line 733 | void recompileAll(vector<string> install
733
734		void copyBSL(string copypath, vector<string>& BSLfolders, ModPackage pkg)
735		{
736	<	ofstream BSLlog("BSL2.log", ios::app );
736	>	ofstream BSLlog("BSL.log", ios::app );
737
738		try {
739		for ( directory_iterator dir_itr( copypath ), end_itr;
#	Line 671 | Line 743 | void copyBSL(string copypath, vector<str
743		if ( is_directory( dir_itr->path() ) && dir_itr->path().string() != ".svn" ) {
744		BSLlog << "Testing " << dir_itr->path().string() << " HasBSL: " << pkg.hasBSL << " HasAddon: " << pkg.hasAddon << "\n";
745		int skip_folder = 0;
746	<
747	<	for(unsigned int k = 0; k < BSLfolders.size(); k++)             {//iterate through already found BSL folders
748	<	BSLlog << "testing " << dir_itr->path().filename() << " vs " << BSLfolders[k] << "\n";
749	<	if(dir_itr->path().filename() == BSLfolders[k]) {
750	<	skip_folder = 1;
751	<	BSLlog << "skipping " << BSLfolders[k] << " in " << pkg.modStringName << "\n";
752	<	break;
746	>	if(!pkg.hasAddon) {
747	>	for(unsigned int k = 0; k < BSLfolders.size(); k++)             {//iterate through already found BSL folders
748	>	BSLlog << "testing " << dir_itr->path().filename() << " vs " << BSLfolders[k] << "\n";
749	>	if(dir_itr->path().filename() == BSLfolders[k]) {
750	>	skip_folder = 1;
751	>	BSLlog << "skipping " << BSLfolders[k] << " in " << pkg.modStringName << "\n";
752	>	break;
753	>	}
754		}
755		}
756		if (!skip_folder && !exists("../GameDataFolder/IGMD/" + dir_itr->path().filename() + "/ignore.txt")) {
757	<	remove_all( "../GameDataFolder/IGMD/" + dir_itr->path().filename() );
757	>	if(!pkg.hasAddon) remove_all( "../GameDataFolder/IGMD/" + dir_itr->path().filename() );
758		Sleep(100);
759		create_directory( "../GameDataFolder/IGMD/" + dir_itr->path().filename());
760		BSLlog << "Copied " << dir_itr->path().string() << " in " << pkg.modStringName << "!\n";
#	Line 689 | Line 762 | void copyBSL(string copypath, vector<str
762		bsl_itr != end_itr;
763		bsl_itr++ ) {
764		if ( bsl_itr->path().extension() == ".bsl" ) {
765	+	if(exists("../GameDataFolder/IGMD/" + dir_itr->path().filename() + "/" + bsl_itr->path().filename()))
766	+	remove("../GameDataFolder/IGMD/" + dir_itr->path().filename() + "/" + bsl_itr->path().filename());
767		copy_file(bsl_itr->path(),  "../GameDataFolder/IGMD/" + dir_itr->path().filename() + "/" + bsl_itr->path().filename());
768		}
769		}
770	<	BSLfolders.push_back( dir_itr->path().filename() ); //add back check for addon
771	<	BSLlog << "Pushing " << dir_itr->path().filename() << "\n" ;
770	>	if( !pkg.hasAddon ) {
771	>	BSLfolders.push_back( dir_itr->path().filename() ); //add back check for addon
772	>	BSLlog << "Pushing " << dir_itr->path().filename() << "\n" ;
773	>	}
774		}
775		}
776		}
#	Line 769 | Line 846 | vector<string> getInstallString(string C
846		|                                                          Installer to be replaced (when the new Installer                     |
847		|                                                          launches, this function will be called again but will        |
848		|                                                          return UPDATE_SIMP_AVAIL or UPDATE_GLOB_AVAIL)                       |
849	+	|  UPDATE_PKG_AVAIL                     -- A newer version of individual package(s) is available        |
850		\* UPDATE_CONT_UPD                      -- Currently unused                                                                                */
851		int GetUpdateStatus(Install_info_cfg *currentAE, Install_info_cfg *updateAE, bool *installerJustUpdated)
852		{
#	Line 797 | Line 875 | int GetUpdateStatus(Install_info_cfg *cu
875		else
876		return UPDATE_LOG_READ_ERR;
877		}
878	<
879	<	// Is there an update folder, and is it a monthly release or a patch?
880	<	if (!exists("../updates/Edition"))
878	>
879	>	// Is there an update in the updates/ folder, and is it a monthly release or a patch?
880	>	bool firstParty = 0;
881	>	// First create the folder if it's missing, so users are never left wondering where updates are supposed to be put
882	>	if (!exists("../updates"))
883	>	create_directory("../updates");
884	>	if (exists("../updates/Edition"))
885		{
886	+	firstParty = 1;
887	+	}
888	+	else {
889		strEUFN = "Edition-patch";
890	<	if (!exists("../updates/Edition-patch"))
891	<	return UPDATE_NO_UPD_AVAIL;
890	>	if (exists("../updates/Edition-patch")) {
891	>	firstParty = 1;
892	>	}
893	>
894		}
895	<
896	<	// Unlike the current AE's version info, we *need* to find the update's version info or we won't continue
897	<	string updateCfgPath = ("../updates/" + strEUFN + "/install/packages/Globalize/Install_Info.cfg");
898	<	updateAECfg.open(updateCfgPath.c_str());
899	<	if (!updateAECfg.fail())
900	<	{
901	<	if (!ReadInstallInfoCfg(&updateAECfg, updateAE))
895	>
896	>	if(firstParty) {
897	>	// Unlike the current AE's version info, we *need* to find the update's version info or we won't continue
898	>	string updateCfgPath = ("../updates/" + strEUFN + "/install/packages/Globalize/Install_Info.cfg");
899	>	updateAECfg.open(updateCfgPath.c_str());
900	>	if (!updateAECfg.fail())
901	>	{
902	>	if (!ReadInstallInfoCfg(&updateAECfg, updateAE))
903	>	return UPDATE_LOG_READ_ERR;
904	>
905	>	updateAECfg.close();
906	>	updateAECfg.clear();
907	>	}
908	>	else
909		return UPDATE_LOG_READ_ERR;
816	–
817	–	updateAECfg.close();
818	–	updateAECfg.clear();
819	–	}
820	–	else
821	–	return UPDATE_LOG_READ_ERR;
910
911	<	// Now we check for an Installer update in progress
912	<	if (exists("Update.log"))
913	<	{
914	<	updateLog.open("Update.log");
915	<	if (!updateLog.fail())
828	<	{
829	<	vector<string> lines;
830	<	string line;
831	<	int num_lines = 0;
832	<	bool readingInstallerVersion = false, doneReadingFile = false;
833	<
834	<	while (!updateLog.eof() && !doneReadingFile)
911	>	// Now we check for an Installer update in progress
912	>	if (exists("Update.log"))
913	>	{
914	>	updateLog.open("Update.log");
915	>	if (!updateLog.fail())
916		{
917	<	getline(updateLog, line);
918	<	lines.push_back(line);
919	<	num_lines++;
920	<	vector<string> tokens;
921	<	vector<string>::iterator iter;
922	<	tokenize(line, tokens);
842	<	iter = tokens.begin();
843	<	if (!readingInstallerVersion && tokens.capacity() >= 4)
917	>	vector<string> lines;
918	>	string line;
919	>	int num_lines = 0;
920	>	bool readingInstallerVersion = false, doneReadingFile = false;
921	>
922	>	while (!updateLog.eof() && !doneReadingFile)
923		{
924	<	if (!strInstaller.compare(*iter))
924	>	getline(updateLog, line);
925	>	lines.push_back(line);
926	>	num_lines++;
927	>	vector<string> tokens;
928	>	vector<string>::iterator iter;
929	>	tokenize(line, tokens);
930	>	iter = tokens.begin();
931	>	if (!readingInstallerVersion && tokens.capacity() >= 4)
932		{
933	<	if (!strBeing.compare(*++iter))
934	<	readingInstallerVersion = true;
935	<	else if (!strWas.compare(*iter))
936	<	*installerJustUpdated = true; // our third indirect return value after currentAE and updateAE
933	>	if (!strInstaller.compare(*iter))
934	>	{
935	>	if (!strBeing.compare(*++iter))
936	>	readingInstallerVersion = true;
937	>	else if (!strWas.compare(*iter))
938	>	*installerJustUpdated = true; // our third indirect return value after currentAE and updateAE
939	>	}
940		}
941	<	}
853	<	else if (readingInstallerVersion && tokens.capacity() >= 3)
854	<	{
855	<	readingInstallerVersion = false;
856	<	string installerVersion = INSTALLER_VERSION;
857	<	if (installerVersion.compare(*iter)) // then the shell script-powered replacement failed
858	<	return UPDATE_INST_REPL_ERR;
859	<	else
941	>	else if (readingInstallerVersion && tokens.capacity() >= 3)
942		{
943	<	updateLog.close();
944	<	updateLog.clear();
945	<	Sleep(1000);
946	<	remove("Update.log");
947	<	ofstream newUpdateLog("Update.log");
866	<	if (!newUpdateLog.fail())
943	>	readingInstallerVersion = false;
944	>	string installerVersion = INSTALLER_VERSION;
945	>	if (installerVersion.compare(*iter)) // then the shell script-powered replacement failed
946	>	return UPDATE_INST_REPL_ERR;
947	>	else
948		{
949	<	// Write over old log with updated information
950	<	ptime startTime(second_clock::local_time());
951	<	string strStartTime = to_simple_string(startTime);
952	<	string newUpdateLine = installerVersion + " on " + strStartTime;
953	<	for (int a = 0; a < lines.capacity() - 2; a++) // if there were even lines in the log before this at all
949	>	updateLog.close();
950	>	updateLog.clear();
951	>	Sleep(1000);
952	>	remove("Update.log");
953	>	ofstream newUpdateLog("Update.log");
954	>	if (!newUpdateLog.fail())
955		{
956	<	newUpdateLog << lines[a].c_str();
957	<	newUpdateLog << "\n";
956	>	// Write over old log with updated information
957	>	ptime startTime(second_clock::local_time());
958	>	string strStartTime = to_simple_string(startTime);
959	>	string newUpdateLine = installerVersion + " on " + strStartTime;
960	>	for (int a = 0; a < lines.capacity() - 2; a++) // if there were even lines in the log before this at all
961	>	{
962	>	newUpdateLog << lines[a].c_str();
963	>	newUpdateLog << "\n";
964	>	}
965	>	newUpdateLog << "Installer was updated to:\n";
966	>	newUpdateLog << newUpdateLine.c_str();
967	>	*installerJustUpdated = true; // this value is indirectly returned to AEInstallerApp::OnInit()
968	>	doneReadingFile = true;
969	>	newUpdateLog.close();
970	>	newUpdateLog.clear();
971	>	//return UPDATE_CONT_UPD; // as noted above, we are not using this return value; in fact, we want...
972	>	//                                                       ...the code to continue running down through the Edition version check
973		}
974	<	newUpdateLog << "Installer was updated to:\n";
975	<	newUpdateLog << newUpdateLine.c_str();
879	<	*installerJustUpdated = true; // this value is indirectly returned to AEInstallerAp::OnInit()
880	<	doneReadingFile = true;
881	<	newUpdateLog.close();
882	<	newUpdateLog.clear();
883	<	//return UPDATE_CONT_UPD; // as noted above, we are not using this return value; in fact, we want...
884	<	//                                                       ...the code to continue running down through the Edition version check
974	>	else
975	>	return UPDATE_LOG_READ_ERR;
976		}
886	–	else
887	–	return UPDATE_LOG_READ_ERR;
977		}
978		}
979	+	updateLog.close();
980	+	updateLog.clear();
981	+	}
982	+	else
983	+	return UPDATE_LOG_READ_ERR;
984	+	}
985	+
986	+	if (updateAE->AEVersion.compare(currentAE->AEVersion) > 0) // is the release update newer than what's installed?
987	+	{
988	+	string strNewInstallerPath = "../updates/" + strEUFN + "/install/" + strInstallerName;
989	+	string installerVersion = INSTALLER_VERSION;
990	+	if (updateAE->InstallerVersion.compare(installerVersion) >= 1)
991	+	{
992	+	if (exists(strNewInstallerPath))
993	+	return UPDATE_INST_AVAIL;
994		}
995	<	updateLog.close();
996	<	updateLog.clear();
995	>	else if (updateAE->globalizationRequired)
996	>	return UPDATE_GLOB_AVAIL;
997	>	else
998	>	return UPDATE_SIMP_AVAIL;
999		}
1000		else
1001	<	return UPDATE_LOG_READ_ERR;
1001	>	return UPDATE_MNTH_REQD_ERR;
1002		}
1003	<
898	<	if (updateAE->AEVersion.compare(currentAE->AEVersion) >= 1) // is the release update newer than what's installed?
1003	>	try
1004		{
1005	<	if (!strEUFN.compare("Edition-patch")) // if update is a patch...
1006	<	{
902	<	if (currentAE->AEVersion.compare(updateAE->AEVersion.substr(0, updateAE->AEVersion.length() - 1))) // ...is it for a different month?
903	<	return UPDATE_MNTH_REQD_ERR;
904	<	}
905	<	string strNewInstallerPath = "../updates/" + strEUFN + "/install/" + strInstallerName;
906	<	string installerVersion = INSTALLER_VERSION;
907	<	if (updateAE->InstallerVersion.compare(installerVersion) >= 1)
1005	>	directory_iterator end;
1006	>	if (exists("../updates"))
1007		{
1008	<	if (exists(strNewInstallerPath))
1009	<	return UPDATE_INST_AVAIL;
1008	>	for (directory_iterator install_iter("../updates"); install_iter != end; ++install_iter)
1009	>	{
1010	>	ModPackage installedPackage, updatePackage;
1011	>	if (is_directory(install_iter->path()) && exists(install_iter->path().string() + "/Mod_Info.cfg"))
1012	>	{
1013	>	fstream file;
1014	>	file.open((install_iter->path().string() + "/Mod_Info.cfg").c_str());
1015	>	if (!file.fail())
1016	>	updatePackage = fileToModPackage(file, install_iter->path().filename());
1017	>	else
1018	>	{
1019	>	file.close();
1020	>	continue;
1021	>	}
1022	>	if (exists("packages/" + install_iter->path().filename() + "/Mod_Info.cfg"))
1023	>	{
1024	>	file.close();
1025	>	file.clear();
1026	>	file.open(("packages/" + install_iter->path().filename() + "/Mod_Info.cfg").c_str());
1027	>	if (!file.fail())
1028	>	installedPackage = fileToModPackage(file, install_iter->path().filename());
1029	>	file.close();
1030	>	if (updatePackage.modStringVersion > installedPackage.modStringVersion)
1031	>	{
1032	>	if (updatePackage.installerVersion <= INSTALLER_VERSION)
1033	>	return UPDATE_PKG_AVAIL;
1034	>	}
1035	>	}
1036	>	else
1037	>	{
1038	>	file.close();
1039	>	return UPDATE_PKG_AVAIL;
1040	>	}
1041	>	}
1042	>	}
1043		}
912	–	else if (updateAE->globalizationRequired)
913	–	return UPDATE_GLOB_AVAIL;
914	–	else
915	–	return UPDATE_SIMP_AVAIL;
1044		}
1045	<	else
1046	<	return UPDATE_NO_UPD_AVAIL;
1047	<
1045	>	catch (exception & ex) {
1046	>	//      setStatusArea("Warning, handled exception: " + (string)ex.what());
1047	>	}
1048	>
1049		return UPDATE_NO_UPD_AVAIL;
1050		}
1051
#	Line 930 | Line 1059 | bool ReadInstallInfoCfg(fstream *fileHan
1059		string strDaodanVersion = "Daodan_Version";
1060		string strOniSplitVersion = "OniSplit_Version";
1061		string strGUIWinVersion = "GUI_Win_Version";
1062	<	string strGUIMacVersion = "GUI_Mac_Version";
1062	>	string strGUIMacVersion = "GUI_Mac_Version";
1063		string strReglobalize = "Reglobalize";
1064		string strDeleteList = "Delete_List";
1065		string strArrow = "->";
#	Line 939 | Line 1068 | bool ReadInstallInfoCfg(fstream *fileHan
1068
1069		while (getline(*fileHandler, line))
1070		{
1071	+	StripNewlines(&line);
1072		tokenize(line, tokens);
1073		iter = tokens.begin();
1074
#	Line 1141 | Line 1271 | bool ProcessInstallerUpdate(Install_info
1271
1272		string popenCommand = "../updates/" + strEUFN + "/install/";
1273		#ifdef WIN32
1274	<	// TODO: Fill in Windows equivalent of code below :-3
1274	>	popenCommand = "replace_installer.bat";
1275		#else
1276		// We can't just use '~' to mean "the home directory" because we need to check the path in C...
1277		// ...so we actually get the current user's shortname and manually construct the path to home
#	Line 1163 | Line 1293 | bool ProcessInstallerUpdate(Install_info
1293		#endif
1294		file.close();
1295		file.clear();
1296	+	#ifdef WIN32
1297	+	system(popenCommand.c_str());
1298	+	#else
1299		popen(popenCommand.c_str(), "r");
1300	<
1300	>	#endif
1301		return true; // returning 'true' tells the Installer to quit itself ASAP so it can be replaced by the process that is now running
1302		}
1303
1304		bool ProcessAEUpdate(Install_info_cfg *currentAE, Install_info_cfg *updateAE, bool *installerJustUpdated)
1305		{
1306	+	try {
1307		fstream file;
1308		string line;
1309		vector<string> tokens, updateStarted;
#	Line 1189 | Line 1323 | bool ProcessAEUpdate(Install_info_cfg *c
1323		string strOniApp = "Oni.exe";
1324		#else
1325		string strOniApp = "Oni.app";
1192	–	#endif
1326		bool needNewTrashDir = false;
1327	+	#endif
1328	+
1329		bool readingVerAndDate = false;
1330
1196	–	// TODO: Fill in Windows equivalent of code below
1331		#ifdef WIN32
1332	<	string strTrashDir = "%RECYCLE%";
1332	>	//remove readonly attrib from files.
1333	>	setStatusArea("Removing readonly attribute...");
1334	>	system("attrib -r ./* /s");
1335	>	system("attrib -r ../Oni.exe /s");
1336	>	system("attrib -r ../binkw32.dll /s");
1337	>
1338		#else
1339		FILE *fUserName = NULL;
1340		char chrUserName[32];
#	Line 1230 | Line 1369 | bool ProcessAEUpdate(Install_info_cfg *c
1369		if (readingVerAndDate && tokens.capacity() >= 3)
1370		tokenize(tokens[2], updateStarted, "-");
1371		}
1372	+	#ifndef WIN32
1373		if (updateStarted.capacity() < 3)
1374		needNewTrashDir = true;
1375		else
#	Line 1239 | Line 1379 | bool ProcessAEUpdate(Install_info_cfg *c
1379		if (!exists(strTrashDir))
1380		needNewTrashDir = true;
1381		}
1382	+	#endif
1383		}
1384	<
1384	>	#ifndef WIN32
1385		if (!*installerJustUpdated || needNewTrashDir) // prepare a new directory for deleted files to go to
1386		{
1387		tm tmStartTime = to_tm(startTime);
#	Line 1248 | Line 1389 | bool ProcessAEUpdate(Install_info_cfg *c
1389		boost::lexical_cast<string>(tmStartTime.tm_min) + "-" + boost::lexical_cast<string>(tmStartTime.tm_sec) + "/";
1390		create_directory(strTrashDir);
1391		}
1392	+	#endif
1393		file.close();
1394		file.clear();
1395
1396		// Special code to replace our special files -- the Oni app, OniSplit, the Daodan DLL, and the GUI for OniSplit
1397		if (exists(strPathToEUFN + strOniApp))
1398		{
1399	<	if (exists(strOniApp))
1400	<	rename((path)strOniApp, (path)(strTrashDir + strOniApp));
1401	<	rename((path)(strPathToEUFN + strOniApp), (path)strOniApp);
1399	>	if (exists("../" + strOniApp))
1400	>	#ifdef WIN32
1401	>	remove((path)("../" + strOniApp));
1402	>	#else
1403	>	rename((path)("../" + strOniApp), (path)(strTrashDir + strOniApp));
1404	>	#endif
1405	>	rename((path)(strPathToEUFN + strOniApp), (path)("../" + strOniApp));
1406		}
1407		if (updateAE->OniSplitVersion.compare(currentAE->OniSplitVersion) >= 1)
1408		{
1409		if (exists(strPathToEUFNInstall + strOniSplit))
1410		{
1411		if (exists(strOniSplit))
1412	+	#ifdef WIN32
1413	+	remove((path)strOniSplit);
1414	+	#else
1415		rename((path)strOniSplit, (path)(strTrashDir + strOniSplit));
1416	+	#endif
1417		rename((path)(strPathToEUFNInstall + strOniSplit), (path)strOniSplit);
1418		}
1419		}
#	Line 1273 | Line 1423 | bool ProcessAEUpdate(Install_info_cfg *c
1423		if (exists(strPathToEUFN + strDaodan))
1424		{
1425		if (exists(("../" + strDaodan)))
1426	<	rename((path)("../" + strDaodan), (path)(strTrashDir + strDaodan));
1426	>	remove((path)("../" + strDaodan));
1427		rename((path)(strPathToEUFN + strDaodan), (path)("../" + strDaodan));
1428		}
1429		}
#	Line 1282 | Line 1432 | bool ProcessAEUpdate(Install_info_cfg *c
1432		if (exists(strPathToEUFNInstall + strWinGUI))
1433		{
1434		if (exists((path)strWinGUI))
1435	<	rename((path)strWinGUI, (path)(strTrashDir + strWinGUI));
1435	>	remove((path)strWinGUI);
1436		if (exists(strWinGUILang))
1437	<	rename((path)strWinGUILang, (path)(strTrashDir + strWinGUILang));
1437	>	remove((path)strWinGUILang);
1438		rename((path)(strPathToEUFNInstall + strWinGUI), (path)strWinGUI);
1439		rename((path)(strPathToEUFNInstall + strWinGUILang), (path)strWinGUILang);
1440		}
#	Line 1317 | Line 1467 | bool ProcessAEUpdate(Install_info_cfg *c
1467		while (curPos != string::npos && curPos < thePath.size())
1468		{
1469		aParentPath = aParentPath + thePath.substr(lastPos, curPos - lastPos);
1470	+	#ifndef WIN32
1471		if (!exists(strTrashDir + aParentPath))
1472		create_directory(strTrashDir + aParentPath);
1473	+	#endif
1474		lastPos = curPos + 1;
1475		curPos = thePath.find("/", lastPos);
1476		aParentPath = aParentPath + "/";
1477		}
1478	+	#ifndef WIN32
1479		rename((path)("../" + thePath), (path)(strTrashDir + thePath));
1480	+	#else
1481	+	remove_all((path)("../" + thePath));
1482	+	#endif
1483		}
1484		}
1485
1486	<	// Now we crawl the update's package folders for newer versions and move them over, trashing ones that are already present
1331	<	vector<ModPackage> updatePackages, currentPackages;
1332	<	bool matchFound;
1333	<	updatePackages.reserve(256);
1334	<	currentPackages.reserve(256);
1486	>	ProcessPackageUpdates(strPathToEUFNPackages, strPathToPackages);
1487
1488	<	currentPackages = getPackages();
1489	<	updatePackages = getPackages(strPathToEUFNPackages);
1490	<
1491	<	for (vector<ModPackage>::iterator iter1 = updatePackages.begin(); iter1 != updatePackages.end(); iter1++)
1488	>	// Next, move over files in the update's Globalize folder; subfolders which do not exist in the current AE will be created by Boost's...
1489	>	// ...create_directories() function
1490	>	string strPath;
1491	>	path thePath;
1492	>	for (recursive_directory_iterator dir_itr(strPathToEUFNPackages + strGlobalize), end_itr; dir_itr != end_itr; ++dir_itr)
1493		{
1494	<	matchFound = false;
1495	<	for (vector<ModPackage>::iterator iter2 = currentPackages.begin(); iter2 != currentPackages.end(); iter2++)
1494	>	strPath = dir_itr->path().string();
1495	>	MakePathLocalToGlobalize(&strPath);
1496	>	thePath = (path)strPath;
1497	>	if (is_regular_file(dir_itr->status()))
1498		{
1499	<	if (!iter1->modStringName.compare(iter2->modStringName))
1499	>	if (thePath.filename().at(0) != '.') // skip over dot-files, which are invisible in Unix
1500		{
1501	<	matchFound = true;
1502	<	if (iter1->modStringVersion > iter2->modStringVersion)
1501	>	if (exists(strPathToPackages + strGlobalize + strPath))
1502	>	{
1503	>	#ifdef WIN32
1504	>	remove((path)(strPathToPackages + strGlobalize + strPath));
1505	>	#else
1506	>	create_directories((path)(strTrashDir + thePath.parent_path().string()));
1507	>	rename((path)(strPathToPackages + strGlobalize + strPath), (path)(strTrashDir + strPath));
1508	>	#endif
1509	>	rename((path)(strPathToEUFNPackages + strGlobalize + strPath), (path)(strPathToPackages + strGlobalize + strPath));
1510	>	}
1511	>	else
1512		{
1513	<	rename((path)(strPathToPackages + iter2->modStringName), (path)(strTrashDir + iter2->modStringName));
1514	<	rename((path)(strPathToEUFNPackages + iter1->modStringName), (path)(strPathToPackages + iter1->modStringName));
1513	>	int slashLoc = 0;
1514	>	slashLoc = strPath.find("/", 0);
1515	>	if (slashLoc != string::npos) // then path contains slashes, so we need to make sure its parents' paths exist before moving it
1516	>	create_directories((path)(strPathToPackages + strGlobalize + thePath.parent_path().string()));
1517	>	rename((path)(strPathToEUFNPackages + strGlobalize + strPath), (path)(strPathToPackages + strGlobalize + strPath));
1518		}
1519		}
1520		}
1354	–	if (!matchFound) // then there's no old package in the way, so just move in the one from the update
1355	–	rename((path)(strPathToEUFNPackages + iter1->modStringName), (path)(strPathToPackages + iter1->modStringName));
1356	–	}
1357	–
1358	–	// 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...
1359	–	// ...and folders which do not exist in the current AE will be created there
1360	–	vector<string> foldersToMake, filesToMove;
1361	–	string thePath;
1362	–	for (recursive_directory_iterator dir_itr(strPathToEUFNPackages + strGlobalize), end_itr; dir_itr != end_itr; ++dir_itr)
1363	–	{
1364	–	thePath = dir_itr->path().string();
1365	–	MakePathLocalToGlobalize(&thePath);
1366	–	if (is_regular_file(dir_itr->status()))
1367	–	{
1368	–	if (dir_itr->filename().at(0) != '.') // skip over dot-files, which are invisible in Unix
1369	–	filesToMove.push_back(thePath);
1370	–	}
1371	–	else if (is_directory(dir_itr->status()))
1372	–	{
1373	–	if (!exists(strPathToPackages + strGlobalize + thePath))
1374	–	foldersToMake.push_back(thePath);
1375	–	}
1376	–	}
1377	–	// Sort the foldersToMake strings by length, which is a fast solution to the problem of "How do we make sure we create folder 'parent/'...
1378	–	// ...before folder 'parent/child/'"?
1379	–	sort(foldersToMake.begin(), foldersToMake.end(), SortBySize); // SortBySize is a custom comparison function found later in this source file
1380	–	// First make the folders that don't exist in the current AE, so all the files have a place to go
1381	–	for (vector<string>::iterator iter = foldersToMake.begin(); iter != foldersToMake.end(); iter++)
1382	–	{
1383	–	create_directory(strPathToPackages + strGlobalize + *iter);
1384	–	}
1385	–	for (vector<string>::iterator iter = filesToMove.begin(); iter != filesToMove.end(); iter++)
1386	–	{
1387	–	if (exists(strPathToPackages + strGlobalize + *iter))
1388	–	rename((path)(strPathToPackages + strGlobalize + *iter), (path)(strTrashDir + *iter));
1389	–	rename((path)(strPathToEUFNPackages + strGlobalize + *iter), (path)(strPathToPackages + strGlobalize + *iter));
1521		}
1522
1523		// Clean up after ourselves, trashing any packages or programs in the update package that are not newer than the current AE
1524	+	#ifdef WIN32
1525	+	remove_all((path)strPathToEUFN);
1526	+	#else
1527		create_directory(strTrashDir + "Unneeded update files");
1528		rename((path)strPathToEUFN, (path)(strTrashDir + "Unneeded update files/" + strEUFN));
1529	<
1529	>	#endif
1530		// Write to log that we are finished with update
1531		ptime end_time(second_clock::local_time());
1532		string progressMsg2 = "Edition was updated to:\n" +
#	Line 1410 | Line 1544 | bool ProcessAEUpdate(Install_info_cfg *c
1544		CheckForGlobalization(true); // the 'true' value forces re-globalization
1545
1546		globalPackages = getPackages(); // refresh the list in memory
1547	<
1548	<	// TODO: Refresh the packages list in the window
1415	<
1547	>	wxCommandEvent e;
1548	>	TheWindow->OnRefreshButtonClick( e );
1549		return true;
1550	+	}
1551	+	catch (exception & ex)
1552	+	{
1553	+	wxMessageDialog* DotNetDialogOfDeath =
1554	+	new wxMessageDialog(TheWindow, ex.what(), "AE Installer Alert",
1555	+	wxICON_EXCLAMATION     , wxDefaultPosition);
1556	+
1557	+	DotNetDialogOfDeath->ShowModal();
1558	+	setStatusArea("Warning, handled exception: " + (string)ex.what());
1559	+	return false;
1560	+	}
1561	+	}
1562	+
1563	+	void ProcessPackageUpdates(string pathToUpdate, string strPathToPackages)
1564	+	{
1565	+	ptime startTime(second_clock::local_time());
1566	+	#ifdef WIN32
1567	+	string strTrashDir = "Trash\\"; // string unused in Windows because files are simply deleted
1568	+	#else
1569	+	FILE *fUserName = NULL;
1570	+	char chrUserName[32];
1571	+	fUserName = popen("whoami", "r");
1572	+	fgets(chrUserName, sizeof(chrUserName), fUserName);
1573	+	pclose(fUserName);
1574	+	string strUserName = (string)chrUserName; // stringsblaaarrrgggghhhh
1575	+	int endOfName = strUserName.find("\n", 0);
1576	+	string strTrashDir = "/Users/" + strUserName.substr(0, endOfName) + "/.Trash/";
1577	+	bool needNewTrashDir = true;
1578	+	tm tmStartTime = to_tm(startTime);
1579	+	#endif
1580	+
1581	+	try
1582	+	{
1583	+	directory_iterator end;
1584	+	for (directory_iterator update_iter(pathToUpdate); update_iter != end; ++update_iter)
1585	+	{
1586	+	ModPackage installedPackage, updatePackage;
1587	+	string updtPath = update_iter->path().string();
1588	+	string updtFolder = update_iter->path().filename();
1589	+	string updtModInfo = updtPath + "/Mod_Info.cfg";
1590	+	string instModInfo = strPathToPackages + "/" + updtFolder + "/Mod_Info.cfg";
1591	+	if (!boost::iequals(updtFolder, "Edition")
1592	+	&& !boost::iequals(updtFolder, "Edition-patch")
1593	+	&& is_directory(update_iter->path())
1594	+	&& exists(updtModInfo))
1595	+	{
1596	+	fstream file;
1597	+	file.open((updtModInfo).c_str());
1598	+	if (!file.fail())
1599	+	updatePackage = fileToModPackage(file, updtFolder);
1600	+	else
1601	+	{
1602	+	file.close();
1603	+	continue;
1604	+	}
1605	+	if (exists(instModInfo))
1606	+	{
1607	+	file.close();
1608	+	file.clear();
1609	+	file.open(instModInfo.c_str());
1610	+	if (!file.fail())
1611	+	{
1612	+	installedPackage = fileToModPackage(file, updtFolder);
1613	+	}
1614	+	file.close();
1615	+	}
1616	+	file.close();
1617	+	if (updatePackage.modStringVersion > installedPackage.modStringVersion)
1618	+	{
1619	+	if (updatePackage.installerVersion <= INSTALLER_VERSION)
1620	+	{
1621	+	if(exists(strPathToPackages +  "/" + updatePackage.modStringName)) {
1622	+	#ifdef WIN32
1623	+	remove_all((path)(strPathToPackages +  "/" + updatePackage.modStringName));
1624	+	#else
1625	+	if (needNewTrashDir)
1626	+	{
1627	+	strTrashDir = strTrashDir + "Old_packages_" + boost::lexical_cast<string>(tmStartTime.tm_hour) + "-" +
1628	+	boost::lexical_cast<string>(tmStartTime.tm_min) + "-" + boost::lexical_cast<string>(tmStartTime.tm_sec) + "/";
1629	+	create_directory(strTrashDir);
1630	+	needNewTrashDir = false;
1631	+	}
1632	+	rename((path)(strPathToPackages +  "/" + updatePackage.modStringName), (path)(strTrashDir + updatePackage.modStringName));
1633	+	#endif
1634	+	}
1635	+	rename((path)(pathToUpdate + "/" + updatePackage.modStringName), (path)(strPathToPackages + "/" + updatePackage.modStringName));
1636	+	}
1637	+	}
1638	+	}
1639	+	}
1640	+	}
1641	+	catch (exception & ex)
1642	+	{
1643	+	setStatusArea("Warning, handled exception: " + (string)ex.what());
1644	+	}
1645	+	wxCommandEvent e;
1646	+	TheWindow->OnRefreshButtonClick( e );
1647		}
1648
1649		/* MakePathLocalToGlobalize is a function used once by ProcessAEUpdate() that takes a file in an        \
#	Line 1457 | Line 1687 | void tokenize(const string& str, vector<
1687		}
1688		}
1689
1690	+	/* StripNewlines() gets rids of any linebreaks that come from text returned by getline(); \
1691	+	|  getline() should be stripping those out, but Windows CR/LF files seem to be sneaking   |
1692	+	\  some extra return characters into strings in the ReadInstallInfoCfg() function.               */
1693	+	void StripNewlines(string *theLine)
1694	+	{
1695	+	int deleteFromHere = 0;
1696	+	deleteFromHere = theLine->find("\r");
1697	+	if (deleteFromHere > 0)
1698	+	theLine->erase(deleteFromHere, theLine->size());
1699	+	}
1700	+
1701		void clearOldDats(void) {
1702		directory_iterator end_iter_gdf;
1703		for ( directory_iterator dir_itr_gdf( "../GameDataFolder" );
#	Line 1501 | Line 1742 | void copy( const path & from_ph,
1742
1743		}
1744		else if(from_ph.filename() != ".svn")
1745	<	{
1746	<	path destination;
1747	<	if(!exists(to_ph))
1748	<	{
1749	<	destination=to_ph;
1750	<	}
1751	<	else
1752	<	{
1753	<	destination=to_ph/from_ph.filename();
1754	<	}
1745	>	{
1746	>	path destination;
1747	>	if(!exists(to_ph))
1748	>	{
1749	>	destination=to_ph;
1750	>	}
1751	>	else
1752	>	{
1753	>	destination=to_ph/from_ph.filename();
1754	>	}
1755
1756	<	for(directory_iterator i(from_ph); i!=directory_iterator(); ++i)
1756	>	for(directory_iterator i(from_ph); i!=directory_iterator(); ++i)
1757		{
1758		//the idiot who coded this in the first place (not me)
1759		//forgot to make a new directory. Exception city. x_x
1760	<	create_directory(destination);
1761	<	copy(*i,destination/i->filename());
1760	>	create_directory(destination);
1761	>	copy(*i, destination/i->filename());
1762		}
1763		}
1764		}
#	Line 1571 | Line 1812 | ModPackage::ModPackage()
1812		name = "";
1813		modStringName = "";
1814		modStringVersion = 0;
1815	+	platform = "Both";
1816		hasOnis = false;
1817		hasDeltas = false;
1818		hasBSL = false;

Diff Legend

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