Subversion Repositories spk

Rev

Rev 164 | Rev 168 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 164 Rev 166
Line 629... Line 629...
629
					break;
629
					break;
630
				}
630
				}
631
			}
631
			}
632
		}
632
		}
633
	}
633
	}
-
 
634
 
-
 
635
	readAvailablePackages();
634
 
636
 
635
	// check the purged time
637
	// check the purged time
636
	this->PurgeGameObjects();
638
	this->PurgeGameObjects();
637
 
639
 
638
	m_bLoaded = true;
640
	m_bLoaded = true;
Line 1030... Line 1032...
1030
			Utils::String model = data.token(";", i);
1032
			Utils::String model = data.token(";", i);
1031
			Utils::String modelExt = model.right(4);
1033
			Utils::String modelExt = model.right(4);
1032
			// check file extension
1034
			// check file extension
1033
			if ( modelExt.Compare(".bod") || modelExt.Compare(".pbd") )
1035
			if ( modelExt.Compare(".bod") || modelExt.Compare(".pbd") )
1034
				data = data.replaceToken(";", i, model.left(-4));
1036
				data = data.replaceToken(";", i, model.left(-4));
1035
		}
1037
		}
1036
 
1038
 
1037
		xsp->SetShipData(data);
1039
		xsp->SetShipData(data);
1038
	}
1040
	}
1039
 
1041
 
1040
	// any extra files that are in director folder
1042
	// any extra files that are in director folder
Line 1563... Line 1565...
1563
				else
1565
				else
1564
				{
1566
				{
1565
					for ( CListNode<C_File> *node = oldPackage->GetFileList()->Front(); node; node = node->next() )
1567
					for ( CListNode<C_File> *node = oldPackage->GetFileList()->Front(); node; node = node->next() )
1566
					{
1568
					{
1567
						if ( !node->Data() )
1569
						if ( !node->Data() )
1568
							continue;
1570
							continue;
1569
						if ( node->Data()->GetFileType() != FILETYPE_MOD )
1571
						if ( node->Data()->GetFileType() != FILETYPE_MOD )
1570
							continue;
1572
							continue;
1571
						// we only need the cat file
1573
						// we only need the cat file
1572
						if ( !node->Data()->CheckFileExt("cat") )
1574
						if ( !node->Data()->CheckFileExt("cat") )
1573
							continue;
1575
							continue;
Line 1629... Line 1631...
1629
						{
1631
						{
1630
							Utils::String oldFilePointer = match->filePointer();
1632
							Utils::String oldFilePointer = match->filePointer();
1631
							match->setDir("");
1633
							match->setDir("");
1632
							match->changeBaseName(next);
1634
							match->changeBaseName(next);
1633
							if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + match->getNameDirectory(package)) )
1635
							if ( CFileIO(oldFilePointer).Rename(m_sCurrentDir + "/" + match->getNameDirectory(package)) )
1634
								match->setFilename(m_sCurrentDir + "/" + match->getNameDirectory(package));
1636
								match->setFilename(m_sCurrentDir + "/" + match->getNameDirectory(package));
1635
						}
1637
						}
1636
					}
1638
					}
1637
					else
1639
					else
1638
					{
1640
					{
1639
						C_File *match = package->FindMatchingMod(f->Data());
1641
						C_File *match = package->FindMatchingMod(f->Data());
1640
 
1642
 
Line 1647... Line 1649...
1647
							if ( CFileIO(match->filePointer()).Rename(m_sCurrentDir + "/" + match->getNameDirectory(package)) )
1649
							if ( CFileIO(match->filePointer()).Rename(m_sCurrentDir + "/" + match->getNameDirectory(package)) )
1648
								match->setFilename(m_sCurrentDir + "/" + match->getNameDirectory(package));
1650
								match->setFilename(m_sCurrentDir + "/" + match->getNameDirectory(package));
1649
						}
1651
						}
1650
					}
1652
					}
1651
				}
1653
				}
1652
			}
1654
			}
