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);
		}
		else if ( errored )
		{
			m_lPackages.remove(p);
			errored->push_back(p);
		}
	}
 
	m_lInstallList.clear();
 
	this->WriteData();

 
	// first check if we are installed a mod
	if ( package->IsMod() && m_pEnabledMod && !m_bForceModInstall ) {
		disabled = true;
		CLog::log(CLog::Log_Install, 2, "Package is a mod and another mod is already enabled, setting to disabled");
	}
	// if vanilla nad package aint signed
	if ( m_bVanilla && !package->IsSigned() ) {
		disabled = true;
		CLog::log(CLog::Log_Install, 2, "Package is a not signed and are we in vanilla mode, setting to disabled");
	}

	// search for an old version
	if ( oldPackage && oldPackage == m_pEnabledMod && disabled )
		disabled = prevDisabled;
 
	return disabled;
}
 
Utils::String CPackages::getCurrentDirectory() const
{ 
	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);
					}
				}

	}
 
	// remove all data
	CLog::log(CLog::Log_Install, 3, "Clearing all unneeded file data");
	package->ClearFileData();
 
	// add to list
	if ( !dontAdd )
	{
		CLog::log(CLog::Log_Install, 1, "Adding package into main list");
		if ( oldPackage )

					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);
 

	CLinkList<C_File> fileList;
	bool readme = false, original = false, shuffle = false;
 
	// find all files that need to be removed
	int maxFiles = 0;
	for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )
	{
		CBaseFile *p = node->Data();
		maxFiles += this->GetAllPackageFiles(p, &fileList, true);
 
		// disable any dependants
		if ( p->GetType() == TYPE_SPK && ((CSpkFile *)p)->IsLibrary() )

					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") ) {

				{
					CFileIO(fDat->filePointer()).copy(m_sCurrentDir + "/mods/PluginManager.dat");
					CFileIO(fCat->filePointer()).copy(m_sCurrentDir + "/mods/PluginManager.cat");
				}
			}
		}
		else if ( m_iGame == GAME_X3 && !m_sSetMod.empty() && CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat") && CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod + ".dat"))
		{
			CLog::log(CLog::Log_Directory, 2, "Copying mod file: " + m_sSetMod + ", to PluginManager.cat");
			CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".dat").copy(m_sCurrentDir + "/mods/PluginManager.dat");
			CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat").copy(m_sCurrentDir + "/mods/PluginManager.cat");
		}
 
		if ( !CDirIO(m_sCurrentDir).exists("mods") )
			CDirIO(m_sCurrentDir).create("mods");
 
		SetupWares();
		SetupShips();
		createEMPFile();
		CreateWareFiles();
		CreateDummies();

	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;
	int maxFiles = this->GetAllPackageFiles(&m_lEnableList, &fileList, false);
 
	int fileCount = 0;
	// we use this list to match cat and dat files
	Utils::CStringList fakePatches;
	for ( CListNode<C_File> *node = fileList.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		if (!f->isForGame(m_iGame))
			continue;
		CBaseFile *package = NULL;
		for ( CListNode<CBaseFile> *node = m_lEnableList.Front(); node; node = node->next() )
		{
			CBaseFile *p = node->Data();
			if ( p->IsFileAdded(f) )
			{
				package = p;
				break;
			}
		}
 
		if ( progress )
		{
			progress->UpdateProgress(fileCount++, maxFiles);
			progress->UpdateFile(f);
		}

		if ( !f->IsFakePatch() )
		{
			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 ( f->GetFileType() == FILETYPE_MOD && !f->IsFakePatch() && f->checkFileExt("cat") )
		{
			if ( f->baseName().Compare(m_sSetMod) )
				m_sSetMod = Utils::String::Null();
		}
 
		// file is not being used by any enabled package
		// set disabled and move to disabled directory
		CDirIO Dir(m_sCurrentDir);
		Utils::String newFilename = "PluginManager/Disabled/";
 

		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
		f->SetDisabled(true);
	}
 
	// 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;
}
 
 

	{
		CBaseFile *file = node->Data();
 
		// only look for spk packages
		if ( file->GetType() != TYPE_SPK )
			continue;
 
		// now compare the name and author, "Compare" is a non case senseative check, opposed to ==.
		if ( file->name().Compare(name) && file->author().Compare(author) )
			return file;
	}
 
	// nothing found

}
 
