.github/workflows/build.yml

@@ -7,7 +7,7 @@ on:
 
 jobs:
   build-linux:
-    runs-on: ubuntu-24.04
+    runs-on: ubuntu-latest
 
     steps:
     - uses: actions/checkout@v4.1.7
@@ -15,7 +15,7 @@ jobs:
     - name: Create Build Environment
       run: |
         sudo apt-get update
-        sudo apt-get install -y build-essential libgl1-mesa-dev libglvnd-dev cmake qt6-base-dev
+        sudo apt-get install -y build-essential libgl1-mesa-dev and libglvnd-dev cmake qt6-base-dev
         mkdir build
   
     - name: Configure CMake
@@ -127,4 +127,4 @@ jobs:
       uses: softprops/action-gh-release@v2.0.8
       if: startsWith(github.ref, 'refs/tags/')
       with:
-        files: "build/Release/NDSFactory-${{ github.ref_name }}-Windows-x64.zip"
+        files: "build/Release/NDSFactory-${{ github.ref_name }}-Windows-x64.zip"

README.md

@@ -39,28 +39,18 @@ In the Unpacker Tab, you can load your Nintendo DS software (.nds) and extract t
 **You can then do what you want with these sections (inject code, apply patches etc.)**
 
 ## Packer Tab
-In the Packer Tab, you can recreate a .nds file using your edited sections.
-If your sections are larger than the originals, you must update their addresses and sizes in the header.
-Ensure that the addresses do not overlap, or the final ROM will be broken.
-If you repack edited sections and the FAT files' address is different from the original, you must patch the FAT (fat.bin).
-The FAT contains absolute addresses representing each file's start and end addresses, so you need to update them accordingly (use the FAT Patching Tab for this).
-
-WARNING: if the ROM contains ARM9/ARM7 overlays and your sections are larger than the original, you must manually update the overlay offsets in the ovr and fat binaries (using an hex editor).
+In the Packer Tab, you can recreate a .nds file using your edited sections. If your sections are larger than the originals, you must update their addresses and sizes in the header. Ensure that the addresses do not overlap, or the final ROM will be broken. If you repack edited sections and the FAT files' address is different from the original, you must patch the FAT (fat.bin). The FAT contains absolute addresses representing each file's start and end addresses, so you need to update them accordingly (use the FAT Patching Tab for this).
 
 ## Fat Tools Tab
 In this tab, you can:
 * extract the FAT files from fat_data.bin.
-* rebuild the FAT files into a new fat.bin and fat_data.bin.
-  If the ROM contains ARM9/ARM7 overlays you must provide the original fat.bin to extract the overlay offsets.
-  
-  WARNING: DO NOT MODIFY FAT FILES NAMES OR EXTENSIONS, OR YOU WILL NEED A NEW fnt.bin.
-* patch the FAT section (fat.bin): this is only necessary if the FAT files' final address (fat_data.bin) differs from the original.
-  Patching the FAT is straightforward: load your fat.bin, and fill in the original and new addresses of fat_data.bin. This will produce a patched fat.bin for use in the packing process.
+* patch the FAT section (fat.bin): this is only necessary if the FAT files' final address (fat_data.bin) differs from the original. Patching the FAT is straightforward: load your fat.bin, and fill in the original and new addresses of fat_data.bin. This will produce a patched fat.bin for use in the packing process.
 
-# Credits
+# Known Limitations/Possible Future Features/Bugs
+
+* Add support to rebuild a new fat_data.bin and fat.bin from a set of files inside a directory.
 
 If you find a bug, feel free to open an issue or submit a pull request :)
 
-Special thanks to [Antonio Barba](https://github.com/antoniobarba) & [Davide Trogu](https://github.com/Dax89)
-
-Developed with ❤ by Luca D'Amico
+### Developed with ❤ by Luca D'Amico
+### Special thanks to Antonio Barba & Davide Trogu

ndsfactory/ndsfactory.cpp

@@ -22,94 +22,107 @@
 #define ROOT_DIRECTORY_ADDRESS 0xF000
 
 
-NFResult NDSFactory::loadRomHeader(const std::string& romPath, std::vector<char>& romHeader)
+NDSFactory::NDSFactory()
+{
+
+}
+
+bool NDSFactory::loadRomHeader(const std::string& romPath, std::vector<char>& romHeader)
 {
     std::streampos headerSize = sizeof(NDSHeader);
     std::ifstream romFile (romPath, std::ios::binary);
-    if (!romFile.is_open())
-		return NFResult({ false, "Error opening file: " + romPath });
-    
-    romHeader.resize(static_cast<unsigned long>(headerSize));
-    romFile.read (romHeader.data(), headerSize);
-    romFile.close();
-	return NFResult({ true, "" });
+    if (romFile.is_open())
+    {
+        romHeader.resize(static_cast<unsigned long>(headerSize));
+
+        romFile.read (romHeader.data(), headerSize);
+        romFile.close();
+
+        return true;
+    }
+    return false;
 }
 
-NFResult NDSFactory::dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
+bool NDSFactory::dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
 {
     std::ifstream romFile (romPath, std::ios::binary);
     std::ofstream savedFile (savePath, std::ios::binary);
-	if (!romFile.is_open()) return NFResult({ false, "Error opening file: " + romPath });
-	if (!savedFile.is_open()) return NFResult({ false, "Error creating file: " + savePath });
+    if (romFile.is_open() && savedFile.is_open())
+    {
+        std::vector<char> dumpBuffer(size);
+        romFile.seekg (startAddr, std::ios::beg);
+        romFile.read (dumpBuffer.data(), size);
+        romFile.close();
 
-    std::vector<char> dumpBuffer(size);
-    romFile.seekg (startAddr, std::ios::beg);
-    romFile.read (dumpBuffer.data(), size);
-    romFile.close();
-
-    savedFile.write(dumpBuffer.data(), size);
-    savedFile.close();
-    return NFResult({ true, "" });
+        savedFile.write(dumpBuffer.data(), size);
+        savedFile.close();
+        return true;
+    }
+    return false;
 }
 
 bool NDSFactory::logToFile(const std::string& logPath, const std::string& log)
 {
     std::ofstream savedFile(logPath, std::ios::out | std::ios::binary | std::ios::app);
-    if (!savedFile.is_open()) return false;
-
-	savedFile.write(log.c_str(), log.size());
-    savedFile.close();
-    return true;
+    if (savedFile.is_open())
+    {
+		savedFile.write(log.c_str(), log.size());
+        savedFile.close();
+        return true;
+    }
+    return false;
 }
 
 
-NFResult NDSFactory::readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size)
+bool NDSFactory::readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size)
 {
     std::ifstream romFile (romPath, std::ios::binary);
-    if (!romFile.is_open())
-		return NFResult({ false, "Error opening file: " + romPath });
-
-    romFile.seekg (startAddr, std::ios::beg);
-    romFile.read (byteBuffer.data(), size);
-    romFile.close();
-	return NFResult({ true, "" });
+    if (romFile.is_open())
+    {
+        romFile.seekg (startAddr, std::ios::beg);
+        romFile.read (byteBuffer.data(), size);
+        romFile.close();
+        return true;
+    }
+    return false;
 }
 
