Subversion Repositories spk

Rev

Rev 225 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed 

#include "../StdAfx.h"
#include "ModSelector.h"
#include "CheckUpdate.h"
#include "MainGui.h"

#undef GetTempPath
#undef GetCurrentDirectory

using namespace System::IO;

namespace PluginManager {

        void ModSelector::Update()
        {
                // update the mod display
                this->PictureBox->Image = nullptr;
                if ( m_pPackages->GetEnabledMod() )
                {
                        m_bFoundPackages = true;
                        CBaseFile *p = m_pPackages->GetEnabledMod();
                        this->TextMod->Text = _US(p->name(m_pPackages->GetLanguage()));
                        this->TextAuthor->Text = _US(p->author());
                        this->TextVersion->Text = _US(p->version());
                        this->TextDesc->Text = _US(p->description().findReplace(L"<br>", L"\n").stripHtml());
                        this->TextCreated->Text = _US(p->creationDate());
                        ButNoMod->Enabled = true;

                        // update graphic
                        bool addedIcon = false;
                        C_File *picFile = p->GetFirstFile(FILETYPE_ADVERT);
                        if ( picFile )
                        {
                                System::String ^pic = _US(picFile->filePointer());
                                if ( System::IO::File::Exists(pic) )
                                {
                                        Bitmap ^myBitmap = gcnew Bitmap(pic);
                                        if ( myBitmap )
                                        {
                                                this->PictureBox->Image = dynamic_cast<Image ^>(myBitmap);
                                                addedIcon = true;
                                        }
                                }
                        }

                        if ( !addedIcon )
                        {
                                System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(ModSelector::typeid));
                                System::Drawing::Icon ^icon = (cli::safe_cast<System::Drawing::Icon^  >(resources->GetObject(L"$this.Icon")));
                                this->PictureBox->Image = icon->ToBitmap();
                        }
                }
                else
                {
                        this->TextMod->Text = "N/A";
                        this->TextAuthor->Text = "";
                        this->TextVersion->Text = "";
                        this->TextCreated->Text = "";
                        this->TextDesc->Text = "";
                        this->PictureBox->Image = nullptr;
                        ButNoMod->Enabled = false;
                }

