Subversion Repositories spk

#include "../stdafx.h"
#include "DirectoryControl.h"

using namespace PluginManager;

DirectoryControl::DirectoryControl(CPackages *packages, Utils::WStringList *currentDirs, Utils::WStringList *removedDirs)
{
        InitializeComponent();

        this->listView1->LargeImageList = this->imageListGames;
        this->listView1->SmallImageList = this->imageListGames;
        this->listView2->LargeImageList = this->imageListGames;
        this->listView2->SmallImageList = this->imageListGames;

        _packages = packages;
        _lDirs = new Utils::WStringList();
        _lRemoveDirs = new Utils::WStringList();
        _lFoundDirs = new Utils::WStringList();

        this->getAllDirs(currentDirs, removedDirs);
        this->UpdateGameDirs();
        this->UpdateFoundDirs();
        this->UpdateTexts();
}

DirectoryControl::~DirectoryControl()
{
        if (components)
        {
                delete components;
        }

        delete _lDirs;
        delete _lRemoveDirs;
        delete _lFoundDirs;
}

void DirectoryControl::AddFoundDir(const Utils::WString &dir)
{
        if (CDirIO(dir).exists())
        {
                Utils::WString gameName = _packages->GetGameExe()->gameName(dir);
                if (!gameName.empty())
                {
                        if (!_lFoundDirs->contains(dir, true) && !_lDirs->contains(dir, true) && !_lRemoveDirs->contains(dir, true))
                        {
                                Utils::WString exe = dir.findReplace(L"\\", L"/").findReplace(L"//", L"/");
                                _lFoundDirs->pushBack(exe, _packages->GetGameExe()->gameName(exe));
                        }
                }
        }
}

void DirectoryControl::FindAllAddons(const Utils::WString &exe, bool checkBase)
{
        CDirIO Dir(exe);

        if (checkBase && _packages->GetGameExe()->isAddon(exe))
        {
                Utils::WString base = _packages->getGameRunExe(_packages->GetGameExe()->gameDir(exe));
                if (CFileIO::Exists(base))
                {
                        AddFoundDir(base);
                        FindAllAddons(base, false);
                        return;
                }
        }

        if (Dir.isFile())
        {
                CFileIO file(exe);
                if (file.exists())
                {
                        // dont include addons, only the base game
                        if (!_packages->GetGameExe()->isAddon(exe))
                        {
                                CDirIO dir(file.dir());
                                Utils::WStringList list;
                                // get all the addons from a base game
                                if (_packages->getGameAddons(list, _packages->GetGameExe()->properDir(exe)))
                                {
                                        for (Utils::WStringNode *a_item = list.first(); a_item; a_item = list.next())
                                        {
                                                //check both the exe and the data directory exists
                                                if (dir.exists(a_item->data) && dir.exists(a_item->str))
                                                {
                                                        Utils::WString newFile = dir.file(a_item->str);
                                                        AddFoundDir(newFile);
                                                }
                                        }
                                }
                        }
                }
        }
        else if (Dir.exists())
        {
                Utils::WStringList list;
                // get all the addons from a base game
                if (_packages->getGameAddons(list, _packages->GetGameExe()->properDir(exe)))
                {
                        for (Utils::WStringNode *a_item = list.first(); a_item; a_item = list.next())
                        {
                                //check both the exe and the data directory exists
                                if (Dir.exists(a_item->data) && Dir.exists(a_item->str))
                                {
                                        Utils::WString newFile = Dir.file(a_item->str);
                                        AddFoundDir(newFile);
                                }
                        }
                }
        }
}

