new unsupported emulator popup

Author: Matteo842

emulator_utils/emulator_manager.py

@@ -43,11 +43,18 @@
 
 UNKNOWN_EMULATORS = [
     # Emulatori non ancora supportati ma che vogliamo rilevare
-    'retroarch', 'project64', 'zsnes', 'fceux', 'nestopia', 'demul', 'mame',
-    'dosbox', 'scummvm', 'melonds', 'xemu', 'redream', 'epsxe', 'mesen',
-    'bsnes', 'higan', 'mednafen', 'kega', 'fusion', 'vita3k', 'play',
-    'supermodel', 'nulldc', 'mupen64plus', 'bizhawk', 'ares', 'raine',
-    'pcsp', 'cxbx', 'cxbx-reloaded', 'xqemu', 'decaf',
+    # Yuzu/Ryujinx forks
+    'suyu', 'sudachi', 'ryubing', 'lime3ds', 'folium', 'strato', 'ryujinx-ldn', 'power-emu',
+    # Altri emulatori
+    'aethersx2', 'ares', 'blastem', 'bsnes', 'beetle-psx', 'bizhawk', 'cxbx',
+    'cxbx-reloaded', 'decaf', 'demul', 'dosbox', 'dosbox-staging', 'dosbox-x',
+    'epsxe', 'fceux', 'fusion', 'genesisplusgx', 'higan', 'ideas', 'kega',
+    'kronos', 'mame', 'mednafen', 'melonds', 'mesen', 'mikage', 'mupen64plus',
+    'nestopia', 'nether_sx2', 'no$gba', 'nulldc', 'panda3ds', 'pcsp',
+    'pcsx-rearmed', 'pcsx-reloaded', 'play', 'project64', 'puNES', 'raine',
+    'redream', 'retroarch', 'rmg', 'scummvm', 'simple64', 'ssantanshiro',
+    'supermodel', 'swanstation', 'vba-m', 'vita3k', 'xemu', 'xqemu',
+    'yabause', 'zsnes',
 ]
 # Dictionary mapping emulator keys (used internally) to their configuration
 # 'name' is the display name, 'profile_finder' is the function to call
