packagemanager.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * This code is based on Broken Sword 2.5 engine
 *
 * Copyright (c) Malte Thiesen, Daniel Queteschiner and Michael Elsdoerfer
 *
 * Licensed under GNU GPL v2
 *
 */

/*
 * BS_PackageManager
 * -----------------
 * This is the package manager interface, that contains all the methods that a package manager
 * must implement.
 * In the package manager, note the following:
 * 1. It creates a completely new (virtual) directory tree in the packages and directories
 *    can be mounted.
 * 2. To separate elements of a directory path '/' must be used rather than '\'
 * 3. LoadDirectoryAsPackage should only be used for testing. The final release will be
 *    have all files in packages.
 *
 * Autor: Malte Thiesen, $author$
 */

#ifndef SWORD25_PACKAGE_MANAGER_H
#define SWORD25_PACKAGE_MANAGER_H

#include "common/archive.h"
#include "common/array.h"
#include "common/fs.h"
#include "common/str.h"

#include "sword25/kernel/common.h"
#include "sword25/kernel/kernel.h"
#include "sword25/kernel/service.h"

namespace Sword25 {

// Class definitions

class PackageManager : public Service {
private:
    class ArchiveEntry {
    public:
        Common::Archive *archive;
        Common::String _mountPath;

        ArchiveEntry(Common::Archive *archive_, const Common::String &mountPath_):
            archive(archive_), _mountPath(mountPath_) {
        }
        ~ArchiveEntry() {
            delete archive;
        }
    };

    Common::String _currentDirectory;
    Common::FSNode _rootFolder;
    Common::List<ArchiveEntry *> _archiveList;
    bool _extractedFiles;
    Common::Path _directoryName;

    bool _useEnglishSpeech;
    Common::String ensureSpeechLang(const Common::String &fileName);

    Common::ArchiveMemberPtr getArchiveMember(const Common::String &fileName);

public:
    PackageManager(Kernel *pKernel);
    ~PackageManager() override;

    enum FILE_TYPES {
        FT_DIRECTORY    = (1 << 0),
        FT_FILE         = (1 << 1)
    };

    void setRunWithExtractedFiles(const Common::Path &directoryName) {
        _extractedFiles = true;
        _directoryName = directoryName;
    }

    bool loadPackage(const Common::Path &fileName, const Common::String &mountPosition);
    bool loadDirectoryAsPackage(const Common::Path &directoryName, const Common::String &mountPosition);
    byte *getFile(const Common::String &fileName, uint *pFileSize = NULL);

    Common::SeekableReadStream *getStream(const Common::String &fileName);
    char *getXmlFile(const Common::String &fileName, uint *pFileSize = NULL) {
        const char *versionStr = "<?xml version=\"1.0\"?>";
        uint fileSize;
        char *data = (char *)getFile(fileName, &fileSize);
        size_t resultSize = fileSize + strlen(versionStr) + 1;
        char *result = (char *)malloc(resultSize);
        if (!result)
            error("[PackageManager::getXmlFile] Cannot allocate memory");

        Common::strcpy_s(result, resultSize, versionStr);
        Common::copy(data, data + fileSize, result + strlen(versionStr));
        result[resultSize - 1] = '\0';

        delete[] data;
        if (pFileSize)
            *pFileSize = fileSize + strlen(versionStr);

        return result;
    }

    Common::String getCurrentDirectory() { return _currentDirectory; }
    bool changeDirectory(const Common::String &directory);
    Common::String getAbsolutePath(const Common::String &fileName);
    int doSearch(Common::ArchiveMemberList &list, const Common::String &filter, const Common::String &path, uint typeFilter = FT_DIRECTORY | FT_FILE);

    bool fileExists(const Common::String &FileName);

private:
    bool registerScriptBindings();
};

} // End of namespace Sword25

#endif