/**
 * 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();

 * Checks if theres any unused shared files available
 *
 * Any file thats marked as shared, and is no longer connected to any installed package
 */
bool CPackages::AnyUnusedShared()
{
	UpdateUsedFiles();
 
	for ( CListNode<C_File> *node = m_lFiles.Back(); node; node = node->prev() )
	{
		C_File *file = node->Data();
 
		// only do marked shared files
		if ( !file->IsShared() )
			continue;
 
		// only do ones that are no longer needed
		if ( file->getUsed() )
			continue;
 
		return true;
	}
 
	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);
		}
	}
}
 
/**
 * Shuffle Fake Patches
 *
 * 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 (p->AnyDependacies())
		{
			for (SNeededLibrary* nl = p->GetNeededLibraries()->First(); nl; nl = p->GetNeededLibraries()->Next())
			{
				auto package = findPackage(nl->sName, nl->sAuthor);
				if (package)
				{
					packagesBefore.insert(package);
					packagesAfter[p].insert(package);
				}
			}
		}
		CSpkFile* spk = dynamic_cast<CSpkFile*>(p);
		if (spk)
		{
			if (spk->IsAnotherMod())
			{
				auto package = findPackage(spk->otherName(), spk->otherAuthor());
				if (package)
				{

			for (auto itr = list.begin(); itr != list.end(); itr++)
			{
				auto package = findPackage((*itr)->str, (*itr)->data);
				if (package)				
					packagesAfter[package].insert(p);
			}
		}
		if (!p->getFakePatchAfterOrder().empty())
		{
			auto& list = p->getFakePatchAfterOrder();
			for (auto itr = list.begin(); itr != list.end(); itr++)

			if (findItr == order.end())
				order.push_back(p);
		}
	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	for(auto itr = order.begin(); itr != order.end(); itr++)
	{
		CBaseFile *package = *itr;
		if ( package )
		{
			// might have more than 1 fake patch for the file, so we'll need the lowest
			while ( true )
			{
				C_File *lowestFile = NULL;
				for ( C_File *file = package->GetFirstFile(FILETYPE_MOD); file; file = package->GetNextFile(file) )

					if (doneList.FindData(file)) continue; // already done?
 
					if ( !lowestFile )
						lowestFile = file;
					else
					{
						if ( file->baseName().toInt() < lowestFile->baseName().toInt() )
							lowestFile = file;
					}
				}
 
				if ( !lowestFile ) // no more files ?
					break;
 
				// check its filename, it might already be in the correct place
				if ( lowestFile->baseName().toInt() != lowest )
				{
					// if the file already exists, we need to move it elsewhere

							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
			}

	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		// already done?
		if ( doneList.FindData(f) ) 
			continue;
 
		// only do files that are enabled
		if ( f->IsDisabled() )
			continue;
 

		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;

 * Find next fake patch
 *
 * Searching for the next gap in patches, starting with 01.cat to 99.cat
 */
int CPackages::findNextFakePatch(int start, const Utils::String &dir) const
{
	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
 
	int check = start;
	while ( check < 99 )
	{
		++check;
		Utils::String checkStr = Utils::String::PadNumber(check, 2);
 

		{
			// it doen't, check if theres a dat file (incase of package error)
			if ( !Dir.exists(checkStr + ".dat") )
				break;
		}
	}
 
	return check;
}
 
