Bump to v1.3.2

* Update build configuration for macOS

* remove -dmg  param from macos build

.github/workflows/build.yml

@@ -7,124 +7,148 @@ on:
 
 jobs:
   build-linux:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
 
     steps:
-    - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.1.7
 
-    - name: Create Build Environment
+      - name: Create Build Environment
-      run: |
+        run: |
-        sudo apt-get update
+          sudo apt-get update
-        sudo apt-get install -y build-essential libgl1-mesa-dev and libglvnd-dev cmake qt6-base-dev
+          sudo apt-get install -y build-essential libgl1-mesa-dev libglvnd-dev cmake qt6-base-dev
-        mkdir build
+          mkdir build
 
-    - name: Configure CMake
+      - name: Configure CMake
-      working-directory: ${{github.workspace}}/build
+        working-directory: ${{github.workspace}}/build
-      shell: bash
+        shell: bash
-      run: |
+        run: |
-        cmake -DCMAKE_BUILD_TYPE=Release ..
+          cmake -DCMAKE_BUILD_TYPE=Release ..
 
-    - name: Build
+      - name: Build
-      working-directory: ${{github.workspace}}/build
+        working-directory: ${{github.workspace}}/build
-      shell: bash
+        shell: bash
-      run: |
+        run: |
-        make -j4
+          make -j4
 
-    - name: Archive Artifact
+      - name: Archive Artifact
-      working-directory: ${{github.workspace}}/build
+        working-directory: ${{github.workspace}}/build
-      shell: bash
+        shell: bash
-      run: |
+        run: |
-        tar -czvf NDSFactory-${{ github.ref_name }}-Linux-x64.tar.gz NDSFactory ../README.md ../LICENSE
+          tar -czvf NDSFactory-${{ github.ref_name }}-Linux-x64.tar.gz NDSFactory ../README.md ../LICENSE
 
-    - name: Release on GitHub
+      - name: Release on GitHub
-      uses: softprops/action-gh-release@v2.0.8
+        uses: softprops/action-gh-release@v2.0.8
-      if: startsWith(github.ref, 'refs/tags/')
+        if: startsWith(github.ref, 'refs/tags/')
-      with:
+        with:
-        files: "build/NDSFactory-${{ github.ref_name }}-Linux-x64.tar.gz"
+          files: "build/NDSFactory-${{ github.ref_name }}-Linux-x64.tar.gz"
 
   build-macos:
     runs-on: macos-latest
 
     steps:
-    - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.1.7
 
-    - name: Install Qt
+      - name: Install Qt
-      uses: jurplel/install-qt-action@v4
+        uses: jurplel/install-qt-action@v4
-      with:
+        with:
-        version: '6.5.2'
+          version: "6.7.2"
 
-    - name: Install CMake
+      - name: Install CMake
-      uses: lukka/get-cmake@latest
+        uses: lukka/get-cmake@latest
 
-    - name: Create Build Environment
+      - name: Create Build Environment
-      run: |
+        run: |
-        mkdir build
+          mkdir -p build/x86_64 build/arm64 build/universal
 
-    - name: Configure CMake
+      - name: Configure CMake (x86_64)
-      working-directory: ${{github.workspace}}/build
+        working-directory: ${{ github.workspace }}/build/x86_64
-      shell: bash
+        shell: bash
-      run: |
+        run: |
-        cmake -DCMAKE_BUILD_TYPE=Release ..
+          cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=x86_64 ../..
 
-    - name: Build
+      - name: Configure CMake (arm64)
-      working-directory: ${{github.workspace}}/build
+        working-directory: ${{ github.workspace }}/build/arm64
-      shell: bash
+        shell: bash
-      run: |
+        run: |
-        make -j4
+          cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_OSX_ARCHITECTURES=arm64 ../..
-        macdeployqt NDSFactory.app
 
-    - name: Archive Artifact
+      - name: Build (x86_64)
-      working-directory: ${{github.workspace}}/build
+        working-directory: ${{ github.workspace }}/build/x86_64
-      shell: bash
+        shell: bash
-      run: |
+        run: |
-        zip -r NDSFactory-${{ github.ref_name }}-macOS.zip NDSFactory.app ../README.md ../LICENSE
+          make -j4
 
-    - name: Release on GitHub
+      - name: Build (arm64)
-      uses: softprops/action-gh-release@v2.0.8
+        working-directory: ${{ github.workspace }}/build/arm64
-      if: startsWith(github.ref, 'refs/tags/')
+        shell: bash
-      with:
+        run: |
-        files: "build/NDSFactory-${{ github.ref_name }}-macOS.zip"
+          make -j4
+
+      - name: Create Universal Binary
+        working-directory: ${{ github.workspace }}/build
+        shell: bash
+        run: |
+          cp -R x86_64/NDSFactory.app universal/
+          lipo -create -output universal/NDSFactory.app/Contents/MacOS/NDSFactory x86_64/NDSFactory.app/Contents/MacOS/NDSFactory arm64/NDSFactory.app/Contents/MacOS/NDSFactory
+
+      - name: Deploy Qt Frameworks
+        working-directory: ${{ github.workspace }}/build/universal
+        shell: bash
+        run: |
+          macdeployqt NDSFactory.app -verbose=1
+
+      - name: Archive Artifact
+        working-directory: ${{ github.workspace }}/build/universal
+        shell: bash
+        run: |
+          zip -r NDSFactory-${{ github.ref_name }}-macOS.zip NDSFactory.app ../README.md ../LICENSE
+
+      - name: Release on GitHub
+        uses: softprops/action-gh-release@v2.0.8
+        if: startsWith(github.ref, 'refs/tags/')
+        with:
+          files: "build/universal/NDSFactory-${{ github.ref_name }}-macOS.zip"
 
   build-windows:
     runs-on: windows-latest
 
     steps:
-    - uses: actions/checkout@v4.1.7
+      - uses: actions/checkout@v4.1.7
 
-    - name: Install Qt
+      - name: Install Qt
-      uses: jurplel/install-qt-action@v4
+        uses: jurplel/install-qt-action@v4
-      with:
+        with:
-        version: '6.5.2'
+          version: "6.7.2"
 
-    - name: Install CMake
+      - name: Install CMake
-      uses: lukka/get-cmake@latest
+        uses: lukka/get-cmake@latest
 
-    - name: Create Build Environment
+      - name: Create Build Environment
-      run: |
+        run: |
-        mkdir build
+          mkdir build
 
-    - name: Configure CMake
+      - name: Configure CMake
-      working-directory: ${{github.workspace}}/build
+        working-directory: ${{github.workspace}}/build
-      run: |
+        run: |
-        cmake ..
+          cmake ..
 
-    - name: Build
+      - name: Build
-      working-directory: ${{github.workspace}}/build
+        working-directory: ${{github.workspace}}/build
-      run: |
+        run: |
-        cmake --build . -j4 --config Release
+          cmake --build . -j4 --config Release
-        mkdir .\Release\prod
+          mkdir .\Release\prod
-        move .\Release\NDSFactory.exe .\Release\prod
+          move .\Release\NDSFactory.exe .\Release\prod
-        windeployqt .\Release\prod\NDSFactory.exe
+          windeployqt .\Release\prod\NDSFactory.exe
 
-    - name: Archive Artifact
+      - name: Archive Artifact
-      working-directory: ${{github.workspace}}/build/Release
+        working-directory: ${{github.workspace}}/build/Release
-      run: |
+        run: |
-        xcopy ..\..\README.md .\prod
+          xcopy ..\..\README.md .\prod
-        xcopy ..\..\LICENSE .\prod
+          xcopy ..\..\LICENSE .\prod
-        powershell "Compress-Archive -Path .\prod\* -DestinationPath .\NDSFactory-${{ github.ref_name }}-Windows-x64.zip"
+          powershell "Compress-Archive -Path .\prod\* -DestinationPath .\NDSFactory-${{ github.ref_name }}-Windows-x64.zip"
 
-    - name: Release on GitHub
+      - name: Release on GitHub
-      uses: softprops/action-gh-release@v2.0.8
+        uses: softprops/action-gh-release@v2.0.8
-      if: startsWith(github.ref, 'refs/tags/')
+        if: startsWith(github.ref, 'refs/tags/')
-      with:
+        with:
-        files: "build/Release/NDSFactory-${{ github.ref_name }}-Windows-x64.zip"
+          files: "build/Release/NDSFactory-${{ github.ref_name }}-Windows-x64.zip"

CMakeLists.txt