-NFResult NDSFactory::writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
+bool NDSFactory::writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
 {
     std::ifstream sectionFile (sectionPath, std::ios::binary);
-    if (!sectionFile.is_open())
-		return NFResult({ false, "Error opening file: " + sectionPath });
-    
-    std::vector<char> dumpBuffer(size);
-    sectionFile.read (dumpBuffer.data(), size);
-    sectionFile.close();
-    return writeBytesToFile(dumpBuffer, savePath, startAddr, size);
+    if (sectionFile.is_open())
+    {
+        std::vector<char> dumpBuffer(size);
+        sectionFile.read (dumpBuffer.data(), size);
+        sectionFile.close();
+        return writeBytesToFile(dumpBuffer, savePath, startAddr, size);
+    }
+    return false;
 }
 
-NFResult NDSFactory::writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size)
+bool NDSFactory::writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size)
 {
     std::ofstream savedFile (savePath, std::ios::in | std::ios::out | std::ios::binary);
     if (!savedFile.is_open())
     {
         savedFile.open(savePath, std::ios::out | std::ios::binary);
         if (!savedFile.is_open()) {
-			return NFResult({ false, "Error creating file: " + savePath });
+            return false;
         }
         savedFile.close();
         savedFile.open(savePath, std::ios::in | std::ios::out | std::ios::binary);
         if (!savedFile.is_open())
-			return NFResult({ false, "Error opening file: " + savePath });
+            return false;
     }
 
     savedFile.seekp(startAddr);
     savedFile.write(byteBuffer.data(), size);
     savedFile.close();
-	return NFResult({ true, "" });
+    return true;
 }
 
 
-NFResult NDSFactory::writePaddingToFile(char paddingChar, const std::string& filePath, uint32_t startAddr, const uint32_t size)
+bool NDSFactory::writePaddingToFile(char paddingChar, const std::string& filePath, uint32_t startAddr, const uint32_t size)
 {
     std::vector<char> paddingBytes(size, paddingChar);
     return writeBytesToFile(paddingBytes, filePath, startAddr, size);
@@ -135,7 +148,7 @@ bool NDSFactory::checkArm9FooterPresence(const std::string& sectionPath, uint32_
     return false;
 }
 
-NFResult NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
+bool NDSFactory::extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
     const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs)
 {
     std::vector<char> fatDataBytes;
@@ -143,7 +156,7 @@ NFResult NDSFactory::extractFatData(const std::string& fatDataSectionPath, const
     std::vector<char> fntBytes;
 
     std::ifstream fatDataSectionFile(fatDataSectionPath, std::ios::in | std::ios::binary | std::ios::ate);
-    if (!fatDataSectionFile.is_open()) return NFResult({ false, "Error opening file: " + fatDataSectionPath });
+    if (!fatDataSectionFile.is_open()) return false;
     std::streamoff fatDataSectionSize = fatDataSectionFile.tellg();
     fatDataBytes.resize(fatDataSectionSize);
     fatDataSectionFile.seekg(0, std::ios::beg);
@@ -151,7 +164,7 @@ NFResult NDSFactory::extractFatData(const std::string& fatDataSectionPath, const
     fatDataSectionFile.close();
 
     std::ifstream fatSectionFile(fatSectionPath, std::ios::in | std::ios::binary | std::ios::ate);
-    if (!fatSectionFile.is_open()) return NFResult({ false, "Error opening file: " + fatSectionPath });
+    if (!fatSectionFile.is_open()) return false;
     std::streamoff fatSectionSize = fatSectionFile.tellg();
     fatBytes.resize(fatSectionSize);
     fatSectionFile.seekg(0, std::ios::beg);
@@ -159,7 +172,7 @@ NFResult NDSFactory::extractFatData(const std::string& fatDataSectionPath, const
     fatSectionFile.close();
 
     std::ifstream fntSectionFile(fntSectionPath, std::ios::in | std::ios::binary | std::ios::ate);
-    if (!fntSectionFile.is_open()) return NFResult({ false, "Error opening file: " + fntSectionPath });
+    if (!fntSectionFile.is_open()) return false;
     std::streamoff fntSectionSize = fntSectionFile.tellg();
     fntBytes.resize(fntSectionSize);
     fntSectionFile.seekg(0, std::ios::beg);
@@ -235,16 +248,16 @@ NFResult NDSFactory::extractFatData(const std::string& fatDataSectionPath, const
                 currentOffset += 2;
 
                 if (!std::filesystem::exists(newPath))
-					if (!std::filesystem::create_directory(newPath)) return NFResult({ false, "Error creating directory: " + newPath });
+                    if (!std::filesystem::create_directory(newPath)) return false;
 
                 if (logFileIDs)
                 {
 					std::string log = std::format("{:x}",subFolderId) + ":::" + newPath.substr(savePath.size()+1) + '\n';
-					if (!logToFile(savePath + "/_file_IDs.txt", log)) return NFResult({ false, "Error writing to file: " + savePath + "/_file_IDs.txt" });
+                    if (!logToFile(savePath + "/_file_IDs.txt", log)) return false;
                 }
 
                 // Jump back to the FNT header and repeat the process for subdirectory !
-                if (!parseFolder(subFolderId, newPath, parseFolder).result) return NFResult({ false, "Error parsing folder: " + newPath });
+                if (!parseFolder(subFolderId, newPath, parseFolder)) return false;
             }
             else
             {
@@ -254,31 +267,31 @@ NFResult NDSFactory::extractFatData(const std::string& fatDataSectionPath, const
 
                 uint32_t fileStartAddr = (pfatrange + fatOffset)->startAddr - originalFatDataAddr;
                 uint32_t fileSize = (pfatrange + fatOffset)->endAddr - (pfatrange + fatOffset)->startAddr;
-                if (!dumpDataFromFile(fatDataSectionPath, newPath, fileStartAddr, fileSize).result) return NFResult({ false, "Error dumping file: " + newPath });
+                if (!dumpDataFromFile(fatDataSectionPath, newPath, fileStartAddr, fileSize)) return false;
 
                 if (logFileIDs)
                 {
                     std::string log = std::format("{:x}", fatOffset) + ":::" + newPath.substr(savePath.size()+1) + '\n';
-					if (!logToFile(savePath + "/_file_IDs.txt", log)) return NFResult({ false, "Error writing to file: " + savePath + "/_file_IDs.txt" });
+                    if (!logToFile(savePath + "/_file_IDs.txt", log)) return false;
                 }
 				
                 fatOffset++;
             }
         }
 
-		return NFResult({ true, "" });
+        return true;
     };
 
     return parseFolder(ROOT_DIRECTORY_ADDRESS, savePath, parseFolder);
 }
 
-NFResult NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftSize, const std::string& savePath)
+bool NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftSize, const std::string& savePath)
 {
     std::vector<char> fatBytes;
 
     std::ifstream sectionFile (fatSectionPath, std::ios::in|std::ios::binary|std::ios::ate);
     if (!sectionFile.is_open())
-        return { false, "Error opening file: " + fatSectionPath };
+        return false;
 
     std::streamoff sectionSize = sectionFile.tellg();
     fatBytes.resize(sectionSize);
@@ -300,15 +313,15 @@ NFResult NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftS
     return writeBytesToFile(fatBytes, savePath, 0, static_cast<uint32_t>(sectionSize));
 }
 