1653
 
1655
 
1654
			package->GetFileList()->RemoveEmpty();
1656
			package->GetFileList()->RemoveEmpty();
1655
			((CSpkFile *)oldPackage)->MergePackage(package);
1657
			((CSpkFile *)oldPackage)->MergePackage(package);
1656
			delete package;
1658
			delete package;
1657
			package = oldPackage;
1659
			package = oldPackage;
Line 1680... Line 1682...
1680
			{
1682
			{
1681
				if ( !Dir.create("PluginManager") )
1683
				if ( !Dir.create("PluginManager") )
1682
					ready = false;
1684
					ready = false;
1683
			}
1685
			}
1684
			if ( ready && !Dir.exists("PluginManager/Icons") )
1686
			if ( ready && !Dir.exists("PluginManager/Icons") )
1685
			{
1687
			{
1686
				if ( !Dir.create("PluginManager/Icons") )
1688
				if ( !Dir.create("PluginManager/Icons") )
1687
					ready = false;
1689
					ready = false;
1688
			}
1690
			}
1689
 
1691
 
1690
			if ( ready )
1692
			if ( ready )
Line 1696... Line 1698...
1696
					CFileIO iconFile(m_sCurrentDir + "/PluginManager/Icons/" + package->author() + "_" + package->name() + "." + package->iconExt());
1698
					CFileIO iconFile(m_sCurrentDir + "/PluginManager/Icons/" + package->author() + "_" + package->name() + "." + package->iconExt());
1697
					if ( iconFile.WriteData((const char *)icon->GetData(), icon->GetDataSize()) )
1699
					if ( iconFile.WriteData((const char *)icon->GetData(), icon->GetDataSize()) )
1698
					{
1700
					{
1699
						icon->SetFilename(CyString(package->author()) + "_" + package->name() + "." + package->iconExt());
1701
						icon->SetFilename(CyString(package->author()) + "_" + package->name() + "." + package->iconExt());
1700
						icon->SetFullDir(m_sCurrentDir + "/PluginManager/Icons");
1702
						icon->SetFullDir(m_sCurrentDir + "/PluginManager/Icons");
1701
					}
1703
					}
1702
					else
1704
					else
1703
						package->SetIcon(NULL, "");
1705
						package->SetIcon(NULL, "");
1704
				}
1706
				}
1705
			}
1707
			}
1706
 
1708
 
Line 3826... Line 3828...
3826
									added = true;
3828
									added = true;
3827
									break;
3829
									break;
3828
								}
3830
								}
3829
							}
3831
							}
3830
							if(!added)
3832
							if(!added)
3831
								foundPackages->push_front(itr->Data());
3833
								foundPackages->push_front(itr->Data());
3832
						}
3834
						}
3833
						found = true;
3835
						found = true;
3834
						break;
3836
						break;
3835
					}
3837
					}
3836
				}
3838
				}
3837
				if (!found)
3839
				if (!found)
3838
					return false;
3840
					return false;
3839
			}
3841
			}