void DirectoryControl::getAllDirs(Utils::WStringList *currentDirs, Utils::WStringList *removedDirs)
{
        if (currentDirs)
        {
                for (auto itr = currentDirs->begin(); itr != currentDirs->end(); itr++)
                {
                        Utils::WString data = (*itr)->data;
                        if(data.contains(L"|"))
                                _lDirs->pushBack(_packages->getGameRunExe((*itr)->str), data.tokens(L"|", 2));
                        else
                                _lDirs->pushBack(_packages->getGameRunExe((*itr)->str), data);
                }
        }
        if (removedDirs)
        {
                for (auto itr = removedDirs->begin(); itr != removedDirs->end(); itr++)
                        _lRemoveDirs->pushBack(_packages->getGameRunExe((*itr)->str), (*itr)->data);
        }

        // find other dirs
        System::String ^progfile = Environment::GetFolderPath(Environment::SpecialFolder::ProgramFiles);
        Utils::WStringList gameDirs;            
        gameDirs.pushBack(L"HKCU\\Software\\Deepsilver\\X2 The Threat", L"INSTALL_DIR");
        gameDirs.pushBack(L"HKCU\\Software\\Deepsilver\\X3 Reunion", L"INSTALL_DIR");
        gameDirs.pushBack(L"HKCU\\Software\\Egosoft\\X3TC", L"INSTALL_DIR");
        gameDirs.pushBack(L"Steam\\x2 - the threat");
        gameDirs.pushBack(L"Steam\\x3 - reunion");
        gameDirs.pushBack(L"Steam\\x3 terran conflict");
        // some custom directories to look for
        gameDirs.pushBack(L"%PROGRAMFILES%\\Egosoft\\X2 The Threat");
        gameDirs.pushBack(L"%PROGRAMFILES%\\Egosoft\\X3 Reunion");
        gameDirs.pushBack(L"%PROGRAMFILES%\\Egosoft\\X3 Terran Conflict");
        gameDirs.pushBack(L"C:\\Games\\X2");
        gameDirs.pushBack(L"C:\\Games\\X3");
        gameDirs.pushBack(L"C:\\Games\\X3TC");
        gameDirs.pushBack(L"D:\\Games\\X2");
        gameDirs.pushBack(L"D:\\Games\\X3");
        gameDirs.pushBack(L"D:\\Games\\X3TC");  
        for (Utils::WStringNode *strNode = gameDirs.first(); strNode; strNode = gameDirs.next())
        {
                Utils::WString sFirst = strNode->str.token(L"\\", 1);
                Utils::WString sRest = strNode->str.tokens(L"\\", 2);

                if (sFirst.Compare(L"HKCU") || sFirst.Compare(L"HKLM"))
                {
                        RegistryKey ^searchKey = nullptr;
                        if (sFirst.Compare(L"HKCU"))
                                searchKey = Registry::CurrentUser->OpenSubKey(_US(sRest));
                        else if (sFirst.Compare(L"HKLM"))
                                searchKey = Registry::LocalMachine->OpenSubKey(_US(sRest));

                        if (searchKey)
                        {
                                System::String ^regRead = System::Convert::ToString(searchKey->GetValue(_US(strNode->data)));
                                if (regRead)
                                        AddFoundDir(_packages->GetGameExe()->gameRunExe(_WS(regRead)));
                        }
                }
                else if (sFirst.Compare(L"Steam"))
                {
                        RegistryKey ^steamKey = Registry::CurrentUser->OpenSubKey("Software\\Valve\\Steam");
                        if (steamKey)
                        {
                                System::String ^regRead = System::Convert::ToString(steamKey->GetValue("SteamPath"));
                                if (regRead)
                                {
                                        Utils::WString steamDir = _WS(regRead);
                                        if (!steamDir.empty())
                                        {
                                                Utils::WString dir = steamDir + L"\\steamapps\\common\\" + sRest;
                                                AddFoundDir(_packages->GetGameExe()->gameRunExe(dir.findReplace(L"\\", L"/").findReplace(L"//", L"/")));
                                        }
                                }
                        }
                }
                else
                {
                        Utils::WString dir = strNode->str;
                        dir = dir.findReplace(L"\\", L"/").findReplace(L"//", L"/");
                        dir = dir.findReplace(L"%PROGRAMFILES%", _WS(progfile));
                        AddFoundDir(_packages->GetGameExe()->gameRunExe(dir));
                }
        }

        // now add all addons for already added dirs
        for(int i = _lFoundDirs->size() - 1; i >= 0; --i)
                FindAllAddons(_lFoundDirs->get(i)->str, true);
        for (auto itr = _lRemoveDirs->begin(); itr != _lRemoveDirs->end(); ++itr)
                FindAllAddons((*itr)->str, true);
        for (auto itr = _lDirs->begin(); itr != _lDirs->end(); ++itr)
                FindAllAddons((*itr)->str, true);
}

