njohnson/XPlor
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases 1 Wiki Activity

Add category support to XTreeWidget with TREE_CATEGORY enum and sorting improvements

Browse Source
This commit is contained in:
= 2025-06-04 22:29:01 -04:00
parent 3e311e5aec
commit af82d9a78a
4 changed files with 155 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

217
app/xtreewidget.cpp
View File

@ -16,6 +16,7 @@ XTreeWidget::XTreeWidget(QWidget *parent)
header()->hide(); header()->hide();
setMinimumWidth(350); setMinimumWidth(350);
setSortingEnabled(true); setSortingEnabled(true);
setIconSize(QSize(16, 16));
header()->setSectionResizeMode(0, QHeaderView::ResizeToContents); header()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
@ -38,42 +39,44 @@ XTreeWidget::~XTreeWidget() {
void XTreeWidget::AddFastFile(std::shared_ptr<FastFile> aFastFile) { void XTreeWidget::AddFastFile(std::shared_ptr<FastFile> aFastFile) {
XTreeWidgetItem *fastFileItem = new XTreeWidgetItem(this); XTreeWidgetItem *fastFileItem = new XTreeWidgetItem(this);
fastFileItem->setText(0, aFastFile->GetStem() + ".ff"); fastFileItem->setText(0, aFastFile->GetStem());
fastFileItem->setIcon(0, QIcon(":/icons/icons/Icon_FastFile.png")); fastFileItem->setIcon(0, Utils::CreateAssetIcon("FF"));
if (aFastFile->GetPlatform() == "PC") { if (aFastFile->GetPlatform() == "PC") {
fastFileItem->setIcon(1, QIcon(":/icons/icons/Icon_PC.png")); fastFileItem->setIcon(1, Utils::CreateAssetIcon("PC"));
} else if (aFastFile->GetPlatform() == "360") { } else if (aFastFile->GetPlatform() == "360") {
fastFileItem->setIcon(1, QIcon(":/icons/icons/Icon_Xbox.png")); fastFileItem->setIcon(1, Utils::CreateAssetIcon("360"));
} else if (aFastFile->GetPlatform() == "PS3") {
fastFileItem->setIcon(1, Utils::CreateAssetIcon("PS3"));
} else if (aFastFile->GetPlatform() == "Wii") { } else if (aFastFile->GetPlatform() == "Wii") {
fastFileItem->setIcon(1, QIcon(":/icons/icons/Icon_Wii.png")); fastFileItem->setIcon(1, Utils::CreateAssetIcon("WII"));
} else if (aFastFile->GetPlatform() == "WiiU") { } else if (aFastFile->GetPlatform() == "WiiU") {
fastFileItem->setIcon(1, QIcon(":/icons/icons/Icon_WiiU.png")); fastFileItem->setIcon(1, Utils::CreateAssetIcon("WU"));
} }
if (aFastFile->GetGame() == "COD2") { if (aFastFile->GetGame() == "COD2") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD2.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(2));
} if (aFastFile->GetGame() == "COD4") { } if (aFastFile->GetGame() == "COD4") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD4.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(4));
} else if (aFastFile->GetGame() == "COD5") { } else if (aFastFile->GetGame() == "COD5") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD5.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(5));
} else if (aFastFile->GetGame() == "COD6") { } else if (aFastFile->GetGame() == "COD6") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD6.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(6));
} else if (aFastFile->GetGame() == "COD7") { } else if (aFastFile->GetGame() == "COD7") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD7.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(7));
} else if (aFastFile->GetGame() == "COD8") { } else if (aFastFile->GetGame() == "COD8") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD8.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(8));
} else if (aFastFile->GetGame() == "COD9") { } else if (aFastFile->GetGame() == "COD9") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD9.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(9));
} else if (aFastFile->GetGame() == "COD10") { } else if (aFastFile->GetGame() == "COD10") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD10.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(10));
} else if (aFastFile->GetGame() == "COD11") { } else if (aFastFile->GetGame() == "COD11") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD11.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(11));
} else if (aFastFile->GetGame() == "COD12") { } else if (aFastFile->GetGame() == "COD12") {
fastFileItem->setIcon(2, QIcon(":/icons/icons/Icon_COD12.png")); fastFileItem->setIcon(2, Utils::CreateGameIcon(12));
} }
AddZoneFile(aFastFile->GetZoneFile(), fastFileItem); AddZoneFile(aFastFile->GetZoneFile(), fastFileItem);
mFastFiles[aFastFile->GetStem().section(".", 0, 0)] = aFastFile; mFastFiles[aFastFile->GetStem()] = aFastFile;
resizeColumnToContents(1); resizeColumnToContents(1);
setSortingEnabled(true); setSortingEnabled(true);
@ -87,42 +90,52 @@ void XTreeWidget::AddZoneFile(std::shared_ptr<ZoneFile> aZoneFile, XTreeWidgetIt
} else { } else {
zoneItem = new XTreeWidgetItem(this); zoneItem = new XTreeWidgetItem(this);
} }
zoneItem->setIcon(0, QIcon(":/icons/icons/Icon_ZoneFile.png")); zoneItem->setIcon(0, ZoneFile::AssetTypeToIcon(ASSET_ZONE_FILE));
zoneItem->setText(0, aZoneFile->GetStem() + ".zone"); zoneItem->setText(0, aZoneFile->GetBaseStem() + ".zone");
auto assetMap = aZoneFile->GetAssetMap(); auto assetMap = aZoneFile->GetAssetMap();
if (!assetMap.localStrings.isEmpty()) { if (!assetMap.localStrings.isEmpty()) {
QIcon localStrIcon = ZoneFile::AssetTypeToIcon(ASSET_LOCAL_STRING);
XTreeWidgetItem *localStrRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *localStrRoot = new XTreeWidgetItem(zoneItem);
localStrRoot->setText(0, "String Files"); localStrRoot->setText(0, "String Files");
localStrRoot->setIcon(0, QIcon(":/icons/icons/Icon_StringFile.png")); localStrRoot->setIcon(0, localStrIcon);
localStrRoot->SetCategory(CATEGORY_TYPE);
XTreeWidgetItem *localStrItem = new XTreeWidgetItem(localStrRoot); XTreeWidgetItem *localStrItem = new XTreeWidgetItem(localStrRoot);
localStrItem->setText(0, aZoneFile->GetStem().section('.', 0, 0) + ".str"); localStrItem->setText(0, aZoneFile->GetStem().section('.', 0, 0) + ".str");
localStrItem->setIcon(0, QIcon(":/icons/icons/Icon_StringFile.png")); localStrItem->setIcon(0, localStrIcon);
} }
if (!assetMap.techSets.isEmpty()) { if (!assetMap.techSets.isEmpty()) {
QIcon techSetIcon = ZoneFile::AssetTypeToIcon(ASSET_TECH_SET);
XTreeWidgetItem *techSetRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *techSetRoot = new XTreeWidgetItem(zoneItem);
techSetRoot->setText(0, "Tech Sets"); techSetRoot->setText(0, "Tech Sets");
techSetRoot->setIcon(0, QIcon(":/icons/icons/Icon_TechSetFile.png")); techSetRoot->setIcon(0, techSetIcon);
techSetRoot->SetCategory(CATEGORY_TYPE);
for (TechSet techSet : assetMap.techSets) { for (TechSet techSet : assetMap.techSets) {
XTreeWidgetItem *techSetItem = new XTreeWidgetItem(techSetRoot); XTreeWidgetItem *techSetItem = new XTreeWidgetItem(techSetRoot);
techSetItem->setText(0, techSet.name); techSetItem->setText(0, techSet.name);
techSetItem->setIcon(0, QIcon(":/icons/icons/Icon_TechSetFile.png")); techSetItem->setIcon(0, techSetIcon);
} }
} }
if (!assetMap.rawFiles.isEmpty()) { if (!assetMap.rawFiles.isEmpty()) {
QIcon rawFileIcon = ZoneFile::AssetTypeToIcon(ASSET_RAW_FILE);
XTreeWidgetItem *rawFileRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *rawFileRoot = new XTreeWidgetItem(zoneItem);
rawFileRoot->setText(0, "Raw Files"); rawFileRoot->setText(0, "Raw Files");
rawFileRoot->setIcon(0, QIcon(":/icons/icons/Icon_GSCFile.png")); rawFileRoot->setIcon(0, rawFileIcon);
rawFileRoot->SetCategory(CATEGORY_TYPE);
for (RawFile rawFile : assetMap.rawFiles) { for (RawFile rawFile : assetMap.rawFiles) {
if (!rawFile.length) { continue; } if (!rawFile.length) { continue; }
XTreeWidgetItem *tempItem = rawFileRoot; XTreeWidgetItem *tempItem = rawFileRoot;
for (const QString &pathPart : rawFile.path.split('/')) { const QStringList pathParts = rawFile.path.split('/');
for (const QString &pathPart : pathParts) {
bool childFound = false; bool childFound = false;
for (int i = 0; i < tempItem->childCount(); i++) { for (int i = 0; i < tempItem->childCount(); i++) {
QTreeWidgetItem *rawChildItem = tempItem->child(i); QTreeWidgetItem *rawChildItem = tempItem->child(i);
@ -135,25 +148,30 @@ void XTreeWidget::AddZoneFile(std::shared_ptr<ZoneFile> aZoneFile, XTreeWidgetIt
} }
} }
if (pathPart.contains(".gsc")) { const QString rawFileStr = QString("%1 [%2-%3]").arg(pathPart).arg(rawFile.startPos).arg(rawFile.endPos);
//rawFileStr = pathPart;
if (pathPart == pathParts.last()) {
XTreeWidgetItem *rawFileItem = new XTreeWidgetItem(tempItem); XTreeWidgetItem *rawFileItem = new XTreeWidgetItem(tempItem);
rawFileItem->setText(0, pathPart); rawFileItem->setText(0, rawFileStr);
tempItem = rawFileItem; tempItem = rawFileItem;
} else if (!childFound) { } else if (!childFound) {
tempItem = new XTreeWidgetItem(tempItem); tempItem = new XTreeWidgetItem(tempItem);
tempItem->setText(0, pathPart); tempItem->setText(0, rawFileStr);
} }
} }
tempItem->setIcon(0, QIcon(":/icons/icons/Icon_GSCFile.png")); tempItem->setIcon(0, rawFileIcon);
} }
} }
if (!assetMap.menuFiles.isEmpty()) { if (!assetMap.menuFiles.isEmpty()) {
QIcon menuFileIcon = ZoneFile::AssetTypeToIcon(ASSET_MENU);
XTreeWidgetItem *menuRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *menuRoot = new XTreeWidgetItem(zoneItem);
menuRoot->setText(0, "Menu Files"); menuRoot->setText(0, "Menu Files");
menuRoot->setIcon(0, QIcon(":/icons/icons/Icon_MenuFile.png")); menuRoot->setIcon(0, menuFileIcon);
menuRoot->SetCategory(CATEGORY_TYPE);
int menuIndex = 1; int menuIndex = 1;
for (MenuFile menuFile : assetMap.menuFiles) { for (MenuFile menuFile : assetMap.menuFiles) {
@ -162,64 +180,79 @@ void XTreeWidget::AddZoneFile(std::shared_ptr<ZoneFile> aZoneFile, XTreeWidgetIt
for (Menu menu : menuFile.menuDefs) { for (Menu menu : menuFile.menuDefs) {
XTreeWidgetItem *menuItem = new XTreeWidgetItem(menuFileRoot); XTreeWidgetItem *menuItem = new XTreeWidgetItem(menuFileRoot);
menuItem->setText(0, menu.filePath); menuItem->setText(0, menu.filePath);
menuItem->setIcon(0, QIcon(":/icons/icons/Icon_MenuFile.png")); menuItem->setIcon(0, menuFileIcon);
} }
menuIndex++; menuIndex++;
} }
} }
if (!assetMap.images.isEmpty()) { if (!assetMap.images.isEmpty()) {
QIcon imageIcon = ZoneFile::AssetTypeToIcon(ASSET_IMAGE);
XTreeWidgetItem *imageRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *imageRoot = new XTreeWidgetItem(zoneItem);
imageRoot->setText(0, "Images"); imageRoot->setText(0, "Images");
imageRoot->setIcon(0, QIcon(":/icons/icons/Icon_Image.png")); imageRoot->setIcon(0, imageIcon);
imageRoot->SetCategory(CATEGORY_TYPE);
for (Image image : assetMap.images) { for (Image image : assetMap.images) {
XTreeWidgetItem *imageItem = new XTreeWidgetItem(imageRoot); XTreeWidgetItem *imageItem = new XTreeWidgetItem(imageRoot);
imageItem->setText(0, image.materialName); imageItem->setText(0, image.materialName);
imageItem->setIcon(0, QIcon(":/icons/icons/Icon_Image.png")); imageItem->setIcon(0, imageIcon);
} }
} }
if (!assetMap.models.isEmpty()) { if (!assetMap.models.isEmpty()) {
QIcon modelIcon = ZoneFile::AssetTypeToIcon(ASSET_MODEL);
XTreeWidgetItem *modelsRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *modelsRoot = new XTreeWidgetItem(zoneItem);
modelsRoot->setText(0, "Models"); modelsRoot->setText(0, "Models");
modelsRoot->setIcon(0, QIcon(":/icons/icons/Icon_Model.png")); modelsRoot->setIcon(0, modelIcon);
modelsRoot->SetCategory(CATEGORY_TYPE);
for (Model model: assetMap.models) { for (Model model: assetMap.models) {
XTreeWidgetItem *modelItem = new XTreeWidgetItem(modelsRoot); XTreeWidgetItem *modelItem = new XTreeWidgetItem(modelsRoot);
modelItem->setText(0, model.modelName); modelItem->setText(0, model.modelName);
modelItem->setIcon(0, QIcon(":/icons/icons/Icon_Model.png")); modelItem->setIcon(0, modelIcon);
} }
} }
if (!assetMap.materials.isEmpty()) { if (!assetMap.materials.isEmpty()) {
QIcon materialIcon = ZoneFile::AssetTypeToIcon(ASSET_MATERIAL);
XTreeWidgetItem *materialsRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *materialsRoot = new XTreeWidgetItem(zoneItem);
materialsRoot->setText(0, "Materials"); materialsRoot->setText(0, "Materials");
materialsRoot->setIcon(0, QIcon(":/icons/icons/Icon_Material.png")); materialsRoot->setIcon(0, materialIcon);
materialsRoot->SetCategory(CATEGORY_TYPE);
for (Material material: assetMap.materials) { for (Material material: assetMap.materials) {
XTreeWidgetItem *materialItem = new XTreeWidgetItem(materialsRoot); XTreeWidgetItem *materialItem = new XTreeWidgetItem(materialsRoot);
materialItem->setText(0, material.name); materialItem->setText(0, material.name);
materialItem->setIcon(0, QIcon(":/icons/icons/Icon_Material.png")); materialItem->setIcon(0, materialIcon);
} }
} }
if (!assetMap.stringTables.isEmpty()) { if (!assetMap.stringTables.isEmpty()) {
QIcon stringTableIcon = ZoneFile::AssetTypeToIcon(ASSET_STRING_TABLE);
XTreeWidgetItem *strTableRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *strTableRoot = new XTreeWidgetItem(zoneItem);
strTableRoot->setText(0, "String Tables"); strTableRoot->setText(0, "String Tables");
strTableRoot->setIcon(0, QIcon(":/icons/icons/Icon_StringTable.png")); strTableRoot->setIcon(0, stringTableIcon);
strTableRoot->SetCategory(CATEGORY_TYPE);
for (StringTable strTable: assetMap.stringTables) { for (StringTable strTable: assetMap.stringTables) {
XTreeWidgetItem *modelItem = new XTreeWidgetItem(strTableRoot); XTreeWidgetItem *modelItem = new XTreeWidgetItem(strTableRoot);
modelItem->setText(0, strTable.name); modelItem->setText(0, strTable.name);
modelItem->setIcon(0, QIcon(":/icons/icons/Icon_StringTable.png")); modelItem->setIcon(0, stringTableIcon);
} }
} }
if (!assetMap.sounds.isEmpty()) { if (!assetMap.sounds.isEmpty()) {
QIcon soundIcon = ZoneFile::AssetTypeToIcon(ASSET_SOUND);
XTreeWidgetItem *soundsRoot = new XTreeWidgetItem(zoneItem); XTreeWidgetItem *soundsRoot = new XTreeWidgetItem(zoneItem);
soundsRoot->setText(0, "Sounds"); soundsRoot->setText(0, "Sounds");
soundsRoot->setIcon(0, QIcon(":/icons/icons/Icon_Sound.png")); soundsRoot->setIcon(0, soundIcon);
soundsRoot->SetCategory(CATEGORY_TYPE);
for (SoundAsset soundAsset : assetMap.sounds) { for (SoundAsset soundAsset : assetMap.sounds) {
for (Sound sound : soundAsset.sounds) { for (Sound sound : soundAsset.sounds) {
XTreeWidgetItem *tempItem = soundsRoot; XTreeWidgetItem *tempItem = soundsRoot;
@ -251,16 +284,16 @@ void XTreeWidget::AddZoneFile(std::shared_ptr<ZoneFile> aZoneFile, XTreeWidgetIt
} }
} }
tempItem->setIcon(0, QIcon(":/icons/icons/Icon_Sound.png")); tempItem->setIcon(0, soundIcon);
} }
} }
} }
mZoneFiles[aZoneFile->GetStem().section(".", 0, 0)] = aZoneFile; mZoneFiles[aZoneFile->GetBaseStem() + ".zone"] = aZoneFile;
} }
void XTreeWidget::CloseFastFile(const QString aFFName) { void XTreeWidget::CloseFastFile(const QString aFFName) {
const QString fileStem = aFFName.section(".", 0, 0); const QString fileStem = aFFName;
emit ItemClosed(fileStem); emit ItemClosed(fileStem);
} }
@ -361,7 +394,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
iwiFile->SaveJPG(); iwiFile->SaveJPG();
}); });
} else if (activeText.contains(".ff")) { } else if (activeText.contains(".ff")) {
const QString fileStem = activeText.replace(".zone", ""); const QString fileStem = activeText;
QMenu *closeMultipleAction = new QMenu("Close Multiple Tabs"); QMenu *closeMultipleAction = new QMenu("Close Multiple Tabs");
@ -385,7 +418,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
auto childItem = invisibleRootItem()->child(i); auto childItem = invisibleRootItem()->child(i);
if (childItem == activeItem) { continue; } if (childItem == activeItem) { continue; }
const QString fileStem = childItem->text(0).replace(".ff", ""); const QString fileStem = childItem->text(0);
if (!mFastFiles.contains(fileStem)) { if (!mFastFiles.contains(fileStem)) {
qDebug() << "Error: Could not find " << fileStem << " in Fast File map!"; qDebug() << "Error: Could not find " << fileStem << " in Fast File map!";
return; return;
@ -407,7 +440,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
auto childItem = invisibleRootItem()->child(i); auto childItem = invisibleRootItem()->child(i);
if (childItem == activeItem) { return; } if (childItem == activeItem) { return; }
const QString fileStem = childItem->text(0).replace(".ff", ""); const QString fileStem = childItem->text(0);
if (!mFastFiles.contains(fileStem)) { if (!mFastFiles.contains(fileStem)) {
qDebug() << "Error: Could not find " << fileStem << " in Fast File map!"; qDebug() << "Error: Could not find " << fileStem << " in Fast File map!";
return; return;
@ -434,7 +467,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
continue; continue;
} }
const QString fileStem = childItem->text(0).replace(".ff", ""); const QString fileStem = childItem->text(0);
if (!mFastFiles.contains(fileStem)) { if (!mFastFiles.contains(fileStem)) {
qDebug() << "Error: Could not find " << fileStem << " in Fast File map!"; qDebug() << "Error: Could not find " << fileStem << " in Fast File map!";
return; return;
@ -454,7 +487,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
connect(closeAction, &QAction::triggered, this, [this, &activeItem, &activeText](bool checked) { connect(closeAction, &QAction::triggered, this, [this, &activeItem, &activeText](bool checked) {
Q_UNUSED(checked); Q_UNUSED(checked);
const QString fileStem = activeItem->text(0).replace(".ff", ""); const QString fileStem = activeItem->text(0);
mFastFiles.remove(fileStem); mFastFiles.remove(fileStem);
CloseFastFile(activeText); CloseFastFile(activeText);
@ -488,7 +521,7 @@ void XTreeWidget::PrepareContextMenu(const QPoint &pos) {
fastFile->GetZoneFile()->SaveZoneFile(zoneFilePath); fastFile->GetZoneFile()->SaveZoneFile(zoneFilePath);
}); });
} else if (activeText.contains(".zone")) { } else if (activeText.contains(".zone")) {
const QString fileStem = activeText.replace(".zone", ""); const QString fileStem = activeText;
if (!mZoneFiles.contains(fileStem)) { if (!mZoneFiles.contains(fileStem)) {
qDebug() << "Error: Could not find " << fileStem << " in Zone File map!"; qDebug() << "Error: Could not find " << fileStem << " in Zone File map!";
return; return;
@ -618,63 +651,39 @@ void XTreeWidget::ItemSelectionChanged() {
QString selectedText = selectedItem->text(0); QString selectedText = selectedItem->text(0);
emit ItemSelected(selectedText); emit ItemSelected(selectedText);
const QString fileStem = selectedText.section(".", 0, 0);
XTreeWidgetItem *parentItem = dynamic_cast<XTreeWidgetItem*>(selectedItem->parent()); XTreeWidgetItem *parentItem = dynamic_cast<XTreeWidgetItem*>(selectedItem->parent());
if (selectedText.contains(".dds")) { if (selectedText.contains(".dds")) {
if (!mDDSFiles.contains(fileStem)) { if (!mDDSFiles.contains(selectedText)) {
LogManager::instance().addError("Could not find " + fileStem + " in DDS map!"); LogManager::instance().addError("Could not find " + selectedText + " in DDS map!");
return; return;
} }
std::shared_ptr<DDSFile> ddsFile = mDDSFiles[fileStem]; std::shared_ptr<DDSFile> ddsFile = mDDSFiles[selectedText];
emit DDSFileSelected(ddsFile, fileStem); emit DDSFileSelected(ddsFile, selectedText);
} else if (selectedText.contains(".iwi")) { } else if (selectedText.contains(".iwi")) {
if (!mIWIFiles.contains(fileStem)) { if (!mIWIFiles.contains(selectedText)) {
LogManager::instance().addError("Could not find " + fileStem + " in IWI map!"); LogManager::instance().addError("Could not find " + selectedText + " in IWI map!");
return; return;
} }
emit IWIFileSelected(mIWIFiles[fileStem], fileStem); emit IWIFileSelected(mIWIFiles[selectedText], selectedText);
} else if (selectedText.contains(".ff")) { } else if (selectedText.contains(".ff")) {
if (!mFastFiles.contains(fileStem)) { if (!mFastFiles.contains(selectedText)) {
LogManager::instance().addError("Could not find " + fileStem + " in Fast File map!"); LogManager::instance().addError("Could not find " + selectedText + " in Fast File map!");
return; return;
} }
emit FastFileSelected(mFastFiles[fileStem], fileStem); emit FastFileSelected(mFastFiles[selectedText], selectedText);
} else if (selectedText.contains(".zone")) { } else if (selectedText.contains(".zone")) {
if (!mZoneFiles.contains(fileStem)) { if (!mZoneFiles.contains(selectedText)) {
LogManager::instance().addError("Could not find " + fileStem + " in Zone File map!"); LogManager::instance().addError("Could not find " + selectedText + " in Zone File map!");
return; return;
} }
emit ZoneFileSelected(mZoneFiles[fileStem], fileStem); emit ZoneFileSelected(mZoneFiles[selectedText], selectedText);
} else if (selectedText.contains(".str")) { } else if (selectedText.contains(".str")) {
if (!mZoneFiles.contains(fileStem)) { if (!mZoneFiles.contains(selectedText.replace(".str", ".zone"))) {
LogManager::instance().addError("Could not find " + fileStem + " in Zone File map!"); LogManager::instance().addError("Could not find " + selectedText + " in Zone File map!");
return; return;
} }
emit LocalStringSelected(mZoneFiles[fileStem], fileStem); emit LocalStringSelected(mZoneFiles[selectedText], selectedText);
} else if (selectedText.contains(".gsc")) {
XTreeWidgetItem *zoneRoot = selectedItem;
if (!zoneRoot) { return; }
while (!zoneRoot->text(0).contains(".zone")) {
zoneRoot = dynamic_cast<XTreeWidgetItem*>(zoneRoot->parent());
if (!zoneRoot) { return; }
}
const QString fileStem = zoneRoot->text(0).section('.', 0, 0);
if (!mZoneFiles.contains(fileStem)) {
LogManager::instance().addError("Could not find " + fileStem + " in Zone File map!");
return;
}
QVector<RawFile> rawFiles = mZoneFiles[fileStem]->GetAssetMap().rawFiles;
for (RawFile rawFile : rawFiles) {
if (rawFile.path.contains(selectedText)) {
emit RawFileSelected(std::make_shared<RawFile>(rawFile), fileStem);
return;
}
}
} else if (parentItem && (parentItem->text(0) == "Images")) { } else if (parentItem && (parentItem->text(0) == "Images")) {
XTreeWidgetItem *grandpaItem = dynamic_cast<XTreeWidgetItem*>(parentItem->parent()); XTreeWidgetItem *grandpaItem = dynamic_cast<XTreeWidgetItem*>(parentItem->parent());
if (grandpaItem && grandpaItem->text(0).contains(".zone")) { if (grandpaItem && grandpaItem->text(0).contains(".zone")) {
@ -744,6 +753,32 @@ void XTreeWidget::ItemSelectionChanged() {
} }
} }
} }
} else if (selectedItem->GetCategory() != CATEGORY_TYPE) {
XTreeWidgetItem *zoneRoot = selectedItem;
bool zoneChild = false;
while (zoneRoot) {
zoneRoot = dynamic_cast<XTreeWidgetItem*>(zoneRoot->parent());
if (zoneRoot->text(0).contains("Raw Files")) {
zoneChild = true;
break;
}
}
if (!zoneChild) { return; }
const QString fileStem = zoneRoot->parent()->text(0);
if (!mZoneFiles.contains(fileStem)) {
LogManager::instance().addError("Could not find " + fileStem + " in Zone File map!");
return;
}
QVector<RawFile> rawFiles = mZoneFiles[fileStem]->GetAssetMap().rawFiles;
for (RawFile rawFile : rawFiles) {
if (rawFile.path.split('/').last() == selectedText) {
emit RawFileSelected(std::make_shared<RawFile>(rawFile), fileStem);
return;
}
}
} }
} }
@ -784,7 +819,7 @@ void XTreeWidget::AddIWIFile(std::shared_ptr<IWIFile> aIWIFile) {
} }
XTreeWidgetItem *iwiItem = new XTreeWidgetItem(this); XTreeWidgetItem *iwiItem = new XTreeWidgetItem(this);
iwiItem->setIcon(0, QIcon(":/icons/icons/Icon_IWIFile.png")); iwiItem->setIcon(0, ZoneFile::AssetTypeToIcon(ASSET_IMAGE));
iwiItem->setText(0, iwiFileName); iwiItem->setText(0, iwiFileName);
mIWIFiles[aIWIFile->fileStem.section(".", 0, 0)] = aIWIFile; mIWIFiles[aIWIFile->fileStem.section(".", 0, 0)] = aIWIFile;
} }
@ -800,7 +835,7 @@ void XTreeWidget::AddDDSFile(std::shared_ptr<DDSFile> aDDSFile) {
} }
XTreeWidgetItem *ddsItem = new XTreeWidgetItem(this); XTreeWidgetItem *ddsItem = new XTreeWidgetItem(this);
ddsItem->setIcon(0, QIcon(":/icons/icons/Icon_DDSFile.png")); ddsItem->setIcon(0, ZoneFile::AssetTypeToIcon(ASSET_IMAGE));
ddsItem->setText(0, ddsFileName); ddsItem->setText(0, ddsFileName);
mDDSFiles[aDDSFile->fileStem.section(".", 0, 0)] = aDDSFile; mDDSFiles[aDDSFile->fileStem.section(".", 0, 0)] = aDDSFile;
} }