@@ -165,20 +172,20 @@ def find_profiles_for_emulator(emulator_key: str, custom_path: Optional[str] = N
         log.exception(f"Error finding profiles for {emulator_config.get('name', emulator_key)}: {e}")
         return {}
 
-def is_known_emulator(file_path: str) -> bool:
+def is_known_emulator(file_path: str) -> tuple[str, str | None]:
     """
-    Verifica se il file è un emulatore conosciuto, senza cercare i profili di salvataggio.
-    Usato principalmente per il filtraggio rapido durante la scansione delle cartelle.
-    
+    Verifica se il file è un emulatore conosciuto e il suo stato di supporto.
+
     Args:
-        file_path: Il percorso del file da verificare
-        
+        file_path: Il percorso del file da verificare.
+
     Returns:
-        bool: True se è un emulatore conosciuto, False altrimenti
+        tuple[str, str | None]: Una tupla contenente lo stato ('supported',
+        'unsupported', 'not_found') e il nome dell'emulatore rilevato (o None).
     """
     try:
         if not file_path or not os.path.exists(file_path):
-            return False
+            return 'not_found', None
 
         # Risolvi il collegamento .lnk se necessario
         target_path = file_path
@@ -192,26 +199,31 @@ def is_known_emulator(file_path: str) -> bool:
                     target_path = resolved_target
                     log.info(f"is_known_emulator: Resolved .lnk target to: {target_path}")
                 else:
-                    return False
+                    return 'not_found', None
             except Exception as e:
                 log.error(f"Error resolving shortcut in is_known_emulator: {e}")
-                return False
+                return 'not_found', None
 
         # Verifica se il percorso contiene uno degli emulatori conosciuti
         target_path_lower = target_path.lower()
         file_name = os.path.basename(target_path_lower)
 
-        # Combine known and unknown emulators for exclusion
-        all_emulators = KNOWN_EMULATORS + UNKNOWN_EMULATORS
-        for emulator in all_emulators:
+        # Controlla prima gli emulatori supportati
+        for emulator in KNOWN_EMULATORS:
             if emulator in file_name or f"\\{emulator}\\" in target_path_lower or f"/{emulator}/" in target_path_lower:
-                log.info(f"Detected emulator '{emulator}' in path: {target_path}")
-                return True
-                
-        return False
+                log.info(f"Detected supported emulator '{emulator}' in path: {target_path}")
+                return 'supported', emulator
+
+        # Controlla gli emulatori non supportati
+        for emulator in UNKNOWN_EMULATORS:
+            if emulator in file_name or f"\\{emulator}\\" in target_path_lower or f"/{emulator}/" in target_path_lower:
+                log.info(f"Detected unsupported emulator '{emulator}' in path: {target_path}")
+                return 'unsupported', emulator
+
+        return 'not_found', None
     except Exception as e:
         log.error(f"Error in is_known_emulator: {e}")
-        return False
+        return 'not_found', None
 
 def detect_and_find_profiles(target_path: str | None) -> tuple[str, list[dict]] | None:
     """

gui_components/drag_drop_handler.py

@@ -182,10 +182,10 @@ def _scan_directory_for_executables(self, directory_path):
                             continue
 
                     # Verifica se il file è un emulatore conosciuto (solo detection, senza scan dei profili)
-                    is_emulator = self._is_known_emulator(item_path)
-                    if is_emulator:
-                        # Se è un emulatore, lo saltiamo immediatamente senza cercare i profili
-                        logging.info(f"Skipping emulator in directory: {item_path}")
+                    # Verifica se il file è un emulatore conosciuto per escluderlo dalla scansione
+                    emulator_status, _ = self._is_known_emulator(item_path)
+                    if emulator_status in ['supported', 'unsupported']:
+                        logging.info(f"Skipping emulator file found during directory scan: {item_path}")
                         continue
 
                     # Se arriviamo qui, il file non è un emulatore e può essere aggiunto
@@ -480,19 +480,15 @@ def _check_detection_threads_status(self):
 
             logging.info("All detection threads completed.")
 
-    def _is_known_emulator(self, file_path):
-        """Verifica solo se il file è un emulatore conosciuto, senza cercare i profili di salvataggio.
-        Usa la funzione centralizzata in emulator_manager.
-        
-        Args:
-            file_path: Il percorso del file da verificare
-            
-        Returns:
-            bool: True se è un emulatore conosciuto, False altrimenti
-        """
-        from emulator_utils.emulator_manager import is_known_emulator
-        return is_known_emulator(file_path)
-        
+    def _is_known_emulator(self, file_path) -> tuple[str, str | None]:
+        """Controlla se il file è un emulatore conosciuto e restituisce il suo stato."""
+        try:
+            from emulator_utils.emulator_manager import is_known_emulator
+            return is_known_emulator(file_path)
+        except ImportError:
+            log.error("Failed to import is_known_emulator. Check circular dependencies or project structure.")
+            return 'not_found', None
+
     def _check_if_emulator(self, file_path):
         """Verifica se il file è un emulatore supportato e cerca i profili di salvataggio.
         

gui_components/drop_event_logic.py

@@ -216,6 +216,18 @@ def dropEvent(self, event: QDropEvent):
         # Verifica se è un emulatore
         if len(files_to_process) == 1:
             file_path = files_to_process[0]
+
+            # Controlla prima se è un emulatore conosciuto ma non supportato
+            emulator_status, emulator_name = handler_instance._is_known_emulator(file_path)
+            if emulator_status == 'unsupported':
+                QMessageBox.information(handler_instance.main_window,
+                                        "Emulatore Riconosciuto",
+                                        f"L'emulatore '{emulator_name}' è stato riconosciuto ma non è ancora supportato da SaveState.\n\n"
+                                        "Il supporto per nuovi emulatori viene aggiunto regolarmente.")
+                event.acceptProposedAction()
+                return
+
+            # Se non è 'unsupported', procedi con la normale verifica per emulatori supportati
             emulator_result = handler_instance._check_if_emulator(file_path)
 
             if emulator_result:
@@ -333,10 +345,10 @@ def dropEvent(self, event: QDropEvent):
             # Filter out emulators and uninstalled Steam games from files_to_process
             filtered_files = []
             for file_path in files_to_process:
-                # Check if it's an emulator
-                emulator_result = handler_instance._check_if_emulator(file_path)
-                if emulator_result:
-                    logging.info(f"DragDropHandler.dropEvent: Skipping emulator: {file_path}")
+                # Controlla se è un emulatore (supportato o meno) per escluderlo
+                emulator_status, emulator_name = handler_instance._is_known_emulator(file_path)
+                if emulator_status in ['supported', 'unsupported']:
+                    logging.info(f"DragDropHandler.dropEvent: Skipping emulator '{emulator_name}' in multi-file drop: {file_path}")
                     continue
 
                 # Check if it's a Steam link to an uninstalled game