MME_NDS.py

from PyQt6 import QtGui, QtWidgets, QtCore#, QtMultimedia Qt6, Qt6.qsci
from pathlib import Path
import sys, os, platform, re, math
import argparse
import traceback
import bisect
#import logging, time, random
import ndspy
#import ndspy.graphics2D
#import ndspy.model
import ndspy.lz10
import ndspy.rom, ndspy.codeCompression, ndspy.code
import ndspy.soundArchive
import ndspy.soundSequenceArchive
import lib

try:
    import matplotlib.pyplot as pyplt#, matplotlib.backends.backend_qtagg as qtagg
except ImportError:
    pass

PATH_ROOT = Path(__file__).resolve().parent
lib.ini_rw.ini_dir = PATH_ROOT
parser = argparse.ArgumentParser()
parser.add_argument("-R", "--ROM", help="NDS ROM to open using the editor.", dest="openPath")
args = parser.parse_args()
"""
class ThreadSignals(QtCore.QObject): # signals can omly be emmited by QObject
    valueChanged = QtCore.pyqtSignal(int)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

class RunnableDisplayProgress(QtCore.QRunnable):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.signals = ThreadSignals()

    def run(self):
        print("runnable active")
        value = 0
        while value < 100:
            self.signals.valueChanged.emit(value)
            time.sleep(0.5)
            value += 10
        QtCore.QMetaObject.invokeMethod(w.progress, "close", QtCore.Qt.ConnectionType.QueuedConnection)
        QtCore.QMetaObject.invokeMethod(w.progress, "setValue", QtCore.Qt.ConnectionType.QueuedConnection, QtCore.Q_ARG(int, 0))
        print("runnable finish")
"""

