implement up/forward/back/top buttons

CMakeLists.txt

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

source/common.h

@@ -11,6 +11,7 @@
 #include <array>
 #include <filesystem>
 #include <fstream>
+#include <functional>
 #include <ios>
 #include <istream>
 #include <iterator>
@@ -28,12 +29,16 @@ 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 {
@@ -120,6 +125,15 @@ 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;
@@ -141,4 +155,14 @@ 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

source/quam/archive.cc

@@ -18,33 +18,153 @@ namespace Arc {
 		return None;
 	}
 
-	Dir readArchive(std::istream &st) {
+	Node::Node(std::string _name) :
-		switch(auto v = getArchiveType(st);
+		name(_name),
-		       v.has_value() ? *v : throw FileFormatError("not an archive")) {
+		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) {
 			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(begin(), end(), [&name](Node &node) {
+		auto it = std::find_if(m_data.begin(), m_data.end(),
-			return node.name == name;
+			[&name](auto const &node) {
+				return node->name == name;
 			});
-		return it != end() ? &*it : nullptr;
+		return it != m_data.end() ? &**it : nullptr;
 	}
 
-	Node::Node(Dir &&f, std::string &&n, FileType t) :
+	File::File(std::string _name, QByteArray &&_data) :
-		superType(std::move(f)),
+		Node(_name),
-		name(std::move(n)),
+		m_data(std::move(_data))
-		type(t)
 	{
 	}
 
-	Node::Node(File &&f, std::string &&n, FileType t) :
+	File::~File() {
-		superType(std::move(f)),
+	}
-		name(std::move(n)),
+
-		type(t)
+	ArcInfo::ArcInfo(ArcType arcType) noexcept :
+		type{arcType}
 	{
+		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) :
@@ -67,21 +187,23 @@ namespace Arc {
 		switch(role) {
 			case Qt::DecorationRole:
 				if(col == Column::Name) {
-					auto icon =
+					auto icon = node->getDir() ? "folder" : "text-x-generic";
-						std::holds_alternative<Dir>(*node) ? "folder"
+					return QVariant{QIcon::fromTheme(QString::fromUtf8(icon))};
-						                                   : "text-x-generic";
-					return QVariant{QIcon::fromTheme(icon)};
 				}
 				break;
 			case Qt::DisplayRole:
 				switch(col) {
 					case Column::Size:
-						if(auto file = std::get_if<File>(node)) {
+						if(auto file = node->getFile()) {
 							return QVariant{QString::number(file->size())};
 						}
 						break;
 					case Column::Type:
-						return QVariant{tr(enumToString(node->type))};
+						if(auto file = node->getFile()) {
+							return QVariant{tr(enumToString(file->type))};
+						} else {
+							return QVariant{tr("Directory")};
+						}
 					case Column::Name:
 						return QVariant{tr(node->name.data())};
 				}
@@ -123,7 +245,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));
 		}
 	}
 
@@ -143,11 +265,49 @@ namespace Arc {
 		return m_dir;
 	}
 
-	void Model::setDir(Dir *dir) {
+	Node *Model::findPath(std::string path) {
-		if(dir != m_dir) {
+		return m_dir->findPath(path);
-			m_dir = dir;
+	}
+
+	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;
 			emit layoutChanged();
-			emit dirChanged(dir);
+			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;
 		}
 	}
 }

source/quam/archive.h

@@ -4,14 +4,13 @@
 
 #include <QAbstractItemModel>
 #include <QByteArray>
+#include <QMetaObject>
 #include <QObject>
+#include <QValidator>
 
 namespace Arc {
 	Q_NAMESPACE
 
-	struct Node;
-	struct Dir;
-
 	enum class Column {
 		Size,
 		Type,
@@ -36,33 +35,83 @@ namespace Arc {
 	};
 	Q_ENUM_NS(ArcType)
 
-	Option<ArcType> getArchiveType(std::istream &st) noexcept;
+	class Dir;
+	class File;
 
-	Dir readArchive(std::istream &st);
+	class Node {
-
+	public:
-	struct Dir : public std::vector<Node> {
+		Node()             = delete;
-		using std::vector<Node>::vector;
+		Node(Node const &) = delete;
-
-		Node *findNode(std::string const &name);
-	};
-
-	struct File : public QByteArray {
-		using QByteArray::QByteArray;
-	};
-
-	struct Node : public Variant<Dir, File> {
-		using superType = Variant<Dir, File>;
-
-		Node() = default;
-
-		Node(Dir  &&f, std::string &&n, FileType t = FileType::Normal);
-		Node(File &&f, std::string &&n, FileType t = FileType::Normal);
-
-		Node(Node const &) = default;
 		Node(Node &&)      = default;
+		virtual ~Node();
 
+		virtual Dir  const *getDir()  const = 0;
+		virtual Dir        *getDir()        = 0;
+		virtual File const *getFile() const = 0;
+		virtual File       *getFile()       = 0;
+
+		Dir  *getRoot();
+		Node *findPath(std::string path);
+
+		std::string getPath(bool fromChild = false) const;
+
+		Dir        *parent{nullptr};
 		std::string name;
-		FileType    type;
+
+	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;
+
+		File(std::string name, QByteArray &&data);
+		File(File const &) = delete;
+		File(File &&)      = default;
+		virtual ~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;}
+
+		DataType const &data() const {return m_data;}
+
+		std::size_t size() const {return m_data.size();}
+
+		FileType type{FileType::Normal};
+
+	private:
+		DataType m_data;
 	};
 
 	class Model : public QAbstractItemModel {
@@ -87,24 +136,63 @@ 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 *dir);
+		void dirChanged(Dir *from, Dir *to);
 
 	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 << ", ";
-	std::visit([&](auto &&arg) {debug << arg;},
+	if(auto v = t.getDir()) {
-	           static_cast<Variant<Arc::Dir, Arc::File>>(t));
+		debug << *v;
+	} else if(auto v = t.getFile()) {
+		debug << *v;
+	}
 	debug << ")";
 	return debug;
 }

source/quam/main.cc

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

source/quam/main_window.cc

@@ -5,6 +5,16 @@
 
 #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},
@@ -16,6 +26,11 @@ 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() {
@@ -34,9 +49,15 @@ void MainWindow::fileOpen() {
 
 	if(!fileName.isEmpty()) {
 		try {
-			auto st  = openReadBin(fileName.toStdString());
+			auto path = std::filesystem::path(fileName.toStdString());
-			auto arc = Arc::readArchive(st);
+			auto st   = openReadBin(path);
-			new Project{std::move(arc), m_errors, mdiArea};
+			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();
 		} catch(std::exception const &exc) {
 			m_errors->showMessage(tr(exc.what()));
 		}
@@ -49,4 +70,20 @@ 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

source/quam/main_window.h

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

source/quam/main_window.ui

@@ -17,6 +17,15 @@
    <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>
@@ -39,7 +48,7 @@
      <x>0</x>
      <y>0</y>
      <width>640</width>
-     <height>29</height>
+     <height>24</height>
     </rect>
    </property>
    <widget class="QMenu" name="menuFile">
@@ -51,7 +60,17 @@
     <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">
@@ -81,6 +100,42 @@
     <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>
@@ -132,10 +187,78 @@
     </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>

source/quam/pack.cc

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

source/quam/pack.h

@@ -4,6 +4,17 @@
 
 #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

source/quam/project.cc

@@ -1,47 +1,103 @@
 #include "quam/project.h"
 
-#include <QAbstractItemModel>
 #include <QErrorMessage>
-#include <QMdiArea>
 #include <QSortFilterProxyModel>
 
-Project::Project(Arc::Dir &&arc, QErrorMessage *errors, QMdiArea *parent) :
+Project::Project(std::istream &st, QErrorMessage *errors, QWidget *parent) :
-	QMdiSubWindow{parent},
+	QWidget{parent},
 	Ui::Project{},
-	m_arc{std::move(arc)},
+	m_seekingDir{false},
+	m_histPos{0},
+	m_hist(),
+	m_arc{new Arc::Arc{st, this}},
 	m_errors{errors},
 	m_model{new Arc::Model{this}},
 	m_sorter{new QSortFilterProxyModel{this}}
 {
-	auto widget = new QWidget(this);
+	setupUi(this);
-	setupUi(widget);
-	setWidget(widget);
-	setAttribute(Qt::WA_DeleteOnClose);
-	showMaximized();
 
 	connect(m_model, &Arc::Model::dirChanged,
 	        this,    &Project::dirChanged);
 	connect(tableView, &QAbstractItemView::doubleClicked,
-	        this,      &Project::viewDoubleClicked);
+	        m_model,   &Arc::Model::setDirToIndex);
 
+	dirName->setValidator(m_arc->validator);
 	m_sorter->setSourceModel(m_model);
 	tableView->setModel(m_sorter);
-	m_model->setDir(&m_arc);
+	seekTop();
 }
 
 Project::~Project() {
 }
 
-void Project::dirChanged(Arc::Dir *) {
+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);
 	tableView->resizeColumnsToContents();
 }
 
-void Project::viewDoubleClicked(QModelIndex const &index) {
+void Project::seekTop() {
-	auto node = static_cast<Arc::Node *>(index.data(Qt::UserRole)
+	m_model->setDir(&m_arc->root);
-	                                          .value<void *>());
+}
-	if(auto dir = std::get_if<Arc::Dir>(node)) {
+
+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;
 			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

source/quam/project.h

@@ -5,27 +5,37 @@
 #include "quam/archive.h"
 #include "quam/ui_project.h"
 
-#include <QMainWindow>
-#include <QMdiSubWindow>
 #include <QWidget>
 
-class QAbstractItemModel;
 class QErrorMessage;
 class QSortFilterProxyModel;
 
-class Project : public QMdiSubWindow, private Ui::Project {
+class Project : public QWidget, private Ui::Project {
 	Q_OBJECT
 
 public:
-	explicit Project(Arc::Dir &&arc, QErrorMessage *errors, QMdiArea *parent);
+	explicit Project(std::istream &st, QErrorMessage *errors, QWidget *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 *dir);
+	void dirChanged(Arc::Dir *from, Arc::Dir *to);
-	void viewDoubleClicked(QModelIndex const &index);
 
 private:
-	Arc::Dir               m_arc;
+	bool                     m_seekingDir;
+	std::size_t              m_histPos;
+	std::vector<std::string> m_hist;
+	Arc::Arc                *m_arc;
 	QErrorMessage           *m_errors;
 	Arc::Model              *m_model;
 	QSortFilterProxyModel   *m_sorter;

source/quam/project.ui

@@ -13,12 +13,70 @@
   <property name="windowTitle">
    <string>Project View</string>
   </property>
-  <layout class="QHBoxLayout" name="horizontalLayout">
+  <layout class="QHBoxLayout" name="horizontalLayout_2">
    <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>
@@ -57,11 +115,69 @@
           <bool>false</bool>
          </attribute>
         </widget>
+       </item>
+      </layout>
+     </widget>
      <widget class="QPlainTextEdit" name="textEdit"/>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
- <connections/>
+ <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>
 </ui>

source/quam/wad2.cc

@@ -7,17 +7,6 @@ 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;
@@ -31,20 +20,19 @@ static Arc::FileType getFileType(int n) {
 	}
 }
 
-static Wad2Header readWad2Header(std::istream &st) {
+static std::pair<quint32, quint32> 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)");
 	}
 
-	Wad2Header hdr;
+	auto dirNum    = readLE<quint32>(st);
-	hdr.dirNum    = readLE<quint32>(st);
+	auto dirOffset = readLE<quint32>(st);
-	hdr.dirOffset = readLE<quint32>(st);
+	return std::make_pair(dirOffset, dirNum);
-	return hdr;
 }
 
-static Wad2Entry readWad2Entry(std::istream &st) {
+static Arc::File readWad2Entry(std::istream &st) {
 	auto entOffset = readLE<quint32>(st);
 	auto entSize   = readLE<quint32>(st);
 	auto entCSize  = readLE<quint32>(st);
@@ -61,31 +49,37 @@ static Wad2Entry readWad2Entry(std::istream &st) {
 
 	st.seekg(entOffset);
 
-	Arc::File file;
+	QByteArray data;
-	file.resize(entSize);
-	st.read(file.data(), entSize);
 
+	data.resize(entSize);
+	st.read(data.data(), entSize);
 	st.seekg(pos);
 
-	Wad2Entry ent;
+	Arc::File file{ntbsToString(entName), std::move(data)};
-	ent.name = ntbsToString(entName);
+	file.type = getFileType(entType);
-	ent.file = std::move(file);
+	return file;
-	ent.type = getFileType(entType);
-	return ent;
 }
 
 Arc::Dir readWad2(std::istream &st) {
 	auto hdr = readWad2Header(st);
-	st.seekg(hdr.dirOffset);
+	st.seekg(hdr.first);
 
-	Arc::Dir root;
+	Arc::Dir root{std::string{}};
 
-	for(quint32 i = 0; i < hdr.dirNum; i++) {
+	for(quint32 i = 0; i < hdr.second; i++) {
-		auto ent = readWad2Entry(st);
+		root.emplaceBack(new Arc::File(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

source/quam/wad2.h

@@ -4,6 +4,17 @@
 
 #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