Line 4095... Line 4097...
4095
int CPackages::RemoveUnusedSharedFiles(CyStringList *errors, CProgressInfo *progress)
4097
int CPackages::RemoveUnusedSharedFiles(CyStringList *errors, CProgressInfo *progress)
4096
{
4098
{
4097
	UpdateUsedFiles();
4099
	UpdateUsedFiles();
4098
	int files = 0;
4100
	int files = 0;
4099
	int done = 0;
4101
	int done = 0;
4100
 
4102
 
4101
	for ( CListNode<C_File> *node = m_lFiles.Back(); node; node = node->prev() )
4103
	for ( CListNode<C_File> *node = m_lFiles.Back(); node; node = node->prev() )
4102
	{
4104
	{
4103
		if ( progress )
4105
		if ( progress )
4104
			progress->UpdateProgress(files, m_lFiles.size());
4106
			progress->UpdateProgress(files, m_lFiles.size());
4105
		files++;
4107
		files++;
4106
 
4108
 
4107
		C_File *file = node->Data();
4109
		C_File *file = node->Data();
4108
 
4110
 
4109
		// only do marked shared files
4111
		// only do marked shared files
4110
		if ( !file->IsShared() )
4112
		if ( !file->IsShared() )
4111
			continue;
4113
			continue;
4112
 
4114
 
4113
		// only do ones that are no longer needed
4115
		// only do ones that are no longer needed
4114
		if ( file->getUsed() )
4116
		if ( file->getUsed() )
4115
			continue;
4117
			continue;
4116
 
4118
 
4117
		if ( RemoveSharedFile(file, errors) )
4119
		if ( RemoveSharedFile(file, errors) )
4118
			++done;
4120
			++done;
4119
		node->ChangeData(NULL);
4121
		node->ChangeData(NULL);
4120
	}
4122
	}
4121
 
4123
 
4122
	m_lFiles.RemoveEmpty();
4124
	m_lFiles.RemoveEmpty();
4123
 
4125
 
4124
	return done;
4126
	return done;
4125
}
4127
}
4126
 
4128
 
4127
/**
4129
/**
4128
 * Any Unused Shared
4130
 * Any Unused Shared
4129
 *
4131
 *
4130
 * Checks if theres any unused shared files available
4132
 * Checks if theres any unused shared files available
4131
 *
4133
 *
4132
 * Any file thats marked as shared, and is no longer connected to any installed package
4134
 * Any file thats marked as shared, and is no longer connected to any installed package
4133
 */
4135
 */