1
app/xtreewidget.h
View File

@ -8,6 +8,7 @@
#include "fastfile.h" #include "fastfile.h"
#include "xtreewidgetitem.h" #include "xtreewidgetitem.h"
#include "zonefile.h" #include "zonefile.h"
#include "utils.h"
#include <QTreeWidget> #include <QTreeWidget>
#include <QFileDialog> #include <QFileDialog>

18
app/xtreewidgetitem.cpp
View File

@ -1,15 +1,29 @@
#include "xtreewidgetitem.h" #include "xtreewidgetitem.h"
XTreeWidgetItem::XTreeWidgetItem(QTreeWidget *parent, bool group) XTreeWidgetItem::XTreeWidgetItem(QTreeWidget *parent, bool group)
: QTreeWidgetItem(parent), isGroup(group) { : QTreeWidgetItem(parent)
, isGroup(group)
, mCategory(CATEGORY_NONE) {
} }
XTreeWidgetItem::XTreeWidgetItem(QTreeWidgetItem *parent, bool group) XTreeWidgetItem::XTreeWidgetItem(QTreeWidgetItem *parent, bool group)
: QTreeWidgetItem(parent), isGroup(group) { : QTreeWidgetItem(parent)
, isGroup(group)
, mCategory(CATEGORY_NONE) {
} }
void XTreeWidgetItem::SetCategory(TREE_CATEGORY category)
{
mCategory = category;
}
TREE_CATEGORY XTreeWidgetItem::GetCategory()
{
return mCategory;
}
bool XTreeWidgetItem::operator<(const QTreeWidgetItem &other) const { bool XTreeWidgetItem::operator<(const QTreeWidgetItem &other) const {
// Attempt to cast the other item to our custom type. // Attempt to cast the other item to our custom type.
const XTreeWidgetItem* otherItem = dynamic_cast<const XTreeWidgetItem*>(&other); const XTreeWidgetItem* otherItem = dynamic_cast<const XTreeWidgetItem*>(&other);

12
app/xtreewidgetitem.h
View File

@ -4,6 +4,12 @@
#include <QTreeWidget> #include <QTreeWidget>
#include <QTreeWidgetItem> #include <QTreeWidgetItem>
enum TREE_CATEGORY {
CATEGORY_NONE = 0x00,
CATEGORY_FILE = 0x01,
CATEGORY_TYPE = 0x02
};
// Custom item class // Custom item class
class XTreeWidgetItem : public QTreeWidgetItem class XTreeWidgetItem : public QTreeWidgetItem
{ {
@ -15,9 +21,15 @@ public:
XTreeWidgetItem(QTreeWidget *parent, bool group = false); XTreeWidgetItem(QTreeWidget *parent, bool group = false);
XTreeWidgetItem(QTreeWidgetItem *parent, bool group = false); XTreeWidgetItem(QTreeWidgetItem *parent, bool group = false);
void SetCategory(TREE_CATEGORY category);
TREE_CATEGORY GetCategory();
// Override the less-than operator to customize sorting. // Override the less-than operator to customize sorting.
bool operator<(const QTreeWidgetItem &other) const override; bool operator<(const QTreeWidgetItem &other) const override;
XTreeWidgetItem &operator =(const XTreeWidgetItem &other); XTreeWidgetItem &operator =(const XTreeWidgetItem &other);
private:
TREE_CATEGORY mCategory;
}; };