void DirectoryControl::UpdateGameDirs()
{
        this->listView1->Items->Clear();
        for (Utils::WStringNode *s_item = _lDirs->first(); s_item; s_item = _lDirs->next()) {
                Utils::WString dir = _packages->GetGameExe()->properDir(s_item->str);
                ListViewItem ^item = gcnew ListViewItem(_US(dir));
                
                int iGame = _packages->GetGameExe()->getGameType(s_item->str);
                item->ImageIndex = iGame;

                item->SubItems->Add(_US(s_item->data));
                if (CFileIO::Exists(s_item->str))
                {
                        ListViewItem::ListViewSubItem ^i = _packages->isCurrentDir(dir) ? item->SubItems->Add("Active") : item->SubItems->Add("OK");
                        i->ForeColor = Color::Green;
                        item->SubItems->Add(_US(_packages->ConvertLanguage(_packages->getGameLanguage(CFileIO(s_item->str).dir()))));
                }
                else
                {
                        ListViewItem::ListViewSubItem ^i = item->SubItems->Add("Not Found");
                        i->ForeColor = Color::Red;
                        item->SubItems->Add("-");
                }

                item->SubItems->Add(_US(_packages->GetGameExe()->isAddon(s_item->str) ? L"Yes" : L"No"));
                item->SubItems->Add(_US(s_item->str));
                this->listView1->Items->Add(item);

        }

        this->listView1->AutoResizeColumns(ColumnHeaderAutoResizeStyle::HeaderSize);
        this->ColumnStatus->Width = 100;
        this->ColumnDirectory->Width += 50;
        this->ColumnID->Width = 0;

        this->removeButton->Enabled = (this->listView1->SelectedItems->Count) ? true : false;
}

void DirectoryControl::UpdateFoundDirs()
{
        this->listView2->Items->Clear();
        for (Utils::WStringNode *s_item = _lRemoveDirs->first(); s_item; s_item = _lRemoveDirs->next()) {
                if (CFileIO::Exists(s_item->str)) {
                        ListViewItem ^item = gcnew ListViewItem(_US(_packages->GetGameExe()->properDir(s_item->str)));
                        int iGame = _packages->GetGameExe()->getGameType(s_item->str);
                        item->ImageIndex = iGame;
                        item->SubItems->Add(_US(s_item->data));
                        item->SubItems->Add(_US(_packages->ConvertLanguage(_packages->getGameLanguage(CFileIO(s_item->str).dir()))));
                        item->SubItems->Add(_US(_packages->GetGameExe()->isAddon(s_item->str) ? L"Yes" : L"No"));
                        item->SubItems->Add(_US(s_item->str));
                        this->listView2->Items->Add(item);
                }
        }

        for (Utils::WStringNode *s_item = _lFoundDirs->first(); s_item; s_item = _lFoundDirs->next()) {
                if (CFileIO::Exists(s_item->str)) {
                        ListViewItem ^item = gcnew ListViewItem(_US(_packages->GetGameExe()->properDir(s_item->str)));
                        int iGame = _packages->GetGameExe()->getGameType(s_item->str);
                        item->ImageIndex = iGame;
                        item->SubItems->Add(_US(_packages->GetGameExe()->gameName(s_item->str)));
                        item->SubItems->Add(_US(_packages->ConvertLanguage(_packages->getGameLanguage(CFileIO(s_item->str).dir()))));
                        item->SubItems->Add(_US(_packages->GetGameExe()->isAddon(s_item->str) ? L"Yes" : L"No"));
                        item->SubItems->Add(_US(s_item->str));
                        this->listView2->Items->Add(item);
                }
        }

        this->listView2->AutoResizeColumns(ColumnHeaderAutoResizeStyle::HeaderSize);
        this->ColumnDir2->Width += 50;
        this->ColumnID2->Width = 0;

        this->ButtonAddFound->Enabled = (this->listView2->SelectedItems->Count) ? true : false;
}

void DirectoryControl::UpdateTexts()
{
        CLanguages *texts = CLanguages::Instance();
        this->Text = _US(texts->findText(LS_DIRECTORY, LANGDIR_TITLE));
}