class MainWindow(QtWidgets.QMainWindow):
    def __init__(self):
        super().__init__()
        # expected module versions
        self.VERSION_EDITOR = "0.4.6" # objective, feature, WIP
        self.VERSION_PYTHON = "3.14.3"
        self.VERSION_PYQT = "6.11.0"
        self.VERSION_NDSPY = "4.2.0"
        self.window_width = 1024
        self.window_height = 720
        self.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/appicon')))
        self.setWindowTitle("Mega Man ZX Editor")
        self.temp_path = str(PATH_ROOT / "temp/")
        self.rom = None #ndspy.rom.NintendoDSRom # placeholder definitions
        self.isGameSupported = False
        self.gamedat = None
        self.rom_fat = [] # list of file addresses (see loadFat())
        self.sdats: list[ndspy.soundArchive.SDAT] = [] #ndspy.soundArchive.SDAT
        self.base_address = 0
        self.relative_address = 0
        self.romToEdit_name = ''
        self.romToEdit_ext = ''
        self.romToEdit_path = '' # for overwrite save
        self.fileToEdit_name = ''
        self.fileDisplayRaw = False # Display file in 'raw'(hex) format. Else, displayed in readable format
        self.fileDisplayMode = "Adapt" # Modes: Adapt, Binary, Dialogue, Graphics, Font, Sound, Movie, Code
        self.fileDisplayState = "None" # Same states as mode
        self.widget_set = "Empty" # Empty, Text, Graphics, Font, Sound, VX
        self.GFX_PALETTES = [
            [0xff000000+((0x0b7421*i)%0x1000000) for i in range(256)], # default
            [0xff000000, 0xffffffff]*128, # font
            [0xff639c6b, 0xff426b9c, 0xff42a5c6, 0xff84c6e7, 0xffbdefff, 0xffdeffef, 0xffb58cff, 0xffefc6ff, # generic
             0xffffdeff, 0xfff70010, 0xfff76310, 0xfff79410, 0xfff7c600, 0xfff7f710, 0xfff7f794, 0xffffffff,
             0xff7b8463, 0xff102163, 0xff395294, 0xff949cc6, 0xffd6def7, 0xffffffff, 0xff9c0029, 0xfff7394a, # ZX
             0xffff9484, 0xff108c73, 0xffffce18, 0xffffff8c, 0xffffd6bd, 0xffd68410, 0xff8c4a00, 0xff39e7c6,
             0xff000000, 0xffc6f7ff, 0xffbdd6ff, 0xffa5adf7, 0xff8c7be7, 0xff7352de, 0xff5a29ce, 0xff4200c6, # PX shield
             0xff6b10ce, 0xff8c21de, 0xffb531ef, 0xffde4aff, 0xfff763ff, 0xffff9cff, 0xffffd6ff, 0xffffffff,
             0xff000000, 0xffc6f7ff, 0xffbdd6ff, 0xffa5adf7, 0xff8c7be7, 0xff7352de, 0xff5a29ce, 0xff4200c6, # PX shield
             0xff6b10ce, 0xff8c21de, 0xffb531ef, 0xffde4aff, 0xfff763ff, 0xffff9cff, 0xffffd6ff, 0xffffffff]*4, # sprites
            [0xff000000+((0x010101*i)%0x1000000) for i in range(256)], # 8bpp
            [0xff000000+((0x010101*i)%0x1000000) if i not in [0,255] else 0xffff00dd if i != 255 else 0xff000000 for i in range(256)], # cutscene
        ]
        self.gfx_palette = self.GFX_PALETTES[0]
        self.fileEdited_object = None
        self.levelEdited_ovlTable = {"entity slot": [], "entity coord": [], "level": []}
        self.levelEdited_ovl_object = None
        self.levelEdited_object = None
        self.resize(self.window_width, self.window_height)
        # Default Preferences
        self.theme_index = 0
        self.displayBase = 16
        self.displayBase_old = 16
        self.displayAlphanumeric = True
        self.firstLaunch = True
        self.fastLevel = False
        self.load_preferences()
        self.UiComponents()
        self.show()
        if args.openPath != None:
            self.loadROM(args.openPath)

    def load_preferences(self):
        lib.ini_rw.read(self, "SETTINGS", property_type="int", exc=["displayAlphanumeric"])
        lib.ini_rw.read(self, "SETTINGS", property_type="bool", inc=["displayAlphanumeric"])
        lib.ini_rw.read(self, "PERFORMANCE", property_type="bool", inc=["fastLevel"])
        lib.ini_rw.read(self, "MISC", property_type="bool")
        if self.firstLaunch:
            firstLaunch_dialog = QtWidgets.QMessageBox()
            firstLaunch_dialog.setWindowTitle("Mega Man ZX Editor - First Launch")
            firstLaunch_dialog.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/information')))
            firstLaunch_dialog.setTextFormat(QtCore.Qt.TextFormat.MarkdownText)
            firstLaunch_dialog.setText(f"""Thank you for trying out Mega Man ZX Editor!
                                       \rThe current version is {self.VERSION_EDITOR}."""
                                       )
            firstLaunch_dialog.setInformativeText(f"""Editor's current features ({self.VERSION_EDITOR.split('.')[1]}):
                                                  \r- Dialogue text editor
                                                  \r- Patcher(not many patches available yet)
                                                  \r- Graphics editor
                                                  \r- Font editor

                                                  \rWIP ({self.VERSION_EDITOR.split('.')[2]}):
                                                  \r- Sound data editor
                                                  \r- VX file editor
                                                  \r- OAM editor
                                                  \r- Level editor
                                                  \r- Dialogue name editor
                                                  \r- 3D Model editor""")
            #firstLaunch_dialog.setDetailedText("abc")
            firstLaunch_dialog.exec()

    def widgetIcon_update(self, widget: QtWidgets.QWidget, checkedicon: QtGui.QImage, uncheckedicon: QtGui.QImage):
        if widget.isChecked():
            widget.setIcon(checkedicon)
        else:
            widget.setIcon(uncheckedicon)

    def UiComponents(self):
        # reusable
        self.window_progress = QtWidgets.QMdiSubWindow()
        self.window_progress.setWindowFlags(QtCore.Qt.WindowType.Window | QtCore.Qt.WindowType.CustomizeWindowHint | QtCore.Qt.WindowType.WindowStaysOnTopHint | QtCore.Qt.WindowType.FramelessWindowHint)
        self.window_progress.resize(250, 35)
        self.window_progress.setWindowTitle("Progress")
        #self.window_progress.layout().addWidget(self.label_progress)

        self.progress = QtWidgets.QProgressBar(self.window_progress)

        self.layout_progress_title = QtWidgets.QHBoxLayout()

        self.label_progress_title = QtWidgets.QLabel(self.window_progress)
        self.label_progress_icon = QtWidgets.QLabel(self.window_progress)
        self.label_progress = QtWidgets.QLabel(self.window_progress)

        self.layout_progress_title.addWidget(self.label_progress_icon)
        self.layout_progress_title.addWidget(self.label_progress_title)

        self.window_progress.layout().addItem(self.layout_progress_title)
        self.window_progress.layout().addWidget(self.progress)
        self.window_progress.layout().addWidget(self.label_progress)
        # Menus
        self.openAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/folder-horizontal-open')), '&Open', self)    
        self.openAction.setShortcut('Ctrl+O')
        self.openAction.setStatusTip('Open ROM')
        self.openAction.triggered.connect(self.openCall)

        self.saveAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/disk')), '&Save', self)    
        self.saveAction.setShortcut('Ctrl+S')
        self.saveAction.setStatusTip('Save ROM')
        self.saveAction.triggered.connect(self.saveCall)
        self.saveAction.setDisabled(True)

        self.exportAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/blueprint--arrow')), '&Export...', self)        
        self.exportAction.setShortcut('Ctrl+E')
        self.exportAction.setStatusTip('Export file in binary or converted format')
        self.exportAction.triggered.connect(lambda: self.exportCall(self.tree.currentItem()))
        self.exportAction.setDisabled(True)

        self.replaceAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/blue-document-import')), '&Replace...', self)
        self.replaceAction.setShortcut('Ctrl+R')
        self.replaceAction.setStatusTip('Replace with file in binary or converted format')
        self.replaceAction.triggered.connect(lambda: self.replaceCall(self.tree.currentItem()))
        self.replaceAction.setDisabled(True)

        self.replacebynameAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/blue-document-import')), '&Replace by name...', self)        
        self.replacebynameAction.setStatusTip('Replace with file of same name in binary or converted format')
        self.replacebynameAction.triggered.connect(self.replacebynameCall)

        self.menu_bar = self.menuBar()
        self.fileMenu = self.menu_bar.addMenu('&File')
        self.fileMenu.addActions([self.openAction, self.saveAction, self.exportAction])
        self.importSubmenu = self.fileMenu.addMenu('&Import...')
        #self.importSubmenu.setStatusTip('Use external file to replace a file in ROM')
        self.importSubmenu.setIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/blue-document-import')))
        self.importSubmenu.addActions([self.replaceAction, self.replacebynameAction])
        self.importSubmenu.setDisabled(True)


        self.dialog_about = QtWidgets.QDialog(self)
        self.dialog_about.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/information')))
        self.dialog_about.setWindowTitle("About Mega Man ZX Editor")
        self.dialog_about.resize(500, 500)
        self.text_about = QtWidgets.QTextBrowser(self.dialog_about)
        self.text_about.resize(self.dialog_about.width(), self.dialog_about.height())
        self.text_about.setText(f"""Supports:\
                                \rMEGAMANZX (Mega Man ZX)\
                                \rROCKMANZX (ロックマン ゼクス)\
                                \rMEGAMANZXA (Mega Man ZX Advent)\
                                \rROCKMANZXA (ロックマンゼクス アドベント)\

                                \rVersionning:\
                                \rEditor version: {self.VERSION_EDITOR} (final objective(s) completed, major functional features, WIP features)\
                                \rPython version: {self.VERSION_PYTHON} (your version is {platform.python_version()})\
                                \rPyQt version: {self.VERSION_PYQT} (your version is {QtCore.PYQT_VERSION_STR})\
                                \rNDSPy version: {self.VERSION_NDSPY} (your version is {list(ndspy.VERSION)[0]}.{list(ndspy.VERSION)[1]}.{list(ndspy.VERSION)[2]})""")
        self.aboutAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/information')), '&About', self)
        self.aboutAction.setStatusTip('Show information about the application')
        self.aboutAction.triggered.connect(lambda: self.dialog_about.exec())

        self.dialog_settings = QtWidgets.QDialog(self)
        self.dialog_settings.setWindowTitle("Settings")
        self.dialog_settings.resize(250, 50)
        self.dialog_settings.setLayout(QtWidgets.QGridLayout())
        self.tabs_settings = QtWidgets.QTabWidget(self.dialog_settings)
        self.page_settings_general = QtWidgets.QWidget(self.tabs_settings)
        self.page_settings_general.setLayout(QtWidgets.QGridLayout())
        self.page_settings_performance = QtWidgets.QWidget(self.tabs_settings)
        self.page_settings_performance.setLayout(QtWidgets.QGridLayout())
        self.tabs_settings.addTab(self.page_settings_general, "General")
        self.tabs_settings.addTab(self.page_settings_performance, "Performance")
        # General Settings
        self.label_theme = QtWidgets.QLabel("Theme", self.page_settings_general)
        self.dropdown_theme = QtWidgets.QComboBox(self.page_settings_general)
        self.dropdown_theme.addItems(QtWidgets.QStyleFactory.keys())
        self.dropdown_theme.addItem("Custom")
        self.switch_theme(True) # Update theme dropdown with current option
        self.dropdown_theme.activated.connect(lambda: self.switch_theme())
        self.label_base = QtWidgets.QLabel("Numeric Base", self.page_settings_general)
        self.field_base = QtWidgets.QSpinBox(self.page_settings_general)
        self.field_base.setValue(self.displayBase)
        self.field_base.setRange(-1000, 1000)
        self.field_base.editingFinished.connect(lambda: setattr(self, "displayBase", self.field_base.value()))
        self.field_base.editingFinished.connect(self.reloadCall)
        self.checkbox_alphanumeric = QtWidgets.QCheckBox(self.page_settings_general)
        self.checkbox_alphanumeric.setText("Alphanumeric Numbers")
        self.checkbox_alphanumeric.setChecked(self.displayAlphanumeric)
        self.checkbox_alphanumeric.toggled.connect(lambda: setattr(self, "displayAlphanumeric", not self.displayAlphanumeric))
        self.checkbox_alphanumeric.toggled.connect(self.reloadCall)
        # Performance Settings
        self.checkbox_fastLevel = QtWidgets.QCheckBox(self.page_settings_performance)
        self.checkbox_fastLevel.checkStateChanged.connect(lambda: setattr(self, "fastLevel", self.checkbox_fastLevel.isChecked()))
        self.checkbox_fastLevel.setChecked(self.fastLevel)
        self.checkbox_fastLevel.setText("Disable LevelTileItem coordinate cache")
        self.checkbox_fastLevel.setToolTip("Sacrifices some graphical fidelity in favor of faster rendering when zooming in/out")
        self.checkbox_fastLevel.setToolTipDuration(10000)

        self.dialog_settings.layout().addWidget(self.tabs_settings)
        self.page_settings_general.layout().addWidget(self.label_theme)
        self.page_settings_general.layout().addWidget(self.dropdown_theme)
        self.page_settings_general.layout().addWidget(self.label_base)
        self.page_settings_general.layout().addWidget(self.field_base)
        self.page_settings_general.layout().addWidget(self.checkbox_alphanumeric)
        self.page_settings_performance.layout().addWidget(self.checkbox_fastLevel)

        self.settingsAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/gear')), '&Settings', self)
        self.settingsAction.setStatusTip('Settings')
        self.settingsAction.triggered.connect(lambda: self.dialog_settings.exec())

        self.exitAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/door')), '&Exit', self)
        self.exitAction.setStatusTip('Exit application')
        self.exitAction.triggered.connect(self.close)

        self.appMenu = self.menu_bar.addMenu('&Application')
        self.appMenu.addActions([self.aboutAction, self.settingsAction, self.exitAction])

        self.displayRawAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/brain')), '&Converted formats', self)
        self.displayRawAction.setStatusTip('Displays files in a readable format instead of hex format.')
        self.displayRawAction.setCheckable(True)
        self.displayRawAction.setChecked(True)
        self.displayRawAction.triggered.connect(self.display_format_toggleCall)

        self.viewAdaptAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/document-node')), '&Adapt', self)
        self.viewAdaptAction.setStatusTip('Files will be decrypted on a case per case basis.')
        self.viewAdaptAction.setCheckable(True)
        self.viewAdaptAction.setChecked(True)
        self.viewAdaptAction.triggered.connect(lambda: setattr(self, "fileDisplayMode", "Adapt"))
        self.viewAdaptAction.triggered.connect(lambda: self.treeCall())

        self.viewDialogueAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/document-text')), '&Dialogue', self)
        self.viewDialogueAction.setStatusTip('Files will be decrypted as in-game dialogues.')
        self.viewDialogueAction.setCheckable(True)
        self.viewDialogueAction.triggered.connect(lambda: setattr(self, "fileDisplayMode", "Dialogue"))
        self.viewDialogueAction.triggered.connect(lambda: self.treeCall())

        self.viewGraphicAction = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/appicon')), '&Graphics', self)
        self.viewGraphicAction.setStatusTip('Files will be decrypted as graphics.')
        self.viewGraphicAction.setCheckable(True)
        self.viewGraphicAction.triggered.connect(lambda: setattr(self, "fileDisplayMode", "Graphics"))
        self.viewGraphicAction.triggered.connect(lambda: self.treeCall())

        self.viewFormatsGroup = QtGui.QActionGroup(self) #group for mutually exclusive togglable items
        self.viewFormatsGroup.addAction(self.viewAdaptAction)
        self.viewFormatsGroup.addAction(self.viewDialogueAction)
        self.viewFormatsGroup.addAction(self.viewGraphicAction)

        self.viewMenu = self.menu_bar.addMenu('&View')
        self.viewMenu.addAction(self.displayRawAction)
        self.displayFormatSubmenu = self.viewMenu.addMenu(QtGui.QIcon(str(PATH_ROOT / 'icons/document-convert')), '&Set edit mode...')
        self.displayFormatSubmenu.addAction(self.viewAdaptAction)
        self.displayFormatSubmenu.addSeparator()
        self.displayFormatSubmenu.addActions(self.viewFormatsGroup.actions()[1:])

        #Toolbar
        self.toolbar = lib.widget.Toolbar("Main Toolbar", span=[23, self.width()])
        self.toolbar.setSizePolicy(QtWidgets.QSizePolicy.Policy.Ignored, QtWidgets.QSizePolicy.Policy.Ignored)
        self.addToolBar(self.toolbar)

        self.action_open = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/folder-horizontal-open')), "Load ROM from Disk", self)
        self.action_open.setStatusTip("Open NDS or SRL file to be able to edit its contents.")
        self.action_open.triggered.connect(self.openCall)
        self.action_save = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/disk')), "Save ROM to Disk", self)
        self.action_save.setStatusTip("Generate ROM with saved changes; unsaved changes will remain unsaved.")
        self.action_save.triggered.connect(self.saveCall)
        self.action_save.setDisabled(True)
        self.button_playtest = lib.widget.HoldButton(QtGui.QIcon(str(PATH_ROOT / 'icons/control')), "", self)
        self.button_playtest.setToolTip("Playtest ROM (Hold for options)")
        self.button_playtest.setStatusTip("Create a temporary ROM to test saved changes")
        self.button_playtest.allow_repeat = False
        self.button_playtest.allow_press = True
        self.button_playtest.pressed_quick.connect(lambda: self.testCall(True))
        self.button_playtest.held.connect(lambda: self.testCall(False))
        self.button_playtest.setDisabled(True)
        self.button_reload = lib.widget.HoldButton(QtGui.QIcon(str(PATH_ROOT / 'icons/arrow-circle-315')), "", self)
        self.button_reload.setToolTip("Reload Interface (Hold for deep reload)")
        self.button_reload.setStatusTip("Reload the displayed data(all changes that aren't saved will be lost)")
        self.button_reload.allow_repeat = False
        self.button_reload.allow_press = True
        self.button_reload.pressed_quick.connect(lambda: self.reloadCall(1))
        self.button_reload.held.connect(lambda: self.reloadCall(2))
        self.action_sdat = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/speaker-volume')), "Open Sound Data Archive", self)
        self.action_sdat.setStatusTip("Show the contents of this ROM's sdat file")
        self.action_sdat.triggered.connect(lambda: self.dialogOpenCall("dialog_sdat"))
        self.action_sdat.setDisabled(True)
        self.action_arm9 = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/processor-num-9')), "Open ARM9", self)
        self.action_arm9.setStatusTip("Show the contents of this ROM's ARM9")
        self.action_arm9.triggered.connect(lambda: self.dialogOpenCall("dialog_arm9"))
        self.action_arm9.setDisabled(True)
        self.action_arm7 = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/processor-num-7')), "Open ARM7", self)
        self.action_arm7.setStatusTip("Show the contents of this ROM's ARM7")
        self.action_arm7.triggered.connect(lambda: self.dialogOpenCall("dialog_arm7"))
        self.action_arm7.setDisabled(True)
        #self.button_codeedit = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/document-text')), "Open code", self)
        #self.button_codeedit.setStatusTip("Edit the ROM's code")
        #self.button_codeedit.triggered.connect(self.codeeditCall)
        #self.button_codeedit.setDisabled(True)
        self.toolbar.addActions([self.action_open, self.action_save, self.action_arm9, self.action_arm7, self.action_sdat])
        self.toolbar.insertWidget(self.action_arm9, self.button_playtest)
        self.toolbar.addWidget(self.button_reload)
        self.toolbar.addSeparator()

        #Tabs
        self.tabs = QtWidgets.QTabWidget(self)
        self.setCentralWidget(self.tabs)

        self.page_explorer = QtWidgets.QWidget(self.tabs)
        self.page_explorer.setLayout(QtWidgets.QHBoxLayout())

        self.page_leveleditor = QtWidgets.QWidget(self.tabs)
        self.page_leveleditor.setLayout(QtWidgets.QHBoxLayout())
        self.page_leveleditor.layout().setContentsMargins(0,0,0,0)

        self.page_tweaks = QtWidgets.QWidget(self.tabs)
        self.page_tweaks.setLayout(QtWidgets.QVBoxLayout())
        self.page_tweaks.layout().setContentsMargins(0,0,0,0)

        self.page_patches = QtWidgets.QWidget(self.tabs)
        self.page_patches.setLayout(QtWidgets.QGridLayout())

        self.tabs.addTab(self.page_explorer, "File Explorer")
        self.tabs.addTab(self.page_leveleditor, "Level Editor") # Coming Soon™
        self.tabs.addTab(self.page_tweaks, "Tweaks") # Coming Soon™
        self.tabs.addTab(self.page_patches, "Patches") # Coming Soon™
        self.tabs.currentChanged.connect(self.tabChangeCall)

        #  ROM-related
        # ARM

        self.dialog_arm9 = QtWidgets.QMainWindow(self) # "independent" window: can move anywhere on screen, but still affected by main window
        self.dialog_arm9.setWindowTitle("ARM9")
        self.dialog_arm9.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/processor-num-9')))
        self.dialog_arm9.resize(600, 400)

        self.tabs_arm9 = QtWidgets.QTabWidget(self.dialog_arm9)
        self.dialog_arm9.setCentralWidget(self.tabs_arm9)

        self.page_arm9 = QtWidgets.QWidget(self.tabs_arm9)
        self.page_arm9.setLayout(QtWidgets.QVBoxLayout())
        self.page_arm9Ovltable = QtWidgets.QWidget(self.tabs_arm9)
        self.page_arm9Ovltable.setLayout(QtWidgets.QHBoxLayout())

        self.dialog_arm9_dialogueNames = QtWidgets.QMainWindow(self)
        self.dialog_arm9_dialogueNames.setWindowTitle("ARM9 - Dialogue Names")
        self.dialog_arm9_dialogueNames.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/document-text')))

        self.page_dialoguenames = QtWidgets.QWidget(self.dialog_arm9_dialogueNames)
        self.page_dialoguenames.setLayout(QtWidgets.QGridLayout())
        self.button_dialogueNames_save = QtWidgets.QPushButton("Save Name", self.page_dialoguenames)
        self.button_dialogueNames_save.pressed.connect(self.saveDialogueName)
        self.button_dialogueNames_save.setDisabled(True)
        self.dropdown_dialogueNames = QtWidgets.QComboBox(self.page_dialoguenames)
        self.dropdown_dialogueNames.setPlaceholderText("Select name index...")
        self.dropdown_dialogueNames.currentIndexChanged.connect(self.loadDialogueName)
        self.dropdown_dialogueNames_lang = QtWidgets.QComboBox(self.page_dialoguenames)
        self.dropdown_dialogueNames_lang.addItems(["jp", "en"])
        self.dropdown_dialogueNames_lang.currentIndexChanged.connect(lambda: self.dropdown_dialogueNames.setCurrentIndex(-1))
        self.textEdit_dialogueNames = lib.widget.LongTextEdit(self.page_dialoguenames, charmap=lib.dialogue.CHARMAP_DIALOGUENAME_ZX_EN)
        self.textEdit_dialogueNames.textChanged.connect(lambda: self.button_dialogueNames_save.setDisabled(False))
        self.textEdit_dialogueNames.setMaximumHeight(30)

        self.dialog_arm9_dialogueNames.setCentralWidget(self.page_dialoguenames)
        self.page_dialoguenames.layout().addWidget(self.button_dialogueNames_save, 0,0,1,2)
        self.page_dialoguenames.layout().addWidget(self.dropdown_dialogueNames, 1,0,1,1)
        self.page_dialoguenames.layout().addWidget(self.dropdown_dialogueNames_lang, 1,1,1,1)
        self.page_dialoguenames.layout().addWidget(self.textEdit_dialogueNames, 2,0,1,2)

        self.tabs_arm9.addTab(self.page_arm9, "Main Code")
        self.tabs_arm9.addTab(self.page_arm9Ovltable, "Overlays")

        self.action_arm9_dialogueNames = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/document-text')), "Dialogue Names", self.dialog_arm9)
        self.action_arm9_dialogueNames.triggered.connect(lambda: self.dialogOpenCall("dialog_arm9_dialogueNames"))
        self.toolbar_arm9 = lib.widget.Toolbar("ARM9 Toolbar")
        self.toolbar_arm9.addActions([self.action_arm9_dialogueNames])

        self.tree_arm9 = lib.widget.EditorTree(self.page_arm9)
        self.tree_arm9.ContextNameType = "code-section at "
        self.tree_arm9.setColumnCount(3)
        self.tree_arm9.setHeaderLabels(["RAM Address", "Name", "Implicit", "BSS Size"])
        self.tree_arm9.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)

        self.page_arm9.layout().addWidget(self.toolbar_arm9)
        self.page_arm9.layout().addWidget(self.tree_arm9)


        self.tree_arm9Ovltable = lib.widget.EditorTree(self.page_arm9Ovltable)
        self.tree_arm9Ovltable.ContextNameType = "overlay "
        self.tree_arm9Ovltable.setColumnCount(10)
        self.tree_arm9Ovltable.setHeaderLabels(["File ID", "RAM Address", "Compressed", "Size", "RAM Size", "BSS Size", "StaticInit Start", "StaticInit End", "Flags", "Verify Hash"])
        self.tree_arm9Ovltable.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)

        self.page_arm9Ovltable.layout().addWidget(self.tree_arm9Ovltable)


        self.dialog_arm7 = QtWidgets.QMainWindow(self)
        self.dialog_arm7.setWindowTitle("ARM7")
        self.dialog_arm7.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/processor-num-7')))
        self.dialog_arm7.resize(600, 400)

        self.tabs_arm7 = QtWidgets.QTabWidget(self.dialog_arm7)
        self.dialog_arm7.setCentralWidget(self.tabs_arm7)

        self.page_arm7 = QtWidgets.QWidget(self.tabs_arm7)
        self.page_arm7.setLayout(QtWidgets.QHBoxLayout())
        self.page_arm7Ovltable = QtWidgets.QWidget(self.tabs_arm7)
        self.page_arm7Ovltable.setLayout(QtWidgets.QHBoxLayout())

        self.tabs_arm7.addTab(self.page_arm7, "Main Code")
        self.tabs_arm7.addTab(self.page_arm7Ovltable, "Overlays")

        self.tree_arm7 = lib.widget.EditorTree(self.page_arm7)
        self.page_arm7.layout().addWidget(self.tree_arm7)
        self.tree_arm7.ContextNameType = "code-section at "
        self.tree_arm7.setColumnCount(3)
        self.tree_arm7.setHeaderLabels(["RAM Address", "Name", "Implicit", "BSS Size"])
        self.tree_arm7.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)

        self.tree_arm7Ovltable = lib.widget.EditorTree(self.page_arm7Ovltable)
        self.page_arm7Ovltable.layout().addWidget(self.tree_arm7Ovltable)
        self.tree_arm7Ovltable.ContextNameType = "overlay "
        self.tree_arm7Ovltable.setColumnCount(10)
        self.tree_arm7Ovltable.setHeaderLabels(["File ID", "RAM Address", "Compressed", "Size", "RAM Size", "BSS Size", "StaticInit Start", "StaticInit End", "Flags", "Verify Hash"])
        self.tree_arm7Ovltable.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)

        # File explorer
        self.tree = lib.widget.EditorTree(self.page_explorer)
        self.tree.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOn)
        self.page_explorer.layout().addWidget(self.tree, 0)
        self.tree.setMaximumWidth(450)
        self.tree.setColumnCount(3)
        self.tree.setHeaderLabels(["File ID", "Name", "Type"])
        self.tree.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)
        self.tree_called = False
        self.tree.itemSelectionChanged.connect(lambda: self.treeCall(addr_reset=True))

        self.layout_editzone = QtWidgets.QVBoxLayout()
        self.page_explorer.layout().addItem(self.layout_editzone)
        self.layout_editzone_row0 = QtWidgets.QHBoxLayout()
        self.layout_editzone_row1 = QtWidgets.QHBoxLayout()
        self.layout_editzone_row2 = QtWidgets.QHBoxLayout()
        self.layout_editzone_row3 = QtWidgets.QHBoxLayout()
        self.widget_colorpick = QtWidgets.QWidget(self.page_explorer)
        self.layout_colorpick = lib.widget.GridLayout()
        self.layout_colorpick.setAlignment(QtCore.Qt.AlignmentFlag.AlignLeft)
        self.layout_colorpick.setContentsMargins(0,2,5,0)
        self.layout_colorpick.setSpacing(0)
        self.widget_colorpick.setLayout(self.layout_colorpick)

        self.button_file_save = QtWidgets.QPushButton("Save changes", self.page_explorer)
        self.button_file_save.setMaximumWidth(100)
        self.button_file_save.setToolTip("save this file's changes")
        self.button_file_save.pressed.connect(self.save_filecontent)
        self.button_file_save.setDisabled(True)
        self.button_file_save.hide()

        self.file_content = QtWidgets.QGridLayout()
        self.file_content_text = lib.widget.LongTextEdit(self.page_explorer)
        self.file_content_text.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Expanding)
        font = QtGui.QFont("Monospace")
        font.setStyleHint(QtGui.QFont.StyleHint.TypeWriter)
        self.file_content_text.setFont(font)
        self.file_content_text.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.NoContextMenu)
        self.file_content_text.textChanged.connect(lambda: self.button_file_save.setDisabled(False))
        self.file_content_text.setDisabled(True)

        self.dropdown_textindex = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_textindex.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
        self.dropdown_textindex.previousIndex = self.dropdown_textindex.currentIndex()
        self.dropdown_textindex.currentIndexChanged.connect(lambda: self.treeCall())

        self.checkbox_textoverwite = QtWidgets.QCheckBox("Overwite\n existing text", self.page_explorer)
        self.checkbox_textoverwite.setStatusTip("With this enabled, writing text won't change filesize")
        self.checkbox_textoverwite.clicked.connect(lambda: self.file_content_text.setOverwriteMode(not self.file_content_text.overwriteMode()))

        self.layout_editzone_row1.addWidget(self.checkbox_textoverwite)
        self.layout_editzone_row1.addWidget(self.dropdown_textindex)

        self.file_content_gfx = lib.widget.GFXView(self.page_explorer)
        self.file_content_gfx.setSizePolicy(QtWidgets.QSizePolicy.Policy.Ignored, QtWidgets.QSizePolicy.Policy.Expanding)
        self.file_content.addWidget(self.file_content_gfx)
        self.file_content.addWidget(self.file_content_text)

        self.dropdown_gfx_depth = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_gfx_depth.addItems(["1bpp", "4bpp", "8bpp"])# order of names is determined by the enum in dataconverter
        self.dropdown_gfx_depth.currentIndexChanged.connect(lambda: self.treeCall())# Update gfx with current depth

        self.font_caps = QtGui.QFont()
        self.font_caps.setCapitalization(QtGui.QFont.Capitalization.AllUppercase)
        
        #Address bar
        self.field_address = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_address.numfill = 8
        self.field_address.setFont(self.font_caps)
        self.field_address.setValue(self.base_address+self.relative_address)
        self.field_address.isInt = True
        #self.field_address.setPrefix("0x")
        self.field_address.numbase = self.displayBase
        #self.field_address.textChanged.connect(lambda: self.value_update_Call("relative_address", library.dataconverter.baseToInt(library.dataconverter.strToBase(self.field_address.text()), self.field_address.displayIntegerBase()) - self.base_address, True))
        self.field_address.textChanged.connect(lambda: self.value_update_Call("relative_address", int(self.field_address.valueFromText(self.field_address.text()) - self.base_address), True))
        self.field_address.setDisabled(True)
        self.field_address.hide()
        #notes
        self.label_file_size = QtWidgets.QLabel(self.page_explorer)
        self.label_file_size.setContentsMargins(5,0,0,0)
        self.label_file_size.setText("Size: N/A")
        self.label_file_size.hide()

        self.button_view_save = QtWidgets.QPushButton(QtGui.QIcon(str(PATH_ROOT / 'icons/blueprint--arrow')), "", self.page_explorer)
        self.button_view_save.setMaximumWidth(25)
        self.button_view_save.setToolTip("Save to bmp")
        self.button_view_save.setStatusTip("Generate BMP from view")
        self.button_view_save.pressed.connect(self.save_viewImage)
        self.button_view_load = QtWidgets.QPushButton(QtGui.QIcon(str(PATH_ROOT / 'icons/blue-document-import')), "", self.page_explorer)
        self.button_view_load.setMaximumWidth(25)
        self.button_view_load.setToolTip("Load from bmp")
        self.button_view_load.setStatusTip("Load BMP into view")
        self.button_view_load.pressed.connect(self.load_viewImage)
        #Tile Wifth
        self.tile_width = 8
        self.field_tile_width = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_tile_width.setStatusTip(f"Set tile width to {lib.datconv.numToStr(16, self.displayBase, self.displayAlphanumeric)}, {lib.datconv.numToStr(32, self.displayBase, self.displayAlphanumeric)} or {lib.datconv.numToStr(64, self.displayBase, self.displayAlphanumeric)} for some ZXA sprites")
        self.field_tile_width.setFont(self.font_caps)
        self.field_tile_width.setValue(self.tile_width)
        self.field_tile_width.setMinimum(1)
        self.field_tile_width.numbase = self.displayBase
        self.field_tile_width.isInt = True
        self.field_tile_width.valueChanged.connect(lambda: self.value_update_Call("tile_width", int(self.field_tile_width.value()), True))
        self.field_tile_width.valueChanged.connect(self.file_content_gfx.fitInView2)

        self.label_tile_width = QtWidgets.QLabel(self.page_explorer)
        self.label_tile_width.setText(" width")

        self.layout_tile_width = QtWidgets.QVBoxLayout()
        self.layout_tile_width.addWidget(self.field_tile_width)
        self.layout_tile_width.addWidget(self.label_tile_width)
        self.layout_tile_width.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
        #Tile Height
        self.tile_height = 8
        self.field_tile_height = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_tile_height.setFont(self.font_caps)
        self.field_tile_height.setValue(self.tile_height)
        self.field_tile_height.setMinimum(1)
        self.field_tile_height.numbase = self.displayBase
        self.field_tile_height.isInt = True
        self.field_tile_height.valueChanged.connect(lambda: self.value_update_Call("tile_height", int(self.field_tile_height.value()), True)) 
        self.field_tile_height.valueChanged.connect(self.file_content_gfx.fitInView2)

        self.label_tile_height = QtWidgets.QLabel(self.page_explorer)
        self.label_tile_height.setText(" height")

        self.layout_tile_height = QtWidgets.QVBoxLayout()
        self.layout_tile_height.addWidget(self.field_tile_height)
        self.layout_tile_height.addWidget(self.label_tile_height)
        self.layout_tile_height.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
        #Tiles Per row
        self.tiles_per_row = 8
        self.field_tiles_per_row = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_tiles_per_row.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
        self.field_tiles_per_row.setFont(self.font_caps)
        self.field_tiles_per_row.setValue(self.tiles_per_row)
        self.field_tiles_per_row.setMinimum(1)
        self.field_tiles_per_row.isInt = True
        self.field_tiles_per_row.numbase = self.displayBase
        self.field_tiles_per_row.valueChanged.connect(lambda: self.value_update_Call("tiles_per_row", int(self.field_tiles_per_row.value()), True))
        self.field_tiles_per_row.valueChanged.connect(self.file_content_gfx.fitInView2)

        self.label_tiles_per_row = QtWidgets.QLabel(self.page_explorer)
        self.label_tiles_per_row.setText(" columns")

        self.layout_tiles_per_row = QtWidgets.QVBoxLayout()
        self.layout_tiles_per_row.addWidget(self.field_tiles_per_row)
        self.layout_tiles_per_row.addWidget(self.label_tiles_per_row)
        self.layout_tiles_per_row.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
        #Tiles Per Column
        self.tiles_per_column = 8
        self.field_tiles_per_column = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_tiles_per_column.setSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding, QtWidgets.QSizePolicy.Policy.Fixed)
        self.field_tiles_per_column.setFont(self.font_caps)
        self.field_tiles_per_column.setValue(self.tiles_per_column)
        self.field_tiles_per_column.setMinimum(1)
        self.field_tiles_per_column.isInt = True
        self.field_tiles_per_column.numbase = self.displayBase
        self.field_tiles_per_column.valueChanged.connect(lambda: self.value_update_Call("tiles_per_column", int(self.field_tiles_per_column.value()), True))
        self.field_tiles_per_column.valueChanged.connect(self.file_content_gfx.fitInView2)

        self.label_tiles_per_column = QtWidgets.QLabel(self.page_explorer)
        self.label_tiles_per_column.setText(" rows")

        self.layout_tiles_per_column = QtWidgets.QVBoxLayout()
        self.layout_tiles_per_column.addWidget(self.field_tiles_per_column)
        self.layout_tiles_per_column.addWidget(self.label_tiles_per_column)
        self.layout_tiles_per_column.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)

        self.layout_tile_settings = QtWidgets.QHBoxLayout()
        self.layout_tile_settings.addItem(self.layout_tile_width)
        self.layout_tile_settings.addItem(self.layout_tile_height)
        self.layout_tile_settings.addItem(self.layout_tiles_per_row)
        self.layout_tile_settings.addItem(self.layout_tiles_per_column)

        self.dropdown_gfx_index = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_gfx_index.setPlaceholderText("no section entries")
        self.dropdown_gfx_index.setToolTip("Choose index")
        self.dropdown_gfx_index.setStatusTip("Select the object index to go to in gfx file")
        self.dropdown_gfx_index.currentIndexChanged.connect(lambda: self.treeCall())
        self.dropdown_gfx_subindex = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_gfx_subindex.setPlaceholderText("no sub-entries")
        self.dropdown_gfx_subindex.setToolTip("Choose sub-index")
        self.dropdown_gfx_subindex.setStatusTip("Select the image index to go to in gfx object")
        self.dropdown_gfx_subindex.currentIndexChanged.connect(lambda: self.treeCall())

        self.checkbox_depthUpdate = QtWidgets.QCheckBox(self.page_explorer)
        self.checkbox_depthUpdate.setStatusTip("Update depth to match palette size")
        self.checkbox_depthUpdate.setChecked(True)
        self.checkbox_depthUpdate.checkStateChanged.connect(lambda: self.treeCall())

        self.label_depthUpdate = QtWidgets.QLabel(self.page_explorer)
        self.label_depthUpdate.setText("Guess correct depth")

        self.layout_other_settings = QtWidgets.QGridLayout()
        self.layout_other_settings.addWidget(self.checkbox_depthUpdate, 0,0, QtCore.Qt.AlignmentFlag.AlignRight)
        self.layout_other_settings.addWidget(self.label_depthUpdate, 0,1)
        self.layout_other_settings.addWidget(self.dropdown_gfx_index, 1,0)
        self.layout_other_settings.addWidget(self.dropdown_gfx_subindex, 1,1)

        #Palettes
        for i in range(256): #setup default palette
            setattr(self, f"button_palettepick_{i}", lib.widget.HoldButton(self.page_explorer))
            button_palettepick: lib.widget.HoldButton = getattr(self, f"button_palettepick_{i}")
            button_palettepick.allow_press = True
            button_palettepick.press_quick_threshold = 1
            button_palettepick.setStyleSheet(f"background-color: #{self.gfx_palette[i]:08x}; color: white;")
            button_palettepick.setMaximumSize(10, 10)
            self.layout_colorpick.addWidget(button_palettepick, int(i/16), int(i%16))
            button_palettepick.held.connect(lambda hold, press=None, color_index=i: self.colorpickCall(color_index, press, hold))
            button_palettepick.pressed_quick.connect(lambda press, hold=None, color_index=i: self.colorpickCall(color_index, press, hold))

        self.dropdown_gfx_palette = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_gfx_palette.addItems(["Default Palette", "Font Palette", "Sprites Palette", "Grayscale", "Grayscale Alt"]) # order of names is determined by self.GFX_PALETTES
        self.dropdown_gfx_palette.setToolTip("Choose palette")
        self.dropdown_gfx_palette.setStatusTip("Select the color palette preset that you want to use to render images")
        self.dropdown_gfx_palette.currentIndexChanged.connect(lambda: self.setPalette(self.GFX_PALETTES[self.dropdown_gfx_palette.currentIndex()])) # Update gfx with current depth
        self.dropdown_gfx_palette.currentIndexChanged.connect(lambda: self.treeCall())

        self.layout_palette_settings = QtWidgets.QHBoxLayout()
        self.layout_palette_settings.addWidget(self.dropdown_gfx_palette)

        self.layout_gfx_settings = QtWidgets.QVBoxLayout()
        self.layout_gfx_settings.addItem(self.layout_tile_settings)
        self.layout_gfx_settings.addItem(self.layout_other_settings)
        self.layout_gfx_settings.addItem(self.layout_palette_settings)

        #OAM
        self.dropdown_oam_entry = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_oam_entry.setPlaceholderText("no oam entries")
        self.dropdown_oam_entry.setToolTip("Choose entry")
        self.dropdown_oam_entry.setStatusTip("Select the OAM entry to load")
        self.dropdown_oam_entry.currentIndexChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.tabs_oam = QtWidgets.QTabWidget(self.page_explorer)
        self.page_oam_frames = QtWidgets.QWidget(self.tabs_oam)
        self.page_oam_frames.setLayout(QtWidgets.QGridLayout())
        self.page_oam_anims = QtWidgets.QWidget(self.tabs_oam)
        self.page_oam_anims.setLayout(QtWidgets.QGridLayout())
        self.tabs_oam.addTab(self.page_oam_frames, "Frames")
        self.tabs_oam.addTab(self.page_oam_anims, "Animations")
        self.tabs_oam.currentChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.dropdown_oam_anim = QtWidgets.QComboBox(self.page_oam_anims)
        self.dropdown_oam_anim.setPlaceholderText("no animation entries")
        self.dropdown_oam_anim.setToolTip("Choose animation")
        self.dropdown_oam_anim.setStatusTip("Select the animation to load")
        self.dropdown_oam_anim.currentIndexChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.dropdown_oam_animFrame = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_oam_animFrame.setPlaceholderText("no animation frames")
        self.dropdown_oam_animFrame.setToolTip("Choose frame")
        self.dropdown_oam_animFrame.setStatusTip("Select the animation frame to load")
        self.dropdown_oam_animFrame.currentIndexChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.field_oam_animFrameId = lib.widget.BetterSpinBox(self.page_oam_anims)
        self.field_oam_animFrameId.setToolTip("Frame Id")
        self.field_oam_animFrameId.setStatusTip("Frame index as seen in the frame editing tab")
        self.field_oam_animFrameId.isInt = True
        self.field_oam_animFrameId.setRange(0, 0xFF)
        self.field_oam_animFrameId.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_oam_animFrameId.valueChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.field_oam_animFrameDuration = lib.widget.BetterSpinBox(self.page_oam_anims)
        self.field_oam_animFrameDuration.setToolTip("Duration (Frames)")
        self.field_oam_animFrameDuration.setStatusTip("Duration of current frame; After the first frame, 0xFE and 0xFF are treated as loop and end")
        self.field_oam_animFrameDuration.isInt = True
        self.field_oam_animFrameDuration.setRange(0, 0xFF)
        self.field_oam_animFrameDuration.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_oam_animFrameDuration.valueChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.button_oam_animFrameAdd = QtWidgets.QPushButton("Add Frame", self.page_oam_anims)
        self.button_oam_animFrameAdd.pressed.connect(lambda: self.treeCall(addr_disabled=True))

        self.button_oam_animFrameRemove = QtWidgets.QPushButton("Remove Frame", self.page_oam_anims)
        self.button_oam_animFrameRemove.pressed.connect(lambda: self.treeCall(addr_disabled=True))

        self.checkbox_oam_animLoop = QtWidgets.QCheckBox(self.page_oam_anims)
        self.checkbox_oam_animLoop.setText("Loop")
        self.checkbox_oam_animLoop.setToolTip("Loop")
        self.checkbox_oam_animLoop.setStatusTip("Enable/Disable animation loop point")
        self.checkbox_oam_animLoop.checkStateChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.checkbox_oam_animLoop.checkStateChanged.connect(lambda: self.field_oam_animLoopStart.setEnabled(self.checkbox_oam_animLoop.isChecked()))

        self.field_oam_animLoopStart = lib.widget.BetterSpinBox(self.page_oam_anims)
        self.field_oam_animLoopStart.setToolTip("Loop Start")
        self.field_oam_animLoopStart.setStatusTip("Frame index to jump to at the end of animation")
        self.field_oam_animLoopStart.isInt = True
        self.field_oam_animLoopStart.setRange(0, 0xFF)
        self.field_oam_animLoopStart.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))

        self.button_oam_animToStart = QtWidgets.QPushButton(self.page_oam_anims)
        self.button_oam_animToStart.setIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/control-skip-180')))
        self.button_oam_animToStart.setToolTip("To Start")
        self.button_oam_animToStart.pressed.connect(lambda: self.button_oam_animPlay.autoPause())
        self.button_oam_animToStart.pressed.connect(lambda: self.dropdown_oam_animFrame.setCurrentIndex(0))

        self.button_oam_animPlay = lib.widget.PlayButton(self.page_oam_anims)
        self.button_oam_animPlay.setToolTip("Play/Pause")
        self.button_oam_animPlay.frameRequested.connect(self.OAM_playAnimFrame)

        self.button_oam_animToEnd = QtWidgets.QPushButton(self.page_oam_anims)
        self.button_oam_animToEnd.setIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/control-skip')))
        self.button_oam_animToEnd.setToolTip("To End")
        self.button_oam_animToEnd.pressed.connect(lambda: self.button_oam_animPlay.autoPause())
        self.button_oam_animToEnd.pressed.connect(lambda: self.dropdown_oam_animFrame.setCurrentIndex(self.dropdown_oam_animFrame.count()-1))

        self.dropdown_oam_objFrame = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_oam_objFrame.setPlaceholderText("no OAM frames")
        self.dropdown_oam_objFrame.setToolTip("Choose frame")
        self.dropdown_oam_objFrame.setStatusTip("Select the OAM frame to load")
        self.dropdown_oam_objFrame.currentIndexChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.dropdown_oam_obj = QtWidgets.QComboBox(self.page_oam_frames) #temporary until gfx interface implemented
        self.dropdown_oam_obj.previousIndex = 0
        self.dropdown_oam_obj.setPlaceholderText("no objects")
        self.dropdown_oam_obj.setToolTip("Choose object")
        self.dropdown_oam_obj.setStatusTip("Select the object to edit")
        self.dropdown_oam_obj.currentIndexChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.button_oam_objSelect = QtWidgets.QPushButton(self.page_oam_frames)
        self.button_oam_objSelect.setText("Select current object")
        self.button_oam_objSelect.pressed.connect(lambda: self.treeCall(addr_disabled=True))

        self.button_oam_objAdd = QtWidgets.QPushButton(self.page_oam_frames)
        self.button_oam_objAdd.setText("Add object")
        self.button_oam_objAdd.pressed.connect(lambda: self.treeCall(addr_disabled=True))

        self.button_oam_objRemove = QtWidgets.QPushButton(self.page_oam_frames)
        self.button_oam_objRemove.setText("Remove object")
        self.button_oam_objRemove.pressed.connect(lambda: self.treeCall(addr_disabled=True))

        self.field_objTileId = lib.widget.BetterSpinBox(self.page_oam_frames)
        self.field_objTileId.setToolTip("Tile Id (OAM)")
        self.field_objTileId.setStatusTip("OAM tile id is half the value of VRAM tile id")
        self.field_objTileId.isInt = True
        self.field_objTileId.setRange(0, 0x3FF)
        self.field_objTileId.numbase = self.displayBase
        self.field_objTileId.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_objTileId.valueChanged.connect(lambda: self.OAM_updateItemGFX(self.dropdown_oam_obj.currentIndex(), item=self.file_content_oam.item_current))

        self.checkbox_objFlipH = QtWidgets.QCheckBox(self.page_oam_frames)
        self.checkbox_objFlipH.setText("Flip H")
        self.checkbox_objFlipH.checkStateChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.checkbox_objFlipH.checkStateChanged.connect(lambda: self.file_content_oam.item_current.setPixmap(
            self.file_content_oam.item_current.pixmap().transformed(QtGui.QTransform().scale(-1,1))))

        self.checkbox_objFlipV = QtWidgets.QCheckBox(self.page_oam_frames)
        self.checkbox_objFlipV.setText("Flip V")
        self.checkbox_objFlipV.checkStateChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.checkbox_objFlipV.checkStateChanged.connect(lambda: self.file_content_oam.item_current.setPixmap(
            self.file_content_oam.item_current.pixmap().transformed(QtGui.QTransform().scale(1,-1))))

        self.slider_objSizeIndex = lib.widget.LabeledSlider(self.page_oam_frames, 0, 3, interval=1, orientation=QtCore.Qt.Orientation.Horizontal, labels=["1x1", "2x2", "4x4", "8x8"])
        self.slider_objSizeIndex.setMaximumSize(260, 60)
        self.slider_objSizeIndex.setToolTip("Size increment")
        self.slider_objSizeIndex.sl.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.slider_objSizeIndex.sl.valueChanged.connect(lambda: self.OAM_updateItemGFX(self.dropdown_oam_obj.currentIndex(), item=self.file_content_oam.item_current))

        self.radio_objShapeSquare = QtWidgets.QRadioButton()
        self.radio_objShapeSquare.setText("Square")
        self.radio_objShapeSquare.toggled.connect(lambda: self.button_file_save.setEnabled(True))
        self.radio_objShapeWide = QtWidgets.QRadioButton()
        self.radio_objShapeWide.setText("Wide")
        self.radio_objShapeWide.toggled.connect(lambda: self.button_file_save.setEnabled(True))
        self.radio_objShapeTall = QtWidgets.QRadioButton()
        self.radio_objShapeTall.setText("Tall")
        self.radio_objShapeTall.toggled.connect(lambda: self.button_file_save.setEnabled(True))
        self.radio_objShapeProhibit = QtWidgets.QRadioButton()
        self.radio_objShapeProhibit.setText("Prohibited")
        self.radio_objShapeProhibit.toggled.connect(lambda: self.button_file_save.setEnabled(True))

        self.buttonGroup_oam_objShape = QtWidgets.QButtonGroup(self.page_oam_frames)
        self.buttonGroup_oam_objShape.addButton(self.radio_objShapeSquare, 0)
        self.buttonGroup_oam_objShape.addButton(self.radio_objShapeWide, 1)
        self.buttonGroup_oam_objShape.addButton(self.radio_objShapeTall, 2)
        self.buttonGroup_oam_objShape.addButton(self.radio_objShapeProhibit, 3)
        self.buttonGroup_oam_objShape.idReleased.connect(lambda: self.slider_objSizeIndex.setLabels(lib.oam.SPRITE_DIMENSIONS[self.buttonGroup_oam_objShape.checkedId()]))
        self.buttonGroup_oam_objShape.idReleased.connect(lambda: self.OAM_updateItemGFX(self.dropdown_oam_obj.currentIndex(), item=self.file_content_oam.item_current))

        self.group_oam_objShape = QtWidgets.QGroupBox(self.page_oam_frames)
        self.group_oam_objShape.setTitle("Shape")
        self.group_oam_objShape.setLayout(QtWidgets.QVBoxLayout())
        self.group_oam_objShape.layout().addWidget(self.radio_objShapeSquare)
        self.group_oam_objShape.layout().addWidget(self.radio_objShapeWide)
        self.group_oam_objShape.layout().addWidget(self.radio_objShapeTall)
        self.group_oam_objShape.layout().addWidget(self.radio_objShapeProhibit)

        self.slider_obj3DHeightIndex = lib.widget.LabeledSlider(self.page_oam_frames, 0, 3, interval=1, orientation=QtCore.Qt.Orientation.Horizontal, labels=["0x1", "0x2", "0x4", "0x8"])
        self.slider_obj3DHeightIndex.setMaximumSize(260, 60)
        self.slider_obj3DHeightIndex.setToolTip("Height increment")
        self.slider_obj3DHeightIndex.sl.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.slider_obj3DHeightIndex.sl.valueChanged.connect(lambda: self.OAM_updateItemGFX(self.dropdown_oam_obj.currentIndex(), item=self.file_content_oam.item_current))
        self.slider_obj3DHeightIndex.hide()

        self.slider_obj3DTileWidth = lib.widget.LabeledSlider(self.page_oam_frames, 0, 3, interval=1, orientation=QtCore.Qt.Orientation.Horizontal, labels=["0x8", "0x10", "0x20", "0x40"])
        self.slider_obj3DTileWidth.setMaximumSize(260, 60)
        self.slider_obj3DTileWidth.setToolTip("Tile width increment")
        self.slider_obj3DTileWidth.sl.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.slider_obj3DTileWidth.sl.valueChanged.connect(lambda: self.OAM_updateItemGFX(self.dropdown_oam_obj.currentIndex(), item=self.file_content_oam.item_current))
        self.slider_obj3DTileWidth.hide()

        self.field_objX = lib.widget.BetterSpinBox(self.page_oam_frames)
        self.field_objX.setToolTip("X")
        self.field_objX.isInt = True
        self.field_objX.setRange(-128, 127)
        self.field_objX.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_objX.valueChanged.connect(lambda: self.file_content_oam.item_current.setX(self.field_objX.value()))
        self.field_objY = lib.widget.BetterSpinBox(self.page_oam_frames)
        self.field_objY.setToolTip("Y")
        self.field_objY.isInt = True
        self.field_objY.setRange(-128, 127)
        self.field_objY.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_objY.valueChanged.connect(lambda: self.file_content_oam.item_current.setY(self.field_objY.value()))

        self.file_content_oam = lib.widget.OAMView(self.page_explorer)
        self.file_content_oam.setSizePolicy(QtWidgets.QSizePolicy.Policy.Ignored, QtWidgets.QSizePolicy.Policy.Expanding)
        self.file_content.addWidget(self.file_content_oam)

        self.layout_oam_navigation = QtWidgets.QGridLayout()
        self.layout_oam_navigation.addWidget(self.dropdown_oam_entry, 0, 0)
        self.page_oam_anims.layout().addWidget(self.dropdown_oam_anim, 0, 0, 1, 3)
        self.page_oam_anims.layout().addWidget(self.dropdown_oam_animFrame, 0, 3)
        self.page_oam_anims.layout().addWidget(self.field_oam_animFrameId, 1, 3)
        self.page_oam_anims.layout().addWidget(self.button_oam_animFrameAdd, 1, 4, 1, 2)
        self.page_oam_anims.layout().addWidget(self.field_oam_animFrameDuration, 2, 3)
        self.page_oam_anims.layout().addWidget(self.button_oam_animFrameRemove, 2, 4, 1, 2)
        self.page_oam_anims.layout().addWidget(self.checkbox_oam_animLoop, 1, 0)
        self.page_oam_anims.layout().addWidget(self.field_oam_animLoopStart, 2, 0)
        self.page_oam_anims.layout().addWidget(self.button_oam_animToStart, 3, 0, 1, 2)
        self.page_oam_anims.layout().addWidget(self.button_oam_animPlay, 3, 2, 1, 2)
        self.page_oam_anims.layout().addWidget(self.button_oam_animToEnd, 3, 4, 1, 2)
        self.page_oam_frames.layout().addWidget(self.dropdown_oam_objFrame, 0, 0, 1, 2)
        self.page_oam_frames.layout().addWidget(self.dropdown_oam_obj, 0, 2)
        self.page_oam_frames.layout().addWidget(self.button_oam_objAdd, 0, 3)
        self.page_oam_frames.layout().addWidget(self.field_objTileId, 1, 0, 1, 2)
        self.page_oam_frames.layout().addWidget(self.button_oam_objSelect, 1, 2)
        self.page_oam_frames.layout().addWidget(self.button_oam_objRemove, 1, 3)
        self.page_oam_frames.layout().addWidget(self.checkbox_objFlipH, 2, 0, 1, 2)
        self.page_oam_frames.layout().addWidget(self.checkbox_objFlipV, 3, 0, 1, 2)
        self.page_oam_frames.layout().addWidget(self.slider_objSizeIndex, 4, 0, 1, 2)
        self.page_oam_frames.layout().addWidget(self.group_oam_objShape, 4, 2, 1, 2)
        self.page_oam_frames.layout().addWidget(self.slider_obj3DHeightIndex, 4, 0, 1, 2)
        self.page_oam_frames.layout().addWidget(self.slider_obj3DTileWidth, 4, 2, 1, 2)
        self.page_oam_frames.layout().addWidget(self.field_objX, 5, 0, 1, 2)
        self.page_oam_frames.layout().addWidget(self.field_objY, 5, 2, 1, 2)

        #Palette Animation
        self.dropdown_panm_entry = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_panm_entry.setPlaceholderText("no animations")
        self.dropdown_panm_entry.setToolTip("Choose palette animation")
        self.dropdown_panm_entry.setStatusTip("Palette animations for mavericks. 0=evil; 1=patrol; 2=alert")
        self.dropdown_panm_entry.currentIndexChanged.connect(lambda: self.treeCall(addr_disabled=True))
        self.dropdown_panm_oamEntry = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_panm_oamEntry.setPlaceholderText("no entries to preview")
        self.dropdown_panm_oamEntry.setToolTip("Choose oam entry")
        self.dropdown_panm_oamEntry.setStatusTip("OAM entry to use when previewing palette.")
        self.dropdown_panm_oamEntry.currentIndexChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.dropdown_panm_frame = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_panm_frame.setPlaceholderText("no frames")
        self.dropdown_panm_frame.setToolTip("Choose animation frame")
        self.dropdown_panm_frame.setStatusTip("Each frame overwrites two colors from a 16-color palette")
        self.dropdown_panm_frame.currentIndexChanged.connect(lambda: self.treeCall(addr_disabled=True))

        self.layout_panm = QtWidgets.QGridLayout()

        self.field_panm_frameId = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_panm_frameId.setToolTip("Frame")
        self.field_panm_frameId.isInt = True
        self.field_panm_frameId.setRange(0x00, 0xFF)
        self.field_panm_frameId.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_panm_frameDuration = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_panm_frameDuration.setToolTip("Duration")
        self.field_panm_frameDuration.isInt = True
        self.field_panm_frameDuration.setRange(0x00, 0xFF)
        self.field_panm_frameDuration.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.checkbox_panm_loop = QtWidgets.QCheckBox(self.page_explorer)
        self.checkbox_panm_loop.setText("Loop")
        self.checkbox_panm_loop.setToolTip("Loop On/Off")
        self.checkbox_panm_loop.checkStateChanged.connect(lambda: self.field_panm_loopStart.setEnabled(self.checkbox_panm_loop.isChecked()))
        self.checkbox_panm_loop.checkStateChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_panm_loopStart = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_panm_loopStart.setToolTip("Loop Start")
        self.field_panm_loopStart.isInt = True
        self.field_panm_loopStart.setRange(0x00, 0xFF)
        self.field_panm_loopStart.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))

        self.label_panm_colorSlots = QtWidgets.QLabel("Color slots", self.page_explorer)
        self.label_panm_colorSlots.setMaximumHeight(50)
        self.label_panm_colorSlots.setAlignment(QtCore.Qt.AlignmentFlag.AlignBottom)
        self.field_panm_colorSlot0 = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_panm_colorSlot0.setToolTip("Color Slot 0")
        self.field_panm_colorSlot0.setStatusTip("The index of the first color to overwrite in a 16-color palette")
        self.field_panm_colorSlot0.isInt = True
        self.field_panm_colorSlot0.setRange(0x00, 0xFF)
        self.field_panm_colorSlot0.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_panm_colorSlot1 = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_panm_colorSlot1.setStatusTip("The index of the second color to overwrite in a 16-color palette")
        self.field_panm_colorSlot1.setToolTip("Color Slot 1")
        self.field_panm_colorSlot1.isInt = True
        self.field_panm_colorSlot1.setRange(0x00, 0xFF)
        self.field_panm_colorSlot1.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))

        self.gfx_scene_panm = lib.widget.View(self.page_explorer)
        self.gfx_scene_panm.hide()

        self.layout_panm.addWidget(self.dropdown_panm_oamEntry, 0, 0)
        self.layout_panm.addWidget(self.dropdown_panm_entry, 0, 1)
        self.layout_panm.addWidget(self.dropdown_panm_frame, 3, 1)
        self.layout_panm.addWidget(self.field_panm_frameId, 4, 1)
        self.layout_panm.addWidget(self.field_panm_frameDuration, 5, 1)
        self.layout_panm.addWidget(self.checkbox_panm_loop, 1, 1)
        self.layout_panm.addWidget(self.field_panm_loopStart, 2, 1)
        self.layout_panm.addWidget(self.label_panm_colorSlots, 3, 0)
        self.layout_panm.addWidget(self.field_panm_colorSlot0, 4, 0)
        self.layout_panm.addWidget(self.field_panm_colorSlot1, 5, 0)
        self.layout_panm.addWidget(self.gfx_scene_panm, 6, 0, 1, 2)
        self.layout_panm.setSpacing(3)

        #Font
        self.field_font_size = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_font_size.setFont(self.font_caps)
        self.field_font_size.setMinimum(0)
        self.field_font_size.isInt = True
        self.field_font_size.numbase = self.displayBase
        self.field_font_size.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.label_font_size = QtWidgets.QLabel(self.page_explorer)
        self.label_font_size.setText("file size")
        self.layout_font_size = QtWidgets.QVBoxLayout()
        self.layout_font_size.addWidget(self.field_font_size)
        self.layout_font_size.addWidget(self.label_font_size)
        self.layout_font_size.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)

        self.field_font_width = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_font_width.setFont(self.font_caps)
        self.field_font_width.setMinimum(0)
        self.field_font_width.isInt = True
        self.field_font_width.numbase = self.displayBase
        self.field_font_width.setStatusTip("Make sure that this is an even number to prevent the game from crashing")
        self.field_font_width.valueChanged.connect(lambda: self.treeCall())
        self.field_font_width.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_font_width.valueChanged.connect(self.file_content_gfx.fitInView2)
        self.label_font_width = QtWidgets.QLabel(self.page_explorer)
        self.label_font_width.setText("char width")
        self.layout_font_width = QtWidgets.QVBoxLayout()
        self.layout_font_width.addWidget(self.field_font_width)
        self.layout_font_width.addWidget(self.label_font_width)
        self.layout_font_width.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)

        self.field_font_height = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_font_height.setFont(self.font_caps)
        self.field_font_height.setMinimum(0)
        self.field_font_height.isInt = True
        self.field_font_height.numbase = self.displayBase
        self.field_font_height.valueChanged.connect(lambda: self.treeCall())
        self.field_font_height.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.field_font_height.valueChanged.connect(self.file_content_gfx.fitInView2)
        self.label_font_height = QtWidgets.QLabel(self.page_explorer)
        self.label_font_height.setText("char height")
        self.layout_font_height = QtWidgets.QVBoxLayout()
        self.layout_font_height.addWidget(self.field_font_height)
        self.layout_font_height.addWidget(self.label_font_height)
        self.layout_font_height.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)

        self.label_font_indexingSpace = QtWidgets.QLabel(self.page_explorer)
        self.label_font_indexingSpace.setText("indexing space: ")

        self.label_font_charCount = QtWidgets.QLabel(self.page_explorer)
        self.label_font_charCount.setText("char count: ")

        self.label_font_unusedStr = QtWidgets.QLabel(self.page_explorer)
        self.label_font_unusedStr.setText("unused string: ")

        self.layout_editzone_row0.addWidget(self.button_file_save)
        self.layout_editzone_row0.addWidget(self.button_view_save)
        self.layout_editzone_row0.addWidget(self.button_view_load)
        self.layout_editzone_row0.addWidget(self.label_file_size)
        self.layout_editzone_row0.addWidget(self.dropdown_gfx_depth)
        self.layout_editzone_row0.addWidget(self.field_address)
        
        self.layout_editzone_row1.addWidget(self.widget_colorpick)
        self.layout_editzone_row1.addItem(self.layout_gfx_settings)
        self.layout_editzone_row1.addItem(self.layout_oam_navigation)

        self.layout_editzone_row2.addItem(self.layout_panm)
        self.layout_editzone_row2.addItem(self.layout_font_size)
        self.layout_editzone_row2.addItem(self.layout_font_width)
        self.layout_editzone_row2.addItem(self.layout_font_height)
        self.layout_editzone_row2.addWidget(self.tabs_oam)

        self.layout_editzone_row3.addWidget(self.label_font_indexingSpace)
        self.layout_editzone_row3.addWidget(self.label_font_charCount)
        self.layout_editzone_row3.addWidget(self.label_font_unusedStr)

        self.layout_editzone.addItem(self.layout_editzone_row0)
        self.layout_editzone.addItem(self.layout_editzone_row1)
        self.layout_editzone.addItem(self.layout_editzone_row2)
        self.layout_editzone.addItem(self.layout_editzone_row3)
        self.layout_editzone.addItem(self.file_content)


        #Sound Data Archive
        self.dialog_sdat = QtWidgets.QMainWindow(self)
        self.dialog_sdat.setWindowTitle("Sound Data Archive")
        self.dialog_sdat.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/speaker-volume')))
        self.dialog_sdat.resize(600, 400)
        self.dialog_sdat.setCentralWidget(QtWidgets.QWidget())
        self.dialog_sdat.centralWidget().setLayout(QtWidgets.QVBoxLayout())

        self.toolbar_sdat = lib.widget.Toolbar("SDAT Toolbar")
        self.dialog_sdat.addToolBar(self.toolbar_sdat)

        self.action_playSdat = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/control')), "Play Sound", self)
        self.action_playSdat.setStatusTip("Play a SWAV or SSEQ")
        self.action_playSdat.triggered.connect(self.sdatPlayCall)

        self.action_stopSdat = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/control-stop-square')), "Stop Sound", self)
        self.action_stopSdat.setStatusTip("Stop Sound")
        self.action_stopSdat.triggered.connect(lambda: lib.sdat.stopSound())

        self.action_plotSdat = QtGui.QAction(QtGui.QIcon(str(PATH_ROOT / 'icons/blueprint--arrow')), "Plot Sound", self)
        self.action_plotSdat.setStatusTip("Plot current soud")
        self.action_plotSdat.triggered.connect(self.sdatPlotCall)

        self.toolbar_sdat.addActions([self.action_playSdat, self.action_stopSdat])
        if "matplotlib" in sys.modules:
            self.toolbar_sdat.addAction(self.action_plotSdat)

        self.page_sdat = QtWidgets.QWidget()
        self.page_sdat.setLayout(QtWidgets.QStackedLayout())
        self.dropdown_sdat = QtWidgets.QComboBox()
        self.dropdown_sdat.currentIndexChanged.connect(self.page_sdat.layout().setCurrentIndex)

        self.dialog_sdat.centralWidget().layout().addWidget(self.dropdown_sdat)
        self.dialog_sdat.centralWidget().layout().addWidget(self.page_sdat)

        self.trees_sdat = []

        #VX
        self.label_vxHeader_length = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_length.setText("Duration(frames): ")
        self.label_vxHeader_length.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_length = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_length.setFont(self.font_caps)
        self.field_vxHeader_length.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_length.numfill = 8
        self.field_vxHeader_length.isInt = True
        self.field_vxHeader_length.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_length = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_length.addWidget(self.label_vxHeader_length)
        self.layout_vxHeader_length.addWidget(self.field_vxHeader_length)

        self.label_vxHeader_framerate = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_framerate.setText("Frame rate: ")
        self.label_vxHeader_framerate.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_framerate = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_framerate.setDecimals(16) # increase precision to allow spinbox to respect range
        self.field_vxHeader_framerate.setRange(0x00000000,65535.9999847412109375) # prevent impossible values (max is ffff.ffff)
        #self.field_vxHeader_framerate.numfill = 8
        self.field_vxHeader_framerate.textChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_framerate = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_framerate.addWidget(self.label_vxHeader_framerate)
        self.layout_vxHeader_framerate.addWidget(self.field_vxHeader_framerate)

        self.label_vxHeader_frameSizeMax = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_frameSizeMax.setText("Maximal frame data size: ")
        self.label_vxHeader_frameSizeMax.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_frameSizeMax = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_frameSizeMax.setFont(self.font_caps)
        self.field_vxHeader_frameSizeMax.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_frameSizeMax.numfill = 8
        self.field_vxHeader_frameSizeMax.isInt = True
        self.field_vxHeader_frameSizeMax.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_frameSizeMax = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_frameSizeMax.addWidget(self.label_vxHeader_frameSizeMax)
        self.layout_vxHeader_frameSizeMax.addWidget(self.field_vxHeader_frameSizeMax)

        self.layout_vx_framesHeader = QtWidgets.QHBoxLayout()
        self.layout_vx_framesHeader.addItem(self.layout_vxHeader_length)
        self.layout_vx_framesHeader.addItem(self.layout_vxHeader_framerate)
        self.layout_vx_framesHeader.addItem(self.layout_vxHeader_frameSizeMax)

        self.label_vxHeader_streamCount = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_streamCount.setText("Audio stream count: ")
        self.label_vxHeader_streamCount.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_streamCount = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_streamCount.setFont(self.font_caps)
        self.field_vxHeader_streamCount.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_streamCount.numfill = 8
        self.field_vxHeader_streamCount.isInt = True
        self.field_vxHeader_streamCount.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_streamCount = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_streamCount.addWidget(self.label_vxHeader_streamCount)
        self.layout_vxHeader_streamCount.addWidget(self.field_vxHeader_streamCount)

        self.label_vxHeader_sampleRate = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_sampleRate.setText("Sound sample rate(Hz): ")
        self.label_vxHeader_sampleRate.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_sampleRate = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_sampleRate.setFont(self.font_caps)
        self.field_vxHeader_sampleRate.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_sampleRate.numfill = 8
        self.field_vxHeader_sampleRate.isInt = True
        self.field_vxHeader_sampleRate.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_sampleRate = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_sampleRate.addWidget(self.label_vxHeader_sampleRate)
        self.layout_vxHeader_sampleRate.addWidget(self.field_vxHeader_sampleRate)

        self.label_vxHeader_audioExtraDataOffset = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_audioExtraDataOffset.setText("Extra audio data offset: ")
        self.label_vxHeader_audioExtraDataOffset.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_audioExtraDataOffset = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_audioExtraDataOffset.setFont(self.font_caps)
        self.field_vxHeader_audioExtraDataOffset.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_audioExtraDataOffset.numfill = 8
        self.field_vxHeader_audioExtraDataOffset.isInt = True
        self.field_vxHeader_audioExtraDataOffset.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_audioExtraDataOffset = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_audioExtraDataOffset.addWidget(self.label_vxHeader_audioExtraDataOffset)
        self.layout_vxHeader_audioExtraDataOffset.addWidget(self.field_vxHeader_audioExtraDataOffset)

        self.layout_vx_soundHeader = QtWidgets.QHBoxLayout()
        self.layout_vx_soundHeader.addItem(self.layout_vxHeader_streamCount)
        self.layout_vx_soundHeader.addItem(self.layout_vxHeader_sampleRate)
        self.layout_vx_soundHeader.addItem(self.layout_vxHeader_audioExtraDataOffset)

        self.label_vxHeader_width = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_width.setText("Frame width(pixels): ")
        self.label_vxHeader_width.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_width = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_width.setFont(self.font_caps)
        self.field_vxHeader_width.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_width.numfill = 8
        self.field_vxHeader_width.isInt = True
        self.field_vxHeader_width.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_width = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_width.addWidget(self.label_vxHeader_width)
        self.layout_vxHeader_width.addWidget(self.field_vxHeader_width)

        self.label_vxHeader_height = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_height.setText("Frame height(pixels): ")
        self.label_vxHeader_height.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_height = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_height.setFont(self.font_caps)
        self.field_vxHeader_height.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_height.numfill = 8
        self.field_vxHeader_height.isInt = True
        self.field_vxHeader_height.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_height = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_height.addWidget(self.label_vxHeader_height)
        self.layout_vxHeader_height.addWidget(self.field_vxHeader_height)

        self.layout_vx_frameSize = QtWidgets.QHBoxLayout()
        self.layout_vx_frameSize.addItem(self.layout_vxHeader_width)
        self.layout_vx_frameSize.addItem(self.layout_vxHeader_height)

        self.label_vxHeader_quantiser = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_quantiser.setText("Quantiser: ")
        self.label_vxHeader_quantiser.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_quantizer = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_quantizer.setFont(self.font_caps)
        self.field_vxHeader_quantizer.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_quantizer.numfill = 8
        self.field_vxHeader_quantizer.isInt = True
        self.field_vxHeader_quantizer.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_quantiser = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_quantiser.addWidget(self.label_vxHeader_quantiser)
        self.layout_vxHeader_quantiser.addWidget(self.field_vxHeader_quantizer)

        self.label_vxHeader_seekTableOffset = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_seekTableOffset.setText("Seek table offset: ")
        self.label_vxHeader_seekTableOffset.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_seekTableOffset = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_seekTableOffset.setFont(self.font_caps)
        self.field_vxHeader_seekTableOffset.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_seekTableOffset.numfill = 8
        self.field_vxHeader_seekTableOffset.isInt = True
        self.field_vxHeader_seekTableOffset.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_seekTableOffset = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_seekTableOffset.addWidget(self.label_vxHeader_seekTableOffset)
        self.layout_vxHeader_seekTableOffset.addWidget(self.field_vxHeader_seekTableOffset)

        self.label_vxHeader_seekTableEntryCount = QtWidgets.QLabel(self.page_explorer)
        self.label_vxHeader_seekTableEntryCount.setText("Seek table entry count: ")
        self.label_vxHeader_seekTableEntryCount.setAlignment(QtCore.Qt.AlignmentFlag.AlignCenter)
        self.field_vxHeader_seekTableEntryCount = lib.widget.BetterSpinBox(self.page_explorer)
        self.field_vxHeader_seekTableEntryCount.setFont(self.font_caps)
        self.field_vxHeader_seekTableEntryCount.setRange(0x00000000, 0xFFFFFFFF) # prevent impossible values
        self.field_vxHeader_seekTableEntryCount.numfill = 8
        self.field_vxHeader_seekTableEntryCount.isInt = True
        self.field_vxHeader_seekTableEntryCount.valueChanged.connect(lambda: self.button_file_save.setEnabled(True))
        self.layout_vxHeader_seekTableEntryCount = QtWidgets.QVBoxLayout()
        self.layout_vxHeader_seekTableEntryCount.addWidget(self.label_vxHeader_seekTableEntryCount)
        self.layout_vxHeader_seekTableEntryCount.addWidget(self.field_vxHeader_seekTableEntryCount)

        self.layout_vx_seekTable = QtWidgets.QHBoxLayout()
        self.layout_vx_seekTable.addItem(self.layout_vxHeader_seekTableOffset)
        self.layout_vx_seekTable.addItem(self.layout_vxHeader_seekTableEntryCount)

        self.file_content.addItem(self.layout_vx_framesHeader)
        self.file_content.addItem(self.layout_vx_soundHeader)
        self.file_content.addItem(self.layout_vx_frameSize)
        self.file_content.addItem(self.layout_vxHeader_quantiser)
        self.file_content.addItem(self.layout_vx_seekTable)

        self.dropdown_model_entry = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_model_entry.currentIndexChanged.connect(lambda: self.treeCall())
        self.dropdown_model_geometry = QtWidgets.QComboBox(self.page_explorer)
        self.dropdown_model_geometry.currentIndexChanged.connect(lambda: self.treeCall())
        self.file_content_model = lib.widget.View3D(self.page_explorer)
        self.file_content.addWidget(self.dropdown_model_entry)
        self.file_content.addWidget(self.dropdown_model_geometry)
        self.file_content.addWidget(self.file_content_model)

        # File callers
        self.FILEOPEN_WIDGETS: list[QtWidgets.QWidget] = [self.tree, self.viewAdaptAction, self.viewDialogueAction, self.viewGraphicAction, self.displayRawAction]
        # Contents of widget sets, used in file_editor_show
        self.WIDGETS_EMPTY: list[QtWidgets.QWidget] = [self.file_content_text]
        self.WIDGETS_HEX: list[QtWidgets.QWidget] = [self.file_content_text, self.checkbox_textoverwite]
        self.WIDGETS_TEXT: list[QtWidgets.QWidget] = [self.file_content_text, self.checkbox_textoverwite, self.dropdown_textindex]
        self.WIDGETS_GRAPHIC: list[QtWidgets.QWidget] = [
            self.file_content_gfx,
            self.checkbox_depthUpdate,
            self.label_depthUpdate,
            self.dropdown_gfx_depth,
            self.dropdown_gfx_index,
            self.dropdown_gfx_subindex,
            self.dropdown_gfx_palette,
            self.field_tile_width,
            self.label_tile_width,
            self.field_tile_height,
            self.label_tile_height,
            self.field_tiles_per_row,
            self.label_tiles_per_row,
            self.field_tiles_per_column,
            self.label_tiles_per_column,
            self.widget_colorpick,
            self.button_view_save,
            self.button_view_load
            ]
        self.WIDGETS_OAM: list[QtWidgets.QWidget] = [
            self.file_content_oam,
            self.tabs_oam,
            self.dropdown_oam_entry
            ]
        self.WIDGETS_PANM: list[QtWidgets.QWidget] = [
            self.dropdown_panm_entry,
            self.dropdown_panm_oamEntry,
            self.dropdown_panm_frame,
            self.field_panm_frameId,
            self.field_panm_frameDuration,
            self.checkbox_panm_loop,
            self.field_panm_loopStart,
            self.label_panm_colorSlots,
            self.field_panm_colorSlot0,
            self.field_panm_colorSlot1,
            self.widget_colorpick,
            self.gfx_scene_panm
        ]
        self.WIDGETS_FONT: list[QtWidgets.QWidget] = [
            self.file_content_gfx,
            self.field_tiles_per_row,
            self.label_tiles_per_row,
            self.field_tiles_per_column,
            self.label_tiles_per_column,
            self.field_font_size,
            self.label_font_size,
            self.field_font_width,
            self.label_font_width,
            self.field_font_height,
            self.label_font_height,
            self.label_font_indexingSpace,
            self.label_font_charCount,
            self.label_font_unusedStr,
            self.widget_colorpick
            ]
        self.WIDGETS_SOUND: list[QtWidgets.QWidget] = [
            ]
        self.WIDGETS_VX: list[QtWidgets.QWidget] = [
            self.field_vxHeader_length,
            self.label_vxHeader_length,
            self.field_vxHeader_width,
            self.label_vxHeader_width,
            self.field_vxHeader_height,
            self.label_vxHeader_height,
            self.field_vxHeader_streamCount,
            self.label_vxHeader_streamCount,
            self.field_vxHeader_framerate,
            self.label_vxHeader_framerate,
            self.field_vxHeader_sampleRate,
            self.label_vxHeader_sampleRate,
            self.field_vxHeader_quantizer,
            self.label_vxHeader_quantiser,
            self.field_vxHeader_frameSizeMax,
            self.label_vxHeader_frameSizeMax,
            self.field_vxHeader_audioExtraDataOffset,
            self.label_vxHeader_audioExtraDataOffset,
            self.field_vxHeader_seekTableOffset,
            self.label_vxHeader_seekTableOffset,
            self.field_vxHeader_seekTableEntryCount,
            self.label_vxHeader_seekTableEntryCount
            ]
        self.WIDGETS_MODEL = [
            self.dropdown_model_entry,
            self.dropdown_model_geometry,
            self.file_content_model
        ]
        self.file_editor_show("Empty")

        # Level Editor(WIP)
        self.layout_level_editpannel = QtWidgets.QVBoxLayout()
        self.layout_level_editpannel.setContentsMargins(0,0,0,0)

        self.button_level_save = QtWidgets.QPushButton("Save level", self.page_leveleditor)
        self.button_level_save.setMaximumWidth(75)
        self.button_level_save.setToolTip("Save this level's changes")
        self.button_level_save.pressed.connect(self.save_level)
        self.button_level_save.setDisabled(True)

        self.button_level_load = QtWidgets.QPushButton("Load level", self.page_leveleditor)
        self.button_level_load.setMaximumWidth(75)
        self.button_level_load.setToolTip("Load tileset(s) and layout. May take some time")
        self.button_level_load.pressed.connect(self.loadLevel)
        self.button_level_load.setDisabled(True)

        self.checkbox_level_fitInView = QtWidgets.QCheckBox("Reset view", self.page_leveleditor)
        self.checkbox_level_fitInView.setChecked(True)

        self.lineedit_level_tilesetName = QtWidgets.QLineEdit("N/A", self.page_leveleditor)
        self.lineedit_level_tilesetName.setToolTip("The name of the asset file that is used")
        self.lineedit_level_tilesetName.setMaxLength(8)
        self.lineedit_level_tilesetName.textChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.lineedit_level_tilesetName.setDisabled(True)

        self.dropdown_level_area = QtWidgets.QComboBox(self.page_leveleditor)
        self.dropdown_level_area.setPlaceholderText("Select...")
        self.dropdown_level_area.setToolTip("Choose an overlay to load")
        self.dropdown_level_area.currentIndexChanged.connect(self.updateLevelareaUI)
        self.dropdown_level_area.setDisabled(True)

        self.dropdown_level_type = QtWidgets.QComboBox(self.page_leveleditor)
        self.dropdown_level_type.setPlaceholderText("N/A")
        self.dropdown_level_type.setMinimumWidth(100)
        self.dropdown_level_type.setToolTip("Choose between normal level and scanner map (if applicable)")
        self.dropdown_level_type.currentIndexChanged.connect(lambda: self.group_radar_tilesetType.setEnabled(self.dropdown_level_type.currentIndex() == 1))
        self.dropdown_level_type.setDisabled(True)

        self.radio_radar_LX = QtWidgets.QRadioButton(self.page_leveleditor)
        self.radio_radar_LX.setText("Model LX")
        self.radio_radar_PX = QtWidgets.QRadioButton(self.page_leveleditor)
        self.radio_radar_PX.setText("Model PX")
        self.buttonGroup_radar_tilesetType = QtWidgets.QButtonGroup()
        self.buttonGroup_radar_tilesetType.addButton(self.radio_radar_LX, 2) # rindex to getData
        self.buttonGroup_radar_tilesetType.addButton(self.radio_radar_PX, 1)
        #self.buttonGroup_radar_tilesetType.idReleased.connect(self.loadLevel)
        self.group_radar_tilesetType = QtWidgets.QGroupBox(self.page_leveleditor)
        self.group_radar_tilesetType.setMaximumHeight(70)
        self.group_radar_tilesetType.setTitle("Radar mode")
        self.group_radar_tilesetType.setLayout(QtWidgets.QVBoxLayout())
        self.group_radar_tilesetType.layout().addWidget(self.radio_radar_LX)
        self.group_radar_tilesetType.layout().addWidget(self.radio_radar_PX)
        self.group_radar_tilesetType.setDisabled(True)

        self.tabs_level = QtWidgets.QTabWidget(self.page_leveleditor)
        self.page_level_tileset = QtWidgets.QWidget(self.tabs_level)
        self.page_level_tileset.setLayout(QtWidgets.QVBoxLayout())
        self.page_level_tileset.layout().setContentsMargins(10,0,0,0)
        self.page_level_screens = QtWidgets.QWidget(self.tabs_level)
        self.page_level_screens.setLayout(QtWidgets.QVBoxLayout())
        self.page_level_screens.layout().setContentsMargins(10,0,0,0)
        self.page_level_entities = QtWidgets.QWidget(self.tabs_level)
        self.page_level_entities.setLayout(QtWidgets.QVBoxLayout())
        self.page_level_entities.layout().setContentsMargins(10,0,0,0)

        self.tabs_level.addTab(self.page_level_tileset, "Tileset")
        self.tabs_level.addTab(self.page_level_screens, "Screens")
        self.tabs_level.addTab(self.page_level_entities, "Entities")

        self.dropdown_metaTile_collisionShape = QtWidgets.QComboBox(self.page_level_tileset)
        self.dropdown_metaTile_collisionShape.setToolTip("Choose collision geometry to apply")
        self.dropdown_metaTile_collisionShape.addItems(["0 - Air",
                                                        "1 - Solid",
                                                        "2 - lower 2x1 slope /",
                                                        "3 - upper 2x1 slope /",
                                                        "4 - lower 4x1 slope /",
                                                        "5 - lower middle 4x1 slope /",
                                                        "6 - upper middle 4x1 slope /",
                                                        "7 - upper 4x1 slope /",
                                                        "8 - upper 2x1 slope \\",
                                                        "9 - lower 2x1 slope \\",
                                                        "A - upper 4x1 slope \\",
                                                        "B - upper middle 4x1 slope \\",
                                                        "C - lower middle 4x1 slope \\",
                                                        "D - lower 4x1 slope \\",
                                                        "E - ladder end",
                                                        "F - ladder"])
        self.dropdown_metaTile_collisionShape.currentIndexChanged.connect(self.changeTileShape)
        self.dropdown_metaTile_collisionShape.setDisabled(True)

        self.group_metaTile_gfx = QtWidgets.QGroupBox(self.page_level_tileset)
        self.group_metaTile_gfx.setTitle("Meta Tile Graphics")
        self.group_metaTile_gfx.setLayout(QtWidgets.QGridLayout())
        self.group_metaTile_gfx.setDisabled(True)

        self.field_metaTile_topLeft_id = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_metaTile_topLeft_id.setToolTip("Tile ID")
        self.field_metaTile_topLeft_id.isInt = True
        self.field_metaTile_topLeft_id.numbase = self.displayBase
        self.field_metaTile_topLeft_id.numfill = 3
        self.field_metaTile_topLeft_id.setRange(0x0000, 0xFFFF)
        self.field_metaTile_topLeft_id.valueChanged.connect(lambda: self.changeTileGfx(0, 0xFFFF-0x03FF, self.field_metaTile_topLeft_id.value()))
        self.checkbox_metaTile_topLeft_flipH = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_topLeft_flipH.setText("H")
        self.checkbox_metaTile_topLeft_flipH.checkStateChanged.connect(lambda: self.changeTileGfx(0, 0xFFFF-0x0400, self.checkbox_metaTile_topLeft_flipH.isChecked()))
        self.field_metaTile_topLeft_attr = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_metaTile_topLeft_attr.setToolTip("Palette ID")
        self.field_metaTile_topLeft_attr.isInt = True
        self.field_metaTile_topLeft_attr.numbase = self.displayBase
        self.field_metaTile_topLeft_attr.setRange(0x0000, 0xFFFF)
        self.field_metaTile_topLeft_attr.valueChanged.connect(lambda: self.changeTileGfx(0, 0xFFFF-0xF000, self.field_metaTile_topLeft_attr.value()))
        self.checkbox_metaTile_topLeft_flipV = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_topLeft_flipV.setText("V")
        self.checkbox_metaTile_topLeft_flipV.checkStateChanged.connect(lambda: self.changeTileGfx(0, 0xFFFF-0x0800, self.checkbox_metaTile_topLeft_flipV.isChecked()))

        self.field_metaTile_topRight_id = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_metaTile_topRight_id.setToolTip("Tile ID")
        self.field_metaTile_topRight_id.isInt = True
        self.field_metaTile_topRight_id.numbase = self.displayBase
        self.field_metaTile_topRight_id.numfill = 3
        self.field_metaTile_topRight_id.setRange(0x0000, 0xFFFF)
        self.field_metaTile_topRight_id.valueChanged.connect(lambda: self.changeTileGfx(1, 0xFFFF-0x03FF, self.field_metaTile_topRight_id.value()))
        self.checkbox_metaTile_topRight_flipH = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_topRight_flipH.setText("H")
        self.checkbox_metaTile_topRight_flipH.checkStateChanged.connect(lambda: self.changeTileGfx(1, 0xFFFF-0x0400, self.checkbox_metaTile_topRight_flipH.isChecked()))
        self.field_metaTile_topRight_attr = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_metaTile_topRight_attr.setToolTip("Palette ID")
        self.field_metaTile_topRight_attr.isInt = True
        self.field_metaTile_topRight_attr.numbase = self.displayBase
        self.field_metaTile_topRight_attr.setRange(0x0000, 0xFFFF)
        self.field_metaTile_topRight_attr.valueChanged.connect(lambda: self.changeTileGfx(1, 0xFFFF-0xF000, self.field_metaTile_topRight_attr.value()))
        self.checkbox_metaTile_topRight_flipV = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_topRight_flipV.setText("V")
        self.checkbox_metaTile_topRight_flipV.checkStateChanged.connect(lambda: self.changeTileGfx(1, 0xFFFF-0x0800, self.checkbox_metaTile_topRight_flipV.isChecked()))

        self.field_metaTile_bottomLeft_id = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_metaTile_bottomLeft_id.setToolTip("Tile ID")
        self.field_metaTile_bottomLeft_id.isInt = True
        self.field_metaTile_bottomLeft_id.numbase = self.displayBase
        self.field_metaTile_bottomLeft_id.numfill = 3
        self.field_metaTile_bottomLeft_id.setRange(0x0000, 0xFFFF)
        self.field_metaTile_bottomLeft_id.valueChanged.connect(lambda: self.changeTileGfx(2, 0xFFFF-0x03FF, self.field_metaTile_bottomLeft_id.value()))
        self.checkbox_metaTile_bottomLeft_flipH = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_bottomLeft_flipH.setText("H")
        self.checkbox_metaTile_bottomLeft_flipH.checkStateChanged.connect(lambda: self.changeTileGfx(2, 0xFFFF-0x0400, self.checkbox_metaTile_bottomLeft_flipH.isChecked()))
        self.field_metaTile_bottomLeft_attr = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_metaTile_bottomLeft_attr.setToolTip("Palette ID")
        self.field_metaTile_bottomLeft_attr.isInt = True
        self.field_metaTile_bottomLeft_attr.numbase = self.displayBase
        self.field_metaTile_bottomLeft_attr.setRange(0x0000, 0xFFFF)
        self.field_metaTile_bottomLeft_attr.valueChanged.connect(lambda: self.changeTileGfx(2, 0xFFFF-0xF000, self.field_metaTile_bottomLeft_attr.value()))
        self.checkbox_metaTile_bottomLeft_flipV = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_bottomLeft_flipV.setText("V")
        self.checkbox_metaTile_bottomLeft_flipV.checkStateChanged.connect(lambda: self.changeTileGfx(2, 0xFFFF-0x0800, self.checkbox_metaTile_bottomLeft_flipV.isChecked()))

        self.field_metaTile_bottomRight_id = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_metaTile_bottomRight_id.setToolTip("Tile ID")
        self.field_metaTile_bottomRight_id.isInt = True
        self.field_metaTile_bottomRight_id.numbase = self.displayBase
        self.field_metaTile_bottomRight_id.numfill = 3
        self.field_metaTile_bottomRight_id.setRange(0x0000, 0xFFFF)
        self.field_metaTile_bottomRight_id.valueChanged.connect(lambda: self.changeTileGfx(3, 0xFFFF-0x03FF, self.field_metaTile_bottomRight_id.value()))
        self.checkbox_metaTile_bottomRight_flipH = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_bottomRight_flipH.setText("H")
        self.checkbox_metaTile_bottomRight_flipH.checkStateChanged.connect(lambda: self.changeTileGfx(3, 0xFFFF-0x0400, self.checkbox_metaTile_bottomRight_flipH.isChecked()))
        self.field_metaTile_bottomRight_attr = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_metaTile_bottomRight_attr.setToolTip("Palette ID")
        self.field_metaTile_bottomRight_attr.isInt = True
        self.field_metaTile_bottomRight_attr.numbase = self.displayBase
        self.field_metaTile_bottomRight_attr.setRange(0x0000, 0xFFFF)
        self.field_metaTile_bottomRight_attr.valueChanged.connect(lambda: self.changeTileGfx(3, 0xFFFF-0xF000, self.field_metaTile_bottomRight_attr.value()))
        self.checkbox_metaTile_bottomRight_flipV = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_bottomRight_flipV.setText("V")
        self.checkbox_metaTile_bottomRight_flipV.checkStateChanged.connect(lambda: self.changeTileGfx(3, 0xFFFF-0x0800, self.checkbox_metaTile_bottomRight_flipV.isChecked()))

        self.group_metaTile_gfx.layout().addWidget(self.field_metaTile_topLeft_id, 0, 0)
        self.group_metaTile_gfx.layout().addWidget(self.checkbox_metaTile_topLeft_flipH, 0, 1)
        self.group_metaTile_gfx.layout().addWidget(self.field_metaTile_topLeft_attr, 1, 0)
        self.group_metaTile_gfx.layout().addWidget(self.checkbox_metaTile_topLeft_flipV, 1, 1)
        self.group_metaTile_gfx.layout().addWidget(self.field_metaTile_topRight_id, 0, 2)
        self.group_metaTile_gfx.layout().addWidget(self.checkbox_metaTile_topRight_flipH, 0, 3)
        self.group_metaTile_gfx.layout().addWidget(self.field_metaTile_topRight_attr, 1, 2)
        self.group_metaTile_gfx.layout().addWidget(self.checkbox_metaTile_topRight_flipV, 1, 3)
        self.group_metaTile_gfx.layout().addWidget(QtWidgets.QLabel(), 2, 0, 1, 3)
        self.group_metaTile_gfx.layout().addWidget(self.field_metaTile_bottomLeft_id, 3, 0)
        self.group_metaTile_gfx.layout().addWidget(self.checkbox_metaTile_bottomLeft_flipH, 3, 1)
        self.group_metaTile_gfx.layout().addWidget(self.field_metaTile_bottomLeft_attr, 4, 0)
        self.group_metaTile_gfx.layout().addWidget(self.checkbox_metaTile_bottomLeft_flipV, 4, 1)
        self.group_metaTile_gfx.layout().addWidget(self.field_metaTile_bottomRight_id, 3, 2)
        self.group_metaTile_gfx.layout().addWidget(self.checkbox_metaTile_bottomRight_flipH, 3, 3)
        self.group_metaTile_gfx.layout().addWidget(self.field_metaTile_bottomRight_attr, 4, 2)
        self.group_metaTile_gfx.layout().addWidget(self.checkbox_metaTile_bottomRight_flipV, 4, 3)

        self.checkbox_metaTile_attrRospark = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrRospark.setText("Rospark pole")
        self.checkbox_metaTile_attrRospark.setStatusTip("This attribute is only used in ZXA.")
        self.checkbox_metaTile_attrRospark.checkStateChanged.connect(lambda: self.changeTileShapeAttr(0, self.checkbox_metaTile_attrRospark.isChecked()))
        self.checkbox_metaTile_attrRospark.setDisabled(True)
        self.checkbox_metaTile_attrWaterfall = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrWaterfall.setText("Waterfall")
        self.checkbox_metaTile_attrWaterfall.setStatusTip("This attribute is only used in ZXA. Will act as air, but Model L can still swim in it.")
        self.checkbox_metaTile_attrWaterfall.checkStateChanged.connect(lambda: self.changeTileShapeAttr(1, self.checkbox_metaTile_attrWaterfall.isChecked()))
        self.checkbox_metaTile_attrWaterfall.setDisabled(True)
        self.checkbox_metaTile_attrUnk2 = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrUnk2.setText("Unused?")
        self.checkbox_metaTile_attrUnk2.checkStateChanged.connect(lambda: self.changeTileShapeAttr(2, self.checkbox_metaTile_attrUnk2.isChecked()))
        self.checkbox_metaTile_attrUnk2.setDisabled(True)
        self.checkbox_metaTile_attrMetal = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrMetal.setText("Metallic sound")
        self.checkbox_metaTile_attrMetal.checkStateChanged.connect(lambda: self.changeTileShapeAttr(3, self.checkbox_metaTile_attrMetal.isChecked()))
        self.checkbox_metaTile_attrMetal.setDisabled(True)

        self.checkbox_metaTile_attrSpike = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrSpike.setText("Spike")
        self.checkbox_metaTile_attrSpike.checkStateChanged.connect(lambda: self.changeTileAttr("11111110", self.checkbox_metaTile_attrSpike.isChecked()))
        self.checkbox_metaTile_attrSpike.setDisabled(True)
        self.checkbox_metaTile_attrWater = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrWater.setText("Underwater")
        self.checkbox_metaTile_attrWater.checkStateChanged.connect(lambda: self.changeTileAttr("11111101", self.checkbox_metaTile_attrWater.isChecked()))
        self.checkbox_metaTile_attrWater.setDisabled(True)
        self.checkbox_metaTile_attrNoCeilHang = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrNoCeilHang.setText("No ceiling hang")
        self.checkbox_metaTile_attrNoCeilHang.checkStateChanged.connect(lambda: self.changeTileAttr("11111011", self.checkbox_metaTile_attrNoCeilHang.isChecked()))
        self.checkbox_metaTile_attrNoCeilHang.setDisabled(True)
        self.checkbox_metaTile_attrNoWalljump = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrNoWalljump.setText("No walljump")
        self.checkbox_metaTile_attrNoWalljump.checkStateChanged.connect(lambda: self.changeTileAttr("11110111", self.checkbox_metaTile_attrNoWalljump.isChecked()))
        self.checkbox_metaTile_attrNoWalljump.setDisabled(True)
        self.checkbox_metaTile_attrSand = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrSand.setText("Quicksand")
        self.checkbox_metaTile_attrSand.checkStateChanged.connect(lambda: self.changeTileAttr("11101111", self.checkbox_metaTile_attrSand.isChecked()))
        self.checkbox_metaTile_attrSand.setDisabled(True)
        self.radio_metaTile_attrNone = QtWidgets.QRadioButton(self.page_level_tileset)
        self.radio_metaTile_attrNone.setText("Normal")
        self.radio_metaTile_attrConveyR = QtWidgets.QRadioButton(self.page_level_tileset)
        self.radio_metaTile_attrConveyR.setText("Conveyor >>")
        self.radio_metaTile_attrConveyR.setStatusTip("For unknown reasons, this attribute only works on levels that already have conveyor belts.")
        self.radio_metaTile_attrConveyL = QtWidgets.QRadioButton(self.page_level_tileset)
        self.radio_metaTile_attrConveyL.setText("Conveyor <<")
        self.radio_metaTile_attrConveyL.setStatusTip("For unknown reasons, this attribute only works on levels that already have conveyor belts.")
        self.radio_metaTile_attrIce = QtWidgets.QRadioButton(self.page_level_tileset)
        self.radio_metaTile_attrIce.setText("Ice")
        self.buttonGroup_metaTile_attrConvey = QtWidgets.QButtonGroup(self.page_level_tileset)
        self.buttonGroup_metaTile_attrConvey.addButton(self.radio_metaTile_attrNone, 0)
        self.buttonGroup_metaTile_attrConvey.addButton(self.radio_metaTile_attrConveyR, 1)
        self.buttonGroup_metaTile_attrConvey.addButton(self.radio_metaTile_attrConveyL, 2)
        self.buttonGroup_metaTile_attrConvey.addButton(self.radio_metaTile_attrIce, 3)
        self.buttonGroup_metaTile_attrConvey.idReleased.connect(lambda: self.changeTileAttr("10011111", self.buttonGroup_metaTile_attrConvey.checkedId()))
        self.group_metaTile_attrConvey = QtWidgets.QGroupBox(self.page_level_tileset)
        self.group_metaTile_attrConvey.setTitle("Floor type")
        self.group_metaTile_attrConvey.setLayout(QtWidgets.QVBoxLayout())
        self.group_metaTile_attrConvey.layout().addWidget(self.radio_metaTile_attrNone)
        self.group_metaTile_attrConvey.layout().addWidget(self.radio_metaTile_attrConveyR)
        self.group_metaTile_attrConvey.layout().addWidget(self.radio_metaTile_attrConveyL)
        self.group_metaTile_attrConvey.layout().addWidget(self.radio_metaTile_attrIce)
        self.group_metaTile_attrConvey.setDisabled(True)
        self.checkbox_metaTile_attrPlat = QtWidgets.QCheckBox(self.page_level_tileset)
        self.checkbox_metaTile_attrPlat.setText("Platform")
        self.checkbox_metaTile_attrPlat.setStatusTip("Has only top collision and allows to drop through it with Down+Jump. Model P can hang from it and climb it.")
        self.checkbox_metaTile_attrPlat.checkStateChanged.connect(lambda: self.changeTileAttr("01111111", self.checkbox_metaTile_attrPlat.isChecked()))
        self.checkbox_metaTile_attrPlat.setDisabled(True)

        self.layout_metaTile_shape = QtWidgets.QVBoxLayout()
        self.layout_metaTile_shape.addWidget(self.dropdown_metaTile_collisionShape)
        self.layout_metaTile_shape.addWidget(self.group_metaTile_gfx)

        self.layout_metaTile_attr = QtWidgets.QGridLayout()
        self.layout_metaTile_attr.setContentsMargins(10, 0, 0, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrRospark, 0, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrWaterfall, 1, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrUnk2, 2, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrMetal, 3, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrSpike, 4, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrWater, 5, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrNoCeilHang, 6, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrNoWalljump, 7, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrSand, 8, 0)
        self.layout_metaTile_attr.addWidget(self.checkbox_metaTile_attrPlat, 9, 0)
        self.layout_metaTile_attr.addWidget(self.group_metaTile_attrConvey, 0, 2, 10, 1)

        self.layout_level_areaName = QtWidgets.QVBoxLayout()
        self.layout_level_areaName.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
        self.layout_level_areaName.setContentsMargins(0,24,0,0)
        self.layout_level_areaName.addWidget(self.dropdown_level_area)
        self.layout_level_areaName.addWidget(self.lineedit_level_tilesetName)

        self.layout_level_area = QtWidgets.QHBoxLayout()
        self.layout_level_area.addWidget(self.button_level_save)
        self.layout_level_area.addWidget(self.button_level_load)
        self.layout_level_area.addWidget(self.checkbox_level_fitInView)
        self.layout_level_area.addItem(self.layout_level_areaName)
        self.layout_level_area.addWidget(self.dropdown_level_type)
        self.layout_level_area.addWidget(self.group_radar_tilesetType)

        self.layout_metaTile_properties = QtWidgets.QHBoxLayout()
        self.layout_metaTile_properties.addItem(self.layout_metaTile_shape)
        self.layout_metaTile_properties.addItem(self.layout_metaTile_attr)
        self.gfx_scene_tileset = lib.widget.TilesetView(self.page_level_tileset)
        self.gfx_scene_tileset.scene().selectionChanged.connect(self.loadTileProperties)

        self.field_screen_tilesetOffset = lib.widget.BetterSpinBox(self.page_level_tileset)
        self.field_screen_tilesetOffset.setToolTip("Set tileset offset")
        self.field_screen_tilesetOffset.setStatusTip("Set how many graphic entries from the graphic table to skip for the tileset")

        self.tabs_level_screens = QtWidgets.QTabWidget(self.page_level_screens)
        self.page_level_screens_layout0 = QtWidgets.QWidget(self.tabs_level_screens)
        self.page_level_screens_layout1 = QtWidgets.QWidget(self.tabs_level_screens)
        self.page_level_screens_layout2 = QtWidgets.QWidget(self.tabs_level_screens)
        self.page_level_screens_layout3 = QtWidgets.QWidget(self.tabs_level_screens)
        self.page_level_screens_layout_camera = QtWidgets.QWidget(self.tabs_level_screens)
        self.page_level_screens_layout_radar = QtWidgets.QWidget(self.tabs_level_screens)
        self.page_level_screens_map_offset = QtWidgets.QWidget(self.tabs_level_screens)
        self.page_level_screens_map_behavior = QtWidgets.QWidget(self.tabs_level_screens)
        self.tabs_level_screens.addTab(self.page_level_screens_layout0, "Layout 0")
        self.tabs_level_screens.addTab(self.page_level_screens_layout1, "Layout 1")
        self.tabs_level_screens.addTab(self.page_level_screens_layout2, "Layout 2")
        self.tabs_level_screens.addTab(self.page_level_screens_layout3, "Layout 3")
        self.tabs_level_screens.addTab(self.page_level_screens_layout_camera, "Camera Scroll Layout")
        self.tabs_level_screens.addTab(self.page_level_screens_layout_radar, "Radar Scope Layout")
        self.tabs_level_screens.addTab(self.page_level_screens_map_offset, "Tileset Offset Map")
        self.tabs_level_screens.addTab(self.page_level_screens_map_behavior, "Behavior Map")

        self.checkbox_entities_enable = QtWidgets.QCheckBox(self.page_level_entities)
        self.checkbox_entities_enable.setChecked(True)
        self.checkbox_entities_enable.setText("Load Entities")
        self.checkbox_entities_gfxEnable = QtWidgets.QCheckBox(self.page_level_entities)
        self.checkbox_entities_gfxEnable.setChecked(True)
        self.checkbox_entities_gfxEnable.setText("Load Entity Graphics")
        self.layout_entitySettings = QtWidgets.QHBoxLayout()
        self.layout_entitySettings.addWidget(self.checkbox_entities_enable)
        self.layout_entitySettings.addWidget(self.checkbox_entities_gfxEnable)

        self.tabs_level_entities = QtWidgets.QTabWidget(self.page_level_entities)
        self.page_level_entities_coords = QtWidgets.QWidget(self.tabs_level_entities)
        self.page_level_entities_coords.setLayout(QtWidgets.QGridLayout())
        self.label_level_entities_coords_id = QtWidgets.QLabel("Entity Index: ", self.page_level_entities_coords)
        self.label_level_entities_coords_id.setMaximumHeight(50)
        self.field_level_entities_coords_x = lib.widget.LabeledSpinBox(self.page_level_entities_coords, labelText="X:", Vertical=True)
        self.field_level_entities_coords_x.setDisabled(True)
        self.field_level_entities_coords_x.sb.isInt = True
        self.field_level_entities_coords_x.sb.numbase = self.displayBase
        self.field_level_entities_coords_x.sb.setRange(0, 0xFFFFFF)
        self.field_level_entities_coords_x.setToolTip("X")
        self.field_level_entities_coords_x.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_coords_x.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.coords.entityList,
                                                                self.gfx_scene_level.scene().selectedItems()[0].coordIndex if
                                                                len(self.gfx_scene_level.scene().selectedItems()) and isinstance(self.gfx_scene_level.scene().selectedItems()[0], lib.widget.LevelEntityItem) else None,
                                                                "x",
                                                                self.field_level_entities_coords_x.sb.value()))
        self.field_level_entities_coords_x.sb.valueChanged.connect(lambda: self.gfx_scene_level.scene().selectedItems()[0].setX(self.gfx_scene_level.scene().selectedItems()[0].getSceneX(self.field_level_entities_coords_x.sb.value())) if
                                                                len(self.gfx_scene_level.scene().selectedItems()) and isinstance(self.gfx_scene_level.scene().selectedItems()[0], lib.widget.LevelEntityItem) else None)
        self.field_level_entities_coords_y = lib.widget.LabeledSpinBox(self.page_level_entities_coords, labelText="Y:", Vertical=True)
        self.field_level_entities_coords_y.setDisabled(True)
        self.field_level_entities_coords_y.sb.isInt = True
        self.field_level_entities_coords_y.sb.numbase = self.displayBase
        self.field_level_entities_coords_y.sb.setRange(0, 0xFFFF)
        self.field_level_entities_coords_y.setToolTip("Y")
        self.field_level_entities_coords_y.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_coords_y.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.coords.entityList,
                                                                self.gfx_scene_level.scene().selectedItems()[0].coordIndex if
                                                                len(self.gfx_scene_level.scene().selectedItems()) and isinstance(self.gfx_scene_level.scene().selectedItems()[0], lib.widget.LevelEntityItem) else None,
                                                                "y",
                                                                self.field_level_entities_coords_y.sb.value()))
        self.field_level_entities_coords_y.sb.valueChanged.connect(lambda: self.gfx_scene_level.scene().selectedItems()[0].setY(self.gfx_scene_level.scene().selectedItems()[0].getSceneY(self.field_level_entities_coords_y.sb.value())) if
                                                                len(self.gfx_scene_level.scene().selectedItems()) and isinstance(self.gfx_scene_level.scene().selectedItems()[0], lib.widget.LevelEntityItem) else None)
        self.field_level_entities_coords_slot = lib.widget.LabeledSpinBox(self.page_level_entities_coords, labelText="Slot:", Vertical=True)
        self.field_level_entities_coords_slot.setDisabled(True)
        self.field_level_entities_coords_slot.sb.isInt = True
        self.field_level_entities_coords_slot.sb.numbase = self.displayBase
        self.field_level_entities_coords_slot.sb.setRange(0, 0xFFFF)
        self.field_level_entities_coords_slot.setToolTip("Slot ID")
        self.field_level_entities_coords_slot.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_coords_slot.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.coords.entityList,
                                                                self.gfx_scene_level.scene().selectedItems()[0].coordIndex if
                                                                len(self.gfx_scene_level.scene().selectedItems()) and isinstance(self.gfx_scene_level.scene().selectedItems()[0], lib.widget.LevelEntityItem) else None,
                                                                "slot",
                                                                self.field_level_entities_coords_slot.sb.value()))
        self.field_level_entities_coords_slot.sb.valueChanged.connect(lambda: self.loadEntityProperties())
        self.page_level_entities_coords.layout().addWidget(self.label_level_entities_coords_id, 0, 0, 1, 2)
        self.page_level_entities_coords.layout().addWidget(self.field_level_entities_coords_x, 1, 0)
        self.page_level_entities_coords.layout().addWidget(self.field_level_entities_coords_y, 1, 1)
        self.page_level_entities_coords.layout().addWidget(self.field_level_entities_coords_slot, 2, 0, 1, 2)
        self.page_level_entities_slots = QtWidgets.QWidget(self.tabs_level_entities)
        self.page_level_entities_slots.setLayout(QtWidgets.QGridLayout())
        self.label_level_entities_slots_id = QtWidgets.QLabel("Slot Index: ", self.page_level_entities_slots)
        self.label_level_entities_slots_id.setMaximumHeight(50)
        self.field_level_entities_slots_attr = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Attributes(?):", Vertical=True)
        self.field_level_entities_slots_attr.setDisabled(True)
        self.field_level_entities_slots_attr.sb.isInt = True
        self.field_level_entities_slots_attr.sb.numbase = self.displayBase
        self.field_level_entities_slots_attr.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_attr.setToolTip("Attributes(?)")
        self.field_level_entities_slots_attr.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_attr.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "attr",
                                                                self.field_level_entities_slots_attr.sb.value()))
        self.field_level_entities_slots_kind = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Kind:", Vertical=True)
        self.field_level_entities_slots_kind.setDisabled(True)
        self.field_level_entities_slots_kind.sb.isInt = True
        self.field_level_entities_slots_kind.sb.numbase = self.displayBase
        self.field_level_entities_slots_kind.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_kind.setToolTip("Kind")
        self.field_level_entities_slots_kind.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_kind.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "kind",
                                                                self.field_level_entities_slots_kind.sb.value()))
        self.field_level_entities_slots_subkind = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Sub-kind:", Vertical=True)
        self.field_level_entities_slots_subkind.setDisabled(True)
        self.field_level_entities_slots_subkind.sb.isInt = True
        self.field_level_entities_slots_subkind.sb.numbase = self.displayBase
        self.field_level_entities_slots_subkind.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_subkind.setToolTip("Sub kind")
        self.field_level_entities_slots_subkind.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_subkind.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "subkind",
                                                                self.field_level_entities_slots_subkind.sb.value()))
        self.field_level_entities_slots_role = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Role:", Vertical=True)
        self.field_level_entities_slots_role.setDisabled(True)
        self.field_level_entities_slots_role.sb.isInt = True
        self.field_level_entities_slots_role.sb.numbase = self.displayBase
        self.field_level_entities_slots_role.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_role.setToolTip("Role")
        self.field_level_entities_slots_role.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_role.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "role",
                                                                self.field_level_entities_slots_role.sb.value()))
        self.field_level_entities_slots_modifier = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Modifier:", Vertical=True)
        self.field_level_entities_slots_modifier.setDisabled(True)
        self.field_level_entities_slots_modifier.sb.isInt = True
        self.field_level_entities_slots_modifier.sb.numbase = self.displayBase
        self.field_level_entities_slots_modifier.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_modifier.setToolTip("Modifier")
        self.field_level_entities_slots_modifier.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_modifier.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "modifier",
                                                                self.field_level_entities_slots_modifier.sb.value()))
        self.field_level_entities_slots_unk5 = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Unknown(0x5):", Vertical=True)
        self.field_level_entities_slots_unk5.setDisabled(True)
        self.field_level_entities_slots_unk5.sb.isInt = True
        self.field_level_entities_slots_unk5.sb.numbase = self.displayBase
        self.field_level_entities_slots_unk5.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_unk5.setToolTip("5")
        self.field_level_entities_slots_unk5.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_unk5.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "unk5",
                                                                self.field_level_entities_slots_unk5.sb.value()))
        self.field_level_entities_slots_unk6 = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Unknown(0x6):", Vertical=True)
        self.field_level_entities_slots_unk6.setDisabled(True)
        self.field_level_entities_slots_unk6.sb.isInt = True
        self.field_level_entities_slots_unk6.sb.numbase = self.displayBase
        self.field_level_entities_slots_unk6.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_unk6.setToolTip("6")
        self.field_level_entities_slots_unk6.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_unk6.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "unk6",
                                                                self.field_level_entities_slots_unk6.sb.value()))
        self.field_level_entities_slots_unk7 = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Unknown(0x7):", Vertical=True)
        self.field_level_entities_slots_unk7.setDisabled(True)
        self.field_level_entities_slots_unk7.sb.isInt = True
        self.field_level_entities_slots_unk7.sb.numbase = self.displayBase
        self.field_level_entities_slots_unk7.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_unk7.setToolTip("7")
        self.field_level_entities_slots_unk7.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_unk7.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "unk7",
                                                                self.field_level_entities_slots_unk7.sb.value()))
        self.field_level_entities_slots_unk8 = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Unknown(0x8):", Vertical=True)
        self.field_level_entities_slots_unk8.setDisabled(True)
        self.field_level_entities_slots_unk8.sb.isInt = True
        self.field_level_entities_slots_unk8.sb.numbase = self.displayBase
        self.field_level_entities_slots_unk8.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_unk8.setToolTip("8")
        self.field_level_entities_slots_unk8.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_unk8.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "unk8",
                                                                self.field_level_entities_slots_unk8.sb.value()))
        self.field_level_entities_slots_unk9 = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Unknown(0x9):", Vertical=True)
        self.field_level_entities_slots_unk9.setDisabled(True)
        self.field_level_entities_slots_unk9.sb.isInt = True
        self.field_level_entities_slots_unk9.sb.numbase = self.displayBase
        self.field_level_entities_slots_unk9.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_unk9.setToolTip("9")
        self.field_level_entities_slots_unk9.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_unk9.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "unk9",
                                                                self.field_level_entities_slots_unk9.sb.value()))
        self.field_level_entities_slots_unkA = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Unknown(0xA):", Vertical=True)
        self.field_level_entities_slots_unkA.setDisabled(True)
        self.field_level_entities_slots_unkA.sb.isInt = True
        self.field_level_entities_slots_unkA.sb.numbase = self.displayBase
        self.field_level_entities_slots_unkA.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_unkA.setToolTip("A")
        self.field_level_entities_slots_unkA.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_unkA.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "unkA",
                                                                self.field_level_entities_slots_unkA.sb.value()))
        self.field_level_entities_slots_unkB = lib.widget.LabeledSpinBox(self.page_level_entities_slots, labelText="Unknown(0xB):", Vertical=True)
        self.field_level_entities_slots_unkB.setDisabled(True)
        self.field_level_entities_slots_unkB.sb.isInt = True
        self.field_level_entities_slots_unkB.sb.numbase = self.displayBase
        self.field_level_entities_slots_unkB.sb.setRange(0, 0xFF)
        self.field_level_entities_slots_unkB.setToolTip("B")
        self.field_level_entities_slots_unkB.sb.valueChanged.connect(lambda: self.button_level_save.setEnabled(True))
        self.field_level_entities_slots_unkB.sb.valueChanged.connect(lambda: self.changeEntityAttribute(self.levelEdited_ovl_object.entities.slots.entityList,
                                                                self.field_level_entities_coords_slot.sb.value(),
                                                                "unkB",
                                                                self.field_level_entities_slots_unkB.sb.value()))
        self.page_level_entities_slots.layout().addWidget(self.label_level_entities_slots_id, 0, 0, 1, 2)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_attr, 1, 0)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_kind, 2, 0)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_subkind, 3, 0)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_role, 4, 0)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_modifier, 5, 0)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_unk5, 1, 1)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_unk6, 2, 1)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_unk7, 3, 1)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_unk8, 4, 1)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_unk9, 5, 1)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_unkA, 6, 1)
        self.page_level_entities_slots.layout().addWidget(self.field_level_entities_slots_unkB, 7, 1)
        self.tabs_level_entities.addTab(self.page_level_entities_coords, "Coordinates")
        self.tabs_level_entities.addTab(self.page_level_entities_slots, "Slot data")

        self.gfx_scene_level = lib.widget.LevelView(self.page_leveleditor)
        self.gfx_scene_level.scene().selectionChanged.connect(self.loadEntityProperties)

        self.page_leveleditor.layout().addItem(self.layout_level_editpannel)
        self.layout_level_editpannel.addItem(self.layout_level_area)
        self.layout_level_editpannel.addWidget(self.tabs_level)
        self.page_level_tileset.layout().addWidget(self.field_screen_tilesetOffset)
        self.page_level_tileset.layout().addItem(self.layout_metaTile_properties)
        self.page_level_tileset.layout().addWidget(self.gfx_scene_tileset)
        self.page_level_screens.layout().addWidget(self.tabs_level_screens)
        self.page_level_entities.layout().addItem(self.layout_entitySettings)
        self.page_level_entities.layout().addWidget(self.tabs_level_entities)
        self.page_leveleditor.layout().addWidget(self.gfx_scene_level)

        # Tweaks(WIP)
        self.tabs_tweaks = QtWidgets.QTabWidget(self.page_tweaks)

        self.button_tweak_save = QtWidgets.QPushButton("Apply Tweaks", self.page_tweaks)
        self.button_tweak_save.pressed.connect(self.save_tweaks)
        self.button_tweak_save.setDisabled(True)
        self.dropdown_tweak_target = QtWidgets.QComboBox(self.page_tweaks)
        self.dropdown_tweak_target.setToolTip("Choose a target to appy tweaks to")
        self.dropdown_tweak_target.currentTextChanged.connect(self.tweakTargetCall)
        self.dropdown_tweak_target.hide()
        self.page_tweaks.layout().addWidget(self.button_tweak_save)
        self.page_tweaks.layout().addWidget(self.dropdown_tweak_target)
        self.page_tweaks.layout().addWidget(self.tabs_tweaks)

        self.page_tweaks_stats = QtWidgets.QWidget(self.tabs_tweaks)
        self.page_tweaks_stats.setLayout(QtWidgets.QGridLayout())

        self.page_tweaks_physics = QtWidgets.QWidget(self.tabs_tweaks)
        self.page_tweaks_physics.setLayout(QtWidgets.QGridLayout())

        self.page_tweaks_behaviour = QtWidgets.QWidget(self.tabs_tweaks)
        self.page_tweaks_behaviour.setLayout(QtWidgets.QGridLayout())

        self.page_tweaks_misc = QtWidgets.QWidget(self.tabs_tweaks)
        self.page_tweaks_misc.setLayout(QtWidgets.QGridLayout())

        self.tabs_tweaks.addTab(self.page_tweaks_stats, "Stats")


        self.tabs_tweaks.addTab(self.page_tweaks_physics, "Physics")


        self.tabs_tweaks.addTab(self.page_tweaks_behaviour, "Behaviour")


        self.tabs_tweaks.addTab(self.page_tweaks_misc, "Misc.")


        # Patches
        self.button_patches_apply = QtWidgets.QPushButton("Apply Patches", self.page_patches)
        self.button_patches_apply.pressed.connect(self.patch_game)
        self.button_patches_apply.setDisabled(True)
        self.tree_patches = lib.widget.EditorTree(self.page_patches)
        self.tree_patches.setColumnCount(4)
        self.tree_patches.setHeaderLabels(["Enabled", "Address", "Name", "Type", "Size"])
        self.tree_patches.header().resizeSection(2, 250)
        self.tree_patches.itemChanged.connect(self.patch_checkboxUpdate)
        self.tree_patches.itemChanged.connect(lambda: self.button_patches_apply.setEnabled(True))
        self.tree_patches_checkboxes = [] # stores the state of checkboxes for complex checkbox logic

        self.page_patches.layout().addWidget(self.button_patches_apply)
        self.page_patches.layout().addWidget(self.tree_patches)
        # Shortcuts
        #QtWidgets.QKeySequenceEdit()

        self.setStatusBar(QtWidgets.QStatusBar(self))

    def progressShow(self):
        self.window_progress.move(self.pos().x() + (self.width() - self.window_progress.width())//2, self.pos().y() + self.height()//2) # center progress bar
        self.progress.setValue(0)
        self.label_progress.setText("")
        self.window_progress.show()

    def progressUpdate(self, percent: int, status: str="", isgame: bool=None, title: str=None, pixmap: QtGui.QPixmap=None):
        self.progress.setValue(percent)
        self.label_progress.setText(status)
        if isgame == True:
            self.label_progress_title.show()
            self.label_progress_icon.show()
        elif isgame == False:
            self.label_progress_title.hide()
            self.label_progress_icon.hide()
        if title:
            self.label_progress_title.setText(title)
        if pixmap:
            self.label_progress_icon.setPixmap(pixmap)
        app.processEvents()

    def progressHide(self):
        self.progress.setValue(0)
        self.label_progress.setText("")
        self.window_progress.close()

    """
    def runTasks(self, runnableInfo_list: list[list[QtCore.QRunnable, list[QtCore.Q_ARG], QtCore.pyqtSignal, lambda _: _]]):
        pool = QtCore.QThreadPool.globalInstance()
        for runnableInfo in runnableInfo_list:
            # 2. Instantiate the subclass of QRunnable
            runnable_inst = runnableInfo[0](*runnableInfo[1])
            app.processEvents()
            getattr(runnable_inst.signals, runnableInfo[2]).connect(runnableInfo[3])
            # 3. Call start()
            pool.start(runnable_inst)
            self.setWindowTitle(self.windowTitle() + " (Running " + str(pool.activeThreadCount()) + " Threads)")

    def clearTasks(self):
        pool = QtCore.QThreadPool.globalInstance()
        pool.clear()
        self.setWindowTitle(self.windowTitle().split(" (Running ")[0])
    """

    def file_fromItem(self, item: QtWidgets.QTreeWidgetItem):
        RESULT_EMPTY = [b'', "", None, None, None]
        tree = item.treeWidget()
        name = ""
        data = bytes()
        obj = self.rom.files
        obj2 = None # allow ref to object
        obj3 = None # for sdat objects in sections
        if tree == self.tree:
            name = item.text(1) + "." + item.text(2)
            data = obj[int(item.text(0))]
        else:
            if tree.ContextNameType == "[Filenames]":
                name = item.text(1) + ("." + item.text(2)).replace(".Folder", " and contents")
            else:
                name = tree.ContextNameType + item.text(0)
            if tree == self.tree_arm9: # 02000000 - 00004000 = 01FFC000
                obj = self.rom.arm9
                if item.text(1) == "main code file":
                    data = self.rom.arm9
                else:
                    if item.text(2) == "True":
                        try: # convert dynamically according to base (also arm9 window should update on base change)
                            item_next = tree.itemBelow(item)
                            data = self.rom.arm9[lib.datconv.strToNum(item.text(0), self.displayBase) - 0x01FFC000 - 0x00004000:lib.datconv.strToNum(item.text(0), self.displayBase) - 0x01FFC000 - 0x00004000 + (lib.datconv.strToNum(item_next.text(0), self.displayBase) - lib.datconv.strToNum(item.text(0), self.displayBase))]
                        except Exception:
                            data = self.rom.arm9[lib.datconv.strToNum(item.text(0), self.displayBase) - 0x01FFC000 - 0x00004000:]
                    else:
                        print("Explicit ARM9 code-sections are not (yet) supported")
                        return RESULT_EMPTY
                        #data = ndspy.codeCompression._compress(self.rom.loadArm9().sections[int(tree.indexFromItem(item).row())].data) #compressed
                name += ".bin"
            if tree == self.tree_arm7: # 02380000 - 0014E000 = 02232000
                self.rom.arm7EntryAddress
                obj = self.rom.arm7
                if item.text(2) == "True":
                    try:
                        item_next = tree.itemBelow(item)
                        data = self.rom.arm7[
                            lib.datconv.strToNum(item.text(0), self.displayBase) - 0x02232000 - 0x0014E000
                            :lib.datconv.strToNum(item.text(0), self.displayBase) - 0x02232000 - 0x0014E000 + (lib.datconv.strToNum(item_next.text(0), self.displayBase) - lib.datconv.strToNum(item.text(0), self.displayBase))]
                    except Exception:
                        data = self.rom.arm7[lib.datconv.strToNum(item.text(0), self.displayBase) - 0x02232000 - 0x0014E000]
                else:
                    print("Explicit ARM7 code-sections are not (yet) supported")
                    return RESULT_EMPTY
                    #ndspy.codeCompression.compress(self.rom.loadArm7().sections[int(tree.indexFromItem(item).row())].data)
                name += ".bin"
            if tree == self.tree_arm9Ovltable:
                data = self.rom.files[int(item.text(0))] #self.rom.arm9OverlayTable
                name += ".bin"
            if tree == self.tree_arm7Ovltable:
                data = self.rom.files[int(item.text(0))] #.loadArm7Overlays()[int(item.text(0))].data
                name += ".bin"
            if tree in self.trees_sdat:
                obj2 = self.sdats[self.dropdown_sdat.currentIndex()]
                data_list = [
                obj2.sequences,
                obj2.sequenceArchives,
                obj2.banks,
                obj2.waveArchives,
                obj2.sequencePlayers,
                obj2.streams,
                obj2.streamPlayers,
                obj2.groups
                ]
                for category in data_list:
                    for file in category:
                        obj3 = file[1]
                        obj2 = category
                        if file[0] == item.text(1):
                            data = obj3.save()
                            if isinstance(data, tuple):
                                data = data[0]
                            break
                        elif item.parent() != None and file[0] == item.parent().text(1):
                            if item.text(2) == "SWAV":
                                data = obj3.waves[int(item.text(0))].save()
                                #print(type(data))
                                break
                            elif item.text(2) == "SSARS":
                                data = obj3.sequences[int(item.text(0))][1].save()
                                print(data)
                                if isinstance(data, tuple):
                                    data = data[0]
                                break
                            else:
                                print("unhandled data type")
                                data = file
                                break
        return [data, name, obj, obj2, obj3]
    
    def patches_reload(self):
        #print("call")
        self.tree_patches.blockSignals(True)
        #self.progress.show()
        self.tree_patches.clear()
        self.tree_patches_checkboxes.clear()
        if self.isGameSupported:
            patches = []
            for patch in self.gamedat.patches:
                #self.progress.setValue(self.progress.value()+12)
                #QtWidgets.QTreeWidgetItem(None, ["", "<address>", "<patch name>", "<patch type>", "<size>"])
                if isinstance(patch[2], tuple): # if patch contains patches
                    patch_item = QtWidgets.QTreeWidgetItem(None, ["", "N/A", patch[0], patch[1], "0"])
                    patches.append(patch_item)
                    patch_size = 0
                    subPatchMatches = 0
                    for subPatch in patch:
                        if isinstance(subPatch, tuple):
                            subPatch_item = QtWidgets.QTreeWidgetItem(patch_item, ["", str(lib.datconv.numToStr(subPatch[0], self.displayBase, self.displayAlphanumeric).zfill(8)), subPatch[1], "Patch Segment", str(lib.datconv.numToStr(len(subPatch[3].replace("-", ""))//2, self.displayBase, self.displayAlphanumeric).zfill(1))])
                            subPatch_item.setToolTip(0, subPatch[3])
                            subPatch_item.setFlags(patch_item.flags() | QtCore.Qt.ItemFlag.ItemIsUserCheckable)
                            patch_item.addChild(subPatch_item)
                            patch_size += len(subPatch[3].replace("-", ""))
                            patchType = patch_item.text(3)
                            if patchType == "arm9":
                                data_ref = self.arm9_decompressed.save()[subPatch[0]:subPatch[0]+len(subPatch[3])//2]
                            else:
                                data_ref = self.rom.save()[subPatch[0]:subPatch[0]+len(subPatch[3])//2]
                            if data_ref.hex().upper() == subPatch[3]:
                                subPatchMatches += 1
                                subPatch_item.setCheckState(0, QtCore.Qt.CheckState.Checked)
                            else:
                                subPatch_item.setCheckState(0, QtCore.Qt.CheckState.Unchecked)
                            self.tree_patches_checkboxes.append(subPatch_item.checkState(0))
                    patch_item.setText(4, f"{lib.datconv.numToStr(patch_size//2, self.displayBase, self.displayAlphanumeric).zfill(1)}")
                    patch_item.setFlags(patch_item.flags() | QtCore.Qt.ItemFlag.ItemIsUserCheckable)
                    if subPatchMatches == patch_item.childCount(): # Check for already applied patches
                        patch_item.setCheckState(0, QtCore.Qt.CheckState.Checked)
                    elif subPatchMatches > 0:
                        patch_item.setCheckState(0, QtCore.Qt.CheckState.PartiallyChecked)
                    else:
                        patch_item.setCheckState(0, QtCore.Qt.CheckState.Unchecked)
                    self.tree_patches_checkboxes.append(patch_item.checkState(0))
                else: # if patch contains no subpatches
                    patch_item = QtWidgets.QTreeWidgetItem(None, ["", str(lib.datconv.numToStr(patch[0], self.displayBase, self.displayAlphanumeric).zfill(8)), patch[1], patch[2], str(lib.datconv.numToStr(len(patch[4].replace("-", ""))//2, self.displayBase, self.displayAlphanumeric).zfill(1))])
                    patch_item.setToolTip(0, str(patch[4]))
                    patches.append(patch_item)
                    patch_item.setFlags(patch_item.flags() | QtCore.Qt.ItemFlag.ItemIsUserCheckable)
                    patchType = patch_item.text(3)
                    if patchType == "arm9":
                        data_ref = self.arm9_decompressed.save()[patch[0]:patch[0]+len(patch[4])//2]
                    else:
                        data_ref = self.rom.save()[patch[0]:patch[0]+len(patch[4])//2]
                    if data_ref.hex().upper() == patch[4]: # Check for already applied patches
                        patch_item.setCheckState(0, QtCore.Qt.CheckState.Checked)
                    else:
                        patch_item.setCheckState(0, QtCore.Qt.CheckState.Unchecked)
                    self.tree_patches_checkboxes.append(patch_item.checkState(0))
            self.tree_patches.addTopLevelItems(patches)
        self.tree_patches.blockSignals(False)
        #self.progress.setValue(100)
        #self.progress.close()

    def openCall(self):
        filename = QtWidgets.QFileDialog.getOpenFileName(
            self,
            "Open File",
            str(PATH_ROOT),
            "NDS Files (*.nds *.srl);; All Files (*)",
            options=QtWidgets.QFileDialog.Option.DontUseNativeDialog,
        )
        if not filename == ("", ""):
            self.loadROM(filename[0])

    def loadFat(self): # ndspy already does this to load the ROM properly, but does not store any of the info on the fat in the final rom object
        self.rom_fat.clear()
        rom = self.rom.save()
        fat_offset = int.from_bytes(rom[0x48:0x4C], "little") # read from nds header
        fat_size = int.from_bytes(rom[0x4C:0x50], "little")
        for i in range(fat_size//8): # 8 bytes for start and end address of each file, so this is like range(fileCount)
            self.rom_fat.append(int.from_bytes(rom[fat_offset+i*8:fat_offset+i*8+4], "little"))

    def loadROM(self, fname: str):
        if fname == "" or not os.path.exists(fname):
            print("file does not exist.")
            QtWidgets.QMessageBox.critical(
            self,
            "Failed to load ROM",
            str("Could not find the file to load. Make sure the path entered is valid.")
            )
            return
        if len(open(fname, 'rb').read()) <= 0:
            print("file is empty")
            QtWidgets.QMessageBox.critical(
            self,
            "Failed to load ROM",
            str("An empty file is not a valid ROM! Please select a valid Nintendo DS file.")
            )
            return

        # reset stuff to prevent conflicts
        self.rom = None
        self.sdats = []
        self.disable_editing_ui()

        self.progressShow() # progress bar
        self.progressUpdate(0, "Loading ROM", False) # icon and title won't show until loaded
        #self.runTasks([[RunnableDisplayProgress, [], "valueChanged", self.progress.setValue]])
        pathSep = "/"
        if not "/" in fname:
            pathSep = "\\"
        nameParts = fname.split(pathSep)[len(fname.split(pathSep)) - 1].rsplit(".", 1)
        self.romToEdit_path = fname
        self.romToEdit_name = nameParts[0]
        self.romToEdit_ext = "." + nameParts[-1]
        self.setWindowTitle("Mega Man ZX Editor" + " \"" + self.romToEdit_name + self.romToEdit_ext + "\"")
        try:
            self.rom = ndspy.rom.NintendoDSRom.fromFile(fname)
            self.treeUpdate()
            # create a file allocation table that can be read rapidly because ndspy does not provide any
            self.loadFat()
            offset_icon_image = 0x20
            offset_icon_pal = offset_icon_image + 0x200
            offset_icon_title = offset_icon_pal + 0x20
            icon_pixmap = QtGui.QPixmap.fromImage(lib.datconv.binToQt(
                bytearray(self.rom.iconBanner[offset_icon_image:offset_icon_pal]),
                lib.datconv.BGR15_to_ARGB32(self.rom.iconBanner[offset_icon_pal:offset_icon_title]),
                lib.datconv.CompressionAlgorithmEnum.FOURBPP,
                4, 4
                ))
            icon_title = str(self.rom.iconBanner[offset_icon_title:offset_icon_title+0x100].decode('UTF-16LE').replace("\x00", ""))
            print(icon_title)
        except Exception as e:
            self.progressHide()
            print(e)
            QtWidgets.QMessageBox.critical(
            self,
            "Failed to load ROM",
            str(e)
            )
            self.setWindowTitle("Mega Man ZX Editor")
            self.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/appicon')))
            for widget in self.findChildren(QtWidgets.QWidget):
                widget.blockSignals(False)
            return
        try:
            #fileID = str(self.rom.filenames).rpartition(".sdat")[0].split()[-2]
            for i, item in enumerate(self.tree.findItems("sdat", QtCore.Qt.MatchFlag.MatchRecursive, column=2)):
                try:
                    fileID = int(item.text(0))
                    sdat = ndspy.soundArchive.SDAT(self.rom.files[fileID])
                    sdat.fileID = fileID
                    self.sdats.append(sdat)
                    print(f"SDAT at {fileID}")
                except Exception:
                    print(f"Failed to load SDAT at {fileID}")
                    continue
            #self.sdats[self.dropdown_sdat.currentIndex()].fatLengthsIncludePadding = True
            self.action_sdat.setEnabled(True)
        except Exception as e:
            print(e)
            self.window_progress.hide()
            self.sdats = []
            dialog = QtWidgets.QMessageBox(self)
            dialog.setWindowTitle("No SDAT")
            dialog.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/exclamation')))
            dialog.setText("Sound data archive was not found. \n This means that sound data may not be there or may not be in a recognizable format.")
            dialog.exec()
            self.progressShow()
        self.progressUpdate(10, "Obtaining metadata")
        self.temp_path = str(PATH_ROOT / "temp" / (self.romToEdit_name+self.romToEdit_ext))
        self.setWindowTitle("Mega Man ZX Editor" + " <" + self.rom.name.decode() + ", Serial ID " + ''.join(char for char in self.rom.idCode.decode("utf-8") if char.isalnum())  + ", Rev." + str(self.rom.version) + ", Region " + str(self.rom.region) + ">" + " \"" + self.romToEdit_name + self.romToEdit_ext + "\"")
        if not self.rom.name.decode() in lib.gamedat.GameEnum.__members__:
            print("ROM is NOT supported! Continue at your own risk!")
            self.isGameSupported = False
            self.window_progress.hide()
            dialog = QtWidgets.QMessageBox(self)
            dialog.setWindowTitle("Warning!")
            dialog.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/exclamation')))
            dialog.setText("Game \"" + self.rom.name.decode() + "\" is NOT supported! Continue at your own risk!")
            dialog.exec()
            self.window_progress.show()
        else:
            self.isGameSupported = True

        self.gamedat = lib.gamedat.GameEnum[self.rom.name.decode() if self.isGameSupported else "UNSUPPORTED"]

        self.progressUpdate(20, "Loading ARM9", True, icon_title, icon_pixmap)
        self.arm9_decompressed = self.rom.loadArm9()
        self.treeArm9Update()
        self.progressUpdate(30, "Loading ARM7")
        self.treeArm7Update()
        self.progressUpdate(40, "Loading SDAT")
        self.treeSdatUpdate()
        #print(self.rom.filenames)
        self.progressUpdate(45, "Loading Tweaks")
        self.loadTweaks()
        self.progressUpdate(50, "Loading Patches")
        self.patches_reload()
        self.progressUpdate(90, "Loading game-specific content")
        arm9_data = self.arm9_decompressed.save()
        arm9_dialogueAddr = self.gamedat.arm9Addrs["dialogue names jp"]
        self.dropdown_dialogueNames.clear()
        for i in range(0x100):
            arm9_dialogueName = arm9_data[arm9_dialogueAddr+i*0x0C:arm9_dialogueAddr+i*0x0C+0x0C]
            if not 0xFF in arm9_dialogueName:
                break
            self.dropdown_dialogueNames.addItem(f"Name 0x{i:02X}")
        self.dropdown_dialogueNames.setCurrentIndex(-1)
        self.progressUpdate(100, "Finishing load")
        self.enable_editing_ui()
        self.file_content_text.setDisabled(True)
        self.progressHide()
        

    def enable_editing_ui(self):
        #self.button_codeedit.setDisabled(False)
        self.importSubmenu.setDisabled(False)
        self.button_file_save.show()
        self.action_save.setDisabled(False)
        self.saveAction.setDisabled(False)
        self.action_arm9.setDisabled(False)
        self.action_arm7.setDisabled(False)
        self.button_playtest.setDisabled(False)
        for i in range(self.tree.columnCount()):
            self.tree.showColumn(i)
        if self.gamedat.name.endswith("ZX"):
            self.dropdown_tweak_target.addItems(["Player", "Player(Hu)", "Player(X)", "Player(ZX)", "Player(HX)", "Player(LX)", "Player(FX)", "Player(PX)", "Player(OX)", "Other"])
        self.dropdown_tweak_target.setCurrentIndex(-1)
        self.dropdown_tweak_target.show()
        self.button_tweak_save.setDisabled(False)
        self.field_address.show()
        self.label_file_size.show()
        self.dropdown_level_area.blockSignals(True)
        if self.tree_arm9Ovltable.topLevelItemCount():
            self.dropdown_level_area.addItems([item.text(0) for item in self.tree_arm9Ovltable.findItems(self.tree_arm9Ovltable.topLevelItem(self.tree_arm9Ovltable.topLevelItemCount()-1).text(1), QtCore.Qt.MatchFlag.MatchExactly, 1)])
            self.loadOvelrayStructAddressTable()
        self.dropdown_level_area.setCurrentIndex(-1)
        self.dropdown_level_area.setEnabled(True)
        for i in range(self.layout_level_area.count()):
            widget = self.layout_level_area.itemAt(i).widget()
            if not widget in [None, self.button_level_save, self.dropdown_level_type]:
                widget.setEnabled(True)
        for widget in self.findChildren(QtWidgets.QWidget):
            widget.blockSignals(False)

    def disable_editing_ui(self):
        self.tree.setCurrentItem(None)
        self.field_address.setRange(0,0) # set address to 0 for consistency with the fact that no file is selected
        self.tree_patches.clear()
        #self.button_codeedit.setDisabled(False)
        self.importSubmenu.setDisabled(True)
        self.button_file_save.hide()
        self.action_save.setDisabled(True)
        self.action_arm9.setDisabled(True)
        self.action_arm7.setDisabled(True)
        self.button_playtest.setDisabled(True)
        for i in range(self.tree.columnCount()):
            self.tree.hideColumn(i)
        self.dropdown_tweak_target.hide()
        self.dropdown_tweak_target.clear()
        self.button_tweak_save.setDisabled(True)
        self.field_address.hide()
        self.label_file_size.hide()
        self.lineedit_level_tilesetName.setDisabled(True)
        self.lineedit_level_tilesetName.setText("N/A")
        self.dropdown_level_area.setEnabled(False)
        for i in range(self.layout_level_area.count()):
            widget = self.layout_level_area.itemAt(i).widget()
            if widget != None:
                widget.setEnabled(False)
        for widget in self.findChildren(QtWidgets.QWidget):
            widget.blockSignals(True)
        self.gfx_scene_level.scene().clear()
        self.gfx_scene_tileset.scene().clear()
        self.dropdown_level_area.clear()
        self.dropdown_level_type.clear()
        self.textEdit_dialogueNames.clear()
        self.dropdown_sdat.clear()
        self.button_patches_apply.setDisabled(True)
        for widget in self.trees_sdat:
            self.page_sdat.layout().removeWidget(widget)

    def exportCall(self, item: QtWidgets.QTreeWidgetItem):
        dialog = QtWidgets.QFileDialog(
                self,
                "Export File",
                "",
                "Supported Export Formats (*.bin *.txt *.bmp *.vx);;All Files (*)",
                options=QtWidgets.QFileDialog.Option.DontUseNativeDialog,
                )
        dialog.setAcceptMode(dialog.AcceptMode.AcceptSave)
        dialog.setFileMode(dialog.FileMode.AnyFile)
        dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.Accept, "Export")
        dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.FileName, "Output Destination:")
        if dialog.exec(): # if you saved a file
            dialog2 = QtWidgets.QMessageBox()
            dialog2.setWindowTitle("Export Status")
            dialog2.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/information')))
            dialog2.setText("File export failed!")
            selectedFiles = dialog.selectedFiles()
            path = selectedFiles[0][:selectedFiles[0].rfind("/")]
            name = selectedFiles[0].split("/")[-1]
            print(path, name)
            dialog_formatSelect = QtWidgets.QDialog(self)
            dialog_formatSelect.setWindowTitle("Choose format and compression")
            dropdown_formatSelect = QtWidgets.QComboBox(dialog_formatSelect)
            dropdown_formatSelect.addItems(["Raw", "English dialogue", "Bitmap", "VX"])
            dropdown_compressSelect = QtWidgets.QComboBox(dialog_formatSelect)
            dropdown_compressSelect.addItems(["No compression change", "compression", "decompression"])
            dropdown_compressSelect.currentIndexChanged.connect(lambda: dropdown_compresstypeSelect.setDisabled(dropdown_compressSelect.currentIndex() == 0))
            dropdown_compresstypeSelect = QtWidgets.QComboBox(dialog_formatSelect)
            dropdown_compresstypeSelect.addItems(["LZ10", "BLZ"])
            dropdown_compresstypeSelect.setDisabled(True)
            button_OK = QtWidgets.QPushButton("OK", dialog_formatSelect)
            button_OK.pressed.connect(lambda: dialog_formatSelect.close())
            button_OK.pressed.connect(lambda: dialog_formatSelect.setResult(1))
            dialog_formatSelect.setLayout(QtWidgets.QGridLayout())
            dialog_formatSelect.layout().addWidget(dropdown_formatSelect, 0,0,1,2)
            dialog_formatSelect.layout().addWidget(dropdown_compressSelect, 1,0,1,1)
            dialog_formatSelect.layout().addWidget(dropdown_compresstypeSelect, 1,1,1,1)
            dialog_formatSelect.layout().addWidget(button_OK, 2,0,1,2)
            dialog_formatSelect.resize(250, 200)
            dialog_formatSelect.exec()
            if dialog_formatSelect.result():
                print("Selected: " + dropdown_formatSelect.currentText() + ", " + dropdown_compressSelect.currentText())
                print("Item: " + item.text(0))
                if item != None:
                    fileInfo = self.file_fromItem(item)
                    if fileInfo == [b'', "", None, None]:
                        print("could not fetch data from tree item")
                        dialog2.setText("no file could be exported!\nmake sure to select a file before trying to export.")
                        dialog2.exec()
                        return
                    elif not isinstance(fileInfo[0], (bytes, bytearray)): # both bytes and bytearray are essentially the same, but need to be checked for separately
                        if type(fileInfo[0]) == tuple:
                            fileData = fileInfo[0][1].save()
                        else:
                            fileData = fileInfo[0].save()
                        print(fileData)
                        if isinstance(fileData, tuple):
                            fileData = fileData[0]
                    else:
                        fileData = fileInfo[0] # fileInfo[0] is already the expected data
                    if not "Folder" in item.text(2): # if file
                        self.extract(fileData, name=name, path=path, format=dropdown_formatSelect.currentText(), compress=[dropdown_compressSelect.currentText(), dropdown_compresstypeSelect.currentText()])
                        dialog2.setText(f"file \"{item.text(1)}\" exported!")
                    else: # if folder
                        folder_path = os.path.join(selectedFiles[0]) # here, "file name" specifies folder name instead
                        if os.path.exists(folder_path) == False:
                            print("Folder " + folder_path  + " will be created")
                            os.makedirs(folder_path)
                        else:
                            print("Folder " + folder_path  + " will be used")
                        print(item.childCount() - 1)
                        for i in range(item.childCount()):
                            print(item.child(i).text(0))
                            # file_fromItem gets the name automatically
                            self.extract(*self.file_fromItem(item.child(i))[:2], path=folder_path, format=dropdown_formatSelect.currentText(), compress=[dropdown_compressSelect.currentText(), dropdown_compresstypeSelect.currentText()])#, w.fileToEdit_name.replace(".Folder", "/")
                            #str(w.tree.currentItem().child(i).text(1) + "." + w.tree.currentItem().child(i).text(2)), 
                        dialog2.setText(f"folder \"{item.text(1)}\" exported!")
                    dialog2.exec()

    def replacebynameCall(self):
        if hasattr(w.rom, "name"):
            dialog = QtWidgets.QFileDialog(
                self,
                "Import File",
                "",
                "All Files (*)",
                options=QtWidgets.QFileDialog.Option.DontUseNativeDialog,
                )
            dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.Accept, "Import")
            dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.FileName, "ROM file:")
            if dialog.exec():
                selectedFiles = dialog.selectedFiles()
                dialog2 = QtWidgets.QMessageBox()
                dialog2.setWindowTitle("Import Status")
                dialog2.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/information')))
                dialog2.setText("File \"" + str(selectedFiles[0]).split("/")[-1] + "\" imported!")
                if str(selectedFiles[0]).split("/")[-1].removesuffix("']") in str(self.rom.filenames): # if file you're trying to replace is in ROM
                    with open(*selectedFiles, 'rb') as f:
                        fileEdited = f.read()
                        w.rom.setFileByName(str(f.name).split("/")[-1], bytearray(fileEdited))
                    dialog2.exec()
                elif str(selectedFiles[0]).split("/")[-1].split(".")[0] in [filename[filename.rfind(" ")+1:filename.find(".")] for filename in str(self.rom.filenames).split("\n")]: # if filename of file(without extension) you're trying to replace is in ROM
                    with open(*selectedFiles, 'rb') as f:
                        fileEdited = f.read()
                        if str(f.name).split("/")[-1].split(".")[1] == "txt":
                            #print(w.rom.filenames.idOf(str(selectedFiles).split("/")[-1].removesuffix("']").replace(".txt", ".bin")))
                            if "en" in str(f.name):
                                w.rom.files[w.rom.filenames.idOf(str(f.name).split("/")[-1].replace(".txt", ".bin"))] = bytearray(lib.dialogue.DialogueFile.textToBin(fileEdited.decode("utf-8"), self.gamedat.charmaps["en"]))
                            elif "jp" in str(f.name):
                                w.rom.files[w.rom.filenames.idOf(str(f.name).split("/")[-1].replace(".txt", ".bin"))] = bytearray(lib.dialogue.DialogueFile.textToBin(fileEdited.decode("utf-8"), self.gamedat.charmaps["jp"]))
                            dialog2.exec()
                        else:
                            QtWidgets.QMessageBox.critical(
                            self,
                            "Format not recognized",
                            "Please select a file that is supported by the editor."
                            )
                else:
                    QtWidgets.QMessageBox.critical(
                    self,
                    "File \"" + str(selectedFiles[0]).split("/")[-1].removesuffix("']") + "\" not found in game files",
                    "Please select a file that has the same name as an existing ROM file."
                    )
                self.treeCall()

    def switch_dialogMode(self, dialog: QtWidgets.QFileDialog):
        nameFilters = dialog.nameFilters()
        index = nameFilters.index(dialog.selectedNameFilter())
        dialog.setFileMode([QtWidgets.QFileDialog.FileMode.ExistingFiles, QtWidgets.QFileDialog.FileMode.Directory][index])
        dialog.setNameFilters([nameFilters[0], nameFilters[1]]) # setting to directory removes non-directory filters, so fix that
        dialog.selectNameFilter(dialog.nameFilters()[index]) # resetting filters resets selection, so re-select desired option

    def replaceCall(self, item: QtWidgets.QTreeWidgetItem):
        if hasattr(w.rom, "name"):
            dialog = QtWidgets.QFileDialog(
                self,
                "Import File",
                "",
                "All Files (*);;Directories",
                options=QtWidgets.QFileDialog.Option.DontUseNativeDialog,
                )
            dialog.setFileMode(QtWidgets.QFileDialog.FileMode.ExistingFiles) # allow more than one file to be selected
            dialog.filterSelected.connect(lambda: self.switch_dialogMode(dialog))
            dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.Accept, "Import")
            dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.FileName, "Source:")
            if dialog.exec(): # if file you're trying to replace is in ROM
                    isFolder = dialog.selectedNameFilter() == "Directories"
                    selectedFiles = dialog.selectedFiles()
                    dialog2 = QtWidgets.QMessageBox()
                    dialog2.setWindowTitle("Import Status")
                    dialog2.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/information')))
                    dialog2.setText("File import failed!")
                    fileInfo = self.file_fromItem(item)
                    if not isFolder and str(selectedFiles[0]).split("/")[-1].split(".")[1] == "txt" and re.search(r".*(_\d+)$", str(selectedFiles[0]).split("/")[-1].split(".")[0]): # fileExt and fileName
                        dialogue = lib.dialogue.DialogueFile(fileInfo[2][fileInfo[2].index(fileInfo[0])]) # object created before loop to improve performance
                    for file in selectedFiles:
                        try:
                            fileName = str(file).split("/")[-1].split(".")[0]
                            fileExt = str(file).split("/")[-1].split(".")[-1]
                        except IndexError:
                            fileName = ""
                            fileExt = ""
                        if not isFolder:
                            with open(file, 'rb') as f:
                                fileEdited = f.read()
                                #print(fileExt)
                                # find a way to get attr and replace data at correct index.. maybe it's better to just save ROM and patch
                                #self.rom.files[self.rom.files.index(self.file_fromItem(item)[0])]
                                supported_list = ["txt", "bmp",
                                                  "swar", "sbnk", "ssar", "sseq",
                                                  "cmp", "blz", "lz", "lz10", "lz77", 
                                                  "dec", "declz", "declz10", "declz77", "decblz",
                                                  "bin", "vx", ""]
                                #print(selectedFiles)
                                print(f.name)
                                #print(fileName + "." + fileExt)
                                if not any(supported == fileExt.lower() for supported in supported_list): # unknown
                                    dialog2.exec()
                                    return
                                elif not isinstance(fileInfo[2], type(None)):
                                    if fileExt == "txt": # english text file
                                        if "en" in fileName or "jp" in fileName:
                                            if re.search(r".*(_\d+)$", fileName) and dialogue: # match the indicator that the file is a chunk of the original file
                                                dialogue.text_list[int(fileName.split("_")[-1])] = fileEdited.decode("utf-8") # add file text to object
                                                if selectedFiles.index(file) == len(selectedFiles)-1: # if at last selected file
                                                    data = dialogue.toBytes() # generate final binary to import (done only once to improve performance)
                                            else: # forced dialogue state
                                                data = bytearray(lib.dialogue.DialogueFile.textToBin(fileEdited.decode("utf-8")))
                                        else:
                                            data = bytearray(lib.dialogue.DialogueFile.textToBin(fileEdited.decode("utf-8")))
                                    elif fileExt == "bmp":
                                        img = QtGui.QImage()
                                        img.load(file)
                                        for member in lib.datconv.CompressionAlgorithmEnum:
                                            if member.depth == img.depth():
                                                algorithm = member
                                        data = lib.datconv.qtToBin(img, algorithm=algorithm)
                                    elif fileExt == "blz":
                                        try:
                                            data = bytearray(ndspy.codeCompression.decompress(fileEdited))
                                        except TypeError as e:
                                            print(e)
                                            QtWidgets.QMessageBox.critical(
                                            self,
                                            "Compression Failed",
                                            str(e + "\nMake sure the file has the correct extension.")
                                            )
                                            print("Aborted file replacement.")
                                            return
                                    elif fileExt == "cmp" or ("lz" in fileExt and not "dec" in fileExt):
                                        try:
                                            data = bytearray(ndspy.lz10.decompress(fileEdited))
                                        except TypeError as e:
                                            print(e)
                                            QtWidgets.QMessageBox.critical(
                                            self,
                                            "Decompression Failed",
                                            str(e + "\nMake sure the file has the correct extension.")
                                            )
                                            print("Aborted file replacement.")
                                            return
                                    elif fileExt == "decblz":
                                        data = bytearray(ndspy.codeCompression.compress(fileEdited))
                                        data += bytearray((-len(data)) & 0xF) # 16-byte padding
                                    elif "dec" in fileExt:
                                        data = bytearray(ndspy.lz10.compress(fileEdited))
                                        data += bytearray((-len(data)) & 3) # 4-byte padding
                                    else: # raw data
                                        data = bytearray(fileEdited)
                                else:
                                    dialog2.exec()
                                    return
                        else:
                            print("folder import")
                            if fileExt == "vx":
                                print("is vx")
                                self.progressShow()
                                self.progressUpdate(0, "Loading folder", False)
                                act = lib.act.ActImagine()
                                try:
                                    import_vxfolder_iter = act.import_vxfolder(file)
                                except Exception as e:
                                    print(e)
                                    print("This folder is not formatted properly!")
                                    self.progressHide()
                                    return
                                self.progressUpdate(0, "Preparing encoding")
                                for i, _ in enumerate(import_vxfolder_iter):
                                    self.progressUpdate(50, f"Preparing encoding (processing frame {i+1}/???)")
                                self.progressUpdate(100, "Preparing encoding")
                                vframe_strategy = lib.actEncVStrats.SimpleKeyframeOnly()
                                aframe_strategy = lib.actEncAStrats.SimplePulseExtend()
                                for i, avframe in enumerate(act.avframes):
                                    avframe.encode(avframe.vframe.plane_buffers, vframe_strategy, aframe_strategy)
                                    self.progressUpdate(int(((i+1)/act.frames_qty)*100), f"Encoding VX folder (frame {i+1}/{act.frames_qty})")
                                data = act.save_vx()
                                self.progressHide()
                            else:
                                print("not a special folder")
                                return

                    if isinstance(fileInfo[2], bytearray): # other
                            fileInfo[2][fileInfo[2].index(fileInfo[0]):fileInfo[2].index(fileInfo[0])+len(fileInfo[0])] = data
                            print(data[:0x15].hex())
                    elif fileInfo[3] == None: # rom files
                        fileInfo[2][fileInfo[2].index(fileInfo[0])] = data
                        print(data[:0x15].hex())
                    elif any(x for x in self.sdats[self.dropdown_sdat.currentIndex()].__dict__.values() if x == fileInfo[3]):
                        #SDAT. this code is very experimental and should not be expected to work perfectly
                        for key, value in self.sdats[self.dropdown_sdat.currentIndex()].__dict__.items():
                            if value == fileInfo[3]:
                                categoryName = key
                                break
                        newName = fileName
                        if fileInfo[4] is not None: # object listed within object in one of the sdat sections
                            oldObject = fileInfo[4]#fileInfo[0][1]
                        else:
                            oldObject = fileInfo[0]
                        try:
                            newObject = type(oldObject).fromFile(f.name)
                        except:
                            dialog2.exec()
                            return
                        if isinstance(oldObject, ndspy.soundSequenceArchive.soundSequence.SSEQ): # bankID fix (defaults to 0)
                            newObject.bankID = oldObject.bankID
                            newObject.volume = oldObject.volume
                            newObject.channelPressure = oldObject.channelPressure
                            newObject.polyphonicPressure = oldObject.polyphonicPressure
                            newObject.playerID = oldObject.playerID
                            #for sseq in fileInfo[3]:
                            #    if sseq[0] == fileName:
                            #        newObject.bankID = sseq[1].bankID
                            #        newName = fileInfo[0][0]
                        print(oldObject)
                        print(newObject)
                        objectIndex = fileInfo[3].index([x for x in fileInfo[3] if fileInfo[4] in x])
                        if hasattr(fileInfo[4], "waves"):
                                fileInfo[4].waves[fileInfo[4].waves.index(fileInfo[0])] = (newObject) 
                                fileInfo[3][objectIndex][1] = fileInfo[4]
                        elif hasattr(fileInfo[4], "sequences"):
                            fileInfo[4].sequences[fileInfo[4].sequences.index(fileInfo[0])] = (newObject) 
                            fileInfo[3][objectIndex][1] = fileInfo[4]
                        else: # category object
                            fileInfo[3][objectIndex] = (newName, newObject) 
                        setattr(self.sdats[self.dropdown_sdat.currentIndex()], categoryName, fileInfo[3])
                        fileInfo[2][self.sdats[self.dropdown_sdat.currentIndex()].fileID] = self.sdats[self.dropdown_sdat.currentIndex()].save() # save sdat to its parent object
                        self.treeSdatUpdate() # refresh tree to avoid interactions with files that are not in the new state
                    else: # subfile
                        for file in fileInfo[2]:
                            if fileInfo[0] in file:
                                fileInfo[2][fileInfo[2].index(file)][file.index(fileInfo[0]):file.index(fileInfo[0])+len(fileInfo[0])] = data
                            
                    dialog2.setText("File \"" + str(selectedFiles[0]).split("/")[-1] + "\" imported!")
                    dialog2.exec()
                    self.treeCall()
    
    def switch_theme(self, isupdate=False):
        if isupdate == False:
            self.theme_index = self.dropdown_theme.currentIndex()
            lib.ini_rw.write(self)
        else:
            self.dropdown_theme.setCurrentIndex(self.theme_index) # Update dropdown with current option
        app: QtWidgets.QMainWindow = QtWidgets.QApplication.instance()
        app.setStyleSheet("QComboBox QAbstractItemView {background-color: palette(base);}")
        if self.theme_index < len(QtWidgets.QStyleFactory.keys()):
            app.setStyle(self.dropdown_theme.currentText())
        else:
            if os.path.exists('theme\\custom_theme.qss'):
                app.setStyleSheet(open('theme\\custom_theme.qss').read())
            else:
                os.mkdir("theme")
                open('theme\\custom_theme.qss', "w")
                dialog = QtWidgets.QMessageBox()
                dialog.setWindowTitle("No custom stylesheet found")
                dialog.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/exclamation')))
                dialog.setText("No custom stylesheet was found in location \"theme\\custom_theme.qss\".\nAn empty file has been created there.\nPlease put the contents of your custom stylesheet in it.\nIf you wish to create one yourself but do not know how, refer to this page:\nhttps://doc.qt.io/qtforpython-6.5/overviews/stylesheet-examples.html")
                dialog.exec()
    
    def display_format_toggleCall(self):
        self.fileDisplayRaw = not self.fileDisplayRaw
        self.displayFormatSubmenu.setDisabled(self.displayFormatSubmenu.isEnabled())
        self.widgetIcon_update(self.displayRawAction, QtGui.QIcon(str(PATH_ROOT / 'icons/brain')), QtGui.QIcon(str(PATH_ROOT / 'icons/document-binary')))
        self.treeCall()

    def value_update_Call(self, var, val, istreecall=True):
        #print(f"{self.field_address.value():08X}" + " - " + f"{self.base_address:08X}")
        setattr(self, var, val)
        if istreecall:
            self.treeCall()

    def OAM_updateItemGFX(self, obj_index: int, oamsec:lib.oam.OAMSection=None, frameIndex:int=None, gfxsec:lib.graphic.GraphicSection=None, objs:list[lib.oam.Object]=None, item: lib.widget.OAMObjectItem|None=None, palette:list[int]=None):
        # creates and returns an item if none specified
        args_auto = [oamsec, frameIndex, gfxsec, objs]
        if args_auto.count(None) == len(args_auto):
            # by default, will use self.fileEdited if no info specified
            oamsec = self.fileEdited_object.oamsec
            frameIndex = self.fileEdited_object.frameIndex
            gfxsec = self.fileEdited_object.gfxsec
            objs = self.fileEdited_object.objs
        elif None in args_auto:
            raise TypeError("Only some arguments are defined")
        frame = oamsec.frameTable[frameIndex]
        gfxheader_index = frame[2]
        if len(gfxsec.graphics) <= 0:
            print("no graphics in section!")
            return
        if gfxheader_index >= len(gfxsec.graphics):
            print(f"Graphic Header at index {gfxheader_index} of Graphic Section does not exist!")
            return
        gfxheader = gfxsec.graphics[gfxheader_index]
        depth = 4 # actual depth that will be used to render
        indexingFactor = 1 # I guess this is changed based on the size of assembled gfx
        # in 4bpp, oam tile id * indexingFactor = vram tile id
        # in 8bpp, oam tile id * indexingFactor // 2 = vram tile id
        if gfxsec.entry_size == 0x14:
            depth = gfxsec.graphics[0].depth//2
        else:
            print("depth unknown")
        obj: lib.oam.Object = objs[obj_index]

        if item != None:
            obj.tileId = self.field_objTileId.value()
            obj.tileId_add = self.field_objTileId.value() & 0x300
            obj.flip_h = self.checkbox_objFlipH.isChecked()
            obj.flip_v = self.checkbox_objFlipV.isChecked()
            if isinstance(obj, lib.oam.Object3D):
                obj.heightIndex = self.slider_obj3DHeightIndex.sl.value()
                obj.tile_width_index = self.slider_obj3DTileWidth.sl.value()
            else:
                obj.sizeIndex = self.slider_objSizeIndex.sl.value()
                obj.shape = self.buttonGroup_oam_objShape.checkedId()
            obj.x = self.field_objX.value()
            obj.y = self.field_objY.value()
        if gfxheader.oam_tile_indexing == 0:
            indexingFactor = 1
        elif gfxheader.oam_tile_indexing == 0x18:
            indexingFactor = 4
        else:
            print(f"unhandled tile indexing mode: {gfxheader.oam_tile_indexing:02X}")
        img_offset = gfxheader.offset_start - gfxsec.offset_start
        if gfxsec.entry_size == 0x14:
            pal_off = img_offset + gfxheader.palette_offset+0xc
            pal = [0xffffffff]*(gfxheader.unk13 & 0xf0)
            pal.extend(lib.datconv.BGR15_to_ARGB32(gfxsec.data[pal_off:pal_off+gfxheader.palette_size]))
        else:
            #print("palette changed")
            #print(int.from_bytes(oamsec.data[oamsec.paletteTable_offset:oamsec.paletteTable_offset+2]))
            if len(oamsec.header_items) == 4:
                pal = oamsec.paletteTable[0]
            else: # palette may be handled dynamically in RAM
                print(f"palette ram: 0x{gfxheader.ram_palette_offset:04X}")
                pal = self.GFX_PALETTES[2]
        if palette is not None:
            for i, color in enumerate(palette):
                if color is None: continue
                pal[i] = color
        tileId = gfxheader.oam_tile_offset + obj.tileId
        gfxOffset = img_offset + gfxheader.gfx_offset
        # multiply oam tile id by indexingFactor(relative to 4bpp) and 4bpp tile size to get vram tile id
        gfxOffset += int(tileId*indexingFactor*32) # 8*8pixels*4bpp/8bits = 32bytes
        #print(f"offset: {gfxOffset:04X}")
        #print(f"tile {tileId:02X}")
        depth_obj = lib.datconv.CompressionAlgorithmEnum.FOURBPP
        for member in lib.datconv.CompressionAlgorithmEnum:
            if member.depth == depth:
                depth_obj = member
        try: #gfxOffset+img_current.gfx_size
            if isinstance(obj, lib.oam.Object3D):
                obj_img = lib.datconv.binToQt(gfxsec.data[gfxOffset:], pal,
                    depth_obj,
                    1,
                    obj.getHeight(), obj.getTileWidth()
                )
            else:
                obj_img = lib.datconv.binToQt(gfxsec.data[gfxOffset:], pal,
                    depth_obj,
                    obj.getWidth(),
                    obj.getHeight()
                )
        except AssertionError:
            print(f"invalid object properties detected in object {obj_index}!")
            return
        colorTable = obj_img.colorTable()
        if len(colorTable) <= 0:
            print("empty palette!")
            return
        colorTable[0] -= 0xff000000 # remove alpha from first color
        obj_img.setColorTable(colorTable)
        if item == None:
            obj_item = lib.widget.OAMObjectItem(QtGui.QPixmap.fromImage(obj_img), id=obj_index, editable=(self.tabs_oam.currentWidget()==self.page_oam_frames))
        else:
            obj_item = item
            obj_item.setPixmap(QtGui.QPixmap.fromImage(obj_img))
        obj_item.setPixmap(
            obj_item.pixmap().transformed(QtGui.QTransform().scale(-1 if obj.flip_h else 1,-1 if obj.flip_v else 1))
        )
        obj_item.setPos(obj.x, obj.y)
        obj_item.setZValue(-obj_item.obj_id)
        if item == None:
            return obj_item
        
    def OAM_processFrame(self, oamsec:lib.oam.OAMSection|list[str,int], frameIndex:int, gfxsec:lib.graphic.GraphicSection=None, palette:list[int]=None):
        """
        oamsec: The object containing data about a specific entry of an OAM file OR a list containing that file's name as well as the entry index.\n
        frameIndex: An integer used as the index of the oamsec's frameTable to fetch data from.\n
        gfxsec: The object containing the entry's graphics; Can be initialized automatically based on oamsec or fileEdited_object.\n
        palette: A list of ints representing each argb32 color of a palette to load, overwriting the intended palette; None can be used to keep the original color.
        """
        if isinstance(oamsec, list): # file name, entry index
            oamfile = lib.oam.File(self.rom.getFileByName(oamsec[0]))
            if gfxsec is None:
                auxfile = lib.graphic.File(self.rom.getFileByName(oamsec[0].replace("dat", "fnt")))
                gfxsec = lib.graphic.GraphicSection.fromParent(auxfile, oamsec[1])
            oamsec = lib.oam.OAMSection(oamfile, oamsec[1])
        frame = oamsec.frameTable[frameIndex] # ptr, count, gfxsec id
        obj_offset_base = oamsec.frameTable_offset + frame[0]
        is3D = False
        objs = []
        try:
            if frameIndex < len(oamsec.frameTable)-1:
                #print(frame[0]+frame[1]*0x06, "vs", oamsec.frameTable[frameIndex+1][0])
                assert frame[0]+frame[1]*0x06 == oamsec.frameTable[frameIndex+1][0]
            else:
                obj_offset_end = obj_offset_base + frame[1]*0x06
                #print(oamsec.data[obj_offset_end:oamsec.header_items[1]].hex())
                #print(obj_offset_end, "vs", oamsec.header_items[1])
                assert obj_offset_end <= oamsec.header_items[1]
            is3D = True
            print("3D objects detected")
        except AssertionError:
            pass
        obj_list = []
        for i in range(frame[1]):
            if i >= 128:
                print("Object limit reached! Proceed at your own risk!")
                break
            self.dropdown_oam_obj.addItem(f"object {i}")
            if is3D:
                obj_offset = obj_offset_base + i*0x06
                objs.append(lib.oam.Object3D(oamsec.data[obj_offset:obj_offset+0x06]))
            else:
                obj_offset = obj_offset_base + i*0x04
                objs.append(lib.oam.Object(oamsec.data[obj_offset:obj_offset+0x04]))
            obj_item = self.OAM_updateItemGFX(
                i,
                oamsec,
                frameIndex,
                gfxsec,
                objs,
                palette=palette
            )
            if obj_item == None:
                print("Load aborted. Proceed at your own risk!")
                break
            obj_list.append(obj_item)
        result = {"objs":objs, "items":obj_list, "is3D":is3D}
        return result
        
    def OAM_playAnimFrame(self):
        if self.fileDisplayState != "OAM" or self.fileEdited_object is None: # prevents crash when loading another file or refreshing
            self.button_oam_animPlay.autoPause()
            return
        anim: lib.oam.Animation = self.fileEdited_object.oamsec_anim
        frame_index = self.dropdown_oam_animFrame.currentIndex()
        frame = anim.frames[frame_index]
        duration = frame[1]
        if frame_index > 0 and duration == 0:
            duration = 0xFF
        if self.button_oam_animPlay.counter >= duration:
            #print(f"{self.button_oam_animPlay.counter} vs {duration}")
            self.button_oam_animPlay.counter = 0
            if frame_index < self.dropdown_oam_animFrame.count()-1:
                self.dropdown_oam_animFrame.setCurrentIndex(frame_index+1)
            else:
                if self.checkbox_oam_animLoop.isChecked():
                    self.dropdown_oam_animFrame.setCurrentIndex(self.field_oam_animLoopStart.value())
                else: # pause anim
                    self.button_oam_animPlay.autoPause()

    def setPalette(self, palette: list[int], skip:int=0):
        #for i in range(self.dropdown_gfx_depth.count()): # re-enable depth options
        #    self.dropdown_gfx_depth.model().item(i).setEnabled(True)
        new_pal = palette.copy()
        if new_pal == []:
            print("empty palette!")
            if not self.gfx_palette in self.GFX_PALETTES:
                self.setPalette(self.GFX_PALETTES[0])
            return
        try:
            self.dropdown_gfx_palette.setCurrentIndex(self.GFX_PALETTES.index(palette)) # if setPalette wasn't called by the dropdown itself
        except ValueError:
            self.dropdown_gfx_palette.setCurrentIndex(-1) # dynamically generated palette
        self.gfx_palette = new_pal
        self.file_content_gfx.pen.setColor(0x00010101) # set to first color
        for i in range(256):
            button_palettepick: lib.widget.HoldButton = getattr(self, f"button_palettepick_{i}")
            if i < len(self.gfx_palette) and i >= skip:
                button_palettepick.setStyleSheet(f"background-color: #{self.gfx_palette[i]:08x}; color: white;")
            else:
                button_palettepick.setStyleSheet(f"background-color: white; color: white;") # fill missing colors with NaN white

    def colorpickCall(self, color_index: int, press=None, hold=None):
        #print(color_index)
        button: lib.widget.HoldButton = getattr(self, f"button_palettepick_{color_index}")
        stylesheet = button.styleSheet()
        depth = list(lib.datconv.CompressionAlgorithmEnum)[self.dropdown_gfx_depth.currentIndex()].depth
        if hold:
            dialog = QtWidgets.QColorDialog(self)
            dialog.setOptions(QtWidgets.QColorDialog.ColorDialogOption.DontUseNativeDialog)
            if stylesheet.find("#") != -1:
                color = stylesheet[stylesheet.find("#")+1:stylesheet.find(";")]
                dialog.setCurrentColor(int(color, 16))
                dialog.exec()
                if dialog.selectedColor().isValid():
                    self.gfx_palette[color_index] = dialog.selectedColor().rgba()
                    button.setStyleSheet(f"background-color: #{self.gfx_palette[color_index]:08X}; color: white;")
                    if self.dropdown_gfx_palette.currentIndex() == -1:
                        self.button_file_save.setEnabled(True)
                    self.treeCall() # update gfx colors
        if press:
            #print(button.styleSheet())
            if color_index < 2**depth:
                self.file_content_gfx.pen.setColor(0xff000000 + color_index * 0x00010101)#int(button.styleSheet()[button.styleSheet().find(":")+3:button.styleSheet().find(";")], 16))
            elif color_index < len(self.gfx_palette): # outside of first subpalette range, but is an existing color in palette
                color_index2 = color_index//(2**depth)*(2**depth)
                new_pal = self.gfx_palette.copy() # copy to another var to facilitate color swap
                new_pal[:2**depth] = self.gfx_palette[color_index2:color_index2+(2**depth)] # switch up colors between selected subpalette and 1st subpalette
                new_pal[color_index2:color_index2+(2**depth)] = self.gfx_palette[:2**depth]
                self.gfx_palette = new_pal
                self.file_content_gfx.pen.setColor(0xff000000 + color_index%(2**depth) * 0x00010101) # set to first color
                for i in range(2**depth): # change affected buttons (primary)
                    button_palettepick: lib.widget.HoldButton = getattr(self, f"button_palettepick_{i}")
                    button_palettepick.setStyleSheet(f"background-color: #{self.gfx_palette[i]:08x}; color: white;")
                for i in range(color_index2, color_index2+2**depth): # change affected buttons (selected)
                    button_palettepick: lib.widget.HoldButton = getattr(self, f"button_palettepick_{i}")
                    button_palettepick.setStyleSheet(f"background-color: #{self.gfx_palette[i]:08x}; color: white;")
                self.treeCall()
                    
    
    def saveCall(self): #Save to external ROM
        save_buttons = [self.button_file_save, self.button_level_save, self.button_dialogueNames_save, self.button_patches_apply]
        if any(b.isEnabled() for b in save_buttons):
            save_choice = QtWidgets.QMessageBox.warning(
                self,
                "Unsaved Changes",
                f"Looks like you are trying to save your ROM to disk despite not having saved all your modifications.\nIgnore unsaved changes and proceed?\n\nButtons reporting unsaved changes:\n{[b.text() for b in save_buttons if b.isEnabled()]}",
                QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No
            )
            if save_choice == QtWidgets.QMessageBox.StandardButton.No:
                return # abort save
        dialog = QtWidgets.QFileDialog(
                self,
                "Save ROM",
                self.romToEdit_path,
                "NDS Files (*.nds *.srl);; All Files (*)",
                options=QtWidgets.QFileDialog.Option.DontUseNativeDialog,
                )
        dialog.setAcceptMode(dialog.AcceptMode.AcceptSave)
        dialog.setDefaultSuffix(self.romToEdit_ext)
        dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.Accept, "Save")
        dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.FileName, "Hack name:")
        if dialog.exec(): # if you saved a file
            romName = dialog.selectedFiles()[0]
            print(romName)
            self.rom.saveToFile(romName)
            print("ROM modifs saved!")
            # allow user to choose whether or not they want to reload fat
            reload_dialog = QtWidgets.QMessageBox()
            reload_dialog.setWindowTitle("Mega Man ZX Editor - Reload from saved ROM")
            reload_dialog.setWindowIcon(QtGui.QIcon(str(PATH_ROOT / 'icons/question')))
            reload_dialog.setText("Now that the ROM is saved, the FAT may have changed.\n Reload ROM from this file to fetch accurate file addresses?")
            reload_dialog.setStandardButtons(reload_dialog.StandardButton.Yes | reload_dialog.StandardButton.No)
            if reload_dialog.exec() == reload_dialog.StandardButton.Yes:
                self.loadROM(romName)

    def testCall(self, isQuick=True):
        #print("isQuick: " + str(isQuick))
        if isQuick == False:
            dialog_playtest = QtWidgets.QDialog(self)
            dialog_playtest.setWindowTitle("Playtest Options")
            dialog_playtest.resize(500, 500)
            dialog_playtest.setLayout(QtWidgets.QGridLayout())
            # Test options; arm 9 at 0x00004000; starting pos x=00A00D00 y=FF6F0400
            input_address = QtWidgets.QLineEdit(dialog_playtest)
            input_address.setPlaceholderText("insert test patch adress")
            input_value = QtWidgets.QLineEdit(dialog_playtest)
            input_value.setPlaceholderText("insert test patch data")

            button_play = QtWidgets.QPushButton("Play", dialog_playtest)
            button_play.move(dialog_playtest.width() - 100, dialog_playtest.height() - 50)
            button_play.pressed.connect(lambda: dialog_playtest.close())
            button_play.pressed.connect(lambda: dialog_playtest.setResult(1))
            dialog_playtest.layout().addWidget(input_address)
            dialog_playtest.layout().addWidget(input_value)
            dialog_playtest.layout().addWidget(button_play)
            dialog_playtest.exec()
        if not os.path.exists("temp"):
                os.mkdir("temp")
        self.rom.saveToFile(self.temp_path)# Create temporary ROM to playtest
        if 'dialog_playtest' in locals() and dialog_playtest.result():
            with open(self.temp_path, "r+b") as f:
                    if input_address.text() != "":
                        try:
                            address = lib.datconv.strToNum(input_address.text(), self.displayBase)
                            value = lib.datconv.strSetAlnum(input_value.text(), 16, True)
                            f.seek(address)# get to pos for message
                            value_og = lib.datconv.strSetAlnum(f.read(len(bytes.fromhex(value))).hex(), self.displayBase, self.displayAlphanumeric)
                            print(f"successfully wrote {value_og} => {input_value.text().upper()} to {input_address.text().zfill(8)}")
                            f.seek(address)# get to pos
                            f.write(bytes.fromhex(value))# write data
                        except ValueError as e:
                            QtWidgets.QMessageBox.critical(
                                self,
                                str(e),
                                f"Address input must be numeric and must not go over size {lib.datconv.numToStr(len(self.rom.save()), self.displayBase, self.displayAlphanumeric)}\nValue input must be numeric."
                                )
                            return
        if isQuick or dialog_playtest.result():
            os.startfile(self.temp_path)
            print("game will start in a few seconds")

    def dialogOpenCall(self, dialog_name: str):
        if hasattr(self, dialog_name):
            dialog: QtWidgets.QMainWindow = getattr(self, dialog_name)
            dialog.show()
            dialog.activateWindow()

    def sdatPlayCall(self):
        items: list[QtWidgets.QTreeWidgetItem] = self.trees_sdat[self.dropdown_sdat.currentIndex()].selectedItems()
        if len(items) == 0: return
        if items[0].text(0) == "N/A": return
        snd_type = items[0].text(2)
        if snd_type == "SWAV": # WIP
            print("play SWAV")
            snd_data = ndspy.soundArchive.soundWaveArchive.soundWave.SWAV(self.file_fromItem(items[0])[0])
            lib.sdat.playSWAV(snd_data)
        elif snd_type == "SSEQ": # Incomplete
            print("play SSEQ")
            sseq = ndspy.soundArchive.soundSequence.SSEQ(self.file_fromItem(items[0])[0], bankID=int(items[0].toolTip(0).removeprefix("bankID: ")))
            lib.sdat.playSSEQ(sseq, self.sdats[self.dropdown_sdat.currentIndex()])

    def sdatPlotCall(self):
        items = self.trees_sdat[self.dropdown_sdat.currentIndex()].selectedItems()
        if len(items) == 0: return
        if items[0].text(0) == "N/A": return
        if items[0].text(2) != "SWAV": return
        snd_data = ndspy.soundArchive.soundWaveArchive.soundWave.SWAV(self.file_fromItem(items[0])[0])
        fig, ax = pyplt.subplots()
        ax.plot(lib.sdat.loadSWAV(snd_data))
        pyplt.show()

    #def codeeditCall(self):
        #self.tree.clearSelection()
        #self.arm9 = ndspy.code.MainCodeFile(w.rom.files[0], 0x00000000)
        #self.file_content_text.setPlainText(str(self.arm9))
        #print("code")

    def treeUpdate(self): # files from filename table (fnt.bin)
        tree_files: list[QtWidgets.QTreeWidgetItem] = []
        try: # convert NDS Py filenames to QTreeWidgetItems
            if self.rom != None and self.rom.files != []:
                tree_folder_ovlt = QtWidgets.QTreeWidgetItem([f"{0:04}", "ovltable", "Folder"])
                for i in range(0, len(self.rom.arm9OverlayTable)//0x20):
                    tree_folder_ovlt.addChild(QtWidgets.QTreeWidgetItem([f"{i:04}", f"overlay9_{i:04}", "bin"]))
                tree_files.append(tree_folder_ovlt)
                tree_folder: list[QtWidgets.QTreeWidgetItem] = []
                for f in str(self.rom.filenames).split("\n"):
                    if not "/" in f: # if file
                        if "    " in f: # if contents of folder
                            tree_folder[f.count("    ") - 1].addChild(QtWidgets.QTreeWidgetItem([f.split(" ")[0], f.split(" ")[-1].split(".")[0], f.split(".")[-1]]))
                        else:
                            tree_files.append(QtWidgets.QTreeWidgetItem([f.split(" ")[0], f.split(" ")[-1].split(".")[0], f.split(".")[-1]]))
                    else: # if folder
                        if f.count("    ") < len(tree_folder):
                            tree_folder[f.count("    ")] = QtWidgets.QTreeWidgetItem([f.split(" ")[0], f.split(" ")[-1].removesuffix("/"), "Folder"])
                        else:
                            tree_folder.append(QtWidgets.QTreeWidgetItem([f.split(" ")[0], f.split(" ")[-1].removesuffix("/"), "Folder"]))
                        if not "    " in f:
                            tree_files.append(tree_folder[f.count("    ")])
                        else:
                            tree_folder[f.count("    ") - 1].addChild(tree_folder[f.count("    ")])
        except Exception as e: # if failed, do nothing
            print("Failed to load filesystem")
        self.tree.clear()
        self.tree.addTopLevelItems(tree_files)

    def treeArm9Update(self):
        self.tree_arm9.clear()
        #print(self.rom.loadArm9Overlays())
        #item_mainCode = QtWidgets.QTreeWidgetItem([library.dataconverter.StrFromNumber(self.arm9.ramAddress, self.displayBase, self.displayAlphanumeric).zfill(8), "Main Code", "N/A"])
        item_main = QtWidgets.QTreeWidgetItem([
                lib.datconv.numToStr(self.rom.arm9RamAddress, self.displayBase, self.displayAlphanumeric).zfill(8), 
                "main code file", 
                "N/A",
                "N/A"
            ])
        self.tree_arm9.addTopLevelItem(item_main)
        for e in self.arm9_decompressed.sections:
            item_main.addChild(QtWidgets.QTreeWidgetItem([
                lib.datconv.numToStr(e.ramAddress, self.displayBase, self.displayAlphanumeric).zfill(8), 
                str(e).split()[0].removeprefix("<"), 
                str(e.implicit),
                lib.datconv.numToStr(e.bssSize, self.displayBase, self.displayAlphanumeric)
            ]))
        
        #print(arm9.save().hex().find("50D31B02".lower())) 
        #.find("44431902".lower())
        #.find("50D31B02".lower())
        
        self.tree_arm9Ovltable.clear()
        arm9OvlDict = self.rom.loadArm9Overlays()
        for overlayID in arm9OvlDict:
                overlay = arm9OvlDict[overlayID]
                self.tree_arm9Ovltable.addTopLevelItem(QtWidgets.QTreeWidgetItem([
                    str(overlay.fileID).zfill(4), 
                    lib.datconv.numToStr(overlay.ramAddress, self.displayBase, self.displayAlphanumeric).zfill(8), 
                    str(overlay.compressed), 
                    lib.datconv.numToStr(overlay.compressedSize, self.displayBase, self.displayAlphanumeric), 
                    lib.datconv.numToStr(overlay.ramSize, self.displayBase, self.displayAlphanumeric), 
                    lib.datconv.numToStr(overlay.bssSize, self.displayBase, self.displayAlphanumeric), 
                    lib.datconv.numToStr(overlay.staticInitStart, self.displayBase, self.displayAlphanumeric).zfill(8), 
                    lib.datconv.numToStr(overlay.staticInitEnd, self.displayBase, self.displayAlphanumeric).zfill(8), 
                    lib.datconv.numToStr(overlay.flags, self.displayBase, self.displayAlphanumeric), 
                    str(overlay.verifyHash)
                ]))
        self.tree_arm9Ovltable.header().resizeSections(QtWidgets.QHeaderView.ResizeMode.ResizeToContents)

        #self.tree_arm9.addTopLevelItem(item_mainCode)

    def treeArm7Update(self):
        self.tree_arm7.clear()
        arm7 = self.rom.loadArm7()
        item_mainCode = QtWidgets.QTreeWidgetItem([
                lib.datconv.numToStr(arm7.ramAddress, self.displayBase, self.displayAlphanumeric).zfill(8), 
                "main code file", 
                "N/A",
                "N/A"
            ])
        self.tree_arm7.addTopLevelItem(item_mainCode)
        for e in arm7.sections:
            item_mainCode.addChild(QtWidgets.QTreeWidgetItem([
                lib.datconv.strSetAlnum(str(e).split()[2].removeprefix("0x").removesuffix(":"), self.displayBase, self.displayAlphanumeric).zfill(8), 
                str(e).split()[0].removeprefix("<"), 
                str(e.implicit),
                str(e.bssSize)
            ]))

        self.tree_arm7Ovltable.clear()
        arm7OvlDict = self.rom.loadArm7Overlays()
        for overlayID in arm7OvlDict:
                overlay = arm7OvlDict[overlayID]
                self.tree_arm7Ovltable.addTopLevelItem(QtWidgets.QTreeWidgetItem([
                    str(overlay.fileID).zfill(4), 
                    lib.datconv.numToStr(overlay.ramAddress, self.displayBase, self.displayAlphanumeric).zfill(8), 
                    str(overlay.compressed), 
                    lib.datconv.numToStr(overlay.compressedSize, self.displayBase, self.displayAlphanumeric), 
                    lib.datconv.numToStr(overlay.ramSize, self.displayBase, self.displayAlphanumeric), 
                    lib.datconv.numToStr(overlay.bssSize, self.displayBase, self.displayAlphanumeric), 
                    lib.datconv.numToStr(overlay.staticInitStart, self.displayBase, self.displayAlphanumeric).zfill(8), 
                    lib.datconv.numToStr(overlay.staticInitEnd, self.displayBase, self.displayAlphanumeric).zfill(8), 
                    lib.datconv.numToStr(overlay.flags, self.displayBase, self.displayAlphanumeric), 
                    str(overlay.verifyHash)
                ]))
        self.tree_arm7Ovltable.header().resizeSections(QtWidgets.QHeaderView.ResizeMode.ResizeToContents)
    
    def treeSdatUpdate(self):
        #print(str(self.sdats[self.dropdown_sdat.currentIndex()].groups)[:13000])
        #progress = QtWidgets.QProgressBar()
        #progress.setValue(0)
        #progress.show()
        self.trees_sdat.clear()
        self.dropdown_sdat.clear()
        for i in range(len(self.sdats)):
            self.dropdown_sdat.addItem(f"SDAT {self.sdats[i].fileID:04}")
            tree_sdat = lib.widget.EditorTree(self.page_sdat)
            tree_sdat.setColumnCount(3)
            tree_sdat.setHeaderLabels(["File ID", "Name", "Type"])
            tree_sdat.setContextMenuPolicy(QtCore.Qt.ContextMenuPolicy.CustomContextMenu)
            self.page_sdat.layout().addWidget(tree_sdat)
            setattr(self, f"tree_sdat_{i}", tree_sdat)
            self.trees_sdat.append(getattr(self, f"tree_sdat_{i}"))
        self.dropdown_sdat.setCurrentIndex(0)

        for i, sdat in enumerate(self.sdats):
            tree_current: lib.widget.EditorTree = getattr(self, f"tree_sdat_{i}")

            # all sdat sections follow the [(Name, object(data)), ...] format except swar with [(Name, object([object(data), ...])), ...] and groups, which have [(Name, [object(data), ...]), ...]
            item_sseq = QtWidgets.QTreeWidgetItem(["N/A", "Sequenced Music", "SSEQ"]) #SSEQ
            item_ssar = QtWidgets.QTreeWidgetItem(["N/A", "Sequenced Sound Effects", "SSAR"]) #SSAR
            item_sbnk = QtWidgets.QTreeWidgetItem(["N/A", "Sound Banks", "SBNK"]) #SBNK
            item_swar = QtWidgets.QTreeWidgetItem(["N/A", "Sound Waves", "SWAR"]) #SWAR
            item_sseqplayer = QtWidgets.QTreeWidgetItem(["N/A", "Sequence Player", ""]) #plays SSEQ or SSAR
            item_strm = QtWidgets.QTreeWidgetItem(["N/A", "Multi-Channel Stream", "STRM"]) #STRM
            item_strmplayer = QtWidgets.QTreeWidgetItem(["N/A", "Stream Player", ""]) #plays STRM
            item_group = QtWidgets.QTreeWidgetItem(["N/A", "Group", ""])
            item_list = [
                item_sseq,
                item_ssar,
                item_sbnk,
                item_swar,
                item_sseqplayer,
                item_strm,
                item_strmplayer,
                item_group
            ]
            data_list = [
                sdat.sequences,
                sdat.sequenceArchives,
                sdat.banks,
                sdat.waveArchives,
                sdat.sequencePlayers,
                sdat.streams,
                sdat.streamPlayers,
                sdat.groups
            ]
            for category in item_list:
                for section in data_list[item_list.index(category)]:
                    child = QtWidgets.QTreeWidgetItem([str(data_list[item_list.index(category)].index(section)), section[0], category.text(2)])
                    if hasattr(section[1], "bankID"):
                        child.setToolTip(0, "bankID: " + str(section[1].bankID))
                    category.addChild(child)
                    if hasattr(section[1], "sequences"):
                        for sseq_i, sseq in enumerate(section[1].sequences): # actually a list with [name, SSARSequence]
                            subChild = QtWidgets.QTreeWidgetItem([str(sseq_i), sseq[0], "SSARS"])
                            child.addChild(subChild)
                    if hasattr(section[1], "waves"):
                        for wave_i, wave in enumerate(section[1].waves):
                            subChild = QtWidgets.QTreeWidgetItem([str(wave_i), f"{child.text(1)} (Wave {wave_i})", "SWAV"])
                            child.addChild(subChild)
                #progress.setValue(progress.value()+ 100//len(item_list))

            tree_current.addTopLevelItems(item_list)
            tree_current.header().resizeSection(1, 250)
            #progress.setValue(100)
            #progress.close()

    def treeCall(self, addr_reset=False, addr_disabled=False):
        #print("Tree")
        #self.clearTasks()
        sender = self.sender()
        #print(self.sender())
        if sender in self.FILEOPEN_WIDGETS:
            self.fileEdited_object = None # change this into a generic file object
        self.file_content_text.setReadOnly(False)
        self.field_address.setDisabled(addr_disabled)
        QtCore.qInstallMessageHandler(lambda a, b, c: None) # Silence Invalid base warnings from the following code
        for widget in self.findChildren(lib.widget.BetterSpinBox): # update all widgets of same type with current settings
            widget.alphanum = self.displayAlphanumeric
            widget.numbase = self.displayBase
            widget.repaint()
        for widget in self.findChildren(lib.widget.LabeledSpinBox): # update all widgets of same type with current settings
            widget.sb.alphanum = self.displayAlphanumeric
            widget.sb.numbase = self.displayBase
            widget.sb.repaint()
        QtCore.qInstallMessageHandler(None) # Revert to default message handler
        if self.dialog_settings.isVisible() and (self.field_address.numbase != self.displayBase): # handle error manually
            QtWidgets.QMessageBox.critical(
                                self,
                                "Numeric Base Warning!",
                                f"Base is not supported for inputting data in spinboxes.\n This means that all spinboxes will revert to base 10 until they are set to a supported base.\n Proceed at your own risk!"
                                )
        for widget in self.findChildren(QtWidgets.QWidget):
            if not isinstance(widget, QtWidgets.QButtonGroup):
                widget.blockSignals(True) # prevent treeCall from being executed twice in a row. Reduces lag
        self.treeSubCall(addr_reset)
        if sender in self.FILEOPEN_WIDGETS:
            self.file_editor_show(self.widget_set)
            self.button_file_save.setDisabled(True)
        for widget in self.findChildren(QtWidgets.QWidget):
            widget.blockSignals(False) # prevent treeCall from being executed twice in a row. Reduces lag

    def treeSubCall(self, addr_reset):
        sender = self.sender()
        current_item = self.tree.currentItem()
        if current_item != None:
            current_id = int(current_item.text(0))
            current_name = current_item.text(1)
            current_ext  = current_item.text(2)
            if addr_reset:
                self.relative_address = 0
            if sender in self.FILEOPEN_WIDGETS:
                self.fileToEdit_name = str(current_name + "." + current_ext)
                #self.base_address = self.rom.save().index(self.rom.files[current_id]) # find address based on file content. not entirely accurate.
                self.base_address = self.rom_fat[current_id] # load address from a list that already contains the required info to improve performance
                # set text to current ROM address
                #print(self.relative_address)
                self.field_address.setRange(self.base_address, self.base_address+len(self.rom.files[current_id]))
            self.field_address.setValue(self.base_address+self.relative_address)
            if not ".Folder" in self.fileToEdit_name:# if it's a file
                self.label_file_size.setText(f"Size: {lib.datconv.numToStr(len(self.rom.files[current_id]), self.displayBase, self.displayAlphanumeric).zfill(0)} bytes")
                if self.fileDisplayRaw == False:
                    indicator_list = self.gamedat.fileIndicators
                    if self.fileDisplayMode == "Adapt":
                        self.fileDisplayState = "None"
                        if current_ext == "vx":
                            self.fileDisplayState = "VX"
                        elif current_ext == "sdat":
                            self.fileDisplayState = "Sound"
                        elif current_ext == "nbfc":
                            self.fileDisplayState = "Graphics"
                        elif current_ext == "bin":
                            if any(current_name.startswith(indicator) for indicator in indicator_list["Font"]):
                                self.fileDisplayState = "Font"
                            elif any(current_name.startswith(indicator) for indicator in indicator_list["Dialogue"]):
                                self.fileDisplayState = "Dialogue"
                            elif any(indicator in current_name for indicator in indicator_list["Graphics"]) and current_name.find("_dat") == -1:
                                self.fileDisplayState = "Graphics"
                            elif any(indicator in current_name for indicator in indicator_list["Model"]):
                                self.fileDisplayState = "Model"
                            elif any(indicator.replace("fnt", "dat") in current_name for indicator in indicator_list["Graphics"]):
                                self.fileDisplayState = "OAM"
                            elif any(indicator in current_name for indicator in indicator_list["Palette Animation"]):
                                self.fileDisplayState = "Palette Animation"
                    else:
                        self.fileDisplayState = self.fileDisplayMode

                    self.file_content_text.setLineWrapMode(lib.widget.LongTextEdit.LineWrapMode.WidgetWidth)
                    if self.fileDisplayState == "Dialogue":
                        self.widget_set = "Text"
                        if sender in self.FILEOPEN_WIDGETS:
                            dialogue_lang = current_name.split("_")[-1][:2] # get the two letters that indicate language
                            try:
                                self.file_content_text.charmap = self.gamedat.charmaps[dialogue_lang]
                            except KeyError:
                                self.file_content_text.charmap = lib.dialogue.CharMap()
                            self.dropdown_textindex.setEnabled(True)
                            self.dropdown_textindex.clear()
                            try:
                                self.fileEdited_object = lib.dialogue.DialogueFile(self.rom.files[current_id], self.file_content_text.charmap)
                            except AssertionError: # forcing text view on non-text file = simple conversion mode
                                self.file_content_text.setEnabled(True)
                                self.dropdown_textindex.setDisabled(True)
                                self.fileEdited_object = lib.dialogue.DialogueFile.binToText(self.rom.files[current_id][self.relative_address:self.relative_address+0x1FFF], self.file_content_text.charmap)
                                self.file_content_text.setPlainText(self.fileEdited_object)
                                return
                            for i in range(len(self.fileEdited_object.text_list)):
                                self.dropdown_textindex.addItem(f"message {i}")
                            self.dropdown_textindex.previousIndex = self.dropdown_textindex.currentIndex()
                        elif self.dropdown_textindex.isEnabled(): # when text index changed
                            #print(f"index = {self.dropdown_textindex.currentIndex()} prev = {self.dropdown_textindex.previousIndex}")
                            if self.button_file_save.isEnabled(): # if content was modified
                                self.fileEdited_object.text_list[self.dropdown_textindex.previousIndex] = self.file_content_text.toPlainText() # keep changes to text on previous index
                                self.dropdown_textindex.previousIndex = self.dropdown_textindex.currentIndex()
                        else: # simple conversion mode during address change
                            self.fileEdited_object = lib.dialogue.DialogueFile.binToText(self.rom.files[current_id][self.relative_address:self.relative_address+0x1FFF], self.file_content_text.charmap)
                            self.file_content_text.setPlainText(self.fileEdited_object)
                            return
                        textIndex = self.dropdown_textindex.currentIndex()

                        if self.fileEdited_object.text_list != []:
                            self.relative_address = self.fileEdited_object.textAddress_list[textIndex]
                            self.field_address.setValue(self.base_address+self.relative_address)
                            self.field_address.setDisabled(True)
                            self.file_content_text.setPlainText(self.fileEdited_object.text_list[textIndex])
                        else:
                            self.file_content_text.setPlainText("")
                            self.file_content_text.setReadOnly(True)
                    elif self.fileDisplayState == "Graphics":
                        self.widget_set = "Graphics"
                        if sender in self.FILEOPEN_WIDGETS:
                            self.layout_colorpick.rearrange(16, 16)
                            # reset from viewing font
                            self.tile_width = self.field_tile_width.value()
                            self.tile_height = self.field_tile_height.value()
                            if any(indicator in current_name for indicator in indicator_list["Mugshot"]): # for convenience
                                self.tiles_per_column = 7
                                self.tiles_per_row = 6
                                self.field_tiles_per_column.setValue(self.tiles_per_column)
                                self.field_tiles_per_row.setValue(self.tiles_per_row)
                            elif "dm" in current_name:
                                self.tiles_per_row = 0x20
                                self.field_tiles_per_row.setValue(self.tiles_per_row)
                                self.dropdown_gfx_depth.setCurrentIndex(2)
                                self.setPalette(self.GFX_PALETTES[3])
                            if current_ext == "nbfc":
                                try:
                                    pal = self.rom.getFileByName(current_name+".nbfp")
                                    self.setPalette(lib.datconv.BGR15_to_ARGB32(pal))
                                except:
                                    pass
                            self.dropdown_gfx_index.clear()
                            self.dropdown_gfx_subindex.clear()
                            try: # obj_fnt.bin
                                self.fileEdited_object = lib.graphic.File(self.rom.files[current_id])
                                for i in range(len(self.fileEdited_object.address_list)):
                                    self.dropdown_gfx_index.addItem(f"entry {i}")
                                self.dropdown_gfx_index.setCurrentIndex(0)
                            except AssertionError:
                                try: # face.bin and some other files
                                    self.fileEdited_object = lib.graphic.GraphicSection(self.rom.files[current_id])
                                except AssertionError:
                                    print("failed to load graphic entry table!")
                                    self.fileEdited_object = None
                        if self.fileEdited_object != None:
                            self.file_content_gfx.resetScene()
                            self.button_file_save.setDisabled(True)
                            self.dropdown_gfx_depth.setDisabled(True)
                            self.field_address.setDisabled(True)
                            self.dropdown_gfx_palette.setDisabled(True)
                            self.field_tile_height.setDisabled(True)
                            self.field_tile_width.setDisabled(True)
                            self.field_tiles_per_row.setDisabled(True)
                            self.field_tiles_per_column.setDisabled(True)
                            if isinstance(self.fileEdited_object, lib.graphic.File):
                                try:
                                    gfxsec = lib.graphic.GraphicSection.fromParent(self.fileEdited_object, self.dropdown_gfx_index.currentIndex())
                                except AssertionError:
                                    print(f"failed to load graphic section at index {self.dropdown_gfx_index.currentIndex()}!")
                                    self.dropdown_gfx_subindex.clear()
                                    return
                            elif isinstance(self.fileEdited_object, lib.graphic.GraphicSection):
                                gfxsec = self.fileEdited_object
                            if sender == self.dropdown_gfx_index or sender in self.FILEOPEN_WIDGETS: # if graphic section changed, reload header list
                                self.dropdown_gfx_subindex.clear()
                                for i in range(gfxsec.entryCount):
                                    self.dropdown_gfx_subindex.addItem(f"image {i}")
                                self.dropdown_gfx_subindex.setCurrentIndex(0)
                            if self.dropdown_gfx_subindex.count() > 0:
                                if sender == self.dropdown_gfx_index or sender == self.dropdown_gfx_subindex or sender in self.FILEOPEN_WIDGETS or sender == self.checkbox_depthUpdate:
                                    header_index = self.dropdown_gfx_subindex.currentIndex()
                                    gfx_current = gfxsec.graphics[header_index]
                                    if self.checkbox_depthUpdate.isChecked() and gfxsec.entry_size == 0x14:
                                        if gfx_current.depth//2 == 4:
                                            self.dropdown_gfx_depth.setCurrentIndex(1)
                                            if gfxsec.entry_size == 0x14 and gfx_current.unk13 & 0x0f:
                                                print("wrong depth guess(?)")
                                        elif gfx_current.depth//2 == 8:
                                            self.dropdown_gfx_depth.setCurrentIndex(2)
                                        else: # this should now be impossible
                                            print(f"unrecognized depth {gfx_current.depth}")
                                            self.dropdown_gfx_depth.setCurrentIndex(1)
                                    gfxOffset = gfx_current.offset_start + gfx_current.gfx_offset
                                    gfxSize = gfx_current.gfx_size
                                    self.relative_address = gfxOffset
                                    self.field_address.setRange(self.base_address+gfxOffset, self.base_address + gfxOffset+gfxSize)
                                    self.field_address.setValue(self.base_address+self.relative_address)
                                    if gfxSize <= 0:
                                        print("There is no image to load.")
                                        return
                                    print(f"{gfxsec.entryCount} sub-entrie(s)")
                                    print(f"size: {gfxSize:02X}")
                                    if hasattr(gfx_current, "oam_tile_indexing"):
                                        print(f"oam_tile_indexing: {gfx_current.oam_tile_indexing:02X}")
                                    if hasattr(gfx_current, "oam_tile_offset"):
                                        print(f"oam tile offset: {gfx_current.oam_tile_offset:02X}")
                                    if hasattr(gfx_current, "unk08"):
                                        print(f"unk08: {gfx_current.unk08:02X}")
                                    if hasattr(gfx_current, "unk09"):
                                        print(f"unk09: {gfx_current.unk09:02X}")
                                    if gfxsec.entry_size == 0x14:
                                        pal_off = gfx_current.offset_start + gfx_current.palette_offset+0xc
                                        pal_skip = (gfx_current.unk13 & 0xf0)
                                        pal = [0xffffffff]*pal_skip # shift palette
                                        pal.extend(lib.datconv.BGR15_to_ARGB32(self.rom.files[current_id][pal_off:pal_off+gfx_current.palette_size]))
                                        print(f"unk13 & 0F: {gfx_current.unk13 & 0x0f:02X}")
                                    else:
                                        pal_skip = 0
                                        pal = [] # empty palette because idk where it is
                                    self.setPalette(pal, pal_skip)
                            else:
                                print(f"{gfxsec.entryCount} graphic sub-entries!")
                                #print(f"data: {gfxsec.data.hex()}")

                        depth_obj = list(lib.datconv.CompressionAlgorithmEnum)[self.dropdown_gfx_depth.currentIndex()]
                        #print(self.dropdown_gfx_depth.currentText()[:1] + " bpp graphics")
                        # since the pen is in grayscale, we can use r, g or b as color index
                        if self.file_content_gfx.pen.color().blue() >= 2**depth_obj.depth: # if color out of range
                            self.file_content_gfx.pen.setColor(0x00010101) # set to first color
                        tile_size = int((self.tile_width*self.tile_height)*depth_obj.depth/8)
                        view_size = tile_size*self.tiles_per_row*self.tiles_per_column
                        gfx_viewed = self.rom.files[current_id][self.relative_address:max(self.field_address.maximum()-self.base_address,self.relative_address+view_size)]
                        if len(gfx_viewed) > 0:
                            try:
                                gfx_viewed = ndspy.lz10.decompress(gfx_viewed)
                                print("this image is compressed")
                            except Exception:
                                pass
                        else:
                            print("no graphic data to process! This address is most likely invalid.")
                            return
                        self.draw_tilesQImage_fromBytes(self.file_content_gfx,
                                                   gfx_viewed,
                                                   algorithm=depth_obj,
                                                   grid=True)
                        self.dropdown_gfx_depth.setDisabled(False)
                        self.field_address.setDisabled(False)
                        self.dropdown_gfx_palette.setDisabled(False)
                        self.field_tile_height.setDisabled(False)
                        self.field_tile_width.setDisabled(False)
                        self.field_tiles_per_row.setDisabled(False)
                        self.field_tiles_per_column.setDisabled(False)
                    elif self.fileDisplayState == "OAM":
                        self.widget_set = "OAM"
                        if sender in self.FILEOPEN_WIDGETS:
                            self.field_address.setDisabled(True)
                            self.fileEdited_object = lib.oam.File(self.rom.files[current_id])
                            self.fileEdited_object.auxfile = lib.graphic.File(self.rom.getFileByName(current_name.replace("dat", "fnt")+".bin"))
                            self.fileEdited_object.objs = []
                            self.dropdown_oam_entry.clear()
                            for i in range(self.fileEdited_object.entryCount):
                                self.dropdown_oam_entry.addItem(f"entry {i}")
                            self.dropdown_oam_entry.setCurrentIndex(0)
                        #print(f"{:02X}")
                        #print(oamsec.data[oamsec.frameTable_offset:oamsec.frameTable_offset+0x04].hex())
                        if sender in [self.dropdown_oam_entry, *self.FILEOPEN_WIDGETS]:
                            self.fileEdited_object.oamsec = lib.oam.OAMSection(
                                self.fileEdited_object,
                                self.dropdown_oam_entry.currentIndex() if self.dropdown_oam_entry.currentIndex() != -1 else 0
                            )
                            self.fileEdited_object.gfxsec = lib.graphic.GraphicSection.fromParent(
                                self.fileEdited_object.auxfile,
                                self.dropdown_oam_entry.currentIndex() if self.dropdown_oam_entry.currentIndex() != -1 else 0
                            )
                            print(f"offset: {self.fileEdited_object.oamsec.offset_start:02X}")
                            print(f"header items: {[f"{header_item:02X}" for header_item in self.fileEdited_object.oamsec.header_items]}")

                            self.dropdown_oam_anim.clear()
                            for i in range(len(self.fileEdited_object.oamsec.animTable)):
                                self.dropdown_oam_anim.addItem(f"animation {i}")
                            self.dropdown_oam_anim.setCurrentIndex(0)

                            self.dropdown_oam_objFrame.clear()
                            if len(self.fileEdited_object.oamsec.frameTable) > 0:
                                for i in range(len(self.fileEdited_object.oamsec.frameTable)):
                                    self.dropdown_oam_objFrame.addItem(f"frame {i}")
                                self.dropdown_oam_objFrame.setCurrentIndex(0)
                        if sender in [self.dropdown_oam_entry, self.dropdown_oam_anim, *self.FILEOPEN_WIDGETS]:
                            self.fileEdited_object.oamsec_anim = lib.oam.Animation.fromParent(self.fileEdited_object.oamsec, self.dropdown_oam_anim.currentIndex())
                            self.checkbox_oam_animLoop.setChecked(self.fileEdited_object.oamsec_anim.isLooping)
                            self.field_oam_animLoopStart.setEnabled(self.fileEdited_object.oamsec_anim.isLooping)
                            self.button_oam_animPlay.autoPause()
                            if self.fileEdited_object.oamsec_anim.isLooping:
                                self.field_oam_animLoopStart.setValue(self.fileEdited_object.oamsec_anim.loopStart)
                            else:
                                self.field_oam_animLoopStart.setValue(0)
                            self.dropdown_oam_animFrame.clear()
                            if len(self.fileEdited_object.oamsec_anim.frames) > 0:
                                for i in range(len(self.fileEdited_object.oamsec_anim.frames)-1):
                                    self.dropdown_oam_animFrame.addItem(f"frame {i}")
                                self.dropdown_oam_animFrame.previousIndex = 0
                                self.dropdown_oam_animFrame.setCurrentIndex(0)
                            else:
                                self.dropdown_oam_animFrame.previousIndex = -1
                        
                        if sender == self.button_oam_animFrameAdd:
                            self.button_file_save.setEnabled(True)
                            self.fileEdited_object.oamsec_anim.frames.insert(self.dropdown_oam_animFrame.currentIndex()+1, [0,1])
                            self.dropdown_oam_animFrame.addItem(f"frame {self.dropdown_oam_animFrame.count()}")
                            self.dropdown_oam_animFrame.setCurrentIndex(self.dropdown_oam_animFrame.currentIndex()+1)

                        if sender == self.button_oam_animFrameRemove:
                            if self.dropdown_oam_animFrame.count() == 0: return
                            self.button_file_save.setEnabled(True)
                            self.fileEdited_object.oamsec_anim.frames.pop(self.dropdown_oam_animFrame.currentIndex())
                            self.dropdown_oam_animFrame.removeItem(self.dropdown_oam_animFrame.count()-1)

                        if sender in [self.button_oam_animFrameAdd, self.button_oam_animFrameRemove, self.dropdown_oam_animFrame, self.dropdown_oam_entry, self.dropdown_oam_anim, *self.FILEOPEN_WIDGETS]:
                            if self.dropdown_oam_animFrame.count() == 0:
                                self.field_oam_animFrameId.setValue(0)
                                self.field_oam_animFrameDuration.setValue(0)
                            else:
                                if sender is not self.button_oam_animFrameRemove and (self.dropdown_oam_animFrame.previousIndex != self.dropdown_oam_animFrame.currentIndex() and self.button_file_save.isEnabled()):
                                    isDurationfix = self.dropdown_oam_animFrame.previousIndex > 0 and self.field_oam_animFrameDuration.value() >= 0xFE
                                    if isDurationfix:
                                        if self.field_oam_animFrameDuration.value() == 0xFE:
                                            self.field_oam_animFrameId.setValue(self.dropdown_oam_animFrame.previousIndex) # loop to current index neutralizes the loop
                                        elif self.field_oam_animFrameDuration.value() == 0xFF:
                                            self.field_oam_animFrameDuration.setValue(0)
                                    self.fileEdited_object.oamsec_anim.frames[self.dropdown_oam_animFrame.previousIndex] = [
                                        self.field_oam_animFrameId.value(),
                                        self.field_oam_animFrameDuration.value()]
                                self.field_oam_animFrameId.setValue(self.fileEdited_object.oamsec_anim.frames[self.dropdown_oam_animFrame.currentIndex()][0])
                                self.field_oam_animFrameDuration.setValue(self.fileEdited_object.oamsec_anim.frames[self.dropdown_oam_animFrame.currentIndex()][1])
                                self.dropdown_oam_animFrame.previousIndex = self.dropdown_oam_animFrame.currentIndex()
                        
                        frame_current = []
                        if len(self.fileEdited_object.oamsec.frameTable) > 0:
                            try:
                                if self.tabs_oam.currentWidget() == self.page_oam_frames:
                                    self.fileEdited_object.frameIndex = self.dropdown_oam_objFrame.currentIndex() if self.dropdown_oam_objFrame.currentIndex() != -1 else 0   
                                elif self.tabs_oam.currentWidget() == self.page_oam_anims:
                                    self.fileEdited_object.frameIndex = self.field_oam_animFrameId.value() if self.field_oam_animFrameId.isEnabled() else 0
                                frame_current = self.fileEdited_object.oamsec.frameTable[self.fileEdited_object.frameIndex]
                                #print(f"section id: {frame_current[2]}")
                            except IndexError:
                                print(f"invalid frame!\nanim: {self.dropdown_oam_anim.currentIndex()}\nframe:{self.dropdown_oam_objFrame.currentIndex()}")
                        if frame_current != []:
                            if sender in [self.dropdown_oam_entry, self.dropdown_oam_anim, self.dropdown_oam_animFrame, self.field_oam_animFrameId,
                                          self.button_oam_animFrameAdd, self.button_oam_animFrameRemove, 
                                          self.dropdown_oam_objFrame, self.tabs_oam, self.button_reload, *self.FILEOPEN_WIDGETS]:
                                self.file_content_oam.scene().clear()
                                OAMRect = QtCore.QRectF(-128, -128, 256, 256)
                                crosshairPen = QtGui.QPen()
                                crosshairPen.setWidthF(0.05) # extra thin line
                                self.file_content_oam.scene().addRect(OAMRect)
                                self.file_content_oam.scene().addLine(OAMRect.left(), 0, OAMRect.right(), 0, crosshairPen)
                                self.file_content_oam.scene().addLine(0, OAMRect.top(), 0, OAMRect.bottom(), crosshairPen)
                                if not isinstance(sender, lib.widget.BetterSpinBox) and sender not in [
                                    self.button_oam_animFrameAdd, self.button_oam_animFrameRemove, self.dropdown_oam_animFrame]:
                                    self.button_file_save.setDisabled(True)
                                self.fileEdited_object.objs.clear()
                                self.dropdown_oam_obj.clear()
                                #print("start")
                                frame_result = self.OAM_processFrame(
                                    self.fileEdited_object.oamsec,
                                    self.fileEdited_object.frameIndex,
                                    self.fileEdited_object.gfxsec
                                )
                                self.fileEdited_object.objs = frame_result["objs"]
                                if len(frame_result["items"]) > 0:
                                    self.file_content_oam.item_current = frame_result["items"][0]
                                if frame_result["is3D"]:
                                    self.field_objTileId.setMaximum(0xFFFF)
                                    self.slider_objSizeIndex.hide()
                                    self.group_oam_objShape.hide()
                                    self.slider_obj3DHeightIndex.show()
                                    self.slider_obj3DTileWidth.show()
                                else:
                                    self.field_objTileId.setMaximum(0x3FF)
                                    self.slider_obj3DHeightIndex.hide()
                                    self.slider_obj3DTileWidth.hide()
                                    self.slider_objSizeIndex.show()
                                    self.group_oam_objShape.show()
                                for obj_item in frame_result["items"]:
                                    self.file_content_oam.scene().addItem(obj_item)

                                if sender == self.dropdown_oam_entry:
                                    self.file_content_oam.fitInView2()
                                self.dropdown_oam_obj.previousIndex = 0
                                self.dropdown_oam_obj.setCurrentIndex(0)

                            if sender == self.button_oam_objAdd:
                                if self.dropdown_oam_obj.count() > 128: return
                                self.button_file_save.setEnabled(True)
                                self.fileEdited_object.objs.insert(self.dropdown_oam_obj.currentIndex()+1, lib.oam.Object())
                                for item in self.file_content_oam.scene().items():
                                    if isinstance(item, lib.widget.OAMObjectItem) and item.obj_id > self.dropdown_oam_obj.currentIndex():
                                        item.obj_id += 1
                                        item.setZValue(-item.obj_id) # update depth
                                self.file_content_oam.scene().addItem(self.OAM_updateItemGFX(self.dropdown_oam_obj.currentIndex()+1))
                                self.dropdown_oam_obj.addItem(f"object {self.dropdown_oam_obj.count()}")
                                self.dropdown_oam_obj.setCurrentIndex(self.dropdown_oam_obj.currentIndex()+1)
                                
                            if sender == self.button_oam_objRemove:
                                if self.dropdown_oam_obj.count() == 0: return
                                self.button_file_save.setEnabled(True)
                                self.fileEdited_object.objs.pop(self.dropdown_oam_obj.currentIndex())
                                for item in self.file_content_oam.scene().items():
                                    if isinstance(item, lib.widget.OAMObjectItem) and item.obj_id == self.dropdown_oam_obj.currentIndex():
                                        self.file_content_oam.scene().removeItem(item)
                                for item in self.file_content_oam.scene().items():
                                    if isinstance(item, lib.widget.OAMObjectItem) and item.obj_id > self.dropdown_oam_obj.currentIndex():
                                        item.obj_id -= 1
                                        item.setZValue(-item.obj_id) # update depth
                                self.dropdown_oam_obj.removeItem(self.dropdown_oam_obj.count()-1)

                            if sender in [self.button_oam_objAdd, self.button_oam_objRemove, self.dropdown_oam_obj, self.dropdown_oam_entry, self.dropdown_oam_objFrame, self.tabs_oam, self.file_content_oam.scene(), *self.FILEOPEN_WIDGETS]:
                                #print(f"{frame[0]:02X}")
                                #print(f"frame: {self.dropdown_oam_objFrame.currentIndex()}")
                                if self.tabs_oam.currentWidget()!=self.page_oam_frames:return
                                if self.dropdown_oam_obj.currentIndex() == -1: return
                                if sender is not self.button_oam_objRemove and self.dropdown_oam_obj.previousIndex != self.dropdown_oam_obj.currentIndex() and self.button_file_save.isEnabled(): # save state of previous object
                                    obj_prev = self.fileEdited_object.objs[self.dropdown_oam_obj.previousIndex]
                                    obj_prev.tileId = self.field_objTileId.value()
                                    obj_prev.flip_h = self.checkbox_objFlipH.isChecked()
                                    obj_prev.flip_v = self.checkbox_objFlipV.isChecked()
                                    if isinstance(obj_prev, lib.oam.Object3D):
                                        obj_prev.heightIndex = self.slider_obj3DHeightIndex.sl.value()
                                        obj_prev.tile_width_index = self.slider_obj3DTileWidth.sl.value()
                                    else:
                                        obj_prev.sizeIndex = self.slider_objSizeIndex.sl.value()
                                        obj_prev.shape = self.buttonGroup_oam_objShape.checkedId()
                                    obj_prev.x = self.field_objX.value()
                                    obj_prev.y = self.field_objY.value()
                                offset = self.fileEdited_object.oamsec.frameTable_offset + frame_current[0] + self.dropdown_oam_obj.currentIndex()*0x04
                                self.relative_address = self.fileEdited_object.address_list[self.dropdown_oam_entry.currentIndex()][0] + offset
                                self.field_address.setValue(self.relative_address + self.base_address)
                                obj = self.fileEdited_object.objs[self.dropdown_oam_obj.currentIndex()]#lib.oam.Object(oamsec.data[offset:offset+0x04])
                                self.dropdown_oam_obj.previousIndex = self.dropdown_oam_obj.currentIndex()
                                self.field_objTileId.setValue(obj.tileId)
                                self.checkbox_objFlipH.setChecked(obj.flip_h)
                                self.checkbox_objFlipV.setChecked(obj.flip_v)
                                if isinstance(obj, lib.oam.Object3D):
                                    self.slider_obj3DHeightIndex.sl.setValue(obj.heightIndex)
                                    self.slider_obj3DTileWidth.sl.setValue(obj.tile_width_index)
                                else:
                                    self.slider_objSizeIndex.sl.setValue(obj.sizeIndex)
                                    self.group_oam_objShape.findChildren(QtWidgets.QRadioButton)[obj.shape].setChecked(True)
                                    self.slider_objSizeIndex.setLabels(lib.oam.SPRITE_DIMENSIONS[self.buttonGroup_oam_objShape.checkedId()])
                                self.field_objX.setValue(obj.x)
                                self.field_objY.setValue(obj.y)
                            if sender in [self.button_oam_objAdd, self.button_oam_objRemove, self.dropdown_oam_obj, self.button_oam_objSelect]:
                                for item in self.file_content_oam.scene().items():
                                    if isinstance(item, lib.widget.OAMObjectItem):
                                        item.setSelected(item.obj_id == self.dropdown_oam_obj.currentIndex())
                        else:
                            print("empty frame!", self.fileEdited_object.oamsec.frameTable)
                    elif self.fileDisplayState == "Palette Animation":
                        self.widget_set = "PAnm"
                        if sender in self.FILEOPEN_WIDGETS:
                            self.fileEdited_object = lib.panim.File(self.rom.files[current_id])
                            self.dropdown_gfx_depth.setCurrentIndex(1)
                            self.dropdown_panm_oamEntry.clear()
                            for i in range(lib.oam.File(self.rom.getFileByName("obj_dat.bin")).entryCount):
                                self.dropdown_panm_oamEntry.addItem("oam entry "+str(i))
                            self.dropdown_panm_oamEntry.setCurrentIndex(0)
                            self.dropdown_panm_entry.clear()
                            for i in range(self.fileEdited_object.animCount):
                                self.dropdown_panm_entry.addItem("palette animation "+str(i))
                            self.dropdown_panm_entry.setCurrentIndex(0)
                            self.dropdown_panm_entry.previousIndex = 0
                        anim_current = self.fileEdited_object.anims[self.dropdown_panm_entry.currentIndex()]
                        palette_current = self.fileEdited_object.palettes[self.dropdown_panm_entry.currentIndex()]
                        if sender in [self.dropdown_panm_entry, *self.FILEOPEN_WIDGETS]:
                            self.layout_colorpick.rearrange(2, len(palette_current.colorTable)) # rearrange palette button layout for this mode
                            if self.button_file_save.isEnabled():
                                self.fileEdited_object.anims[self.dropdown_panm_entry.previousIndex].isLooping = self.checkbox_panm_loop.isChecked()
                                self.fileEdited_object.anims[self.dropdown_panm_entry.previousIndex].loopStart = self.field_panm_loopStart.value()
                                self.fileEdited_object.palettes[self.dropdown_panm_entry.previousIndex].colorSlot0 = self.field_panm_colorSlot0.value()
                                self.fileEdited_object.palettes[self.dropdown_panm_entry.previousIndex].colorSlot1 = self.field_panm_colorSlot1.value()
                            self.dropdown_panm_frame.clear()
                            for i in range(len(self.fileEdited_object.anims[self.dropdown_panm_entry.currentIndex()].frames)-1):
                                self.dropdown_panm_frame.addItem("frame "+str(i))
                            self.dropdown_panm_frame.setCurrentIndex(0)
                            self.setPalette([color for group in self.fileEdited_object.palettes[self.dropdown_panm_entry.currentIndex()].colorTable for color in group])
                            self.checkbox_panm_loop.setChecked(anim_current.isLooping)
                            self.field_panm_loopStart.setValue(anim_current.loopStart)
                            self.field_panm_colorSlot0.setValue(palette_current.colorSlot0)
                            self.field_panm_colorSlot1.setValue(palette_current.colorSlot1)
                        if sender in [self.dropdown_panm_frame, self.dropdown_panm_entry, self.dropdown_panm_oamEntry, *self.FILEOPEN_WIDGETS]:
                            frame_current = anim_current.frames[self.dropdown_panm_frame.currentIndex()]
                            if self.button_file_save.isEnabled():
                                self.fileEdited_object.anims[self.dropdown_panm_entry.previousIndex].frames[self.dropdown_panm_frame.previousIndex]\
                                = [self.field_panm_frameId.value(), self.field_panm_frameDuration.value()]
                            self.field_panm_frameId.setValue(frame_current[0])
                            self.field_panm_frameDuration.setValue(frame_current[1])
                            # load some object to preview palette effects
                            palette_preview = [None]*16
                            palette_preview[palette_current.colorSlot0] = self.gfx_palette[frame_current[0]*2]
                            palette_preview[palette_current.colorSlot1] = self.gfx_palette[frame_current[0]*2+1]
                            frame_result = self.OAM_processFrame(["obj_dat.bin", self.dropdown_panm_oamEntry.currentIndex()], 0, palette=palette_preview)["items"]
                            self.gfx_scene_panm.scene().clear()
                            OAMRect = QtCore.QRectF(-128, -128, 256, 256)
                            self.gfx_scene_panm.scene().addRect(OAMRect)
                            for item in frame_result:
                                self.gfx_scene_panm.scene().addItem(item)
                            if sender is not self.dropdown_panm_frame:
                                self.gfx_scene_panm.fitInView2(False)
                            self.dropdown_panm_frame.previousIndex = self.dropdown_panm_frame.currentIndex()
                            if sender == self.dropdown_panm_entry:
                                self.dropdown_panm_entry.previousIndex = self.dropdown_panm_entry.currentIndex()
                    elif self.fileDisplayState == "Font":
                        self.widget_set = "Font"
                        if sender in self.FILEOPEN_WIDGETS:
                            self.layout_colorpick.rearrange(2, 1)
                            self.dropdown_gfx_depth.setCurrentIndex(0)
                            self.fileEdited_object = lib.font.Font(self.rom.files[current_id])
                            self.relative_address = self.fileEdited_object.CHR_ADDRESS
                            self.field_font_size.setValue(self.fileEdited_object.file_size)
                            self.field_font_width.setValue(self.fileEdited_object.char_width)
                            self.field_font_height.setValue(self.fileEdited_object.char_height)
                            self.label_font_indexingSpace.setText("indexing space: " + lib.datconv.numToStr(self.fileEdited_object.indexing_space, self.displayBase, self.displayAlphanumeric))
                            self.label_font_charCount.setText("char count: " + lib.datconv.numToStr(self.fileEdited_object.char_count, self.displayBase, self.displayAlphanumeric))
                            self.label_font_unusedStr.setText("unused string: " + self.fileEdited_object.unused_string)
                            self.setPalette(self.GFX_PALETTES[1])
                            self.field_address.setMinimum(self.base_address+self.fileEdited_object.CHR_ADDRESS)
                        self.file_content_gfx.resetScene()
                        self.tile_width = math.ceil(self.field_font_width.value()/8)*8
                        self.tile_height = self.field_font_height.value()
                        self.draw_tilesQImage_fromBytes(self.file_content_gfx,
                                                   self.rom.files[current_id][self.relative_address:self.relative_address+self.fileEdited_object.file_size],
                                                   algorithm=list(lib.datconv.CompressionAlgorithmEnum)[self.dropdown_gfx_depth.currentIndex()],
                                                   grid=True)
                    elif self.fileDisplayState == "Sound":
                        self.widget_set = "Empty" # placeholder
                        #self.widget_set = "Sound"
                        self.file_content_text.setReadOnly(True)
                        self.file_content_text.setPlainText("Sound editor is not yet implemented.\n Right click on this file > open Sound Archive\nor click on the sound icon in the toolbar to open sound archive viewer.")
                        self.field_address.setDisabled(True)
                    elif self.fileDisplayState == "VX":
                        self.widget_set = "VX"
                        self.field_address.setDisabled(True)
                        if sender in self.FILEOPEN_WIDGETS:
                            self.fileEdited_object = lib.act.ActImagine()
                            self.fileEdited_object.load_vx(self.rom.files[current_id])
                            #print(self.rom.files[current_id][5:6].hex()+self.rom.files[current_id][4:5].hex())
                            self.field_vxHeader_length.setValue(self.fileEdited_object.frames_qty)
                            self.field_vxHeader_width.setValue(self.fileEdited_object.frame_width)
                            self.field_vxHeader_height.setValue(self.fileEdited_object.frame_height)
                            self.field_vxHeader_framerate.setValue(self.fileEdited_object.frame_rate)
                            self.field_vxHeader_quantizer.setValue(self.fileEdited_object.quantizer)
                            self.field_vxHeader_sampleRate.setValue(self.fileEdited_object.audio_sample_rate)
                            self.field_vxHeader_streamCount.setValue(self.fileEdited_object.audio_streams_qty)
                            self.field_vxHeader_frameSizeMax.setValue(self.fileEdited_object.frame_data_size_max)
                            self.field_vxHeader_audioExtraDataOffset.setValue(self.fileEdited_object.audio_extradata_offset)
                            self.field_vxHeader_seekTableOffset.setValue(self.fileEdited_object.seek_table_offset)
                            self.field_vxHeader_seekTableEntryCount.setValue(self.fileEdited_object.seek_table_entries_qty)
                    elif self.fileDisplayState == "Model":
                        self.widget_set = "Model"
                        self.file_content_model.setFocus()
                        self.field_address.setDisabled(True)
                        if sender in self.FILEOPEN_WIDGETS:
                            self.fileEdited_object = lib.model.File(self.rom.files[current_id])
                            self.dropdown_model_entry.clear()
                            for i in range(self.fileEdited_object.entryCount):
                                self.dropdown_model_entry.addItem(f"model {i}")
                        model = lib.model.ModelHeader(self.fileEdited_object.data[self.fileEdited_object.address_list[self.dropdown_model_entry.currentIndex()][0]:])
                        if sender in [self.dropdown_model_entry, *self.FILEOPEN_WIDGETS]:
                            self.dropdown_model_geometry.clear()
                            for g in model.geometries:
                                self.dropdown_model_geometry.addItem(g.name)
                        if sender in [self.dropdown_model_geometry, self.dropdown_model_entry, *self.FILEOPEN_WIDGETS]:
                            gheader = model.geometries[self.dropdown_model_geometry.currentIndex()]
                            geometry = lib.model.Geometry(model.data[gheader.geometry_offset:gheader.geometry_offset+gheader.geometry_size])
                            if self.file_content_model.isUsable:
                                self.file_content_model.loadModel(geometry.commands, geometry.params)
                    else:
                        self.widget_set = "Empty"
                        self.field_address.setDisabled(True)
                        self.file_content_text.setReadOnly(True)
                        if self.fileDisplayState == "None":
                            file_knowledge = "unknown"
                        else:
                            file_knowledge = "not supported at the moment"
                        self.file_content_text.setPlainText(f"This file's format is {file_knowledge}.\n Go to [View > Converted formats] to disable file interpretation and view hex data.")
                else:# if in hex display mode
                    self.widget_set = "Hex"
                    #hex_string = self.rom.files[current_id][self.relative_address:self.relative_address+self.file_content_text.page_charcount()].hex()
                    hex_string = ""
                    for i in range(0, self.file_content_text.page_linecount()*0x10):
                        if i > 0 and i % 0x10 == 0:
                            hex_string += "\n"
                        hex_string += self.rom.files[current_id][self.relative_address+i:self.relative_address+i+1].hex()
                        hex_string += " "
                    self.file_content_text.setLineWrapMode(lib.widget.LongTextEdit.LineWrapMode.NoWrap)
                    self.file_content_text.setPlainText(hex_string)
                self.file_content_text.setDisabled(False)
            else:# if it's a folder
                self.widget_set = "Empty"
                self.label_file_size.setText(f"Size: N/A")
                self.field_address.setDisabled(True)
                self.file_content_text.setPlainText("")
                self.file_content_text.setDisabled(True)
            # code that applies to any item
            self.exportAction.setDisabled(False)
            self.replaceAction.setDisabled(False)
        else:# Nothing is selected, reset edit space
            self.widget_set = "Empty"
            self.field_address.setDisabled(True)
            self.label_file_size.setText("Size: N/A")
            self.file_content_text.clear()
            self.file_content_text.setDisabled(True)
            self.exportAction.setDisabled(True)
            self.replaceAction.setDisabled(True)

    def loadDialogueName(self):
        self.button_dialogueNames_save.setDisabled(True)
        index = self.dropdown_dialogueNames.currentIndex()
        self.textEdit_dialogueNames.blockSignals(True)
        if index == -1:
            self.textEdit_dialogueNames.clear()
            return
        arm9_data = self.arm9_decompressed.save()
        addr = self.gamedat.arm9Addrs["dialogue names " + self.dropdown_dialogueNames_lang.currentText()]
        name = arm9_data[addr+index*0x0C:addr+index*0x0C+0x0C]
        self.textEdit_dialogueNames.charmap = self.gamedat.charmaps["names "+self.dropdown_dialogueNames_lang.currentText()]
        self.textEdit_dialogueNames.setPlainText(lib.dialogue.DialogueFile.binToText(name, self.textEdit_dialogueNames.charmap))
        self.textEdit_dialogueNames.blockSignals(False)

    def loadTileProperties(self):
        if not self.gfx_scene_tileset.scene().isActive(): return
        if len(self.gfx_scene_tileset.scene().selectedItems()) == 0:
            for i in range(self.layout_metaTile_properties.count()):
                layout = self.layout_metaTile_properties.itemAt(i)
                if isinstance(layout, QtWidgets.QLayout):
                    for j in range(layout.count()):
                        layout.itemAt(j).widget().setDisabled(True)
            return
        level = self.levelEdited_object.levels[self.dropdown_level_type.currentIndex()]
        for i in range(self.layout_metaTile_properties.count()):
            layout = self.layout_metaTile_properties.itemAt(i)
            if isinstance(layout, QtWidgets.QLayout):
                for j in range(layout.count()):
                    layout.itemAt(j).widget().blockSignals(True)
        for w in self.group_metaTile_gfx.children():
                w.blockSignals(True)

        if len(self.gfx_scene_tileset.scene().selectedItems()) == 1:
            metaTile_index = self.gfx_scene_tileset.metaTiles.index(*self.gfx_scene_tileset.scene().selectedItems())
            attr = level.collision[metaTile_index][1]
            attr_shape = (level.collision[metaTile_index][0] & 0xF0) >> 4
            self.dropdown_metaTile_collisionShape.setCurrentIndex(level.collision[metaTile_index][0] & 0x0F)
            self.field_metaTile_topLeft_id.setValue(level.metaTiles[metaTile_index][0] & 0x03FF)
            self.checkbox_metaTile_topLeft_flipH.setChecked((level.metaTiles[metaTile_index][0] & 0x400) >> (8+2))
            self.field_metaTile_topLeft_attr.setValue((level.metaTiles[metaTile_index][0] & 0xF000) >> (8+4))
            self.checkbox_metaTile_topLeft_flipV.setChecked((level.metaTiles[metaTile_index][0] & 0x800) >> (8+3))
            self.field_metaTile_topRight_id.setValue(level.metaTiles[metaTile_index][1] & 0x03FF)
            self.checkbox_metaTile_topRight_flipH.setChecked((level.metaTiles[metaTile_index][1] & 0x400) >> (8+2))
            self.field_metaTile_topRight_attr.setValue((level.metaTiles[metaTile_index][1] & 0xF000) >> (8+4))
            self.checkbox_metaTile_topRight_flipV.setChecked((level.metaTiles[metaTile_index][1] & 0x800) >> (8+3))
            self.field_metaTile_bottomLeft_id.setValue(level.metaTiles[metaTile_index][2] & 0x03FF)
            self.checkbox_metaTile_bottomLeft_flipH.setChecked((level.metaTiles[metaTile_index][2] & 0x400) >> (8+2))
            self.field_metaTile_bottomLeft_attr.setValue((level.metaTiles[metaTile_index][2] & 0xF000) >> (8+4))
            self.checkbox_metaTile_bottomLeft_flipV.setChecked((level.metaTiles[metaTile_index][2] & 0x800) >> (8+3))
            self.field_metaTile_bottomRight_id.setValue(level.metaTiles[metaTile_index][3] & 0x03FF)
            self.checkbox_metaTile_bottomRight_flipH.setChecked((level.metaTiles[metaTile_index][3] & 0x400) >> (8+2))
            self.field_metaTile_bottomRight_attr.setValue((level.metaTiles[metaTile_index][3] & 0xF000) >> (8+4))
            self.checkbox_metaTile_bottomRight_flipV.setChecked((level.metaTiles[metaTile_index][3] & 0x800) >> (8+3))
        else:
            attr = 0x00
            attr_shape = 0x0
            self.dropdown_metaTile_collisionShape.setCurrentIndex(0)
            self.field_metaTile_topLeft_id.setValue(0)
            self.field_metaTile_topRight_id.setValue(0)
            self.field_metaTile_bottomLeft_id.setValue(0)
            self.field_metaTile_bottomRight_id.setValue(0)
            self.field_metaTile_topLeft_id.setValue(0)
            self.checkbox_metaTile_topLeft_flipH.setChecked(False)
            self.field_metaTile_topLeft_attr.setValue(0)
            self.checkbox_metaTile_topLeft_flipV.setChecked(False)
            self.field_metaTile_topRight_id.setValue(0)
            self.checkbox_metaTile_topRight_flipH.setChecked(False)
            self.field_metaTile_topRight_attr.setValue(0)
            self.checkbox_metaTile_topRight_flipV.setChecked(False)
            self.field_metaTile_bottomLeft_id.setValue(0)
            self.checkbox_metaTile_bottomLeft_flipH.setChecked(False)
            self.field_metaTile_bottomLeft_attr.setValue(0)
            self.checkbox_metaTile_bottomLeft_flipV.setChecked(False)
            self.field_metaTile_bottomRight_id.setValue(0)
            self.checkbox_metaTile_bottomRight_flipH.setChecked(False)
            self.field_metaTile_bottomRight_attr.setValue(0)
            self.checkbox_metaTile_bottomRight_flipV.setChecked(False)

        self.checkbox_metaTile_attrRospark.setChecked(attr_shape & 0b0001)
        self.checkbox_metaTile_attrWaterfall.setChecked(attr_shape & 0b0010)
        self.checkbox_metaTile_attrUnk2.setChecked(attr_shape & 0b0100)
        self.checkbox_metaTile_attrMetal.setChecked(attr_shape & 0b1000)
        self.checkbox_metaTile_attrSpike.setChecked(attr & 0b00000001)
        self.checkbox_metaTile_attrWater.setChecked(attr & 0b00000010)
        self.checkbox_metaTile_attrNoCeilHang.setChecked(attr & 0b00000100)
        self.checkbox_metaTile_attrNoWalljump.setChecked(attr & 0b00001000)
        self.checkbox_metaTile_attrSand.setChecked(attr & 0b00010000)
        self.group_metaTile_attrConvey.findChildren(QtWidgets.QRadioButton)[(attr & 0b01100000) >> 5].setChecked(True)
        self.checkbox_metaTile_attrPlat.setChecked(attr & 0b10000000)

        for i in range(self.layout_metaTile_properties.count()):
            layout = self.layout_metaTile_properties.itemAt(i)
            if isinstance(layout, QtWidgets.QLayout):
                for j in range(layout.count()):
                    layout.itemAt(j).widget().blockSignals(False)
                    layout.itemAt(j).widget().setEnabled(True)
        for w in self.group_metaTile_gfx.children():
                w.blockSignals(False)

    def changeTileProperty(self, attrList:list, listIndex:int, bitstring: str, val: int):
        self.button_level_save.setEnabled(bool(self.gfx_scene_tileset.scene().selectedItems()) or self.button_level_save.isEnabled())
        for item in self.gfx_scene_tileset.scene().selectedItems():
            metaTile_index = self.gfx_scene_tileset.metaTiles.index(item)
            bitmask = int(bitstring, 2)
            shiftL = len(bitstring)-1 - bitstring.rindex('0')
            attrList[metaTile_index][listIndex] = \
                (attrList[metaTile_index][listIndex] & bitmask) | (val << shiftL)

    def changeTileShape(self):
        level = self.levelEdited_object.levels[self.dropdown_level_type.currentIndex()]
        self.changeTileProperty(level.collision, 0, "11110000", self.dropdown_metaTile_collisionShape.currentIndex())

    def changeTileShapeAttr(self, index:int, val:bool):
        level = self.levelEdited_object.levels[self.dropdown_level_type.currentIndex()]
        self.changeTileProperty(level.collision, 0, "00001111", val << index)

    def changeTileAttr(self, bitmask: str, val: bool):
        level = self.levelEdited_object.levels[self.dropdown_level_type.currentIndex()]
        self.changeTileProperty(level.collision, 1, bitmask, val)
        
    def changeTileGfx(self, index:int, bitmask: int, val: bool):
        level = self.levelEdited_object.levels[self.dropdown_level_type.currentIndex()]
        bitstring = bin(bitmask).removeprefix("0b").zfill(16)
        print(bitmask, bitstring)
        self.changeTileProperty(level.metaTiles, index, bitstring, val)

    def loadEntityProperties(self):
        if not self.gfx_scene_level.scene().isActive() or len(self.gfx_scene_level.scene().selectedItems()) == 0:
            for w in self.page_level_entities_coords.findChildren(lib.widget.LabeledSpinBox):
                w.setEnabled(False)
            for w in self.page_level_entities_slots.findChildren(lib.widget.LabeledSpinBox):
                w.setEnabled(False)
            return
        for w in self.page_level_entities_coords.findChildren(lib.widget.LabeledSpinBox):
            w.setEnabled(True)
        for w in self.page_level_entities_slots.findChildren(lib.widget.LabeledSpinBox):
            w.setEnabled(True)
        item: lib.widget.LevelEntityItem = self.gfx_scene_level.scene().selectedItems()[0]
        #print(item)
        for w in self.page_level_entities_coords.findChildren(lib.widget.LabeledSpinBox):
            w.blockSignals(True)
        for w in self.page_level_entities_slots.findChildren(lib.widget.LabeledSpinBox):
            w.blockSignals(True)

        self.tabs_level.setCurrentWidget(self.page_level_entities)
        entities = self.levelEdited_ovl_object.entities

        self.label_level_entities_coords_id.setText(f"Entity Index: {lib.datconv.numToStr(item.coordIndex, self.displayBase, self.displayAlphanumeric)}")
        self.field_level_entities_coords_x.sb.setValue(entities.coords.entityList[item.coordIndex]["x"])
        self.field_level_entities_coords_y.sb.setValue(entities.coords.entityList[item.coordIndex]["y"])
        self.field_level_entities_coords_slot.sb.setValue(entities.coords.entityList[item.coordIndex]["slot"])

        slot = entities.coords.entityList[item.coordIndex]["slot"]
        self.label_level_entities_slots_id.setText(f"Slot Index: {lib.datconv.numToStr(slot, self.displayBase, self.displayAlphanumeric)}")
        self.field_level_entities_slots_attr.sb.setValue(entities.slots.entityList[slot]["attr"])
        self.field_level_entities_slots_kind.sb.setValue(entities.slots.entityList[slot]["kind"])
        self.field_level_entities_slots_subkind.sb.setValue(entities.slots.entityList[slot]["subkind"])
        self.field_level_entities_slots_role.sb.setValue(entities.slots.entityList[slot]["role"])
        self.field_level_entities_slots_modifier.sb.setValue(entities.slots.entityList[slot]["modifier"])
        self.field_level_entities_slots_unk5.sb.setValue(entities.slots.entityList[slot]["unk5"])
        self.field_level_entities_slots_unk6.sb.setValue(entities.slots.entityList[slot]["unk6"])
        self.field_level_entities_slots_unk7.sb.setValue(entities.slots.entityList[slot]["unk7"])
        self.field_level_entities_slots_unk8.sb.setValue(entities.slots.entityList[slot]["unk8"])
        self.field_level_entities_slots_unk9.sb.setValue(entities.slots.entityList[slot]["unk9"])
        self.field_level_entities_slots_unkA.sb.setValue(entities.slots.entityList[slot]["unkA"])
        self.field_level_entities_slots_unkB.sb.setValue(entities.slots.entityList[slot]["unkB"])

        for w in self.page_level_entities_coords.findChildren(lib.widget.BetterSpinBox):
            w.blockSignals(False)
        for w in self.page_level_entities_slots.findChildren(lib.widget.BetterSpinBox):
            w.blockSignals(False)

    def changeEntityAttribute(self, dict_list, dict_index:int, dict_key:str, value):
        if dict_index is None: return
        dict_list[dict_index][dict_key] = value
        if len(self.gfx_scene_level.scene().selectedItems()) and isinstance(self.gfx_scene_level.scene().selectedItems()[0], lib.widget.LevelEntityItem):
            self.levelEdited_ovl_object.entities.slots.updateName(self.field_level_entities_coords_slot.sb.value(), fromDict=True)
            self.gfx_scene_level.scene().selectedItems()[0].updateInfo(
                self.levelEdited_ovl_object.entities.coords.entityList[self.gfx_scene_level.scene().selectedItems()[0].coordIndex],
                self.levelEdited_ovl_object.entities.slots.nameList[self.field_level_entities_coords_slot.sb.value()]
            ) 

    def loadOvelrayStructAddressTable(self): # called on ROM load
        addr_levelt = self.gamedat.arm9Addrs["level"]
        arm9_bin = self.arm9_decompressed.save()
        entityt_size = arm9_bin[self.gamedat.arm9Addrs["entity"]+0x04:].find(bytes(4))+0x04
        #print(f"calculated overlay table size: 0x{entityt_size:02X}", "vs expected (ZX/ZXA) 0x120/0x10C")
        #addr_entityunkt = self.gamedat.arm9Addrs["entity"]+0*entityt_size # 4 bytes of data, usually at 0x01 after start of overlay?
        #addr_entityunkt = self.gamedat.arm9Addrs["entity"]+1*entityt_size # table of some kind
        addr_entityCoordt = self.gamedat.arm9Addrs["entity"]+2*entityt_size # coordinates
        addr_entitySlott = self.gamedat.arm9Addrs["entity"]+3*entityt_size # slot defs
        #addr_entityunkt = self.gamedat.arm9Addrs["entity"]+4*entityt_size #???
        self.levelEdited_ovlTable["entity slot"].clear()
        self.levelEdited_ovlTable["entity coord"].clear()
        self.levelEdited_ovlTable["level"].clear()
        skip_level = 0
        skip_entity = 0
        if addr_levelt == 0:
            print("No ARM9 overlay pointer table address provided for entities of current game!")
        for i in range(self.dropdown_level_area.count()):
            addr_level = int.from_bytes(arm9_bin[addr_levelt+(i-skip_level)*0x04:addr_levelt+0x04+(i-skip_level)*0x04], byteorder='little')
            addr_entityCoord = int.from_bytes(arm9_bin[addr_entityCoordt+(i-skip_entity)*0x04:addr_entityCoordt+0x04+(i-skip_entity)*0x04], byteorder='little')
            addr_entitySlot = int.from_bytes(arm9_bin[addr_entitySlott+(i-skip_entity)*0x04:addr_entitySlott+0x04+(i-skip_entity)*0x04], byteorder='little')
            if self.tree_arm9Ovltable.topLevelItem(int(self.dropdown_level_area.itemText(i))) is None: break
            if lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(int(self.dropdown_level_area.itemText(i))).text(4), self.displayBase) <= 0x60 and addr_level != 0x00000000:
                print("re-ordering overlays struct table to fix level data alignment issue at", i)
                skip_level += 1
                self.levelEdited_ovlTable["level"].append(0)
            else:
                self.levelEdited_ovlTable["level"].append(addr_level)
            if lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(int(self.dropdown_level_area.itemText(i))).text(4), self.displayBase) <= 0x20 and addr_entityCoord != 0x00000000:
                print("re-ordering overlays struct table to fix entity data alignment issue at", i)
                skip_entity += 1
                self.levelEdited_ovlTable["entity coord"].append(0)
                self.levelEdited_ovlTable["entity slot"].append(0)
            else:
                self.levelEdited_ovlTable["entity coord"].append(addr_entityCoord)
                self.levelEdited_ovlTable["entity slot"].append(addr_entitySlot)
        #print(arm9_bin[addr_entityt:addr_entityt+0x04*68].hex())
        #print([f"{addr:08X}" for addr in self.levelEdited_ovlTable["entity"]])

    def openLevel(self):
        self.button_level_save.setDisabled(True)
        self.lineedit_level_tilesetName.setDisabled(True)
        if self.dropdown_level_area.currentText() == "":
            return 1 # error code
        self.gfx_scene_level.scene().clear()
        self.gfx_scene_tileset.scene().clear()
        ovlID = int(self.dropdown_level_area.currentText())
        self.levelEdited_ovl_object = lib.level.Overlay(self.rom.loadArm9Overlays([ovlID])[ovlID].data,
                                                        lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(ovlID).text(1), self.displayBase),
                                                        self.levelEdited_ovlTable,
                                                        self.dropdown_level_area.currentIndex(),
                                                        self.gamedat.entityNames)
        self.checkbox_entities_enable.setEnabled(hasattr(self.levelEdited_ovl_object.entities, "coords"))
        self.checkbox_entities_gfxEnable.setEnabled(hasattr(self.levelEdited_ovl_object.entities, "coords"))
        try:
            fileID = self.rom.filenames.idOf(self.levelEdited_ovl_object.tilesetName)
        except IndexError:
            print("This overlay has no proper tileset to load")
            return 1
        try :
            self.levelEdited_object = lib.level.File(self.rom.files[fileID])
        except TypeError:
            QtWidgets.QMessageBox.critical(
                self,
                "Load Failed",
                "The tileset or its pointers may be corrupted"
            )
            return 1
        return 0

    def updateLevelareaUI(self):
        if self.button_level_save.isEnabled() and QtWidgets.QMessageBox.warning(
                self,
                "Unsaved changes",
                "You are attempting to leave the level with unsaved changes!\nDiscard changes and switch to new level?",
                QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No
            ) == QtWidgets.QMessageBox.StandardButton.No:
            self.dropdown_level_area.blockSignals(True)
            self.dropdown_level_area.setCurrentIndex(self.levelEdited_ovlTable["level"].index(self.levelEdited_ovl_object.struct_RAMAddress)) # go back to level index
            self.dropdown_level_area.blockSignals(False)
            return
        self.openLevel()
        self.lineedit_level_tilesetName.blockSignals(True)
        self.lineedit_level_tilesetName.setText(self.levelEdited_ovl_object.tilesetName)
        self.lineedit_level_tilesetName.blockSignals(False)
        self.buttonGroup_radar_tilesetType.blockSignals(True)
        self.radio_radar_PX.setChecked(True)
        self.buttonGroup_radar_tilesetType.blockSignals(False)
        self.dropdown_level_type.clear()
        self.dropdown_level_type.addItem("Normal Level")
        if self.levelEdited_object != None and len(self.levelEdited_object.levels) > 1:
            self.dropdown_level_type.addItem("Radar Level")
        self.dropdown_level_type.setCurrentIndex(0)
        self.dropdown_level_type.setEnabled(self.dropdown_level_area.currentIndex() != -1)

    def loadTileset(self, gfx_table: lib.graphic.GraphicsTable, pal_sec: lib.level.PaletteSection):
        print("load tileset")
        self.gfx_scene_tileset.metaTiles = []
        gfx_index = int(self.field_screen_tilesetOffset.value()) # tilesetOffset
        if gfx_index > gfx_table.offsetCount-1:
            print("tileset offset index out of range")
            return
        if len(gfx_table.getData(gfx_index)) == 0:
            print("cannot load tileset without gfx")
            return
        self.gfx_scene_tileset.scene().clearSelection() # prevent crash if multiple items selected
        self.gfx_scene_tileset.scene().clear()
        #gfx = lib.graphic.GraphicHeader(gfx_table.joinData()[0])
        try:
            gfx = lib.graphic.GraphicHeader(ndspy.lz10.decompress(gfx_table.joinData(gfx_index)[0]))
        except TypeError:
            gfx = lib.graphic.GraphicHeader(gfx_table.joinData(gfx_index)[0])
        pixmap = QtGui.QPixmap(16, 16)
        painter = QtGui.QPainter()
        painter.begin(pixmap)
        pal_list: list[dict] = []
        pl: dict = {}
        depth_obj = lib.datconv.CompressionAlgorithmEnum.EIGHTBPP
        palette_ref = self.GFX_PALETTES[3]
        if len(set(gfx.data[:64])) > 1 and len(set(gfx.data[:32])) <= 1: #hotfixy way of checking for depth
            print("First tile is not uniform in 8bpp. Switching to 4bpp.")
            depth_obj = lib.datconv.CompressionAlgorithmEnum.FOURBPP
            palette_ref = self.GFX_PALETTES[2]
        print(f"unk: {gfx.unk13}")
        ref = QtWidgets.QGraphicsPixmapItem(QtGui.QPixmap.fromImage(lib.datconv.binToQt(gfx.data, palette_ref, depth_obj, 32, len(gfx.data)//64//32)))
        ref.setPos(-32*8-self.gfx_scene_tileset.item_spacing*2, 0)
        self.gfx_scene_tileset.scene().addItem(ref) # to see the gfx used to construct tileset
        print("loop start")
        for i in range(pal_sec.palHeaderCount):
            pl.clear()
            for j in range(pal_sec.paletteHeaders[i].palCount):
                #print(pal_sec.paletteHeaders[i].palettes[j][0])
                pl[pal_sec.paletteHeaders[i].palettes[j][0]] = (lib.datconv.BGR15_to_ARGB32(
                        pal_sec.data[pal_sec.paletteOffsets[i]+pal_sec.paletteHeaders[i].palettes[j][1]:
                                    pal_sec.paletteOffsets[i]+pal_sec.paletteHeaders[i].palettes[j][1]+0x200]))
            pal_list.append(pl.copy())
        print("loop2 start")
        for metaTile_index, metaTile in enumerate(self.levelEdited_object.levels[self.dropdown_level_type.currentIndex()].metaTiles):
            for tile_index, tile in enumerate(metaTile):
                flipH = (tile & 0x0400) >> (8+2)
                flipV = (tile & 0x0800) >> (8+3)
                tileId = (tile & 0x03FF)
                tile_pal = (tile & 0xF000) >> (8+4)
                #print(pal_index, tile_pal)
                try:
                    pal = pal_list[gfx_index][tile_pal]
                except:
                    try:
                        pal = pal_list[gfx_index+1][tile_pal]
                    except:
                        try:
                            #print("palette error lv0 at", gfx_index, tile_pal)
                            pal = list(pal_list[gfx_index].values())[0]
                        except:
                            try:
                                #print("palette error lv1 at", gfx_index, tile_pal)
                                pal = list(pal_list[gfx_index+1].values())[0]
                            except:
                                #print("palette error lvmax at", gfx_index, tile_pal)
                                pal = list(pal_list[0].values())[0]
                #gfx_bin = gfx.data[gfx.gfx_offset:][8*depth_obj.depth*tileId:]
                gfx_bin = gfx.data[gfx.gfx_offset:][8*depth_obj.depth*tileId:]
                #gfx_bin = gfx.data[gfx.gfx_offset:][gfx_ptrs[ptr_index]+8*depth_obj.depth*(tileId&0x3FF):]
                painter.drawImage(QtCore.QRectF(8*(tile_index%2), 8*(tile_index//2), 8, 8), lib.datconv.binToQt(gfx_bin, pal, depth_obj, 1, 1).mirrored(flipH, flipV))
            
            metaTileItem = lib.widget.TilesetItem(pixmap)
            metaTileItem.setPos((16+self.gfx_scene_tileset.item_spacing)*(metaTile_index%self.gfx_scene_tileset.item_columns), (16+self.gfx_scene_tileset.item_spacing)*(metaTile_index//self.gfx_scene_tileset.item_columns))
            self.gfx_scene_tileset.scene().addItem(metaTileItem)
            self.gfx_scene_tileset.metaTiles.append(metaTileItem)
        painter.end()
        self.gfx_scene_tileset.fitInView2()
        print("load tileset end")

    def initScreens(self):
        self.gfx_scene_level.tileGroups = []
        level = self.levelEdited_object.levels[self.dropdown_level_type.currentIndex()]
        for screen_index in range(len(level.screens)):
            self.gfx_scene_level.tileGroups.append([])
            for metaTile_index in range(len(level.screens[screen_index])):
                self.gfx_scene_level.tileGroups[screen_index].append([])

    def loadScreen(self, screen_id: int, x: float=0, y: float=0):
        #print(f"screen {screen_id}")
        screen = self.levelEdited_object.levels[self.dropdown_level_type.currentIndex()].screens[screen_id]
        for metaTile_index, metaTile in enumerate(screen):
            item = lib.widget.LevelTileItem(index=metaTile_index, id=metaTile, screen=screen_id)
            item.setPixmap(self.gfx_scene_tileset.metaTiles[metaTile].pixmap())
            item.setPos(x + 16*(metaTile_index%16),y + 16*(metaTile_index//16))
            self.gfx_scene_level.addItem(item)
            self.gfx_scene_level.tileGroups[screen_id][metaTile_index].append(item)
            item.tileGroup = self.gfx_scene_level.tileGroups[screen_id][metaTile_index]
            #print(item.pos())

    def loadEntities(self, screenSpacing:int=0):
        if not self.checkbox_entities_enable.isChecked(): return
        entities = self.levelEdited_ovl_object.entities
        if not hasattr(entities, "coords"): return
        self.field_level_entities_coords_slot.sb.setRange(0, len(entities.slots.entityList)-1) # prevent using inexistant slots
        
        for i in range(len(entities.coords.entityList[1:-1])):
            entityCoord = entities.coords.entityList[1:-1][i]
            try:
                entitySlot = entities.slots.entityList[entityCoord["slot"]]
                entitySlot_names = entities.slots.nameList[entityCoord["slot"]]
            except IndexError as e:
                entitySlot_names = {
                "attr": "Undefined",
                "kind": "Undefined",
                "subkind": "Undefined",
                "role": "Undefined",
                "modifier": "Undefined",
                "unk5": "Undefined",
                "unk6": "Undefined",
                "unk7": "Undefined",
                "unk8": "Undefined",
                "unk9": "Undefined",
                "unkA": "Undefined",
                "unkB": "Undefined"
                }
                print(f"Entity slot {entityCoord["slot"]} did not load correclty. Slot may not exist in slot definitions.")
                print(e)
            self.gfx_scene_level.scene().addItem(
                lib.widget.LevelEntityItem(
                coordIndex=i+1,
                coord=entityCoord,
                slot=entitySlot,
                slotnames=entitySlot_names,
                screenSpacing=screenSpacing,
                displayBase=self.displayBase,
                alphanumeric=self.displayAlphanumeric,
                graphicItems=self.OAM_processFrame(["obj_dat.bin", 0], 0)["items"] if self.checkbox_entities_gfxEnable.isChecked() else []
                )
            )

    def loadLevel(self):
        if self.dropdown_level_area.currentIndex() == -1:
            QtWidgets.QMessageBox.warning(
                self,
                "Load Failed",
                "A level must be selected before loading it."
            )
            return
        self.button_level_save.setDisabled(True)
        print("Load level")
        if self.levelEdited_object == None:
            if self.openLevel() == 1:
                return
        self.lineedit_level_tilesetName.setEnabled(True)
        file = self.levelEdited_object
        level = file.levels[self.dropdown_level_type.currentIndex()]
        print(f"level offset: {file.level_offset_rom:02X}")
        print(f"gfx offset: {file.gfx_offset_rom:02X}")
        print(f"pal offset: {file.pal_offset_rom:02X}")
        print(f"leveldata size: {len(file.data[file.level_offset_rom:file.gfx_offset_rom])}")
        gfx_ptrs = None
        if level == file.level:
            if file.gfx_offset_attr == 0x80: # if compressed
                gfx_data = ndspy.lz10.decompress(file.data[file.gfx_offset_rom:file.pal_offset_rom])
            else:
                gfx_data = file.data[file.gfx_offset_rom:file.pal_offset_rom]
            gfx_table = lib.graphic.GraphicsTable(gfx_data, start=file.gfx_offset_rom, end=file.pal_offset_rom)
            table_dat = gfx_table.joinData()
            gfx = lib.graphic.GraphicHeader(table_dat[0], start=file.gfx_offset_rom, end=file.pal_offset_rom)
            gfx_ptrs = table_dat[1]

            pal_sec = lib.level.PaletteSection(file.data[file.pal_offset_rom:], file.pal_offset_attr == 0x80)
            #pal = lib.datconv.BGR15_to_ARGB32(pal_sec.data[pal_sec.palettes_offset:pal_sec.palettes_offset+0x200])
        elif level == file.level_radar:
            if self.rom.filenames.idOf("elf_usa.bin") != None: # ZX
                file_radar = self.rom.files[self.rom.filenames.idOf("elf_usa.bin")]
                pointergfx = int.from_bytes(file_radar[0x04:0x08], 'little')
                pointerpal = int.from_bytes(file_radar[0x08:0x0C], 'little')
                gfx_table = lib.graphic.GraphicsTable(file_radar[pointergfx:], start=pointergfx, end=pointerpal)
                # compressed part has redundant tiles at the end
                gfx = lib.graphic.GraphicHeader(
                    ndspy.lz10.decompress(gfx_table.getData(0))[:-0x200]+gfx_table.getData(gfx_table.offsetCount-self.buttonGroup_radar_tilesetType.checkedId()),
                      start=gfx_table.getAddr(0), end=pointerpal)
            else: # ZXA
                file_radar = self.rom.files[self.rom.filenames.idOf("ls_map_def.bin")]
                pointergfx = int.from_bytes(file_radar[0x04:0x08], 'little')
                pointerpal = int.from_bytes(file_radar[0x08:0x0C], 'little')
                gfx_table = lib.graphic.GraphicsTable(file_radar[pointergfx:], start=pointergfx, end=pointerpal)
                gfx = lib.graphic.GraphicHeader(
                    gfx_table.getData(0)[:-0x480]+gfx_table.getData(gfx_table.offsetCount-self.buttonGroup_radar_tilesetType.checkedId())[0x240:],
                      start=gfx_table.getAddr(0), end=pointerpal)
                #gfx = lib.graphic.GraphicHeader(file_radar[pointergfx:], start=pointergfx, end=len(file_radar))
            pal_sec = lib.level.PaletteSection(file_radar[pointerpal:], False)
            #pal = lib.datconv.BGR15_to_ARGB32(pal_sec.data[pal_sec.palettes_offset:pal_sec.palettes_offset+0x200])
        else:
            print("invalid level type!")
            return
        #print(gfx.gfx_offset)
        #self.loadTileset(gfx_sec.data[gfx.offset_start+gfx.gfx_offset:], pal)
        #self.loadTileset(gfx.data[gfx.gfx_offset:], pal_sec, gfx_ptrs)
        self.loadTileset(gfx_table, pal_sec)
        self.gfx_scene_level.scene().clear()
        if self.gfx_scene_tileset.metaTiles == []:
            return
        self.initScreens()
        screenSpacing = 4
        if level == file.level:
            for i in range(self.levelEdited_ovl_object.screenLayout0.height):
                for j in range(self.levelEdited_ovl_object.screenLayout0.realWidth):
                    if j >= self.levelEdited_ovl_object.screenLayout0.width:
                        break # skip unused screens
                    self.loadScreen(self.levelEdited_ovl_object.screenLayout0.layout[i][j], j*(16*(8*2)+screenSpacing), i*(12*(8*2)+screenSpacing))
        elif level == file.level_radar:
            for i in range(self.levelEdited_ovl_object.screenLayout_radar.height):
                for j in range(self.levelEdited_ovl_object.screenLayout_radar.realWidth):
                    if j >= self.levelEdited_ovl_object.screenLayout_radar.width:
                        break # skip unused screens
                    self.loadScreen(self.levelEdited_ovl_object.screenLayout_radar.layout[i][j], j*(16*(8*2)+screenSpacing), i*(12*(8*2)+screenSpacing))
        self.loadEntities(screenSpacing)
        if self.checkbox_level_fitInView.isChecked():
            self.gfx_scene_level.fitInView2()

    def loadTweaks(self):
        arm9_bin = self.arm9_decompressed.save()
        for i in range(self.tabs_tweaks.count()):
            page = self.tabs_tweaks.widget(i)
            for widget in page.findChildren(QtWidgets.QWidget):
                widget.deleteLater() # delete previously generated widgets
        for category in self.gamedat.tweaks:
            field_parent: QtWidgets.QWidget = getattr(self, f"page_tweaks_{category.lower()}")
            for tweak in self.gamedat.tweaks[category]:
                tweak_data = self.gamedat.tweaks[category][tweak]
                field_name = f"field_{category}_{tweak}"
                bitCount = tweak_data[1]*8
                setattr(self, field_name, lib.widget.LabeledSpinBox(field_parent, labelText=f"{tweak.split("_")[-1]} ({"" if tweak_data[2] else "u"}int{bitCount})"))
                field: lib.widget.LabeledSpinBox = getattr(self, field_name)
                field.sb.isInt = True
                field.sb.numbase = self.displayBase
                field.sb.numfill = tweak_data[1]*2
                if tweak_data[2]:
                    field.sb.setRange(-(2**(bitCount-1)), 2**(bitCount-1)-1)
                else:
                    field.sb.setRange(0, 2**(bitCount))
                field.isMainCode = tweak_data[0] < self.rom.arm9RamAddress+len(arm9_bin)
                field.model = None if field.isMainCode else tweak.split("_")[0]
                if field.isMainCode:
                    tweak_addr = tweak_data[0] - self.rom.arm9RamAddress
                    tweak_val = int.from_bytes(arm9_bin[tweak_addr:tweak_addr+tweak_data[1]], 'little', signed=tweak_data[2])
                else:
                    overlay = self.rom.loadArm9Overlays([tweak_data[3]])[tweak_data[3]]
                    tweak_addr = tweak_data[0] - overlay.ramAddress
                    tweak_val = int.from_bytes(overlay.data[tweak_addr:tweak_addr+tweak_data[1]], 'little', signed=tweak_data[2])
                field.sb.setValue(tweak_val)
                field.hide()
                field_parent.layout().addWidget(field)


    def tweakTargetCall(self):
        if self.dropdown_tweak_target.currentIndex() == 0:
            for widget in self.page_tweaks_physics.findChildren(lib.widget.LabeledSpinBox):
                if widget.isMainCode:
                    widget.show()
                else:
                    widget.hide()
        else:
            for widget in self.page_tweaks_physics.findChildren(lib.widget.LabeledSpinBox):
                if widget.isMainCode:
                    widget.hide()
                else:
                    if self.dropdown_tweak_target.currentText().find(widget.model) != -1:
                        widget.show()
                    else:
                        widget.hide()

    def treeBaseUpdate(self, tree: lib.widget.EditorTree):
        for e in tree.findItems("", QtCore.Qt.MatchFlag.MatchContains | QtCore.Qt.MatchFlag.MatchRecursive):
            for t in range(e.columnCount()):
                text = e.text(t)
                text_header = tree.headerItem().text(t).lower()
                if any(char.isdigit() for char in text) and text.replace("{", "").replace("}", "").isalnum():
                    if not "file id" in text_header:
                        value = lib.datconv.strToNum(text, self.displayBase_old)
                        newtext = lib.datconv.numToStr(value, self.displayBase, self.displayAlphanumeric)
                        zerofill = 8 if "address" in text_header else 0
                        e.setText(t, newtext.zfill(zerofill))

    def reloadCall(self, level: int=0): # Reload all reloadable content
        if hasattr(self.rom, "name"):
            #print("reloadlevel " + str(level))
            if level == 0: #reload only necessary
                self.treeCall() # update for betterspinboxes as well
                self.treeBaseUpdate(self.tree_arm9)
                self.treeBaseUpdate(self.tree_arm9Ovltable)
                self.treeBaseUpdate(self.tree_arm7)
                self.treeBaseUpdate(self.tree_arm7Ovltable)
                self.treeBaseUpdate(self.tree_patches)
            elif level == 1: #medium reload
                self.treeBaseUpdate(self.tree_arm9)
                self.treeBaseUpdate(self.tree_arm9Ovltable)
                self.treeBaseUpdate(self.tree_arm7)
                self.treeBaseUpdate(self.tree_arm7Ovltable)
                self.treeCall(addr_reset=True)
                self.patches_reload()
            else: #reload everything
                self.tree.setCurrentItem(None)
                self.field_address.setRange(0,0)
                self.treeArm9Update()
                self.treeArm7Update()
                self.treeSdatUpdate()
                self.treeUpdate()
                self.patches_reload()
            self.displayBase_old = self.displayBase

    def tabChangeCall(self):
        if self.rom == None: return
        if self.tabs.currentIndex() == self.tabs.indexOf(self.page_explorer):
            self.treeCall()

    def file_editor_show(self, mode: str): # UiComponents
        modes = ["Empty", "Hex", "Text", "Graphics", "OAM", "PAnm", "Font", "Sound", "VX", "Model"]
        # Associates each mode with a set of widgets to show or hide
        widget_sets = [self.WIDGETS_EMPTY, self.WIDGETS_HEX, self.WIDGETS_TEXT, self.WIDGETS_GRAPHIC, self.WIDGETS_OAM, self.WIDGETS_PANM, self.WIDGETS_FONT, self.WIDGETS_SOUND, self.WIDGETS_VX, self.WIDGETS_MODEL]

        mode_index = modes.index(mode)
        # Hide all widgets from other modes
        for s in widget_sets:
            if s != widget_sets[mode_index]:
                for w in s:
                    w.hide()
        # Show widgets specific to this mode
        for w in widget_sets[mode_index]:
            w.show()
        # case-specific code
        if mode == "Graphics" or "Font":
            # Reset Values
            #self.field_address.setValue(self.base_address)
            if self.file_content_gfx.sceneRect().width() != 0: # disallow zero div
                self.file_content_gfx.fitInView2()
            #print(f"{len(self.rom.save()):08X}")
        elif mode == "Font":
            pass

    def load_viewImage(self):
        dialog = QtWidgets.QFileDialog(
                self,
                "Load image to overwrite view",
                "",
                "Image (*.bmp);;All Files (*)",
                options=QtWidgets.QFileDialog.Option.DontUseNativeDialog,
                )
        if dialog.exec():
            pixmap = self.file_content_gfx._graphic.pixmap()
            pixmap.load(dialog.selectedFiles()[0])
            self.file_content_gfx._graphic.setPixmap(pixmap)
            QtWidgets.QMessageBox.information(
                self,
                "Import Status",
                "Image loaded!"
            )

    def save_viewImage(self):
        dialog = QtWidgets.QFileDialog(
                self,
                "Save view to image",
                "",
                "Image (*.bmp);;All Files (*)",
                options=QtWidgets.QFileDialog.Option.DontUseNativeDialog,
                )
        dialog.setLabelText(QtWidgets.QFileDialog.DialogLabel.Accept, "Save")
        if dialog.exec():
            path = dialog.selectedFiles()[0]
            if path.split("/")[-1].find(".") == -1:
                path += ".bmp"
            print(path)
            self.file_content_gfx._graphic.pixmap().save(path)
            QtWidgets.QMessageBox.information(
                self,
                "Export Status",
                "Image saved to disk!"
            )

    def save_filecontent(self): #Save to virtual ROM
        file_id = int(self.tree.currentItem().text(0))
        if self.fileDisplayRaw == False:
            if self.fileDisplayState == "Dialogue": # dialogue names are handled in a separate function
                if self.dropdown_textindex.isEnabled():
                    self.fileEdited_object.text_list[self.dropdown_textindex.currentIndex()] = self.file_content_text.toPlainText()
                    #dialog.text_id_list = 
                    self.rom.files[file_id] = self.fileEdited_object.toBytes()
                else: # forced dialogue state 
                    self.rom.files[file_id][self.relative_address:self.relative_address+0x1FFF] = lib.dialogue.DialogueFile.textToBin(self.file_content_text.toPlainText(), self.file_content_text.charmap)
            elif self.fileDisplayState == "Graphics":
                save_data = lib.datconv.qtToBin(self.file_content_gfx._graphic.pixmap().toImage(),
                                                algorithm=list(lib.datconv.CompressionAlgorithmEnum)[self.dropdown_gfx_depth.currentIndex()],
                                                tileWidth=self.tile_width, tileHeight=self.tile_height)
                w.rom.files[file_id][self.relative_address:self.relative_address+len(save_data)] = save_data
                if self.dropdown_gfx_palette.currentIndex() == -1: # if palette from ROM
                    header_index = self.dropdown_gfx_subindex.currentIndex()
                    if isinstance(self.fileEdited_object, lib.graphic.File):
                        section = lib.graphic.GraphicSection.fromParent(self.fileEdited_object, self.dropdown_gfx_index.currentIndex())
                    elif isinstance(self.fileEdited_object, lib.graphic.GraphicSection):
                        section = self.fileEdited_object
                    offset = section.graphics[header_index].offset_start+0xc+section.graphics[header_index].palette_offset
                    w.rom.files[file_id][offset:offset+section.graphics[header_index].palette_size] = lib.datconv.ARGB32_to_BGR15(self.gfx_palette[section.graphics[header_index].unk13 & 0xf0:]) # save to ROM
            elif self.fileDisplayState == "OAM":
                if self.tabs_oam.currentWidget()==self.page_oam_frames:
                    if -1 in [self.dropdown_oam_entry.currentIndex(),  self.dropdown_oam_objFrame.currentIndex(),
                              self.dropdown_oam_obj.currentIndex()]:
                        print("no valid object to save!")
                        return
                    section = self.fileEdited_object.oamsec
                    frame = section.frameTable[self.fileEdited_object.frameIndex]
                    save_data = bytearray()
                    obj_offset_base = self.fileEdited_object.oamsec.frameTable_offset + frame[0]
                    is3D = False
                    try:
                        if self.fileEdited_object.frameIndex < len(self.fileEdited_object.oamsec.frameTable)-1:
                            #print(frame[0]+frame[1]*0x06, "vs", self.fileEdited_object.oamsec.frameTable[self.fileEdited_object.frameIndex+1][0])
                            assert frame[0]+frame[1]*0x06 == self.fileEdited_object.oamsec.frameTable[self.fileEdited_object.frameIndex+1][0]
                        else:
                            obj_offset_end = obj_offset_base + frame[1]*0x06
                            #print(self.fileEdited_object.oamsec.data[obj_offset_end:self.fileEdited_object.oamsec.header_items[1]].hex())
                            #print(obj_offset_end, "vs", self.fileEdited_object.oamsec.header_items[1])
                            assert obj_offset_end <= self.fileEdited_object.oamsec.header_items[1]
                        is3D = True
                    except AssertionError:
                        pass
                    for obj_index in range(len(self.fileEdited_object.objs)):
                        if is3D:
                            offset = section.frameTable_offset + frame[0] + obj_index*0x06
                            obj = lib.oam.Object3D(section.data[offset:offset+0x06])
                            if obj_index == self.dropdown_oam_obj.currentIndex(): # current changes
                                obj.tileId = self.field_objTileId.value()
                                obj.tileId_add = self.field_objTileId.value() & 0xFF00
                                obj.flip_h = self.checkbox_objFlipH.isChecked()
                                obj.flip_v = self.checkbox_objFlipV.isChecked()
                                obj.heightIndex = self.slider_obj3DHeightIndex.sl.value()
                                obj.tile_width_index = self.slider_obj3DTileWidth.sl.value()
                                obj.x = self.field_objX.value()
                                obj.y = self.field_objY.value()
                            else: # cached changes
                                obj = self.fileEdited_object.objs[obj_index]
                        else:
                            offset = section.frameTable_offset + frame[0] + obj_index*0x04
                            obj = lib.oam.Object(section.data[offset:offset+0x04])
                            if obj_index == self.dropdown_oam_obj.currentIndex(): # current changes
                                obj.tileId = self.field_objTileId.value()
                                obj.tileId_add = self.field_objTileId.value() & 0x300
                                obj.flip_h = self.checkbox_objFlipH.isChecked()
                                obj.flip_v = self.checkbox_objFlipV.isChecked()
                                obj.sizeIndex = self.slider_objSizeIndex.sl.value()
                                obj.shape = self.buttonGroup_oam_objShape.checkedId()
                                obj.x = self.field_objX.value()
                                obj.y = self.field_objY.value()
                            else: # cached changes
                                obj = self.fileEdited_object.objs[obj_index]
                        save_data += obj.toBytes()
                    offset2 = section.offset_start + section.frameTable_offset + frame[0]
                    offset2_end = offset2+frame[1]*obj.SIZE
                    w.rom.files[file_id][offset2:offset2_end] = save_data
                    objCountDelta = len(self.fileEdited_object.objs) - frame[1]
                    if objCountDelta != 0:
                        offset3 = section.offset_start + section.frameTable_offset + self.dropdown_oam_objFrame.currentIndex()*0x04 # go to current index in frameTable
                        w.rom.files[file_id][offset3+0x02:offset3+0x03] = int.to_bytes(len(self.fileEdited_object.objs), 1, 'little') # update header obj count
                        for i in range(offset3+0x04, section.offset_start + section.frameTable_offset + section.frameTable_size, 0x04): # for all later entries in frameTable
                            #print(objCountDelta*obj.SIZE, w.rom.files[file_id][i:i+0x02].hex())
                            w.rom.files[file_id][i:i+0x02] = int.to_bytes(int.from_bytes(w.rom.files[file_id][i:i+0x02], 'little')+objCountDelta*obj.SIZE, 2, 'little') # update header obj offset
                        for i in range(1, len(section.header_items)): # section pointers from anim
                                section.header_items[i] += objCountDelta*obj.SIZE
                        w.rom.files[file_id][section.offset_start:section.offset_start+section.header_size] = section.headerToBytes() # update section header pointers
                        for i in range(self.dropdown_oam_entry.currentIndex()+1, len(self.fileEdited_object.address_list)): # file
                            self.fileEdited_object.address_list[i][0] += objCountDelta*obj.SIZE
                        self.fileEdited_object.fileSize += objCountDelta*obj.SIZE
                        w.rom.files[file_id][:self.fileEdited_object.header_size] = self.fileEdited_object.headerToBytes() # update file header pointers
                elif self.tabs_oam.currentWidget()==self.page_oam_anims:
                    if -1 in [self.dropdown_oam_entry.currentIndex(), self.dropdown_oam_anim.currentIndex(),
                            self.dropdown_oam_animFrame.currentIndex()]:
                        print("no valid animation data to save!")
                        return
                    section: lib.oam.OAMSection = self.fileEdited_object.oamsec
                    anim: lib.oam.Animation = self.fileEdited_object.oamsec_anim
                    isDurationfix = self.dropdown_oam_animFrame.currentIndex() > 0 and self.field_oam_animFrameDuration.value() >= 0xFE
                    if isDurationfix:
                        if self.field_oam_animFrameDuration.value() == 0xFE:
                            self.field_oam_animFrameId.setValue(self.dropdown_oam_animFrame.currentIndex()) # loop to current index neutralizes the loop
                        elif self.field_oam_animFrameDuration.value() == 0xFF:
                            self.field_oam_animFrameDuration.setValue(0)
                    anim.isLooping = self.checkbox_oam_animLoop.isChecked()
                    anim.loopStart = self.field_oam_animLoopStart.value()
                    anim.frames[self.dropdown_oam_animFrame.currentIndex()] = [
                        self.field_oam_animFrameId.value(),
                        self.field_oam_animFrameDuration.value()
                    ]
                    if isDurationfix:
                        print(f"while saving, special duration was found in frame {self.dropdown_oam_animFrame.currentIndex()} of animation and frame was modified to match expected duration")
                    save_data = anim.toBytes()
                    save_offset =  self.fileEdited_object.oamsec.offset_start+self.fileEdited_object.oamsec.animTable_offset+anim.frames_offset
                    save_offset_end = save_offset+anim.oldFrameCount*anim.FRAME_SIZE
                    print(save_data.hex(), w.rom.files[file_id][save_offset:save_offset_end].hex())
                    w.rom.files[file_id][save_offset:save_offset_end] = save_data
                    frameCountDelta = len(anim.frames) - anim.oldFrameCount
                    #delta_size = frameCountDelta*anim.FRAME_SIZE
                    if frameCountDelta != 0: # not all pointers were identified, so this does not fully work
                        offset = section.offset_start + section.animTable_offset + self.dropdown_oam_anim.currentIndex()*section.ANIMTABLE_PTR_SIZE
                        for i in range(offset+section.ANIMTABLE_PTR_SIZE, section.offset_start + section.animTable_offset + section.animTable_size, section.ANIMTABLE_PTR_SIZE):
                            #print(frameCountDelta*anim.FRAME_SIZE, w.rom.files[file_id][i:i+section.ANIMTABLE_PTR_SIZE].hex())
                            w.rom.files[file_id][i:i+section.ANIMTABLE_PTR_SIZE] = int.to_bytes(int.from_bytes(w.rom.files[file_id][i:i+section.ANIMTABLE_PTR_SIZE], 'little')+frameCountDelta*anim.FRAME_SIZE, section.ANIMTABLE_PTR_SIZE, 'little') # update header obj offset
                        for i in range(2, len(section.header_items)): # section pointers from palette
                                section.header_items[i] += frameCountDelta*anim.FRAME_SIZE
                        w.rom.files[file_id][section.offset_start:section.offset_start+section.header_size] = section.headerToBytes() # update section header pointers
                        for i in range(self.dropdown_oam_entry.currentIndex()+1, len(self.fileEdited_object.address_list)): # file
                            self.fileEdited_object.address_list[i][0] += frameCountDelta*anim.FRAME_SIZE
                        self.fileEdited_object.fileSize += frameCountDelta*anim.FRAME_SIZE
                        w.rom.files[file_id][:self.fileEdited_object.header_size] = self.fileEdited_object.headerToBytes() # update file header pointers
                    anim.oldFrameCount = len(anim.frames)
                # update data of oamsec
                self.fileEdited_object.oamsec = lib.oam.OAMSection(self.fileEdited_object, self.dropdown_oam_entry.currentIndex())
            elif self.fileDisplayState == "Palette Animation":
                self.fileEdited_object.anims[self.dropdown_panm_entry.currentIndex()].frames[self.dropdown_panm_frame.currentIndex()]\
                                = [self.field_panm_frameId.value(), self.field_panm_frameDuration.value()]
                self.fileEdited_object.anims[self.dropdown_panm_entry.currentIndex()].isLooping = self.checkbox_panm_loop.isChecked()
                self.fileEdited_object.anims[self.dropdown_panm_entry.currentIndex()].loopStart = self.field_panm_loopStart.value()
                self.fileEdited_object.palettes[self.dropdown_panm_entry.currentIndex()].colorSlot0 = self.field_panm_colorSlot0.value()
                self.fileEdited_object.palettes[self.dropdown_panm_entry.currentIndex()].colorSlot1 = self.field_panm_colorSlot1.value()

                for colorset_index in range(len(self.fileEdited_object.palettes[self.dropdown_panm_entry.currentIndex()].colorTable)):
                    self.fileEdited_object.palettes[self.dropdown_panm_entry.currentIndex()].colorTable[colorset_index] = \
                        self.gfx_palette[colorset_index*2:colorset_index*2+2]
                save_data = self.fileEdited_object.toBytes()
                #print(w.rom.files[file_id] == save_data)
                w.rom.files[file_id][:] = save_data

            elif self.fileDisplayState == "Font":
                save_data = lib.datconv.qtToBin(self.file_content_gfx._graphic.pixmap().toImage(),
                                                algorithm=lib.datconv.CompressionAlgorithmEnum.ONEBPP,
                                                tileWidth=self.tile_width, tileHeight=self.tile_height)
                w.rom.files[file_id][self.relative_address:self.relative_address+len(save_data)] = save_data
                w.rom.files[file_id][0x00:0x02] = bytearray(int.to_bytes(int(self.field_font_width.value()), 2, "little"))
                w.rom.files[file_id][0x02:0x04] = bytearray(int.to_bytes(int(self.field_font_height.value()), 2, "little"))
                i_space = self.field_font_width.value()*self.field_font_height.value()/8
                w.rom.files[file_id][0x04:0x08] = bytearray(int.to_bytes(int(i_space), 4, "little"))
                if i_space:
                    w.rom.files[file_id][0x08:0x0C] = bytearray(int.to_bytes(int(self.field_font_size.value()/self.field_font_width.value()*self.field_font_height.value()/8), 4, "little"))
                else:
                    w.rom.files[file_id][0x08:0x0C] = bytearray(int.to_bytes(int(0), 4, "little"))
                w.rom.files[file_id][0x0C:0x10] = bytearray(int.to_bytes(int(self.field_font_size.value()), 4, "little"))
            elif self.fileDisplayState == "VX":
                w.rom.files[file_id][0x04:0x08] = bytearray(int.to_bytes(int(self.field_vxHeader_length.value()), 4, "little"))
                w.rom.files[file_id][0x08:0x0C] = bytearray(int.to_bytes(int(self.field_vxHeader_width.value()), 4, "little"))
                w.rom.files[file_id][0x0C:0x10] = bytearray(int.to_bytes(int(self.field_vxHeader_height.value()), 4, "little"))
                w.rom.files[file_id][0x10:0x14] = bytearray(int.to_bytes(int(self.field_vxHeader_framerate.value()*0x10000), 4, "little")) #convert float to 16.16
                w.rom.files[file_id][0x14:0x18] = bytearray(int.to_bytes(int(self.field_vxHeader_quantizer.value()), 4, "little"))
                w.rom.files[file_id][0x18:0x1C] = bytearray(int.to_bytes(int(self.field_vxHeader_sampleRate.value()), 4, "little"))
                w.rom.files[file_id][0x1C:0x20] = bytearray(int.to_bytes(int(self.field_vxHeader_streamCount.value()), 4, "little"))
                w.rom.files[file_id][0x20:0x24] = bytearray(int.to_bytes(int(self.field_vxHeader_frameSizeMax.value()), 4, "little"))
                w.rom.files[file_id][0x24:0x28] = bytearray(int.to_bytes(int(self.field_vxHeader_audioExtraDataOffset.value()), 4, "little"))
                w.rom.files[file_id][0x28:0x2C] = bytearray(int.to_bytes(int(self.field_vxHeader_seekTableOffset.value()), 4, "little"))
                w.rom.files[file_id][0x2C:0x30] = bytearray(int.to_bytes(int(self.field_vxHeader_seekTableEntryCount.value()), 4, "little"))
            elif self.fileDisplayState == "Sound":
                return
        else:
            save_data = bytearray.fromhex(lib.datconv.strSetAlnum(self.file_content_text.toPlainText().replace(" ", "").replace("\n", ""), 16, True)) # force to alphanumeric for bytearray conversion
            w.rom.files[file_id][self.relative_address:self.relative_address+len(save_data)] = save_data
        #print(type(w.rom.files[file_id]))
        print("file changes saved")
        # fat is only recalculated when entire rom is saved, so it keeps outdated values
        self.button_file_save.setDisabled(True)
    
    def saveDialogueName(self):
        self.button_dialogueNames_save.setDisabled(True)
        addr = self.gamedat.arm9Addrs["dialogue names " + self.dropdown_dialogueNames_lang.currentText()]
        index = self.dropdown_dialogueNames.currentIndex()
        arm9_bin = self.arm9_decompressed.save()
        arm9_bin_old = arm9_bin[:]
        new_data = lib.dialogue.DialogueFile.textToBin(self.textEdit_dialogueNames.toPlainText(), self.textEdit_dialogueNames.charmap)
        new_data += bytearray(0x0C)
        arm9_bin[addr+index*0x0C:addr+index*0x0C+0x0C] = bytearray(new_data[:0x0C])
        if arm9_bin != arm9_bin_old:
            self.save_toARM9(arm9_bin)
        print("name saved!")

    def save_level(self):
        self.button_level_save.setDisabled(True)
        
        # find level file in rom
        if self.lineedit_level_tilesetName.text() != self.levelEdited_ovl_object.tilesetName:
            tilset_choice = QtWidgets.QMessageBox.warning(
            self,
            "Tileset conflict",
            "You are attempting to save the level with a different tileset!\nDo you want to save the current tile data to the new tileset file?\n(Selecting \"No\" will save the data to the original tileset file while associating the new tileset to this level)",
            QtWidgets.QMessageBox.StandardButton.Yes | QtWidgets.QMessageBox.StandardButton.No | QtWidgets.QMessageBox.StandardButton.Cancel
            )
            if tilset_choice == QtWidgets.QMessageBox.StandardButton.Yes:
                fileID_tileset = self.rom.filenames.idOf(self.lineedit_level_tilesetName.text())
            elif tilset_choice == QtWidgets.QMessageBox.StandardButton.No:
                fileID_tileset = self.rom.filenames.idOf(self.levelEdited_ovl_object.tilesetName)
            else:
                print("level save aborted.")
                return
        else:
            fileID_tileset = self.rom.filenames.idOf(self.lineedit_level_tilesetName.text())
        if hasattr(self.levelEdited_object, "level"):
            level_bin = bytearray(self.levelEdited_object.level.toBytes())
        else:
            level_bin = self.levelEdited_object.data[self.levelEdited_object.level_offset_rom:self.levelEdited_object.gfx_offset_rom]
        level_bin += bytearray((-len(level_bin)) & 3) # 4-byte padding
        gfx_bin = self.levelEdited_object.data[self.levelEdited_object.gfx_offset_rom:self.levelEdited_object.pal_offset_rom]
        gfx_bin += bytearray((-len(gfx_bin)) & 3)
        if self.levelEdited_object.entryCount == 7:
            pal_bin = self.levelEdited_object.data[self.levelEdited_object.pal_offset_rom:self.levelEdited_object.address_list[3][0]]
            pal_bin += bytearray((-len(pal_bin)) & 3)
            bin_03 = self.levelEdited_object.data[self.levelEdited_object.address_list[3][0]:self.levelEdited_object.address_list[4][0]]
            #bin_03 = ndspy.lz10.compress(bytearray(4))
            bin_03 += bytearray((-len(bin_03)) & 3)
            bin_04 = self.levelEdited_object.data[self.levelEdited_object.address_list[4][0]:self.levelEdited_object.address_list[5][0]]
            bin_04 += bytearray((-len(bin_04)) & 3)
            bin_05 = self.levelEdited_object.data[self.levelEdited_object.address_list[5][0]:self.levelEdited_object.address_list[6][0]]
            bin_05 += bytearray((-len(bin_05)) & 3)
            if hasattr(self.levelEdited_object, "level_radar"):
                bin_06 = bytearray(self.levelEdited_object.level_radar.toBytes())
            else:
                bin_06 = self.levelEdited_object.data[self.levelEdited_object.address_list[6][0]:]
            bin_06 += bytearray((-len(bin_06)) & 3)

        if self.levelEdited_object.entryCount == 7:
            self.rom.files[fileID_tileset][self.levelEdited_object.address_list[6][0]:] = bin_06
            self.rom.files[fileID_tileset][self.levelEdited_object.address_list[5][0]:self.levelEdited_object.address_list[6][0]] = bin_05
            self.rom.files[fileID_tileset][self.levelEdited_object.address_list[4][0]:self.levelEdited_object.address_list[5][0]] = bin_04
            self.rom.files[fileID_tileset][self.levelEdited_object.address_list[3][0]:self.levelEdited_object.address_list[4][0]] = bin_03
            self.rom.files[fileID_tileset][self.levelEdited_object.pal_offset_rom:self.levelEdited_object.address_list[3][0]] = pal_bin
        self.rom.files[fileID_tileset][self.levelEdited_object.gfx_offset_rom:self.levelEdited_object.pal_offset_rom] = gfx_bin
        self.rom.files[fileID_tileset][self.levelEdited_object.level_offset_rom:self.levelEdited_object.gfx_offset_rom] = level_bin

        self.levelEdited_object.gfx_offset_rom = self.levelEdited_object.level_offset_rom + len(level_bin)
        self.levelEdited_object.pal_offset_rom = self.levelEdited_object.gfx_offset_rom + len(gfx_bin)
        if self.levelEdited_object.entryCount == 7:
            self.levelEdited_object.address_list[3][0] = self.levelEdited_object.pal_offset_rom + len(pal_bin)
            self.levelEdited_object.address_list[4][0] = self.levelEdited_object.address_list[3][0] + len(bin_03)
            self.levelEdited_object.address_list[5][0] = self.levelEdited_object.address_list[4][0] + len(bin_04)
            self.levelEdited_object.address_list[6][0] = self.levelEdited_object.address_list[5][0] + len(bin_05)
        self.levelEdited_object.fileSize = len(self.rom.files[fileID_tileset])
        self.rom.files[fileID_tileset][:self.levelEdited_object.level_offset_rom] = self.levelEdited_object.headerToBytes()
        # Overlay
        print("Saving overlay")
        fileID_overlay = int(self.dropdown_level_area.currentText())
        self.levelEdited_ovl_object.tilesetName = self.lineedit_level_tilesetName.text()
        overlay_bin = self.levelEdited_ovl_object.toBytes()
        overlay_og = self.rom.loadArm9Overlays([fileID_overlay])[fileID_overlay]
        # Overlay object expects data to be in its original state (compressed if flags & 1), so flags is set to 0
        overlay = ndspy.code.Overlay(overlay_bin,
                                    ramAddress=overlay_og.ramAddress,#lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(fileID_overlay).text(1), self.displayBase),#
                                    ramSize=len(overlay_bin),#lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(fileID_overlay).text(4), self.displayBase),#
                                    bssSize=overlay_og.bssSize,#lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(fileID_overlay).text(5), self.displayBase),#
                                    staticInitStart=overlay_og.staticInitStart,#lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(fileID_overlay).text(6), self.displayBase),#
                                    staticInitEnd=overlay_og.staticInitEnd,#lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(fileID_overlay).text(7), self.displayBase),#
                                    fileID=fileID_overlay,
                                    compressedSize=overlay_og.compressedSize,#lib.datconv.strToNum(self.tree_arm9Ovltable.topLevelItem(fileID_overlay).text(3), self.displayBase),#
                                    flags=0)
        self.rom.files[fileID_overlay] = overlay.save(compress=True)
        print(f"Level data {self.dropdown_level_area.currentText()} has been saved!")
        self.levelEdited_object = lib.level.File(self.rom.files[fileID_tileset]) # update data
        #self.levelEdited_ovl_object = lib.level.Overlay(self.rom.files[fileID_overlay])
        #print(f"{len(self.rom.files[fileID_tileset][self.levelEdited_object.level_offset_rom:self.levelEdited_object.gfx_offset_rom])} {self.levelEdited_object.level_offset_rom}")
        #print(f"{len(self.rom.files[fileID_tileset][self.levelEdited_object.gfx_offset_rom:self.levelEdited_object.pal_offset_rom])} {self.levelEdited_object.gfx_offset_rom}")
        #print(f"{len(self.rom.files[fileID_tileset][self.levelEdited_object.pal_offset_rom:])} {self.levelEdited_object.pal_offset_rom}")

    def save_tweaks(self):
        if self.gamedat.tweaks == {}: 
            print("No supported tweaks for current game!")
            return
        arm9_bin = self.arm9_decompressed.save()
        arm9_bin_old = arm9_bin[:]
        overlay_list = [None]*self.tree_arm9Ovltable.topLevelItemCount()
        for category in self.gamedat.tweaks:
            print(category)
            for tweak in self.gamedat.tweaks[category]:
                print("\t"+tweak)
                tweak_data: list = self.gamedat.tweaks[category][tweak]
                tweak_val: int = None
                field_name = f"field_{category}_{tweak}"
                field: lib.widget.LabeledSpinBox = getattr(self, field_name)
                tweak_val = field.sb.value()
                if tweak_val is not None:
                    if field.isMainCode:
                        tweak_addr = tweak_data[0] - self.rom.arm9RamAddress
                        arm9_bin[tweak_addr:tweak_addr+tweak_data[1]] = int.to_bytes(tweak_val, tweak_data[1], 'little', signed=tweak_data[2])
                    else:
                        if overlay_list[tweak_data[3]] == None:
                            overlay = self.rom.loadArm9Overlays([tweak_data[3]])[tweak_data[3]]
                            overlay_list[tweak_data[3]] = [overlay, overlay.data[:]] # changed, unchanged
                        else:
                            overlay = overlay_list[tweak_data[3]][0]
                        tweak_addr = tweak_data[0] - overlay.ramAddress
                        overlay.data[tweak_addr:tweak_addr+tweak_data[1]] = int.to_bytes(tweak_val, tweak_data[1], 'little', signed=tweak_data[2])
        for ovl_arr in overlay_list:
            if ovl_arr is None: continue
            if ovl_arr[0].data != ovl_arr[1]: # if data was changed
                overlay = ndspy.code.Overlay( # re-initialize the entire thing because data changed
                    ovl_arr[0].data,
                    ramAddress=ovl_arr[0].ramAddress,
                    ramSize=len(ovl_arr[0].data),
                    bssSize=ovl_arr[0].bssSize,
                    staticInitStart=ovl_arr[0].staticInitStart,
                    staticInitEnd=ovl_arr[0].staticInitEnd,
                    fileID=ovl_arr[0].fileID,
                    compressedSize=ovl_arr[0].compressedSize,
                    flags=0
                )
                #print(ovl_arr[1][0x02187F48-overlay.ramAddress:0x02187F48-overlay.ramAddress+0x04].hex())
                #print(overlay.data[0x02187F48-overlay.ramAddress:0x02187F48-overlay.ramAddress+0x04].hex())
                #print(self.rom.files[overlay.fileID].hex())
                print(len(self.rom.files[overlay.fileID]))
                self.rom.files[overlay.fileID] = bytearray(overlay.save(compress=True)) # saving modified data doesn't actually work in-game??
                print(len(self.rom.files[overlay.fileID]))
                #print(self.rom.files[overlay.fileID].hex())
        if arm9_bin != arm9_bin_old:
            self.save_toARM9(arm9_bin)
        print("This game's supported tweaks have been saved!")
        

    def patch_checkboxUpdate(self):
        self.tree_patches.blockSignals(True)
        tree_list = self.tree_patches.findItems("", QtCore.Qt.MatchFlag.MatchContains | QtCore.Qt.MatchFlag.MatchRecursive)
        for item_i, item in enumerate(tree_list):# Iterate through patch groups
            if item.childCount() != 0:
                if item.checkState(0) != self.tree_patches_checkboxes[item_i]: # if checkstate changed
                    if item.checkState(0) != QtCore.Qt.CheckState.PartiallyChecked:
                        for child_i in range(item.childCount()): # update children
                            item.child(child_i).setCheckState(0, item.checkState(0))
                else: # update according to children
                    subPatchMatches = 0
                    for child_i in range(item.childCount()):
                        if item.child(child_i).checkState(0) == QtCore.Qt.CheckState.Checked:
                            subPatchMatches += 1
                    if subPatchMatches == item.childCount(): # Check for already applied patches
                            item.setCheckState(0, QtCore.Qt.CheckState.Checked)
                    elif subPatchMatches > 0:
                        item.setCheckState(0, QtCore.Qt.CheckState.PartiallyChecked)
                    else:
                        item.setCheckState(0, QtCore.Qt.CheckState.Unchecked)
        for item_i, item in enumerate(tree_list):# Iterate through all patches
            self.tree_patches_checkboxes[item_i] = item.checkState(0) #and update checkbox state list
        self.tree_patches.blockSignals(False)
        return tree_list

    def patch_game(self):# Currently a workaround to having no easy way of writing directly to any address in the ndspy rom object
        #print("call")
        # format 1 = [Address, Name, Type, OGData, NewData]
        # format 2 (with subpatch) = [Name, Type, [Address, Name, OGData, NewData]]
        self.button_patches_apply.setDisabled(True)
        self.progressShow()
        rom_patched = bytearray(self.rom.save()) # Create temporary ROM to write patch to
        arm9_bin = self.arm9_decompressed.save()
        arm9_bin_old = arm9_bin[:]
        patch_list = [] # create a list of patch data that corresponds to tree items
        self.progressUpdate(0, "Loading patch data", False)
        for patch in self.gamedat.patches: # create a patch list with a consistent format
            if isinstance(patch[2], tuple):
                patch_list.append(['N/A', patch[0], patch[1], 'N/A', 'N/A'])
                for subPatch in patch:
                    if isinstance(subPatch, tuple):
                        patch_list.append([subPatch[0], subPatch[1], "Patch Segment", subPatch[2], subPatch[3]])
            else:
                patch_list.append(patch)

        tree_list = self.patch_checkboxUpdate()
        self.progressUpdate(33, "Unapplying disabled patches", False)
        for item_i, item in enumerate(tree_list):# Go through unchecked ones first
            if (item.checkState(0) == QtCore.Qt.CheckState.Unchecked):
                # Revert patch
                if item.childCount() == 0: # if not a patch group
                    newData = bytes.fromhex(patch_list[item_i][3])
                    patchType = item.text(3)
                    if item.parent() != None:
                        patchType = item.parent().text(3)
                    if patchType.lower() == "arm9":
                        arm9_bin[patch_list[item_i][0]:patch_list[item_i][0]+len(newData)] = newData
                    else:
                        rom_patched[patch_list[item_i][0]:patch_list[item_i][0]+len(newData)] = newData # write og data

        self.progressUpdate(66, "Applying enabled patches", False)
        for item_i, item in enumerate(tree_list):# Then through active patches
            if (item.checkState(0) == QtCore.Qt.CheckState.Checked):
                # Apply patch
                if item.childCount() == 0: # if not a patch group
                    newData = patch_list[item_i][4]
                    for s in range(len(patch_list[item_i][4])):
                        if newData[s] == "-":
                            newData = newData[:s] + patch_list[item_i][3][s] + newData[s+1:] # replace '-' with og data
                    newData = bytes.fromhex(newData)
                    patchType = item.text(3)
                    if item.parent() != None:
                        patchType = item.parent().text(3)
                    if patchType.lower() == "arm9":
                        arm9_bin[patch_list[item_i][0]:patch_list[item_i][0]+len(newData)] = newData
                    else:
                        rom_patched[patch_list[item_i][0]:patch_list[item_i][0]+len(newData)] = newData # write patch data

        self.progressUpdate(75, "Writing to ROM", False)
        self.rom = ndspy.rom.NintendoDSRom(rom_patched)# update the editor with patched ROM
        self.progressUpdate(90, "Writing to ARM9", False)
        if arm9_bin != arm9_bin_old:
            self.save_toARM9(arm9_bin)
            self.progressHide()
        else: # no changes!
            self.progressHide()
            QtWidgets.QMessageBox.information(
                self,
                "Patching Status",
                "No changes to save!"
            )

    def save_toARM9(self, data: bytes):
        print(f"ARM9 len before: {len(self.rom.arm9)}")
        self.arm9_decompressed = ndspy.code.MainCodeFile(data, self.rom.arm9RamAddress, self.arm9_decompressed.codeSettingsOffs)
        self.rom.arm9 = self.arm9_decompressed.save(compress=True)
        print(f"ARM9 len after: {len(self.rom.arm9)}")

    # Draw contents of tile viewer
    def draw_tilesQImage_fromBytes(self, view: lib.widget.GFXView, data: bytearray, algorithm=lib.datconv.CompressionAlgorithmEnum.ONEBPP,  grid: bool=True):
        #print("draw")
        tile_size = int((self.tile_width*self.tile_height)*algorithm.depth/8) # size in bytes
        gfx = lib.datconv.binToQt(data[:tile_size*self.tiles_per_row*self.tiles_per_column],
                                palette=self.gfx_palette, algorithm=algorithm,
                                tilesPerRow=self.tiles_per_row, tilesPerColumn=self.tiles_per_column,
                                tileWidth=self.tile_width, tileHeight=self.tile_height)
        view._graphic.setPixmap(QtGui.QPixmap.fromImage(gfx, QtCore.Qt.ImageConversionFlag.NoFormatConversion)) # overwrite current canvas with new one
        if grid:
            view.createGrid(self.tile_width, self.tile_height)

    def extract(self, data: bytes, name="", path="", format="", compress=["", ""]):
        ext = ""
        if name == "":
            print("Error, tried to extract nameless file!")
            return
        if compress[0] == "decompression":
            try:
                if compress[1] == "LZ10":
                    data = ndspy.lz10.decompress(data)
                elif compress[1] == "BLZ":
                    data = ndspy.codeCompression.decompress(data)
            except TypeError as e:
                print(e)
                QtWidgets.QMessageBox.critical(
                self,
                "Decompression Failed",
                str(e)
                )
                print("Aborted file extraction.")
                return

        print("file " + name + ": " + format)
        print(data[0x65:0xc5])

        # create a copy of the file outside ROM
        if format == "" or format == "Raw":
            ext = ".bin"
        else:
            if format == "English dialogue":
                ext = ".txt"
                try: # create multiple text files
                    text_list = lib.dialogue.DialogueFile(data).text_list
                    data = [""]*len(text_list)
                    for text_i, text in enumerate(text_list):
                        data[text_i] = bytes(text, "utf-8")
                except AssertionError: # not a real dialogue file
                    data = bytes(lib.dialogue.DialogueFile.binToText(data), "utf-8")
            elif format == "Bitmap": # WIP
                ext = ".bmp"
                tiles = len(data)//(self.tile_width*self.tile_height)
                rows = tiles//self.tiles_per_row
                img = lib.datconv.binToQt(
                    data,
                    self.gfx_palette,
                    list(lib.datconv.CompressionAlgorithmEnum)[self.dropdown_gfx_depth.currentIndex()],
                    self.tiles_per_row,
                    rows,
                    self.tile_width,
                    self.tile_height
                )
                img.save(os.path.join(path + "/" + name.split(".")[0] + ext))
                print("image extracted!")
                return
            elif format == "VX":
                ext = ".vx" # even if it is a folder, use extension to know what it contains when importing
                act = lib.act.ActImagine()
                load_vx_iter = act.load_vx(data)
                self.progressShow()
                for i, _ in enumerate(load_vx_iter):
                    self.progressUpdate(int(((i+1)/act.frames_qty)*100), f"Loading VX file (frame {i+1}/{act.frames_qty})", False)
                export_vx_iter = act.export_vxfolder(os.path.join(path + "/" + name + ext))
                for i, _ in enumerate(export_vx_iter):
                    self.progressUpdate(int(((i+1)/act.frames_qty)*100), f"Exporting VX folder (frame {i+1}/{act.frames_qty})")
                self.progressHide()
                return
            else:
                print("could not find method for converting to specified format.")
                return
        if compress[0] == " compression":
            if compress[1] == "LZ10":
                data = ndspy.lz10.compress(data)
            elif compress[1] == "BLZ":
                data = ndspy.codeCompression.compress(data)

        print(os.path.join(path + "/" + name.split(".")[0] + ext))
        if isinstance(data, (bytes, bytearray)): # one file
            with open(os.path.join(path + "/" + name.split(".")[0] + ext), 'wb') as f:
                f.write(data)
        else: # list of bytes
            for subdata_i, subdata in enumerate(data):
                with open(os.path.join(path + "/" + name.split(".")[0] + "_" + str(subdata_i) + ext), 'wb') as f:
                    f.write(subdata)
        print("File extracted!")




app = QtWidgets.QApplication(sys.argv)
w = MainWindow()

#run the app
try:
    app.exec()
except BaseException:
    QtWidgets.QMessageBox.critical(None,
                                   "Error handling test",
                                   traceback.format_exc())
    traceback.print_exc()
# After execution
w.firstLaunch = False
lib.ini_rw.write(w)
if os.path.exists(w.temp_path) and w.romToEdit_name != "":
    try:
        os.remove(w.temp_path) # delete temporary ROM
    except OSError as error:
        print(error)