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



	}
 
	return NULL;
}
 
int CBaseFile::CheckFile(const Utils::WString &filename, float *version )
{
	CFileIO File(filename);
	if ( !File.startRead() ) return 0;
	Utils::String line = File.readEndOfLineStr();
	Utils::String type = line.token(";", 1);
	File.close();
 
	// check for old version
	if ( line.left(3) == "HiP" ) return SPKFILE_OLD;

	{
		f->Data()->DeleteData();
	}
}
 
Utils::WString CBaseFile::getNameValidFile() const
{
	Utils::WString name = this->name();
	name.removeChar(':');
	name.removeChar('/');
	name.removeChar('\\');
	name.removeChar('*');
	name.removeChar('?');

	}
 
	_addFile(file);
}
 
C_File *CBaseFile::addFile(const Utils::WString &file, const Utils::WString &dir, FileType type, int game, bool packed)
{
	C_File *newfile = new C_File(file);
	newfile->setDir(dir);
	newfile->setFileType(type);
	newfile->setGame(game);
 
	if (packed)
	{
		if (newfile->PCKFile())
 
			newfile->setFilename(CFileIO(newfile->filePointer()).changeFileExtension(L"pck"));
 
	}
 
	// first check if the file already exists
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *f = node->Data();
		if ( f->fileType() != newfile->fileType() )
			continue;
		if ( f->name() != newfile->name () )
			continue;
		if ( f->dir() != newfile->dir() )
			continue;
		if (f->game() != newfile->game())
		{
			//same file, for different game, check if they are the same and combine them

						if (data[i] != newData[i])
						{
							matched = false;
							break;
						}
					}
				}
 
				if (data)
					delete data;
				if (newData)
					delete newData;
 

					break;
				}
			}
			continue;
		}
 
		// must already exist, delete this one
		m_lFiles.remove(node, true);
		break;
	}
 
	_addFile(newfile);
 
	return newfile;
}
 

 
	// compress the file
	return f->CompressData(m_SHeader2.iDataCompression, progress);
}
 
C_File *CBaseFile::appendFile(const Utils::WString &file, int type, int game, bool packed, const Utils::WString &dir, CProgressInfo *progress )
{
	C_File *newfile = addFile(file, dir, static_cast<FileType>(type), game, packed);
	if ( !newfile )
		return NULL;
 
	// read the file into memory
	if (newfile->GetData() && newfile->GetDataSize())
	{
		// now compress the file
		if (newfile->CompressData(m_SHeader2.iDataCompression, progress))
			return newfile;
	}
	if ( newfile->ReadFromFile () )

	}
 
	return NULL;
}
 
C_File* CBaseFile::findFile(const Utils::WString &filename, FileType type, const Utils::WString &dir, int game) const
{	
	Utils::WString lfile = CFileIO(filename.lower()).filename();
 
	CListNode<C_File>* node = m_lFiles.Front();
	while (node)
	{
		C_File* f = node->Data();

	C_File *file = m_lFiles.Get ( pos );
	m_lFiles.erase ( pos + 1 );
 
	if ( file )
		delete file;
 
	_changed();
 
	return true;
}
 
 
void CBaseFile::removeAllFiles(FileType type, int game)
{
	if ( m_lFiles.empty() )
		return;
 
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		if (game == 0 && node->Data()->game() && node->Data()->game() != GAME_ALLNEW)
			continue;
		if ( game > -1 )

		C_File *file = node->Data();
		if ( progress )
			progress->UpdateFile(file);
 
		if ( file->GetCompressionType() == type )
			continue;
 
		if ( !file->GetData() )
			file->ReadFromFile();
 
		file->ChangeCompression ( type, progress );
	}

	Return: String - returns the full string for files list
	Desc:   Creates a signle line list of all the files
*/
Utils::String CBaseFile::createFilesLine(SSPKHeader2 *header, CProgressInfo* progress) const
{
	Utils::WString line;
 
	if (progress)
	{
		progress->SetDone(0);
		progress->UpdateStatus(STATUS_COMPRESS);
	}
 
	if (header)

 
		// compress the file
		if (!m_pIconFile->CompressData(m_SHeader2.iDataCompression, progress))
			m_pIconFile->SetDataCompression(SPKCOMPRESS_NONE);
 
		line += L"Icon:" + Utils::WString::Number(m_pIconFile->GetDataSize() + (long)4) + L":" + m_pIconFile->uncompressedDataSize() + L":" + (long)m_pIconFile->GetCompressionType() + L":" + _sIconExt + L"\n";
		if (header)
		{
			++header->iNumFiles;
			header->lFullSize += (m_pIconFile->GetDataSize() + 4);
		}

		{
			file->SetDataCompression(SPKCOMPRESS_NONE);
			file->SetUncompressedDataSize(file->GetDataSize());
		}
 
		Utils::WString command = GetFileTypeString(file->GetFileType());
		if (command.empty())
			continue;
 
		if (file->IsShared())
			command = L"$" + command;
 
		if (file->dir().empty())
			line += command + L":" + (file->GetDataSize() + (long)4) + L":" + file->uncompressedDataSize() + L":" + (long)file->GetCompressionType() + L":" + (long)file->GetCreationTime() + L":" + ((file->IsCompressedToFile()) ? L"1" : L"0") + L":" + file->filename() + L":NULL:" + (long)file->game() + L"\n";
		else
			line += command + L":" + (file->GetDataSize() + (long)4) + L":" + file->uncompressedDataSize() + L":" + (long)file->GetCompressionType() + L":" + (long)file->GetCreationTime() + L":" + ((file->IsCompressedToFile()) ? L"1" : L"0") + L":" + file->filename() + L":" + file->dir() + L":" + (long)file->game() + L"\n";
 
		if (header)
		{
			++header->iNumFiles;
			header->lFullSize += (file->GetDataSize() + 4);
		}
	}
 
	return line.toString();
}
 
