Subversion Repositories spk

Rev

Rev 104 | Rev 125 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 cycrow 1 
#include "../StdAfx.h"
2 
#include "MainGui.h"
3 
#include "ModSelector.h"
4 
#include "PackageBrowser.h"
5 
#include "InstallPackageDialog.h"
6 
#include "CompareList.h"
7 
#include "EditGlobals.h"
88 cycrow 8 
#include "EditWares.h"
89 cycrow 9 
#include "CommandSlots.h"
1 cycrow 10 
#include "DownloadPackageList.h"
11 
#include "FileLog.h"
12 
#include "MessageBoxDetails.h"
13 
#include <shellapi.h>
14 
 
15 
using System::Configuration::ApplicationSettingsBase;
16 
 
17 
#undef GetEnvironmentVariable
18 
 
19 
enum {LISTGROUP_INSTALLED, LISTGROUP_SHIP, LISTGROUP_FAKE, LISTGROUP_LIBRARY, LISTGROUP_MOD, LISTGROUP_ARCHIVE};
20 
 
21 
namespace PluginManager {
22 
 
121 cycrow 23 
	void MainGui::OpenDirectoryControl()
24 
	{
25 
		DirectoryControl ^dialog = gcnew DirectoryControl(m_pPackages, m_pDirList, m_pRemovedDirList);
26 
		if (dialog->ShowDialog(this) == System::Windows::Forms::DialogResult::OK)
27 
		{
28 
			Utils::CStringList *dirs = dialog->directories();
29 
			Utils::CStringList *removed = dialog->removeDirectories();
30 
 
31 
			// check if the current directory has been remove
32 
			bool isRemoved = m_pPackages->IsLoaded() && removed->contains(m_pPackages->getCurrentDirectory(), true);
33 
 
34 
			// add all removed directories to list
35 
			m_pRemovedDirList->clear();
36 
			for (auto itr = removed->begin(); itr != removed->end(); itr++)
37 
				m_pRemovedDirList->pushBack(m_pPackages->getProperDir((*itr)->str), (*itr)->data);
38 
 
39 
			bool changed = false;
40 
 
41 
			Utils::String current;
42 
			if (ComboDir->SelectedIndex == (ComboDir->Items->Count - 1))
43 
				current = _S(ComboDir->Text);
44 
			else
45 
				current = m_pDirList->get(ComboDir->SelectedIndex)->str;
46 
 
47 
			// remove any directories from main list that are not removed
48 
			for (int i = m_pDirList->size() - 1; i >= 0; --i)
49 
			{
50 
				Utils::String dir = m_pDirList->get(i)->str;
51 
				if (m_pRemovedDirList->contains(dir))
52 
				{
53 
					m_pDirList->removeAt(i);
54 
					changed = true;
55 
				}
56 
			}
57 
 
58 
			// now add any remaining directories
59 
			for (auto itr = dirs->begin(); itr != dirs->end(); itr++)
60 
			{
61 
				Utils::String dir = m_pPackages->getProperDir((*itr)->str);
62 
				if (!m_pDirList->contains(dir))
63 
				{
64 
					int lang = m_pPackages->GetGameLanguage(dir);
65 
					if(lang > 0)
66 
						m_pDirList->pushBack(dir, Utils::String::Number(lang) + "|" + (*itr)->data);
67 
					else
68 
						m_pDirList->pushBack(dir, (*itr)->data);
69 
					changed = true;
70 
				}
71 
			}
72 
 
73 
			if (isRemoved)
74 
				ComboDir->SelectedIndex = ComboDir->Items->Count - 1;
75 
			else if (changed)
76 
				UpdateDirList(current);
77 
		}
78 
	}
79 
 
80 
	void MainGui::AboutDialog()
81 
	{
82 
		CBaseFile *pm = m_pPackages->FindScriptByAuthor("PluginManager");
83 
		System::String ^scriptVer = "None";
84 
		if (pm)
85 
		{
86 
			scriptVer = _US(pm->version());
87 
			if (!pm->creationDate().empty())
88 
				scriptVer += " (" + _US(pm->creationDate()) + ")";
89 
		}
90 
		About ^about = gcnew About(GetVersionString(), PMLDATE, scriptVer, m_bAdvanced);
91 
		about->ShowDialog(this);
92 
	}
93 
 
94 
 
1 cycrow 95 
	void MainGui::CheckProtectedDir()
96 
	{
121 cycrow 97 
		if (!m_pPackages || !m_pPackages->IsLoaded())
98 
			return;
99 
 
100 
		Utils::String dir = m_pPackages->getCurrentDirectory();
101 
		if(!dir.empty())
102 
		{
1 cycrow 103 
			m_bDirLocked = false;
104 
 
105 
			// write a file in the directory
104 cycrow 106 
			String ^sDir = _US(dir.findReplace("/", "\\"));
1 cycrow 107 
			bool written = true;
108 
			StreamWriter ^sw = nullptr;
109 
			try {
110 
				sw = System::IO::File::CreateText(sDir + "\\checklock.xpmtest");
111 
				sw->WriteLine("can write");
112 
			}
113 
			catch (System::Exception ^) {
114 
				written = false;
115 
			}
116 
			finally	{
117 
				if ( sw )
118 
					delete (IDisposable ^)sw;
119 
			}
120 
 
121 
			// check its there
122 
			if ( written ) {
123 
				written = false;
124 
				cli::array<String ^> ^dirList = IO::Directory::GetFiles(sDir, "*.xpmtest");
125 
				if ( dirList && dirList->Length ) {
126 
					for ( int i = 0; i < dirList->Length; i++ ) {
127 
						if ( IO::FileInfo(dirList[i]).Name == "checklock.xpmtest" ) {
128 
							written = true;
129 
							break;
130 
						}
131 
					}
132 
				}
133 
			}
134 
 
135 
			// remove it
136 
			if ( !IO::File::Exists(sDir + "\\checklock.xpmtest") )
137 
				written = false;
138 
			else {
139 
				try {
140 
					IO::File::Delete(sDir + "\\checklock.xpmtest");
141 
					if ( IO::File::Exists(sDir + "\\checklock.xpmtest") )
142 
						written = false;
143 
				}
144 
				catch (System::Exception ^) {
145 
					written = false;
146 
				}
147 
			}
148 
 
149 
			if ( !written ) {
104 cycrow 150 
				MessageBox::Show(this, _US(Utils::String::Format(CLanguages::Instance()->findText(LS_STARTUP, LANGSTARTUP_LOCKEDDIR), (char *)dir)), _US(CLanguages::Instance()->findText(LS_STARTUP, LANGSTARTUP_LOCKEDDIR_TITLE)), MessageBoxButtons::OK, MessageBoxIcon::Error);
1 cycrow 151 
				m_bDirLocked = true;
152 
			}
153 
			else {
104 cycrow 154 
				dir = dir.findReplace("/", "\\");
1 cycrow 155 
				bool found = false;
156 
 
157 
				String ^folder = Environment::GetFolderPath(Environment::SpecialFolder::ProgramFiles);
104 cycrow 158 
				if ( dir.isin(_S(folder)) )
1 cycrow 159 
					found = true;
160 
				else {
161 
					folder = Environment::GetEnvironmentVariable("ProgramFiles(x86)");
104 cycrow 162 
					if ( dir.isin(_S(folder)) )
1 cycrow 163 
						found = true;
164 
				}
165 
				if ( !found ) {
166 
					folder = Environment::GetEnvironmentVariable("ProgramFiles");
104 cycrow 167 
					if ( dir.isin(_S(folder)) )
1 cycrow 168 
						found = true;
169 
				}
170 
 
171 
				if ( found ) {
172 
					if ( !m_pPackages->IsSupressProtectedWarning() ) {
104 cycrow 173 
						if ( MessageBox::Show(this, "WARNING: The game directory:\n" + _US(dir) + "\n\nIs in a protected directory (" + _US(CFileIO(dir).dir().tokens("/", 1, 2).findReplace("/", "\\")) + ")\n\nThis might cause problems with installing anything, its better to move to game elsewhere, or you may need to run the Plugin Manager with admin access rights\n\nWould you like to surpress this warning in the future?", "Protected Directory", MessageBoxButtons::YesNo, MessageBoxIcon::Warning) == Windows::Forms::DialogResult::Yes ) {
1 cycrow 174 
							m_pPackages->SurpressProtectedWarning();
175 
						}
176 
					}
177 
				}
178 
			}
179 
		}
180 
	}
181 
 
121 cycrow 182 
	void MainGui::UpdateDirList(const Utils::String &current)
1 cycrow 183 
	{
121 cycrow 184 
		System::String ^checkCurrent = ComboDir->Text;
185 
		System::String ^selected = nullptr;
186 
		bool foundCurrent = false;
187 
 
188 
		ComboDir->Items->Clear();
189 
 
190 
		if (m_pDirList && !m_pDirList->empty())
1 cycrow 191 
		{
121 cycrow 192 
			for(auto itr = m_pDirList->begin(); itr != m_pDirList->end(); itr++)
1 cycrow 193 
			{
121 cycrow 194 
				System::String ^str;
195 
				if ((*itr)->data.isin("|"))
196 
					str = _US((*itr)->str + " [" + (*itr)->data.tokens("|", 2) + "] (Language: " + CPackages::ConvertLanguage((*itr)->data.token("|", 1).toInt()) + ")");
197 
				else
198 
					str = _US((*itr)->str + " [" + (*itr)->data + "]");
199 
				ComboDir->Items->Add(str);
1 cycrow 200 
 
121 cycrow 201 
				if (!current.empty() && current.Compare((*itr)->str))
202 
					selected = str;
203 
 
204 
				if (!foundCurrent && System::String::Compare(str, checkCurrent) == 0)
205 
					foundCurrent = true;
1 cycrow 206 
			}
207 
		}
208 
 
121 cycrow 209 
		ComboDir->Items->Add("-- None --");
210 
		if (selected && selected->Length > 0)
211 
			ComboDir->Text = selected;
212 
		else if (current == "-- None --")
213 
			ComboDir->Text = "-- None --";
214 
		else if(!foundCurrent || !ComboDir->Text || ComboDir->Text->Length < 1)
215 
			ComboDir->Text = ComboDir->Items[0]->ToString();
1 cycrow 216 
 
217 
		this->UpdateRunButton();
218 
	}
219 
 
220 
	void MainGui::UpdateRunButton()
221 
	{
121 cycrow 222 
		if (!m_pPackages || !m_pPackages->IsLoaded())
223 
		{
224 
			ButRun->Visible = false;
225 
			return;
226 
		}
227 
 
228 
		ButRun->Text = "Run: " + _US(m_pPackages->getGameName());
229 
		ButRun->Visible = true;
1 cycrow 230 
 
121 cycrow 231 
		Utils::String exe = m_pPackages->GetGameExe()->GetGameRunExe(m_pPackages->getCurrentDirectory());
232 
		if ( CFileIO(exe).exists() )
1 cycrow 233 
		{
121 cycrow 234 
			exe = exe.findReplace("/", "\\");
1 cycrow 235 
			wchar_t wText[200];
121 cycrow 236 
			::MultiByteToWideChar(CP_ACP, NULL, (char *)exe.c_str(), -1, wText, exe.length() + 1);
1 cycrow 237 
 
238 
			System::Drawing::Icon ^myIcon;
239 
			SHFILEINFO *shinfo = new SHFILEINFO();
240 
 
241 
			if ( FAILED(SHGetFileInfo(wText, 0, shinfo, sizeof(shinfo), SHGFI_ICON | SHGFI_LARGEICON)) )
242 
			{
243 
				if ( FAILED(SHGetFileInfo(wText, 0, shinfo, sizeof(shinfo), SHGFI_ICON | SHGFI_SMALLICON)) )
244 
				{
245 
					System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(MainGui::typeid));
246 
					this->ButRun->Image = (cli::safe_cast<System::Drawing::Image^  >(resources->GetObject(L"ButRun.Image")));
247 
				}
248 
				else
249 
				{
250 
					myIcon = System::Drawing::Icon::FromHandle(IntPtr(shinfo->hIcon));
251 
					ButRun->Image = myIcon->ToBitmap();
252 
				}
253 
			}
254 
			else
255 
			{
256 
				myIcon = System::Drawing::Icon::FromHandle(IntPtr(shinfo->hIcon));
257 
				ButRun->Image = myIcon->ToBitmap();
258 
			}
259 
 
260 
			delete shinfo;
261 
		}
262 
	}
263 
 
264 
	void MainGui::_DisplayPackages(CBaseFile *currentParent, ListViewGroup ^useGroup)
