Subversion Repositories spk

Rev

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