-NFResult NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
+bool NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
 {
     std::vector<char> fatDataBytes;
     std::vector<FatRange> fat;
     std::vector<char> fntBytes;
 
     std::vector<FatFileID> fileIDs;
-    std::ifstream fileIDsFile(fatDataDirPath + "/_file_IDs.txt", std::ios::in);
-    if (!fileIDsFile.is_open()) return { false, "Error opening file: " + fatDataDirPath + "/_file_IDs.txt" };
+    std::ifstream fileIDsFile(fatDataDirPath + "/_file_IDs.txt", std::ios::in | std::ios::beg);
+    if (!fileIDsFile.is_open()) return false;
     std::string fileIDsLine;
     while (std::getline(fileIDsFile, fileIDsLine))
     {
@@ -330,8 +343,8 @@ NFResult NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::
         int firstFileId = fatFileID.id;
         if (firstFileId > 0)
         {
-            std::ifstream originalFatFile(originalFatPath, std::ios::in | std::ios::binary);
-            if (!originalFatFile.is_open()) return { false, "Error opening file: " + originalFatPath };
+            std::ifstream originalFatFile(originalFatPath, std::ios::in | std::ios::binary | std::ios::beg);
+            if (!originalFatFile.is_open()) return false;
             std::vector<char> ovrBytes;
             uint32_t requiredBytes = firstFileId * sizeof(FatRange);
             ovrBytes.resize(requiredBytes);
@@ -355,7 +368,7 @@ NFResult NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::
         fatRange.startAddr = fatDataAddr + static_cast<uint32_t>(fatDataBytes.size());
 
         std::ifstream currentFatDataFile(currentFile, std::ios::in | std::ios::binary | std::ios::ate);
-        if (!currentFatDataFile.is_open()) return NFResult({ false, "Error opening file: " + currentFile });
+		if (!currentFatDataFile.is_open()) return false;
         std::streamsize size = currentFatDataFile.tellg();
         currentFatDataFile.seekg(0, std::ios::beg);
 
@@ -364,26 +377,25 @@ NFResult NDSFactory::buildFatData(const std::string& fatDataDirPath, const std::
             fatDataBytes.insert(fatDataBytes.end(), buffer.begin(), buffer.end());
         else
         {
-            currentFatDataFile.close();
-            return NFResult({ false, "Error reading file: " + currentFile });
+			currentFatDataFile.close();
+			return false;
         }
         currentFatDataFile.close();
 
         fatRange.endAddr = fatDataAddr + static_cast<uint32_t>(fatDataBytes.size());
-        fat.push_back(fatRange);
+		fat.push_back(fatRange);
     }
 
-
+   
     const char* fat_ptr = reinterpret_cast<const char*>(fat.data());
     std::vector<char> fatBytes(fat_ptr, fat_ptr + fat.size() * sizeof(FatRange));
     std::remove((savePath + "/fat_data.bin").c_str());
     std::remove((savePath + "/fat.bin").c_str());
-    if (!writeBytesToFile(fatDataBytes, savePath + "/fat_data.bin", 0, static_cast<uint32_t>(fatDataBytes.size())).result)
-        return NFResult({ false, "Error writing to file: " + savePath + "/fat_data.bin" });
-    if (!writeBytesToFile(fatBytes, savePath + "/fat.bin", 0, static_cast<uint32_t>(fatBytes.size())).result)
-        return NFResult({ false, "Error writing to file: " + savePath + "/fat.bin" });
+    bool res = true;
+    res &= writeBytesToFile(fatDataBytes, savePath + "/fat_data.bin", 0, static_cast<uint32_t>(fatDataBytes.size()));
+	res &= writeBytesToFile(fatBytes, savePath + "/fat.bin", 0, static_cast<uint32_t>(fatBytes.size()));
+    return res;
 
-    return NFResult({ true, "" });
 }
 
 uint16_t NDSFactory::calcHeaderCrc16(const std::vector<char>& romHeader)

ndsfactory/ndsfactory.h

@@ -5,28 +5,29 @@
 #include <cstdint>
 #include "ndsheader.h"
 #include "fatstruct.h"
-#include "nfresult.h"
+
 
 
 class NDSFactory
 {
 public:
-    NFResult loadRomHeader(const std::string& romPath, std::vector<char>& header);
-    NFResult dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size);
-    NFResult readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size);
-    NFResult writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size);
-    NFResult writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size);
-    NFResult writePaddingToFile(char paddingChar, const std::string& savePath, uint32_t startAddr, uint32_t size);
+    NDSFactory();
+    bool loadRomHeader(const std::string& romPath, std::vector<char>& header);
+    bool dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size);
+    bool logToFile(const std::string& logPath, const std::string& log);
+    bool readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size);
+    bool writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size);
+    bool writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size);
+    bool writePaddingToFile(char paddingChar, const std::string& savePath, uint32_t startAddr, uint32_t size);
     int getCardSizeInBytes(int cardType);
     bool checkArm9FooterPresence(const std::string& sectionPath, uint32_t size);
-    NFResult extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
+    bool extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
         const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs);
-    NFResult patchFat(const std::string& sectionPath, uint32_t shiftSize, const std::string& savePath);
-    NFResult buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath);
+    bool patchFat(const std::string& sectionPath, uint32_t shiftSize, const std::string& savePath);
+	bool buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath);
     uint16_t calcHeaderCrc16(const std::vector<char>& romHeader);
 
 private:
