WebSVN – spk – Diff – /libspk/src/Packages.cpp



					long time = rest.toLong();
					if ( time == m_iLastUpdated )
					{
						this->PurgeWares();
						this->PurgeShips();
						this->removeUninstallScripts();
					}
				}
			}
 
			delete lines;

	this->ConvertOldPackage (installFile);
 
	return installFile;
}
 
void CPackages::purgeUninstallScripts(CBaseFile *package, Utils::CStringList *errors)
{
	for ( CListNode<C_File> *fNode = m_lUninstallFiles.Front(); fNode; fNode = fNode->next() )
	{
		C_File *uf = fNode->Data();
		// check against any script files

			if ( checkFile->GetFileType() != FILETYPE_UNINSTALL && checkFile->GetFileType() != FILETYPE_SCRIPT )
				continue;
 
			if ( uf->filename().Compare(checkFile->filename()) )
			{
				if (removeUninstallFile(uf, errors) )
					fNode->DeleteData();
				break;
			}
		}
	}

	m_lUninstallFiles.RemoveEmpty();
 
	this->WriteData();
}
 
int CPackages::installPreparedPackages(Utils::CStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *errored, CLinkList<CBaseFile> *installedList)
{
	if ( m_lInstallList.empty() ) return false;
 
	int installed = 0;
	for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )
	{
		CBaseFile *p = node->Data();
		if ( this->installPackage(p, errors, progress, !p->IsEnabled()) )
		{
			++installed;
			if ( installedList )
				installedList->push_back(p);
		}

{ 
	return (_pCurrentDir) ? _pCurrentDir->dir : Utils::String::Null(); 
}
 
 
bool CPackages::installPackage(CBaseFile *package, Utils::CStringList *errors, CProgressInfo *progress, bool disabled)
{
	CLog::logf(CLog::Log_Install, 1, "Starting to install new package, %s by %s (Version: %s)", package->name().c_str(), package->author().c_str(), package->version().c_str());
	
 
 
	CBaseFile *oldPackage = findPackage(package);
	disabled = _checkForDisable(package, disabled, oldPackage);
 
	// update packages must have an old package installed already (should have been checked for already)
	if ( package->GetType() == TYPE_SPK )

	// no need to backup if we're disabling them
	if ( !disabled )
	{
		// find any uninstall files and remove them
		CLog::log(CLog::Log_Install, 3, "Purging uninstall scripts");
		this->purgeUninstallScripts(package, errors);
 
		// backup any original files before installing
		_pOriginalFiles->backup(package, errors);
	}
 

 
	CLog::log(CLog::Log_Install, 3, "Reading all files into memory");
	package->ReadAllFilesToMemory();
 
	CLog::log(CLog::Log_Install, 3, "Starting to install files");
	if ( !package->installFiles (m_sCurrentDir, progress, &m_lFiles, errors, !disabled, this) )
	{
		CLog::log(CLog::Log_Install, 2, "There was an error installing files!!");
 
		// TODO: clear up installed files
		return false;

						}
					}
 
					// now remove the files
					C_File *m = package->findMatchingMod(f->Data());
					removeFile(f->Data(), errors);
					m_lFiles.remove(f->Data());
					f->ChangeData(NULL);
					if ( m )
					{
						int pos = package->GetFileList()->FindPos(m);
						removeFile(m, errors);
						m_lFiles.remove(m);
						if ( pos != -1 )
							package->GetFileList()->GetNode(pos)->ChangeData(NULL);
					}
				}

					if ( package->findFile(f->filename(), FILETYPE_README) )
						dontRemove = true;
				}
 
				// remove from hard drive
				if ( !dontRemove && removeFile(f, errors) )
				{
					CLog::logf(CLog::Log_Install, 1, "Removed unused file: %s", f->filePointer().c_str());
					// if a fake patch, we need to shufle
					if ( f->IsFakePatch() )
						shuffle = true;

	}
 
	if ( shuffle )
	{
		CLog::log(CLog::Log_Install, 2, "Shuffling Fake patches");
		shuffleFakePatches(errors);
		CLog::log(CLog::Log_Install, 2, "Shuffling Text Files");
		shuffleTextFiles(errors);
	}
 
	// now we need to link any child/parent packages
	if ( package->GetType() == TYPE_SPK )
	{

 
	CLog::log(CLog::Log_Install, 1, "Installation Finished");
	return true;
}
 