/*
######################################################################################
##########							Reading Functions			    		##########

	// now open the file
	CFileIO File(this->filename());
	if ( !File.startRead() ) return;
 
	// read the header
	File.readEndOfLineStr();
	// skip past values
	File.seek(4 + m_SHeader.lValueCompressSize);
 
	// read the next header
	File.readEndOfLineStr();
	// skip past files
	File.seek(4 + m_SHeader2.lSize);
 
	if ( m_pIconFile )
	{

	// now open the file
	CFileIO *File = new CFileIO(this->filename());
	if ( !File->startRead() ) return NULL;
 
	// read the header
	File->readEndOfLineStr();
	// skip past values
	File->seek(4 + m_SHeader.lValueCompressSize);
 
	// read the next header
	File->readEndOfLineStr();
	// skip past files
	File->seek(4 + m_SHeader2.lSize);
 
	return File;
}

}
 
void CBaseFile::_updateTextDB(C_File *file)
{
	if ( !_pTextDB ) _pTextDB = new CTextDB();
 
	if ( file->GetFileType() == FILETYPE_TEXT ) {
		Utils::WString baseFile = CFileIO(file->filePointer()).baseName();
		int lang = (baseFile.contains(L"-L")) ? baseFile.right(3) : baseFile.truncate(-4);
 
		// read in the text file to the database

		_updateTextDB(node->Data());
	}
}
 
void CBaseFile::ReadIconFileToMemory ()
{
	if ( !m_pIconFile )	return;
	CFileIO *File = _startRead();
	if ( !File ) return;
 
	if ( (!m_pIconFile->GetData()) && (!m_pIconFile->Skip()) )

	delete File;
}
 
void CBaseFile::_install_adjustFakePatches(CPackages *pPackages)
{
	Utils::WStringList lPatches;
	int startfake = pPackages->findNextFakePatch();
 
	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
	{
		C_File *fit = node->Data();
		// only do fake patchs
		if ( !fit->IsFakePatch() )
			continue;
 
		// we should only have cat and dat files, but lets check just incase they have been added incorrectly
		if ( !fit->checkFileExt ("cat") && !fit->checkFileExt("dat") )
			continue;
 
		// search for the name on the list
		Utils::WString newname;
		bool isOpposite = false;
		if (lPatches.contains(fit->baseName()))
		{
			newname = lPatches.findString(fit->baseName());
			isOpposite = true;
		}
		else
		{
			newname = Utils::WString::PadNumber((long)startfake, 2);
			lPatches.pushBack(fit->baseName(), newname);
		}
 
		// rename the file
		fit->FixOriginalName();

	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
		C_File *fit = node->Data();
		if ( !fit->isAutoTextFile() )
			continue;
 
		Utils::WString newname = SPK::FormatTextName(starttext, pPackages->GetLanguage(), (pPackages->GetCurrentGameFlags() & EXEFLAG_TCTEXT));
		fit->FixOriginalName();
		CLog::logf(CLog::Log_Install, 2, "Adjusting text file, %s => %s", fit->getNameDirectory(this).c_str(), (newname + "." + fit->fileExt()).c_str());
		fit->setName(newname + "." + fit->fileExt());
 
		++starttext;

	}
 
	return bEnable;
}
 
bool CBaseFile::_install_uncompress(C_File *fit, CProgressInfo *progress, Utils::WStringList *errorStr, bool *uncomprToFile)
{
	*uncomprToFile = false;
	_sLastError = fit->getNameDirectory(this);
	_iLastError = SPKERR_UNCOMPRESS;
 
	if ( !fit->UncompressData ( progress ) )
	{
		CLog::log(CLog::Log_Install, 2, "Failed to uncompress data, attempting file decompression");
		if ( fit->GetCompressionType() == SPKCOMPRESS_7ZIP )
		{
			if ( fit->uncompressToFile(Utils::WString::Null(), this, false, progress ) )
				*uncomprToFile = true;
		}
 
		if ( !uncomprToFile )
		{

	ClearError ();
 
	return true;
}
 
bool CBaseFile::_install_checkVersion(C_File *pFile, const Utils::WString &sDestination)
{
	// new check if we should install the file
	// first get the version
	if ( !m_bOverrideFiles && pFile->ReadScriptVersion() )
	{
		CLog::log(CLog::Log_Install, 2, "Checking for existing file version");
		C_File checkfile;
		Utils::WString checkfilename = sDestination;
		if ( !checkfilename.empty() ) checkfilename += L"/";
		checkfilename += pFile->getNameDirectory(this);
		checkfile.setFilename(checkfilename);
		checkfile.setFileType(pFile->fileType());
		if ( checkfile.CheckValidFilePointer() ) {
			if ( checkfile.ReadScriptVersion() > pFile->GetVersion() ) {

	}
 
	return true;
}
 
Utils::String CBaseFile::_install_adjustFilepointer(C_File *pFile, bool bEnabled, const Utils::WString &sDestination)
{
	Utils::WString filename = sDestination;
	if ( !filename.empty() ) filename += L"/";
 
	if ( (IsPatch()) && (pFile->fileType() == FILETYPE_MOD) )
		pFile->setDir(L"Patch");
 
	if ( pFile->isInMod() )
	{
		if ( bEnabled )
			pFile->setFilename(filename + pFile->getInMod() + L"::" + pFile->getNameDirectory(this));
		else
			pFile->setFilename(filename + L"PluginManager/DisabledFiles.cat::" + pFile->getNameDirectory(this));
	}
	else
		pFile->setFilename ( filename + pFile->getNameDirectory(this) );
 
	if ( !bEnabled )
	{
		if ( !pFile->isInMod() )
		{
			if ( pFile->IsFakePatch() )
				pFile->setFilename ( filename + L"PluginManager/Disabled/FakePatches/FakePatch_" + this->getNameValidFile() + L"_" + this->author().toWString() + L"_&quot; + pFile->name());
			else if ( pFile->isAutoTextFile() )
				pFile->setFilename ( filename + L"PluginManager/Disabled/TextFiles/Text_" + this->getNameValidFile() + L"_" + this->author().toWString() + L"_&quot; + pFile->name());
			else
				pFile->setFullDir ( filename + L"PluginManager/Disabled/" + pFile->getDirectory(this) );
		}
		pFile->SetDisabled(true);
	}
 
	CLog::logf(CLog::Log_Install, 2, "Adjusting the file pointer to correct install destintation, %s", pFile->filePointer().c_str());
 
	return filename.toString();
}
 
C_File *CBaseFile::_install_checkFile(C_File *pFile, Utils::WStringList *errorStr, bool *bDoFile, CLinkList<C_File> *pFileList)
{
	if ( !pFile->IsFakePatch() && pFile->GetFileType() != FILETYPE_README )
	{
		C_File *cFile;
		for ( cFile = pFileList->First(); cFile; cFile = pFileList->Next() )

	}
 
	return NULL;
}
 
bool CBaseFile::_install_checkFileEnable(C_File *pCheckFile, C_File *fit, const Utils::WString &sDestination, bool bEnabled, Utils::WStringList *errorStr)
{
	// found a file, check if its in the disabled directory
	Utils::WString dir = CFileIO(pCheckFile->filePointer()).dir();
	Utils::WString lastDir = CDirIO(dir).topDir().lower();
 

	if ( ((pCheckFile->IsDisabled()) || (lastDir == L"disabled") || (dir.lower().contains(L"/disabled/"))) && (bEnabled) )
	{
		CLog::logf(CLog::Log_Install, 2, "Existing file, %s, is disabled, re-enabling it", pCheckFile->filePointer().c_str());
		// first check if the directory exists
		if ( pCheckFile->isInMod() ) {
			Utils::WString tofile = pCheckFile->filePointer().token(L"::", 2);
 
			CCatFile tocat;
			int err = tocat.open(fit->filePointer().token(L"::", 1), L"", CATREAD_CATDECRYPT, true);
			if ( (err == CATERR_NONE) || (err == CATERR_CREATED) ) {
				tocat.appendFile(pCheckFile->filePointer(), tofile);
				CLog::logf(CLog::Log_Install, 2, "Adding existing file into new mod File, %s => %s", fit->filePointer().token(L"::", 1).c_str(), tofile.c_str());
			}
 
			CCatFile fromcat;
			err = fromcat.open(pCheckFile->filePointer().token(L"::", 1), L"", CATREAD_CATDECRYPT, false);
			if ( err == CATERR_NONE ) {
				fromcat.removeFile(tofile);
				CLog::logf(CLog::Log_Install, 2, "Removing file from existing mod, %s::%s", pCheckFile->filePointer().token(L"::", 1).c_str(), tofile.c_str());
			}
 
			CLog::logf(CLog::Log_Install, 1, "Adjusting existing file name %s => %s", pCheckFile->filePointer().c_str(), fit->filePointer().c_str());
			pCheckFile->setFilename(fit->filePointer());
			CLog::logf(CLog::Log_Install, 2, "Adjusting In Mod setting, %s => %s", pCheckFile->getInMod().c_str(), fit->getInMod().c_str());
			pCheckFile->setInMod(fit->getInMod());
		}
		else {
			Utils::WString to = pCheckFile->getDirectory(this);
			CDirIO Dir(sDestination);
			if ( !Dir.exists(to) ) {
				if ( !Dir.create ( to ) ) {
					if ( errorStr )	errorStr->pushBack(to.toString(), ERRORLOG(SPKINSTALL_CREATEDIRECTORY_FAIL));
					return false;
				}
				if ( errorStr )	errorStr->pushBack(to.toString(), ERRORLOG(SPKINSTALL_CREATEDIRECTORY));
			}
 
			Utils::WString destfile = sDestination + L"/" + pCheckFile->getNameDirectory(this);
			if ( CFileIO::Exists(destfile) ) CFileIO::Remove(destfile);
			CLog::logf(CLog::Log_Install, 1, "Adjusting existing filename, %s => %s", pCheckFile->filePointer().c_str(), destfile.c_str());
			CFileIO::Rename(pCheckFile->filePointer(), destfile);
			pCheckFile->setFilename (sDestination + L"/" + pCheckFile->getNameDirectory(this) );
		}
		pCheckFile->SetDisabled(false);
 
		if ( errorStr ) errorStr->pushBack(pCheckFile->getNameDirectory(this), ERRORLOG(SPKINSTALL_ENABLEFILE));
	}
 
	return true;
}
 
bool CBaseFile::_install_createDirectory(CDirIO &Dir, const Utils::WString &sTo, C_File *pFile, Utils::WStringList *errorStr)
{
	_sLastError = sTo;
	if ( !sTo.contains(L"::"))
	{
		if ( !Dir.exists(sTo) )
		{
			CLog::logf(CLog::Log_Install, 2, "Creating directory to install file into, %s", sTo.c_str());
			if ( !Dir.create(sTo) )

	}
 
	return true;
}
 
void CBaseFile::_install_writeFile(C_File *pFile, const Utils::WString &sDestination, Utils::WStringList *errorStr)
{
	_iLastError = SPKERR_WRITEFILE;
	_sLastError = pFile->filePointer();
	Utils::WString sInstalledFile = pFile->getNameDirectory(this);
	if ( pFile->IsDisabled() )
	{
		sInstalledFile = pFile->filePointer().findRemove(sDestination);
		if ( sInstalledFile[0] == '/' || sInstalledFile[0] == '\\' )
			sInstalledFile.erase(0, 1);

				break;
		}
	}
}
 
bool CBaseFile::installFiles(const Utils::WString &destdir, CProgressInfo *progress, CLinkList<C_File> *filelist, Utils::WStringList *errorStr, bool enabled, CPackages *packages )
{
	//TODO: add errorStr and progress as member variables
	if ( enabled ) {
		this->_install_adjustFakePatches(packages);
		if ( packages ) this->_install_renameText(packages);

		}
 
		bool dofile = _install_checkVersion(fit, destdir);
 
		// change file pointer
		Utils::WString sInstallDir = _install_adjustFilepointer(fit, fileEnabled, destdir);
 
		C_File *adjustPointer = NULL;
 
		if ( filelist ) {
			C_File *cFile = _install_checkFile(fit, errorStr, &dofile, filelist);

		{
			// uncompressed to file, rename and move
			if ( uncomprToFile )
			{
				_iLastError = SPKERR_WRITEFILE;
				Utils::WString to = fit->getDirectory(this);
				if ( !fileEnabled )	to = L"PluginManager/Disabled/" + to;
 
				if ( !_install_createDirectory(Dir, to, fit, errorStr) ) {
					bFailed = true;
					continue;
				}
 
				bool err = true;
				_sLastError = to;
				if ( !fit->getTempFile().empty())
					err = CFileIO::Rename(fit->getTempFile(), to);
				if ( err ) {
					bFailed = true;
					continue;
				}
			}

				if ( (filelist) && (adjustPointer) ) {
					adjustPointer->CopyData(fit, false);
					CLog::log(CLog::Log_Install, 2, "Copying data into existing file");
				}
 
				Utils::WString fpointer = fit->filePointer();
				_iLastError = SPKERR_CREATEDIRECTORY;
				Utils::WString dir = CFileIO(fit->filePointer()).dir().toString();
 
				dir = dir.findRemove(destdir);
				if (!dir.empty() && (dir[0] == '/' || dir[0] == '\\')) 
					dir.erase(0, 1);
 

	if ( first.Compare("Name:") )					this->setName(rest);
	else if ( first.Compare("Author:") )			this->setAuthor(rest);
	else if ( first.Compare("Version:") )			this->setVersion(rest);
	else if ( first.Compare("fGameVersion:") ) {
		if ( m_lGames.Back() ) {
			m_lGames.Back()->Data()->sVersion = rest.toWString();
		}
	}
	else if ( first.Compare("GameVersion:") ) {
		if ( m_lGames.Back() ) {
			m_lGames.Back()->Data()->iVersion = rest.toInt();
		}
	}
	else if ( first.Compare("Game:") )
		this->AddGameCompatability(rest, "");
	else if ( first.Compare("GameCompat:") )

	long usize = line.token(":", 3).toInt ();
	long compression = line.token(":", 4).toInt ();
 
	if ( command == "Icon" )
	{
		_sIconExt = line.token(":", 5).toWString();
		m_pIconFile = new C_File ();
		m_pIconFile->SetDataSize ( size - 4 );
		m_pIconFile->SetDataCompression ( compression );
		m_pIconFile->SetUncompressedDataSize ( usize );
 

bool CBaseFile::readFile(CFileIO &File, int readtype, CProgressInfo *progress)
{
	ClearError ();
 
	// first read the header
	if ( !_parseHeader(File.readEndOfLineStr()) ) return false;
	if ( readtype == SPKREAD_HEADER ) return true;
 
	// update the progress for each section
	int maxProgress = (readtype == SPKREAD_VALUES) ? 3 : 6;
	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(1, maxProgress);

	// update the progress for each section
	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(3, maxProgress);
	if ( readtype == SPKREAD_VALUES ) return true;
 
	// next should be the next header
	if ( !_parseFileHeader(File.readEndOfLineStr()) ) return false;
 
	// clear the current file list
	m_lFiles.clear(true);
	if ( _pTextDB ) {
		delete _pTextDB;

	if ( readtype != SPKREAD_ALL && progress )	progress->UpdateProgress(6, maxProgress);
 
	if ( readtype == SPKREAD_ALL ) {
		int fileCount = 2;
		if ( m_pIconFile ) m_pIconFile->readFromFile(File, m_pIconFile->GetDataSize());
 
		// ok finally we need to read all the file
		for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
			node->Data()->readFromFile(File, node->Data()->GetDataSize());
			if ( progress )	progress->UpdateProgress(fileCount++, m_lFiles.size() + 2);
		}
 
		m_bFullyLoaded = true;
	}
 
	return true;
}
 
bool CBaseFile::IsMod()
{
	// check for any mod files that are not fake patchs
	for ( CListNode<C_File> *fNode = m_lFiles.Front(); fNode; fNode = fNode->next() )
	{
		C_File *f = fNode->Data();
		if ( f->GetFileType() != FILETYPE_MOD )
			continue;
 
		if ( !f->IsFakePatch() )
			return true;
	}
 
	return false;
}
 
bool CBaseFile::IsFakePatch() const
{
	// check for any mod files that are not fake patchs
	for ( CListNode<C_File> *fNode = m_lFiles.Front(); fNode; fNode = fNode->next() )
	{

 
	return false;
}
 
Utils::String CBaseFile::createValuesLine () const
{
	Utils::String values("Name: ");
	values += this->name() + "\n";
	values += "Author: " + this->author() + "\n";
	values += "Version: " + this->version() + "\n";
	if ( !this->creationDate().empty() )values += "Date: "			+ this->creationDate()	+ "\n";

		values += "Desc: " + desc + "\n";
	}
 
	for ( CListNode<SGameCompat> *gc = m_lGames.Front(); gc; gc = gc->next() ) {
		if ( !gc->Data()->sVersion.empty() )
			values += Utils::String("GameCompatExact: ") + (long)gc->Data()->iGame + " " + gc->Data()->sVersion.toString() + "\n";
		else
			values += Utils::String("GameCompat: ") + (long)gc->Data()->iGame + " " + (long)gc->Data()->iVersion + "\n";
	}
 
	if (computeSigned(true))

 
	return true;
}
 
bool CBaseFile::extractFile(C_File *file, const Utils::String &dir, bool includedir, CProgressInfo *progress)
{
	if (ReadFileToMemory(file))
	{
		// now finally, uncompress the file
		long len = 0;
		unsigned char *data = file->UncompressData(&len, progress);
		if (!data)
		{
			// attempt a file decompress
			if (file->GetCompressionType() == SPKCOMPRESS_7ZIP)
			{
				if (file->uncompressToFile(dir, this, includedir, progress))
					return true;
			}
			return false;
		}
 
		if (!file->writeToDir(dir, this, includedir, Utils::String::Null(), data, len))
			return false;
 
		return true;
 
	}
	else
		return false;
}
bool CBaseFile::extractFile(C_File *file, const Utils::String &dir, unsigned int game, const Utils::WStringList &gameAddons, bool includedir, CProgressInfo *progress)
{
	if (ReadFileToMemory(file))
	{
		CDirIO Dir(dir);
		Utils::WString addonDir;
		if (file->isFileInAddon())
		{
			int addonGame = file->getForSingleGame();
			if (!addonGame) addonGame = game;
 
			if (addonGame > 0)
				addonDir = gameAddons.findString(Utils::WString::Number(addonGame));
		}
 
		if (!addonDir.empty())
			Dir.cd(addonDir);
 

	}
	else
		return false;
}
 
bool CBaseFile::extractFile(int filenum, const Utils::String &dir, unsigned int game, const Utils::WStringList &gameAddons, bool includedir, CProgressInfo *progress)
{
	// invalid valus
	if (filenum < 0)
		return false;
	// out of range

 
bool CBaseFile::extractAll(const Utils::String &dir, int game, const Utils::CStringList &gameAddons, bool includedir, CProgressInfo *progress)
{
	// no file to read from
	if (this->filename().empty())
		return false;
 
	// now open the file
	CFileIO *File = _startRead();
	if (!File) return false;
 

	m_bSigned = computeSigned(updateFiles);
	return m_bSigned;
}
 
bool CBaseFile::IsPackageNeeded(const Utils::String &scriptName, const Utils::String &author)
{
	for ( CListNode<SNeededLibrary> *node = m_lNeededLibrarys.Front(); node; node = node->next() )
	{
		SNeededLibrary *l = node->Data();
		if ( l->sName.Compare(scriptName) && l->sAuthor.Compare(author) )
			return true;
	}
 
	return false;
}
 
SNeededLibrary *CBaseFile::FindPackageNeeded(const Utils::String &scriptName, const Utils::String &author)
{
	for ( CListNode<SNeededLibrary> *node = m_lNeededLibrarys.Front(); node; node = node->next() )
	{

		if ( l->sName.Compare(scriptName) && l->sAuthor.Compare(author) )
			return l;
	}
 
	return NULL;
}
 
void CBaseFile::removeFakePatchOrder(const Utils::String &scriptName, const Utils::String &author)
{
	removeFakePatchOrder(true, scriptName, author);
	removeFakePatchOrder(false, scriptName, author);
}
void CBaseFile::removeFakePatchOrder(bool after, const Utils::String &scriptName, const Utils::String &author)
{
	Utils::CStringList *list;
	if ( after )
		list = &_lFakePatchAfter;
	else
		list = &_lFakePatchBefore;
 
	int found = list->findStringAndData(scriptName, author);
	while (found != -1)

void CBaseFile::addFakePatchOrder(bool after, const Utils::String &scriptName, const Utils::String &author)
{
	Utils::CStringList *list;
	if ( after )
		list = &_lFakePatchAfter;
	else
		list = &_lFakePatchBefore;
 
	// check if the package already exists
	if (!list->containsStringAndData(scriptName, author))
	{

		l->sName = scriptName;
		l->sAuthor = author;
		m_lNeededLibrarys.push_back(l);
	}
	l->sMinVersion = minVersion;
}
 
void CBaseFile::RemovePackageNeeded(const Utils::String &scriptName, const Utils::String &author)
{
	SNeededLibrary *l = this->FindPackageNeeded(scriptName, author);
	if ( l )

	for ( CListNode<SNeededLibrary> *node = m_lNeededLibrarys.Front(); node; node = node->next() )
		node->DeleteData();
	m_lNeededLibrarys.clear();
 
	if ( !version.empty() )	this->AddNeededLibrary("<package>", "<author>", version);
}
 
 
bool CBaseFile::GeneratePackagerScript(bool wildcard, Utils::CStringList *list, int game, const Utils::CStringList &gameAddons, bool datafile)
{
	list->pushBack("#");

	if ( datafile )
		list->pushBack("Date: " + this->creationDate());
	else {
		list->pushBack("# $DATE variable is used to get the current date");
		list->pushBack("Date: $DATE");
	}
	list->pushBack("");
	list->pushBack("# The version of script");
	if ( datafile )
		list->pushBack("Version: " + this->version());
	else

		list->pushBack("# The game version the script is for <game> <version> (can have multiple games)");
		for ( SGameCompat *g = m_lGames.First(); g; g = m_lGames.Next() ) {
			if (game > 0 && g->iGame != game)
				continue;
 
			Utils::WString game = CBaseFile::ConvertGameToString(g->iGame);
 
			if ( !g->sVersion.empty() )
			{
				game += L" ";
				game += g->sVersion;
			}
			else
			{
				game += L" ";
				game += (long)g->iVersion;
			}
 
			list->pushBack("Game: " + game.toString());
		}
 
		list->pushBack("");
	}
 

}
 
bool CBaseFile::GeneratePackagerScriptFile(bool wildcard, Utils::CStringList *list, int game, const Utils::CStringList &gameAddons)
{
	// now do files and wildcards
	Utils::WStringList files;
	for ( CListNode<C_File> *f = m_lFiles.Front(); f; f = f->next() )
	{
		if (game && !(f->Data()->game() & 1 << game))
			continue;
 
		Utils::WString name = L"$GAMEDIR/";
 
		// addon directory?
		unsigned int checkGame = f->Data()->game() & ~(1 << 31);
		unsigned int foundGame = 0;
		for (int i = 0; i < 31; ++i)
		{
			if (checkGame == 1 << i)
			{
				foundGame = i;
				break;
			}
		}
 
		if (foundGame)
		{
			Utils::WString str = gameAddons.findString(Utils::String::Number(foundGame));
			if(!str.empty())
				name += str + L"/";
		}
 
		bool done = false;
		if ( wildcard )
		{
			Utils::WString base = f->Data()->baseName();
			if ( f->Data()->fileType() == FILETYPE_SCRIPT )
			{
				if ( base.token(L".", 1).Compare(L"plugin") || base.token(L".", 1).Compare(L"lib") )
				{
					name += f->Data()->getDirectory(this) + "/" + base.tokens(L".", 1, 2) + L".*";
					done = true;
				}
				else if ( base.token(L".", 1).Compare(L"al") && !base.token(L".", 2).Compare(L"plugin") )
				{
					name += f->Data()->getDirectory(this) + L"/" + base.tokens(L".", 1, 2) + L".*";
					done = true;
				}
			}
			else if ( f->Data()->fileType() == FILETYPE_TEXT )
			{
				if ( base.contains(L"-L") )
				{
					name += f->Data()->getDirectory(this) + L"/" + base.token(L&quot;-L", 1) + L"-L*";
					done = true;
				}
				else
				{
					name += f->Data()->getDirectory(this) + L"/*" + base.right(4) + L".*";
					done = true;
				}
			}
		}
 
		if ( !done )
			name += f->Data()->getNameDirectory(this);
 
		if ( !f->Data()->dir().empty() )
		{
			name += L"|";
			name += f->Data()->dir();
		}
		Utils::WString s = L"GAME ";
		if (!f->Data()->game() || f->Data()->game() == GAME_ALLNEW)
			s += CBaseFile::ConvertGameToString(f->Data()->game());
		else
		{
			bool first = true;

					s += CBaseFile::ConvertGameToString(i);
				}
			}
		}
 
		s += L" " + name;
		if(!files.contains(s))
			files.pushBack(s, f->Data()->fileTypeString());
	}
 
 
	if ( !files.empty() )
	{
		list->pushBack("# Files List, all the files to add, can include wild cards");
		for(auto itr = files.begin(); itr != files.end(); itr++)
			list->pushBack((*itr)->data.toString() + ": " + (*itr)->str.toString());
		list->pushBack("");
	}
 
	return true;
}

			return true;
	}
	return false;
}
 
bool CBaseFile::checkGameVersionCompatability(int game, const Utils::WString &sVersion, int iVersion) const
{
	if (m_lGames.empty())
		return true; // no game compatability added, assume its ok for all
 
	bool foundAll = false;

	Found->iGame = game;
	Found->iVersion = -1;
	Found->sVersion = "";
 
	if ( version.isin(".") || !version.isNumber() )
		Found->sVersion = version.toWString();
	else
		Found->iVersion = version.toWString();
	_changed();
}
 
Utils::WString CBaseFile::_replaceFilename(const Utils::WString &fname)
{

	filename = filename.findReplace("L$CDATE", cdate);
	filename = filename.findReplace("L$VERSION", this->version());
 
	return filename;
}
bool CBaseFile::loadPackageData(const Utils::WString &sFirst, const Utils::WString &sRest, const Utils::WString &sMainGame, Utils::WStringList &otherGames, Utils::WStringList &gameAddons, CProgressInfo *progress)
{
	if (sFirst.Compare(L"Name"))					this->setName(sRest.toString());
	else if (sFirst.Compare(L"Author"))				this->setAuthor(sRest.toString());
	else if (sFirst.Compare(L"ScriptName"))			addName(ParseLanguage(sRest.token(L" ";, 1).toString()), sRest.tokens(L" ", 2).toString());
	else if (sFirst.Compare(L"UninstallBefore"))	this->addUninstallText(ParseLanguage(sRest.token(L" ", 1).toString()), true, sRest.tokens(L" ", 2).toString());
	else if (sFirst.Compare(L"UninstallAfter"))		this->addUninstallText(ParseLanguage(sRest.token(L" ", 1).toString()), false, sRest.tokens(L" ", 2).toString());
	else if (sFirst.Compare(L"InstallBefore"))		this->addInstallText(ParseLanguage(sRest.token(L" ", 1).toString()), true, sRest.tokens(L" ", 2).toString());
	else if (sFirst.Compare(L"InstallAfter"))		this->addInstallText(ParseLanguage(sRest.token(L" ", 1).toString()), false, sRest.tokens(L" ", 2).toString());
	else if (sFirst.Compare(L"Date"))				this->setCreationDate(sRest.toString());
	else if (sFirst.Compare(L"Version"))			this->setVersion(sRest.toString());
	else if (sFirst.Compare(L"GameVersion"))
		this->AddGameCompatability(-1, sRest.toString());
	else if (sFirst.Compare(L"PluginType")) {
		if (sRest.isNumber())						this->setPluginType(sRest);
		else if (sRest.Compare(L"Normal"))			this->setPluginType(PLUGIN_NORMAL);
		else if (sRest.Compare(L"Stable"))			this->setPluginType(PLUGIN_STABLE);
		else if (sRest.Compare(L"Experimental"))	this->setPluginType(PLUGIN_EXPERIMENTAL);
		else if (sRest.Compare(L"Cheat"))			this->setPluginType(PLUGIN_CHEAT);
		else if (sRest.Compare(L"Mod"))				this->setPluginType(PLUGIN_MOD);
	}
	// new version
	else if (sFirst.Compare(L"GenerateUpdateFile"))
		m_bAutoGenerateUpdateFile = true;
	else if (sFirst.Compare(L"Game"))
	{
		Utils::WString sGame = sRest.token(L" ", 1);
		this->AddGameCompatability(CBaseFile::GetGameFromString(sGame.toString()), sRest.token(L" ", 2).toString());
	}
	else if (sFirst.Compare(L"Description"))		this->setDescription(sRest.toString());
	else if (sFirst.Compare(L"AutoSave") || sFirst.Compare(L"AutoExport") || sFirst.Compare(L"AutoRarExport") || sFirst.Compare(L"AutoZipExport"))
	{
		Utils::WString filename = _replaceFilename(sRest);
 
		if (sFirst.Compare(L"AutoZipExport") || sFirst.Compare(L"AutoExport"))
			this->setExportFilename(CFileIO(filename).changeFileExtension(L"zip").toString());
		else if (sFirst.Compare(L"AutoRarExport"))
			this->setExportFilename(CFileIO(filename).changeFileExtension(L"rar").toString());
		else
			this->setFilename(filename);
	}
	else if (sFirst.Compare(L"WebSite"))		this->setWebSite(sRest.toString());
	else if (sFirst.Compare(L"ForumLink") || sFirst.Compare("Forum")) this->setForumLink(sRest.toString());
	else if (sFirst.Compare(L"Email"))			this->setEmail(sRest.toString());
	else if (sFirst.Compare(L"WebAddress"))		this->setWebAddress(sRest.toString());
	else if (sFirst.Compare(L"WebMirror"))
		this->addWebMirror(sRest.toString());
	else if (sFirst.Compare(L"WebMirror1"))
		this->addWebMirror(sRest.toString());
	else if (sFirst.Compare(L"WebMirror2"))
		this->addWebMirror(sRest.toString());
	else if (sFirst.Compare(L"Ftp"))
		_sFtpAddr = sRest.toString();
	else if (sFirst.Compare(L"Ratings"))		_setRatings(sRest.token(L" ", 1), sRest.token(L" ", 2), sRest.token(L" ", 3));
	else if (sFirst.Compare(L"EaseOfUse"))		setEaseOfUse(sRest);
	else if (sFirst.Compare(L"GameChanging"))	setGameChanging(sRest);
	else if (sFirst.Compare(L"Recommended"))	setRecommended(sRest);
	else if (sFirst.Compare(L"Depend"))
	{
		Utils::WString version = sRest.token(L"|", 2);
		Utils::WString name = sRest.token(L"|", 1);
		Utils::WString author = sRest.tokens(L"|", 3);
 
		this->AddNeededLibrary(name.toString(), author.toString(), version.toString());
	}
	else if (sFirst.Compare(L"DependPackage"))
	{
		CPackages p;
		CBaseFile *spk = p.openPackage(sRest, 0, 0, SPKREAD_VALUES);
		if (spk)
		{
			this->AddNeededLibrary(spk->name(), spk->author(), spk->version());
			delete spk;
		}
	}
	else if (sFirst.Compare(L"Icon"))
	{
		C_File *icon = new C_File(sRest);
		if (icon->ReadFromFile())
			this->setIcon(icon, CFileIO(sRest).extension().toString());
	}
	else if (sFirst.Compare(L"CombineGameFiles"))
		_bCombineFiles = sRest.Compare(L"true") || sRest.Compare(L"yes") || sRest.toInt();
	else if (sFirst.Compare(L"UpdateFile"))
		this->createUpdateFile(sRest);
	else if (sFirst.Compare(L"ExportZip"))
	{
		Utils::WString ext = L"zip";
		Utils::WString game = sRest.word(1);
		Utils::WString file = _replaceFilename(CFileIO(sRest.words(2)).fullFilename());
		if (game.contains(L"|"))
		{
 
			std::vector<Utils::WString&gt; games;
			if(game.tokenise(L"|", games))
			{
				for (size_t i = 0; i < games.size(); ++i)
				{
					unsigned int g = CBaseFile::GetGameFromString(games[i].toString());
					Utils::WString filename = CFileIO(file).dir() + L"/" + CFileIO(file).baseName() + L"_" + CBaseFile::ConvertGameToString(g) + L"." + ext;
					this->addAutoExport(g, filename.toString());
				}
 
			}
		}
		else
		{
			unsigned int g = CBaseFile::GetGameFromString(game.toString());
			Utils::WString filename = CFileIO(file).dir() + L"/" + CFileIO(file).baseName() + L"_" + CBaseFile::ConvertGameToString(g) + L"." + ext;
			this->addAutoExport(g, filename.toString());
		}
	}
	else if (sFirst.Compare(L"Extract"))
	{
		Utils::WString game = sRest.word(1);
		Utils::WString dir = CDirIO(sRest.words(2)).dir();
		if (game.contains(L"|"))
		{
 
			std::vector<Utils::WString&gt; games;
			if (game.tokenise(L"|", games))
			{
				for(size_t i = 0; i < games.size(); ++i)
					this->addAutoExtract(CBaseFile::GetGameFromString(games[i].toString()), dir.toString());
 
			}
		}
		else
			this->addAutoExtract(CBaseFile::GetGameFromString(game.toString()), dir.toString());
	}
	else
	{
		Utils::WString checkType = sFirst;
		bool shared = false;
		if (checkType.left(6).Compare(L"Shared"))
		{
			checkType = sFirst.right(-6);
			shared = true;
		}
		bool packed = false;
		if (checkType.right(3).Compare(L"PCK"))
		{
			checkType = sFirst.left(-3);
			packed = true;
		}
 
		// now check type name
		FileType filetype = GetFileTypeFromString(checkType);
		if (filetype != FILETYPE_UNKNOWN)
			this->addFileScript(filetype, shared, packed, sRest, sMainGame, otherGames, gameAddons, progress);
		else if ( !checkType.Compare("changelog") )
			return false;
	}
 
	return true;
}
 
void CBaseFile::addFileScript(FileType filetype, bool shared, bool packed, const Utils::WString &sRest, const Utils::WString &sMainGame, Utils::WStringList &otherGames, Utils::WStringList &gameAddons, CProgressInfo *progress)
{
	Utils::WString dir;
	Utils::WString rest = sRest;
 
	unsigned int mainGame = CBaseFile::GetGameFromString(sMainGame.toString());
	unsigned int game = 0;
	if ( rest.token(L" ", 1).left(4).Compare(L"GAME") ) {
		Utils::WString gameStr = rest.token(L" ", 2);
		if (gameStr.contains(L"|"))
		{
			std::vector<Utils::WString> games;
			gameStr.tokenise(L"|";, games);
			for (size_t i = 0; i < games.size(); ++i)
			{
				unsigned int g = CBaseFile::GetGameFromString(games[i].toString());
				if (g)
					game |= 1 << g;
			}
 
		}
		else
		{
			unsigned int g = CBaseFile::GetGameFromString(gameStr.toString());
			if (g)
				game = 1 << g;
		}
		rest = rest.tokens(L" ", 3);
	}
	if (game)
		game |= 1 << 31;
 
	if (rest.contains(L"|"))
	{
		dir = rest.tokens(L"|", 2);
		rest = rest.token(L"|", 1);
	}
 
	rest = rest.findReplace(L"\\", L"/");
 
	// wild cards
	if ( rest.containsAny(L"*?") )
	{
		CDirIO Dir(CFileIO(rest).dir());
		Utils::WStringList dirList;
		if(Dir.dirList(dirList))
		{
			for(auto itr = dirList.begin(); itr != dirList.end(); itr++)
			{
				Utils::WString file = Dir.file((*itr)->str);

				{
					int addGame = game;
					// check if the file exists in the subdirectory too, if it does, add for each game
					if ( game == GAME_ALL && !sMainGame.empty() && !otherGames.empty() ) {
						CFileIO F(file);
						for(Utils::WString g = otherGames.firstString(); !g.empty(); g = otherGames.nextString()) {
							Utils::WString checkDir = F.dir() + L"/" + g;
							if ( CDirIO(checkDir).exists(F.filename()) ) {
								addGame = mainGame;
								C_File *newfile = this->appendFile(CDirIO(checkDir).file(F.filename()), filetype, CBaseFile::GetGameFromString(g.toString()), packed, dir);
								if (newfile && progress)
									progress->UpdateFile(newfile);
								if ( newfile ) newfile->SetShared(shared);
							}
						}
					}
 
					C_File *newfile = this->appendFile(file, filetype, addGame, packed, dir);
					if (newfile && progress)
						progress->UpdateFile(newfile);
					if ( newfile )
						newfile->SetShared(shared);
				}

	{
		unsigned int addGame = game;
		// check if the file exists in the subdirectory too, if it does, add for each game
		if ( game == GAME_ALL && !sMainGame.empty() && !otherGames.empty() ) {
			CFileIO F(rest);
			for(Utils::WString g = otherGames.firstString(); !g.empty(); g = otherGames.nextString()) {
				Utils::WString checkDir = F.dir() + L"/" + g;
				if ( CDirIO(checkDir).exists(F.filename()) ) {
					addGame = mainGame;
					C_File *newfile = this->appendFile(CDirIO(checkDir).file(F.filename()), filetype, CBaseFile::GetGameFromString(g.toString()), packed, dir);
					if (newfile && progress)
						progress->UpdateFile(newfile);
					if ( newfile ) newfile->SetShared(shared);
				}
			}

		}
 
		C_File *file = NULL;
		if (foundGame)
		{
			Utils::WString addon = gameAddons.findString(Utils::WString::Number(foundGame));
			if (!addon.empty())
			{
				Utils::WString dir = C_File::GetDirectory(filetype, rest, this);
				Utils::WString filename = rest;
				if (CCatFile::IsAddonDir(dir) && !filename.contains(addon))
				{
					filename = filename.findReplace(dir + L"/", addon + L"/" + dir + L"/");
					file = this->appendFile(filename, filetype, addGame, packed, dir);
				}
			}
		}
 

			file->SetShared(shared);
	}
}
 
 
Utils::WString CBaseFile::fileSizeString() const { return SPK::GetSizeString ( this->fileSize() ); }
 
// used for a multiple spk file
unsigned char *CBaseFile::createData(size_t *size, CProgressInfo *progress)
{
	if ( this->writeFile("temp.dat", progress) ) {
		CFileIO File(L"temp.dat");
		File.setAutoDelete(true);
		return File.readAll(size);
	}
	return NULL;
}

	f->changeBaseName(to);
}
 
void CBaseFile::convertAutoText(C_File *f) const
{
	Utils::WString to;
	if ( f->baseName().contains(L"-L") )
		to = L";0000-L" + f->baseName().token(L"-L", 2);
	else if ( f->baseName().contains("-l") )
		to = L";0000-L" + f->baseName().token(L"-l", 2);
	else
		to = f->baseName().left(-4) + L"0000";
 
	// file link
	if ( !f->GetData() )
		f->ReadFromFile();
 

	_changed(); 
}
 
Utils::WString CBaseFile::createUpdateFile(const Utils::WString &dir) const
{
	Utils::WString file = this->getNameValidFile() + L"_" + this->author().toWString() + L".dat";
	file.removeChar(' ');
 
	Utils::CStringList write;
	write.pushBack("Package: " + this->name());
	write.pushBack("Author: " + this->author());
	write.pushBack("Version: " + this->version());
	write.pushBack("File: " + CFileIO(this->filename()).filename().toString());
 
	CFileIO File(dir + L"/" + file);
	if (File.writeFile(&write))
		return File.fullFilename();
	return Utils::WString::Null();
}
 
Utils::WString CBaseFile::ErrorString(int error, const Utils::WString &errorStr)
{
	if (error == SPKERR_NONE) return Utils::WString::Null();
 
	Utils::WString err;
 
	switch (error)
	{
	case SPKERR_MALLOC:
		err = L"Memory Failed";
		break;
	case SPKERR_FILEOPEN:
		err = L"Failed to open file";
		break;
	case SPKERR_FILEREAD:
		err = L"Failed to read file";
		break;
	case SPKERR_UNCOMPRESS:
		err = L"Failed to Uncompress";
		break;
	case SPKERR_WRITEFILE:
		err = L"Failed to write file";
		break;
	case SPKERR_CREATEDIRECTORY:
		err = L"Failed to create directory";
		break;
	case SPKERR_FILEMISMATCH:
		err = L"File count mismatch";
		break;
	}
 
	if (!err.empty())
	{
		if (!errorStr.empty())
		{
			err += L" (";
			err += errorStr + L")";
		}
		return err;
	}
 
	return Utils::WString::Number((long)error);
}
 
bool CBaseFile::saveToArchive(const Utils::String &filename, int game, const CGameExe *exes, CProgressInfo *progress)
{
	CDirIO Dir(CFileIO(filename).dir());

				continue;
			// extracting for all games, so ignore files that have a game set
			if (!game && node->Data()->game() && node->Data()->game() != GAME_ALLNEW)
				continue;
		}
		Utils::WString fname = node->Data()->getNameDirectory(this);
 
		// use the addon directory
		if (node->Data()->isFileInAddon() && exes)
		{
			unsigned int whatGame = game;

				}
			}
 
			if (whatGame > 0)
			{
				SGameExe *e = exes->game(whatGame - 1);
				if (e)
				{
					if (e->iFlags & EXEFLAG_ADDON)
						fname = e->sAddon + L"/" + fname;
				}
			}
		}
 
		// create the directory
		//wsprintf(buf, L"%hs", fname.c_str());
		if (node->Data()->isExternalFile())
		{
			CFileIO file(node->Data()->filePointer());
			size_t size = 0;
			unsigned char *data = file.readAll(&size);
			ZipAdd(hz, fname.c_str(), data, size);
			delete data;
		}
		else
			ZipAdd(hz, fname.c_str(), node->Data()->GetData(), node->Data()->GetDataSize());
	}
 
	// if its a ship, then add any generated files
	this->addGeneratedFiles(hz);
 

		iGame = sGame;
 
	return iGame;
}
 
Utils::WString CBaseFile::ConvertGameToString(int iGame)
{
	Utils::WString game = L"ALL";
 
	switch(iGame) {
		case GAME_ALL:
		case GAME_ALLNEW:
			game = L"ALL";
			break;
		case GAME_X2:
			game = L"X2";
			break;
		case GAME_X3:
			game = L"X3";
			break;
		case GAME_X3TC:
			game = L"X3TC";
			break;
		case GAME_X3AP:
			game = L"X3AP";
			break;
		case GAME_X3FL:
			game = L"X3FL";
			break;
		default:
			game = (long)iGame;
	}
 

	str += "28;0;0;0;0;90;15093;0;105;1;5;0;105;0;1043;0;SS_WARE_SW_X3TC_6;\n";
 
	return str;
}
 
void CBaseFile::_addWaresToList(int iLang, CLinkList<SWareEntry> &list, const Utils::WString &wares, enum WareTypes eType)
{
	std::vector<Utils::WString> w;
	wares.tokenise(L"\n";, w);
	
	for(size_t i = 0; i < w.size(); i++) {
		int textId = w[i].token(L";", 7).toLong();
		int useLang = iLang;
		if ( !_pTextDB->exists(useLang, 17, textId) )
			useLang = 44;
		if ( !_pTextDB->exists(useLang, 17, textId) )
			useLang = 49;
		if ( _pTextDB->exists(useLang, 17, textId) ) {	
			SWareEntry *ware = new SWareEntry;
			ware->name = _pTextDB->get(useLang, 17, textId);
			ware->description = _pTextDB->get(useLang, 17, textId + 1);
			ware->id = w[i].token(L";", -2);
			ware->relval = w[i].token(L";", 9).toLong();
			ware->notority = w[i].token(L";", 14).toLong();
			ware->type = eType;
			ware->position = i;
			ware->package = this;
			list.push_back(ware);
		}
	}
 
 
}
 
bool CBaseFile::readWares(int iLang, CLinkList<SWareEntry> &list, const Utils::WString &empWares)
{
	_pTextDB->setLanguage(iLang);
 
	// now go through all emp wares and get the ones we have text for
	_addWaresToList(iLang, list, empWares, Ware_EMP);

Rev 196	Rev 197
Line 193...	Line 193...
193	`}`	193	`}`
194		194
195	`return NULL;`	195	`return NULL;`
196	`}`	196	`}`
197		197
198	`int CBaseFile::CheckFile(const Utils::String &filename, float *version )`	198	`int CBaseFile::CheckFile(const Utils::WString &filename, float *version )`
199	`{`	199	`{`
200	`CFileIO File(filename);`	200	`CFileIO File(filename);`
201	`if ( !File.startRead() ) return 0;`	201	`if ( !File.startRead() ) return 0;`
202	`Utils::String line = File.readEndOfLine();`	202	`Utils::String line = File.readEndOfLineStr();`
203	`Utils::String type = line.token(";", 1);`	203	`Utils::String type = line.token(";", 1);`
204	`File.close();`	204	`File.close();`
205		205
206	`// check for old version`	206	`// check for old version`
207	`if ( line.left(3) == "HiP" ) return SPKFILE_OLD;`	207	`if ( line.left(3) == "HiP" ) return SPKFILE_OLD;`
Line 222...	Line 222...
222	`{`	222	`{`
223	`f->Data()->DeleteData();`	223	`f->Data()->DeleteData();`
224	`}`	224	`}`
225	`}`	225	`}`
226		226
227	`Utils::String CBaseFile::getNameValidFile() const`	227	`Utils::WString CBaseFile::getNameValidFile() const`
228	`{`	228	`{`
229	`Utils::String name = this->name();`	229	`Utils::WString name = this->name();`
230	`name.removeChar(':');`	230	`name.removeChar(':');`
231	`name.removeChar('/');`	231	`name.removeChar('/');`
232	`name.removeChar('\\');`	232	`name.removeChar('\\');`
233	`name.removeChar('*');`	233	`name.removeChar('*');`
234	`name.removeChar('?');`	234	`name.removeChar('?');`
Line 283...	Line 283...
283	`}`	283	`}`
284		284
285	`_addFile(file);`	285	`_addFile(file);`
286	`}`	286	`}`
287		287
288	`C_File *CBaseFile::addFile(const Utils::String &file, const Utils::String &dir, FileType type, int game, bool packed)`	288	`C_File *CBaseFile::addFile(const Utils::WString &file, const Utils::WString &dir, FileType type, int game, bool packed)`
289	`{`	289	`{`
290	`C_File *newfile = new C_File(file);`	290	`C_File *newfile = new C_File(file);`
291	`newfile->setDir(dir);`	291	`newfile->setDir(dir);`
292	`newfile->setFileType(type);`	292	`newfile->setFileType(type);`
293	`newfile->setGame(game);`	293	`newfile->setGame(game);`
294		294
295	`if (packed)`	295	`if (packed)`
296	`{`	296	`{`
297	`if (newfile->PCKFile())`	297	`if (newfile->PCKFile())`
298	`{`	-
299	`newfile->setFilename(CFileIO(newfile->filePointer()).changeFileExtension(L"pck").toString());`	298	`newfile->setFilename(CFileIO(newfile->filePointer()).changeFileExtension(L"pck"));`
300	`}`	-
301	`}`	299	`}`
302		300
303	`// first check if the file already exists`	301	`// first check if the file already exists`
304	`for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )`	302	`for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )`
305	`{`	303	`{`
306	`C_File *f = node->Data();`	304	`C_File *f = node->Data();`
307	`if ( f->fileType() != newfile->fileType() )`	305	`if ( f->fileType() != newfile->fileType() )`
308	`continue;`	306	`continue;`
309	`if ( f->name() != newfile->name () )`	307	`if ( f->name() != newfile->name () )`
310	`continue;`	308	`continue;`
311	`if ( f->dir() != newfile->dir() )`	309	`if ( f->dir() != newfile->dir() )`
312	`continue;`	310	`continue;`
313	`if (f->game() != newfile->game())`	311	`if (f->game() != newfile->game())`
314	`{`	312	`{`
315	`//same file, for different game, check if they are the same and combine them`	313	`//same file, for different game, check if they are the same and combine them`
Line 339...	Line 337...
339	`if (data[i] != newData[i])`	337	`if (data[i] != newData[i])`
340	`{`	338	`{`
341	`matched = false;`	339	`matched = false;`
342	`break;`	340	`break;`
343	`}`	341	`}`
344	`}`	342	`}`
345	`}`	343	`}`
346		344
347	`if (data)`	345	`if (data)`
348	`delete data;`	346	`delete data;`
349	`if (newData)`	347	`if (newData)`
350	`delete newData;`	348	`delete newData;`
351		349
Line 359...	Line 357...
359	`break;`	357	`break;`
360	`}`	358	`}`
361	`}`	359	`}`
362	`continue;`	360	`continue;`
363	`}`	361	`}`
364		362
365	`// must already exist, delete this one`	363	`// must already exist, delete this one`
366	`m_lFiles.remove(node, true);`	364	`m_lFiles.remove(node, true);`
367	`break;`	365	`break;`
368	`}`	366	`}`
369		367
370	`_addFile(newfile);`	368	`_addFile(newfile);`
371		369
372	`return newfile;`	370	`return newfile;`
373	`}`	371	`}`
374		372
Line 380...	Line 378...
380		378
381	`// compress the file`	379	`// compress the file`
382	`return f->CompressData(m_SHeader2.iDataCompression, progress);`	380	`return f->CompressData(m_SHeader2.iDataCompression, progress);`
383	`}`	381	`}`
384		382
385	`C_File CBaseFile::appendFile(const Utils::String &file, int type, int game, bool packed, const Utils::String &dir, CProgressInfo progress )`	383	`C_File CBaseFile::appendFile(const Utils::WString &file, int type, int game, bool packed, const Utils::WString &dir, CProgressInfo progress )`
386	`{`	384	`{`
387	`C_File *newfile = addFile(file, dir, static_cast<FileType>(type), game, packed);`	385	`C_File *newfile = addFile(file, dir, static_cast<FileType>(type), game, packed);`
388	`if ( !newfile )`	386	`if ( !newfile )`
389	`return NULL;`	387	`return NULL;`
390		388
391	`// read the file into memory`	389	`// read the file into memory`
392	`if (newfile->GetData() && newfile->GetDataSize())`	390	`if (newfile->GetData() && newfile->GetDataSize())`
393	`{`	391	`{`
394	`// now compress the file`	392	`// now compress the file`
395	`if (newfile->CompressData(m_SHeader2.iDataCompression, progress))`	393	`if (newfile->CompressData(m_SHeader2.iDataCompression, progress))`
396	`return newfile;`	394	`return newfile;`
397	`}`	395	`}`
398	`if ( newfile->ReadFromFile () )`	396	`if ( newfile->ReadFromFile () )`
Line 429...	Line 427...
429	`}`	427	`}`
430		428
431	`return NULL;`	429	`return NULL;`
432	`}`	430	`}`
433		431
434	`C_File* CBaseFile::findFile(const Utils::String &filename, FileType type, const Utils::String &dir, int game) const`	432	`C_File* CBaseFile::findFile(const Utils::WString &filename, FileType type, const Utils::WString &dir, int game) const`
435	`{`	433	`{`
436	`Utils::String lfile = CFileIO(filename.lower()).filename().toString();`	434	`Utils::WString lfile = CFileIO(filename.lower()).filename();`
437		435
438	`CListNode<C_File>* node = m_lFiles.Front();`	436	`CListNode<C_File>* node = m_lFiles.Front();`
439	`while (node)`	437	`while (node)`
440	`{`	438	`{`
441	`C_File* f = node->Data();`	439	`C_File* f = node->Data();`
Line 482...	Line 480...
482	`C_File *file = m_lFiles.Get ( pos );`	480	`C_File *file = m_lFiles.Get ( pos );`
483	`m_lFiles.erase ( pos + 1 );`	481	`m_lFiles.erase ( pos + 1 );`
484		482
485	`if ( file )`	483	`if ( file )`
486	`delete file;`	484	`delete file;`
487		485
488	`_changed();`	486	`_changed();`
489		487
490	`return true;`	488	`return true;`
491	`}`	489	`}`
492		490
493		491
494	`void CBaseFile::removeAllFiles(FileType type, int game)`	492	`void CBaseFile::removeAllFiles(FileType type, int game)`
495	`{`	493	`{`
496	`if ( m_lFiles.empty() )`	494	`if ( m_lFiles.empty() )`
497	`return;`	495	`return;`
498		496
499	`for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )`	497	`for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )`
500	`{`	498	`{`
501	`if (game == 0 && node->Data()->game() && node->Data()->game() != GAME_ALLNEW)`	499	`if (game == 0 && node->Data()->game() && node->Data()->game() != GAME_ALLNEW)`
502	`continue;`	500	`continue;`
503	`if ( game > -1 )`	501	`if ( game > -1 )`
Line 527...	Line 525...
527	`C_File *file = node->Data();`	525	`C_File *file = node->Data();`
528	`if ( progress )`	526	`if ( progress )`
529	`progress->UpdateFile(file);`	527	`progress->UpdateFile(file);`
530		528
531	`if ( file->GetCompressionType() == type )`	529	`if ( file->GetCompressionType() == type )`
532	`continue;`	530	`continue;`
533		531
534	`if ( !file->GetData() )`	532	`if ( !file->GetData() )`
535	`file->ReadFromFile();`	533	`file->ReadFromFile();`
536		534
537	`file->ChangeCompression ( type, progress );`	535	`file->ChangeCompression ( type, progress );`
538	`}`	536	`}`
Line 664...	Line 662...
664	`Return: String - returns the full string for files list`	662	`Return: String - returns the full string for files list`
665	`Desc: Creates a signle line list of all the files`	663	`Desc: Creates a signle line list of all the files`
666	`*/`	664	`*/`
667	`Utils::String CBaseFile::createFilesLine(SSPKHeader2 header, CProgressInfo progress) const`	665	`Utils::String CBaseFile::createFilesLine(SSPKHeader2 header, CProgressInfo progress) const`
668	`{`	666	`{`
669	`Utils::String line;`	667	`Utils::WString line;`
670		668
671	`if (progress)`	669	`if (progress)`
672	`{`	670	`{`
673	`progress->SetDone(0);`	671	`progress->SetDone(0);`
674	`progress->UpdateStatus(STATUS_COMPRESS);`	672	`progress->UpdateStatus(STATUS_COMPRESS);`
675	`}`	673	`}`
676		674
677	`if (header)`	675	`if (header)`
Line 691...	Line 689...
691		689
692	`// compress the file`	690	`// compress the file`
693	`if (!m_pIconFile->CompressData(m_SHeader2.iDataCompression, progress))`	691	`if (!m_pIconFile->CompressData(m_SHeader2.iDataCompression, progress))`
694	`m_pIconFile->SetDataCompression(SPKCOMPRESS_NONE);`	692	`m_pIconFile->SetDataCompression(SPKCOMPRESS_NONE);`
695		693
696	`line += "Icon:" + Utils::String::Number(m_pIconFile->GetDataSize() + (long)4) + ":" + m_pIconFile->uncompressedDataSize() + ":" + (long)m_pIconFile->GetCompressionType() + ":" + _sIconExt + "\n";`	694	`line += L"Icon:" + Utils::WString::Number(m_pIconFile->GetDataSize() + (long)4) + L":" + m_pIconFile->uncompressedDataSize() + L":" + (long)m_pIconFile->GetCompressionType() + L":" + _sIconExt + L"\n";`
697	`if (header)`	695	`if (header)`
698	`{`	696	`{`
699	`++header->iNumFiles;`	697	`++header->iNumFiles;`
700	`header->lFullSize += (m_pIconFile->GetDataSize() + 4);`	698	`header->lFullSize += (m_pIconFile->GetDataSize() + 4);`
701	`}`	699	`}`
Line 728...	Line 726...
728	`{`	726	`{`
729	`file->SetDataCompression(SPKCOMPRESS_NONE);`	727	`file->SetDataCompression(SPKCOMPRESS_NONE);`
730	`file->SetUncompressedDataSize(file->GetDataSize());`	728	`file->SetUncompressedDataSize(file->GetDataSize());`
731	`}`	729	`}`
732		730
733	`Utils::String command = GetFileTypeString(file->GetFileType());`	731	`Utils::WString command = GetFileTypeString(file->GetFileType());`
734	`if (command.empty())`	732	`if (command.empty())`
735	`continue;`	733	`continue;`
736		734
737	`if (file->IsShared())`	735	`if (file->IsShared())`
738	`command = "$" + command;`	736	`command = L"$" + command;`
739		737
740	`if (file->dir().empty())`	738	`if (file->dir().empty())`
741	`line += command + ":" + (file->GetDataSize() + (long)4) + ":" + file->uncompressedDataSize() + ":" + (long)file->GetCompressionType() + ":" + (long)file->GetCreationTime() + ":" + ((file->IsCompressedToFile()) ? "1" : "0") + ":" + file->filename() + ":NULL:" + (long)file->game() + "\n";`	739	`line += command + L":" + (file->GetDataSize() + (long)4) + L":" + file->uncompressedDataSize() + L":" + (long)file->GetCompressionType() + L":" + (long)file->GetCreationTime() + L":" + ((file->IsCompressedToFile()) ? L"1" : L"0") + L":" + file->filename() + L":NULL:" + (long)file->game() + L"\n";`
742	`else`	740	`else`
743	`line += command + ":" + (file->GetDataSize() + (long)4) + ":" + file->uncompressedDataSize() + ":" + (long)file->GetCompressionType() + ":" + (long)file->GetCreationTime() + ":" + ((file->IsCompressedToFile()) ? "1" : "0") + ":" + file->filename() + ":" + file->dir() + ":" + (long)file->game() + "\n";`	741	`line += command + L":" + (file->GetDataSize() + (long)4) + L":" + file->uncompressedDataSize() + L":" + (long)file->GetCompressionType() + L":" + (long)file->GetCreationTime() + L":" + ((file->IsCompressedToFile()) ? L"1" : L"0") + L":" + file->filename() + L":" + file->dir() + L":" + (long)file->game() + L"\n";`
744		742
745	`if (header)`	743	`if (header)`
746	`{`	744	`{`
747	`++header->iNumFiles;`	745	`++header->iNumFiles;`
748	`header->lFullSize += (file->GetDataSize() + 4);`	746	`header->lFullSize += (file->GetDataSize() + 4);`
749	`}`	747	`}`
750	`}`	748	`}`
751		749
752	`return line;`	750	`return line.toString();`
753	`}`	751	`}`
754		752
755	`/*`	753	`/*`
756	`######################################################################################`	754	`######################################################################################`
757	`########## Reading Functions ##########`	755	`########## Reading Functions ##########`
Line 766...	Line 764...
766	`// now open the file`	764	`// now open the file`
767	`CFileIO File(this->filename());`	765	`CFileIO File(this->filename());`
768	`if ( !File.startRead() ) return;`	766	`if ( !File.startRead() ) return;`
769		767
770	`// read the header`	768	`// read the header`
771	`File.readEndOfLine();`	769	`File.readEndOfLineStr();`
772	`// skip past values`	770	`// skip past values`
773	`File.seek(4 + m_SHeader.lValueCompressSize);`	771	`File.seek(4 + m_SHeader.lValueCompressSize);`
774		772
775	`// read the next header`	773	`// read the next header`
776	`File.readEndOfLine();`	774	`File.readEndOfLineStr();`
777	`// skip past files`	775	`// skip past files`
778	`File.seek(4 + m_SHeader2.lSize);`	776	`File.seek(4 + m_SHeader2.lSize);`
779		777
780	`if ( m_pIconFile )`	778	`if ( m_pIconFile )`
781	`{`	779	`{`
Line 829...	Line 827...
829	`// now open the file`	827	`// now open the file`
830	`CFileIO *File = new CFileIO(this->filename());`	828	`CFileIO *File = new CFileIO(this->filename());`
831	`if ( !File->startRead() ) return NULL;`	829	`if ( !File->startRead() ) return NULL;`
832		830
833	`// read the header`	831	`// read the header`
834	`File->readEndOfLine();`	832	`File->readEndOfLineStr();`
835	`// skip past values`	833	`// skip past values`
836	`File->seek(4 + m_SHeader.lValueCompressSize);`	834	`File->seek(4 + m_SHeader.lValueCompressSize);`
837		835
838	`// read the next header`	836	`// read the next header`
839	`File->readEndOfLine();`	837	`File->readEndOfLineStr();`
840	`// skip past files`	838	`// skip past files`
841	`File->seek(4 + m_SHeader2.lSize);`	839	`File->seek(4 + m_SHeader2.lSize);`
842		840
843	`return File;`	841	`return File;`
844	`}`	842	`}`
Line 855...	Line 853...
855	`}`	853	`}`
856		854
857	`void CBaseFile::_updateTextDB(C_File *file)`	855	`void CBaseFile::_updateTextDB(C_File *file)`
858	`{`	856	`{`
859	`if ( !_pTextDB ) _pTextDB = new CTextDB();`	857	`if ( !_pTextDB ) _pTextDB = new CTextDB();`
860		858
861	`if ( file->GetFileType() == FILETYPE_TEXT ) {`	859	`if ( file->GetFileType() == FILETYPE_TEXT ) {`
862	`Utils::WString baseFile = CFileIO(file->filePointer()).baseName();`	860	`Utils::WString baseFile = CFileIO(file->filePointer()).baseName();`
863	`int lang = (baseFile.contains(L"-L")) ? baseFile.right(3) : baseFile.truncate(-4);`	861	`int lang = (baseFile.contains(L"-L")) ? baseFile.right(3) : baseFile.truncate(-4);`
864		862
865	`// read in the text file to the database`	863	`// read in the text file to the database`
Line 876...	Line 874...
876	`_updateTextDB(node->Data());`	874	`_updateTextDB(node->Data());`
877	`}`	875	`}`
878	`}`	876	`}`
879		877
880	`void CBaseFile::ReadIconFileToMemory ()`	878	`void CBaseFile::ReadIconFileToMemory ()`
881	`{`	879	`{`
882	`if ( !m_pIconFile ) return;`	880	`if ( !m_pIconFile ) return;`
883	`CFileIO *File = _startRead();`	881	`CFileIO *File = _startRead();`
884	`if ( !File ) return;`	882	`if ( !File ) return;`
885		883
886	`if ( (!m_pIconFile->GetData()) && (!m_pIconFile->Skip()) )`	884	`if ( (!m_pIconFile->GetData()) && (!m_pIconFile->Skip()) )`
Line 891...	Line 889...
891	`delete File;`	889	`delete File;`
892	`}`	890	`}`
893		891
894	`void CBaseFile::_install_adjustFakePatches(CPackages *pPackages)`	892	`void CBaseFile::_install_adjustFakePatches(CPackages *pPackages)`
895	`{`	893	`{`
896	`Utils::CStringList lPatches;`	894	`Utils::WStringList lPatches;`
897	`int startfake = pPackages->findNextFakePatch();`	895	`int startfake = pPackages->findNextFakePatch();`
898		896
899	`for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )`	897	`for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )`
900	`{`	898	`{`
901	`C_File *fit = node->Data();`	899	`C_File *fit = node->Data();`
902	`// only do fake patchs`	900	`// only do fake patchs`
903	`if ( !fit->IsFakePatch() )`	901	`if ( !fit->IsFakePatch() )`
904	`continue;`	902	`continue;`
905		903
906	`// we should only have cat and dat files, but lets check just incase they have been added incorrectly`	904	`// we should only have cat and dat files, but lets check just incase they have been added incorrectly`
907	`if ( !fit->checkFileExt ("cat") && !fit->checkFileExt("dat") )`	905	`if ( !fit->checkFileExt ("cat") && !fit->checkFileExt("dat") )`
908	`continue;`	906	`continue;`
909		907
910	`// search for the name on the list`	908	`// search for the name on the list`
911	`Utils::String newname;`	909	`Utils::WString newname;`
912	`bool isOpposite = false;`	910	`bool isOpposite = false;`
913	`if (lPatches.contains(fit->baseName()))`	911	`if (lPatches.contains(fit->baseName()))`
914	`{`	912	`{`
915	`newname = lPatches.findString(fit->baseName());`	913	`newname = lPatches.findString(fit->baseName());`
916	`isOpposite = true;`	914	`isOpposite = true;`
917	`}`	915	`}`
918	`else`	916	`else`
919	`{`	917	`{`
920	`newname = Utils::String::PadNumber((long)startfake, 2);`	918	`newname = Utils::WString::PadNumber((long)startfake, 2);`
921	`lPatches.pushBack(fit->baseName(), newname);`	919	`lPatches.pushBack(fit->baseName(), newname);`
922	`}`	920	`}`
923		921
924	`// rename the file`	922	`// rename the file`
925	`fit->FixOriginalName();`	923	`fit->FixOriginalName();`
Line 939...	Line 937...
939	`for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {`	937	`for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {`
940	`C_File *fit = node->Data();`	938	`C_File *fit = node->Data();`
941	`if ( !fit->isAutoTextFile() )`	939	`if ( !fit->isAutoTextFile() )`
942	`continue;`	940	`continue;`
943		941
944	`Utils::String newname = SPK::FormatTextName(starttext, pPackages->GetLanguage(), (pPackages->GetCurrentGameFlags() & EXEFLAG_TCTEXT));`	942	`Utils::WString newname = SPK::FormatTextName(starttext, pPackages->GetLanguage(), (pPackages->GetCurrentGameFlags() & EXEFLAG_TCTEXT));`
945	`fit->FixOriginalName();`	943	`fit->FixOriginalName();`
946	`CLog::logf(CLog::Log_Install, 2, "Adjusting text file, %s => %s", fit->getNameDirectory(this).c_str(), (newname + "." + fit->fileExt()).c_str());`	944	`CLog::logf(CLog::Log_Install, 2, "Adjusting text file, %s => %s", fit->getNameDirectory(this).c_str(), (newname + "." + fit->fileExt()).c_str());`
947	`fit->setName(newname + "." + fit->fileExt());`	945	`fit->setName(newname + "." + fit->fileExt());`
948		946
949	`++starttext;`	947	`++starttext;`
Line 965...	Line 963...
965	`}`	963	`}`
966		964
967	`return bEnable;`	965	`return bEnable;`
968	`}`	966	`}`
969		967
970	`bool CBaseFile::_install_uncompress(C_File fit, CProgressInfo progress, Utils::CStringList errorStr, bool uncomprToFile)`	968	`bool CBaseFile::_install_uncompress(C_File fit, CProgressInfo progress, Utils::WStringList errorStr, bool uncomprToFile)`
971	`{`	969	`{`
972	`*uncomprToFile = false;`	970	`*uncomprToFile = false;`
973	`_sLastError = fit->getNameDirectory(this);`	971	`_sLastError = fit->getNameDirectory(this);`
974	`_iLastError = SPKERR_UNCOMPRESS;`	972	`_iLastError = SPKERR_UNCOMPRESS;`
975		973
976	`if ( !fit->UncompressData ( progress ) )`	974	`if ( !fit->UncompressData ( progress ) )`
977	`{`	975	`{`
978	`CLog::log(CLog::Log_Install, 2, "Failed to uncompress data, attempting file decompression");`	976	`CLog::log(CLog::Log_Install, 2, "Failed to uncompress data, attempting file decompression");`
979	`if ( fit->GetCompressionType() == SPKCOMPRESS_7ZIP )`	977	`if ( fit->GetCompressionType() == SPKCOMPRESS_7ZIP )`
980	`{`	978	`{`
981	`if ( fit->uncompressToFile(Utils::String::Null(), this, false, progress ) )`	979	`if ( fit->uncompressToFile(Utils::WString::Null(), this, false, progress ) )`
982	`*uncomprToFile = true;`	980	`*uncomprToFile = true;`
983	`}`	981	`}`
984		982
985	`if ( !uncomprToFile )`	983	`if ( !uncomprToFile )`
986	`{`	984	`{`
Line 993...	Line 991...
993	`ClearError ();`	991	`ClearError ();`
994		992
995	`return true;`	993	`return true;`
996	`}`	994	`}`
997		995
998	`bool CBaseFile::_install_checkVersion(C_File *pFile, const Utils::String &sDestination)`	996	`bool CBaseFile::_install_checkVersion(C_File *pFile, const Utils::WString &sDestination)`
999	`{`	997	`{`
1000	`// new check if we should install the file`	998	`// new check if we should install the file`
1001	`// first get the version`	999	`// first get the version`
1002	`if ( !m_bOverrideFiles && pFile->ReadScriptVersion() )`	1000	`if ( !m_bOverrideFiles && pFile->ReadScriptVersion() )`
1003	`{`	1001	`{`
1004	`CLog::log(CLog::Log_Install, 2, "Checking for existing file version");`	1002	`CLog::log(CLog::Log_Install, 2, "Checking for existing file version");`
1005	`C_File checkfile;`	1003	`C_File checkfile;`
1006	`Utils::String checkfilename = sDestination;`	1004	`Utils::WString checkfilename = sDestination;`
1007	`if ( !checkfilename.empty() ) checkfilename += "/";`	1005	`if ( !checkfilename.empty() ) checkfilename += L"/";`
1008	`checkfilename += pFile->getNameDirectory(this);`	1006	`checkfilename += pFile->getNameDirectory(this);`
1009	`checkfile.setFilename(checkfilename);`	1007	`checkfile.setFilename(checkfilename);`
1010	`checkfile.setFileType(pFile->fileType());`	1008	`checkfile.setFileType(pFile->fileType());`
1011	`if ( checkfile.CheckValidFilePointer() ) {`	1009	`if ( checkfile.CheckValidFilePointer() ) {`
1012	`if ( checkfile.ReadScriptVersion() > pFile->GetVersion() ) {`	1010	`if ( checkfile.ReadScriptVersion() > pFile->GetVersion() ) {`
Line 1017...	Line 1015...
1017	`}`	1015	`}`
1018		1016
1019	`return true;`	1017	`return true;`
1020	`}`	1018	`}`
1021		1019
1022	`Utils::String CBaseFile::_install_adjustFilepointer(C_File *pFile, bool bEnabled, const Utils::String &sDestination)`	1020	`Utils::String CBaseFile::_install_adjustFilepointer(C_File *pFile, bool bEnabled, const Utils::WString &sDestination)`
1023	`{`	1021	`{`
1024	`Utils::String filename = sDestination;`	1022	`Utils::WString filename = sDestination;`
1025	`if ( !filename.empty() ) filename += "/";`	1023	`if ( !filename.empty() ) filename += L"/";`
1026		1024
1027	`if ( (IsPatch()) && (pFile->fileType() == FILETYPE_MOD) )`	1025	`if ( (IsPatch()) && (pFile->fileType() == FILETYPE_MOD) )`
1028	`pFile->setDir("Patch");`	1026	`pFile->setDir(L"Patch");`
1029		1027
1030	`if ( pFile->isInMod() )`	1028	`if ( pFile->isInMod() )`
1031	`{`	1029	`{`
1032	`if ( bEnabled )`	1030	`if ( bEnabled )`
1033	`pFile->setFilename(filename + pFile->getInMod() + "::" + pFile->getNameDirectory(this));`	1031	`pFile->setFilename(filename + pFile->getInMod() + L"::" + pFile->getNameDirectory(this));`
1034	`else`	1032	`else`
1035	`pFile->setFilename(filename + "PluginManager/DisabledFiles.cat::" + pFile->getNameDirectory(this));`	1033	`pFile->setFilename(filename + L"PluginManager/DisabledFiles.cat::" + pFile->getNameDirectory(this));`
1036	`}`	1034	`}`
1037	`else`	1035	`else`
1038	`pFile->setFilename ( filename + pFile->getNameDirectory(this) );`	1036	`pFile->setFilename ( filename + pFile->getNameDirectory(this) );`
1039		1037
1040	`if ( !bEnabled )`	1038	`if ( !bEnabled )`
1041	`{`	1039	`{`
1042	`if ( !pFile->isInMod() )`	1040	`if ( !pFile->isInMod() )`
1043	`{`	1041	`{`
1044	`if ( pFile->IsFakePatch() )`	1042	`if ( pFile->IsFakePatch() )`
1045	`pFile->setFilename ( filename + "PluginManager/Disabled/FakePatches/FakePatch_" + this->getNameValidFile() + "_" + this->author() + "_" + pFile->name() );`	1043	`pFile->setFilename ( filename + L"PluginManager/Disabled/FakePatches/FakePatch_" + this->getNameValidFile() + L"_" + this->author().toWString() + L"_" + pFile->name());`
1046	`else if ( pFile->isAutoTextFile() )`	1044	`else if ( pFile->isAutoTextFile() )`
1047	`pFile->setFilename ( filename + "PluginManager/Disabled/TextFiles/Text_" + this->getNameValidFile() + "_" + this->author() + "_" + pFile->name() );`	1045	`pFile->setFilename ( filename + L"PluginManager/Disabled/TextFiles/Text_" + this->getNameValidFile() + L"_" + this->author().toWString() + L"_" + pFile->name());`
1048	`else`	1046	`else`
1049	`pFile->setFullDir ( filename + "PluginManager/Disabled/" + pFile->getDirectory(this) );`	1047	`pFile->setFullDir ( filename + L"PluginManager/Disabled/" + pFile->getDirectory(this) );`
1050	`}`	1048	`}`
1051	`pFile->SetDisabled(true);`	1049	`pFile->SetDisabled(true);`
1052	`}`	1050	`}`
1053		1051
1054	`CLog::logf(CLog::Log_Install, 2, "Adjusting the file pointer to correct install destintation, %s", pFile->filePointer().c_str());`	1052	`CLog::logf(CLog::Log_Install, 2, "Adjusting the file pointer to correct install destintation, %s", pFile->filePointer().c_str());`
1055		1053
1056	`return filename;`	1054	`return filename.toString();`
1057	`}`	1055	`}`
1058		1056
1059	`C_File CBaseFile::_install_checkFile(C_File pFile, Utils::CStringList errorStr, bool bDoFile, CLinkList<C_File> *pFileList)`	1057	`C_File CBaseFile::_install_checkFile(C_File pFile, Utils::WStringList errorStr, bool bDoFile, CLinkList<C_File> *pFileList)`
1060	`{`	1058	`{`
1061	`if ( !pFile->IsFakePatch() && pFile->GetFileType() != FILETYPE_README )`	1059	`if ( !pFile->IsFakePatch() && pFile->GetFileType() != FILETYPE_README )`
1062	`{`	1060	`{`
1063	`C_File *cFile;`	1061	`C_File *cFile;`
1064	`for ( cFile = pFileList->First(); cFile; cFile = pFileList->Next() )`	1062	`for ( cFile = pFileList->First(); cFile; cFile = pFileList->Next() )`
Line 1076...	Line 1074...
1076	`}`	1074	`}`
1077		1075
1078	`return NULL;`	1076	`return NULL;`
1079	`}`	1077	`}`
1080		1078
1081	`bool CBaseFile::_install_checkFileEnable(C_File pCheckFile, C_File fit, const Utils::String &sDestination, bool bEnabled, Utils::CStringList *errorStr)`	1079	`bool CBaseFile::_install_checkFileEnable(C_File pCheckFile, C_File fit, const Utils::WString &sDestination, bool bEnabled, Utils::WStringList *errorStr)`
1082	`{`	1080	`{`
1083	`// found a file, check if its in the disabled directory`	1081	`// found a file, check if its in the disabled directory`
1084	`Utils::WString dir = CFileIO(pCheckFile->filePointer()).dir();`	1082	`Utils::WString dir = CFileIO(pCheckFile->filePointer()).dir();`
1085	`Utils::WString lastDir = CDirIO(dir).topDir().lower();`	1083	`Utils::WString lastDir = CDirIO(dir).topDir().lower();`
1086		1084
Line 1088...	Line 1086...
1088	`if ( ((pCheckFile->IsDisabled()) \|\| (lastDir == L"disabled") \|\| (dir.lower().contains(L"/disabled/"))) && (bEnabled) )`	1086	`if ( ((pCheckFile->IsDisabled()) \|\| (lastDir == L"disabled") \|\| (dir.lower().contains(L"/disabled/"))) && (bEnabled) )`
1089	`{`	1087	`{`
1090	`CLog::logf(CLog::Log_Install, 2, "Existing file, %s, is disabled, re-enabling it", pCheckFile->filePointer().c_str());`	1088	`CLog::logf(CLog::Log_Install, 2, "Existing file, %s, is disabled, re-enabling it", pCheckFile->filePointer().c_str());`
1091	`// first check if the directory exists`	1089	`// first check if the directory exists`
1092	`if ( pCheckFile->isInMod() ) {`	1090	`if ( pCheckFile->isInMod() ) {`
1093	`Utils::String tofile = pCheckFile->filePointer().token("::", 2);`	1091	`Utils::WString tofile = pCheckFile->filePointer().token(L"::", 2);`
1094		1092
1095	`CCatFile tocat;`	1093	`CCatFile tocat;`
1096	`int err = tocat.open(fit->filePointer().token("::", 1), "", CATREAD_CATDECRYPT, true);`	1094	`int err = tocat.open(fit->filePointer().token(L"::", 1), L"", CATREAD_CATDECRYPT, true);`
1097	`if ( (err == CATERR_NONE) \|\| (err == CATERR_CREATED) ) {`	1095	`if ( (err == CATERR_NONE) \|\| (err == CATERR_CREATED) ) {`
1098	`tocat.appendFile(pCheckFile->filePointer(), tofile);`	1096	`tocat.appendFile(pCheckFile->filePointer(), tofile);`
1099	`CLog::logf(CLog::Log_Install, 2, "Adding existing file into new mod File, %s => %s", fit->filePointer().token("::", 1).c_str(), tofile.c_str());`	1097	`CLog::logf(CLog::Log_Install, 2, "Adding existing file into new mod File, %s => %s", fit->filePointer().token(L"::", 1).c_str(), tofile.c_str());`
1100	`}`	1098	`}`
1101		1099
1102	`CCatFile fromcat;`	1100	`CCatFile fromcat;`
1103	`err = fromcat.open(pCheckFile->filePointer().token("::", 1), "", CATREAD_CATDECRYPT, false);`	1101	`err = fromcat.open(pCheckFile->filePointer().token(L"::", 1), L"", CATREAD_CATDECRYPT, false);`
1104	`if ( err == CATERR_NONE ) {`	1102	`if ( err == CATERR_NONE ) {`
1105	`fromcat.removeFile(tofile);`	1103	`fromcat.removeFile(tofile);`
1106	`CLog::logf(CLog::Log_Install, 2, "Removing file from existing mod, %s::%s", pCheckFile->filePointer().token("::", 1).c_str(), tofile.c_str());`	1104	`CLog::logf(CLog::Log_Install, 2, "Removing file from existing mod, %s::%s", pCheckFile->filePointer().token(L"::", 1).c_str(), tofile.c_str());`
1107	`}`	1105	`}`
1108		1106
1109	`CLog::logf(CLog::Log_Install, 1, "Adjusting existing file name %s => %s", pCheckFile->filePointer().c_str(), fit->filePointer().c_str());`	1107	`CLog::logf(CLog::Log_Install, 1, "Adjusting existing file name %s => %s", pCheckFile->filePointer().c_str(), fit->filePointer().c_str());`
1110	`pCheckFile->setFilename(fit->filePointer());`	1108	`pCheckFile->setFilename(fit->filePointer());`
1111	`CLog::logf(CLog::Log_Install, 2, "Adjusting In Mod setting, %s => %s", pCheckFile->getInMod().c_str(), fit->getInMod().c_str());`	1109	`CLog::logf(CLog::Log_Install, 2, "Adjusting In Mod setting, %s => %s", pCheckFile->getInMod().c_str(), fit->getInMod().c_str());`
1112	`pCheckFile->setInMod(fit->getInMod());`	1110	`pCheckFile->setInMod(fit->getInMod());`
1113	`}`	1111	`}`
1114	`else {`	1112	`else {`
1115	`Utils::String to = pCheckFile->getDirectory(this);`	1113	`Utils::WString to = pCheckFile->getDirectory(this);`
1116	`CDirIO Dir(sDestination);`	1114	`CDirIO Dir(sDestination);`
1117	`if ( !Dir.exists(to) ) {`	1115	`if ( !Dir.exists(to) ) {`
1118	`if ( !Dir.create ( to ) ) {`	1116	`if ( !Dir.create ( to ) ) {`
1119	`if ( errorStr ) errorStr->pushBack(to, ERRORLOG(SPKINSTALL_CREATEDIRECTORY_FAIL));`	1117	`if ( errorStr ) errorStr->pushBack(to.toString(), ERRORLOG(SPKINSTALL_CREATEDIRECTORY_FAIL));`
1120	`return false;`	1118	`return false;`
1121	`}`	1119	`}`
1122	`if ( errorStr ) errorStr->pushBack(to, ERRORLOG(SPKINSTALL_CREATEDIRECTORY));`	1120	`if ( errorStr ) errorStr->pushBack(to.toString(), ERRORLOG(SPKINSTALL_CREATEDIRECTORY));`
1123	`}`	1121	`}`
1124		1122
1125	`Utils::String destfile = sDestination + "/" + pCheckFile->getNameDirectory(this);`	1123	`Utils::WString destfile = sDestination + L"/" + pCheckFile->getNameDirectory(this);`
1126	`if ( CFileIO(destfile).ExistsOld() ) CFileIO::Remove(destfile);`	1124	`if ( CFileIO::Exists(destfile) ) CFileIO::Remove(destfile);`
1127	`CLog::logf(CLog::Log_Install, 1, "Adjusting existing filename, %s => %s", pCheckFile->filePointer().c_str(), destfile.c_str());`	1125	`CLog::logf(CLog::Log_Install, 1, "Adjusting existing filename, %s => %s", pCheckFile->filePointer().c_str(), destfile.c_str());`
1128	`rename ( pCheckFile->filePointer().c_str(), destfile.c_str() );`	1126	`CFileIO::Rename(pCheckFile->filePointer(), destfile);`
1129	`pCheckFile->setFilename (sDestination + "/" + pCheckFile->getNameDirectory(this) );`	1127	`pCheckFile->setFilename (sDestination + L"/" + pCheckFile->getNameDirectory(this) );`
1130	`}`	1128	`}`
1131	`pCheckFile->SetDisabled(false);`	1129	`pCheckFile->SetDisabled(false);`
1132		1130
1133	`if ( errorStr ) errorStr->pushBack(pCheckFile->getNameDirectory(this), ERRORLOG(SPKINSTALL_ENABLEFILE));`	1131	`if ( errorStr ) errorStr->pushBack(pCheckFile->getNameDirectory(this), ERRORLOG(SPKINSTALL_ENABLEFILE));`
1134	`}`	1132	`}`
1135		1133
1136	`return true;`	1134	`return true;`
1137	`}`	1135	`}`
1138		1136
1139	`bool CBaseFile::_install_createDirectory(CDirIO &Dir, const Utils::String &sTo, C_File pFile, Utils::CStringList errorStr)`	1137	`bool CBaseFile::_install_createDirectory(CDirIO &Dir, const Utils::WString &sTo, C_File pFile, Utils::WStringList errorStr)`
1140	`{`	1138	`{`
1141	`_sLastError = sTo;`	1139	`_sLastError = sTo;`
1142	`if ( !sTo.contains( "::" ) )`	1140	`if ( !sTo.contains(L"::"))`
1143	`{`	1141	`{`
1144	`if ( !Dir.exists(sTo) )`	1142	`if ( !Dir.exists(sTo) )`
1145	`{`	1143	`{`
1146	`CLog::logf(CLog::Log_Install, 2, "Creating directory to install file into, %s", sTo.c_str());`	1144	`CLog::logf(CLog::Log_Install, 2, "Creating directory to install file into, %s", sTo.c_str());`
1147	`if ( !Dir.create(sTo) )`	1145	`if ( !Dir.create(sTo) )`
Line 1160...	Line 1158...
1160	`}`	1158	`}`
1161		1159
1162	`return true;`	1160	`return true;`
1163	`}`	1161	`}`

Subversion Repositories spk

(root)/libspk/src/BaseFile.cpp – Rev 196 → 197