265 
	{
266 
		CLinkList<CBaseFile> packageList;
267 
 
268 
		for ( CBaseFile *p = m_pPackages->FirstPackage(); p; p = m_pPackages->NextPackage() )
269 
		{
270 
			if ( p->IsMod() )
271 
				continue;
50 cycrow 272 
			if ( p->author().Compare("PluginManager") )
1 cycrow 273 
				continue;
274 
			// if thier parent is a library dont add unless top level
275 
			if ( currentParent && p->GetParent() && p->GetParent()->GetType() == TYPE_SPK && ((CSpkFile *)p->GetParent())->IsLibrary() )
276 
				continue;
277 
			else if ( p->GetParent() == currentParent )
278 
				packageList.push_back(p);
279 
			// add any mod addons as the top level
280 
			else if ( p->GetParent() && p->GetParent()->IsMod() && !currentParent && p->GetParent() == m_pPackages->GetEnabledMod() )
281 
				packageList.push_back(p);
282 
			// if thier parent is a library add at top level
283 
			else if ( !currentParent && p->GetParent() && p->GetParent()->GetType() == TYPE_SPK && ((CSpkFile *)p->GetParent())->IsLibrary() )
284 
				packageList.push_back(p);
285 
		}
286 
 
287 
		array<SortPackage ^> ^aPackages = gcnew array<SortPackage ^>(packageList.size());
288 
		array<System::String ^> ^aNames = gcnew array<System::String ^>(packageList.size());
289 
 
290 
		int i = 0;
291 
		for ( CBaseFile *p = packageList.First(); p; p = packageList.Next(), i++ )
292 
		{
293 
			aPackages[i] = gcnew SortPackage(p);
294 
			if ( m_iSortingColumn == SORT_AUTHOR ) // sort by author
50 cycrow 295 
				aNames[i] = _US(p->author())->ToLower();
1 cycrow 296 
			else if ( m_iSortingColumn == SORT_VERSION ) // sort by author
50 cycrow 297 
				aNames[i] = _US(p->version())->ToLower();
1 cycrow 298 
			else if ( m_iSortingColumn == SORT_CREATED ) // sort by author
50 cycrow 299 
				aNames[i] = _US(p->creationDate().token("/", 3) + p->creationDate().token("/", 2) + p->creationDate().token("/", 1));
1 cycrow 300 
			else if ( m_iSortingColumn == SORT_ENABLE ) // sort by author
301 
			{
302 
				if ( p->IsEnabled() )
303 
					aNames[i] = SystemStringFromCyString(CyString::Number(1));
304 
				else
305 
					aNames[i] = SystemStringFromCyString(CyString::Number(0));
306 
			}
307 
			else if ( m_iSortingColumn == SORT_SIGNED ) // sort by author
308 
			{
309 
				if ( p->IsEnabled() )
310 
					aNames[i] = SystemStringFromCyString(CyString::Number(1));
311 
				else
312 
					aNames[i] = SystemStringFromCyString(CyString::Number(0));
313 
			}
314 
			else if ( m_iSortingColumn == SORT_TYPE ) // sort by type
315 
			{
316 
				if ( p->GetType() == TYPE_XSP )
317 
					aNames[i] = "Ship";
318 
				else if ( p->GetType() == TYPE_ARCHIVE )
319 
					aNames[i] = "- Archive -";
320 
				else if ( p->GetType() == TYPE_SPK )
321 
					aNames[i] = SystemStringFromCyString(((CSpkFile *)p)->GetScriptTypeString(m_pPackages->GetLanguage()));
322 
				else
323 
					aNames[i] = "";
324 
			}
325 
			else
326 
				aNames[i] = SystemStringFromCyString(p->GetLanguageName(m_pPackages->GetLanguage()))->ToLower();
327 
		}
328 
 
329 
		Array::Sort(aNames, aPackages);
330 
 
331 
		// now display
332 
		for ( i = 0; i < aPackages->Length; i++ )
333 
		{
334 
			CBaseFile *p = (m_bSortingAsc) ? aPackages[i]->Package : aPackages[(aPackages->Length - 1 - i)]->Package;
335 
			CyString name;
336 
			if ( p->GetType() == TYPE_ARCHIVE )
50 cycrow 337 
				name = CFileIO(p->filename()).GetFilename();
1 cycrow 338 
			else
339 
				name = p->GetLanguageName(m_pPackages->GetLanguage());
340 
 
341 
			int indent = 0;
342 
			CBaseFile *parent = p;
343 
 
344 
			if ( p->GetParent() && p->GetParent()->GetType() == TYPE_SPK && ((CSpkFile *)p->GetParent())->IsLibrary() )
345 
				indent = 0;
346 
			else
347 
			{
348 
				while ( parent->GetParent() )
349 
				{
350 
					parent = parent->GetParent();
351 
					++indent;
352 
				}
353 
 
354 
				if ( p->GetParent() && p->GetParent() == m_pPackages->GetEnabledMod() )
355 
					--indent;
356 
			}
357 
 
358 
			ListViewItem ^item = gcnew ListViewItem(SystemStringFromCyString(name));
86 cycrow 359 
			item->UseItemStyleForSubItems = false;
1 cycrow 360 
			item->IndentCount = (indent * 2);
50 cycrow 361 
			item->SubItems->Add(_US(p->author()));
362 
			item->SubItems->Add(_US(p->version()));
363 
			item->SubItems->Add(_US(p->creationDate()));
1 cycrow 364 
			if ( p->GetType() == TYPE_XSP )
365 
				item->SubItems->Add("Ship");
366 
			else if ( p->GetType() == TYPE_ARCHIVE )
367 
				item->SubItems->Add("- Archive -");
368 
			else if ( p->GetType() == TYPE_SPK )
369 
			{
370 
				CSpkFile *spk = (CSpkFile *)p;
371 
				item->SubItems->Add(SystemStringFromCyString(spk->GetScriptTypeString(m_pPackages->GetLanguage())));
372 
			}
373 
			else
374 
				item->SubItems->Add("");
375 
 
86 cycrow 376 
			if ( p->IsEnabled() ) {
1 cycrow 377 
				item->SubItems->Add("Yes");
86 cycrow 378 
				item->SubItems[item->SubItems->Count - 1]->ForeColor = Color::Green;
379 
			}
380 
			else {
1 cycrow 381 
				item->SubItems->Add("No");
86 cycrow 382 
				item->SubItems[item->SubItems->Count - 1]->ForeColor = Color::Red;
383 
			}
1 cycrow 384 
			if ( p->IsSigned() )
385 
				item->SubItems->Add("Yes");
386 
			else
387 
				item->SubItems->Add("No");
388 
			item->Tag = SystemStringFromCyString(CyString::Number(p->GetNum()));
389 
 
390 
			ListPackages->Items->Add(item);
391 
 
392 
			if ( useGroup )
393 
				item->Group = useGroup;
394 
			else
395 
			{
396 
				int addGroup = LISTGROUP_INSTALLED;
397 
				if ( p->GetParent() && p->GetParent() == m_pPackages->GetEnabledMod() )
398 
					addGroup = LISTGROUP_MOD;
399 
				else if ( p->GetType() == TYPE_SPK && ((CSpkFile *)p)->IsLibrary() )
400 
					addGroup = LISTGROUP_LIBRARY;
401 
				else if ( p->GetType() == TYPE_SPK && ((CSpkFile *)p)->IsFakePatch() )
402 
					addGroup = LISTGROUP_FAKE;
403 
				else if ( p->GetType() == TYPE_XSP )
404 
					addGroup = LISTGROUP_SHIP;
405 
				else if ( p->GetType() == TYPE_ARCHIVE )
406 
					addGroup = LISTGROUP_ARCHIVE;
407 
 
408 
				item->Group = ListPackages->Groups[addGroup];
409 
			}
410 
 
411 
			CyString groupName = CyStringFromSystemString(item->Group->Header);
412 
			if ( groupName.IsIn(" [") )
413 
			{
414 
				int enabled = groupName.GetToken(" [", 2, 2).GetToken("/", 1, 1).ToInt();
415 
				int total = groupName.GetToken(" [", 2, 2).GetToken("/", 2, 2).GetToken("]", 1, 1).ToInt() + 1;
416 
				if ( p->IsEnabled() ) ++enabled;
417 
				groupName = groupName.GetToken(" [", 1, 1) + " [" + CyString::Number(enabled) + "/" + CyString::Number(total) + "]";
418 
			}
419 
			else
420 
			{
421 
				if ( p->IsEnabled() )
422 
					groupName = groupName + " [1/1]";
423 
				else
424 
					groupName = groupName + " [0/1]";
425 
			}
426 
			item->Group->Header = SystemStringFromCyString(groupName);
427 
 
428 
			// get the icon
429 
			item->ImageIndex = -1;
430 
			if ( p->GetIcon() )
431 
				PluginManager::DisplayListIcon(p, ListPackages, item);
432 
 
433 
			if ( item->ImageIndex == -1 )
434 
			{
435 
				if ( p->GetType() == TYPE_XSP )
436 
					item->ImageKey = "ship";
437 
				else if ( p->GetType() == TYPE_ARCHIVE )
438 
					item->ImageKey = "archive";
439 
				else if ( p->GetType() == TYPE_SPK && ((CSpkFile *)p)->IsLibrary() )
440 
					item->ImageKey = "library";
441 
				else if ( p->IsFakePatch() )
442 
					item->ImageKey = "fake";
443 
				else
444 
					item->ImageKey = "package";
445 
			}
446 
 
447 
			// check for any children
448 
			this->_DisplayPackages(p, item->Group);
449 
		}
450 
	}
451 
 
86 cycrow 452 
	void MainGui::AddIconToPackages(String ^icon)
453 
	{
454 
		int index = this->imageList1->Images->IndexOfKey(icon + ".png");
455 
		if ( index != -1 )
456 
		{
457 
			ListPackages->SmallImageList->Images->Add(icon, this->imageList1->Images[index]);
458 
			ListPackages->LargeImageList->Images->Add(icon, this->imageList1->Images[index]);
459 
		}
460 
	}
461 
 
1 cycrow 462 
	void MainGui::UpdatePackages()
463 
	{
464 
		ListPackages->Items->Clear();
465 
		ListPackages->Groups->Clear();
466 
		ListPackages->SmallImageList = gcnew ImageList();
467 
		ListPackages->LargeImageList = gcnew ImageList();
468 
		ListPackages->LargeImageList->ImageSize = System::Drawing::Size(32, 32);
469 
		ListPackages->LargeImageList->ColorDepth = Windows::Forms::ColorDepth::Depth32Bit;
470 
		ListPackages->SmallImageList->ImageSize = System::Drawing::Size(16, 16);
471 
		ListPackages->SmallImageList->ColorDepth = Windows::Forms::ColorDepth::Depth32Bit;
472 
 
121 cycrow 473 
		if (m_pPackages && m_pPackages->IsLoaded())
1 cycrow 474 
		{
121 cycrow 475 
			int index = this->imageList1->Images->IndexOfKey("package.png");
476 
			if (index != -1)
477 
			{
478 
				ListPackages->SmallImageList->Images->Add("package", this->imageList1->Images[index]);
479 
				ListPackages->LargeImageList->Images->Add("package", this->imageList1->Images[index]);
480 
			}
481 
			index = this->imageList1->Images->IndexOfKey("ship.png");
482 
			if (index != -1)
483 
			{
484 
				ListPackages->SmallImageList->Images->Add("ship", this->imageList1->Images[index]);
485 
				ListPackages->LargeImageList->Images->Add("ship", this->imageList1->Images[index]);
486 
			}
487 
			index = this->imageList1->Images->IndexOfKey("fake.png");
488 
			if (index != -1)
489 
			{
490 
				ListPackages->SmallImageList->Images->Add("fake", this->imageList1->Images[index]);
491 
				ListPackages->LargeImageList->Images->Add("fake", this->imageList1->Images[index]);
492 
			}
493 
			index = this->imageList1->Images->IndexOfKey("library.png");
494 
			if (index != -1)
495 
			{
496 
				ListPackages->SmallImageList->Images->Add("library", this->imageList1->Images[index]);
497 
				ListPackages->LargeImageList->Images->Add("library", this->imageList1->Images[index]);
498 
			}
1 cycrow 499 
 
121 cycrow 500 
			index = this->imageList1->Images->IndexOfKey("archive.png");
501 
			if (index != -1)
502 
			{
503 
				ListPackages->SmallImageList->Images->Add("archive", this->imageList1->Images[index]);
504 
				ListPackages->LargeImageList->Images->Add("archive", this->imageList1->Images[index]);
505 
			}
1 cycrow 506 
 
121 cycrow 507 
			AddIconToPackages("tick");
508 
			AddIconToPackages("no");
86 cycrow 509 
 
121 cycrow 510 
			ListViewGroup ^group = gcnew ListViewGroup("Installed Scripts", HorizontalAlignment::Left);
511 
			ListPackages->Groups->Add(group);
512 
			ListViewGroup ^shipGroup = gcnew ListViewGroup("Installed Ships", HorizontalAlignment::Left);
513 
			ListPackages->Groups->Add(shipGroup);
514 
			ListViewGroup ^fakeGroup = gcnew ListViewGroup("Fake Patches", HorizontalAlignment::Left);
515 
			ListPackages->Groups->Add(fakeGroup);
516 
			ListViewGroup ^libGroup = gcnew ListViewGroup("Script Libraries", HorizontalAlignment::Left);
517 
			ListPackages->Groups->Add(libGroup);
518 
			ListViewGroup ^modGroup = gcnew ListViewGroup("Current Mod Addons", HorizontalAlignment::Left);
519 
			ListPackages->Groups->Add(modGroup);
520 
			ListViewGroup ^arcGroup = gcnew ListViewGroup("Installed Archives", HorizontalAlignment::Left);
521 
			ListPackages->Groups->Add(arcGroup);
1 cycrow 522 
 
121 cycrow 523 
			// sort the items
1 cycrow 524 
			m_pPackages->AssignPackageNumbers();
525 
			this->_DisplayPackages(NULL, nullptr);
121 cycrow 526 
 
527 
			PackageListSelected(ListPackages, gcnew System::EventArgs());
528 
 
529 
			// update the status bar
530 
			LabelStatus->Text = "Plugins Available: " + (m_pPackages->CountPackages(TYPE_BASE, false) - m_pPackages->CountBuiltInPackages(false)) + " (" + (m_pPackages->CountPackages(TYPE_BASE, true) - m_pPackages->CountBuiltInPackages(true)) + " Enabled)";
1 cycrow 531 
		}
121 cycrow 532 
		else
533 
			LabelStatus->Text = "No current directory";
1 cycrow 534 
 
535 
		ListPackages->AutoResizeColumns(ColumnHeaderAutoResizeStyle::HeaderSize);
536 
	}
537 
 
538 
	void MainGui::StartCheckTimer()
539 
	{
540 
		System::Windows::Forms::Timer ^timer = gcnew System::Windows::Forms::Timer();
541 
		timer->Interval = 5000;
542 
		timer->Tick += gcnew System::EventHandler(this, &MainGui::TimerEvent_CheckFile);
543 
		timer->Start();
544 
	}
545 
 
546 
 
547 
	//
548 
	// Update Controls
549 
	// Updates any additional controls, ie adding columns to package list
550 
	//
551 
	void MainGui::UpdateControls()
552 
	{
553 
		// Package List Columns
554 
		int csize = ListPackages->Width - 200 - 5;
555 
		int psize = ((csize * 7) / 10);
556 
		int asize = ((csize * 3) / 10);
557 
		if ( psize < 60 ) psize = 60;
558 
		if ( asize < 60 ) asize = 60;
559 
		ListPackages->Columns->Clear();
560 
		ListPackages->Columns->Add("Package", psize, HorizontalAlignment::Left);
561 
		ListPackages->Columns->Add("Author", asize, HorizontalAlignment::Left);
562 
		ListPackages->Columns->Add("Version", 60, HorizontalAlignment::Right);
563 
		ListPackages->Columns->Add("Updated", 80, HorizontalAlignment::Left);
564 
		ListPackages->Columns->Add("Type", 100, HorizontalAlignment::Left);
565 
		ListPackages->Columns->Add("Enabled", 60, HorizontalAlignment::Right);
566 
		ListPackages->Columns->Add("Signed", 60, HorizontalAlignment::Right);
567 
		ListPackages->FullRowSelect = true;
568 
		ListPackages->Focus();
569 
 
570 
		if ( m_pPackages->IsVanilla() )
571 
			m_pMenuBar->Vanilla();
572 
		else
573 
			m_pMenuBar->Modified();
121 cycrow 574 
 
575 
		// enable/disable if directory is loaded
576 
		bool isLoaded = m_pPackages && m_pPackages->IsLoaded();
577 
		GroupPackages->Enabled = isLoaded;
578 
		m_pMenuBar->SetLoaded(isLoaded);
1 cycrow 579 
	}
580 
 
581 
	//
582 
	// Install a package
583 
	// Called from either install button, or from command line
584 
	//
585 
	bool MainGui::InstallPackage(System::String ^file, bool straightAway, bool builtin, bool background)
586 
	{
587 
		bool errored = false;
588 
 
589 
		if ( file->Length )
590 
		{
591 
			int error;
592 
			CBaseFile *package = m_pPackages->OpenPackage(CyStringFromSystemString(file), &error, 0, SPKREAD_NODATA, READFLAG_NOUNCOMPRESS);
593 
			if ( error == INSTALLERR_NOMULTI )
594 
			{
595 
				CLinkList<CBaseFile> erroredList;
596 
				m_pPackages->PrepareMultiPackage(CyStringFromSystemString(file), &erroredList, &error, 0);
597 
				if ( erroredList.size() )
598 
				{
599 
					System::String ^modified;
600 
					for ( CBaseFile *p = erroredList.First(); p; p = erroredList.Next() )
601 
					{
602 
						p->SetOverrideFiles(builtin);
603 
						if ( m_pPackages->PrepareInstallPackage(p, false, false, IC_MODIFIED) != INSTALLCHECK_OK )
604 
						{
605 
							modified += SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage()));
606 
							modified += "\n";
607 
							errored = true;
608 
						}
609 
					}
610 
 
611 
					if ( errored )
612 
						this->DisplayMessageBox(false, "Installing", "Currently in Vanilla Mode, Package is not an Vanilla Package\n\n" + modified + "\nSwitch to modified mode if you wish to install this package", MessageBoxButtons::OK, MessageBoxIcon::Question);
613 
				}
614 
			}
615 
			else if ( !package )
616 
			{
617 
				System::String ^errorStr;
618 
				switch ( error )
619 
				{
620 
					case INSTALLERR_OLD:
621 
						errorStr = "File is in old format no longer supported";
622 
						break;
623 
					case INSTALLERR_NOEXIST:
624 
						errorStr = "file doesn't exist";
625 
						break;
626 
					case INSTALLERR_INVALID:
627 
						errorStr = "Invalid package file";
628 
						break;
629 
					case INSTALLERR_NOSHIP:
630 
						errorStr = "Ship Packages are currently not supported";
631 
						break;
632 
					case INSTALLERR_VERSION:
633 
						errorStr = "Package file was created in a newer version, unable to open";
634 
						break;
635 
 
636 
					default:
637 
						errorStr = "Unknown Error";
638 
				}
639 
 
640 
				if ( !builtin )
641 
					this->DisplayMessageBox(false, "Open Package Error", "Error Opening: " + file + "\n" + errorStr, MessageBoxButtons::OK, MessageBoxIcon::Stop);
642 
				errored = true;
643 
			}
644 
			else