bool CPackages::uninstallPreparedPackages(Utils::CStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *uninstalledPackages, CLinkList<CBaseFile> *disabledPackages)
{
 
 
	if ( m_lInstallList.empty() ) return false;
 
	// update the used status, excluding all packages we are about to remove
	UpdateUsedFiles(&m_lInstallList);
 

					if ( depP->IsEnabled() )
						this->PrepareDisablePackage(depP);
				}
 
				if ( m_lDisableList.size() )
					this->disablePreparedPackages(errors, progress, disabledPackages);
			}
		}
	}
 
	// interate through all the files in the package

		{
			if (!removeDirs.contains("Extras"))
				removeDirs.pushBack("Extras");
		}
 
		if (removeFile(f, errors))
			original = _pOriginalFiles->restoreFile(f, errors);
		else // problem removeing (try when the program closes)
			m_lNonRemovedFiles.pushBack(f->filePointer());
 
		// check for fake patchs

		// make sure the scripts directory is created, even thou it should always be there anyways
		CDirIO scriptDir(m_sCurrentDir);
		if ( !scriptDir.exists("scripts") )
		{
			if ( scriptDir.create("Scripts") )
				this->addLogEntry(SPKINSTALL_CREATEDIRECTORY, "Scripts", errors);
			else
				this->addLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, "Scripts", errors);
		}
 
		for ( C_File *uf = uninstallFiles.First(); uf; uf = uninstallFiles.Next() )
		{
			C_File *newFile = new C_File();

			CFileIO file(uf->filePointer());
 
			if ( uf->getUsed() )
			{
				if ( file.copy(newFilename) )
					this->addLogEntry(SPKINSTALL_UNINSTALL_COPY, newFile->getNameDirectory(NULL), errors);
				else
				{
					this->addLogEntry(SPKINSTALL_UNINSTALL_COPY_FAIL, newFile->getNameDirectory(NULL), errors);
					delete newFile;
					newFile = NULL;
				}
			}
			// otherwise just move it
			else
			{
				if ( file.Rename(newFilename) )
					this->addLogEntry(SPKINSTALL_UNINSTALL_MOVE, newFile->getNameDirectory(NULL), errors);
				else
				{
					this->addLogEntry(SPKINSTALL_UNINSTALL_MOVE_FAIL, newFile->getNameDirectory(NULL), errors);
					delete newFile;
					newFile = NULL;
				}
 
				m_lFiles.remove(uf, false);

	if ( original ) {
		removeDirs.pushBack("PluginManager/Original/Replacements");
		removeDirs.pushBack("PluginManager/Original");
	}
	removeDirs.pushBack("PluginManager/Disabled");
	removeUnusedDirectories(removeDirs, errors);
 
	// finally lets shuffle any fake patchs to fill in gaps
	if ( shuffle )
	{
		shuffleFakePatches(errors);
		shuffleTextFiles(errors);
	}
 
	this->WriteData();
 
	return true;

/**
 * Closing the current directory
 *
 * When existing, program needs to close the directory
 */
bool CPackages::closeDir(Utils::CStringList *errors, CProgressInfo *progress, bool removedir)
{
	if ( m_sCurrentDir.empty() )
		return true;
	if ( !m_bLoaded )
		return true;
 
 
 
	CLog::log(CLog::Log_Directory, 1, "closing directory: " + m_sCurrentDir);
 
	if ( m_bRenameText ) {
		CLog::log(CLog::Log_Directory, 2, "Creating other language files for game");
		CreateLanguageTextFiles(errors);
	}
 
	CLog::log(CLog::Log_Directory, 2, "Backing up save game files");
 
	if ( CFileIO::Exists(m_sCurrentDir + "/mods/PluginManager.dat") ) {

	if ( removedir && m_bRemoveDir )
	{
		m_bRemoveDir = false;
		Utils::CStringList removeDirs;
		removeDirs.pushBack(".");
		removeUnusedDirectories(removeDirs, errors);
	}
 
	this->setCurrentDir("");
		 
 
 
 
 
 
 
 
	m_bLoaded = false;
	return true;
}
 
Utils::String CPackages::getModKey() const

/**
 * Add Log
 *
 * Adds a log entry to displayed at end
 */
 
 
 
 
 
 
 
void CPackages::addLogEntry(int type, const Utils::String &args, Utils::CStringList *errors)
{
	if (!errors)
		return;
 

 * param: errors		- The string list for all the status for debugging, ie has an entry for whats happened to every file
 * param: progress		- The progress class, updates a progress screen of the derived class
 *
 * return: boolen - Returns true if the package enabling was successful
 */
bool CPackages::enablePackage(CBaseFile *package, Utils::CStringList *errors, CProgressInfo *progress )
{
	ClearError();
 
	// if already enabled, just skip
	if ( package->IsEnabled() )

		m_iError = PKERR_MODIFIED;
		return false;
	}
 
	if ( this->PrepareEnablePackage(package) )
		return this->enablePreparedPackages(errors, progress);
 
	return false;
}
bool CPackages::enablePreparedPackages(Utils::CStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *enabledPackages )
{
	ClearError();
 
	// get all files, including children
	CLinkList<C_File> fileList;

		{
			if ( !Dir.exists(f->getDirectory(package)) )
			{
				if ( !Dir.create(f->getDirectory(package)) )
				{
					this->addLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, f->getDirectory(package), errors);
					continue;
				}
				this->addLogEntry(SPKINSTALL_CREATEDIRECTORY, f->getDirectory(package), errors);
			}
		}
 
		// check if theres an original file to backup
		_pOriginalFiles->doBackup(f, errors);

		if ( !currentFile.exists() )
		{
			// missing file ??
			if ( !newFile.exists() )
			{
				this->addLogEntry(SPKINSTALL_MISSINGFILE, newFilename, errors);
				continue;
			}
		}
		// remove existing file
		// file exists, so lets try to move it

			if ( newFile.exists() )
				newFile.remove();
 
			if ( !currentFile.Rename(newFile.fullFilename()) )
			{
				this->addLogEntry(SPKINSTALL_ENABLEFILE_FAIL, newFilename, errors);
				continue;
			}
		}
 
		this->addLogEntry(SPKINSTALL_ENABLEFILE, newFilename, errors);
 
		// adjust the internal name to match the new filename
		f->setFilename(m_sCurrentDir + "/" + newFilename);
		// no longer disabled, we need to remove the flag
		f->SetDisabled(false);

	if ( pMod )
		m_pEnabledMod = pMod;
 
	// disabled the mod
	if ( oldMod && oldMod != m_pEnabledMod && !m_bForceModInstall )
		this->disablePackage(oldMod, errors, progress);
 
	// lets remove all the directories we might have left empty
	Utils::CStringList removeDirs;
	removeDirs.pushBack("PluginManager/Disabled");
	removeUnusedDirectories(removeDirs, errors);
 
	m_lEnableList.clear();
 
	this->WriteData();
 
	return true;
}
 
 
bool CPackages::disablePreparedPackages(Utils::CStringList *errors, CProgressInfo *progress, CLinkList<CBaseFile> *disabledPackages )
{
	if ( progress )
		progress->UpdateStatus(PROGRESS_DISABLEFILE);
 
	UpdateUsedFiles(&m_lDisableList, false);
 
	// checks if there are any original files to restore and if any fake patches were disabled to reshuffle
	bool original = false, shuffle = false;
 
	// holds our list of directories that we might need to remove, only empty ones from this list will actually be removed
	Utils::CStringList removeDirs;
 
	// get all files, including children
	CLinkList<C_File> fileList;
	int maxFiles = this->GetAllPackageFiles(&m_lDisableList, &fileList, true);
 

		if ( !Dir.exists(newFilename) )
		{
			// we couldn't create the directory for some reason, this is not good
			if ( !Dir.create(newFilename) )
			{
				this->addLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, newFilename, errors);
				continue;
			}
			this->addLogEntry(SPKINSTALL_CREATEDIRECTORY, newFilename, errors);
		}
 
		// fake patches need a special directory and filename so they dont overright each other as thier filenames are always changes
		// if a package with a fake patch is installed while another one is disabled, it will fill the gap left by the disabled one
		// they will then end up with the same filename, if it gets disabled they would overright each other, so we change the filename to prevent that from happening

		CFileIO currentFile(f->filePointer());
		if ( !currentFile.exists() )
		{
			if ( !CFileIO(newFilename).exists() )
			{
				this->addLogEntry(SPKINSTALL_MISSINGFILE, f->getNameDirectory(checkPackage), errors);
				continue;
			}
		}
		// otherwise the file must exists, so lets move it
		else if ( !currentFile.Rename(newFilename) )
		{
			this->addLogEntry(SPKINSTALL_DISABLEFILE_FAIL, f->getNameDirectory(checkPackage), errors);
			continue;
		}
 
		// must have been fine
		this->addLogEntry(SPKINSTALL_DISABLEFILE, f->getNameDirectory(checkPackage), errors);
 
		original = _pOriginalFiles->restoreFile(f, errors);
 
		// extra file thats not in the extras directory
		if (f->GetFileType() == FILETYPE_EXTRA || f->GetFileType() == FILETYPE_MAP || f->GetFileType() == FILETYPE_SOUND)
		{
			if(!removeDirs.contains(f->getDirectory(checkPackage)))
				removeDirs.pushBack(f->getDirectory(checkPackage));
		}
 
		// change the filename
		f->setFilename(newFilename);
 
		// finally mark the file as disabled so we know not to try to move it again

	// a fake patch has been disabled, we need to reshuffle the rest to fill in any gaps
	if ( shuffle )
	{
		if ( progress )
			progress->UpdateStatus(PROGRESS_SHUFFLEFAKE);
		shuffleFakePatches(errors);
		shuffleTextFiles(errors);
	}
 
	// original files were restored, check to remove the original file directory if its now empty
	if ( original )
		removeDirs.pushBack("PluginManager/Original");
 
	// remove any empty directories that we might have left
	if ( !removeDirs.empty() )
		removeUnusedDirectories(removeDirs, errors);
 
	// finally mark the whole package as disabled
	// recursive, we need to disable all children
	for ( CBaseFile *child = m_lDisableList.First(); child; child = m_lDisableList.Next() )
	{

 * param: errors	- A string list used to add the status as it progresses, used in debugging output
 * param: progress	- The progress class, updates the progress of the current disabling.  Needs a divered class to report the progress somewhere
 *
 * return: boolean, true if there was no errors, otherwise false
 */
bool CPackages::disablePackage(CBaseFile *package, Utils::CStringList *errors, CProgressInfo *progress )
{
	// if already disabled, just skip
	if ( !package->IsEnabled() )
		return true;
 
	m_lDisableList.clear();
	if ( this->PrepareDisablePackage(package) )
		return this->disablePreparedPackages(errors, progress);
 
	return false;
}
 
 

}
 
/**
 * Removes all empty directories that might have been created
 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
void CPackages::removeUnusedDirectories(const Utils::CStringList& dirs, Utils::CStringList* errors)
{
	CDirIO Dir(m_sCurrentDir);
	for(auto itr = dirs.begin(); itr != dirs.end(); itr++)
	{

/**
 * Remove uninstall file
 *
 * Removes a single uninstall file
 */
bool CPackages::removeUninstallFile(C_File *file, Utils::CStringList *errors)
{
	CFileIO fio(file->filePointer());
	if ( fio.exists() )
	{
		if ( fio.remove() ) {
			this->addLogEntry(SPKINSTALL_UNINSTALL_REMOVE, file->getNameDirectory(NULL), errors);
			return true;
		}
		else if ( errors )
			this->addLogEntry(SPKINSTALL_UNINSTALL_REMOVE_FAIL, file->getNameDirectory(NULL), errors);
	}
 
	return false;
}
 

 * Remove uninstall scripts
 *
 * Removes any unused unisntall scripts
 * Finds if any scripts are in the current package
 */
int CPackages::removeUninstallScripts(Utils::CStringList *errors, CProgressInfo *progress)
{
	if ( m_lUninstallFiles.empty() )
		return 0;
 
	UpdateUsedFiles();

		}
 
		// not found a matching file, we can safetly remove it
		if ( !found )
		{
			if (removeUninstallFile(file))
				node->DeleteData();
		}
	}
 
	m_lUninstallFiles.RemoveEmpty();