-    bool logToFile(const std::string& logPath, const std::string& log);
 
 };
 

ndsfactory/nfresult.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include <string>
-
-struct NFResult
-{
-	bool result;
-	std::string message;
-};

ui/dialogs/about/aboutdialog.ui

@@ -42,7 +42,7 @@
     <bool>false</bool>
    </property>
    <property name="text">
-    <string>NDSFactory V1.3.1</string>
+    <string>NDSFactory V1.2</string>
    </property>
    <property name="alignment">
     <set>Qt::AlignmentFlag::AlignCenter</set>

ui/dialogs/about/revision.h

@@ -1,6 +1,6 @@
 #ifndef REVISION_H
 #define REVISION_H
 
-#define GIT_COMMIT_HASH "c916f47"
+#define GIT_COMMIT_HASH "f46e527"
 
 #endif

ui/mainwindow.h

@@ -69,48 +69,48 @@ private:
     void populateHeader(NDSHeader* ndsHeader);
     void enableExtractionButtons();
     void disableExtractionButtons();
-    NFResult dumpHeader(const std::string& dirPath);
-    NFResult dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes);
-    NFResult dumpArm7Bin(const std::string& dirPath);
-    NFResult dumpFnt(const std::string& dirPath);
-    NFResult dumpFat(const std::string& dirPath);
-    NFResult dumpArm9Overlay(const std::string& dirPath);
-    NFResult dumpArm9OverlayFiles(const std::string& dirPath);
-    NFResult dumpArm7Overlay(const std::string& dirPath);
-    NFResult dumpArm7OverlayFiles(const std::string& dirPath);
-    NFResult dumpIconTitle(const std::string& dirPath);
-    NFResult dumpFatFiles(const std::string& dirPath);
-    NFResult dumpEverything(QString dirPath);
+    bool dumpHeader(const std::string& dirPath);
+    bool dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes);
+    bool dumpArm7Bin(const std::string& dirPath);
+    bool dumpFnt(const std::string& dirPath);
+    bool dumpFat(const std::string& dirPath);
+    bool dumpArm9Overlay(const std::string& dirPath);
+    bool dumpArm9OverlayFiles(const std::string& dirPath);
+    bool dumpArm7Overlay(const std::string& dirPath);
+    bool dumpArm7OverlayFiles(const std::string& dirPath);
+    bool dumpIconTitle(const std::string& dirPath);
+    bool dumpFatFiles(const std::string& dirPath);
+    bool dumpEverything(QString dirPath);
 
     void populatePackerSectionHeader(NDSHeader *ndsHeader);
     void enableCalcCrcButton();
     void enableBuildRomButton();
     void generateHeader(NDSHeader* pRomHeader);
-    NFResult writeHeader(const std::string& savePath);
+    bool writeHeader(const std::string& savePath);
     void calcHeaderCrc16();
-    NFResult writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent);
-    NFResult writeArm7Bin(const std::string& savePath);
-    NFResult writeFnt(const std::string& savePath);
-    NFResult writeFat(const std::string& savePath);
-    NFResult writeArm9Overlay(const std::string& savePath);
-    NFResult writeArm9OverlayFiles(const std::string& savePath);
-    NFResult writeArm7Overlay(const std::string& savePath);
-    NFResult writeArm7OverlayFiles(const std::string& savePath);
-    NFResult writeIconTitle(const std::string& savePath);
-    NFResult writeFatFiles(const std::string& savePath);
-    NFResult writeEverything(const std::string& savePath);
+    bool writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent);
+    bool writeArm7Bin(const std::string& savePath);
+    bool writeFnt(const std::string& savePath);
+    bool writeFat(const std::string& savePath);
+    bool writeArm9Overlay(const std::string& savePath);
+    bool writeArm9OverlayFiles(const std::string& savePath);
+    bool writeArm7Overlay(const std::string& savePath);
+    bool writeArm7OverlayFiles(const std::string& savePath);
+    bool writeIconTitle(const std::string& savePath);
+    bool writeFatFiles(const std::string& savePath);
+    bool writeEverything(const std::string& savePath);
 
-    NFResult writeHeaderPadding(char paddingByte, const std::string& savePath);
-    NFResult writeArm9BinPadding(char paddingByte, const std::string& savePath, bool isArm9FooterPresent);
-    NFResult writeArm7BinPadding(char paddingByte, const std::string& savePath);
-    NFResult writeFntPadding(char paddingByte, const std::string& savePath);
-    NFResult writeFatPadding(char paddingByte, const std::string& savePath);
-    NFResult writeRomPadding(const std::string& savePath);
+    bool writeHeaderPadding(char paddingByte, const std::string& savePath);
+    bool writeArm9BinPadding(char paddingByte, const std::string& savePath, bool isArm9FooterPresent);
+    bool writeArm7BinPadding(char paddingByte, const std::string& savePath);
+    bool writeFntPadding(char paddingByte, const std::string& savePath);
+    bool writeFatPadding(char paddingByte, const std::string& savePath);
+    bool writeRomPadding(const std::string& savePath);
 
     QString extractPackerHeaderTableData(int index);
 
-    NFResult extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
+    bool extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
         const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs);
-    NFResult patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath);
-    NFResult buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath);
+    bool patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath);
+	bool buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath);
 };

ui/tabs/fattools/fattoolstabfunctions.cpp

@@ -2,18 +2,19 @@
 #include "./../../mainwindow.h"
 
 
-NFResult MainWindow::extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
+bool MainWindow::extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
     const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs)
 {
     return ndsFactory.extractFatData(fatDataSectionPath, fatSectionPath, fntSectionPath, originalFatDataAddr, savePath, logFileIDs);
 }
 
-NFResult MainWindow::patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath)
+bool MainWindow::patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath)
 {
     return ndsFactory.patchFat(loadPath, shiftSize, savePath);
 }
 
-NFResult MainWindow::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
+bool MainWindow::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
 {
+    if (!std::filesystem::exists(fatDataDirPath + "/_file_IDs.txt")) return false;
 	return ndsFactory.buildFatData(fatDataDirPath, originalFatPath, fatDataAddr, savePath);
 }

ui/tabs/fattools/fattoolstabsignals.cpp

@@ -55,16 +55,14 @@ void MainWindow::on_fatExtractorExtractBtn_clicked()
         "",
         QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
 