@@ -40,6 +40,9 @@ file(GLOB_RECURSE TABS_SOURCES ui/tabs/*.cpp)
 file(GLOB_RECURSE MODELS_HEADERS ui/models/*.h)
 file(GLOB_RECURSE MODELS_SOURCES ui/models/*.cpp)
 
+## Utils
+file(GLOB_RECURSE UTILS_HEADERS ui/utils/*.h)
+
 ## NDSFactory
 file(GLOB_RECURSE NDSFACTORY_SOURCES ndsfactory/*.cpp)
 file(GLOB_RECURSE NDSFACTORY_HEADERS ndsfactory/*.h)
@@ -59,6 +62,7 @@ SET(HEADERS
     ${TABS_HEADERS}
     ${MODELS_HEADERS}
     ${DIALOGS_HEADERS}
+    ${UTILS_HEADERS}
 )
 
 set(FORMS
@@ -80,7 +84,7 @@ else()
 endif()
 
 # Set C++ standard for the target
-target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_14)
+target_compile_features(${PROJECT_NAME} PUBLIC cxx_std_20)
 
 # Enable Qt's automatic features for the target
 set_target_properties(${PROJECT_NAME} PROPERTIES

README.md

@@ -10,8 +10,6 @@ If you find this software useful, please consider supporting it:
 
 ![screenshot](https://raw.githubusercontent.com/Luca1991/NDSFactory/master/screenshot.png)
 
-**!!!ROMS WITH OVERLAY ARE CURRENTLY NOT SUPPORTED!!!**
-
 # Description
 
 NDSFactory helps you easily unpack and repack Nintendo DS ROMs, but **some technical knowledge is required.**
@@ -19,11 +17,13 @@ NDSFactory helps you easily unpack and repack Nintendo DS ROMs, but **some techn
 A typical NDS ROM consists of the following sections:
 * Header
 * ARM9 Binary
+* ARM9 Overlay (Optional)
+* ARM9 Overlay Files (Optional)
 * ARM7 Binary
+* ARM7 Overlay (Optional)
+* ARM7 Overlay Files (Optional)
 * FNT (Filename Table)
 * FAT (File Allocation Table)
-* ARM9/ARM7 Overlay (Optional)
-* ARM9/ARM7 Overlay Files (Optional)
 * Icon/Title Logo
 * FAT Files (The actual files used by the software, like Graphics, Music etc.)
 
@@ -34,22 +34,33 @@ This tool is particularly useful for modding games or writing trainers.
 # How to use
 
 ## Unpacker Tab
-In the Unpacker Tab, you can load your Nintendo DS software (.nds) and extract the ROM sections, including individual FAT files. Take note of the original address of the FAT files, as you will need this value if you alter the addresses and sizes of the sections.
+In the Unpacker Tab, you can load your Nintendo DS software (.nds) and extract the ROM sections. Take note of the original address of the FAT files, as you will need this value if you alter the addresses and sizes of the sections or if you want to extract its contents.
 
 **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).
+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).
 
 ## Fat Tools Tab
-In this tab, you can 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.
+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.
   
-# Known Limitations/Possible Future Features/Bugs
+  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.
 
-* Add support for ROMs with overlays.
+# Credits
-* 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 :)
 
-### Developed with ❤ by Luca D'Amico
+Special thanks to [Antonio Barba](https://github.com/antoniobarba) & [Davide Trogu](https://github.com/Dax89)
-### Special thanks to Antonio Barba & Davide Trogu
+
+Developed with ❤ by Luca D'Amico

main.cpp

@@ -1,13 +1,23 @@
 #include "ui/mainwindow.h"
 #include <QApplication>
 #include <QStyleFactory>
+#include "ui/utils/theme.h"
 
 int main(int argc, char *argv[])
 {
     QApplication::setStyle(QStyleFactory::create("Fusion"));
-    QApplication a(argc, argv);
+    QApplication app(argc, argv);
-    MainWindow w;
+    app.setApplicationName("NDSFactory");
-    w.show();
+    app.setOrganizationName("NDSFactory");
 
-    return a.exec();
+    QString theme = getCurrentTheme();
+    if(theme == "dark")
+		setDarkTheme(app);
+	else if(theme == "light")
+        setLightTheme(app);
+
+    MainWindow mainWindow;
+    mainWindow.show();
+
+    return app.exec();
 }

ndsfactory/crctable.h

@@ -1,5 +1,4 @@
-#ifndef CRCTABLE_H
+#pragma once
-#define CRCTABLE_H
 
 #include <cstdint>
 
@@ -39,5 +38,3 @@ static const uint16_t lCRCTable[] =
     0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
     0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
 };
-
-#endif // CRCTABLE_H

ndsfactory/fatstruct.h

@@ -1,5 +1,4 @@
-#ifndef FATSTRUCT_H
+#pragma once
-#define FATSTRUCT_H
 
 #include <cstdint>
 
@@ -8,4 +7,7 @@ struct FatRange {
   uint32_t endAddr;
 };
 
-#endif // FATSTRUCT_H
+struct FatFileID {
+	uint16_t id;
+	std::string path;
+};

ndsfactory/ndsfactory.cpp

@@ -2,105 +2,114 @@
 #include <iostream>
 #include <fstream>
 #include <cmath>
+#include <filesystem>
+#include <format>
 #include "ndsfactory.h"
 #include "fatstruct.h"
 #include "crctable.h"
 
 
-NDSFactory::NDSFactory()
+// Byte offsets for interpreting memory
-{
+#define SECOND_BYTE_SHIFT 8
+#define THIRD_BYTE_SHIFT 16
+#define FOURTH_BYTE_SHIFT 24
 
-}
+// Magic values for FAT extraction
+#define CONTROL_BYTE_LENGTH_MASK 0x7F
+#define CONTROL_BYTE_DIR_MASK 0x80
+#define DUMMY_CONTROL_VALUE 0xFF
+#define FNT_HEADER_OFFSET_MASK 0XFFF
+#define ROOT_DIRECTORY_ADDRESS 0xF000
 
-bool NDSFactory::loadRomHeader(const std::string& romPath, std::vector<char>& romHeader)
+
+NFResult NDSFactory::loadRomHeader(const std::string& romPath, std::vector<char>& romHeader)
 {
     std::streampos headerSize = sizeof(NDSHeader);
-    std::ifstream romFile (romPath, std::ios::in|std::ios::binary|std::ios::ate);
+    std::ifstream romFile (romPath, std::ios::binary);
-    if (romFile.is_open())
+    if (!romFile.is_open())
-    {
+		return NFResult({ false, "Error opening file: " + romPath });
-        romHeader.resize(static_cast<unsigned long>(headerSize));
     
-        romFile.seekg (0, std::ios::beg);
+    romHeader.resize(static_cast<unsigned long>(headerSize));
-        romFile.read (romHeader.data(), headerSize);
+    romFile.read (romHeader.data(), headerSize);
-        romFile.close();
+    romFile.close();
-
+	return NFResult({ true, "" });
-        return true;
-    }
-    return false;
 }
 
-bool NDSFactory::dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
+NFResult NDSFactory::dumpDataFromFile(const std::string& romPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
 {
-    std::ifstream romFile (romPath, std::ios::in|std::ios::binary|std::ios::ate);
+    std::ifstream romFile (romPath, std::ios::binary);
-    std::ofstream savedFile (savePath, std::ios::out|std::ios::binary|std::ios::ate);
+    std::ofstream savedFile (savePath, std::ios::binary);
-    if (romFile.is_open() && savedFile.is_open())
+	if (!romFile.is_open()) return NFResult({ false, "Error opening file: " + romPath });
-    {
+	if (!savedFile.is_open()) return NFResult({ false, "Error creating file: " + savePath });
-        std::vector<char> dumpBuffer(size);
-        romFile.seekg (startAddr, std::ios::beg);
-        romFile.read (dumpBuffer.data(), size);
-        romFile.close();
 
-        savedFile.write(dumpBuffer.data(), size);
+    std::vector<char> dumpBuffer(size);
-        savedFile.close();
+    romFile.seekg (startAddr, std::ios::beg);
-        return true;
+    romFile.read (dumpBuffer.data(), size);
-    }
+    romFile.close();
-    return false;
+
+    savedFile.write(dumpBuffer.data(), size);
+    savedFile.close();
+    return NFResult({ true, "" });
 }
 
-
+bool NDSFactory::logToFile(const std::string& logPath, const std::string& log)
-bool NDSFactory::readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size)
 {
-    std::ifstream romFile (romPath, std::ios::in|std::ios::binary|std::ios::ate);
+    std::ofstream savedFile(logPath, std::ios::out | std::ios::binary | std::ios::app);
-    if (romFile.is_open())
+    if (!savedFile.is_open()) return false;
-    {
-        romFile.seekg (startAddr, std::ios::beg);
-        romFile.read (byteBuffer.data(), size);
-        romFile.close();
-        return true;
-    }
-    return false;
-}
 
-bool NDSFactory::writeSectionToFile(const std::string& sectionPath, const std::string& savePath, uint32_t startAddr, uint32_t size)
+	savedFile.write(log.c_str(), log.size());
-{
+    savedFile.close();
-    std::ifstream sectionFile (sectionPath, std::ios::in|std::ios::binary|std::ios::ate);
-    std::ofstream savedFile (savePath, std::ios::out|std::ios::binary|std::ios::app);
-    if (sectionFile.is_open() && savedFile.is_open())
-    {
-        std::vector<char> dumpBuffer(size);
-        sectionFile.seekg (0, std::ios::beg);
-        sectionFile.read (dumpBuffer.data(), size);
-        sectionFile.close();
-
-        savedFile.seekp(startAddr, std::ios::beg);
-        savedFile.write(dumpBuffer.data(), size);
-        savedFile.close();
-        return true;
-    }
-    return false;
-}
-
-bool NDSFactory::writeFatSectionToFile(const std::string& romPath, FatRange* pfatrange, const std::string& savePath){
-    uint32_t size=pfatrange->endAddr-pfatrange->startAddr;
-    if(!dumpDataFromFile(romPath, savePath, pfatrange->startAddr, size)) return false;
     return true;
 }
 
-bool NDSFactory::writeBytesToFile(std::vector<char>& byteBuffer, const std::string& savePath, uint32_t startAddr, uint32_t size)
+
+NFResult NDSFactory::readBytesFromFile(std::vector<char>& byteBuffer, const std::string& romPath, uint32_t startAddr, uint32_t size)
 {
-    std::ofstream savedFile (savePath, std::ios::out|std::ios::binary|std::ios::app);
+    std::ifstream romFile (romPath, std::ios::binary);
-    if (savedFile.is_open())
+    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, "" });
+}
+
+NFResult 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);
+}
+
+NFResult 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.seekp(startAddr, std::ios::beg);
+        savedFile.open(savePath, std::ios::out | std::ios::binary);
-        savedFile.write(byteBuffer.data(), size);
+        if (!savedFile.is_open()) {
+			return NFResult({ false, "Error creating file: " + savePath });
+        }
         savedFile.close();
-        return true;
+        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, "" });
 }
 
 
-bool NDSFactory::writePaddingToFile(char paddingChar, const std::string& filePath, uint32_t startAddr, const uint32_t size)
+NFResult 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);
@@ -113,7 +122,7 @@ int NDSFactory::getCardSizeInBytes(int cardType)
 
 bool NDSFactory::checkArm9FooterPresence(const std::string& sectionPath, uint32_t size)
 {
-    std::ifstream sectionFile (sectionPath, std::ios::in|std::ios::binary|std::ios::ate);
+    std::ifstream sectionFile (sectionPath, std::ios::binary | std::ios::ate);
     if (sectionFile.is_open())
     {
         std::streamoff sectionRealSize = sectionFile.tellg();
@@ -126,13 +135,150 @@ bool NDSFactory::checkArm9FooterPresence(const std::string& sectionPath, uint32_
     return false;
 }
 
-bool NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftSize, const std::string& savePath)
+NFResult 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;
+    std::vector<char> fatBytes;
+    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 });
+    std::streamoff fatDataSectionSize = fatDataSectionFile.tellg();
+    fatDataBytes.resize(fatDataSectionSize);
+    fatDataSectionFile.seekg(0, std::ios::beg);
+    fatDataSectionFile.read(fatDataBytes.data(), fatDataSectionSize);
+    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 });
+    std::streamoff fatSectionSize = fatSectionFile.tellg();
+    fatBytes.resize(fatSectionSize);
+    fatSectionFile.seekg(0, std::ios::beg);
+    fatSectionFile.read(fatBytes.data(), fatSectionSize);
+    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 });
+    std::streamoff fntSectionSize = fntSectionFile.tellg();
+    fntBytes.resize(fntSectionSize);
+    fntSectionFile.seekg(0, std::ios::beg);
+    fntSectionFile.read(fntBytes.data(), fntSectionSize);
+    fntSectionFile.close();
+
+    FatRange* pfatrange = reinterpret_cast<FatRange*>(fatBytes.data());
+
+    // This lambda function was written by NyuBlara, all credits to him.
+    // I edited it a bit to make it work with the rest of the updated code.
+    auto parseFolder = [this, fntBytes, pfatrange, fatDataSectionPath, originalFatDataAddr, savePath, logFileIDs](uint32_t folderId, std::string curPath, auto& parseFolder) {
+
+        uint32_t currentOffset = 8 * (folderId & FNT_HEADER_OFFSET_MASK); // offset for the current directory's info in the FNT header
+        // Only the lower 12 bit of the given offset are relevant
+
+        // ---------------------------------------------------------------------
+        // About how the FAT and FNT work :
+        // The FNT has two sections :
+        // a "header" where every entry contains :
+        //// - a 4-byte address where the corresponding directory's data starts in the body
+        //// - a 2-byte offset that is the index of the first file of the directory in the FAT
+        //// (e.g. : if the offset is 42, the first file in the directory is situated at the ROM addresses stored in the 42nd FAT entry)
+        //// (and its second will be 43, etc.)
+        // a "body" where every entry contains :
+        //// - a length+status/control byte : lower 7 bits (control byte & 0x7F) are a length, highest bit (control byte & 0x80) is set if entry is a directory, and not set if it's a file
+        //// - a name which length is the length portion of the previous control byte (e.g. : if the control byte was 0x83, the name is three bytes long)
+        //// - if the entry is a directory, a 2-byte address (where only the lower 12 bit are relevant for some reason) at which this directory's info is located in the FNT header
+        // Thus, the FNT reading operation will consist in bouncing back and forth between body and header every time we must process a subdirectory
+        // Thank Heavens for random-access containers !
+        // ---------------------------------------------------------------------
+
+        // Get the 4-byte address for the folder data
+
+        uint32_t fntBodyOffset =
+            (uint32_t)((unsigned char)fntBytes[currentOffset + 3] << (uint32_t)FOURTH_BYTE_SHIFT |
+                (unsigned char)fntBytes[currentOffset + 2] << (uint32_t)THIRD_BYTE_SHIFT |
+                (unsigned char)fntBytes[currentOffset + 1] << (uint32_t)SECOND_BYTE_SHIFT |
+                (unsigned char)fntBytes[currentOffset]);
+        currentOffset += 4;
+
+        // Get the 2-byte offset for the folder's first file in the FAT
+        uint16_t fatOffset =
+            (uint16_t)((unsigned char)fntBytes[currentOffset + 1] << SECOND_BYTE_SHIFT |
+                (unsigned char)fntBytes[currentOffset]);
+
+        // Jump to FNT body a specified address
+        currentOffset = fntBodyOffset;
+
+        uint8_t controlByte = DUMMY_CONTROL_VALUE;
+
+        while (true)
+        {
+            controlByte = fntBytes[currentOffset]; // Entry's control byte
+            if (controlByte == 0) break; // A control byte of 0 terminates the directory's contents
+            currentOffset++;
+
+            uint8_t nameLength = controlByte & CONTROL_BYTE_LENGTH_MASK; // length of entry name
+            bool isDir = controlByte & CONTROL_BYTE_DIR_MASK; // set if entry is a directory
+
+            // Reconstitute name from bytes
+            // Btw I wish I could use the actual byte type but I have to comply with the software's choice of using char
+            std::vector<char> nameString;
+            for (size_t i = 0; i < nameLength; i++) nameString.push_back(fntBytes[currentOffset++]);
+            std::string name(&nameString[0], (size_t)nameLength);
+
+            std::string newPath = curPath + '/' + name;
+
+            if (isDir)
+            {
+                // Get the 2-byte address for this folder's info in the FNT header
+                uint16_t subFolderId = ((unsigned char)fntBytes[currentOffset + 1] << SECOND_BYTE_SHIFT |
+                    (unsigned char)fntBytes[currentOffset]);
+                currentOffset += 2;
+
+                if (!std::filesystem::exists(newPath))
+					if (!std::filesystem::create_directory(newPath)) return NFResult({ false, "Error creating directory: " + newPath });
+
+                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" });
+                }
+
+                // 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 });
+            }
+            else
+            {
+                // Remember we have the offset for the directory's first file in the FAT.
+                // From then, every file is just the next entry.
+                // So we just have to use that offset and increment it every time.
+
+                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 (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" });
+                }
+				
+                fatOffset++;
+            }
+        }
+
+		return NFResult({ true, "" });
+    };
+
+    return parseFolder(ROOT_DIRECTORY_ADDRESS, savePath, parseFolder);
+}
+
+NFResult 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;
+        return { false, "Error opening file: " + fatSectionPath };
 
     std::streamoff sectionSize = sectionFile.tellg();
     fatBytes.resize(sectionSize);
@@ -142,7 +288,6 @@ bool NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftSize,
     sectionFile.read (fatBytes.data(), sectionSize);
     sectionFile.close();
 
-
     FatRange* pfatrange = reinterpret_cast<FatRange*>(fatBytes.data());
 
     for(size_t i = 0; i < fatBytes.size(); i += sizeof(FatRange), pfatrange++) {
@@ -150,9 +295,97 @@ bool NDSFactory::patchFat(const std::string& fatSectionPath, uint32_t shiftSize,
         pfatrange->endAddr += shiftSize;
     }
 
+    std::remove(savePath.c_str());
+
     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)
+{
+    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::string fileIDsLine;
+    while (std::getline(fileIDsFile, fileIDsLine))
+    {
+        FatFileID fatFileID;
+        fatFileID.id = static_cast<uint16_t>(std::stoi(fileIDsLine.substr(0, fileIDsLine.find(":::")), nullptr, 16));
+        fatFileID.path = fileIDsLine.substr(fileIDsLine.find(":::") + 3);
+        fileIDs.push_back(fatFileID);
+    }
+    fileIDsFile.close();
+
+    // This loop is needed to detect if roms has overlay files
+    // and if so, we need to extract their addresses from the original fat.bin
+    // it is a hacky but it works
+    for (FatFileID fatFileID : fileIDs)
+    {
+        std::string currentFile = fatDataDirPath + "/" + fatFileID.path;
+        if (std::filesystem::is_directory(std::filesystem::path(currentFile))) continue;
+
+        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::vector<char> ovrBytes;
+            uint32_t requiredBytes = firstFileId * sizeof(FatRange);
+            ovrBytes.resize(requiredBytes);
+            originalFatFile.read(ovrBytes.data(), requiredBytes);
+            originalFatFile.close();
+
+            FatRange* pfatrange = reinterpret_cast<FatRange*>(ovrBytes.data());
+            for (size_t i = 0; i < ovrBytes.size(); i += sizeof(FatRange), pfatrange++)
+                fat.push_back({ pfatrange->startAddr, pfatrange->endAddr });
+        }
+        break;
+    }
+
+    for (FatFileID fatFileID : fileIDs)
+    {
+        std::string currentFile = fatDataDirPath + "/" + fatFileID.path;
+
+        if (std::filesystem::is_directory(std::filesystem::path(currentFile))) continue;
+
+        FatRange fatRange;
+        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 });
+        std::streamsize size = currentFatDataFile.tellg();
+        currentFatDataFile.seekg(0, std::ios::beg);
+
+        std::vector<char> buffer(size);
+        if (currentFatDataFile.read(buffer.data(), size))
+            fatDataBytes.insert(fatDataBytes.end(), buffer.begin(), buffer.end());
+        else
+        {
+            currentFatDataFile.close();
+            return NFResult({ false, "Error reading file: " + currentFile });
+        }
+        currentFatDataFile.close();
+
+        fatRange.endAddr = fatDataAddr + static_cast<uint32_t>(fatDataBytes.size());
+        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" });
+
+    return NFResult({ true, "" });
+}
+
 uint16_t NDSFactory::calcHeaderCrc16(const std::vector<char>& romHeader)
 {
     uint8_t loc;

ndsfactory/ndsfactory.h

@@ -1,32 +1,32 @@
-#ifndef NDSFACTORY_H
+#pragma once
-#define NDSFACTORY_H
 
 #include <string>
 #include <vector>
 #include <cstdint>
 #include "ndsheader.h"
 #include "fatstruct.h"
-
+#include "nfresult.h"
 
 
 class NDSFactory
 {
 public:
-    NDSFactory();
+    NFResult loadRomHeader(const std::string& romPath, std::vector<char>& header);
-    bool 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);
-    bool 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);
-    bool 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);
-    bool 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);
-    bool writeFatSectionToFile(const std::string& romPath, FatRange* pfatrange, const std::string& savePath);
+    NFResult writePaddingToFile(char paddingChar, 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);
-    bool patchFat(const std::string& sectionPath, uint32_t shiftSize, const std::string& savePath);
+    NFResult 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);
     uint16_t calcHeaderCrc16(const std::vector<char>& romHeader);
 
 private:
+    bool logToFile(const std::string& logPath, const std::string& log);
 
 };
 
-#endif // NDSFACTORY_H

ndsfactory/ndsheader.h

@@ -1,5 +1,4 @@
-#ifndef NDSHEADER_H
+#pragma once
-#define NDSHEADER_H
 
 #include <cstdint>
 
@@ -69,5 +68,3 @@ struct NDSHeader
     unsigned char Reserved4[0x90];
 };
 #pragma pack(pop)
-
-#endif // NDSHEADER_H

ndsfactory/nfresult.h

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

ui/dialogs/about/aboutdialog.h

@@ -1,5 +1,4 @@
-#ifndef ABOUTDIALOG_H
+#pragma once
-#define ABOUTDIALOG_H
 
 #include <QDialog>
 
@@ -18,5 +17,3 @@ class AboutDialog : public QDialog
         Ui::AboutDialog *ui;
 
 };
-
-#endif // ABOUTDIALOG_H

ui/dialogs/about/aboutdialog.ui

@@ -42,7 +42,7 @@
     <bool>false</bool>
    </property>
    <property name="text">
-    <string>NDS Factory V1.1</string>
+    <string>NDSFactory V1.3.2</string>
    </property>
    <property name="alignment">
     <set>Qt::AlignmentFlag::AlignCenter</set>
@@ -58,7 +58,7 @@
     </rect>
    </property>
    <property name="text">
-    <string>(C) 2019-2024 - Luca D'Amico</string>
+    <string>(C) 2019-2025 - Luca D'Amico</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 "c7eaa8e"
+#define GIT_COMMIT_HASH "c916f47"
 
 #endif

ui/mainwindow.cpp

@@ -2,6 +2,7 @@
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
 #include "dialogs/about/aboutdialog.h"
+#include "utils/theme.h"
 
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
@@ -26,3 +27,18 @@ void MainWindow::on_actionAbout_triggered()
     AboutDialog aboutDialog;
     aboutDialog.exec();
 }
+
+void MainWindow::on_actionDark_triggered()
+{
+	setTheme("dark");
+}
+
+void MainWindow::on_actionLight_triggered()
+{
+	setTheme("light");
+}
+
+void MainWindow::on_actionDefault_triggered()
+{
+	setTheme("default");
+}

ui/mainwindow.h

@@ -1,5 +1,4 @@
-#ifndef MAINWINDOW_H
+#pragma once
-#define MAINWINDOW_H
 
 #include <QMainWindow>
 #include <cstdint>
@@ -32,9 +31,10 @@ private slots:
     void on_unpackerDumpArm9OverlayFilesBtn_clicked();
     void on_unpackerDumpArm7OverlayFilesBtn_clicked();
     void on_unpackerDumpEverythingBtn_clicked();
-    void on_unpackerDecodeFatFilesBtn_clicked();
-    void notifyExtractionResult(bool result);
 
+    void on_actionDark_triggered();
+    void on_actionLight_triggered();
+    void on_actionDefault_triggered();
     void on_actionExit_triggered();
     void on_actionAbout_triggered();
 
@@ -49,13 +49,18 @@ private slots:
     void on_packerLoadArm7OverlayFilesBtn_clicked();
     void on_packerLoadIconTitleBtn_clicked();
     void on_packerLoadFatFilesBtn_clicked();
+    void on_packerCalcHeaderCrcBtn_clicked();
     void on_packerBuildNDSRomBtn_clicked();
 
     void on_fatPatcherLoadFatBtn_clicked();
-
     void on_fatPatcherPatchFatBtn_clicked();
-
+    void on_fatExtractorLoadFatDataBtn_clicked();
-    void on_packerCalcHeaderCrcBtn_clicked();
+    void on_fatExtractorLoadFatBtn_clicked();
+    void on_fatExtractorLoadFntBtn_clicked();
+    void on_fatExtractorExtractBtn_clicked();
+    void on_fatBuilderOpenFatDataDirBtn_clicked();
+	void on_fatBuilderLoadOriginalFatBtn_clicked();
+    void on_fatBuilderBuildBtn_clicked();
 
 private:
     Ui::MainWindow *ui;
@@ -64,54 +69,48 @@ private:
     void populateHeader(NDSHeader* ndsHeader);
     void enableExtractionButtons();
     void disableExtractionButtons();
-    bool dumpHeader(const std::string& dirPath);
+    NFResult dumpHeader(const std::string& dirPath);
-    bool dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes);
+    NFResult dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes);
-    bool dumpArm7Bin(const std::string& dirPath);
+    NFResult dumpArm7Bin(const std::string& dirPath);
-    bool dumpFnt(const std::string& dirPath);
+    NFResult dumpFnt(const std::string& dirPath);
-    bool dumpFat(const std::string& dirPath);
+    NFResult dumpFat(const std::string& dirPath);
-    bool dumpArm9Overlay(const std::string& dirPath);
+    NFResult dumpArm9Overlay(const std::string& dirPath);
-    bool dumpArm9OverlayFiles(const std::string& dirPath);
+    NFResult dumpArm9OverlayFiles(const std::string& dirPath);
-    bool dumpArm7Overlay(const std::string& dirPath);
+    NFResult dumpArm7Overlay(const std::string& dirPath);
-    bool dumpArm7OverlayFiles(const std::string& dirPath);
+    NFResult dumpArm7OverlayFiles(const std::string& dirPath);
-    bool dumpIconTitle(const std::string& dirPath);
+    NFResult dumpIconTitle(const std::string& dirPath);
-    bool dumpFatFiles(const std::string& dirPath);
+    NFResult dumpFatFiles(const std::string& dirPath);
-    bool dumpEverything(QString dirPath);
+    NFResult dumpEverything(QString dirPath);
 
     void populatePackerSectionHeader(NDSHeader *ndsHeader);
     void enableCalcCrcButton();
     void enableBuildRomButton();
     void generateHeader(NDSHeader* pRomHeader);
-    bool writeHeader(const std::string& savePath);
+    NFResult writeHeader(const std::string& savePath);
     void calcHeaderCrc16();
-    bool writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent);
+    NFResult writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent);
-    bool writeArm7Bin(const std::string& savePath);
+    NFResult writeArm7Bin(const std::string& savePath);
-    bool writeFnt(const std::string& savePath);
+    NFResult writeFnt(const std::string& savePath);
-    bool writeFat(const std::string& savePath);
+    NFResult writeFat(const std::string& savePath);
-    bool writeArm9Overlay(const std::string& savePath);
+    NFResult writeArm9Overlay(const std::string& savePath);
-    bool writeArm9OverlayFiles(const std::string& savePath);
+    NFResult writeArm9OverlayFiles(const std::string& savePath);
-    bool writeArm7Overlay(const std::string& savePath);
+    NFResult writeArm7Overlay(const std::string& savePath);
-    bool writeArm7OverlayFiles(const std::string& savePath);
+    NFResult writeArm7OverlayFiles(const std::string& savePath);
-    bool writeIconTitle(const std::string& savePath);
+    NFResult writeIconTitle(const std::string& savePath);
-    bool writeFatFiles(const std::string& savePath);
+    NFResult writeFatFiles(const std::string& savePath);
-    bool writeEverything(const std::string& savePath);
+    NFResult writeEverything(const std::string& savePath);
 
-    bool writeHeaderPadding(char paddingByte, const std::string& savePath);
+    NFResult writeHeaderPadding(char paddingByte, const std::string& savePath);
-    bool writeArm9BinPadding(char paddingByte, const std::string& savePath, bool isArm9FooterPresent);
+    NFResult writeArm9BinPadding(char paddingByte, const std::string& savePath, bool isArm9FooterPresent);
-    bool writeArm7BinPadding(char paddingByte, const std::string& savePath);
+    NFResult writeArm7BinPadding(char paddingByte, const std::string& savePath);
-    bool writeFntPadding(char paddingByte, const std::string& savePath);
+    NFResult writeFntPadding(char paddingByte, const std::string& savePath);
-    bool writeFatPadding(char paddingByte, const std::string& savePath);
+    NFResult writeFatPadding(char paddingByte, const std::string& savePath);
-    bool writeArm9OverlayPadding(char paddingByte, const std::string& savePath);
+    NFResult writeRomPadding(const std::string& savePath);
-    bool writeArm9OverlayFilesPadding(char paddingByte, const std::string& savePath);
-    bool writeArm7OverlayPadding(char paddingByte, const std::string& savePath);
-    bool writeArm7OverlayFilesPadding(char paddingByte, const std::string& savePath);
-    bool writeRomPadding(const std::string& savePath);
 
-    //QString extractUnpackerHeaderTableData(int index);
     QString extractPackerHeaderTableData(int index);
 
-    bool decodeFatFiles(QString dirPath);
+    NFResult extractFatData(const std::string& fatDataSectionPath, const std::string& fatSectionPath,
-
+        const std::string& fntSectionPath, uint32_t originalFatDataAddr, const std::string& savePath, bool logFileIDs);
-    bool patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath);
+    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);
 };
-
-#endif // MAINWINDOW_H

ui/mainwindow.ui

@@ -274,13 +274,6 @@
                 </property>
                </widget>
               </item>
-              <item>
-               <widget class="QPushButton" name="unpackerDecodeFatFilesBtn">
-                <property name="text">
-                 <string>Decode FAT Contents</string>
-                </property>
-               </widget>
-              </item>
              </layout>
             </widget>
            </item>
@@ -601,11 +594,223 @@
         <item>
          <layout class="QVBoxLayout" name="verticalLayout_14">
           <property name="spacing">
-           <number>4</number>
+           <number>6</number>
           </property>
           <property name="sizeConstraint">
            <enum>QLayout::SizeConstraint::SetDefaultConstraint</enum>
           </property>
+          <item>
+           <widget class="QGroupBox" name="groupBox_7">
+            <property name="title">
+             <string>FAT Data Extractor</string>
+            </property>
+            <layout class="QVBoxLayout" name="verticalLayout_16">
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_38">
+               <property name="leftMargin">
+                <number>0</number>
+               </property>
+               <property name="topMargin">
+                <number>0</number>
+               </property>
+               <property name="rightMargin">
+                <number>0</number>
+               </property>
+               <property name="bottomMargin">
+                <number>0</number>
+               </property>
+               <item>
+                <widget class="QLineEdit" name="fatExtractorFatDataPathEdt"/>
+               </item>
+               <item>
+                <widget class="QPushButton" name="fatExtractorLoadFatDataBtn">
+                 <property name="text">
+                  <string>Load FAT Data(fat_data.bin)</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_40">
+               <property name="leftMargin">
+                <number>0</number>
+               </property>
+               <property name="topMargin">
+                <number>0</number>
+               </property>
+               <property name="rightMargin">
+                <number>0</number>
+               </property>
+               <property name="bottomMargin">
+                <number>0</number>
+               </property>
+               <item>
+                <widget class="QLineEdit" name="fatExtractorFntPathEdt"/>
+               </item>
+               <item>
+                <widget class="QPushButton" name="fatExtractorLoadFntBtn">
+                 <property name="text">
+                  <string>Load FNT(fnt.bin)</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_39" stretch="0,0">
+               <property name="leftMargin">
+                <number>0</number>
+               </property>
+               <property name="topMargin">
+                <number>0</number>
+               </property>
+               <property name="rightMargin">
+                <number>0</number>
+               </property>
+               <property name="bottomMargin">
+                <number>0</number>
+               </property>
+               <item>
+                <widget class="QLineEdit" name="fatExtractorFatPathEdt"/>
+               </item>
+               <item>
+                <widget class="QPushButton" name="fatExtractorLoadFatBtn">
+                 <property name="text">
+                  <string>Load FAT(fat.bin)</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_6">
+               <item>
+                <widget class="QLabel" name="label">
+                 <property name="text">
+                  <string>Original Fat Files (fat_data.bin) Addr:</string>
+                 </property>
+                </widget>
+               </item>
+               <item>
+                <widget class="QLineEdit" name="fatExtractorOriginalFatFilesAddrEdt"/>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_8">
+               <item>
+                <widget class="QCheckBox" name="fatExtractorSaveFileIDsCbx">
+                 <property name="text">
+                  <string>Save file IDs to _file_IDs.txt (required for rebuilding FAT)</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_41">
+               <property name="leftMargin">
+                <number>0</number>
+               </property>
+               <property name="topMargin">
+                <number>0</number>
+               </property>
+               <property name="rightMargin">
+                <number>0</number>
+               </property>
+               <property name="bottomMargin">
+                <number>0</number>
+               </property>
+               <item>
+                <widget class="QPushButton" name="fatExtractorExtractBtn">
+                 <property name="text">
+                  <string>Extract FAT Data!</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+            </layout>
+           </widget>
+          </item>
+         </layout>
+        </item>
+        <item>
+         <layout class="QVBoxLayout" name="verticalLayout_17">
+          <item>
+           <widget class="QGroupBox" name="groupBox_8">
+            <property name="title">
+             <string>FAT Builder</string>
+            </property>
+            <layout class="QVBoxLayout" name="verticalLayout_18">
+             <item>
+              <layout class="QVBoxLayout" name="verticalLayout_19">
+               <item>
+                <widget class="QLabel" name="label_3">
+                 <property name="text">
+                  <string>Original fat.bin is required ONLY if the ROM has an overlay...</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_9">
+               <item>
+                <widget class="QLineEdit" name="fatBuilderFatDirPathEdt"/>
+               </item>
+               <item>
+                <widget class="QPushButton" name="fatBuilderOpenFatDataDirBtn">
+                 <property name="text">
+                  <string>Open FAT Data Directory</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_12">
+               <item>
+                <widget class="QLineEdit" name="fatBuilderOriginalFatPathEdt"/>
+               </item>
+               <item>
+                <widget class="QPushButton" name="fatBuilderLoadOriginalFatBtn">
+                 <property name="text">
+                  <string>Load Original fat.bin</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_11">
+               <item>
+                <widget class="QLabel" name="label_2">
+                 <property name="text">
+                  <string>Fat Files (fat_data.bin) Addr:</string>
+                 </property>
+                </widget>
+               </item>
+               <item>
+                <widget class="QLineEdit" name="fatBuilderFatAddrEdt"/>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_10">
+               <item>
+                <widget class="QPushButton" name="fatBuilderBuildBtn">
+                 <property name="text">
+                  <string>Build!</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+            </layout>
+           </widget>
+          </item>
          </layout>
         </item>
         <item>
@@ -617,23 +822,27 @@
             </property>
             <layout class="QVBoxLayout" name="verticalLayout_15">
              <item>
-              <widget class="QLabel" name="label_83">
+              <layout class="QHBoxLayout" name="horizontalLayout_5">
-               <property name="sizePolicy">
+               <item>
-                <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
+                <widget class="QLabel" name="label_83">
-                 <horstretch>0</horstretch>
+                 <property name="sizePolicy">
-                 <verstretch>0</verstretch>
+                  <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
-                </sizepolicy>
+                   <horstretch>0</horstretch>
-               </property>
+                   <verstretch>0</verstretch>
-               <property name="text">
+                  </sizepolicy>
-                <string>If the address of the fat_data.bin file is different from the original location in ROM, you need to patch the fat.bin file...</string>
+                 </property>
-               </property>
+                 <property name="text">
-               <property name="scaledContents">
+                  <string>If the address of the fat_data.bin file is different from the original location in ROM, you need to patch the fat.bin file...</string>
-                <bool>false</bool>
+                 </property>
-               </property>
+                 <property name="scaledContents">
-               <property name="alignment">
+                  <bool>false</bool>
-                <set>Qt::AlignmentFlag::AlignCenter</set>
+                 </property>
-               </property>
+                 <property name="alignment">
-              </widget>
+                  <set>Qt::AlignmentFlag::AlignCenter</set>
+                 </property>
+                </widget>
+               </item>
+              </layout>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_35">
@@ -730,6 +939,9 @@
           <property name="orientation">
            <enum>Qt::Orientation::Vertical</enum>
           </property>
+          <property name="sizeType">
+           <enum>QSizePolicy::Policy::Expanding</enum>
+          </property>
           <property name="sizeHint" stdset="0">
            <size>
             <width>20</width>
@@ -760,6 +972,15 @@
     <property name="title">
      <string>File</string>
     </property>
+    <widget class="QMenu" name="menuTheme">
+     <property name="title">
+      <string>Theme</string>
+     </property>
+     <addaction name="actionDark"/>
+     <addaction name="actionLight"/>
+     <addaction name="actionDefault"/>
+    </widget>
+    <addaction name="menuTheme"/>
     <addaction name="actionExit"/>
    </widget>
    <widget class="QMenu" name="menuHelp">
@@ -786,6 +1007,21 @@
     <string>Exit</string>
    </property>
   </action>
+  <action name="actionDark">
+   <property name="text">
+    <string>Dark</string>
+   </property>
+  </action>
+  <action name="actionLight">
+   <property name="text">
+    <string>Light</string>
+   </property>
+  </action>
+  <action name="actionDefault">
+   <property name="text">
+    <string>Default</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <resources/>

ui/models/ndsheadermodel.cpp

@@ -151,7 +151,7 @@ bool NDSHeaderModel::setData(const QModelIndex &index, const QVariant &value, in
     case 37: ndsHeader->DebugRomAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
     case 38: ndsHeader->DebugSize = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
     case 39: ndsHeader->DebugRamAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
-    case 40: QMessageBox::information(nullptr, tr("NDS Factory"), tr("FAT files address is automatically calculated based on Icon/Title address!")); break;
+    case 40: QMessageBox::information(nullptr, tr("NDSFactory"), tr("FAT files address is automatically calculated based on Icon/Title address!")); break;
     default: return false;
     }
     Q_EMIT this->dataChanged(index, index);

ui/models/ndsheadermodel.h

@@ -1,5 +1,4 @@
-#ifndef NDSHEADERMODEL_H
+#pragma once
-#define NDSHEADERMODEL_H
 
 #include <QAbstractTableModel>
 
@@ -21,5 +20,3 @@ private:
     NDSHeader *ndsHeader;
     bool isValueRowEditable = false;
 };
-
-#endif // NDSHEADERMODEL_H

ui/tabs/commons/headernames.h

@@ -1,5 +1,4 @@
-#ifndef HEADERNAMES_H
+#pragma once
-#define HEADERNAMES_H
 
 #include <array>
 #include <string>
@@ -52,5 +51,3 @@ namespace NDSHeaderNames {
         FATFilesAddress
     };
 }
-
-#endif // HEADERNAMES_H

ui/tabs/fattools/fattoolstabfunctions.cpp

@@ -1,7 +1,19 @@
+#include <filesystem> 
 #include "./../../mainwindow.h"
 
 
-bool MainWindow::patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath)
+NFResult 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)
 {
     return ndsFactory.patchFat(loadPath, shiftSize, savePath);
 }
+
+NFResult MainWindow::buildFatData(const std::string& fatDataDirPath, const std::string& originalFatPath, uint32_t fatDataAddr, const std::string& savePath)
+{
+	return ndsFactory.buildFatData(fatDataDirPath, originalFatPath, fatDataAddr, savePath);
+}

ui/tabs/fattools/fattoolstabsignals.cpp

@@ -2,48 +2,154 @@
 #include <QMessageBox>
 #include "./../../mainwindow.h"
 #include "./../../ui_mainwindow.h"
+#include "./../../utils/filepicker.h"
 
+void MainWindow::on_fatExtractorLoadFatDataBtn_clicked()
+{
+    QString FatDataPath = QFileDialog::getOpenFileName(
+        Q_NULLPTR,
+        "NDS Fat Data",
+        "",
+        "NDS FAT_DATA (*.bin)");
+
+    if (!FatDataPath.isNull())
+    {
+        ui->fatExtractorFatDataPathEdt->setText(FatDataPath.toUtf8());
+    }
+}
+
+void MainWindow::on_fatExtractorLoadFatBtn_clicked()
+{
+	QString FatPath = QFileDialog::getOpenFileName(
+		Q_NULLPTR,
+		"NDS Fat",
+		"",
+		"NDS FAT (*.bin)");
+
+	if (!FatPath.isNull())
+	{
+		ui->fatExtractorFatPathEdt->setText(FatPath.toUtf8());
+	}
+}
+
+void MainWindow::on_fatExtractorLoadFntBtn_clicked()
+{
+	QString FntPath = QFileDialog::getOpenFileName(
+		Q_NULLPTR,
+		"NDS Fnt",
+		"",
+		"NDS FNT (*.bin)");
+
+	if (!FntPath.isNull())
+	{
+		ui->fatExtractorFntPathEdt->setText(FntPath.toUtf8());
+	}
+}
+
+void MainWindow::on_fatExtractorExtractBtn_clicked()
+{
+	ui->fatExtractorExtractBtn->setEnabled(false);
+
+    QString dirPath = QFileDialog::getExistingDirectory(
+        this, tr("Select Directory"),
+        "",
+        QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
+
+    if (!dirPath.isNull()) {
+        NFResult nfResult = 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->fatExtractorExtractBtn->setEnabled(true);
+
+}
 
 void MainWindow::on_fatPatcherLoadFatBtn_clicked()
 {
     QString fatPath =  QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Fat",
-          QDir::currentPath(),
+          "",
           "NDS Fat (*.bin)");
 
-    if( !fatPath.isNull() )
+    if(!fatPath.isNull())
-    {
+        ui->fatPatcherFatPathEdt->setText(fatPath.toUtf8());
-      ui->fatPatcherFatPathEdt->setText(fatPath.toUtf8());
-    }
 }
 
 void MainWindow::on_fatPatcherPatchFatBtn_clicked()
 {
+	ui->fatPatcherPatchFatBtn->setEnabled(false);
+
     uint32_t positionDiff = 0;
     uint32_t originalPos = ui->fatPatcherOriginalFatFilesAddrEdt->text().toUInt(nullptr, 16);
     uint32_t newPos = ui->fatPatcherNewFatFilesAddrEdt->text().toUInt(nullptr, 16);
 
-    QString dirPath =  QFileDialog::getSaveFileName(
+    QString dirPath = customSaveFileDialog("NDS FAT",
-          Q_NULLPTR,
+        "fat.bin",
-          "NDS FAT",
+        "Binary (*.bin)");
-          "fat.bin",
-          "Binary (*.bin)");
 
-    if(dirPath.isNull())
+    if (!dirPath.isNull())
     {
-        return;
+        if(originalPos < newPos)
+            positionDiff = newPos - originalPos;
+        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());
     }
 
-    if (originalPos < newPos)
+    ui->fatPatcherPatchFatBtn->setEnabled(true);
-    {
+}
-        positionDiff = newPos-originalPos;
+
-    } else {
+void MainWindow::on_fatBuilderOpenFatDataDirBtn_clicked()
-        positionDiff = originalPos-newPos;
+{
-    }
+    QString fatDirPat = QFileDialog::getExistingDirectory(
-
+        this, tr("Select Directory"),
-    patchFat(ui->fatPatcherFatPathEdt->text().toStdString(), positionDiff, dirPath.toStdString())
+        "",
-            ? QMessageBox::information(this, tr("NDS Factory"), tr("FAT patching completed!"))
+        QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
-            : QMessageBox::critical(this, tr("NDS Factory"), tr("Error patching FAT!"));
+
-
+    if (!fatDirPat.isNull())
+        ui->fatBuilderFatDirPathEdt->setText(fatDirPat.toUtf8());
+}
+
+void MainWindow::on_fatBuilderLoadOriginalFatBtn_clicked()
+{
+	QString fatPath = QFileDialog::getOpenFileName(
+		Q_NULLPTR,
+		"NDS Fat",
+		"",
+		"NDS Fat (*.bin)");
+
+	if (!fatPath.isNull())
+		ui->fatBuilderOriginalFatPathEdt->setText(fatPath.toUtf8());
+}
+
+void MainWindow::on_fatBuilderBuildBtn_clicked()
+{
+    ui->fatBuilderOpenFatDataDirBtn->setEnabled(false);
+
+    QString dirPath = QFileDialog::getExistingDirectory(
+        this, tr("Select Directory"),
+        "",
+        QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
+
+    if (!dirPath.isNull())
+    {
+        NFResult nfResult = 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());
+    }
+
+    ui->fatBuilderOpenFatDataDirBtn->setEnabled(true);
 }

ui/tabs/packer/packertabfunctions.cpp

@@ -91,17 +91,6 @@ void MainWindow::generateHeader(NDSHeader* pRomHeader)
     std::fill(std::begin(pRomHeader->Reserved4), std::end(pRomHeader->Reserved4), 0);
 }
 
-
-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));;
-}
-
 void MainWindow::calcHeaderCrc16()
 {
     std::vector<char> romHeaderBuffer(sizeof(NDSHeader));
@@ -113,7 +102,29 @@ void MainWindow::calcHeaderCrc16()
     ui->packerHeaderDataTable->model()->setData(headerCrcIndex, QString::number(ndsFactory.calcHeaderCrc16(romHeaderBuffer), 16), Qt::EditRole);
 }
 
-bool MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent)
+NFResult 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));
+}
+
+NFResult MainWindow::writeHeaderPadding(char paddingType, const std::string& savePath)
+{
+    uint32_t startAddr = sizeof(NDSHeader);
+    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16) - startAddr;
+
+    return ndsFactory.writePaddingToFile(
+        paddingType,
+        savePath,
+        startAddr,
+        size);
+}
+
+NFResult MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent)
 {
     uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16);
     if (isArm9FooterPresent)
@@ -125,7 +136,52 @@ bool MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPres
                 size);
 }
 
-bool MainWindow::writeArm7Bin(const std::string& savePath)
+
+NFResult 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);
+    uint32_t size;
+    if (extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) != 0)
+        size = extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) - startAddr;
+    else
+        size = extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16) - startAddr;
+
+    if (isFooterPresent)
+    {
+        startAddr += Arm9FooterSize;
+        size -= Arm9FooterSize;
+    }
+
+    return ndsFactory.writePaddingToFile(
+        paddingType,
+        savePath,
+        startAddr,
+        size);
+}
+
+NFResult MainWindow::writeArm9Overlay(const std::string& savePath)
+{
+    return ndsFactory.writeSectionToFile(
+        ui->loadedArm9OverlayPathEdt->text().toStdString(),
+        savePath,
+        extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16),
+        extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16));
+}
+
+NFResult MainWindow::writeArm9OverlayFiles(const std::string& savePath)
+{
+    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) +
+        extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16);
+    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16) - startAddr;
+    return ndsFactory.writeSectionToFile(
+        ui->loadedArm9OverlayFilesPathEdt->text().toStdString(),
+        savePath,
+        startAddr,
+        size);
+}
+
+NFResult MainWindow::writeArm7Bin(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedArm7BinPathEdt->text().toStdString(),
@@ -134,7 +190,45 @@ bool MainWindow::writeArm7Bin(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16));
 }
 
-bool MainWindow::writeFnt(const std::string& savePath)
+NFResult MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePath)
+{
+    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16) +
+        extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16);
+    uint32_t size;
+    if (extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16) != 0)
+        size = extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16) - startAddr;
+    else
+        size = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16) - startAddr;
+
+    return ndsFactory.writePaddingToFile(
+        paddingType,
+        savePath,
+        startAddr,
+        size);
+}
+
+NFResult MainWindow::writeArm7Overlay(const std::string& savePath)
+{
+    return ndsFactory.writeSectionToFile(
+        ui->loadedArm7OverlayPathEdt->text().toStdString(),
+        savePath,
+        extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16),
+        extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlaySize).toUInt(nullptr, 16));
+}
+
+NFResult MainWindow::writeArm7OverlayFiles(const std::string& savePath)
+{
+    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16) +
+        extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlaySize).toUInt(nullptr, 16);
+    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16) - startAddr;
+    return ndsFactory.writeSectionToFile(
+        ui->loadedArm7OverlayFilesPathEdt->text().toStdString(),
+        savePath,
+        startAddr,
+        size);
+}
+
+NFResult MainWindow::writeFnt(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedFntPathEdt->text().toStdString(),
@@ -143,7 +237,20 @@ bool MainWindow::writeFnt(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16));
 }
 
-bool MainWindow::writeFat(const std::string& savePath)
+NFResult MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
+{
+    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16) +
+        extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16);
+    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::FATAddress).toUInt(nullptr, 16) - startAddr;
+
+    return ndsFactory.writePaddingToFile(
+        paddingType,
+        savePath,
+        startAddr,
+        size);
+}
+
+NFResult MainWindow::writeFat(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedFatPathEdt->text().toStdString(),
@@ -152,35 +259,20 @@ bool MainWindow::writeFat(const std::string& savePath)
                 extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16));
 }
 
-bool MainWindow::writeArm9Overlay(const std::string& savePath)
+NFResult MainWindow::writeFatPadding(char paddingType, const std::string& savePath)
 {
-    return ndsFactory.writeSectionToFile(
+    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::FATAddress).toUInt(nullptr, 16) +
-                ui->loadedArm9OverlayPathEdt->text().toStdString(),
+        extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16);
-                savePath,
+    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::IconTitleAddress).toUInt(nullptr, 16) - startAddr;
-                extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16),
+
-                extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16));
+    return ndsFactory.writePaddingToFile(
+        paddingType,
+        savePath,
+        startAddr,
+        size);
 }
 
-bool MainWindow::writeArm9OverlayFiles([[maybe_unused]] const std::string& savePath)
+NFResult MainWindow::writeIconTitle(const std::string& savePath)
-{
-    return false; // TODO: implement me!
-}
-
-bool MainWindow::writeArm7Overlay(const std::string& savePath)
-{
-    return ndsFactory.writeSectionToFile(
-                ui->loadedArm7OverlayPathEdt->text().toStdString(),
-                savePath,
-                extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16),
-                extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16));
-}
-
-bool MainWindow::writeArm7OverlayFiles([[maybe_unused]] const std::string& savePath)
-{
-    return false; // TODO: implement me!
-}
-
-bool MainWindow::writeIconTitle(const std::string& savePath)
 {
     return ndsFactory.writeSectionToFile(
                 ui->loadedIconTitlePathEdt->text().toStdString(),
@@ -189,7 +281,7 @@ bool MainWindow::writeIconTitle(const std::string& savePath)
                 IconTitleSize);
 }
 
-bool MainWindow::writeFatFiles(const std::string& savePath)
+NFResult 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;
@@ -201,95 +293,7 @@ bool MainWindow::writeFatFiles(const std::string& savePath)
                 size);
 }
 
-bool MainWindow::writeHeaderPadding(char paddingType, const std::string& savePath)
+NFResult MainWindow::writeRomPadding(const std::string& savePath)
-{
-    uint32_t startAddr = sizeof(NDSHeader);
-    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16) - startAddr;
-
-    return ndsFactory.writePaddingToFile(
-                paddingType,
-                savePath,
-                startAddr,
-                size);
-}
-
-bool MainWindow::writeArm9BinPadding(char paddingType, const std::string& savePath, bool isFooterPresent)
-{ // FIXME check ARM9 Overlay
-    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16) +
-            extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16);
-    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16) - startAddr;
-
-    if (isFooterPresent)
-        size -= Arm9FooterSize;
-
-    return ndsFactory.writePaddingToFile(
-                paddingType,
-                savePath,
-                startAddr,
-                size);
-}
-
-bool MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePath)
-{  // FIXME check ARM7 Overlay
-    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16) +
-            extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16);
-    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16) - startAddr;
-
-    return ndsFactory.writePaddingToFile(
-                paddingType,
-                savePath,
-                startAddr,
-                size);
-}
-
-bool MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
-{
-    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16) +
-            extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16);
-    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::FATAddress).toUInt(nullptr, 16) - startAddr;
-
-    return ndsFactory.writePaddingToFile(
-                paddingType,
-                savePath,
-                startAddr,
-                size);
-}
-
-bool MainWindow::writeFatPadding(char paddingType, const std::string& savePath)
-{
-    uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::FATAddress).toUInt(nullptr, 16) +
-            extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16);
-    uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::IconTitleAddress).toUInt(nullptr, 16) - startAddr;
-
-    return ndsFactory.writePaddingToFile(
-                paddingType,
-                savePath,
-                startAddr,
-                size);
-}
-
-bool MainWindow::writeArm9OverlayPadding([[maybe_unused]] char paddingType, [[maybe_unused]] const std::string& savePath)
-{   // FIXME TODO
-    return true;
-}
-
-bool MainWindow::writeArm9OverlayFilesPadding([[maybe_unused]] char paddingType, [[maybe_unused]] const std::string& savePath)
-{   // FIXME TODO
-    return true;
-}
-
-bool MainWindow::writeArm7OverlayPadding([[maybe_unused]] char paddingType, [[maybe_unused]] const std::string& savePath)
-{   // FIXME TODO
-    return true;
-}
-
-
-bool MainWindow::writeArm7OverlayFilesPadding([[maybe_unused]] char paddingType, [[maybe_unused]] const std::string& savePath)
-{   // FIXME TODO
-    return true;
-}
-
-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;
@@ -301,12 +305,12 @@ bool MainWindow::writeRomPadding(const std::string& savePath)
                  size);
 }
 
-bool MainWindow::writeEverything(const std::string& savePath)
+NFResult MainWindow::writeEverything(const std::string& savePath)
 {
-    bool res = true;
+	NFResult nfResult;
     char paddingType;
     bool isArm9FooterPresent = ndsFactory.checkArm9FooterPresence(ui->loadedArm9BinPathEdt->text().toStdString(),
-                                                                  extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16));
+        extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16));
     if (ui->packerPadType00RdBtn->isChecked())
         paddingType = static_cast<char>('\x00');
     else
@@ -314,35 +318,49 @@ bool MainWindow::writeEverything(const std::string& savePath)
 
     std::remove(savePath.c_str());
 
-    res &= writeHeader(savePath);
+    nfResult = writeHeader(savePath);
-    res &= writeHeaderPadding(paddingType, savePath);
+    if (!nfResult.result) return nfResult;
-    res &= writeArm9Bin(savePath, isArm9FooterPresent);
+    nfResult = writeHeaderPadding(paddingType, savePath);
-    res &= writeArm9BinPadding(paddingType, savePath, isArm9FooterPresent);
+    if (!nfResult.result) return nfResult;
-    res &= writeArm7Bin(savePath);
+    nfResult = writeArm9Bin(savePath, isArm9FooterPresent);
-    res &= writeArm7BinPadding(paddingType, savePath);
+    if (!nfResult.result) return nfResult;
-    res &= writeFnt(savePath);
+    nfResult = writeArm9BinPadding(paddingType, savePath, isArm9FooterPresent);
-    res &= writeFntPadding(paddingType, savePath);
+    if (!nfResult.result) return nfResult;
-    res &= writeFat(savePath);
+    if (extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) != 0)
-    res &= writeFatPadding(paddingType, savePath);
+    {
-    if(extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) != 0) {
+        nfResult = writeArm9Overlay(savePath);
-        res &= writeArm9Overlay(savePath);
+        if (!nfResult.result) return nfResult;
-        res &= writeArm9OverlayPadding(paddingType, savePath);
+        nfResult = writeArm9OverlayFiles(savePath);
-        res &= writeArm9OverlayFiles(savePath);
+        if (!nfResult.result) return nfResult;
-        res &= writeArm9OverlayFilesPadding(paddingType, savePath);
     }
-    if(extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) != 0) {
+    nfResult = writeArm7Bin(savePath);
-        res &= writeArm7Overlay(savePath);
+    if (!nfResult.result) return nfResult;
-        res &= writeArm7OverlayPadding(paddingType, savePath);
+    nfResult = writeArm7BinPadding(paddingType, savePath);
-        res &= writeArm7OverlayFiles(savePath);
+    if (!nfResult.result) return nfResult;
-        res &= writeArm7OverlayFilesPadding(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 &= writeIconTitle(savePath);
+    nfResult = writeFnt(savePath);
-    res &= writeFatFiles(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;
     if(!ui->packerTrimRomsCbx->isChecked())
     {
-        res &= writeRomPadding(savePath);
+        nfResult = writeRomPadding(savePath);
+        if (!nfResult.result) return nfResult;
     }
-    return res;
+	return { true, "" };
 }
 
 QString MainWindow::extractPackerHeaderTableData(int index)

ui/tabs/packer/packertabsignals.cpp

@@ -2,6 +2,7 @@
 #include <QMessageBox>
 #include "./../../mainwindow.h"
 #include "./../../ui_mainwindow.h"
+#include "./../../utils/filepicker.h"
 #include "../commons/headernames.h"
 
 
@@ -15,13 +16,9 @@ void MainWindow::on_packerLoadHeaderBtn_clicked()
           QDir::currentPath(),
           "NDS Header (*.bin)");
 
-    if(headerPath.isNull())
+    if (headerPath.isNull()) return;
-    {
-        QMessageBox::critical(this, tr("NDS Factory"), tr("Unable to open file!"));
-        return;
-    }
 
-    if (ndsFactory.loadRomHeader(headerPath.toStdString(), romHeader))
+    if (ndsFactory.loadRomHeader(headerPath.toStdString(), romHeader).result)
     {
         pNDSHeader = reinterpret_cast<NDSHeader*>(romHeader.data());
         populatePackerSectionHeader(pNDSHeader);
@@ -35,7 +32,7 @@ void MainWindow::on_packerLoadArm9BinBtn_clicked()
     QString arm9BinPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Arm9Bin",
-          QDir::currentPath(),
+          "",
           "NDS Arm9Bin (*.bin)");
 
     if(!arm9BinPath.isNull())
@@ -49,7 +46,7 @@ void MainWindow::on_packerLoadArm7BinBtn_clicked()
     QString arm7BinPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Arm7Bin",
-          QDir::currentPath(),
+          "",
           "NDS Arm7Bin (*.bin)");
 
     if(!arm7BinPath.isNull())
@@ -63,7 +60,7 @@ void MainWindow::on_packerLoadFntBtn_clicked()
     QString fntPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Fnt",
-          QDir::currentPath(),
+          "",
           "NDS Fnt (*.bin)");
 
     if(!fntPath.isNull())
@@ -77,7 +74,7 @@ void MainWindow::on_packerLoadFatBtn_clicked()
     QString fatPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Fat",
-          QDir::currentPath(),
+          "",
           "NDS Fat (*.bin)");
 
     if(!fatPath.isNull())
@@ -91,7 +88,7 @@ void MainWindow::on_packerLoadArm9OverlayBtn_clicked()
     QString arm9OverlayPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Arm9Overlay",
-          QDir::currentPath(),
+          "",
           "NDS A9OVR (*.bin)");
 
     if( !arm9OverlayPath.isNull() )
@@ -105,7 +102,7 @@ void MainWindow::on_packerLoadArm9OverlayFilesBtn_clicked()
     QString arm9OverlayFilesPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Arm9Overlay Data",
-          QDir::currentPath(),
+          "",
           "NDS A9OVR_DATA (*.bin)");
 
     if(!arm9OverlayFilesPath.isNull())
@@ -119,7 +116,7 @@ void MainWindow::on_packerLoadArm7OverlayBtn_clicked()
     QString arm7OverlayPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Arm7Overlay",
-          QDir::currentPath(),
+          "",
           "NDS A7OVR (*.bin)");
 
     if(!arm7OverlayPath.isNull())
@@ -133,7 +130,7 @@ void MainWindow::on_packerLoadArm7OverlayFilesBtn_clicked()
     QString arm7OverlayFilesPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Arm7Overlay Data",
-          QDir::currentPath(),
+          "",
           "NDS A7OVR_DATA (*.bin)");
 
     if(!arm7OverlayFilesPath.isNull())
@@ -147,7 +144,7 @@ void MainWindow::on_packerLoadIconTitleBtn_clicked()
     QString iconTitlePath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS IconTitleLogo",
-          QDir::currentPath(),
+          "",
           "NDS ITL (*.bin)");
 
     if(!iconTitlePath.isNull())
@@ -161,7 +158,7 @@ void MainWindow::on_packerLoadFatFilesBtn_clicked()
     QString fatFilesPath = QFileDialog::getOpenFileName(
           Q_NULLPTR,
           "NDS Fat Data",
-          QDir::currentPath(),
+          "",
           "NDS FAT_DATA (*.bin)");
 
     if(!fatFilesPath.isNull())
@@ -172,17 +169,19 @@ void MainWindow::on_packerLoadFatFilesBtn_clicked()
 
 void MainWindow::on_packerBuildNDSRomBtn_clicked()
 {
-    QString dirPath = QFileDialog::getSaveFileName(
+	ui->packerBuildNDSRomBtn->setEnabled(false);
-          Q_NULLPTR,
+
-          "NDS Rom",
+    QString dirPath = customSaveFileDialog("NDS Rom",
-          "rom.nds",
+        "rom.nds",
-          "NDS ROM (*.nds)");
+        "NDS ROM (*.nds)");
 
     if (!dirPath.isNull())
     {
-        writeEverything(dirPath.toStdString()) ? QMessageBox::information(this, tr("NDS Factory"), tr("Creation completed!"))
+        NFResult nfResult = writeEverything(dirPath.toStdString());
-                                               : QMessageBox::critical(this, tr("NDS Factory"), tr("Error during the creation!"));
+        nfResult.result? QMessageBox::information(this, tr("NDSFactory"), tr("Creation completed!"))
+            : QMessageBox::critical(this, tr("NDSFactory"), nfResult.message.c_str());
     }
+    ui->packerBuildNDSRomBtn->setEnabled(true);
 }
 
 void MainWindow::on_packerCalcHeaderCrcBtn_clicked()

ui/tabs/unpacker/unpackertabfunctions.cpp

@@ -8,18 +8,6 @@
 #include "../../models/ndsheadermodel.h"
 #include "../../../ndsfactory/fatstruct.h"
 
-// Byte offsets for interpreting memory
-#define SECOND_BYTE_SHIFT 8
-#define THIRD_BYTE_SHIFT 16
-#define FOURTH_BYTE_SHIFT 24
-
-// Magic values for FAT extraction
-#define CONTROL_BYTE_LENGTH_MASK 0x7F
-#define CONTROL_BYTE_DIR_MASK 0x80
-#define DUMMY_CONTROL_VALUE 0xFF
-#define FNT_HEADER_OFFSET_MASK 0XFFF
-#define ROOT_DIRECTORY_ADDRESS 0xF000
-
 // Size constants
 #define ICON_TITLE_SIZE 0xA00
 
@@ -35,14 +23,26 @@ void MainWindow::enableExtractionButtons()
 {
     ui->unpackerExtractorGbx->setEnabled(true);
     ui->unpackerExtraGbx->setEnabled(true);
-    if (ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr,16) == 0){
+    if (ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr,16) == 0)
+    {
         ui->unpackerDumpArm9OverlayBtn->setEnabled(false);
         ui->unpackerDumpArm9OverlayFilesBtn->setEnabled(false);
     }
-    if (ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr,16) == 0){
+    else
+	{
+		ui->unpackerDumpArm9OverlayBtn->setEnabled(true);
+		ui->unpackerDumpArm9OverlayFilesBtn->setEnabled(true);
+	}
+    if (ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr,16) == 0)
+    {
         ui->unpackerDumpArm7OverlayBtn->setEnabled(false);
         ui->unpackerDumpArm7OverlayFilesBtn->setEnabled(false);
     }
+    else
+    {
+		ui->unpackerDumpArm7OverlayBtn->setEnabled(true);
+		ui->unpackerDumpArm7OverlayFilesBtn->setEnabled(true);
+    }
 }
 
 void MainWindow::disableExtractionButtons()
@@ -51,7 +51,7 @@ void MainWindow::disableExtractionButtons()
     ui->unpackerExtraGbx->setEnabled(false);
 }
 
-bool MainWindow::dumpHeader(const std::string& dirPath)
+NFResult MainWindow::dumpHeader(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -60,7 +60,7 @@ bool MainWindow::dumpHeader(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::HeaderSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes)
+NFResult 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 @@ bool MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes)
                 size);
 }
 
-bool MainWindow::dumpArm7Bin(const std::string& dirPath)
+NFResult MainWindow::dumpArm7Bin(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -81,7 +81,7 @@ bool MainWindow::dumpArm7Bin(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7Size, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpFnt(const std::string& dirPath)
+NFResult MainWindow::dumpFnt(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -90,7 +90,7 @@ bool MainWindow::dumpFnt(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FilenameTableSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpFat(const std::string& dirPath)
+NFResult MainWindow::dumpFat(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -99,7 +99,7 @@ bool MainWindow::dumpFat(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FATSize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpArm9Overlay(const std::string& dirPath)
+NFResult MainWindow::dumpArm9Overlay(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -108,12 +108,20 @@ bool MainWindow::dumpArm9Overlay(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlaySize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpArm9OverlayFiles([[maybe_unused]] const std::string& dirPath)
+NFResult MainWindow::dumpArm9OverlayFiles(const std::string& dirPath)
 {
-    return false; // TODO: implement me!
+    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);
+	uint32_t size = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7RomAddress, 1).data().toString().toUInt(nullptr, 16) - startAddr;
+
+    return ndsFactory.dumpDataFromFile(
+        ui->loadedRomPath->text().toStdString(),
+        dirPath,
+        startAddr,
+        size);
 }
 
-bool MainWindow::dumpArm7Overlay(const std::string& dirPath)
+NFResult MainWindow::dumpArm7Overlay(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -122,12 +130,20 @@ bool MainWindow::dumpArm7Overlay(const std::string& dirPath)
                 ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlaySize, 1).data().toString().toUInt(nullptr,16));
 }
 
-bool MainWindow::dumpArm7OverlayFiles([[maybe_unused]] const std::string& dirPath)
+NFResult MainWindow::dumpArm7OverlayFiles(const std::string& dirPath)
 {
-    return false; // TODO: implement me!
+    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);
+    uint32_t size = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FilenameTableAddress, 1).data().toString().toUInt(nullptr, 16) - startAddr;
+
+    return ndsFactory.dumpDataFromFile(
+        ui->loadedRomPath->text().toStdString(),
+        dirPath,
+        startAddr,
+        size);
 }
 
-bool MainWindow::dumpIconTitle(const std::string& dirPath)
+NFResult MainWindow::dumpIconTitle(const std::string& dirPath)
 {
     return ndsFactory.dumpDataFromFile(
                 ui->loadedRomPath->text().toStdString(),
@@ -136,7 +152,7 @@ bool MainWindow::dumpIconTitle(const std::string& dirPath)
                 ICON_TITLE_SIZE);
 }
 
-bool MainWindow::dumpFatFiles(const std::string& dirPath)
+NFResult 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;
@@ -149,170 +165,34 @@ bool MainWindow::dumpFatFiles(const std::string& dirPath)
 }
 
 
-bool MainWindow::dumpEverything(QString dirPath)
+NFResult MainWindow::dumpEverything(QString dirPath)
 {
-    bool result = true;
+    NFResult nfResult;
-    result &= dumpHeader(QDir::toNativeSeparators(dirPath+"/header.bin").toStdString());
+    nfResult = dumpHeader(QDir::toNativeSeparators(dirPath + "/header.bin").toStdString());
-    result &= dumpArm9Bin(QDir::toNativeSeparators(dirPath+"/arm9.bin").toStdString(), true);
+	if (!nfResult.result) return nfResult;
-    result &= dumpArm7Bin(QDir::toNativeSeparators(dirPath+"/arm7.bin").toStdString());
+    nfResult = dumpArm9Bin(QDir::toNativeSeparators(dirPath+"/arm9.bin").toStdString(), true);
-    result &= dumpFnt(QDir::toNativeSeparators(dirPath+"/fnt.bin").toStdString());
+    if (!nfResult.result) return nfResult;
-    result &= dumpFat(QDir::toNativeSeparators(dirPath+"/fat.bin").toStdString());
+    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;
     if(ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr,16) != 0) {
-		result &= dumpArm9Overlay(QDir::toNativeSeparators(dirPath+"/a9ovr.bin").toStdString());
+        nfResult = dumpArm9Overlay(QDir::toNativeSeparators(dirPath+"/a9ovr.bin").toStdString());
-		result &= dumpArm9OverlayFiles(QDir::toNativeSeparators(dirPath+"/a9ovr_data.bin").toStdString());
+        if (!nfResult.result) return nfResult;
+        nfResult = dumpArm9OverlayFiles(QDir::toNativeSeparators(dirPath+"/a9ovr_data.bin").toStdString());
+        if (!nfResult.result) return nfResult;
 	}
     if(ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr,16) != 0) {
-        result &= dumpArm7Overlay(QDir::toNativeSeparators(dirPath+"/a7ovr.bin").toStdString());
+        nfResult = dumpArm7Overlay(QDir::toNativeSeparators(dirPath+"/a7ovr.bin").toStdString());
-        result &= dumpArm7OverlayFiles(QDir::toNativeSeparators(dirPath+"/a7ovr_data.bin").toStdString());
+        if (!nfResult.result) return nfResult;
-        }
+        nfResult = dumpArm7OverlayFiles(QDir::toNativeSeparators(dirPath+"/a7ovr_data.bin").toStdString());
-    result &= dumpIconTitle(QDir::toNativeSeparators(dirPath+"/itl.bin").toStdString());
+        if (!nfResult.result) return nfResult;
-    result &= dumpFatFiles(QDir::toNativeSeparators(dirPath+"/fat_data.bin").toStdString());
+    }
-    return result;
+    nfResult = dumpIconTitle(QDir::toNativeSeparators(dirPath+"/itl.bin").toStdString());
-}
+    if (!nfResult.result) return nfResult;
-
+    nfResult = dumpFatFiles(QDir::toNativeSeparators(dirPath+"/fat_data.bin").toStdString());
-bool MainWindow::decodeFatFiles(QString dirPath)
+    if (!nfResult.result) return nfResult;
-{
+	return { true, "" };
-    // Prepare necessary info from ROM
-
-    std::string romPath = ui->loadedRomPath->text().toStdString(); // ROM itself
-
-    // Addresses of the file allocation table and file name table
-
-    uint32_t fatAddr = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FATAddress, 1).data().toString().toUInt(nullptr,16);
-    uint32_t fatSize = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FATSize, 1).data().toString().toUInt(nullptr,16);
-
-    // Sizes of these tables
-
-    uint32_t fntAddr = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FilenameTableAddress, 1).data().toString().toUInt(nullptr,16);
-    uint32_t fntSize = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FilenameTableSize, 1).data().toString().toUInt(nullptr,16);
-
-    // Buffers to receive the contents of the FAT and FNT
-
-    std::vector<char> fatBytes(static_cast<unsigned long>(fatSize));
-    std::vector<char> fntBytes(static_cast<unsigned long>(fntSize));
-
-    // Fill them
-
-    if(!ndsFactory.readBytesFromFile(fatBytes, romPath, fatAddr, fatSize)) return false;
-    if(!ndsFactory.readBytesFromFile(fntBytes, romPath, fntAddr, fntSize)) return false;
-
-    // Use the available FAT range struct and read the FAT bytes as such
-
-    FatRange* pfatrange = reinterpret_cast<FatRange*>(fatBytes.data());
-
-    // Recursive function that looks up FNT info to find file names and directory structures,
-    // And writes the ROM data in the ranges indicated by the FAT simultaneously.
-
-    auto parseFolder = [this, fntBytes, pfatrange, romPath](uint32_t folderId, std::string curPath, auto& parseFolder){
-
-        if(false) return false; // this is stupid, but it's C++
-        // If we take it out, the compiler will complain because it doesn't known the return type of the lambda
-        // But we can't make the lambda bool either...so this is the best option...
-
-        QDir curDir(QString::fromStdString(curPath)); // useful a bit later
-
-        uint32_t currentOffset = 8 * (folderId & FNT_HEADER_OFFSET_MASK); // offset for the current directory's info in the FNT header
-        // Only the lower 12 bit of the given offset are relevant
-
-        // ---------------------------------------------------------------------
-        // About how the FAT and FNT work :
-
-        // The FNT has two sections :
-        // a "header" where every entry contains :
-          // - a 4-byte address where the corresponding directory's data starts in the body
-          // - a 2-byte offset that is the index of the first file of the directory in the FAT
-          // (e.g. : if the offset is 42, the first file in the directory is situated at the ROM addresses stored in the 42nd FAT entry)
-          // (and its second will be 43, etc.)
-        // a "body" where every entry contains :
-         // - a length+status/control byte : lower 7 bits (control byte & 0x7F) are a length, highest bit (control byte & 0x80) is set if entry is a directory, and not set if it's a file
-         // - a name which length is the length portion of the previous control byte (e.g. : if the control byte was 0x83, the name is three bytes long)
-         // - if the entry is a directory, a 2-byte address (where only the lower 12 bit are relevant for some reason) at which this directory's info is located in the FNT header
-
-        // Thus, the FNT reading operation will consist in bouncing back and forth between body and header every time we must process a subdirectory
-        // Thank Heavens for random-access containers !
-
-        // ---------------------------------------------------------------------
-
-        // Get the 4-byte address for the folder data
-
-        uint32_t fntBodyOffset =
-          (uint32_t)((unsigned char) fntBytes[currentOffset+3] << (uint32_t) FOURTH_BYTE_SHIFT |
-          (unsigned char) fntBytes[currentOffset+2] << (uint32_t) THIRD_BYTE_SHIFT |
-          (unsigned char) fntBytes[currentOffset + 1] << (uint32_t) SECOND_BYTE_SHIFT |
-          (unsigned char) fntBytes[currentOffset]);
-        currentOffset+=4;
-
-        // Get the 2-byte offset for the folder's first file in the FAT
-
-        uint16_t fatOffset =
-          (uint16_t)((unsigned char) fntBytes[currentOffset+1] << SECOND_BYTE_SHIFT |
-          (unsigned char) fntBytes[currentOffset]);
-
-        // Jump to FNT body a specified address
-
-        currentOffset = fntBodyOffset;
-
-        uint8_t controlByte = DUMMY_CONTROL_VALUE;
-
-        while(true){
-
-            controlByte = fntBytes[currentOffset]; // Entry's control byte
-            if(controlByte==0) break; // A control byte of 0 terminates the directory's contents
-            currentOffset++;
-
-            uint8_t nameLength = controlByte & CONTROL_BYTE_LENGTH_MASK; // length of entry name
-            bool isDir = controlByte & CONTROL_BYTE_DIR_MASK; // set if entry is a directory
-
-            // Reconstitute name from bytes
-            // Btw I wish I could use the actual byte type but I have to comply with the software's choice of using char
-
-            std::vector<char> nameString;
-            for(size_t i = 0 ; i<nameLength ; i++) nameString.push_back(fntBytes[currentOffset++]);
-            std::string name(&nameString[0], (size_t)nameLength);
-
-            // We'll need this either way
-
-            QString newPath(QDir::toNativeSeparators(QString::fromStdString(curPath+"/"+name)));
-
-            if(isDir){
-
-                // Get the 2-byte address for this folder's info in the FNT header
-                uint16_t subFolderId = ((unsigned char) fntBytes[currentOffset+1] << SECOND_BYTE_SHIFT |
-                (unsigned char) fntBytes[currentOffset]);
-                currentOffset+=2;
-
-                // Now the QDir we created earlier comes into play :
-                // C++ doesn't automatically create directories (!!!) so we have to rely on QT to do that manually.
-                // Otherwise, the ofstream will not open,
-                // And even if we force it open, it will just write into nothingness !!!
-
-                if(!curDir.exists(newPath)) curDir.mkdir(newPath); // I don't think the check is even necessary, actually
-
-                // Jump back to the FNT header and repeat the process for subdirectory !
-
-                if(!parseFolder(subFolderId,newPath.toStdString(),parseFolder)) return false;
-
-            }
-            else{
-
-                // Remember we have the offset for the directory's first file in the FAT.
-                // From then, every file is just the next entry.
-                // So we just have to use that offset and increment it every time.
-
-                if(!ndsFactory.writeFatSectionToFile(
-                  romPath,
-                  pfatrange+fatOffset,
-                  newPath.toStdString()))
-                  return false;
-                fatOffset++;
-
-            }
-        }
-
-        return true;
-    };
-
-    // The root folder's ID is, obviously, 0 (only the lower 12-bit count!)
-
-    return parseFolder(ROOT_DIRECTORY_ADDRESS,dirPath.toStdString(),parseFolder);
 }

ui/tabs/unpacker/unpackertabsignals.cpp

@@ -3,6 +3,8 @@
 #include <QMessageBox>
 #include "./../../mainwindow.h"
 #include "./../../ui_mainwindow.h"
+#include "./../../utils/filepicker.h"
+#include "./../../utils/ui.h"
 
 
 void MainWindow::on_loadRomBtn_clicked()
@@ -15,12 +17,11 @@ void MainWindow::on_loadRomBtn_clicked()
           QDir::currentPath(),
           "NDS Rom (*.nds)");
 
-    if( !romPath.isNull() )
+    if (romPath.isNull()) return;
-    {
-      ui->loadedRomPath->setText(romPath.toUtf8());
-    }
 
-    if (ndsFactory.loadRomHeader(ui->loadedRomPath->text().toStdString(), romHeader))
+    ui->loadedRomPath->setText(romPath.toUtf8());
+
+    if (ndsFactory.loadRomHeader(ui->loadedRomPath->text().toStdString(), romHeader).result)
     {
         pNDSHeader = reinterpret_cast<NDSHeader*>(romHeader.data());
         populateHeader(pNDSHeader);
@@ -34,132 +35,135 @@ void MainWindow::on_loadRomBtn_clicked()
 
 void MainWindow::on_unpackerDumpHeaderBtn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpHeaderBtn->setEnabled(false);
-          Q_NULLPTR,
-          "NDS Header",
-          "header.bin",
-          "Binary (*.bin)");
 
-    if (!dirPath.isNull())
+    QString dirPath = customSaveFileDialog("NDS Header", "header.bin", "Binary (*.bin)");
-        notifyExtractionResult(dumpHeader(dirPath.toStdString()));
+
+    if (!dirPath.isNull()) notifyExtractionResult(dumpHeader(dirPath.toStdString()));
+
+	ui->unpackerDumpHeaderBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpArm9Btn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpArm9Btn->setEnabled(false);
-          Q_NULLPTR,
+
-          "NDS ARM9",
+	QString dirPath = customSaveFileDialog("NDS ARM9", "arm9.bin", "Binary (*.bin)");
-          "arm9.bin",
-          "Binary (*.bin)");
 
     QMessageBox::StandardButton dumpExtraBytes = QMessageBox::question(
                 this,
-                "NDS Factory",
+                "NDSFactory",
                 "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())
+    if (!dirPath.isNull()) notifyExtractionResult(dumpArm9Bin(dirPath.toStdString(), dumpExtraBytes == QMessageBox::Yes ? true : false));
-        notifyExtractionResult(dumpArm9Bin(dirPath.toStdString(), dumpExtraBytes == QMessageBox::Yes ? true : false));
+
+	ui->unpackerDumpArm9Btn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpArm7Btn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpArm7Btn->setEnabled(false);
-          Q_NULLPTR,
-          "NDS ARM7",
-          "arm7.bin",
-          "Binary (*.bin)");
 
-    if (!dirPath.isNull())
+    QString dirPath = customSaveFileDialog("NDS ARM7", "arm7.bin", "Binary (*.bin)");
-        notifyExtractionResult(dumpArm7Bin(dirPath.toStdString()));
+
+    if (!dirPath.isNull()) notifyExtractionResult(dumpArm7Bin(dirPath.toStdString()));
+
+	ui->unpackerDumpArm7Btn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpFntBtn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpFntBtn->setEnabled(false);
-          Q_NULLPTR,
-          "NDS FNT",
-          "fnt.bin",
-          "Binary (*.bin)");
 
-    if (!dirPath.isNull())
+    QString dirPath = customSaveFileDialog("NDS FNT", "fnt.bin", "Binary (*.bin)");
-        notifyExtractionResult(dumpFnt(dirPath.toStdString()));
+
+    if (!dirPath.isNull()) notifyExtractionResult(dumpFnt(dirPath.toStdString()));
+
+	ui->unpackerDumpFntBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpFatBtn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpFatBtn->setEnabled(false);
-          Q_NULLPTR,
-          "NDS FAT",
-          "fat.bin",
-          "Binary (*.bin)");
 
-    if (!dirPath.isNull())
+    QString dirPath = customSaveFileDialog("NDS FAT", "fat.bin", "Binary (*.bin)");
-        notifyExtractionResult(dumpFat(dirPath.toStdString()));
+
+    if (!dirPath.isNull()) notifyExtractionResult(dumpFat(dirPath.toStdString()));
+
+	ui->unpackerDumpFatBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpArm9OverlayBtn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpArm9OverlayBtn->setEnabled(false);
-          Q_NULLPTR,
-          "NDS ARM9 Overlay",
-          "a9ovr.bin",
-          "Binary (*.bin)");
 
-    if (!dirPath.isNull())
+    QString dirPath = customSaveFileDialog("NDS ARM9 Overlay", "a9ovr.bin", "Binary (*.bin)");
-        notifyExtractionResult(dumpArm9Overlay(dirPath.toStdString()));
+
+    if (!dirPath.isNull()) notifyExtractionResult(dumpArm9Overlay(dirPath.toStdString()));
+
+	ui->unpackerDumpArm9OverlayBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpArm7OverlayBtn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpArm7OverlayBtn->setEnabled(false);
-          Q_NULLPTR,
-          "NDS ARM7 Overlay",
-          "a7ovr.bin",
-          "Binary (*.bin)");
 
-    if (!dirPath.isNull())
+    QString dirPath = customSaveFileDialog("NDS ARM7 Overlay", "a7ovr.bin", "Binary (*.bin)");
-        notifyExtractionResult(dumpArm7Overlay(dirPath.toStdString()));
+
+    if (!dirPath.isNull()) notifyExtractionResult(dumpArm7Overlay(dirPath.toStdString()));
+
+	ui->unpackerDumpArm7OverlayBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpIconTitleLogoBtn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpIconTitleLogoBtn->setEnabled(false);
-          Q_NULLPTR,
-          "NDS IconTitleLogo",
-          "itl.bin",
-          "Binary (*.bin)");
 
-    if (!dirPath.isNull())
+    QString dirPath = customSaveFileDialog("NDS IconTitleLogo", "itl.bin", "Binary (*.bin)");
-        notifyExtractionResult(dumpIconTitle(dirPath.toStdString()));
+
+    if (!dirPath.isNull()) notifyExtractionResult(dumpIconTitle(dirPath.toStdString()));
+
+	ui->unpackerDumpIconTitleLogoBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpFatFilesBtn_clicked()
 {
-    QString dirPath =  QFileDialog::getSaveFileName(
+	ui->unpackerDumpFatFilesBtn->setEnabled(false);
-          Q_NULLPTR,
-          "NDS FAT Files",
-          "fat_data.bin",
-          "Binary (*.bin)");
 
-    if (!dirPath.isNull())
+    QString dirPath = customSaveFileDialog("NDS FAT Files", "fat_data.bin", "Binary (*.bin)");
-        notifyExtractionResult(dumpFatFiles(dirPath.toStdString()));
+
+    if (!dirPath.isNull()) notifyExtractionResult(dumpFatFiles(dirPath.toStdString()));
+
+	ui->unpackerDumpFatFilesBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpArm9OverlayFilesBtn_clicked()
 {
-    QMessageBox::warning(this, tr("NDS Factory"), tr("This function is currently not implemented!"));
+	ui->unpackerDumpArm9OverlayFilesBtn->setEnabled(false);
-    //dumpArm9OverlayFiles()
+
+    QString dirPath = customSaveFileDialog("NDS ARM9 Overlay Data", "a9ovr_data.bin", "Binary (*.bin)");
+
+	if (!dirPath.isNull()) notifyExtractionResult(dumpArm9OverlayFiles(dirPath.toStdString()));
+
+	ui->unpackerDumpArm9OverlayFilesBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpArm7OverlayFilesBtn_clicked()
 {
-    QMessageBox::warning(this, tr("NDS Factory"), tr("This function is currently not implemented!"));
+    ui->unpackerDumpArm7OverlayFilesBtn->setEnabled(false);
-    //dumpArm7OverlayFiles()
+
+	QString dirPath = customSaveFileDialog("NDS ARM7 Overlay Data", "a7ovr_data.bin", "Binary (*.bin)");
+
+	if (!dirPath.isNull())
+		notifyExtractionResult(dumpArm7OverlayFiles(dirPath.toStdString()));
+
+    ui->unpackerDumpArm7OverlayFilesBtn->setEnabled(true);
 }
 
 void MainWindow::on_unpackerDumpEverythingBtn_clicked()
 {
+    ui->unpackerDumpEverythingBtn->setEnabled(false);
     QString dirPath = QFileDialog::getExistingDirectory(
                 this, tr("Select Directory"),
                 "",
@@ -167,27 +171,5 @@ void MainWindow::on_unpackerDumpEverythingBtn_clicked()
 
     if (!dirPath.isNull())
         notifyExtractionResult(dumpEverything(dirPath));
-}
+    ui->unpackerDumpEverythingBtn->setEnabled(true);
-
-void MainWindow::on_unpackerDecodeFatFilesBtn_clicked()
-{
-    QString dirPath = QFileDialog::getExistingDirectory(
-                this, tr("Select Directory"),
-                "",
-                QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
-
-    if (!dirPath.isNull())
-        notifyExtractionResult(decodeFatFiles(dirPath));
-}
-
-void MainWindow::notifyExtractionResult(bool result)
-{
-    if(result)
-	{
-		QMessageBox::information(this, tr("NDS Factory"), tr("Extraction completed!"));
-	}
-	else
-	{
-		QMessageBox::critical(this, tr("NDS Factory"), tr("Error during the extraction!"));
-	}
 }

ui/utils/filepicker.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <QFileDialog>
+
+inline QString customSaveFileDialog(const QString& title, const QString& defaultName, const QString& filter)
+{
+
+    static QString lastUsedPath;
+
+    QString selectedPath = QFileDialog::getSaveFileName(
+        Q_NULLPTR,
+        title,
+        lastUsedPath + defaultName,
+        filter);
+
+    if (!selectedPath.isNull())
+        lastUsedPath = selectedPath.mid(0, selectedPath.lastIndexOf('/', Qt::CaseInsensitive)+1);
+
+    return selectedPath;
+}

ui/utils/theme.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <QApplication>
+#include <QPalette>
+#include <QSettings>
+#include <QMessageBox>
+
+inline void setDarkTheme(QApplication& app)
+{
+    QPalette darkPalette;
+    darkPalette.setColor(QPalette::Window, QColor(53, 53, 53));
+    darkPalette.setColor(QPalette::WindowText, Qt::white);
+    darkPalette.setColor(QPalette::Base, QColor(35, 35, 35));
+    darkPalette.setColor(QPalette::AlternateBase, QColor(53, 53, 53));
+    darkPalette.setColor(QPalette::ToolTipBase, Qt::white);
+    darkPalette.setColor(QPalette::ToolTipText, Qt::white);
+    darkPalette.setColor(QPalette::Text, Qt::white);
+    darkPalette.setColor(QPalette::Button, QColor(53, 53, 53));
+    darkPalette.setColor(QPalette::ButtonText, Qt::white);
+    darkPalette.setColor(QPalette::BrightText, Qt::red);
+    darkPalette.setColor(QPalette::Link, QColor(42, 130, 218));
+    darkPalette.setColor(QPalette::Highlight, QColor(42, 130, 218));
+    darkPalette.setColor(QPalette::HighlightedText, Qt::black);
+
+    app.setPalette(darkPalette);
+}
+
+inline void setLightTheme(QApplication& app)
+{
+    QPalette lightPalette;
+    lightPalette.setColor(QPalette::Window, QColor(240, 240, 240));
+    lightPalette.setColor(QPalette::WindowText, Qt::black);
+    lightPalette.setColor(QPalette::Base, QColor(255, 255, 255));
+    lightPalette.setColor(QPalette::AlternateBase, QColor(233, 233, 233));
+    lightPalette.setColor(QPalette::ToolTipBase, Qt::black);
+    lightPalette.setColor(QPalette::ToolTipText, Qt::white);
+    lightPalette.setColor(QPalette::Text, Qt::black);
+    lightPalette.setColor(QPalette::Button, QColor(240, 240, 240));
+    lightPalette.setColor(QPalette::ButtonText, Qt::black);
+    lightPalette.setColor(QPalette::BrightText, Qt::red);
+    lightPalette.setColor(QPalette::Link, QColor(42, 130, 218));
+    lightPalette.setColor(QPalette::Highlight, QColor(42, 130, 218));
+    lightPalette.setColor(QPalette::HighlightedText, Qt::white);
+
+    app.setPalette(lightPalette);
+}
+
+inline void setTheme(QString themeValue)
+{
+    QSettings settings;
+    settings.setValue("theme", themeValue);
+    QMessageBox::information(nullptr, "NDSFactory", "Restart NDSFactory to change theme!");
+
+}
+
+inline QString getCurrentTheme()
+{
+	QSettings settings;
+    return settings.value("theme", "default").toString();
+}

ui/utils/ui.h

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