Subversion Repositories spk

Rev

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

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