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



 
//////////////////////////////////////////////////////////////////////
// STATIC FUNCTIONS
//////////////////////////////////////////////////////////////////////
 
Utils::WString C_File::GetDirectory(FileType eType, const Utils::WString &filename, CBaseFile *file)
{
	switch (eType)
	{
	case FILETYPE_SCRIPT:
		return L"Scripts";
	case FILETYPE_TEXT:
		return L"T";
	case FILETYPE_README:
	{
		if (file)
			return Utils::WString(L"PluginManager/Readme/") + file->getNameValidFile();
		return L"PluginManager/Readme";
	}
	case FILETYPE_MAP:
		return L"Maps";
	case FILETYPE_MOD:
		return L"Mods";
	case FILETYPE_UNINSTALL:
		return L"PluginManager/Uninstall";
	case FILETYPE_SOUND:
		if (!filename.empty() && !CFileIO(filename).isFileExtension(L"wav"))
			return L"Soundtrack";
		return L"s";
	case FILETYPE_SOUNDTRACK:
		return L"Soundtrack";
	case FILETYPE_EXTRA:
		return L"PluginManager/Extras";
	case FILETYPE_SCREEN:
		return L"loadscr";
	case FILETYPE_ADVERT:
		return L"PluginManager/Graphics";
	case FILETYPE_MISSION:
		return L"Director";
	}
	return Utils::WString::Null();
}
 
bool C_File::DoesTypeHaveExtraDir(int i)
{
	switch (i)

	m_bUsedMalloc = false;
	m_sData = NULL;
	Reset();
}
 
