Active_prgs/Gromulus/Gromulus_UI.py

"""
Created by Emanuel Borges
05.19.2023

This is the main UI for Gromulus, which is a catalog inventory for roms, games and maybe one day applications.
Like most of my GUI programs, this will import a separate library with my methods for doing the actual work.

"""


import sys, os, wx
#import wx.lib.buttons  as  buttons
import wx.lib.agw.pybusyinfo as PBI
import Gromulus_Lib


class MyFrame(wx.Frame):
    def __init__(self, parent, ID, title, pos=wx.DefaultPosition):
        wx.Frame.__init__(self, parent, ID, title, pos, size = (1450,925))
        self.db = Gromulus_Lib.DatabaseManager()
        self.dbConnection  = self.db.get_connection()
        self.panel = wx.Panel(self,-1)
        self.currentSystemKey = "SNES"
        self.gamesListMatrix = Gromulus_Lib.GetGameListBySystem(self.currentSystemKey, self.dbConnection)
        gamesList = list(self.gamesListMatrix.keys())
        gamesList.sort()
        self.gamesCount = len(gamesList)
        unmatchedGamesList=[i for i in gamesList if "." in i] 
        self.unmatchedGamesCount = len(unmatchedGamesList)
        print(f"{self.gamesCount} total games for this system.  {self.gamesCount - self.unmatchedGamesCount} matched and {self.unmatchedGamesCount} unmatched.")

        self.CreateSystemButtonSection()
        self.gameSelectionListBox = wx.ListBox(self.panel, 60, (100, 50), (490, 500), gamesList , wx.LB_SINGLE|wx.LB_OWNERDRAW)
        self.CreateFieldsFirstRow()
        self.CreateArtworkPreviewSection()
        

        mainSizer = wx.BoxSizer(wx.HORIZONTAL)
        mainSizer.Add(self.buttonSizer, 0, wx.ALIGN_TOP|wx.LEFT|wx.TOP,25)
        mainSizer.Add(self.gameSelectionListBox, 0, wx.ALIGN_TOP|wx.LEFT|wx.TOP,25)
        mainSizer.Add(self.fieldsFirstRowSizer, 0, wx.ALIGN_TOP|wx.LEFT|wx.TOP,25)

        rootSizer = wx.BoxSizer(wx.VERTICAL)
        rootSizer.Add(mainSizer, 0, wx.EXPAND)
        rootSizer.AddStretchSpacer(1)
        rootSizer.Add(self.artworkPreviewSizer, 0, wx.ALIGN_CENTER|wx.ALL, 15)
        self.panel.SetSizer(rootSizer)


        self.CreateStatusBar()
        self.SetStatusText("Ready.")
        self.CreateMenuBar()

        self.Bind(wx. EVT_TOGGLEBUTTON, self.OnSystemSelected, self.snesSystemButton)
        self.Bind(wx. EVT_TOGGLEBUTTON, self.OnSystemSelected, self.nesSystemButton)
        self.Bind(wx. EVT_TOGGLEBUTTON, self.OnSystemSelected, self.genesisSystemButton)
        self.Bind(wx. EVT_TOGGLEBUTTON, self.OnSystemSelected, self.fz1SystemButton)
        self.Bind(wx. EVT_TOGGLEBUTTON, self.OnSystemSelected, self.ps1SystemButton)

        self.Bind(wx.EVT_LISTBOX, self.OnGameSelected, self.gameSelectionListBox)

    def _set_text(self, text_ctrl, value):
        text_ctrl.SetValue(value if value else "")

    def _load_scaled_bitmap(self, image_path, width, height):
        if not image_path or not os.path.isfile(image_path):
            return wx.Bitmap(width, height)
        image = wx.Image(image_path, wx.BITMAP_TYPE_ANY)
        if not image.IsOk():
            return wx.Bitmap(width, height)
        image = image.Scale(width, height, wx.IMAGE_QUALITY_HIGH)
        return wx.Bitmap(image)

    def _set_artwork_preview(self, bitmap_ctrl, image_path):
        width, height = bitmap_ctrl.GetSize()
        bitmap_ctrl.SetBitmap(self._load_scaled_bitmap(image_path, width, height))

    def _clear_artwork_previews(self):
        self._set_artwork_preview(self.boxArtBitmap, None)
        self._set_artwork_preview(self.titleArtBitmap, None)
        self._set_artwork_preview(self.ingameArtBitmap, None)

    def _run_with_busy(self, message, func, *args, **kwargs):
        busy = PBI.PyBusyInfo(message, parent=self, title="System Busy: Please Wait.")
        wx.YieldIfNeeded()
        try:
            return func(*args, **kwargs)
        finally:
            del busy

    def _load_games_for_system(self, system_key):
        self.currentSystemKey = system_key
        self.gamesListMatrix = Gromulus_Lib.GetGameListBySystem(system_key, self.dbConnection)
        gamesList = list(self.gamesListMatrix.keys())
        gamesList.sort()

        self.gameSelectionListBox.Clear()
        self.gameSelectionListBox.AppendItems(gamesList)

        self._set_text(self.gameNameTextCtrl, "")
        self._set_text(self.gameHashTextCtrl, "")
        self._set_text(self.gameFileNameTextCtrl, "")
        self._set_text(self.gameFilePathTextCtrl, "")
        self._set_text(self.noIntroGameNameTextCtrl, "")
        self._set_text(self.noIntroSystemNameTextCtrl, "")
        self._set_text(self.tosecGameNameTextCtrl, "")
        self._clear_artwork_previews()

    def _choose_system(self, prompt_title, only_with_roms=False):
        systemMatrix = (
            Gromulus_Lib.GetSystemListWithRoms(self.dbConnection)
            if only_with_roms
            else Gromulus_Lib.GetSystemList(self.dbConnection)
        )
        systemsList = list(systemMatrix.keys())
        if not systemsList:
            wx.MessageBox("No eligible systems found.", "System Selection", wx.OK | wx.ICON_WARNING)
            return None

        dlg = wx.SingleChoiceDialog(self, "Select system", prompt_title, systemsList)
        if dlg.ShowModal() != wx.ID_OK:
            return None
        selected_name = dlg.GetStringSelection()
        return systemMatrix[selected_name][0]


    def CreateSystemButtonSection(self):
        #systemsList = ['SNES','NES','Genisys']
        #for system in systemsList:
        #self.snesSystemButton = buttons.GenToggleButton(self.panel, -1, "SNES")
        #self.nesSystemButton = buttons.GenToggleButton(self.panel, -1, "NES")
        #self.genesisSystemButton = buttons.GenToggleButton(self.panel, -1, "Genesis")
        #self.ps1SystemButton = buttons.GenToggleButton(self.panel, -1, "Playstation")

        ## Create a dictionary that holds the button instances by label text, so that you can toggle the other ones off in the bind event.
        self.systemButtonDict = {}
        self.buttonSystemMap = {}
        self.snesSystemButton = wx.ToggleButton(self.panel, -1, "SNES")
        self.systemButtonDict[self.snesSystemButton.GetLabelText()] = self.snesSystemButton
        self.buttonSystemMap[self.snesSystemButton.GetLabelText()] = "SNES"

        self.nesSystemButton = wx.ToggleButton(self.panel, -1, "NES")
        self.systemButtonDict[self.nesSystemButton.GetLabelText()] = self.nesSystemButton
        self.buttonSystemMap[self.nesSystemButton.GetLabelText()] = "NES"

        self.genesisSystemButton = wx.ToggleButton(self.panel, -1, "Genesis")
        self.systemButtonDict[self.genesisSystemButton.GetLabelText()] = self.genesisSystemButton
        self.buttonSystemMap[self.genesisSystemButton.GetLabelText()] = "Genesis"

        self.fz1SystemButton = wx.ToggleButton(self.panel, -1, "3DO")
        self.systemButtonDict[self.fz1SystemButton.GetLabelText()] = self.fz1SystemButton
        self.buttonSystemMap[self.fz1SystemButton.GetLabelText()] = "3DO"

        self.ps1SystemButton = wx.ToggleButton(self.panel, -1, "Playstation")
        self.systemButtonDict[self.ps1SystemButton.GetLabelText()] = self.ps1SystemButton
        self.buttonSystemMap[self.ps1SystemButton.GetLabelText()] = "Playstation"
        self.snesSystemButton.SetValue(True)


        self.buttonSizer = wx.BoxSizer(wx.VERTICAL)
        self.buttonSizer.Add(self.snesSystemButton, 0, wx.ALL,10)
        self.buttonSizer.Add(self.nesSystemButton,0,wx.ALL,10)
        self.buttonSizer.Add(self.genesisSystemButton,0,wx.ALL,10)
        self.buttonSizer.Add(self.fz1SystemButton,0,wx.ALL,10)
        self.buttonSizer.Add(self.ps1SystemButton,0,wx.ALL,10)

    def CreateFieldsFirstRow(self):
        self.gameNameStaticText = wx.StaticText(self.panel, -1, "Game Name:")
        self.gameNameTextCtrl = wx.TextCtrl(self.panel, -1, size=(325, -1))

        self.gameHashStaticText = wx.StaticText(self.panel, -1, "Game Hash:")
        self.gameHashTextCtrl = wx.TextCtrl(self.panel, -1, size=(325, -1))

        self.gameFileNameStaticText = wx.StaticText(self.panel, -1, "Game File Name:")
        self.gameFileNameTextCtrl = wx.TextCtrl(self.panel, -1, size=(325, -1))

        self.gameFilePathStaticText = wx.StaticText(self.panel, -1, "Game File Path:")
        self.gameFilePathTextCtrl = wx.TextCtrl(self.panel, -1, size=(425, -1))

        self.noIntroGameNameStaticText = wx.StaticText(self.panel, -1, "No Intro Game Name:")
        self.noIntroGameNameTextCtrl = wx.TextCtrl(self.panel, -1, size=(325, -1))

        self.noIntroSystemNameStaticText = wx.StaticText(self.panel, -1, "No Intro System:")
        self.noIntroSystemNameTextCtrl = wx.TextCtrl(self.panel, -1, size=(380, -1))

        self.tosecGameNameStaticText = wx.StaticText(self.panel, -1, "TOSEC Game Name:")
        self.tosecGameNameTextCtrl = wx.TextCtrl(self.panel, -1, size=(325, -1))

        self.gameNameSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.gameNameSizer.Add(self.gameNameStaticText,0,wx.ALL, 10)
        self.gameNameSizer.Add(self.gameNameTextCtrl,0,wx.ALL, 10)

        self.gameHashSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.gameHashSizer.Add(self.gameHashStaticText,0,wx.ALL, 10)
        self.gameHashSizer.Add(self.gameHashTextCtrl,0,wx.ALL, 10)

        self.gameFileNameSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.gameFileNameSizer.Add(self.gameFileNameStaticText,0,wx.ALL, 10)
        self.gameFileNameSizer.Add(self.gameFileNameTextCtrl,0,wx.ALL, 10)

        self.gameFilePathSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.gameFilePathSizer.Add(self.gameFilePathStaticText,0,wx.ALL, 10)
        self.gameFilePathSizer.Add(self.gameFilePathTextCtrl,0,wx.ALL, 10)

        self.noIntroGameNameSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.noIntroGameNameSizer.Add(self.noIntroGameNameStaticText,0,wx.ALL, 10)
        self.noIntroGameNameSizer.Add(self.noIntroGameNameTextCtrl,0,wx.ALL, 10)

        self.noIntroSystemNameSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.noIntroSystemNameSizer.Add(self.noIntroSystemNameStaticText,0,wx.ALL, 10)
        self.noIntroSystemNameSizer.Add(self.noIntroSystemNameTextCtrl,0,wx.ALL, 10)

        self.tosecGameNameSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.tosecGameNameSizer.Add(self.tosecGameNameStaticText,0,wx.ALL, 10)
        self.tosecGameNameSizer.Add(self.tosecGameNameTextCtrl,0,wx.ALL, 10)

        self.fieldsFirstRowSizer = wx.BoxSizer(wx.VERTICAL)
        self.fieldsFirstRowSizer.Add(self.gameNameSizer,0,wx.ALL, 10)
        self.fieldsFirstRowSizer.Add(self.gameHashSizer,0,wx.ALL, 10)
        self.fieldsFirstRowSizer.Add(self.gameFileNameSizer,0,wx.ALL, 10)
        self.fieldsFirstRowSizer.Add(self.gameFilePathSizer,0,wx.ALL, 10)
        self.fieldsFirstRowSizer.Add(self.noIntroGameNameSizer,0,wx.ALL, 10)
        self.fieldsFirstRowSizer.Add(self.noIntroSystemNameSizer,0,wx.ALL, 10)
        self.fieldsFirstRowSizer.Add(self.tosecGameNameSizer,0,wx.ALL, 10)

    def CreateArtworkPreviewSection(self):
        preview_size = (300, 180)

        boxSizer = wx.StaticBoxSizer(wx.VERTICAL, self.panel, "Box Art")
        self.boxArtBitmap = wx.StaticBitmap(self.panel, -1, wx.Bitmap(*preview_size), size=preview_size)
        boxSizer.Add(self.boxArtBitmap, 0, wx.ALL, 8)

        titleSizer = wx.StaticBoxSizer(wx.VERTICAL, self.panel, "Title Art")
        self.titleArtBitmap = wx.StaticBitmap(self.panel, -1, wx.Bitmap(*preview_size), size=preview_size)
        titleSizer.Add(self.titleArtBitmap, 0, wx.ALL, 8)

        ingameSizer = wx.StaticBoxSizer(wx.VERTICAL, self.panel, "Ingame Art")
        self.ingameArtBitmap = wx.StaticBitmap(self.panel, -1, wx.Bitmap(*preview_size), size=preview_size)
        ingameSizer.Add(self.ingameArtBitmap, 0, wx.ALL, 8)

        self.artworkPreviewSizer = wx.BoxSizer(wx.HORIZONTAL)
        self.artworkPreviewSizer.Add(boxSizer, 0, wx.ALL, 10)
        self.artworkPreviewSizer.Add(titleSizer, 0, wx.ALL, 10)
        self.artworkPreviewSizer.Add(ingameSizer, 0, wx.ALL, 10)
        self._clear_artwork_previews()


    def MenuData(self):
        return(("&Tools",
                ("&Add Roms","Adds new Roms to a selected system.", self.OnAddNewRoms),
                ("Add &Artwork","Adds artwork files to matched games for a selected system.", self.OnAddNewArtwork),
                ("Import &NoIntro DAT", "Allows for the import of any of the No Intro DAT files.", self.OnImportNewNoIntroDat),
                ("Import &TOSEC DAT", "Allows for the import of any of the TOSEC DAT files.", self.OnImportNewTosecDat)),
               ("&Reports",
                ("&Duplicates Report","Generates a report detailing duplicates that exist in your collection.", self.NothingYet)),
               ("&Help",
                ("&About", "Displays the About Window", self.NothingYet)))
    
    def CreateMenuBar(self):
        menuBar = wx.MenuBar()
        for eachMenuData in self.MenuData():
            menuLabel = eachMenuData[0]
            menuItems = eachMenuData[1:]
            menuBar.Append(self.CreateMenu(menuItems), menuLabel)
        self.SetMenuBar(menuBar)

    def CreateMenu(self, menuData):
        menu = wx.Menu()
        for eachLabel, eachStatus, eachHandler in menuData:
            if not eachLabel:
                menu.AppendSeparator()
                continue
            menuItem = menu.Append(-1, eachLabel, eachStatus)
            self.Bind(wx.EVT_MENU, eachHandler, menuItem)
        return menu

    def OnSystemSelected(self, evt):
        if not evt.GetEventObject().GetValue():
            evt.GetEventObject().SetValue(True)
            return

        systemsButtonNamesList = list(self.systemButtonDict.keys())
        systemsButtonNamesList.remove(evt.GetEventObject().GetLabelText())
        for i in systemsButtonNamesList:
            self.systemButtonDict[i].SetValue(False)

        system_key = self.buttonSystemMap.get(evt.GetEventObject().GetLabelText(), "SNES")
        self._run_with_busy("Loading games for selected system...", self._load_games_for_system, system_key)


    def OnGameSelected(self, evt):
        print(self.gameSelectionListBox.GetStringSelection())
        selected = self.gameSelectionListBox.GetStringSelection()
        if not selected:
            return

        gameData = Gromulus_Lib.GetSingleGameById(self.gamesListMatrix[selected], self.dbConnection)
        if not gameData:
            return

        display_name = gameData.get("game_name") or gameData.get("no_intro_game") or gameData.get("tosec_game") or gameData.get("filename")
        no_intro_name = gameData.get("no_intro_game")
        no_intro_system = gameData.get("no_intro_system") or gameData.get("tosec_system")
        tosec_name = gameData.get("tosec_game")

        self._set_text(self.gameNameTextCtrl, display_name)
        self._set_text(self.gameHashTextCtrl, gameData.get("hash"))
        self._set_text(self.gameFileNameTextCtrl, gameData.get("filename"))
        self._set_text(self.gameFilePathTextCtrl, gameData.get("path"))
        self._set_text(self.noIntroGameNameTextCtrl, no_intro_name)
        self._set_text(self.noIntroSystemNameTextCtrl, no_intro_system)
        self._set_text(self.tosecGameNameTextCtrl, tosec_name)
        self._set_artwork_preview(self.boxArtBitmap, gameData.get("box_art_path"))
        self._set_artwork_preview(self.titleArtBitmap, gameData.get("title_art_path"))
        self._set_artwork_preview(self.ingameArtBitmap, gameData.get("ingame_art_path"))

    def NothingYet(self, event):
        diag = wx.MessageDialog(self, "Nothing here yet!", "Disabled...", wx.OK | wx.ICON_INFORMATION)
        diag.ShowModal()
        diag.Destroy()

    def OnImportNewNoIntroDat(self,event):
        selected_system_id = self._choose_system("No-Intro DAT System Selection")
        if not selected_system_id:
            return

        dlg = wx.FileDialog(
            self, message="Import New NoIntro DAT ...", defaultDir=os.getcwd(),
            defaultFile="", wildcard="DAT files (*.dat)|*.dat", style=wx.FD_OPEN | wx.FD_CHANGE_DIR
            )
        if dlg.ShowModal() == wx.ID_OK:
            datPath = dlg.GetPath()
            Gromulus_Lib.ImportNewNoIntroDat(datPath, selected_system_id, self.dbConnection)
            doneDiag = wx.MessageDialog(self, "NoIntro DAT imported","All Done!",wx.OK | wx.ICON_INFORMATION)
            doneDiag.ShowModal()
            doneDiag.Destroy()

    def OnImportNewTosecDat(self,event):
        selected_system_id = self._choose_system("TOSEC DAT System Selection")
        if not selected_system_id:
            return

        dlg = wx.FileDialog(
            self, message="Import New Tosec DAT ...", defaultDir=os.getcwd(),
            defaultFile="", wildcard="DAT files (*.dat)|*.dat", style=wx.FD_OPEN | wx.FD_CHANGE_DIR
            )
        if dlg.ShowModal() == wx.ID_OK:
            datPath = dlg.GetPath()
            Gromulus_Lib.ImportNewTosecDat(datPath, selected_system_id, self.dbConnection)
            doneDiag = wx.MessageDialog(self, "Tosec DAT imported","All Done!",wx.OK | wx.ICON_INFORMATION)
            doneDiag.ShowModal()
            doneDiag.Destroy()

    def OnAddNewArtwork(self, event):
        selected_system_id = self._choose_system("Artwork System Selection", only_with_roms=True)
        if not selected_system_id:
            return

        artwork_type_map = {
            "Game Box Art": "box",
            "Game Title": "title",
            "Game Ingame Screenshot": "ingame",
        }
        type_choices = list(artwork_type_map.keys())
        type_dlg = wx.SingleChoiceDialog(
            self,
            "Select the type of artwork to ingest",
            "Artwork Type",
            type_choices,
        )
        if type_dlg.ShowModal() != wx.ID_OK:
            return
        selected_artwork_label = type_dlg.GetStringSelection()
        artwork_type_key = artwork_type_map[selected_artwork_label]

        dry_run_dlg = wx.MessageDialog(
            self,
            "Run as dry run (preview only, no file copy and no DB updates)?",
            "Artwork Import Mode",
            wx.YES_NO | wx.ICON_QUESTION,
        )
        dry_run_mode = dry_run_dlg.ShowModal() == wx.ID_YES
        dry_run_dlg.Destroy()

        dir_dlg = wx.DirDialog(
            self,
            f"Choose a directory containing {selected_artwork_label} artwork files:",
            style=wx.DD_DEFAULT_STYLE,
        )
        if dir_dlg.ShowModal() != wx.ID_OK:
            return
        artwork_source_dir = dir_dlg.GetPath()

        matched_count, skipped_existing_count, unmatched_count, error_count = self._run_with_busy(
            "Matching artwork files and updating game records...",
            Gromulus_Lib.AddNewArtwork,
            artwork_source_dir,
            selected_system_id,
            artwork_type_key,
            self.dbConnection,
            testOnly=dry_run_mode,
        )
        doneDiag = wx.MessageDialog(
            self,
            (
                f"Mode: {'Dry Run (no files written)' if dry_run_mode else 'Import'}\n\n"
                f"{matched_count} artwork files matched and imported.\n"
                f"{skipped_existing_count} games skipped (artwork already set).\n"
                f"{unmatched_count} games had no filename/title match.\n"
                f"{error_count} files failed during copy/update."
            ),
            "Artwork import complete",
            wx.OK | wx.ICON_INFORMATION,
        )
        doneDiag.ShowModal()
        doneDiag.Destroy()


    def OnAddNewRoms(self,event):
        systemMatrix = Gromulus_Lib.GetSystemList(self.dbConnection)
        systemsList = list(systemMatrix.keys())
        dlg = wx.SingleChoiceDialog(self,
                                   "Select system for new ROMs",
                                   "List of systemss", systemsList)
        if (dlg.ShowModal() == wx.ID_OK):
            dlg2 = wx.DirDialog(self, "Choose a directory:",
                          style=wx.DD_DEFAULT_STYLE)
            if (dlg2.ShowModal() == wx.ID_OK):
                romsToImportPath = dlg2.GetPath()
                systemID = systemMatrix[dlg.GetStringSelection()][0] 
                importedCount, alreadyExistsCount, errImportCount = Gromulus_Lib.AddNewRoms(romsToImportPath, systemID, self.dbConnection)#, testOnly=True)
                #print(systemMatrix[dlg.GetStringSelection()])
                #print(dlg2.GetPath())
                doneDiag = wx.MessageDialog(self, f"{str(importedCount)} files imported.\n{str(alreadyExistsCount)} files not imported because you already have them.\n{str(errImportCount)} files imported because of errors.", "Rom import process complete",wx.OK | wx.ICON_INFORMATION)
                doneDiag.ShowModal()
                doneDiag.Destroy()


class MyApp(wx.App):
    def OnInit(self):
        self.frame = MyFrame(None, -1, "Gromulus v1.3")
        self.frame.Show(True)
        self.SetTopWindow(self.frame)
        return True
    def OnExit(self):
        if hasattr(self, "frame") and hasattr(self.frame, "db"):
            self.frame.db.close()
            print("Closed DB")
        return 0


if __name__ == '__main__':
    app = MyApp(0)
    app.MainLoop()
Revision:	979
Committed:	Sat Feb 14 03:49:44 2026 UTC (6 weeks ago) by nino.borges
Content type:	text/x-python
File size:	21177 byte(s)
Log Message:	Refactor metadata import and UI workflows; add system-scoped DAT handling, artwork ingestion, and artwork previews - Scope No-Intro/TOSEC imports to selected local system and track import metadata - Improve hash matching using file-level hashes with system-aware joins - Add artwork ingest workflow with type selection, dry-run mode, and busy indicators - Add bottom-row artwork previews (box/title/ingame) driven by selected game - Improve UI responsiveness and layout (system-switch busy dialog, taller game list, preview row positioning)