4134
bool CPackages::AnyUnusedShared()
4136
bool CPackages::AnyUnusedShared()
4135
{
4137
{
Line 4171... Line 4173...
4171
			continue;
4173
			continue;
4172
 
4174
 
4173
		// we need to rename it
4175
		// we need to rename it
4174
		int current = findNextTextFile();
4176
		int current = findNextTextFile();
4175
		if ( current < f->GetTextFileID() )
4177
		if ( current < f->GetTextFileID() )
4176
		{
4178
		{
4177
			CFileIO moveFile(f->filePointer());
4179
			CFileIO moveFile(f->filePointer());
4178
	
4180
	
4179
			Utils::String newName = SPK::FormatTextName(current, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT)) + "." + moveFile.extension();
4181
			Utils::String newName = SPK::FormatTextName(current, m_iLanguage, (m_iGameFlags & EXEFLAG_TCTEXT)) + "." + moveFile.extension();
4180
			if ( moveFile.Rename(m_sCurrentDir + "/t/" + newName) )
4182
			if ( moveFile.Rename(m_sCurrentDir + "/t/" + newName) )
4181
			{
4183
			{
Line 4202... Line 4204...
4202
	// lets make sure our order is correct
4204
	// lets make sure our order is correct
4203
	// find Lowest Fake Patch Installed
4205
	// find Lowest Fake Patch Installed
4204
	CLinkList<C_File> doneList;
4206
	CLinkList<C_File> doneList;
4205
	int lowest = FindLowestFakePatchInstalled();
4207
	int lowest = FindLowestFakePatchInstalled();
4206
	if ( check < lowest ) lowest = check; // gap at the beginning, lets use that
4208
	if ( check < lowest ) lowest = check; // gap at the beginning, lets use that
4207
 
4209
 
4208
	// find all packages that need to go before or after other packages
4210
	// find all packages that need to go before or after other packages
4209
	std::set<CBaseFile*> packagesBefore;
4211
	std::set<CBaseFile*> packagesBefore;
4210
	std::map<CBaseFile*, std::set<CBaseFile*>> packagesAfter;
4212
	std::map<CBaseFile*, std::set<CBaseFile*>> packagesAfter;
4211
	for (CListNode<CBaseFile>* pNode = m_lPackages.Front(); pNode; pNode = pNode->next())
4213
	for (CListNode<CBaseFile>* pNode = m_lPackages.Front(); pNode; pNode = pNode->next())
4212
	{
4214
	{
Line 4214... Line 4216...
4214
		// search for any fake patches in package
4216
		// search for any fake patches in package
4215
		if (!p->IsEnabled()) continue;
4217
		if (!p->IsEnabled()) continue;
4216
		if (!p->AnyFileType(FILETYPE_MOD)) continue;
4218
		if (!p->AnyFileType(FILETYPE_MOD)) continue;
4217
 
4219
 
4218
		if (p->AnyDependacies())
4220
		if (p->AnyDependacies())
4219
		{
4221
		{
4220
			for (SNeededLibrary* nl = p->GetNeededLibraries()->First(); nl; nl = p->GetNeededLibraries()->Next())
4222
			for (SNeededLibrary* nl = p->GetNeededLibraries()->First(); nl; nl = p->GetNeededLibraries()->Next())
4221
			{
4223
			{
4222
				auto package = FindPackage(nl->sName, nl->sAuthor);
4224
				auto package = FindPackage(nl->sName, nl->sAuthor);
4223
				if (package)
4225
				if (package)
4224
				{
4226
				{
4225
					packagesBefore.insert(package);
4227
					packagesBefore.insert(package);
4226
					packagesAfter[p].insert(package);
4228
					packagesAfter[p].insert(package);
4227
				}
4229
				}
4228
			}
4230
			}
4229
		}
4231
		}
4230
		CSpkFile* spk = dynamic_cast<CSpkFile*>(p);
4232
		CSpkFile* spk = dynamic_cast<CSpkFile*>(p);
4231
		if (spk)
4233
		if (spk)
4232
		{
4234
		{
4233
			if (spk->IsAnotherMod())
4235
			if (spk->IsAnotherMod())
4234
			{
4236
			{
4235
				auto package = FindPackage(spk->otherName(), spk->otherAuthor());
4237
				auto package = FindPackage(spk->otherName(), spk->otherAuthor());
4236
				if (package)
4238
				if (package)
4237
				{
4239
				{
4238
					packagesBefore.insert(package);
4240
					packagesBefore.insert(package);
4239
					packagesAfter[p].insert(package);
4241
					packagesAfter[p].insert(package);
Line 4762... Line 4764...
4762
	{
4764
	{
4763
		CFileIO File(Dir.file("lang.dat"));
4765
		CFileIO File(Dir.file("lang.dat"));
4764
 
4766
 
4765
		size_t size;
4767
		size_t size;
4766
		char *data = File.ReadToData(&size);
4768
		char *data = File.ReadToData(&size);
4767
 
4769
 
4768
		if ( data )
4770
		if ( data )
4769
		{
4771
		{
4770
			Utils::String str(data);
4772
			Utils::String str(data);
4771
			m_iLanguage = str.token("\n", 1).token(" ", 1).toInt();
4773
			m_iLanguage = str.token("\n", 1).token(" ", 1).toInt();
4772
		}
4774
		}
Line 4862... Line 4864...
4862
					useId = 49;
4864
					useId = 49;
4863
				// if we have not found a valid language yet, we will use this one
4865
				// if we have not found a valid language yet, we will use this one
4864
				else if ( !useId )
4866
				else if ( !useId )
4865
					useId = num;
4867
					useId = num;
4866
			}
4868
			}
4867
		}
4869
		}
4868
 
4870
 
4869
		if (found)
4871
		if (found)
4870
		{
4872
		{
4871
			CLEANSPLIT(data, size);
4873
			CLEANSPLIT(data, size);
4872
			continue;
4874
			continue;
4873
		}
4875
		}
4874
 
4876
 
4875
		if ( !useId )
4877
		if ( !useId )
4876
			useId = data[0].toInt();
4878
			useId = data[0].toInt();
4877
		if ( !useId )
4879
		if ( !useId )
4878
			useId = -1;
4880
			useId = -1;
4879
 
4881
 
4880
		CLEANSPLIT(data, size);
4882
		CLEANSPLIT(data, size);
4881
		RenameTextFile((*itr)->str, useId, errors);
4883
		RenameTextFile((*itr)->str, useId, errors);
4882
	}
4884
	}
4883
}
4885
}
4884
 
4886
 
4885
/**
4887
/**
4886
 * Rename a text file
4888
 * Rename a text file
4887
 *
4889
 *
4888
 * Creates a new text file for the selected langage by copying an existing one
4890
 * Creates a new text file for the selected langage by copying an existing one
4889
 */
4891
 */
Line 4895... Line 4897...
4895
	if ( !addFile )
4897
	if ( !addFile )
4896
		addFile = FindFile(FILETYPE_TEXT, newFilename + ".pck");
4898
		addFile = FindFile(FILETYPE_TEXT, newFilename + ".pck");
4897
 
4899
 
4898
	// we have found the file, lets just add it to our scripts
4900
	// we have found the file, lets just add it to our scripts
4899
	if ( addFile )
4901
	if ( addFile )
4900
	{
4902
	{
4901
		AddTextFileToScripts(addFile, textid);
4903
		AddTextFileToScripts(addFile, textid);
4902
		return true;
4904
		return true;
4903
	}
4905
	}
4904
 
4906
 
4905
	// first we need to find our text file
4907
	// first we need to find our text file
Line 8094... Line 8096...
8094
 
8096
 
8095
	return 0;
8097
	return 0;
8096
}
8098
}
8097
 
8099
 
8098
size_t CPackages::addFoundPackages(const Utils::String& dir)
8100
size_t CPackages::addFoundPackages(const Utils::String& dir)
8099
{
8101
{
8100
	return findPackageDirectories(m_lFoundPackages, dir);
8102
	return findPackageDirectories(m_lFoundPackages, dir);
8101
}
8103
}
8102
 
8104
 
8103
int CPackages::findAllPackages(CLinkList<CBaseFile> &packages, const Utils::String &dir)
8105
int CPackages::findAllPackages(CLinkList<CBaseFile> &packages, const Utils::String &dir)
8104
{
8106
{
Line 8159... Line 8161...
8159
		{
8161
		{
8160
			Utils::String f = Dir.file((*itr)->str);
8162
			Utils::String f = Dir.file((*itr)->str);
8161
			int error = 0;
8163
			int error = 0;
8162
			CBaseFile *p = this->OpenPackage(f, &error, 0, SPKREAD_NODATA, READFLAG_NOUNCOMPRESS);
8164
			CBaseFile *p = this->OpenPackage(f, &error, 0, SPKREAD_NODATA, READFLAG_NOUNCOMPRESS);
8163
			if (!p)
8165
			if (!p)
8164
				continue;
8166
				continue;
8165
			if (p->IsMod() || this->FindSpkPackage(p->name(), p->author()))
8167
			if (p->IsMod() || this->FindSpkPackage(p->name(), p->author()))
8166
			{
8168
			{
8167
				delete p;
8169
				delete p;
8168
				continue;
8170
				continue;
8169
			}
8171
			}
8170
 
8172
 
8171
			// check its for the correct game
8173
			// check its for the correct game
8172
			if (!p->CheckGameCompatability(this->GetGame()))
8174
			if (!p->CheckGameCompatability(this->GetGame()))
8173
			{
8175
			{
8174
				delete p;
8176
				delete p;
8175
				continue;
8177
				continue;
8176
			}
8178
			}
8177
 
8179
 
8178
			// check if its already on the list
8180
			// check if its already on the list
8179
			bool found = false;
8181
			bool found = false;
8180
			for (CBaseFile *checkp = packages.First(); checkp; checkp = packages.Next())
8182
			for (CBaseFile *checkp = packages.First(); checkp; checkp = packages.Next())
8181
			{
8183
			{
8182
				if (p->name().Compare(checkp->name()) && p->author().Compare(checkp->author()))
8184
				if (p->name().Compare(checkp->name()) && p->author().Compare(checkp->author()))
8183
				{
8185
				{
8184
					found = true;
8186
					found = true;
8185
					break;
8187
					break;
8186
				}
8188
				}
Line 8226... Line 8228...
8226
				if (!done)
8228
				if (!done)
8227
					f->DeleteData();
8229
					f->DeleteData();
8228
			}
8230
			}
8229
 
8231
 
8230
			packages.push_back(p);
8232
			packages.push_back(p);
8231
			++count;
8233
			++count;
8232
		}
8234
		}
8233
	}
8235
	}
8234
 
8236
 
8235
	return count;
8237
	return count;
8236
}
8238
}
8237
 
8239
 
8238
Utils::String CPackages::ConvertLanguage(int lang)
8240
Utils::String CPackages::ConvertLanguage(int lang)
Line 8291... Line 8293...
8291
	// check if file exists and remove it
8293
	// check if file exists and remove it
8292
	if ( File.exists() )
8294
	if ( File.exists() )
8293
	{
8295
	{
8294
		// if we cant remove it, we dont have enough rights
8296
		// if we cant remove it, we dont have enough rights
8295
		if ( !File.remove() )
8297
		if ( !File.remove() )
8296
			return false;
8298
			return false;
8297
 
8299
 
8298
		// if its still there, we dont have enough rights
8300
		// if its still there, we dont have enough rights
8299
		if ( File.exists() )
8301
		if ( File.exists() )
8300
			return false;
8302
			return false;
8301
	}
8303
	}
Line 8339... Line 8341...
8339
		CCatFile cat;
8341
		CCatFile cat;
8340
		if ( cat.open(file.ToString(), this->getAddonDir(), CATREAD_CATDECRYPT, false) != CATERR_NONE )
8342
		if ( cat.open(file.ToString(), this->getAddonDir(), CATREAD_CATDECRYPT, false) != CATERR_NONE )
8341
			return false;
8343
			return false;
8342
 
8344
 
8343
		if ( !cat.ExtractFile("types\\TShips.pck", m_sTempDir + "/tships.txt") )
8345
		if ( !cat.ExtractFile("types\\TShips.pck", m_sTempDir + "/tships.txt") )
8344
			return false;
8346
			return false;
8345
 
8347
 
8346
		File.open(m_sTempDir + "/tships.txt");
8348
		File.open(m_sTempDir + "/tships.txt");
8347
		deleteFile = true;
8349
		deleteFile = true;
8348
	}
8350
	}
8349
	// otherwise its a normal file
8351
	// otherwise its a normal file
8350
	else if ( CFileIO(file).isFileExtension("pck") )
8352
	else if ( CFileIO(file).isFileExtension("pck") )
8351
	{
8353
	{
8352
		C_File f(file.ToString());
8354
		C_File f(file.ToString());
Line 8357... Line 8359...
8357
		f.SetFilename(m_sTempDir + "/tships.txt");
8359
		f.SetFilename(m_sTempDir + "/tships.txt");
8358
		if ( !f.writeFilePointer() )
8360
		if ( !f.writeFilePointer() )
8359
			return false;
8361
			return false;
8360
 
8362
 
8361
		File.open(m_sTempDir + "/tships.txt");
8363
		File.open(m_sTempDir + "/tships.txt");
8362
		deleteFile = true;
8364
		deleteFile = true;
8363
	}
8365
	}
8364
	else
8366
	else
8365
		File.open(file.ToString());
8367
		File.open(file.ToString());
8366
 
8368
 
8367
	if ( !File.exists() )
8369
	if ( !File.exists() )
8368
		return false;
8370
		return false;
8369
 
8371
 
8370
	bool ret = false;
8372
	bool ret = false;
8371
	CyStringList *lines = File.ReadLinesStr();
8373
	CyStringList *lines = File.ReadLinesStr();
Line 8761... Line 8763...
8761
{
8763
{
8762
	// not a valid file
8764
	// not a valid file
8763
	if ( !file ) return false;
8765
	if ( !file ) return false;
8764
	if ( file->GetFileType() != FILETYPE_MOD ) return false;
8766
	if ( file->GetFileType() != FILETYPE_MOD ) return false;
8765
	if ( !file->GetFileExt().Compare("cat") ) return false;
8767
	if ( !file->GetFileExt().Compare("cat") ) return false;
8766
 
8768
 
8767
	// we need to read the file list for the mod
8769
	// we need to read the file list for the mod
8768
	CCatFile cat;
8770
	CCatFile cat;
8769
	if ( cat.open(file->filePointer(), this->getAddonDir(), CATREAD_JUSTCONTENTS, false) == CATERR_NONE )
8771
	if ( cat.open(file->filePointer(), this->getAddonDir(), CATREAD_JUSTCONTENTS, false) == CATERR_NONE )
8770
	{
8772
	{
8771
		for (unsigned int i = 0; i < cat.GetNumFiles(); i++ )
8773
		for (unsigned int i = 0; i < cat.GetNumFiles(); i++ )
Line 9159... Line 9161...
9159
			return true;
9161
			return true;
9160
		m_lAvailablePackages.remove(p);
9162
		m_lAvailablePackages.remove(p);
9161
	}
9163
	}
9162
 
9164
 
9163
	m_lAvailablePackages.push_back(package); 
9165
	m_lAvailablePackages.push_back(package); 
9164
 
-
 
-
 
9166
	saveAvailablePackages();
9165
	return true;
9167
	return true;
-
 
9168
}
-
 
9169
 
-
 
9170
void CPackages::saveAvailablePackages()
-
 
9171
{
-
 
9172
	std::vector<Utils::String> lines;
-
 
9173
 
-
 
9174
	lines.push_back("Version;1;" + Utils::String::Number(m_lAvailablePackages.size()));
-
 
9175
 
-
 
9176
	for (auto itr = m_lAvailablePackages.First(); itr; itr = m_lAvailablePackages.Next())
-
 
9177
	{
-
 
9178
		Utils::String l = "Package";
-
 
9179
		l += ";" + itr->sName.findReplace(";", ":&COL&:");
-
 
9180
		l += ";" + itr->sAuthor.findReplace(";", ":&COL&:");
-
 
9181
		l += ";" + itr->sVersion.findReplace(";", ":&COL&:");
-
 
9182
		l += ";" + itr->sFilename;
-
 
9183
		l += ";" + itr->sDesc.findReplace(";", ":&COL&:");
-
 
9184
		l += ";" + itr->sUpdated;
-
 
9185
 
-
 
9186
		l += ";" + Utils::String::Number(itr->lGames.size());
-
 
9187
 
-
 
9188
		for (auto g = itr->lGames.First(); g; g = itr->lGames.Next())
-
 
9189
			l += ";" + Utils::String::Number(g->iGame) + ";" + Utils::String::Number(g->iVersion) + ";" + g->sVersion;
-
 
9190
 
-
 
9191
		l += ";" + Utils::String::Number(itr->iType);
-
 
9192
		l += ";" + Utils::String::Number(itr->iPluginType);
-
 
9193
		l += ";" + Utils::String::Number(itr->iScriptType);
-
 
9194
		l += ";" + Utils::String::Number(itr->iChanging);
-
 
9195
		l += ";" + Utils::String::Number(itr->iEase);
-
 
9196
		l += ";" + Utils::String::Number(itr->iRec);
-
 
9197
		l += itr->bSigned ? ";1" : ";0";
-
 
9198
 
-
 
9199
		lines.push_back(l);
-
 
9200
	}
-
 
9201
 
-
 
9202
	// write out the file
-
 
9203
	CDirIO dir(m_sCurrentDir + "/PluginManager");
-
 
9204
	if (!dir.exists())
-
 
9205
		dir.create();
-
 
9206
	CFileIO file(dir.file("packagecache.new"));
-
 
9207
	if (file.writeFile(&lines))
-
 
9208
	{
-
 
9209
		if (CFileIO::Exists(dir.file("packagecache.new")))
-
 
9210
		{
-
 
9211
			if (CFileIO::Exists(dir.file("packagecache.dat")))
-
 
9212
				CFileIO::Remove(dir.file("packagecache.dat"));
-
 
9213
			file.Rename(dir.file("packagecache.dat"));
-
 
9214
		}
-
 
9215
	}
-
 
9216
}
-
 
9217
 
-
 
9218
void CPackages::readAvailablePackages()
-
 
9219
{
-
 
9220
	m_lAvailablePackages.MemoryClear();
-
 
9221
 
-
 
9222
	CDirIO dir(m_sCurrentDir + "/PluginManager");
-
 
9223
	CFileIO file(dir.file("packagecache.dat"));
-
 
9224
 
-
 
9225
	if (file.exists())
-
 
9226
	{
-
 
9227
 
-
 
9228
		size_t version = 0;
-
 
9229
		size_t count = 0;
-
 
9230
		std::vector<Utils::String> lines;
-
 
9231
		if (file.readLines(lines))
-
 
9232
		{
-
 
9233
			for (auto itr = lines.begin(); itr != lines.end(); itr++)
-
 
9234
			{
-
 
9235
				Utils::String cmd = itr->token(";", 1);
-
 
9236
				if (cmd == "Version")
-
 
9237
				{
-
 
9238
					version = itr->token(";", 2).toInt();
-
 
9239
					count = itr->token(";", 3).toInt();
-
 
9240
				}
-
 
9241
				else if (cmd == "Package")
-
 
9242
				{
-
 
9243
					int max = 0;
-
 
9244
					Utils::String *str = itr->tokenise(";", &max);
-
 
9245
 
-
 
9246
					SAvailablePackage* package = new SAvailablePackage;
-
 
9247
					int pos = 1;
-
 
9248
					package->sName = str[pos++].findReplace(":&COL&:", ";");
-
 
9249
					package->sAuthor = str[pos++].findReplace(":&COL&:", ";");
-
 
9250
					package->sVersion = str[pos++].findReplace(":&COL&:", ";");
-
 
9251
					package->sFilename = str[pos++].findReplace(":&COL&:", ";");
-
 
9252
					package->sDesc = str[pos++].findReplace(":&COL&:", ";");
-
 
9253
					package->sUpdated = str[pos++].findReplace(":&COL&:", ";");
-
 
9254
 
-
 
9255
					size_t games = str[pos++].toInt();
-
 
9256
					for (size_t i = 0; i < games; i++)
-
 
9257
					{
-
 
9258
						SGameCompat* g = new SGameCompat;
-
 
9259
						g->iGame = str[pos++].toInt();
-
 
9260
						g->iVersion = str[pos++].toInt();
-
 
9261
						g->sVersion = str[pos++];
-
 
9262
						package->lGames.push_back(g);
-
 
9263
					}
-
 
9264
 
-
 
9265
					package->iType = str[pos++].toInt();
-
 
9266
					package->iPluginType = str[pos++].toInt();
-
 
9267
					package->iScriptType = str[pos++].toInt();
-
 
9268
					package->iChanging = str[pos++].toInt();
-
 
9269
					package->iEase = str[pos++].toInt();
-
 
9270
					package->iRec = str[pos++].toInt();
-
 
9271
					package->bSigned = (str[pos] == "1");
-
 
9272
 
-
 
9273
					CLEANSPLIT(str, max);
-
 
9274
 
-
 
9275
					addAvailablePackage(package);
-
 
9276
				}
-
 
9277
			}
-
 
9278
		}
-
 
9279
	}
9166
}
9280
}
9167
 
9281
 
9168
bool CPackages::AnyAvailablePackages(int type)
9282
bool CPackages::AnyAvailablePackages(int type)
9169
{
9283
{
9170
	if ( type == -1 ) return !m_lAvailablePackages.empty();
9284
	if ( type == -1 ) return !m_lAvailablePackages.empty();