/**
 * Remove unused shared file
 *
 * Removes a single file
 */
bool CPackages::removeSharedFile(C_File *file, Utils::CStringList *errors)
{
	CFileIO fio(file->filePointer());
	if ( fio.exists() )
	{
		if ( fio.remove() ) {
			this->addLogEntry(SPKINSTALL_SHARED, file->getNameDirectory(NULL), errors);
			delete file;
			return true;
		}
		else if ( errors )
			this->addLogEntry(SPKINSTALL_SHARED_FAIL, file->getNameDirectory(NULL), errors);
	}
 
	return false;
}
 

 * Files that have been marked as shared will not be removed or disabled when the last package is removed
 * This function will remove any that are no longer connected with packages
 *
 * Marked shared fiels are mainly used for library scripts that arn't always added to packages
 */
int CPackages::removeUnusedSharedFiles(Utils::CStringList *errors, CProgressInfo *progress)
{
	UpdateUsedFiles();
	int files = 0;
	int done = 0;
 

 
		// only do ones that are no longer needed
		if ( file->getUsed() )
			continue;
 
		if (removeSharedFile(file, errors) )
			++done;
		node->ChangeData(NULL);
	}
 
	m_lFiles.RemoveEmpty();

 
	return false;
 
}
 
void CPackages::shuffleTextFiles(Utils::CStringList *errors)
{
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		// only do files that are enabled

			CFileIO moveFile(f->filePointer());
	
			Utils::String newName = SPK::FormatTextName(current, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT)) + "." + moveFile.extension();
			if ( moveFile.Rename(m_sCurrentDir + "/t/" + newName) )
			{
				this->addLogEntry(SPKINSTALL_AUTOTEXT, f->name() + "~" + newName, errors);
				f->setName(newName);
			}
			else
				this->addLogEntry(SPKINSTALL_AUTOTEXT_FAIL, f->name() + "~" + newName, errors);
		}
	}
}
 
/**

 *
 * Rename the fake patches so they are always in sequence to be loaded into the game
 *
 * IE, when one is removed, the rest need to be shuffled down so theres no gaps
 */
void CPackages::shuffleFakePatches(Utils::CStringList *errors)
{
	int check = findNextFakePatch();
 
	// lets make sure our order is correct
	// find Lowest Fake Patch Installed

			if (findItr == order.end())
				order.push_back(p);
		}
	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	for(auto itr = order.begin(); itr != order.end(); itr++)
	{
		CBaseFile *package = *itr;
		if ( package )
		{

							lowest++;
							continue;
						}
 
						// now we can move the the cat/dat file elsewhere, lets shuffle it to the highest free number
						shufflePatchTo(moveFile, findLastFakePatch(), errors);
					}
 
					// space should be free, now lets shuffle it
					shufflePatchTo(lowestFile, lowest, errors);
				}
 
				doneList.push_back(lowestFile); // we've done this file now
				lowest++; // move up the lowest ready for the next patch
			}

		int check = findNextFakePatch();
		int patchNum = f->filename().token(".", 1).toInt();
		if ( patchNum <= check )
			continue;
 
		shufflePatchTo(f, check, errors);
	}
}
 
void CPackages::shufflePatchTo(C_File *file, int to, Utils::CStringList *errors)
{
	// it is, we need to shift this to fill the gap
	Utils::String newName = Utils::String::PadNumber(to, 2) + "." + file->fileExt();
 
	// now rename the file
	CFileIO moveFile(file->filePointer());
	if ( moveFile.Rename(m_sCurrentDir + "/" + newName) )
	{
		// display moveing
		this->addLogEntry(SPKINSTALL_FAKEPATCH, file->name() + "~" + newName, errors);
 
		// now find the matching pairing if it exists
		for ( CListNode<C_File> *node2 = m_lFiles.Front(); node2; node2 = node2->next() )
		{
			C_File *f2 = node2->Data();

 
			Utils::String newName2 = Utils::String::PadNumber(to, 2) + "." + f2->fileExt();
			CFileIO moveFile(f2->filePointer());
			if ( moveFile.Rename(m_sCurrentDir + "/" + newName2) )
			{
				this->addLogEntry(SPKINSTALL_FAKEPATCH, f2->name() + "~" + newName2, errors);
				f2->setName(newName2);
			}
			else
				this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, f2->name() + "~" + newName2, errors);
		}
 
		// finally make sure the internal name matches the new one
		file->setName(newName);
	}
	else
		this->addLogEntry(SPKINSTALL_FAKEPATCH_FAIL, file->name() + "~" + newName, errors);
}
 
int CPackages::FindLowestFakePatchInstalled()
{
	int lowest = 99;

		if ( found )
			package->GetFileList()->push_back(file);
	}
}
 
bool CPackages::removeFile(C_File *file, Utils::CStringList *errors)
{
	if ( !file )
		return true;
 
	Utils::String remFileStr = file->filePointer();

			CCatFile cat;
			if ( cat.open(CatFile.fullFilename(), this->getAddonDir(), CATREAD_DAT, false) == CATERR_NONE ) {
				Utils::String fileName = file->filePointer().token("::", 2);
				if ( cat.findData(fileName) ) {
					if ( cat.removeFile(fileName) ) {
						this->addLogEntry(SPKINSTALL_DELETEFILE, remFileStr, errors);
					}
					else {
						this->addLogEntry(SPKINSTALL_DELETEFILE_FAIL, remFileStr, errors);
						return false;
					}
				}
			}
		}
	}
	else {
		CFileIO f(file->filePointer());
		if ( f.exists() )
		{
			if ( f.remove() ) this->addLogEntry(SPKINSTALL_DELETEFILE, remFileStr, errors);
			else if ( errors )
			{
				this->addLogEntry(SPKINSTALL_DELETEFILE_FAIL, remFileStr, errors);
				return false;
			}
			else
				return false;
		}
	}
 
	return true;
}
 
int CPackages::removeAllPackages(Utils::CStringList *errors, CProgressInfo *progress)
{
	int files = 0;
 
	// remove all files
	int max = m_lFiles.size() + _pOriginalFiles->count() + m_lUninstallFiles.size();

		// update the progress
		if ( progress )
			progress->UpdateProgress(files, max);
		++files;
 
		removeFile(node->Data());
		delete node->Data();
	}
	m_lFiles.clear();
 
	// restore any original files that are backed up

		// update the progress
		if ( progress )
			progress->UpdateProgress(files, max);
		++files;
 
		removeFile(uNode->Data());
		delete uNode->Data();
	}
	m_lUninstallFiles.clear();
 
	// delete all packages

void CPackages::startup(const Utils::String &dir, const Utils::String &tempDir, const Utils::String &myDoc, const Utils::String &mod)
{
	startup(dir, tempDir, myDoc);
	m_sSetMod = mod;
}
 
 
 
 
 
 
int CPackages::getGameLanguage() const
{
	return this->getGameLanguage(m_sCurrentDir);
}

