Subversion Repositories spk

Rev

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

#include "..\StdAfx.h"
#include "..\listviewsorter.h"

#include "PackageBrowser.h"
#include "CheckUpdate.h"
#include "MainGui.h"

using namespace System::IO;

#undef GetTempPath
#undef GetCurrentDirectory

namespace PluginManager {

        void PackageBrowser::FindPackages_Files(System::String ^dir)
        {
                for ( int type = 0; type < 2; type++ )
                {
                        array <System::String ^> ^Files = nullptr;
                        if ( type == 0 )
                                Files = Directory::GetFiles(dir, "*.spk");
                        else if ( type == 1 )
                                Files = Directory::GetFiles(dir, "*.xsp");
                        else
                                break;

                        for ( int i = 0; i < Files->Length; i++ )
                        {
                                CyString file = CyStringFromSystemString(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->GetName(), p->GetAuthor()) )
                                {
                                        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->GetName().Compare(checkp->GetName()) && p->GetAuthor().Compare(checkp->GetAuthor()) )
                                        {
                                                found = true;
                                                break;
                                        }
                                }

                                if ( found )
                                {
                                        delete p;
                                        continue;
                                }

                                if ( p->GetIcon() )
                                {
                                        bool addedIcon = false;
                                        p->ReadIconFileToMemory();
                                        p->GetIcon()->SetFilename(m_pPackages->GetTempDirectory().FindReplace("\\", "/") + "/" + p->GetAuthor() + "_" + p->GetName() + "." + p->GetIconExt());
                                        p->GetIcon()->SetFullDir(m_pPackages->GetTempDirectory());
                                        if ( p->GetIcon()->UncompressData() )
                                        {
                                                if ( p->GetIcon()->WriteFilePointer() )
                                                        addedIcon = true;
                                        }

                                        if ( !addedIcon )
                                                p->SetIcon(NULL, "");
                                }

                                // 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->GetTempDirectory());
                                                if ( f->UncompressData() )
                                                {
                                                        if ( f->WriteFilePointer() )
                                                                done = true;
                                                }
                                        }

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