/**
 * Find next text file

unsigned int CPackages::findNextTextFile(unsigned int start) const
{
	return findNextTextFile(Utils::String::Null(), start);
}
unsigned int CPackages::findNextTextFile(const Utils::String &dir, unsigned int start) const
{
	int check = start;
	if ( check < 2 ) check = 2;
	while ( check < 9999 )
	{
		++check;
		Utils::String newFilename = SPK::FormatTextName(check, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
 
		// check the vfs
		if ( m_pGameVFS.isFileAvailable("t/" + newFilename + ".pck") ) continue;
		if ( m_pGameVFS.isFileAvailable("t/" + newFilename + ".xml") ) continue;
 
		break;
	}
 
	return check;
}
 
int CPackages::findLastTextFile(int start, const Utils::String& dir) const
{

	int check = start;
	while ( check < 9999 )
	{
		++check;
		Utils::String newFilename = SPK::FormatTextName(check, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT));
 
		// check if a packed file exists
		if ( !Dir.exists(newFilename + ".pck") )
		{
			// it doen't, check if theres an unpacked file
			if ( !Dir.exists(newFilename + ".xml") )
				break;
		}
	}
 
	return check;
}
 
/**
 * Read game language
 *
 * Reads the lang.dat file from the game directory for the language id
 */
void CPackages::ReadGameLanguage(bool force)

			Utils::String str(data);
			m_iLanguage = str.token("\n", 1).token(" ", 1).toInt();
		}
	}
}
 
