elfExplorer/filemanager.cpp at master · hanrai/elfExplorer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#include "filemanager.h"
#include <QFile>
#include <QUrl>
#include "arcmodel.h"
#include "DecodeArcMes.h"
#include "mesdecoder.h"

FileManager::FileManager(QObject *parent) : QObject(parent)
{
    m_arcFile = 0;
    m_arcModel = new ArcModel(this);
}

FileManager::~FileManager()
{
    if(m_arcFile)
        delete m_arcFile;
}

QString FileManager::getArcFilename() const
{
    if(!m_arcFile)
        return QString();

    return getFilename(m_arcFile->fileName());
}

QString FileManager::getMesScript() const
{
    return m_mesScript;
}

QAbstractListModel *FileManager::getModel()
{
    return m_arcModel;
}

void FileManager::openArc(QString filename)
{
    if(filename.isEmpty())
        return;
    QUrl fn(filename);

    QFile* file = new QFile(fn.toLocalFile());
    if(!file->open(QIODevice::ReadOnly))
    {
        emit fileSystemError(file->errorString());
        delete file;
        return;
    }

    replaceArcFileObject(file);
    emit arcFilenameChanged(getArcFilename());
    QByteArray buffer;
    auto sz = decodeFilenames(buffer);

    m_arcModel->init(buffer, sz);

    file->close();
}

void FileManager::decodeFile(QString filename, quint32 offset, quint32 size)
{
    QStringList fn = filename.split(".");
    QString ext = fn.last();

    m_arcFile->open(QIODevice::ReadOnly);
    if(!m_arcFile->isOpen())
    {
        emit fileSystemError(m_arcFile->errorString());
        return;
    }
    m_arcFile->seek(offset);
    QByteArray src = m_arcFile->read(size);
    m_arcFile->close();

    QByteArray buffer(1000000,'\0');
    quint32 sz = DecodeArcMes(src.data(), buffer.data(), size);
    buffer.truncate(sz);
    if(!ext.compare("MES", Qt::CaseInsensitive))
    {
        auto decoder = MesDecoder(this);
        m_mesScript = decoder.Decode(buffer);
        emit mesScriptChanged(m_mesScript);
        return;
    }
}

void FileManager::saveMes(QString filename)
{
    QUrl fn = QUrl(filename);
    QString locFn = fn.toLocalFile();
    QFile saveFile(locFn);
    saveFile.open(QIODevice::WriteOnly|QIODevice::Text);
    if(!saveFile.isOpen())
    {
        emit fileSystemError(saveFile.errorString());
        return;
    }
    saveFile.write(m_mesScript.toLocal8Bit());
    saveFile.close();
}

void FileManager::replaceArcFileObject(QFile *file)
{
    if(m_arcFile)
        delete m_arcFile;

    m_arcFile = file;
}

QString FileManager::getFilename(QString fullpath) const
{
    QUrl fn = QUrl::fromLocalFile(fullpath);
    return fn.fileName();
}

quint32 FileManager::decodeFilenames(QByteArray &dataBuffer)
{
    quint32 fileCount;
    m_arcFile->read((char*)&fileCount, 4);
    Q_ASSERT(fileCount);

    dataBuffer = m_arcFile->read(fileCount*20);
    Q_ASSERT(dataBuffer.size() == fileCount*20);

    struct FilenameListStructure
    {
        quint32 filename[3];
        quint32 size;
        quint32 offset;
    };
    Q_ASSERT ( sizeof(FilenameListStructure)==20 );
    FilenameListStructure *pFilenameList;

    pFilenameList = (FilenameListStructure*) dataBuffer.data();

    for(quint32 i=0; i<fileCount; i++)
    {
        pFilenameList[i].filename[0] ^= 0x55555555;
        pFilenameList[i].filename[1] ^= 0x55555555;
        pFilenameList[i].filename[2] ^= 0x55555555;
        pFilenameList[i].size ^= 0xAA55AA55;
        pFilenameList[i].offset ^= 0x55AA55AA;
    }

    return fileCount;
}