Subversion Repositories spk

#include "../StdAfx.h"
#include "ExtractDialog.h"

#include "FileExists.h"

namespace SpkExplorer {
        void ExtractDialog::Background_DoWork(System::Object ^Sender, DoWorkEventArgs ^E)
        {
                System::Threading::Thread::Sleep(5);
                switch ( m_iWorkingStatus )
                {
                        case WORKER_READ:
                                if ( m_pMultiPackage )
                                {
                                        if ( !m_pMultiPackage->ReadSpk(m_pWorkingPackage, SPKREAD_ALL) )
                                                m_sFailed = "Reading";
                                }
                                else
                                {
                                        if ( m_iGame != -1 ) {
                                                if ( m_pWorkingFile->game() && !(m_pWorkingFile->game() & (1 << m_iGame))) {
                                                        m_iWorkingStatus = WORKER_WRITE;
                                                        break;
                                                }
                                                else if ( !m_iGame && m_pWorkingFile->game() ) {
                                                        m_iWorkingStatus = WORKER_WRITE;
                                                        break;
                                                }
                                        }

                                        if ( !m_pPackage->ReadFileToMemory(m_pWorkingFile) )
                                                m_sFailed = "Reading";
                                }
                                break;
                        case WORKER_UNCOMPRESS:
                                {
                                        if ( !m_pMultiPackage )
                                        {
                                                long size = 0;
                                                if ( m_pWorkingFile->GetDataSize() ) {
                                                        m_pUncompressData = m_pWorkingFile->UncompressData(&size, 0);
                                                        if ( !size || !m_pUncompressData )
                                                                m_sFailed = "Uncompressing";
                                                }
                                                m_iUncompressSize = size;
                                        }
                                }
                                break;
                        case WORKER_WRITE:
                                {
                                        Utils::String sToDir = _S(m_sToDir);
                                        if ( m_pMultiPackage )
                                        {
                                                if ( !m_pMultiPackage->ExtractFile(m_pWorkingPackage, sToDir) )
                                                        m_sFailed = "Writing";
                                        }
                                        else
                                        {
                                                // check for addon directory
                                                if (m_pWorkingFile->isFileInAddon())
                                                {
                                                        unsigned int game = m_iGame;
                                                        if (game <= 0)
                                                        {
                                                                unsigned int checkGame = m_pWorkingFile->game() & ~GAME_ALLNEW;
                                                                for (int i = 0; i < 31; ++i)
                                                                {
                                                                        if (checkGame == (1 << i))
                                                                        {
                                                                                game = i;
                                                                                break;
                                                                        }
                                                                }
                                                        }

                                                        if (game > 0)
                                                        {
                                                                SGameExe *exe = _pPackages->GetGameExe()->GetGame(game - 1);
                                                                if (exe && !exe->sAddon.empty())
                                                                        sToDir += "/" + exe->sAddon;
                                                        }
                                                }

                                                if ( !CDirIO(sToDir + "/" + m_pWorkingFile->getDirectory(NULL)).exists() )
                                                {
                                                        if ( !CDirIO(sToDir + "/" + m_pWorkingFile->getDirectory(NULL)).Create() )
                                                        {
                                                                m_sFailed = "Creating Directory";
                                                                break;
                                                        }
                                                }

                                                if ( !m_pWorkingFile->writeToFile(CFileIO(sToDir + "/" + m_pWorkingFile->getNameDirectory(NULL)).fullFilename(), m_pUncompressData, m_iUncompressSize) )
                                                        m_sFailed = "Writing";
                                                else
                                                        m_iExtractCount++;
                                        }
                                }
                                break;
                }
        }

        void ExtractDialog::DoNextFile()
        {
                ++m_iCount;
                this->progressBar1->Value = m_iCount;

                bool finished = false;
                if ( m_pMultiPackage )
                {
                        m_pWorkingPackage = m_pMultiList->Next();
                        if ( !m_pWorkingPackage )
                                finished = true;
                }
                else
                {
                        m_pWorkingFile = m_pList->Next();
                        if ( !m_pWorkingFile )
                                finished = true;
                }

                if ( !finished )
                {
                        this->UpdateDisplay();
                        this->StartWork(WORKER_READ);
                }
                else
                        this->Finished();
        }

        void ExtractDialog::Background_Finished(System::Object ^Sender, RunWorkerCompletedEventArgs ^E)
        {
                if ( m_sFailed->Length )
                {
                        if ( m_pMultiPackage )
                                m_pFailedList->PushBack(m_pWorkingPackage->sName, CyStringFromSystemString(m_sFailed));
                        else
                                m_pFailedList->PushBack(m_pWorkingFile->GetNameDirectory(NULL), CyStringFromSystemString(m_sFailed));
                }

                if ( m_iWorkingStatus == WORKER_WRITE || m_sFailed->Length )
                        this->DoNextFile();
                else
                        this->StartWork(m_iWorkingStatus + 1);
        }