                // now update the mods list
                // first any installed mods
                this->UpdatePackages();
        }

        void ModSelector::UpdatePackages()
        {
                m_pPackages->AssignPackageNumbers();
                ListAvailable->Items->Clear();
                ListAvailable->Groups->Clear();
                ListAvailable->SmallImageList = gcnew ImageList();
                ListAvailable->LargeImageList = ListAvailable->SmallImageList;

                // display the installed mods
                ListViewGroup ^group = gcnew ListViewGroup("Installed Mods", HorizontalAlignment::Left);
                ListAvailable->Groups->Add(group);

                for ( CBaseFile *p = m_pPackages->FirstPackage(); p; p = m_pPackages->NextPackage() )
                {
                        if ( !p->IsMod() )
                                continue;
                        if ( p == m_pPackages->GetEnabledMod() )
                                continue;

                        m_bFoundPackages = true;
                        ListViewItem ^item = gcnew ListViewItem(_US(p->name(m_pPackages->GetLanguage())));
                        item->SubItems->Add(_US(p->author()));
                        item->SubItems->Add(_US(p->version()));
                        item->SubItems->Add(_US(p->creationDate()));
                        ListAvailable->Items->Add(item);
                        item->Tag = _US(Utils::String::Number(p->GetNum()));

                        item->Group = group;
                        if ( p->icon() )
                                PluginManager::DisplayListIcon(p, ListAvailable, item);
                }

                if ( m_lAvailablePackages )
                {
                        // display the available mods
                        ListViewGroup ^availGroup = gcnew ListViewGroup("Available Mods", HorizontalAlignment::Left);
                        ListAvailable->Groups->Add(availGroup);

                        for ( CBaseFile *p = m_lAvailablePackages->First(); p; p = m_lAvailablePackages->Next() )
                        {
                                if ( !p->IsMod() )
                                        continue;

                                // check if its already installed
                                if ( m_pPackages->findSpkPackage(p->name(), p->author()) )
                                        continue;

                                m_bFoundPackages = true;
                                ListViewItem ^item = gcnew ListViewItem(_US(p->name(m_pPackages->GetLanguage())));
                                item->SubItems->Add(_US(p->author()));
                                item->SubItems->Add(_US(p->version()));
                                item->SubItems->Add(_US(p->creationDate()));
                                ListAvailable->Items->Add(item);
                                item->Tag = _US(Utils::String::Number(p->GetNum()));

                                item->Group = availGroup;
                                if ( p->icon() )
                                        PluginManager::DisplayListIcon(p, ListAvailable, item);
                        }
                }

                if ( m_pPackages->AnyAvailablePackages(PACKAGETYPE_MOD) )
                {
                        // display the available mods
                        ListViewGroup ^availGroup = gcnew ListViewGroup("Downloadable Mods", HorizontalAlignment::Left);
                        ListAvailable->Groups->Add(availGroup);

                        for (const SAvailablePackage *ap = m_pPackages->getAvailablePackageList()->First(); ap; ap = m_pPackages->getAvailablePackageList()->Next() )
                        {
                                if ( ap->iType != PACKAGETYPE_MOD ) continue; // only display mods
                                m_bFoundPackages = true;
                                ListViewItem ^item = gcnew ListViewItem(_US(ap->sName));
                                item->SubItems->Add(_US(ap->sAuthor));
                                item->SubItems->Add(_US(ap->sVersion));
                                item->SubItems->Add(_US(ap->sUpdated));
                                item->Tag = _US(ap->sFilename);
                                item->Group = availGroup;
                                ListAvailable->Items->Add(item);
                        }
                }

                ListAvailable->AutoResizeColumns(ColumnHeaderAutoResizeStyle::HeaderSize);
                ModSelected(ListAvailable, gcnew System::EventArgs());
        }

        void ModSelector::UpdateControls()
        {
                ListAvailable->FullRowSelect = true;
        }

        void ModSelector::FindPackages_Directory(String ^dir)
        {
                if ( Directory::Exists(dir) )
                {
                        this->FindPackages(dir);

                        array <System::String ^> ^Dirs = Directory::GetDirectories(dir);
                        if ( Dirs )
                        {
                                for ( int i = 0; i < Dirs->Length; i++ )
                                        this->FindPackages_Directory(Dirs[i]);
                        }
                }
        }

        void ModSelector::FindPackages(String ^dir)
        {
                if ( !Directory::Exists(dir) )
                        return;

                array <System::String ^> ^Files = Directory::GetFiles(dir, "*.spk");

                for ( int i = 0; i < Files->Length; i++ )
                {
                        Utils::WString file = _WS(Files[i]);
                        int error = 0;
                        CBaseFile *p = m_pPackages->openPackage(file, &error, 0, SPKREAD_NODATA);
                        if ( !p )
                                continue;
                        if ( !p->IsMod() || m_pPackages->findSpkPackage(p->name(), p->author()) )
                        {
                                delete p;
                                continue;
                        }

                        // check its for the correct game
                        if ( !p->CheckGameCompatability(m_pPackages->GetGame()) )
                        {
                                delete p;
                                continue;
                        }

                        // check if its already on the list
                        bool found = false;
                        for ( CBaseFile *checkp = m_lAvailablePackages->First(); checkp; checkp = m_lAvailablePackages->Next() )
                        {
                                if ( p->name().Compare(checkp->name()) && p->author().Compare(checkp->author()) )
                                {
                                        found = true;
                                        break;
                                }
                        }

                        if ( found )
                        {
                                delete p;
                                continue;
                        }

                        if ( p->icon() )
                        {
                                bool addedIcon = false;
                                p->ReadIconFileToMemory();
                                p->icon()->setFilename(m_pPackages->tempDirectory().findReplace(L"\\", L"/") + L"/" + p->author() + L"_" + p->name() + L"." + p->iconExt());
                                p->icon()->setFullDir(m_pPackages->tempDirectory());
                                if ( p->icon()->UncompressData() )
                                {
                                        if ( p->icon()->writeFilePointer() )
                                                addedIcon = true;
                                }

                                if ( !addedIcon )
                                        p->setIcon(NULL, L"");
                        }
                        // get an advert to display
                        if ( p->GetFirstFile(FILETYPE_ADVERT) )
                        {
                                bool done = false;
                                C_File *f = p->GetFirstFile(FILETYPE_ADVERT);
                                if ( p->ReadFileToMemory(f) )
                                {
                                        f->setFullDir(m_pPackages->tempDirectory());
                                        if ( f->UncompressData() )
                                        {
                                                if ( f->writeFilePointer() )
                                                        done = true;
                                        }
                                }

                                if ( !done )
                                        f->DeleteData();
                        }

                        m_lAvailablePackages->push_back(p);                             
                }
        }

        void ModSelector::FindPackages_Current(String ^curDir)
        {
                this->FindPackages(curDir + "\\Addons\\Mods");

                if ( Directory::Exists(curDir + "\\Addons") )
                {
                        if ( Directory::Exists(curDir + "\\Addons\\Mods") )
                                this->FindPackages_Directory(curDir + "\\Addons\\Mods");
                }

                if ( Directory::Exists(curDir + "\\Downloads") )
                        this->FindPackages_Directory(curDir + "\\Downloads");
        }

        void ModSelector::FindPackages()
        {
                if ( !m_lAvailablePackages )
                        m_lAvailablePackages = new CLinkList<CBaseFile>;

                FindPackages_Current(System::IO::FileInfo(System::Windows::Forms::Application::ExecutablePath).DirectoryName);
                FindPackages_Current(Directory::GetCurrentDirectory());

                // find packages from registry key
                RegistryKey ^searchKey = Registry::CurrentUser->OpenSubKey("Software\\Egosoft\\SuperBox");
                if ( searchKey )
                {
                        String ^dir = System::Convert::ToString(searchKey->GetValue("Addons"));
                        if ( dir )
                                this->FindPackages_Directory(dir);
                }

                // find packages from DVD
                cli::array<IO::DriveInfo ^> ^Drives = IO::DriveInfo::GetDrives();
                if ( Drives )
                {
                        for ( int i = 0; i < Drives->Length; i++ )
                        {
                                IO::DriveInfo ^info = Drives[i];
                                if ( info->DriveType != IO::DriveType::CDRom )
                                        continue;
                                if ( info->IsReady )
                                        this->FindPackages_Directory(info->RootDirectory + "XPluginManager");
                        }
                }

                // read all game directories extra content
                this->FindPackages_Directory(_US((m_pPackages->getCurrentDirectory().findReplace(L"\\",L"/") + L"/ExtraContent").findReplace(L"//", L"/")));

                int num = -1;
                for ( CBaseFile *p = m_lAvailablePackages->First(); p; p = m_lAvailablePackages->Next() )
                {
                        p->SetNum(num);
                        --num;
                }
        }

        void ModSelector::RemovePackages()
        {
                if ( m_lAvailablePackages )
                {
                        for ( CBaseFile *p = m_lAvailablePackages->First(); p; p = m_lAvailablePackages->Next() )
                        {
                                if ( p->icon() )
                                        CFileIO::Remove(p->icon()->filePointer());
                                delete p;
                        }
                        m_lAvailablePackages->destroy();
                        delete m_lAvailablePackages;
                }
                m_lAvailablePackages = NULL;
        }

        //
        // Events
        //
        void ModSelector::SetupEvents()
        {
                ListAvailable->SelectedIndexChanged += gcnew EventHandler(this, &PluginManager::ModSelector::ModSelected);
                ButSelect->Click += gcnew EventHandler(this, &PluginManager::ModSelector::SelectModEvent);
                ButNoMod->Click += gcnew EventHandler(this, &PluginManager::ModSelector::NoModEvent);
                ButUninstall->Click += gcnew EventHandler(this, &PluginManager::ModSelector::UninstallModEvent);
        }

        void ModSelector::UpdateEaseOfUse(bool disable, int value)
        {
                if ( disable )
                {
                        this->PicEase1->Visible = false;
                        this->PicEase2->Visible = false;
                        this->PicEase3->Visible = false;
                        this->PicEase4->Visible = false;
                        this->PicEase5->Visible = false;
                }

                if ( value > -1 )
                {
                        // ease of use rating
                        if ( value < 1 )
                                LabEaseNA->Show();
                        if ( value >= 1 )
                                PicEase1->Show();
                        if ( value >= 2 )
                                PicEase2->Show();
                        if ( value >= 3 )
                                PicEase3->Show();
                        if ( value >= 4 )
                                PicEase4->Show();
                        if ( value >= 5 )
                                PicEase5->Show();
                }
        }
        
        void ModSelector::UpdateRecommended(bool disable, int value)
        {
                if ( disable )
                {
                        this->PicRec1->Visible = false;
                        this->PicRec2->Visible = false;
                        this->PicRec3->Visible = false;
                        this->PicRec4->Visible = false;
                        this->PicRec5->Visible = false;
                }

                if ( value > -1 )
                {
                        // Recommanded rating
                        if ( value < 1 )
                                LabelRecNA->Show();
                        if ( value >= 1 )
                                PicRec1->Show();
                        if ( value >= 2 )
                                PicRec2->Show();
                        if ( value >= 3 )
                                PicRec3->Show();
                        if ( value >= 4 )
                                PicRec4->Show();
                        if ( value >= 5 )
                                PicRec5->Show();
                }
        }

        void ModSelector::UpdateGameChanging(bool disable, int value)
        {
                if ( disable )
                {
                        this->PicChange1->Visible = false;
                        this->PicChange2->Visible = false;
                        this->PicChange3->Visible = false;
                        this->PicChange4->Visible = false;
                        this->PicChange5->Visible = false;
                }

                if ( value > -1 )
                {
                        // game changing rating
                        if ( value < 1 )
                                LabelChangeNA->Show();
                        if ( value >= 1 )
                                PicChange1->Show();
                        if ( value >= 2 )
                                PicChange2->Show();
                        if ( value >= 3 )
                                PicChange3->Show();
                        if ( value >= 4 )
                                PicChange4->Show();
                        if ( value >= 5 )
                                PicChange5->Show();
                }
        }

        void ModSelector::ModSelected(System::Object ^Sender, System::EventArgs ^E)
        {
                bool enabled = false;

                m_pSelectedMod = NULL;
                m_pSelectedPackage = NULL;

                ButUninstall->Visible = false;
                button1->Visible = false;
                this->PictureSelected->Image = nullptr;
                UpdateEaseOfUse(true, -1);
                UpdateGameChanging(true, -1);
                UpdateRecommended(true, -1);
                this->LabEaseNA->Visible = false;
                this->LabelChangeNA->Visible = false;
                this->LabelRecNA->Visible = false;

                bool dontEnable = false;
                if ( ListAvailable->SelectedItems->Count )
                {
                        ListViewItem ^item = ListAvailable->SelectedItems[0];
                        if ( item )
                        {
                                Utils::WString sNum = _WS(System::Convert::ToString(item->Tag));
                                int num = sNum.toInt();

                                CBaseFile *p = NULL;
                                if ( num || sNum == L"0" )
                                {
                                        // its an installed mod
                                        if ( num >= 0 )
                                        {
                                                p = m_pPackages->GetPackageAt(num);
                                                ButUninstall->Visible = true;
                                        }
                                        //else its from a file
                                        else
                                        {
                                                p = m_lAvailablePackages->Get(-1 - num);
                                        }

                                        if ( p )
                                        {
                                                enabled = true;
                                                this->TextDescSelected->Text = _US(p->description().findReplace(L"<br>", L"\n").stripHtml());
                                                m_pSelectedMod = p;

                                                // update graphic
                                                bool addedIcon = false;
                                                C_File *picFile = p->GetFirstFile(FILETYPE_ADVERT);
                                                if ( picFile )
                                                {
                                                        System::String ^pic = _US(picFile->filePointer());
                                                        if ( System::IO::File::Exists(pic) )
                                                        {
                                                                Bitmap ^myBitmap = gcnew Bitmap(pic);
                                                                if ( myBitmap )
                                                                {
                                                                        this->PictureSelected->Image = dynamic_cast<Image ^>(myBitmap);
                                                                        addedIcon = true;
                                                                }
                                                        }
                                                }

                                                if ( !addedIcon )
                                                {
                                                        System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(ModSelector::typeid));
                                                        System::Drawing::Icon ^icon = (cli::safe_cast<System::Drawing::Icon^  >(resources->GetObject(L"$this.Icon")));
                                                        this->PictureSelected->Image = icon->ToBitmap();
                                                }

                                                // ratings display
                                                UpdateEaseOfUse(false, p->easeOfUse());
                                                UpdateGameChanging(false, p->gameChanging());
                                                UpdateRecommended(false, p->recommended());
                                        }
                                }
                                else // otherwise its a name (download package)
                                {
                                        const SAvailablePackage *p = m_pPackages->findAvailablePackage(sNum);
                                        if ( p )
                                        {
                                                enabled = true;
                                                dontEnable = true;
                                                this->button1->Visible = true;
                                                this->TextDescSelected->Text = _US(p->sDesc.findReplace(L"<br>", L"\n").stripHtml());

                                                // ratings display
                                                UpdateEaseOfUse(false, p->iEase);
                                                UpdateGameChanging(false, p->iChanging);
                                                UpdateRecommended(false, p->iRec);

                                                // default display image
                                                System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(ModSelector::typeid));
                                                System::Drawing::Icon ^icon = (cli::safe_cast<System::Drawing::Icon^  >(resources->GetObject(L"$this.Icon")));
                                                this->PictureSelected->Image = icon->ToBitmap();

                                                m_pSelectedPackage = p;
                                        }
                                }
                        }
                }

                // nothing selected
                if ( !enabled )
                        TextDescSelected->Text = "";

                ButSelect->Enabled = (dontEnable) ? false : enabled;
        }

        void ModSelector::SelectModEvent(System::Object ^Sender, System::EventArgs ^E)
        {
        }

        void ModSelector::NoModEvent(System::Object ^Sender, System::EventArgs ^E)
        {
        }

        void ModSelector::UninstallModEvent(System::Object ^Sender, System::EventArgs ^E)
        {
        }

        void ModSelector::UpdateDetails()
        {
                if ( m_bDetails )
                {
                        ButDetails->Text = "Hide Details <<<";
                        this->PanelDetails->Show();
                }
                else
                {
                        ButDetails->Text = "Show Details >>>";
                        this->PanelDetails->Hide();
                }
        }

        void ModSelector::DownloadPackage()
        {
                if ( !m_pSelectedPackage ) 
                {
                        this->button1->Visible = false;
                        return;
                }

                CheckUpdate ^update = gcnew CheckUpdate(m_pPackages, m_pImageList);
                update->SetDownloader();
                update->OnePackage(m_pSelectedPackage);
                if ( update->ShowDialog(this) == Windows::Forms::DialogResult::OK )
                {
                        this->DialogResult = Windows::Forms::DialogResult::Yes;
                        for ( int i = 0; i < update->GetInstallList()->Count; i++ )
                                cli::safe_cast<MainGui ^>(this->Owner)->InstallPackage(Convert::ToString(update->GetInstallList()[i]), false, false, true);
                        this->Close();
                }
        }

}