-    if (!dirPath.isNull()) {
-        NFResult nfResult = extractFatData(ui->fatExtractorFatDataPathEdt->text().toStdString(),
+    if (!dirPath.isNull())
+        extractFatData(ui->fatExtractorFatDataPathEdt->text().toStdString(),
             ui->fatExtractorFatPathEdt->text().toStdString(),
             ui->fatExtractorFntPathEdt->text().toStdString(),
             ui->fatExtractorOriginalFatFilesAddrEdt->text().toUInt(nullptr, 16),
             dirPath.toStdString(),
-            ui->fatExtractorSaveFileIDsCbx->isChecked());
-        nfResult.result? QMessageBox::information(this, tr("NDSFactory"), tr("FAT files extraction completed!"))
-            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
-    }
+            ui->fatExtractorSaveFileIDsCbx->isChecked()) ? QMessageBox::information(this, tr("NDSFactory"), tr("FAT files extraction completed!"))
+        : QMessageBox::critical(this, tr("NDSFactory"), tr("Error extracting FAT files!"));
 
     ui->fatExtractorExtractBtn->setEnabled(true);
 
@@ -101,9 +99,9 @@ void MainWindow::on_fatPatcherPatchFatBtn_clicked()
         else
             positionDiff = originalPos - newPos;
 
-        NFResult nfResult = patchFat(ui->fatPatcherFatPathEdt->text().toStdString(), positionDiff, dirPath.toStdString());
-        nfResult.result ? QMessageBox::information(this, tr("NDSFactory"), tr("FAT patching completed!"))
-            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
+        patchFat(ui->fatPatcherFatPathEdt->text().toStdString(), positionDiff, dirPath.toStdString())
+            ? QMessageBox::information(this, tr("NDSFactory"), tr("FAT patching completed!"))
+            : QMessageBox::critical(this, tr("NDSFactory"), tr("Error patching FAT!"));
     }
 
     ui->fatPatcherPatchFatBtn->setEnabled(true);
@@ -142,14 +140,11 @@ void MainWindow::on_fatBuilderBuildBtn_clicked()
         QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
 
     if (!dirPath.isNull())
-    {
-        NFResult nfResult = buildFatData(ui->fatBuilderFatDirPathEdt->text().toStdString(),
-            ui->fatBuilderOriginalFatPathEdt->text().toStdString(),
+        buildFatData(ui->fatBuilderFatDirPathEdt->text().toStdString(),
+			ui->fatBuilderOriginalFatPathEdt->text().toStdString(),
             ui->fatBuilderFatAddrEdt->text().toUInt(nullptr, 16),
-            dirPath.toStdString());
-        nfResult.result? QMessageBox::information(this, tr("NDSFactory"), tr("fat_data.bin and fat.bin correctly built!"))
-            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
-    }
+            dirPath.toStdString()) ? QMessageBox::information(this, tr("NDSFactory"), tr("fat_data.bin and fat.bin correctly built!"))
+        : QMessageBox::critical(this, tr("NDSFactory"), tr("Error building FAT!"));
 
     ui->fatBuilderOpenFatDataDirBtn->setEnabled(true);
 }

ui/tabs/packer/packertabfunctions.cpp

@@ -102,17 +102,17 @@ void MainWindow::calcHeaderCrc16()
     ui->packerHeaderDataTable->model()->setData(headerCrcIndex, QString::number(ndsFactory.calcHeaderCrc16(romHeaderBuffer), 16), Qt::EditRole);
 }
 
-NFResult MainWindow::writeHeader(const std::string& savePath)
+bool MainWindow::writeHeader(const std::string& savePath)
 {
     std::vector<char> romHeaderBuffer(sizeof(NDSHeader));
     NDSHeader* pRomHeader = reinterpret_cast<NDSHeader*>(romHeaderBuffer.data());
 
     generateHeader(pRomHeader);
 
-    return ndsFactory.writeBytesToFile(romHeaderBuffer, savePath, 0, sizeof(NDSHeader));
+    return ndsFactory.writeBytesToFile(romHeaderBuffer, savePath, 0, sizeof(NDSHeader));;
 }
 
-NFResult MainWindow::writeHeaderPadding(char paddingType, const std::string& savePath)
+bool MainWindow::writeHeaderPadding(char paddingType, const std::string& savePath)
 {
     uint32_t startAddr = sizeof(NDSHeader);
     uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16) - startAddr;
@@ -124,7 +124,7 @@ NFResult MainWindow::writeHeaderPadding(char paddingType, const std::string& sav
         size);
 }
 
-NFResult MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent)
+bool MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent)
 {
     uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16);
     if (isArm9FooterPresent)
@@ -137,7 +137,7 @@ NFResult MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9Footer
 }
 
 
-NFResult MainWindow::writeArm9BinPadding(char paddingType, const std::string& savePath, bool isFooterPresent)
+bool MainWindow::writeArm9BinPadding(char paddingType, const std::string& savePath, bool isFooterPresent)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16);
@@ -160,7 +160,7 @@ NFResult MainWindow::writeArm9BinPadding(char paddingType, const std::string& sa
         size);
 }
 
-NFResult MainWindow::writeArm9Overlay(const std::string& savePath)
+bool MainWindow::writeArm9Overlay(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
         ui->loadedArm9OverlayPathEdt->text().toStdString(),
@@ -169,7 +169,7 @@ NFResult MainWindow::writeArm9Overlay(const std::string& savePath)
         extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16));
 }
 
-NFResult MainWindow::writeArm9OverlayFiles(const std::string& savePath)
+bool MainWindow::writeArm9OverlayFiles(const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16);
@@ -181,7 +181,7 @@ NFResult MainWindow::writeArm9OverlayFiles(const std::string& savePath)
         size);
 }
 
-NFResult MainWindow::writeArm7Bin(const std::string& savePath)
+bool MainWindow::writeArm7Bin(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedArm7BinPathEdt->text().toStdString(),
@@ -190,7 +190,7 @@ NFResult MainWindow::writeArm7Bin(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16));
 }
 
-NFResult MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePath)
+bool MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16);
@@ -207,7 +207,7 @@ NFResult MainWindow::writeArm7BinPadding(char paddingType, const std::string& sa
         size);
 }
 
-NFResult MainWindow::writeArm7Overlay(const std::string& savePath)
+bool MainWindow::writeArm7Overlay(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
         ui->loadedArm7OverlayPathEdt->text().toStdString(),
@@ -216,7 +216,7 @@ NFResult MainWindow::writeArm7Overlay(const std::string& savePath)
         extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlaySize).toUInt(nullptr, 16));
 }
 
-NFResult MainWindow::writeArm7OverlayFiles(const std::string& savePath)
+bool MainWindow::writeArm7OverlayFiles(const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlaySize).toUInt(nullptr, 16);
@@ -228,7 +228,7 @@ NFResult MainWindow::writeArm7OverlayFiles(const std::string& savePath)
         size);
 }
 
