marrub/quake-tools
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: marrub:d904117b798dcf71d32728f90f4201c8dec817ae
Branches Tags
marrub:master
..
compare: marrub:881fa8c9bd421d73648d9ff25882c6edf52eda2e
Branches Tags
marrub:master

No commits in common. "d904117b798dcf71d32728f90f4201c8dec817ae" and "881fa8c9bd421d73648d9ff25882c6edf52eda2e" have entirely different histories.
d904117b79 ... 881fa8c9bd

15 changed files with 208 additions and 842 deletions
Show Stats Expand all files Collapse all files

9
CMakeLists.txt
View File

@ -27,12 +27,9 @@ macro(make_qt_project TARGET_NAME)
target_compile_definitions(
${TARGET_NAME}
PUBLIC
-DQT_DISABLE_DEPRECATED_BEFORE=0x051300
-DQT_NO_CAST_FROM_ASCII
-DQT_NO_CAST_TO_ASCII
-DQT_NO_NARROWING_CONVERSIONS_IN_CONNECT
-DQT_NO_URL_CAST_FROM_STRING
-DQT_STRICT_ITERATORS)
-DQT_DEPRECATED_WARNINGS
-DQT_STRICT_ITERATORS
-DQT_NO_NARROWING_CONVERSIONS_IN_CONNECT)
endmacro()
find_package(

24
source/common.h
View File

@ -11,7 +11,6 @@
#include <array>
#include <filesystem>
#include <fstream>
#include <functional>
#include <ios>
#include <istream>
#include <iterator>
@ -29,16 +28,12 @@ using Option = std::optional<T>;
template<typename... Ts>
using Variant = std::variant<Ts...>;
template<typename T>
using UniquePtr = std::unique_ptr<T>;
struct Error : public std::runtime_error {
using std::runtime_error::runtime_error;
};
struct EnumError : public Error {using Error::Error;};
struct FileFormatError : public Error {using Error::Error;};
struct FileSystemError : public Error {using Error::Error;};
struct UnimplementedError : public Error {using Error::Error;};
struct MemoryStreamBuf : public std::streambuf {
@ -125,15 +120,6 @@ static inline int enumMax() {
return QMetaEnum::fromType<T>().keyCount();
}
template<typename T>
static inline T orThrow(Option<T> opt, Error err) {
if(opt) {
return *opt;
} else {
throw err;
}
}
static inline QDebug operator<<(QDebug debug, std::string const &t) {
debug << QString::fromStdString(t);
return debug;
@ -155,14 +141,4 @@ static inline QDebug operator<<(QDebug debug, Option<T> const &t) {
return debug;
}
template<typename T>
static inline QDebug operator<<(QDebug debug, UniquePtr<T> const &t) {
if(t) {
debug << *t;
} else {
debug << "nullptr";
}
return debug;
}
// EOF

210
source/quam/archive.cc
View File

@ -18,153 +18,33 @@ namespace Arc {
return None;
}
Node::Node(std::string _name) :
name(_name),
parent(nullptr)
{
}
Node::~Node() {
}
Dir *Node::getRoot() {
if(!parent) {
return getDir();
} else {
Dir *rover = parent;
while(rover->parent) {
rover = rover->parent;
}
return rover;
}
}
Node *Node::findPath(std::string path) {
if(path.empty()) {
return nullptr;
}
Dir *rover;
// get the initial dir, which will either be:
// - the root if the path starts with /
// - the node itself
// - the node's current Dir (when it's not a Dir)
if(path.front() == '/') {
path.erase(path.begin());
rover = getRoot();
} else {
rover = getDir();
if(!rover) {
rover = parent;
}
}
if(path.empty()) {
// no file, so just the directory itself
return rover;
} else if(auto slash = path.find('/'); slash != std::string::npos) {
std::string prev;
prev = path.substr(0, slash);
path = path.substr(slash + 1);
if(prev == "..") {
// parent dir on ".."
rover = rover->parent ? rover->parent : rover;
} else if(prev != ".") {
if(auto node = rover->findNode(prev)) {
// we want a subdirectory since this path continues
rover = node->getDir();
} else {
// took a wrong turn
rover = nullptr;
}
}
// recurse
return rover ? rover->findPath(path) : nullptr;
} else {
// must be a node inside a directory
return rover->findNode(path);
}
}
std::string Node::getPath(bool fromChild) const {
if(parent) {
return parent->getPath(true) + '/' + name;
} else if(fromChild) {
return std::string{};
} else {
return "/";
}
}
Dir::Dir(std::string _name) :
Node(_name),
m_data()
{
}
Dir::~Dir() {
}
UniquePtr<Node> const &Dir::emplaceBack(Node *node) {
node->parent = this;
return m_data.emplace_back(node);
}
Dir Dir::readArchive(std::istream &st, ArcType type) {
switch(type) {
Dir readArchive(std::istream &st) {
switch(auto v = getArchiveType(st);
v.has_value() ? *v : throw FileFormatError("not an archive")) {
case ArcType::Pack: return readPack(st);
case ArcType::Wad2: return readWad2(st);
}
Q_UNREACHABLE();
}
Node *Dir::findNode(std::string const &name) {
auto it = std::find_if(m_data.begin(), m_data.end(),
[&name](auto const &node) {
return node->name == name;
auto it = std::find_if(begin(), end(), [&name](Node &node) {
return node.name == name;
});
return it != m_data.end() ? &**it : nullptr;
return it != end() ? &*it : nullptr;
}
File::File(std::string _name, QByteArray &&_data) :
Node(_name),
m_data(std::move(_data))
Node::Node(Dir &&f, std::string &&n, FileType t) :
superType(std::move(f)),
name(std::move(n)),
type(t)
{
}
File::~File() {
}
ArcInfo::ArcInfo(ArcType arcType) noexcept :
type{arcType}
Node::Node(File &&f, std::string &&n, FileType t) :
superType(std::move(f)),
name(std::move(n)),
type(t)
{
switch(type) {
case ArcType::Pack:
pathMaxChars = 56;
validatorType = PackValidator::staticMetaObject;
break;
case ArcType::Wad2:
pathMaxChars = 16;
validatorType = Wad2Validator::staticMetaObject;
break;
}
}
Arc::Arc(std::istream &st, QObject *parent) :
QObject{parent},
info{ArcInfo(orThrow(getArchiveType(st),
FileFormatError("not an archive")))},
root{Dir::readArchive(st, info.type)},
validator{qobject_cast<QValidator *>(info.validatorType
.newInstance(Q_ARG(QObject *,
this)))}
{
}
Arc::~Arc() {
}
Model::Model(QObject *parent) :
@ -187,23 +67,21 @@ namespace Arc {
switch(role) {
case Qt::DecorationRole:
if(col == Column::Name) {
auto icon = node->getDir() ? "folder" : "text-x-generic";
return QVariant{QIcon::fromTheme(QString::fromUtf8(icon))};
auto icon =
std::holds_alternative<Dir>(*node) ? "folder"
: "text-x-generic";
return QVariant{QIcon::fromTheme(icon)};
}
break;
case Qt::DisplayRole:
switch(col) {
case Column::Size:
if(auto file = node->getFile()) {
if(auto file = std::get_if<File>(node)) {
return QVariant{QString::number(file->size())};
}
break;
case Column::Type:
if(auto file = node->getFile()) {
return QVariant{tr(enumToString(file->type))};
} else {
return QVariant{tr("Directory")};
}
return QVariant{tr(enumToString(node->type))};
case Column::Name:
return QVariant{tr(node->name.data())};
}
@ -245,7 +123,7 @@ namespace Arc {
if(!m_dir || !hasIndex(row, col, parent) || row > m_dir->size()) {
return QModelIndex{};
} else {
return createIndex(row, col, m_dir->at(row));
return createIndex(row, col, &m_dir->at(row));
}
}
@ -265,49 +143,11 @@ namespace Arc {
return m_dir;
}
Node *Model::findPath(std::string path) {
return m_dir->findPath(path);
}
void Model::setDir(Dir *to) {
auto from = m_dir;
if(to != from) {
emit layoutAboutToBeChanged();
for(int row = 0, rows = rowCount(); row < rows; row++) {
for(int col = 0, cols = columnCount(); col < cols; col++) {
changePersistentIndex(index(row, col), QModelIndex{});
}
}
m_dir = to;
void Model::setDir(Dir *dir) {
if(dir != m_dir) {
m_dir = dir;
emit layoutChanged();
emit dirChanged(from, to);
}
}
void Model::setDirToIndex(QModelIndex const &ind) {
auto node = static_cast<Node *>(ind.data(Qt::UserRole).value<void *>());
if(auto dir = node->getDir()) {
setDir(dir);
}
}
bool Model::goUp() {
if(m_dir && m_dir->parent) {
setDir(m_dir->parent);
return true;
} else {
return false;
}
}
bool Model::goPath(std::string path) {
Node *node;
Dir *dir;
if(m_dir && (node = m_dir->findPath(path)) && (dir = node->getDir())) {
setDir(dir);
return true;
} else {
return false;
emit dirChanged(dir);
}
}
}

138
source/quam/archive.h
View File

@ -4,13 +4,14 @@
#include <QAbstractItemModel>
#include <QByteArray>
#include <QMetaObject>
#include <QObject>
#include <QValidator>
namespace Arc {
Q_NAMESPACE
struct Node;
struct Dir;
enum class Column {
Size,
Type,
@ -35,83 +36,33 @@ namespace Arc {
};
Q_ENUM_NS(ArcType)
class Dir;
class File;
Option<ArcType> getArchiveType(std::istream &st) noexcept;
class Node {
public:
Node() = delete;
Node(Node const &) = delete;
Node(Node &&) = default;
virtual ~Node();
Dir readArchive(std::istream &st);
virtual Dir const *getDir() const = 0;
virtual Dir *getDir() = 0;
virtual File const *getFile() const = 0;
virtual File *getFile() = 0;
struct Dir : public std::vector<Node> {
using std::vector<Node>::vector;
Dir *getRoot();
Node *findPath(std::string path);
std::string getPath(bool fromChild = false) const;
Dir *parent{nullptr};
std::string name;
protected:
Node(std::string name);
};
class Dir : public Node {
public:
using DataType = std::vector<UniquePtr<Node>>;
Dir(std::string name);
Dir(Dir const &) = delete;
Dir(Dir &&) = default;
virtual ~Dir();
Dir const *getDir() const override {return this;}
Dir *getDir() override {return this;}
File const *getFile() const override {return nullptr;}
File *getFile() override {return nullptr;}
DataType const &data() const {return m_data;}
Node *at(std::size_t i) const {return &*m_data.at(i);}
std::size_t size() const {return m_data.size();}
UniquePtr<Node> const &emplaceBack(Node *node);
Node *findNode(std::string const &name);
static Dir readArchive(std::istream &st, ArcType type);
private:
DataType m_data;
};
class File : public Node {
public:
using DataType = QByteArray;
struct File : public QByteArray {
using QByteArray::QByteArray;
};
File(std::string name, QByteArray &&data);
File(File const &) = delete;
File(File &&) = default;
virtual ~File();
struct Node : public Variant<Dir, File> {
using superType = Variant<Dir, File>;
Dir const *getDir() const override {return nullptr;}
Dir *getDir() override {return nullptr;}
File const *getFile() const override {return this;}
File *getFile() override {return this;}
Node() = default;
DataType const &data() const {return m_data;}
Node(Dir &&f, std::string &&n, FileType t = FileType::Normal);
Node(File &&f, std::string &&n, FileType t = FileType::Normal);
std::size_t size() const {return m_data.size();}
Node(Node const &) = default;
Node(Node &&) = default;
FileType type{FileType::Normal};
private:
DataType m_data;
std::string name;
FileType type;
};
class Model : public QAbstractItemModel {
@ -136,63 +87,24 @@ namespace Arc {
Dir *dir() const;
Node *findPath(std::string path);
public slots:
void setDir(Dir *dir);
void setDirToIndex(QModelIndex const &ind);
bool goUp();
bool goPath(std::string path);
signals:
void dirChanged(Dir *from, Dir *to);
void dirChanged(Dir *dir);
private:
Dir *m_dir;
};
class ArcInfo {
public:
ArcInfo(ArcType arcType) noexcept;
ArcType type;
std::size_t pathMaxChars;
QMetaObject validatorType;
};
class Arc : QObject {
Q_OBJECT
public:
explicit Arc(std::istream &st, QObject *parent = nullptr);
~Arc();
ArcInfo info;
Dir root;
QValidator *validator;
};
Option<ArcType> getArchiveType(std::istream &st) noexcept;
}
static inline QDebug operator<<(QDebug debug, Arc::Dir const &t) {
debug << t.data();
return debug;
}
static inline QDebug operator<<(QDebug debug, Arc::File const &t) {
debug << t.data();
return debug;
}
Q_DECLARE_METATYPE(Arc::Dir)
Q_DECLARE_METATYPE(Arc::File)
Q_DECLARE_METATYPE(Arc::Node)
static inline QDebug operator<<(QDebug debug, Arc::Node const &t) {
debug << "Arc::Node(" << t.name << ", ";
if(auto v = t.getDir()) {
debug << *v;
} else if(auto v = t.getFile()) {
debug << *v;
}
std::visit([&](auto &&arg) {debug << arg;},
static_cast<Variant<Arc::Dir, Arc::File>>(t));
debug << ")";
return debug;
}

17
source/quam/main.cc
View File

@ -6,10 +6,10 @@
#include <QCoreApplication>
static void setupAppl(QCoreApplication &appl) {
appl.setApplicationName(QString::fromUtf8("QuAM!"));
appl.setApplicationVersion(QString::fromUtf8("1.0"));
appl.setOrganizationDomain(QString::fromUtf8("greyserv.net"));
appl.setOrganizationName(QString::fromUtf8("Project Golan"));
appl.setApplicationName("QuAM!");
appl.setApplicationVersion("1.0");
appl.setOrganizationDomain("greyserv.net");
appl.setOrganizationName("Project Golan");
}
static int modeGui(int argc, char *argv[]) {
@ -26,15 +26,14 @@ static int modeText(int argc, char *argv[]) {
QCommandLineParser par;
par.setApplicationDescription(QString::fromUtf8("Quake Archive Manager"));
par.setApplicationDescription("Quake Archive Manager");
par.setSingleDashWordOptionMode(
QCommandLineParser::ParseAsCompactedShortOptions);
par.addHelpOption();
par.addVersionOption();
QCommandLineOption fileNameOpt{QStringList{QString::fromUtf8("f"),
QString::fromUtf8("file")},
QCommandLineOption fileNameOpt{QStringList{"f", "file"},
trMain("Open the archive <file>."),
trMain("file")};
par.addOption(fileNameOpt);
@ -44,7 +43,9 @@ static int modeText(int argc, char *argv[]) {
auto fileName = par.value(fileNameOpt).toStdString();
auto st = openReadBin(fileName);
qDebug() << Arc::Arc(st).root;
auto arc = Arc::readArchive(st);
qDebug() << arc;
return 0;
}

43
source/quam/main_window.cc
View File

@ -5,16 +5,6 @@
#include <QErrorMessage>
#include <QFileDialog>
#include <QMdiSubWindow>
static bool applyActiveWin(QMdiArea *area, std::function<bool(Project *)> fn) {
if(auto subWin = area->activeSubWindow()) {
if(auto win = qobject_cast<Project *>(subWin->widget())) {
return fn(win);
}
}
return false;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow{parent},
@ -26,11 +16,6 @@ MainWindow::MainWindow(QWidget *parent) :
actionClose->setShortcut(QKeySequence{QKeySequence::Close});
actionOpen->setShortcut(QKeySequence{QKeySequence::Open});
actionQuit->setShortcut(QKeySequence{QKeySequence::Quit});
actionUp->setShortcut(Qt::ALT + Qt::Key_Up);
actionTop->setShortcut(Qt::ALT + Qt::Key_Home);
actionBack->setShortcut(QKeySequence{QKeySequence::Back});
actionForward->setShortcut(QKeySequence{QKeySequence::Forward});
}
MainWindow::~MainWindow() {
@ -49,15 +34,9 @@ void MainWindow::fileOpen() {
if(!fileName.isEmpty()) {
try {
auto path = std::filesystem::path(fileName.toStdString());
auto st = openReadBin(path);
auto win = new QMdiSubWindow;
auto proj = new Project{st, m_errors, win};
win->setWidget(proj);
win->setAttribute(Qt::WA_DeleteOnClose);
win->setWindowTitle(QString::fromStdString(path.filename()));
mdiArea->addSubWindow(win);
win->showMaximized();
auto st = openReadBin(fileName.toStdString());
auto arc = Arc::readArchive(st);
new Project{std::move(arc), m_errors, mdiArea};
} catch(std::exception const &exc) {
m_errors->showMessage(tr(exc.what()));
}
@ -70,20 +49,4 @@ void MainWindow::fileClose() {
}
}
bool MainWindow::goBack() {
return applyActiveWin(mdiArea, [](auto win) {return win->goBack();});
}
bool MainWindow::goForward() {
return applyActiveWin(mdiArea, [](auto win) {return win->goForward();});
}
bool MainWindow::goTop() {
return applyActiveWin(mdiArea, [](auto win) {return win->goTop();});
}
bool MainWindow::goUp() {
return applyActiveWin(mdiArea, [](auto win) {return win->goUp();});
}
// EOF

5
source/quam/main_window.h
View File

@ -20,11 +20,6 @@ public slots:
void fileOpen();
void fileClose();
bool goBack();
bool goForward();
bool goTop();
bool goUp();
private:
QErrorMessage *m_errors;
};

125
source/quam/main_window.ui
View File

@ -17,15 +17,6 @@
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QMdiArea" name="mdiArea">
<property name="background">
<brush brushstyle="Dense7Pattern">
<color alpha="255">
<red>0</red>
<green>0</green>
<blue>0</blue>
</color>
</brush>
</property>
<property name="viewMode">
<enum>QMdiArea::TabbedView</enum>
</property>
@ -48,7 +39,7 @@
<x>0</x>
<y>0</y>
<width>640</width>
<height>24</height>
<height>29</height>
</rect>
</property>
<widget class="QMenu" name="menuFile">
@ -60,17 +51,7 @@
<addaction name="separator"/>
<addaction name="actionQuit"/>
</widget>
<widget class="QMenu" name="menuGo">
<property name="title">
<string>&amp;Go</string>
</property>
<addaction name="actionUp"/>
<addaction name="actionBack"/>
<addaction name="actionForward"/>
<addaction name="actionTop"/>
</widget>
<addaction name="menuFile"/>
<addaction name="menuGo"/>
</widget>
<widget class="QStatusBar" name="statusbar"/>
<action name="actionOpen">
@ -100,42 +81,6 @@
<string>&amp;Close</string>
</property>
</action>
<action name="actionUp">
<property name="icon">
<iconset theme="go-up">
<normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>&amp;Up</string>
</property>
</action>
<action name="actionBack">
<property name="icon">
<iconset theme="go-previous">
<normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>&amp;Back</string>
</property>
</action>
<action name="actionForward">
<property name="icon">
<iconset theme="go-next">
<normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>&amp;Forward</string>
</property>
</action>
<action name="actionTop">
<property name="icon">
<iconset theme="go-top">
<normaloff>.</normaloff>.</iconset>
</property>
<property name="text">
<string>&amp;Top</string>
</property>
</action>
</widget>
<resources/>
<connections>
@ -187,78 +132,10 @@
</hint>
</hints>
</connection>
<connection>
<sender>actionUp</sender>
<signal>triggered()</signal>
<receiver>MainWindow</receiver>
<slot>goUp()</slot>
<hints>
<hint type="sourcelabel">
<x>-1</x>
<y>-1</y>
</hint>
<hint type="destinationlabel">
<x>319</x>
<y>239</y>
</hint>
</hints>
</connection>
<connection>
<sender>actionTop</sender>
<signal>triggered()</signal>
<receiver>MainWindow</receiver>
<slot>goTop()</slot>
<hints>
<hint type="sourcelabel">
<x>-1</x>
<y>-1</y>
</hint>
<hint type="destinationlabel">
<x>319</x>
<y>239</y>
</hint>
</hints>
</connection>
<connection>
<sender>actionBack</sender>
<signal>triggered()</signal>
<receiver>MainWindow</receiver>
<slot>goBack()</slot>
<hints>
<hint type="sourcelabel">
<x>-1</x>
<y>-1</y>
</hint>
<hint type="destinationlabel">
<x>319</x>
<y>239</y>
</hint>
</hints>
</connection>
<connection>
<sender>actionForward</sender>
<signal>triggered()</signal>
<receiver>MainWindow</receiver>
<slot>goForward()</slot>
<hints>
<hint type="sourcelabel">
<x>-1</x>
<y>-1</y>
</hint>
<hint type="destinationlabel">
<x>319</x>
<y>239</y>
</hint>
</hints>
</connection>
</connections>
<slots>
<slot>fileOpen()</slot>
<slot>selectCell(int,int)</slot>
<slot>fileClose()</slot>
<slot>goUp()</slot>
<slot>goForward()</slot>
<slot>goBack()</slot>
<slot>goTop()</slot>
</slots>
</ui>

77
source/quam/pack.cc
View File

@ -1,8 +1,18 @@
#include "quam/pack.h"
struct PackHeader {
quint32 dirOffset;
quint32 dirNum;
};
struct PackEntry {
std::string name;
Arc::File file;
};
static constexpr quint32 sizeOfPackEntry = 64;
static std::pair<quint32, quint32> readPackHeader(std::istream &st) {
static PackHeader readPackHeader(std::istream &st) {
auto magic = readBytes<4>(st);
if(magic != std::array{'P', 'A', 'C', 'K'}) {
@ -16,31 +26,40 @@ static std::pair<quint32, quint32> readPackHeader(std::istream &st) {
throw FileFormatError("invalid directory size");
}
return std::make_pair(dirOffset, dirSize / sizeOfPackEntry);
PackHeader hdr;
hdr.dirOffset = dirOffset;
hdr.dirNum = dirSize / sizeOfPackEntry;
return hdr;
}
static Arc::File readPackEntry(std::istream &st) {
static PackEntry readPackEntry(std::istream &st) {
auto entName = readBytes<56>(st);
auto entOffset = readLE<quint32>(st);
auto entSize = readLE<quint32>(st);
if(entName.front() == '/') {
throw FileFormatError("empty root directory name");
}
auto pos = st.tellg();
st.seekg(entOffset);
QByteArray data;
data.resize(entSize);
st.read(data.data(), entSize);
Arc::File file;
file.resize(entSize);
st.read(file.data(), entSize);
st.seekg(pos);
return Arc::File{ntbsToString(entName), std::move(data)};
std::string name = ntbsToString(entName);
if(name.front() == '/') {
throw FileFormatError("empty root directory name");
}
static void insertFile(Arc::Dir &dir, Arc::File &file, std::string name) {
PackEntry ent;
ent.name = std::move(name);
ent.file = std::move(file);
return ent;
}
static void insertFile(Arc::Dir &dir, std::string &name, Arc::File &file) {
Option<std::string> next;
if(auto slash = name.find('/'); slash != std::string::npos) {
@ -50,18 +69,11 @@ static void insertFile(Arc::Dir &dir, Arc::File &file, std::string name) {
auto existing = dir.findNode(name);
if(next) {
Arc::Node *ref;
if(existing) {
ref = existing;
} else {
ref = new Arc::Dir(name);
dir.emplaceBack(ref);
}
insertFile(*ref->getDir(), file, *next);
auto &ref = existing ? *existing
: dir.emplace_back(Arc::Dir{}, std::move(name));
insertFile(std::get<Arc::Dir>(ref), *next, file);
} else if(!existing) {
file.name = name;
file.parent = &dir;
dir.emplaceBack(new Arc::File(std::move(file)));
dir.emplace_back(std::move(file), std::move(name));
} else {
throw FileFormatError("duplicate file");
}
@ -69,25 +81,16 @@ static void insertFile(Arc::Dir &dir, Arc::File &file, std::string name) {
Arc::Dir readPack(std::istream &st) {
auto hdr = readPackHeader(st);
st.seekg(hdr.first);
st.seekg(hdr.dirOffset);
Arc::Dir root{std::string{}};
Arc::Dir root;
for(quint32 i = 0; i < hdr.second; i++) {
auto file = readPackEntry(st);
insertFile(root, file, file.name);
for(quint32 i = 0; i < hdr.dirNum; i++) {
auto ent = readPackEntry(st);
insertFile(root, ent.name, ent.file);
}
return root;
}
PackValidator::PackValidator(QObject *parent) :
QValidator{parent}
{
}
QValidator::State PackValidator::validate(QString &input, int &pos) const {
return QValidator::Acceptable;
}
// EOF

11
source/quam/pack.h
View File

@ -4,17 +4,6 @@
#include "quam/archive.h"
#include <QValidator>
class PackValidator : public QValidator {
Q_OBJECT
public:
Q_INVOKABLE explicit PackValidator(QObject *parent);
QValidator::State validate(QString &input, int &pos) const override;
};
Arc::Dir readPack(std::istream &st);
// EOF

90
source/quam/project.cc
View File

@ -1,103 +1,47 @@
#include "quam/project.h"
#include <QAbstractItemModel>
#include <QErrorMessage>
#include <QMdiArea>
#include <QSortFilterProxyModel>
Project::Project(std::istream &st, QErrorMessage *errors, QWidget *parent) :
QWidget{parent},
Project::Project(Arc::Dir &&arc, QErrorMessage *errors, QMdiArea *parent) :
QMdiSubWindow{parent},
Ui::Project{},
m_seekingDir{false},
m_histPos{0},
m_hist(),
m_arc{new Arc::Arc{st, this}},
m_arc{std::move(arc)},
m_errors{errors},
m_model{new Arc::Model{this}},
m_sorter{new QSortFilterProxyModel{this}}
{
setupUi(this);
auto widget = new QWidget(this);
setupUi(widget);
setWidget(widget);
setAttribute(Qt::WA_DeleteOnClose);
showMaximized();
connect(m_model, &Arc::Model::dirChanged,
this, &Project::dirChanged);
connect(tableView, &QAbstractItemView::doubleClicked,
m_model, &Arc::Model::setDirToIndex);
this, &Project::viewDoubleClicked);
dirName->setValidator(m_arc->validator);
m_sorter->setSourceModel(m_model);
tableView->setModel(m_sorter);
seekTop();
m_model->setDir(&m_arc);
}
Project::~Project() {
}
void Project::dirChanged(Arc::Dir *from, Arc::Dir *to) {
if(!m_seekingDir) {
if(std::ptrdiff_t(m_histPos) < std::ptrdiff_t(m_hist.size()) - 1) {
auto beg = m_hist.begin();
std::advance(beg, m_histPos + 1);
m_hist.erase(beg, m_hist.end());
}
m_hist.push_back(to->getPath());
m_histPos = m_hist.size() - 1;
} else {
m_seekingDir = false;
}
tableView->sortByColumn(int(Arc::Column::Type), Qt::AscendingOrder);
void Project::dirChanged(Arc::Dir *) {
tableView->resizeColumnsToContents();
}
void Project::seekTop() {
m_model->setDir(&m_arc->root);
}
bool Project::seekHistory(std::ptrdiff_t newPos) {
if(newPos < 0 || newPos >= m_hist.size()) {
return false;
}
m_histPos = newPos;
qDebug() << "hist pos changed:" << m_histPos;
auto newPath = m_hist.at(newPos);
if(auto node = m_model->findPath(newPath)) {
if(auto dir = node->getDir()) {
m_seekingDir = true;
void Project::viewDoubleClicked(QModelIndex const &index) {
auto node = static_cast<Arc::Node *>(index.data(Qt::UserRole)
.value<void *>());
if(auto dir = std::get_if<Arc::Dir>(node)) {
m_model->setDir(dir);
return true;
} else {
m_errors->showMessage(QString::fromStdString("'"s + newPath + "' ") +
tr("is not a directory"));
return false;
}
} else {
m_errors->showMessage(tr("could not find directory") +
QString::fromStdString(" '"s + newPath + "'"));
return false;
}
}
bool Project::goBack() {
return seekHistory(std::ptrdiff_t(m_histPos) - 1);
}
bool Project::goForward() {
return seekHistory(std::ptrdiff_t(m_histPos) + 1);
}
bool Project::goTop() {
seekTop();
return true;
}
bool Project::goUp() {
return m_model->goUp();
}
bool Project::goPath(std::string path) {
return m_model->goPath(path);
}
// EOF

26
source/quam/project.h
View File

@ -5,37 +5,27 @@
#include "quam/archive.h"
#include "quam/ui_project.h"
#include <QMainWindow>
#include <QMdiSubWindow>
#include <QWidget>
class QAbstractItemModel;
class QErrorMessage;
class QSortFilterProxyModel;
class Project : public QWidget, private Ui::Project {
class Project : public QMdiSubWindow, private Ui::Project {
Q_OBJECT
public:
explicit Project(std::istream &st, QErrorMessage *errors, QWidget *parent);
explicit Project(Arc::Dir &&arc, QErrorMessage *errors, QMdiArea *parent);
virtual ~Project();
bool seekHistory(std::ptrdiff_t newPos);
void seekTop();
public slots:
bool goBack();
bool goForward();
bool goTop();
bool goUp();
bool goPath(std::string path);
private slots:
void dirChanged(Arc::Dir *from, Arc::Dir *to);
void dirChanged(Arc::Dir *dir);
void viewDoubleClicked(QModelIndex const &index);
private:
bool m_seekingDir;
std::size_t m_histPos;
std::vector<std::string> m_hist;
Arc::Arc *m_arc;
Arc::Dir m_arc;
QErrorMessage *m_errors;
Arc::Model *m_model;
QSortFilterProxyModel *m_sorter;

120
source/quam/project.ui
View File

@ -13,70 +13,12 @@
<property name="windowTitle">
<string>Project View</string>
</property>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QSplitter" name="splitter">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<widget class="QWidget" name="">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QPushButton" name="buttonBack">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="icon">
<iconset theme="go-previous"/>
</property>
<property name="flat">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonForward">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="icon">
<iconset theme="go-next"/>
</property>
<property name="flat">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QPushButton" name="buttonUp">
<property name="sizePolicy">
<sizepolicy hsizetype="Minimum" vsizetype="Minimum">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<property name="icon">
<iconset theme="go-up"/>
</property>
<property name="flat">
<bool>true</bool>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="dirName"/>
</item>
</layout>
</item>
<item>
<widget class="QTableView" name="tableView">
<property name="verticalScrollBarPolicy">
<enum>Qt::ScrollBarAlwaysOn</enum>
@ -115,69 +57,11 @@
<bool>false</bool>
</attribute>
</widget>
</item>
</layout>
</widget>
<widget class="QPlainTextEdit" name="textEdit"/>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections>
<connection>
<sender>buttonBack</sender>
<signal>clicked()</signal>
<receiver>Project</receiver>
<slot>goBack()</slot>
<hints>
<hint type="sourcelabel">
<x>18</x>
<y>17</y>
</hint>
<hint type="destinationlabel">
<x>319</x>
<y>239</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonForward</sender>
<signal>clicked()</signal>
<receiver>Project</receiver>
<slot>goForward()</slot>
<hints>
<hint type="sourcelabel">
<x>47</x>
<y>17</y>
</hint>
<hint type="destinationlabel">
<x>319</x>
<y>239</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonUp</sender>
<signal>clicked()</signal>
<receiver>Project</receiver>
<slot>goUp()</slot>
<hints>
<hint type="sourcelabel">
<x>76</x>
<y>17</y>
</hint>
<hint type="destinationlabel">
<x>319</x>
<y>239</y>
</hint>
</hints>
</connection>
</connections>
<slots>
<slot>goUp()</slot>
<slot>goForward()</slot>
<slot>goBack()</slot>
<slot>goTop()</slot>
</slots>
<connections/>
</ui>

54
source/quam/wad2.cc
View File

@ -7,6 +7,17 @@ namespace Wad2 {
};
}
struct Wad2Header {
quint32 dirNum;
quint32 dirOffset;
};
struct Wad2Entry {
std::string name;
Arc::FileType type;
Arc::File file;
};
static Arc::FileType getFileType(int n) {
switch(n) {
case 0: return Arc::FileType::Normal;
@ -20,19 +31,20 @@ static Arc::FileType getFileType(int n) {
}
}
static std::pair<quint32, quint32> readWad2Header(std::istream &st) {
static Wad2Header readWad2Header(std::istream &st) {
auto magic = readBytes<4>(st);
if(magic != std::array{'W', 'A', 'D', '2'}) {
throw FileFormatError("not a wad2 file (invalid magic number)");
}
auto dirNum = readLE<quint32>(st);
auto dirOffset = readLE<quint32>(st);
return std::make_pair(dirOffset, dirNum);
Wad2Header hdr;
hdr.dirNum = readLE<quint32>(st);
hdr.dirOffset = readLE<quint32>(st);
return hdr;
}
static Arc::File readWad2Entry(std::istream &st) {
static Wad2Entry readWad2Entry(std::istream &st) {
auto entOffset = readLE<quint32>(st);
auto entSize = readLE<quint32>(st);
auto entCSize = readLE<quint32>(st);
@ -49,37 +61,31 @@ static Arc::File readWad2Entry(std::istream &st) {
st.seekg(entOffset);
QByteArray data;
Arc::File file;
file.resize(entSize);
st.read(file.data(), entSize);
data.resize(entSize);
st.read(data.data(), entSize);
st.seekg(pos);
Arc::File file{ntbsToString(entName), std::move(data)};
file.type = getFileType(entType);
return file;
Wad2Entry ent;
ent.name = ntbsToString(entName);
ent.file = std::move(file);
ent.type = getFileType(entType);
return ent;
}
Arc::Dir readWad2(std::istream &st) {
auto hdr = readWad2Header(st);
st.seekg(hdr.first);
st.seekg(hdr.dirOffset);
Arc::Dir root{std::string{}};
Arc::Dir root;
for(quint32 i = 0; i < hdr.second; i++) {
root.emplaceBack(new Arc::File(readWad2Entry(st)));
for(quint32 i = 0; i < hdr.dirNum; i++) {
auto ent = readWad2Entry(st);
root.emplace_back(std::move(ent.file), std::move(ent.name), ent.type);
}
return root;
}
Wad2Validator::Wad2Validator(QObject *parent) :
QValidator{parent}
{
}
QValidator::State Wad2Validator::validate(QString &input, int &pos) const {
return QValidator::Acceptable;
}
// EOF

11
source/quam/wad2.h
View File

@ -4,17 +4,6 @@
#include "quam/archive.h"
#include <QValidator>
class Wad2Validator : public QValidator {
Q_OBJECT
public:
Q_INVOKABLE explicit Wad2Validator(QObject *parent);
QValidator::State validate(QString &input, int &pos) const override;
};
Arc::Dir readWad2(std::istream &st);
// EOF