645 
			{
646 
				if ( builtin )
647 
				{
648 
					package->SetOverrideFiles(builtin);
649 
					if ( m_pPackages->PrepareInstallPackage(package, false, false, IC_WRONGGAME|IC_WRONGVERSION|IC_OLDVERSION) != INSTALLCHECK_OK )
650 
						errored = true;
651 
				}
652 
				else
653 
				{
654 
					int errorNum = m_pPackages->PrepareInstallPackage(package, false, false, IC_ALL);
655 
					if ( errorNum != INSTALLCHECK_OK )
656 
					{
657 
						if ( errorNum == INSTALLCHECK_NOSHIP )
658 
						{
659 
							this->DisplayMessageBox(false, "No Ships", "Ships are not supported for " + SystemStringFromCyString(m_pPackages->GetGameName()), MessageBoxButtons::OK, MessageBoxIcon::Stop);
660 
							errored = true;
661 
						}
662 
						else if ( m_pPackages->PrepareInstallPackage(package, false, false, IC_MODIFIED) != INSTALLCHECK_OK )
663 
						{
664 
							this->DisplayMessageBox(false, "Installing", "Currently in Vanilla Mode, Package is not an Vanilla Package\n" + SystemStringFromCyString(package->GetLanguageName(m_pPackages->GetLanguage())) + "\n\nSwitch to modified mode if you wish to install this package", MessageBoxButtons::OK, MessageBoxIcon::Question);
665 
							errored = true;
666 
						}
667 
					}
668 
 
669 
					// check for compatabilities
670 
					CLinkList<CBaseFile> packages;
671 
					int compat = m_pPackages->CheckCompatabilityAgainstPackages(package, NULL, &packages);
672 
					if ( compat )
673 
					{
674 
						String ^message = "\nConflicts with:\n";
675 
						for ( CBaseFile *p = packages.First(); p; p = packages.Next() )
676 
							message += SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage())) + "\n";
677 
 
678 
						if ( MessageBox::Show(this, SystemStringFromCyString(package->GetFullPackageName(m_pPackages->GetLanguage())) + ":\nIncompatabilities found with installed fake patches\n" + message + "\n\nDo you still wish to install?", "Packages Incompatable", MessageBoxButtons::YesNo, MessageBoxIcon::Warning) != Windows::Forms::DialogResult::Yes )
679 
						{
680 
							m_pPackages->RemovePreparedInstall(package);
681 
							errored = true;
682 
						}
683 
					}
684 
				}
685 
 
686 
				// not installing
687 
				if ( errored )
688 
				{
689 
					delete package;
690 
					package = NULL;
691 
				}
692 
			}
693 
		}
694 
 
695 
		if ( errored )
696 
		{
697 
			this->Enabled= true;
698 
			this->ProgressBar->Hide();
699 
			return false;
700 
		}
701 
 
702 
		// start installing
703 
		if ( straightAway )
704 
			return this->StartInstalling(builtin, background);
705 
 
706 
		return true;
707 
	}
708 
 
709 
	void MainGui::DoUninstall()
710 
	{
711 
		m_pPi = gcnew PackageInstalled("Uninstall Packages");
712 
 
713 
		CLinkList<CBaseFile> packageList;
714 
		CLinkList<CBaseFile> disableList;
715 
 
716 
		if ( m_pPackages->UninstallPreparedPackages(m_pFileErrors, 0, &packageList, &disableList) )
717 
		{
718 
			CyString sDisplay;
719 
			CyString sAfterText;
720 
			for ( CBaseFile *p = packageList.First(); p; p = packageList.Next() )
721 
			{
722 
				sAfterText = m_pPackages->GetUninstallAfterText(p);
50 cycrow 723 
				m_pPi->AddPackageWithGroup(SystemStringFromCyString(p->GetLanguageName(m_pPackages->GetLanguage())), _US(p->author()), _US(p->version()), (sAfterText.Empty() ? "Uninstalled" : SystemStringFromCyString(sAfterText)), "Uninstalled");
1 cycrow 724 
				sDisplay = p->GetFullPackageName(m_pPackages->GetLanguage());
725 
				delete p;
726 
			}
727 
			for ( CBaseFile *p = disableList.First(); p; p = disableList.Next() )
50 cycrow 728 
				m_pPi->AddPackageWithGroup(SystemStringFromCyString(p->GetLanguageName(m_pPackages->GetLanguage())), _US(p->author()), _US(p->version()), "Disabled", "Dependants Disabled");
1 cycrow 729 
			packageList.clear();
730 
 
731 
			if ( m_pPi->PackageCount() == 1 )
732 
			{
733 
				if ( sAfterText.Empty() )
734 
					this->DisplayMessageBox(true, "Uninstalled", "Package Uninstalled\n" + SystemStringFromCyString(sDisplay), MessageBoxButtons::OK, MessageBoxIcon::Information);
735 
				else
736 
					this->DisplayMessageBox(true, "Uninstalled", "Package Uninstalled\n" + SystemStringFromCyString(sDisplay) + "\n\n" + SystemStringFromCyString(sAfterText), MessageBoxButtons::OK, MessageBoxIcon::Information);
737 
			}
738 
			else
739 
				m_bDisplayDialog = true;
740 
		}
741 
		else
742 
			this->DisplayMessageBox(true, "Uninstall Error", "Error Uninstalling", MessageBoxButtons::OK, MessageBoxIcon::Stop);
743 
	}
744 
 
745 
	void MainGui::DoDisable()
746 
	{
747 
		CLinkList<CBaseFile> packageList;
748 
 
749 
		System::String ^display;
750 
		m_pPi = gcnew PackageInstalled("Enabled/Disabled Packages");
751 
 
752 
		if ( m_pPackages->GetNumPackagesInDisabledQueue() )
753 
		{
754 
			if ( m_pPackages->DisablePreparedPackages(0, 0, &packageList) )
755 
			{
756 
				for ( CBaseFile *p = packageList.First(); p; p = packageList.Next() )
757 
				{
50 cycrow 758 
					m_pPi->AddPackageWithGroup(SystemStringFromCyString(p->GetLanguageName(m_pPackages->GetLanguage())), _US(p->author()), _US(p->version()), "Disabled", "Disabled Packages");
1 cycrow 759 
					display = "Package Disabled\n\n" + SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage()));
760 
				}
761 
			}
762 
			else
763 
				this->DisplayMessageBox(true, "Disable Error", "Error Disabling packages", MessageBoxButtons::OK, MessageBoxIcon::Stop);
764 
		}
765 
 
766 
		packageList.clear();
767 
		if ( m_pPackages->GetNumPackagesInEnabledQueue() )
768 
		{
769 
			if ( m_pPackages->EnablePreparedPackages(0, 0, &packageList) )
770 
			{
771 
				for ( CBaseFile *p = packageList.First(); p; p = packageList.Next() )
772 
				{
50 cycrow 773 
					m_pPi->AddPackageWithGroup(SystemStringFromCyString(p->GetLanguageName(m_pPackages->GetLanguage())), _US(p->author()), _US(p->version()), "Enabled", "Enable Packages");
1 cycrow 774 
					display = "Package Enabled\n\n" + SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage()));
775 
				}
776 
			}
777 
			else
778 
				this->DisplayMessageBox(true, "Enable Error", "Error Enabling packages", MessageBoxButtons::OK, MessageBoxIcon::Stop);
779 
		}
780 
 
781 
		if ( m_pPi->PackageCount() == 1 )
782 
			this->DisplayMessageBox(true, "Packages Enabled/Disabled", display, MessageBoxButtons::OK, MessageBoxIcon::Information);
783 
		else
784 
		{
785 
			m_bDisplayDialog = true;
786 
		}
787 
	}
788 
 
789 
	void MainGui::DoInstall(bool builtin, bool frombackground)
790 
	{
791 
		CLinkList<CBaseFile> erroredPackages;
792 
		CLinkList<CBaseFile> installedPackages;
793 
		if ( m_pPackages->InstallPreparedPackages(m_pFileErrors, 0, &erroredPackages, &installedPackages) )
794 
		{
795 
			if ( !builtin )
796 
			{
797 
				if ( installedPackages.size() == 1 && erroredPackages.size() == 0 )
798 
				{
799 
					CBaseFile *p = installedPackages.Front()->Data();
800 
					CyString packageName = p->GetFullPackageName(m_pPackages->GetLanguage());
801 
					CyString afterText = m_pPackages->GetInstallAfterText(p);
802 
					if ( afterText.Empty() )
803 
						this->DisplayMessageBox(frombackground, "Installed", "Package: " + SystemStringFromCyString(packageName) + " installed!\n\n", MessageBoxButtons::OK, MessageBoxIcon::Information);
804 
					else
805 
					{
806 
						afterText.StripHTML();
807 
						this->DisplayMessageBox(frombackground, "Installed", "Package: " + SystemStringFromCyString(packageName) + " installed!\n\n" + SystemStringFromCyString(afterText), MessageBoxButtons::OK, MessageBoxIcon::Information);
808 
					}
809 
				}
810 
				else
811 
				{
812 
					m_pPi = gcnew PackageInstalled("Packages Installed");
813 
 
814 
					CyStringList packages;
815 
					for ( CListNode<CBaseFile> *node = installedPackages.Front(); node; node = node->next() )
816 
					{
817 
						CBaseFile *p = node->Data();
818 
						CyString packageName = p->GetFullPackageName(m_pPackages->GetLanguage());
819 
						CyString afterText = m_pPackages->GetInstallAfterText(p);
820 
 
821 
						if ( afterText.Empty() )
822 
							afterText = "Installed";
50 cycrow 823 
						m_pPi->AddPackage(SystemStringFromCyString(packageName), _US(p->author()), _US(p->version()), SystemStringFromCyString(afterText));
1 cycrow 824 
					}
825 
					for ( CListNode<CBaseFile> *node = erroredPackages.Front(); node; node = node->next() )
826 
					{
827 
						CBaseFile *p = node->Data();
828 
						CyString packageName = p->GetFullPackageName(m_pPackages->GetLanguage());
50 cycrow 829 
						m_pPi->AddPackage(SystemStringFromCyString(packageName), _US(p->author()), _US(p->version()), SystemStringFromCyString("Failed to Install"));
1 cycrow 830 
					}
831 
 
832 
					m_bDisplayDialog = true;
833 
				}
834 
			}
835 
		}
836 
		// no packages were installed
837 
		else
838 
		{
839 
			if ( !builtin )
840 
			{
841 
				if ( erroredPackages.size() == 1 )
842 
				{
843 
					CBaseFile *p = erroredPackages.Front()->Data();
844 
					CyString packageName = p->GetFullPackageName(m_pPackages->GetLanguage());
845 
					this->DisplayMessageBox(frombackground, "Error Installing", "Package: " + SystemStringFromCyString(packageName) + " failed to install!\nError: " + SystemStringFromCyString(CBaseFile::ErrorString(p->GetLastError(), p->GetLastErrorString())) + "\n", MessageBoxButtons::OK, MessageBoxIcon::Error);
846 
				}
847 
				else
848 
				{
849 
					m_pPi = gcnew PackageInstalled("Packages Failed To Install");
850 
 
851 
					CyStringList packages;
852 
					for ( CListNode<CBaseFile> *node = erroredPackages.Front(); node; node = node->next() )
853 
					{
854 
						CBaseFile *p = node->Data();
855 
						CyString packageName = p->GetFullPackageName(m_pPackages->GetLanguage());
50 cycrow 856 
						m_pPi->AddPackage(SystemStringFromCyString(packageName), _US(p->author()), _US(p->version()), "Failed: " + SystemStringFromCyString(CBaseFile::ErrorString(p->GetLastError(), p->GetLastErrorString())));
1 cycrow 857 
					}
858 
 
859 
					m_bDisplayDialog = true;
860 
				}
861 
			}
862 
		}
863 
 
864 
		if ( !frombackground )
865 
			this->Background_Finished();
866 
	}
867 
 
868 
	void MainGui::ClearSelectedItems()
869 
	{
870 
		for ( int i = 0; i < this->ListPackages->Items->Count; i++ )
871 
			this->ListPackages->Items[i]->Selected = false;
872 
		PackageListSelected(ListPackages, gcnew System::EventArgs());
873 
	}
874 
 
875 
	bool MainGui::StartInstalling(bool builtin, bool background, bool archive)
876 
	{
877 
		// no packages to install
878 
		if ( !m_pPackages->GetNumPackagesInQueue() )
879 
			return false;
880 
 
881 
		// clear selected
882 
		this->ClearSelectedItems();
883 
 
884 
		// lets install them now
885 
		CLinkList<CBaseFile> lCheckPackages;
886 
		if ( m_pPackages->CheckPreparedInstallRequired(&lCheckPackages) )
887 
		{
888 
			for ( CListNode<CBaseFile> *pNode = lCheckPackages.Front(); pNode; pNode = pNode->next() )
889 
			{
890 
				CBaseFile *package = pNode->Data();
891 
				CSpkFile *spk = (CSpkFile *)package;
892 
 
893 
				CyStringList missingList;
894 
				if ( m_pPackages->GetMissingDependacies(package, &missingList) )
895 
				{
896 
					CyString requires;
897 
					for ( SStringList *strNode = missingList.Head(); strNode; strNode = strNode->next )
898 
					{
899 
						if ( strNode->str.IsIn("|") )
900 
							requires += strNode->str.GetToken("|", 1, 1) + " V" + strNode->str.GetToken("|", 2, 2) + " by " + strNode->data;
901 
						else
902 
							requires += strNode->str + " by " + strNode->data;
903 
						requires += "\n";
904 
					}
905 
					this->DisplayMessageBox(false, "Installing", "Missing Package for " + SystemStringFromCyString(package->GetLanguageName(m_pPackages->GetLanguage())) + "\nRequires:\n" + SystemStringFromCyString(requires), MessageBoxButtons::OK, MessageBoxIcon::Exclamation);
906 
				}
907 
			}
908 
		}
909 
 
910 
		// no packages to install
911 
		if ( !m_pPackages->GetNumPackagesInQueue() )
912 
		{
913 
			this->Enabled = true;
914 
			this->ProgressBar->Hide();
915 
			return false;
916 
		}
917 
 
918 
		ProgressBar->Show();
919 
		this->Enabled = false;
920 
 
921 
		if ( builtin )
922 
		{
923 
			if ( background )
924 
				this->StartBackground(MGUI_BACKGROUND_INSTALLBUILTIN);
925 
			else
926 
				this->DoInstall(builtin, false);
927 
		}
928 
		else if ( archive )
929 
		{
930 
			if ( background )
931 
				this->StartBackground(MGUI_BACKGROUND_INSTALL);
932 
			else
933 
				this->DoInstall(false, false);
934 
		}
935 
		else
936 
		{
937 
			InstallPackageDialog ^installDialog = gcnew InstallPackageDialog(m_pPackages);
938 
			if ( installDialog->ShowDialog(this) == System::Windows::Forms::DialogResult::OK )
939 
			{
940 
				// no packages to install
941 
				if ( !m_pPackages->GetNumPackagesInQueue() )
942 
				{
943 
					this->Enabled = true;
944 
					this->ProgressBar->Hide();
945 
					return false;
946 
				}
947 
				if ( background )
948 
					this->StartBackground(MGUI_BACKGROUND_INSTALL);
949 
				else
950 
					this->DoInstall(false, false);
951 
			}
952 
			else
953 
			{
954 
				m_pPackages->RemovePreparedInstall(NULL);
955 
				this->Enabled = true;
956 
				this->ProgressBar->Hide();
957 
				return false;
958 
			}
959 
		}
960 
		return true;
961 
	}
962 
 
963 
	bool MainGui::StartBackground(int type, System::String ^info)
964 
	{
965 
		if ( backgroundWorker1->IsBusy )
966 
			return false;
967 
		if ( m_bRunningBackground )
968 
			return false;
969 
 
970 
		m_sBackgroundInfo = info;
971 
		return this->StartBackground(type);
972 
	}
973 
 
974 
	bool MainGui::StartBackground(int type)
975 
	{
976 
		if ( backgroundWorker1->IsBusy )
977 
			return false;
978 
		if ( m_bRunningBackground )
979 
			return false;
980 
 
981 
		m_iBackgroundTask = type;
982 
 
983 
		backgroundWorker1->RunWorkerAsync();
984 
		m_bRunningBackground = true;
985 
		return true;
986 
	}
987 
 
121 cycrow 988 
	void MainGui::CloseCurrentDirectory()
1 cycrow 989 
	{
121 cycrow 990 
		if (m_pPackages->IsLoaded())
1 cycrow 991 
		{
121 cycrow 992 
			if (m_pPackages->CloseDir(0, 0, true))
1 cycrow 993 
			{
994 
				// write the modname
121 cycrow 995 
				if (!m_pPackages->GetModKey().Empty())
1 cycrow 996 
					PluginManager::WriteRegistryValue(m_pPackages->GetModKey(), m_pPackages->GetSelectedModName());
997 
				m_pPackages->Reset();
998 
			}
999 
			else
1000 
			{
1001 
				this->DisplayMessageBox(true, "Error", "unable to close directory", MessageBoxButtons::OK, MessageBoxIcon::Error);
1002 
				return;
1003 
			}
1004 
		}
1005 
 
1006 
		m_pPackages->Reset();
121 cycrow 1007 
	}