-NFResult MainWindow::writeFnt(const std::string& savePath)
+bool MainWindow::writeFnt(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedFntPathEdt->text().toStdString(),
@@ -237,7 +237,7 @@ NFResult MainWindow::writeFnt(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16));
 }
 
-NFResult MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
+bool MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16);
@@ -250,7 +250,7 @@ NFResult MainWindow::writeFntPadding(char paddingType, const std::string& savePa
         size);
 }
 
-NFResult MainWindow::writeFat(const std::string& savePath)
+bool MainWindow::writeFat(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedFatPathEdt->text().toStdString(),
@@ -259,7 +259,7 @@ NFResult MainWindow::writeFat(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16));
 }
 
-NFResult MainWindow::writeFatPadding(char paddingType, const std::string& savePath)
+bool MainWindow::writeFatPadding(char paddingType, const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::FATAddress).toUInt(nullptr, 16) +
         extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16);
@@ -272,7 +272,7 @@ NFResult MainWindow::writeFatPadding(char paddingType, const std::string& savePa
         size);
 }
 
-NFResult MainWindow::writeIconTitle(const std::string& savePath)
+bool MainWindow::writeIconTitle(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedIconTitlePathEdt->text().toStdString(),
@@ -281,7 +281,7 @@ NFResult MainWindow::writeIconTitle(const std::string& savePath)
                 IconTitleSize);
 }
 
-NFResult MainWindow::writeFatFiles(const std::string& savePath)
+bool MainWindow::writeFatFiles(const std::string& savePath)
 {
     uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::IconTitleAddress).toUInt(nullptr, 16) + IconTitleSize;
     uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::UsedRomSize).toUInt(nullptr, 16) - startAddr;
@@ -293,7 +293,7 @@ NFResult MainWindow::writeFatFiles(const std::string& savePath)
                 size);
 }
 
-NFResult MainWindow::writeRomPadding(const std::string& savePath)
+bool MainWindow::writeRomPadding(const std::string& savePath)
 {
      uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::UsedRomSize).toUInt(nullptr, 16);
      uint32_t size = static_cast<uint32_t>(ndsFactory.getCardSizeInBytes(extractPackerHeaderTableData(NDSHeaderNames::CardSize).toInt())) - startAddr;
@@ -305,9 +305,9 @@ NFResult MainWindow::writeRomPadding(const std::string& savePath)
                  size);
 }
 
-NFResult MainWindow::writeEverything(const std::string& savePath)
+bool MainWindow::writeEverything(const std::string& savePath)
 {
-	NFResult nfResult;
+    bool res = true;
     char paddingType;
     bool isArm9FooterPresent = ndsFactory.checkArm9FooterPresence(ui->loadedArm9BinPathEdt->text().toStdString(),
         extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16));
@@ -318,49 +318,32 @@ NFResult MainWindow::writeEverything(const std::string& savePath)
 
     std::remove(savePath.c_str());
 
-    nfResult = writeHeader(savePath);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeHeaderPadding(paddingType, savePath);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeArm9Bin(savePath, isArm9FooterPresent);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeArm9BinPadding(paddingType, savePath, isArm9FooterPresent);
-    if (!nfResult.result) return nfResult;
+    res &= writeHeader(savePath);
+    res &= writeHeaderPadding(paddingType, savePath);
+    res &= writeArm9Bin(savePath, isArm9FooterPresent);
+    res &= writeArm9BinPadding(paddingType, savePath, isArm9FooterPresent);
     if (extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) != 0)
     {
-        nfResult = writeArm9Overlay(savePath);
-        if (!nfResult.result) return nfResult;
-        nfResult = writeArm9OverlayFiles(savePath);
-        if (!nfResult.result) return nfResult;
+        res &= writeArm9Overlay(savePath);
+        res &= writeArm9OverlayFiles(savePath);
     }
-    nfResult = writeArm7Bin(savePath);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeArm7BinPadding(paddingType, savePath);
-    if (!nfResult.result) return nfResult;
+    res &= writeArm7Bin(savePath);
+    res &= writeArm7BinPadding(paddingType, savePath);
     if (extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16) != 0) {
-        nfResult = writeArm7Overlay(savePath);
-        if (!nfResult.result) return nfResult;
-        nfResult = writeArm7OverlayFiles(savePath);
-        if (!nfResult.result) return nfResult;
+        res &= writeArm7Overlay(savePath);
+        res &= writeArm7OverlayFiles(savePath);
     }
-    nfResult = writeFnt(savePath);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeFntPadding(paddingType, savePath);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeFat(savePath);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeFatPadding(paddingType, savePath);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeIconTitle(savePath);
-    if (!nfResult.result) return nfResult;
-    nfResult = writeFatFiles(savePath);
-    if (!nfResult.result) return nfResult;
+    res &= writeFnt(savePath);
+    res &= writeFntPadding(paddingType, savePath);
+    res &= writeFat(savePath);
+    res &= writeFatPadding(paddingType, savePath);
+    res &= writeIconTitle(savePath);
+    res &= writeFatFiles(savePath);
     if(!ui->packerTrimRomsCbx->isChecked())
     {
-        nfResult = writeRomPadding(savePath);
-        if (!nfResult.result) return nfResult;
+        res &= writeRomPadding(savePath);
     }
-	return { true, "" };
+    return res;
 }
 
 QString MainWindow::extractPackerHeaderTableData(int index)

ui/tabs/packer/packertabsignals.cpp

@@ -16,9 +16,13 @@ void MainWindow::on_packerLoadHeaderBtn_clicked()
           QDir::currentPath(),
           "NDS Header (*.bin)");
 
-    if (headerPath.isNull()) return;
+    if(headerPath.isNull())
+    {
+        QMessageBox::critical(this, tr("NDSFactory"), tr("Unable to open file!"));
+        return;
+    }
 
-    if (ndsFactory.loadRomHeader(headerPath.toStdString(), romHeader).result)
+    if (ndsFactory.loadRomHeader(headerPath.toStdString(), romHeader))
     {
         pNDSHeader = reinterpret_cast<NDSHeader*>(romHeader.data());
         populatePackerSectionHeader(pNDSHeader);
@@ -176,11 +180,9 @@ void MainWindow::on_packerBuildNDSRomBtn_clicked()
         "NDS ROM (*.nds)");
 
     if (!dirPath.isNull())