C_File::C_File(const Utils::WString &filename)
{
	m_bDontDeleteData = false;
	m_bUsedMalloc = false;
	m_sData = NULL;
	Reset ();

 
C_File::~C_File()
{
	DeleteData ();
	if (!_sTmpFile.empty())
		CFileIO::Remove(_sTmpFile);
}
 
 
long C_File::uncompressedDataSize() const
{

/*
	Func:	getDirectory()
	Return: Directory String
	Desc:	Returns the directory the file goes into, based on m_sDir and Filetype
*/
Utils::WString C_File::getDirectory(CBaseFile *file) const
{
	if (IsFakePatch())
		return L"";
 
	Utils::WString sDir = _sDir;
 
	if ((m_iFileType == FILETYPE_MOD) && (sDir == L"Patch"))
		return L"PluginManager/Patch";
 
	if ((!sDir.empty()) && (m_iFileType != FILETYPE_README) && sDir != L".")
	{
		Utils::WString dir = sDir.findReplace(L"\\", L"/");
		if (file)
		{
			dir = dir.findReplace(L"$scriptname", file->getNameValidFile());
			dir = dir.findReplace(L"$scriptauthor", file->author());
		}
		return dir;
	}
 
	return C_File::GetDirectory(m_iFileType, _sName, file);
}
 
Utils::WString C_File::getNameDirectory(CBaseFile *file) const
{
	Utils::WString dir = getDirectory(file);
	if (!dir.empty())
		dir += L"/";
	return (dir + _sName).findReplace(L"\\", L"/").findReplace(L"//", L"/");
}
 
/*
	Func:	Reset()
	Desc:	Resets the file data, clears all data inside

			m_bSigned = false;
			break;
 
		// extra files are a special case
		case FILETYPE_EXTRA:
			if ( this->dir().left(6).Compare(L"extras") )
				m_bSigned = true;
			else
				m_bSigned = false;
			break;
 

	}
	m_bUsedMalloc = false;
	m_iDataCompression = SPKCOMPRESS_NONE;
}
 
int C_File::textFileID(const Utils::WString &sFilename) const
{
	if ( m_iFileType != FILETYPE_TEXT )
		return -1;
 
	Utils::WString filename = sFilename;
 
	if ( filename.empty() )
		filename = _sName;
 
	Utils::WString textid;
	if ( filename.contains(L";-L") || filename.contains(L"-l") )
		textid = filename.token(L"-", 1);
	else
		textid = filename.tokens(L".", -1).right(4);
 
	if (textid.isNumber()) return textid.toInt();
	return -1;
}
bool C_File::isAutoTextFile ()

bool C_File::IsFakePatch() const
{
	if (m_iFileType != FILETYPE_MOD)
		return false;
 
	Utils::WString name = _sName;
 
	if (name.token(L".", 1).toLong())
		return true;
 
	if (name.left(10) == L"FakePatch_")
		return true;
 
	return false;
}
 

	Desc:	Sets the file pointer
			Reads the file size and last modifed time to store in the class
			Splits up the filename and dir path
*/
 
void C_File::setFilename(const Utils::WString &filename)
{
	Utils::WString file = filename.findReplace ( L"\\", L"/" ).findReplace ( L"//", L"/" );
 
	_sFullDir = file.tokens(L"/", 1, -2);
	_sName = file.token(L"/", -1);
	if ( _sFullDir.right(2) == L"/." )
		_sFullDir = _sFullDir.left(-2);
 
	ReadFileSize ();
 
	ReadLastModified ();

bool C_File::ReadFromFile ()
{
	return this->readFromFile(filePointer());
}
 
bool C_File::readFromFile(const Utils::WString filename)
{
	CFileIO File(filename);
	if ( !File.startRead() ) {
		m_iLastError = SPKERR_FILEOPEN;
		return false;

	Func:	filePointer
	Desc:	Returns the file pointer name
			Joins dir and name together
			Works for relative paths as well
*/
Utils::WString C_File::filePointer() const
{
	Utils::WString fullfile = _sFullDir;
	if ( !fullfile.empty() )
		fullfile += L"/";
 
	if ( !_sName.empty() )
		fullfile += _sName;
 
	return fullfile;

 
bool C_File::isExternalFile() const
{
	if (!m_sData && !m_lDataSize)
	{
		Utils::WString file = this->filePointer();
		if (!file.empty() && CFileIO::Exists(file))
			return true;
	}
	return false;
}
 
 
 
void C_File::updateSignature()
{
	_sSignature = L"";
 
	bool deleteData = false;
	if ( !m_sData )
	{
		if ( !ReadFromFile() )

	size_t fPos = m_lDataSize;
	if ( fPos > 700 )
		fPos = 700;
	unsigned char *data = m_sData + (m_lDataSize - fPos);
	data[fPos - 1] = '\0';
	Utils::WString sData ((char *)data);
	int pos = sData.findPos(L"</codearray>", 0);
	if ( pos != -1 )
	{
		sData = sData.right(sData.length() - pos);
		pos = sData.findPos(L"<signature>", 0);
		int endpos = sData.findPos(L"</signature>", 0);
		if ( pos != -1 && endpos != -1 )
		{
			_sSignature = sData.mid(pos + 12, endpos - (pos + 12) + 1);
			_sSignature = _sSignature.remove('\n').remove('\r');
		}

	Desc:	Reads the last modified time of the file and returns
			Uses seperate rountines for Windows and Linux
*/
time_t C_File::ReadLastModified ()
{
	Utils::WString file = filePointer();
	if ( file.empty() )
		return m_tTime;
 
	#ifndef _WIN32
	struct stat attrib;			// create a file attribute structure

{
	if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) )
		return false;
 
	// check file pointer
	Utils::WString file = filePointer();
	Utils::WString ext = CFileIO(file).extension();
	if ( !ext.Compare(L"xml") && !ext.Compare(L"pck") )
		return false;
 
	if ( m_iDataCompression != SPKCOMPRESS_NONE )

########################################################################################################################
*/
 
bool C_File::CompressFile ( CProgressInfo *progress )
{
	Utils::WString file = this->filePointer();
	if ( !CFileIO(file).exists() )
	{
		if ( !this->writeToFile("tempuncompr.dat", m_sData, m_lDataSize) )
			return false;
		file = "tempuncompr.dat";
	}
 
	bool ret = false;
 
	FILE *fIn = fopen(std::string(file.begin(), file.end()).c_str(), "rb");
	if ( fIn )
	{
		FILE *fOut = fopen("tempcompr.dat", "wb");
		if ( fOut )
		{

			fclose(fOut);
			if ( err == Z_OK )
			{
				DeleteData ();
 
				CFileIO File(L"tempcompr.dat");
				File.setAutoDelete(true);
				if ( File.startRead() ) {
					m_sData = File.readAll((size_t *)&m_lDataSize);
					if ( !m_sData ) {
						m_iLastError = SPKERR_FILEREAD;

			}
		}
		fclose(fIn);
	}
 
	CFileIO::Remove(L"tempuncompr.dat");
 
	return ret;
}
 
bool C_File::ChangeCompression ( int compressionType, CProgressInfo *progress )

 
	if ( compressionType == SPKCOMPRESS_7ZIP )
		compressionType = SPKCOMPRESS_LZMA;
 
	// if its zlib, and we are trying to compress pcked files (ie already zlib compression) then switch to lzma instead
	if ( compressionType == SPKCOMPRESS_ZLIB && (this->checkFileExt(L"pck") || this->checkFileExt(L"cat") || this->checkFileExt(L"dat") || this->checkFileExt(L"pbb") || this->checkFileExt(L"pbd")) )
		compressionType = SPKCOMPRESS_LZMA;
 
	// if its already compressed, no need to compress again
	if ( compressionType == m_iDataCompression )
		return true;

	}
 
	return NULL;
}
 
bool C_File::uncompressToFile(const Utils::WString &toFile, CBaseFile *spkfile, bool includedir, CProgressInfo *progress)
{
#ifdef _INCLUDE7ZIP
	if ( (!m_sData) || (!m_lDataSize) )
		return false;
	// if theres a tmp file, open it and check it still exists

 
bool C_File::writeFilePointer(unsigned char *cData, long len)
{
	return writeToFile(filePointer(), cData, len);
}
bool C_File::writeToFile(const Utils::WString &filename, unsigned char *cData, long len)
{
	unsigned char *data = cData;
	if ( (!len) || (!data) ) {
		len = m_lDataSize;
		data = m_sData;

	}
 
	bool ret = false;
 
	// check for cat file
	if ( filename.contains(L"::")) {
		Utils::WString catfile = filename.token(L"::", 1);
		Utils::WString file = filename.token(L"::", 2);
 
		CCatFile newcat;
		return newcat.addData(catfile.toString(), data, len, file.toString(), true, true);
	}
	else {
		Utils::WString filen = filename.findReplace(L";/";, L"\\");
		filen = filen.findReplace(L";\\\\";, L"\\");
 
		if ( len && data ) {
			CFileIO File(filen);
			if ( File.startWrite() ) ret = File.write(data, len);
		}
	}
 
	return ret;
}
 
bool C_File::writeToDir(const Utils::WString &dir, CBaseFile *spkfile, bool includedir, const Utils::WString &appendDir, unsigned char *data, long len)
{
	Utils::WString fullfile = _getFullFileToDir(dir, includedir, spkfile);
 
	if (!appendDir.empty())
	{
		if (!fullfile.empty())
			fullfile += L"/";
		fullfile += appendDir;
	}
 
	Utils::WString fulldir = fullfile.tokens(L"/", 1, -2);
	if (!fulldir.empty())
	{
		if (!CDirIO(fulldir).create())
			return false;
	}
 
	return writeToFile(fullfile, data, len);
}
 
Utils::WString C_File::dataSizeString() const
{
	return SPK::GetSizeString(m_lDataSize);
}
Utils::WString C_File::uncompressedSizeString() const
{
	return SPK::GetSizeString(uncompressedDataSize());
}
 
Utils::WString C_File::creationTimeString() const
{
	if ( !m_tTime )
		return Utils::String::Null();
 
	struct tm   *currDate;

 
	currDate = localtime(&n);
 
	strftime(dateString, sizeof dateString, "(%d/%m/%Y) %H:%M", currDate);
 
	return Utils::WString(dateString);
}
 
bool C_File::CompareNew ( C_File *file )
{
	if ( !m_iVersion )

 
	// assume same or newer
	return true;
}
 
Utils::WString GetFileTypeString(int type)
{
	switch ( type )
	{
		case FILETYPE_SCRIPT:
			return L"Script";
		case FILETYPE_TEXT:
			return L"Text";
		case FILETYPE_README:
			return L"Readme";
		case FILETYPE_MAP:
			return L"Map";
		case FILETYPE_MOD:
			return L"Mod";
		case FILETYPE_UNINSTALL:
			return L"Uninstall";
		case FILETYPE_SOUND:
			return L"Sound";
		case FILETYPE_EXTRA:
			return L"Extra";
		case FILETYPE_SCREEN:
			return L"Screen";
		case FILETYPE_ADVERT:
			return L"Advert";
		case FILETYPE_MISSION:
			return L"Mission";
		case FILETYPE_BACKUP:
			return L"Backup";
		case FILETYPE_SHIPOTHER:
			return L"ShipOther";
		case FILETYPE_SHIPMODEL:
			return L"ShipModel";
		case FILETYPE_SHIPSCENE:
			return L"ShipScene";
		case FILETYPE_COCKPITSCENE:
			return L"CockpitScene";
	}
 
	return Utils::WString::Null();
}
 
FileType GetFileTypeFromString(const Utils::WString &type)
{
	Utils::WString ltype = type.lower();
	if ( ltype == L"script" || ltype == L"scriptpck")
		return FILETYPE_SCRIPT;
	else if ( ltype == L"text" )
		return FILETYPE_TEXT;
	else if ( ltype == L"readme" )
		return FILETYPE_README;
	else if ( ltype == L"map" )
		return FILETYPE_MAP;
	else if ( ltype == L"mod" )
		return FILETYPE_MOD;
	else if ( ltype == L"uninstall" )
		return FILETYPE_UNINSTALL;
	else if ( ltype == L"sound" )
		return FILETYPE_SOUND;
	else if ( ltype == L"extra" )
		return FILETYPE_EXTRA;
	else if ( ltype == L"screen" )
		return FILETYPE_SCREEN;
	else if ( ltype == L"advert" )
		return FILETYPE_ADVERT;
	else if ( ltype == L"mission" )
		return FILETYPE_MISSION;
	else if ( ltype == L"backup" )
		return FILETYPE_BACKUP;
	else if ( ltype == L"shipother" )
		return FILETYPE_SHIPOTHER;
	else if ( ltype == L"shipmodel" )
		return FILETYPE_SHIPMODEL;
	else if ( ltype == L"shipscene" )
		return FILETYPE_SHIPSCENE;
	else if ( ltype == L"cockpitscene" )
		return FILETYPE_COCKPITSCENE;
 
	return FILETYPE_UNKNOWN;
}
 

bool C_File::CheckPCK ()
{
	if ( (m_sData) && (m_lDataSize) && (m_iDataCompression == SPKCOMPRESS_NONE) )
		return IsDataPCK ( m_sData, m_lDataSize );
 
	Utils::WString filename = filePointer();
	if ( !filename.empty() ) {
		CFileIO File(filename);
		if ( File.startRead() ) {
			unsigned char data[4];
			if ( File.read(data, 3) ) return IsDataPCK ( data, 3 );
		}
	}
 
	if (checkFileExt(L"pck") || checkFileExt(L"pbb") || checkFileExt(L"pbd")) return true;
	return false;
}
 
bool C_File::PCKFile()
{

	}
 
	return iVersion;
}
 
Utils::WString C_File::baseName() const
{
	// remove any directory
	Utils::WString file = _sName.token(L"/", -1);
 
	// remove file extension
	return file.remToken(L".", -1);
}
 
void C_File::CopyData(C_File *oldFile, bool includeData)
{
	setFilename(oldFile->fullFilename());

}
 
float GetLibraryVersion() { return (float)LIBRARYVERSION; }
float GetFileFormatVersion() { return (float)FILEVERSION; }
 
Utils::WString C_File::fileExt() const 
{ 
	return _sName.token(L".", -1); 
}
 
bool C_File::checkFileExt(const Utils::WString& ext) 
{
	if (fileExt().Compare(ext)) return true; return false;
}
 
const Utils::WString &C_File::changeFileExt(const Utils::WString &ext)
{
	_sName = CFileIO(_sName).changeFileExtension(ext);
	return _sName;
}
 
bool C_File::CheckPackedExtension()
{
	Utils::WString ext = this->fileExt();
	if ( ext == L"pck" )
		return true;
	else if ( ext == L"pbb" )
		return true;
	else if ( ext == L"pbd" )
		return true;
 
	return false;
}
 

 
unsigned char *C_File::BobDecompile(size_t *size)
{
	(*size) = 0;
 
	Utils::WString fromFile = this->filePointer();
	if ( !CFileIO::Exists(fromFile) ) {
		if ( this->writeToFile(CPackages::tempDirectory().toString() + "bob.tmp")) {
			fromFile = CPackages::tempDirectory() + L"bob.tmp";
		}
	}
 
	fromFile = fromFile.findReplace(L"/", L"\\");
	Utils::WString toFile = CPackages::tempDirectory() + L"bod.tmp";
	toFile = toFile.findReplace("/", "\\");
 
	if ( CFileIO::Exists(fromFile) ) {
		if ( X2BC_BOB2BOD(fromFile.toString().c_str(), toFile.toString().c_str())) {
			CFileIO F(toFile);
			if ( F.exists() && F.startRead() ) {
				unsigned char *data = F.readAll(size);
				F.close();
				F.remove();

				return data;
			}
		}
	}
 
	if ( CFileIO::Exists(CPackages::tempDirectory() + L"bob.tmp") )
		CFileIO::Remove(CPackages::tempDirectory() + L";bob.tmp");
	/*
	Settings settings;
	bob_dom_document doc(&settings);
	
	ibinaryrealfile is;

bool C_File::BodCompile()
{
	return true;
}
 
bool C_File::renameScript(const Utils::WString &baseName)
{
	if ( !m_sData || !m_lDataSize )
	{
		if ( !this->ReadFromFile() )
			return false;

	// uncompress the file
	if ( !this->UncompressData() )
		return false;
 
	// un pck the file
	if (this->checkFileExt(L"pck"))
	{
		if ( !this->UnPCKFile() )
			return false;
	}
 
	// now we should have the raw data
	Utils::WString data((const char *)m_sData);
	data.truncate(m_lDataSize);
	data = data.findReplace(this->baseName(), baseName);
 
	this->DeleteData();
	m_sData = new unsigned char[data.length()];
	memcpy(m_sData, data.c_str(), data.length());
	m_lDataSize = (long)data.length();
 
	// repck the file
	if (this->checkFileExt(L"pck"))
	{
		if ( !this->PCKFile() )
			return false;
	}
 
 
	return true;
}
 
Utils::WString C_File::_getFullFileToDir(const Utils::WString &dir, bool includedir, CBaseFile *file) const
{
	Utils::WString fullfile = dir;
	if (includedir)
	{
		Utils::WString d = getDirectory(file);
		if (!d.empty())
		{
			if (!fullfile.empty())
				fullfile += L"/";
			fullfile += d;
		}
	}
	if (!_sName.empty())
	{
		if (!fullfile.empty())
			fullfile += L"/";
		fullfile += _sName;
	}
 
	fullfile = fullfile.findReplace(L"\\", L"/");
	return fullfile;
}

Rev 196	Rev 197
Line 38...	Line 38...
38		38
39	`//////////////////////////////////////////////////////////////////////`	39	`//////////////////////////////////////////////////////////////////////`
40	`// STATIC FUNCTIONS`	40	`// STATIC FUNCTIONS`
41	`//////////////////////////////////////////////////////////////////////`	41	`//////////////////////////////////////////////////////////////////////`
42		42
43	`Utils::String C_File::GetDirectory(FileType eType, const Utils::String &filename, CBaseFile *file)`	43	`Utils::WString C_File::GetDirectory(FileType eType, const Utils::WString &filename, CBaseFile *file)`
44	`{`	44	`{`
45	`switch (eType)`	45	`switch (eType)`
46	`{`	46	`{`
47	`case FILETYPE_SCRIPT:`	47	`case FILETYPE_SCRIPT:`
48	`return "Scripts";`	48	`return L"Scripts";`
49	`case FILETYPE_TEXT:`	49	`case FILETYPE_TEXT:`
50	`return "T";`	50	`return L"T";`
51	`case FILETYPE_README:`	51	`case FILETYPE_README:`
52	`{`	52	`{`
53	`if (file)`	53	`if (file)`
54	`return Utils::String("PluginManager/Readme/") + file->getNameValidFile();`	54	`return Utils::WString(L"PluginManager/Readme/") + file->getNameValidFile();`
55	`return "PluginManager/Readme";`	55	`return L"PluginManager/Readme";`
56	`}`	56	`}`
57	`case FILETYPE_MAP:`	57	`case FILETYPE_MAP:`
58	`return "Maps";`	58	`return L"Maps";`
59	`case FILETYPE_MOD:`	59	`case FILETYPE_MOD:`
60	`return "Mods";`	60	`return L"Mods";`
61	`case FILETYPE_UNINSTALL:`	61	`case FILETYPE_UNINSTALL:`
62	`return "PluginManager/Uninstall";`	62	`return L"PluginManager/Uninstall";`
63	`case FILETYPE_SOUND:`	63	`case FILETYPE_SOUND:`
64	`if (!filename.empty() && !CFileIO(filename).isFileExtension(L"wav"))`	64	`if (!filename.empty() && !CFileIO(filename).isFileExtension(L"wav"))`
65	`return "Soundtrack";`	65	`return L"Soundtrack";`
66	`return "s";`	66	`return L"s";`
67	`case FILETYPE_SOUNDTRACK:`	67	`case FILETYPE_SOUNDTRACK:`
68	`return "Soundtrack";`	68	`return L"Soundtrack";`
69	`case FILETYPE_EXTRA:`	69	`case FILETYPE_EXTRA:`
70	`return "PluginManager/Extras";`	70	`return L"PluginManager/Extras";`
71	`case FILETYPE_SCREEN:`	71	`case FILETYPE_SCREEN:`
72	`return "loadscr";`	72	`return L"loadscr";`
73	`case FILETYPE_ADVERT:`	73	`case FILETYPE_ADVERT:`
74	`return "PluginManager/Graphics";`	74	`return L"PluginManager/Graphics";`
75	`case FILETYPE_MISSION:`	75	`case FILETYPE_MISSION:`
76	`return "Director";`	76	`return L"Director";`
77	`}`	77	`}`
78	`return Utils::String::Null();`	78	`return Utils::WString::Null();`
79	`}`	79	`}`
80		80
81	`bool C_File::DoesTypeHaveExtraDir(int i)`	81	`bool C_File::DoesTypeHaveExtraDir(int i)`
82	`{`	82	`{`
83	`switch (i)`	83	`switch (i)`
Line 129...	Line 129...
129	`m_bUsedMalloc = false;`	129	`m_bUsedMalloc = false;`
130	`m_sData = NULL;`	130	`m_sData = NULL;`
131	`Reset();`	131	`Reset();`
132	`}`	132	`}`
133		133
134	`C_File::C_File(const Utils::String &filename)`	134	`C_File::C_File(const Utils::WString &filename)`
135	`{`	135	`{`
136	`m_bDontDeleteData = false;`	136	`m_bDontDeleteData = false;`
137	`m_bUsedMalloc = false;`	137	`m_bUsedMalloc = false;`
138	`m_sData = NULL;`	138	`m_sData = NULL;`
139	`Reset ();`	139	`Reset ();`
Line 142...	Line 142...
142		142
143	`C_File::~C_File()`	143	`C_File::~C_File()`
144	`{`	144	`{`
145	`DeleteData ();`	145	`DeleteData ();`
146	`if (!_sTmpFile.empty())`	146	`if (!_sTmpFile.empty())`
147	`remove(_sTmpFile.c_str());`	147	`CFileIO::Remove(_sTmpFile);`
148	`}`	148	`}`
149		149
150		150
151	`long C_File::uncompressedDataSize() const`	151	`long C_File::uncompressedDataSize() const`
152	`{`	152	`{`
Line 160...	Line 160...
160	`/*`	160	`/*`
161	`Func: getDirectory()`	161	`Func: getDirectory()`
162	`Return: Directory String`	162	`Return: Directory String`
163	`Desc: Returns the directory the file goes into, based on m_sDir and Filetype`	163	`Desc: Returns the directory the file goes into, based on m_sDir and Filetype`
164	`*/`	164	`*/`
165	`Utils::String C_File::getDirectory(CBaseFile *file) const`	165	`Utils::WString C_File::getDirectory(CBaseFile *file) const`
166	`{`	166	`{`
167	`if (IsFakePatch())`	167	`if (IsFakePatch())`
168	`return "";`	168	`return L"";`
169		169
170	`Utils::String sDir = _sDir;`	170	`Utils::WString sDir = _sDir;`
171		171
172	`if ((m_iFileType == FILETYPE_MOD) && (sDir == "Patch"))`	172	`if ((m_iFileType == FILETYPE_MOD) && (sDir == L"Patch"))`
173	`return "PluginManager/Patch";`	173	`return L"PluginManager/Patch";`
174		174
175	`if ((!sDir.empty()) && (m_iFileType != FILETYPE_README) && sDir != ".")`	175	`if ((!sDir.empty()) && (m_iFileType != FILETYPE_README) && sDir != L".")`
176	`{`	176	`{`
177	`Utils::String dir = sDir.findReplace("\\", "/");`	177	`Utils::WString dir = sDir.findReplace(L"\\", L"/");`
178	`if (file)`	178	`if (file)`
179	`{`	179	`{`
180	`dir = dir.findReplace("$scriptname", file->getNameValidFile());`	180	`dir = dir.findReplace(L"$scriptname", file->getNameValidFile());`
181	`dir = dir.findReplace("$scriptauthor", file->author());`	181	`dir = dir.findReplace(L"$scriptauthor", file->author());`
182	`}`	182	`}`
183	`return dir;`	183	`return dir;`
184	`}`	184	`}`
185		185
186	`return C_File::GetDirectory(m_iFileType, _sName, file);`	186	`return C_File::GetDirectory(m_iFileType, _sName, file);`
187	`}`	187	`}`
188		188
189	`Utils::String C_File::getNameDirectory(CBaseFile *file) const`	189	`Utils::WString C_File::getNameDirectory(CBaseFile *file) const`
190	`{`	190	`{`
191	`Utils::String dir = getDirectory(file);`	191	`Utils::WString dir = getDirectory(file);`
192	`if (!dir.empty())`	192	`if (!dir.empty())`
193	`dir += "/";`	193	`dir += L"/";`
194	`return (dir + _sName).findReplace("\\", "/").findReplace("//", "/");`	194	`return (dir + _sName).findReplace(L"\\", L"/").findReplace(L"//", L"/");`
195	`}`	195	`}`
196		196
197	`/*`	197	`/*`
198	`Func: Reset()`	198	`Func: Reset()`
199	`Desc: Resets the file data, clears all data inside`	199	`Desc: Resets the file data, clears all data inside`
Line 245...	Line 245...
245	`m_bSigned = false;`	245	`m_bSigned = false;`
246	`break;`	246	`break;`
247		247
248	`// extra files are a special case`	248	`// extra files are a special case`
249	`case FILETYPE_EXTRA:`	249	`case FILETYPE_EXTRA:`
250	`if ( this->dir().left(6).Compare("extras") )`	250	`if ( this->dir().left(6).Compare(L"extras") )`
251	`m_bSigned = true;`	251	`m_bSigned = true;`
252	`else`	252	`else`
253	`m_bSigned = false;`	253	`m_bSigned = false;`
254	`break;`	254	`break;`
255		255
Line 287...	Line 287...
287	`}`	287	`}`
288	`m_bUsedMalloc = false;`	288	`m_bUsedMalloc = false;`
289	`m_iDataCompression = SPKCOMPRESS_NONE;`	289	`m_iDataCompression = SPKCOMPRESS_NONE;`
290	`}`	290	`}`
291		291
292	`int C_File::textFileID(const Utils::String &sFilename) const`	292	`int C_File::textFileID(const Utils::WString &sFilename) const`
293	`{`	293	`{`
294	`if ( m_iFileType != FILETYPE_TEXT )`	294	`if ( m_iFileType != FILETYPE_TEXT )`
295	`return -1;`	295	`return -1;`
296		296
297	`Utils::String filename = sFilename;`	297	`Utils::WString filename = sFilename;`
298		298
299	`if ( filename.empty() )`	299	`if ( filename.empty() )`
300	`filename = _sName;`	300	`filename = _sName;`
301		301
302	`Utils::String textid;`	302	`Utils::WString textid;`
303	`if ( filename.contains(";-L") \|\| filename.contains("-l") )`	303	`if ( filename.contains(L";-L") \|\| filename.contains(L"-l") )`
304	`textid = filename.token("-", 1);`	304	`textid = filename.token(L"-", 1);`
305	`else`	305	`else`
306	`textid = filename.tokens(".", -1).right(4);`	306	`textid = filename.tokens(L".", -1).right(4);`
307		307
308	`if (textid.isNumber()) return textid.toInt();`	308	`if (textid.isNumber()) return textid.toInt();`
309	`return -1;`	309	`return -1;`
310	`}`	310	`}`
311	`bool C_File::isAutoTextFile ()`	311	`bool C_File::isAutoTextFile ()`
Line 345...	Line 345...
345	`bool C_File::IsFakePatch() const`	345	`bool C_File::IsFakePatch() const`
346	`{`	346	`{`
347	`if (m_iFileType != FILETYPE_MOD)`	347	`if (m_iFileType != FILETYPE_MOD)`
348	`return false;`	348	`return false;`
349		349
350	`Utils::String name = _sName;`	350	`Utils::WString name = _sName;`
351		351
352	`if (name.token(".", 1).toLong())`	352	`if (name.token(L".", 1).toLong())`
353	`return true;`	353	`return true;`
354		354
355	`if (name.left(10) == "FakePatch_")`	355	`if (name.left(10) == L"FakePatch_")`
356	`return true;`	356	`return true;`
357		357
358	`return false;`	358	`return false;`
359	`}`	359	`}`
360		360
Line 370...	Line 370...
370	`Desc: Sets the file pointer`	370	`Desc: Sets the file pointer`
371	`Reads the file size and last modifed time to store in the class`	371	`Reads the file size and last modifed time to store in the class`
372	`Splits up the filename and dir path`	372	`Splits up the filename and dir path`
373	`*/`	373	`*/`
374		374
375	`void C_File::setFilename(const Utils::String &filename)`	375	`void C_File::setFilename(const Utils::WString &filename)`
376	`{`	376	`{`
377	`Utils::String file = filename.findReplace ( "\\", "/" ).findReplace ( "//", "/" );`	377	`Utils::WString file = filename.findReplace ( L"\\", L"/" ).findReplace ( L"//", L"/" );`
378		378
379	`_sFullDir = file.tokens("/", 1, -2);`	379	`_sFullDir = file.tokens(L"/", 1, -2);`
380	`_sName = file.token("/", -1);`	380	`_sName = file.token(L"/", -1);`
381	`if ( _sFullDir.right(2) == "/." )`	381	`if ( _sFullDir.right(2) == L"/." )`
382	`_sFullDir = _sFullDir.left(-2);`	382	`_sFullDir = _sFullDir.left(-2);`
383		383
384	`ReadFileSize ();`	384	`ReadFileSize ();`
385		385
386	`ReadLastModified ();`	386	`ReadLastModified ();`
Line 396...	Line 396...
396	`bool C_File::ReadFromFile ()`	396	`bool C_File::ReadFromFile ()`
397	`{`	397	`{`
398	`return this->readFromFile(filePointer());`	398	`return this->readFromFile(filePointer());`
399	`}`	399	`}`
400		400
401	`bool C_File::readFromFile(const Utils::String filename)`	401	`bool C_File::readFromFile(const Utils::WString filename)`
402	`{`	402	`{`
403	`CFileIO File(filename);`	403	`CFileIO File(filename);`
404	`if ( !File.startRead() ) {`	404	`if ( !File.startRead() ) {`
405	`m_iLastError = SPKERR_FILEOPEN;`	405	`m_iLastError = SPKERR_FILEOPEN;`
406	`return false;`	406	`return false;`
Line 496...	Line 496...
496	`Func: filePointer`	496	`Func: filePointer`
497	`Desc: Returns the file pointer name`	497	`Desc: Returns the file pointer name`
498	`Joins dir and name together`	498	`Joins dir and name together`
499	`Works for relative paths as well`	499	`Works for relative paths as well`
500	`*/`	500	`*/`
501	`Utils::String C_File::filePointer() const`	501	`Utils::WString C_File::filePointer() const`
502	`{`	502	`{`
503	`Utils::String fullfile = _sFullDir;`	503	`Utils::WString fullfile = _sFullDir;`
504	`if ( !fullfile.empty() )`	504	`if ( !fullfile.empty() )`
505	`fullfile += "/";`	505	`fullfile += L"/";`
506		506
507	`if ( !_sName.empty() )`	507	`if ( !_sName.empty() )`
508	`fullfile += _sName;`	508	`fullfile += _sName;`
509		509
510	`return fullfile;`	510	`return fullfile;`
Line 512...	Line 512...
512		512
513	`bool C_File::isExternalFile() const`	513	`bool C_File::isExternalFile() const`
514	`{`	514	`{`
515	`if (!m_sData && !m_lDataSize)`	515	`if (!m_sData && !m_lDataSize)`
516	`{`	516	`{`
517	`Utils::String file = this->filePointer();`	517	`Utils::WString file = this->filePointer();`
518	`if (!file.empty() && CFileIO::Exists(file))`	518	`if (!file.empty() && CFileIO::Exists(file))`
519	`return true;`	519	`return true;`
520	`}`	520	`}`
521	`return false;`	521	`return false;`
522	`}`	522	`}`
523		523
524		524
525		525
526	`void C_File::updateSignature()`	526	`void C_File::updateSignature()`
527	`{`	527	`{`
528	`_sSignature = "";`	528	`_sSignature = L"";`
529		529
530	`bool deleteData = false;`	530	`bool deleteData = false;`
531	`if ( !m_sData )`	531	`if ( !m_sData )`
532	`{`	532	`{`
533	`if ( !ReadFromFile() )`	533	`if ( !ReadFromFile() )`
Line 546...	Line 546...
546	`size_t fPos = m_lDataSize;`	546	`size_t fPos = m_lDataSize;`
547	`if ( fPos > 700 )`	547	`if ( fPos > 700 )`
548	`fPos = 700;`	548	`fPos = 700;`
549	`unsigned char *data = m_sData + (m_lDataSize - fPos);`	549	`unsigned char *data = m_sData + (m_lDataSize - fPos);`
550	`data[fPos - 1] = '\0';`	550	`data[fPos - 1] = '\0';`
551	`Utils::String sData ((char *)data);`	551	`Utils::WString sData ((char *)data);`
552	`int pos = sData.findPos("</codearray>", 0);`	552	`int pos = sData.findPos(L"</codearray>", 0);`
553	`if ( pos != -1 )`	553	`if ( pos != -1 )`
554	`{`	554	`{`
555	`sData = sData.right(sData.length() - pos);`	555	`sData = sData.right(sData.length() - pos);`
556	`pos = sData.findPos("<signature>", 0);`	556	`pos = sData.findPos(L"<signature>", 0);`
557	`int endpos = sData.findPos("</signature>", 0);`	557	`int endpos = sData.findPos(L"</signature>", 0);`
558	`if ( pos != -1 && endpos != -1 )`	558	`if ( pos != -1 && endpos != -1 )`
559	`{`	559	`{`
560	`_sSignature = sData.mid(pos + 12, endpos - (pos + 12) + 1);`	560	`_sSignature = sData.mid(pos + 12, endpos - (pos + 12) + 1);`
561	`_sSignature = _sSignature.remove('\n').remove('\r');`	561	`_sSignature = _sSignature.remove('\n').remove('\r');`
562	`}`	562	`}`
Line 587...	Line 587...
587	`Desc: Reads the last modified time of the file and returns`	587	`Desc: Reads the last modified time of the file and returns`
588	`Uses seperate rountines for Windows and Linux`	588	`Uses seperate rountines for Windows and Linux`
589	`*/`	589	`*/`
590	`time_t C_File::ReadLastModified ()`	590	`time_t C_File::ReadLastModified ()`
591	`{`	591	`{`
592	`Utils::String file = filePointer();`	592	`Utils::WString file = filePointer();`
593	`if ( file.empty() )`	593	`if ( file.empty() )`
594	`return m_tTime;`	594	`return m_tTime;`
595		595
596	`#ifndef _WIN32`	596	`#ifndef _WIN32`
597	`struct stat attrib; // create a file attribute structure`	597	`struct stat attrib; // create a file attribute structure`
Line 612...	Line 612...
612	`{`	612	`{`
613	`if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) )`	613	`if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) )`
614	`return false;`	614	`return false;`
615		615
616	`// check file pointer`	616	`// check file pointer`
617	`Utils::String file = filePointer();`	617	`Utils::WString file = filePointer();`
618	`Utils::WString ext = CFileIO(file).extension();`	618	`Utils::WString ext = CFileIO(file).extension();`
619	`if ( !ext.Compare(L"xml") && !ext.Compare(L"pck") )`	619	`if ( !ext.Compare(L"xml") && !ext.Compare(L"pck") )`
620	`return false;`	620	`return false;`
621		621
622	`if ( m_iDataCompression != SPKCOMPRESS_NONE )`	622	`if ( m_iDataCompression != SPKCOMPRESS_NONE )`
Line 703...	Line 703...
703	`########################################################################################################################`	703	`########################################################################################################################`
704	`*/`	704	`*/`
705		705
706	`bool C_File::CompressFile ( CProgressInfo *progress )`	706	`bool C_File::CompressFile ( CProgressInfo *progress )`
707	`{`	707	`{`
708	`Utils::String file = this->filePointer();`	708	`Utils::WString file = this->filePointer();`
709	`if ( !CFileIO(this->filePointer()).exists() )`	709	`if ( !CFileIO(file).exists() )`
710	`{`	710	`{`
711	`if ( !this->writeToFile("tempuncompr.dat", m_sData, m_lDataSize) )`	711	`if ( !this->writeToFile("tempuncompr.dat", m_sData, m_lDataSize) )`
712	`return false;`	712	`return false;`
713	`file = "tempuncompr.dat";`	713	`file = "tempuncompr.dat";`
714	`}`	714	`}`
715		715
716	`bool ret = false;`	716	`bool ret = false;`
717		717
718	`FILE *fIn = fopen(file.c_str(), "rb");`	718	`FILE *fIn = fopen(std::string(file.begin(), file.end()).c_str(), "rb");`
719	`if ( fIn )`	719	`if ( fIn )`
720	`{`	720	`{`
721	`FILE *fOut = fopen("tempcompr.dat", "wb");`	721	`FILE *fOut = fopen("tempcompr.dat", "wb");`
722	`if ( fOut )`	722	`if ( fOut )`
723	`{`	723	`{`
Line 730...	Line 730...
730	`fclose(fOut);`	730	`fclose(fOut);`
731	`if ( err == Z_OK )`	731	`if ( err == Z_OK )`
732	`{`	732	`{`
733	`DeleteData ();`	733	`DeleteData ();`
734		734
735	`CFileIO File("tempcompr.dat");`	735	`CFileIO File(L"tempcompr.dat");`
736	`File.setAutoDelete(true);`	736	`File.setAutoDelete(true);`
737	`if ( File.startRead() ) {`	737	`if ( File.startRead() ) {`
738	`m_sData = File.readAll((size_t *)&m_lDataSize);`	738	`m_sData = File.readAll((size_t *)&m_lDataSize);`
739	`if ( !m_sData ) {`	739	`if ( !m_sData ) {`
740	`m_iLastError = SPKERR_FILEREAD;`	740	`m_iLastError = SPKERR_FILEREAD;`
Line 750...	Line 750...
750	`}`	750	`}`
751	`}`	751	`}`
752	`fclose(fIn);`	752	`fclose(fIn);`
753	`}`	753	`}`
754		754
755	`CFileIO::Remove("tempuncompr.dat");`	755	`CFileIO::Remove(L"tempuncompr.dat");`
756		756
757	`return ret;`	757	`return ret;`
758	`}`	758	`}`
759		759
760	`bool C_File::ChangeCompression ( int compressionType, CProgressInfo *progress )`	760	`bool C_File::ChangeCompression ( int compressionType, CProgressInfo *progress )`
Line 853...	Line 853...
853		853
854	`if ( compressionType == SPKCOMPRESS_7ZIP )`	854	`if ( compressionType == SPKCOMPRESS_7ZIP )`
855	`compressionType = SPKCOMPRESS_LZMA;`	855	`compressionType = SPKCOMPRESS_LZMA;`
856		856
857	`// if its zlib, and we are trying to compress pcked files (ie already zlib compression) then switch to lzma instead`	857	`// if its zlib, and we are trying to compress pcked files (ie already zlib compression) then switch to lzma instead`
858	`if ( compressionType == SPKCOMPRESS_ZLIB && (this->checkFileExt("pck") \|\| this->checkFileExt("cat") \|\| this->checkFileExt("dat") \|\| this->checkFileExt("pbb") \|\| this->checkFileExt("pbd")) )`	858	`if ( compressionType == SPKCOMPRESS_ZLIB && (this->checkFileExt(L"pck") \|\| this->checkFileExt(L"cat") \|\| this->checkFileExt(L"dat") \|\| this->checkFileExt(L"pbb") \|\| this->checkFileExt(L"pbd")) )`
859	`compressionType = SPKCOMPRESS_LZMA;`	859	`compressionType = SPKCOMPRESS_LZMA;`
860		860
861	`// if its already compressed, no need to compress again`	861	`// if its already compressed, no need to compress again`
862	`if ( compressionType == m_iDataCompression )`	862	`if ( compressionType == m_iDataCompression )`
863	`return true;`	863	`return true;`
Line 1063...	Line 1063...
1063	`}`	1063	`}`
1064		1064
1065	`return NULL;`	1065	`return NULL;`
1066	`}`	1066	`}`
1067		1067
1068	`bool C_File::uncompressToFile(const Utils::String &toFile, CBaseFile spkfile, bool includedir, CProgressInfo progress)`	1068	`bool C_File::uncompressToFile(const Utils::WString &toFile, CBaseFile spkfile, bool includedir, CProgressInfo progress)`
1069	`{`	1069	`{`
1070	`#ifdef _INCLUDE7ZIP`	1070	`#ifdef _INCLUDE7ZIP`
1071	`if ( (!m_sData) \|\| (!m_lDataSize) )`	1071	`if ( (!m_sData) \|\| (!m_lDataSize) )`
1072	`return false;`	1072	`return false;`
1073	`// if theres a tmp file, open it and check it still exists`	1073	`// if theres a tmp file, open it and check it still exists`
Line 1109...	Line 1109...
1109		1109
1110	`bool C_File::writeFilePointer(unsigned char *cData, long len)`	1110	`bool C_File::writeFilePointer(unsigned char *cData, long len)`
1111	`{`	1111	`{`
1112	`return writeToFile(filePointer(), cData, len);`	1112	`return writeToFile(filePointer(), cData, len);`
1113	`}`	1113	`}`
1114	`bool C_File::writeToFile(const Utils::String &filename, unsigned char *cData, long len)`	1114	`bool C_File::writeToFile(const Utils::WString &filename, unsigned char *cData, long len)`
1115	`{`	1115	`{`
1116	`unsigned char *data = cData;`	1116	`unsigned char *data = cData;`
1117	`if ( (!len) \|\| (!data) ) {`	1117	`if ( (!len) \|\| (!data) ) {`
1118	`len = m_lDataSize;`	1118	`len = m_lDataSize;`
1119	`data = m_sData;`	1119	`data = m_sData;`
Line 1124...	Line 1124...
1124	`}`	1124	`}`
1125		1125
1126	`bool ret = false;`	1126	`bool ret = false;`
1127		1127
1128	`// check for cat file`	1128	`// check for cat file`
1129	`if ( filename.contains("::")) {`	1129	`if ( filename.contains(L"::")) {`
1130	`Utils::String catfile = filename.token("::", 1);`	1130	`Utils::WString catfile = filename.token(L"::", 1);`
1131	`Utils::String file = filename.token( "::", 2);`	1131	`Utils::WString file = filename.token(L"::", 2);`
1132		1132
1133	`CCatFile newcat;`	1133	`CCatFile newcat;`
1134	`return newcat.addData(catfile, data, len, file, true, true);`	1134	`return newcat.addData(catfile.toString(), data, len, file.toString(), true, true);`
1135	`}`	1135	`}`
1136	`else {`	1136	`else {`
1137	`Utils::String filen = filename.findReplace ( ";/";, "\\" );`	1137	`Utils::WString filen = filename.findReplace(L";/";, L"\\");`
1138	`filen = filen.findReplace ( ";\\\\";, "\\" );`	1138	`filen = filen.findReplace(L";\\\\";, L"\\");`
1139		1139
1140	`if ( len && data ) {`	1140	`if ( len && data ) {`
1141	`CFileIO File(filen);`	1141	`CFileIO File(filen);`
1142	`if ( File.startWrite() ) ret = File.write(data, len);`	1142	`if ( File.startWrite() ) ret = File.write(data, len);`
1143	`}`	1143	`}`
1144	`}`	1144	`}`
1145		1145
1146	`return ret;`	1146	`return ret;`
1147	`}`	1147	`}`
1148		1148
1149	`bool C_File::writeToDir(const Utils::String &dir, CBaseFile spkfile, bool includedir, const Utils::String &appendDir, unsigned char data, long len)`	1149	`bool C_File::writeToDir(const Utils::WString &dir, CBaseFile spkfile, bool includedir, const Utils::WString &appendDir, unsigned char data, long len)`
1150	`{`	1150	`{`
1151	`Utils::String fullfile = _getFullFileToDir(dir, includedir, spkfile);`	1151	`Utils::WString fullfile = _getFullFileToDir(dir, includedir, spkfile);`
1152		1152
1153	`if (!appendDir.empty())`	1153	`if (!appendDir.empty())`
1154	`{`	1154	`{`
1155	`if (!fullfile.empty())`	1155	`if (!fullfile.empty())`
1156	`fullfile += "/";`	1156	`fullfile += L"/";`
1157	`fullfile += appendDir;`	1157	`fullfile += appendDir;`
1158	`}`	1158	`}`
1159		1159
1160	`Utils::String fulldir = fullfile.tokens("/", 1, -2);`	1160	`Utils::WString fulldir = fullfile.tokens(L"/", 1, -2);`
1161	`if (!fulldir.empty())`	1161	`if (!fulldir.empty())`
1162	`{`	1162	`{`
1163	`if (!CDirIO(fulldir).create())`	1163	`if (!CDirIO(fulldir).create())`
1164	`return false;`	1164	`return false;`
1165	`}`	1165	`}`
1166		1166
1167	`return writeToFile(fullfile, data, len);`	1167	`return writeToFile(fullfile, data, len);`
1168	`}`	1168	`}`
1169		1169
1170	`Utils::String C_File::dataSizeString() const`	1170	`Utils::WString C_File::dataSizeString() const`
1171	`{`	1171	`{`
1172	`return SPK::GetSizeString(m_lDataSize);`	1172	`return SPK::GetSizeString(m_lDataSize);`
1173	`}`	1173	`}`
1174	`Utils::String C_File::uncompressedSizeString() const`	1174	`Utils::WString C_File::uncompressedSizeString() const`
1175	`{`	1175	`{`
1176	`return SPK::GetSizeString(uncompressedDataSize());`	1176	`return SPK::GetSizeString(uncompressedDataSize());`
1177	`}`	1177	`}`
1178		1178
1179	`Utils::String C_File::creationTimeString() const`	1179	`Utils::WString C_File::creationTimeString() const`
1180	`{`	1180	`{`
1181	`if ( !m_tTime )`	1181	`if ( !m_tTime )`
1182	`return Utils::String::Null();`	1182	`return Utils::String::Null();`
1183		1183
1184	`struct tm *currDate;`	1184	`struct tm *currDate;`
Line 1188...	Line 1188...
1188		1188
1189	`currDate = localtime(&n);`	1189	`currDate = localtime(&n);`
1190		1190
1191	`strftime(dateString, sizeof dateString, "(%d/%m/%Y) %H:%M", currDate);`	1191	`strftime(dateString, sizeof dateString, "(%d/%m/%Y) %H:%M", currDate);`
1192		1192
1193	`return Utils::String(dateString);`	1193	`return Utils::WString(dateString);`
1194	`}`	1194	`}`
1195		1195
1196	`bool C_File::CompareNew ( C_File *file )`	1196	`bool C_File::CompareNew ( C_File *file )`
1197	`{`	1197	`{`
1198	`if ( !m_iVersion )`	1198	`if ( !m_iVersion )`
Line 1214...	Line 1214...
1214		1214
1215	`// assume same or newer`	1215	`// assume same or newer`
1216	`return true;`	1216	`return true;`
1217	`}`	1217	`}`
1218		1218
1219	`Utils::String GetFileTypeString(int type)`	1219	`Utils::WString GetFileTypeString(int type)`
1220	`{`	1220	`{`
1221	`switch ( type )`	1221	`switch ( type )`
1222	`{`	1222	`{`
1223	`case FILETYPE_SCRIPT:`	1223	`case FILETYPE_SCRIPT:`
1224	`return "Script";`	1224	`return L"Script";`
1225	`case FILETYPE_TEXT:`	1225	`case FILETYPE_TEXT:`
1226	`return "Text";`	1226	`return L"Text";`
1227	`case FILETYPE_README:`	1227	`case FILETYPE_README:`
1228	`return "Readme";`	1228	`return L"Readme";`
1229	`case FILETYPE_MAP:`	1229	`case FILETYPE_MAP:`
1230	`return "Map";`	1230	`return L"Map";`
1231	`case FILETYPE_MOD:`	1231	`case FILETYPE_MOD:`
1232	`return "Mod";`	1232	`return L"Mod";`
1233	`case FILETYPE_UNINSTALL:`	1233	`case FILETYPE_UNINSTALL:`
1234	`return "Uninstall";`	1234	`return L"Uninstall";`
1235	`case FILETYPE_SOUND:`	1235	`case FILETYPE_SOUND:`
1236	`return "Sound";`	1236	`return L"Sound";`
1237	`case FILETYPE_EXTRA:`	1237	`case FILETYPE_EXTRA:`
1238	`return "Extra";`	1238	`return L"Extra";`
1239	`case FILETYPE_SCREEN:`	1239	`case FILETYPE_SCREEN:`
1240	`return "Screen";`	1240	`return L"Screen";`
1241	`case FILETYPE_ADVERT:`	1241	`case FILETYPE_ADVERT:`
1242	`return "Advert";`	1242	`return L"Advert";`
1243	`case FILETYPE_MISSION:`	1243	`case FILETYPE_MISSION:`
1244	`return "Mission";`	1244	`return L"Mission";`
1245	`case FILETYPE_BACKUP:`	1245	`case FILETYPE_BACKUP:`
1246	`return "Backup";`	1246	`return L"Backup";`
1247	`case FILETYPE_SHIPOTHER:`	1247	`case FILETYPE_SHIPOTHER:`
1248	`return "ShipOther";`	1248	`return L"ShipOther";`
1249	`case FILETYPE_SHIPMODEL:`	1249	`case FILETYPE_SHIPMODEL:`
1250	`return "ShipModel";`	1250	`return L"ShipModel";`
1251	`case FILETYPE_SHIPSCENE:`	1251	`case FILETYPE_SHIPSCENE:`
1252	`return "ShipScene";`	1252	`return L"ShipScene";`
1253	`case FILETYPE_COCKPITSCENE:`	1253	`case FILETYPE_COCKPITSCENE:`
1254	`return "CockpitScene";`	1254	`return L"CockpitScene";`
1255	`}`	1255	`}`
1256		1256
1257	`return Utils::String::Null();`	1257	`return Utils::WString::Null();`
1258	`}`	1258	`}`
1259		1259
1260	`FileType GetFileTypeFromString(const Utils::String &type)`	1260	`FileType GetFileTypeFromString(const Utils::WString &type)`
1261	`{`	1261	`{`
1262	`Utils::String ltype = type.lower();`	1262	`Utils::WString ltype = type.lower();`
1263	`if ( ltype == "script" \|\| ltype == "scriptpck")`	1263	`if ( ltype == L"script" \|\| ltype == L"scriptpck")`
1264	`return FILETYPE_SCRIPT;`	1264	`return FILETYPE_SCRIPT;`
1265	`else if ( ltype == "text" )`	1265	`else if ( ltype == L"text" )`
1266	`return FILETYPE_TEXT;`	1266	`return FILETYPE_TEXT;`
1267	`else if ( ltype == "readme" )`	1267	`else if ( ltype == L"readme" )`
1268	`return FILETYPE_README;`	1268	`return FILETYPE_README;`
1269	`else if ( ltype == "map" )`	1269	`else if ( ltype == L"map" )`
1270	`return FILETYPE_MAP;`	1270	`return FILETYPE_MAP;`
1271	`else if ( ltype == "mod" )`	1271	`else if ( ltype == L"mod" )`
1272	`return FILETYPE_MOD;`	1272	`return FILETYPE_MOD;`
1273	`else if ( ltype == "uninstall" )`	1273	`else if ( ltype == L"uninstall" )`
1274	`return FILETYPE_UNINSTALL;`	1274	`return FILETYPE_UNINSTALL;`
1275	`else if ( ltype == "sound" )`	1275	`else if ( ltype == L"sound" )`
1276	`return FILETYPE_SOUND;`	1276	`return FILETYPE_SOUND;`
1277	`else if ( ltype == "extra" )`	1277	`else if ( ltype == L"extra" )`
1278	`return FILETYPE_EXTRA;`	1278	`return FILETYPE_EXTRA;`

Subversion Repositories spk

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