                                m_lAvailablePackages->push_back(p);                             
                        }
                }
        }

        bool PackageBrowser::AnyPackages()
        {
                if ( m_lAvailablePackages && m_lAvailablePackages->size() )
                        return true;
                if ( m_pPackages->AnyAvailablePackages() )
                        return true;
                return false;
        }

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

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

        void PackageBrowser::FindPackages()
        {
                if ( !m_lAvailablePackages )
                        m_lAvailablePackages = new CLinkList<CBaseFile>;
                
                String ^curDir = System::IO::FileInfo(System::Windows::Forms::Application::ExecutablePath).DirectoryName;
                this->FindPackages_Directory(curDir + "\\Addons");
                this->FindPackages_Directory(curDir + "\\Downloads");
                this->FindPackages_Directory(".\\Addons");
                this->FindPackages_Directory(".\\Downloads");
                this->FindPackages_Directory(m_sCurrentDir + "\\Addons");
                this->FindPackages_Directory(m_sCurrentDir + "\\Downloads");

                // 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(SystemStringFromCyString(m_pPackages->GetCurrentDirectoryW().FindReplace("/","\\")) + "\\ExtraContent");
                

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

        bool PackageBrowser::CheckValidPackage(CBaseFile *p)
        {
                if ( !p->CheckGameCompatability(m_pPackages->GetGame()) )
                        return false;

                if ( !this->CheckCheat->Checked && p->GetPluginType() == PLUGIN_CHEAT )
                        return false;
                if ( !this->CheckExperimental->Checked && p->GetPluginType() == PLUGIN_EXPERIMENTAL )
                        return false;
                if ( p->GetType() == TYPE_XSP && !this->CheckShips->Checked )
                        return false;
                if ( this->CheckSigned->Checked && !p->IsSigned() )
                        return false;

                return true;
        }

        bool PackageBrowser::CheckValidPackage(SAvailablePackage *p)
        {
                if ( p->iType == PACKAGETYPE_MOD )
                        return false;

                if ( !p->lGames.empty() )
                {
                        bool found = false;
                        for ( SGameCompat *gc = p->lGames.First(); gc; gc = p->lGames.Next() ) {
                                if ( gc->iGame == m_pPackages->GetGame() ) {
                                        found = true;
                                        break;
                                }
                        }

                        if ( !found )
                                return false;
                }

                if ( !this->CheckCheat->Checked && p->iPluginType == PLUGIN_CHEAT )
                        return false;
                if ( !this->CheckExperimental->Checked && p->iPluginType == PLUGIN_EXPERIMENTAL )
                        return false;
                if ( p->iType == PACKAGETYPE_SHIP && !this->CheckShips->Checked )
                        return false;
                if ( this->CheckSigned->Checked && !p->bSigned )
                        return false;

                return true;
        }

        ListViewItem ^PackageBrowser::CreateItem(CBaseFile *p)
        {
                ListViewItem ^item = gcnew ListViewItem(SystemStringFromCyString(p->GetLanguageName(m_pPackages->GetLanguage())), -1);
                item->SubItems->Add(SystemStringFromCyString(p->GetAuthor()));
                item->SubItems->Add(SystemStringFromCyString(p->GetVersion()));
                item->SubItems->Add(SystemStringFromCyString(p->GetCreationDate()));
                if ( p->GetType() == TYPE_SPK )
                        item->SubItems->Add(SystemStringFromCyString(((CSpkFile *)p)->GetScriptTypeString(m_pPackages->GetLanguage())));
                else if ( p->GetType() == TYPE_XSP )
                        item->SubItems->Add("Ship");

                if ( p->IsSigned() )
                        item->SubItems->Add("Yes");
                else
                        item->SubItems->Add("No");


                return item;
        }

        ListViewItem ^PackageBrowser::CreateItem(SAvailablePackage *p)
        {
                ListViewItem ^item = gcnew ListViewItem(SystemStringFromCyString(p->sName), -1);
                item->SubItems->Add(SystemStringFromCyString(p->sAuthor));
                item->SubItems->Add(SystemStringFromCyString(p->sVersion));
                item->SubItems->Add(SystemStringFromCyString(p->sUpdated));

                switch (p->iType)
                {
                        case PACKAGETYPE_SHIP:
                                item->SubItems->Add("Ship");
                                break;
                        case PACKAGETYPE_LIBRARY:
                                item->SubItems->Add("Library");
                                break;
                        case PACKAGETYPE_CUSTOMSTART:
                                item->SubItems->Add("Custom Start");
                                break;
                        case PACKAGETYPE_PATCH:
                                item->SubItems->Add("Patch");
                                break;
                        case PACKAGETYPE_UPDATE:
                                item->SubItems->Add("Update");
                                break;
                        case PACKAGETYPE_MOD:
                                item->SubItems->Add("Mod");
                                break;
                        case PACKAGETYPE_FAKEPATCH:
                                item->SubItems->Add("Fake Patch");
                                break;
                        case PACKAGETYPE_NORMAL:
                                if ( p->iScriptType > 0 )
                                        item->SubItems->Add(SystemStringFromCyString(CSpkFile::GetScriptTypeStringStatic(p->iScriptType)));
                                else
                                        item->SubItems->Add("Package");
                                break;
                }

                if ( p->bSigned )
                        item->SubItems->Add("Yes");
                else
                        item->SubItems->Add("No");

                return item;
        }

        void PackageBrowser::UpdatePackages()
        {
                m_pPackages->AssignPackageNumbers();
                ListPackages->Items->Clear();
                ListPackages->Groups->Clear();

                ListViewGroup ^gNormal = gcnew ListViewGroup("Normal", HorizontalAlignment::Left);
                ListPackages->Groups->Add(gNormal);
                ListViewGroup ^gStable = gcnew ListViewGroup("Stable", HorizontalAlignment::Left);
                ListPackages->Groups->Add(gStable);
                ListViewGroup ^gExperimental = gcnew ListViewGroup("Experimental", HorizontalAlignment::Left);
                ListPackages->Groups->Add(gExperimental);
                ListViewGroup ^gCheat = gcnew ListViewGroup("Cheat", HorizontalAlignment::Left);
                ListPackages->Groups->Add(gCheat);
                ListViewGroup ^gShip = gcnew ListViewGroup("Ships", HorizontalAlignment::Left);
                ListPackages->Groups->Add(gShip);
                ListViewGroup ^gMod = gcnew ListViewGroup("Mods", HorizontalAlignment::Left);
                ListPackages->Groups->Add(gMod);

                if ( m_lAvailablePackages )
                {
                        for ( CBaseFile *p = m_lAvailablePackages->First(); p; p = m_lAvailablePackages->Next() )
                        {
                                // check if its already installed
                                if ( m_pPackages->FindPackage(p) )
                                        continue;

                                if ( !this->CheckValidPackage(p) )
                                        continue;


                                ListViewItem ^item = this->CreateItem(p);
                                item->Group = gNormal;
                                if ( p->GetType() == TYPE_XSP )
                                        item->Group = gShip;
                                else if ( p->GetType() == TYPE_SPK )
                                {
                                        switch ( p->GetPluginType() )
                                        {
                                                case PLUGIN_STABLE:
                                                        item->Group = gStable;
                                                        break;
                                                case PLUGIN_EXPERIMENTAL:
                                                        item->Group = gExperimental;
                                                        break;
                                                case PLUGIN_CHEAT:
                                                        item->Group = gCheat;
                                                        break;
                                                case PLUGIN_MOD:
                                                        item->Group = gMod;
                                                        break;
                                        }
                                }

                                item->Tag = p->GetNum();
                                ListPackages->Items->Add(item);
                                if ( p->GetIcon() )
                                        PluginManager::DisplayListIcon(p, ListPackages, item);
                                else
                                {
                                        if ( p->GetType() == TYPE_XSP )
                                                item->ImageIndex = this->imageList1->Images->IndexOfKey("ship.png");
                                        else if ( p->IsMod() || p->IsFakePatch() )
                                                item->ImageIndex = this->imageList1->Images->IndexOfKey("fake.png");
                                        else if ( p->GetType() == TYPE_SPK && ((CSpkFile *)p)->IsLibrary() )
                                                item->ImageIndex = this->imageList1->Images->IndexOfKey("library.png");
                                        else
                                                item->ImageIndex = this->imageList1->Images->IndexOfKey("package.png");
                                }
                        }
                }

                if ( this->checkBox1->Checked )
                {
                        for ( SAvailablePackage *p = m_pPackages->GetAvailablePackageList()->First(); p; p = m_pPackages->GetAvailablePackageList()->Next() )
                        {
                                if ( m_pPackages->FindPackage(p->sName, p->sAuthor) ) continue;
                                if ( !this->CheckValidPackage(p) ) continue;

                                ListViewItem ^item = this->CreateItem(p);
                                item->Group = gNormal;
                                if ( p->iType == PACKAGETYPE_SHIP )
                                        item->Group = gShip;
                                else 
                                {
                                        switch ( p->iPluginType )
                                        {
                                                case PLUGIN_STABLE:
                                                        item->Group = gStable;
                                                        break;
                                                case PLUGIN_EXPERIMENTAL:
                                                        item->Group = gExperimental;
                                                        break;
                                                case PLUGIN_CHEAT:
                                                        item->Group = gCheat;
                                                        break;
                                                case PLUGIN_MOD:
                                                        item->Group = gMod;
                                                        break;
                                        }
                                }

                                item->ImageIndex = this->imageList1->Images->IndexOfKey("download");


                                item->Tag = SystemStringFromCyString(p->sFilename);
                                ListPackages->Items->Add(item);
                        }
                }

                ListPackages->AutoResizeColumns(ColumnHeaderAutoResizeStyle::HeaderSize);
                PackageSelected(ListPackages, gcnew System::EventArgs());
        }

        void PackageBrowser::RemovePackages()
        {
                if ( m_lAvailablePackages )
                {
                        for ( CBaseFile *p = m_lAvailablePackages->First(); p; p = m_lAvailablePackages->Next() )
                        {
                                if ( p->GetIcon() )
                                        CFileIO(p->GetIcon()->GetFilePointer()).Remove();
                                delete p;
                        }
                        m_lAvailablePackages->destroy();
                        delete m_lAvailablePackages;
                }
                m_lAvailablePackages = NULL;
        }

        void PackageBrowser::UpdateControls()
        {
        }

        void PackageBrowser::SetupEvents()
        {
                ListPackages->SelectedIndexChanged += gcnew EventHandler(this, &PluginManager::PackageBrowser::PackageSelected);
                CheckCheat->Click += gcnew EventHandler(this, &PluginManager::PackageBrowser::CheckEvent);
                CheckShips->Click += gcnew EventHandler(this, &PluginManager::PackageBrowser::CheckEvent);
                CheckExperimental->Click += gcnew EventHandler(this, &PluginManager::PackageBrowser::CheckEvent);
                this->ListPackages->ColumnClick += gcnew ColumnClickEventHandler(this, &PluginManager::PackageBrowser::SortList);
        }

        void PackageBrowser::UpdateRatings(bool clear, int ease, int change, int rec)
        {
                if ( clear )
                {
                        LabRecNA->Hide();
                        LabChangeNA->Hide();
                        LabEaseNA->Hide();
                        PicEase1->Hide();
                        PicEase2->Hide();
                        PicEase3->Hide();
                        PicEase4->Hide();
                        PicEase5->Hide();
                        PicChange1->Hide();
                        PicChange2->Hide();
                        PicChange3->Hide();
                        PicChange4->Hide();
                        PicChange5->Hide();
                        PicRec1->Hide();
                        PicRec2->Hide();
                        PicRec3->Hide();
                        PicRec4->Hide();
                        PicRec5->Hide();
                }

                // ease of use rating
                if ( ease < 1 )
                        LabEaseNA->Show();
                if ( ease >= 1 )
                        PicEase1->Show();
                if ( ease >= 2 )
                        PicEase2->Show();
                if ( ease >= 3 )
                        PicEase3->Show();
                if ( ease >= 4 )
                        PicEase4->Show();
                if ( ease >= 5 )
                        PicEase5->Show();

                // game changing rating
                if ( change < 1 )
                        LabChangeNA->Show();
                if ( change >= 1 )
                        PicChange1->Show();
                if ( change >= 2 )
                        PicChange2->Show();
                if ( change >= 3 )
                        PicChange3->Show();
                if ( change >= 4 )
                        PicChange4->Show();
                if ( change >= 5 )
                        PicChange5->Show();

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

        void PackageBrowser::PackageSelected(System::Object ^Sender, System::EventArgs ^E)
        {
                this->PictureBox->Image = nullptr;

                UpdateRatings(true, -1, -1, -1);

                this->button1->Visible = false;
                bool enabled = false;
                CBaseFile *p = NULL;
                SAvailablePackage *ap = NULL;
                if ( ListPackages->SelectedItems->Count )
                {
                        ListViewItem ^item = ListPackages->SelectedItems[0];
                        if ( item )
                        {
                                CyString sNum = CyStringFromSystemString(Convert::ToString(item->Tag));
                                if ( sNum.IsNumber() )
                                {
                                        enabled = true;
                                        p = m_lAvailablePackages->Get(Convert::ToInt32(item->Tag));
                                }
                                else
                                {
                                        this->button1->Visible = true;
                                        ap = m_pPackages->FindAvailablePackage(sNum);
                                }
                        }
                }

                // update package display
                if ( p )
                {
                        CyString desc = p->GetDescription();
                        desc = desc.FindReplace("<br>", "\n");
                        desc = desc.FindReplace("<br/>", "\n");
                        desc = desc.FindReplace("<p>", "\n\t");
                        desc = desc.FindReplace("<p/>", "\n");
                        TextDesc->Text = SystemStringFromCyString(desc.StripHTML());
                        GroupPackage->Text = "Current Package (" + SystemStringFromCyString(p->GetLanguageName(m_pPackages->GetLanguage())) + ")";

                        UpdateRatings(true, p->GetEaseOfUse(), p->GetGameChanging(), p->GetRecommended());
                        // display an advert
                        bool addedIcon = false;
                        if ( p->GetFirstFile(FILETYPE_ADVERT) )
                        {
                                C_File *f = p->GetFirstFile(FILETYPE_ADVERT);
                                System::String ^aFile = SystemStringFromCyString(f->GetFilePointer().FindReplace("/", "\\").FindReplace("\\\\", "\\"));
                                if ( System::IO::File::Exists(aFile) )
                                {
                                        try 
                                        {
                                                Bitmap ^myBitmap = gcnew Bitmap(aFile);
                                                if ( myBitmap )
                                                {
                                                        this->PictureBox->Image = dynamic_cast<Image ^>(myBitmap);
                                                        addedIcon = true;
                                                }
                                        } catch (System::ArgumentException ^) {
                                        }
                                        if ( !addedIcon )
                                        {
                                                try 
                                                {
                                                        Image ^myImage = Drawing::Image::FromFile(aFile);
                                                        if ( myImage )
                                                        {
                                                                this->PictureBox->Image = myImage;
                                                                addedIcon = true;
                                                        }
                                                } catch (System::ArgumentException ^) {
                                                } catch (System::OutOfMemoryException ^) {
                                                }
                                        }
                                }
                        }

                        if ( !addedIcon )
                        {
                                System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(PackageBrowser::typeid));
                                System::Drawing::Icon ^icon = (cli::safe_cast<System::Drawing::Icon^  >(resources->GetObject(L"$this.Icon")));
                                this->PictureBox->Image = icon->ToBitmap();
                        }
                }
                else if ( ap )
                {
                        CyString desc = ap->sDesc;
                        desc = desc.FindReplace("<br>", "\n");
                        desc = desc.FindReplace("<br/>", "\n");
                        desc = desc.FindReplace("<p>", "\n\t");
                        desc = desc.FindReplace("<p/>", "\n");
                        TextDesc->Text = SystemStringFromCyString(desc.StripHTML());
                        GroupPackage->Text = "Current Package (" + SystemStringFromCyString(ap->sName) + ") [DOWNLOAD REQUIRED]";

                        UpdateRatings(true, ap->iEase, ap->iChanging, ap->iRec);

                        System::ComponentModel::ComponentResourceManager^  resources = (gcnew System::ComponentModel::ComponentResourceManager(PackageBrowser::typeid));
                        System::Drawing::Icon ^icon = (cli::safe_cast<System::Drawing::Icon^  >(resources->GetObject(L"$this.Icon")));
                        this->PictureBox->Image = icon->ToBitmap();
                }
                // clear package display
                else
                {
                        GroupPackage->Text = "Current Package (None)";
                        TextDesc->Text = "";
                }

                m_pSelectedMod = p;
                m_pSelectedPackage = ap;

                ButInstall->Enabled = enabled;
        }

        void PackageBrowser::SortList(System::Object ^Sender, ColumnClickEventArgs ^E)
        {
                if ( E->Column == m_iLastCol )
                {
                        m_bReverse = !m_bReverse;
                        this->ListPackages->ListViewItemSorter = gcnew ListViewItemComparer(E->Column, m_bReverse);
                }
                else
                {
                        m_bReverse = false;
                        this->ListPackages->ListViewItemSorter = gcnew ListViewItemComparer(E->Column, m_bReverse);
                }
                this->ListPackages->Sort();
                m_iLastCol = E->Column;

        }

        void PackageBrowser::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();
                }
        }

}