-    {
-        NFResult nfResult = writeEverything(dirPath.toStdString());
-        nfResult.result? QMessageBox::information(this, tr("NDSFactory"), tr("Creation completed!"))
-            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
-    }
+        writeEverything(dirPath.toStdString()) ? QMessageBox::information(this, tr("NDSFactory"), tr("Creation completed!"))
+                                               : QMessageBox::critical(this, tr("NDSFactory"), tr("Error during the creation!"));
+
     ui->packerBuildNDSRomBtn->setEnabled(true);
 }
 

ui/tabs/unpacker/unpackertabfunctions.cpp

@@ -51,7 +51,7 @@ void MainWindow::disableExtractionButtons()
     ui->unpackerExtraGbx->setEnabled(false);
 }
 
-NFResult MainWindow::dumpHeader(const std::string& dirPath)
+bool MainWindow::dumpHeader(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -60,7 +60,7 @@ NFResult MainWindow::dumpHeader(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::HeaderSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-NFResult MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes)
+bool MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes)
 {
     uint32_t size = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9Size, 1).data().toString().toUInt(nullptr,16);
     if (dumpExtraBytes)
@@ -72,7 +72,7 @@ NFResult MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes
                 size);
 }
 
-NFResult MainWindow::dumpArm7Bin(const std::string& dirPath)
+bool MainWindow::dumpArm7Bin(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -81,7 +81,7 @@ NFResult MainWindow::dumpArm7Bin(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7Size, 1).data().toString().toUInt(nullptr,16));
 }
 
-NFResult MainWindow::dumpFnt(const std::string& dirPath)
+bool MainWindow::dumpFnt(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -90,7 +90,7 @@ NFResult MainWindow::dumpFnt(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FilenameTableSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-NFResult MainWindow::dumpFat(const std::string& dirPath)
+bool MainWindow::dumpFat(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -99,7 +99,7 @@ NFResult MainWindow::dumpFat(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FATSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-NFResult MainWindow::dumpArm9Overlay(const std::string& dirPath)
+bool MainWindow::dumpArm9Overlay(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -108,7 +108,7 @@ NFResult MainWindow::dumpArm9Overlay(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlaySize, 1).data().toString().toUInt(nullptr,16));
 }
 
-NFResult MainWindow::dumpArm9OverlayFiles(const std::string& dirPath)
+bool MainWindow::dumpArm9OverlayFiles(const std::string& dirPath)
 {
     uint32_t startAddr = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr, 16) +
         ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlaySize, 1).data().toString().toUInt(nullptr, 16);
@@ -121,7 +121,7 @@ NFResult MainWindow::dumpArm9OverlayFiles(const std::string& dirPath)
         size);
 }
 
-NFResult MainWindow::dumpArm7Overlay(const std::string& dirPath)
+bool MainWindow::dumpArm7Overlay(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -130,7 +130,7 @@ NFResult MainWindow::dumpArm7Overlay(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlaySize, 1).data().toString().toUInt(nullptr,16));
 }
 
-NFResult MainWindow::dumpArm7OverlayFiles(const std::string& dirPath)
+bool MainWindow::dumpArm7OverlayFiles(const std::string& dirPath)
 {
     uint32_t startAddr = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr, 16) +
         ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlaySize, 1).data().toString().toUInt(nullptr, 16);
@@ -143,7 +143,7 @@ NFResult MainWindow::dumpArm7OverlayFiles(const std::string& dirPath)
         size);
 }
 
-NFResult MainWindow::dumpIconTitle(const std::string& dirPath)
+bool MainWindow::dumpIconTitle(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -152,7 +152,7 @@ NFResult MainWindow::dumpIconTitle(const std::string& dirPath)
                 ICON_TITLE_SIZE);
 }
 
-NFResult MainWindow::dumpFatFiles(const std::string& dirPath)
+bool MainWindow::dumpFatFiles(const std::string& dirPath)
 {
     uint32_t startAddr = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::IconTitleAddress, 1).data().toString().toUInt(nullptr,16) + IconTitleSize ;
     uint32_t size = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::UsedRomSize, 1).data().toString().toUInt(nullptr,16) - startAddr;
@@ -165,34 +165,23 @@ NFResult MainWindow::dumpFatFiles(const std::string& dirPath)
 }
 
 
-NFResult MainWindow::dumpEverything(QString dirPath)
+bool MainWindow::dumpEverything(QString dirPath)
 {
-    NFResult nfResult;
-    nfResult = dumpHeader(QDir::toNativeSeparators(dirPath + "/header.bin").toStdString());
-	if (!nfResult.result) return nfResult;
-    nfResult = dumpArm9Bin(QDir::toNativeSeparators(dirPath+"/arm9.bin").toStdString(), true);
-    if (!nfResult.result) return nfResult;
-    nfResult = dumpArm7Bin(QDir::toNativeSeparators(dirPath+"/arm7.bin").toStdString());
-    if (!nfResult.result) return nfResult;
-    nfResult = dumpFnt(QDir::toNativeSeparators(dirPath+"/fnt.bin").toStdString());
-    if (!nfResult.result) return nfResult;
-    nfResult = dumpFat(QDir::toNativeSeparators(dirPath+"/fat.bin").toStdString());
-    if (!nfResult.result) return nfResult;
+    bool result = true;
+    result &= dumpHeader(QDir::toNativeSeparators(dirPath+"/header.bin").toStdString());
+    result &= dumpArm9Bin(QDir::toNativeSeparators(dirPath+"/arm9.bin").toStdString(), true);
+    result &= dumpArm7Bin(QDir::toNativeSeparators(dirPath+"/arm7.bin").toStdString());
+    result &= dumpFnt(QDir::toNativeSeparators(dirPath+"/fnt.bin").toStdString());
+    result &= dumpFat(QDir::toNativeSeparators(dirPath+"/fat.bin").toStdString());
     if(ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr,16) != 0) {
-        nfResult = dumpArm9Overlay(QDir::toNativeSeparators(dirPath+"/a9ovr.bin").toStdString());
-        if (!nfResult.result) return nfResult;
-        nfResult = dumpArm9OverlayFiles(QDir::toNativeSeparators(dirPath+"/a9ovr_data.bin").toStdString());
-        if (!nfResult.result) return nfResult;
+		result &= dumpArm9Overlay(QDir::toNativeSeparators(dirPath+"/a9ovr.bin").toStdString());
+		result &= dumpArm9OverlayFiles(QDir::toNativeSeparators(dirPath+"/a9ovr_data.bin").toStdString());
 	}
     if(ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr,16) != 0) {
-        nfResult = dumpArm7Overlay(QDir::toNativeSeparators(dirPath+"/a7ovr.bin").toStdString());
-        if (!nfResult.result) return nfResult;
-        nfResult = dumpArm7OverlayFiles(QDir::toNativeSeparators(dirPath+"/a7ovr_data.bin").toStdString());
-        if (!nfResult.result) return nfResult;
-    }
-    nfResult = dumpIconTitle(QDir::toNativeSeparators(dirPath+"/itl.bin").toStdString());
-    if (!nfResult.result) return nfResult;
-    nfResult = dumpFatFiles(QDir::toNativeSeparators(dirPath+"/fat_data.bin").toStdString());
-    if (!nfResult.result) return nfResult;
-	return { true, "" };
+        result &= dumpArm7Overlay(QDir::toNativeSeparators(dirPath+"/a7ovr.bin").toStdString());
+        result &= dumpArm7OverlayFiles(QDir::toNativeSeparators(dirPath+"/a7ovr_data.bin").toStdString());
+        }
+    result &= dumpIconTitle(QDir::toNativeSeparators(dirPath+"/itl.bin").toStdString());
+    result &= dumpFatFiles(QDir::toNativeSeparators(dirPath+"/fat_data.bin").toStdString());
+    return result;
 }

