Subversion Repositories spk

Rev

Rev 226 | 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 {

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

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

                if ( !this->CheckCheat->Checked && p->pluginType() == PLUGIN_CHEAT )
                        return false;
                if ( !this->CheckExperimental->Checked && p->pluginType() == 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 || 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(_US(p->name(m_pPackages->GetLanguage())), -1);
                item->SubItems->Add(_US(p->author()));
                item->SubItems->Add(_US(p->version()));
                item->SubItems->Add(_US(p->creationDate()));
                if ( p->GetType() == TYPE_SPK )
                        item->SubItems->Add(_US(((CSpkFile *)p)->scriptTypeString(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(_US(p->sName), -1);
                item->SubItems->Add(_US(p->sAuthor));
                item->SubItems->Add(_US(p->sVersion));
                item->SubItems->Add(_US(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(_US(CSpkFile::GetScriptTypeStringStatic(p->iScriptType, m_pPackages->GetLanguage())));
                                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->pluginType() ) {
                                                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->icon() )
                                        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 = _US(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->icon() )
                                        CFileIO::Remove(p->icon()->filePointer());
                                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;
                const SAvailablePackage *ap = NULL;
                if ( ListPackages->SelectedItems->Count )
                {
                        ListViewItem ^item = ListPackages->SelectedItems[0];
                        if ( item )
                        {
                                Utils::WString sNum = _WS(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 )
                {
                        Utils::WString desc = p->description();
                        desc = desc.findReplace(L"<br>", L"\n");
                        desc = desc.findReplace(L"<br/>", L"\n");
                        desc = desc.findReplace(L"<p>", L"\n\t");
                        desc = desc.findReplace(L"<p/>", L"\n");
                        TextDesc->Text = _US(desc.stripHtml());
                        GroupPackage->Text = "Current Package (" + _US(p->name(m_pPackages->GetLanguage())) + ")";

                        UpdateRatings(true, p->easeOfUse(), p->gameChanging(), p->recommended());
                        // display an advert
                        bool addedIcon = false;
                        if ( p->GetFirstFile(FILETYPE_ADVERT) )
                        {
                                C_File *f = p->GetFirstFile(FILETYPE_ADVERT);
                                System::String ^aFile = _US(f->filePointer().findReplace(L"/", L"\\").findReplace(L"\\\\", L"\\"));
                                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 )
                {
                        Utils::WString desc = ap->sDesc;
                        desc = desc.findReplace(L"<br>", L"\n");
                        desc = desc.findReplace(L"<br/>", L"\n");
                        desc = desc.findReplace(L"<p>", L"\n\t");
                        desc = desc.findReplace(L"<p/>", L"\n");
                        TextDesc->Text = _US(desc.stripHtml());
                        GroupPackage->Text = "Current Package (" + _US(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();
                }
                else
                {
                        m_pMainGui->FindPackages();
                        this->UpdatePackages();
                }

        }

}