Subversion Repositories spk

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

using namespace PluginManager;

DirectoryControl::DirectoryControl(CPackages *packages, Utils::CStringList *currentDirs, Utils::CStringList *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::CStringList();
        _lRemoveDirs = new Utils::CStringList();
        _lFoundDirs = new Utils::CStringList();

        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::String &dir)
{
        if (CDirIO(dir).exists())
        {
                Utils::String gameName = _packages->GetGameExe()->GetGameName(dir);
                if (!gameName.empty())
                {
                        if (!_lFoundDirs->contains(dir, true) && !_lDirs->contains(dir, true) && !_lRemoveDirs->contains(dir, true))
                        {
                                Utils::String exe = dir.findReplace("\\", "/").findReplace("//", "/");
                                _lFoundDirs->pushBack(exe, _packages->GetGameExe()->GetGameName(exe));
                        }
                }
        }
}

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

        if (checkBase && _packages->GetGameExe()->isAddon(exe))
        {
                Utils::String base = _packages->GetGameRunExe(_packages->GetGameExe()->GetGameDir(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::CStringList list;
                                // get all the addons from a base game
                                if (_packages->GetGameAddons(list, _packages->GetGameExe()->GetProperDir(exe)))
                                {
                                        for (Utils::SStringList *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::String newFile = dir.file(a_item->str);
                                                        AddFoundDir(newFile);
                                                }
                                        }
                                }
                        }
                }
        }
        else if (Dir.exists())
        {
                Utils::CStringList list;
                // get all the addons from a base game
                if (_packages->GetGameAddons(list, _packages->GetGameExe()->GetProperDir(exe)))
                {
                        for (Utils::SStringList *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::String newFile = Dir.file(a_item->str);
                                        AddFoundDir(newFile);
                                }
                        }
                }
        }
}