System::Void DirectoryControl::button1_Click(System::Object^  sender, System::EventArgs^  e)
{
        OpenFileDialog ^ofd = gcnew OpenFileDialog();
        ofd->Filter = "X-Universe Executable|";
        String ^games = "";
        for (int i = 0; i < _packages->GetGameExe()->numGames(); i++)
        {
                SGameExe *exe = _packages->GetGameExe()->game(i);
                if (i) ofd->Filter += ";";
                ofd->Filter += _US(exe->sExe);
                games += "|" + _US(exe->sName) + "|" + _US(exe->sExe);
        }
        ofd->Filter += games;
        ofd->FilterIndex = 1;
        ofd->RestoreDirectory = true;
        if (ofd->ShowDialog(this) == System::Windows::Forms::DialogResult::OK)
        {
                Utils::WString file = _WS(ofd->FileName);
                Utils::WString dir = _WS(IO::FileInfo(ofd->FileName).DirectoryName);
                // check its a valid directory
                if (!dir.empty())
                {
                        Utils::WString gameName = _packages->getGameName(file);
                        if (gameName.empty())
                                MessageBox::Show(this, "No X-Universe game found in folder:\n" + _US(dir), "Add Directory Error", MessageBoxButtons::OK, MessageBoxIcon::Error);
                        else
                        {
                                // lets check if theres an old folder
                                if (_packages->isOldDir(dir))
                                {
                                        if (MessageBox::Show(this, "Game directory: " + _US(dir) + "\nIs currently being controled by the old plugin manager\nIf you continue, you will be unable to use the old version again\nDo you wish to continue?", "Update Game Directory", MessageBoxButtons::YesNo, MessageBoxIcon::Question) != System::Windows::Forms::DialogResult::Yes)
                                                return;
                                }
                                Utils::WString properDir = _packages->getProperDir(file);
                                _lRemoveDirs->remove(properDir, true);
                                _lDirs->pushBack(file.findReplace(L"\\", L"/").findReplace(L"//", L"/"), gameName);

                                // now add any connected dirs
                                if (_packages->GetGameExe()->isAddon(file))
                                {
                                        Utils::WString baseExe = _packages->getGameRunExe(_packages->GetGameExe()->gameDir(file));
                                        if (CFileIO::Exists(baseExe))
                                        {
                                                this->AddFoundDir(baseExe);
                                                this->FindAllAddons(baseExe, false);
                                        }
                                }
                                else
                                        this->FindAllAddons(file, false);

                                UpdateGameDirs();
                                UpdateFoundDirs();
                        }
                }
        }
}

System::Void DirectoryControl::listView1_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e) 
{
        this->removeButton->Enabled = (this->listView1->SelectedItems->Count) ? true : false;
}

System::Void DirectoryControl::removeButton_Click(System::Object^  sender, System::EventArgs^  e) 
{
        bool anyDone = false;
        for (int i = 0; i < this->listView1->SelectedItems->Count; ++i)
        {
                String ^s = this->listView1->SelectedItems[i]->SubItems[this->listView1->SelectedItems[i]->SubItems->Count - 1]->Text;

                Utils::WString dir = _packages->getProperDir(_WS(s));
                if (_packages->isCurrentDir(dir))
                {
                        if (MessageBox::Show(this, "The game directory: " + _US(dir) + "\nIs currently the active game directory, are you sure you want to remove it?", "Remove Game Directory", MessageBoxButtons::YesNo, MessageBoxIcon::Question) == Windows::Forms::DialogResult::No)
                                continue;
                }
                anyDone = true;
                _lRemoveDirs->pushBack(_WS(s), _lDirs->findString(_WS(s)));
                _lDirs->remove(_WS(s), false);
        }

        if (anyDone)
        {
                UpdateGameDirs();
                UpdateFoundDirs();
        }
}

System::Void DirectoryControl::listView2_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e) 
{
        this->ButtonAddFound->Enabled = (this->listView2->SelectedItems->Count) ? true : false;
}

System::Void DirectoryControl::ButtonAddFound_Click(System::Object^  sender, System::EventArgs^  e) 
{
        for (int i = 0; i < this->listView2->SelectedItems->Count; ++i)
        {
                String ^s = this->listView2->SelectedItems[i]->SubItems[this->listView2->SelectedItems[i]->SubItems->Count - 1]->Text;
                _lDirs->pushBack(_WS(s), _packages->GetGameExe()->gameName(_WS(s)));
                _lFoundDirs->remove(_WS(s), false);
                _lRemoveDirs->remove(_WS(s), false);
        }

        UpdateGameDirs();
        UpdateFoundDirs();
}

System::Void DirectoryControl::listView1_DoubleClick(System::Object^  sender, System::EventArgs^  e)
{
        String ^s = this->listView1->SelectedItems[0]->SubItems[this->listView1->SelectedItems[0]->SubItems->Count - 1]->Text;
        if (s && s->Length > 0)
        {
        }
}

System::Void DirectoryControl::listView2_DoubleClick(System::Object^  sender, System::EventArgs^  e)
{
        String ^s = this->listView2->SelectedItems[0]->SubItems[this->listView2->SelectedItems[0]->SubItems->Count - 1]->Text;
        if (s && s->Length > 0)
        {
                _lDirs->pushBack(_WS(s), _packages->GetGameExe()->gameName(_WS(s)));
                _lFoundDirs->remove(_WS(s), false);
                _lRemoveDirs->remove(_WS(s), false);

                UpdateGameDirs();
                UpdateFoundDirs();
        }
}

Utils::WStringList *DirectoryControl::directories()
{
        return _lDirs;
}
Utils::WStringList *DirectoryControl::removeDirectories()
{
        return _lRemoveDirs;
}