{
	if ( !m_bLoaded )
		return false;
 
	// remove all package files
	this->removeAllPackages();
 
	// remove all plugin manager files
	this->RemoveCreatedFiles();
 
	this->Reset();

Rev 182	Rev 183
Line 671...	Line 671...
671	`long time = rest.toLong();`	671	`long time = rest.toLong();`
672	`if ( time == m_iLastUpdated )`	672	`if ( time == m_iLastUpdated )`
673	`{`	673	`{`
674	`this->PurgeWares();`	674	`this->PurgeWares();`
675	`this->PurgeShips();`	675	`this->PurgeShips();`
676	`this->RemoveUninstallScripts();`	676	`this->removeUninstallScripts();`
677	`}`	677	`}`
678	`}`	678	`}`
679	`}`	679	`}`
680		680
681	`delete lines;`	681	`delete lines;`
Line 1328...	Line 1328...
1328	`this->ConvertOldPackage (installFile);`	1328	`this->ConvertOldPackage (installFile);`
1329		1329
1330	`return installFile;`	1330	`return installFile;`
1331	`}`	1331	`}`
1332		1332
1333	`void CPackages::PurgeUninstallScripts(CBaseFile package, CyStringList errors)`	1333	`void CPackages::purgeUninstallScripts(CBaseFile package, Utils::CStringList errors)`
1334	`{`	1334	`{`
1335	`for ( CListNode<C_File> *fNode = m_lUninstallFiles.Front(); fNode; fNode = fNode->next() )`	1335	`for ( CListNode<C_File> *fNode = m_lUninstallFiles.Front(); fNode; fNode = fNode->next() )`
1336	`{`	1336	`{`
1337	`C_File *uf = fNode->Data();`	1337	`C_File *uf = fNode->Data();`
1338	`// check against any script files`	1338	`// check against any script files`
Line 1344...	Line 1344...
1344	`if ( checkFile->GetFileType() != FILETYPE_UNINSTALL && checkFile->GetFileType() != FILETYPE_SCRIPT )`	1344	`if ( checkFile->GetFileType() != FILETYPE_UNINSTALL && checkFile->GetFileType() != FILETYPE_SCRIPT )`
1345	`continue;`	1345	`continue;`
1346		1346
1347	`if ( uf->filename().Compare(checkFile->filename()) )`	1347	`if ( uf->filename().Compare(checkFile->filename()) )`
1348	`{`	1348	`{`
1349	`if ( RemoveUninstallFile(uf, errors) )`	1349	`if (removeUninstallFile(uf, errors) )`
1350	`fNode->DeleteData();`	1350	`fNode->DeleteData();`
1351	`break;`	1351	`break;`
1352	`}`	1352	`}`
1353	`}`	1353	`}`
1354	`}`	1354	`}`
Line 1356...	Line 1356...
1356	`m_lUninstallFiles.RemoveEmpty();`	1356	`m_lUninstallFiles.RemoveEmpty();`
1357		1357
1358	`this->WriteData();`	1358	`this->WriteData();`
1359	`}`	1359	`}`
1360		1360
1361	`int CPackages::InstallPreparedPackages(CyStringList errors, CProgressInfo progress, CLinkList<CBaseFile> errored, CLinkList<CBaseFile> installedList)`	1361	`int CPackages::installPreparedPackages(Utils::CStringList errors, CProgressInfo progress, CLinkList<CBaseFile> errored, CLinkList<CBaseFile> installedList)`
1362	`{`	1362	`{`
1363	`if ( m_lInstallList.empty() ) return false;`	1363	`if ( m_lInstallList.empty() ) return false;`
1364		-
1365	`int installed = 0;`	1364	`int installed = 0;`
1366	`for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )`	1365	`for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )`
1367	`{`	1366	`{`
1368	`CBaseFile *p = node->Data();`	1367	`CBaseFile *p = node->Data();`
1369	`if ( this->InstallPackage(p, errors, progress, !p->IsEnabled()) )`	1368	`if ( this->installPackage(p, errors, progress, !p->IsEnabled()) )`
1370	`{`	1369	`{`
1371	`++installed;`	1370	`++installed;`
1372	`if ( installedList )`	1371	`if ( installedList )`
1373	`installedList->push_back(p);`	1372	`installedList->push_back(p);`
1374	`}`	1373	`}`
Line 1443...	Line 1442...
1443	`{`	1442	`{`
1444	`return (_pCurrentDir) ? _pCurrentDir->dir : Utils::String::Null();`	1443	`return (_pCurrentDir) ? _pCurrentDir->dir : Utils::String::Null();`
1445	`}`	1444	`}`
1446		1445
1447		1446
1448	`bool CPackages::InstallPackage ( CBaseFile package, CyStringList errors, CProgressInfo *progress, bool disabled )`	1447	`bool CPackages::installPackage(CBaseFile package, Utils::CStringList errors, CProgressInfo *progress, bool disabled)`
1449	`{`	1448	`{`
1450	`CLog::logf(CLog::Log_Install, 1, "Starting to install new package, %s by %s (Version: %s)", package->name().c_str(), package->author().c_str(), package->version().c_str());`	1449	`CLog::logf(CLog::Log_Install, 1, "Starting to install new package, %s by %s (Version: %s)", package->name().c_str(), package->author().c_str(), package->version().c_str());`
1451		1450
1452	`Utils::CStringList lErrors;`	-
1453		-
1454	`CBaseFile *oldPackage = findPackage(package);`	1451	`CBaseFile *oldPackage = findPackage(package);`
1455	`disabled = _checkForDisable(package, disabled, oldPackage);`	1452	`disabled = _checkForDisable(package, disabled, oldPackage);`
1456		1453
1457	`// update packages must have an old package installed already (should have been checked for already)`	1454	`// update packages must have an old package installed already (should have been checked for already)`
1458	`if ( package->GetType() == TYPE_SPK )`	1455	`if ( package->GetType() == TYPE_SPK )`
Line 1482...	Line 1479...
1482	`// no need to backup if we're disabling them`	1479	`// no need to backup if we're disabling them`
1483	`if ( !disabled )`	1480	`if ( !disabled )`
1484	`{`	1481	`{`
1485	`// find any uninstall files and remove them`	1482	`// find any uninstall files and remove them`
1486	`CLog::log(CLog::Log_Install, 3, "Purging uninstall scripts");`	1483	`CLog::log(CLog::Log_Install, 3, "Purging uninstall scripts");`
1487	`this->PurgeUninstallScripts(package, errors);`	1484	`this->purgeUninstallScripts(package, errors);`
1488		1485
1489	`// backup any original files before installing`	1486	`// backup any original files before installing`
1490	`_pOriginalFiles->backup(package, errors);`	1487	`_pOriginalFiles->backup(package, errors);`
1491	`}`	1488	`}`
1492		1489
Line 1504...	Line 1501...
1504		1501
1505	`CLog::log(CLog::Log_Install, 3, "Reading all files into memory");`	1502	`CLog::log(CLog::Log_Install, 3, "Reading all files into memory");`
1506	`package->ReadAllFilesToMemory();`	1503	`package->ReadAllFilesToMemory();`
1507		1504
1508	`CLog::log(CLog::Log_Install, 3, "Starting to install files");`	1505	`CLog::log(CLog::Log_Install, 3, "Starting to install files");`
1509	`if ( !package->installFiles (m_sCurrentDir, progress, &m_lFiles, &lErrors, !disabled, this) )`	1506	`if ( !package->installFiles (m_sCurrentDir, progress, &m_lFiles, errors, !disabled, this) )`
1510	`{`	1507	`{`
1511	`CLog::log(CLog::Log_Install, 2, "There was an error installing files!!");`	1508	`CLog::log(CLog::Log_Install, 2, "There was an error installing files!!");`
1512		1509
1513	`// TODO: clear up installed files`	1510	`// TODO: clear up installed files`
1514	`return false;`	1511	`return false;`
Line 1595...	Line 1592...
1595	`}`	1592	`}`
1596	`}`	1593	`}`
1597		1594
1598	`// now remove the files`	1595	`// now remove the files`
1599	`C_File *m = package->findMatchingMod(f->Data());`	1596	`C_File *m = package->findMatchingMod(f->Data());`
1600	`RemoveFile(f->Data(), errors);`	1597	`removeFile(f->Data(), errors);`
1601	`m_lFiles.remove(f->Data());`	1598	`m_lFiles.remove(f->Data());`
1602	`f->ChangeData(NULL);`	1599	`f->ChangeData(NULL);`
1603	`if ( m )`	1600	`if ( m )`
1604	`{`	1601	`{`
1605	`int pos = package->GetFileList()->FindPos(m);`	1602	`int pos = package->GetFileList()->FindPos(m);`
1606	`RemoveFile(m, errors);`	1603	`removeFile(m, errors);`
1607	`m_lFiles.remove(m);`	1604	`m_lFiles.remove(m);`
1608	`if ( pos != -1 )`	1605	`if ( pos != -1 )`
1609	`package->GetFileList()->GetNode(pos)->ChangeData(NULL);`	1606	`package->GetFileList()->GetNode(pos)->ChangeData(NULL);`
1610	`}`	1607	`}`
1611	`}`	1608	`}`
Line 1760...	Line 1757...
1760	`if ( package->findFile(f->filename(), FILETYPE_README) )`	1757	`if ( package->findFile(f->filename(), FILETYPE_README) )`
1761	`dontRemove = true;`	1758	`dontRemove = true;`
1762	`}`	1759	`}`
1763		1760
1764	`// remove from hard drive`	1761	`// remove from hard drive`
1765	`if ( !dontRemove && RemoveFile(f, errors) )`	1762	`if ( !dontRemove && removeFile(f, errors) )`
1766	`{`	1763	`{`
1767	`CLog::logf(CLog::Log_Install, 1, "Removed unused file: %s", f->filePointer().c_str());`	1764	`CLog::logf(CLog::Log_Install, 1, "Removed unused file: %s", f->filePointer().c_str());`
1768	`// if a fake patch, we need to shufle`	1765	`// if a fake patch, we need to shufle`
1769	`if ( f->IsFakePatch() )`	1766	`if ( f->IsFakePatch() )`
1770	`shuffle = true;`	1767	`shuffle = true;`
Line 1779...	Line 1776...
1779	`}`	1776	`}`
1780		1777
1781	`if ( shuffle )`	1778	`if ( shuffle )`
1782	`{`	1779	`{`
1783	`CLog::log(CLog::Log_Install, 2, "Shuffling Fake patches");`	1780	`CLog::log(CLog::Log_Install, 2, "Shuffling Fake patches");`
1784	`ShuffleFakePatches(errors);`	1781	`shuffleFakePatches(errors);`
1785	`CLog::log(CLog::Log_Install, 2, "Shuffling Text Files");`	1782	`CLog::log(CLog::Log_Install, 2, "Shuffling Text Files");`
1786	`ShuffleTextFiles(errors);`	1783	`shuffleTextFiles(errors);`
1787	`}`	1784	`}`
1788		1785
1789	`// now we need to link any child/parent packages`	1786	`// now we need to link any child/parent packages`
1790	`if ( package->GetType() == TYPE_SPK )`	1787	`if ( package->GetType() == TYPE_SPK )`
1791	`{`	1788	`{`
Line 1811...	Line 1808...
1811		1808
1812	`CLog::log(CLog::Log_Install, 1, "Installation Finished");`	1809	`CLog::log(CLog::Log_Install, 1, "Installation Finished");`
1813	`return true;`	1810	`return true;`
1814	`}`	1811	`}`
1815		1812
1816	`bool CPackages::UninstallPreparedPackages(CyStringList errors, CProgressInfo progress, CLinkList<CBaseFile> uninstalledPackages, CLinkList<CBaseFile> disabledPackages)`	1813	`bool CPackages::uninstallPreparedPackages(Utils::CStringList errors, CProgressInfo progress, CLinkList<CBaseFile> uninstalledPackages, CLinkList<CBaseFile> disabledPackages)`
1817	`{`	1814	`{`
1818	`Utils::CStringList lErrors;`	-
1819		-
1820	`if ( m_lInstallList.empty() ) return false;`	1815	`if ( m_lInstallList.empty() ) return false;`
1821		1816
1822	`// update the used status, excluding all packages we are about to remove`	1817	`// update the used status, excluding all packages we are about to remove`
1823	`UpdateUsedFiles(&m_lInstallList);`	1818	`UpdateUsedFiles(&m_lInstallList);`
1824		1819
Line 1845...	Line 1840...
1845	`if ( depP->IsEnabled() )`	1840	`if ( depP->IsEnabled() )`
1846	`this->PrepareDisablePackage(depP);`	1841	`this->PrepareDisablePackage(depP);`
1847	`}`	1842	`}`
1848		1843
1849	`if ( m_lDisableList.size() )`	1844	`if ( m_lDisableList.size() )`
1850	`this->DisablePreparedPackages(errors, progress, disabledPackages);`	1845	`this->disablePreparedPackages(errors, progress, disabledPackages);`
1851	`}`	1846	`}`
1852	`}`	1847	`}`
1853	`}`	1848	`}`
1854		1849
1855	`// interate through all the files in the package`	1850	`// interate through all the files in the package`
Line 1900...	Line 1895...
1900	`{`	1895	`{`
1901	`if (!removeDirs.contains("Extras"))`	1896	`if (!removeDirs.contains("Extras"))`
1902	`removeDirs.pushBack("Extras");`	1897	`removeDirs.pushBack("Extras");`
1903	`}`	1898	`}`
1904		1899
1905	`if ( RemoveFile(f, errors) )`	1900	`if (removeFile(f, errors))`
1906	`original = _pOriginalFiles->restoreFile(f, errors);`	1901	`original = _pOriginalFiles->restoreFile(f, errors);`
1907	`else // problem removeing (try when the program closes)`	1902	`else // problem removeing (try when the program closes)`
1908	`m_lNonRemovedFiles.pushBack(f->filePointer());`	1903	`m_lNonRemovedFiles.pushBack(f->filePointer());`
1909		1904
1910	`// check for fake patchs`	1905	`// check for fake patchs`
Line 1944...	Line 1939...
1944	`// make sure the scripts directory is created, even thou it should always be there anyways`	1939	`// make sure the scripts directory is created, even thou it should always be there anyways`
1945	`CDirIO scriptDir(m_sCurrentDir);`	1940	`CDirIO scriptDir(m_sCurrentDir);`
1946	`if ( !scriptDir.exists("scripts") )`	1941	`if ( !scriptDir.exists("scripts") )`
1947	`{`	1942	`{`
1948	`if ( scriptDir.create("Scripts") )`	1943	`if ( scriptDir.create("Scripts") )`
1949	`this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY, "Scripts", errors);`	1944	`this->addLogEntry(SPKINSTALL_CREATEDIRECTORY, "Scripts", errors);`
1950	`else`	1945	`else`
1951	`this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, "Scripts", errors);`	1946	`this->addLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, "Scripts", errors);`
1952	`}`	1947	`}`
1953		1948
1954	`for ( C_File *uf = uninstallFiles.First(); uf; uf = uninstallFiles.Next() )`	1949	`for ( C_File *uf = uninstallFiles.First(); uf; uf = uninstallFiles.Next() )`
1955	`{`	1950	`{`
1956	`C_File *newFile = new C_File();`	1951	`C_File *newFile = new C_File();`
Line 1963...	Line 1958...
1963	`CFileIO file(uf->filePointer());`	1958	`CFileIO file(uf->filePointer());`
1964		1959
1965	`if ( uf->getUsed() )`	1960	`if ( uf->getUsed() )`
1966	`{`	1961	`{`
1967	`if ( file.copy(newFilename) )`	1962	`if ( file.copy(newFilename) )`
1968	`this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY, newFile->getNameDirectory(NULL), errors);`	1963	`this->addLogEntry(SPKINSTALL_UNINSTALL_COPY, newFile->getNameDirectory(NULL), errors);`
1969	`else`	1964	`else`
1970	`{`	1965	`{`
1971	`this->AddLogEntry(SPKINSTALL_UNINSTALL_COPY_FAIL, newFile->getNameDirectory(NULL), errors);`	1966	`this->addLogEntry(SPKINSTALL_UNINSTALL_COPY_FAIL, newFile->getNameDirectory(NULL), errors);`
1972	`delete newFile;`	1967	`delete newFile;`
1973	`newFile = NULL;`	1968	`newFile = NULL;`
1974	`}`	1969	`}`
1975	`}`	1970	`}`
1976	`// otherwise just move it`	1971	`// otherwise just move it`
1977	`else`	1972	`else`
1978	`{`	1973	`{`
1979	`if ( file.Rename(newFilename) )`	1974	`if ( file.Rename(newFilename) )`
1980	`this->AddLogEntry(SPKINSTALL_UNINSTALL_MOVE, newFile->getNameDirectory(NULL), errors);`	1975	`this->addLogEntry(SPKINSTALL_UNINSTALL_MOVE, newFile->getNameDirectory(NULL), errors);`
1981	`else`	1976	`else`
1982	`{`	1977	`{`
1983	`this->AddLogEntry(SPKINSTALL_UNINSTALL_MOVE_FAIL, newFile->getNameDirectory(NULL), errors);`	1978	`this->addLogEntry(SPKINSTALL_UNINSTALL_MOVE_FAIL, newFile->getNameDirectory(NULL), errors);`
1984	`delete newFile;`	1979	`delete newFile;`
1985	`newFile = NULL;`	1980	`newFile = NULL;`
1986	`}`	1981	`}`
1987		1982
1988	`m_lFiles.remove(uf, false);`	1983	`m_lFiles.remove(uf, false);`
Line 2024...	Line 2019...
2024	`if ( original ) {`	2019	`if ( original ) {`
2025	`removeDirs.pushBack("PluginManager/Original/Replacements");`	2020	`removeDirs.pushBack("PluginManager/Original/Replacements");`
2026	`removeDirs.pushBack("PluginManager/Original");`	2021	`removeDirs.pushBack("PluginManager/Original");`
2027	`}`	2022	`}`
2028	`removeDirs.pushBack("PluginManager/Disabled");`	2023	`removeDirs.pushBack("PluginManager/Disabled");`
2029	`removeUnusedDirectories(removeDirs, &lErrors);`	2024	`removeUnusedDirectories(removeDirs, errors);`
2030		2025
2031	`// finally lets shuffle any fake patchs to fill in gaps`	2026	`// finally lets shuffle any fake patchs to fill in gaps`
2032	`if ( shuffle )`	2027	`if ( shuffle )`
2033	`{`	2028	`{`
2034	`ShuffleFakePatches(errors);`	2029	`shuffleFakePatches(errors);`
2035	`ShuffleTextFiles(errors);`	2030	`shuffleTextFiles(errors);`
2036	`}`	2031	`}`
2037		2032
2038	`this->WriteData();`	2033	`this->WriteData();`
2039		2034
2040	`return true;`	2035	`return true;`
Line 2460...	Line 2455...
2460	`/**`	2455	`/**`
2461	`* Closing the current directory`	2456	`* Closing the current directory`
2462	`*`	2457	`*`
2463	`* When existing, program needs to close the directory`	2458	`* When existing, program needs to close the directory`
2464	`*/`	2459	`*/`
2465	`bool CPackages::CloseDir ( CyStringList errors, CProgressInfo progress, bool removedir )`	2460	`bool CPackages::closeDir(Utils::CStringList errors, CProgressInfo progress, bool removedir)`
2466	`{`	2461	`{`
2467	`if ( m_sCurrentDir.empty() )`	2462	`if ( m_sCurrentDir.empty() )`
2468	`return true;`	2463	`return true;`
2469	`if ( !m_bLoaded )`	2464	`if ( !m_bLoaded )`
2470	`return true;`	2465	`return true;`
2471		2466
2472	`Utils::CStringList lErrors;`	-
2473		-
2474	`CLog::log(CLog::Log_Directory, 1, "closing directory: " + m_sCurrentDir);`	2467	`CLog::log(CLog::Log_Directory, 1, "closing directory: " + m_sCurrentDir);`
2475		2468
2476	`if ( m_bRenameText ) {`	2469	`if ( m_bRenameText ) {`
2477	`CLog::log(CLog::Log_Directory, 2, "Creating other language files for game");`	2470	`CLog::log(CLog::Log_Directory, 2, "Creating other language files for game");`
2478	`CreateLanguageTextFiles(&lErrors);`	2471	`CreateLanguageTextFiles(errors);`
2479	`}`	2472	`}`
2480		2473
2481	`CLog::log(CLog::Log_Directory, 2, "Backing up save game files");`	2474	`CLog::log(CLog::Log_Directory, 2, "Backing up save game files");`
2482		2475
2483	`if ( CFileIO::Exists(m_sCurrentDir + "/mods/PluginManager.dat") ) {`	2476	`if ( CFileIO::Exists(m_sCurrentDir + "/mods/PluginManager.dat") ) {`
Line 2543...	Line 2536...
2543	`if ( removedir && m_bRemoveDir )`	2536	`if ( removedir && m_bRemoveDir )`
2544	`{`	2537	`{`
2545	`m_bRemoveDir = false;`	2538	`m_bRemoveDir = false;`
2546	`Utils::CStringList removeDirs;`	2539	`Utils::CStringList removeDirs;`
2547	`removeDirs.pushBack(".");`	2540	`removeDirs.pushBack(".");`
2548	`removeUnusedDirectories(removeDirs, &lErrors);`	2541	`removeUnusedDirectories(removeDirs, errors);`
2549	`}`	2542	`}`
2550		2543
2551	`this->setCurrentDir("");`	2544	`this->setCurrentDir("");`
2552		2545
2553	`//TEMP: switch to errors`	-
2554	`if (errors)`	-
2555	`{`	-
2556	`for (auto itr = lErrors.begin(); itr != lErrors.end(); itr++)`	-
2557	`errors->PushBack(CyString((itr)->str), CyString((itr)->data));`	-
2558	`}`	-
2559		-
2560	`m_bLoaded = false;`	2546	`m_bLoaded = false;`
2561	`return true;`	2547	`return true;`
2562	`}`	2548	`}`
2563		2549
2564	`Utils::String CPackages::getModKey() const`	2550	`Utils::String CPackages::getModKey() const`
Line 2948...	Line 2934...
2948	`/**`	2934	`/**`
2949	`* Add Log`	2935	`* Add Log`
2950	`*`	2936	`*`
2951	`* Adds a log entry to displayed at end`	2937	`* Adds a log entry to displayed at end`
2952	`*/`	2938	`*/`
2953	`void CPackages::AddLogEntry(int type, CyString args, CyStringList* errors)`	-
2954	`{`	-
2955	`if (!errors)`	-
2956	`return;`	-
2957		2939
2958	`errors->PushBack(args, ERRORLOG_OLD(type));`	-
2959	`}`	-
2960	`void CPackages::addLogEntry(int type, const Utils::String &args, Utils::CStringList *errors)`	2940	`void CPackages::addLogEntry(int type, const Utils::String &args, Utils::CStringList *errors)`
2961	`{`	2941	`{`
2962	`if (!errors)`	2942	`if (!errors)`
2963	`return;`	2943	`return;`
2964		2944
Line 2979...	Line 2959...
2979	`* param: errors - The string list for all the status for debugging, ie has an entry for whats happened to every file`	2959	`* param: errors - The string list for all the status for debugging, ie has an entry for whats happened to every file`
2980	`* param: progress - The progress class, updates a progress screen of the derived class`	2960	`* param: progress - The progress class, updates a progress screen of the derived class`
2981	`*`	2961	`*`
2982	`* return: boolen - Returns true if the package enabling was successful`	2962	`* return: boolen - Returns true if the package enabling was successful`
2983	`*/`	2963	`*/`
2984	`bool CPackages::EnablePackage ( CBaseFile package, CyStringList errors, CProgressInfo *progress )`	2964	`bool CPackages::enablePackage(CBaseFile package, Utils::CStringList errors, CProgressInfo *progress )`
2985	`{`	2965	`{`
2986	`ClearError();`	2966	`ClearError();`
2987		2967
2988	`// if already enabled, just skip`	2968	`// if already enabled, just skip`
2989	`if ( package->IsEnabled() )`	2969	`if ( package->IsEnabled() )`
Line 3002...	Line 2982...
3002	`m_iError = PKERR_MODIFIED;`	2982	`m_iError = PKERR_MODIFIED;`
3003	`return false;`	2983	`return false;`
3004	`}`	2984	`}`
3005		2985
3006	`if ( this->PrepareEnablePackage(package) )`	2986	`if ( this->PrepareEnablePackage(package) )`
3007	`return this->EnablePreparedPackages(errors, progress);`	2987	`return this->enablePreparedPackages(errors, progress);`
3008		2988
3009	`return false;`	2989	`return false;`
3010	`}`	2990	`}`
3011	`bool CPackages::EnablePreparedPackages ( CyStringList errors, CProgressInfo progress, CLinkList<CBaseFile> *enabledPackages )`	2991	`bool CPackages::enablePreparedPackages(Utils::CStringList errors, CProgressInfo progress, CLinkList<CBaseFile> *enabledPackages )`
3012	`{`	2992	`{`
3013	`ClearError();`	2993	`ClearError();`
3014		2994
3015	`// get all files, including children`	2995	`// get all files, including children`
3016	`CLinkList<C_File> fileList;`	2996	`CLinkList<C_File> fileList;`
Line 3053...	Line 3033...
3053	`{`	3033	`{`
3054	`if ( !Dir.exists(f->getDirectory(package)) )`	3034	`if ( !Dir.exists(f->getDirectory(package)) )`
3055	`{`	3035	`{`
3056	`if ( !Dir.create(f->getDirectory(package)) )`	3036	`if ( !Dir.create(f->getDirectory(package)) )`
3057	`{`	3037	`{`
3058	`this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, f->getDirectory(package), errors);`	3038	`this->addLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, f->getDirectory(package), errors);`
3059	`continue;`	3039	`continue;`
3060	`}`	3040	`}`
3061	`this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY, f->getDirectory(package), errors);`	3041	`this->addLogEntry(SPKINSTALL_CREATEDIRECTORY, f->getDirectory(package), errors);`
3062	`}`	3042	`}`
3063	`}`	3043	`}`
3064		3044
3065	`// check if theres an original file to backup`	3045	`// check if theres an original file to backup`
3066	`_pOriginalFiles->doBackup(f, errors);`	3046	`_pOriginalFiles->doBackup(f, errors);`
Line 3090...	Line 3070...
3090	`if ( !currentFile.exists() )`	3070	`if ( !currentFile.exists() )`
3091	`{`	3071	`{`
3092	`// missing file ??`	3072	`// missing file ??`
3093	`if ( !newFile.exists() )`	3073	`if ( !newFile.exists() )`
3094	`{`	3074	`{`
3095	`this->AddLogEntry(SPKINSTALL_MISSINGFILE, newFilename, errors);`	3075	`this->addLogEntry(SPKINSTALL_MISSINGFILE, newFilename, errors);`
3096	`continue;`	3076	`continue;`
3097	`}`	3077	`}`
3098	`}`	3078	`}`
3099	`// remove existing file`	3079	`// remove existing file`
3100	`// file exists, so lets try to move it`	3080	`// file exists, so lets try to move it`
Line 3103...	Line 3083...
3103	`if ( newFile.exists() )`	3083	`if ( newFile.exists() )`
3104	`newFile.remove();`	3084	`newFile.remove();`
3105		3085
3106	`if ( !currentFile.Rename(newFile.fullFilename()) )`	3086	`if ( !currentFile.Rename(newFile.fullFilename()) )`
3107	`{`	3087	`{`
3108	`this->AddLogEntry(SPKINSTALL_ENABLEFILE_FAIL, newFilename, errors);`	3088	`this->addLogEntry(SPKINSTALL_ENABLEFILE_FAIL, newFilename, errors);`
3109	`continue;`	3089	`continue;`
3110	`}`	3090	`}`
3111	`}`	3091	`}`
3112		3092
3113	`this->AddLogEntry(SPKINSTALL_ENABLEFILE, newFilename, errors);`	3093	`this->addLogEntry(SPKINSTALL_ENABLEFILE, newFilename, errors);`
3114		3094
3115	`// adjust the internal name to match the new filename`	3095	`// adjust the internal name to match the new filename`
3116	`f->setFilename(m_sCurrentDir + "/" + newFilename);`	3096	`f->setFilename(m_sCurrentDir + "/" + newFilename);`
3117	`// no longer disabled, we need to remove the flag`	3097	`// no longer disabled, we need to remove the flag`
3118	`f->SetDisabled(false);`	3098	`f->SetDisabled(false);`
Line 3139...	Line 3119...
3139	`if ( pMod )`	3119	`if ( pMod )`
3140	`m_pEnabledMod = pMod;`	3120	`m_pEnabledMod = pMod;`
3141		3121
3142	`// disabled the mod`	3122	`// disabled the mod`
3143	`if ( oldMod && oldMod != m_pEnabledMod && !m_bForceModInstall )`	3123	`if ( oldMod && oldMod != m_pEnabledMod && !m_bForceModInstall )`
3144	`this->DisablePackage(oldMod, errors, progress);`	3124	`this->disablePackage(oldMod, errors, progress);`
3145		3125
3146	`// lets remove all the directories we might have left empty`	3126	`// lets remove all the directories we might have left empty`
3147	`CyStringList removeDirs;`	3127	`Utils::CStringList removeDirs;`
3148	`removeDirs.PushBack(CyString("PluginManager/Disabled"));`	3128	`removeDirs.pushBack("PluginManager/Disabled");`
3149	`RemoveUnusedDirectories(removeDirs, errors);`	3129	`removeUnusedDirectories(removeDirs, errors);`
3150		3130
3151	`m_lEnableList.clear();`	3131	`m_lEnableList.clear();`
3152		3132
3153	`this->WriteData();`	3133	`this->WriteData();`
3154		3134
3155	`return true;`	3135	`return true;`
3156	`}`	3136	`}`
3157		3137
3158		3138
3159	`bool CPackages::DisablePreparedPackages ( CyStringList errors, CProgressInfo progress, CLinkList<CBaseFile> *disabledPackages )`	3139	`bool CPackages::disablePreparedPackages(Utils::CStringList errors, CProgressInfo progress, CLinkList<CBaseFile> *disabledPackages )`
3160	`{`	3140	`{`
3161	`if ( progress )`	3141	`if ( progress )`
3162	`progress->UpdateStatus(PROGRESS_DISABLEFILE);`	3142	`progress->UpdateStatus(PROGRESS_DISABLEFILE);`
3163		3143
3164	`UpdateUsedFiles(&m_lDisableList, false);`	3144	`UpdateUsedFiles(&m_lDisableList, false);`
3165		3145
3166	`// checks if there are any original files to restore and if any fake patches were disabled to reshuffle`	3146	`// checks if there are any original files to restore and if any fake patches were disabled to reshuffle`
3167	`bool original = false, shuffle = false;`	3147	`bool original = false, shuffle = false;`
3168		3148
3169	`// holds our list of directories that we might need to remove, only empty ones from this list will actually be removed`	3149	`// holds our list of directories that we might need to remove, only empty ones from this list will actually be removed`
3170	`CyStringList removeDirs;`	3150	`Utils::CStringList removeDirs;`
3171		3151
3172	`// get all files, including children`	3152	`// get all files, including children`
3173	`CLinkList<C_File> fileList;`	3153	`CLinkList<C_File> fileList;`
3174	`int maxFiles = this->GetAllPackageFiles(&m_lDisableList, &fileList, true);`	3154	`int maxFiles = this->GetAllPackageFiles(&m_lDisableList, &fileList, true);`
3175		3155
Line 3249...	Line 3229...
3249	`if ( !Dir.exists(newFilename) )`	3229	`if ( !Dir.exists(newFilename) )`
3250	`{`	3230	`{`
3251	`// we couldn't create the directory for some reason, this is not good`	3231	`// we couldn't create the directory for some reason, this is not good`
3252	`if ( !Dir.create(newFilename) )`	3232	`if ( !Dir.create(newFilename) )`
3253	`{`	3233	`{`
3254	`this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, newFilename, errors);`	3234	`this->addLogEntry(SPKINSTALL_CREATEDIRECTORY_FAIL, newFilename, errors);`
3255	`continue;`	3235	`continue;`
3256	`}`	3236	`}`
3257	`this->AddLogEntry(SPKINSTALL_CREATEDIRECTORY, newFilename, errors);`	3237	`this->addLogEntry(SPKINSTALL_CREATEDIRECTORY, newFilename, errors);`
3258	`}`	3238	`}`
3259		3239
3260	`// fake patches need a special directory and filename so they dont overright each other as thier filenames are always changes`	3240	`// fake patches need a special directory and filename so they dont overright each other as thier filenames are always changes`
3261	`// if a package with a fake patch is installed while another one is disabled, it will fill the gap left by the disabled one`	3241	`// if a package with a fake patch is installed while another one is disabled, it will fill the gap left by the disabled one`
3262	`// they will then end up with the same filename, if it gets disabled they would overright each other, so we change the filename to prevent that from happening`	3242	`// they will then end up with the same filename, if it gets disabled they would overright each other, so we change the filename to prevent that from happening`
Line 3287...	Line 3267...
3287	`CFileIO currentFile(f->filePointer());`	3267	`CFileIO currentFile(f->filePointer());`
3288	`if ( !currentFile.exists() )`	3268	`if ( !currentFile.exists() )`
3289	`{`	3269	`{`
3290	`if ( !CFileIO(newFilename).exists() )`	3270	`if ( !CFileIO(newFilename).exists() )`
3291	`{`	3271	`{`
3292	`this->AddLogEntry(SPKINSTALL_MISSINGFILE, f->getNameDirectory(checkPackage), errors);`	3272	`this->addLogEntry(SPKINSTALL_MISSINGFILE, f->getNameDirectory(checkPackage), errors);`
3293	`continue;`	3273	`continue;`
3294	`}`	3274	`}`
3295	`}`	3275	`}`
3296	`// otherwise the file must exists, so lets move it`	3276	`// otherwise the file must exists, so lets move it`
3297	`else if ( !currentFile.Rename(newFilename) )`	3277	`else if ( !currentFile.Rename(newFilename) )`
3298	`{`	3278	`{`
3299	`this->AddLogEntry(SPKINSTALL_DISABLEFILE_FAIL, f->getNameDirectory(checkPackage), errors);`	3279	`this->addLogEntry(SPKINSTALL_DISABLEFILE_FAIL, f->getNameDirectory(checkPackage), errors);`
3300	`continue;`	3280	`continue;`
3301	`}`	3281	`}`
3302		3282
3303	`// must have been fine`	3283	`// must have been fine`
3304	`this->AddLogEntry(SPKINSTALL_DISABLEFILE, f->getNameDirectory(checkPackage), errors);`	3284	`this->addLogEntry(SPKINSTALL_DISABLEFILE, f->getNameDirectory(checkPackage), errors);`
3305		3285
3306	`original = _pOriginalFiles->restoreFile(f, errors);`	3286	`original = _pOriginalFiles->restoreFile(f, errors);`
3307		3287
3308	`// extra file thats not in the extras directory`	3288	`// extra file thats not in the extras directory`
3309	`if ( f->GetFileType() == FILETYPE_EXTRA \|\| f->GetFileType() == FILETYPE_MAP \|\| f->GetFileType() == FILETYPE_SOUND )`	3289	`if (f->GetFileType() == FILETYPE_EXTRA \|\| f->GetFileType() == FILETYPE_MAP \|\| f->GetFileType() == FILETYPE_SOUND)`
-		3290	`{`
-		3291	`if(!removeDirs.contains(f->getDirectory(checkPackage)))`
3310	`removeDirs.PushBack(CyString(f->getDirectory(checkPackage)), NullString, true);`	3292	`removeDirs.pushBack(f->getDirectory(checkPackage));`
-		3293	`}`
3311		3294
3312	`// change the filename`	3295	`// change the filename`
3313	`f->setFilename(newFilename);`	3296	`f->setFilename(newFilename);`
3314		3297
3315	`// finally mark the file as disabled so we know not to try to move it again`	3298	`// finally mark the file as disabled so we know not to try to move it again`
Line 3319...	Line 3302...
3319	`// a fake patch has been disabled, we need to reshuffle the rest to fill in any gaps`	3302	`// a fake patch has been disabled, we need to reshuffle the rest to fill in any gaps`
3320	`if ( shuffle )`	3303	`if ( shuffle )`
3321	`{`	3304	`{`
3322	`if ( progress )`	3305	`if ( progress )`
3323	`progress->UpdateStatus(PROGRESS_SHUFFLEFAKE);`	3306	`progress->UpdateStatus(PROGRESS_SHUFFLEFAKE);`
3324	`ShuffleFakePatches(errors);`	3307	`shuffleFakePatches(errors);`
3325	`ShuffleTextFiles(errors);`	3308	`shuffleTextFiles(errors);`
3326	`}`	3309	`}`
3327		3310
3328	`// original files were restored, check to remove the original file directory if its now empty`	3311	`// original files were restored, check to remove the original file directory if its now empty`
3329	`if ( original )`	3312	`if ( original )`
3330	`removeDirs.PushBack(CyString("PluginManager/Original"));`	3313	`removeDirs.pushBack("PluginManager/Original");`
3331		3314
3332	`// remove any empty directories that we might have left`	3315	`// remove any empty directories that we might have left`
3333	`if ( !removeDirs.Empty() )`	3316	`if ( !removeDirs.empty() )`
3334	`RemoveUnusedDirectories(removeDirs, errors);`	3317	`removeUnusedDirectories(removeDirs, errors);`
3335		3318
3336	`// finally mark the whole package as disabled`	3319	`// finally mark the whole package as disabled`
3337	`// recursive, we need to disable all children`	3320	`// recursive, we need to disable all children`
3338	`for ( CBaseFile *child = m_lDisableList.First(); child; child = m_lDisableList.Next() )`	3321	`for ( CBaseFile *child = m_lDisableList.First(); child; child = m_lDisableList.Next() )`
3339	`{`	3322	`{`
Line 3372...	Line 3355...
3372	`* param: errors - A string list used to add the status as it progresses, used in debugging output`	3355	`* param: errors - A string list used to add the status as it progresses, used in debugging output`
3373	`* param: progress - The progress class, updates the progress of the current disabling. Needs a divered class to report the progress somewhere`	3356	`* param: progress - The progress class, updates the progress of the current disabling. Needs a divered class to report the progress somewhere`
3374	`*`	3357	`*`
3375	`* return: boolean, true if there was no errors, otherwise false`	3358	`* return: boolean, true if there was no errors, otherwise false`
3376	`*/`	3359	`*/`
3377	`bool CPackages::DisablePackage ( CBaseFile package, CyStringList errors, CProgressInfo *progress )`	3360	`bool CPackages::disablePackage(CBaseFile package, Utils::CStringList errors, CProgressInfo *progress )`
3378	`{`	3361	`{`
3379	`// if already disabled, just skip`	3362	`// if already disabled, just skip`
3380	`if ( !package->IsEnabled() )`	3363	`if ( !package->IsEnabled() )`
3381	`return true;`	3364	`return true;`
3382		3365
3383	`m_lDisableList.clear();`	3366	`m_lDisableList.clear();`
3384	`if ( this->PrepareDisablePackage(package) )`	3367	`if ( this->PrepareDisablePackage(package) )`
3385	`return this->DisablePreparedPackages(errors, progress);`	3368	`return this->disablePreparedPackages(errors, progress);`

Subversion Repositories spk

(root)/libspk/src/Packages.cpp – Rev 182 → 183