void DirectoryControl::getAllDirs(Utils::CStringList *currentDirs, Utils::CStringList *removedDirs)
{
        if (currentDirs)
        {
                for (auto itr = currentDirs->begin(); itr != currentDirs->end(); itr++)
                {
                        Utils::String data = (*itr)->data;
                        if(data.isin("|"))
                                _lDirs->pushBack(_packages->GetGameRunExe((*itr)->str), data.tokens("|", 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::CStringList gameDirs;            
        gameDirs.pushBack("HKCU\\Software\\Deepsilver\\X2 The Threat", "INSTALL_DIR");
        gameDirs.pushBack("HKCU\\Software\\Deepsilver\\X3 Reunion", "INSTALL_DIR");
        gameDirs.pushBack("HKCU\\Software\\Egosoft\\X3TC", "INSTALL_DIR");
        gameDirs.pushBack("Steam\\x2 - the threat");
        gameDirs.pushBack("Steam\\x3 - reunion");
        gameDirs.pushBack("Steam\\x3 terran conflict");
        // some custom directories to look for
        gameDirs.pushBack("%PROGRAMFILES%\\Egosoft\\X2 The Threat");
        gameDirs.pushBack("%PROGRAMFILES%\\Egosoft\\X3 Reunion");
        gameDirs.pushBack("%PROGRAMFILES%\\Egosoft\\X3 Terran Conflict");
        gameDirs.pushBack("C:\\Games\\X2");
        gameDirs.pushBack("C:\\Games\\X3");
        gameDirs.pushBack("C:\\Games\\X3TC");
        gameDirs.pushBack("D:\\Games\\X2");
        gameDirs.pushBack("D:\\Games\\X3");
        gameDirs.pushBack("D:\\Games\\X3TC");   
        for (Utils::SStringList *strNode = gameDirs.first(); strNode; strNode = gameDirs.next())
        {
                Utils::String sFirst = strNode->str.token("\\", 1);
                Utils::String sRest = strNode->str.tokens("\\", 2);

                if (sFirst.Compare("HKCU") || sFirst.Compare("HKLM"))
                {
                        RegistryKey ^searchKey = nullptr;
                        if (sFirst.Compare("HKCU"))
                                searchKey = Registry::CurrentUser->OpenSubKey(_US(sRest));
                        else if (sFirst.Compare("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()->GetGameRunExe(_S(regRead)));
                        }
                }
                else if (sFirst.Compare("Steam"))
                {
                        RegistryKey ^steamKey = Registry::CurrentUser->OpenSubKey("Software\\Valve\\Steam");
                        if (steamKey)
                        {
                                System::String ^regRead = System::Convert::ToString(steamKey->GetValue("SteamPath"));
                                if (regRead)
                                {
                                        Utils::String steamDir = _S(regRead);
                                        if (!steamDir.empty())
                                        {
                                                Utils::String dir = steamDir + "\\steamapps\\common\\" + sRest;
                                                AddFoundDir(_packages->GetGameExe()->GetGameRunExe(dir.findReplace("\\", "/").findReplace("//", "/")));
                                        }
                                }
                        }
                }
                else
                {
                        Utils::String dir = strNode->str;
                        dir = dir.findReplace("\\", "/").findReplace("//", "/");
                        dir = dir.findReplace("%PROGRAMFILES%", _S(progfile));
                        AddFoundDir(_packages->GetGameExe()->GetGameRunExe(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::SStringList *s_item = _lDirs->first(); s_item; s_item = _lDirs->next()) {
                Utils::String dir = _packages->GetGameExe()->GetProperDir(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) ? "Yes" : "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::SStringList *s_item = _lRemoveDirs->first(); s_item; s_item = _lRemoveDirs->next()) {
                if (CFileIO::Exists(s_item->str)) {
                        ListViewItem ^item = gcnew ListViewItem(_US(_packages->GetGameExe()->GetProperDir(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) ? "Yes" : "No"));
                        item->SubItems->Add(_US(s_item->str));
                        this->listView2->Items->Add(item);
                }
        }

        for (Utils::SStringList *s_item = _lFoundDirs->first(); s_item; s_item = _lFoundDirs->next()) {
                if (CFileIO::Exists(s_item->str)) {
                        ListViewItem ^item = gcnew ListViewItem(_US(_packages->GetGameExe()->GetProperDir(s_item->str)));
                        int iGame = _packages->GetGameExe()->GetGameType(s_item->str);
                        item->ImageIndex = iGame;
                        item->SubItems->Add(_US(_packages->GetGameExe()->GetGameName(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) ? "Yes" : "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()->GetNumGames(); i++)
        {
                SGameExe *exe = _packages->GetGameExe()->GetGame(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::String file = _S(ofd->FileName);
                Utils::String dir = _S(IO::FileInfo(ofd->FileName).DirectoryName);
                // check its a valid directory
                if (!dir.empty())
                {
                        Utils::String gameName = _packages->GetGameName(file).ToString();
                        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::String properDir = _packages->GetProperDir(file).ToString();
                                _lRemoveDirs->remove(properDir, true);
                                _lDirs->pushBack(file.findReplace("\\", "/").findReplace("//", "/"), gameName);

                                // now add any connected dirs
                                if (_packages->GetGameExe()->isAddon(file))
                                {
                                        Utils::String baseExe = _packages->GetGameRunExe(_packages->GetGameExe()->GetGameDir(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::String dir = _packages->getProperDir(_S(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(_S(s), _lDirs->findString(_S(s)));
                _lDirs->remove(_S(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(_S(s), _packages->GetGameExe()->GetGameName(_S(s)));
                _lFoundDirs->remove(_S(s), false);
                _lRemoveDirs->remove(_S(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(_S(s), _packages->GetGameExe()->GetGameName(_S(s)));
                _lFoundDirs->remove(_S(s), false);
                _lRemoveDirs->remove(_S(s), false);

                UpdateGameDirs();
                UpdateFoundDirs();
        }
}

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