1 cycrow 1008 
 
121 cycrow 1009 
	void MainGui::ChangeDirectory(const Utils::String &dir)
1010 
	{
1011 
		if ( m_pPackages->isCurrentDir(dir) )
1012 
			return;
1013 
 
1014 
		CloseCurrentDirectory();
1015 
 
1016 
		if ( m_pPackages->read(dir, 0) )
1 cycrow 1017 
		{
1018 
			if ( m_iSaveGameManager == 1 )
1019 
				m_pPackages->RestoreSaves();
1020 
			m_pPackages->UpdatePackages();
1021 
			m_pPackages->ReadGameLanguage(true);
1022 
			System::String ^mod = PluginManager::ReadRegistryValue(m_pPackages->GetModKey());
1023 
			m_pPackages->SetMod(CyStringFromSystemString(mod));
1024 
		}
1025 
		else
1026 
		{
1027 
			this->DisplayMessageBox(true, "Error", "unable to open new directory", MessageBoxButtons::OK, MessageBoxIcon::Error);
121 cycrow 1028 
			this->CloseCurrentDirectory();
1 cycrow 1029 
		}
1030 
	}
1031 
 
1032 
	CBaseFile *MainGui::FindPackageFromList(ListViewItem ^item)
1033 
	{
1034 
		if ( !item )
1035 
			return NULL;
1036 
 
1037 
		System::String ^sNum = System::Convert::ToString(item->Tag);
1038 
		int iNum = CyStringFromSystemString(sNum).ToInt();
1039 
 
1040 
		CBaseFile *p = m_pPackages->GetPackageAt(iNum);
1041 
		return p;
1042 
	}
1043 
 
1044 
	void MainGui::FindPackagesOnline()
1045 
	{
1046 
		CyStringList servers;
1047 
		m_pPackages->FindAllServers(&servers);
1048 
		if ( servers.Empty() )
1049 
		{
1050 
			MessageBox::Show(this, "Found now web address to check for packages", "No Web Address", MessageBoxButtons::OK, MessageBoxIcon::Warning);
1051 
			return;
1052 
		}
1053 
 
1054 
		DownloadPackageList ^dpl = gcnew DownloadPackageList(m_pPackages, &servers);
1055 
		dpl->ShowDialog(this);
1056 
 
1057 
		if ( m_pPackages->AnyAvailablePackages() )
1058 
			MessageBox::Show(this, "Package update completed\n" + m_pPackages->GetAvailablePackageList()->size() + " packages have been added to the package browser", "Found Packages", MessageBoxButtons::OK, MessageBoxIcon::Information);
1059 
		else
1060 
			MessageBox::Show(this, "Unable to find any packages\n", "No Packages Found", MessageBoxButtons::OK, MessageBoxIcon::Warning);
1061 
	}
1062 
 
1063 
	//
1064 
	// Event Handlers
1065 
	//
1066 
	void MainGui::SetupEventHandlers()
1067 
	{
1068 
		// setup Event Handlers
1069 
		ButClose->Click += gcnew EventHandler(this, &PluginManager::MainGui::ClosedEvent);
1070 
		ButInstall->Click += gcnew EventHandler(this, &PluginManager::MainGui::InstallEvent);
1071 
		ButUninstall->Click += gcnew EventHandler(this, &PluginManager::MainGui::UninstallEvent);
1072 
		ButDisable->Click += gcnew EventHandler(this, &PluginManager::MainGui::DisableEvent);
1073 
		ListPackages->SelectedIndexChanged += gcnew EventHandler(this, &PluginManager::MainGui::PackageListSelected);
1074 
		ListPackages->ColumnClick  += gcnew ColumnClickEventHandler(this, &PluginManager::MainGui::PackageListSort);
1075 
		ComboDir->SelectedIndexChanged += gcnew EventHandler(this, &PluginManager::MainGui::ChangeDirectoryEvent);
1076 
 
1077 
 
1078 
		// background worker
1079 
		backgroundWorker1->DoWork += gcnew DoWorkEventHandler( this, &MainGui::Background_DoWork );
1080 
		backgroundWorker1->RunWorkerCompleted += gcnew RunWorkerCompletedEventHandler( this, &MainGui::Background_Finished );
1081 
		backgroundWorker1->ProgressChanged += gcnew ProgressChangedEventHandler( this, &MainGui::Background_Progress );
1082 
 
1083 
		// auto update
1084 
		backgroundUpdater->DoWork += gcnew DoWorkEventHandler( this, &MainGui::Updater_DoWork );
1085 
		backgroundUpdater->RunWorkerCompleted += gcnew RunWorkerCompletedEventHandler( this, &MainGui::Updater_Finished );
1086 
	}
1087 
 
1088 
	void MainGui::PackageListSort(System::Object ^Sender, ColumnClickEventArgs ^E)
1089 
	{
1090 
		if ( E->Column != m_iSortingColumn )
1091 
		{
1092 
			m_iSortingColumn = E->Column;
1093 
			m_bSortingAsc = true;
1094 
		}
1095 
		else
1096 
			m_bSortingAsc = !m_bSortingAsc;
1097 
		this->UpdatePackages();
1098 
	}
1099 
 
1100 
	void MainGui::PackageListSelected(System::Object ^Sender, System::EventArgs ^E)
1101 
	{
1102 
		// is there any selected items
1103 
		this->PictureDisplay->Image = nullptr;
1104 
		this->PanelDisplay->Hide();
1105 
		TextDesc->Text = "";
1106 
		bool buttonEnabled = false;
1107 
		if ( ListPackages->SelectedItems->Count )
1108 
		{
1109 
			buttonEnabled = true;
1110 
 
1111 
			ListView::SelectedListViewItemCollection^ selected = this->ListPackages->SelectedItems;
1112 
			System::Collections::IEnumerator^ myEnum = selected->GetEnumerator();
1113 
			while ( myEnum->MoveNext() )
1114 
			{
1115 
				CBaseFile *p = this->FindPackageFromList(safe_cast<ListViewItem ^>(myEnum->Current));
1116 
				if ( p )
1117 
				{
1118 
					if ( p->IsEnabled() )
1119 
						ButDisable->Text = "Disable";
1120 
					else
1121 
						ButDisable->Text = "Enable";
48 cycrow 1122 
					if ( !p->description().empty() )	TextDesc->Text = _US(p->description().findReplace("<br>", "\n").stripHtml());
1 cycrow 1123 
 
1124 
					this->PictureDisplay->Show();
1125 
					bool addedIcon = false;
1126 
					C_File *picFile = p->GetFirstFile(FILETYPE_ADVERT);
1127 
					if ( picFile )
1128 
					{
1129 
						System::String ^pic = SystemStringFromCyString(picFile->GetFilePointer());
1130 
						if ( System::IO::File::Exists(pic) )
1131 
						{
1132 
							Bitmap ^myBitmap = gcnew Bitmap(pic);
1133 
							if ( myBitmap )
1134 
							{
1135 
								this->PictureDisplay->Image = dynamic_cast<Image ^>(myBitmap);
1136 
								addedIcon = true;
1137 
							}
1138 
						}
1139 
					}
1140 
 
1141 
					if ( !addedIcon )
1142 
					{
1143 
 
1144 
						System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(MainGui::typeid));
1145 
						this->PictureDisplay->Image = (cli::safe_cast<System::Drawing::Image^  >(resources->GetObject(L"PictureDisplay.Image")));
1146 
					}
1147 
 
1148 
					if ( p->GetType() != TYPE_ARCHIVE )
1149 
						this->PanelDisplay->Show();
1150 
				}
1151 
			}
1152 
		}
1153 
 
1154 
		// enable/disable the buttons connected to the package list
1155 
		ButUninstall->Enabled = buttonEnabled;
1156 
		ButDisable->Enabled = buttonEnabled;
1157 
	}
1158 
 
1159 
	bool MainGui::EnablePackage(CBaseFile *p)
1160 
	{
1161 
		if ( !m_pPackages->PrepareEnablePackage(p) )
1162 
		{
1163 
			if ( m_pPackages->GetError() == PKERR_NOPARENT )
1164 
				this->DisplayMessageBox(false, "Enable Error", "Error enabling package\n" + SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage())) + "\n\nParent mod is not enabled", MessageBoxButtons::OK, MessageBoxIcon::Warning);
1165 
			else if ( m_pPackages->GetError() == PKERR_MODIFIED )
1166 
				this->DisplayMessageBox(false, "Enable Error", "Error enabling package\n" + SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage())) + "\n\nPackage is modified and game is currently set to vanilla\nSwitch to modified mode to enable", MessageBoxButtons::OK, MessageBoxIcon::Warning);
1167 
			else if ( m_pPackages->GetError() == PKERR_MISSINGDEP )
1168 
			{
1169 
				CyStringList depList;
1170 
				m_pPackages->GetMissingDependacies(p, &depList, true);
1171 
				CyString sDep;
1172 
				for ( SStringList *strNode = depList.Head(); strNode; strNode = strNode->next )
1173 
				{
1174 
					if ( strNode->str.IsIn("|") )
1175 
						sDep = strNode->str.GetToken("|", 1, 1) + " V" + strNode->str.GetToken("|", 2, 2) + " by " + strNode->data + "\n";
1176 
					else
1177 
						sDep = strNode->str + " by " + strNode->data + "\n";
1178 
				}
1179 
				this->DisplayMessageBox(false, "Enable Error", "Error enabling package\n" + SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage())) + "\n\nMissing Enabled Dependacies:\n" + SystemStringFromCyString(sDep), MessageBoxButtons::OK, MessageBoxIcon::Warning);
1180 
			}
1181 
			else
1182 
				this->DisplayMessageBox(false, "Enable Error", "Error enabling package\n" + SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage())) + "\n\nUnknown Error", MessageBoxButtons::OK, MessageBoxIcon::Warning);
1183 
			return false;
1184 
		}
1185 
		return true;
1186 
	}
1187 
 
1188 
	void MainGui::DisableList(ArrayList ^List)