ui/tabs/unpacker/unpackertabsignals.cpp

@@ -17,11 +17,12 @@ void MainWindow::on_loadRomBtn_clicked()
           QDir::currentPath(),
           "NDS Rom (*.nds)");
 
-    if (romPath.isNull()) return;
+    if( !romPath.isNull() )
+    {
+      ui->loadedRomPath->setText(romPath.toUtf8());
+    }
 
-    ui->loadedRomPath->setText(romPath.toUtf8());
-
-    if (ndsFactory.loadRomHeader(ui->loadedRomPath->text().toStdString(), romHeader).result)
+    if (ndsFactory.loadRomHeader(ui->loadedRomPath->text().toStdString(), romHeader))
     {
         pNDSHeader = reinterpret_cast<NDSHeader*>(romHeader.data());
         populateHeader(pNDSHeader);
@@ -39,7 +40,8 @@ void MainWindow::on_unpackerDumpHeaderBtn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS Header", "header.bin", "Binary (*.bin)");
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpHeader(dirPath.toStdString()));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpHeader(dirPath.toStdString()));
 
 	ui->unpackerDumpHeaderBtn->setEnabled(true);
 }
@@ -56,7 +58,8 @@ void MainWindow::on_unpackerDumpArm9Btn_clicked()
                 "Do you want to dump the extra 12 bytes? (click yes if you want a 1:1 arm9 dump)",
                 QMessageBox::Yes|QMessageBox::No);
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpArm9Bin(dirPath.toStdString(), dumpExtraBytes == QMessageBox::Yes ? true : false));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpArm9Bin(dirPath.toStdString(), dumpExtraBytes == QMessageBox::Yes ? true : false));
 
 	ui->unpackerDumpArm9Btn->setEnabled(true);
 }
@@ -67,7 +70,8 @@ void MainWindow::on_unpackerDumpArm7Btn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS ARM7", "arm7.bin", "Binary (*.bin)");
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpArm7Bin(dirPath.toStdString()));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpArm7Bin(dirPath.toStdString()));
 
 	ui->unpackerDumpArm7Btn->setEnabled(true);
 }
@@ -78,7 +82,8 @@ void MainWindow::on_unpackerDumpFntBtn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS FNT", "fnt.bin", "Binary (*.bin)");
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpFnt(dirPath.toStdString()));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpFnt(dirPath.toStdString()));
 
 	ui->unpackerDumpFntBtn->setEnabled(true);
 }
@@ -89,7 +94,8 @@ void MainWindow::on_unpackerDumpFatBtn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS FAT", "fat.bin", "Binary (*.bin)");
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpFat(dirPath.toStdString()));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpFat(dirPath.toStdString()));
 
 	ui->unpackerDumpFatBtn->setEnabled(true);
 }
@@ -100,7 +106,8 @@ void MainWindow::on_unpackerDumpArm9OverlayBtn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS ARM9 Overlay", "a9ovr.bin", "Binary (*.bin)");
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpArm9Overlay(dirPath.toStdString()));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpArm9Overlay(dirPath.toStdString()));
 
 	ui->unpackerDumpArm9OverlayBtn->setEnabled(true);
 }
@@ -111,7 +118,8 @@ void MainWindow::on_unpackerDumpArm7OverlayBtn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS ARM7 Overlay", "a7ovr.bin", "Binary (*.bin)");
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpArm7Overlay(dirPath.toStdString()));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpArm7Overlay(dirPath.toStdString()));
 
 	ui->unpackerDumpArm7OverlayBtn->setEnabled(true);
 }
@@ -122,7 +130,8 @@ void MainWindow::on_unpackerDumpIconTitleLogoBtn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS IconTitleLogo", "itl.bin", "Binary (*.bin)");
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpIconTitle(dirPath.toStdString()));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpIconTitle(dirPath.toStdString()));
 
 	ui->unpackerDumpIconTitleLogoBtn->setEnabled(true);
 }
@@ -133,7 +142,8 @@ void MainWindow::on_unpackerDumpFatFilesBtn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS FAT Files", "fat_data.bin", "Binary (*.bin)");
 
-    if (!dirPath.isNull()) notifyExtractionResult(dumpFatFiles(dirPath.toStdString()));
+    if (!dirPath.isNull())
+        notifyExtractionResult(dumpFatFiles(dirPath.toStdString()));
 
 	ui->unpackerDumpFatFilesBtn->setEnabled(true);
 }
@@ -144,7 +154,8 @@ void MainWindow::on_unpackerDumpArm9OverlayFilesBtn_clicked()
 
     QString dirPath = customSaveFileDialog("NDS ARM9 Overlay Data", "a9ovr_data.bin", "Binary (*.bin)");
 
-	if (!dirPath.isNull()) notifyExtractionResult(dumpArm9OverlayFiles(dirPath.toStdString()));
+	if (!dirPath.isNull())
+		notifyExtractionResult(dumpArm9OverlayFiles(dirPath.toStdString()));
 
 	ui->unpackerDumpArm9OverlayFilesBtn->setEnabled(true);
 }

ui/utils/ui.h

@@ -1,16 +1,15 @@
 #pragma once
 
 #include <QMessageBox>
-#include "../../ndsfactory/nfresult.h"
 
-void notifyExtractionResult(NFResult nfResult)
+void notifyExtractionResult(bool result)
 {
-	if (nfResult.result)
+	if (result)
 	{
 		QMessageBox::information(Q_NULLPTR, "NDSFactory", "Extraction completed!");
 	}
 	else
 	{
-		QMessageBox::critical(Q_NULLPTR, "NDSFactory", nfResult.message.c_str());
+		QMessageBox::critical(Q_NULLPTR, "NDSFactory", "Error during the extraction!");
 	}
 }