Mathis/NDSFactory
1
0
Fork 0
mirror of https://github.com/Luca1991/NDSFactory.git synced 2025-07-08 21:20:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

UI redesign: now use QTableView (#12)

Browse Source 
* Switched to QTableView in Unpacker Tab

* Switched to QTableView in Packer Tab
This commit is contained in:
Luca D'Amico 2021-04-07 22:44:07 +02:00 committed by GitHub
parent f64b0702a4
commit 319d0e232e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 548 additions and 1514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
CMakeLists.txt
View File

@ -6,10 +6,12 @@ find_package(Qt5Core REQUIRED)
find_package(Qt5Gui REQUIRED)
find_package(Qt5Widgets REQUIRED)
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTOUIC ON)
include(${CMAKE_SOURCE_DIR}/sanitizers.cmake)
if(EXISTS "${CMAKE_SOURCE_DIR}/.git")
execute_process(
COMMAND git log -1 --format=%h
@ -32,8 +34,13 @@ file(GLOB_RECURSE DIALOGS_SOURCES ui/dialogs/*.cpp)
file(GLOB_RECURSE DIALOGS_UIS ui/dialogs/*.ui)
# Tabs
file(GLOB_RECURSE TABS_HEADERS ui/tabs/*.h)
file(GLOB_RECURSE TABS_SOURCES ui/tabs/*.cpp)
# Models
file(GLOB_RECURSE MODELS_HEADERS ui/models/*.h)
file(GLOB_RECURSE MODELS_SOURCES ui/models/*.cpp)
# NDSFactory
file(GLOB_RECURSE NDSFACTORY_SOURCES ndsfactory/*.cpp)
file(GLOB_RECURSE NDSFACTORY_HEADERS ndsfactory/*.h)
@ -43,12 +50,15 @@ set(SOURCES
ui/mainwindow.cpp
${NDSFACTORY_SOURCES}
${DIALOGS_SOURCES}
${MODELS_SOURCES}
${TABS_SOURCES}
)
SET(HEADERS
ui/mainwindow.h
${NDSFACTORY_HEADERS}
${TABS_HEADERS}
${MODELS_HEADERS}
${DIALOGS_HEADERS}
)

1
ndsfactory/ndsheader.h
View File

@ -70,5 +70,4 @@ struct NDSHeader
};
#pragma pack(pop)
#endif // NDSHEADER_H

55
sanitizers.cmake Normal file
View File

@ -0,0 +1,55 @@
# Build Types
set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}
CACHE STRING "Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel tsan asan lsan msan ubsan"
FORCE)
# ThreadSanitizer
set(CMAKE_C_FLAGS_TSAN
"-fsanitize=thread -g -O1"
CACHE STRING "Flags used by the C compiler during ThreadSanitizer builds."
FORCE)
set(CMAKE_CXX_FLAGS_TSAN
"-fsanitize=thread -g -O1"
CACHE STRING "Flags used by the C++ compiler during ThreadSanitizer builds."
FORCE)
# AddressSanitize
set(CMAKE_C_FLAGS_ASAN
"-fsanitize=address -fno-optimize-sibling-calls -fsanitize-address-use-after-scope -fno-omit-frame-pointer -g -O1"
CACHE STRING "Flags used by the C compiler during AddressSanitizer builds."
FORCE)
set(CMAKE_CXX_FLAGS_ASAN
"-fsanitize=address -fno-optimize-sibling-calls -fsanitize-address-use-after-scope -fno-omit-frame-pointer -g -O1"
CACHE STRING "Flags used by the C++ compiler during AddressSanitizer builds."
FORCE)
# LeakSanitizer
set(CMAKE_C_FLAGS_LSAN
"-fsanitize=leak -fno-omit-frame-pointer -g -O1"
CACHE STRING "Flags used by the C compiler during LeakSanitizer builds."
FORCE)
set(CMAKE_CXX_FLAGS_LSAN
"-fsanitize=leak -fno-omit-frame-pointer -g -O1"
CACHE STRING "Flags used by the C++ compiler during LeakSanitizer builds."
FORCE)
# MemorySanitizer
set(CMAKE_C_FLAGS_MSAN
"-fsanitize=memory -fno-optimize-sibling-calls -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer -g -O2"
CACHE STRING "Flags used by the C compiler during MemorySanitizer builds."
FORCE)
set(CMAKE_CXX_FLAGS_MSAN
"-fsanitize=memory -fno-optimize-sibling-calls -fsanitize-memory-track-origins=2 -fno-omit-frame-pointer -g -O2"
CACHE STRING "Flags used by the C++ compiler during MemorySanitizer builds."
FORCE)
# UndefinedBehaviour
set(CMAKE_C_FLAGS_UBSAN
"-fsanitize=undefined"
CACHE STRING "Flags used by the C compiler during UndefinedBehaviourSanitizer builds."
FORCE)
set(CMAKE_CXX_FLAGS_UBSAN
"-fsanitize=undefined"
CACHE STRING "Flags used by the C++ compiler during UndefinedBehaviourSanitizer builds."
FORCE)

BIN
screenshot.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 87 KiB

After

Width:  |  Height:  |  Size: 62 KiB

2
ui/dialogs/about/revision.h
View File

@ -1,6 +1,6 @@
#ifndef REVISION_H
#define REVISION_H
#define GIT_COMMIT_HASH "658ca1b"
#define GIT_COMMIT_HASH "0b9b628"
#endif

6
ui/mainwindow.h
View File

@ -59,6 +59,7 @@ private slots:
private:
Ui::MainWindow *ui;
NDSFactory ndsFactory;
std::vector<char> romHeader;
void populateHeader(NDSHeader* ndsHeader);
void enableExtractionButtons();
void disableExtractionButtons();
@ -76,6 +77,8 @@ private:
bool dumpEverything(QString dirPath);
void populatePackerSectionHeader(NDSHeader *ndsHeader);
void enableCalcCrcButton();
void enableBuildRomButton();
void generateHeader(NDSHeader* pRomHeader);
bool writeHeader(const std::string& savePath);
void calcHeaderCrc16();
@ -102,6 +105,9 @@ private:
bool writeArm7OverlayFilesPadding(char paddingByte, const std::string& savePath);
bool writeRomPadding(const std::string& savePath);
//QString extractUnpackerHeaderTableData(int index);
QString extractPackerHeaderTableData(int index);
bool decodeFatFiles();
bool patchFat(const std::string& loadPath, uint32_t shiftSize, const std::string& savePath);

1343
ui/mainwindow.ui
View File

File diff suppressed because it is too large Load Diff

190
ui/models/ndsheadermodel.cpp Normal file
View File

@ -0,0 +1,190 @@
#include <QMessageBox>
#include "ndsheadermodel.h"
#include "../../ndsfactory/ndsheader.h"
#include "../tabs/commons/headernames.h"
NDSHeaderModel::NDSHeaderModel(NDSHeader *ndsHeader, QObject *parent) : QAbstractTableModel(parent)
{
this->ndsHeader = ndsHeader;
}
int NDSHeaderModel::rowCount(const QModelIndex &parent) const
{
return static_cast<int>(ndsHeaderNamesArr.size());
}
int NDSHeaderModel::columnCount(const QModelIndex &parent) const
{
return 2;
}
QVariant NDSHeaderModel::data(const QModelIndex &index, int role) const
{
if(role == Qt::DisplayRole || role == Qt::EditRole)
{
if(index.column() == 0)
return QString::fromStdString(ndsHeaderNamesArr.at(static_cast<size_t>(index.row())));
else if(index.column() == 1) {
switch (index.row())
{
case 0: return QString::fromUtf8(ndsHeader->GameTitle, 0xC);
case 1: return QString::fromUtf8(ndsHeader->GameCode, 0x4);
case 2: return QString::fromUtf8(reinterpret_cast<char*>(ndsHeader->MakerCode), 0x2);
case 3: return QString::number(ndsHeader->UnitCode, 16);
case 4: return QString::number(ndsHeader->DeviceType, 16);
case 5: return QString::number(ndsHeader->DeviceSize, 16);
case 6: return QString::number(ndsHeader->RomVersion, 16);
case 7: return QString::number(ndsHeader->Flags, 16);
case 8: return QString::number(ndsHeader->Arm9RomAddr,16);
case 9: return QString::number(ndsHeader->Arm9EntryAddr,16);
case 10: return QString::number(ndsHeader->Arm9RamAddr,16);
case 11: return QString::number(ndsHeader->Arm9Size,16);
case 12: return QString::number(ndsHeader->Arm7RomAddr,16);
case 13: return QString::number(ndsHeader->Arm7EntryAddr,16);
case 14: return QString::number(ndsHeader->Arm7RamAddr,16);
case 15: return QString::number(ndsHeader->Arm7Size,16);
case 16: return QString::number(ndsHeader->FilenameTableAddr,16);
case 17: return QString::number(ndsHeader->FilenameSize,16);
case 18: return QString::number(ndsHeader->FATAddr,16);
case 19: return QString::number(ndsHeader->FATSize,16);
case 20: return QString::number(ndsHeader->Arm9OverlayAddr,16);
case 21: return QString::number(ndsHeader->Arm9OverlaySize,16);
case 22: return QString::number(ndsHeader->Arm7OverlayAddr,16);
case 23: return QString::number(ndsHeader->Arm7OverlaySize,16);
case 24: return QString::number(ndsHeader->NormalCommandsSettings,16);
case 25: return QString::number(ndsHeader->Key1CommandsSettings,16);
case 26: return QString::number(ndsHeader->IconTitleAddr,16);
case 27: return QString::number(ndsHeader->SecureAreaCRC16,16);
case 28: return QString::number(ndsHeader->SecureAreaLoadingTimeout,16);
case 29: return QString::number(ndsHeader->ARM9AutoLoadListRamAddr,16);
case 30: return QString::number(ndsHeader->ARM7AutoLoadListRamAddr,16);
case 31: return QString::number(ndsHeader->SecureAreaDisable,16);
case 32: return QString::number(ndsHeader->RomSize,16);
case 33: return QString::number(ndsHeader->HeaderSize,16);
case 34: return QByteArray::fromRawData(reinterpret_cast<char*>(ndsHeader->NintendoLogo), 0x9C).toHex();
case 35: return QString::number(ndsHeader->NintendoLogoCRC,16);
case 36: return QString::number(ndsHeader->HeaderCRC16,16);
case 37: return QString::number(ndsHeader->DebugRomAddr,16);
case 38: return QString::number(ndsHeader->DebugSize,16);
case 39: return QString::number(ndsHeader->DebugRamAddr,16);
case 40: return QString::number((ndsHeader->IconTitleAddr+IconTitleSize),16);
default: return QString("");
}
}
}
return QVariant();
}
bool NDSHeaderModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
if(role != Qt::EditRole)
return QAbstractTableModel::setData(index, value, role);
switch (index.row())
{
case 0:
{
std::fill_n(ndsHeader->GameTitle, 0xC, 0x0);
QString gameTitleStr = value.toString().toUpper();
size_t size = std::min<size_t>(gameTitleStr.size(), 0xC);
std::copy_n(qUtf8Printable(gameTitleStr), size, ndsHeader->GameTitle);
break;
}
case 1:
{
std::fill_n(ndsHeader->GameCode, 0x4, 0x0);
QString gameCodeStr = value.toString().toUpper();
size_t size = std::min<size_t>(gameCodeStr.size(), 0x4);
std::copy_n(qUtf8Printable(gameCodeStr), size, ndsHeader->GameCode);
break;
}
case 2:
{
std::fill_n(ndsHeader->MakerCode, 0x2, 0x0);
QString makerCodeStr = value.toString().toUpper();
size_t size = std::min<size_t>(makerCodeStr.size(), 0x2);
std::copy_n(qUtf8Printable(makerCodeStr), size, ndsHeader->MakerCode);
break;
}
case 3: ndsHeader->UnitCode = static_cast<unsigned char>(value.toString().toUInt(nullptr, 16)); break;
case 4: ndsHeader->DeviceType = static_cast<unsigned char>(value.toString().toUInt(nullptr, 16)); break;
case 5: ndsHeader->DeviceSize = static_cast<unsigned char>(value.toString().toUInt(nullptr, 16)); break;
case 6: ndsHeader->RomVersion = static_cast<unsigned char>(value.toString().toUInt(nullptr, 16)); break;
case 7: ndsHeader->Flags = static_cast<unsigned char>(value.toString().toUInt(nullptr, 16)); break;
case 8: ndsHeader->Arm9RomAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 9: ndsHeader->Arm9EntryAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 10: ndsHeader->Arm9RamAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 11: ndsHeader->Arm9Size = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 12: ndsHeader->Arm7RomAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 13: ndsHeader->Arm7EntryAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 14: ndsHeader->Arm7RamAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 15: ndsHeader->Arm7Size = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 16: ndsHeader->FilenameTableAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 17: ndsHeader->FilenameSize = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 18: ndsHeader->FATAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 19: ndsHeader->FATSize = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 20: ndsHeader->Arm9OverlayAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 21: ndsHeader->Arm9OverlaySize = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 22: ndsHeader->Arm7OverlayAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 23: ndsHeader->Arm7OverlaySize = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 24: ndsHeader->NormalCommandsSettings = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 25: ndsHeader->Key1CommandsSettings = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 26: ndsHeader->IconTitleAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 27: ndsHeader->SecureAreaCRC16 = static_cast<uint16_t>(value.toString().toUInt(nullptr, 16)); break;
case 28: ndsHeader->SecureAreaLoadingTimeout = static_cast<uint16_t>(value.toString().toUInt(nullptr, 16)); break;
case 29: ndsHeader->ARM9AutoLoadListRamAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 30: ndsHeader->ARM7AutoLoadListRamAddr = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 31: ndsHeader->SecureAreaDisable = static_cast<uint64_t>(value.toString().toUInt(nullptr, 16)); break;
case 32: ndsHeader->RomSize = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 33: ndsHeader->HeaderSize = static_cast<uint32_t>(value.toString().toUInt(nullptr, 16)); break;
case 34:
{
std::fill_n(ndsHeader->NintendoLogo, 0x9C, 0x0);
QByteArray nintendoLogoBytes = QByteArray::fromHex(qUtf8Printable(value.toString()));
size_t size = std::min<size_t>(nintendoLogoBytes.size(), 0x9C);
std::copy_n(std::begin(nintendoLogoBytes), size, ndsHeader->NintendoLogo);
break;
}
case 35: ndsHeader->NintendoLogoCRC = static_cast<uint16_t>(value.toString().toUInt(nullptr, 16)); break;
case 36: ndsHeader->HeaderCRC16 = static_cast<uint16_t>(value.toString().toUInt(nullptr, 16)); break;
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;
default: return false;
}
Q_EMIT this->dataChanged(index, index);
return true;
}
QVariant NDSHeaderModel::headerData(int section, Qt::Orientation orientation, int role) const
{
if(orientation == Qt::Horizontal)
{
if(role == Qt::DisplayRole)
{
switch(section)
{
case 0:
return "Name";
case 1:
return "Value";
}
}
}
return QVariant();
}
Qt::ItemFlags NDSHeaderModel::flags(const QModelIndex &index) const
{
if (index.isValid() && index.column() == 1 && isValueRowEditable)
return QAbstractItemModel::flags(index) | Qt::ItemIsEditable;
return QAbstractItemModel::flags(index);
}
void NDSHeaderModel::setValueRowEditable(bool isEditable)
{
isValueRowEditable = isEditable;
}

25
ui/models/ndsheadermodel.h Normal file
View File

@ -0,0 +1,25 @@
#ifndef NDSHEADERMODEL_H
#define NDSHEADERMODEL_H
#include <QAbstractTableModel>
struct NDSHeader;
class NDSHeaderModel : public QAbstractTableModel
{
Q_OBJECT
public:
explicit NDSHeaderModel(NDSHeader *ndsHeader, QObject *parent = nullptr);
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
bool setData(const QModelIndex &index, const QVariant &value, int role) override;
QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
Qt::ItemFlags flags(const QModelIndex &index) const override;
void setValueRowEditable(bool isEditable);
private:
NDSHeader *ndsHeader;
bool isValueRowEditable = false;
};
#endif // NDSHEADERMODEL_H

45
ui/tabs/commons/headernames.cpp Normal file
View File

@ -0,0 +1,45 @@
#include "headernames.h"
std::vector<std::string> ndsHeaderNamesArr = {
"Game Title",
"Game Code",
"Maker Code",
"Unit Code",
"Device Code",
"Card Size",
"Card Info",
"Flags",
"ARM9 Rom Address",
"ARM9 Entry Address",
"ARM9 Ram Address",
"ARM9 Size",
"ARM7 Rom Address",
"ARM7 Entry Address",
"ARM7 Ram Address",
"ARM7 Size",
"Filename Table Address",
"Filename Table Size",
"FAT Address",
"FAT Size",
"ARM9 Overlay Address",
"ARM9 Overlay Size",
"ARM7 Overlay Address",
"ARM7 Overlay Size",
"Port 40001A4h NC",
"Port 40001a4h KC",
"Icon/Title Address",
"Secure Area CRC16",
"Secure Area Timeout",
"ARM9 AL Ram Address",
"ARM7 AL Ram Address",
"Secure Area Disable",
"Used Rom Size",
"Header Size",
"Nintendo Logo",
"Nintendo Logo CRC",
"Header CRC",
"Debug Rom Address",
"Debug Size",
"Debug Ram Address",
"FAT Files Address"
};

56
ui/tabs/commons/headernames.h Normal file
View File

@ -0,0 +1,56 @@
#ifndef HEADERNAMES_H
#define HEADERNAMES_H
#include <array>
#include <string>
#include <vector>
extern std::vector<std::string> ndsHeaderNamesArr;
namespace NDSHeaderNames {
enum {
GameTitle,
GameCode,
MakerCode,
UnitCode,
DeviceCode,
CardSize,
CardInfo,
Flags,
ARM9RomAddress,
ARM9EntryAddress,
ARM9RamAddress,
ARM9Size,
ARM7RomAddress,
ARM7EntryAddress,
ARM7RamAddress,
ARM7Size,
FilenameTableAddress,
FilenameTableSize,
FATAddress,
FATSize,
ARM9OverlayAddress,
ARM9OverlaySize,
ARM7OverlayAddress,
ARM7OverlaySize,
Port40001A4hNC,
Port40001a4hKC,
IconTitleAddress,
SecureAreaCRC16,
SecureAreaTimeout,
ARM9ALRamAddress,
ARM7ALRamAddress,
SecureAreaDisable,
UsedRomSize,
HeaderSize,
NintendoLogo,
NintendoLogoCRC,
HeaderCRC,
DebugRomAddress,
DebugSize,
DebugRamAddress,
FATFilesAddress
};
}
#endif // HEADERNAMES_H

216
ui/tabs/packer/packertabfunctions.cpp
View File

@ -3,117 +3,88 @@
#include <algorithm>
#include "./../../mainwindow.h"
#include "./../../ui_mainwindow.h"
#include "../commons/headernames.h"
#include "../../models/ndsheadermodel.h"
void MainWindow::populatePackerSectionHeader(NDSHeader *ndsHeader)
{
ui->packerGameTitleEdt->setText(QString::fromUtf8(ndsHeader->GameTitle, 0xC));
ui->packerGameCodeEdt->setText(QString::fromUtf8(ndsHeader->GameCode, 0x4));
ui->packerMakerCodeEdt->setText(QString::fromUtf8(reinterpret_cast<char*>(ndsHeader->MakerCode), 0x2));
ui->packerUnitCodeEdt->setText(QString::number(ndsHeader->UnitCode, 16));
auto* headerDataModel = new NDSHeaderModel(ndsHeader);
headerDataModel->setValueRowEditable(true);
ui->packerHeaderDataTable->setModel(headerDataModel);
ui->packerHeaderDataTable->setEditTriggers(QAbstractItemView::AllEditTriggers);
ui->packerHeaderDataTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeMode::ResizeToContents);
ui->packerHeaderDataTable->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeMode::Stretch);
}
ui->packerDeviceCodeEdt->setText(QString::number(ndsHeader->DeviceType, 16));
ui->packerCardSizeEdt->setText(QString::number(ndsHeader->DeviceSize, 16));
ui->packerCardInfoEdt->setText(QString::number(ndsHeader->RomVersion, 16));
ui->packerFlagsEdt->setText(QString::number(ndsHeader->Flags, 16));
void MainWindow::enableCalcCrcButton()
{
ui->packerCalcHeaderCrcBtn->setEnabled(true);
}
ui->packerARM9RomAddrEdt->setText(QString::number(ndsHeader->Arm9RomAddr, 16));
ui->packerARM9EntryAddrEdt->setText(QString::number(ndsHeader->Arm9EntryAddr, 16));
ui->packerARM9RamAddrEdt->setText(QString::number(ndsHeader->Arm9RamAddr, 16));
ui->packerARM9SizeEdt->setText(QString::number(ndsHeader->Arm9Size, 16));
ui->packerARM7RomAddrEdt->setText(QString::number(ndsHeader->Arm7RomAddr, 16));
ui->packerARM7EntryAddrEdt->setText(QString::number(ndsHeader->Arm7EntryAddr, 16));
ui->packerARM7RamAddrEdt->setText(QString::number(ndsHeader->Arm7RamAddr, 16));
ui->packerARM7SizeEdt->setText(QString::number(ndsHeader->Arm7Size, 16));
ui->packerFilenameTableAddrEdt->setText(QString::number(ndsHeader->FilenameTableAddr, 16));
ui->packerFilenameTableSizeEdt->setText(QString::number(ndsHeader->FilenameSize, 16));
ui->packerFATAddrEdt->setText(QString::number(ndsHeader->FATAddr, 16));
ui->packerFATSizeEdt->setText(QString::number(ndsHeader->FATSize, 16));
ui->packerARM9OverlayAddrEdt->setText(QString::number(ndsHeader->Arm9OverlayAddr, 16));
ui->packerARM9OverlaySizeEdt->setText(QString::number(ndsHeader->Arm9OverlaySize, 16));
ui->packerARM7OverlayAddrEdt->setText(QString::number(ndsHeader->Arm7OverlayAddr, 16));
ui->packerARM7OverlaySizeEdt->setText(QString::number(ndsHeader->Arm7OverlaySize, 16));
ui->packerPortNCEdt->setText(QString::number(ndsHeader->NormalCommandsSettings, 16));
ui->packerPortKCEdt->setText(QString::number(ndsHeader->Key1CommandsSettings, 16));
ui->packerIconTitleEdt->setText(QString::number(ndsHeader->IconTitleAddr, 16));
ui->packerSecureAreaCRC16Edt->setText(QString::number(ndsHeader->SecureAreaCRC16, 16));
ui->packerSecureAreaTimeoutEdt->setText(QString::number(ndsHeader->SecureAreaLoadingTimeout, 16));
ui->packerARM9AURamAddrEdt->setText(QString::number(ndsHeader->ARM9AutoLoadListRamAddr, 16));
ui->packerARM7AURamAddrEdt->setText(QString::number(ndsHeader->ARM7AutoLoadListRamAddr, 16));
ui->packerSecureAreaDisableEdt->setText(QString::number(ndsHeader->SecureAreaDisable, 16));
ui->packerUsedRomSizeEdt->setText(QString::number(ndsHeader->RomSize, 16));
ui->packerHeaderSizeEdt->setText(QString::number(ndsHeader->HeaderSize, 16));
ui->packerNintendoLogoEdt->setText(QByteArray::fromRawData(reinterpret_cast<char*>(ndsHeader->NintendoLogo), 0x9C).toHex());
ui->packerNintendoLogoCRCEdt->setText(QString::number(ndsHeader->NintendoLogoCRC, 16));
ui->packerHeaderCRCEdt->setText(QString::number(ndsHeader->HeaderCRC16, 16));
ui->packerDebugRomAddrEdt->setText(QString::number(ndsHeader->DebugRomAddr, 16));
ui->packerDebugSizeEdt->setText(QString::number(ndsHeader->DebugSize, 16));
ui->packerDebugRamAddrEdt->setText(QString::number(ndsHeader->DebugRamAddr, 16));
void MainWindow::enableBuildRomButton()
{
ui->packerBuildNDSRomBtn->setEnabled(true);
}
void MainWindow::generateHeader(NDSHeader* pRomHeader)
{
std::copy_n(ui->packerGameTitleEdt->text().toLatin1().data(), 0xc, std::begin(pRomHeader->GameTitle));
std::copy_n(ui->packerGameCodeEdt->text().toStdString().data(), 0x4, std::begin(pRomHeader->GameCode));
std::copy_n(ui->packerMakerCodeEdt->text().toStdString().data(), 0x2, std::begin(pRomHeader->MakerCode));
pRomHeader->UnitCode = static_cast<unsigned char>(ui->packerUnitCodeEdt->text().toUInt(nullptr, 16));
std::copy_n(extractPackerHeaderTableData(NDSHeaderNames::GameTitle).toLatin1().data(), 0xc, std::begin(pRomHeader->GameTitle));
pRomHeader->DeviceType = static_cast<unsigned char>(ui->packerDeviceCodeEdt->text().toUInt(nullptr, 16));
pRomHeader->DeviceSize = static_cast<unsigned char>(ui->packerCardSizeEdt->text().toUInt(nullptr, 16));
std::copy_n(extractPackerHeaderTableData(NDSHeaderNames::GameCode).toLatin1().data(), 0x4, std::begin(pRomHeader->GameCode));
std::copy_n(extractPackerHeaderTableData(NDSHeaderNames::MakerCode).toLatin1().data(), 0x2, std::begin(pRomHeader->MakerCode));
pRomHeader->UnitCode = static_cast<unsigned char>(extractPackerHeaderTableData(NDSHeaderNames::UnitCode).toUInt(nullptr, 16));
pRomHeader->DeviceType = static_cast<unsigned char>(extractPackerHeaderTableData(NDSHeaderNames::DeviceCode).toUInt(nullptr, 16));
pRomHeader->DeviceSize = static_cast<unsigned char>(extractPackerHeaderTableData(NDSHeaderNames::CardSize).toUInt(nullptr, 16));
std::fill(std::begin(pRomHeader->Reserved1), std::end(pRomHeader->Reserved1), 0);
pRomHeader->RomVersion = static_cast<unsigned char>(ui->packerCardInfoEdt->text().toUInt(nullptr, 16));
pRomHeader->Flags = static_cast<unsigned char>(ui->packerFlagsEdt->text().toUInt(nullptr, 16));
pRomHeader->RomVersion = static_cast<unsigned char>(extractPackerHeaderTableData(NDSHeaderNames::CardInfo).toUInt(nullptr, 16));
pRomHeader->Flags = static_cast<unsigned char>(extractPackerHeaderTableData(NDSHeaderNames::Flags).toUInt(nullptr, 16));
pRomHeader->Arm9RomAddr = ui->packerARM9RomAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm9EntryAddr = ui->packerARM9EntryAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm9RamAddr = ui->packerARM9RamAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm9Size = ui->packerARM9SizeEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm9RomAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16);
pRomHeader->Arm9EntryAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9EntryAddress).toUInt(nullptr, 16);
pRomHeader->Arm9RamAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9RamAddress).toUInt(nullptr, 16);
pRomHeader->Arm9Size = extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16);
pRomHeader->Arm7RomAddr = ui->packerARM7RomAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm7EntryAddr = ui->packerARM7EntryAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm7RamAddr = ui->packerARM7RamAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm7Size = ui->packerARM7SizeEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm7RomAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16);
pRomHeader->Arm7EntryAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7EntryAddress).toUInt(nullptr, 16);
pRomHeader->Arm7RamAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7RamAddress).toUInt(nullptr, 16);
pRomHeader->Arm7Size = extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16);
pRomHeader->FilenameTableAddr = ui->packerFilenameTableAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->FilenameSize = ui->packerFilenameTableSizeEdt->text().toUInt(nullptr, 16);
pRomHeader->FATAddr = ui->packerFATAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->FATSize = ui->packerFATSizeEdt->text().toUInt(nullptr, 16);
pRomHeader->FilenameTableAddr = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16);
pRomHeader->FilenameSize = extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16);
pRomHeader->FATAddr = extractPackerHeaderTableData(NDSHeaderNames::FATAddress).toUInt(nullptr, 16);
pRomHeader->FATSize = extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16);
pRomHeader->Arm9OverlayAddr = ui->packerARM9OverlayAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm9OverlaySize = ui->packerARM9OverlaySizeEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm7OverlayAddr = ui->packerARM7OverlayAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm7OverlaySize = ui->packerARM7OverlaySizeEdt->text().toUInt(nullptr, 16);
pRomHeader->Arm9OverlayAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16);
pRomHeader->Arm9OverlaySize = extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16);
pRomHeader->Arm7OverlayAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlayAddress).toUInt(nullptr, 16);
pRomHeader->Arm7OverlaySize = extractPackerHeaderTableData(NDSHeaderNames::ARM7OverlaySize).toUInt(nullptr, 16);
pRomHeader->NormalCommandsSettings = ui->packerPortNCEdt->text().toUInt(nullptr, 16);
pRomHeader->Key1CommandsSettings = ui->packerPortKCEdt->text().toUInt(nullptr, 16);
pRomHeader->IconTitleAddr = ui->packerIconTitleEdt->text().toUInt(nullptr, 16);
pRomHeader->SecureAreaCRC16 = ui->packerSecureAreaCRC16Edt->text().toUShort(nullptr, 16);
pRomHeader->NormalCommandsSettings = extractPackerHeaderTableData(NDSHeaderNames::Port40001A4hNC).toUInt(nullptr, 16);
pRomHeader->Key1CommandsSettings = extractPackerHeaderTableData(NDSHeaderNames::Port40001a4hKC).toUInt(nullptr, 16);
pRomHeader->IconTitleAddr = extractPackerHeaderTableData(NDSHeaderNames::IconTitleAddress).toUInt(nullptr, 16);
pRomHeader->SecureAreaCRC16 = extractPackerHeaderTableData(NDSHeaderNames::SecureAreaCRC16).toUShort(nullptr, 16);
pRomHeader->SecureAreaLoadingTimeout = ui->packerSecureAreaTimeoutEdt->text().toUShort(nullptr, 16);
pRomHeader->ARM9AutoLoadListRamAddr = ui->packerARM9AURamAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->ARM7AutoLoadListRamAddr = ui->packerARM7AURamAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->SecureAreaDisable = ui->packerSecureAreaDisableEdt->text().toULong(nullptr, 16);
pRomHeader->SecureAreaLoadingTimeout = extractPackerHeaderTableData(NDSHeaderNames::SecureAreaTimeout).toUShort(nullptr, 16);
pRomHeader->ARM9AutoLoadListRamAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM9ALRamAddress).toUInt(nullptr, 16);
pRomHeader->ARM7AutoLoadListRamAddr = extractPackerHeaderTableData(NDSHeaderNames::ARM7ALRamAddress).toUInt(nullptr, 16);
pRomHeader->SecureAreaDisable = extractPackerHeaderTableData(NDSHeaderNames::SecureAreaDisable).toULong(nullptr, 16);
pRomHeader->RomSize = ui->packerUsedRomSizeEdt->text().toUInt(nullptr, 16);
pRomHeader->HeaderSize = ui->packerHeaderSizeEdt->text().toUInt(nullptr, 16);
pRomHeader->RomSize = extractPackerHeaderTableData(NDSHeaderNames::UsedRomSize).toUInt(nullptr, 16);
pRomHeader->HeaderSize = extractPackerHeaderTableData(NDSHeaderNames::HeaderSize).toUInt(nullptr, 16);
std::fill(std::begin(pRomHeader->Reserved2), std::end(pRomHeader->Reserved2), 0);
std::copy_n(std::begin(QByteArray::fromHex(ui->packerNintendoLogoEdt->text().toUtf8())), 0x9C, std::begin(pRomHeader->NintendoLogo));
pRomHeader->NintendoLogoCRC = ui->packerNintendoLogoCRCEdt->text().toUShort(nullptr, 16);
std::copy_n(std::begin(QByteArray::fromHex(extractPackerHeaderTableData(NDSHeaderNames::NintendoLogo).toUtf8())), 0x9C, std::begin(pRomHeader->NintendoLogo));
pRomHeader->NintendoLogoCRC = extractPackerHeaderTableData(NDSHeaderNames::NintendoLogoCRC).toUShort(nullptr, 16);
pRomHeader->HeaderCRC16 = ui->packerHeaderCRCEdt->text().toUShort(nullptr, 16);
pRomHeader->DebugRomAddr = ui->packerDebugRomAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->DebugSize = ui->packerDebugSizeEdt->text().toUInt(nullptr, 16);
pRomHeader->DebugRamAddr = ui->packerDebugRamAddrEdt->text().toUInt(nullptr, 16);
pRomHeader->HeaderCRC16 = extractPackerHeaderTableData(NDSHeaderNames::HeaderCRC).toUShort(nullptr, 16);
pRomHeader->DebugRomAddr = extractPackerHeaderTableData(NDSHeaderNames::DebugRomAddress).toUInt(nullptr, 16);
pRomHeader->DebugSize = extractPackerHeaderTableData(NDSHeaderNames::DebugSize).toUInt(nullptr, 16);
pRomHeader->DebugRamAddr = extractPackerHeaderTableData(NDSHeaderNames::DebugRamAddress).toUInt(nullptr, 16);
std::fill(std::begin(pRomHeader->Reserved3), std::end(pRomHeader->Reserved3), 0);
std::fill(std::begin(pRomHeader->Reserved4), std::end(pRomHeader->Reserved4), 0);
@ -137,19 +108,19 @@ void MainWindow::calcHeaderCrc16()
generateHeader(pRomHeader);
ui->packerHeaderCRCEdt->setText(QString::number(ndsFactory.calcHeaderCrc16(romHeader), 16));
QModelIndex headerCrcIndex = ui->packerHeaderDataTable->model()->index(NDSHeaderNames::HeaderCRC, 1);
ui->packerHeaderDataTable->model()->setData(headerCrcIndex, QString::number(ndsFactory.calcHeaderCrc16(romHeader), 16), Qt::EditRole);
}
bool MainWindow::writeArm9Bin(const std::string& savePath, bool isArm9FooterPresent)
{
uint32_t size = ui->packerARM9SizeEdt->text().toUInt(nullptr, 16);
uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16);
if (isArm9FooterPresent)
size += Arm9FooterSize;
return ndsFactory.writeSectionToFile(
ui->loadedArm9BinPathEdt->text().toStdString(),
savePath,
ui->packerARM9RomAddrEdt->text().toUInt(nullptr, 16),
extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16),
size);
}
@ -158,8 +129,8 @@ bool MainWindow::writeArm7Bin(const std::string& savePath)
return ndsFactory.writeSectionToFile(
ui->loadedArm7BinPathEdt->text().toStdString(),
savePath,
ui->packerARM7RomAddrEdt->text().toUInt(nullptr, 16),
ui->packerARM7SizeEdt->text().toUInt(nullptr, 16));
extractPackerHeaderTableData(NDSHeaderNames::ARM7RomAddress).toUInt(nullptr, 16),
extractPackerHeaderTableData(NDSHeaderNames::ARM7Size).toUInt(nullptr, 16));
}
bool MainWindow::writeFnt(const std::string& savePath)
@ -167,8 +138,8 @@ bool MainWindow::writeFnt(const std::string& savePath)
return ndsFactory.writeSectionToFile(
ui->loadedFntPathEdt->text().toStdString(),
savePath,
ui->packerFilenameTableAddrEdt->text().toUInt(nullptr, 16),
ui->packerFilenameTableSizeEdt->text().toUInt(nullptr, 16));
extractPackerHeaderTableData(NDSHeaderNames::FilenameTableAddress).toUInt(nullptr, 16),
extractPackerHeaderTableData(NDSHeaderNames::FilenameTableSize).toUInt(nullptr, 16));
}
bool MainWindow::writeFat(const std::string& savePath)
@ -176,8 +147,8 @@ bool MainWindow::writeFat(const std::string& savePath)
return ndsFactory.writeSectionToFile(
ui->loadedFatPathEdt->text().toStdString(),
savePath,
ui->packerFATAddrEdt->text().toUInt(nullptr, 16),
ui->packerFATSizeEdt->text().toUInt(nullptr, 16));
extractPackerHeaderTableData(NDSHeaderNames::FATAddress).toUInt(nullptr, 16),
extractPackerHeaderTableData(NDSHeaderNames::FATSize).toUInt(nullptr, 16));
}
bool MainWindow::writeArm9Overlay(const std::string& savePath)
@ -185,8 +156,8 @@ bool MainWindow::writeArm9Overlay(const std::string& savePath)
return ndsFactory.writeSectionToFile(
ui->loadedArm9OverlayPathEdt->text().toStdString(),
savePath,
ui->packerARM9OverlayAddrEdt->text().toUInt(nullptr, 16),
ui->packerARM9OverlaySizeEdt->text().toUInt(nullptr, 16));
extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16),
extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16));
}
bool MainWindow::writeArm9OverlayFiles(const std::string& savePath)
@ -199,8 +170,8 @@ bool MainWindow::writeArm7Overlay(const std::string& savePath)
return ndsFactory.writeSectionToFile(
ui->loadedArm7OverlayPathEdt->text().toStdString(),
savePath,
ui->packerARM7OverlayAddrEdt->text().toUInt(nullptr, 16),
ui->packerARM7OverlaySizeEdt->text().toUInt(nullptr, 16));
extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16),
extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlaySize).toUInt(nullptr, 16));
}
bool MainWindow::writeArm7OverlayFiles(const std::string& savePath)
@ -213,14 +184,14 @@ bool MainWindow::writeIconTitle(const std::string& savePath)
return ndsFactory.writeSectionToFile(
ui->loadedIconTitlePathEdt->text().toStdString(),
savePath,
ui->packerIconTitleEdt->text().toUInt(nullptr, 16),
extractPackerHeaderTableData(NDSHeaderNames::IconTitleAddress).toUInt(nullptr, 16),
IconTitleSize);
}
bool MainWindow::writeFatFiles(const std::string& savePath)
{
uint32_t startAddr = ui->packerIconTitleEdt->text().toUInt(nullptr, 16) + IconTitleSize;
uint32_t size = ui->packerUsedRomSizeEdt->text().toUInt(nullptr, 16) - startAddr;
uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::IconTitleAddress).toUInt(nullptr, 16) + IconTitleSize;
uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::UsedRomSize).toUInt(nullptr, 16) - startAddr;
return ndsFactory.writeSectionToFile(
ui->loadedFatFilesPathEdt->text().toStdString(),
@ -232,7 +203,7 @@ bool MainWindow::writeFatFiles(const std::string& savePath)
bool MainWindow::writeHeaderPadding(char paddingType, const std::string& savePath)
{
uint32_t startAddr = sizeof(NDSHeader);
uint32_t size = ui->packerARM9RomAddrEdt->text().toUInt(nullptr, 16) - startAddr;
uint32_t size = extractPackerHeaderTableData(NDSHeaderNames::ARM9RomAddress).toUInt(nullptr, 16) - startAddr;
return ndsFactory.writePaddingToFile(
paddingType,
@ -243,8 +214,9 @@ bool MainWindow::writeHeaderPadding(char paddingType, const std::string& savePat
bool MainWindow::writeArm9BinPadding(char paddingType, const std::string& savePath, bool isFooterPresent)
{ // FIXME check ARM9 Overlay
uint32_t startAddr = ui->packerARM9RomAddrEdt->text().toUInt(nullptr, 16) + ui->packerARM9SizeEdt->text().toUInt(nullptr, 16);
uint32_t size = ui->packerARM7RomAddrEdt->text().toUInt(nullptr, 16) - startAddr;
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;
@ -258,8 +230,9 @@ bool MainWindow::writeArm9BinPadding(char paddingType, const std::string& savePa
bool MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePath)
{ // FIXME check ARM7 Overlay
uint32_t startAddr = ui->packerARM7RomAddrEdt->text().toUInt(nullptr, 16) + ui->packerARM7SizeEdt->text().toUInt(nullptr, 16);
uint32_t size = ui->packerFilenameTableAddrEdt->text().toUInt(nullptr, 16) - startAddr;
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,
@ -270,8 +243,9 @@ bool MainWindow::writeArm7BinPadding(char paddingType, const std::string& savePa
bool MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
{
uint32_t startAddr = ui->packerFilenameTableAddrEdt->text().toUInt(nullptr, 16) + ui->packerFilenameTableSizeEdt->text().toUInt(nullptr, 16);
uint32_t size = ui->packerFATAddrEdt->text().toUInt(nullptr, 16) - startAddr;
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,
@ -282,8 +256,9 @@ bool MainWindow::writeFntPadding(char paddingType, const std::string& savePath)
bool MainWindow::writeFatPadding(char paddingType, const std::string& savePath)
{
uint32_t startAddr = ui->packerFATAddrEdt->text().toUInt(nullptr, 16) + ui->packerFATSizeEdt->text().toUInt(nullptr, 16);
uint32_t size = ui->packerIconTitleEdt->text().toUInt(nullptr, 16) - startAddr;
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,
@ -315,8 +290,8 @@ bool MainWindow::writeArm7OverlayFilesPadding(char paddingType, const std::strin
bool MainWindow::writeRomPadding(const std::string& savePath)
{
uint32_t startAddr = ui->packerUsedRomSizeEdt->text().toUInt(nullptr, 16);
uint32_t size = static_cast<uint32_t>(ndsFactory.getCardSizeInBytes(ui->packerCardSizeEdt->text().toInt())) - startAddr;
uint32_t startAddr = extractPackerHeaderTableData(NDSHeaderNames::UsedRomSize).toUInt(nullptr, 16);
uint32_t size = static_cast<uint32_t>(ndsFactory.getCardSizeInBytes(extractPackerHeaderTableData(NDSHeaderNames::CardSize).toInt())) - startAddr;
return ndsFactory.writePaddingToFile(
static_cast<char>('\xff'),
@ -330,7 +305,7 @@ bool MainWindow::writeEverything(const std::string& savePath)
bool res = true;
char paddingType;
bool isArm9FooterPresent = ndsFactory.checkArm9FooterPresence(ui->loadedArm9BinPathEdt->text().toStdString(),
ui->packerARM9SizeEdt->text().toUInt(nullptr, 16));
extractPackerHeaderTableData(NDSHeaderNames::ARM9Size).toUInt(nullptr, 16));
if (ui->packerPadType00RdBtn->isChecked())
paddingType = static_cast<char>('\x00');
else
@ -346,13 +321,13 @@ bool MainWindow::writeEverything(const std::string& savePath)
res &= writeFntPadding(paddingType, savePath);
res &= writeFat(savePath);
res &= writeFatPadding(paddingType, savePath);
if(ui->packerARM9OverlayAddrEdt->text().toUInt(nullptr, 16) != 0) {
if(extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) != 0) {
res &= writeArm9Overlay(savePath);
res &= writeArm9OverlayPadding(paddingType, savePath);
res &= writeArm9OverlayFiles(savePath);
res &= writeArm9OverlayFilesPadding(paddingType, savePath);
}
if(ui->packerARM7OverlayAddrEdt->text().toUInt(nullptr, 16) != 0) {
if(extractPackerHeaderTableData(NDSHeaderNames::ARM9OverlayAddress).toUInt(nullptr, 16) != 0) {
res &= writeArm7Overlay(savePath);
res &= writeArm7OverlayPadding(paddingType, savePath);
res &= writeArm7OverlayFiles(savePath);
@ -366,3 +341,8 @@ bool MainWindow::writeEverything(const std::string& savePath)
}
return res;
}
QString MainWindow::extractPackerHeaderTableData(int index)
{
return ui->packerHeaderDataTable->model()->index(index, 1).data().toString();
}

6
ui/tabs/packer/packertabsignals.cpp
View File

@ -2,11 +2,11 @@
#include <QMessageBox>
#include "./../../mainwindow.h"
#include "./../../ui_mainwindow.h"
#include "../commons/headernames.h"
void MainWindow::on_packerLoadHeaderBtn_clicked()
{
std::vector<char> romHeader;
NDSHeader *pNDSHeader;
QString headerPath = QFileDialog::getOpenFileName(
@ -25,6 +25,8 @@ void MainWindow::on_packerLoadHeaderBtn_clicked()
{
pNDSHeader = reinterpret_cast<NDSHeader*>(romHeader.data());
populatePackerSectionHeader(pNDSHeader);
enableCalcCrcButton();
enableBuildRomButton();
}
}
@ -165,7 +167,6 @@ void MainWindow::on_packerLoadFatFilesBtn_clicked()
if(!fatFilesPath.isNull())
{
ui->loadedFatFilesPathEdt->setText(fatFilesPath.toUtf8());
ui->packerFatFilesAddrEdt->setText(QString::number((ui->packerIconTitleEdt->text().toUInt(nullptr, 16) + IconTitleSize), 16));
}
}
@ -184,7 +185,6 @@ void MainWindow::on_packerBuildNDSRomBtn_clicked()
}
}
void MainWindow::on_packerCalcHeaderCrcBtn_clicked()
{
calcHeaderCrc16();

104
ui/tabs/unpacker/unpackertabfunctions.cpp
View File

@ -3,76 +3,29 @@
#include <cstring>
#include <sstream>
#include <iomanip>
#include "./../../mainwindow.h"
#include "./../../ui_mainwindow.h"
#include "../../mainwindow.h"
#include "../../ui_mainwindow.h"
#include "../commons/headernames.h"
#include "../../models/ndsheadermodel.h"
void MainWindow::populateHeader(NDSHeader* ndsHeader)
{
ui->unpackerGameTitleEdt->setText(QString::fromUtf8(ndsHeader->GameTitle, 0xC));
ui->unpackerGameCodeEdt->setText(QString::fromUtf8(ndsHeader->GameCode, 0x4));
ui->unpackerMakerCodeEdt->setText(QString::fromUtf8(reinterpret_cast<char*>(ndsHeader->MakerCode), 0x2));
ui->unpackerUnitCodeEdt->setText(QString::number(ndsHeader->UnitCode, 16));
ui->unpackerDeviceCodeEdt->setText(QString::number(ndsHeader->DeviceType, 16));
ui->unpackerCardSizeEdt->setText(QString::number(ndsHeader->DeviceSize, 16));
ui->unpackerCardInfoEdt->setText(QString::number(ndsHeader->RomVersion, 16));
ui->unpackerFlagsEdt->setText(QString::number(ndsHeader->Flags, 16));
ui->unpackerARM9RomAddrEdt->setText(QString::number(ndsHeader->Arm9RomAddr,16));
ui->unpackerARM9EntryAddrEdt->setText(QString::number(ndsHeader->Arm9EntryAddr,16));
ui->unpackerARM9RamAddrEdt->setText(QString::number(ndsHeader->Arm9RamAddr,16));
ui->unpackerARM9SizeEdt->setText(QString::number(ndsHeader->Arm9Size,16));
ui->unpackerARM7RomAddrEdt->setText(QString::number(ndsHeader->Arm7RomAddr,16));
ui->unpackerARM7EntryAddrEdt->setText(QString::number(ndsHeader->Arm7EntryAddr,16));
ui->unpackerARM7RamAddrEdt->setText(QString::number(ndsHeader->Arm7RamAddr,16));
ui->unpackerARM7SizeEdt->setText(QString::number(ndsHeader->Arm7Size,16));
ui->unpackerFilenameTableAddrEdt->setText(QString::number(ndsHeader->FilenameTableAddr,16));
ui->unpackerFilenameTableSizeEdt->setText(QString::number(ndsHeader->FilenameSize,16));
ui->unpackerFATAddrEdt->setText(QString::number(ndsHeader->FATAddr,16));
ui->unpackerFATSizeEdt->setText(QString::number(ndsHeader->FATSize,16));
ui->unpackerARM9OverlayAddrEdt->setText(QString::number(ndsHeader->Arm9OverlayAddr,16));
ui->unpackerARM9OverlaySizeEdt->setText(QString::number(ndsHeader->Arm9OverlaySize,16));
ui->unpackerARM7OverlayAddrEdt->setText(QString::number(ndsHeader->Arm7OverlayAddr,16));
ui->unpackerARM7OverlaySizeEdt->setText(QString::number(ndsHeader->Arm7OverlaySize,16));
ui->unpackerPortNCEdt->setText(QString::number(ndsHeader->NormalCommandsSettings,16));
ui->unpackerPortKCEdt->setText(QString::number(ndsHeader->Key1CommandsSettings,16));
ui->unpackerIconTitleEdt->setText(QString::number(ndsHeader->IconTitleAddr,16));
ui->unpackerSecureAreaCRC16Edt->setText(QString::number(ndsHeader->SecureAreaCRC16,16));
ui->unpackerSecureAreaTimeoutEdt->setText(QString::number(ndsHeader->SecureAreaLoadingTimeout,16));
ui->unpackerARM9AURamAddrEdt->setText(QString::number(ndsHeader->ARM9AutoLoadListRamAddr,16));
ui->unpackerARM7AURamAddrEdt->setText(QString::number(ndsHeader->ARM7AutoLoadListRamAddr,16));
ui->unpackerSecureAreaDisableEdt->setText(QString::number(ndsHeader->SecureAreaDisable,16));
ui->unpackerUsedRomSizeEdt->setText(QString::number(ndsHeader->RomSize,16));
ui->unpackerHeaderSizeEdt->setText(QString::number(ndsHeader->HeaderSize,16));
ui->unpackerNintendoLogoEdt->setText(QByteArray::fromRawData(reinterpret_cast<char*>(ndsHeader->NintendoLogo), 0x9C).toHex());
ui->unpackerNintendoLogoCRCEdt->setText(QString::number(ndsHeader->NintendoLogoCRC,16));
ui->unpackerHeaderCRCEdt->setText(QString::number(ndsHeader->HeaderCRC16,16));
ui->unpackerDebugRomAddrEdt->setText(QString::number(ndsHeader->DebugRomAddr,16));
ui->unpackerDebugSizeEdt->setText(QString::number(ndsHeader->DebugSize,16));
ui->unpackerDebugRamAddrEdt->setText(QString::number(ndsHeader->DebugRamAddr,16));
ui->unpackerFatFilesOriginalAddrEdt->setText(QString::number((ndsHeader->IconTitleAddr+IconTitleSize),16));
auto* headerDataModel = new NDSHeaderModel(ndsHeader);
ui->unpackerHeaderDataTable->setModel(headerDataModel);
ui->unpackerHeaderDataTable->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeMode::ResizeToContents);
ui->unpackerHeaderDataTable->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeMode::Stretch);
}
void MainWindow::enableExtractionButtons()
{
ui->unpackerExtractorGbx->setEnabled(true);
ui->unpackerExtraGbx->setEnabled(true);
if (ui->unpackerARM9OverlayAddrEdt->text().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->unpackerARM7OverlayAddrEdt->text().toUInt(nullptr, 16) == 0){
if (ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr,16) == 0){
ui->unpackerDumpArm7OverlayBtn->setEnabled(false);
ui->unpackerDumpArm7OverlayFilesBtn->setEnabled(false);
}
@ -90,18 +43,18 @@ bool MainWindow::dumpHeader(const std::string& dirPath)
ui->loadedRomPath->text().toStdString(),
dirPath,
0,
ui->unpackerHeaderSizeEdt->text().toUInt(nullptr, 16));
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::HeaderSize, 1).data().toString().toUInt(nullptr,16));
}
bool MainWindow::dumpArm9Bin(const std::string& dirPath, bool dumpExtraBytes)
{
uint32_t size = ui->unpackerARM9SizeEdt->text().toUInt(nullptr, 16);
uint32_t size = ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9Size, 1).data().toString().toUInt(nullptr,16);
if (dumpExtraBytes)
size += 12;
return ndsFactory.dumpDataFromFile(
ui->loadedRomPath->text().toStdString(),
dirPath,
ui->unpackerARM9RomAddrEdt->text().toUInt(nullptr, 16),
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9RomAddress, 1).data().toString().toUInt(nullptr,16),
size);
}
@ -110,8 +63,8 @@ bool MainWindow::dumpArm7Bin(const std::string& dirPath)
return ndsFactory.dumpDataFromFile(
ui->loadedRomPath->text().toStdString(),
dirPath,
ui->unpackerARM7RomAddrEdt->text().toUInt(nullptr, 16),
ui->unpackerARM7SizeEdt->text().toUInt(nullptr, 16));
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7RomAddress, 1).data().toString().toUInt(nullptr,16),
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7Size, 1).data().toString().toUInt(nullptr,16));
}
bool MainWindow::dumpFnt(const std::string& dirPath)
@ -119,8 +72,8 @@ bool MainWindow::dumpFnt(const std::string& dirPath)
return ndsFactory.dumpDataFromFile(
ui->loadedRomPath->text().toStdString(),
dirPath,
ui->unpackerFilenameTableAddrEdt->text().toUInt(nullptr, 16),
ui->unpackerFilenameTableSizeEdt->text().toUInt(nullptr, 16));
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FilenameTableAddress, 1).data().toString().toUInt(nullptr,16),
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FilenameTableSize, 1).data().toString().toUInt(nullptr,16));
}
bool MainWindow::dumpFat(const std::string& dirPath)
@ -128,8 +81,8 @@ bool MainWindow::dumpFat(const std::string& dirPath)
return ndsFactory.dumpDataFromFile(
ui->loadedRomPath->text().toStdString(),
dirPath,
ui->unpackerFATAddrEdt->text().toUInt(nullptr, 16),
ui->unpackerFATSizeEdt->text().toUInt(nullptr, 16));
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FATAddress, 1).data().toString().toUInt(nullptr,16),
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::FATSize, 1).data().toString().toUInt(nullptr,16));
}
bool MainWindow::dumpArm9Overlay(const std::string& dirPath)
@ -137,8 +90,8 @@ bool MainWindow::dumpArm9Overlay(const std::string& dirPath)
return ndsFactory.dumpDataFromFile(
ui->loadedRomPath->text().toStdString(),
dirPath,
ui->unpackerARM9OverlayAddrEdt->text().toUInt(nullptr, 16),
ui->unpackerARM9OverlaySizeEdt->text().toUInt(nullptr, 16));
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr,16),
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlaySize, 1).data().toString().toUInt(nullptr,16));
}
bool MainWindow::dumpArm9OverlayFiles(const std::string& dirPath)
@ -151,8 +104,8 @@ bool MainWindow::dumpArm7Overlay(const std::string& dirPath)
return ndsFactory.dumpDataFromFile(
ui->loadedRomPath->text().toStdString(),
dirPath,
ui->unpackerARM7OverlayAddrEdt->text().toUInt(nullptr, 16),
ui->unpackerARM7OverlaySizeEdt->text().toUInt(nullptr, 16));
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr,16),
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlaySize, 1).data().toString().toUInt(nullptr,16));
}
bool MainWindow::dumpArm7OverlayFiles(const std::string& dirPath)
@ -165,14 +118,14 @@ bool MainWindow::dumpIconTitle(const std::string& dirPath)
return ndsFactory.dumpDataFromFile(
ui->loadedRomPath->text().toStdString(),
dirPath,
ui->unpackerIconTitleEdt->text().toUInt(nullptr, 16),
ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::IconTitleAddress, 1).data().toString().toUInt(nullptr,16),
0xA00);
}
bool MainWindow::dumpFatFiles(const std::string& dirPath)
{
uint32_t startAddr = ui->unpackerIconTitleEdt->text().toUInt(nullptr, 16) + IconTitleSize;
uint32_t size = ui->unpackerUsedRomSizeEdt->text().toUInt(nullptr, 16) - startAddr;
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;
return ndsFactory.dumpDataFromFile(
ui->loadedRomPath->text().toStdString(),
@ -184,7 +137,6 @@ bool MainWindow::dumpFatFiles(const std::string& dirPath)
bool MainWindow::dumpEverything(QString dirPath)
{
if(!dumpHeader(QDir::toNativeSeparators(dirPath+"/header.bin").toStdString()))
return false;
if(!dumpArm9Bin(QDir::toNativeSeparators(dirPath+"/arm9.bin").toStdString(), true))
@ -195,13 +147,13 @@ bool MainWindow::dumpEverything(QString dirPath)
return false;
if(!dumpFat(QDir::toNativeSeparators(dirPath+"/fat.bin").toStdString()))
return false;
if(ui->unpackerARM9OverlayAddrEdt->text().toUInt(nullptr, 16) != 0) {
if(ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM9OverlayAddress, 1).data().toString().toUInt(nullptr,16) != 0) {
if(!dumpArm9Overlay(QDir::toNativeSeparators(dirPath+"/a9ovr.bin").toStdString()))
return false;
if(!dumpArm9OverlayFiles(QDir::toNativeSeparators(dirPath+"/a9ovr_data.bin").toStdString()))
return false;
}
if(ui->unpackerARM7OverlayAddrEdt->text().toUInt(nullptr, 16) != 0) {
if(ui->unpackerHeaderDataTable->model()->index(NDSHeaderNames::ARM7OverlayAddress, 1).data().toString().toUInt(nullptr,16) != 0) {
if(!dumpArm7Overlay(QDir::toNativeSeparators(dirPath+"/a7ovr.bin").toStdString()))
return false;
if(!dumpArm7OverlayFiles(QDir::toNativeSeparators(dirPath+"/a7ovr_data.bin").toStdString()))

1
ui/tabs/unpacker/unpackertabsignals.cpp
View File

@ -7,7 +7,6 @@
void MainWindow::on_loadRomBtn_clicked()
{
std::vector<char> romHeader;
NDSHeader *pNDSHeader;
QString romPath = QFileDialog::getOpenFileName(