1189 
	{
1190 
		bool skipShips = false;
1191 
		int count = 0;
1192 
 
1193 
		for ( int i = 0; i < List->Count; i++ )
1194 
		{
1195 
			CBaseFile *p = this->FindPackageFromList(cli::safe_cast<ListViewItem ^>(List[i]));
1196 
			if ( p )
1197 
			{
1198 
				if ( p->IsEnabled() )
1199 
				{
1200 
					if ( p->GetType() == TYPE_SPK && ((CSpkFile *)p)->IsLibrary() )
1201 
					{
1202 
						if ( this->DisplayMessageBox(false, "Disable Library", "Package: " + SystemStringFromCyString(p->GetFullPackageName(m_pPackages->GetLanguage())) + "\nThis is a library package and might be required for other installed packages\nDo you still wish to disable it?", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == System::Windows::Forms::DialogResult::No )
1203 
							continue;
1204 
					}
1205 
					if ( p->GetType() == TYPE_XSP )
1206 
					{
1207 
						if ( !this->DisplayTip(TIPSECTION_YESNO, TIP_SHIPDISABLE) )
1208 
							skipShips = true;
1209 
 
1210 
						if ( skipShips )
1211 
							continue;
1212 
					}
1213 
 
1214 
					m_pPackages->PrepareDisablePackage(p);
1215 
					++count;
1216 
				}
1217 
				else
1218 
				{
1219 
					this->EnablePackage(p);
1220 
					++count;
1221 
				}
1222 
			}
1223 
		}
1224 
 
1225 
		if ( count )
1226 
		{
1227 
			this->Enabled = false;
1228 
			this->StartBackground(MGUI_BACKGROUND_DISABLE);
1229 
		}
1230 
	}
1231 
 
1232 
	void MainGui::DisableEvent(System::Object ^Sender, System::EventArgs ^E)
1233 
	{
1234 
		if ( !ListPackages->SelectedItems->Count )
1235 
			return;
1236 
 
1237 
		bool skipShips = false;
1238 
 
1239 
		ListView::SelectedListViewItemCollection^ selected = this->ListPackages->SelectedItems;
1240 
		System::Collections::IEnumerator^ myEnum = selected->GetEnumerator();
1241 
		int count = 0;
1242 
		ArrayList ^List = gcnew ArrayList();
1243 
 
1244 
		while ( myEnum->MoveNext() )
1245 
			List->Add(safe_cast<ListViewItem ^>(myEnum->Current));
1246 
 
1247 
		if ( List->Count )
1248 
			this->DisableList(List);
1249 
	}
1250 
 
1251 
	void MainGui::PackageBrowserEvent(System::Object ^Sender, System::EventArgs ^E)
1252 
	{
1253 
		this->Enabled = false;
1254 
		PackageBrowser ^mod = gcnew PackageBrowser(m_pPackages, this->imageList1);
1255 
		if ( !mod->AnyPackages() )
1256 
		{
121 cycrow 1257 
			System::String ^game = _US(m_pPackages->getGameName());
1 cycrow 1258 
			this->DisplayMessageBox(false, "No Available Packages", "No available packages found for " + game, MessageBoxButtons::OK, MessageBoxIcon::Exclamation);
1259 
 
1260 
			this->Enabled = true;
1261 
			return;
1262 
		}
1263 
 
1264 
		if ( m_bDirLocked ) {
1265 
			this->DisplayLocked(false);
1266 
			this->Enabled = true;
1267 
			return;
1268 
		}
1269 
 
1270 
		mod->SetExperimental(m_bExperimental);
1271 
		mod->SetCheat(m_bCheat);
1272 
		mod->SetShips(m_bShips);
1273 
		if ( m_pPackages->IsVanilla() )
1274 
			mod->SetSigned(true);
1275 
		else
1276 
			mod->SetSigned(m_bSigned);
1277 
		mod->SetDownload(m_bDownloadable);
1278 
		mod->UpdatePackages();
1279 
		System::Windows::Forms::DialogResult result = mod->ShowDialog(this);
1280 
 
1281 
		m_bDownloadable = mod->IsDownload();
1282 
		m_bCheat = mod->IsCheat();
1283 
		m_bExperimental = mod->IsExperimental();
1284 
		m_bShips = mod->IsShips();
1285 
		m_bSigned = mod->IsSigned();
1286 
 
1287 
		bool doenable = true;
1288 
		CBaseFile *p = mod->SelectedMod();
1289 
		if ( result == System::Windows::Forms::DialogResult::OK )
1290 
		{
1291 
			if ( p )
1292 
			{
50 cycrow 1293 
				if ( this->InstallPackage(_US(p->filename()), true, false, true) )
1 cycrow 1294 
					doenable = false;
1295 
			}
1296 
		}
1297 
		else if ( result == System::Windows::Forms::DialogResult::Yes )
1298 
			this->StartInstalling(false, true);
1299 
 
1300 
		this->Enabled = doenable;
1301 
	}
1302 
 
1303 
	void MainGui::CloseEvent(System::Object ^Sender, FormClosingEventArgs ^E)
1304 
	{
1305 
		int h = this->Size.Height;
1306 
		int w = this->Size.Width;
1307 
	}
1308 
 
1309 
	void MainGui::DisplayLocked(bool inthread)
1310 
	{
1311 
		this->DisplayMessageBox(inthread, "Directory Locked", "The current directory is locked and unable to make any changes\nYou may need to adjust the directory permissions", MessageBoxButtons::OK, MessageBoxIcon::Error);
1312 
	}
1313 
 
1314 
	void MainGui::ModSelectorEvent(System::Object ^Sender, System::EventArgs ^E)
1315 
	{
1316 
		if ( m_pPackages->IsVanilla() )
1317 
		{
1318 
			this->DisplayMessageBox(false, "Mod Selector", "Currently in Vanilla Mode, You can only enable mods when in Modified Mode\n\nSwitch to modified mode if you wish to install mods", MessageBoxButtons::OK, MessageBoxIcon::Question);
1319 
			return;
1320 
		}
1321 
		this->Enabled = false;
1322 
		ModSelector ^mod = gcnew ModSelector(m_pPackages, this->imageList1);
1323 
 
1324 
		if ( !mod->AnyPackages() )
1325 
		{
1326 
			this->DisplayMessageBox(false, "Mod Selector", "No available mods have been found", MessageBoxButtons::OK, MessageBoxIcon::Warning);
1327 
			this->Enabled = true;
1328 
			return;
1329 
		}
1330 
 
1331 
		if ( m_bDirLocked ) {
1332 
			this->DisplayLocked(false);
1333 
			this->Enabled = true;
1334 
			return;
1335 
		}
1336 
 
1337 
		if ( !m_bModSelectorDetails )
1338 
		{
1339 
			mod->HideDetails();
1340 
			mod->Update();
1341 
		}
1342 
 
1343 
		System::Windows::Forms::DialogResult result = mod->ShowDialog(this);
1344 
		m_bModSelectorDetails = mod->ShowingDetails();
1345 
 
1346 
		// install the selected mod
1347 
		bool reEnable = true;
1348 
 
1349 
		CBaseFile *p = mod->SelectedMod();
1350 
		if ( result == System::Windows::Forms::DialogResult::OK )
1351 
		{
1352 
			if ( p )
1353 
			{
1354 
				// from file
1355 
				if ( p->GetNum() < 0 )
1356 
				{
1357 
					if ( m_pPackages->GetEnabledMod() )
1358 
						m_pPackages->DisablePackage(m_pPackages->GetEnabledMod(), 0, 0);
50 cycrow 1359 
					if ( this->InstallPackage(_US(p->filename()), true, false, true) )
1 cycrow 1360 
						reEnable = false;
1361 
				}
1362 
				// otherwise just enable it
1363 
				else
1364 
				{
1365 
					if ( this->EnablePackage(p) )
1366 
					{
1367 
						this->StartBackground(MGUI_BACKGROUND_DISABLE);
1368 
						reEnable = false;
1369 
					}
1370 
				}
1371 
			}
1372 
		}
1373 
 
1374 
		// install downloaded mods
1375 
		else if ( result == Windows::Forms::DialogResult::Yes )
1376 
			this->StartInstalling(false, true);
1377 
 
1378 
		// remove the current mod
1379 
		else if ( result == System::Windows::Forms::DialogResult::Abort )
1380 
		{
1381 
			if ( m_pPackages->GetEnabledMod() )
1382 
			{
1383 
				CBaseFile *mod = m_pPackages->GetEnabledMod();
1384 
				CyString message = mod->GetFullPackageName(m_pPackages->GetLanguage());
1385 
				m_pPackages->DisablePackage(m_pPackages->GetEnabledMod(), 0, 0);
1386 
				this->DisplayMessageBox(false, "Mod Disabed", SystemStringFromCyString(message) + " has been disabled\nYour game is no longer using any mods\n", MessageBoxButtons::OK, MessageBoxIcon::Exclamation);
1387 
			}
1388 
		}
1389 
 
1390 
		// uninstall the selected mod
1391 
		else if ( result == System::Windows::Forms::DialogResult::Retry )
1392 
		{
1393 
			if ( p && p->GetNum() >= 0 )
1394 
			{
1395 
				m_pPackages->PrepareUninstallPackage(p);
1396 
				if ( m_pPackages->GetNumPackagesInQueue() )
1397 
				{
1398 
					reEnable = false;
1399 
					this->StartBackground(MGUI_BACKGROUND_UNINSTALL);
1400 
				}
1401 
			}
1402 
		}
1403 
 
1404 
		if ( reEnable )
1405 
			this->Enabled = true;
1406 
 
1407 
		mod->RemovePackages();
1408 
	}
1409 
 
1410 
	void MainGui::UninstallList(ArrayList ^List)
1411 
	{
1412 
		bool skipShips = false;
1413 
 
1414 
		for ( int i = 0; i < List->Count; i++ )
1415 
		{
1416 
			CBaseFile *p = this->FindPackageFromList(safe_cast<ListViewItem ^>(List[i]));
1417 
			if ( p )
1418 
			{
1419 
				if ( p->GetType() == TYPE_XSP )
1420 
				{
1421 
					if ( !this->DisplayTip(TIPSECTION_YESNO, TIP_SHIPUNINSTALL) )
1422 
						skipShips = true;
1423 
 
1424 
					if ( skipShips )
1425 
						continue;
1426 
				}
1427 
 
46 cycrow 1428 
				// display uninstall text
1429 
				Utils::String beforeText = m_pPackages->GetUninstallBeforeText(p).ToString();
1430 
				if ( !beforeText.empty() ) {
1431 
					if ( this->DisplayMessageBox(false, "Uninstall Package", _US(p->GetFullPackageName(m_pPackages->GetLanguage()).ToString() + "\n" + beforeText + "\n\nDo you want to uninstall this package?"), MessageBoxButtons::YesNo, MessageBoxIcon::Question) != System::Windows::Forms::DialogResult::Yes )
1432 
						continue;
1433 
				}
1434 
 
1 cycrow 1435 
				m_pPackages->PrepareUninstallPackage(p);
1436 
			}
1437 
		}
1438 
 
1439 
		if ( m_pPackages->GetNumPackagesInQueue() )
1440 
		{
1441 
			this->Enabled = false;
1442 
			this->StartBackground(MGUI_BACKGROUND_UNINSTALL);
1443 
		}
1444 
	}
1445 
	void MainGui::UninstallEvent(System::Object ^Sender, System::EventArgs ^E)
1446 
	{
1447 
		if ( !ListPackages->SelectedItems->Count )
1448 
			return;
1449 
 
1450 
		ArrayList ^List = gcnew ArrayList();
1451 
 
1452 
		ListView::SelectedListViewItemCollection^ selected = this->ListPackages->SelectedItems;
1453 
		System::Collections::IEnumerator^ myEnum = selected->GetEnumerator();
1454 
 
1455 
		while ( myEnum->MoveNext() )
1456 
			List->Add(safe_cast<ListViewItem ^>(myEnum->Current));
1457 
 
1458 
		this->UninstallList(List);
1459 
	}
1460 
 
1461 
	void MainGui::ModifiedEvent(System::Object ^Sender, System::EventArgs ^E)
1462 
	{
1463 
		if ( m_bDirLocked ) {
1464 
			this->DisplayLocked(false);
1465 
			return;
1466 
		}
1467 
		if ( m_pPackages->IsVanilla() )
1468 
		{
1469 
			this->Enabled = false;
1470 
			if ( this->DisplayMessageBox(false, "Modified Mode", "Enabling modified mode will allow you to use any modified content\nThis will however mark any games you save as modified and you will be unable to participate in Uplink\nAny current save games wil also be backed up and kept seperate from your modified save games\n\nDo you wish to enable modified mode?", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == System::Windows::Forms::DialogResult::Yes )
1471 
			{
1472 
				if ( m_iSaveGameManager == 1 )
1473 
				{
1474 
					m_pPackages->BackupSaves(true);
1475 
					m_pPackages->RestoreSaves(false);
1476 
				}
1477 
				m_pPackages->SetVanilla(false);
1478 
				m_pMenuBar->Modified();
1479 
				m_pPackages->PrepareEnableLibrarys();
1480 
				m_pPackages->PrepareEnableFromVanilla();
1481 
				this->StartBackground(MGUI_BACKGROUND_DISABLE);
1482 
			}
1483 
			else
1484 
				this->Enabled = true;
1485 
		}
1486 
	}
1487 
 
1488 
	void MainGui::VanillaEvent(System::Object ^Sender, System::EventArgs ^E)
1489 
	{
1490 
		if ( m_bDirLocked ) {
1491 
			this->DisplayLocked(false);
1492 
			return;
1493 
		}
1494 
		if ( !m_pPackages->IsVanilla() )
1495 
		{
1496 
			this->Enabled = false;
1497 
			if ( this->DisplayMessageBox(false, "Vanilla Mode", "Switching back to vanilla mode you will no longer be able to use any modifying packages, these will be disabled\nYour current save games will be backed up as modified saves, and any vanilla save games will be restored\n\nDo you wish to go back to Vanilla?", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == System::Windows::Forms::DialogResult::Yes )
1498 
			{
1499 
				if ( m_iSaveGameManager == 1 )
1500 
				{
86 cycrow 1501 
					m_pPackages->BackupSaves(false);
1 cycrow 1502 
					m_pPackages->RestoreSaves(true);
1503 
				}
1504 
				m_pPackages->SetVanilla(true);
1505 
				m_pMenuBar->Vanilla();
1506 
				m_pPackages->PrepareDisableForVanilla();
1507 
				this->StartBackground(MGUI_BACKGROUND_DISABLE);
1508 
			}
1509 
			else
1510 
				this->Enabled = true;
1511 
		}
1512 
	}
1513 
 
1514 
	void MainGui::InstallEvent(System::Object ^Sender, System::EventArgs ^E)
1515 
	{
1516 
		if ( m_bDirLocked ) {
1517 
			this->DisplayLocked(false);
1518 
			return;
1519 
		}
1520 
 
1521 
		OpenFileDialog ^ofd = gcnew OpenFileDialog();
1522 
		ofd->Filter = "All (*.spk, *.xsp)|*.spk;*.xsp|Package Files (*.spk)|*.spk|Ship Files (*.xsp)|*.xsp";
1523 
		ofd->FilterIndex = 1;
1524 
		ofd->RestoreDirectory = true;
1525 
		ofd->Multiselect = true;
1526 
 
1527 
		this->Enabled = false;
1528 
		if ( ofd->ShowDialog(this) == System::Windows::Forms::DialogResult::OK )
1529 
		{
1530 
			bool anytoinstall = false;
1531 
			array<System::String ^> ^fileArray = ofd->FileNames;
1532 
			for ( int i = 0; i < fileArray->Length; i++ )
1533 
			{
1534 
				System::String ^file = fileArray[i];
1535 
				if ( this->InstallPackage(file, false, false, true) )
1536 
					anytoinstall = true;
1537 
			}
1538 
 
1539 
			if ( anytoinstall )
1540 
				this->StartInstalling(false, true);
1541 
		}
1542 
		else
1543 
		{
1544 
			ProgressBar->Hide();
1545 
			this->Enabled = true;
1546 
		}
1547 
	}
1548 
 
1549 
	void MainGui::CheckUnusedShared()
1550 
	{
1551 
		if ( m_pPackages->AnyUnusedShared() )
1552 
		{
1553 
			if ( this->DisplayMessageBox(false, "Remove Shared Files", "You have some unused shared files, would you like to remove these?", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == System::Windows::Forms::DialogResult::Yes)
1554 
				m_pPackages->RemoveUnusedSharedFiles();
1555 
		}
1556 
	}
1557 
 
1558 
	void MainGui::ChangeDirectoryEvent(System::Object ^Sender, System::EventArgs ^E)
1559 
	{
121 cycrow 1560 
		if (ComboDir->SelectedIndex == (ComboDir->Items->Count - 1))
1 cycrow 1561 
		{
121 cycrow 1562 
			if (m_pPackages && m_pPackages->IsLoaded())
1563 
			{
1564 
				this->Enabled = false;
1565 
				ProgressBar->Show();
1566 
				this->CheckUnusedShared();
1567 
				this->StartBackground(MGUI_BACKGROUND_CLOSEDIR, "");
1568 
			}
1 cycrow 1569 
		}
121 cycrow 1570 
		else if (ComboDir->SelectedIndex >= 0)
1571 
		{
1572 
			Utils::String dir = m_pDirList->get(ComboDir->SelectedIndex)->str;
1573 
			if (!m_pPackages->isCurrentDir(dir))
1574 
			{
1575 
				this->Enabled = false;
1576 
				ProgressBar->Show();
1577 
				this->CheckUnusedShared();
1578 
				this->StartBackground(MGUI_BACKGROUND_CHANGEDIR, _US(dir));
1579 
			}
1580 
		}
1 cycrow 1581 
	}
1582 
 
1583 
	void MainGui::Background_DoWork(System::Object ^Sender, DoWorkEventArgs ^E)
1584 
	{
1585 
		m_bDisplayMessage = false;
1586 
		m_bDisplayDialog = false;
1587 
 
1588 
		switch ( m_iBackgroundTask )
1589 
		{
1590 
			case MGUI_BACKGROUND_INSTALL:
1591 
				this->DoInstall(false, true);
1592 
				break;
1593 
			case MGUI_BACKGROUND_INSTALLBUILTIN:
1594 
				this->DoInstall(true, true);
1595 
				break;
1596 
			case MGUI_BACKGROUND_UNINSTALL:
1597 
				this->DoUninstall();
1598 
				break;
1599 
			case MGUI_BACKGROUND_DISABLE:
1600 
				this->DoDisable();
1601 
				break;
121 cycrow 1602 
			case MGUI_BACKGROUND_CLOSEDIR:
1603 
				this->CloseCurrentDirectory();
1604 
				break;
1 cycrow 1605 
			case MGUI_BACKGROUND_CHANGEDIR:
121 cycrow 1606 
				this->ChangeDirectory(_S(m_sBackgroundInfo));
1 cycrow 1607 
				break;
1608 
		}
1609 
	}
1610 
 
1611 
	void MainGui::Background_Finished()
1612 
	{
1613 
		ProgressBar->Hide();
1614 
 
1615 
		if ( m_bDisplayMessage )
1616 
			MessageBox::Show(this, m_sMessageText, m_sMessageTitle, m_messageButtons, m_messageIcon);
1617 
 
1618 
		if ( m_bDisplayDialog )
1619 
		{
1620 
			if ( m_pPi->PackageCount() )
1621 
			{
1622 
				m_pPi->AdjustColumns();
1623 
				m_pPi->ShowDialog(this);
1624 
			}
1625 
		}
1626 
 
1627 
		m_bDisplayDialog = false;
1628 
		m_bDisplayMessage = false;
1629 
 
121 cycrow 1630 
		if ( m_iBackgroundTask == MGUI_BACKGROUND_CHANGEDIR || m_iBackgroundTask == MGUI_BACKGROUND_CLOSEDIR)
1 cycrow 1631 
		{
1632 
			// switch the dir list
121 cycrow 1633 
			Utils::String selectedDir;
1634 
			if (ComboDir->SelectedIndex == ComboDir->Items->Count - 1)
1635 
				selectedDir = _S(ComboDir->Text);
1636 
			else if (ComboDir->SelectedIndex >= 0)
1 cycrow 1637 
			{
121 cycrow 1638 
				Utils::String dir = m_pDirList->get(ComboDir->SelectedIndex)->str;
1639 
				selectedDir = dir;
1640 
				if ( !dir.empty() )
1 cycrow 1641 
				{
121 cycrow 1642 
					if ( (m_iBackgroundTask == MGUI_BACKGROUND_CHANGEDIR) && (dir.countToken(" [")) )
1643 
						dir = dir.tokens(" [", 1);
1644 
					if ( m_pDirList->findString(dir) )
1 cycrow 1645 
					{
121 cycrow 1646 
						Utils::String data = m_pDirList->findString(dir);
1647 
						m_pDirList->remove(dir, false);
1648 
						m_pDirList->pushFront(dir, data);
1 cycrow 1649 
					}
1650 
					else
1651 
					{
1652 
						int lang = m_pPackages->GetGameLanguage(dir);
1653 
						if ( lang )
121 cycrow 1654 
							m_pDirList->pushFront(dir, Utils::String::Number(lang) + "|" + m_pPackages->getGameName(dir));
1 cycrow 1655 
						else
121 cycrow 1656 
							m_pDirList->pushFront(dir, m_pPackages->getGameName(dir));
1 cycrow 1657 
					}
1658 
				}
1659 
			}
121 cycrow 1660 
 
1661 
			this->UpdateDirList(selectedDir);
1662 
			this->UpdateRunButton();
1 cycrow 1663 
		}
1664 
 
1665 
		// display any files that failed
1666 
		if ( m_iBackgroundTask == MGUI_BACKGROUND_INSTALL )
1667 
		{
1668 
			String ^files = "";
1669 
			for ( SStringList *str = m_pFileErrors->Head(); str; str = str->next )
1670 
			{
1671 
				if ( str->data.ToInt() == SPKINSTALL_WRITEFILE_FAIL )
1672 
				{
1673 
					files += "\n";
1674 
					files += SystemStringFromCyString(str->str);
1675 
				}
1676 
			}
1677 
 
1678 
			if ( files->Length )
1679 
				MessageBox::Show(this, "These files failed to install\n" + files, "Failed Files", MessageBoxButtons::OK, MessageBoxIcon::Warning);
1680 
		}
1681 
 
1682 
		switch ( m_iBackgroundTask )
1683 
		{
121 cycrow 1684 
			case MGUI_BACKGROUND_CLOSEDIR:
1 cycrow 1685 
			case MGUI_BACKGROUND_CHANGEDIR:
1686 
				this->UpdateControls();
1687 
				this->UpdatePackages();
1688 
				this->CheckProtectedDir();
1689 
				m_bRunningBackground = false;
1690 
				if ( this->UpdateBuiltInPackages() )
1691 
					return;
1692 
				break;
1693 
 
1694 
			case MGUI_BACKGROUND_INSTALL:
1695 
			case MGUI_BACKGROUND_INSTALLBUILTIN:
1696 
			case MGUI_BACKGROUND_UNINSTALL:
1697 
			case MGUI_BACKGROUND_DISABLE:
1698 
				this->UpdatePackages();
1699 
				break;
1700 
		}
1701 
 
1702 
		m_iBackgroundTask = MGUI_BACKGROUND_NONE;
1703 
 
1704 
		this->Enabled = true;
121 cycrow 1705 
		ProgressBar->Hide();
1 cycrow 1706 
		m_bRunningBackground = false;
1707 
	}
1708 
 
1709 
	void MainGui::Background_Progress(System::Object ^Sender, ProgressChangedEventArgs ^E)
1710 
	{
1711 
		this->ProgressBar->Value = E->ProgressPercentage;
1712 
	}
1713 
 
1714 
	bool MainGui::UpdateBuiltInPackages()
1715 
	{
121 cycrow 1716 
		// no current directory
1717 
		if (!m_pPackages || !m_pPackages->IsLoaded())
1718 
			return false;
1719 
 
1 cycrow 1720 
		// find all built-in packages
53 cycrow 1721 
		System::String ^dir = ".\\Required";
78 cycrow 1722 
 
53 cycrow 1723 
		if ( System::IO::Directory::Exists(dir) )
1 cycrow 1724 
		{
1725 
			bool installing = false;
53 cycrow 1726 
			array <System::String ^> ^Files = System::IO::Directory::GetFiles(dir, "*.spk");
1 cycrow 1727 
 
1728 
			for ( int i = 0; i < Files->Length; i++ )
1729 
			{
1730 
				CyString file = CyStringFromSystemString(Files[i]);
1731 
				int error;
1732 
				CBaseFile *p = m_pPackages->OpenPackage(file, &error, 0, SPKREAD_NODATA);
1733 
				if ( !p )
1734 
					continue;
1735 
 
1736 
				if ( !((CSpkFile *)p)->IsLibrary() )
1737 
					continue;
1738 
 
1739 
				if ( !p->CheckGameCompatability(m_pPackages->GetGame()) )
1740 
					continue;
1741 
 
1742 
				// if its installed, check if we have a newer version
50 cycrow 1743 
				CBaseFile *check = m_pPackages->FindSpkPackage(p->name(), p->author());
1 cycrow 1744 
				if ( check )
1745 
				{
50 cycrow 1746 
					if ( check->version().compareVersion(p->version()) != COMPARE_OLDER )
1 cycrow 1747 
					{
1748 
						this->InstallPackage(Files[i], false, true, true);
1749 
						installing = true;
1750 
					}
1751 
				}
1752 
				else
1753 
				{
1754 
					this->InstallPackage(Files[i], false, true, true);
1755 
					installing = true;
1756 
				}
1757 
 
1758 
				delete p;
1759 
			}
1760 
 
1761 
			if ( installing )
1762 
				this->StartInstalling(true, true);
1763 
			return installing;
1764 
		}
1765 
 
1766 
		return false;
1767 
	}
1768 
 
1769 
	////
1770 
	// Auto Update
1771 
	////
1772 
	void MainGui::AutoUpdate()
1773 
	{
1774 
		if ( !m_bAutoUpdate || !System::IO::File::Exists( ".\\AutoUpdater.exe") )
1775 
			return;
1776 
 
1777 
		// load the dir list
1778 
		if ( !m_pUpdateList )
1779 
		{
1780 
			m_pUpdateList = new CyStringList;
1781 
 
1782 
			// TODO: read addresses from data
1783 
 
1784 
			// hardcoded address
80 cycrow 1785 
			m_pUpdateList->PushBack("http://xpluginmanager.co.uk/pmupdate.dat", "", true);
1 cycrow 1786 
			if ( (int)PMLBETA )
80 cycrow 1787 
				m_pUpdateList->PushBack("http://xpluginmanager/Beta/pmupdatebeta.dat", "", true);
1 cycrow 1788 
		}
1789 
 
1790 
		backgroundUpdater->RunWorkerAsync();
1791 
	}
1792 
 
1793 
	void MainGui::Updater_Finished(System::Object ^Sender, RunWorkerCompletedEventArgs ^E)
1794 
	{
1795 
		if ( !m_pUpdateList )
1796 
			return;
1797 
		if ( !m_pUpdateList->Head() )
1798 
		{
1799 
			delete m_pUpdateList;
1800 
			m_pUpdateList = NULL;
1801 
			return;
1802 
		}
1803 
 
1804 
		this->Enabled = false;
1805 
 
1806 
		CyString server = m_pUpdateList->Head()->str;
1807 
		CyString data = m_pUpdateList->Head()->data;
1808 
 
1809 
		m_pUpdateList->PopFront();
1810 
 
1811 
		// lets check if we have an update
1812 
		if ( data.GetToken(" ", 1, 1) != "!ERROR!" )
1813 
		{
1814 
			CyString download;
1815 
			CyString message;
1816 
			int max;
1817 
			CyString *strs = data.SplitToken("\n", &max);
1818 
			if ( strs )
1819 
			{
1820 
				for ( int i = 0; i < max; i++ )
1821 
				{
1822 
					CyString cmd = strs[i].GetToken(":", 1, 1);
1823 
					CyString rest = strs[i].GetToken(":", 2);
1824 
					rest.RemoveFirstSpace();
1825 
					if ( cmd.Compare("SPKVERSION") )
1826 
					{
1827 
						float v = rest.GetToken(" ", 1, 1).ToFloat();
1828 
						if ( v > GetLibraryVersion() )
1829 
						{
1830 
							message += "New version of the SPK Libraries available\nCurrent = ";
1831 
							message += CyString::CreateFromFloat(GetLibraryVersion(), 2);
1832 
							message += "\nNew Version = ";
1833 
							message += CyString::CreateFromFloat(v, 2);
1834 
							message += "\n\n";
1835 
 
1836 
							CyString filename = rest.GetToken(" ", 2);
1837 
							if ( download.Empty() )
1838 
								download = filename;
1839 
							else
1840 
							{
1841 
								download += "|";
1842 
								download += filename;
1843 
							}
1844 
						}
1845 
					}
1846 
					else if ( cmd.Compare("PMLVERSION") )
1847 
					{
1848 
						float v = rest.GetToken(" ", 1, 1).ToFloat();
1849 
						int beta = rest.GetToken(" ", 2, 2).ToInt();
1850 
 
1851 
						bool newVersion = false;
1852 
						// new version
1853 
						if ( v > (float)PMLVERSION )
1854 
							newVersion = true;
1855 
						// same version, check beta/rc
1856 
						if ( v == (float)PMLVERSION )
1857 
						{
1858 
							// newer beta version
1859 
							if ( beta > (int)PMLBETA && (int)PMLBETA > 0 )
1860 
								newVersion = true;
1861 
							// current is beta, new is an RC
1862 
							else if ( (int)PMLBETA > 0 && beta < 0 )
1863 
								newVersion = true;
1864 
							// current is rc, new is an rc
1865 
							else if ( (int)PMLBETA < 0 && beta < 0 && beta < (int)PMLBETA )
1866 
								newVersion = true;
1867 
							// current is beta or rc, new is not, so its newer
1868 
							else if ( (int)PMLBETA != 0 && beta == 0 )
1869 
								newVersion = true;
1870 
						}
1871 
 
1872 
						if ( newVersion )
1873 
						{
1874 
							message += "New version of the ";
1875 
							message += CyStringFromSystemString(GetProgramName(m_bAdvanced));
1876 
							message += " available\nCurrent = ";
1877 
							message += CyStringFromSystemString(PluginManager::GetVersionString());
1878 
							message += "\nNew Version = ";
1879 
							message += CyStringFromSystemString(PluginManager::GetVersionString(v, beta));
1880 
							message += "\n\n";
1881 
							if ( download.Empty() )
1882 
								download = rest.GetToken(" ", 3);
1883 
							else
1884 
							{
1885 
								download += "|";
1886 
								download += rest.GetToken(" ", 3);
1887 
							}
1888 
						}
1889 
					}
1890 
				}
1891 
			}
1892 
 
1893 
			CLEANSPLIT(strs, max)
1894 
 
1895 
			if ( !download.Empty() && !message.Empty() )
1896 
			{
1897 
				if ( this->DisplayMessageBox(false, "Updater", SystemStringFromCyString(message) + "Do You wish to download and install it?", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == System::Windows::Forms::DialogResult::Yes )
1898 
				{
1899 
					// absolute address
1900 
					CyString downloadFile;
1901 
 
1902 
					int max;
1903 
					CyString *strs = download.SplitToken("|", &max);
1904 
					for ( int i = 0; i < max; i++ )
1905 
					{
1906 
						CyString d = strs[i];
1907 
						// relative address
1908 
						if ( !d.Left(7).Compare("http://") && !d.Left(4).Compare("www.") )
1909 
							d = server.DelToken("/", server.NumToken("/")) + "/" + d;
1910 
 
1911 
						if ( downloadFile.Empty() )
1912 
							downloadFile = d;
1913 
						else
1914 
						{
1915 
							downloadFile += "|";
1916 
							downloadFile += d;
1917 
						}
1918 
					}
1919 
 
1920 
					CLEANSPLIT(strs, max);
1921 
 
1922 
					if ( !downloadFile.Empty() )
1923 
					{
1924 
						m_sDownload = SystemStringFromCyString(downloadFile);
1925 
						this->Close();
1926 
						return;
1927 
					}
1928 
				}
1929 
			}
1930 
		}
1931 
 
1932 
		// otherwise, lets continue with the next server
1933 
		if ( m_pUpdateList->Head() )
1934 
			backgroundUpdater->RunWorkerAsync();
1935 
		else
1936 
		{
1937 
			delete m_pUpdateList;
1938 
			m_pUpdateList = NULL;
1939 
		}
1940 
 
1941 
		this->Enabled = true;
1942 
	}
1943 
 
1944 
	void MainGui::TimerEvent_CheckFile(System::Object ^Sender, System::EventArgs ^E)
1945 
	{
1946 
		if ( m_bRunningBackground )
1947 
			return;
1948 
 
1949 
		System::String ^mydoc = Environment::GetFolderPath(Environment::SpecialFolder::Personal );
1950 
 
1951 
		bool anytoinstall = false;
1952 
 
1953 
		if ( System::IO::File::Exists(mydoc + "\\Egosoft\\pluginmanager_load.dat") )
1954 
		{
1955 
			System::String ^lines = System::IO::File::ReadAllText(mydoc + "\\Egosoft\\pluginmanager_load.dat");
1956 
			System::IO::File::Delete(mydoc + "\\Egosoft\\pluginmanager_load.dat");
1957 
			if ( lines )
1958 
			{
1959 
				CyString strLines = CyStringFromSystemString(lines);
1960 
				int num;
1961 
				CyString *aLines = strLines.SplitToken("\n", &num);
1962 
				if ( num && aLines )
1963 
				{
1964 
					for ( int i = 0; i < num; i++ )
1965 
					{
1966 
						CyString l = aLines[i];
1967 
						l = l.Remove("\r");
1968 
						CyString first = l.GetToken(":", 1, 1);
1969 
						CyString rest = l.GetToken(":", 2);
1970 
						rest.RemoveFirstSpace();
1971 
 
1972 
						if ( first.Compare("File") )
1973 
						{
1974 
							if ( m_bDirLocked ) {
1975 
								this->DisplayLocked(false);
1976 
								return;
1977 
							}
1978 
							if ( this->InstallPackage(SystemStringFromCyString(rest), false, false, true) )
1979 
								anytoinstall = true;
1980 
						}
1981 
					}
1982 
 
1983 
					CLEANSPLIT(aLines, num);
1984 
				}
1985 
			}
1986 
		}
1987 
 
1988 
		if ( anytoinstall )
1989 
			this->StartInstalling(false, true);
1990 
	}
1991 
 
1992 
	void MainGui::Updater_DoWork(System::Object ^Sender, DoWorkEventArgs ^E)
1993 
	{
1994 
		if ( !m_pUpdateList )
1995 
			return;
1996 
		if ( !m_pUpdateList->Head() )
1997 
		{
1998 
			delete m_pUpdateList;
1999 
			m_pUpdateList = NULL;
2000 
			return;
2001 
		}
2002 
 
2003 
		try
2004 
		{
2005 
			System::Net::WebClient ^Client = gcnew System::Net::WebClient();
2006 
 
2007 
			System::IO::Stream ^strm = Client->OpenRead(SystemStringFromCyString(m_pUpdateList->Head()->str));
2008 
			System::IO::StreamReader ^sr = gcnew System::IO::StreamReader(strm);
2009 
			System::String ^read = sr->ReadToEnd();
2010 
			strm->Close();
2011 
			sr->Close();
2012 
 
2013 
			m_pUpdateList->Head()->data = CyStringFromSystemString(read);
2014 
		}
2015 
		catch (System::Net::WebException ^ex)
2016 
		{
2017 
			m_pUpdateList->Head()->data = CyStringFromSystemString("!ERROR! " + ex->ToString());
2018 
			if ( ex->Status == System::Net::WebExceptionStatus::ConnectFailure )
2019 
			{
2020 
				m_pUpdateList->Head()->data = CyStringFromSystemString("!ERROR! " + ex->ToString());
2021 
 
2022 
			}
2023 
		}
2024 
	}
2025 
 
2026 
	void MainGui::LaunchGame()
2027 
	{
2028 
		if ( !System::IO::File::Exists(".\\GameLauncher.exe") )
2029 
			return;
2030 
 
121 cycrow 2031 
		m_sRun = _US(m_pPackages->GetGameRunExe());
1 cycrow 2032 
		this->Close();
2033 
	}
2034 
 
2035 
	bool MainGui::DisplayTip(int tipsection, int tip)
2036 
	{
2037 
		if ( tipsection < 0 || tipsection >= MAXTIPS )
2038 
			return false;
2039 
 
2040 
		STips ^tips = (STips ^)m_lTips[tipsection];
2041 
		if ( !(tips->iTips & tip) )
2042 
		{
2043 
			System::String ^sTip = cli::safe_cast<System::String ^>(tips->sTips[(tip >> 1)]);
2044 
 
2045 
			tips->iTips |= tip;
2046 
 
2047 
			if ( this->DisplayMessageBox(false, "Plugin Manager Tip", sTip, MessageBoxButtons::YesNo, MessageBoxIcon::Question) == System::Windows::Forms::DialogResult::Yes )
2048 
				return true;
2049 
			else
2050 
				return false;
2051 
		}
2052 
 
2053 
		return true;
2054 
	}
2055 
 
2056 
	void MainGui::SetTipStrings(int section)
2057 
	{
2058 
		STips ^t = (STips ^)m_lTips[section];
2059 
		t->sTips = gcnew ArrayList();
2060 
 
2061 
		switch ( section )
2062 
		{
2063 
			case TIPSECTION_YESNO:
2064 
				t->sTips->Add("You are about to uninstall a ship, you need to make sure that there are no ships in the sector you was in when you saved, otherwise it could prevent the save from loading\n\nContinue Uninstalling Ship?");
2065 
				t->sTips->Add("You are about to disable a ship, you need to make sure that there are no ships in the sector you was in when you saved, otherwise it could prevent the save from loading\n\nContinue Disabling Ship?");
2066 
				break;
2067 
		}
2068 
	}
2069 
 
2070 
	System::Windows::Forms::DialogResult MainGui::DisplayMessageBox(bool inthread, System::String ^title, System::String ^text, MessageBoxButtons buttons, MessageBoxIcon icon)
2071 
	{
2072 
		if ( !inthread )
2073 
			return MessageBox::Show(this, text, title, buttons, icon);
2074 
		else
2075 
		{
2076 
			m_bDisplayMessage = true;
2077 
			m_sMessageText = text;
2078 
			m_sMessageTitle = title;
2079 
			m_messageIcon = icon;
2080 
			m_messageButtons = buttons;
2081 
 
2082 
			return System::Windows::Forms::DialogResult::Abort;
2083 
		}
2084 
	}
2085 
 
2086 
	ListViewItem ^MainGui::FindSelectedItem()
2087 
	{
2088 
		Point ^mousePoint = this->ListPackages->PointToClient(this->contextMenuStrip1->MousePosition);
2089 
		return  this->ListPackages->GetItemAt(mousePoint->X, mousePoint->Y);
2090 
	}
2091 
 
2092 
	CBaseFile *MainGui::GetFileFromItem(ListViewItem ^item)
2093 
	{
2094 
		int num = System::Convert::ToInt32(item->Tag);
2095 
		return m_pPackages->GetPackageAt(num);
2096 
	}
2097 
 
2098 
	System::Void MainGui::OpenContextMenu(System::Object ^Sender, CancelEventArgs ^E)
2099 
	{
2100 
		m_pListItem = nullptr;
2101 
		E->Cancel = true;
2102 
		bool showSep = false;
2103 
		bool showSep2 = false;
2104 
 
2105 
		ListViewItem ^item = this->FindSelectedItem();
2106 
		CBaseFile *p = NULL;
2107 
		if ( item )
2108 
				p = this->GetFileFromItem(item);
2109 
 
2110 
		this->emailAuthorToolStripMenuItem->Visible = false;
2111 
		this->visitForumPageToolStripMenuItem->Visible = false;
2112 
		this->visitWebSiteToolStripMenuItem->Visible = false;
2113 
		this->ContextDisable->Visible = false;
2114 
		this->ContextEnable->Visible = false;
2115 
		this->ContextName->Image = nullptr;
2116 
		this->UninstallSelectedContext->Visible = false;
2117 
		this->viewReadmeToolStripMenuItem->Visible = false;
2118 
		this->extrasToolStripMenuItem->Visible = false;
2119 
		this->checkForUpdatesToolStripMenuItem->Visible = false;
2120 
 
2121 
		if ( p 	|| this->ListPackages->SelectedItems->Count )
2122 
		{
2123 
 
2124 
			if ( item && p )
2125 
			{
2126 
				m_pListItem = item;
2127 
				this->ContextName->Text = item->Text;
2128 
				if ( item->ImageIndex != -1 )
2129 
					this->ContextName->Image = this->ListPackages->LargeImageList->Images[item->ImageIndex];
2130 
				else if ( item->ImageKey )
2131 
				{
2132 
					int key = this->ListPackages->LargeImageList->Images->IndexOfKey(item->ImageKey);
2133 
					if ( key != -1 )
2134 
						this->ContextName->Image = this->ListPackages->LargeImageList->Images[key];
2135 
				}
2136 
				else if ( p->GetIcon() )
2137 
					PluginManager::DisplayContextIcon(p, this->ContextName, nullptr);
2138 
 
2139 
				this->uninstallToolStripMenuItem->Text = "Uninstall: " + item->Text;
2140 
 
2141 
				this->viewReadmeToolStripMenuItem->DropDownItems->Clear();
2142 
				if ( p->CountFiles(FILETYPE_README) )
2143 
				{
2144 
					for ( C_File *f = p->GetFirstFile(FILETYPE_README); f; f = p->GetNextFile(f) )
2145 
					{
2146 
						if ( f->GetBaseName().GetToken(".", 1, 1).IsNumber() )
2147 
						{
2148 
							if ( f->GetBaseName().GetToken(".", 1, 1).ToInt() != m_pPackages->GetLanguage() )
2149 
								continue;
2150 
						}
2151 
						if ( f->GetBaseName().IsIn("-L") )
2152 
						{
2153 
							int pos = f->GetBaseName().FindPos("-L");
2154 
							int l = f->GetBaseName().Mid(pos + 2, 3).ToInt();
2155 
							if ( l != m_pPackages->GetLanguage() )
2156 
								continue;
2157 
						}
2158 
 
2159 
						Windows::Forms::ToolStripMenuItem ^item = gcnew Windows::Forms::ToolStripMenuItem();
2160 
						item->Text = SystemStringFromCyString(f->GetFilename());
2161 
						item->Image = this->viewReadmeToolStripMenuItem->Image;
2162 
						item->ImageScaling = ToolStripItemImageScaling::None;
2163 
						item->Click += gcnew System::EventHandler(this, &MainGui::RunItem);
2164 
						item->Tag = SystemStringFromCyString(f->GetFilePointer());
2165 
						this->viewReadmeToolStripMenuItem->DropDownItems->Add(item);
2166 
					}
2167 
 
2168 
					if ( this->viewReadmeToolStripMenuItem->DropDownItems->Count )
2169 
					{
2170 
						this->viewReadmeToolStripMenuItem->Visible = true;
2171 
						showSep = true;
2172 
					}
2173 
				}
2174 
 
2175 
				this->extrasToolStripMenuItem->DropDownItems->Clear();
2176 
				if ( p->CountFiles(FILETYPE_EXTRA) )
2177 
				{
2178 
					showSep = true;
2179 
					for ( C_File *f = p->GetFirstFile(FILETYPE_EXTRA); f; f = p->GetNextFile(f) )
2180 
					{
2181 
						if ( !f->GetDir().Left(6).Compare("extras") )
2182 
							continue;
2183 
 
2184 
						Windows::Forms::ToolStripMenuItem ^item = gcnew Windows::Forms::ToolStripMenuItem();
2185 
						item->Text = SystemStringFromCyString(f->GetFilename());
2186 
						if ( this->imageList2->Images->IndexOfKey(SystemStringFromCyString(f->GetFileExt().ToLower())) > -1 )
2187 
							item->Image = this->imageList2->Images[this->imageList2->Images->IndexOfKey(SystemStringFromCyString(f->GetFileExt().ToLower()))];
2188 
						else
2189 
						{
2190 
							CyString exe = f->GetFilePointer();
2191 
							exe = exe.FindReplace("/", "\\");
2192 
							wchar_t wText[200];
2193 
							::MultiByteToWideChar(CP_ACP, NULL, (char *)exe.c_str(), -1, wText, exe.Length() + 1);
2194 
 
2195 
							System::Drawing::Icon ^myIcon;
2196 
							SHFILEINFO *shinfo = new SHFILEINFO();
2197 
 
2198 
							if ( FAILED(SHGetFileInfo(wText, 0, shinfo, sizeof(shinfo), SHGFI_ICON | SHGFI_LARGEICON)) )
2199 
							{
2200 
								if ( FAILED(SHGetFileInfo(wText, 0, shinfo, sizeof(shinfo), SHGFI_ICON | SHGFI_SMALLICON)) )
2201 
									item->Image = this->imageList2->Images[0];
2202 
								else
2203 
								{
2204 
									myIcon = System::Drawing::Icon::FromHandle(IntPtr(shinfo->hIcon));
2205 
									item->Image = myIcon->ToBitmap();
2206 
								}
2207 
							}
2208 
							else
2209 
							{
2210 
								myIcon = System::Drawing::Icon::FromHandle(IntPtr(shinfo->hIcon));
2211 
								item->Image = myIcon->ToBitmap();
2212 
							}
2213 
 
2214 
							delete shinfo;
2215 
						}
2216 
						item->ImageScaling = ToolStripItemImageScaling::None;
2217 
						item->Click += gcnew System::EventHandler(this, &MainGui::RunItem);
2218 
						item->Tag = SystemStringFromCyString(f->GetFilePointer());
2219 
						this->extrasToolStripMenuItem->DropDownItems->Add(item);
2220 
					}
2221 
				}
2222 
 
2223 
				if ( this->extrasToolStripMenuItem->DropDownItems->Count )
2224 
					this->extrasToolStripMenuItem->Visible = true;
2225 
 
2226 
				// email/website/forum
49 cycrow 2227 
				if ( !p->forumLink().empty() ) {
2228 
					Utils::String web = p->forumLink();
2229 
					if ( web.isNumber() )
2230 
						web = Utils::String("http://forum.egosoft.com/viewtopic.php?t=") + web;
1 cycrow 2231 
 
2232 
					this->visitForumPageToolStripMenuItem->Visible = true;
49 cycrow 2233 
					if ( !web.isin("http://") )
2234 
						this->visitForumPageToolStripMenuItem->Tag = "http://" + _US(web);
1 cycrow 2235 
					else
49 cycrow 2236 
						this->visitForumPageToolStripMenuItem->Tag = _US(web);
1 cycrow 2237 
					showSep2 = true;
2238 
				}
49 cycrow 2239 
				if ( !p->email().empty() )
1 cycrow 2240 
				{
2241 
					this->emailAuthorToolStripMenuItem->Visible = true;
50 cycrow 2242 
					this->emailAuthorToolStripMenuItem->Tag = "mailto://" + _US(p->email()) + "?subject=Re: " + _US(p->name().findReplace(" ", "%20"));
1 cycrow 2243 
					showSep2 = true;
2244 
				}
49 cycrow 2245 
				if ( !p->webSite().empty() ) {
1 cycrow 2246 
					this->visitWebSiteToolStripMenuItem->Visible = true;
49 cycrow 2247 
					if ( !p->webSite().isin("http://") )
2248 
						this->visitWebSiteToolStripMenuItem->Tag = "http://" + _US(p->webSite());
2249 
					else
2250 
						this->visitWebSiteToolStripMenuItem->Tag = _US(p->webSite());
1 cycrow 2251 
					showSep2 = true;
2252 
				}
2253 
 
49 cycrow 2254 
				if ( !p->webAddress().empty() )
1 cycrow 2255 
					this->checkForUpdatesToolStripMenuItem->Visible = true;
2256 
			}
2257 
			else
2258 
				m_pListItem = nullptr;
2259 
 
2260 
			if ( this->ListPackages->SelectedItems->Count > 1 || !p )
2261 
			{
2262 
				this->UninstallSelectedContext->Visible = true;
2263 
				this->UninstallSelectedContext->Text = "Uninstall Selected (" + System::Convert::ToString(this->ListPackages->SelectedItems->Count) + " packages)";
2264 
			}
2265 
 
2266 
			if ( p )
2267 
			{
2268 
				if ( p->IsEnabled() )
2269 
					this->ContextDisable->Visible = true;
2270 
				else
2271 
					this->ContextEnable->Visible = true;
2272 
			}
2273 
 
2274 
			this->ContextSeperator->Visible = showSep;
2275 
			this->ContextSeperator2->Visible = showSep2;
2276 
			E->Cancel = false;
2277 
		}
2278 
	}
2279 
 
2280 
	System::Void MainGui::ListPackages_DragOver(System::Object^  sender, System::Windows::Forms::DragEventArgs^  e)
2281 
	{
2282 
		e->Effect = DragDropEffects::None;
2283 
 
2284 
		if (e->Data->GetDataPresent(DataFormats::FileDrop))
2285 
		{
2286 
			cli::array<String ^> ^a = (cli::array<String ^> ^)e->Data->GetData(DataFormats::FileDrop, false);
2287 
			int i;
2288 
			for(i = 0; i < a->Length; i++)
2289 
			{
2290 
				String ^s = a[i];
2291 
				String ^ext = IO::FileInfo(s).Extension;
2292 
				if ( String::Compare(IO::FileInfo(s).Extension, ".xsp", true) == 0 || String::Compare(IO::FileInfo(s).Extension, ".spk", true) == 0 )
2293 
				{
2294 
					e->Effect = DragDropEffects::Copy;
2295 
					break;
2296 
				}
2297 
			}
2298 
		}
2299 
	}
2300 
 
2301 
	System::Void MainGui::ListPackages_DragDrop(System::Object^  sender, System::Windows::Forms::DragEventArgs^  e)
2302 
	{
2303 
		if (e->Data->GetDataPresent(DataFormats::FileDrop))
2304 
		{
2305 
			cli::array<String ^> ^a = (cli::array<String ^> ^)e->Data->GetData(DataFormats::FileDrop, false);
2306 
			int i;
2307 
			for(i = 0; i < a->Length; i++)
2308 
			{
2309 
				String ^s = a[i];
2310 
				String ^ext = IO::FileInfo(s).Extension;
2311 
				if ( String::Compare(IO::FileInfo(s).Extension, ".xsp", true) == 0 || String::Compare(IO::FileInfo(s).Extension, ".spk", true) == 0 )
2312 
				{
2313 
					if ( m_bDirLocked ) {
2314 
						this->DisplayLocked(false);
2315 
						return;
2316 
					}
2317 
					this->InstallPackage(s, false, false, true);
2318 
				}
2319 
			}
2320 
 
2321 
			this->StartInstalling(false, true);
2322 
		}
2323 
	}
2324 
 
2325 
	bool MainGui::CheckAccessRights(String ^dir)
2326 
	{
2327 
		/*
2328 
		// check if already exists
2329 
		String ^file = dir + "\\accessrightscheck.dat";
2330 
		String ^writeStr = "testing file access";
2331 
		if ( IO::File::Exists(file) )
2332 
		{
2333 
			// remove it
2334 
			IO::File::Delete(file);
2335 
			// still exists, cant delete it
2336 
			if ( IO::File::Exists(file) )
2337 
				return false;
2338 
		}
2339 
 
2340 
		IO::DirectoryInfo ^dInfo = gcnew IO::DirectoryInfo(dir);
2341 
		Security::AccessControl::DirectorySecurity ^dSecurity = dInfo->GetAccessControl();
2342 
		dSecurity->
2343 
 
2344 
 
2345 
		System::IO::FileStream ^writeStream = nullptr;
2346 
		IO::BinaryWriter ^writer = nullptr;
2347 
		try {
2348 
			 writeStream = gcnew System::IO::FileStream(file, System::IO::FileMode::Create);
2349 
			 writer = gcnew IO::BinaryWriter(writeStream);
2350 
		}
2351 
		catch (System::IO::IOException ^e)
2352 
		{
2353 
			MessageBox::Show("Error: " + e->ToString(), "Error", MessageBoxButtons::OK, MessageBoxIcon::Warning);
2354 
		}
2355 
		catch (System::Exception ^e)
2356 
		{
2357 
			MessageBox::Show("Error: " + e->ToString(), "Error", MessageBoxButtons::OK, MessageBoxIcon::Warning);
2358 
		}
2359 
		finally
2360 
		{
2361 
			writer->Write(writeStr);
2362 
			writer->Close();
2363 
			writeStream->Close();
2364 
		}
2365 
 
2366 
		// check if its written
2367 
		if ( !IO::File::Exists(file) )
2368 
			return false;
2369 
 
2370 
		// remove the file again
2371 
		IO::File::Delete(file);
2372 
		if ( IO::File::Exists(file) )
2373 
			return false;
2374 
*/
2375 
		return true;
2376 
	}
2377 
 
2378 
	System::Void MainGui::RunItem(System::Object ^sender, System::EventArgs ^e)
2379 
	{
2380 
		Windows::Forms::ToolStripMenuItem ^item = cli::safe_cast<ToolStripMenuItem ^>(sender);
2381 
		String ^file = Convert::ToString(item->Tag);
2382 
 
2383 
		if ( IO::File::Exists(file) )
2384 
		{
2385 
			System::Diagnostics::Process::Start(file);
2386 
		}
2387 
	}
2388 
 
2389 
	void MainGui::RunFromToolItem(ToolStripMenuItem ^item)
2390 
	{
2391 
		if ( !item ) return;
2392 
		if ( !item->Tag ) return;
2393 
 
2394 
		String ^file = Convert::ToString(item->Tag);
2395 
		System::Diagnostics::Process::Start(file);
2396 
	}
2397 
 
2398 
	void MainGui::FakePatchControlDialog()
2399 
	{
2400 
		FakePatchControl ^fpc = gcnew FakePatchControl(m_pPackages);
2401 
		if ( fpc->ShowDialog(this) == Windows::Forms::DialogResult::OK )
2402 
		{
2403 
			m_pPackages->ApplyFakePatchOrder(fpc->GetPatchOrder());
2404 
			m_pPackages->ShuffleFakePatches(0);
2405 
		}
2406 
	}
2407 
 
2408 
	void MainGui::CheckFakePatchCompatability()
2409 
	{
2410 
		CyStringList errorList;
2411 
		int count = 0;
2412 
		int packageCount = 0;
2413 
		for ( CBaseFile *p = m_pPackages->GetFirstPackage(); p; p = m_pPackages->GetNextPackage(p) )
2414 
		{
2415 
			if ( !p->IsEnabled() ) continue;
2416 
			if ( !p->AnyFileType(FILETYPE_MOD) ) continue;
2417 
 
2418 
			CyString packageName = p->GetFullPackageName(m_pPackages->GetLanguage());
2419 
 
2420 
			// compare this file against all other packages
2421 
			for ( CBaseFile *comparePackage = m_pPackages->GetNextPackage(p); comparePackage; comparePackage = m_pPackages->GetNextPackage(comparePackage) )
2422 
			{
2423 
				if ( comparePackage == p ) continue; // dont include the same package
2424 
				if ( !comparePackage->IsEnabled() ) continue;
2425 
				if ( !comparePackage->AnyFileType(FILETYPE_MOD) ) continue;
2426 
 
2427 
				CyStringList list;
2428 
				if ( m_pPackages->CheckCompatabilityBetweenMods(p, comparePackage, &list) )
2429 
				{
2430 
					CyString package2Name = comparePackage->GetFullPackageName(m_pPackages->GetLanguage());
2431 
					for ( SStringList *str = list.Head(); str; str = str->next )
2432 
					{
2433 
						errorList.PushBack(str->str + " (" + packageName + ")", str->data + " (" + package2Name + ")");
2434 
						++count;
2435 
					}
2436 
					++packageCount;
2437 
				}
2438 
			}
2439 
		}
2440 
 
2441 
		if ( count )
2442 
		{
2443 
			if ( MessageBox::Show(this, "Found incompatability between fake patches\n" + count + " errors found\n\nDo you wish to view the errors?", "Fake Patch Compatability", MessageBoxButtons::YesNo, MessageBoxIcon::Information) == Windows::Forms::DialogResult::Yes )
2444 
			{
2445 
				CompareList ^cl = gcnew CompareList("Fake Patch Incompatabilities");
2446 
				cl->AddStringList(errorList);
2447 
				cl->ShowDialog(this);
2448 
			}
2449 
		}
2450 
		else
2451 
			MessageBox::Show(this, "No incompatabilities found between fake patches", "Fake Patch Compatability", MessageBoxButtons::OK, MessageBoxIcon::Information);
2452 
	}
2453 
 
88 cycrow 2454 
	void MainGui::EditWaresDialog()
2455 
	{
2456 
		if ( m_bDirLocked ) {
2457 
			this->DisplayLocked(false);
2458 
			return;
2459 
		}
2460 
 
2461 
		EditWares ^edit = gcnew EditWares(m_pPackages);
2462 
 
2463 
		if ( edit->ShowDialog(this) == Windows::Forms::DialogResult::OK )
2464 
		{
2465 
		}
2466 
	}
2467 
 
89 cycrow 2468 
	void MainGui::CommandSlotsDialog()
2469 
	{
2470 
		CommandSlots ^slots = gcnew CommandSlots(m_pPackages);
2471 
 
2472 
		slots->ShowDialog(this);
2473 
	}
2474 
 
1 cycrow 2475 
	void MainGui::EditGlobalsDialog()
2476 
	{
2477 
		if ( m_pPackages->IsVanilla() ) {
2478 
			this->DisplayMessageBox(false, "Edit Globals", "Currently in Vanilla Mode, Cant change globals without being modified\n\nSwitch to modified mode if you wish to edit globals", MessageBoxButtons::OK, MessageBoxIcon::Question);
2479 
			return;
2480 
		}
2481 
		if ( m_bDirLocked ) {
2482 
			this->DisplayLocked(false);
2483 
			return;
2484 
		}
2485 
 
2486 
		//load globals
2487 
		CyStringList globals;
2488 
		m_pPackages->ReadGlobals(globals);
2489 
 
2490 
		EditGlobals ^edit = gcnew EditGlobals(&globals);
2491 
 
2492 
		// make our saved changes
2493 
		for ( SStringList *str = m_pPackages->GetGlobals()->Head(); str; str = str->next )
2494 
			edit->SetEditedItem(SystemStringFromCyString(str->str), SystemStringFromCyString(str->data));
2495 
 
2496 
		if ( edit->ShowDialog(this) == Windows::Forms::DialogResult::OK )
2497 
		{
2498 
			// compare whats different and save
2499 
			m_pPackages->GetGlobals()->Clear();
2500 
			for ( SStringList *str = edit->GetSavedSettings()->Head(); str; str = str->next )
2501 
				m_pPackages->GetGlobals()->PushBack(str->str, str->data);
2502 
		}
2503 
	}
2504 
 
2505 
	void MainGui::ViewFileLog()
2506 
	{
2507 
		if ( m_pFileErrors->Empty() )
2508 
			MessageBox::Show(this, "No messages to view in file log", "Empty File Log", MessageBoxButtons::OK, MessageBoxIcon::Warning);
2509 
		else
2510 
		{
2511 
			FileLog ^log = gcnew FileLog;
2512 
			for ( SStringList *str = m_pFileErrors->Head(); str; str = str->next )
2513 
			{
2514 
				bool add = true;
2515 
				String ^status = "Unknown Error";
2516 
				switch(str->data.GetToken(" ", 1, 1).ToInt())
2517 
				{
2518 
					case SPKINSTALL_CREATEDIRECTORY:
2519 
						status = "Created Directory";
2520 
						break;
2521 
					case SPKINSTALL_CREATEDIRECTORY_FAIL:
2522 
						status = "Failed to create Directory";
2523 
						break;
2524 
					case SPKINSTALL_WRITEFILE:
2525 
						status = "File Written";
2526 
						break;
2527 
					case SPKINSTALL_WRITEFILE_FAIL:
2528 
						status = "Failed to Write File";
2529 
						break;
2530 
					case SPKINSTALL_DELETEFILE:
2531 
						status = "Deleted File";
2532 
						break;
2533 
					case SPKINSTALL_DELETEFILE_FAIL:
2534 
						status = "Failed to Delete File";
2535 
						break;
2536 
					case SPKINSTALL_SKIPFILE:
2537 
						status = "File Skipped";
2538 
						break;
2539 
					case SPKINSTALL_REMOVEDIR:
2540 
						status = "Removed Directory";
2541 
						break;
2542 
					case SPKINSTALL_ENABLEFILE:
2543 
						status = "Enabled File";
2544 
						break;
2545 
					case SPKINSTALL_DISABLEFILE:
2546 
						status = "Disabled File";
2547 
						break;
2548 
					case SPKINSTALL_ENABLEFILE_FAIL:
2549 
						status = "Failed to Enable File";
2550 
						break;
2551 
					case SPKINSTALL_DISABLEFILE_FAIL:
2552 
						status = "Failed to Disable File";
2553 
						break;
2554 
					case SPKINSTALL_UNINSTALL_MOVE:
2555 
						status = "Moved Uninstall File";
2556 
						break;
2557 
					case SPKINSTALL_UNINSTALL_COPY:
2558 
						status = "Copied Uninstall File";
2559 
						break;
2560 
					case SPKINSTALL_UNINSTALL_MOVE_FAIL:
2561 
						status = "Failed to move uninstall file";
2562 
						break;
2563 
					case SPKINSTALL_UNINSTALL_COPY_FAIL:
2564 
						status = "Failed to copy uninstall file";
2565 
						break;
2566 
					case SPKINSTALL_UNINSTALL_REMOVE:
2567 
						status = "Removed uninstall file";
2568 
						break;
2569 
					case SPKINSTALL_UNINSTALL_REMOVE_FAIL:
2570 
						status = "Failed to remove uninstall file";
2571 
						break;
2572 
					case SPKINSTALL_ORIGINAL_BACKUP:
2573 
						status = "Backed up Original";
2574 
						break;
2575 
					case SPKINSTALL_ORIGINAL_RESTORE:
2576 
						status = "Restored Original";
2577 
						break;
2578 
					case SPKINSTALL_ORIGINAL_BACKUP_FAIL:
2579 
						status = "Failed to Backup Original";
2580 
						break;
2581 
					case SPKINSTALL_ORIGINAL_RESTORE_FAIL:
2582 
						status = "Failed to restore Original";
2583 
						break;
2584 
					case SPKINSTALL_FAKEPATCH:
2585 
						status = "Adjusting Fakepatch";
2586 
						break;
2587 
					case SPKINSTALL_FAKEPATCH_FAIL:
2588 
						status = "Failed to adjust Fakepatch";
2589 
						break;
2590 
					case SPKINSTALL_AUTOTEXT:
2591 
						status = "Adjusting Text File";
2592 
						break;
2593 
					case SPKINSTALL_AUTOTEXT_FAIL:
2594 
						status = "Failed to adjust Text File";
2595 
						break;
2596 
					case SPKINSTALL_MISSINGFILE:
2597 
						status = "Missing File";
2598 
						break;
2599 
					case SPKINSTALL_SHARED:
2600 
						status = "Shared File";
2601 
						break;
2602 
					case SPKINSTALL_SHARED_FAIL:
2603 
						status = "Shared File Failed";
2604 
						break;
2605 
					case SPKINSTALL_ORPHANED:
2606 
						status = "File Orphaned";
2607 
						break;
2608 
					case SPKINSTALL_ORPHANED_FAIL:
2609 
						status = "Failed to Orphan file";
2610 
						break;
2611 
					case SPKINSTALL_UNCOMPRESS_FAIL:
2612 
						status = "Failed to Uncompress";
2613 
						break;
2614 
				}
2615 
 
2616 
				if ( add )
2617 
				{
2618 
					if ( str->data.NumToken(" ") > 1 )
2619 
						log->AddItem(SystemStringFromCyString(str->str.findreplace("~", " => ")), status, SystemStringFromCyString(SPK::ConvertTimeString((long)str->data.GetToken(" ", 2, 2).ToLong())));
2620 
					else
2621 
						log->AddItem(SystemStringFromCyString(str->str.findreplace("~", " => ")), status, nullptr);
2622 
				}
2623 
			}
2624 
			if ( log->ShowDialog(this) == Windows::Forms::DialogResult::Cancel )
2625 
			{
2626 
				if ( MessageBox::Show(this, "Are you sure you want to clear the file log?", "Clear File Log", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == Windows::Forms::DialogResult::Yes )
2627 
				{
2628 
					m_pFileErrors->Clear();
2629 
					MessageBox::Show(this, "The file log has been cleared", "File Log Cleared", MessageBoxButtons::OK, MessageBoxIcon::Information);
2630 
				}
2631 
			}
2632 
 
2633 
		}
2634 
	}
2635 
 
2636 
	void MainGui::VerifyInstalledFiles()
2637 
	{
2638 
		CyStringList missing;
2639 
		int amount = m_pPackages->VerifyInstalledFiles(&missing);
2640 
		if ( !amount )
2641 
			MessageBox::Show(this, "All files are currently installed", "Verifying Installed Files", MessageBoxButtons::OK, MessageBoxIcon::Information);
2642 
		else
2643 
		{
2644 
			String ^text;
2645 
			for ( SStringList *str = missing.Head(); str; str = str->next )
2646 
			{
2647 
				text += SystemStringFromCyString(str->str);
2648 
				text += "\n\t";
2649 
				CyString data = str->data.findreplace("\n", "\t\n");
2650 
				text += SystemStringFromCyString(data);
2651 
				text += "\n\n";
2652 
			}
2653 
			MessageBoxDetails::Show(this, "Verifing Installed Files", "Missing files detected\nAmount = " + amount, text, false, 600);
2654 
		}
2655 
	}
2656 
 
2657 
	void MainGui::ExportPackageList()
2658 
	{
2659 
		bool enabled = false;
2660 
		if ( MessageBox::Show(this, "Do you only want to export enabled packages?", "Only Enabled", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == Windows::Forms::DialogResult::Yes )
2661 
			enabled =true;
2662 
		SaveFileDialog ^ofd = gcnew SaveFileDialog();
2663 
		ofd->Filter = "Log Files (*.log)|*.log";
2664 
		ofd->FilterIndex = 1;
2665 
		ofd->RestoreDirectory = true;
2666 
		ofd->AddExtension =  true;
2667 
		ofd->Title = "Select the file to save the package list to";
2668 
		if ( ofd->ShowDialog(this) == Windows::Forms::DialogResult::OK )
2669 
		{
2670 
			if ( IO::File::Exists(ofd->FileName) )
2671 
				IO::File::Delete(ofd->FileName);
2672 
 
2673 
			StreamWriter ^sw = File::CreateText(ofd->FileName);
2674 
			try
2675 
			{
2676 
				for ( CBaseFile *package = m_pPackages->FirstPackage(); package; package = m_pPackages->NextPackage() )
2677 
				{
2678 
					if ( enabled && !package->IsEnabled() ) continue;
50 cycrow 2679 
					Utils::String line = package->name() + " :: " + package->author() + " :: " + package->version() + " :: " + package->creationDate() + " :: ";
1 cycrow 2680 
 
2681 
					if ( package->GetType() == TYPE_XSP )
2682 
						line += "Ship :: ";
2683 
					else if ( package->GetType() == TYPE_ARCHIVE )
2684 
						line += "- Archive - :: ";
50 cycrow 2685 
					else if ( package->GetType() == TYPE_SPK ) {
2686 
						Utils::String type = ((CSpkFile *)package)->GetScriptTypeString(m_pPackages->GetLanguage());
2687 
						if ( !type.empty() ) line += type + " :: ";
1 cycrow 2688 
					}
2689 
 
50 cycrow 2690 
					line = line + ((package->IsEnabled()) ? "Yes" : "No") + " :: " + ((package->IsSigned()) ? "Yes" : "No");
2691 
					sw->WriteLine(_US(line));
1 cycrow 2692 
				}
2693 
			}
2694 
			finally
2695 
			{
2696 
				if ( sw )
2697 
					delete (IDisposable ^)sw;
2698 
			}
2699 
 
2700 
			if ( IO::File::Exists(ofd->FileName) )
2701 
			{
2702 
				if ( enabled )
2703 
					MessageBox::Show(this, "Enabled Packages have been saved to:\n" + ofd->FileName, "Package List Saved", MessageBoxButtons::OK, MessageBoxIcon::Information);
2704 
				else
2705 
					MessageBox::Show(this, "Complete Package List has been saved to:\n" + ofd->FileName, "Package List Saved", MessageBoxButtons::OK, MessageBoxIcon::Information);
2706 
			}
2707 
			else
2708 
				MessageBox::Show(this, "There was an error writing file:\n" + ofd->FileName, "File Write Error", MessageBoxButtons::OK, MessageBoxIcon::Error);
2709 
		}
2710 
	}
121 cycrow 2711 
	System::Void MainGui::MainGui_Shown(System::Object^  sender, System::EventArgs^  e)
2712 
	{
2713 
		if (m_pDirList->empty())
2714 
		{
2715 
			if (MessageBox::Show(this, "You currently have no directories added, would you like to add them now?", "No Game Directories", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == Windows::Forms::DialogResult::Yes)
2716 
				this->OpenDirectoryControl();
2717 
		}
2718 
	}
2719 
 
2720 
	System::Void MainGui::MainGui_Load(System::Object^  sender, System::EventArgs^  e)
2721 
	{
2722 
 
2723 
		if ( m_iSaveGameManager == -1 )
2724 
		{
2725 
			m_iSaveGameManager = 0;
2726 
			/*
2727 
			if ( MessageBox::Show(this, "The save game manager will keep seperate save games for each directory and keeps vanilla and modified save games seperate\n\nDo you want to enable the save game manager?", "Save Game Manager", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == Windows::Forms::DialogResult::Yes )
2728 
			{
2729 
				m_iSaveGameManager = 1;
2730 
				this->PrepareSaveGameManager();
2731 
			}
2732 
			else
2733 
				m_iSaveGameManager = 0;
2734 
			*/
2735 
		}
2736 
		m_pMenuBar->SetSaveGameManager((m_iSaveGameManager == 1) ? true : false);
2737 
 
2738 
		// auto update
2739 
		if (m_iSizeX != -1 && m_iSizeY != -1)
2740 
			this->Size = System::Drawing::Size(m_iSizeX, m_iSizeY);
2741 
 
2742 
		this->UpdateBuiltInPackages();
2743 
		this->AutoUpdate();
2744 
	}
1 cycrow 2745 
}