        void ExtractDialog::Finished()
        {
                m_bOK = true;
                if ( !m_pFailedList->Empty() )
                {
                        CyString s;
                        for ( SStringList *str = m_pFailedList->Head(); str; str = str->next )
                                s += str->str + " (" + str->data + ")\n";
                        MessageBox::Show(this, "Error Extracting Files:\n\n" + SystemStringFromCyString(s), "Extract Error", MessageBoxButtons::OK, MessageBoxIcon::Error);
                        m_bOK = false;
                }

                this->Close();
        }

        bool ExtractDialog::CheckExists(System::String ^file)
        {
                if ( m_bYesToAll )
                        return true;

                if ( !System::IO::File::Exists(file) )
                        return true;

                if ( m_bNoToAll )
                        return false;

                CyString sFile = CyStringFromSystemString(file);
                sFile.FindReplace("/", "\\");
                FileExists ^exists = gcnew FileExists(SystemStringFromCyString(sFile));
                System::Windows::Forms::DialogResult result = exists->ShowDialog(this);
                if ( result == System::Windows::Forms::DialogResult::Yes )
                        return true;
                else if ( result == System::Windows::Forms::DialogResult::Cancel )
                {
                        m_bCancel = true;
                        this->Close();
                        return false;
                }
                else if ( result == System::Windows::Forms::DialogResult::No )
                        return false;
                else if ( result == System::Windows::Forms::DialogResult::Ignore )
                {
                        m_bNoToAll = true;
                        return false;
                }
                else if ( result == System::Windows::Forms::DialogResult::OK )
                {
                        m_bYesToAll = true;
                        return true;
                }

                return false;
        }

        void ExtractDialog::StartWork(int status)
        {
                m_iWorkingStatus = status;
                bool start = true;
                switch ( m_iWorkingStatus )
                {
                        case WORKER_READ:
                                {
                                        String ^checkFile;
                                        if ( m_pMultiPackage )
                                                checkFile = m_sToDir + "/" + SystemStringFromCyString(m_pWorkingPackage->sName);
                                        else
                                                checkFile = m_sToDir + "/" + SystemStringFromCyString(m_pWorkingFile->GetNameDirectory(NULL));
                                        if ( !this->CheckExists(checkFile) )
                                        {
                                                start = false;
                                                if ( !m_bCancel )
                                                        this->DoNextFile();
                                                break;
                                        }
                                        this->LabStatus->Text = "Reading file to memory";
                                }
                                break;
                        case WORKER_UNCOMPRESS:
                                this->LabStatus->Text = "Uncompressing...";
                                break;
                        case WORKER_WRITE:
                                this->LabStatus->Text = "Writing File...";
                                break;
                        default:
                                start = false;
                }

                if ( start )
                {
                        m_sFailed = "";
                        backgroundWorker1->RunWorkerAsync();
                }
        }


        void ExtractDialog::UpdateDisplay()
        {
                CyString sToDir = CyStringFromSystemString(m_sToDir);

                int max = 0;
                if ( m_pMultiPackage )
                        max = m_pMultiList->size();
                else
                        max = m_pList->size();

                this->Text = "Extracting Files [" + (m_iCount + 1) + "/" + max + "]";

                CyString filename;
                if ( m_pMultiPackage )
                        filename = sToDir + "/" + m_pWorkingPackage->sName;
                else
                        filename = sToDir + "/" + m_pWorkingFile->GetNameDirectory(NULL);

                CyString displayFilename = filename;
                displayFilename.FindReplace("/", "\\");
                this->LabFilename->Text = SystemStringFromCyString(displayFilename);

                if ( m_pMultiPackage )
                        this->LabSize->Text = SystemStringFromCyString(SPK::GetSizeString(m_pWorkingPackage->lSize));
                else
                        this->LabSize->Text = SystemStringFromCyString(m_pWorkingFile->GetUncompressedSizeString());
                this->LabStatus->Text = "Waiting";
        }

        void ExtractDialog::Start()
        {
                if ( m_pMultiPackage )
                {
                        this->progressBar1->Maximum = m_pMultiList->size();
                        m_pWorkingPackage = m_pMultiList->First();
                }
                else
                {
                        this->progressBar1->Maximum = m_pList->size();
                        m_pWorkingFile = m_pList->First();
                }
                this->progressBar1->Value = 0;

                m_iCount = 0;
                this->UpdateDisplay();
                this->StartWork(WORKER_READ);
        }
}