/**
 * Create Language Text File
 *
 * Creates text files for all packages into the correct language
 */

	if ( !m_iLanguage )
		return;
 
	// find all text files
	Utils::CStringList ids;
 
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		// only do text fiels
		if ( f->GetFileType() != FILETYPE_TEXT )
			continue;
 
		Utils::String id, lang;
		if ( m_iGameFlags & EXEFLAG_TCTEXT )
		{
			id = f->baseName().token("-", 1);
			lang = f->baseName().token("-", 2);
			if ( lang.empty() )
				lang = "NULL";
			else
				lang = lang.erase(0, 1);  // remove the "L"
		}
		else
		{
			lang = Utils::String::PadNumber(f->baseName().left((int)f->baseName().length() - 4), 3);
			id = f->baseName().mid(((int)f->baseName().length() - 4) + 1, 4);
		}
 
 
		// not added, add a new one
		if (!ids.contains(id))
			ids.pushBack(id, lang);
		else
		{

		bool found = false;
		for ( int i = 0; i < size; i++ )
		{
			if ( data[i] == "NULL" )
				useId = -1;
			else
			{
				int num = data[i].toInt();
				if ( num == m_iLanguage )
				{
					found = true;

		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();
	remFileStr.findReplace(m_sCurrentDir, "");
 
	if ( file->filePointer().contains("::")) {
		CFileIO CatFile(file->filePointer().token("::", 1));

			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	`}`
1375	`else if ( errored )`	1374	`else if ( errored )`
1376	`{`	1375	`{`
1377	`m_lPackages.remove(p);`	1376	`m_lPackages.remove(p);`
1378	`errored->push_back(p);`	1377	`errored->push_back(p);`
1379	`}`	1378	`}`
1380	`}`	1379	`}`
1381		1380
1382	`m_lInstallList.clear();`	1381	`m_lInstallList.clear();`
1383		1382
1384	`this->WriteData();`	1383	`this->WriteData();`
Line 1417...	Line 1416...
1417		1416
1418	`// first check if we are installed a mod`	1417	`// first check if we are installed a mod`
1419	`if ( package->IsMod() && m_pEnabledMod && !m_bForceModInstall ) {`	1418	`if ( package->IsMod() && m_pEnabledMod && !m_bForceModInstall ) {`
1420	`disabled = true;`	1419	`disabled = true;`
1421	`CLog::log(CLog::Log_Install, 2, "Package is a mod and another mod is already enabled, setting to disabled");`	1420	`CLog::log(CLog::Log_Install, 2, "Package is a mod and another mod is already enabled, setting to disabled");`
1422	`}`	1421	`}`
1423	`// if vanilla nad package aint signed`	1422	`// if vanilla nad package aint signed`
1424	`if ( m_bVanilla && !package->IsSigned() ) {`	1423	`if ( m_bVanilla && !package->IsSigned() ) {`
1425	`disabled = true;`	1424	`disabled = true;`
1426	`CLog::log(CLog::Log_Install, 2, "Package is a not signed and are we in vanilla mode, setting to disabled");`	1425	`CLog::log(CLog::Log_Install, 2, "Package is a not signed and are we in vanilla mode, setting to disabled");`
1427	`}`	1426	`}`
Line 1435...	Line 1434...
1435	`// search for an old version`	1434	`// search for an old version`
1436	`if ( oldPackage && oldPackage == m_pEnabledMod && disabled )`	1435	`if ( oldPackage && oldPackage == m_pEnabledMod && disabled )`
1437	`disabled = prevDisabled;`	1436	`disabled = prevDisabled;`
1438		1437
1439	`return disabled;`	1438	`return disabled;`
1440	`}`	1439	`}`
1441		1440
1442	`Utils::String CPackages::getCurrentDirectory() const`	1441	`Utils::String CPackages::getCurrentDirectory() const`
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 1709...	Line 1706...
1709	`}`	1706	`}`
1710		1707
1711	`// remove all data`	1708	`// remove all data`
1712	`CLog::log(CLog::Log_Install, 3, "Clearing all unneeded file data");`	1709	`CLog::log(CLog::Log_Install, 3, "Clearing all unneeded file data");`
1713	`package->ClearFileData();`	1710	`package->ClearFileData();`
1714		1711
1715	`// add to list`	1712	`// add to list`
1716	`if ( !dontAdd )`	1713	`if ( !dontAdd )`
1717	`{`	1714	`{`
1718	`CLog::log(CLog::Log_Install, 1, "Adding package into main list");`	1715	`CLog::log(CLog::Log_Install, 1, "Adding package into main list");`
1719	`if ( oldPackage )`	1716	`if ( oldPackage )`
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 1827...	Line 1822...
1827	`CLinkList<C_File> fileList;`	1822	`CLinkList<C_File> fileList;`
1828	`bool readme = false, original = false, shuffle = false;`	1823	`bool readme = false, original = false, shuffle = false;`
1829		1824
1830	`// find all files that need to be removed`	1825	`// find all files that need to be removed`
1831	`int maxFiles = 0;`	1826	`int maxFiles = 0;`
1832	`for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )`	1827	`for ( CListNode<CBaseFile> *node = m_lInstallList.Front(); node; node = node->next() )`
1833	`{`	1828	`{`
1834	`CBaseFile *p = node->Data();`	1829	`CBaseFile *p = node->Data();`
1835	`maxFiles += this->GetAllPackageFiles(p, &fileList, true);`	1830	`maxFiles += this->GetAllPackageFiles(p, &fileList, true);`
1836		1831
1837	`// disable any dependants`	1832	`// disable any dependants`
1838	`if ( p->GetType() == TYPE_SPK && ((CSpkFile *)p)->IsLibrary() )`	1833	`if ( p->GetType() == TYPE_SPK && ((CSpkFile *)p)->IsLibrary() )`
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		-
2472	`Utils::CStringList lErrors;`	-
2473		2466
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 2508...	Line 2501...
2508	`{`	2501	`{`
2509	`CFileIO(fDat->filePointer()).copy(m_sCurrentDir + "/mods/PluginManager.dat");`	2502	`CFileIO(fDat->filePointer()).copy(m_sCurrentDir + "/mods/PluginManager.dat");`
2510	`CFileIO(fCat->filePointer()).copy(m_sCurrentDir + "/mods/PluginManager.cat");`	2503	`CFileIO(fCat->filePointer()).copy(m_sCurrentDir + "/mods/PluginManager.cat");`
2511	`}`	2504	`}`
2512	`}`	2505	`}`
2513	`}`	2506	`}`
2514	`else if ( m_iGame == GAME_X3 && !m_sSetMod.empty() && CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat") && CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod + ".dat"))`	2507	`else if ( m_iGame == GAME_X3 && !m_sSetMod.empty() && CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat") && CFileIO::Exists(m_sCurrentDir + "/mods/" + m_sSetMod + ".dat"))`
2515	`{`	2508	`{`
2516	`CLog::log(CLog::Log_Directory, 2, "Copying mod file: " + m_sSetMod + ", to PluginManager.cat");`	2509	`CLog::log(CLog::Log_Directory, 2, "Copying mod file: " + m_sSetMod + ", to PluginManager.cat");`
2517	`CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".dat").copy(m_sCurrentDir + "/mods/PluginManager.dat");`	2510	`CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".dat").copy(m_sCurrentDir + "/mods/PluginManager.dat");`
2518	`CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat").copy(m_sCurrentDir + "/mods/PluginManager.cat");`	2511	`CFileIO(m_sCurrentDir + "/mods/" + m_sSetMod + ".cat").copy(m_sCurrentDir + "/mods/PluginManager.cat");`
2519	`}`	2512	`}`
2520		2513
2521	`if ( !CDirIO(m_sCurrentDir).exists("mods") )`	2514	`if ( !CDirIO(m_sCurrentDir).exists("mods") )`
2522	`CDirIO(m_sCurrentDir).create("mods");`	2515	`CDirIO(m_sCurrentDir).create("mods");`
2523		2516
2524	`SetupWares();`	2517	`SetupWares();`
2525	`SetupShips();`	2518	`SetupShips();`
2526	`createEMPFile();`	2519	`createEMPFile();`
2527	`CreateWareFiles();`	2520	`CreateWareFiles();`
2528	`CreateDummies();`	2521	`CreateDummies();`
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;`
3017	`int maxFiles = this->GetAllPackageFiles(&m_lEnableList, &fileList, false);`	2997	`int maxFiles = this->GetAllPackageFiles(&m_lEnableList, &fileList, false);`
3018		2998
3019	`int fileCount = 0;`	2999	`int fileCount = 0;`
3020	`// we use this list to match cat and dat files`	3000	`// we use this list to match cat and dat files`
3021	`Utils::CStringList fakePatches;`	3001	`Utils::CStringList fakePatches;`
3022	`for ( CListNode<C_File> *node = fileList.Front(); node; node = node->next() )`	3002	`for ( CListNode<C_File> *node = fileList.Front(); node; node = node->next() )`
3023	`{`	3003	`{`
3024	`C_File *f = node->Data();`	3004	`C_File *f = node->Data();`
3025	`if (!f->isForGame(m_iGame))`	3005	`if (!f->isForGame(m_iGame))`
3026	`continue;`	3006	`continue;`
3027	`CBaseFile *package = NULL;`	3007	`CBaseFile *package = NULL;`
3028	`for ( CListNode<CBaseFile> *node = m_lEnableList.Front(); node; node = node->next() )`	3008	`for ( CListNode<CBaseFile> *node = m_lEnableList.Front(); node; node = node->next() )`
3029	`{`	3009	`{`
3030	`CBaseFile *p = node->Data();`	3010	`CBaseFile *p = node->Data();`
3031	`if ( p->IsFileAdded(f) )`	3011	`if ( p->IsFileAdded(f) )`
3032	`{`	3012	`{`
3033	`package = p;`	3013	`package = p;`
3034	`break;`	3014	`break;`
3035	`}`	3015	`}`
3036	`}`	3016	`}`
3037		3017
3038	`if ( progress )`	3018	`if ( progress )`
3039	`{`	3019	`{`
3040	`progress->UpdateProgress(fileCount++, maxFiles);`	3020	`progress->UpdateProgress(fileCount++, maxFiles);`
3041	`progress->UpdateFile(f);`	3021	`progress->UpdateFile(f);`
3042	`}`	3022	`}`
Line 3052...	Line 3032...
3052	`if ( !f->IsFakePatch() )`	3032	`if ( !f->IsFakePatch() )`
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	`}`

Subversion Repositories spk

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